var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// node_modules/ajv/dist/compile/codegen/code.js
var require_code = __commonJS({
  "node_modules/ajv/dist/compile/codegen/code.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
    var _CodeOrName = class {
    };
    exports._CodeOrName = _CodeOrName;
    exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
    var Name = class extends _CodeOrName {
      constructor(s) {
        super();
        if (!exports.IDENTIFIER.test(s))
          throw new Error("CodeGen: name must be a valid identifier");
        this.str = s;
      }
      toString() {
        return this.str;
      }
      emptyStr() {
        return false;
      }
      get names() {
        return { [this.str]: 1 };
      }
    };
    exports.Name = Name;
    var _Code = class extends _CodeOrName {
      constructor(code) {
        super();
        this._items = typeof code === "string" ? [code] : code;
      }
      toString() {
        return this.str;
      }
      emptyStr() {
        if (this._items.length > 1)
          return false;
        const item = this._items[0];
        return item === "" || item === '""';
      }
      get str() {
        var _a;
        return (_a = this._str) !== null && _a !== void 0 ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
      }
      get names() {
        var _a;
        return (_a = this._names) !== null && _a !== void 0 ? _a : this._names = this._items.reduce((names, c) => {
          if (c instanceof Name)
            names[c.str] = (names[c.str] || 0) + 1;
          return names;
        }, {});
      }
    };
    exports._Code = _Code;
    exports.nil = new _Code("");
    function _(strs, ...args) {
      const code = [strs[0]];
      let i = 0;
      while (i < args.length) {
        addCodeArg(code, args[i]);
        code.push(strs[++i]);
      }
      return new _Code(code);
    }
    exports._ = _;
    var plus = new _Code("+");
    function str(strs, ...args) {
      const expr = [safeStringify(strs[0])];
      let i = 0;
      while (i < args.length) {
        expr.push(plus);
        addCodeArg(expr, args[i]);
        expr.push(plus, safeStringify(strs[++i]));
      }
      optimize(expr);
      return new _Code(expr);
    }
    exports.str = str;
    function addCodeArg(code, arg) {
      if (arg instanceof _Code)
        code.push(...arg._items);
      else if (arg instanceof Name)
        code.push(arg);
      else
        code.push(interpolate(arg));
    }
    exports.addCodeArg = addCodeArg;
    function optimize(expr) {
      let i = 1;
      while (i < expr.length - 1) {
        if (expr[i] === plus) {
          const res = mergeExprItems(expr[i - 1], expr[i + 1]);
          if (res !== void 0) {
            expr.splice(i - 1, 3, res);
            continue;
          }
          expr[i++] = "+";
        }
        i++;
      }
    }
    function mergeExprItems(a, b) {
      if (b === '""')
        return a;
      if (a === '""')
        return b;
      if (typeof a == "string") {
        if (b instanceof Name || a[a.length - 1] !== '"')
          return;
        if (typeof b != "string")
          return `${a.slice(0, -1)}${b}"`;
        if (b[0] === '"')
          return a.slice(0, -1) + b.slice(1);
        return;
      }
      if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
        return `"${a}${b.slice(1)}`;
      return;
    }
    function strConcat(c1, c2) {
      return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
    }
    exports.strConcat = strConcat;
    function interpolate(x) {
      return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
    }
    function stringify(x) {
      return new _Code(safeStringify(x));
    }
    exports.stringify = stringify;
    function safeStringify(x) {
      return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
    }
    exports.safeStringify = safeStringify;
    function getProperty(key) {
      return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
    }
    exports.getProperty = getProperty;
    function getEsmExportName(key) {
      if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
        return new _Code(`${key}`);
      }
      throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
    }
    exports.getEsmExportName = getEsmExportName;
    function regexpCode(rx) {
      return new _Code(rx.toString());
    }
    exports.regexpCode = regexpCode;
  }
});

// node_modules/ajv/dist/compile/codegen/scope.js
var require_scope = __commonJS({
  "node_modules/ajv/dist/compile/codegen/scope.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
    var code_1 = require_code();
    var ValueError = class extends Error {
      constructor(name) {
        super(`CodeGen: "code" for ${name} not defined`);
        this.value = name.value;
      }
    };
    var UsedValueState;
    (function(UsedValueState2) {
      UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
      UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
    })(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
    exports.varKinds = {
      const: new code_1.Name("const"),
      let: new code_1.Name("let"),
      var: new code_1.Name("var")
    };
    var Scope = class {
      constructor({ prefixes, parent } = {}) {
        this._names = {};
        this._prefixes = prefixes;
        this._parent = parent;
      }
      toName(nameOrPrefix) {
        return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
      }
      name(prefix) {
        return new code_1.Name(this._newName(prefix));
      }
      _newName(prefix) {
        const ng = this._names[prefix] || this._nameGroup(prefix);
        return `${prefix}${ng.index++}`;
      }
      _nameGroup(prefix) {
        var _a, _b;
        if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) {
          throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
        }
        return this._names[prefix] = { prefix, index: 0 };
      }
    };
    exports.Scope = Scope;
    var ValueScopeName = class extends code_1.Name {
      constructor(prefix, nameStr) {
        super(nameStr);
        this.prefix = prefix;
      }
      setValue(value, { property, itemIndex }) {
        this.value = value;
        this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
      }
    };
    exports.ValueScopeName = ValueScopeName;
    var line = (0, code_1._)`\n`;
    var ValueScope = class extends Scope {
      constructor(opts) {
        super(opts);
        this._values = {};
        this._scope = opts.scope;
        this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
      }
      get() {
        return this._scope;
      }
      name(prefix) {
        return new ValueScopeName(prefix, this._newName(prefix));
      }
      value(nameOrPrefix, value) {
        var _a;
        if (value.ref === void 0)
          throw new Error("CodeGen: ref must be passed in value");
        const name = this.toName(nameOrPrefix);
        const { prefix } = name;
        const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
        let vs = this._values[prefix];
        if (vs) {
          const _name = vs.get(valueKey);
          if (_name)
            return _name;
        } else {
          vs = this._values[prefix] = /* @__PURE__ */ new Map();
        }
        vs.set(valueKey, name);
        const s = this._scope[prefix] || (this._scope[prefix] = []);
        const itemIndex = s.length;
        s[itemIndex] = value.ref;
        name.setValue(value, { property: prefix, itemIndex });
        return name;
      }
      getValue(prefix, keyOrRef) {
        const vs = this._values[prefix];
        if (!vs)
          return;
        return vs.get(keyOrRef);
      }
      scopeRefs(scopeName, values = this._values) {
        return this._reduceValues(values, (name) => {
          if (name.scopePath === void 0)
            throw new Error(`CodeGen: name "${name}" has no value`);
          return (0, code_1._)`${scopeName}${name.scopePath}`;
        });
      }
      scopeCode(values = this._values, usedValues, getCode) {
        return this._reduceValues(values, (name) => {
          if (name.value === void 0)
            throw new Error(`CodeGen: name "${name}" has no value`);
          return name.value.code;
        }, usedValues, getCode);
      }
      _reduceValues(values, valueCode, usedValues = {}, getCode) {
        let code = code_1.nil;
        for (const prefix in values) {
          const vs = values[prefix];
          if (!vs)
            continue;
          const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map();
          vs.forEach((name) => {
            if (nameSet.has(name))
              return;
            nameSet.set(name, UsedValueState.Started);
            let c = valueCode(name);
            if (c) {
              const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
              code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
            } else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) {
              code = (0, code_1._)`${code}${c}${this.opts._n}`;
            } else {
              throw new ValueError(name);
            }
            nameSet.set(name, UsedValueState.Completed);
          });
        }
        return code;
      }
    };
    exports.ValueScope = ValueScope;
  }
});

// node_modules/ajv/dist/compile/codegen/index.js
var require_codegen = __commonJS({
  "node_modules/ajv/dist/compile/codegen/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
    var code_1 = require_code();
    var scope_1 = require_scope();
    var code_2 = require_code();
    Object.defineProperty(exports, "_", { enumerable: true, get: function() {
      return code_2._;
    } });
    Object.defineProperty(exports, "str", { enumerable: true, get: function() {
      return code_2.str;
    } });
    Object.defineProperty(exports, "strConcat", { enumerable: true, get: function() {
      return code_2.strConcat;
    } });
    Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
      return code_2.nil;
    } });
    Object.defineProperty(exports, "getProperty", { enumerable: true, get: function() {
      return code_2.getProperty;
    } });
    Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
      return code_2.stringify;
    } });
    Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function() {
      return code_2.regexpCode;
    } });
    Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
      return code_2.Name;
    } });
    var scope_2 = require_scope();
    Object.defineProperty(exports, "Scope", { enumerable: true, get: function() {
      return scope_2.Scope;
    } });
    Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function() {
      return scope_2.ValueScope;
    } });
    Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function() {
      return scope_2.ValueScopeName;
    } });
    Object.defineProperty(exports, "varKinds", { enumerable: true, get: function() {
      return scope_2.varKinds;
    } });
    exports.operators = {
      GT: new code_1._Code(">"),
      GTE: new code_1._Code(">="),
      LT: new code_1._Code("<"),
      LTE: new code_1._Code("<="),
      EQ: new code_1._Code("==="),
      NEQ: new code_1._Code("!=="),
      NOT: new code_1._Code("!"),
      OR: new code_1._Code("||"),
      AND: new code_1._Code("&&"),
      ADD: new code_1._Code("+")
    };
    var Node = class {
      optimizeNodes() {
        return this;
      }
      optimizeNames(_names, _constants) {
        return this;
      }
    };
    var Def = class extends Node {
      constructor(varKind, name, rhs) {
        super();
        this.varKind = varKind;
        this.name = name;
        this.rhs = rhs;
      }
      render({ es5, _n }) {
        const varKind = es5 ? scope_1.varKinds.var : this.varKind;
        const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
        return `${varKind} ${this.name}${rhs};` + _n;
      }
      optimizeNames(names, constants6) {
        if (!names[this.name.str])
          return;
        if (this.rhs)
          this.rhs = optimizeExpr(this.rhs, names, constants6);
        return this;
      }
      get names() {
        return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
      }
    };
    var Assign = class extends Node {
      constructor(lhs, rhs, sideEffects) {
        super();
        this.lhs = lhs;
        this.rhs = rhs;
        this.sideEffects = sideEffects;
      }
      render({ _n }) {
        return `${this.lhs} = ${this.rhs};` + _n;
      }
      optimizeNames(names, constants6) {
        if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
          return;
        this.rhs = optimizeExpr(this.rhs, names, constants6);
        return this;
      }
      get names() {
        const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
        return addExprNames(names, this.rhs);
      }
    };
    var AssignOp = class extends Assign {
      constructor(lhs, op, rhs, sideEffects) {
        super(lhs, rhs, sideEffects);
        this.op = op;
      }
      render({ _n }) {
        return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
      }
    };
    var Label = class extends Node {
      constructor(label) {
        super();
        this.label = label;
        this.names = {};
      }
      render({ _n }) {
        return `${this.label}:` + _n;
      }
    };
    var Break = class extends Node {
      constructor(label) {
        super();
        this.label = label;
        this.names = {};
      }
      render({ _n }) {
        const label = this.label ? ` ${this.label}` : "";
        return `break${label};` + _n;
      }
    };
    var Throw = class extends Node {
      constructor(error3) {
        super();
        this.error = error3;
      }
      render({ _n }) {
        return `throw ${this.error};` + _n;
      }
      get names() {
        return this.error.names;
      }
    };
    var AnyCode = class extends Node {
      constructor(code) {
        super();
        this.code = code;
      }
      render({ _n }) {
        return `${this.code};` + _n;
      }
      optimizeNodes() {
        return `${this.code}` ? this : void 0;
      }
      optimizeNames(names, constants6) {
        this.code = optimizeExpr(this.code, names, constants6);
        return this;
      }
      get names() {
        return this.code instanceof code_1._CodeOrName ? this.code.names : {};
      }
    };
    var ParentNode = class extends Node {
      constructor(nodes = []) {
        super();
        this.nodes = nodes;
      }
      render(opts) {
        return this.nodes.reduce((code, n) => code + n.render(opts), "");
      }
      optimizeNodes() {
        const { nodes } = this;
        let i = nodes.length;
        while (i--) {
          const n = nodes[i].optimizeNodes();
          if (Array.isArray(n))
            nodes.splice(i, 1, ...n);
          else if (n)
            nodes[i] = n;
          else
            nodes.splice(i, 1);
        }
        return nodes.length > 0 ? this : void 0;
      }
      optimizeNames(names, constants6) {
        const { nodes } = this;
        let i = nodes.length;
        while (i--) {
          const n = nodes[i];
          if (n.optimizeNames(names, constants6))
            continue;
          subtractNames(names, n.names);
          nodes.splice(i, 1);
        }
        return nodes.length > 0 ? this : void 0;
      }
      get names() {
        return this.nodes.reduce((names, n) => addNames(names, n.names), {});
      }
    };
    var BlockNode = class extends ParentNode {
      render(opts) {
        return "{" + opts._n + super.render(opts) + "}" + opts._n;
      }
    };
    var Root = class extends ParentNode {
    };
    var Else = class extends BlockNode {
    };
    Else.kind = "else";
    var If = class _If extends BlockNode {
      constructor(condition, nodes) {
        super(nodes);
        this.condition = condition;
      }
      render(opts) {
        let code = `if(${this.condition})` + super.render(opts);
        if (this.else)
          code += "else " + this.else.render(opts);
        return code;
      }
      optimizeNodes() {
        super.optimizeNodes();
        const cond = this.condition;
        if (cond === true)
          return this.nodes;
        let e = this.else;
        if (e) {
          const ns = e.optimizeNodes();
          e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
        }
        if (e) {
          if (cond === false)
            return e instanceof _If ? e : e.nodes;
          if (this.nodes.length)
            return this;
          return new _If(not(cond), e instanceof _If ? [e] : e.nodes);
        }
        if (cond === false || !this.nodes.length)
          return void 0;
        return this;
      }
      optimizeNames(names, constants6) {
        var _a;
        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants6);
        if (!(super.optimizeNames(names, constants6) || this.else))
          return;
        this.condition = optimizeExpr(this.condition, names, constants6);
        return this;
      }
      get names() {
        const names = super.names;
        addExprNames(names, this.condition);
        if (this.else)
          addNames(names, this.else.names);
        return names;
      }
    };
    If.kind = "if";
    var For = class extends BlockNode {
    };
    For.kind = "for";
    var ForLoop = class extends For {
      constructor(iteration) {
        super();
        this.iteration = iteration;
      }
      render(opts) {
        return `for(${this.iteration})` + super.render(opts);
      }
      optimizeNames(names, constants6) {
        if (!super.optimizeNames(names, constants6))
          return;
        this.iteration = optimizeExpr(this.iteration, names, constants6);
        return this;
      }
      get names() {
        return addNames(super.names, this.iteration.names);
      }
    };
    var ForRange = class extends For {
      constructor(varKind, name, from, to) {
        super();
        this.varKind = varKind;
        this.name = name;
        this.from = from;
        this.to = to;
      }
      render(opts) {
        const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
        const { name, from, to } = this;
        return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
      }
      get names() {
        const names = addExprNames(super.names, this.from);
        return addExprNames(names, this.to);
      }
    };
    var ForIter = class extends For {
      constructor(loop, varKind, name, iterable) {
        super();
        this.loop = loop;
        this.varKind = varKind;
        this.name = name;
        this.iterable = iterable;
      }
      render(opts) {
        return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
      }
      optimizeNames(names, constants6) {
        if (!super.optimizeNames(names, constants6))
          return;
        this.iterable = optimizeExpr(this.iterable, names, constants6);
        return this;
      }
      get names() {
        return addNames(super.names, this.iterable.names);
      }
    };
    var Func = class extends BlockNode {
      constructor(name, args, async) {
        super();
        this.name = name;
        this.args = args;
        this.async = async;
      }
      render(opts) {
        const _async = this.async ? "async " : "";
        return `${_async}function ${this.name}(${this.args})` + super.render(opts);
      }
    };
    Func.kind = "func";
    var Return = class extends ParentNode {
      render(opts) {
        return "return " + super.render(opts);
      }
    };
    Return.kind = "return";
    var Try = class extends BlockNode {
      render(opts) {
        let code = "try" + super.render(opts);
        if (this.catch)
          code += this.catch.render(opts);
        if (this.finally)
          code += this.finally.render(opts);
        return code;
      }
      optimizeNodes() {
        var _a, _b;
        super.optimizeNodes();
        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes();
        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
        return this;
      }
      optimizeNames(names, constants6) {
        var _a, _b;
        super.optimizeNames(names, constants6);
        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants6);
        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants6);
        return this;
      }
      get names() {
        const names = super.names;
        if (this.catch)
          addNames(names, this.catch.names);
        if (this.finally)
          addNames(names, this.finally.names);
        return names;
      }
    };
    var Catch = class extends BlockNode {
      constructor(error3) {
        super();
        this.error = error3;
      }
      render(opts) {
        return `catch(${this.error})` + super.render(opts);
      }
    };
    Catch.kind = "catch";
    var Finally = class extends BlockNode {
      render(opts) {
        return "finally" + super.render(opts);
      }
    };
    Finally.kind = "finally";
    var CodeGen = class {
      constructor(extScope, opts = {}) {
        this._values = {};
        this._blockStarts = [];
        this._constants = {};
        this.opts = { ...opts, _n: opts.lines ? "\n" : "" };
        this._extScope = extScope;
        this._scope = new scope_1.Scope({ parent: extScope });
        this._nodes = [new Root()];
      }
      toString() {
        return this._root.render(this.opts);
      }
      // returns unique name in the internal scope
      name(prefix) {
        return this._scope.name(prefix);
      }
      // reserves unique name in the external scope
      scopeName(prefix) {
        return this._extScope.name(prefix);
      }
      // reserves unique name in the external scope and assigns value to it
      scopeValue(prefixOrName, value) {
        const name = this._extScope.value(prefixOrName, value);
        const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set());
        vs.add(name);
        return name;
      }
      getScopeValue(prefix, keyOrRef) {
        return this._extScope.getValue(prefix, keyOrRef);
      }
      // return code that assigns values in the external scope to the names that are used internally
      // (same names that were returned by gen.scopeName or gen.scopeValue)
      scopeRefs(scopeName) {
        return this._extScope.scopeRefs(scopeName, this._values);
      }
      scopeCode() {
        return this._extScope.scopeCode(this._values);
      }
      _def(varKind, nameOrPrefix, rhs, constant) {
        const name = this._scope.toName(nameOrPrefix);
        if (rhs !== void 0 && constant)
          this._constants[name.str] = rhs;
        this._leafNode(new Def(varKind, name, rhs));
        return name;
      }
      // `const` declaration (`var` in es5 mode)
      const(nameOrPrefix, rhs, _constant) {
        return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
      }
      // `let` declaration with optional assignment (`var` in es5 mode)
      let(nameOrPrefix, rhs, _constant) {
        return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
      }
      // `var` declaration with optional assignment
      var(nameOrPrefix, rhs, _constant) {
        return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
      }
      // assignment code
      assign(lhs, rhs, sideEffects) {
        return this._leafNode(new Assign(lhs, rhs, sideEffects));
      }
      // `+=` code
      add(lhs, rhs) {
        return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
      }
      // appends passed SafeExpr to code or executes Block
      code(c) {
        if (typeof c == "function")
          c();
        else if (c !== code_1.nil)
          this._leafNode(new AnyCode(c));
        return this;
      }
      // returns code for object literal for the passed argument list of key-value pairs
      object(...keyValues) {
        const code = ["{"];
        for (const [key, value] of keyValues) {
          if (code.length > 1)
            code.push(",");
          code.push(key);
          if (key !== value || this.opts.es5) {
            code.push(":");
            (0, code_1.addCodeArg)(code, value);
          }
        }
        code.push("}");
        return new code_1._Code(code);
      }
      // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
      if(condition, thenBody, elseBody) {
        this._blockNode(new If(condition));
        if (thenBody && elseBody) {
          this.code(thenBody).else().code(elseBody).endIf();
        } else if (thenBody) {
          this.code(thenBody).endIf();
        } else if (elseBody) {
          throw new Error('CodeGen: "else" body without "then" body');
        }
        return this;
      }
      // `else if` clause - invalid without `if` or after `else` clauses
      elseIf(condition) {
        return this._elseNode(new If(condition));
      }
      // `else` clause - only valid after `if` or `else if` clauses
      else() {
        return this._elseNode(new Else());
      }
      // end `if` statement (needed if gen.if was used only with condition)
      endIf() {
        return this._endBlockNode(If, Else);
      }
      _for(node, forBody) {
        this._blockNode(node);
        if (forBody)
          this.code(forBody).endFor();
        return this;
      }
      // a generic `for` clause (or statement if `forBody` is passed)
      for(iteration, forBody) {
        return this._for(new ForLoop(iteration), forBody);
      }
      // `for` statement for a range of values
      forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
        const name = this._scope.toName(nameOrPrefix);
        return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
      }
      // `for-of` statement (in es5 mode replace with a normal for loop)
      forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
        const name = this._scope.toName(nameOrPrefix);
        if (this.opts.es5) {
          const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
          return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
            this.var(name, (0, code_1._)`${arr}[${i}]`);
            forBody(name);
          });
        }
        return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
      }
      // `for-in` statement.
      // With option `ownProperties` replaced with a `for-of` loop for object keys
      forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
        if (this.opts.ownProperties) {
          return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
        }
        const name = this._scope.toName(nameOrPrefix);
        return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
      }
      // end `for` loop
      endFor() {
        return this._endBlockNode(For);
      }
      // `label` statement
      label(label) {
        return this._leafNode(new Label(label));
      }
      // `break` statement
      break(label) {
        return this._leafNode(new Break(label));
      }
      // `return` statement
      return(value) {
        const node = new Return();
        this._blockNode(node);
        this.code(value);
        if (node.nodes.length !== 1)
          throw new Error('CodeGen: "return" should have one node');
        return this._endBlockNode(Return);
      }
      // `try` statement
      try(tryBody, catchCode, finallyCode) {
        if (!catchCode && !finallyCode)
          throw new Error('CodeGen: "try" without "catch" and "finally"');
        const node = new Try();
        this._blockNode(node);
        this.code(tryBody);
        if (catchCode) {
          const error3 = this.name("e");
          this._currNode = node.catch = new Catch(error3);
          catchCode(error3);
        }
        if (finallyCode) {
          this._currNode = node.finally = new Finally();
          this.code(finallyCode);
        }
        return this._endBlockNode(Catch, Finally);
      }
      // `throw` statement
      throw(error3) {
        return this._leafNode(new Throw(error3));
      }
      // start self-balancing block
      block(body, nodeCount) {
        this._blockStarts.push(this._nodes.length);
        if (body)
          this.code(body).endBlock(nodeCount);
        return this;
      }
      // end the current self-balancing block
      endBlock(nodeCount) {
        const len = this._blockStarts.pop();
        if (len === void 0)
          throw new Error("CodeGen: not in self-balancing block");
        const toClose = this._nodes.length - len;
        if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) {
          throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
        }
        this._nodes.length = len;
        return this;
      }
      // `function` heading (or definition if funcBody is passed)
      func(name, args = code_1.nil, async, funcBody) {
        this._blockNode(new Func(name, args, async));
        if (funcBody)
          this.code(funcBody).endFunc();
        return this;
      }
      // end function definition
      endFunc() {
        return this._endBlockNode(Func);
      }
      optimize(n = 1) {
        while (n-- > 0) {
          this._root.optimizeNodes();
          this._root.optimizeNames(this._root.names, this._constants);
        }
      }
      _leafNode(node) {
        this._currNode.nodes.push(node);
        return this;
      }
      _blockNode(node) {
        this._currNode.nodes.push(node);
        this._nodes.push(node);
      }
      _endBlockNode(N1, N2) {
        const n = this._currNode;
        if (n instanceof N1 || N2 && n instanceof N2) {
          this._nodes.pop();
          return this;
        }
        throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
      }
      _elseNode(node) {
        const n = this._currNode;
        if (!(n instanceof If)) {
          throw new Error('CodeGen: "else" without "if"');
        }
        this._currNode = n.else = node;
        return this;
      }
      get _root() {
        return this._nodes[0];
      }
      get _currNode() {
        const ns = this._nodes;
        return ns[ns.length - 1];
      }
      set _currNode(node) {
        const ns = this._nodes;
        ns[ns.length - 1] = node;
      }
    };
    exports.CodeGen = CodeGen;
    function addNames(names, from) {
      for (const n in from)
        names[n] = (names[n] || 0) + (from[n] || 0);
      return names;
    }
    function addExprNames(names, from) {
      return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
    }
    function optimizeExpr(expr, names, constants6) {
      if (expr instanceof code_1.Name)
        return replaceName(expr);
      if (!canOptimize(expr))
        return expr;
      return new code_1._Code(expr._items.reduce((items, c) => {
        if (c instanceof code_1.Name)
          c = replaceName(c);
        if (c instanceof code_1._Code)
          items.push(...c._items);
        else
          items.push(c);
        return items;
      }, []));
      function replaceName(n) {
        const c = constants6[n.str];
        if (c === void 0 || names[n.str] !== 1)
          return n;
        delete names[n.str];
        return c;
      }
      function canOptimize(e) {
        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants6[c.str] !== void 0);
      }
    }
    function subtractNames(names, from) {
      for (const n in from)
        names[n] = (names[n] || 0) - (from[n] || 0);
    }
    function not(x) {
      return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`;
    }
    exports.not = not;
    var andCode = mappend(exports.operators.AND);
    function and(...args) {
      return args.reduce(andCode);
    }
    exports.and = and;
    var orCode = mappend(exports.operators.OR);
    function or(...args) {
      return args.reduce(orCode);
    }
    exports.or = or;
    function mappend(op) {
      return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
    }
    function par(x) {
      return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
    }
  }
});

// node_modules/ajv/dist/compile/util.js
var require_util = __commonJS({
  "node_modules/ajv/dist/compile/util.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
    var codegen_1 = require_codegen();
    var code_1 = require_code();
    function toHash(arr) {
      const hash = {};
      for (const item of arr)
        hash[item] = true;
      return hash;
    }
    exports.toHash = toHash;
    function alwaysValidSchema(it, schema) {
      if (typeof schema == "boolean")
        return schema;
      if (Object.keys(schema).length === 0)
        return true;
      checkUnknownRules(it, schema);
      return !schemaHasRules(schema, it.self.RULES.all);
    }
    exports.alwaysValidSchema = alwaysValidSchema;
    function checkUnknownRules(it, schema = it.schema) {
      const { opts, self } = it;
      if (!opts.strictSchema)
        return;
      if (typeof schema === "boolean")
        return;
      const rules = self.RULES.keywords;
      for (const key in schema) {
        if (!rules[key])
          checkStrictMode(it, `unknown keyword: "${key}"`);
      }
    }
    exports.checkUnknownRules = checkUnknownRules;
    function schemaHasRules(schema, rules) {
      if (typeof schema == "boolean")
        return !schema;
      for (const key in schema)
        if (rules[key])
          return true;
      return false;
    }
    exports.schemaHasRules = schemaHasRules;
    function schemaHasRulesButRef(schema, RULES) {
      if (typeof schema == "boolean")
        return !schema;
      for (const key in schema)
        if (key !== "$ref" && RULES.all[key])
          return true;
      return false;
    }
    exports.schemaHasRulesButRef = schemaHasRulesButRef;
    function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
      if (!$data) {
        if (typeof schema == "number" || typeof schema == "boolean")
          return schema;
        if (typeof schema == "string")
          return (0, codegen_1._)`${schema}`;
      }
      return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
    }
    exports.schemaRefOrVal = schemaRefOrVal;
    function unescapeFragment(str) {
      return unescapeJsonPointer(decodeURIComponent(str));
    }
    exports.unescapeFragment = unescapeFragment;
    function escapeFragment(str) {
      return encodeURIComponent(escapeJsonPointer(str));
    }
    exports.escapeFragment = escapeFragment;
    function escapeJsonPointer(str) {
      if (typeof str == "number")
        return `${str}`;
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
    exports.escapeJsonPointer = escapeJsonPointer;
    function unescapeJsonPointer(str) {
      return str.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    exports.unescapeJsonPointer = unescapeJsonPointer;
    function eachItem(xs, f) {
      if (Array.isArray(xs)) {
        for (const x of xs)
          f(x);
      } else {
        f(xs);
      }
    }
    exports.eachItem = eachItem;
    function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues5, resultToName }) {
      return (gen, from, to, toName) => {
        const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues5(from, to);
        return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
      };
    }
    exports.mergeEvaluated = {
      props: makeMergeEvaluated({
        mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
          gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`));
        }),
        mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
          if (from === true) {
            gen.assign(to, true);
          } else {
            gen.assign(to, (0, codegen_1._)`${to} || {}`);
            setEvaluated(gen, to, from);
          }
        }),
        mergeValues: (from, to) => from === true ? true : { ...from, ...to },
        resultToName: evaluatedPropsToName
      }),
      items: makeMergeEvaluated({
        mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
        mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
        mergeValues: (from, to) => from === true ? true : Math.max(from, to),
        resultToName: (gen, items) => gen.var("items", items)
      })
    };
    function evaluatedPropsToName(gen, ps) {
      if (ps === true)
        return gen.var("props", true);
      const props = gen.var("props", (0, codegen_1._)`{}`);
      if (ps !== void 0)
        setEvaluated(gen, props, ps);
      return props;
    }
    exports.evaluatedPropsToName = evaluatedPropsToName;
    function setEvaluated(gen, props, ps) {
      Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
    }
    exports.setEvaluated = setEvaluated;
    var snippets = {};
    function useFunc(gen, f) {
      return gen.scopeValue("func", {
        ref: f,
        code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code))
      });
    }
    exports.useFunc = useFunc;
    var Type;
    (function(Type2) {
      Type2[Type2["Num"] = 0] = "Num";
      Type2[Type2["Str"] = 1] = "Str";
    })(Type || (exports.Type = Type = {}));
    function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
      if (dataProp instanceof codegen_1.Name) {
        const isNumber = dataPropType === Type.Num;
        return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
      }
      return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
    }
    exports.getErrorPath = getErrorPath;
    function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
      if (!mode)
        return;
      msg = `strict mode: ${msg}`;
      if (mode === true)
        throw new Error(msg);
      it.self.logger.warn(msg);
    }
    exports.checkStrictMode = checkStrictMode;
  }
});

// node_modules/ajv/dist/compile/names.js
var require_names = __commonJS({
  "node_modules/ajv/dist/compile/names.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var names = {
      // validation function arguments
      data: new codegen_1.Name("data"),
      // data passed to validation function
      // args passed from referencing schema
      valCxt: new codegen_1.Name("valCxt"),
      // validation/data context - should not be used directly, it is destructured to the names below
      instancePath: new codegen_1.Name("instancePath"),
      parentData: new codegen_1.Name("parentData"),
      parentDataProperty: new codegen_1.Name("parentDataProperty"),
      rootData: new codegen_1.Name("rootData"),
      // root data - same as the data passed to the first/top validation function
      dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
      // used to support recursiveRef and dynamicRef
      // function scoped variables
      vErrors: new codegen_1.Name("vErrors"),
      // null or array of validation errors
      errors: new codegen_1.Name("errors"),
      // counter of validation errors
      this: new codegen_1.Name("this"),
      // "globals"
      self: new codegen_1.Name("self"),
      scope: new codegen_1.Name("scope"),
      // JTD serialize/parse name for JSON string and position
      json: new codegen_1.Name("json"),
      jsonPos: new codegen_1.Name("jsonPos"),
      jsonLen: new codegen_1.Name("jsonLen"),
      jsonPart: new codegen_1.Name("jsonPart")
    };
    exports.default = names;
  }
});

// node_modules/ajv/dist/compile/errors.js
var require_errors = __commonJS({
  "node_modules/ajv/dist/compile/errors.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var names_1 = require_names();
    exports.keywordError = {
      message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`
    };
    exports.keyword$DataError = {
      message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`
    };
    function reportError(cxt, error3 = exports.keywordError, errorPaths, overrideAllErrors) {
      const { it } = cxt;
      const { gen, compositeRule, allErrors } = it;
      const errObj = errorObjectCode(cxt, error3, errorPaths);
      if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) {
        addError(gen, errObj);
      } else {
        returnErrors(it, (0, codegen_1._)`[${errObj}]`);
      }
    }
    exports.reportError = reportError;
    function reportExtraError(cxt, error3 = exports.keywordError, errorPaths) {
      const { it } = cxt;
      const { gen, compositeRule, allErrors } = it;
      const errObj = errorObjectCode(cxt, error3, errorPaths);
      addError(gen, errObj);
      if (!(compositeRule || allErrors)) {
        returnErrors(it, names_1.default.vErrors);
      }
    }
    exports.reportExtraError = reportExtraError;
    function resetErrorsCount(gen, errsCount) {
      gen.assign(names_1.default.errors, errsCount);
      gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
    }
    exports.resetErrorsCount = resetErrorsCount;
    function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
      if (errsCount === void 0)
        throw new Error("ajv implementation error");
      const err = gen.name("err");
      gen.forRange("i", errsCount, names_1.default.errors, (i) => {
        gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
        gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
        gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
        if (it.opts.verbose) {
          gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
          gen.assign((0, codegen_1._)`${err}.data`, data);
        }
      });
    }
    exports.extendErrors = extendErrors;
    function addError(gen, errObj) {
      const err = gen.const("err", errObj);
      gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
      gen.code((0, codegen_1._)`${names_1.default.errors}++`);
    }
    function returnErrors(it, errs) {
      const { gen, validateName, schemaEnv } = it;
      if (schemaEnv.$async) {
        gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`);
      } else {
        gen.assign((0, codegen_1._)`${validateName}.errors`, errs);
        gen.return(false);
      }
    }
    var E = {
      keyword: new codegen_1.Name("keyword"),
      schemaPath: new codegen_1.Name("schemaPath"),
      // also used in JTD errors
      params: new codegen_1.Name("params"),
      propertyName: new codegen_1.Name("propertyName"),
      message: new codegen_1.Name("message"),
      schema: new codegen_1.Name("schema"),
      parentSchema: new codegen_1.Name("parentSchema")
    };
    function errorObjectCode(cxt, error3, errorPaths) {
      const { createErrors } = cxt.it;
      if (createErrors === false)
        return (0, codegen_1._)`{}`;
      return errorObject(cxt, error3, errorPaths);
    }
    function errorObject(cxt, error3, errorPaths = {}) {
      const { gen, it } = cxt;
      const keyValues = [
        errorInstancePath(it, errorPaths),
        errorSchemaPath(cxt, errorPaths)
      ];
      extraErrorProps(cxt, error3, keyValues);
      return gen.object(...keyValues);
    }
    function errorInstancePath({ errorPath }, { instancePath }) {
      const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath;
      return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
    }
    function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
      let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
      if (schemaPath) {
        schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
      }
      return [E.schemaPath, schPath];
    }
    function extraErrorProps(cxt, { params, message }, keyValues) {
      const { keyword, data, schemaValue, it } = cxt;
      const { opts, propertyName, topSchemaRef, schemaPath } = it;
      keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]);
      if (opts.messages) {
        keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
      }
      if (opts.verbose) {
        keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
      }
      if (propertyName)
        keyValues.push([E.propertyName, propertyName]);
    }
  }
});

// node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema = __commonJS({
  "node_modules/ajv/dist/compile/validate/boolSchema.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
    var errors_1 = require_errors();
    var codegen_1 = require_codegen();
    var names_1 = require_names();
    var boolError = {
      message: "boolean schema is false"
    };
    function topBoolOrEmptySchema(it) {
      const { gen, schema, validateName } = it;
      if (schema === false) {
        falseSchemaError(it, false);
      } else if (typeof schema == "object" && schema.$async === true) {
        gen.return(names_1.default.data);
      } else {
        gen.assign((0, codegen_1._)`${validateName}.errors`, null);
        gen.return(true);
      }
    }
    exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
    function boolOrEmptySchema(it, valid) {
      const { gen, schema } = it;
      if (schema === false) {
        gen.var(valid, false);
        falseSchemaError(it);
      } else {
        gen.var(valid, true);
      }
    }
    exports.boolOrEmptySchema = boolOrEmptySchema;
    function falseSchemaError(it, overrideAllErrors) {
      const { gen, data } = it;
      const cxt = {
        gen,
        keyword: "false schema",
        data,
        schema: false,
        schemaCode: false,
        schemaValue: false,
        params: {},
        it
      };
      (0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
    }
  }
});

// node_modules/ajv/dist/compile/rules.js
var require_rules = __commonJS({
  "node_modules/ajv/dist/compile/rules.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getRules = exports.isJSONType = void 0;
    var _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
    var jsonTypes = new Set(_jsonTypes);
    function isJSONType(x) {
      return typeof x == "string" && jsonTypes.has(x);
    }
    exports.isJSONType = isJSONType;
    function getRules() {
      const groups = {
        number: { type: "number", rules: [] },
        string: { type: "string", rules: [] },
        array: { type: "array", rules: [] },
        object: { type: "object", rules: [] }
      };
      return {
        types: { ...groups, integer: true, boolean: true, null: true },
        rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
        post: { rules: [] },
        all: {},
        keywords: {}
      };
    }
    exports.getRules = getRules;
  }
});

// node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability = __commonJS({
  "node_modules/ajv/dist/compile/validate/applicability.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
    function schemaHasRulesForType({ schema, self }, type) {
      const group = self.RULES.types[type];
      return group && group !== true && shouldUseGroup(schema, group);
    }
    exports.schemaHasRulesForType = schemaHasRulesForType;
    function shouldUseGroup(schema, group) {
      return group.rules.some((rule) => shouldUseRule(schema, rule));
    }
    exports.shouldUseGroup = shouldUseGroup;
    function shouldUseRule(schema, rule) {
      var _a;
      return schema[rule.keyword] !== void 0 || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0));
    }
    exports.shouldUseRule = shouldUseRule;
  }
});

// node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType = __commonJS({
  "node_modules/ajv/dist/compile/validate/dataType.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
    var rules_1 = require_rules();
    var applicability_1 = require_applicability();
    var errors_1 = require_errors();
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var DataType;
    (function(DataType2) {
      DataType2[DataType2["Correct"] = 0] = "Correct";
      DataType2[DataType2["Wrong"] = 1] = "Wrong";
    })(DataType || (exports.DataType = DataType = {}));
    function getSchemaTypes(schema) {
      const types = getJSONTypes(schema.type);
      const hasNull = types.includes("null");
      if (hasNull) {
        if (schema.nullable === false)
          throw new Error("type: null contradicts nullable: false");
      } else {
        if (!types.length && schema.nullable !== void 0) {
          throw new Error('"nullable" cannot be used without "type"');
        }
        if (schema.nullable === true)
          types.push("null");
      }
      return types;
    }
    exports.getSchemaTypes = getSchemaTypes;
    function getJSONTypes(ts) {
      const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
      if (types.every(rules_1.isJSONType))
        return types;
      throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
    }
    exports.getJSONTypes = getJSONTypes;
    function coerceAndCheckDataType(it, types) {
      const { gen, data, opts } = it;
      const coerceTo = coerceToTypes(types, opts.coerceTypes);
      const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
      if (checkTypes) {
        const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
        gen.if(wrongType, () => {
          if (coerceTo.length)
            coerceData(it, types, coerceTo);
          else
            reportTypeError(it);
        });
      }
      return checkTypes;
    }
    exports.coerceAndCheckDataType = coerceAndCheckDataType;
    var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
    function coerceToTypes(types, coerceTypes) {
      return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
    }
    function coerceData(it, types, coerceTo) {
      const { gen, data, opts } = it;
      const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
      const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
      if (opts.coerceTypes === "array") {
        gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
      }
      gen.if((0, codegen_1._)`${coerced} !== undefined`);
      for (const t of coerceTo) {
        if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") {
          coerceSpecificType(t);
        }
      }
      gen.else();
      reportTypeError(it);
      gen.endIf();
      gen.if((0, codegen_1._)`${coerced} !== undefined`, () => {
        gen.assign(data, coerced);
        assignParentData(it, coerced);
      });
      function coerceSpecificType(t) {
        switch (t) {
          case "string":
            gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
            return;
          case "number":
            gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null
              || (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`);
            return;
          case "integer":
            gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null
              || (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`);
            return;
          case "boolean":
            gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
            return;
          case "null":
            gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`);
            gen.assign(coerced, null);
            return;
          case "array":
            gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number"
              || ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`);
        }
      }
    }
    function assignParentData({ gen, parentData, parentDataProperty }, expr) {
      gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr));
    }
    function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
      const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
      let cond;
      switch (dataType) {
        case "null":
          return (0, codegen_1._)`${data} ${EQ} null`;
        case "array":
          cond = (0, codegen_1._)`Array.isArray(${data})`;
          break;
        case "object":
          cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
          break;
        case "integer":
          cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`);
          break;
        case "number":
          cond = numCond();
          break;
        default:
          return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`;
      }
      return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
      function numCond(_cond = codegen_1.nil) {
        return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil);
      }
    }
    exports.checkDataType = checkDataType;
    function checkDataTypes(dataTypes, data, strictNums, correct) {
      if (dataTypes.length === 1) {
        return checkDataType(dataTypes[0], data, strictNums, correct);
      }
      let cond;
      const types = (0, util_1.toHash)(dataTypes);
      if (types.array && types.object) {
        const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
        cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
        delete types.null;
        delete types.array;
        delete types.object;
      } else {
        cond = codegen_1.nil;
      }
      if (types.number)
        delete types.integer;
      for (const t in types)
        cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
      return cond;
    }
    exports.checkDataTypes = checkDataTypes;
    var typeError = {
      message: ({ schema }) => `must be ${schema}`,
      params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
    };
    function reportTypeError(it) {
      const cxt = getTypeErrorContext(it);
      (0, errors_1.reportError)(cxt, typeError);
    }
    exports.reportTypeError = reportTypeError;
    function getTypeErrorContext(it) {
      const { gen, data, schema } = it;
      const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
      return {
        gen,
        keyword: "type",
        data,
        schema: schema.type,
        schemaCode,
        schemaValue: schemaCode,
        parentSchema: schema,
        params: {},
        it
      };
    }
  }
});

// node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults = __commonJS({
  "node_modules/ajv/dist/compile/validate/defaults.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.assignDefaults = void 0;
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    function assignDefaults(it, ty) {
      const { properties, items } = it.schema;
      if (ty === "object" && properties) {
        for (const key in properties) {
          assignDefault(it, key, properties[key].default);
        }
      } else if (ty === "array" && Array.isArray(items)) {
        items.forEach((sch, i) => assignDefault(it, i, sch.default));
      }
    }
    exports.assignDefaults = assignDefaults;
    function assignDefault(it, prop, defaultValue) {
      const { gen, compositeRule, data, opts } = it;
      if (defaultValue === void 0)
        return;
      const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
      if (compositeRule) {
        (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
        return;
      }
      let condition = (0, codegen_1._)`${childData} === undefined`;
      if (opts.useDefaults === "empty") {
        condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
      }
      gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
    }
  }
});

// node_modules/ajv/dist/vocabularies/code.js
var require_code2 = __commonJS({
  "node_modules/ajv/dist/vocabularies/code.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var names_1 = require_names();
    var util_2 = require_util();
    function checkReportMissingProp(cxt, prop) {
      const { gen, data, it } = cxt;
      gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
        cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
        cxt.error();
      });
    }
    exports.checkReportMissingProp = checkReportMissingProp;
    function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
      return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
    }
    exports.checkMissingProp = checkMissingProp;
    function reportMissingProp(cxt, missing) {
      cxt.setParams({ missingProperty: missing }, true);
      cxt.error();
    }
    exports.reportMissingProp = reportMissingProp;
    function hasPropFunc(gen) {
      return gen.scopeValue("func", {
        // eslint-disable-next-line @typescript-eslint/unbound-method
        ref: Object.prototype.hasOwnProperty,
        code: (0, codegen_1._)`Object.prototype.hasOwnProperty`
      });
    }
    exports.hasPropFunc = hasPropFunc;
    function isOwnProperty(gen, data, property) {
      return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
    }
    exports.isOwnProperty = isOwnProperty;
    function propertyInData(gen, data, property, ownProperties) {
      const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
      return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
    }
    exports.propertyInData = propertyInData;
    function noPropertyInData(gen, data, property, ownProperties) {
      const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
      return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
    }
    exports.noPropertyInData = noPropertyInData;
    function allSchemaProperties(schemaMap) {
      return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
    }
    exports.allSchemaProperties = allSchemaProperties;
    function schemaProperties(it, schemaMap) {
      return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
    }
    exports.schemaProperties = schemaProperties;
    function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
      const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
      const valCxt = [
        [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
        [names_1.default.parentData, it.parentData],
        [names_1.default.parentDataProperty, it.parentDataProperty],
        [names_1.default.rootData, names_1.default.rootData]
      ];
      if (it.opts.dynamicRef)
        valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
      const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
      return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
    }
    exports.callValidateCode = callValidateCode;
    var newRegExp = (0, codegen_1._)`new RegExp`;
    function usePattern({ gen, it: { opts } }, pattern) {
      const u = opts.unicodeRegExp ? "u" : "";
      const { regExp } = opts.code;
      const rx = regExp(pattern, u);
      return gen.scopeValue("pattern", {
        key: rx.toString(),
        ref: rx,
        code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
      });
    }
    exports.usePattern = usePattern;
    function validateArray(cxt) {
      const { gen, data, keyword, it } = cxt;
      const valid = gen.name("valid");
      if (it.allErrors) {
        const validArr = gen.let("valid", true);
        validateItems(() => gen.assign(validArr, false));
        return validArr;
      }
      gen.var(valid, true);
      validateItems(() => gen.break());
      return valid;
      function validateItems(notValid) {
        const len = gen.const("len", (0, codegen_1._)`${data}.length`);
        gen.forRange("i", 0, len, (i) => {
          cxt.subschema({
            keyword,
            dataProp: i,
            dataPropType: util_1.Type.Num
          }, valid);
          gen.if((0, codegen_1.not)(valid), notValid);
        });
      }
    }
    exports.validateArray = validateArray;
    function validateUnion(cxt) {
      const { gen, schema, keyword, it } = cxt;
      if (!Array.isArray(schema))
        throw new Error("ajv implementation error");
      const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
      if (alwaysValid && !it.opts.unevaluated)
        return;
      const valid = gen.let("valid", false);
      const schValid = gen.name("_valid");
      gen.block(() => schema.forEach((_sch, i) => {
        const schCxt = cxt.subschema({
          keyword,
          schemaProp: i,
          compositeRule: true
        }, schValid);
        gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
        const merged = cxt.mergeValidEvaluated(schCxt, schValid);
        if (!merged)
          gen.if((0, codegen_1.not)(valid));
      }));
      cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
    }
    exports.validateUnion = validateUnion;
  }
});

// node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword = __commonJS({
  "node_modules/ajv/dist/compile/validate/keyword.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
    var codegen_1 = require_codegen();
    var names_1 = require_names();
    var code_1 = require_code2();
    var errors_1 = require_errors();
    function macroKeywordCode(cxt, def) {
      const { gen, keyword, schema, parentSchema, it } = cxt;
      const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
      const schemaRef = useKeyword(gen, keyword, macroSchema);
      if (it.opts.validateSchema !== false)
        it.self.validateSchema(macroSchema, true);
      const valid = gen.name("valid");
      cxt.subschema({
        schema: macroSchema,
        schemaPath: codegen_1.nil,
        errSchemaPath: `${it.errSchemaPath}/${keyword}`,
        topSchemaRef: schemaRef,
        compositeRule: true
      }, valid);
      cxt.pass(valid, () => cxt.error(true));
    }
    exports.macroKeywordCode = macroKeywordCode;
    function funcKeywordCode(cxt, def) {
      var _a;
      const { gen, keyword, schema, parentSchema, $data, it } = cxt;
      checkAsyncKeyword(it, def);
      const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
      const validateRef = useKeyword(gen, keyword, validate);
      const valid = gen.let("valid");
      cxt.block$data(valid, validateKeyword);
      cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
      function validateKeyword() {
        if (def.errors === false) {
          assignValid();
          if (def.modifying)
            modifyData(cxt);
          reportErrs(() => cxt.error());
        } else {
          const ruleErrs = def.async ? validateAsync() : validateSync();
          if (def.modifying)
            modifyData(cxt);
          reportErrs(() => addErrs(cxt, ruleErrs));
        }
      }
      function validateAsync() {
        const ruleErrs = gen.let("ruleErrs", null);
        gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e)));
        return ruleErrs;
      }
      function validateSync() {
        const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
        gen.assign(validateErrs, null);
        assignValid(codegen_1.nil);
        return validateErrs;
      }
      function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
        const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
        const passSchema = !("compile" in def && !$data || def.schema === false);
        gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
      }
      function reportErrs(errors) {
        var _a2;
        gen.if((0, codegen_1.not)((_a2 = def.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors);
      }
    }
    exports.funcKeywordCode = funcKeywordCode;
    function modifyData(cxt) {
      const { gen, data, it } = cxt;
      gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`));
    }
    function addErrs(cxt, errs) {
      const { gen } = cxt;
      gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => {
        gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
        (0, errors_1.extendErrors)(cxt);
      }, () => cxt.error());
    }
    function checkAsyncKeyword({ schemaEnv }, def) {
      if (def.async && !schemaEnv.$async)
        throw new Error("async keyword in sync schema");
    }
    function useKeyword(gen, keyword, result) {
      if (result === void 0)
        throw new Error(`keyword "${keyword}" failed to compile`);
      return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
    }
    function validSchemaType(schema, schemaType, allowUndefined = false) {
      return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
    }
    exports.validSchemaType = validSchemaType;
    function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {
      if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
        throw new Error("ajv implementation error");
      }
      const deps = def.dependencies;
      if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
        throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
      }
      if (def.validateSchema) {
        const valid = def.validateSchema(schema[keyword]);
        if (!valid) {
          const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors);
          if (opts.validateSchema === "log")
            self.logger.error(msg);
          else
            throw new Error(msg);
        }
      }
    }
    exports.validateKeywordUsage = validateKeywordUsage;
  }
});

// node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema = __commonJS({
  "node_modules/ajv/dist/compile/validate/subschema.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
      if (keyword !== void 0 && schema !== void 0) {
        throw new Error('both "keyword" and "schema" passed, only one allowed');
      }
      if (keyword !== void 0) {
        const sch = it.schema[keyword];
        return schemaProp === void 0 ? {
          schema: sch,
          schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
          errSchemaPath: `${it.errSchemaPath}/${keyword}`
        } : {
          schema: sch[schemaProp],
          schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
          errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
        };
      }
      if (schema !== void 0) {
        if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
          throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
        }
        return {
          schema,
          schemaPath,
          topSchemaRef,
          errSchemaPath
        };
      }
      throw new Error('either "keyword" or "schema" must be passed');
    }
    exports.getSubschema = getSubschema;
    function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
      if (data !== void 0 && dataProp !== void 0) {
        throw new Error('both "data" and "dataProp" passed, only one allowed');
      }
      const { gen } = it;
      if (dataProp !== void 0) {
        const { errorPath, dataPathArr, opts } = it;
        const nextData = gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true);
        dataContextProps(nextData);
        subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
        subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
        subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
      }
      if (data !== void 0) {
        const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true);
        dataContextProps(nextData);
        if (propertyName !== void 0)
          subschema.propertyName = propertyName;
      }
      if (dataTypes)
        subschema.dataTypes = dataTypes;
      function dataContextProps(_nextData) {
        subschema.data = _nextData;
        subschema.dataLevel = it.dataLevel + 1;
        subschema.dataTypes = [];
        it.definedProperties = /* @__PURE__ */ new Set();
        subschema.parentData = it.data;
        subschema.dataNames = [...it.dataNames, _nextData];
      }
    }
    exports.extendSubschemaData = extendSubschemaData;
    function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
      if (compositeRule !== void 0)
        subschema.compositeRule = compositeRule;
      if (createErrors !== void 0)
        subschema.createErrors = createErrors;
      if (allErrors !== void 0)
        subschema.allErrors = allErrors;
      subschema.jtdDiscriminator = jtdDiscriminator;
      subschema.jtdMetadata = jtdMetadata;
    }
    exports.extendSubschemaMode = extendSubschemaMode;
  }
});

// node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = __commonJS({
  "node_modules/fast-deep-equal/index.js"(exports, module) {
    "use strict";
    module.exports = function equal(a, b) {
      if (a === b) return true;
      if (a && b && typeof a == "object" && typeof b == "object") {
        if (a.constructor !== b.constructor) return false;
        var length, i, keys;
        if (Array.isArray(a)) {
          length = a.length;
          if (length != b.length) return false;
          for (i = length; i-- !== 0; )
            if (!equal(a[i], b[i])) return false;
          return true;
        }
        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
        keys = Object.keys(a);
        length = keys.length;
        if (length !== Object.keys(b).length) return false;
        for (i = length; i-- !== 0; )
          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
        for (i = length; i-- !== 0; ) {
          var key = keys[i];
          if (!equal(a[key], b[key])) return false;
        }
        return true;
      }
      return a !== a && b !== b;
    };
  }
});

// node_modules/json-schema-traverse/index.js
var require_json_schema_traverse = __commonJS({
  "node_modules/json-schema-traverse/index.js"(exports, module) {
    "use strict";
    var traverse = module.exports = function(schema, opts, cb) {
      if (typeof opts == "function") {
        cb = opts;
        opts = {};
      }
      cb = opts.cb || cb;
      var pre = typeof cb == "function" ? cb : cb.pre || function() {
      };
      var post = cb.post || function() {
      };
      _traverse(opts, pre, post, schema, "", schema);
    };
    traverse.keywords = {
      additionalItems: true,
      items: true,
      contains: true,
      additionalProperties: true,
      propertyNames: true,
      not: true,
      if: true,
      then: true,
      else: true
    };
    traverse.arrayKeywords = {
      items: true,
      allOf: true,
      anyOf: true,
      oneOf: true
    };
    traverse.propsKeywords = {
      $defs: true,
      definitions: true,
      properties: true,
      patternProperties: true,
      dependencies: true
    };
    traverse.skipKeywords = {
      default: true,
      enum: true,
      const: true,
      required: true,
      maximum: true,
      minimum: true,
      exclusiveMaximum: true,
      exclusiveMinimum: true,
      multipleOf: true,
      maxLength: true,
      minLength: true,
      pattern: true,
      format: true,
      maxItems: true,
      minItems: true,
      uniqueItems: true,
      maxProperties: true,
      minProperties: true
    };
    function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
      if (schema && typeof schema == "object" && !Array.isArray(schema)) {
        pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
        for (var key in schema) {
          var sch = schema[key];
          if (Array.isArray(sch)) {
            if (key in traverse.arrayKeywords) {
              for (var i = 0; i < sch.length; i++)
                _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
            }
          } else if (key in traverse.propsKeywords) {
            if (sch && typeof sch == "object") {
              for (var prop in sch)
                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
            }
          } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
          }
        }
        post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
      }
    }
    function escapeJsonPtr(str) {
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
  }
});

// node_modules/ajv/dist/compile/resolve.js
var require_resolve = __commonJS({
  "node_modules/ajv/dist/compile/resolve.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
    var util_1 = require_util();
    var equal = require_fast_deep_equal();
    var traverse = require_json_schema_traverse();
    var SIMPLE_INLINED = /* @__PURE__ */ new Set([
      "type",
      "format",
      "pattern",
      "maxLength",
      "minLength",
      "maxProperties",
      "minProperties",
      "maxItems",
      "minItems",
      "maximum",
      "minimum",
      "uniqueItems",
      "multipleOf",
      "required",
      "enum",
      "const"
    ]);
    function inlineRef(schema, limit = true) {
      if (typeof schema == "boolean")
        return true;
      if (limit === true)
        return !hasRef(schema);
      if (!limit)
        return false;
      return countKeys(schema) <= limit;
    }
    exports.inlineRef = inlineRef;
    var REF_KEYWORDS = /* @__PURE__ */ new Set([
      "$ref",
      "$recursiveRef",
      "$recursiveAnchor",
      "$dynamicRef",
      "$dynamicAnchor"
    ]);
    function hasRef(schema) {
      for (const key in schema) {
        if (REF_KEYWORDS.has(key))
          return true;
        const sch = schema[key];
        if (Array.isArray(sch) && sch.some(hasRef))
          return true;
        if (typeof sch == "object" && hasRef(sch))
          return true;
      }
      return false;
    }
    function countKeys(schema) {
      let count = 0;
      for (const key in schema) {
        if (key === "$ref")
          return Infinity;
        count++;
        if (SIMPLE_INLINED.has(key))
          continue;
        if (typeof schema[key] == "object") {
          (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
        }
        if (count === Infinity)
          return Infinity;
      }
      return count;
    }
    function getFullPath(resolver, id = "", normalize3) {
      if (normalize3 !== false)
        id = normalizeId(id);
      const p = resolver.parse(id);
      return _getFullPath(resolver, p);
    }
    exports.getFullPath = getFullPath;
    function _getFullPath(resolver, p) {
      const serialized = resolver.serialize(p);
      return serialized.split("#")[0] + "#";
    }
    exports._getFullPath = _getFullPath;
    var TRAILING_SLASH_HASH = /#\/?$/;
    function normalizeId(id) {
      return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
    }
    exports.normalizeId = normalizeId;
    function resolveUrl(resolver, baseId, id) {
      id = normalizeId(id);
      return resolver.resolve(baseId, id);
    }
    exports.resolveUrl = resolveUrl;
    var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
    function getSchemaRefs(schema, baseId) {
      if (typeof schema == "boolean")
        return {};
      const { schemaId, uriResolver } = this.opts;
      const schId = normalizeId(schema[schemaId] || baseId);
      const baseIds = { "": schId };
      const pathPrefix = getFullPath(uriResolver, schId, false);
      const localRefs = {};
      const schemaRefs = /* @__PURE__ */ new Set();
      traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
        if (parentJsonPtr === void 0)
          return;
        const fullPath = pathPrefix + jsonPtr;
        let innerBaseId = baseIds[parentJsonPtr];
        if (typeof sch[schemaId] == "string")
          innerBaseId = addRef.call(this, sch[schemaId]);
        addAnchor.call(this, sch.$anchor);
        addAnchor.call(this, sch.$dynamicAnchor);
        baseIds[jsonPtr] = innerBaseId;
        function addRef(ref) {
          const _resolve = this.opts.uriResolver.resolve;
          ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
          if (schemaRefs.has(ref))
            throw ambiguos(ref);
          schemaRefs.add(ref);
          let schOrRef = this.refs[ref];
          if (typeof schOrRef == "string")
            schOrRef = this.refs[schOrRef];
          if (typeof schOrRef == "object") {
            checkAmbiguosRef(sch, schOrRef.schema, ref);
          } else if (ref !== normalizeId(fullPath)) {
            if (ref[0] === "#") {
              checkAmbiguosRef(sch, localRefs[ref], ref);
              localRefs[ref] = sch;
            } else {
              this.refs[ref] = fullPath;
            }
          }
          return ref;
        }
        function addAnchor(anchor) {
          if (typeof anchor == "string") {
            if (!ANCHOR.test(anchor))
              throw new Error(`invalid anchor "${anchor}"`);
            addRef.call(this, `#${anchor}`);
          }
        }
      });
      return localRefs;
      function checkAmbiguosRef(sch1, sch2, ref) {
        if (sch2 !== void 0 && !equal(sch1, sch2))
          throw ambiguos(ref);
      }
      function ambiguos(ref) {
        return new Error(`reference "${ref}" resolves to more than one schema`);
      }
    }
    exports.getSchemaRefs = getSchemaRefs;
  }
});

// node_modules/ajv/dist/compile/validate/index.js
var require_validate = __commonJS({
  "node_modules/ajv/dist/compile/validate/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
    var boolSchema_1 = require_boolSchema();
    var dataType_1 = require_dataType();
    var applicability_1 = require_applicability();
    var dataType_2 = require_dataType();
    var defaults_1 = require_defaults();
    var keyword_1 = require_keyword();
    var subschema_1 = require_subschema();
    var codegen_1 = require_codegen();
    var names_1 = require_names();
    var resolve_1 = require_resolve();
    var util_1 = require_util();
    var errors_1 = require_errors();
    function validateFunctionCode(it) {
      if (isSchemaObj(it)) {
        checkKeywords(it);
        if (schemaCxtHasRules(it)) {
          topSchemaObjCode(it);
          return;
        }
      }
      validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
    }
    exports.validateFunctionCode = validateFunctionCode;
    function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
      if (opts.code.es5) {
        gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
          gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
          destructureValCxtES5(gen, opts);
          gen.code(body);
        });
      } else {
        gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
      }
    }
    function destructureValCxt(opts) {
      return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
    }
    function destructureValCxtES5(gen, opts) {
      gen.if(names_1.default.valCxt, () => {
        gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`);
        gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`);
        gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);
        gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`);
        if (opts.dynamicRef)
          gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);
      }, () => {
        gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
        gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
        gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
        gen.var(names_1.default.rootData, names_1.default.data);
        if (opts.dynamicRef)
          gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
      });
    }
    function topSchemaObjCode(it) {
      const { schema, opts, gen } = it;
      validateFunction(it, () => {
        if (opts.$comment && schema.$comment)
          commentKeyword(it);
        checkNoDefault(it);
        gen.let(names_1.default.vErrors, null);
        gen.let(names_1.default.errors, 0);
        if (opts.unevaluated)
          resetEvaluated(it);
        typeAndKeywords(it);
        returnResults(it);
      });
      return;
    }
    function resetEvaluated(it) {
      const { gen, validateName } = it;
      it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
      gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
      gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
    }
    function funcSourceUrl(schema, opts) {
      const schId = typeof schema == "object" && schema[opts.schemaId];
      return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
    }
    function subschemaCode(it, valid) {
      if (isSchemaObj(it)) {
        checkKeywords(it);
        if (schemaCxtHasRules(it)) {
          subSchemaObjCode(it, valid);
          return;
        }
      }
      (0, boolSchema_1.boolOrEmptySchema)(it, valid);
    }
    function schemaCxtHasRules({ schema, self }) {
      if (typeof schema == "boolean")
        return !schema;
      for (const key in schema)
        if (self.RULES.all[key])
          return true;
      return false;
    }
    function isSchemaObj(it) {
      return typeof it.schema != "boolean";
    }
    function subSchemaObjCode(it, valid) {
      const { schema, gen, opts } = it;
      if (opts.$comment && schema.$comment)
        commentKeyword(it);
      updateContext(it);
      checkAsyncSchema(it);
      const errsCount = gen.const("_errs", names_1.default.errors);
      typeAndKeywords(it, errsCount);
      gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
    }
    function checkKeywords(it) {
      (0, util_1.checkUnknownRules)(it);
      checkRefsAndKeywords(it);
    }
    function typeAndKeywords(it, errsCount) {
      if (it.opts.jtd)
        return schemaKeywords(it, [], false, errsCount);
      const types = (0, dataType_1.getSchemaTypes)(it.schema);
      const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);
      schemaKeywords(it, types, !checkedTypes, errsCount);
    }
    function checkRefsAndKeywords(it) {
      const { schema, errSchemaPath, opts, self } = it;
      if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) {
        self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
      }
    }
    function checkNoDefault(it) {
      const { schema, opts } = it;
      if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) {
        (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
      }
    }
    function updateContext(it) {
      const schId = it.schema[it.opts.schemaId];
      if (schId)
        it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
    }
    function checkAsyncSchema(it) {
      if (it.schema.$async && !it.schemaEnv.$async)
        throw new Error("async schema in sync schema");
    }
    function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
      const msg = schema.$comment;
      if (opts.$comment === true) {
        gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
      } else if (typeof opts.$comment == "function") {
        const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
        const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
        gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
      }
    }
    function returnResults(it) {
      const { gen, schemaEnv, validateName, ValidationError, opts } = it;
      if (schemaEnv.$async) {
        gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
      } else {
        gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
        if (opts.unevaluated)
          assignEvaluated(it);
        gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
      }
    }
    function assignEvaluated({ gen, evaluated, props, items }) {
      if (props instanceof codegen_1.Name)
        gen.assign((0, codegen_1._)`${evaluated}.props`, props);
      if (items instanceof codegen_1.Name)
        gen.assign((0, codegen_1._)`${evaluated}.items`, items);
    }
    function schemaKeywords(it, types, typeErrors, errsCount) {
      const { gen, schema, data, allErrors, opts, self } = it;
      const { RULES } = self;
      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
        gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
        return;
      }
      if (!opts.jtd)
        checkStrictTypes(it, types);
      gen.block(() => {
        for (const group of RULES.rules)
          groupKeywords(group);
        groupKeywords(RULES.post);
      });
      function groupKeywords(group) {
        if (!(0, applicability_1.shouldUseGroup)(schema, group))
          return;
        if (group.type) {
          gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
          iterateKeywords(it, group);
          if (types.length === 1 && types[0] === group.type && typeErrors) {
            gen.else();
            (0, dataType_2.reportTypeError)(it);
          }
          gen.endIf();
        } else {
          iterateKeywords(it, group);
        }
        if (!allErrors)
          gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
      }
    }
    function iterateKeywords(it, group) {
      const { gen, schema, opts: { useDefaults } } = it;
      if (useDefaults)
        (0, defaults_1.assignDefaults)(it, group.type);
      gen.block(() => {
        for (const rule of group.rules) {
          if ((0, applicability_1.shouldUseRule)(schema, rule)) {
            keywordCode(it, rule.keyword, rule.definition, group.type);
          }
        }
      });
    }
    function checkStrictTypes(it, types) {
      if (it.schemaEnv.meta || !it.opts.strictTypes)
        return;
      checkContextTypes(it, types);
      if (!it.opts.allowUnionTypes)
        checkMultipleTypes(it, types);
      checkKeywordTypes(it, it.dataTypes);
    }
    function checkContextTypes(it, types) {
      if (!types.length)
        return;
      if (!it.dataTypes.length) {
        it.dataTypes = types;
        return;
      }
      types.forEach((t) => {
        if (!includesType(it.dataTypes, t)) {
          strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
        }
      });
      narrowSchemaTypes(it, types);
    }
    function checkMultipleTypes(it, ts) {
      if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
        strictTypesError(it, "use allowUnionTypes to allow union type keyword");
      }
    }
    function checkKeywordTypes(it, ts) {
      const rules = it.self.RULES.all;
      for (const keyword in rules) {
        const rule = rules[keyword];
        if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
          const { type } = rule.definition;
          if (type.length && !type.some((t) => hasApplicableType(ts, t))) {
            strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
          }
        }
      }
    }
    function hasApplicableType(schTs, kwdT) {
      return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
    }
    function includesType(ts, t) {
      return ts.includes(t) || t === "integer" && ts.includes("number");
    }
    function narrowSchemaTypes(it, withTypes) {
      const ts = [];
      for (const t of it.dataTypes) {
        if (includesType(withTypes, t))
          ts.push(t);
        else if (withTypes.includes("integer") && t === "number")
          ts.push("integer");
      }
      it.dataTypes = ts;
    }
    function strictTypesError(it, msg) {
      const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
      msg += ` at "${schemaPath}" (strictTypes)`;
      (0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
    }
    var KeywordCxt = class {
      constructor(it, def, keyword) {
        (0, keyword_1.validateKeywordUsage)(it, def, keyword);
        this.gen = it.gen;
        this.allErrors = it.allErrors;
        this.keyword = keyword;
        this.data = it.data;
        this.schema = it.schema[keyword];
        this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
        this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
        this.schemaType = def.schemaType;
        this.parentSchema = it.schema;
        this.params = {};
        this.it = it;
        this.def = def;
        if (this.$data) {
          this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
        } else {
          this.schemaCode = this.schemaValue;
          if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) {
            throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
          }
        }
        if ("code" in def ? def.trackErrors : def.errors !== false) {
          this.errsCount = it.gen.const("_errs", names_1.default.errors);
        }
      }
      result(condition, successAction, failAction) {
        this.failResult((0, codegen_1.not)(condition), successAction, failAction);
      }
      failResult(condition, successAction, failAction) {
        this.gen.if(condition);
        if (failAction)
          failAction();
        else
          this.error();
        if (successAction) {
          this.gen.else();
          successAction();
          if (this.allErrors)
            this.gen.endIf();
        } else {
          if (this.allErrors)
            this.gen.endIf();
          else
            this.gen.else();
        }
      }
      pass(condition, failAction) {
        this.failResult((0, codegen_1.not)(condition), void 0, failAction);
      }
      fail(condition) {
        if (condition === void 0) {
          this.error();
          if (!this.allErrors)
            this.gen.if(false);
          return;
        }
        this.gen.if(condition);
        this.error();
        if (this.allErrors)
          this.gen.endIf();
        else
          this.gen.else();
      }
      fail$data(condition) {
        if (!this.$data)
          return this.fail(condition);
        const { schemaCode } = this;
        this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
      }
      error(append, errorParams, errorPaths) {
        if (errorParams) {
          this.setParams(errorParams);
          this._error(append, errorPaths);
          this.setParams({});
          return;
        }
        this._error(append, errorPaths);
      }
      _error(append, errorPaths) {
        ;
        (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
      }
      $dataError() {
        (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
      }
      reset() {
        if (this.errsCount === void 0)
          throw new Error('add "trackErrors" to keyword definition');
        (0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
      }
      ok(cond) {
        if (!this.allErrors)
          this.gen.if(cond);
      }
      setParams(obj, assign) {
        if (assign)
          Object.assign(this.params, obj);
        else
          this.params = obj;
      }
      block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
        this.gen.block(() => {
          this.check$data(valid, $dataValid);
          codeBlock();
        });
      }
      check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
        if (!this.$data)
          return;
        const { gen, schemaCode, schemaType, def } = this;
        gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
        if (valid !== codegen_1.nil)
          gen.assign(valid, true);
        if (schemaType.length || def.validateSchema) {
          gen.elseIf(this.invalid$data());
          this.$dataError();
          if (valid !== codegen_1.nil)
            gen.assign(valid, false);
        }
        gen.else();
      }
      invalid$data() {
        const { gen, schemaCode, schemaType, def, it } = this;
        return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
        function wrong$DataType() {
          if (schemaType.length) {
            if (!(schemaCode instanceof codegen_1.Name))
              throw new Error("ajv implementation error");
            const st = Array.isArray(schemaType) ? schemaType : [schemaType];
            return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
          }
          return codegen_1.nil;
        }
        function invalid$DataSchema() {
          if (def.validateSchema) {
            const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema });
            return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`;
          }
          return codegen_1.nil;
        }
      }
      subschema(appl, valid) {
        const subschema = (0, subschema_1.getSubschema)(this.it, appl);
        (0, subschema_1.extendSubschemaData)(subschema, this.it, appl);
        (0, subschema_1.extendSubschemaMode)(subschema, appl);
        const nextContext = { ...this.it, ...subschema, items: void 0, props: void 0 };
        subschemaCode(nextContext, valid);
        return nextContext;
      }
      mergeEvaluated(schemaCxt, toName) {
        const { it, gen } = this;
        if (!it.opts.unevaluated)
          return;
        if (it.props !== true && schemaCxt.props !== void 0) {
          it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
        }
        if (it.items !== true && schemaCxt.items !== void 0) {
          it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
        }
      }
      mergeValidEvaluated(schemaCxt, valid) {
        const { it, gen } = this;
        if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
          gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));
          return true;
        }
      }
    };
    exports.KeywordCxt = KeywordCxt;
    function keywordCode(it, keyword, def, ruleType) {
      const cxt = new KeywordCxt(it, def, keyword);
      if ("code" in def) {
        def.code(cxt, ruleType);
      } else if (cxt.$data && def.validate) {
        (0, keyword_1.funcKeywordCode)(cxt, def);
      } else if ("macro" in def) {
        (0, keyword_1.macroKeywordCode)(cxt, def);
      } else if (def.compile || def.validate) {
        (0, keyword_1.funcKeywordCode)(cxt, def);
      }
    }
    var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
    var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
    function getData($data, { dataLevel, dataNames, dataPathArr }) {
      let jsonPointer;
      let data;
      if ($data === "")
        return names_1.default.rootData;
      if ($data[0] === "/") {
        if (!JSON_POINTER.test($data))
          throw new Error(`Invalid JSON-pointer: ${$data}`);
        jsonPointer = $data;
        data = names_1.default.rootData;
      } else {
        const matches = RELATIVE_JSON_POINTER.exec($data);
        if (!matches)
          throw new Error(`Invalid JSON-pointer: ${$data}`);
        const up = +matches[1];
        jsonPointer = matches[2];
        if (jsonPointer === "#") {
          if (up >= dataLevel)
            throw new Error(errorMsg("property/index", up));
          return dataPathArr[dataLevel - up];
        }
        if (up > dataLevel)
          throw new Error(errorMsg("data", up));
        data = dataNames[dataLevel - up];
        if (!jsonPointer)
          return data;
      }
      let expr = data;
      const segments = jsonPointer.split("/");
      for (const segment of segments) {
        if (segment) {
          data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
          expr = (0, codegen_1._)`${expr} && ${data}`;
        }
      }
      return expr;
      function errorMsg(pointerType, up) {
        return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
      }
    }
    exports.getData = getData;
  }
});

// node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error = __commonJS({
  "node_modules/ajv/dist/runtime/validation_error.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var ValidationError = class extends Error {
      constructor(errors) {
        super("validation failed");
        this.errors = errors;
        this.ajv = this.validation = true;
      }
    };
    exports.default = ValidationError;
  }
});

// node_modules/ajv/dist/compile/ref_error.js
var require_ref_error = __commonJS({
  "node_modules/ajv/dist/compile/ref_error.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var resolve_1 = require_resolve();
    var MissingRefError = class extends Error {
      constructor(resolver, baseId, ref, msg) {
        super(msg || `can't resolve reference ${ref} from id ${baseId}`);
        this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
        this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
      }
    };
    exports.default = MissingRefError;
  }
});

// node_modules/ajv/dist/compile/index.js
var require_compile = __commonJS({
  "node_modules/ajv/dist/compile/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
    var codegen_1 = require_codegen();
    var validation_error_1 = require_validation_error();
    var names_1 = require_names();
    var resolve_1 = require_resolve();
    var util_1 = require_util();
    var validate_1 = require_validate();
    var SchemaEnv = class {
      constructor(env) {
        var _a;
        this.refs = {};
        this.dynamicAnchors = {};
        let schema;
        if (typeof env.schema == "object")
          schema = env.schema;
        this.schema = env.schema;
        this.schemaId = env.schemaId;
        this.root = env.root || this;
        this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
        this.schemaPath = env.schemaPath;
        this.localRefs = env.localRefs;
        this.meta = env.meta;
        this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
        this.refs = {};
      }
    };
    exports.SchemaEnv = SchemaEnv;
    function compileSchema(sch) {
      const _sch = getCompilingSchema.call(this, sch);
      if (_sch)
        return _sch;
      const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
      const { es5, lines } = this.opts.code;
      const { ownProperties } = this.opts;
      const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
      let _ValidationError;
      if (sch.$async) {
        _ValidationError = gen.scopeValue("Error", {
          ref: validation_error_1.default,
          code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
        });
      }
      const validateName = gen.scopeName("validate");
      sch.validateName = validateName;
      const schemaCxt = {
        gen,
        allErrors: this.opts.allErrors,
        data: names_1.default.data,
        parentData: names_1.default.parentData,
        parentDataProperty: names_1.default.parentDataProperty,
        dataNames: [names_1.default.data],
        dataPathArr: [codegen_1.nil],
        // TODO can its length be used as dataLevel if nil is removed?
        dataLevel: 0,
        dataTypes: [],
        definedProperties: /* @__PURE__ */ new Set(),
        topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }),
        validateName,
        ValidationError: _ValidationError,
        schema: sch.schema,
        schemaEnv: sch,
        rootId,
        baseId: sch.baseId || rootId,
        schemaPath: codegen_1.nil,
        errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
        errorPath: (0, codegen_1._)`""`,
        opts: this.opts,
        self: this
      };
      let sourceCode;
      try {
        this._compilations.add(sch);
        (0, validate_1.validateFunctionCode)(schemaCxt);
        gen.optimize(this.opts.code.optimize);
        const validateCode = gen.toString();
        sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
        if (this.opts.code.process)
          sourceCode = this.opts.code.process(sourceCode, sch);
        const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
        const validate = makeValidate(this, this.scope.get());
        this.scope.value(validateName, { ref: validate });
        validate.errors = null;
        validate.schema = sch.schema;
        validate.schemaEnv = sch;
        if (sch.$async)
          validate.$async = true;
        if (this.opts.code.source === true) {
          validate.source = { validateName, validateCode, scopeValues: gen._values };
        }
        if (this.opts.unevaluated) {
          const { props, items } = schemaCxt;
          validate.evaluated = {
            props: props instanceof codegen_1.Name ? void 0 : props,
            items: items instanceof codegen_1.Name ? void 0 : items,
            dynamicProps: props instanceof codegen_1.Name,
            dynamicItems: items instanceof codegen_1.Name
          };
          if (validate.source)
            validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
        }
        sch.validate = validate;
        return sch;
      } catch (e) {
        delete sch.validate;
        delete sch.validateName;
        if (sourceCode)
          this.logger.error("Error compiling schema, function code:", sourceCode);
        throw e;
      } finally {
        this._compilations.delete(sch);
      }
    }
    exports.compileSchema = compileSchema;
    function resolveRef(root, baseId, ref) {
      var _a;
      ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
      const schOrFunc = root.refs[ref];
      if (schOrFunc)
        return schOrFunc;
      let _sch = resolve3.call(this, root, ref);
      if (_sch === void 0) {
        const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
        const { schemaId } = this.opts;
        if (schema)
          _sch = new SchemaEnv({ schema, schemaId, root, baseId });
      }
      if (_sch === void 0)
        return;
      return root.refs[ref] = inlineOrCompile.call(this, _sch);
    }
    exports.resolveRef = resolveRef;
    function inlineOrCompile(sch) {
      if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
        return sch.schema;
      return sch.validate ? sch : compileSchema.call(this, sch);
    }
    function getCompilingSchema(schEnv) {
      for (const sch of this._compilations) {
        if (sameSchemaEnv(sch, schEnv))
          return sch;
      }
    }
    exports.getCompilingSchema = getCompilingSchema;
    function sameSchemaEnv(s1, s2) {
      return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
    }
    function resolve3(root, ref) {
      let sch;
      while (typeof (sch = this.refs[ref]) == "string")
        ref = sch;
      return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
    }
    function resolveSchema(root, ref) {
      const p = this.opts.uriResolver.parse(ref);
      const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
      let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
      if (Object.keys(root.schema).length > 0 && refPath === baseId) {
        return getJsonPointer.call(this, p, root);
      }
      const id = (0, resolve_1.normalizeId)(refPath);
      const schOrRef = this.refs[id] || this.schemas[id];
      if (typeof schOrRef == "string") {
        const sch = resolveSchema.call(this, root, schOrRef);
        if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
          return;
        return getJsonPointer.call(this, p, sch);
      }
      if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
        return;
      if (!schOrRef.validate)
        compileSchema.call(this, schOrRef);
      if (id === (0, resolve_1.normalizeId)(ref)) {
        const { schema } = schOrRef;
        const { schemaId } = this.opts;
        const schId = schema[schemaId];
        if (schId)
          baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
        return new SchemaEnv({ schema, schemaId, root, baseId });
      }
      return getJsonPointer.call(this, p, schOrRef);
    }
    exports.resolveSchema = resolveSchema;
    var PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
      "properties",
      "patternProperties",
      "enum",
      "dependencies",
      "definitions"
    ]);
    function getJsonPointer(parsedRef, { baseId, schema, root }) {
      var _a;
      if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
        return;
      for (const part of parsedRef.fragment.slice(1).split("/")) {
        if (typeof schema === "boolean")
          return;
        const partSchema = schema[(0, util_1.unescapeFragment)(part)];
        if (partSchema === void 0)
          return;
        schema = partSchema;
        const schId = typeof schema === "object" && schema[this.opts.schemaId];
        if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
          baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
        }
      }
      let env;
      if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
        const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
        env = resolveSchema.call(this, root, $ref);
      }
      const { schemaId } = this.opts;
      env = env || new SchemaEnv({ schema, schemaId, root, baseId });
      if (env.schema !== env.root.schema)
        return env;
      return void 0;
    }
  }
});

// node_modules/ajv/dist/refs/data.json
var require_data = __commonJS({
  "node_modules/ajv/dist/refs/data.json"(exports, module) {
    module.exports = {
      $id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
      description: "Meta-schema for $data reference (JSON AnySchema extension proposal)",
      type: "object",
      required: ["$data"],
      properties: {
        $data: {
          type: "string",
          anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }]
        }
      },
      additionalProperties: false
    };
  }
});

// node_modules/fast-uri/lib/utils.js
var require_utils = __commonJS({
  "node_modules/fast-uri/lib/utils.js"(exports, module) {
    "use strict";
    var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
    var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
    function stringArrayToHexStripped(input) {
      let acc = "";
      let code = 0;
      let i = 0;
      for (i = 0; i < input.length; i++) {
        code = input[i].charCodeAt(0);
        if (code === 48) {
          continue;
        }
        if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
          return "";
        }
        acc += input[i];
        break;
      }
      for (i += 1; i < input.length; i++) {
        code = input[i].charCodeAt(0);
        if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
          return "";
        }
        acc += input[i];
      }
      return acc;
    }
    var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
    function consumeIsZone(buffer) {
      buffer.length = 0;
      return true;
    }
    function consumeHextets(buffer, address, output) {
      if (buffer.length) {
        const hex = stringArrayToHexStripped(buffer);
        if (hex !== "") {
          address.push(hex);
        } else {
          output.error = true;
          return false;
        }
        buffer.length = 0;
      }
      return true;
    }
    function getIPV6(input) {
      let tokenCount = 0;
      const output = { error: false, address: "", zone: "" };
      const address = [];
      const buffer = [];
      let endipv6Encountered = false;
      let endIpv6 = false;
      let consume = consumeHextets;
      for (let i = 0; i < input.length; i++) {
        const cursor = input[i];
        if (cursor === "[" || cursor === "]") {
          continue;
        }
        if (cursor === ":") {
          if (endipv6Encountered === true) {
            endIpv6 = true;
          }
          if (!consume(buffer, address, output)) {
            break;
          }
          if (++tokenCount > 7) {
            output.error = true;
            break;
          }
          if (i > 0 && input[i - 1] === ":") {
            endipv6Encountered = true;
          }
          address.push(":");
          continue;
        } else if (cursor === "%") {
          if (!consume(buffer, address, output)) {
            break;
          }
          consume = consumeIsZone;
        } else {
          buffer.push(cursor);
          continue;
        }
      }
      if (buffer.length) {
        if (consume === consumeIsZone) {
          output.zone = buffer.join("");
        } else if (endIpv6) {
          address.push(buffer.join(""));
        } else {
          address.push(stringArrayToHexStripped(buffer));
        }
      }
      output.address = address.join("");
      return output;
    }
    function normalizeIPv6(host) {
      if (findToken(host, ":") < 2) {
        return { host, isIPV6: false };
      }
      const ipv62 = getIPV6(host);
      if (!ipv62.error) {
        let newHost = ipv62.address;
        let escapedHost = ipv62.address;
        if (ipv62.zone) {
          newHost += "%" + ipv62.zone;
          escapedHost += "%25" + ipv62.zone;
        }
        return { host: newHost, isIPV6: true, escapedHost };
      } else {
        return { host, isIPV6: false };
      }
    }
    function findToken(str, token) {
      let ind = 0;
      for (let i = 0; i < str.length; i++) {
        if (str[i] === token) ind++;
      }
      return ind;
    }
    function removeDotSegments(path) {
      let input = path;
      const output = [];
      let nextSlash = -1;
      let len = 0;
      while (len = input.length) {
        if (len === 1) {
          if (input === ".") {
            break;
          } else if (input === "/") {
            output.push("/");
            break;
          } else {
            output.push(input);
            break;
          }
        } else if (len === 2) {
          if (input[0] === ".") {
            if (input[1] === ".") {
              break;
            } else if (input[1] === "/") {
              input = input.slice(2);
              continue;
            }
          } else if (input[0] === "/") {
            if (input[1] === "." || input[1] === "/") {
              output.push("/");
              break;
            }
          }
        } else if (len === 3) {
          if (input === "/..") {
            if (output.length !== 0) {
              output.pop();
            }
            output.push("/");
            break;
          }
        }
        if (input[0] === ".") {
          if (input[1] === ".") {
            if (input[2] === "/") {
              input = input.slice(3);
              continue;
            }
          } else if (input[1] === "/") {
            input = input.slice(2);
            continue;
          }
        } else if (input[0] === "/") {
          if (input[1] === ".") {
            if (input[2] === "/") {
              input = input.slice(2);
              continue;
            } else if (input[2] === ".") {
              if (input[3] === "/") {
                input = input.slice(3);
                if (output.length !== 0) {
                  output.pop();
                }
                continue;
              }
            }
          }
        }
        if ((nextSlash = input.indexOf("/", 1)) === -1) {
          output.push(input);
          break;
        } else {
          output.push(input.slice(0, nextSlash));
          input = input.slice(nextSlash);
        }
      }
      return output.join("");
    }
    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
    var HOST_DELIM_RE = /[@/?#:]/g;
    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
    function reescapeHostDelimiters(host, isIP) {
      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
      re.lastIndex = 0;
      return host.replace(re, (ch) => HOST_DELIMS[ch]);
    }
    function normalizePercentEncoding(input, decodeUnreserved = false) {
      if (input.indexOf("%") === -1) {
        return input;
      }
      let output = "";
      for (let i = 0; i < input.length; i++) {
        if (input[i] === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            const normalizedHex = hex.toUpperCase();
            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
            if (decodeUnreserved && isUnreserved(decoded)) {
              output += decoded;
            } else {
              output += "%" + normalizedHex;
            }
            i += 2;
            continue;
          }
        }
        output += input[i];
      }
      return output;
    }
    function normalizePathEncoding(input) {
      let output = "";
      for (let i = 0; i < input.length; i++) {
        if (input[i] === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            const normalizedHex = hex.toUpperCase();
            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
            if (decoded !== "." && isUnreserved(decoded)) {
              output += decoded;
            } else {
              output += "%" + normalizedHex;
            }
            i += 2;
            continue;
          }
        }
        if (isPathCharacter(input[i])) {
          output += input[i];
        } else {
          output += escape(input[i]);
        }
      }
      return output;
    }
    function escapePreservingEscapes(input) {
      let output = "";
      for (let i = 0; i < input.length; i++) {
        if (input[i] === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            output += "%" + hex.toUpperCase();
            i += 2;
            continue;
          }
        }
        output += escape(input[i]);
      }
      return output;
    }
    function recomposeAuthority(component) {
      const uriTokens = [];
      if (component.userinfo !== void 0) {
        uriTokens.push(component.userinfo);
        uriTokens.push("@");
      }
      if (component.host !== void 0) {
        let host = unescape(component.host);
        if (!isIPv4(host)) {
          const ipV6res = normalizeIPv6(host);
          if (ipV6res.isIPV6 === true) {
            host = `[${ipV6res.escapedHost}]`;
          } else {
            host = reescapeHostDelimiters(host, false);
          }
        }
        uriTokens.push(host);
      }
      if (typeof component.port === "number" || typeof component.port === "string") {
        uriTokens.push(":");
        uriTokens.push(String(component.port));
      }
      return uriTokens.length ? uriTokens.join("") : void 0;
    }
    module.exports = {
      nonSimpleDomain,
      recomposeAuthority,
      reescapeHostDelimiters,
      normalizePercentEncoding,
      normalizePathEncoding,
      escapePreservingEscapes,
      removeDotSegments,
      isIPv4,
      isUUID,
      normalizeIPv6,
      stringArrayToHexStripped
    };
  }
});

// node_modules/fast-uri/lib/schemes.js
var require_schemes = __commonJS({
  "node_modules/fast-uri/lib/schemes.js"(exports, module) {
    "use strict";
    var { isUUID } = require_utils();
    var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
    var supportedSchemeNames = (
      /** @type {const} */
      [
        "http",
        "https",
        "ws",
        "wss",
        "urn",
        "urn:uuid"
      ]
    );
    function isValidSchemeName(name) {
      return supportedSchemeNames.indexOf(
        /** @type {*} */
        name
      ) !== -1;
    }
    function wsIsSecure(wsComponent) {
      if (wsComponent.secure === true) {
        return true;
      } else if (wsComponent.secure === false) {
        return false;
      } else if (wsComponent.scheme) {
        return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
      } else {
        return false;
      }
    }
    function httpParse(component) {
      if (!component.host) {
        component.error = component.error || "HTTP URIs must have a host.";
      }
      return component;
    }
    function httpSerialize(component) {
      const secure = String(component.scheme).toLowerCase() === "https";
      if (component.port === (secure ? 443 : 80) || component.port === "") {
        component.port = void 0;
      }
      if (!component.path) {
        component.path = "/";
      }
      return component;
    }
    function wsParse(wsComponent) {
      wsComponent.secure = wsIsSecure(wsComponent);
      wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
      wsComponent.path = void 0;
      wsComponent.query = void 0;
      return wsComponent;
    }
    function wsSerialize(wsComponent) {
      if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") {
        wsComponent.port = void 0;
      }
      if (typeof wsComponent.secure === "boolean") {
        wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
        wsComponent.secure = void 0;
      }
      if (wsComponent.resourceName) {
        const [path, query] = wsComponent.resourceName.split("?");
        wsComponent.path = path && path !== "/" ? path : void 0;
        wsComponent.query = query;
        wsComponent.resourceName = void 0;
      }
      wsComponent.fragment = void 0;
      return wsComponent;
    }
    function urnParse(urnComponent, options) {
      if (!urnComponent.path) {
        urnComponent.error = "URN can not be parsed";
        return urnComponent;
      }
      const matches = urnComponent.path.match(URN_REG);
      if (matches) {
        const scheme = options.scheme || urnComponent.scheme || "urn";
        urnComponent.nid = matches[1].toLowerCase();
        urnComponent.nss = matches[2];
        const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`;
        const schemeHandler = getSchemeHandler(urnScheme);
        urnComponent.path = void 0;
        if (schemeHandler) {
          urnComponent = schemeHandler.parse(urnComponent, options);
        }
      } else {
        urnComponent.error = urnComponent.error || "URN can not be parsed.";
      }
      return urnComponent;
    }
    function urnSerialize(urnComponent, options) {
      if (urnComponent.nid === void 0) {
        throw new Error("URN without nid cannot be serialized");
      }
      const scheme = options.scheme || urnComponent.scheme || "urn";
      const nid = urnComponent.nid.toLowerCase();
      const urnScheme = `${scheme}:${options.nid || nid}`;
      const schemeHandler = getSchemeHandler(urnScheme);
      if (schemeHandler) {
        urnComponent = schemeHandler.serialize(urnComponent, options);
      }
      const uriComponent = urnComponent;
      const nss = urnComponent.nss;
      uriComponent.path = `${nid || options.nid}:${nss}`;
      options.skipEscape = true;
      return uriComponent;
    }
    function urnuuidParse(urnComponent, options) {
      const uuidComponent = urnComponent;
      uuidComponent.uuid = uuidComponent.nss;
      uuidComponent.nss = void 0;
      if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {
        uuidComponent.error = uuidComponent.error || "UUID is not valid.";
      }
      return uuidComponent;
    }
    function urnuuidSerialize(uuidComponent) {
      const urnComponent = uuidComponent;
      urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
      return urnComponent;
    }
    var http = (
      /** @type {SchemeHandler} */
      {
        scheme: "http",
        domainHost: true,
        parse: httpParse,
        serialize: httpSerialize
      }
    );
    var https = (
      /** @type {SchemeHandler} */
      {
        scheme: "https",
        domainHost: http.domainHost,
        parse: httpParse,
        serialize: httpSerialize
      }
    );
    var ws = (
      /** @type {SchemeHandler} */
      {
        scheme: "ws",
        domainHost: true,
        parse: wsParse,
        serialize: wsSerialize
      }
    );
    var wss = (
      /** @type {SchemeHandler} */
      {
        scheme: "wss",
        domainHost: ws.domainHost,
        parse: ws.parse,
        serialize: ws.serialize
      }
    );
    var urn = (
      /** @type {SchemeHandler} */
      {
        scheme: "urn",
        parse: urnParse,
        serialize: urnSerialize,
        skipNormalize: true
      }
    );
    var urnuuid = (
      /** @type {SchemeHandler} */
      {
        scheme: "urn:uuid",
        parse: urnuuidParse,
        serialize: urnuuidSerialize,
        skipNormalize: true
      }
    );
    var SCHEMES = (
      /** @type {Record<SchemeName, SchemeHandler>} */
      {
        http,
        https,
        ws,
        wss,
        urn,
        "urn:uuid": urnuuid
      }
    );
    Object.setPrototypeOf(SCHEMES, null);
    function getSchemeHandler(scheme) {
      return scheme && (SCHEMES[
        /** @type {SchemeName} */
        scheme
      ] || SCHEMES[
        /** @type {SchemeName} */
        scheme.toLowerCase()
      ]) || void 0;
    }
    module.exports = {
      wsIsSecure,
      SCHEMES,
      isValidSchemeName,
      getSchemeHandler
    };
  }
});

// node_modules/fast-uri/index.js
var require_fast_uri = __commonJS({
  "node_modules/fast-uri/index.js"(exports, module) {
    "use strict";
    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
    var { SCHEMES, getSchemeHandler } = require_schemes();
    function normalize3(uri, options) {
      if (typeof uri === "string") {
        uri = /** @type {T} */
        normalizeString(uri, options);
      } else if (typeof uri === "object") {
        uri = /** @type {T} */
        parse5(serialize(uri, options), options);
      }
      return uri;
    }
    function resolve3(baseURI, relativeURI, options) {
      const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
      const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
      schemelessOptions.skipEscape = true;
      return serialize(resolved, schemelessOptions);
    }
    function resolveComponent(base, relative, options, skipNormalization) {
      const target = {};
      if (!skipNormalization) {
        base = parse5(serialize(base, options), options);
        relative = parse5(serialize(relative, options), options);
      }
      options = options || {};
      if (!options.tolerant && relative.scheme) {
        target.scheme = relative.scheme;
        target.userinfo = relative.userinfo;
        target.host = relative.host;
        target.port = relative.port;
        target.path = removeDotSegments(relative.path || "");
        target.query = relative.query;
      } else {
        if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
          target.userinfo = relative.userinfo;
          target.host = relative.host;
          target.port = relative.port;
          target.path = removeDotSegments(relative.path || "");
          target.query = relative.query;
        } else {
          if (!relative.path) {
            target.path = base.path;
            if (relative.query !== void 0) {
              target.query = relative.query;
            } else {
              target.query = base.query;
            }
          } else {
            if (relative.path[0] === "/") {
              target.path = removeDotSegments(relative.path);
            } else {
              if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
                target.path = "/" + relative.path;
              } else if (!base.path) {
                target.path = relative.path;
              } else {
                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
              }
              target.path = removeDotSegments(target.path);
            }
            target.query = relative.query;
          }
          target.userinfo = base.userinfo;
          target.host = base.host;
          target.port = base.port;
        }
        target.scheme = base.scheme;
      }
      target.fragment = relative.fragment;
      return target;
    }
    function equal(uriA, uriB, options) {
      const normalizedA = normalizeComparableURI(uriA, options);
      const normalizedB = normalizeComparableURI(uriB, options);
      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
    }
    function serialize(cmpts, opts) {
      const component = {
        host: cmpts.host,
        scheme: cmpts.scheme,
        userinfo: cmpts.userinfo,
        port: cmpts.port,
        path: cmpts.path,
        query: cmpts.query,
        nid: cmpts.nid,
        nss: cmpts.nss,
        uuid: cmpts.uuid,
        fragment: cmpts.fragment,
        reference: cmpts.reference,
        resourceName: cmpts.resourceName,
        secure: cmpts.secure,
        error: ""
      };
      const options = Object.assign({}, opts);
      const uriTokens = [];
      const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
      if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
      if (component.path !== void 0) {
        if (!options.skipEscape) {
          component.path = escapePreservingEscapes(component.path);
          if (component.scheme !== void 0) {
            component.path = component.path.split("%3A").join(":");
          }
        } else {
          component.path = normalizePercentEncoding(component.path);
        }
      }
      if (options.reference !== "suffix" && component.scheme) {
        uriTokens.push(component.scheme, ":");
      }
      const authority = recomposeAuthority(component);
      if (authority !== void 0) {
        if (options.reference !== "suffix") {
          uriTokens.push("//");
        }
        uriTokens.push(authority);
        if (component.path && component.path[0] !== "/") {
          uriTokens.push("/");
        }
      }
      if (component.path !== void 0) {
        let s = component.path;
        if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
          s = removeDotSegments(s);
        }
        if (authority === void 0 && s[0] === "/" && s[1] === "/") {
          s = "/%2F" + s.slice(2);
        }
        uriTokens.push(s);
      }
      if (component.query !== void 0) {
        uriTokens.push("?", component.query);
      }
      if (component.fragment !== void 0) {
        uriTokens.push("#", component.fragment);
      }
      return uriTokens.join("");
    }
    var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
    function getParseError(parsed, matches) {
      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
        return 'URI path must start with "/" when authority is present.';
      }
      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
        return "URI port is malformed.";
      }
      return void 0;
    }
    function parseWithStatus(uri, opts) {
      const options = Object.assign({}, opts);
      const parsed = {
        scheme: void 0,
        userinfo: void 0,
        host: "",
        port: void 0,
        path: "",
        query: void 0,
        fragment: void 0
      };
      let malformedAuthorityOrPort = false;
      let isIP = false;
      if (options.reference === "suffix") {
        if (options.scheme) {
          uri = options.scheme + ":" + uri;
        } else {
          uri = "//" + uri;
        }
      }
      const matches = uri.match(URI_PARSE);
      if (matches) {
        parsed.scheme = matches[1];
        parsed.userinfo = matches[3];
        parsed.host = matches[4];
        parsed.port = parseInt(matches[5], 10);
        parsed.path = matches[6] || "";
        parsed.query = matches[7];
        parsed.fragment = matches[8];
        if (isNaN(parsed.port)) {
          parsed.port = matches[5];
        }
        const parseError = getParseError(parsed, matches);
        if (parseError !== void 0) {
          parsed.error = parsed.error || parseError;
          malformedAuthorityOrPort = true;
        }
        if (parsed.host) {
          const ipv4result = isIPv4(parsed.host);
          if (ipv4result === false) {
            const ipv6result = normalizeIPv6(parsed.host);
            parsed.host = ipv6result.host.toLowerCase();
            isIP = ipv6result.isIPV6;
          } else {
            isIP = true;
          }
        }
        if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) {
          parsed.reference = "same-document";
        } else if (parsed.scheme === void 0) {
          parsed.reference = "relative";
        } else if (parsed.fragment === void 0) {
          parsed.reference = "absolute";
        } else {
          parsed.reference = "uri";
        }
        if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
          parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
        }
        const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
            try {
              parsed.host = new URL("http://" + parsed.host).hostname;
            } catch (e) {
              parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
            }
          }
        }
        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
          if (uri.indexOf("%") !== -1) {
            if (parsed.scheme !== void 0) {
              parsed.scheme = unescape(parsed.scheme);
            }
            if (parsed.host !== void 0) {
              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
            }
          }
          if (parsed.path) {
            parsed.path = normalizePathEncoding(parsed.path);
          }
          if (parsed.fragment) {
            try {
              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
            } catch {
              parsed.error = parsed.error || "URI malformed";
            }
          }
        }
        if (schemeHandler && schemeHandler.parse) {
          schemeHandler.parse(parsed, options);
        }
      } else {
        parsed.error = parsed.error || "URI can not be parsed.";
      }
      return { parsed, malformedAuthorityOrPort };
    }
    function parse5(uri, opts) {
      return parseWithStatus(uri, opts).parsed;
    }
    function normalizeString(uri, opts) {
      return normalizeStringWithStatus(uri, opts).normalized;
    }
    function normalizeStringWithStatus(uri, opts) {
      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
      return {
        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
        malformedAuthorityOrPort
      };
    }
    function normalizeComparableURI(uri, opts) {
      if (typeof uri === "string") {
        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
        return malformedAuthorityOrPort ? void 0 : normalized;
      }
      if (typeof uri === "object") {
        return serialize(uri, opts);
      }
    }
    var fastUri = {
      SCHEMES,
      normalize: normalize3,
      resolve: resolve3,
      resolveComponent,
      equal,
      serialize,
      parse: parse5
    };
    module.exports = fastUri;
    module.exports.default = fastUri;
    module.exports.fastUri = fastUri;
  }
});

// node_modules/ajv/dist/runtime/uri.js
var require_uri = __commonJS({
  "node_modules/ajv/dist/runtime/uri.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var uri = require_fast_uri();
    uri.code = 'require("ajv/dist/runtime/uri").default';
    exports.default = uri;
  }
});

// node_modules/ajv/dist/core.js
var require_core = __commonJS({
  "node_modules/ajv/dist/core.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
    var validate_1 = require_validate();
    Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
      return validate_1.KeywordCxt;
    } });
    var codegen_1 = require_codegen();
    Object.defineProperty(exports, "_", { enumerable: true, get: function() {
      return codegen_1._;
    } });
    Object.defineProperty(exports, "str", { enumerable: true, get: function() {
      return codegen_1.str;
    } });
    Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
      return codegen_1.stringify;
    } });
    Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
      return codegen_1.nil;
    } });
    Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
      return codegen_1.Name;
    } });
    Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
      return codegen_1.CodeGen;
    } });
    var validation_error_1 = require_validation_error();
    var ref_error_1 = require_ref_error();
    var rules_1 = require_rules();
    var compile_1 = require_compile();
    var codegen_2 = require_codegen();
    var resolve_1 = require_resolve();
    var dataType_1 = require_dataType();
    var util_1 = require_util();
    var $dataRefSchema = require_data();
    var uri_1 = require_uri();
    var defaultRegExp = (str, flags) => new RegExp(str, flags);
    defaultRegExp.code = "new RegExp";
    var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
    var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
      "validate",
      "serialize",
      "parse",
      "wrapper",
      "root",
      "schema",
      "keyword",
      "pattern",
      "formats",
      "validate$data",
      "func",
      "obj",
      "Error"
    ]);
    var removedOptions = {
      errorDataPath: "",
      format: "`validateFormats: false` can be used instead.",
      nullable: '"nullable" keyword is supported by default.',
      jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
      extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
      missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
      processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
      sourceCode: "Use option `code: {source: true}`",
      strictDefaults: "It is default now, see option `strict`.",
      strictKeywords: "It is default now, see option `strict`.",
      uniqueItems: '"uniqueItems" keyword is always validated.',
      unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
      cache: "Map is used as cache, schema object as key.",
      serialize: "Map is used as cache, schema object as key.",
      ajvErrors: "It is default now."
    };
    var deprecatedOptions = {
      ignoreKeywordsWithRef: "",
      jsPropertySyntax: "",
      unicode: '"minLength"/"maxLength" account for unicode characters by default.'
    };
    var MAX_EXPRESSION = 200;
    function requiredOptions(o) {
      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
      const s = o.strict;
      const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;
      const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
      const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
      const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
      return {
        strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
        strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
        strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
        strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
        strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
        code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },
        loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
        loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
        meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
        messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
        inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
        schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
        addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
        validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
        validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
        unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
        int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
        uriResolver
      };
    }
    var Ajv2 = class {
      constructor(opts = {}) {
        this.schemas = {};
        this.refs = {};
        this.formats = /* @__PURE__ */ Object.create(null);
        this._compilations = /* @__PURE__ */ new Set();
        this._loading = {};
        this._cache = /* @__PURE__ */ new Map();
        opts = this.opts = { ...opts, ...requiredOptions(opts) };
        const { es5, lines } = this.opts.code;
        this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });
        this.logger = getLogger(opts.logger);
        const formatOpt = opts.validateFormats;
        opts.validateFormats = false;
        this.RULES = (0, rules_1.getRules)();
        checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
        checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
        this._metaOpts = getMetaSchemaOptions.call(this);
        if (opts.formats)
          addInitialFormats.call(this);
        this._addVocabularies();
        this._addDefaultMetaSchema();
        if (opts.keywords)
          addInitialKeywords.call(this, opts.keywords);
        if (typeof opts.meta == "object")
          this.addMetaSchema(opts.meta);
        addInitialSchemas.call(this);
        opts.validateFormats = formatOpt;
      }
      _addVocabularies() {
        this.addKeyword("$async");
      }
      _addDefaultMetaSchema() {
        const { $data, meta, schemaId } = this.opts;
        let _dataRefSchema = $dataRefSchema;
        if (schemaId === "id") {
          _dataRefSchema = { ...$dataRefSchema };
          _dataRefSchema.id = _dataRefSchema.$id;
          delete _dataRefSchema.$id;
        }
        if (meta && $data)
          this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
      }
      defaultMeta() {
        const { meta, schemaId } = this.opts;
        return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : void 0;
      }
      validate(schemaKeyRef, data) {
        let v;
        if (typeof schemaKeyRef == "string") {
          v = this.getSchema(schemaKeyRef);
          if (!v)
            throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
        } else {
          v = this.compile(schemaKeyRef);
        }
        const valid = v(data);
        if (!("$async" in v))
          this.errors = v.errors;
        return valid;
      }
      compile(schema, _meta) {
        const sch = this._addSchema(schema, _meta);
        return sch.validate || this._compileSchemaEnv(sch);
      }
      compileAsync(schema, meta) {
        if (typeof this.opts.loadSchema != "function") {
          throw new Error("options.loadSchema should be a function");
        }
        const { loadSchema } = this.opts;
        return runCompileAsync.call(this, schema, meta);
        async function runCompileAsync(_schema, _meta) {
          await loadMetaSchema.call(this, _schema.$schema);
          const sch = this._addSchema(_schema, _meta);
          return sch.validate || _compileAsync.call(this, sch);
        }
        async function loadMetaSchema($ref) {
          if ($ref && !this.getSchema($ref)) {
            await runCompileAsync.call(this, { $ref }, true);
          }
        }
        async function _compileAsync(sch) {
          try {
            return this._compileSchemaEnv(sch);
          } catch (e) {
            if (!(e instanceof ref_error_1.default))
              throw e;
            checkLoaded.call(this, e);
            await loadMissingSchema.call(this, e.missingSchema);
            return _compileAsync.call(this, sch);
          }
        }
        function checkLoaded({ missingSchema: ref, missingRef }) {
          if (this.refs[ref]) {
            throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
          }
        }
        async function loadMissingSchema(ref) {
          const _schema = await _loadSchema.call(this, ref);
          if (!this.refs[ref])
            await loadMetaSchema.call(this, _schema.$schema);
          if (!this.refs[ref])
            this.addSchema(_schema, ref, meta);
        }
        async function _loadSchema(ref) {
          const p = this._loading[ref];
          if (p)
            return p;
          try {
            return await (this._loading[ref] = loadSchema(ref));
          } finally {
            delete this._loading[ref];
          }
        }
      }
      // Adds schema to the instance
      addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
        if (Array.isArray(schema)) {
          for (const sch of schema)
            this.addSchema(sch, void 0, _meta, _validateSchema);
          return this;
        }
        let id;
        if (typeof schema === "object") {
          const { schemaId } = this.opts;
          id = schema[schemaId];
          if (id !== void 0 && typeof id != "string") {
            throw new Error(`schema ${schemaId} must be string`);
          }
        }
        key = (0, resolve_1.normalizeId)(key || id);
        this._checkUnique(key);
        this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
        return this;
      }
      // Add schema that will be used to validate other schemas
      // options in META_IGNORE_OPTIONS are alway set to false
      addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
        this.addSchema(schema, key, true, _validateSchema);
        return this;
      }
      //  Validate schema against its meta-schema
      validateSchema(schema, throwOrLogError) {
        if (typeof schema == "boolean")
          return true;
        let $schema;
        $schema = schema.$schema;
        if ($schema !== void 0 && typeof $schema != "string") {
          throw new Error("$schema must be a string");
        }
        $schema = $schema || this.opts.defaultMeta || this.defaultMeta();
        if (!$schema) {
          this.logger.warn("meta-schema not available");
          this.errors = null;
          return true;
        }
        const valid = this.validate($schema, schema);
        if (!valid && throwOrLogError) {
          const message = "schema is invalid: " + this.errorsText();
          if (this.opts.validateSchema === "log")
            this.logger.error(message);
          else
            throw new Error(message);
        }
        return valid;
      }
      // Get compiled schema by `key` or `ref`.
      // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
      getSchema(keyRef) {
        let sch;
        while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")
          keyRef = sch;
        if (sch === void 0) {
          const { schemaId } = this.opts;
          const root = new compile_1.SchemaEnv({ schema: {}, schemaId });
          sch = compile_1.resolveSchema.call(this, root, keyRef);
          if (!sch)
            return;
          this.refs[keyRef] = sch;
        }
        return sch.validate || this._compileSchemaEnv(sch);
      }
      // Remove cached schema(s).
      // If no parameter is passed all schemas but meta-schemas are removed.
      // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
      // Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
      removeSchema(schemaKeyRef) {
        if (schemaKeyRef instanceof RegExp) {
          this._removeAllSchemas(this.schemas, schemaKeyRef);
          this._removeAllSchemas(this.refs, schemaKeyRef);
          return this;
        }
        switch (typeof schemaKeyRef) {
          case "undefined":
            this._removeAllSchemas(this.schemas);
            this._removeAllSchemas(this.refs);
            this._cache.clear();
            return this;
          case "string": {
            const sch = getSchEnv.call(this, schemaKeyRef);
            if (typeof sch == "object")
              this._cache.delete(sch.schema);
            delete this.schemas[schemaKeyRef];
            delete this.refs[schemaKeyRef];
            return this;
          }
          case "object": {
            const cacheKey = schemaKeyRef;
            this._cache.delete(cacheKey);
            let id = schemaKeyRef[this.opts.schemaId];
            if (id) {
              id = (0, resolve_1.normalizeId)(id);
              delete this.schemas[id];
              delete this.refs[id];
            }
            return this;
          }
          default:
            throw new Error("ajv.removeSchema: invalid parameter");
        }
      }
      // add "vocabulary" - a collection of keywords
      addVocabulary(definitions) {
        for (const def of definitions)
          this.addKeyword(def);
        return this;
      }
      addKeyword(kwdOrDef, def) {
        let keyword;
        if (typeof kwdOrDef == "string") {
          keyword = kwdOrDef;
          if (typeof def == "object") {
            this.logger.warn("these parameters are deprecated, see docs for addKeyword");
            def.keyword = keyword;
          }
        } else if (typeof kwdOrDef == "object" && def === void 0) {
          def = kwdOrDef;
          keyword = def.keyword;
          if (Array.isArray(keyword) && !keyword.length) {
            throw new Error("addKeywords: keyword must be string or non-empty array");
          }
        } else {
          throw new Error("invalid addKeywords parameters");
        }
        checkKeyword.call(this, keyword, def);
        if (!def) {
          (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
          return this;
        }
        keywordMetaschema.call(this, def);
        const definition = {
          ...def,
          type: (0, dataType_1.getJSONTypes)(def.type),
          schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
        };
        (0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
        return this;
      }
      getKeyword(keyword) {
        const rule = this.RULES.all[keyword];
        return typeof rule == "object" ? rule.definition : !!rule;
      }
      // Remove keyword
      removeKeyword(keyword) {
        const { RULES } = this;
        delete RULES.keywords[keyword];
        delete RULES.all[keyword];
        for (const group of RULES.rules) {
          const i = group.rules.findIndex((rule) => rule.keyword === keyword);
          if (i >= 0)
            group.rules.splice(i, 1);
        }
        return this;
      }
      // Add format
      addFormat(name, format) {
        if (typeof format == "string")
          format = new RegExp(format);
        this.formats[name] = format;
        return this;
      }
      errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
        if (!errors || errors.length === 0)
          return "No errors";
        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
      }
      $dataMetaSchema(metaSchema, keywordsJsonPointers) {
        const rules = this.RULES.all;
        metaSchema = JSON.parse(JSON.stringify(metaSchema));
        for (const jsonPointer of keywordsJsonPointers) {
          const segments = jsonPointer.split("/").slice(1);
          let keywords = metaSchema;
          for (const seg of segments)
            keywords = keywords[seg];
          for (const key in rules) {
            const rule = rules[key];
            if (typeof rule != "object")
              continue;
            const { $data } = rule.definition;
            const schema = keywords[key];
            if ($data && schema)
              keywords[key] = schemaOrData(schema);
          }
        }
        return metaSchema;
      }
      _removeAllSchemas(schemas, regex) {
        for (const keyRef in schemas) {
          const sch = schemas[keyRef];
          if (!regex || regex.test(keyRef)) {
            if (typeof sch == "string") {
              delete schemas[keyRef];
            } else if (sch && !sch.meta) {
              this._cache.delete(sch.schema);
              delete schemas[keyRef];
            }
          }
        }
      }
      _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
        let id;
        const { schemaId } = this.opts;
        if (typeof schema == "object") {
          id = schema[schemaId];
        } else {
          if (this.opts.jtd)
            throw new Error("schema must be object");
          else if (typeof schema != "boolean")
            throw new Error("schema must be object or boolean");
        }
        let sch = this._cache.get(schema);
        if (sch !== void 0)
          return sch;
        baseId = (0, resolve_1.normalizeId)(id || baseId);
        const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
        sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
        this._cache.set(sch.schema, sch);
        if (addSchema && !baseId.startsWith("#")) {
          if (baseId)
            this._checkUnique(baseId);
          this.refs[baseId] = sch;
        }
        if (validateSchema)
          this.validateSchema(schema, true);
        return sch;
      }
      _checkUnique(id) {
        if (this.schemas[id] || this.refs[id]) {
          throw new Error(`schema with key or id "${id}" already exists`);
        }
      }
      _compileSchemaEnv(sch) {
        if (sch.meta)
          this._compileMetaSchema(sch);
        else
          compile_1.compileSchema.call(this, sch);
        if (!sch.validate)
          throw new Error("ajv implementation error");
        return sch.validate;
      }
      _compileMetaSchema(sch) {
        const currentOpts = this.opts;
        this.opts = this._metaOpts;
        try {
          compile_1.compileSchema.call(this, sch);
        } finally {
          this.opts = currentOpts;
        }
      }
    };
    Ajv2.ValidationError = validation_error_1.default;
    Ajv2.MissingRefError = ref_error_1.default;
    exports.default = Ajv2;
    function checkOptions(checkOpts, options, msg, log = "error") {
      for (const key in checkOpts) {
        const opt = key;
        if (opt in options)
          this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
      }
    }
    function getSchEnv(keyRef) {
      keyRef = (0, resolve_1.normalizeId)(keyRef);
      return this.schemas[keyRef] || this.refs[keyRef];
    }
    function addInitialSchemas() {
      const optsSchemas = this.opts.schemas;
      if (!optsSchemas)
        return;
      if (Array.isArray(optsSchemas))
        this.addSchema(optsSchemas);
      else
        for (const key in optsSchemas)
          this.addSchema(optsSchemas[key], key);
    }
    function addInitialFormats() {
      for (const name in this.opts.formats) {
        const format = this.opts.formats[name];
        if (format)
          this.addFormat(name, format);
      }
    }
    function addInitialKeywords(defs) {
      if (Array.isArray(defs)) {
        this.addVocabulary(defs);
        return;
      }
      this.logger.warn("keywords option as map is deprecated, pass array");
      for (const keyword in defs) {
        const def = defs[keyword];
        if (!def.keyword)
          def.keyword = keyword;
        this.addKeyword(def);
      }
    }
    function getMetaSchemaOptions() {
      const metaOpts = { ...this.opts };
      for (const opt of META_IGNORE_OPTIONS)
        delete metaOpts[opt];
      return metaOpts;
    }
    var noLogs = { log() {
    }, warn() {
    }, error() {
    } };
    function getLogger(logger) {
      if (logger === false)
        return noLogs;
      if (logger === void 0)
        return console;
      if (logger.log && logger.warn && logger.error)
        return logger;
      throw new Error("logger must implement log, warn and error methods");
    }
    var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
    function checkKeyword(keyword, def) {
      const { RULES } = this;
      (0, util_1.eachItem)(keyword, (kwd) => {
        if (RULES.keywords[kwd])
          throw new Error(`Keyword ${kwd} is already defined`);
        if (!KEYWORD_NAME.test(kwd))
          throw new Error(`Keyword ${kwd} has invalid name`);
      });
      if (!def)
        return;
      if (def.$data && !("code" in def || "validate" in def)) {
        throw new Error('$data keyword must have "code" or "validate" function');
      }
    }
    function addRule(keyword, definition, dataType) {
      var _a;
      const post = definition === null || definition === void 0 ? void 0 : definition.post;
      if (dataType && post)
        throw new Error('keyword with "post" flag cannot have "type"');
      const { RULES } = this;
      let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
      if (!ruleGroup) {
        ruleGroup = { type: dataType, rules: [] };
        RULES.rules.push(ruleGroup);
      }
      RULES.keywords[keyword] = true;
      if (!definition)
        return;
      const rule = {
        keyword,
        definition: {
          ...definition,
          type: (0, dataType_1.getJSONTypes)(definition.type),
          schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType)
        }
      };
      if (definition.before)
        addBeforeRule.call(this, ruleGroup, rule, definition.before);
      else
        ruleGroup.rules.push(rule);
      RULES.all[keyword] = rule;
      (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));
    }
    function addBeforeRule(ruleGroup, rule, before) {
      const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
      if (i >= 0) {
        ruleGroup.rules.splice(i, 0, rule);
      } else {
        ruleGroup.rules.push(rule);
        this.logger.warn(`rule ${before} is not defined`);
      }
    }
    function keywordMetaschema(def) {
      let { metaSchema } = def;
      if (metaSchema === void 0)
        return;
      if (def.$data && this.opts.$data)
        metaSchema = schemaOrData(metaSchema);
      def.validateSchema = this.compile(metaSchema, true);
    }
    var $dataRef = {
      $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
    };
    function schemaOrData(schema) {
      return { anyOf: [schema, $dataRef] };
    }
  }
});

// node_modules/ajv/dist/vocabularies/core/id.js
var require_id = __commonJS({
  "node_modules/ajv/dist/vocabularies/core/id.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var def = {
      keyword: "id",
      code() {
        throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref = __commonJS({
  "node_modules/ajv/dist/vocabularies/core/ref.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.callRef = exports.getValidate = void 0;
    var ref_error_1 = require_ref_error();
    var code_1 = require_code2();
    var codegen_1 = require_codegen();
    var names_1 = require_names();
    var compile_1 = require_compile();
    var util_1 = require_util();
    var def = {
      keyword: "$ref",
      schemaType: "string",
      code(cxt) {
        const { gen, schema: $ref, it } = cxt;
        const { baseId, schemaEnv: env, validateName, opts, self } = it;
        const { root } = env;
        if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
          return callRootRef();
        const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
        if (schOrEnv === void 0)
          throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
        if (schOrEnv instanceof compile_1.SchemaEnv)
          return callValidate(schOrEnv);
        return inlineRefSchema(schOrEnv);
        function callRootRef() {
          if (env === root)
            return callRef(cxt, validateName, env, env.$async);
          const rootName = gen.scopeValue("root", { ref: root });
          return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
        }
        function callValidate(sch) {
          const v = getValidate(cxt, sch);
          callRef(cxt, v, sch, sch.$async);
        }
        function inlineRefSchema(sch) {
          const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch });
          const valid = gen.name("valid");
          const schCxt = cxt.subschema({
            schema: sch,
            dataTypes: [],
            schemaPath: codegen_1.nil,
            topSchemaRef: schName,
            errSchemaPath: $ref
          }, valid);
          cxt.mergeEvaluated(schCxt);
          cxt.ok(valid);
        }
      }
    };
    function getValidate(cxt, sch) {
      const { gen } = cxt;
      return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
    }
    exports.getValidate = getValidate;
    function callRef(cxt, v, sch, $async) {
      const { gen, it } = cxt;
      const { allErrors, schemaEnv: env, opts } = it;
      const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
      if ($async)
        callAsyncRef();
      else
        callSyncRef();
      function callAsyncRef() {
        if (!env.$async)
          throw new Error("async schema referenced by sync schema");
        const valid = gen.let("valid");
        gen.try(() => {
          gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
          addEvaluatedFrom(v);
          if (!allErrors)
            gen.assign(valid, true);
        }, (e) => {
          gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
          addErrorsFrom(e);
          if (!allErrors)
            gen.assign(valid, false);
        });
        cxt.ok(valid);
      }
      function callSyncRef() {
        cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
      }
      function addErrorsFrom(source) {
        const errs = (0, codegen_1._)`${source}.errors`;
        gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
        gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
      }
      function addEvaluatedFrom(source) {
        var _a;
        if (!it.opts.unevaluated)
          return;
        const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
        if (it.props !== true) {
          if (schEvaluated && !schEvaluated.dynamicProps) {
            if (schEvaluated.props !== void 0) {
              it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
            }
          } else {
            const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
            it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
          }
        }
        if (it.items !== true) {
          if (schEvaluated && !schEvaluated.dynamicItems) {
            if (schEvaluated.items !== void 0) {
              it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
            }
          } else {
            const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
            it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
          }
        }
      }
    }
    exports.callRef = callRef;
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/core/index.js
var require_core2 = __commonJS({
  "node_modules/ajv/dist/vocabularies/core/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var id_1 = require_id();
    var ref_1 = require_ref();
    var core = [
      "$schema",
      "$id",
      "$defs",
      "$vocabulary",
      { keyword: "$comment" },
      "definitions",
      id_1.default,
      ref_1.default
    ];
    exports.default = core;
  }
});

// node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/limitNumber.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var ops = codegen_1.operators;
    var KWDs = {
      maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
      minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
      exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
      exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
    };
    var error3 = {
      message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
      params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
    };
    var def = {
      keyword: Object.keys(KWDs),
      type: "number",
      schemaType: "number",
      $data: true,
      error: error3,
      code(cxt) {
        const { keyword, data, schemaCode } = cxt;
        cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/multipleOf.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var error3 = {
      message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
      params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
    };
    var def = {
      keyword: "multipleOf",
      type: "number",
      schemaType: "number",
      $data: true,
      error: error3,
      code(cxt) {
        const { gen, data, schemaCode, it } = cxt;
        const prec = it.opts.multipleOfPrecision;
        const res = gen.let("res");
        const invalid3 = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
        cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid3}))`);
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length = __commonJS({
  "node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    function ucs2length(str) {
      const len = str.length;
      let length = 0;
      let pos = 0;
      let value;
      while (pos < len) {
        length++;
        value = str.charCodeAt(pos++);
        if (value >= 55296 && value <= 56319 && pos < len) {
          value = str.charCodeAt(pos);
          if ((value & 64512) === 56320)
            pos++;
        }
      }
      return length;
    }
    exports.default = ucs2length;
    ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
  }
});

// node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/limitLength.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var ucs2length_1 = require_ucs2length();
    var error3 = {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxLength" ? "more" : "fewer";
        return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
    };
    var def = {
      keyword: ["maxLength", "minLength"],
      type: "string",
      schemaType: "number",
      $data: true,
      error: error3,
      code(cxt) {
        const { keyword, data, schemaCode, it } = cxt;
        const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
        const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
        cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/pattern.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var code_1 = require_code2();
    var util_1 = require_util();
    var codegen_1 = require_codegen();
    var error3 = {
      message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
      params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
    };
    var def = {
      keyword: "pattern",
      type: "string",
      schemaType: "string",
      $data: true,
      error: error3,
      code(cxt) {
        const { gen, data, $data, schema, schemaCode, it } = cxt;
        const u = it.opts.unicodeRegExp ? "u" : "";
        if ($data) {
          const { regExp } = it.opts.code;
          const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
          const valid = gen.let("valid");
          gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
          cxt.fail$data((0, codegen_1._)`!${valid}`);
        } else {
          const regExp = (0, code_1.usePattern)(cxt, schema);
          cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/limitProperties.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var error3 = {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxProperties" ? "more" : "fewer";
        return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
    };
    var def = {
      keyword: ["maxProperties", "minProperties"],
      type: "object",
      schemaType: "number",
      $data: true,
      error: error3,
      code(cxt) {
        const { keyword, data, schemaCode } = cxt;
        const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
        cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/required.js
var require_required = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/required.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var code_1 = require_code2();
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var error3 = {
      message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
      params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
    };
    var def = {
      keyword: "required",
      type: "object",
      schemaType: "array",
      $data: true,
      error: error3,
      code(cxt) {
        const { gen, schema, schemaCode, data, $data, it } = cxt;
        const { opts } = it;
        if (!$data && schema.length === 0)
          return;
        const useLoop = schema.length >= opts.loopRequired;
        if (it.allErrors)
          allErrorsMode();
        else
          exitOnErrorMode();
        if (opts.strictRequired) {
          const props = cxt.parentSchema.properties;
          const { definedProperties } = cxt.it;
          for (const requiredKey of schema) {
            if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
              const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
              const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
              (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
            }
          }
        }
        function allErrorsMode() {
          if (useLoop || $data) {
            cxt.block$data(codegen_1.nil, loopAllRequired);
          } else {
            for (const prop of schema) {
              (0, code_1.checkReportMissingProp)(cxt, prop);
            }
          }
        }
        function exitOnErrorMode() {
          const missing = gen.let("missing");
          if (useLoop || $data) {
            const valid = gen.let("valid", true);
            cxt.block$data(valid, () => loopUntilMissing(missing, valid));
            cxt.ok(valid);
          } else {
            gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
            (0, code_1.reportMissingProp)(cxt, missing);
            gen.else();
          }
        }
        function loopAllRequired() {
          gen.forOf("prop", schemaCode, (prop) => {
            cxt.setParams({ missingProperty: prop });
            gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
          });
        }
        function loopUntilMissing(missing, valid) {
          cxt.setParams({ missingProperty: missing });
          gen.forOf(missing, schemaCode, () => {
            gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
            gen.if((0, codegen_1.not)(valid), () => {
              cxt.error();
              gen.break();
            });
          }, codegen_1.nil);
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/limitItems.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var error3 = {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxItems" ? "more" : "fewer";
        return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
    };
    var def = {
      keyword: ["maxItems", "minItems"],
      type: "array",
      schemaType: "number",
      $data: true,
      error: error3,
      code(cxt) {
        const { keyword, data, schemaCode } = cxt;
        const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
        cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/runtime/equal.js
var require_equal = __commonJS({
  "node_modules/ajv/dist/runtime/equal.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var equal = require_fast_deep_equal();
    equal.code = 'require("ajv/dist/runtime/equal").default';
    exports.default = equal;
  }
});

// node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var dataType_1 = require_dataType();
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var equal_1 = require_equal();
    var error3 = {
      message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
      params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
    };
    var def = {
      keyword: "uniqueItems",
      type: "array",
      schemaType: "boolean",
      $data: true,
      error: error3,
      code(cxt) {
        const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
        if (!$data && !schema)
          return;
        const valid = gen.let("valid");
        const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
        cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
        cxt.ok(valid);
        function validateUniqueItems() {
          const i = gen.let("i", (0, codegen_1._)`${data}.length`);
          const j = gen.let("j");
          cxt.setParams({ i, j });
          gen.assign(valid, true);
          gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
        }
        function canOptimize() {
          return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
        }
        function loopN(i, j) {
          const item = gen.name("item");
          const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
          const indices = gen.const("indices", (0, codegen_1._)`{}`);
          gen.for((0, codegen_1._)`;${i}--;`, () => {
            gen.let(item, (0, codegen_1._)`${data}[${i}]`);
            gen.if(wrongType, (0, codegen_1._)`continue`);
            if (itemTypes.length > 1)
              gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
            gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
              gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
              cxt.error();
              gen.assign(valid, false).break();
            }).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
          });
        }
        function loopN2(i, j) {
          const eql = (0, util_1.useFunc)(gen, equal_1.default);
          const outer = gen.name("outer");
          gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
            cxt.error();
            gen.assign(valid, false).break(outer);
          })));
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/const.js
var require_const = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/const.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var equal_1 = require_equal();
    var error3 = {
      message: "must be equal to constant",
      params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
    };
    var def = {
      keyword: "const",
      $data: true,
      error: error3,
      code(cxt) {
        const { gen, data, $data, schemaCode, schema } = cxt;
        if ($data || schema && typeof schema == "object") {
          cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
        } else {
          cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/enum.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var equal_1 = require_equal();
    var error3 = {
      message: "must be equal to one of the allowed values",
      params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
    };
    var def = {
      keyword: "enum",
      schemaType: "array",
      $data: true,
      error: error3,
      code(cxt) {
        const { gen, data, $data, schema, schemaCode, it } = cxt;
        if (!$data && schema.length === 0)
          throw new Error("enum must have non-empty array");
        const useLoop = schema.length >= it.opts.loopEnum;
        let eql;
        const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
        let valid;
        if (useLoop || $data) {
          valid = gen.let("valid");
          cxt.block$data(valid, loopEnum);
        } else {
          if (!Array.isArray(schema))
            throw new Error("ajv implementation error");
          const vSchema = gen.const("vSchema", schemaCode);
          valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
        }
        cxt.pass(valid);
        function loopEnum() {
          gen.assign(valid, false);
          gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
        }
        function equalCode(vSchema, i) {
          const sch = schema[i];
          return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation = __commonJS({
  "node_modules/ajv/dist/vocabularies/validation/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var limitNumber_1 = require_limitNumber();
    var multipleOf_1 = require_multipleOf();
    var limitLength_1 = require_limitLength();
    var pattern_1 = require_pattern();
    var limitProperties_1 = require_limitProperties();
    var required_1 = require_required();
    var limitItems_1 = require_limitItems();
    var uniqueItems_1 = require_uniqueItems();
    var const_1 = require_const();
    var enum_1 = require_enum();
    var validation = [
      // number
      limitNumber_1.default,
      multipleOf_1.default,
      // string
      limitLength_1.default,
      pattern_1.default,
      // object
      limitProperties_1.default,
      required_1.default,
      // array
      limitItems_1.default,
      uniqueItems_1.default,
      // any
      { keyword: "type", schemaType: ["string", "array"] },
      { keyword: "nullable", schemaType: "boolean" },
      const_1.default,
      enum_1.default
    ];
    exports.default = validation;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/additionalItems.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.validateAdditionalItems = void 0;
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var error3 = {
      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
    };
    var def = {
      keyword: "additionalItems",
      type: "array",
      schemaType: ["boolean", "object"],
      before: "uniqueItems",
      error: error3,
      code(cxt) {
        const { parentSchema, it } = cxt;
        const { items } = parentSchema;
        if (!Array.isArray(items)) {
          (0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
          return;
        }
        validateAdditionalItems(cxt, items);
      }
    };
    function validateAdditionalItems(cxt, items) {
      const { gen, schema, data, keyword, it } = cxt;
      it.items = true;
      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
      if (schema === false) {
        cxt.setParams({ len: items.length });
        cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
      } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
        const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
        gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
        cxt.ok(valid);
      }
      function validateItems(valid) {
        gen.forRange("i", items.length, len, (i) => {
          cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
          if (!it.allErrors)
            gen.if((0, codegen_1.not)(valid), () => gen.break());
        });
      }
    }
    exports.validateAdditionalItems = validateAdditionalItems;
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/items.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.validateTuple = void 0;
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var code_1 = require_code2();
    var def = {
      keyword: "items",
      type: "array",
      schemaType: ["object", "array", "boolean"],
      before: "uniqueItems",
      code(cxt) {
        const { schema, it } = cxt;
        if (Array.isArray(schema))
          return validateTuple(cxt, "additionalItems", schema);
        it.items = true;
        if ((0, util_1.alwaysValidSchema)(it, schema))
          return;
        cxt.ok((0, code_1.validateArray)(cxt));
      }
    };
    function validateTuple(cxt, extraItems, schArr = cxt.schema) {
      const { gen, parentSchema, data, keyword, it } = cxt;
      checkStrictTuple(parentSchema);
      if (it.opts.unevaluated && schArr.length && it.items !== true) {
        it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
      }
      const valid = gen.name("valid");
      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
      schArr.forEach((sch, i) => {
        if ((0, util_1.alwaysValidSchema)(it, sch))
          return;
        gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
          keyword,
          schemaProp: i,
          dataProp: i
        }, valid));
        cxt.ok(valid);
      });
      function checkStrictTuple(sch) {
        const { opts, errSchemaPath } = it;
        const l = schArr.length;
        const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
        if (opts.strictTuples && !fullTuple) {
          const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
          (0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
        }
      }
    }
    exports.validateTuple = validateTuple;
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/prefixItems.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var items_1 = require_items();
    var def = {
      keyword: "prefixItems",
      type: "array",
      schemaType: ["array"],
      before: "uniqueItems",
      code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items2020 = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/items2020.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var code_1 = require_code2();
    var additionalItems_1 = require_additionalItems();
    var error3 = {
      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
    };
    var def = {
      keyword: "items",
      type: "array",
      schemaType: ["object", "boolean"],
      before: "uniqueItems",
      error: error3,
      code(cxt) {
        const { schema, parentSchema, it } = cxt;
        const { prefixItems } = parentSchema;
        it.items = true;
        if ((0, util_1.alwaysValidSchema)(it, schema))
          return;
        if (prefixItems)
          (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
        else
          cxt.ok((0, code_1.validateArray)(cxt));
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/contains.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var error3 = {
      message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
      params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
    };
    var def = {
      keyword: "contains",
      type: "array",
      schemaType: ["object", "boolean"],
      before: "uniqueItems",
      trackErrors: true,
      error: error3,
      code(cxt) {
        const { gen, schema, parentSchema, data, it } = cxt;
        let min;
        let max;
        const { minContains, maxContains } = parentSchema;
        if (it.opts.next) {
          min = minContains === void 0 ? 1 : minContains;
          max = maxContains;
        } else {
          min = 1;
        }
        const len = gen.const("len", (0, codegen_1._)`${data}.length`);
        cxt.setParams({ min, max });
        if (max === void 0 && min === 0) {
          (0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
          return;
        }
        if (max !== void 0 && min > max) {
          (0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
          cxt.fail();
          return;
        }
        if ((0, util_1.alwaysValidSchema)(it, schema)) {
          let cond = (0, codegen_1._)`${len} >= ${min}`;
          if (max !== void 0)
            cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
          cxt.pass(cond);
          return;
        }
        it.items = true;
        const valid = gen.name("valid");
        if (max === void 0 && min === 1) {
          validateItems(valid, () => gen.if(valid, () => gen.break()));
        } else if (min === 0) {
          gen.let(valid, true);
          if (max !== void 0)
            gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
        } else {
          gen.let(valid, false);
          validateItemsWithCount();
        }
        cxt.result(valid, () => cxt.reset());
        function validateItemsWithCount() {
          const schValid = gen.name("_valid");
          const count = gen.let("count", 0);
          validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
        }
        function validateItems(_valid, block) {
          gen.forRange("i", 0, len, (i) => {
            cxt.subschema({
              keyword: "contains",
              dataProp: i,
              dataPropType: util_1.Type.Num,
              compositeRule: true
            }, _valid);
            block();
          });
        }
        function checkLimits(count) {
          gen.code((0, codegen_1._)`${count}++`);
          if (max === void 0) {
            gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
          } else {
            gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
            if (min === 1)
              gen.assign(valid, true);
            else
              gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
          }
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/dependencies.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var code_1 = require_code2();
    exports.error = {
      message: ({ params: { property, depsCount, deps } }) => {
        const property_ies = depsCount === 1 ? "property" : "properties";
        return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
      },
      params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
    missingProperty: ${missingProperty},
    depsCount: ${depsCount},
    deps: ${deps}}`
      // TODO change to reference
    };
    var def = {
      keyword: "dependencies",
      type: "object",
      schemaType: "object",
      error: exports.error,
      code(cxt) {
        const [propDeps, schDeps] = splitDependencies(cxt);
        validatePropertyDeps(cxt, propDeps);
        validateSchemaDeps(cxt, schDeps);
      }
    };
    function splitDependencies({ schema }) {
      const propertyDeps = {};
      const schemaDeps = {};
      for (const key in schema) {
        if (key === "__proto__")
          continue;
        const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
        deps[key] = schema[key];
      }
      return [propertyDeps, schemaDeps];
    }
    function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
      const { gen, data, it } = cxt;
      if (Object.keys(propertyDeps).length === 0)
        return;
      const missing = gen.let("missing");
      for (const prop in propertyDeps) {
        const deps = propertyDeps[prop];
        if (deps.length === 0)
          continue;
        const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
        cxt.setParams({
          property: prop,
          depsCount: deps.length,
          deps: deps.join(", ")
        });
        if (it.allErrors) {
          gen.if(hasProperty, () => {
            for (const depProp of deps) {
              (0, code_1.checkReportMissingProp)(cxt, depProp);
            }
          });
        } else {
          gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
          (0, code_1.reportMissingProp)(cxt, missing);
          gen.else();
        }
      }
    }
    exports.validatePropertyDeps = validatePropertyDeps;
    function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
      const { gen, data, keyword, it } = cxt;
      const valid = gen.name("valid");
      for (const prop in schemaDeps) {
        if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop]))
          continue;
        gen.if(
          (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties),
          () => {
            const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid);
            cxt.mergeValidEvaluated(schCxt, valid);
          },
          () => gen.var(valid, true)
          // TODO var
        );
        cxt.ok(valid);
      }
    }
    exports.validateSchemaDeps = validateSchemaDeps;
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/propertyNames.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var error3 = {
      message: "property name must be valid",
      params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
    };
    var def = {
      keyword: "propertyNames",
      type: "object",
      schemaType: ["object", "boolean"],
      error: error3,
      code(cxt) {
        const { gen, schema, data, it } = cxt;
        if ((0, util_1.alwaysValidSchema)(it, schema))
          return;
        const valid = gen.name("valid");
        gen.forIn("key", data, (key) => {
          cxt.setParams({ propertyName: key });
          cxt.subschema({
            keyword: "propertyNames",
            data: key,
            dataTypes: ["string"],
            propertyName: key,
            compositeRule: true
          }, valid);
          gen.if((0, codegen_1.not)(valid), () => {
            cxt.error(true);
            if (!it.allErrors)
              gen.break();
          });
        });
        cxt.ok(valid);
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var code_1 = require_code2();
    var codegen_1 = require_codegen();
    var names_1 = require_names();
    var util_1 = require_util();
    var error3 = {
      message: "must NOT have additional properties",
      params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
    };
    var def = {
      keyword: "additionalProperties",
      type: ["object"],
      schemaType: ["boolean", "object"],
      allowUndefined: true,
      trackErrors: true,
      error: error3,
      code(cxt) {
        const { gen, schema, parentSchema, data, errsCount, it } = cxt;
        if (!errsCount)
          throw new Error("ajv implementation error");
        const { allErrors, opts } = it;
        it.props = true;
        if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
          return;
        const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
        const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
        checkAdditionalProperties();
        cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
        function checkAdditionalProperties() {
          gen.forIn("key", data, (key) => {
            if (!props.length && !patProps.length)
              additionalPropertyCode(key);
            else
              gen.if(isAdditional(key), () => additionalPropertyCode(key));
          });
        }
        function isAdditional(key) {
          let definedProp;
          if (props.length > 8) {
            const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
            definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
          } else if (props.length) {
            definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
          } else {
            definedProp = codegen_1.nil;
          }
          if (patProps.length) {
            definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
          }
          return (0, codegen_1.not)(definedProp);
        }
        function deleteAdditional(key) {
          gen.code((0, codegen_1._)`delete ${data}[${key}]`);
        }
        function additionalPropertyCode(key) {
          if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
            deleteAdditional(key);
            return;
          }
          if (schema === false) {
            cxt.setParams({ additionalProperty: key });
            cxt.error();
            if (!allErrors)
              gen.break();
            return;
          }
          if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
            const valid = gen.name("valid");
            if (opts.removeAdditional === "failing") {
              applyAdditionalSchema(key, valid, false);
              gen.if((0, codegen_1.not)(valid), () => {
                cxt.reset();
                deleteAdditional(key);
              });
            } else {
              applyAdditionalSchema(key, valid);
              if (!allErrors)
                gen.if((0, codegen_1.not)(valid), () => gen.break());
            }
          }
        }
        function applyAdditionalSchema(key, valid, errors) {
          const subschema = {
            keyword: "additionalProperties",
            dataProp: key,
            dataPropType: util_1.Type.Str
          };
          if (errors === false) {
            Object.assign(subschema, {
              compositeRule: true,
              createErrors: false,
              allErrors: false
            });
          }
          cxt.subschema(subschema, valid);
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/properties.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var validate_1 = require_validate();
    var code_1 = require_code2();
    var util_1 = require_util();
    var additionalProperties_1 = require_additionalProperties();
    var def = {
      keyword: "properties",
      type: "object",
      schemaType: "object",
      code(cxt) {
        const { gen, schema, parentSchema, data, it } = cxt;
        if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) {
          additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
        }
        const allProps = (0, code_1.allSchemaProperties)(schema);
        for (const prop of allProps) {
          it.definedProperties.add(prop);
        }
        if (it.opts.unevaluated && allProps.length && it.props !== true) {
          it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
        }
        const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
        if (properties.length === 0)
          return;
        const valid = gen.name("valid");
        for (const prop of properties) {
          if (hasDefault(prop)) {
            applyPropertySchema(prop);
          } else {
            gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
            applyPropertySchema(prop);
            if (!it.allErrors)
              gen.else().var(valid, true);
            gen.endIf();
          }
          cxt.it.definedProperties.add(prop);
          cxt.ok(valid);
        }
        function hasDefault(prop) {
          return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0;
        }
        function applyPropertySchema(prop) {
          cxt.subschema({
            keyword: "properties",
            schemaProp: prop,
            dataProp: prop
          }, valid);
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/patternProperties.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var code_1 = require_code2();
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var util_2 = require_util();
    var def = {
      keyword: "patternProperties",
      type: "object",
      schemaType: "object",
      code(cxt) {
        const { gen, schema, data, parentSchema, it } = cxt;
        const { opts } = it;
        const patterns = (0, code_1.allSchemaProperties)(schema);
        const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
        if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
          return;
        }
        const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
        const valid = gen.name("valid");
        if (it.props !== true && !(it.props instanceof codegen_1.Name)) {
          it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
        }
        const { props } = it;
        validatePatternProperties();
        function validatePatternProperties() {
          for (const pat of patterns) {
            if (checkProperties)
              checkMatchingProperties(pat);
            if (it.allErrors) {
              validateProperties(pat);
            } else {
              gen.var(valid, true);
              validateProperties(pat);
              gen.if(valid);
            }
          }
        }
        function checkMatchingProperties(pat) {
          for (const prop in checkProperties) {
            if (new RegExp(pat).test(prop)) {
              (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
            }
          }
        }
        function validateProperties(pat) {
          gen.forIn("key", data, (key) => {
            gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
              const alwaysValid = alwaysValidPatterns.includes(pat);
              if (!alwaysValid) {
                cxt.subschema({
                  keyword: "patternProperties",
                  schemaProp: pat,
                  dataProp: key,
                  dataPropType: util_2.Type.Str
                }, valid);
              }
              if (it.opts.unevaluated && props !== true) {
                gen.assign((0, codegen_1._)`${props}[${key}]`, true);
              } else if (!alwaysValid && !it.allErrors) {
                gen.if((0, codegen_1.not)(valid), () => gen.break());
              }
            });
          });
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/not.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var util_1 = require_util();
    var def = {
      keyword: "not",
      schemaType: ["object", "boolean"],
      trackErrors: true,
      code(cxt) {
        const { gen, schema, it } = cxt;
        if ((0, util_1.alwaysValidSchema)(it, schema)) {
          cxt.fail();
          return;
        }
        const valid = gen.name("valid");
        cxt.subschema({
          keyword: "not",
          compositeRule: true,
          createErrors: false,
          allErrors: false
        }, valid);
        cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
      },
      error: { message: "must NOT be valid" }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/anyOf.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var code_1 = require_code2();
    var def = {
      keyword: "anyOf",
      schemaType: "array",
      trackErrors: true,
      code: code_1.validateUnion,
      error: { message: "must match a schema in anyOf" }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/oneOf.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var error3 = {
      message: "must match exactly one schema in oneOf",
      params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
    };
    var def = {
      keyword: "oneOf",
      schemaType: "array",
      trackErrors: true,
      error: error3,
      code(cxt) {
        const { gen, schema, parentSchema, it } = cxt;
        if (!Array.isArray(schema))
          throw new Error("ajv implementation error");
        if (it.opts.discriminator && parentSchema.discriminator)
          return;
        const schArr = schema;
        const valid = gen.let("valid", false);
        const passing = gen.let("passing", null);
        const schValid = gen.name("_valid");
        cxt.setParams({ passing });
        gen.block(validateOneOf);
        cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
        function validateOneOf() {
          schArr.forEach((sch, i) => {
            let schCxt;
            if ((0, util_1.alwaysValidSchema)(it, sch)) {
              gen.var(schValid, true);
            } else {
              schCxt = cxt.subschema({
                keyword: "oneOf",
                schemaProp: i,
                compositeRule: true
              }, schValid);
            }
            if (i > 0) {
              gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
            }
            gen.if(schValid, () => {
              gen.assign(valid, true);
              gen.assign(passing, i);
              if (schCxt)
                cxt.mergeEvaluated(schCxt, codegen_1.Name);
            });
          });
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/allOf.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var util_1 = require_util();
    var def = {
      keyword: "allOf",
      schemaType: "array",
      code(cxt) {
        const { gen, schema, it } = cxt;
        if (!Array.isArray(schema))
          throw new Error("ajv implementation error");
        const valid = gen.name("valid");
        schema.forEach((sch, i) => {
          if ((0, util_1.alwaysValidSchema)(it, sch))
            return;
          const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
          cxt.ok(valid);
          cxt.mergeEvaluated(schCxt);
        });
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/if.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var util_1 = require_util();
    var error3 = {
      message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
      params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
    };
    var def = {
      keyword: "if",
      schemaType: ["object", "boolean"],
      trackErrors: true,
      error: error3,
      code(cxt) {
        const { gen, parentSchema, it } = cxt;
        if (parentSchema.then === void 0 && parentSchema.else === void 0) {
          (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
        }
        const hasThen = hasSchema(it, "then");
        const hasElse = hasSchema(it, "else");
        if (!hasThen && !hasElse)
          return;
        const valid = gen.let("valid", true);
        const schValid = gen.name("_valid");
        validateIf();
        cxt.reset();
        if (hasThen && hasElse) {
          const ifClause = gen.let("ifClause");
          cxt.setParams({ ifClause });
          gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
        } else if (hasThen) {
          gen.if(schValid, validateClause("then"));
        } else {
          gen.if((0, codegen_1.not)(schValid), validateClause("else"));
        }
        cxt.pass(valid, () => cxt.error(true));
        function validateIf() {
          const schCxt = cxt.subschema({
            keyword: "if",
            compositeRule: true,
            createErrors: false,
            allErrors: false
          }, schValid);
          cxt.mergeEvaluated(schCxt);
        }
        function validateClause(keyword, ifClause) {
          return () => {
            const schCxt = cxt.subschema({ keyword }, schValid);
            gen.assign(valid, schValid);
            cxt.mergeValidEvaluated(schCxt, valid);
            if (ifClause)
              gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
            else
              cxt.setParams({ ifClause: keyword });
          };
        }
      }
    };
    function hasSchema(it, keyword) {
      const schema = it.schema[keyword];
      return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
    }
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/thenElse.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var util_1 = require_util();
    var def = {
      keyword: ["then", "else"],
      schemaType: ["object", "boolean"],
      code({ keyword, parentSchema, it }) {
        if (parentSchema.if === void 0)
          (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator = __commonJS({
  "node_modules/ajv/dist/vocabularies/applicator/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var additionalItems_1 = require_additionalItems();
    var prefixItems_1 = require_prefixItems();
    var items_1 = require_items();
    var items2020_1 = require_items2020();
    var contains_1 = require_contains();
    var dependencies_1 = require_dependencies();
    var propertyNames_1 = require_propertyNames();
    var additionalProperties_1 = require_additionalProperties();
    var properties_1 = require_properties();
    var patternProperties_1 = require_patternProperties();
    var not_1 = require_not();
    var anyOf_1 = require_anyOf();
    var oneOf_1 = require_oneOf();
    var allOf_1 = require_allOf();
    var if_1 = require_if();
    var thenElse_1 = require_thenElse();
    function getApplicator(draft2020 = false) {
      const applicator = [
        // any
        not_1.default,
        anyOf_1.default,
        oneOf_1.default,
        allOf_1.default,
        if_1.default,
        thenElse_1.default,
        // object
        propertyNames_1.default,
        additionalProperties_1.default,
        dependencies_1.default,
        properties_1.default,
        patternProperties_1.default
      ];
      if (draft2020)
        applicator.push(prefixItems_1.default, items2020_1.default);
      else
        applicator.push(additionalItems_1.default, items_1.default);
      applicator.push(contains_1.default);
      return applicator;
    }
    exports.default = getApplicator;
  }
});

// node_modules/ajv/dist/vocabularies/format/format.js
var require_format = __commonJS({
  "node_modules/ajv/dist/vocabularies/format/format.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var error3 = {
      message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
      params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
    };
    var def = {
      keyword: "format",
      type: ["number", "string"],
      schemaType: "string",
      $data: true,
      error: error3,
      code(cxt, ruleType) {
        const { gen, data, $data, schema, schemaCode, it } = cxt;
        const { opts, errSchemaPath, schemaEnv, self } = it;
        if (!opts.validateFormats)
          return;
        if ($data)
          validate$DataFormat();
        else
          validateFormat();
        function validate$DataFormat() {
          const fmts = gen.scopeValue("formats", {
            ref: self.formats,
            code: opts.code.formats
          });
          const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
          const fType = gen.let("fType");
          const format = gen.let("format");
          gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef));
          cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
          function unknownFmt() {
            if (opts.strictSchema === false)
              return codegen_1.nil;
            return (0, codegen_1._)`${schemaCode} && !${format}`;
          }
          function invalidFmt() {
            const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
            const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
            return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
          }
        }
        function validateFormat() {
          const formatDef = self.formats[schema];
          if (!formatDef) {
            unknownFormat();
            return;
          }
          if (formatDef === true)
            return;
          const [fmtType, format, fmtRef] = getFormat(formatDef);
          if (fmtType === ruleType)
            cxt.pass(validCondition());
          function unknownFormat() {
            if (opts.strictSchema === false) {
              self.logger.warn(unknownMsg());
              return;
            }
            throw new Error(unknownMsg());
            function unknownMsg() {
              return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
            }
          }
          function getFormat(fmtDef) {
            const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0;
            const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code });
            if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
              return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
            }
            return ["string", fmtDef, fmt];
          }
          function validCondition() {
            if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
              if (!schemaEnv.$async)
                throw new Error("async format in sync schema");
              return (0, codegen_1._)`await ${fmtRef}(${data})`;
            }
            return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
          }
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/vocabularies/format/index.js
var require_format2 = __commonJS({
  "node_modules/ajv/dist/vocabularies/format/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var format_1 = require_format();
    var format = [format_1.default];
    exports.default = format;
  }
});

// node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata = __commonJS({
  "node_modules/ajv/dist/vocabularies/metadata.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.contentVocabulary = exports.metadataVocabulary = void 0;
    exports.metadataVocabulary = [
      "title",
      "description",
      "default",
      "deprecated",
      "readOnly",
      "writeOnly",
      "examples"
    ];
    exports.contentVocabulary = [
      "contentMediaType",
      "contentEncoding",
      "contentSchema"
    ];
  }
});

// node_modules/ajv/dist/vocabularies/draft7.js
var require_draft7 = __commonJS({
  "node_modules/ajv/dist/vocabularies/draft7.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var core_1 = require_core2();
    var validation_1 = require_validation();
    var applicator_1 = require_applicator();
    var format_1 = require_format2();
    var metadata_1 = require_metadata();
    var draft7Vocabularies = [
      core_1.default,
      validation_1.default,
      (0, applicator_1.default)(),
      format_1.default,
      metadata_1.metadataVocabulary,
      metadata_1.contentVocabulary
    ];
    exports.default = draft7Vocabularies;
  }
});

// node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types = __commonJS({
  "node_modules/ajv/dist/vocabularies/discriminator/types.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DiscrError = void 0;
    var DiscrError;
    (function(DiscrError2) {
      DiscrError2["Tag"] = "tag";
      DiscrError2["Mapping"] = "mapping";
    })(DiscrError || (exports.DiscrError = DiscrError = {}));
  }
});

// node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator = __commonJS({
  "node_modules/ajv/dist/vocabularies/discriminator/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var codegen_1 = require_codegen();
    var types_1 = require_types();
    var compile_1 = require_compile();
    var ref_error_1 = require_ref_error();
    var util_1 = require_util();
    var error3 = {
      message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
      params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
    };
    var def = {
      keyword: "discriminator",
      type: "object",
      schemaType: "object",
      error: error3,
      code(cxt) {
        const { gen, data, schema, parentSchema, it } = cxt;
        const { oneOf } = parentSchema;
        if (!it.opts.discriminator) {
          throw new Error("discriminator: requires discriminator option");
        }
        const tagName = schema.propertyName;
        if (typeof tagName != "string")
          throw new Error("discriminator: requires propertyName");
        if (schema.mapping)
          throw new Error("discriminator: mapping is not supported");
        if (!oneOf)
          throw new Error("discriminator: requires oneOf keyword");
        const valid = gen.let("valid", false);
        const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
        gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName }));
        cxt.ok(valid);
        function validateMapping() {
          const mapping = getMapping();
          gen.if(false);
          for (const tagValue in mapping) {
            gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
            gen.assign(valid, applyTagSchema(mapping[tagValue]));
          }
          gen.else();
          cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName });
          gen.endIf();
        }
        function applyTagSchema(schemaProp) {
          const _valid = gen.name("valid");
          const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid);
          cxt.mergeEvaluated(schCxt, codegen_1.Name);
          return _valid;
        }
        function getMapping() {
          var _a;
          const oneOfMapping = {};
          const topRequired = hasRequired(parentSchema);
          let tagRequired = true;
          for (let i = 0; i < oneOf.length; i++) {
            let sch = oneOf[i];
            if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
              const ref = sch.$ref;
              sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
              if (sch instanceof compile_1.SchemaEnv)
                sch = sch.schema;
              if (sch === void 0)
                throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
            }
            const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _a[tagName];
            if (typeof propSch != "object") {
              throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
            }
            tagRequired = tagRequired && (topRequired || hasRequired(sch));
            addMappings(propSch, i);
          }
          if (!tagRequired)
            throw new Error(`discriminator: "${tagName}" must be required`);
          return oneOfMapping;
          function hasRequired({ required: required2 }) {
            return Array.isArray(required2) && required2.includes(tagName);
          }
          function addMappings(sch, i) {
            if (sch.const) {
              addMapping(sch.const, i);
            } else if (sch.enum) {
              for (const tagValue of sch.enum) {
                addMapping(tagValue, i);
              }
            } else {
              throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
            }
          }
          function addMapping(tagValue, i) {
            if (typeof tagValue != "string" || tagValue in oneOfMapping) {
              throw new Error(`discriminator: "${tagName}" values must be unique strings`);
            }
            oneOfMapping[tagValue] = i;
          }
        }
      }
    };
    exports.default = def;
  }
});

// node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = __commonJS({
  "node_modules/ajv/dist/refs/json-schema-draft-07.json"(exports, module) {
    module.exports = {
      $schema: "http://json-schema.org/draft-07/schema#",
      $id: "http://json-schema.org/draft-07/schema#",
      title: "Core schema meta-schema",
      definitions: {
        schemaArray: {
          type: "array",
          minItems: 1,
          items: { $ref: "#" }
        },
        nonNegativeInteger: {
          type: "integer",
          minimum: 0
        },
        nonNegativeIntegerDefault0: {
          allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }]
        },
        simpleTypes: {
          enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
        },
        stringArray: {
          type: "array",
          items: { type: "string" },
          uniqueItems: true,
          default: []
        }
      },
      type: ["object", "boolean"],
      properties: {
        $id: {
          type: "string",
          format: "uri-reference"
        },
        $schema: {
          type: "string",
          format: "uri"
        },
        $ref: {
          type: "string",
          format: "uri-reference"
        },
        $comment: {
          type: "string"
        },
        title: {
          type: "string"
        },
        description: {
          type: "string"
        },
        default: true,
        readOnly: {
          type: "boolean",
          default: false
        },
        examples: {
          type: "array",
          items: true
        },
        multipleOf: {
          type: "number",
          exclusiveMinimum: 0
        },
        maximum: {
          type: "number"
        },
        exclusiveMaximum: {
          type: "number"
        },
        minimum: {
          type: "number"
        },
        exclusiveMinimum: {
          type: "number"
        },
        maxLength: { $ref: "#/definitions/nonNegativeInteger" },
        minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
        pattern: {
          type: "string",
          format: "regex"
        },
        additionalItems: { $ref: "#" },
        items: {
          anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
          default: true
        },
        maxItems: { $ref: "#/definitions/nonNegativeInteger" },
        minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
        uniqueItems: {
          type: "boolean",
          default: false
        },
        contains: { $ref: "#" },
        maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
        minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
        required: { $ref: "#/definitions/stringArray" },
        additionalProperties: { $ref: "#" },
        definitions: {
          type: "object",
          additionalProperties: { $ref: "#" },
          default: {}
        },
        properties: {
          type: "object",
          additionalProperties: { $ref: "#" },
          default: {}
        },
        patternProperties: {
          type: "object",
          additionalProperties: { $ref: "#" },
          propertyNames: { format: "regex" },
          default: {}
        },
        dependencies: {
          type: "object",
          additionalProperties: {
            anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
          }
        },
        propertyNames: { $ref: "#" },
        const: true,
        enum: {
          type: "array",
          items: true,
          minItems: 1,
          uniqueItems: true
        },
        type: {
          anyOf: [
            { $ref: "#/definitions/simpleTypes" },
            {
              type: "array",
              items: { $ref: "#/definitions/simpleTypes" },
              minItems: 1,
              uniqueItems: true
            }
          ]
        },
        format: { type: "string" },
        contentMediaType: { type: "string" },
        contentEncoding: { type: "string" },
        if: { $ref: "#" },
        then: { $ref: "#" },
        else: { $ref: "#" },
        allOf: { $ref: "#/definitions/schemaArray" },
        anyOf: { $ref: "#/definitions/schemaArray" },
        oneOf: { $ref: "#/definitions/schemaArray" },
        not: { $ref: "#" }
      },
      default: true
    };
  }
});

// node_modules/ajv/dist/ajv.js
var require_ajv = __commonJS({
  "node_modules/ajv/dist/ajv.js"(exports, module) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
    var core_1 = require_core();
    var draft7_1 = require_draft7();
    var discriminator_1 = require_discriminator();
    var draft7MetaSchema = require_json_schema_draft_07();
    var META_SUPPORT_DATA = ["/properties"];
    var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
    var Ajv2 = class extends core_1.default {
      _addVocabularies() {
        super._addVocabularies();
        draft7_1.default.forEach((v) => this.addVocabulary(v));
        if (this.opts.discriminator)
          this.addKeyword(discriminator_1.default);
      }
      _addDefaultMetaSchema() {
        super._addDefaultMetaSchema();
        if (!this.opts.meta)
          return;
        const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
        this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
      }
      defaultMeta() {
        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
      }
    };
    exports.Ajv = Ajv2;
    module.exports = exports = Ajv2;
    module.exports.Ajv = Ajv2;
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = Ajv2;
    var validate_1 = require_validate();
    Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
      return validate_1.KeywordCxt;
    } });
    var codegen_1 = require_codegen();
    Object.defineProperty(exports, "_", { enumerable: true, get: function() {
      return codegen_1._;
    } });
    Object.defineProperty(exports, "str", { enumerable: true, get: function() {
      return codegen_1.str;
    } });
    Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
      return codegen_1.stringify;
    } });
    Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
      return codegen_1.nil;
    } });
    Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
      return codegen_1.Name;
    } });
    Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
      return codegen_1.CodeGen;
    } });
    var validation_error_1 = require_validation_error();
    Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
      return validation_error_1.default;
    } });
    var ref_error_1 = require_ref_error();
    Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
      return ref_error_1.default;
    } });
  }
});

// node_modules/ajv-formats/dist/formats.js
var require_formats = __commonJS({
  "node_modules/ajv-formats/dist/formats.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
    function fmtDef(validate, compare) {
      return { validate, compare };
    }
    exports.fullFormats = {
      // date: http://tools.ietf.org/html/rfc3339#section-5.6
      date: fmtDef(date3, compareDate),
      // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
      time: fmtDef(getTime(true), compareTime),
      "date-time": fmtDef(getDateTime(true), compareDateTime),
      "iso-time": fmtDef(getTime(), compareIsoTime),
      "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
      // duration: https://tools.ietf.org/html/rfc3339#appendix-A
      duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
      uri,
      "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
      // uri-template: https://tools.ietf.org/html/rfc6570
      "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
      // For the source: https://gist.github.com/dperini/729294
      // For test cases: https://mathiasbynens.be/demo/url-regex
      url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
      email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
      hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
      // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
      ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
      ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
      regex,
      // uuid: http://tools.ietf.org/html/rfc4122
      uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
      // JSON-pointer: https://tools.ietf.org/html/rfc6901
      // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
      "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
      "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
      // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
      "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
      // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types
      // byte: https://github.com/miguelmota/is-base64
      byte,
      // signed 32 bit integer
      int32: { type: "number", validate: validateInt32 },
      // signed 64 bit integer
      int64: { type: "number", validate: validateInt64 },
      // C-type float
      float: { type: "number", validate: validateNumber },
      // C-type double
      double: { type: "number", validate: validateNumber },
      // hint to the UI to hide input strings
      password: true,
      // unchecked string payload
      binary: true
    };
    exports.fastFormats = {
      ...exports.fullFormats,
      date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
      time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
      "date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
      "iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
      "iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
      // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
      uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
      "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
      // email (sources from jsen validator):
      // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
      // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation')
      email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
    };
    exports.formatNames = Object.keys(exports.fullFormats);
    function isLeapYear(year) {
      return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
    }
    var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
    var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    function date3(str) {
      const matches = DATE.exec(str);
      if (!matches)
        return false;
      const year = +matches[1];
      const month = +matches[2];
      const day = +matches[3];
      return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
    }
    function compareDate(d1, d2) {
      if (!(d1 && d2))
        return void 0;
      if (d1 > d2)
        return 1;
      if (d1 < d2)
        return -1;
      return 0;
    }
    var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
    function getTime(strictTimeZone) {
      return function time3(str) {
        const matches = TIME.exec(str);
        if (!matches)
          return false;
        const hr = +matches[1];
        const min = +matches[2];
        const sec = +matches[3];
        const tz = matches[4];
        const tzSign = matches[5] === "-" ? -1 : 1;
        const tzH = +(matches[6] || 0);
        const tzM = +(matches[7] || 0);
        if (tzH > 23 || tzM > 59 || strictTimeZone && !tz)
          return false;
        if (hr <= 23 && min <= 59 && sec < 60)
          return true;
        const utcMin = min - tzM * tzSign;
        const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
        return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
      };
    }
    function compareTime(s1, s2) {
      if (!(s1 && s2))
        return void 0;
      const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf();
      const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf();
      if (!(t1 && t2))
        return void 0;
      return t1 - t2;
    }
    function compareIsoTime(t1, t2) {
      if (!(t1 && t2))
        return void 0;
      const a1 = TIME.exec(t1);
      const a2 = TIME.exec(t2);
      if (!(a1 && a2))
        return void 0;
      t1 = a1[1] + a1[2] + a1[3];
      t2 = a2[1] + a2[2] + a2[3];
      if (t1 > t2)
        return 1;
      if (t1 < t2)
        return -1;
      return 0;
    }
    var DATE_TIME_SEPARATOR = /t|\s/i;
    function getDateTime(strictTimeZone) {
      const time3 = getTime(strictTimeZone);
      return function date_time(str) {
        const dateTime = str.split(DATE_TIME_SEPARATOR);
        return dateTime.length === 2 && date3(dateTime[0]) && time3(dateTime[1]);
      };
    }
    function compareDateTime(dt1, dt2) {
      if (!(dt1 && dt2))
        return void 0;
      const d1 = new Date(dt1).valueOf();
      const d2 = new Date(dt2).valueOf();
      if (!(d1 && d2))
        return void 0;
      return d1 - d2;
    }
    function compareIsoDateTime(dt1, dt2) {
      if (!(dt1 && dt2))
        return void 0;
      const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
      const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
      const res = compareDate(d1, d2);
      if (res === void 0)
        return void 0;
      return res || compareTime(t1, t2);
    }
    var NOT_URI_FRAGMENT = /\/|:/;
    var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
    function uri(str) {
      return NOT_URI_FRAGMENT.test(str) && URI.test(str);
    }
    var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
    function byte(str) {
      BYTE.lastIndex = 0;
      return BYTE.test(str);
    }
    var MIN_INT32 = -(2 ** 31);
    var MAX_INT32 = 2 ** 31 - 1;
    function validateInt32(value) {
      return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
    }
    function validateInt64(value) {
      return Number.isInteger(value);
    }
    function validateNumber() {
      return true;
    }
    var Z_ANCHOR = /[^\\]\\Z/;
    function regex(str) {
      if (Z_ANCHOR.test(str))
        return false;
      try {
        new RegExp(str);
        return true;
      } catch (e) {
        return false;
      }
    }
  }
});

// node_modules/ajv-formats/dist/limit.js
var require_limit = __commonJS({
  "node_modules/ajv-formats/dist/limit.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.formatLimitDefinition = void 0;
    var ajv_1 = require_ajv();
    var codegen_1 = require_codegen();
    var ops = codegen_1.operators;
    var KWDs = {
      formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
      formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
      formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
      formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
    };
    var error3 = {
      message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
      params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
    };
    exports.formatLimitDefinition = {
      keyword: Object.keys(KWDs),
      type: "string",
      schemaType: "string",
      $data: true,
      error: error3,
      code(cxt) {
        const { gen, data, schemaCode, keyword, it } = cxt;
        const { opts, self } = it;
        if (!opts.validateFormats)
          return;
        const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
        if (fCxt.$data)
          validate$DataFormat();
        else
          validateFormat();
        function validate$DataFormat() {
          const fmts = gen.scopeValue("formats", {
            ref: self.formats,
            code: opts.code.formats
          });
          const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
          cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
        }
        function validateFormat() {
          const format = fCxt.schema;
          const fmtDef = self.formats[format];
          if (!fmtDef || fmtDef === true)
            return;
          if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
            throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
          }
          const fmt = gen.scopeValue("formats", {
            key: format,
            ref: fmtDef,
            code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0
          });
          cxt.fail$data(compareCode(fmt));
        }
        function compareCode(fmt) {
          return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
        }
      },
      dependencies: ["format"]
    };
    var formatLimitPlugin = (ajv) => {
      ajv.addKeyword(exports.formatLimitDefinition);
      return ajv;
    };
    exports.default = formatLimitPlugin;
  }
});

// node_modules/ajv-formats/dist/index.js
var require_dist = __commonJS({
  "node_modules/ajv-formats/dist/index.js"(exports, module) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var formats_1 = require_formats();
    var limit_1 = require_limit();
    var codegen_1 = require_codegen();
    var fullName = new codegen_1.Name("fullFormats");
    var fastName = new codegen_1.Name("fastFormats");
    var formatsPlugin = (ajv, opts = { keywords: true }) => {
      if (Array.isArray(opts)) {
        addFormats(ajv, opts, formats_1.fullFormats, fullName);
        return ajv;
      }
      const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
      const list = opts.formats || formats_1.formatNames;
      addFormats(ajv, list, formats, exportName);
      if (opts.keywords)
        (0, limit_1.default)(ajv);
      return ajv;
    };
    formatsPlugin.get = (name, mode = "full") => {
      const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats;
      const f = formats[name];
      if (!f)
        throw new Error(`Unknown format "${name}"`);
      return f;
    };
    function addFormats(ajv, list, fs, exportName) {
      var _a;
      var _b;
      (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
      for (const f of list)
        ajv.addFormat(f, fs[f]);
    }
    module.exports = exports = formatsPlugin;
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.default = formatsPlugin;
  }
});

// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
import process2 from "node:process";

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/core.js
var NEVER = Object.freeze({
  status: "aborted"
});
// @__NO_SIDE_EFFECTS__
function $constructor(name, initializer3, params) {
  function init(inst, def) {
    var _a;
    Object.defineProperty(inst, "_zod", {
      value: inst._zod ?? {},
      enumerable: false
    });
    (_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
    inst._zod.traits.add(name);
    initializer3(inst, def);
    for (const k in _.prototype) {
      if (!(k in inst))
        Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
    }
    inst._zod.constr = _;
    inst._zod.def = def;
  }
  const Parent = params?.Parent ?? Object;
  class Definition extends Parent {
  }
  Object.defineProperty(Definition, "name", { value: name });
  function _(def) {
    var _a;
    const inst = params?.Parent ? new Definition() : this;
    init(inst, def);
    (_a = inst._zod).deferred ?? (_a.deferred = []);
    for (const fn of inst._zod.deferred) {
      fn();
    }
    return inst;
  }
  Object.defineProperty(_, "init", { value: init });
  Object.defineProperty(_, Symbol.hasInstance, {
    value: (inst) => {
      if (params?.Parent && inst instanceof params.Parent)
        return true;
      return inst?._zod?.traits?.has(name);
    }
  });
  Object.defineProperty(_, "name", { value: name });
  return _;
}
var $brand = Symbol("zod_brand");
var $ZodAsyncError = class extends Error {
  constructor() {
    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
  }
};
var globalConfig = {};
function config(newConfig) {
  if (newConfig)
    Object.assign(globalConfig, newConfig);
  return globalConfig;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/util.js
var util_exports = {};
__export(util_exports, {
  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
  Class: () => Class,
  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
  aborted: () => aborted,
  allowsEval: () => allowsEval,
  assert: () => assert,
  assertEqual: () => assertEqual,
  assertIs: () => assertIs,
  assertNever: () => assertNever,
  assertNotEqual: () => assertNotEqual,
  assignProp: () => assignProp,
  cached: () => cached,
  captureStackTrace: () => captureStackTrace,
  cleanEnum: () => cleanEnum,
  cleanRegex: () => cleanRegex,
  clone: () => clone,
  createTransparentProxy: () => createTransparentProxy,
  defineLazy: () => defineLazy,
  esc: () => esc,
  escapeRegex: () => escapeRegex,
  extend: () => extend,
  finalizeIssue: () => finalizeIssue,
  floatSafeRemainder: () => floatSafeRemainder,
  getElementAtPath: () => getElementAtPath,
  getEnumValues: () => getEnumValues,
  getLengthableOrigin: () => getLengthableOrigin,
  getParsedType: () => getParsedType,
  getSizableOrigin: () => getSizableOrigin,
  isObject: () => isObject,
  isPlainObject: () => isPlainObject,
  issue: () => issue,
  joinValues: () => joinValues,
  jsonStringifyReplacer: () => jsonStringifyReplacer,
  merge: () => merge,
  normalizeParams: () => normalizeParams,
  nullish: () => nullish,
  numKeys: () => numKeys,
  omit: () => omit,
  optionalKeys: () => optionalKeys,
  partial: () => partial,
  pick: () => pick,
  prefixIssues: () => prefixIssues,
  primitiveTypes: () => primitiveTypes,
  promiseAllObject: () => promiseAllObject,
  propertyKeyTypes: () => propertyKeyTypes,
  randomString: () => randomString,
  required: () => required,
  stringifyPrimitive: () => stringifyPrimitive,
  unwrapMessage: () => unwrapMessage
});
function assertEqual(val) {
  return val;
}
function assertNotEqual(val) {
  return val;
}
function assertIs(_arg) {
}
function assertNever(_x) {
  throw new Error();
}
function assert(_) {
}
function getEnumValues(entries) {
  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
  return values;
}
function joinValues(array2, separator = "|") {
  return array2.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
  if (typeof value === "bigint")
    return value.toString();
  return value;
}
function cached(getter) {
  const set = false;
  return {
    get value() {
      if (!set) {
        const value = getter();
        Object.defineProperty(this, "value", { value });
        return value;
      }
      throw new Error("cached value already set");
    }
  };
}
function nullish(input) {
  return input === null || input === void 0;
}
function cleanRegex(source) {
  const start = source.startsWith("^") ? 1 : 0;
  const end = source.endsWith("$") ? source.length - 1 : source.length;
  return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepDecCount = (step.toString().split(".")[1] || "").length;
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
function defineLazy(object3, key, getter) {
  const set = false;
  Object.defineProperty(object3, key, {
    get() {
      if (!set) {
        const value = getter();
        object3[key] = value;
        return value;
      }
      throw new Error("cached value already set");
    },
    set(v) {
      Object.defineProperty(object3, key, {
        value: v
        // configurable: true,
      });
    },
    configurable: true
  });
}
function assignProp(target, prop, value) {
  Object.defineProperty(target, prop, {
    value,
    writable: true,
    enumerable: true,
    configurable: true
  });
}
function getElementAtPath(obj, path) {
  if (!path)
    return obj;
  return path.reduce((acc, key) => acc?.[key], obj);
}
function promiseAllObject(promisesObj) {
  const keys = Object.keys(promisesObj);
  const promises = keys.map((key) => promisesObj[key]);
  return Promise.all(promises).then((results2) => {
    const resolvedObj = {};
    for (let i = 0; i < keys.length; i++) {
      resolvedObj[keys[i]] = results2[i];
    }
    return resolvedObj;
  });
}
function randomString(length = 10) {
  const chars = "abcdefghijklmnopqrstuvwxyz";
  let str = "";
  for (let i = 0; i < length; i++) {
    str += chars[Math.floor(Math.random() * chars.length)];
  }
  return str;
}
function esc(str) {
  return JSON.stringify(str);
}
var captureStackTrace = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => {
};
function isObject(data) {
  return typeof data === "object" && data !== null && !Array.isArray(data);
}
var allowsEval = cached(() => {
  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
    return false;
  }
  try {
    const F = Function;
    new F("");
    return true;
  } catch (_) {
    return false;
  }
});
function isPlainObject(o) {
  if (isObject(o) === false)
    return false;
  const ctor = o.constructor;
  if (ctor === void 0)
    return true;
  const prot = ctor.prototype;
  if (isObject(prot) === false)
    return false;
  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
    return false;
  }
  return true;
}
function numKeys(data) {
  let keyCount = 0;
  for (const key in data) {
    if (Object.prototype.hasOwnProperty.call(data, key)) {
      keyCount++;
    }
  }
  return keyCount;
}
var getParsedType = (data) => {
  const t = typeof data;
  switch (t) {
    case "undefined":
      return "undefined";
    case "string":
      return "string";
    case "number":
      return Number.isNaN(data) ? "nan" : "number";
    case "boolean":
      return "boolean";
    case "function":
      return "function";
    case "bigint":
      return "bigint";
    case "symbol":
      return "symbol";
    case "object":
      if (Array.isArray(data)) {
        return "array";
      }
      if (data === null) {
        return "null";
      }
      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
        return "promise";
      }
      if (typeof Map !== "undefined" && data instanceof Map) {
        return "map";
      }
      if (typeof Set !== "undefined" && data instanceof Set) {
        return "set";
      }
      if (typeof Date !== "undefined" && data instanceof Date) {
        return "date";
      }
      if (typeof File !== "undefined" && data instanceof File) {
        return "file";
      }
      return "object";
    default:
      throw new Error(`Unknown data type: ${t}`);
  }
};
var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
function escapeRegex(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
  const cl = new inst._zod.constr(def ?? inst._zod.def);
  if (!def || params?.parent)
    cl._zod.parent = inst;
  return cl;
}
function normalizeParams(_params) {
  const params = _params;
  if (!params)
    return {};
  if (typeof params === "string")
    return { error: () => params };
  if (params?.message !== void 0) {
    if (params?.error !== void 0)
      throw new Error("Cannot specify both `message` and `error` params");
    params.error = params.message;
  }
  delete params.message;
  if (typeof params.error === "string")
    return { ...params, error: () => params.error };
  return params;
}
function createTransparentProxy(getter) {
  let target;
  return new Proxy({}, {
    get(_, prop, receiver) {
      target ?? (target = getter());
      return Reflect.get(target, prop, receiver);
    },
    set(_, prop, value, receiver) {
      target ?? (target = getter());
      return Reflect.set(target, prop, value, receiver);
    },
    has(_, prop) {
      target ?? (target = getter());
      return Reflect.has(target, prop);
    },
    deleteProperty(_, prop) {
      target ?? (target = getter());
      return Reflect.deleteProperty(target, prop);
    },
    ownKeys(_) {
      target ?? (target = getter());
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(_, prop) {
      target ?? (target = getter());
      return Reflect.getOwnPropertyDescriptor(target, prop);
    },
    defineProperty(_, prop, descriptor) {
      target ?? (target = getter());
      return Reflect.defineProperty(target, prop, descriptor);
    }
  });
}
function stringifyPrimitive(value) {
  if (typeof value === "bigint")
    return value.toString() + "n";
  if (typeof value === "string")
    return `"${value}"`;
  return `${value}`;
}
function optionalKeys(shape) {
  return Object.keys(shape).filter((k) => {
    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
  });
}
var NUMBER_FORMAT_RANGES = {
  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
  int32: [-2147483648, 2147483647],
  uint32: [0, 4294967295],
  float32: [-34028234663852886e22, 34028234663852886e22],
  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
};
var BIGINT_FORMAT_RANGES = {
  int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
  uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
};
function pick(schema, mask) {
  const newShape = {};
  const currDef = schema._zod.def;
  for (const key in mask) {
    if (!(key in currDef.shape)) {
      throw new Error(`Unrecognized key: "${key}"`);
    }
    if (!mask[key])
      continue;
    newShape[key] = currDef.shape[key];
  }
  return clone(schema, {
    ...schema._zod.def,
    shape: newShape,
    checks: []
  });
}
function omit(schema, mask) {
  const newShape = { ...schema._zod.def.shape };
  const currDef = schema._zod.def;
  for (const key in mask) {
    if (!(key in currDef.shape)) {
      throw new Error(`Unrecognized key: "${key}"`);
    }
    if (!mask[key])
      continue;
    delete newShape[key];
  }
  return clone(schema, {
    ...schema._zod.def,
    shape: newShape,
    checks: []
  });
}
function extend(schema, shape) {
  if (!isPlainObject(shape)) {
    throw new Error("Invalid input to extend: expected a plain object");
  }
  const def = {
    ...schema._zod.def,
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    },
    checks: []
    // delete existing checks
  };
  return clone(schema, def);
}
function merge(a, b) {
  return clone(a, {
    ...a._zod.def,
    get shape() {
      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
      assignProp(this, "shape", _shape);
      return _shape;
    },
    catchall: b._zod.def.catchall,
    checks: []
    // delete existing checks
  });
}
function partial(Class2, schema, mask) {
  const oldShape = schema._zod.def.shape;
  const shape = { ...oldShape };
  if (mask) {
    for (const key in mask) {
      if (!(key in oldShape)) {
        throw new Error(`Unrecognized key: "${key}"`);
      }
      if (!mask[key])
        continue;
      shape[key] = Class2 ? new Class2({
        type: "optional",
        innerType: oldShape[key]
      }) : oldShape[key];
    }
  } else {
    for (const key in oldShape) {
      shape[key] = Class2 ? new Class2({
        type: "optional",
        innerType: oldShape[key]
      }) : oldShape[key];
    }
  }
  return clone(schema, {
    ...schema._zod.def,
    shape,
    checks: []
  });
}
function required(Class2, schema, mask) {
  const oldShape = schema._zod.def.shape;
  const shape = { ...oldShape };
  if (mask) {
    for (const key in mask) {
      if (!(key in shape)) {
        throw new Error(`Unrecognized key: "${key}"`);
      }
      if (!mask[key])
        continue;
      shape[key] = new Class2({
        type: "nonoptional",
        innerType: oldShape[key]
      });
    }
  } else {
    for (const key in oldShape) {
      shape[key] = new Class2({
        type: "nonoptional",
        innerType: oldShape[key]
      });
    }
  }
  return clone(schema, {
    ...schema._zod.def,
    shape,
    // optional: [],
    checks: []
  });
}
function aborted(x, startIndex = 0) {
  for (let i = startIndex; i < x.issues.length; i++) {
    if (x.issues[i]?.continue !== true)
      return true;
  }
  return false;
}
function prefixIssues(path, issues) {
  return issues.map((iss) => {
    var _a;
    (_a = iss).path ?? (_a.path = []);
    iss.path.unshift(path);
    return iss;
  });
}
function unwrapMessage(message) {
  return typeof message === "string" ? message : message?.message;
}
function finalizeIssue(iss, ctx, config2) {
  const full = { ...iss, path: iss.path ?? [] };
  if (!iss.message) {
    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
    full.message = message;
  }
  delete full.inst;
  delete full.continue;
  if (!ctx?.reportInput) {
    delete full.input;
  }
  return full;
}
function getSizableOrigin(input) {
  if (input instanceof Set)
    return "set";
  if (input instanceof Map)
    return "map";
  if (input instanceof File)
    return "file";
  return "unknown";
}
function getLengthableOrigin(input) {
  if (Array.isArray(input))
    return "array";
  if (typeof input === "string")
    return "string";
  return "unknown";
}
function issue(...args) {
  const [iss, input, inst] = args;
  if (typeof iss === "string") {
    return {
      message: iss,
      code: "custom",
      input,
      inst
    };
  }
  return { ...iss };
}
function cleanEnum(obj) {
  return Object.entries(obj).filter(([k, _]) => {
    return Number.isNaN(Number.parseInt(k, 10));
  }).map((el) => el[1]);
}
var Class = class {
  constructor(..._args) {
  }
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/errors.js
var initializer = (inst, def) => {
  inst.name = "$ZodError";
  Object.defineProperty(inst, "_zod", {
    value: inst._zod,
    enumerable: false
  });
  Object.defineProperty(inst, "issues", {
    value: def,
    enumerable: false
  });
  Object.defineProperty(inst, "message", {
    get() {
      return JSON.stringify(def, jsonStringifyReplacer, 2);
    },
    enumerable: true
    // configurable: false,
  });
  Object.defineProperty(inst, "toString", {
    value: () => inst.message,
    enumerable: false
  });
};
var $ZodError = $constructor("$ZodError", initializer);
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
function flattenError(error3, mapper = (issue2) => issue2.message) {
  const fieldErrors = {};
  const formErrors = [];
  for (const sub of error3.issues) {
    if (sub.path.length > 0) {
      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
      fieldErrors[sub.path[0]].push(mapper(sub));
    } else {
      formErrors.push(mapper(sub));
    }
  }
  return { formErrors, fieldErrors };
}
function formatError(error3, _mapper) {
  const mapper = _mapper || function(issue2) {
    return issue2.message;
  };
  const fieldErrors = { _errors: [] };
  const processError = (error4) => {
    for (const issue2 of error4.issues) {
      if (issue2.code === "invalid_union" && issue2.errors.length) {
        issue2.errors.map((issues) => processError({ issues }));
      } else if (issue2.code === "invalid_key") {
        processError({ issues: issue2.issues });
      } else if (issue2.code === "invalid_element") {
        processError({ issues: issue2.issues });
      } else if (issue2.path.length === 0) {
        fieldErrors._errors.push(mapper(issue2));
      } else {
        let curr = fieldErrors;
        let i = 0;
        while (i < issue2.path.length) {
          const el = issue2.path[i];
          const terminal = i === issue2.path.length - 1;
          if (!terminal) {
            curr[el] = curr[el] || { _errors: [] };
          } else {
            curr[el] = curr[el] || { _errors: [] };
            curr[el]._errors.push(mapper(issue2));
          }
          curr = curr[el];
          i++;
        }
      }
    }
  };
  processError(error3);
  return fieldErrors;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/parse.js
var _parse = (_Err) => (schema, value, _ctx, _params) => {
  const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  if (result.issues.length) {
    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, _params?.callee);
    throw e;
  }
  return result.value;
};
var parse = /* @__PURE__ */ _parse($ZodRealError);
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  if (result.issues.length) {
    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, params?.callee);
    throw e;
  }
  return result.value;
};
var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
var _safeParse = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  return result.issues.length ? {
    success: false,
    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  return result.issues.length ? {
    success: false,
    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/regexes.js
var cuid = /^[cC][^\s-]{8,}$/;
var cuid2 = /^[0-9a-z]+$/;
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
var xid = /^[0-9a-vA-V]{20}$/;
var ksuid = /^[A-Za-z0-9]{27}$/;
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
var uuid = (version2) => {
  if (!version2)
    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
};
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
function emoji() {
  return new RegExp(_emoji, "u");
}
var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
var base64url = /^[A-Za-z0-9_-]*$/;
var hostname = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
function timeSource(args) {
  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
  return regex;
}
function time(args) {
  return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
  const time3 = timeSource({ precision: args.precision });
  const opts = ["Z"];
  if (args.local)
    opts.push("");
  if (args.offset)
    opts.push(`([+-]\\d{2}:\\d{2})`);
  const timeRegex4 = `${time3}(?:${opts.join("|")})`;
  return new RegExp(`^${dateSource}T(?:${timeRegex4})$`);
}
var string = (params) => {
  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
  return new RegExp(`^${regex}$`);
};
var integer = /^\d+$/;
var number = /^-?\d+(?:\.\d+)?/i;
var boolean = /true|false/i;
var _null = /null/i;
var lowercase = /^[^A-Z]*$/;
var uppercase = /^[^a-z]*$/;

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/checks.js
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
  var _a;
  inst._zod ?? (inst._zod = {});
  inst._zod.def = def;
  (_a = inst._zod).onattach ?? (_a.onattach = []);
});
var numericOriginMap = {
  number: "number",
  bigint: "bigint",
  object: "date"
};
var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
    if (def.value < curr) {
      if (def.inclusive)
        bag.maximum = def.value;
      else
        bag.exclusiveMaximum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
    if (def.value > curr) {
      if (def.inclusive)
        bag.minimum = def.value;
      else
        bag.exclusiveMinimum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    var _a;
    (_a = inst2._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
  });
  inst._zod.check = (payload) => {
    if (typeof payload.value !== typeof def.value)
      throw new Error("Cannot mix number and bigint in multiple_of check.");
    const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
    if (isMultiple)
      return;
    payload.issues.push({
      origin: typeof payload.value,
      code: "not_multiple_of",
      divisor: def.value,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
  $ZodCheck.init(inst, def);
  def.format = def.format || "float64";
  const isInt = def.format?.includes("int");
  const origin = isInt ? "int" : "number";
  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    bag.minimum = minimum;
    bag.maximum = maximum;
    if (isInt)
      bag.pattern = integer;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    if (isInt) {
      if (!Number.isInteger(input)) {
        payload.issues.push({
          expected: origin,
          format: def.format,
          code: "invalid_type",
          input,
          inst
        });
        return;
      }
      if (!Number.isSafeInteger(input)) {
        if (input > 0) {
          payload.issues.push({
            input,
            code: "too_big",
            maximum: Number.MAX_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            continue: !def.abort
          });
        } else {
          payload.issues.push({
            input,
            code: "too_small",
            minimum: Number.MIN_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            continue: !def.abort
          });
        }
        return;
      }
    }
    if (input < minimum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_small",
        minimum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
    if (input > maximum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_big",
        maximum,
        inst
      });
    }
  };
});
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
  var _a;
  $ZodCheck.init(inst, def);
  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
    if (def.maximum < curr)
      inst2._zod.bag.maximum = def.maximum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length <= def.maximum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: def.maximum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
  var _a;
  $ZodCheck.init(inst, def);
  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
    if (def.minimum > curr)
      inst2._zod.bag.minimum = def.minimum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length >= def.minimum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: def.minimum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
  var _a;
  $ZodCheck.init(inst, def);
  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.minimum = def.length;
    bag.maximum = def.length;
    bag.length = def.length;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length === def.length)
      return;
    const origin = getLengthableOrigin(input);
    const tooBig = length > def.length;
    payload.issues.push({
      origin,
      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
      inclusive: true,
      exact: true,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
  var _a, _b;
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    if (def.pattern) {
      bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
      bag.patterns.add(def.pattern);
    }
  });
  if (def.pattern)
    (_a = inst._zod).check ?? (_a.check = (payload) => {
      def.pattern.lastIndex = 0;
      if (def.pattern.test(payload.value))
        return;
      payload.issues.push({
        origin: "string",
        code: "invalid_format",
        format: def.format,
        input: payload.value,
        ...def.pattern ? { pattern: def.pattern.toString() } : {},
        inst,
        continue: !def.abort
      });
    });
  else
    (_b = inst._zod).check ?? (_b.check = () => {
    });
});
var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    def.pattern.lastIndex = 0;
    if (def.pattern.test(payload.value))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "regex",
      input: payload.value,
      pattern: def.pattern.toString(),
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
  def.pattern ?? (def.pattern = lowercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
  def.pattern ?? (def.pattern = uppercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
  $ZodCheck.init(inst, def);
  const escapedRegex = escapeRegex(def.includes);
  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
  def.pattern = pattern;
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.includes(def.includes, def.position))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "includes",
      includes: def.includes,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.startsWith(def.prefix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "starts_with",
      prefix: def.prefix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.endsWith(def.suffix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "ends_with",
      suffix: def.suffix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.check = (payload) => {
    payload.value = def.tx(payload.value);
  };
});

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/doc.js
var Doc = class {
  constructor(args = []) {
    this.content = [];
    this.indent = 0;
    if (this)
      this.args = args;
  }
  indented(fn) {
    this.indent += 1;
    fn(this);
    this.indent -= 1;
  }
  write(arg) {
    if (typeof arg === "function") {
      arg(this, { execution: "sync" });
      arg(this, { execution: "async" });
      return;
    }
    const content = arg;
    const lines = content.split("\n").filter((x) => x);
    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
    for (const line of dedented) {
      this.content.push(line);
    }
  }
  compile() {
    const F = Function;
    const args = this?.args;
    const content = this?.content ?? [``];
    const lines = [...content.map((x) => `  ${x}`)];
    return new F(...args, lines.join("\n"));
  }
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/versions.js
var version = {
  major: 4,
  minor: 0,
  patch: 0
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/schemas.js
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
  var _a;
  inst ?? (inst = {});
  inst._zod.def = def;
  inst._zod.bag = inst._zod.bag || {};
  inst._zod.version = version;
  const checks = [...inst._zod.def.checks ?? []];
  if (inst._zod.traits.has("$ZodCheck")) {
    checks.unshift(inst);
  }
  for (const ch of checks) {
    for (const fn of ch._zod.onattach) {
      fn(inst);
    }
  }
  if (checks.length === 0) {
    (_a = inst._zod).deferred ?? (_a.deferred = []);
    inst._zod.deferred?.push(() => {
      inst._zod.run = inst._zod.parse;
    });
  } else {
    const runChecks = (payload, checks2, ctx) => {
      let isAborted4 = aborted(payload);
      let asyncResult;
      for (const ch of checks2) {
        if (ch._zod.def.when) {
          const shouldRun = ch._zod.def.when(payload);
          if (!shouldRun)
            continue;
        } else if (isAborted4) {
          continue;
        }
        const currLen = payload.issues.length;
        const _ = ch._zod.check(payload);
        if (_ instanceof Promise && ctx?.async === false) {
          throw new $ZodAsyncError();
        }
        if (asyncResult || _ instanceof Promise) {
          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
            await _;
            const nextLen = payload.issues.length;
            if (nextLen === currLen)
              return;
            if (!isAborted4)
              isAborted4 = aborted(payload, currLen);
          });
        } else {
          const nextLen = payload.issues.length;
          if (nextLen === currLen)
            continue;
          if (!isAborted4)
            isAborted4 = aborted(payload, currLen);
        }
      }
      if (asyncResult) {
        return asyncResult.then(() => {
          return payload;
        });
      }
      return payload;
    };
    inst._zod.run = (payload, ctx) => {
      const result = inst._zod.parse(payload, ctx);
      if (result instanceof Promise) {
        if (ctx.async === false)
          throw new $ZodAsyncError();
        return result.then((result2) => runChecks(result2, checks, ctx));
      }
      return runChecks(result, checks, ctx);
    };
  }
  inst["~standard"] = {
    validate: (value) => {
      try {
        const r = safeParse(inst, value);
        return r.success ? { value: r.data } : { issues: r.error?.issues };
      } catch (_) {
        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
      }
    },
    vendor: "zod",
    version: 1
  };
});
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
  inst._zod.parse = (payload, _) => {
    if (def.coerce)
      try {
        payload.value = String(payload.value);
      } catch (_2) {
      }
    if (typeof payload.value === "string")
      return payload;
    payload.issues.push({
      expected: "string",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  $ZodString.init(inst, def);
});
var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
  def.pattern ?? (def.pattern = guid);
  $ZodStringFormat.init(inst, def);
});
var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
  if (def.version) {
    const versionMap = {
      v1: 1,
      v2: 2,
      v3: 3,
      v4: 4,
      v5: 5,
      v6: 6,
      v7: 7,
      v8: 8
    };
    const v = versionMap[def.version];
    if (v === void 0)
      throw new Error(`Invalid UUID version: "${def.version}"`);
    def.pattern ?? (def.pattern = uuid(v));
  } else
    def.pattern ?? (def.pattern = uuid());
  $ZodStringFormat.init(inst, def);
});
var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
  def.pattern ?? (def.pattern = email);
  $ZodStringFormat.init(inst, def);
});
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    try {
      const orig = payload.value;
      const url = new URL(orig);
      const href = url.href;
      if (def.hostname) {
        def.hostname.lastIndex = 0;
        if (!def.hostname.test(url.hostname)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid hostname",
            pattern: hostname.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (def.protocol) {
        def.protocol.lastIndex = 0;
        if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid protocol",
            pattern: def.protocol.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (!orig.endsWith("/") && href.endsWith("/")) {
        payload.value = href.slice(0, -1);
      } else {
        payload.value = href;
      }
      return;
    } catch (_) {
      payload.issues.push({
        code: "invalid_format",
        format: "url",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
  def.pattern ?? (def.pattern = emoji());
  $ZodStringFormat.init(inst, def);
});
var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
  def.pattern ?? (def.pattern = nanoid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
  def.pattern ?? (def.pattern = cuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
  def.pattern ?? (def.pattern = cuid2);
  $ZodStringFormat.init(inst, def);
});
var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
  def.pattern ?? (def.pattern = ulid);
  $ZodStringFormat.init(inst, def);
});
var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
  def.pattern ?? (def.pattern = xid);
  $ZodStringFormat.init(inst, def);
});
var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
  def.pattern ?? (def.pattern = ksuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
  def.pattern ?? (def.pattern = datetime(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
  def.pattern ?? (def.pattern = date);
  $ZodStringFormat.init(inst, def);
});
var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
  def.pattern ?? (def.pattern = time(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
  def.pattern ?? (def.pattern = duration);
  $ZodStringFormat.init(inst, def);
});
var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
  def.pattern ?? (def.pattern = ipv4);
  $ZodStringFormat.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = `ipv4`;
  });
});
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
  def.pattern ?? (def.pattern = ipv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = `ipv6`;
  });
  inst._zod.check = (payload) => {
    try {
      new URL(`http://[${payload.value}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "ipv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv4);
  $ZodStringFormat.init(inst, def);
});
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    const [address, prefix] = payload.value.split("/");
    try {
      if (!prefix)
        throw new Error();
      const prefixNum = Number(prefix);
      if (`${prefixNum}` !== prefix)
        throw new Error();
      if (prefixNum < 0 || prefixNum > 128)
        throw new Error();
      new URL(`http://[${address}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "cidrv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
function isValidBase64(data) {
  if (data === "")
    return true;
  if (data.length % 4 !== 0)
    return false;
  try {
    atob(data);
    return true;
  } catch {
    return false;
  }
}
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
  def.pattern ?? (def.pattern = base64);
  $ZodStringFormat.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    inst2._zod.bag.contentEncoding = "base64";
  });
  inst._zod.check = (payload) => {
    if (isValidBase64(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
function isValidBase64URL(data) {
  if (!base64url.test(data))
    return false;
  const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
  const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "=");
  return isValidBase64(padded);
}
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
  def.pattern ?? (def.pattern = base64url);
  $ZodStringFormat.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    inst2._zod.bag.contentEncoding = "base64url";
  });
  inst._zod.check = (payload) => {
    if (isValidBase64URL(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64url",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
  def.pattern ?? (def.pattern = e164);
  $ZodStringFormat.init(inst, def);
});
function isValidJWT(token, algorithm = null) {
  try {
    const tokensParts = token.split(".");
    if (tokensParts.length !== 3)
      return false;
    const [header] = tokensParts;
    if (!header)
      return false;
    const parsedHeader = JSON.parse(atob(header));
    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
      return false;
    if (!parsedHeader.alg)
      return false;
    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
      return false;
    return true;
  } catch {
    return false;
  }
}
var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    if (isValidJWT(payload.value, def.alg))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "jwt",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = inst._zod.bag.pattern ?? number;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = Number(payload.value);
      } catch (_) {
      }
    const input = payload.value;
    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
      return payload;
    }
    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
    payload.issues.push({
      expected: "number",
      code: "invalid_type",
      input,
      inst,
      ...received ? { received } : {}
    });
    return payload;
  };
});
var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
  $ZodCheckNumberFormat.init(inst, def);
  $ZodNumber.init(inst, def);
});
var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = boolean;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = Boolean(payload.value);
      } catch (_) {
      }
    const input = payload.value;
    if (typeof input === "boolean")
      return payload;
    payload.issues.push({
      expected: "boolean",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = _null;
  inst._zod.values = /* @__PURE__ */ new Set([null]);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (input === null)
      return payload;
    payload.issues.push({
      expected: "null",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload) => payload;
});
var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    payload.issues.push({
      expected: "never",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
function handleArrayResult(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(index, result.issues));
  }
  final.value[index] = result.value;
}
var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!Array.isArray(input)) {
      payload.issues.push({
        expected: "array",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    payload.value = Array(input.length);
    const proms = [];
    for (let i = 0; i < input.length; i++) {
      const item = input[i];
      const result = def.element._zod.run({
        value: item,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
      } else {
        handleArrayResult(result, payload, i);
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
function handleObjectResult(result, final, key) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(key, result.issues));
  }
  final.value[key] = result.value;
}
function handleOptionalObjectResult(result, final, key, input) {
  if (result.issues.length) {
    if (input[key] === void 0) {
      if (key in input) {
        final.value[key] = void 0;
      } else {
        final.value[key] = result.value;
      }
    } else {
      final.issues.push(...prefixIssues(key, result.issues));
    }
  } else if (result.value === void 0) {
    if (key in input)
      final.value[key] = void 0;
  } else {
    final.value[key] = result.value;
  }
}
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
  $ZodType.init(inst, def);
  const _normalized = cached(() => {
    const keys = Object.keys(def.shape);
    for (const k of keys) {
      if (!(def.shape[k] instanceof $ZodType)) {
        throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
      }
    }
    const okeys = optionalKeys(def.shape);
    return {
      shape: def.shape,
      keys,
      keySet: new Set(keys),
      numKeys: keys.length,
      optionalKeys: new Set(okeys)
    };
  });
  defineLazy(inst._zod, "propValues", () => {
    const shape = def.shape;
    const propValues = {};
    for (const key in shape) {
      const field = shape[key]._zod;
      if (field.values) {
        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
        for (const v of field.values)
          propValues[key].add(v);
      }
    }
    return propValues;
  });
  const generateFastpass = (shape) => {
    const doc = new Doc(["shape", "payload", "ctx"]);
    const normalized = _normalized.value;
    const parseStr = (key) => {
      const k = esc(key);
      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
    };
    doc.write(`const input = payload.value;`);
    const ids = /* @__PURE__ */ Object.create(null);
    let counter = 0;
    for (const key of normalized.keys) {
      ids[key] = `key_${counter++}`;
    }
    doc.write(`const newResult = {}`);
    for (const key of normalized.keys) {
      if (normalized.optionalKeys.has(key)) {
        const id = ids[key];
        doc.write(`const ${id} = ${parseStr(key)};`);
        const k = esc(key);
        doc.write(`
        if (${id}.issues.length) {
          if (input[${k}] === undefined) {
            if (${k} in input) {
              newResult[${k}] = undefined;
            }
          } else {
            payload.issues = payload.issues.concat(
              ${id}.issues.map((iss) => ({
                ...iss,
                path: iss.path ? [${k}, ...iss.path] : [${k}],
              }))
            );
          }
        } else if (${id}.value === undefined) {
          if (${k} in input) newResult[${k}] = undefined;
        } else {
          newResult[${k}] = ${id}.value;
        }
        `);
      } else {
        const id = ids[key];
        doc.write(`const ${id} = ${parseStr(key)};`);
        doc.write(`
          if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
          })));`);
        doc.write(`newResult[${esc(key)}] = ${id}.value`);
      }
    }
    doc.write(`payload.value = newResult;`);
    doc.write(`return payload;`);
    const fn = doc.compile();
    return (payload, ctx) => fn(shape, payload, ctx);
  };
  let fastpass;
  const isObject2 = isObject;
  const jit = !globalConfig.jitless;
  const allowsEval2 = allowsEval;
  const fastEnabled = jit && allowsEval2.value;
  const catchall = def.catchall;
  let value;
  inst._zod.parse = (payload, ctx) => {
    value ?? (value = _normalized.value);
    const input = payload.value;
    if (!isObject2(input)) {
      payload.issues.push({
        expected: "object",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    const proms = [];
    if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
      if (!fastpass)
        fastpass = generateFastpass(def.shape);
      payload = fastpass(payload, ctx);
    } else {
      payload.value = {};
      const shape = value.shape;
      for (const key of value.keys) {
        const el = shape[key];
        const r = el._zod.run({ value: input[key], issues: [] }, ctx);
        const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
        if (r instanceof Promise) {
          proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key)));
        } else if (isOptional) {
          handleOptionalObjectResult(r, payload, key, input);
        } else {
          handleObjectResult(r, payload, key);
        }
      }
    }
    if (!catchall) {
      return proms.length ? Promise.all(proms).then(() => payload) : payload;
    }
    const unrecognized = [];
    const keySet = value.keySet;
    const _catchall = catchall._zod;
    const t = _catchall.def.type;
    for (const key of Object.keys(input)) {
      if (keySet.has(key))
        continue;
      if (t === "never") {
        unrecognized.push(key);
        continue;
      }
      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
      if (r instanceof Promise) {
        proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
      } else {
        handleObjectResult(r, payload, key);
      }
    }
    if (unrecognized.length) {
      payload.issues.push({
        code: "unrecognized_keys",
        keys: unrecognized,
        input,
        inst
      });
    }
    if (!proms.length)
      return payload;
    return Promise.all(proms).then(() => {
      return payload;
    });
  };
});
function handleUnionResults(results2, final, inst, ctx) {
  for (const result of results2) {
    if (result.issues.length === 0) {
      final.value = result.value;
      return final;
    }
  }
  final.issues.push({
    code: "invalid_union",
    input: final.value,
    inst,
    errors: results2.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  });
  return final;
}
var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "values", () => {
    if (def.options.every((o) => o._zod.values)) {
      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
    }
    return void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    if (def.options.every((o) => o._zod.pattern)) {
      const patterns = def.options.map((o) => o._zod.pattern);
      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
    }
    return void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    let async = false;
    const results2 = [];
    for (const option of def.options) {
      const result = option._zod.run({
        value: payload.value,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        results2.push(result);
        async = true;
      } else {
        if (result.issues.length === 0)
          return result;
        results2.push(result);
      }
    }
    if (!async)
      return handleUnionResults(results2, payload, inst, ctx);
    return Promise.all(results2).then((results3) => {
      return handleUnionResults(results3, payload, inst, ctx);
    });
  };
});
var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
  $ZodUnion.init(inst, def);
  const _super = inst._zod.parse;
  defineLazy(inst._zod, "propValues", () => {
    const propValues = {};
    for (const option of def.options) {
      const pv = option._zod.propValues;
      if (!pv || Object.keys(pv).length === 0)
        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
      for (const [k, v] of Object.entries(pv)) {
        if (!propValues[k])
          propValues[k] = /* @__PURE__ */ new Set();
        for (const val of v) {
          propValues[k].add(val);
        }
      }
    }
    return propValues;
  });
  const disc = cached(() => {
    const opts = def.options;
    const map = /* @__PURE__ */ new Map();
    for (const o of opts) {
      const values = o._zod.propValues[def.discriminator];
      if (!values || values.size === 0)
        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
      for (const v of values) {
        if (map.has(v)) {
          throw new Error(`Duplicate discriminator value "${String(v)}"`);
        }
        map.set(v, o);
      }
    }
    return map;
  });
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!isObject(input)) {
      payload.issues.push({
        code: "invalid_type",
        expected: "object",
        input,
        inst
      });
      return payload;
    }
    const opt = disc.value.get(input?.[def.discriminator]);
    if (opt) {
      return opt._zod.run(payload, ctx);
    }
    if (def.unionFallback) {
      return _super(payload, ctx);
    }
    payload.issues.push({
      code: "invalid_union",
      errors: [],
      note: "No matching discriminator",
      input,
      path: [def.discriminator],
      inst
    });
    return payload;
  };
});
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
    const async = left instanceof Promise || right instanceof Promise;
    if (async) {
      return Promise.all([left, right]).then(([left2, right2]) => {
        return handleIntersectionResults(payload, left2, right2);
      });
    }
    return handleIntersectionResults(payload, left, right);
  };
});
function mergeValues(a, b) {
  if (a === b) {
    return { valid: true, data: a };
  }
  if (a instanceof Date && b instanceof Date && +a === +b) {
    return { valid: true, data: a };
  }
  if (isPlainObject(a) && isPlainObject(b)) {
    const bKeys = Object.keys(b);
    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues(a[key], b[key]);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
        };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  }
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) {
      return { valid: false, mergeErrorPath: [] };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues(itemA, itemB);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
        };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  }
  return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults(result, left, right) {
  if (left.issues.length) {
    result.issues.push(...left.issues);
  }
  if (right.issues.length) {
    result.issues.push(...right.issues);
  }
  if (aborted(result))
    return result;
  const merged = mergeValues(left.value, right.value);
  if (!merged.valid) {
    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
  }
  result.value = merged.data;
  return result;
}
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!isPlainObject(input)) {
      payload.issues.push({
        expected: "record",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    const proms = [];
    if (def.keyType._zod.values) {
      const values = def.keyType._zod.values;
      payload.value = {};
      for (const key of values) {
        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => {
              if (result2.issues.length) {
                payload.issues.push(...prefixIssues(key, result2.issues));
              }
              payload.value[key] = result2.value;
            }));
          } else {
            if (result.issues.length) {
              payload.issues.push(...prefixIssues(key, result.issues));
            }
            payload.value[key] = result.value;
          }
        }
      }
      let unrecognized;
      for (const key in input) {
        if (!values.has(key)) {
          unrecognized = unrecognized ?? [];
          unrecognized.push(key);
        }
      }
      if (unrecognized && unrecognized.length > 0) {
        payload.issues.push({
          code: "unrecognized_keys",
          input,
          inst,
          keys: unrecognized
        });
      }
    } else {
      payload.value = {};
      for (const key of Reflect.ownKeys(input)) {
        if (key === "__proto__")
          continue;
        const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
        if (keyResult instanceof Promise) {
          throw new Error("Async schemas not supported in object keys currently");
        }
        if (keyResult.issues.length) {
          payload.issues.push({
            origin: "record",
            code: "invalid_key",
            issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
            input: key,
            path: [key],
            inst
          });
          payload.value[keyResult.value] = keyResult.value;
          continue;
        }
        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
        if (result instanceof Promise) {
          proms.push(result.then((result2) => {
            if (result2.issues.length) {
              payload.issues.push(...prefixIssues(key, result2.issues));
            }
            payload.value[keyResult.value] = result2.value;
          }));
        } else {
          if (result.issues.length) {
            payload.issues.push(...prefixIssues(key, result.issues));
          }
          payload.value[keyResult.value] = result.value;
        }
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
  $ZodType.init(inst, def);
  const values = getEnumValues(def.entries);
  inst._zod.values = new Set(values);
  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (inst._zod.values.has(input)) {
      return payload;
    }
    payload.issues.push({
      code: "invalid_value",
      values,
      input,
      inst
    });
    return payload;
  };
});
var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.values = new Set(def.values);
  inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? o.toString() : String(o)).join("|")})$`);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (inst._zod.values.has(input)) {
      return payload;
    }
    payload.issues.push({
      code: "invalid_value",
      values: def.values,
      input,
      inst
    });
    return payload;
  };
});
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    const _out = def.transform(payload.value, payload);
    if (_ctx.async) {
      const output = _out instanceof Promise ? _out : Promise.resolve(_out);
      return output.then((output2) => {
        payload.value = output2;
        return payload;
      });
    }
    if (_out instanceof Promise) {
      throw new $ZodAsyncError();
    }
    payload.value = _out;
    return payload;
  };
});
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  inst._zod.optout = "optional";
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (def.innerType._zod.optin === "optional") {
      return def.innerType._zod.run(payload, ctx);
    }
    if (payload.value === void 0) {
      return payload;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
  });
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (payload.value === null)
      return payload;
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
      return payload;
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleDefaultResult(result2, def));
    }
    return handleDefaultResult(result, def);
  };
});
function handleDefaultResult(payload, def) {
  if (payload.value === void 0) {
    payload.value = def.defaultValue;
  }
  return payload;
}
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => {
    const v = def.innerType._zod.values;
    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleNonOptionalResult(result2, inst));
    }
    return handleNonOptionalResult(result, inst);
  };
});
function handleNonOptionalResult(payload, inst) {
  if (!payload.issues.length && payload.value === void 0) {
    payload.issues.push({
      code: "invalid_type",
      expected: "nonoptional",
      input: payload.value,
      inst
    });
  }
  return payload;
}
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => {
        payload.value = result2.value;
        if (result2.issues.length) {
          payload.value = def.catchValue({
            ...payload,
            error: {
              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
            },
            input: payload.value
          });
          payload.issues = [];
        }
        return payload;
      });
    }
    payload.value = result.value;
    if (result.issues.length) {
      payload.value = def.catchValue({
        ...payload,
        error: {
          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
        },
        input: payload.value
      });
      payload.issues = [];
    }
    return payload;
  };
});
var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => def.in._zod.values);
  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
  inst._zod.parse = (payload, ctx) => {
    const left = def.in._zod.run(payload, ctx);
    if (left instanceof Promise) {
      return left.then((left2) => handlePipeResult(left2, def, ctx));
    }
    return handlePipeResult(left, def, ctx);
  };
});
function handlePipeResult(left, def, ctx) {
  if (aborted(left)) {
    return left;
  }
  return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);
}
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  inst._zod.parse = (payload, ctx) => {
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then(handleReadonlyResult);
    }
    return handleReadonlyResult(result);
  };
});
function handleReadonlyResult(payload) {
  payload.value = Object.freeze(payload.value);
  return payload;
}
var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
  $ZodCheck.init(inst, def);
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _) => {
    return payload;
  };
  inst._zod.check = (payload) => {
    const input = payload.value;
    const r = def.fn(input);
    if (r instanceof Promise) {
      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
    }
    handleRefineResult(r, payload, input, inst);
    return;
  };
});
function handleRefineResult(result, payload, input, inst) {
  if (!result) {
    const _iss = {
      code: "custom",
      input,
      inst,
      // incorporates params.error into issue reporting
      path: [...inst._zod.def.path ?? []],
      // incorporates params.error into issue reporting
      continue: !inst._zod.def.abort
      // params: inst._zod.def.params,
    };
    if (inst._zod.def.params)
      _iss.params = inst._zod.def.params;
    payload.issues.push(issue(_iss));
  }
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/locales/en.js
var parsedType = (data) => {
  const t = typeof data;
  switch (t) {
    case "number": {
      return Number.isNaN(data) ? "NaN" : "number";
    }
    case "object": {
      if (Array.isArray(data)) {
        return "array";
      }
      if (data === null) {
        return "null";
      }
      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
        return data.constructor.name;
      }
    }
  }
  return t;
};
var error = () => {
  const Sizable = {
    string: { unit: "characters", verb: "to have" },
    file: { unit: "bytes", verb: "to have" },
    array: { unit: "items", verb: "to have" },
    set: { unit: "items", verb: "to have" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const Nouns = {
    regex: "input",
    email: "email address",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO datetime",
    date: "ISO date",
    time: "ISO time",
    duration: "ISO duration",
    ipv4: "IPv4 address",
    ipv6: "IPv6 address",
    cidrv4: "IPv4 range",
    cidrv6: "IPv6 range",
    base64: "base64-encoded string",
    base64url: "base64url-encoded string",
    json_string: "JSON string",
    e164: "E.164 number",
    jwt: "JWT",
    template_literal: "input"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type":
        return `Invalid input: expected ${issue2.expected}, received ${parsedType(issue2.input)}`;
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
        return `Invalid option: expected one of ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Too big: expected ${issue2.origin ?? "value"} to have ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`;
        return `Too big: expected ${issue2.origin ?? "value"} to be ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Invalid string: must start with "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `Invalid string: must end with "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Invalid string: must include "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Invalid string: must match pattern ${_issue.pattern}`;
        return `Invalid ${Nouns[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Invalid number: must be a multiple of ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Unrecognized key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Invalid key in ${issue2.origin}`;
      case "invalid_union":
        return "Invalid input";
      case "invalid_element":
        return `Invalid value in ${issue2.origin}`;
      default:
        return `Invalid input`;
    }
  };
};
function en_default() {
  return {
    localeError: error()
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/registries.js
var $output = Symbol("ZodOutput");
var $input = Symbol("ZodInput");
var $ZodRegistry = class {
  constructor() {
    this._map = /* @__PURE__ */ new Map();
    this._idmap = /* @__PURE__ */ new Map();
  }
  add(schema, ..._meta) {
    const meta = _meta[0];
    this._map.set(schema, meta);
    if (meta && typeof meta === "object" && "id" in meta) {
      if (this._idmap.has(meta.id)) {
        throw new Error(`ID ${meta.id} already exists in the registry`);
      }
      this._idmap.set(meta.id, schema);
    }
    return this;
  }
  clear() {
    this._map = /* @__PURE__ */ new Map();
    this._idmap = /* @__PURE__ */ new Map();
    return this;
  }
  remove(schema) {
    const meta = this._map.get(schema);
    if (meta && typeof meta === "object" && "id" in meta) {
      this._idmap.delete(meta.id);
    }
    this._map.delete(schema);
    return this;
  }
  get(schema) {
    const p = schema._zod.parent;
    if (p) {
      const pm = { ...this.get(p) ?? {} };
      delete pm.id;
      return { ...pm, ...this._map.get(schema) };
    }
    return this._map.get(schema);
  }
  has(schema) {
    return this._map.has(schema);
  }
};
function registry() {
  return new $ZodRegistry();
}
var globalRegistry = /* @__PURE__ */ registry();

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/api.js
function _string(Class2, params) {
  return new Class2({
    type: "string",
    ...normalizeParams(params)
  });
}
function _email(Class2, params) {
  return new Class2({
    type: "string",
    format: "email",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _guid(Class2, params) {
  return new Class2({
    type: "string",
    format: "guid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _uuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _uuidv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v4",
    ...normalizeParams(params)
  });
}
function _uuidv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v6",
    ...normalizeParams(params)
  });
}
function _uuidv7(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v7",
    ...normalizeParams(params)
  });
}
function _url(Class2, params) {
  return new Class2({
    type: "string",
    format: "url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _emoji2(Class2, params) {
  return new Class2({
    type: "string",
    format: "emoji",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _nanoid(Class2, params) {
  return new Class2({
    type: "string",
    format: "nanoid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _cuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _cuid2(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid2",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _ulid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ulid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _xid(Class2, params) {
  return new Class2({
    type: "string",
    format: "xid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _ksuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ksuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _ipv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _ipv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _cidrv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _cidrv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _base64(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _base64url(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _e164(Class2, params) {
  return new Class2({
    type: "string",
    format: "e164",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _jwt(Class2, params) {
  return new Class2({
    type: "string",
    format: "jwt",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
function _isoDateTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "datetime",
    check: "string_format",
    offset: false,
    local: false,
    precision: null,
    ...normalizeParams(params)
  });
}
function _isoDate(Class2, params) {
  return new Class2({
    type: "string",
    format: "date",
    check: "string_format",
    ...normalizeParams(params)
  });
}
function _isoTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "time",
    check: "string_format",
    precision: null,
    ...normalizeParams(params)
  });
}
function _isoDuration(Class2, params) {
  return new Class2({
    type: "string",
    format: "duration",
    check: "string_format",
    ...normalizeParams(params)
  });
}
function _number(Class2, params) {
  return new Class2({
    type: "number",
    checks: [],
    ...normalizeParams(params)
  });
}
function _int(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "safeint",
    ...normalizeParams(params)
  });
}
function _boolean(Class2, params) {
  return new Class2({
    type: "boolean",
    ...normalizeParams(params)
  });
}
function _null2(Class2, params) {
  return new Class2({
    type: "null",
    ...normalizeParams(params)
  });
}
function _unknown(Class2) {
  return new Class2({
    type: "unknown"
  });
}
function _never(Class2, params) {
  return new Class2({
    type: "never",
    ...normalizeParams(params)
  });
}
function _lt(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
function _lte(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
function _gt(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
function _gte(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
function _multipleOf(value, params) {
  return new $ZodCheckMultipleOf({
    check: "multiple_of",
    ...normalizeParams(params),
    value
  });
}
function _maxLength(maximum, params) {
  const ch = new $ZodCheckMaxLength({
    check: "max_length",
    ...normalizeParams(params),
    maximum
  });
  return ch;
}
function _minLength(minimum, params) {
  return new $ZodCheckMinLength({
    check: "min_length",
    ...normalizeParams(params),
    minimum
  });
}
function _length(length, params) {
  return new $ZodCheckLengthEquals({
    check: "length_equals",
    ...normalizeParams(params),
    length
  });
}
function _regex(pattern, params) {
  return new $ZodCheckRegex({
    check: "string_format",
    format: "regex",
    ...normalizeParams(params),
    pattern
  });
}
function _lowercase(params) {
  return new $ZodCheckLowerCase({
    check: "string_format",
    format: "lowercase",
    ...normalizeParams(params)
  });
}
function _uppercase(params) {
  return new $ZodCheckUpperCase({
    check: "string_format",
    format: "uppercase",
    ...normalizeParams(params)
  });
}
function _includes(includes, params) {
  return new $ZodCheckIncludes({
    check: "string_format",
    format: "includes",
    ...normalizeParams(params),
    includes
  });
}
function _startsWith(prefix, params) {
  return new $ZodCheckStartsWith({
    check: "string_format",
    format: "starts_with",
    ...normalizeParams(params),
    prefix
  });
}
function _endsWith(suffix, params) {
  return new $ZodCheckEndsWith({
    check: "string_format",
    format: "ends_with",
    ...normalizeParams(params),
    suffix
  });
}
function _overwrite(tx) {
  return new $ZodCheckOverwrite({
    check: "overwrite",
    tx
  });
}
function _normalize(form) {
  return _overwrite((input) => input.normalize(form));
}
function _trim() {
  return _overwrite((input) => input.trim());
}
function _toLowerCase() {
  return _overwrite((input) => input.toLowerCase());
}
function _toUpperCase() {
  return _overwrite((input) => input.toUpperCase());
}
function _array(Class2, element, params) {
  return new Class2({
    type: "array",
    element,
    // get element() {
    //   return element;
    // },
    ...normalizeParams(params)
  });
}
function _custom(Class2, fn, _params) {
  const norm = normalizeParams(_params);
  norm.abort ?? (norm.abort = true);
  const schema = new Class2({
    type: "custom",
    check: "custom",
    fn,
    ...norm
  });
  return schema;
}
function _refine(Class2, fn, _params) {
  const schema = new Class2({
    type: "custom",
    check: "custom",
    fn,
    ...normalizeParams(_params)
  });
  return schema;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/to-json-schema.js
var JSONSchemaGenerator = class {
  constructor(params) {
    this.counter = 0;
    this.metadataRegistry = params?.metadata ?? globalRegistry;
    this.target = params?.target ?? "draft-2020-12";
    this.unrepresentable = params?.unrepresentable ?? "throw";
    this.override = params?.override ?? (() => {
    });
    this.io = params?.io ?? "output";
    this.seen = /* @__PURE__ */ new Map();
  }
  process(schema, _params = { path: [], schemaPath: [] }) {
    var _a;
    const def = schema._zod.def;
    const formatMap = {
      guid: "uuid",
      url: "uri",
      datetime: "date-time",
      json_string: "json-string",
      regex: ""
      // do not set
    };
    const seen = this.seen.get(schema);
    if (seen) {
      seen.count++;
      const isCycle = _params.schemaPath.includes(schema);
      if (isCycle) {
        seen.cycle = _params.path;
      }
      return seen.schema;
    }
    const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
    this.seen.set(schema, result);
    const overrideSchema = schema._zod.toJSONSchema?.();
    if (overrideSchema) {
      result.schema = overrideSchema;
    } else {
      const params = {
        ..._params,
        schemaPath: [..._params.schemaPath, schema],
        path: _params.path
      };
      const parent = schema._zod.parent;
      if (parent) {
        result.ref = parent;
        this.process(parent, params);
        this.seen.get(parent).isParent = true;
      } else {
        const _json = result.schema;
        switch (def.type) {
          case "string": {
            const json = _json;
            json.type = "string";
            const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
            if (typeof minimum === "number")
              json.minLength = minimum;
            if (typeof maximum === "number")
              json.maxLength = maximum;
            if (format) {
              json.format = formatMap[format] ?? format;
              if (json.format === "")
                delete json.format;
            }
            if (contentEncoding)
              json.contentEncoding = contentEncoding;
            if (patterns && patterns.size > 0) {
              const regexes = [...patterns];
              if (regexes.length === 1)
                json.pattern = regexes[0].source;
              else if (regexes.length > 1) {
                result.schema.allOf = [
                  ...regexes.map((regex) => ({
                    ...this.target === "draft-7" ? { type: "string" } : {},
                    pattern: regex.source
                  }))
                ];
              }
            }
            break;
          }
          case "number": {
            const json = _json;
            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
            if (typeof format === "string" && format.includes("int"))
              json.type = "integer";
            else
              json.type = "number";
            if (typeof exclusiveMinimum === "number")
              json.exclusiveMinimum = exclusiveMinimum;
            if (typeof minimum === "number") {
              json.minimum = minimum;
              if (typeof exclusiveMinimum === "number") {
                if (exclusiveMinimum >= minimum)
                  delete json.minimum;
                else
                  delete json.exclusiveMinimum;
              }
            }
            if (typeof exclusiveMaximum === "number")
              json.exclusiveMaximum = exclusiveMaximum;
            if (typeof maximum === "number") {
              json.maximum = maximum;
              if (typeof exclusiveMaximum === "number") {
                if (exclusiveMaximum <= maximum)
                  delete json.maximum;
                else
                  delete json.exclusiveMaximum;
              }
            }
            if (typeof multipleOf === "number")
              json.multipleOf = multipleOf;
            break;
          }
          case "boolean": {
            const json = _json;
            json.type = "boolean";
            break;
          }
          case "bigint": {
            if (this.unrepresentable === "throw") {
              throw new Error("BigInt cannot be represented in JSON Schema");
            }
            break;
          }
          case "symbol": {
            if (this.unrepresentable === "throw") {
              throw new Error("Symbols cannot be represented in JSON Schema");
            }
            break;
          }
          case "null": {
            _json.type = "null";
            break;
          }
          case "any": {
            break;
          }
          case "unknown": {
            break;
          }
          case "undefined": {
            if (this.unrepresentable === "throw") {
              throw new Error("Undefined cannot be represented in JSON Schema");
            }
            break;
          }
          case "void": {
            if (this.unrepresentable === "throw") {
              throw new Error("Void cannot be represented in JSON Schema");
            }
            break;
          }
          case "never": {
            _json.not = {};
            break;
          }
          case "date": {
            if (this.unrepresentable === "throw") {
              throw new Error("Date cannot be represented in JSON Schema");
            }
            break;
          }
          case "array": {
            const json = _json;
            const { minimum, maximum } = schema._zod.bag;
            if (typeof minimum === "number")
              json.minItems = minimum;
            if (typeof maximum === "number")
              json.maxItems = maximum;
            json.type = "array";
            json.items = this.process(def.element, { ...params, path: [...params.path, "items"] });
            break;
          }
          case "object": {
            const json = _json;
            json.type = "object";
            json.properties = {};
            const shape = def.shape;
            for (const key in shape) {
              json.properties[key] = this.process(shape[key], {
                ...params,
                path: [...params.path, "properties", key]
              });
            }
            const allKeys = new Set(Object.keys(shape));
            const requiredKeys = new Set([...allKeys].filter((key) => {
              const v = def.shape[key]._zod;
              if (this.io === "input") {
                return v.optin === void 0;
              } else {
                return v.optout === void 0;
              }
            }));
            if (requiredKeys.size > 0) {
              json.required = Array.from(requiredKeys);
            }
            if (def.catchall?._zod.def.type === "never") {
              json.additionalProperties = false;
            } else if (!def.catchall) {
              if (this.io === "output")
                json.additionalProperties = false;
            } else if (def.catchall) {
              json.additionalProperties = this.process(def.catchall, {
                ...params,
                path: [...params.path, "additionalProperties"]
              });
            }
            break;
          }
          case "union": {
            const json = _json;
            json.anyOf = def.options.map((x, i) => this.process(x, {
              ...params,
              path: [...params.path, "anyOf", i]
            }));
            break;
          }
          case "intersection": {
            const json = _json;
            const a = this.process(def.left, {
              ...params,
              path: [...params.path, "allOf", 0]
            });
            const b = this.process(def.right, {
              ...params,
              path: [...params.path, "allOf", 1]
            });
            const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
            const allOf = [
              ...isSimpleIntersection(a) ? a.allOf : [a],
              ...isSimpleIntersection(b) ? b.allOf : [b]
            ];
            json.allOf = allOf;
            break;
          }
          case "tuple": {
            const json = _json;
            json.type = "array";
            const prefixItems = def.items.map((x, i) => this.process(x, { ...params, path: [...params.path, "prefixItems", i] }));
            if (this.target === "draft-2020-12") {
              json.prefixItems = prefixItems;
            } else {
              json.items = prefixItems;
            }
            if (def.rest) {
              const rest = this.process(def.rest, {
                ...params,
                path: [...params.path, "items"]
              });
              if (this.target === "draft-2020-12") {
                json.items = rest;
              } else {
                json.additionalItems = rest;
              }
            }
            if (def.rest) {
              json.items = this.process(def.rest, {
                ...params,
                path: [...params.path, "items"]
              });
            }
            const { minimum, maximum } = schema._zod.bag;
            if (typeof minimum === "number")
              json.minItems = minimum;
            if (typeof maximum === "number")
              json.maxItems = maximum;
            break;
          }
          case "record": {
            const json = _json;
            json.type = "object";
            json.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
            json.additionalProperties = this.process(def.valueType, {
              ...params,
              path: [...params.path, "additionalProperties"]
            });
            break;
          }
          case "map": {
            if (this.unrepresentable === "throw") {
              throw new Error("Map cannot be represented in JSON Schema");
            }
            break;
          }
          case "set": {
            if (this.unrepresentable === "throw") {
              throw new Error("Set cannot be represented in JSON Schema");
            }
            break;
          }
          case "enum": {
            const json = _json;
            const values = getEnumValues(def.entries);
            if (values.every((v) => typeof v === "number"))
              json.type = "number";
            if (values.every((v) => typeof v === "string"))
              json.type = "string";
            json.enum = values;
            break;
          }
          case "literal": {
            const json = _json;
            const vals = [];
            for (const val of def.values) {
              if (val === void 0) {
                if (this.unrepresentable === "throw") {
                  throw new Error("Literal `undefined` cannot be represented in JSON Schema");
                } else {
                }
              } else if (typeof val === "bigint") {
                if (this.unrepresentable === "throw") {
                  throw new Error("BigInt literals cannot be represented in JSON Schema");
                } else {
                  vals.push(Number(val));
                }
              } else {
                vals.push(val);
              }
            }
            if (vals.length === 0) {
            } else if (vals.length === 1) {
              const val = vals[0];
              json.type = val === null ? "null" : typeof val;
              json.const = val;
            } else {
              if (vals.every((v) => typeof v === "number"))
                json.type = "number";
              if (vals.every((v) => typeof v === "string"))
                json.type = "string";
              if (vals.every((v) => typeof v === "boolean"))
                json.type = "string";
              if (vals.every((v) => v === null))
                json.type = "null";
              json.enum = vals;
            }
            break;
          }
          case "file": {
            const json = _json;
            const file = {
              type: "string",
              format: "binary",
              contentEncoding: "binary"
            };
            const { minimum, maximum, mime } = schema._zod.bag;
            if (minimum !== void 0)
              file.minLength = minimum;
            if (maximum !== void 0)
              file.maxLength = maximum;
            if (mime) {
              if (mime.length === 1) {
                file.contentMediaType = mime[0];
                Object.assign(json, file);
              } else {
                json.anyOf = mime.map((m) => {
                  const mFile = { ...file, contentMediaType: m };
                  return mFile;
                });
              }
            } else {
              Object.assign(json, file);
            }
            break;
          }
          case "transform": {
            if (this.unrepresentable === "throw") {
              throw new Error("Transforms cannot be represented in JSON Schema");
            }
            break;
          }
          case "nullable": {
            const inner = this.process(def.innerType, params);
            _json.anyOf = [inner, { type: "null" }];
            break;
          }
          case "nonoptional": {
            this.process(def.innerType, params);
            result.ref = def.innerType;
            break;
          }
          case "success": {
            const json = _json;
            json.type = "boolean";
            break;
          }
          case "default": {
            this.process(def.innerType, params);
            result.ref = def.innerType;
            _json.default = JSON.parse(JSON.stringify(def.defaultValue));
            break;
          }
          case "prefault": {
            this.process(def.innerType, params);
            result.ref = def.innerType;
            if (this.io === "input")
              _json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
            break;
          }
          case "catch": {
            this.process(def.innerType, params);
            result.ref = def.innerType;
            let catchValue;
            try {
              catchValue = def.catchValue(void 0);
            } catch {
              throw new Error("Dynamic catch values are not supported in JSON Schema");
            }
            _json.default = catchValue;
            break;
          }
          case "nan": {
            if (this.unrepresentable === "throw") {
              throw new Error("NaN cannot be represented in JSON Schema");
            }
            break;
          }
          case "template_literal": {
            const json = _json;
            const pattern = schema._zod.pattern;
            if (!pattern)
              throw new Error("Pattern not found in template literal");
            json.type = "string";
            json.pattern = pattern.source;
            break;
          }
          case "pipe": {
            const innerType = this.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
            this.process(innerType, params);
            result.ref = innerType;
            break;
          }
          case "readonly": {
            this.process(def.innerType, params);
            result.ref = def.innerType;
            _json.readOnly = true;
            break;
          }
          // passthrough types
          case "promise": {
            this.process(def.innerType, params);
            result.ref = def.innerType;
            break;
          }
          case "optional": {
            this.process(def.innerType, params);
            result.ref = def.innerType;
            break;
          }
          case "lazy": {
            const innerType = schema._zod.innerType;
            this.process(innerType, params);
            result.ref = innerType;
            break;
          }
          case "custom": {
            if (this.unrepresentable === "throw") {
              throw new Error("Custom types cannot be represented in JSON Schema");
            }
            break;
          }
          default: {
            def;
          }
        }
      }
    }
    const meta = this.metadataRegistry.get(schema);
    if (meta)
      Object.assign(result.schema, meta);
    if (this.io === "input" && isTransforming(schema)) {
      delete result.schema.examples;
      delete result.schema.default;
    }
    if (this.io === "input" && result.schema._prefault)
      (_a = result.schema).default ?? (_a.default = result.schema._prefault);
    delete result.schema._prefault;
    const _result = this.seen.get(schema);
    return _result.schema;
  }
  emit(schema, _params) {
    const params = {
      cycles: _params?.cycles ?? "ref",
      reused: _params?.reused ?? "inline",
      // unrepresentable: _params?.unrepresentable ?? "throw",
      // uri: _params?.uri ?? ((id) => `${id}`),
      external: _params?.external ?? void 0
    };
    const root = this.seen.get(schema);
    if (!root)
      throw new Error("Unprocessed schema. This is a bug in Zod.");
    const makeURI = (entry) => {
      const defsSegment = this.target === "draft-2020-12" ? "$defs" : "definitions";
      if (params.external) {
        const externalId = params.external.registry.get(entry[0])?.id;
        const uriGenerator = params.external.uri ?? ((id2) => id2);
        if (externalId) {
          return { ref: uriGenerator(externalId) };
        }
        const id = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
        entry[1].defId = id;
        return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
      }
      if (entry[1] === root) {
        return { ref: "#" };
      }
      const uriPrefix = `#`;
      const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
      const defId = entry[1].schema.id ?? `__schema${this.counter++}`;
      return { defId, ref: defUriPrefix + defId };
    };
    const extractToDef = (entry) => {
      if (entry[1].schema.$ref) {
        return;
      }
      const seen = entry[1];
      const { ref, defId } = makeURI(entry);
      seen.def = { ...seen.schema };
      if (defId)
        seen.defId = defId;
      const schema2 = seen.schema;
      for (const key in schema2) {
        delete schema2[key];
      }
      schema2.$ref = ref;
    };
    if (params.cycles === "throw") {
      for (const entry of this.seen.entries()) {
        const seen = entry[1];
        if (seen.cycle) {
          throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>

Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
        }
      }
    }
    for (const entry of this.seen.entries()) {
      const seen = entry[1];
      if (schema === entry[0]) {
        extractToDef(entry);
        continue;
      }
      if (params.external) {
        const ext = params.external.registry.get(entry[0])?.id;
        if (schema !== entry[0] && ext) {
          extractToDef(entry);
          continue;
        }
      }
      const id = this.metadataRegistry.get(entry[0])?.id;
      if (id) {
        extractToDef(entry);
        continue;
      }
      if (seen.cycle) {
        extractToDef(entry);
        continue;
      }
      if (seen.count > 1) {
        if (params.reused === "ref") {
          extractToDef(entry);
          continue;
        }
      }
    }
    const flattenRef = (zodSchema, params2) => {
      const seen = this.seen.get(zodSchema);
      const schema2 = seen.def ?? seen.schema;
      const _cached = { ...schema2 };
      if (seen.ref === null) {
        return;
      }
      const ref = seen.ref;
      seen.ref = null;
      if (ref) {
        flattenRef(ref, params2);
        const refSchema = this.seen.get(ref).schema;
        if (refSchema.$ref && params2.target === "draft-7") {
          schema2.allOf = schema2.allOf ?? [];
          schema2.allOf.push(refSchema);
        } else {
          Object.assign(schema2, refSchema);
          Object.assign(schema2, _cached);
        }
      }
      if (!seen.isParent)
        this.override({
          zodSchema,
          jsonSchema: schema2,
          path: seen.path ?? []
        });
    };
    for (const entry of [...this.seen.entries()].reverse()) {
      flattenRef(entry[0], { target: this.target });
    }
    const result = {};
    if (this.target === "draft-2020-12") {
      result.$schema = "https://json-schema.org/draft/2020-12/schema";
    } else if (this.target === "draft-7") {
      result.$schema = "http://json-schema.org/draft-07/schema#";
    } else {
      console.warn(`Invalid target: ${this.target}`);
    }
    if (params.external?.uri) {
      const id = params.external.registry.get(schema)?.id;
      if (!id)
        throw new Error("Schema is missing an `id` property");
      result.$id = params.external.uri(id);
    }
    Object.assign(result, root.def);
    const defs = params.external?.defs ?? {};
    for (const entry of this.seen.entries()) {
      const seen = entry[1];
      if (seen.def && seen.defId) {
        defs[seen.defId] = seen.def;
      }
    }
    if (params.external) {
    } else {
      if (Object.keys(defs).length > 0) {
        if (this.target === "draft-2020-12") {
          result.$defs = defs;
        } else {
          result.definitions = defs;
        }
      }
    }
    try {
      return JSON.parse(JSON.stringify(result));
    } catch (_err) {
      throw new Error("Error converting schema to JSON.");
    }
  }
};
function toJSONSchema(input, _params) {
  if (input instanceof $ZodRegistry) {
    const gen2 = new JSONSchemaGenerator(_params);
    const defs = {};
    for (const entry of input._idmap.entries()) {
      const [_, schema] = entry;
      gen2.process(schema);
    }
    const schemas = {};
    const external = {
      registry: input,
      uri: _params?.uri,
      defs
    };
    for (const entry of input._idmap.entries()) {
      const [key, schema] = entry;
      schemas[key] = gen2.emit(schema, {
        ..._params,
        external
      });
    }
    if (Object.keys(defs).length > 0) {
      const defsSegment = gen2.target === "draft-2020-12" ? "$defs" : "definitions";
      schemas.__shared = {
        [defsSegment]: defs
      };
    }
    return { schemas };
  }
  const gen = new JSONSchemaGenerator(_params);
  gen.process(input);
  return gen.emit(input, _params);
}
function isTransforming(_schema, _ctx) {
  const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
  if (ctx.seen.has(_schema))
    return false;
  ctx.seen.add(_schema);
  const schema = _schema;
  const def = schema._zod.def;
  switch (def.type) {
    case "string":
    case "number":
    case "bigint":
    case "boolean":
    case "date":
    case "symbol":
    case "undefined":
    case "null":
    case "any":
    case "unknown":
    case "never":
    case "void":
    case "literal":
    case "enum":
    case "nan":
    case "file":
    case "template_literal":
      return false;
    case "array": {
      return isTransforming(def.element, ctx);
    }
    case "object": {
      for (const key in def.shape) {
        if (isTransforming(def.shape[key], ctx))
          return true;
      }
      return false;
    }
    case "union": {
      for (const option of def.options) {
        if (isTransforming(option, ctx))
          return true;
      }
      return false;
    }
    case "intersection": {
      return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
    }
    case "tuple": {
      for (const item of def.items) {
        if (isTransforming(item, ctx))
          return true;
      }
      if (def.rest && isTransforming(def.rest, ctx))
        return true;
      return false;
    }
    case "record": {
      return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
    }
    case "map": {
      return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
    }
    case "set": {
      return isTransforming(def.valueType, ctx);
    }
    // inner types
    case "promise":
    case "optional":
    case "nonoptional":
    case "nullable":
    case "readonly":
      return isTransforming(def.innerType, ctx);
    case "lazy":
      return isTransforming(def.getter(), ctx);
    case "default": {
      return isTransforming(def.innerType, ctx);
    }
    case "prefault": {
      return isTransforming(def.innerType, ctx);
    }
    case "custom": {
      return false;
    }
    case "transform": {
      return true;
    }
    case "pipe": {
      return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
    }
    case "success": {
      return false;
    }
    case "catch": {
      return false;
    }
    default:
      def;
  }
  throw new Error(`Unknown schema type: ${def.type}`);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/classic/iso.js
var iso_exports = {};
__export(iso_exports, {
  ZodISODate: () => ZodISODate,
  ZodISODateTime: () => ZodISODateTime,
  ZodISODuration: () => ZodISODuration,
  ZodISOTime: () => ZodISOTime,
  date: () => date2,
  datetime: () => datetime2,
  duration: () => duration2,
  time: () => time2
});
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
  $ZodISODateTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function datetime2(params) {
  return _isoDateTime(ZodISODateTime, params);
}
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
  $ZodISODate.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function date2(params) {
  return _isoDate(ZodISODate, params);
}
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
  $ZodISOTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function time2(params) {
  return _isoTime(ZodISOTime, params);
}
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
  $ZodISODuration.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function duration2(params) {
  return _isoDuration(ZodISODuration, params);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/classic/errors.js
var initializer2 = (inst, issues) => {
  $ZodError.init(inst, issues);
  inst.name = "ZodError";
  Object.defineProperties(inst, {
    format: {
      value: (mapper) => formatError(inst, mapper)
      // enumerable: false,
    },
    flatten: {
      value: (mapper) => flattenError(inst, mapper)
      // enumerable: false,
    },
    addIssue: {
      value: (issue2) => inst.issues.push(issue2)
      // enumerable: false,
    },
    addIssues: {
      value: (issues2) => inst.issues.push(...issues2)
      // enumerable: false,
    },
    isEmpty: {
      get() {
        return inst.issues.length === 0;
      }
      // enumerable: false,
    }
  });
};
var ZodError = $constructor("ZodError", initializer2);
var ZodRealError = $constructor("ZodError", initializer2, {
  Parent: Error
});

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/classic/parse.js
var parse2 = /* @__PURE__ */ _parse(ZodRealError);
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/classic/schemas.js
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
  $ZodType.init(inst, def);
  inst.def = def;
  Object.defineProperty(inst, "_def", { value: def });
  inst.check = (...checks) => {
    return inst.clone(
      {
        ...def,
        checks: [
          ...def.checks ?? [],
          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
        ]
      }
      // { parent: true }
    );
  };
  inst.clone = (def2, params) => clone(inst, def2, params);
  inst.brand = () => inst;
  inst.register = ((reg, meta) => {
    reg.add(inst, meta);
    return inst;
  });
  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
  inst.safeParse = (data, params) => safeParse2(inst, data, params);
  inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
  inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
  inst.spa = inst.safeParseAsync;
  inst.refine = (check2, params) => inst.check(refine(check2, params));
  inst.superRefine = (refinement) => inst.check(superRefine(refinement));
  inst.overwrite = (fn) => inst.check(_overwrite(fn));
  inst.optional = () => optional(inst);
  inst.nullable = () => nullable(inst);
  inst.nullish = () => optional(nullable(inst));
  inst.nonoptional = (params) => nonoptional(inst, params);
  inst.array = () => array(inst);
  inst.or = (arg) => union([inst, arg]);
  inst.and = (arg) => intersection(inst, arg);
  inst.transform = (tx) => pipe(inst, transform(tx));
  inst.default = (def2) => _default(inst, def2);
  inst.prefault = (def2) => prefault(inst, def2);
  inst.catch = (params) => _catch(inst, params);
  inst.pipe = (target) => pipe(inst, target);
  inst.readonly = () => readonly(inst);
  inst.describe = (description) => {
    const cl = inst.clone();
    globalRegistry.add(cl, { description });
    return cl;
  };
  Object.defineProperty(inst, "description", {
    get() {
      return globalRegistry.get(inst)?.description;
    },
    configurable: true
  });
  inst.meta = (...args) => {
    if (args.length === 0) {
      return globalRegistry.get(inst);
    }
    const cl = inst.clone();
    globalRegistry.add(cl, args[0]);
    return cl;
  };
  inst.isOptional = () => inst.safeParse(void 0).success;
  inst.isNullable = () => inst.safeParse(null).success;
  return inst;
});
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  ZodType.init(inst, def);
  const bag = inst._zod.bag;
  inst.format = bag.format ?? null;
  inst.minLength = bag.minimum ?? null;
  inst.maxLength = bag.maximum ?? null;
  inst.regex = (...args) => inst.check(_regex(...args));
  inst.includes = (...args) => inst.check(_includes(...args));
  inst.startsWith = (...args) => inst.check(_startsWith(...args));
  inst.endsWith = (...args) => inst.check(_endsWith(...args));
  inst.min = (...args) => inst.check(_minLength(...args));
  inst.max = (...args) => inst.check(_maxLength(...args));
  inst.length = (...args) => inst.check(_length(...args));
  inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
  inst.lowercase = (params) => inst.check(_lowercase(params));
  inst.uppercase = (params) => inst.check(_uppercase(params));
  inst.trim = () => inst.check(_trim());
  inst.normalize = (...args) => inst.check(_normalize(...args));
  inst.toLowerCase = () => inst.check(_toLowerCase());
  inst.toUpperCase = () => inst.check(_toUpperCase());
});
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  _ZodString.init(inst, def);
  inst.email = (params) => inst.check(_email(ZodEmail, params));
  inst.url = (params) => inst.check(_url(ZodURL, params));
  inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
  inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
  inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
  inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
  inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
  inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
  inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
  inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
  inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
  inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
  inst.xid = (params) => inst.check(_xid(ZodXID, params));
  inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
  inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
  inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
  inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
  inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
  inst.e164 = (params) => inst.check(_e164(ZodE164, params));
  inst.datetime = (params) => inst.check(datetime2(params));
  inst.date = (params) => inst.check(date2(params));
  inst.time = (params) => inst.check(time2(params));
  inst.duration = (params) => inst.check(duration2(params));
});
function string2(params) {
  return _string(ZodString, params);
}
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  _ZodString.init(inst, def);
});
var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
  $ZodEmail.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
  $ZodGUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
  $ZodUUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
  $ZodURL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
  $ZodEmoji.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
  $ZodNanoID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
  $ZodCUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
  $ZodCUID2.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
  $ZodULID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
  $ZodXID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
  $ZodKSUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
  $ZodIPv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
  $ZodIPv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
  $ZodCIDRv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
  $ZodCIDRv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
  $ZodBase64.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
  $ZodBase64URL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
  $ZodE164.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
  $ZodJWT.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
  $ZodNumber.init(inst, def);
  ZodType.init(inst, def);
  inst.gt = (value, params) => inst.check(_gt(value, params));
  inst.gte = (value, params) => inst.check(_gte(value, params));
  inst.min = (value, params) => inst.check(_gte(value, params));
  inst.lt = (value, params) => inst.check(_lt(value, params));
  inst.lte = (value, params) => inst.check(_lte(value, params));
  inst.max = (value, params) => inst.check(_lte(value, params));
  inst.int = (params) => inst.check(int(params));
  inst.safe = (params) => inst.check(int(params));
  inst.positive = (params) => inst.check(_gt(0, params));
  inst.nonnegative = (params) => inst.check(_gte(0, params));
  inst.negative = (params) => inst.check(_lt(0, params));
  inst.nonpositive = (params) => inst.check(_lte(0, params));
  inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
  inst.step = (value, params) => inst.check(_multipleOf(value, params));
  inst.finite = () => inst;
  const bag = inst._zod.bag;
  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
  inst.isFinite = true;
  inst.format = bag.format ?? null;
});
function number2(params) {
  return _number(ZodNumber, params);
}
var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
  $ZodNumberFormat.init(inst, def);
  ZodNumber.init(inst, def);
});
function int(params) {
  return _int(ZodNumberFormat, params);
}
var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
  $ZodBoolean.init(inst, def);
  ZodType.init(inst, def);
});
function boolean2(params) {
  return _boolean(ZodBoolean, params);
}
var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
  $ZodNull.init(inst, def);
  ZodType.init(inst, def);
});
function _null3(params) {
  return _null2(ZodNull, params);
}
var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
  $ZodUnknown.init(inst, def);
  ZodType.init(inst, def);
});
function unknown() {
  return _unknown(ZodUnknown);
}
var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
  $ZodNever.init(inst, def);
  ZodType.init(inst, def);
});
function never(params) {
  return _never(ZodNever, params);
}
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
  $ZodArray.init(inst, def);
  ZodType.init(inst, def);
  inst.element = def.element;
  inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
  inst.nonempty = (params) => inst.check(_minLength(1, params));
  inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
  inst.length = (len, params) => inst.check(_length(len, params));
  inst.unwrap = () => inst.element;
});
function array(element, params) {
  return _array(ZodArray, element, params);
}
var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
  $ZodObject.init(inst, def);
  ZodType.init(inst, def);
  util_exports.defineLazy(inst, "shape", () => def.shape);
  inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
  inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
  inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
  inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
  inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
  inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
  inst.extend = (incoming) => {
    return util_exports.extend(inst, incoming);
  };
  inst.merge = (other) => util_exports.merge(inst, other);
  inst.pick = (mask) => util_exports.pick(inst, mask);
  inst.omit = (mask) => util_exports.omit(inst, mask);
  inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
  inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
});
function object(shape, params) {
  const def = {
    type: "object",
    get shape() {
      util_exports.assignProp(this, "shape", { ...shape });
      return this.shape;
    },
    ...util_exports.normalizeParams(params)
  };
  return new ZodObject(def);
}
function looseObject(shape, params) {
  return new ZodObject({
    type: "object",
    get shape() {
      util_exports.assignProp(this, "shape", { ...shape });
      return this.shape;
    },
    catchall: unknown(),
    ...util_exports.normalizeParams(params)
  });
}
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
  $ZodUnion.init(inst, def);
  ZodType.init(inst, def);
  inst.options = def.options;
});
function union(options, params) {
  return new ZodUnion({
    type: "union",
    options,
    ...util_exports.normalizeParams(params)
  });
}
var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
  ZodUnion.init(inst, def);
  $ZodDiscriminatedUnion.init(inst, def);
});
function discriminatedUnion(discriminator, options, params) {
  return new ZodDiscriminatedUnion({
    type: "union",
    options,
    discriminator,
    ...util_exports.normalizeParams(params)
  });
}
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
  $ZodIntersection.init(inst, def);
  ZodType.init(inst, def);
});
function intersection(left, right) {
  return new ZodIntersection({
    type: "intersection",
    left,
    right
  });
}
var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
  $ZodRecord.init(inst, def);
  ZodType.init(inst, def);
  inst.keyType = def.keyType;
  inst.valueType = def.valueType;
});
function record(keyType, valueType, params) {
  return new ZodRecord({
    type: "record",
    keyType,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
  $ZodEnum.init(inst, def);
  ZodType.init(inst, def);
  inst.enum = def.entries;
  inst.options = Object.values(def.entries);
  const keys = new Set(Object.keys(def.entries));
  inst.extract = (values, params) => {
    const newEntries = {};
    for (const value of values) {
      if (keys.has(value)) {
        newEntries[value] = def.entries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
  inst.exclude = (values, params) => {
    const newEntries = { ...def.entries };
    for (const value of values) {
      if (keys.has(value)) {
        delete newEntries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
});
function _enum(values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new ZodEnum({
    type: "enum",
    entries,
    ...util_exports.normalizeParams(params)
  });
}
var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
  $ZodLiteral.init(inst, def);
  ZodType.init(inst, def);
  inst.values = new Set(def.values);
  Object.defineProperty(inst, "value", {
    get() {
      if (def.values.length > 1) {
        throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
      }
      return def.values[0];
    }
  });
});
function literal(value, params) {
  return new ZodLiteral({
    type: "literal",
    values: Array.isArray(value) ? value : [value],
    ...util_exports.normalizeParams(params)
  });
}
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
  $ZodTransform.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(util_exports.issue(issue2, payload.value, def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = inst);
        _issue.continue ?? (_issue.continue = true);
        payload.issues.push(util_exports.issue(_issue));
      }
    };
    const output = def.transform(payload.value, payload);
    if (output instanceof Promise) {
      return output.then((output2) => {
        payload.value = output2;
        return payload;
      });
    }
    payload.value = output;
    return payload;
  };
});
function transform(fn) {
  return new ZodTransform({
    type: "transform",
    transform: fn
  });
}
var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
  $ZodOptional.init(inst, def);
  ZodType.init(inst, def);
  inst.unwrap = () => inst._zod.def.innerType;
});
function optional(innerType) {
  return new ZodOptional({
    type: "optional",
    innerType
  });
}
var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
  $ZodNullable.init(inst, def);
  ZodType.init(inst, def);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nullable(innerType) {
  return new ZodNullable({
    type: "nullable",
    innerType
  });
}
var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
  $ZodDefault.init(inst, def);
  ZodType.init(inst, def);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeDefault = inst.unwrap;
});
function _default(innerType, defaultValue) {
  return new ZodDefault({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : defaultValue;
    }
  });
}
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
  $ZodPrefault.init(inst, def);
  ZodType.init(inst, def);
  inst.unwrap = () => inst._zod.def.innerType;
});
function prefault(innerType, defaultValue) {
  return new ZodPrefault({
    type: "prefault",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : defaultValue;
    }
  });
}
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
  $ZodNonOptional.init(inst, def);
  ZodType.init(inst, def);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nonoptional(innerType, params) {
  return new ZodNonOptional({
    type: "nonoptional",
    innerType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
  $ZodCatch.init(inst, def);
  ZodType.init(inst, def);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeCatch = inst.unwrap;
});
function _catch(innerType, catchValue) {
  return new ZodCatch({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
  $ZodPipe.init(inst, def);
  ZodType.init(inst, def);
  inst.in = def.in;
  inst.out = def.out;
});
function pipe(in_, out) {
  return new ZodPipe({
    type: "pipe",
    in: in_,
    out
    // ...util.normalizeParams(params),
  });
}
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
  $ZodReadonly.init(inst, def);
  ZodType.init(inst, def);
});
function readonly(innerType) {
  return new ZodReadonly({
    type: "readonly",
    innerType
  });
}
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
  $ZodCustom.init(inst, def);
  ZodType.init(inst, def);
});
function check(fn) {
  const ch = new $ZodCheck({
    check: "custom"
    // ...util.normalizeParams(params),
  });
  ch._zod.check = fn;
  return ch;
}
function custom(fn, _params) {
  return _custom(ZodCustom, fn ?? (() => true), _params);
}
function refine(fn, _params = {}) {
  return _refine(ZodCustom, fn, _params);
}
function superRefine(fn) {
  const ch = check((payload) => {
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(util_exports.issue(issue2, payload.value, ch._zod.def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = ch);
        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
        payload.issues.push(util_exports.issue(_issue));
      }
    };
    return fn(payload.value, payload);
  });
  return ch;
}
function preprocess(fn, schema) {
  return pipe(transform(fn), schema);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/classic/external.js
config(en_default());

// node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
var LATEST_PROTOCOL_VERSION = "2025-11-25";
var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
var JSONRPC_VERSION = "2.0";
var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
var ProgressTokenSchema = union([string2(), number2().int()]);
var CursorSchema = string2();
var TaskCreationParamsSchema = looseObject({
  /**
   * Time in milliseconds to keep task results available after completion.
   * If null, the task has unlimited lifetime until manually cleaned up.
   */
  ttl: union([number2(), _null3()]).optional(),
  /**
   * Time in milliseconds to wait between task status requests.
   */
  pollInterval: number2().optional()
});
var TaskMetadataSchema = object({
  ttl: number2().optional()
});
var RelatedTaskMetadataSchema = object({
  taskId: string2()
});
var RequestMetaSchema = looseObject({
  /**
   * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
   */
  progressToken: ProgressTokenSchema.optional(),
  /**
   * If specified, this request is related to the provided task.
   */
  [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
});
var BaseRequestParamsSchema = object({
  /**
   * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
   */
  _meta: RequestMetaSchema.optional()
});
var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({
  /**
   * If specified, the caller is requesting task-augmented execution for this request.
   * The request will return a CreateTaskResult immediately, and the actual result can be
   * retrieved later via tasks/result.
   *
   * Task augmentation is subject to capability negotiation - receivers MUST declare support
   * for task augmentation of specific request types in their capabilities.
   */
  task: TaskMetadataSchema.optional()
});
var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
var RequestSchema = object({
  method: string2(),
  params: BaseRequestParamsSchema.loose().optional()
});
var NotificationsParamsSchema = object({
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: RequestMetaSchema.optional()
});
var NotificationSchema = object({
  method: string2(),
  params: NotificationsParamsSchema.loose().optional()
});
var ResultSchema = looseObject({
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: RequestMetaSchema.optional()
});
var RequestIdSchema = union([string2(), number2().int()]);
var JSONRPCRequestSchema = object({
  jsonrpc: literal(JSONRPC_VERSION),
  id: RequestIdSchema,
  ...RequestSchema.shape
}).strict();
var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
var JSONRPCNotificationSchema = object({
  jsonrpc: literal(JSONRPC_VERSION),
  ...NotificationSchema.shape
}).strict();
var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
var JSONRPCResultResponseSchema = object({
  jsonrpc: literal(JSONRPC_VERSION),
  id: RequestIdSchema,
  result: ResultSchema
}).strict();
var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
var ErrorCode;
(function(ErrorCode2) {
  ErrorCode2[ErrorCode2["ConnectionClosed"] = -32e3] = "ConnectionClosed";
  ErrorCode2[ErrorCode2["RequestTimeout"] = -32001] = "RequestTimeout";
  ErrorCode2[ErrorCode2["ParseError"] = -32700] = "ParseError";
  ErrorCode2[ErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
  ErrorCode2[ErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
  ErrorCode2[ErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
  ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError";
  ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
})(ErrorCode || (ErrorCode = {}));
var JSONRPCErrorResponseSchema = object({
  jsonrpc: literal(JSONRPC_VERSION),
  id: RequestIdSchema.optional(),
  error: object({
    /**
     * The error type that occurred.
     */
    code: number2().int(),
    /**
     * A short description of the error. The message SHOULD be limited to a concise single sentence.
     */
    message: string2(),
    /**
     * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
     */
    data: unknown().optional()
  })
}).strict();
var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
var JSONRPCMessageSchema = union([
  JSONRPCRequestSchema,
  JSONRPCNotificationSchema,
  JSONRPCResultResponseSchema,
  JSONRPCErrorResponseSchema
]);
var JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
var EmptyResultSchema = ResultSchema.strict();
var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
  /**
   * The ID of the request to cancel.
   *
   * This MUST correspond to the ID of a request previously issued in the same direction.
   */
  requestId: RequestIdSchema.optional(),
  /**
   * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
   */
  reason: string2().optional()
});
var CancelledNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/cancelled"),
  params: CancelledNotificationParamsSchema
});
var IconSchema = object({
  /**
   * URL or data URI for the icon.
   */
  src: string2(),
  /**
   * Optional MIME type for the icon.
   */
  mimeType: string2().optional(),
  /**
   * Optional array of strings that specify sizes at which the icon can be used.
   * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
   *
   * If not provided, the client should assume that the icon can be used at any size.
   */
  sizes: array(string2()).optional(),
  /**
   * Optional specifier for the theme this icon is designed for. `light` indicates
   * the icon is designed to be used with a light background, and `dark` indicates
   * the icon is designed to be used with a dark background.
   *
   * If not provided, the client should assume the icon can be used with any theme.
   */
  theme: _enum(["light", "dark"]).optional()
});
var IconsSchema = object({
  /**
   * Optional set of sized icons that the client can display in a user interface.
   *
   * Clients that support rendering icons MUST support at least the following MIME types:
   * - `image/png` - PNG images (safe, universal compatibility)
   * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
   *
   * Clients that support rendering icons SHOULD also support:
   * - `image/svg+xml` - SVG images (scalable but requires security precautions)
   * - `image/webp` - WebP images (modern, efficient format)
   */
  icons: array(IconSchema).optional()
});
var BaseMetadataSchema = object({
  /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
  name: string2(),
  /**
   * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
   * even by those unfamiliar with domain-specific terminology.
   *
   * If not provided, the name should be used for display (except for Tool,
   * where `annotations.title` should be given precedence over using `name`,
   * if present).
   */
  title: string2().optional()
});
var ImplementationSchema = BaseMetadataSchema.extend({
  ...BaseMetadataSchema.shape,
  ...IconsSchema.shape,
  version: string2(),
  /**
   * An optional URL of the website for this implementation.
   */
  websiteUrl: string2().optional(),
  /**
   * An optional human-readable description of what this implementation does.
   *
   * This can be used by clients or servers to provide context about their purpose
   * and capabilities. For example, a server might describe the types of resources
   * or tools it provides, while a client might describe its intended use case.
   */
  description: string2().optional()
});
var FormElicitationCapabilitySchema = intersection(object({
  applyDefaults: boolean2().optional()
}), record(string2(), unknown()));
var ElicitationCapabilitySchema = preprocess((value) => {
  if (value && typeof value === "object" && !Array.isArray(value)) {
    if (Object.keys(value).length === 0) {
      return { form: {} };
    }
  }
  return value;
}, intersection(object({
  form: FormElicitationCapabilitySchema.optional(),
  url: AssertObjectSchema.optional()
}), record(string2(), unknown()).optional()));
var ClientTasksCapabilitySchema = looseObject({
  /**
   * Present if the client supports listing tasks.
   */
  list: AssertObjectSchema.optional(),
  /**
   * Present if the client supports cancelling tasks.
   */
  cancel: AssertObjectSchema.optional(),
  /**
   * Capabilities for task creation on specific request types.
   */
  requests: looseObject({
    /**
     * Task support for sampling requests.
     */
    sampling: looseObject({
      createMessage: AssertObjectSchema.optional()
    }).optional(),
    /**
     * Task support for elicitation requests.
     */
    elicitation: looseObject({
      create: AssertObjectSchema.optional()
    }).optional()
  }).optional()
});
var ServerTasksCapabilitySchema = looseObject({
  /**
   * Present if the server supports listing tasks.
   */
  list: AssertObjectSchema.optional(),
  /**
   * Present if the server supports cancelling tasks.
   */
  cancel: AssertObjectSchema.optional(),
  /**
   * Capabilities for task creation on specific request types.
   */
  requests: looseObject({
    /**
     * Task support for tool requests.
     */
    tools: looseObject({
      call: AssertObjectSchema.optional()
    }).optional()
  }).optional()
});
var ClientCapabilitiesSchema = object({
  /**
   * Experimental, non-standard capabilities that the client supports.
   */
  experimental: record(string2(), AssertObjectSchema).optional(),
  /**
   * Present if the client supports sampling from an LLM.
   */
  sampling: object({
    /**
     * Present if the client supports context inclusion via includeContext parameter.
     * If not declared, servers SHOULD only use `includeContext: "none"` (or omit it).
     */
    context: AssertObjectSchema.optional(),
    /**
     * Present if the client supports tool use via tools and toolChoice parameters.
     */
    tools: AssertObjectSchema.optional()
  }).optional(),
  /**
   * Present if the client supports eliciting user input.
   */
  elicitation: ElicitationCapabilitySchema.optional(),
  /**
   * Present if the client supports listing roots.
   */
  roots: object({
    /**
     * Whether the client supports issuing notifications for changes to the roots list.
     */
    listChanged: boolean2().optional()
  }).optional(),
  /**
   * Present if the client supports task creation.
   */
  tasks: ClientTasksCapabilitySchema.optional()
});
var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
  /**
   * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
   */
  protocolVersion: string2(),
  capabilities: ClientCapabilitiesSchema,
  clientInfo: ImplementationSchema
});
var InitializeRequestSchema = RequestSchema.extend({
  method: literal("initialize"),
  params: InitializeRequestParamsSchema
});
var ServerCapabilitiesSchema = object({
  /**
   * Experimental, non-standard capabilities that the server supports.
   */
  experimental: record(string2(), AssertObjectSchema).optional(),
  /**
   * Present if the server supports sending log messages to the client.
   */
  logging: AssertObjectSchema.optional(),
  /**
   * Present if the server supports sending completions to the client.
   */
  completions: AssertObjectSchema.optional(),
  /**
   * Present if the server offers any prompt templates.
   */
  prompts: object({
    /**
     * Whether this server supports issuing notifications for changes to the prompt list.
     */
    listChanged: boolean2().optional()
  }).optional(),
  /**
   * Present if the server offers any resources to read.
   */
  resources: object({
    /**
     * Whether this server supports clients subscribing to resource updates.
     */
    subscribe: boolean2().optional(),
    /**
     * Whether this server supports issuing notifications for changes to the resource list.
     */
    listChanged: boolean2().optional()
  }).optional(),
  /**
   * Present if the server offers any tools to call.
   */
  tools: object({
    /**
     * Whether this server supports issuing notifications for changes to the tool list.
     */
    listChanged: boolean2().optional()
  }).optional(),
  /**
   * Present if the server supports task creation.
   */
  tasks: ServerTasksCapabilitySchema.optional()
});
var InitializeResultSchema = ResultSchema.extend({
  /**
   * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.
   */
  protocolVersion: string2(),
  capabilities: ServerCapabilitiesSchema,
  serverInfo: ImplementationSchema,
  /**
   * Instructions describing how to use the server and its features.
   *
   * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
   */
  instructions: string2().optional()
});
var InitializedNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/initialized"),
  params: NotificationsParamsSchema.optional()
});
var PingRequestSchema = RequestSchema.extend({
  method: literal("ping"),
  params: BaseRequestParamsSchema.optional()
});
var ProgressSchema = object({
  /**
   * The progress thus far. This should increase every time progress is made, even if the total is unknown.
   */
  progress: number2(),
  /**
   * Total number of items to process (or total progress required), if known.
   */
  total: optional(number2()),
  /**
   * An optional message describing the current progress.
   */
  message: optional(string2())
});
var ProgressNotificationParamsSchema = object({
  ...NotificationsParamsSchema.shape,
  ...ProgressSchema.shape,
  /**
   * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
   */
  progressToken: ProgressTokenSchema
});
var ProgressNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/progress"),
  params: ProgressNotificationParamsSchema
});
var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({
  /**
   * An opaque token representing the current pagination position.
   * If provided, the server should return results starting after this cursor.
   */
  cursor: CursorSchema.optional()
});
var PaginatedRequestSchema = RequestSchema.extend({
  params: PaginatedRequestParamsSchema.optional()
});
var PaginatedResultSchema = ResultSchema.extend({
  /**
   * An opaque token representing the pagination position after the last returned result.
   * If present, there may be more results available.
   */
  nextCursor: CursorSchema.optional()
});
var TaskStatusSchema = _enum(["working", "input_required", "completed", "failed", "cancelled"]);
var TaskSchema = object({
  taskId: string2(),
  status: TaskStatusSchema,
  /**
   * Time in milliseconds to keep task results available after completion.
   * If null, the task has unlimited lifetime until manually cleaned up.
   */
  ttl: union([number2(), _null3()]),
  /**
   * ISO 8601 timestamp when the task was created.
   */
  createdAt: string2(),
  /**
   * ISO 8601 timestamp when the task was last updated.
   */
  lastUpdatedAt: string2(),
  pollInterval: optional(number2()),
  /**
   * Optional diagnostic message for failed tasks or other status information.
   */
  statusMessage: optional(string2())
});
var CreateTaskResultSchema = ResultSchema.extend({
  task: TaskSchema
});
var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
var TaskStatusNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/tasks/status"),
  params: TaskStatusNotificationParamsSchema
});
var GetTaskRequestSchema = RequestSchema.extend({
  method: literal("tasks/get"),
  params: BaseRequestParamsSchema.extend({
    taskId: string2()
  })
});
var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
var GetTaskPayloadRequestSchema = RequestSchema.extend({
  method: literal("tasks/result"),
  params: BaseRequestParamsSchema.extend({
    taskId: string2()
  })
});
var GetTaskPayloadResultSchema = ResultSchema.loose();
var ListTasksRequestSchema = PaginatedRequestSchema.extend({
  method: literal("tasks/list")
});
var ListTasksResultSchema = PaginatedResultSchema.extend({
  tasks: array(TaskSchema)
});
var CancelTaskRequestSchema = RequestSchema.extend({
  method: literal("tasks/cancel"),
  params: BaseRequestParamsSchema.extend({
    taskId: string2()
  })
});
var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
var ResourceContentsSchema = object({
  /**
   * The URI of this resource.
   */
  uri: string2(),
  /**
   * The MIME type of this resource, if known.
   */
  mimeType: optional(string2()),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var TextResourceContentsSchema = ResourceContentsSchema.extend({
  /**
   * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
   */
  text: string2()
});
var Base64Schema = string2().refine((val) => {
  try {
    atob(val);
    return true;
  } catch {
    return false;
  }
}, { message: "Invalid Base64 string" });
var BlobResourceContentsSchema = ResourceContentsSchema.extend({
  /**
   * A base64-encoded string representing the binary data of the item.
   */
  blob: Base64Schema
});
var RoleSchema = _enum(["user", "assistant"]);
var AnnotationsSchema = object({
  /**
   * Intended audience(s) for the resource.
   */
  audience: array(RoleSchema).optional(),
  /**
   * Importance hint for the resource, from 0 (least) to 1 (most).
   */
  priority: number2().min(0).max(1).optional(),
  /**
   * ISO 8601 timestamp for the most recent modification.
   */
  lastModified: iso_exports.datetime({ offset: true }).optional()
});
var ResourceSchema = object({
  ...BaseMetadataSchema.shape,
  ...IconsSchema.shape,
  /**
   * The URI of this resource.
   */
  uri: string2(),
  /**
   * A description of what this resource represents.
   *
   * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
   */
  description: optional(string2()),
  /**
   * The MIME type of this resource, if known.
   */
  mimeType: optional(string2()),
  /**
   * Optional annotations for the client.
   */
  annotations: AnnotationsSchema.optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: optional(looseObject({}))
});
var ResourceTemplateSchema = object({
  ...BaseMetadataSchema.shape,
  ...IconsSchema.shape,
  /**
   * A URI template (according to RFC 6570) that can be used to construct resource URIs.
   */
  uriTemplate: string2(),
  /**
   * A description of what this template is for.
   *
   * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
   */
  description: optional(string2()),
  /**
   * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
   */
  mimeType: optional(string2()),
  /**
   * Optional annotations for the client.
   */
  annotations: AnnotationsSchema.optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: optional(looseObject({}))
});
var ListResourcesRequestSchema = PaginatedRequestSchema.extend({
  method: literal("resources/list")
});
var ListResourcesResultSchema = PaginatedResultSchema.extend({
  resources: array(ResourceSchema)
});
var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({
  method: literal("resources/templates/list")
});
var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({
  resourceTemplates: array(ResourceTemplateSchema)
});
var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
  /**
   * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
   *
   * @format uri
   */
  uri: string2()
});
var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
var ReadResourceRequestSchema = RequestSchema.extend({
  method: literal("resources/read"),
  params: ReadResourceRequestParamsSchema
});
var ReadResourceResultSchema = ResultSchema.extend({
  contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema]))
});
var ResourceListChangedNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/resources/list_changed"),
  params: NotificationsParamsSchema.optional()
});
var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
var SubscribeRequestSchema = RequestSchema.extend({
  method: literal("resources/subscribe"),
  params: SubscribeRequestParamsSchema
});
var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
var UnsubscribeRequestSchema = RequestSchema.extend({
  method: literal("resources/unsubscribe"),
  params: UnsubscribeRequestParamsSchema
});
var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({
  /**
   * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
   */
  uri: string2()
});
var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/resources/updated"),
  params: ResourceUpdatedNotificationParamsSchema
});
var PromptArgumentSchema = object({
  /**
   * The name of the argument.
   */
  name: string2(),
  /**
   * A human-readable description of the argument.
   */
  description: optional(string2()),
  /**
   * Whether this argument must be provided.
   */
  required: optional(boolean2())
});
var PromptSchema = object({
  ...BaseMetadataSchema.shape,
  ...IconsSchema.shape,
  /**
   * An optional description of what this prompt provides
   */
  description: optional(string2()),
  /**
   * A list of arguments to use for templating the prompt.
   */
  arguments: optional(array(PromptArgumentSchema)),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: optional(looseObject({}))
});
var ListPromptsRequestSchema = PaginatedRequestSchema.extend({
  method: literal("prompts/list")
});
var ListPromptsResultSchema = PaginatedResultSchema.extend({
  prompts: array(PromptSchema)
});
var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
  /**
   * The name of the prompt or prompt template.
   */
  name: string2(),
  /**
   * Arguments to use for templating the prompt.
   */
  arguments: record(string2(), string2()).optional()
});
var GetPromptRequestSchema = RequestSchema.extend({
  method: literal("prompts/get"),
  params: GetPromptRequestParamsSchema
});
var TextContentSchema = object({
  type: literal("text"),
  /**
   * The text content of the message.
   */
  text: string2(),
  /**
   * Optional annotations for the client.
   */
  annotations: AnnotationsSchema.optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var ImageContentSchema = object({
  type: literal("image"),
  /**
   * The base64-encoded image data.
   */
  data: Base64Schema,
  /**
   * The MIME type of the image. Different providers may support different image types.
   */
  mimeType: string2(),
  /**
   * Optional annotations for the client.
   */
  annotations: AnnotationsSchema.optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var AudioContentSchema = object({
  type: literal("audio"),
  /**
   * The base64-encoded audio data.
   */
  data: Base64Schema,
  /**
   * The MIME type of the audio. Different providers may support different audio types.
   */
  mimeType: string2(),
  /**
   * Optional annotations for the client.
   */
  annotations: AnnotationsSchema.optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var ToolUseContentSchema = object({
  type: literal("tool_use"),
  /**
   * The name of the tool to invoke.
   * Must match a tool name from the request's tools array.
   */
  name: string2(),
  /**
   * Unique identifier for this tool call.
   * Used to correlate with ToolResultContent in subsequent messages.
   */
  id: string2(),
  /**
   * Arguments to pass to the tool.
   * Must conform to the tool's inputSchema.
   */
  input: record(string2(), unknown()),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var EmbeddedResourceSchema = object({
  type: literal("resource"),
  resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
  /**
   * Optional annotations for the client.
   */
  annotations: AnnotationsSchema.optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var ResourceLinkSchema = ResourceSchema.extend({
  type: literal("resource_link")
});
var ContentBlockSchema = union([
  TextContentSchema,
  ImageContentSchema,
  AudioContentSchema,
  ResourceLinkSchema,
  EmbeddedResourceSchema
]);
var PromptMessageSchema = object({
  role: RoleSchema,
  content: ContentBlockSchema
});
var GetPromptResultSchema = ResultSchema.extend({
  /**
   * An optional description for the prompt.
   */
  description: string2().optional(),
  messages: array(PromptMessageSchema)
});
var PromptListChangedNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/prompts/list_changed"),
  params: NotificationsParamsSchema.optional()
});
var ToolAnnotationsSchema = object({
  /**
   * A human-readable title for the tool.
   */
  title: string2().optional(),
  /**
   * If true, the tool does not modify its environment.
   *
   * Default: false
   */
  readOnlyHint: boolean2().optional(),
  /**
   * If true, the tool may perform destructive updates to its environment.
   * If false, the tool performs only additive updates.
   *
   * (This property is meaningful only when `readOnlyHint == false`)
   *
   * Default: true
   */
  destructiveHint: boolean2().optional(),
  /**
   * If true, calling the tool repeatedly with the same arguments
   * will have no additional effect on the its environment.
   *
   * (This property is meaningful only when `readOnlyHint == false`)
   *
   * Default: false
   */
  idempotentHint: boolean2().optional(),
  /**
   * If true, this tool may interact with an "open world" of external
   * entities. If false, the tool's domain of interaction is closed.
   * For example, the world of a web search tool is open, whereas that
   * of a memory tool is not.
   *
   * Default: true
   */
  openWorldHint: boolean2().optional()
});
var ToolExecutionSchema = object({
  /**
   * Indicates the tool's preference for task-augmented execution.
   * - "required": Clients MUST invoke the tool as a task
   * - "optional": Clients MAY invoke the tool as a task or normal request
   * - "forbidden": Clients MUST NOT attempt to invoke the tool as a task
   *
   * If not present, defaults to "forbidden".
   */
  taskSupport: _enum(["required", "optional", "forbidden"]).optional()
});
var ToolSchema = object({
  ...BaseMetadataSchema.shape,
  ...IconsSchema.shape,
  /**
   * A human-readable description of the tool.
   */
  description: string2().optional(),
  /**
   * A JSON Schema 2020-12 object defining the expected parameters for the tool.
   * Must have type: 'object' at the root level per MCP spec.
   */
  inputSchema: object({
    type: literal("object"),
    properties: record(string2(), AssertObjectSchema).optional(),
    required: array(string2()).optional()
  }).catchall(unknown()),
  /**
   * An optional JSON Schema 2020-12 object defining the structure of the tool's output
   * returned in the structuredContent field of a CallToolResult.
   * Must have type: 'object' at the root level per MCP spec.
   */
  outputSchema: object({
    type: literal("object"),
    properties: record(string2(), AssertObjectSchema).optional(),
    required: array(string2()).optional()
  }).catchall(unknown()).optional(),
  /**
   * Optional additional tool information.
   */
  annotations: ToolAnnotationsSchema.optional(),
  /**
   * Execution-related properties for this tool.
   */
  execution: ToolExecutionSchema.optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var ListToolsRequestSchema = PaginatedRequestSchema.extend({
  method: literal("tools/list")
});
var ListToolsResultSchema = PaginatedResultSchema.extend({
  tools: array(ToolSchema)
});
var CallToolResultSchema = ResultSchema.extend({
  /**
   * A list of content objects that represent the result of the tool call.
   *
   * If the Tool does not define an outputSchema, this field MUST be present in the result.
   * For backwards compatibility, this field is always present, but it may be empty.
   */
  content: array(ContentBlockSchema).default([]),
  /**
   * An object containing structured tool output.
   *
   * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
   */
  structuredContent: record(string2(), unknown()).optional(),
  /**
   * Whether the tool call ended in an error.
   *
   * If not set, this is assumed to be false (the call was successful).
   *
   * Any errors that originate from the tool SHOULD be reported inside the result
   * object, with `isError` set to true, _not_ as an MCP protocol-level error
   * response. Otherwise, the LLM would not be able to see that an error occurred
   * and self-correct.
   *
   * However, any errors in _finding_ the tool, an error indicating that the
   * server does not support tool calls, or any other exceptional conditions,
   * should be reported as an MCP error response.
   */
  isError: boolean2().optional()
});
var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({
  toolResult: unknown()
}));
var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
  /**
   * The name of the tool to call.
   */
  name: string2(),
  /**
   * Arguments to pass to the tool.
   */
  arguments: record(string2(), unknown()).optional()
});
var CallToolRequestSchema = RequestSchema.extend({
  method: literal("tools/call"),
  params: CallToolRequestParamsSchema
});
var ToolListChangedNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/tools/list_changed"),
  params: NotificationsParamsSchema.optional()
});
var ListChangedOptionsBaseSchema = object({
  /**
   * If true, the list will be refreshed automatically when a list changed notification is received.
   * The callback will be called with the updated list.
   *
   * If false, the callback will be called with null items, allowing manual refresh.
   *
   * @default true
   */
  autoRefresh: boolean2().default(true),
  /**
   * Debounce time in milliseconds for list changed notification processing.
   *
   * Multiple notifications received within this timeframe will only trigger one refresh.
   * Set to 0 to disable debouncing.
   *
   * @default 300
   */
  debounceMs: number2().int().nonnegative().default(300)
});
var LoggingLevelSchema = _enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
  /**
   * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.
   */
  level: LoggingLevelSchema
});
var SetLevelRequestSchema = RequestSchema.extend({
  method: literal("logging/setLevel"),
  params: SetLevelRequestParamsSchema
});
var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
  /**
   * The severity of this log message.
   */
  level: LoggingLevelSchema,
  /**
   * An optional name of the logger issuing this message.
   */
  logger: string2().optional(),
  /**
   * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
   */
  data: unknown()
});
var LoggingMessageNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/message"),
  params: LoggingMessageNotificationParamsSchema
});
var ModelHintSchema = object({
  /**
   * A hint for a model name.
   */
  name: string2().optional()
});
var ModelPreferencesSchema = object({
  /**
   * Optional hints to use for model selection.
   */
  hints: array(ModelHintSchema).optional(),
  /**
   * How much to prioritize cost when selecting a model.
   */
  costPriority: number2().min(0).max(1).optional(),
  /**
   * How much to prioritize sampling speed (latency) when selecting a model.
   */
  speedPriority: number2().min(0).max(1).optional(),
  /**
   * How much to prioritize intelligence and capabilities when selecting a model.
   */
  intelligencePriority: number2().min(0).max(1).optional()
});
var ToolChoiceSchema = object({
  /**
   * Controls when tools are used:
   * - "auto": Model decides whether to use tools (default)
   * - "required": Model MUST use at least one tool before completing
   * - "none": Model MUST NOT use any tools
   */
  mode: _enum(["auto", "required", "none"]).optional()
});
var ToolResultContentSchema = object({
  type: literal("tool_result"),
  toolUseId: string2().describe("The unique identifier for the corresponding tool call."),
  content: array(ContentBlockSchema).default([]),
  structuredContent: object({}).loose().optional(),
  isError: boolean2().optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
  TextContentSchema,
  ImageContentSchema,
  AudioContentSchema,
  ToolUseContentSchema,
  ToolResultContentSchema
]);
var SamplingMessageSchema = object({
  role: RoleSchema,
  content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
  messages: array(SamplingMessageSchema),
  /**
   * The server's preferences for which model to select. The client MAY modify or omit this request.
   */
  modelPreferences: ModelPreferencesSchema.optional(),
  /**
   * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
   */
  systemPrompt: string2().optional(),
  /**
   * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt.
   * The client MAY ignore this request.
   *
   * Default is "none". Values "thisServer" and "allServers" are soft-deprecated. Servers SHOULD only use these values if the client
   * declares ClientCapabilities.sampling.context. These values may be removed in future spec releases.
   */
  includeContext: _enum(["none", "thisServer", "allServers"]).optional(),
  temperature: number2().optional(),
  /**
   * The requested maximum number of tokens to sample (to prevent runaway completions).
   *
   * The client MAY choose to sample fewer tokens than the requested maximum.
   */
  maxTokens: number2().int(),
  stopSequences: array(string2()).optional(),
  /**
   * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
   */
  metadata: AssertObjectSchema.optional(),
  /**
   * Tools that the model may use during generation.
   * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
   */
  tools: array(ToolSchema).optional(),
  /**
   * Controls how the model uses tools.
   * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
   * Default is `{ mode: "auto" }`.
   */
  toolChoice: ToolChoiceSchema.optional()
});
var CreateMessageRequestSchema = RequestSchema.extend({
  method: literal("sampling/createMessage"),
  params: CreateMessageRequestParamsSchema
});
var CreateMessageResultSchema = ResultSchema.extend({
  /**
   * The name of the model that generated the message.
   */
  model: string2(),
  /**
   * The reason why sampling stopped, if known.
   *
   * Standard values:
   * - "endTurn": Natural end of the assistant's turn
   * - "stopSequence": A stop sequence was encountered
   * - "maxTokens": Maximum token limit was reached
   *
   * This field is an open string to allow for provider-specific stop reasons.
   */
  stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens"]).or(string2())),
  role: RoleSchema,
  /**
   * Response content. Single content block (text, image, or audio).
   */
  content: SamplingContentSchema
});
var CreateMessageResultWithToolsSchema = ResultSchema.extend({
  /**
   * The name of the model that generated the message.
   */
  model: string2(),
  /**
   * The reason why sampling stopped, if known.
   *
   * Standard values:
   * - "endTurn": Natural end of the assistant's turn
   * - "stopSequence": A stop sequence was encountered
   * - "maxTokens": Maximum token limit was reached
   * - "toolUse": The model wants to use one or more tools
   *
   * This field is an open string to allow for provider-specific stop reasons.
   */
  stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string2())),
  role: RoleSchema,
  /**
   * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
   */
  content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
});
var BooleanSchemaSchema = object({
  type: literal("boolean"),
  title: string2().optional(),
  description: string2().optional(),
  default: boolean2().optional()
});
var StringSchemaSchema = object({
  type: literal("string"),
  title: string2().optional(),
  description: string2().optional(),
  minLength: number2().optional(),
  maxLength: number2().optional(),
  format: _enum(["email", "uri", "date", "date-time"]).optional(),
  default: string2().optional()
});
var NumberSchemaSchema = object({
  type: _enum(["number", "integer"]),
  title: string2().optional(),
  description: string2().optional(),
  minimum: number2().optional(),
  maximum: number2().optional(),
  default: number2().optional()
});
var UntitledSingleSelectEnumSchemaSchema = object({
  type: literal("string"),
  title: string2().optional(),
  description: string2().optional(),
  enum: array(string2()),
  default: string2().optional()
});
var TitledSingleSelectEnumSchemaSchema = object({
  type: literal("string"),
  title: string2().optional(),
  description: string2().optional(),
  oneOf: array(object({
    const: string2(),
    title: string2()
  })),
  default: string2().optional()
});
var LegacyTitledEnumSchemaSchema = object({
  type: literal("string"),
  title: string2().optional(),
  description: string2().optional(),
  enum: array(string2()),
  enumNames: array(string2()).optional(),
  default: string2().optional()
});
var SingleSelectEnumSchemaSchema = union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
var UntitledMultiSelectEnumSchemaSchema = object({
  type: literal("array"),
  title: string2().optional(),
  description: string2().optional(),
  minItems: number2().optional(),
  maxItems: number2().optional(),
  items: object({
    type: literal("string"),
    enum: array(string2())
  }),
  default: array(string2()).optional()
});
var TitledMultiSelectEnumSchemaSchema = object({
  type: literal("array"),
  title: string2().optional(),
  description: string2().optional(),
  minItems: number2().optional(),
  maxItems: number2().optional(),
  items: object({
    anyOf: array(object({
      const: string2(),
      title: string2()
    }))
  }),
  default: array(string2()).optional()
});
var MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
var EnumSchemaSchema = union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
var PrimitiveSchemaDefinitionSchema = union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
  /**
   * The elicitation mode.
   *
   * Optional for backward compatibility. Clients MUST treat missing mode as "form".
   */
  mode: literal("form").optional(),
  /**
   * The message to present to the user describing what information is being requested.
   */
  message: string2(),
  /**
   * A restricted subset of JSON Schema.
   * Only top-level properties are allowed, without nesting.
   */
  requestedSchema: object({
    type: literal("object"),
    properties: record(string2(), PrimitiveSchemaDefinitionSchema),
    required: array(string2()).optional()
  })
});
var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
  /**
   * The elicitation mode.
   */
  mode: literal("url"),
  /**
   * The message to present to the user explaining why the interaction is needed.
   */
  message: string2(),
  /**
   * The ID of the elicitation, which must be unique within the context of the server.
   * The client MUST treat this ID as an opaque value.
   */
  elicitationId: string2(),
  /**
   * The URL that the user should navigate to.
   */
  url: string2().url()
});
var ElicitRequestParamsSchema = union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
var ElicitRequestSchema = RequestSchema.extend({
  method: literal("elicitation/create"),
  params: ElicitRequestParamsSchema
});
var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({
  /**
   * The ID of the elicitation that completed.
   */
  elicitationId: string2()
});
var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/elicitation/complete"),
  params: ElicitationCompleteNotificationParamsSchema
});
var ElicitResultSchema = ResultSchema.extend({
  /**
   * The user action in response to the elicitation.
   * - "accept": User submitted the form/confirmed the action
   * - "decline": User explicitly decline the action
   * - "cancel": User dismissed without making an explicit choice
   */
  action: _enum(["accept", "decline", "cancel"]),
  /**
   * The submitted form data, only present when action is "accept".
   * Contains values matching the requested schema.
   * Per MCP spec, content is "typically omitted" for decline/cancel actions.
   * We normalize null to undefined for leniency while maintaining type compatibility.
   */
  content: preprocess((val) => val === null ? void 0 : val, record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional())
});
var ResourceTemplateReferenceSchema = object({
  type: literal("ref/resource"),
  /**
   * The URI or URI template of the resource.
   */
  uri: string2()
});
var PromptReferenceSchema = object({
  type: literal("ref/prompt"),
  /**
   * The name of the prompt or prompt template
   */
  name: string2()
});
var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
  ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
  /**
   * The argument's information
   */
  argument: object({
    /**
     * The name of the argument
     */
    name: string2(),
    /**
     * The value of the argument to use for completion matching.
     */
    value: string2()
  }),
  context: object({
    /**
     * Previously-resolved variables in a URI template or prompt.
     */
    arguments: record(string2(), string2()).optional()
  }).optional()
});
var CompleteRequestSchema = RequestSchema.extend({
  method: literal("completion/complete"),
  params: CompleteRequestParamsSchema
});
function assertCompleteRequestPrompt(request) {
  if (request.params.ref.type !== "ref/prompt") {
    throw new TypeError(`Expected CompleteRequestPrompt, but got ${request.params.ref.type}`);
  }
  void request;
}
function assertCompleteRequestResourceTemplate(request) {
  if (request.params.ref.type !== "ref/resource") {
    throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request.params.ref.type}`);
  }
  void request;
}
var CompleteResultSchema = ResultSchema.extend({
  completion: looseObject({
    /**
     * An array of completion values. Must not exceed 100 items.
     */
    values: array(string2()).max(100),
    /**
     * The total number of completion options available. This can exceed the number of values actually sent in the response.
     */
    total: optional(number2().int()),
    /**
     * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
     */
    hasMore: optional(boolean2())
  })
});
var RootSchema = object({
  /**
   * The URI identifying the root. This *must* start with file:// for now.
   */
  uri: string2().startsWith("file://"),
  /**
   * An optional name for the root.
   */
  name: string2().optional(),
  /**
   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
   * for notes on _meta usage.
   */
  _meta: record(string2(), unknown()).optional()
});
var ListRootsRequestSchema = RequestSchema.extend({
  method: literal("roots/list"),
  params: BaseRequestParamsSchema.optional()
});
var ListRootsResultSchema = ResultSchema.extend({
  roots: array(RootSchema)
});
var RootsListChangedNotificationSchema = NotificationSchema.extend({
  method: literal("notifications/roots/list_changed"),
  params: NotificationsParamsSchema.optional()
});
var ClientRequestSchema = union([
  PingRequestSchema,
  InitializeRequestSchema,
  CompleteRequestSchema,
  SetLevelRequestSchema,
  GetPromptRequestSchema,
  ListPromptsRequestSchema,
  ListResourcesRequestSchema,
  ListResourceTemplatesRequestSchema,
  ReadResourceRequestSchema,
  SubscribeRequestSchema,
  UnsubscribeRequestSchema,
  CallToolRequestSchema,
  ListToolsRequestSchema,
  GetTaskRequestSchema,
  GetTaskPayloadRequestSchema,
  ListTasksRequestSchema,
  CancelTaskRequestSchema
]);
var ClientNotificationSchema = union([
  CancelledNotificationSchema,
  ProgressNotificationSchema,
  InitializedNotificationSchema,
  RootsListChangedNotificationSchema,
  TaskStatusNotificationSchema
]);
var ClientResultSchema = union([
  EmptyResultSchema,
  CreateMessageResultSchema,
  CreateMessageResultWithToolsSchema,
  ElicitResultSchema,
  ListRootsResultSchema,
  GetTaskResultSchema,
  ListTasksResultSchema,
  CreateTaskResultSchema
]);
var ServerRequestSchema = union([
  PingRequestSchema,
  CreateMessageRequestSchema,
  ElicitRequestSchema,
  ListRootsRequestSchema,
  GetTaskRequestSchema,
  GetTaskPayloadRequestSchema,
  ListTasksRequestSchema,
  CancelTaskRequestSchema
]);
var ServerNotificationSchema = union([
  CancelledNotificationSchema,
  ProgressNotificationSchema,
  LoggingMessageNotificationSchema,
  ResourceUpdatedNotificationSchema,
  ResourceListChangedNotificationSchema,
  ToolListChangedNotificationSchema,
  PromptListChangedNotificationSchema,
  TaskStatusNotificationSchema,
  ElicitationCompleteNotificationSchema
]);
var ServerResultSchema = union([
  EmptyResultSchema,
  InitializeResultSchema,
  CompleteResultSchema,
  GetPromptResultSchema,
  ListPromptsResultSchema,
  ListResourcesResultSchema,
  ListResourceTemplatesResultSchema,
  ReadResourceResultSchema,
  CallToolResultSchema,
  ListToolsResultSchema,
  GetTaskResultSchema,
  ListTasksResultSchema,
  CreateTaskResultSchema
]);
var McpError = class _McpError extends Error {
  constructor(code, message, data) {
    super(`MCP error ${code}: ${message}`);
    this.code = code;
    this.data = data;
    this.name = "McpError";
  }
  /**
   * Factory method to create the appropriate error type based on the error code and data
   */
  static fromError(code, message, data) {
    if (code === ErrorCode.UrlElicitationRequired && data) {
      const errorData = data;
      if (errorData.elicitations) {
        return new UrlElicitationRequiredError(errorData.elicitations, message);
      }
    }
    return new _McpError(code, message, data);
  }
};
var UrlElicitationRequiredError = class extends McpError {
  constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) {
    super(ErrorCode.UrlElicitationRequired, message, {
      elicitations
    });
  }
  get elicitations() {
    return this.data?.elicitations ?? [];
  }
};

// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
var ReadBuffer = class {
  append(chunk) {
    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
  }
  readMessage() {
    if (!this._buffer) {
      return null;
    }
    const index = this._buffer.indexOf("\n");
    if (index === -1) {
      return null;
    }
    const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
    this._buffer = this._buffer.subarray(index + 1);
    return deserializeMessage(line);
  }
  clear() {
    this._buffer = void 0;
  }
};
function deserializeMessage(line) {
  return JSONRPCMessageSchema.parse(JSON.parse(line));
}
function serializeMessage(message) {
  return JSON.stringify(message) + "\n";
}

// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
var StdioServerTransport = class {
  constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
    this._stdin = _stdin;
    this._stdout = _stdout;
    this._readBuffer = new ReadBuffer();
    this._started = false;
    this._ondata = (chunk) => {
      this._readBuffer.append(chunk);
      this.processReadBuffer();
    };
    this._onerror = (error3) => {
      this.onerror?.(error3);
    };
  }
  /**
   * Starts listening for messages on stdin.
   */
  async start() {
    if (this._started) {
      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
    }
    this._started = true;
    this._stdin.on("data", this._ondata);
    this._stdin.on("error", this._onerror);
  }
  processReadBuffer() {
    while (true) {
      try {
        const message = this._readBuffer.readMessage();
        if (message === null) {
          break;
        }
        this.onmessage?.(message);
      } catch (error3) {
        this.onerror?.(error3);
      }
    }
  }
  async close() {
    this._stdin.off("data", this._ondata);
    this._stdin.off("error", this._onerror);
    const remainingDataListeners = this._stdin.listenerCount("data");
    if (remainingDataListeners === 0) {
      this._stdin.pause();
    }
    this._readBuffer.clear();
    this.onclose?.();
  }
  send(message) {
    return new Promise((resolve3) => {
      const json = serializeMessage(message);
      if (this._stdout.write(json)) {
        resolve3();
      } else {
        this._stdout.once("drain", resolve3);
      }
    });
  }
};

// sceneboard-mcp/src/cli/api-key-credential.command.ts
import { Writable } from "node:stream";
import { createInterface } from "node:readline/promises";

// sceneboard-mcp/src/config/config-discovery.ts
import { access, open } from "node:fs/promises";
import { constants } from "node:fs";
import { dirname, isAbsolute, join, parse as parse3, resolve } from "node:path";

// sceneboard-mcp/src/config/board-config.ts
var BOARD_CONFIG_MAX_BYTES_V1 = 65536;
var BOARD_PROFILE_PATTERN_V1 = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
var BoardConfigError = class extends Error {
  source;
  field;
  constructor(source, field) {
    super("Board configuration is invalid");
    this.name = "BoardConfigError";
    this.source = source;
    this.field = field;
  }
};
var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
var hasExactKeys = (value, keys) => {
  const actual = Object.keys(value).sort();
  const expected = [...keys].sort();
  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
};
var hasDuplicateJsonMember = (source) => {
  const objectKeySets = [];
  const containers = [];
  let expectingKey = false;
  let index = 0;
  while (index < source.length) {
    const character = source[index];
    if (character === '"') {
      const start = index;
      index += 1;
      while (index < source.length) {
        const current = source[index];
        if (current === "\\") {
          index += 2;
          continue;
        }
        if (current === '"') break;
        index += 1;
      }
      if (index >= source.length) return false;
      if (expectingKey && containers.at(-1) === "object") {
        let key;
        try {
          key = JSON.parse(source.slice(start, index + 1));
        } catch {
          return false;
        }
        const keys = objectKeySets.at(-1);
        if (typeof key !== "string" || keys === void 0) return false;
        if (keys.has(key)) return true;
        keys.add(key);
        expectingKey = false;
      }
      index += 1;
      continue;
    }
    if (character === "{") {
      containers.push("object");
      objectKeySets.push(/* @__PURE__ */ new Set());
      expectingKey = true;
    } else if (character === "[") {
      containers.push("array");
    } else if (character === "}" || character === "]") {
      const removed = containers.pop();
      if (removed === "object") objectKeySets.pop();
      expectingKey = false;
    } else if (character === "," && containers.at(-1) === "object") {
      expectingKey = true;
    } else if (character === ":" && containers.at(-1) === "object") {
      expectingKey = false;
    }
    index += 1;
  }
  return false;
};
var parseJsonBytes = (bytes, source) => {
  if (bytes.byteLength === 0 || bytes.byteLength > BOARD_CONFIG_MAX_BYTES_V1) {
    throw new BoardConfigError(source, null);
  }
  let text;
  try {
    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
  } catch {
    throw new BoardConfigError(source, null);
  }
  if (hasDuplicateJsonMember(text)) throw new BoardConfigError(source, null);
  try {
    return JSON.parse(text);
  } catch {
    throw new BoardConfigError(source, null);
  }
};
var canonicalBaseUrl = (value, source) => {
  if (typeof value !== "string" || value.length === 0 || value.length > 2048 || /[<>${}\s]/.test(value) || /example\.(?:com|org|net)$/i.test(value)) {
    throw new BoardConfigError(source, "baseUrl");
  }
  let url;
  try {
    url = new URL(value);
  } catch {
    throw new BoardConfigError(source, "baseUrl");
  }
  const loopback = url.hostname === "127.0.0.1" || url.hostname === "[::1]" || url.hostname === "::1";
  if (url.origin !== value || url.pathname !== "/" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
    throw new BoardConfigError(source, "baseUrl");
  }
  return url.origin;
};
var parseBoardConfigV1 = (value, source) => {
  const legacyKeys = ["version", "baseUrl", "accessTokenRef", "authScheme", "timeoutMs", "profile"];
  const discriminatedKeys = [...legacyKeys, "credentialMode"];
  if (!isRecord(value) || !hasExactKeys(value, legacyKeys) && !hasExactKeys(value, discriminatedKeys))
    throw new BoardConfigError(source, null);
  if (value.version !== 1) throw new BoardConfigError(source, "version");
  if (value.authScheme !== "bearer") throw new BoardConfigError(source, "authScheme");
  if (value.credentialMode !== void 0 && value.credentialMode !== "pairing" && value.credentialMode !== "api_key")
    throw new BoardConfigError(source, "credentialMode");
  if (!Number.isSafeInteger(value.timeoutMs) || Number(value.timeoutMs) < 1e3 || Number(value.timeoutMs) > 12e4) {
    throw new BoardConfigError(source, "timeoutMs");
  }
  if (typeof value.profile !== "string" || !BOARD_PROFILE_PATTERN_V1.test(value.profile)) {
    throw new BoardConfigError(source, "profile");
  }
  const credentialMode = value.credentialMode ?? "pairing";
  const environmentReference = credentialMode === "api_key" ? "env://SCENEBOARD_API_KEY" : "env://SCENEBOARD_ACCESS_TOKEN";
  if (value.accessTokenRef !== environmentReference && value.accessTokenRef !== `store://${value.profile}`)
    throw new BoardConfigError(source, "accessTokenRef");
  const base = {
    version: 1,
    baseUrl: canonicalBaseUrl(value.baseUrl, source),
    authScheme: "bearer",
    timeoutMs: Number(value.timeoutMs),
    profile: value.profile
  };
  if (credentialMode === "api_key")
    return {
      ...base,
      accessTokenRef: value.accessTokenRef === "env://SCENEBOARD_API_KEY" ? value.accessTokenRef : `store://${value.profile}`,
      credentialMode: "api_key"
    };
  const pairing = {
    ...base,
    accessTokenRef: value.accessTokenRef === "env://SCENEBOARD_ACCESS_TOKEN" ? value.accessTokenRef : `store://${value.profile}`
  };
  return value.credentialMode === "pairing" ? { ...pairing, credentialMode: "pairing" } : pairing;
};
var sameFileStatus = (left, right) => left.dev === right.dev && left.ino === right.ino && left.uid === right.uid && left.mode === right.mode && left.nlink === right.nlink && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
var readBoundedFileHandle = async (handle) => {
  const buffer = new Uint8Array(BOARD_CONFIG_MAX_BYTES_V1 + 1);
  let offset = 0;
  while (offset < buffer.byteLength) {
    const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
    if (bytesRead === 0) break;
    offset += bytesRead;
  }
  return buffer.subarray(0, offset);
};
var readBoardConfigFileV1 = async (handle, source, approvedStatus) => {
  let before;
  let bytes;
  let after;
  try {
    before = await handle.stat({ bigint: true });
    if (!sameFileStatus(approvedStatus, before)) throw new BoardConfigError(source, null);
    bytes = await readBoundedFileHandle(handle);
    after = await handle.stat({ bigint: true });
  } catch {
    throw new BoardConfigError(source, null);
  }
  if (!sameFileStatus(before, after)) throw new BoardConfigError(source, null);
  return parseBoardConfigV1(parseJsonBytes(bytes, source), source);
};

// sceneboard-mcp/src/config/config-discovery.ts
var IMPLICIT_REPOSITORY_BASE_URLS_V1 = /* @__PURE__ */ new Set(["https://sceneboard.dev"]);
var processConfigPath = (argv) => {
  const entries = argv.filter((argument) => argument.startsWith("--config="));
  if (entries.length > 1) throw new BoardConfigError("process_option", null);
  if (entries.length === 0) return null;
  const path = entries[0]?.slice("--config=".length) ?? "";
  if (!isAbsolute(path)) throw new BoardConfigError("process_option", null);
  return path;
};
var nearestBoardFile = async (cwd) => {
  let current = resolve(cwd);
  while (true) {
    const candidate = join(current, ".board.json");
    try {
      await access(candidate, constants.F_OK);
      return candidate;
    } catch {
      const parent = dirname(current);
      if (parent === current || current === parse3(current).root) return null;
      current = parent;
    }
  }
};
var userConfigPath = (env) => {
  if (env.XDG_CONFIG_HOME !== void 0 && env.XDG_CONFIG_HOME !== "") {
    if (!isAbsolute(env.XDG_CONFIG_HOME)) throw new BoardConfigError("user_config_file", null);
    return join(env.XDG_CONFIG_HOME, "leecat-board", "board.json");
  }
  if (env.HOME === void 0 || env.HOME === "" || !isAbsolute(env.HOME)) return null;
  return join(env.HOME, ".config", "leecat-board", "board.json");
};
var existing = async (path) => {
  try {
    await access(path, constants.F_OK);
    return true;
  } catch {
    return false;
  }
};
var environmentTimeout = (value) => {
  if (value === void 0 || value === "") return 3e4;
  return /^\d+$/u.test(value) ? Number(value) : Number.NaN;
};
var assertSafeFile = (status, source, effectiveUserId) => {
  if (!status.isFile() || status.nlink !== 1n || status.size < 1n || status.size > BigInt(BOARD_CONFIG_MAX_BYTES_V1) || (status.mode & 0o022n) !== 0n) {
    throw new BoardConfigError(source, null);
  }
  if (effectiveUserId === void 0 || status.uid !== BigInt(effectiveUserId))
    throw new BoardConfigError(source, null);
};
var loadFile = async (path, source, effectiveUserId) => {
  let handle;
  try {
    handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
    const approvedStatus = await handle.stat({ bigint: true });
    assertSafeFile(approvedStatus, source, effectiveUserId);
    const config2 = await readBoardConfigFileV1(handle, source, approvedStatus);
    if (source === "nearest_board_file" && !IMPLICIT_REPOSITORY_BASE_URLS_V1.has(config2.baseUrl))
      throw new BoardConfigError(source, "baseUrl");
    return { config: config2, source, path };
  } catch (error3) {
    if (error3 instanceof BoardConfigError) throw error3;
    throw new BoardConfigError(source, null);
  } finally {
    await handle?.close().catch(() => void 0);
  }
};
var discoverBoardConfigV1 = async (options) => {
  const effectiveUserId = options.effectiveUserId ?? process.geteuid?.();
  const processPath = processConfigPath(options.argv);
  if (processPath !== null) return loadFile(processPath, "process_option", effectiveUserId);
  if (options.env.BOARD_CONFIG !== void 0 && options.env.BOARD_CONFIG !== "") {
    if (!isAbsolute(options.env.BOARD_CONFIG)) throw new BoardConfigError("board_config_env", null);
    return loadFile(options.env.BOARD_CONFIG, "board_config_env", effectiveUserId);
  }
  const nearest = await nearestBoardFile(options.cwd);
  if (nearest !== null) return loadFile(nearest, "nearest_board_file", effectiveUserId);
  const userPath = userConfigPath(options.env);
  if (userPath !== null && await existing(userPath))
    return loadFile(userPath, "user_config_file", effectiveUserId);
  if (options.env.BOARD_API_URL === void 0 || options.env.BOARD_API_URL === "") {
    throw new BoardConfigError("environment", "baseUrl");
  }
  const config2 = parseBoardConfigV1(
    {
      version: 1,
      baseUrl: options.env.BOARD_API_URL,
      accessTokenRef: options.env.BOARD_ACCESS_TOKEN_REF ?? (options.env.BOARD_CREDENTIAL_MODE === "api_key" ? "env://SCENEBOARD_API_KEY" : "env://SCENEBOARD_ACCESS_TOKEN"),
      authScheme: "bearer",
      timeoutMs: environmentTimeout(options.env.BOARD_TIMEOUT_MS),
      profile: options.env.BOARD_PROFILE ?? "default",
      ...options.env.BOARD_CREDENTIAL_MODE === void 0 ? {} : { credentialMode: options.env.BOARD_CREDENTIAL_MODE }
    },
    "environment"
  );
  return { config: config2, source: "environment", path: null };
};

// sceneboard-mcp/src/config/secret-reference.ts
import { isAbsolute as isAbsolute2, join as join2 } from "node:path";
var resolveSecretReferenceV1 = (config2, env) => {
  const credentialMode = config2.credentialMode ?? "pairing";
  if (config2.accessTokenRef === "env://SCENEBOARD_ACCESS_TOKEN" || config2.accessTokenRef === "env://SCENEBOARD_API_KEY") {
    return {
      kind: "environment",
      variable: credentialMode === "api_key" ? "SCENEBOARD_API_KEY" : "SCENEBOARD_ACCESS_TOKEN"
    };
  }
  const conflictingEnvironmentVariable = credentialMode === "api_key" ? env.SCENEBOARD_API_KEY : env.SCENEBOARD_ACCESS_TOKEN;
  if (conflictingEnvironmentVariable !== void 0 && conflictingEnvironmentVariable !== "") {
    throw new BoardConfigError(null, "accessTokenRef");
  }
  let root;
  if (env.XDG_STATE_HOME !== void 0 && env.XDG_STATE_HOME !== "") {
    if (!isAbsolute2(env.XDG_STATE_HOME)) throw new BoardConfigError(null, "accessTokenRef");
    root = env.XDG_STATE_HOME;
  } else {
    if (env.HOME === void 0 || env.HOME === "" || !isAbsolute2(env.HOME)) {
      throw new BoardConfigError(null, "accessTokenRef");
    }
    root = join2(env.HOME, ".local", "state");
  }
  return {
    kind: "store",
    profile: config2.profile,
    stateDirectory: join2(root, "leecat-board", "credentials", config2.profile)
  };
};

// sceneboard-mcp/src/credentials/api-key-credential-record.ts
import { timingSafeEqual as timingSafeEqual2 } from "node:crypto";

// sceneboard-mcp/src/credentials/credential-record.ts
import { timingSafeEqual } from "node:crypto";
var ACCESS_TOKEN_PATTERN_V1 = /^lcbg_v1\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}$/;
var GENERATION_PATTERN_V1 = /^[A-Za-z0-9_-]{22}$/;
var parseCredentialRecordV1 = (bytes) => {
  if (bytes.byteLength === 0 || bytes.byteLength > 512) throw new Error("credential record is invalid");
  let source;
  try {
    source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
  } catch {
    throw new Error("credential record is invalid");
  }
  let value;
  try {
    value = JSON.parse(source);
  } catch {
    throw new Error("credential record is invalid");
  }
  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("credential record is invalid");
  const record2 = value;
  const keys = Object.keys(record2).sort();
  if (keys.join("\0") !== ["accessToken", "generation", "version"].join("\0") || record2.version !== 1 || typeof record2.generation !== "string" || !GENERATION_PATTERN_V1.test(record2.generation) || typeof record2.accessToken !== "string" || !ACCESS_TOKEN_PATTERN_V1.test(record2.accessToken) || JSON.stringify(record2) !== source) throw new Error("credential record is invalid");
  return { version: 1, generation: record2.generation, accessToken: record2.accessToken };
};
var sameCredentialV1 = (left, right) => {
  if (left.generation !== right.generation) return false;
  const leftToken = Buffer.from(left.accessToken, "ascii");
  const rightToken = Buffer.from(right.accessToken, "ascii");
  return leftToken.byteLength === rightToken.byteLength && timingSafeEqual(leftToken, rightToken);
};

// sceneboard-mcp/src/credentials/api-key-credential-record.ts
var ACCOUNT_API_KEY_PATTERN_V1 = /^sbk_v1\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}$/;
var API_KEY_CREDENTIAL_RECORD_MAX_BYTES_V1 = 512;
var parseApiKeyCredentialRecordV1 = (bytes) => {
  if (bytes.byteLength === 0 || bytes.byteLength > API_KEY_CREDENTIAL_RECORD_MAX_BYTES_V1)
    throw new Error("API key credential record is invalid");
  let source;
  try {
    source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
  } catch {
    throw new Error("API key credential record is invalid");
  }
  let value;
  try {
    value = JSON.parse(source);
  } catch {
    throw new Error("API key credential record is invalid");
  }
  if (value === null || typeof value !== "object" || Array.isArray(value))
    throw new Error("API key credential record is invalid");
  const record2 = value;
  if (Object.keys(record2).sort().join("\0") !== ["apiKey", "generation", "version"].join("\0") || record2.version !== 1 || typeof record2.generation !== "string" || !GENERATION_PATTERN_V1.test(record2.generation) || typeof record2.apiKey !== "string" || !ACCOUNT_API_KEY_PATTERN_V1.test(record2.apiKey) || JSON.stringify(record2) !== source)
    throw new Error("API key credential record is invalid");
  return {
    version: 1,
    generation: record2.generation,
    apiKey: record2.apiKey
  };
};
var sameApiKeyCredentialV1 = (left, right) => {
  if (left.generation !== right.generation) return false;
  const leftToken = Buffer.from(left.apiKey, "ascii");
  const rightToken = Buffer.from(right.apiKey, "ascii");
  return leftToken.byteLength === rightToken.byteLength && timingSafeEqual2(leftToken, rightToken);
};

// sceneboard-mcp/src/credentials/private-file-api-key.store.ts
import { randomBytes as randomBytes2 } from "node:crypto";
import { constants as constants3 } from "node:fs";
import { open as open3, unlink as unlink2 } from "node:fs/promises";
import { join as join4 } from "node:path";

// sceneboard-mcp/src/credentials/private-file-credential.store.ts
import { randomBytes } from "node:crypto";
import { constants as constants2 } from "node:fs";
import { lstat, mkdir, open as open2, readFile, rename, unlink } from "node:fs/promises";
import { join as join3 } from "node:path";
var CREDENTIAL_FILE = "credential.json";
var assertPrivateStateDirectoryV1 = async (stateDirectory, signal) => {
  signal?.throwIfAborted();
  await mkdir(stateDirectory, { recursive: true, mode: 448 });
  signal?.throwIfAborted();
  const status = await lstat(stateDirectory);
  if (!status.isDirectory() || status.isSymbolicLink() || status.uid !== process.geteuid?.()) {
    throw new Error("private state directory is invalid");
  }
  if ((status.mode & 511) !== 448) {
    signal?.throwIfAborted();
    const handle = await open2(
      stateDirectory,
      constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW
    );
    try {
      await handle.chmod(448);
    } finally {
      await handle.close();
    }
  }
  signal?.throwIfAborted();
  const confirmed = await lstat(stateDirectory);
  if ((confirmed.mode & 511) !== 448)
    throw new Error("private state directory permissions are invalid");
};
var assertPrivateFile = async (path, signal) => {
  signal?.throwIfAborted();
  const status = await lstat(path);
  if (!status.isFile() || status.isSymbolicLink() || status.uid !== process.geteuid?.() || (status.mode & 511) !== 384 || status.nlink !== 1)
    throw new Error("private record is invalid");
};
var atomicPrivateWriteV1 = async (stateDirectory, fileName, bytes) => {
  await assertPrivateStateDirectoryV1(stateDirectory);
  const temporaryName = `.${fileName}.${randomBytes(16).toString("base64url")}.tmp`;
  const temporaryPath = join3(stateDirectory, temporaryName);
  const targetPath = join3(stateDirectory, fileName);
  const handle = await open2(
    temporaryPath,
    constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY | constants2.O_NOFOLLOW,
    384
  );
  try {
    await handle.chmod(384);
    await handle.writeFile(bytes);
    await handle.sync();
  } catch (error3) {
    await handle.close().catch(() => void 0);
    await unlink(temporaryPath).catch(() => void 0);
    throw error3;
  }
  await handle.close();
  await assertPrivateFile(temporaryPath);
  await rename(temporaryPath, targetPath);
  const directory = await open2(
    stateDirectory,
    constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW
  );
  try {
    await directory.sync();
  } finally {
    await directory.close();
  }
};
var PrivateFileCredentialStoreV1 = class {
  constructor(stateDirectory) {
    this.stateDirectory = stateDirectory;
  }
  async preflight(signal) {
    await assertPrivateStateDirectoryV1(this.stateDirectory, signal);
  }
  async read(signal) {
    signal?.throwIfAborted();
    const path = join3(this.stateDirectory, CREDENTIAL_FILE);
    try {
      await assertPrivateFile(path, signal);
      signal?.throwIfAborted();
      const bytes = await readFile(path, { signal });
      signal?.throwIfAborted();
      return parseCredentialRecordV1(bytes);
    } catch (error3) {
      if (error3.code === "ENOENT") return null;
      throw error3;
    }
  }
  async replace(accessToken) {
    const record2 = parseCredentialRecordV1(
      new TextEncoder().encode(
        JSON.stringify({
          version: 1,
          generation: randomBytes(16).toString("base64url"),
          accessToken
        })
      )
    );
    const bytes = new TextEncoder().encode(JSON.stringify(record2));
    try {
      await atomicPrivateWriteV1(this.stateDirectory, CREDENTIAL_FILE, bytes);
    } finally {
      bytes.fill(0);
    }
    return record2;
  }
  async deleteIfCurrent(snapshot, signal) {
    const current = await this.read(signal);
    if (current === null || !sameCredentialV1(current, snapshot)) return false;
    signal?.throwIfAborted();
    await unlink(join3(this.stateDirectory, CREDENTIAL_FILE));
    const directory = await open2(
      this.stateDirectory,
      constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW
    );
    try {
      await directory.sync();
    } finally {
      await directory.close();
    }
    return true;
  }
};

// sceneboard-mcp/src/credentials/private-file-api-key.store.ts
var API_KEY_CREDENTIAL_FILE_V1 = "api-key.credential.json";
var privateFileInvalid = () => new Error("private API key record is invalid");
var readApiKeyCredentialFileHandleV1 = async (handle, effectiveUserId, signal) => {
  signal?.throwIfAborted();
  if (effectiveUserId === void 0) throw privateFileInvalid();
  try {
    const before = await handle.stat({ bigint: true });
    if (!before.isFile() || before.uid !== BigInt(effectiveUserId) || (before.mode & 0o777n) !== 0o600n || before.nlink !== 1n || before.size < 1n || before.size > BigInt(API_KEY_CREDENTIAL_RECORD_MAX_BYTES_V1))
      throw privateFileInvalid();
    const bytes = Buffer.alloc(Number(before.size));
    try {
      let offset = 0;
      while (offset < bytes.byteLength) {
        signal?.throwIfAborted();
        const result = await handle.read(bytes, offset, bytes.byteLength - offset, offset);
        if (result.bytesRead === 0) break;
        offset += result.bytesRead;
      }
      signal?.throwIfAborted();
      const after = await handle.stat({ bigint: true });
      if (offset !== bytes.byteLength || !after.isFile() || after.uid !== BigInt(effectiveUserId) || (after.mode & 0o777n) !== 0o600n || after.nlink !== 1n || before.dev !== after.dev || before.ino !== after.ino || before.mode !== after.mode || before.uid !== after.uid || before.nlink !== after.nlink || before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs)
        throw privateFileInvalid();
      return parseApiKeyCredentialRecordV1(bytes);
    } finally {
      bytes.fill(0);
    }
  } catch (error3) {
    signal?.throwIfAborted();
    if (error3 instanceof Error && error3.message === "private API key record is invalid") throw error3;
    throw privateFileInvalid();
  }
};
var PrivateFileApiKeyStoreV1 = class {
  constructor(stateDirectory, platform = process.platform) {
    this.stateDirectory = stateDirectory;
    this.platform = platform;
  }
  async preflight(signal) {
    signal?.throwIfAborted();
    if (this.platform === "win32")
      throw new Error("private API key storage is unsupported on Windows");
    await assertPrivateStateDirectoryV1(this.stateDirectory, signal);
  }
  async read(signal) {
    await this.preflight(signal);
    const path = join4(this.stateDirectory, API_KEY_CREDENTIAL_FILE_V1);
    let handle;
    try {
      signal?.throwIfAborted();
      if (typeof constants3.O_NOFOLLOW !== "number") throw privateFileInvalid();
      const closeOnExec = process.platform === "linux" ? 524288 : 0;
      handle = await open3(path, constants3.O_RDONLY | constants3.O_NOFOLLOW | closeOnExec);
    } catch (error3) {
      if (error3.code === "ENOENT") return null;
      throw error3;
    }
    try {
      return await readApiKeyCredentialFileHandleV1(handle, process.geteuid?.(), signal);
    } finally {
      await handle.close().catch(() => void 0);
    }
  }
  async replace(apiKey) {
    const record2 = parseApiKeyCredentialRecordV1(
      new TextEncoder().encode(
        JSON.stringify({
          version: 1,
          generation: randomBytes2(16).toString("base64url"),
          apiKey
        })
      )
    );
    const bytes = new TextEncoder().encode(JSON.stringify(record2));
    try {
      await atomicPrivateWriteV1(this.stateDirectory, API_KEY_CREDENTIAL_FILE_V1, bytes);
    } finally {
      bytes.fill(0);
    }
    return record2;
  }
  async delete() {
    await this.preflight();
    try {
      await unlink2(join4(this.stateDirectory, API_KEY_CREDENTIAL_FILE_V1));
    } catch (error3) {
      if (error3.code === "ENOENT") return false;
      throw error3;
    }
    const directory = await open3(
      this.stateDirectory,
      constants3.O_RDONLY | constants3.O_DIRECTORY | constants3.O_NOFOLLOW
    );
    try {
      await directory.sync();
    } finally {
      await directory.close();
    }
    return true;
  }
  async deleteIfCurrent(snapshot) {
    const current = await this.read();
    if (current === null || !sameApiKeyCredentialV1(current, snapshot)) return false;
    return this.delete();
  }
};

// sceneboard-mcp/src/cli/api-key-credential.command.ts
var MAX_SECRET_BYTES_V1 = 512;
var safeWrite = (writer, value) => {
  writer?.(`${JSON.stringify(value)}
`);
};
var readBoundedStream = async (stream) => {
  const chunks = [];
  let length = 0;
  for await (const chunk of stream) {
    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
    length += bytes.byteLength;
    if (length > MAX_SECRET_BYTES_V1) {
      for (const item of chunks) item.fill(0);
      bytes.fill(0);
      throw new Error("API key input is too large");
    }
    chunks.push(bytes);
  }
  const combined = Buffer.concat(chunks);
  for (const item of chunks) item.fill(0);
  try {
    const value = new TextDecoder("utf-8", { fatal: true }).decode(combined);
    return value.endsWith("\r\n") ? value.slice(0, -2) : value.endsWith("\n") ? value.slice(0, -1) : value;
  } finally {
    combined.fill(0);
  }
};
var readHiddenTtyLine = async (stdin, stderr) => {
  stderr("SceneBoard API key: ");
  const muted = new Writable({
    write(_chunk, _encoding, callback) {
      callback();
    }
  });
  const readline = createInterface({
    input: stdin,
    output: muted,
    terminal: true,
    historySize: 0
  });
  try {
    const value = await readline.question("");
    stderr("\n");
    if (Buffer.byteLength(value, "utf8") > MAX_SECRET_BYTES_V1)
      throw new Error("API key input is too large");
    return value;
  } finally {
    readline.close();
    muted.destroy();
  }
};
var commandArguments = (argv) => {
  if (argv[0] !== "api-key") return null;
  if (argv[1] !== "set" && argv[1] !== "remove") return null;
  const configArgv = argv.slice(2);
  if (configArgv.some((argument) => !argument.startsWith("--config=")) || configArgv.length > 1)
    return null;
  return { action: argv[1], configArgv };
};
var runApiKeyCredentialCommandV1 = async (options) => {
  const command2 = commandArguments(options.argv);
  if (command2 === null) {
    if (options.argv[0] === "api-key") {
      safeWrite(options.stderr, {
        ok: false,
        code: "CLI_USAGE",
        message: "Usage: sceneboard-mcp api-key set|remove [--config=/absolute/path]"
      });
      return { handled: true, exitCode: 64 };
    }
    return { handled: false };
  }
  try {
    const loaded = await discoverBoardConfigV1({
      argv: command2.configArgv,
      cwd: options.cwd,
      env: options.env
    });
    if ((loaded.config.credentialMode ?? "pairing") !== "api_key")
      throw new Error("API key credential mode is not configured");
    const reference = resolveSecretReferenceV1(loaded.config, options.env);
    if (reference.kind !== "store")
      throw new Error("API key command requires a private-store reference");
    const store = new PrivateFileApiKeyStoreV1(reference.stateDirectory);
    if (command2.action === "remove") {
      const removed = await store.delete();
      safeWrite(options.stdout, {
        ok: true,
        action: "remove",
        removed,
        profile: reference.profile
      });
      return { handled: true, exitCode: 0 };
    }
    const stdin = options.stdin ?? process.stdin;
    const secret = options.readSecret !== void 0 ? await options.readSecret() : stdin.isTTY ? await readHiddenTtyLine(
      stdin,
      options.stderr ?? ((value) => process.stderr.write(value))
    ) : await readBoundedStream(stdin);
    if (!ACCOUNT_API_KEY_PATTERN_V1.test(secret)) throw new Error("API key credential is invalid");
    await store.replace(secret);
    safeWrite(options.stdout, {
      ok: true,
      action: "set",
      profile: reference.profile
    });
    return { handled: true, exitCode: 0 };
  } catch {
    safeWrite(options.stderr, {
      ok: false,
      code: "API_KEY_CREDENTIAL_COMMAND_FAILED",
      message: "API key credential command failed"
    });
    return { handled: true, exitCode: 74 };
  }
};

// sceneboard-mcp/src/server.ts
import { randomBytes as randomBytes11 } from "node:crypto";
import { fileURLToPath } from "node:url";

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v3/helpers/util.js
var util;
(function(util4) {
  util4.assertEqual = (_) => {
  };
  function assertIs2(_arg) {
  }
  util4.assertIs = assertIs2;
  function assertNever2(_x) {
    throw new Error();
  }
  util4.assertNever = assertNever2;
  util4.arrayToEnum = (items) => {
    const obj = {};
    for (const item of items) {
      obj[item] = item;
    }
    return obj;
  };
  util4.getValidEnumValues = (obj) => {
    const validKeys = util4.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
    const filtered = {};
    for (const k of validKeys) {
      filtered[k] = obj[k];
    }
    return util4.objectValues(filtered);
  };
  util4.objectValues = (obj) => {
    return util4.objectKeys(obj).map(function(e) {
      return obj[e];
    });
  };
  util4.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
    const keys = [];
    for (const key in object3) {
      if (Object.prototype.hasOwnProperty.call(object3, key)) {
        keys.push(key);
      }
    }
    return keys;
  };
  util4.find = (arr, checker) => {
    for (const item of arr) {
      if (checker(item))
        return item;
    }
    return void 0;
  };
  util4.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
  function joinValues2(array2, separator = " | ") {
    return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
  }
  util4.joinValues = joinValues2;
  util4.jsonStringifyReplacer = (_, value) => {
    if (typeof value === "bigint") {
      return value.toString();
    }
    return value;
  };
})(util || (util = {}));
var objectUtil;
(function(objectUtil4) {
  objectUtil4.mergeShapes = (first, second) => {
    return {
      ...first,
      ...second
      // second overwrites first
    };
  };
})(objectUtil || (objectUtil = {}));
var ZodParsedType = util.arrayToEnum([
  "string",
  "nan",
  "number",
  "integer",
  "float",
  "boolean",
  "date",
  "bigint",
  "symbol",
  "function",
  "undefined",
  "null",
  "array",
  "object",
  "unknown",
  "promise",
  "void",
  "never",
  "map",
  "set"
]);
var getParsedType2 = (data) => {
  const t = typeof data;
  switch (t) {
    case "undefined":
      return ZodParsedType.undefined;
    case "string":
      return ZodParsedType.string;
    case "number":
      return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
    case "boolean":
      return ZodParsedType.boolean;
    case "function":
      return ZodParsedType.function;
    case "bigint":
      return ZodParsedType.bigint;
    case "symbol":
      return ZodParsedType.symbol;
    case "object":
      if (Array.isArray(data)) {
        return ZodParsedType.array;
      }
      if (data === null) {
        return ZodParsedType.null;
      }
      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
        return ZodParsedType.promise;
      }
      if (typeof Map !== "undefined" && data instanceof Map) {
        return ZodParsedType.map;
      }
      if (typeof Set !== "undefined" && data instanceof Set) {
        return ZodParsedType.set;
      }
      if (typeof Date !== "undefined" && data instanceof Date) {
        return ZodParsedType.date;
      }
      return ZodParsedType.object;
    default:
      return ZodParsedType.unknown;
  }
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v3/ZodError.js
var ZodIssueCode = util.arrayToEnum([
  "invalid_type",
  "invalid_literal",
  "custom",
  "invalid_union",
  "invalid_union_discriminator",
  "invalid_enum_value",
  "unrecognized_keys",
  "invalid_arguments",
  "invalid_return_type",
  "invalid_date",
  "invalid_string",
  "too_small",
  "too_big",
  "invalid_intersection_types",
  "not_multiple_of",
  "not_finite"
]);
var ZodError2 = class _ZodError extends Error {
  get errors() {
    return this.issues;
  }
  constructor(issues) {
    super();
    this.issues = [];
    this.addIssue = (sub) => {
      this.issues = [...this.issues, sub];
    };
    this.addIssues = (subs = []) => {
      this.issues = [...this.issues, ...subs];
    };
    const actualProto = new.target.prototype;
    if (Object.setPrototypeOf) {
      Object.setPrototypeOf(this, actualProto);
    } else {
      this.__proto__ = actualProto;
    }
    this.name = "ZodError";
    this.issues = issues;
  }
  format(_mapper) {
    const mapper = _mapper || function(issue2) {
      return issue2.message;
    };
    const fieldErrors = { _errors: [] };
    const processError = (error3) => {
      for (const issue2 of error3.issues) {
        if (issue2.code === "invalid_union") {
          issue2.unionErrors.map(processError);
        } else if (issue2.code === "invalid_return_type") {
          processError(issue2.returnTypeError);
        } else if (issue2.code === "invalid_arguments") {
          processError(issue2.argumentsError);
        } else if (issue2.path.length === 0) {
          fieldErrors._errors.push(mapper(issue2));
        } else {
          let curr = fieldErrors;
          let i = 0;
          while (i < issue2.path.length) {
            const el = issue2.path[i];
            const terminal = i === issue2.path.length - 1;
            if (!terminal) {
              curr[el] = curr[el] || { _errors: [] };
            } else {
              curr[el] = curr[el] || { _errors: [] };
              curr[el]._errors.push(mapper(issue2));
            }
            curr = curr[el];
            i++;
          }
        }
      }
    };
    processError(this);
    return fieldErrors;
  }
  static assert(value) {
    if (!(value instanceof _ZodError)) {
      throw new Error(`Not a ZodError: ${value}`);
    }
  }
  toString() {
    return this.message;
  }
  get message() {
    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
  }
  get isEmpty() {
    return this.issues.length === 0;
  }
  flatten(mapper = (issue2) => issue2.message) {
    const fieldErrors = {};
    const formErrors = [];
    for (const sub of this.issues) {
      if (sub.path.length > 0) {
        const firstEl = sub.path[0];
        fieldErrors[firstEl] = fieldErrors[firstEl] || [];
        fieldErrors[firstEl].push(mapper(sub));
      } else {
        formErrors.push(mapper(sub));
      }
    }
    return { formErrors, fieldErrors };
  }
  get formErrors() {
    return this.flatten();
  }
};
ZodError2.create = (issues) => {
  const error3 = new ZodError2(issues);
  return error3;
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v3/locales/en.js
var errorMap = (issue2, _ctx) => {
  let message;
  switch (issue2.code) {
    case ZodIssueCode.invalid_type:
      if (issue2.received === ZodParsedType.undefined) {
        message = "Required";
      } else {
        message = `Expected ${issue2.expected}, received ${issue2.received}`;
      }
      break;
    case ZodIssueCode.invalid_literal:
      message = `Invalid literal value, expected ${JSON.stringify(issue2.expected, util.jsonStringifyReplacer)}`;
      break;
    case ZodIssueCode.unrecognized_keys:
      message = `Unrecognized key(s) in object: ${util.joinValues(issue2.keys, ", ")}`;
      break;
    case ZodIssueCode.invalid_union:
      message = `Invalid input`;
      break;
    case ZodIssueCode.invalid_union_discriminator:
      message = `Invalid discriminator value. Expected ${util.joinValues(issue2.options)}`;
      break;
    case ZodIssueCode.invalid_enum_value:
      message = `Invalid enum value. Expected ${util.joinValues(issue2.options)}, received '${issue2.received}'`;
      break;
    case ZodIssueCode.invalid_arguments:
      message = `Invalid function arguments`;
      break;
    case ZodIssueCode.invalid_return_type:
      message = `Invalid function return type`;
      break;
    case ZodIssueCode.invalid_date:
      message = `Invalid date`;
      break;
    case ZodIssueCode.invalid_string:
      if (typeof issue2.validation === "object") {
        if ("includes" in issue2.validation) {
          message = `Invalid input: must include "${issue2.validation.includes}"`;
          if (typeof issue2.validation.position === "number") {
            message = `${message} at one or more positions greater than or equal to ${issue2.validation.position}`;
          }
        } else if ("startsWith" in issue2.validation) {
          message = `Invalid input: must start with "${issue2.validation.startsWith}"`;
        } else if ("endsWith" in issue2.validation) {
          message = `Invalid input: must end with "${issue2.validation.endsWith}"`;
        } else {
          util.assertNever(issue2.validation);
        }
      } else if (issue2.validation !== "regex") {
        message = `Invalid ${issue2.validation}`;
      } else {
        message = "Invalid";
      }
      break;
    case ZodIssueCode.too_small:
      if (issue2.type === "array")
        message = `Array must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `more than`} ${issue2.minimum} element(s)`;
      else if (issue2.type === "string")
        message = `String must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `over`} ${issue2.minimum} character(s)`;
      else if (issue2.type === "number")
        message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`;
      else if (issue2.type === "bigint")
        message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`;
      else if (issue2.type === "date")
        message = `Date must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue2.minimum))}`;
      else
        message = "Invalid input";
      break;
    case ZodIssueCode.too_big:
      if (issue2.type === "array")
        message = `Array must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `less than`} ${issue2.maximum} element(s)`;
      else if (issue2.type === "string")
        message = `String must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `under`} ${issue2.maximum} character(s)`;
      else if (issue2.type === "number")
        message = `Number must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`;
      else if (issue2.type === "bigint")
        message = `BigInt must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`;
      else if (issue2.type === "date")
        message = `Date must be ${issue2.exact ? `exactly` : issue2.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue2.maximum))}`;
      else
        message = "Invalid input";
      break;
    case ZodIssueCode.custom:
      message = `Invalid input`;
      break;
    case ZodIssueCode.invalid_intersection_types:
      message = `Intersection results could not be merged`;
      break;
    case ZodIssueCode.not_multiple_of:
      message = `Number must be a multiple of ${issue2.multipleOf}`;
      break;
    case ZodIssueCode.not_finite:
      message = "Number must be finite";
      break;
    default:
      message = _ctx.defaultError;
      util.assertNever(issue2);
  }
  return { message };
};
var en_default2 = errorMap;

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v3/errors.js
var overrideErrorMap = en_default2;
function getErrorMap() {
  return overrideErrorMap;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v3/helpers/parseUtil.js
var makeIssue = (params) => {
  const { data, path, errorMaps, issueData } = params;
  const fullPath = [...path, ...issueData.path || []];
  const fullIssue = {
    ...issueData,
    path: fullPath
  };
  if (issueData.message !== void 0) {
    return {
      ...issueData,
      path: fullPath,
      message: issueData.message
    };
  }
  let errorMessage = "";
  const maps = errorMaps.filter((m) => !!m).slice().reverse();
  for (const map of maps) {
    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
  }
  return {
    ...issueData,
    path: fullPath,
    message: errorMessage
  };
};
function addIssueToContext(ctx, issueData) {
  const overrideMap = getErrorMap();
  const issue2 = makeIssue({
    issueData,
    data: ctx.data,
    path: ctx.path,
    errorMaps: [
      ctx.common.contextualErrorMap,
      // contextual error map is first priority
      ctx.schemaErrorMap,
      // then schema-bound map if available
      overrideMap,
      // then global override map
      overrideMap === en_default2 ? void 0 : en_default2
      // then global default map
    ].filter((x) => !!x)
  });
  ctx.common.issues.push(issue2);
}
var ParseStatus = class _ParseStatus {
  constructor() {
    this.value = "valid";
  }
  dirty() {
    if (this.value === "valid")
      this.value = "dirty";
  }
  abort() {
    if (this.value !== "aborted")
      this.value = "aborted";
  }
  static mergeArray(status, results2) {
    const arrayValue = [];
    for (const s of results2) {
      if (s.status === "aborted")
        return INVALID;
      if (s.status === "dirty")
        status.dirty();
      arrayValue.push(s.value);
    }
    return { status: status.value, value: arrayValue };
  }
  static async mergeObjectAsync(status, pairs) {
    const syncPairs = [];
    for (const pair of pairs) {
      const key = await pair.key;
      const value = await pair.value;
      syncPairs.push({
        key,
        value
      });
    }
    return _ParseStatus.mergeObjectSync(status, syncPairs);
  }
  static mergeObjectSync(status, pairs) {
    const finalObject = {};
    for (const pair of pairs) {
      const { key, value } = pair;
      if (key.status === "aborted")
        return INVALID;
      if (value.status === "aborted")
        return INVALID;
      if (key.status === "dirty")
        status.dirty();
      if (value.status === "dirty")
        status.dirty();
      if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
        finalObject[key.value] = value.value;
      }
    }
    return { status: status.value, value: finalObject };
  }
};
var INVALID = Object.freeze({
  status: "aborted"
});
var DIRTY = (value) => ({ status: "dirty", value });
var OK = (value) => ({ status: "valid", value });
var isAborted = (x) => x.status === "aborted";
var isDirty = (x) => x.status === "dirty";
var isValid = (x) => x.status === "valid";
var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v3/helpers/errorUtil.js
var errorUtil;
(function(errorUtil4) {
  errorUtil4.errToObj = (message) => typeof message === "string" ? { message } : message || {};
  errorUtil4.toString = (message) => typeof message === "string" ? message : message?.message;
})(errorUtil || (errorUtil = {}));

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v3/types.js
var ParseInputLazyPath = class {
  constructor(parent, value, path, key) {
    this._cachedPath = [];
    this.parent = parent;
    this.data = value;
    this._path = path;
    this._key = key;
  }
  get path() {
    if (!this._cachedPath.length) {
      if (Array.isArray(this._key)) {
        this._cachedPath.push(...this._path, ...this._key);
      } else {
        this._cachedPath.push(...this._path, this._key);
      }
    }
    return this._cachedPath;
  }
};
var handleResult = (ctx, result) => {
  if (isValid(result)) {
    return { success: true, data: result.value };
  } else {
    if (!ctx.common.issues.length) {
      throw new Error("Validation failed but no issues detected.");
    }
    return {
      success: false,
      get error() {
        if (this._error)
          return this._error;
        const error3 = new ZodError2(ctx.common.issues);
        this._error = error3;
        return this._error;
      }
    };
  }
};
function processCreateParams(params) {
  if (!params)
    return {};
  const { errorMap: errorMap4, invalid_type_error, required_error, description } = params;
  if (errorMap4 && (invalid_type_error || required_error)) {
    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
  }
  if (errorMap4)
    return { errorMap: errorMap4, description };
  const customMap = (iss, ctx) => {
    const { message } = params;
    if (iss.code === "invalid_enum_value") {
      return { message: message ?? ctx.defaultError };
    }
    if (typeof ctx.data === "undefined") {
      return { message: message ?? required_error ?? ctx.defaultError };
    }
    if (iss.code !== "invalid_type")
      return { message: ctx.defaultError };
    return { message: message ?? invalid_type_error ?? ctx.defaultError };
  };
  return { errorMap: customMap, description };
}
var ZodType2 = class {
  get description() {
    return this._def.description;
  }
  _getType(input) {
    return getParsedType2(input.data);
  }
  _getOrReturnCtx(input, ctx) {
    return ctx || {
      common: input.parent.common,
      data: input.data,
      parsedType: getParsedType2(input.data),
      schemaErrorMap: this._def.errorMap,
      path: input.path,
      parent: input.parent
    };
  }
  _processInputParams(input) {
    return {
      status: new ParseStatus(),
      ctx: {
        common: input.parent.common,
        data: input.data,
        parsedType: getParsedType2(input.data),
        schemaErrorMap: this._def.errorMap,
        path: input.path,
        parent: input.parent
      }
    };
  }
  _parseSync(input) {
    const result = this._parse(input);
    if (isAsync(result)) {
      throw new Error("Synchronous parse encountered promise.");
    }
    return result;
  }
  _parseAsync(input) {
    const result = this._parse(input);
    return Promise.resolve(result);
  }
  parse(data, params) {
    const result = this.safeParse(data, params);
    if (result.success)
      return result.data;
    throw result.error;
  }
  safeParse(data, params) {
    const ctx = {
      common: {
        issues: [],
        async: params?.async ?? false,
        contextualErrorMap: params?.errorMap
      },
      path: params?.path || [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType2(data)
    };
    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
    return handleResult(ctx, result);
  }
  "~validate"(data) {
    const ctx = {
      common: {
        issues: [],
        async: !!this["~standard"].async
      },
      path: [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType2(data)
    };
    if (!this["~standard"].async) {
      try {
        const result = this._parseSync({ data, path: [], parent: ctx });
        return isValid(result) ? {
          value: result.value
        } : {
          issues: ctx.common.issues
        };
      } catch (err) {
        if (err?.message?.toLowerCase()?.includes("encountered")) {
          this["~standard"].async = true;
        }
        ctx.common = {
          issues: [],
          async: true
        };
      }
    }
    return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
      value: result.value
    } : {
      issues: ctx.common.issues
    });
  }
  async parseAsync(data, params) {
    const result = await this.safeParseAsync(data, params);
    if (result.success)
      return result.data;
    throw result.error;
  }
  async safeParseAsync(data, params) {
    const ctx = {
      common: {
        issues: [],
        contextualErrorMap: params?.errorMap,
        async: true
      },
      path: params?.path || [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType2(data)
    };
    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
    const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
    return handleResult(ctx, result);
  }
  refine(check2, message) {
    const getIssueProperties = (val) => {
      if (typeof message === "string" || typeof message === "undefined") {
        return { message };
      } else if (typeof message === "function") {
        return message(val);
      } else {
        return message;
      }
    };
    return this._refinement((val, ctx) => {
      const result = check2(val);
      const setError = () => ctx.addIssue({
        code: ZodIssueCode.custom,
        ...getIssueProperties(val)
      });
      if (typeof Promise !== "undefined" && result instanceof Promise) {
        return result.then((data) => {
          if (!data) {
            setError();
            return false;
          } else {
            return true;
          }
        });
      }
      if (!result) {
        setError();
        return false;
      } else {
        return true;
      }
    });
  }
  refinement(check2, refinementData) {
    return this._refinement((val, ctx) => {
      if (!check2(val)) {
        ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
        return false;
      } else {
        return true;
      }
    });
  }
  _refinement(refinement) {
    return new ZodEffects({
      schema: this,
      typeName: ZodFirstPartyTypeKind.ZodEffects,
      effect: { type: "refinement", refinement }
    });
  }
  superRefine(refinement) {
    return this._refinement(refinement);
  }
  constructor(def) {
    this.spa = this.safeParseAsync;
    this._def = def;
    this.parse = this.parse.bind(this);
    this.safeParse = this.safeParse.bind(this);
    this.parseAsync = this.parseAsync.bind(this);
    this.safeParseAsync = this.safeParseAsync.bind(this);
    this.spa = this.spa.bind(this);
    this.refine = this.refine.bind(this);
    this.refinement = this.refinement.bind(this);
    this.superRefine = this.superRefine.bind(this);
    this.optional = this.optional.bind(this);
    this.nullable = this.nullable.bind(this);
    this.nullish = this.nullish.bind(this);
    this.array = this.array.bind(this);
    this.promise = this.promise.bind(this);
    this.or = this.or.bind(this);
    this.and = this.and.bind(this);
    this.transform = this.transform.bind(this);
    this.brand = this.brand.bind(this);
    this.default = this.default.bind(this);
    this.catch = this.catch.bind(this);
    this.describe = this.describe.bind(this);
    this.pipe = this.pipe.bind(this);
    this.readonly = this.readonly.bind(this);
    this.isNullable = this.isNullable.bind(this);
    this.isOptional = this.isOptional.bind(this);
    this["~standard"] = {
      version: 1,
      vendor: "zod",
      validate: (data) => this["~validate"](data)
    };
  }
  optional() {
    return ZodOptional2.create(this, this._def);
  }
  nullable() {
    return ZodNullable2.create(this, this._def);
  }
  nullish() {
    return this.nullable().optional();
  }
  array() {
    return ZodArray2.create(this);
  }
  promise() {
    return ZodPromise.create(this, this._def);
  }
  or(option) {
    return ZodUnion2.create([this, option], this._def);
  }
  and(incoming) {
    return ZodIntersection2.create(this, incoming, this._def);
  }
  transform(transform2) {
    return new ZodEffects({
      ...processCreateParams(this._def),
      schema: this,
      typeName: ZodFirstPartyTypeKind.ZodEffects,
      effect: { type: "transform", transform: transform2 }
    });
  }
  default(def) {
    const defaultValueFunc = typeof def === "function" ? def : () => def;
    return new ZodDefault2({
      ...processCreateParams(this._def),
      innerType: this,
      defaultValue: defaultValueFunc,
      typeName: ZodFirstPartyTypeKind.ZodDefault
    });
  }
  brand() {
    return new ZodBranded({
      typeName: ZodFirstPartyTypeKind.ZodBranded,
      type: this,
      ...processCreateParams(this._def)
    });
  }
  catch(def) {
    const catchValueFunc = typeof def === "function" ? def : () => def;
    return new ZodCatch2({
      ...processCreateParams(this._def),
      innerType: this,
      catchValue: catchValueFunc,
      typeName: ZodFirstPartyTypeKind.ZodCatch
    });
  }
  describe(description) {
    const This = this.constructor;
    return new This({
      ...this._def,
      description
    });
  }
  pipe(target) {
    return ZodPipeline.create(this, target);
  }
  readonly() {
    return ZodReadonly2.create(this);
  }
  isOptional() {
    return this.safeParse(void 0).success;
  }
  isNullable() {
    return this.safeParse(null).success;
  }
};
var cuidRegex = /^c[^\s-]{8,}$/i;
var cuid2Regex = /^[0-9a-z]+$/;
var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
var nanoidRegex = /^[a-z0-9_-]{21}$/i;
var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
var emojiRegex;
var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
var ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
var ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
var dateRegex = new RegExp(`^${dateRegexSource}$`);
function timeRegexSource(args) {
  let secondsRegexSource = `[0-5]\\d`;
  if (args.precision) {
    secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
  } else if (args.precision == null) {
    secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
  }
  const secondsQuantifier = args.precision ? "+" : "?";
  return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
}
function timeRegex(args) {
  return new RegExp(`^${timeRegexSource(args)}$`);
}
function datetimeRegex(args) {
  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
  const opts = [];
  opts.push(args.local ? `Z?` : `Z`);
  if (args.offset)
    opts.push(`([+-]\\d{2}:?\\d{2})`);
  regex = `${regex}(${opts.join("|")})`;
  return new RegExp(`^${regex}$`);
}
function isValidIP(ip, version2) {
  if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) {
    return true;
  }
  if ((version2 === "v6" || !version2) && ipv6Regex.test(ip)) {
    return true;
  }
  return false;
}
function isValidJWT2(jwt, alg) {
  if (!jwtRegex.test(jwt))
    return false;
  try {
    const [header] = jwt.split(".");
    if (!header)
      return false;
    const base642 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
    const decoded = JSON.parse(atob(base642));
    if (typeof decoded !== "object" || decoded === null)
      return false;
    if ("typ" in decoded && decoded?.typ !== "JWT")
      return false;
    if (!decoded.alg)
      return false;
    if (alg && decoded.alg !== alg)
      return false;
    return true;
  } catch {
    return false;
  }
}
function isValidCidr(ip, version2) {
  if ((version2 === "v4" || !version2) && ipv4CidrRegex.test(ip)) {
    return true;
  }
  if ((version2 === "v6" || !version2) && ipv6CidrRegex.test(ip)) {
    return true;
  }
  return false;
}
var ZodString2 = class _ZodString2 extends ZodType2 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = String(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.string) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext(ctx2, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.string,
        received: ctx2.parsedType
      });
      return INVALID;
    }
    const status = new ParseStatus();
    let ctx = void 0;
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        if (input.data.length < check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_small,
            minimum: check2.value,
            type: "string",
            inclusive: true,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        if (input.data.length > check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_big,
            maximum: check2.value,
            type: "string",
            inclusive: true,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "length") {
        const tooBig = input.data.length > check2.value;
        const tooSmall = input.data.length < check2.value;
        if (tooBig || tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          if (tooBig) {
            addIssueToContext(ctx, {
              code: ZodIssueCode.too_big,
              maximum: check2.value,
              type: "string",
              inclusive: true,
              exact: true,
              message: check2.message
            });
          } else if (tooSmall) {
            addIssueToContext(ctx, {
              code: ZodIssueCode.too_small,
              minimum: check2.value,
              type: "string",
              inclusive: true,
              exact: true,
              message: check2.message
            });
          }
          status.dirty();
        }
      } else if (check2.kind === "email") {
        if (!emailRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "email",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "emoji") {
        if (!emojiRegex) {
          emojiRegex = new RegExp(_emojiRegex, "u");
        }
        if (!emojiRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "emoji",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "uuid") {
        if (!uuidRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "uuid",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "nanoid") {
        if (!nanoidRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "nanoid",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cuid") {
        if (!cuidRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "cuid",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cuid2") {
        if (!cuid2Regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "cuid2",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "ulid") {
        if (!ulidRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "ulid",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "url") {
        try {
          new URL(input.data);
        } catch {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "url",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "regex") {
        check2.regex.lastIndex = 0;
        const testResult = check2.regex.test(input.data);
        if (!testResult) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "regex",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "trim") {
        input.data = input.data.trim();
      } else if (check2.kind === "includes") {
        if (!input.data.includes(check2.value, check2.position)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_string,
            validation: { includes: check2.value, position: check2.position },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "toLowerCase") {
        input.data = input.data.toLowerCase();
      } else if (check2.kind === "toUpperCase") {
        input.data = input.data.toUpperCase();
      } else if (check2.kind === "startsWith") {
        if (!input.data.startsWith(check2.value)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_string,
            validation: { startsWith: check2.value },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "endsWith") {
        if (!input.data.endsWith(check2.value)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_string,
            validation: { endsWith: check2.value },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "datetime") {
        const regex = datetimeRegex(check2);
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_string,
            validation: "datetime",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "date") {
        const regex = dateRegex;
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_string,
            validation: "date",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "time") {
        const regex = timeRegex(check2);
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_string,
            validation: "time",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "duration") {
        if (!durationRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "duration",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "ip") {
        if (!isValidIP(input.data, check2.version)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "ip",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "jwt") {
        if (!isValidJWT2(input.data, check2.alg)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "jwt",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cidr") {
        if (!isValidCidr(input.data, check2.version)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "cidr",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "base64") {
        if (!base64Regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "base64",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "base64url") {
        if (!base64urlRegex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            validation: "base64url",
            code: ZodIssueCode.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  _regex(regex, validation, message) {
    return this.refinement((data) => regex.test(data), {
      validation,
      code: ZodIssueCode.invalid_string,
      ...errorUtil.errToObj(message)
    });
  }
  _addCheck(check2) {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  email(message) {
    return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
  }
  url(message) {
    return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
  }
  emoji(message) {
    return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
  }
  uuid(message) {
    return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
  }
  nanoid(message) {
    return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
  }
  cuid(message) {
    return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
  }
  cuid2(message) {
    return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
  }
  ulid(message) {
    return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
  }
  base64(message) {
    return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
  }
  base64url(message) {
    return this._addCheck({
      kind: "base64url",
      ...errorUtil.errToObj(message)
    });
  }
  jwt(options) {
    return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) });
  }
  ip(options) {
    return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
  }
  cidr(options) {
    return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
  }
  datetime(options) {
    if (typeof options === "string") {
      return this._addCheck({
        kind: "datetime",
        precision: null,
        offset: false,
        local: false,
        message: options
      });
    }
    return this._addCheck({
      kind: "datetime",
      precision: typeof options?.precision === "undefined" ? null : options?.precision,
      offset: options?.offset ?? false,
      local: options?.local ?? false,
      ...errorUtil.errToObj(options?.message)
    });
  }
  date(message) {
    return this._addCheck({ kind: "date", message });
  }
  time(options) {
    if (typeof options === "string") {
      return this._addCheck({
        kind: "time",
        precision: null,
        message: options
      });
    }
    return this._addCheck({
      kind: "time",
      precision: typeof options?.precision === "undefined" ? null : options?.precision,
      ...errorUtil.errToObj(options?.message)
    });
  }
  duration(message) {
    return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
  }
  regex(regex, message) {
    return this._addCheck({
      kind: "regex",
      regex,
      ...errorUtil.errToObj(message)
    });
  }
  includes(value, options) {
    return this._addCheck({
      kind: "includes",
      value,
      position: options?.position,
      ...errorUtil.errToObj(options?.message)
    });
  }
  startsWith(value, message) {
    return this._addCheck({
      kind: "startsWith",
      value,
      ...errorUtil.errToObj(message)
    });
  }
  endsWith(value, message) {
    return this._addCheck({
      kind: "endsWith",
      value,
      ...errorUtil.errToObj(message)
    });
  }
  min(minLength, message) {
    return this._addCheck({
      kind: "min",
      value: minLength,
      ...errorUtil.errToObj(message)
    });
  }
  max(maxLength, message) {
    return this._addCheck({
      kind: "max",
      value: maxLength,
      ...errorUtil.errToObj(message)
    });
  }
  length(len, message) {
    return this._addCheck({
      kind: "length",
      value: len,
      ...errorUtil.errToObj(message)
    });
  }
  /**
   * Equivalent to `.min(1)`
   */
  nonempty(message) {
    return this.min(1, errorUtil.errToObj(message));
  }
  trim() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "trim" }]
    });
  }
  toLowerCase() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "toLowerCase" }]
    });
  }
  toUpperCase() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "toUpperCase" }]
    });
  }
  get isDatetime() {
    return !!this._def.checks.find((ch) => ch.kind === "datetime");
  }
  get isDate() {
    return !!this._def.checks.find((ch) => ch.kind === "date");
  }
  get isTime() {
    return !!this._def.checks.find((ch) => ch.kind === "time");
  }
  get isDuration() {
    return !!this._def.checks.find((ch) => ch.kind === "duration");
  }
  get isEmail() {
    return !!this._def.checks.find((ch) => ch.kind === "email");
  }
  get isURL() {
    return !!this._def.checks.find((ch) => ch.kind === "url");
  }
  get isEmoji() {
    return !!this._def.checks.find((ch) => ch.kind === "emoji");
  }
  get isUUID() {
    return !!this._def.checks.find((ch) => ch.kind === "uuid");
  }
  get isNANOID() {
    return !!this._def.checks.find((ch) => ch.kind === "nanoid");
  }
  get isCUID() {
    return !!this._def.checks.find((ch) => ch.kind === "cuid");
  }
  get isCUID2() {
    return !!this._def.checks.find((ch) => ch.kind === "cuid2");
  }
  get isULID() {
    return !!this._def.checks.find((ch) => ch.kind === "ulid");
  }
  get isIP() {
    return !!this._def.checks.find((ch) => ch.kind === "ip");
  }
  get isCIDR() {
    return !!this._def.checks.find((ch) => ch.kind === "cidr");
  }
  get isBase64() {
    return !!this._def.checks.find((ch) => ch.kind === "base64");
  }
  get isBase64url() {
    return !!this._def.checks.find((ch) => ch.kind === "base64url");
  }
  get minLength() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxLength() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
};
ZodString2.create = (params) => {
  return new ZodString2({
    checks: [],
    typeName: ZodFirstPartyTypeKind.ZodString,
    coerce: params?.coerce ?? false,
    ...processCreateParams(params)
  });
};
function floatSafeRemainder2(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepDecCount = (step.toString().split(".")[1] || "").length;
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
var ZodNumber2 = class _ZodNumber extends ZodType2 {
  constructor() {
    super(...arguments);
    this.min = this.gte;
    this.max = this.lte;
    this.step = this.multipleOf;
  }
  _parse(input) {
    if (this._def.coerce) {
      input.data = Number(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.number) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext(ctx2, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.number,
        received: ctx2.parsedType
      });
      return INVALID;
    }
    let ctx = void 0;
    const status = new ParseStatus();
    for (const check2 of this._def.checks) {
      if (check2.kind === "int") {
        if (!util.isInteger(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: "integer",
            received: "float",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "min") {
        const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
        if (tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_small,
            minimum: check2.value,
            type: "number",
            inclusive: check2.inclusive,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
        if (tooBig) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_big,
            maximum: check2.value,
            type: "number",
            inclusive: check2.inclusive,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "multipleOf") {
        if (floatSafeRemainder2(input.data, check2.value) !== 0) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.not_multiple_of,
            multipleOf: check2.value,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "finite") {
        if (!Number.isFinite(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.not_finite,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  gte(value, message) {
    return this.setLimit("min", value, true, errorUtil.toString(message));
  }
  gt(value, message) {
    return this.setLimit("min", value, false, errorUtil.toString(message));
  }
  lte(value, message) {
    return this.setLimit("max", value, true, errorUtil.toString(message));
  }
  lt(value, message) {
    return this.setLimit("max", value, false, errorUtil.toString(message));
  }
  setLimit(kind, value, inclusive, message) {
    return new _ZodNumber({
      ...this._def,
      checks: [
        ...this._def.checks,
        {
          kind,
          value,
          inclusive,
          message: errorUtil.toString(message)
        }
      ]
    });
  }
  _addCheck(check2) {
    return new _ZodNumber({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  int(message) {
    return this._addCheck({
      kind: "int",
      message: errorUtil.toString(message)
    });
  }
  positive(message) {
    return this._addCheck({
      kind: "min",
      value: 0,
      inclusive: false,
      message: errorUtil.toString(message)
    });
  }
  negative(message) {
    return this._addCheck({
      kind: "max",
      value: 0,
      inclusive: false,
      message: errorUtil.toString(message)
    });
  }
  nonpositive(message) {
    return this._addCheck({
      kind: "max",
      value: 0,
      inclusive: true,
      message: errorUtil.toString(message)
    });
  }
  nonnegative(message) {
    return this._addCheck({
      kind: "min",
      value: 0,
      inclusive: true,
      message: errorUtil.toString(message)
    });
  }
  multipleOf(value, message) {
    return this._addCheck({
      kind: "multipleOf",
      value,
      message: errorUtil.toString(message)
    });
  }
  finite(message) {
    return this._addCheck({
      kind: "finite",
      message: errorUtil.toString(message)
    });
  }
  safe(message) {
    return this._addCheck({
      kind: "min",
      inclusive: true,
      value: Number.MIN_SAFE_INTEGER,
      message: errorUtil.toString(message)
    })._addCheck({
      kind: "max",
      inclusive: true,
      value: Number.MAX_SAFE_INTEGER,
      message: errorUtil.toString(message)
    });
  }
  get minValue() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxValue() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
  get isInt() {
    return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
  }
  get isFinite() {
    let max = null;
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
        return true;
      } else if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      } else if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return Number.isFinite(min) && Number.isFinite(max);
  }
};
ZodNumber2.create = (params) => {
  return new ZodNumber2({
    checks: [],
    typeName: ZodFirstPartyTypeKind.ZodNumber,
    coerce: params?.coerce || false,
    ...processCreateParams(params)
  });
};
var ZodBigInt = class _ZodBigInt extends ZodType2 {
  constructor() {
    super(...arguments);
    this.min = this.gte;
    this.max = this.lte;
  }
  _parse(input) {
    if (this._def.coerce) {
      try {
        input.data = BigInt(input.data);
      } catch {
        return this._getInvalidInput(input);
      }
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.bigint) {
      return this._getInvalidInput(input);
    }
    let ctx = void 0;
    const status = new ParseStatus();
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
        if (tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_small,
            type: "bigint",
            minimum: check2.value,
            inclusive: check2.inclusive,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
        if (tooBig) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_big,
            type: "bigint",
            maximum: check2.value,
            inclusive: check2.inclusive,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "multipleOf") {
        if (input.data % check2.value !== BigInt(0)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.not_multiple_of,
            multipleOf: check2.value,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  _getInvalidInput(input) {
    const ctx = this._getOrReturnCtx(input);
    addIssueToContext(ctx, {
      code: ZodIssueCode.invalid_type,
      expected: ZodParsedType.bigint,
      received: ctx.parsedType
    });
    return INVALID;
  }
  gte(value, message) {
    return this.setLimit("min", value, true, errorUtil.toString(message));
  }
  gt(value, message) {
    return this.setLimit("min", value, false, errorUtil.toString(message));
  }
  lte(value, message) {
    return this.setLimit("max", value, true, errorUtil.toString(message));
  }
  lt(value, message) {
    return this.setLimit("max", value, false, errorUtil.toString(message));
  }
  setLimit(kind, value, inclusive, message) {
    return new _ZodBigInt({
      ...this._def,
      checks: [
        ...this._def.checks,
        {
          kind,
          value,
          inclusive,
          message: errorUtil.toString(message)
        }
      ]
    });
  }
  _addCheck(check2) {
    return new _ZodBigInt({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  positive(message) {
    return this._addCheck({
      kind: "min",
      value: BigInt(0),
      inclusive: false,
      message: errorUtil.toString(message)
    });
  }
  negative(message) {
    return this._addCheck({
      kind: "max",
      value: BigInt(0),
      inclusive: false,
      message: errorUtil.toString(message)
    });
  }
  nonpositive(message) {
    return this._addCheck({
      kind: "max",
      value: BigInt(0),
      inclusive: true,
      message: errorUtil.toString(message)
    });
  }
  nonnegative(message) {
    return this._addCheck({
      kind: "min",
      value: BigInt(0),
      inclusive: true,
      message: errorUtil.toString(message)
    });
  }
  multipleOf(value, message) {
    return this._addCheck({
      kind: "multipleOf",
      value,
      message: errorUtil.toString(message)
    });
  }
  get minValue() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxValue() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
};
ZodBigInt.create = (params) => {
  return new ZodBigInt({
    checks: [],
    typeName: ZodFirstPartyTypeKind.ZodBigInt,
    coerce: params?.coerce ?? false,
    ...processCreateParams(params)
  });
};
var ZodBoolean2 = class extends ZodType2 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = Boolean(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.boolean) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.boolean,
        received: ctx.parsedType
      });
      return INVALID;
    }
    return OK(input.data);
  }
};
ZodBoolean2.create = (params) => {
  return new ZodBoolean2({
    typeName: ZodFirstPartyTypeKind.ZodBoolean,
    coerce: params?.coerce || false,
    ...processCreateParams(params)
  });
};
var ZodDate = class _ZodDate extends ZodType2 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = new Date(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.date) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext(ctx2, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.date,
        received: ctx2.parsedType
      });
      return INVALID;
    }
    if (Number.isNaN(input.data.getTime())) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext(ctx2, {
        code: ZodIssueCode.invalid_date
      });
      return INVALID;
    }
    const status = new ParseStatus();
    let ctx = void 0;
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        if (input.data.getTime() < check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_small,
            message: check2.message,
            inclusive: true,
            exact: false,
            minimum: check2.value,
            type: "date"
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        if (input.data.getTime() > check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_big,
            message: check2.message,
            inclusive: true,
            exact: false,
            maximum: check2.value,
            type: "date"
          });
          status.dirty();
        }
      } else {
        util.assertNever(check2);
      }
    }
    return {
      status: status.value,
      value: new Date(input.data.getTime())
    };
  }
  _addCheck(check2) {
    return new _ZodDate({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  min(minDate, message) {
    return this._addCheck({
      kind: "min",
      value: minDate.getTime(),
      message: errorUtil.toString(message)
    });
  }
  max(maxDate, message) {
    return this._addCheck({
      kind: "max",
      value: maxDate.getTime(),
      message: errorUtil.toString(message)
    });
  }
  get minDate() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min != null ? new Date(min) : null;
  }
  get maxDate() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max != null ? new Date(max) : null;
  }
};
ZodDate.create = (params) => {
  return new ZodDate({
    checks: [],
    coerce: params?.coerce || false,
    typeName: ZodFirstPartyTypeKind.ZodDate,
    ...processCreateParams(params)
  });
};
var ZodSymbol = class extends ZodType2 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.symbol) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.symbol,
        received: ctx.parsedType
      });
      return INVALID;
    }
    return OK(input.data);
  }
};
ZodSymbol.create = (params) => {
  return new ZodSymbol({
    typeName: ZodFirstPartyTypeKind.ZodSymbol,
    ...processCreateParams(params)
  });
};
var ZodUndefined = class extends ZodType2 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.undefined) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.undefined,
        received: ctx.parsedType
      });
      return INVALID;
    }
    return OK(input.data);
  }
};
ZodUndefined.create = (params) => {
  return new ZodUndefined({
    typeName: ZodFirstPartyTypeKind.ZodUndefined,
    ...processCreateParams(params)
  });
};
var ZodNull2 = class extends ZodType2 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.null) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.null,
        received: ctx.parsedType
      });
      return INVALID;
    }
    return OK(input.data);
  }
};
ZodNull2.create = (params) => {
  return new ZodNull2({
    typeName: ZodFirstPartyTypeKind.ZodNull,
    ...processCreateParams(params)
  });
};
var ZodAny = class extends ZodType2 {
  constructor() {
    super(...arguments);
    this._any = true;
  }
  _parse(input) {
    return OK(input.data);
  }
};
ZodAny.create = (params) => {
  return new ZodAny({
    typeName: ZodFirstPartyTypeKind.ZodAny,
    ...processCreateParams(params)
  });
};
var ZodUnknown2 = class extends ZodType2 {
  constructor() {
    super(...arguments);
    this._unknown = true;
  }
  _parse(input) {
    return OK(input.data);
  }
};
ZodUnknown2.create = (params) => {
  return new ZodUnknown2({
    typeName: ZodFirstPartyTypeKind.ZodUnknown,
    ...processCreateParams(params)
  });
};
var ZodNever2 = class extends ZodType2 {
  _parse(input) {
    const ctx = this._getOrReturnCtx(input);
    addIssueToContext(ctx, {
      code: ZodIssueCode.invalid_type,
      expected: ZodParsedType.never,
      received: ctx.parsedType
    });
    return INVALID;
  }
};
ZodNever2.create = (params) => {
  return new ZodNever2({
    typeName: ZodFirstPartyTypeKind.ZodNever,
    ...processCreateParams(params)
  });
};
var ZodVoid = class extends ZodType2 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.undefined) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.void,
        received: ctx.parsedType
      });
      return INVALID;
    }
    return OK(input.data);
  }
};
ZodVoid.create = (params) => {
  return new ZodVoid({
    typeName: ZodFirstPartyTypeKind.ZodVoid,
    ...processCreateParams(params)
  });
};
var ZodArray2 = class _ZodArray extends ZodType2 {
  _parse(input) {
    const { ctx, status } = this._processInputParams(input);
    const def = this._def;
    if (ctx.parsedType !== ZodParsedType.array) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.array,
        received: ctx.parsedType
      });
      return INVALID;
    }
    if (def.exactLength !== null) {
      const tooBig = ctx.data.length > def.exactLength.value;
      const tooSmall = ctx.data.length < def.exactLength.value;
      if (tooBig || tooSmall) {
        addIssueToContext(ctx, {
          code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
          minimum: tooSmall ? def.exactLength.value : void 0,
          maximum: tooBig ? def.exactLength.value : void 0,
          type: "array",
          inclusive: true,
          exact: true,
          message: def.exactLength.message
        });
        status.dirty();
      }
    }
    if (def.minLength !== null) {
      if (ctx.data.length < def.minLength.value) {
        addIssueToContext(ctx, {
          code: ZodIssueCode.too_small,
          minimum: def.minLength.value,
          type: "array",
          inclusive: true,
          exact: false,
          message: def.minLength.message
        });
        status.dirty();
      }
    }
    if (def.maxLength !== null) {
      if (ctx.data.length > def.maxLength.value) {
        addIssueToContext(ctx, {
          code: ZodIssueCode.too_big,
          maximum: def.maxLength.value,
          type: "array",
          inclusive: true,
          exact: false,
          message: def.maxLength.message
        });
        status.dirty();
      }
    }
    if (ctx.common.async) {
      return Promise.all([...ctx.data].map((item, i) => {
        return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
      })).then((result2) => {
        return ParseStatus.mergeArray(status, result2);
      });
    }
    const result = [...ctx.data].map((item, i) => {
      return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
    });
    return ParseStatus.mergeArray(status, result);
  }
  get element() {
    return this._def.type;
  }
  min(minLength, message) {
    return new _ZodArray({
      ...this._def,
      minLength: { value: minLength, message: errorUtil.toString(message) }
    });
  }
  max(maxLength, message) {
    return new _ZodArray({
      ...this._def,
      maxLength: { value: maxLength, message: errorUtil.toString(message) }
    });
  }
  length(len, message) {
    return new _ZodArray({
      ...this._def,
      exactLength: { value: len, message: errorUtil.toString(message) }
    });
  }
  nonempty(message) {
    return this.min(1, message);
  }
};
ZodArray2.create = (schema, params) => {
  return new ZodArray2({
    type: schema,
    minLength: null,
    maxLength: null,
    exactLength: null,
    typeName: ZodFirstPartyTypeKind.ZodArray,
    ...processCreateParams(params)
  });
};
function deepPartialify(schema) {
  if (schema instanceof ZodObject2) {
    const newShape = {};
    for (const key in schema.shape) {
      const fieldSchema = schema.shape[key];
      newShape[key] = ZodOptional2.create(deepPartialify(fieldSchema));
    }
    return new ZodObject2({
      ...schema._def,
      shape: () => newShape
    });
  } else if (schema instanceof ZodArray2) {
    return new ZodArray2({
      ...schema._def,
      type: deepPartialify(schema.element)
    });
  } else if (schema instanceof ZodOptional2) {
    return ZodOptional2.create(deepPartialify(schema.unwrap()));
  } else if (schema instanceof ZodNullable2) {
    return ZodNullable2.create(deepPartialify(schema.unwrap()));
  } else if (schema instanceof ZodTuple) {
    return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
  } else {
    return schema;
  }
}
var ZodObject2 = class _ZodObject extends ZodType2 {
  constructor() {
    super(...arguments);
    this._cached = null;
    this.nonstrict = this.passthrough;
    this.augment = this.extend;
  }
  _getCached() {
    if (this._cached !== null)
      return this._cached;
    const shape = this._def.shape();
    const keys = util.objectKeys(shape);
    this._cached = { shape, keys };
    return this._cached;
  }
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.object) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext(ctx2, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.object,
        received: ctx2.parsedType
      });
      return INVALID;
    }
    const { status, ctx } = this._processInputParams(input);
    const { shape, keys: shapeKeys } = this._getCached();
    const extraKeys = [];
    if (!(this._def.catchall instanceof ZodNever2 && this._def.unknownKeys === "strip")) {
      for (const key in ctx.data) {
        if (!shapeKeys.includes(key)) {
          extraKeys.push(key);
        }
      }
    }
    const pairs = [];
    for (const key of shapeKeys) {
      const keyValidator = shape[key];
      const value = ctx.data[key];
      pairs.push({
        key: { status: "valid", value: key },
        value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
        alwaysSet: key in ctx.data
      });
    }
    if (this._def.catchall instanceof ZodNever2) {
      const unknownKeys = this._def.unknownKeys;
      if (unknownKeys === "passthrough") {
        for (const key of extraKeys) {
          pairs.push({
            key: { status: "valid", value: key },
            value: { status: "valid", value: ctx.data[key] }
          });
        }
      } else if (unknownKeys === "strict") {
        if (extraKeys.length > 0) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.unrecognized_keys,
            keys: extraKeys
          });
          status.dirty();
        }
      } else if (unknownKeys === "strip") {
      } else {
        throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
      }
    } else {
      const catchall = this._def.catchall;
      for (const key of extraKeys) {
        const value = ctx.data[key];
        pairs.push({
          key: { status: "valid", value: key },
          value: catchall._parse(
            new ParseInputLazyPath(ctx, value, ctx.path, key)
            //, ctx.child(key), value, getParsedType(value)
          ),
          alwaysSet: key in ctx.data
        });
      }
    }
    if (ctx.common.async) {
      return Promise.resolve().then(async () => {
        const syncPairs = [];
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          syncPairs.push({
            key,
            value,
            alwaysSet: pair.alwaysSet
          });
        }
        return syncPairs;
      }).then((syncPairs) => {
        return ParseStatus.mergeObjectSync(status, syncPairs);
      });
    } else {
      return ParseStatus.mergeObjectSync(status, pairs);
    }
  }
  get shape() {
    return this._def.shape();
  }
  strict(message) {
    errorUtil.errToObj;
    return new _ZodObject({
      ...this._def,
      unknownKeys: "strict",
      ...message !== void 0 ? {
        errorMap: (issue2, ctx) => {
          const defaultError = this._def.errorMap?.(issue2, ctx).message ?? ctx.defaultError;
          if (issue2.code === "unrecognized_keys")
            return {
              message: errorUtil.errToObj(message).message ?? defaultError
            };
          return {
            message: defaultError
          };
        }
      } : {}
    });
  }
  strip() {
    return new _ZodObject({
      ...this._def,
      unknownKeys: "strip"
    });
  }
  passthrough() {
    return new _ZodObject({
      ...this._def,
      unknownKeys: "passthrough"
    });
  }
  // const AugmentFactory =
  //   <Def extends ZodObjectDef>(def: Def) =>
  //   <Augmentation extends ZodRawShape>(
  //     augmentation: Augmentation
  //   ): ZodObject<
  //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
  //     Def["unknownKeys"],
  //     Def["catchall"]
  //   > => {
  //     return new ZodObject({
  //       ...def,
  //       shape: () => ({
  //         ...def.shape(),
  //         ...augmentation,
  //       }),
  //     }) as any;
  //   };
  extend(augmentation) {
    return new _ZodObject({
      ...this._def,
      shape: () => ({
        ...this._def.shape(),
        ...augmentation
      })
    });
  }
  /**
   * Prior to zod@1.0.12 there was a bug in the
   * inferred type of merged objects. Please
   * upgrade if you are experiencing issues.
   */
  merge(merging) {
    const merged = new _ZodObject({
      unknownKeys: merging._def.unknownKeys,
      catchall: merging._def.catchall,
      shape: () => ({
        ...this._def.shape(),
        ...merging._def.shape()
      }),
      typeName: ZodFirstPartyTypeKind.ZodObject
    });
    return merged;
  }
  // merge<
  //   Incoming extends AnyZodObject,
  //   Augmentation extends Incoming["shape"],
  //   NewOutput extends {
  //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
  //       ? Augmentation[k]["_output"]
  //       : k extends keyof Output
  //       ? Output[k]
  //       : never;
  //   },
  //   NewInput extends {
  //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
  //       ? Augmentation[k]["_input"]
  //       : k extends keyof Input
  //       ? Input[k]
  //       : never;
  //   }
  // >(
  //   merging: Incoming
  // ): ZodObject<
  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
  //   Incoming["_def"]["unknownKeys"],
  //   Incoming["_def"]["catchall"],
  //   NewOutput,
  //   NewInput
  // > {
  //   const merged: any = new ZodObject({
  //     unknownKeys: merging._def.unknownKeys,
  //     catchall: merging._def.catchall,
  //     shape: () =>
  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
  //     typeName: ZodFirstPartyTypeKind.ZodObject,
  //   }) as any;
  //   return merged;
  // }
  setKey(key, schema) {
    return this.augment({ [key]: schema });
  }
  // merge<Incoming extends AnyZodObject>(
  //   merging: Incoming
  // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
  // ZodObject<
  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
  //   Incoming["_def"]["unknownKeys"],
  //   Incoming["_def"]["catchall"]
  // > {
  //   // const mergedShape = objectUtil.mergeShapes(
  //   //   this._def.shape(),
  //   //   merging._def.shape()
  //   // );
  //   const merged: any = new ZodObject({
  //     unknownKeys: merging._def.unknownKeys,
  //     catchall: merging._def.catchall,
  //     shape: () =>
  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
  //     typeName: ZodFirstPartyTypeKind.ZodObject,
  //   }) as any;
  //   return merged;
  // }
  catchall(index) {
    return new _ZodObject({
      ...this._def,
      catchall: index
    });
  }
  pick(mask) {
    const shape = {};
    for (const key of util.objectKeys(mask)) {
      if (mask[key] && this.shape[key]) {
        shape[key] = this.shape[key];
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => shape
    });
  }
  omit(mask) {
    const shape = {};
    for (const key of util.objectKeys(this.shape)) {
      if (!mask[key]) {
        shape[key] = this.shape[key];
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => shape
    });
  }
  /**
   * @deprecated
   */
  deepPartial() {
    return deepPartialify(this);
  }
  partial(mask) {
    const newShape = {};
    for (const key of util.objectKeys(this.shape)) {
      const fieldSchema = this.shape[key];
      if (mask && !mask[key]) {
        newShape[key] = fieldSchema;
      } else {
        newShape[key] = fieldSchema.optional();
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => newShape
    });
  }
  required(mask) {
    const newShape = {};
    for (const key of util.objectKeys(this.shape)) {
      if (mask && !mask[key]) {
        newShape[key] = this.shape[key];
      } else {
        const fieldSchema = this.shape[key];
        let newField = fieldSchema;
        while (newField instanceof ZodOptional2) {
          newField = newField._def.innerType;
        }
        newShape[key] = newField;
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => newShape
    });
  }
  keyof() {
    return createZodEnum(util.objectKeys(this.shape));
  }
};
ZodObject2.create = (shape, params) => {
  return new ZodObject2({
    shape: () => shape,
    unknownKeys: "strip",
    catchall: ZodNever2.create(),
    typeName: ZodFirstPartyTypeKind.ZodObject,
    ...processCreateParams(params)
  });
};
ZodObject2.strictCreate = (shape, params) => {
  return new ZodObject2({
    shape: () => shape,
    unknownKeys: "strict",
    catchall: ZodNever2.create(),
    typeName: ZodFirstPartyTypeKind.ZodObject,
    ...processCreateParams(params)
  });
};
ZodObject2.lazycreate = (shape, params) => {
  return new ZodObject2({
    shape,
    unknownKeys: "strip",
    catchall: ZodNever2.create(),
    typeName: ZodFirstPartyTypeKind.ZodObject,
    ...processCreateParams(params)
  });
};
var ZodUnion2 = class extends ZodType2 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const options = this._def.options;
    function handleResults(results2) {
      for (const result of results2) {
        if (result.result.status === "valid") {
          return result.result;
        }
      }
      for (const result of results2) {
        if (result.result.status === "dirty") {
          ctx.common.issues.push(...result.ctx.common.issues);
          return result.result;
        }
      }
      const unionErrors = results2.map((result) => new ZodError2(result.ctx.common.issues));
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_union,
        unionErrors
      });
      return INVALID;
    }
    if (ctx.common.async) {
      return Promise.all(options.map(async (option) => {
        const childCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          },
          parent: null
        };
        return {
          result: await option._parseAsync({
            data: ctx.data,
            path: ctx.path,
            parent: childCtx
          }),
          ctx: childCtx
        };
      })).then(handleResults);
    } else {
      let dirty = void 0;
      const issues = [];
      for (const option of options) {
        const childCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          },
          parent: null
        };
        const result = option._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: childCtx
        });
        if (result.status === "valid") {
          return result;
        } else if (result.status === "dirty" && !dirty) {
          dirty = { result, ctx: childCtx };
        }
        if (childCtx.common.issues.length) {
          issues.push(childCtx.common.issues);
        }
      }
      if (dirty) {
        ctx.common.issues.push(...dirty.ctx.common.issues);
        return dirty.result;
      }
      const unionErrors = issues.map((issues2) => new ZodError2(issues2));
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_union,
        unionErrors
      });
      return INVALID;
    }
  }
  get options() {
    return this._def.options;
  }
};
ZodUnion2.create = (types, params) => {
  return new ZodUnion2({
    options: types,
    typeName: ZodFirstPartyTypeKind.ZodUnion,
    ...processCreateParams(params)
  });
};
var getDiscriminator = (type) => {
  if (type instanceof ZodLazy) {
    return getDiscriminator(type.schema);
  } else if (type instanceof ZodEffects) {
    return getDiscriminator(type.innerType());
  } else if (type instanceof ZodLiteral2) {
    return [type.value];
  } else if (type instanceof ZodEnum2) {
    return type.options;
  } else if (type instanceof ZodNativeEnum) {
    return util.objectValues(type.enum);
  } else if (type instanceof ZodDefault2) {
    return getDiscriminator(type._def.innerType);
  } else if (type instanceof ZodUndefined) {
    return [void 0];
  } else if (type instanceof ZodNull2) {
    return [null];
  } else if (type instanceof ZodOptional2) {
    return [void 0, ...getDiscriminator(type.unwrap())];
  } else if (type instanceof ZodNullable2) {
    return [null, ...getDiscriminator(type.unwrap())];
  } else if (type instanceof ZodBranded) {
    return getDiscriminator(type.unwrap());
  } else if (type instanceof ZodReadonly2) {
    return getDiscriminator(type.unwrap());
  } else if (type instanceof ZodCatch2) {
    return getDiscriminator(type._def.innerType);
  } else {
    return [];
  }
};
var ZodDiscriminatedUnion2 = class _ZodDiscriminatedUnion extends ZodType2 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType.object) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.object,
        received: ctx.parsedType
      });
      return INVALID;
    }
    const discriminator = this.discriminator;
    const discriminatorValue = ctx.data[discriminator];
    const option = this.optionsMap.get(discriminatorValue);
    if (!option) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_union_discriminator,
        options: Array.from(this.optionsMap.keys()),
        path: [discriminator]
      });
      return INVALID;
    }
    if (ctx.common.async) {
      return option._parseAsync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
    } else {
      return option._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
    }
  }
  get discriminator() {
    return this._def.discriminator;
  }
  get options() {
    return this._def.options;
  }
  get optionsMap() {
    return this._def.optionsMap;
  }
  /**
   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
   * have a different value for each object in the union.
   * @param discriminator the name of the discriminator property
   * @param types an array of object schemas
   * @param params
   */
  static create(discriminator, options, params) {
    const optionsMap = /* @__PURE__ */ new Map();
    for (const type of options) {
      const discriminatorValues = getDiscriminator(type.shape[discriminator]);
      if (!discriminatorValues.length) {
        throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
      }
      for (const value of discriminatorValues) {
        if (optionsMap.has(value)) {
          throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
        }
        optionsMap.set(value, type);
      }
    }
    return new _ZodDiscriminatedUnion({
      typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
      discriminator,
      options,
      optionsMap,
      ...processCreateParams(params)
    });
  }
};
function mergeValues2(a, b) {
  const aType = getParsedType2(a);
  const bType = getParsedType2(b);
  if (a === b) {
    return { valid: true, data: a };
  } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
    const bKeys = util.objectKeys(b);
    const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues2(a[key], b[key]);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
    if (a.length !== b.length) {
      return { valid: false };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues2(itemA, itemB);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
    return { valid: true, data: a };
  } else {
    return { valid: false };
  }
}
var ZodIntersection2 = class extends ZodType2 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    const handleParsed = (parsedLeft, parsedRight) => {
      if (isAborted(parsedLeft) || isAborted(parsedRight)) {
        return INVALID;
      }
      const merged = mergeValues2(parsedLeft.value, parsedRight.value);
      if (!merged.valid) {
        addIssueToContext(ctx, {
          code: ZodIssueCode.invalid_intersection_types
        });
        return INVALID;
      }
      if (isDirty(parsedLeft) || isDirty(parsedRight)) {
        status.dirty();
      }
      return { status: status.value, value: merged.data };
    };
    if (ctx.common.async) {
      return Promise.all([
        this._def.left._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        }),
        this._def.right._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        })
      ]).then(([left, right]) => handleParsed(left, right));
    } else {
      return handleParsed(this._def.left._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      }), this._def.right._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      }));
    }
  }
};
ZodIntersection2.create = (left, right, params) => {
  return new ZodIntersection2({
    left,
    right,
    typeName: ZodFirstPartyTypeKind.ZodIntersection,
    ...processCreateParams(params)
  });
};
var ZodTuple = class _ZodTuple extends ZodType2 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType.array) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.array,
        received: ctx.parsedType
      });
      return INVALID;
    }
    if (ctx.data.length < this._def.items.length) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.too_small,
        minimum: this._def.items.length,
        inclusive: true,
        exact: false,
        type: "array"
      });
      return INVALID;
    }
    const rest = this._def.rest;
    if (!rest && ctx.data.length > this._def.items.length) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.too_big,
        maximum: this._def.items.length,
        inclusive: true,
        exact: false,
        type: "array"
      });
      status.dirty();
    }
    const items = [...ctx.data].map((item, itemIndex) => {
      const schema = this._def.items[itemIndex] || this._def.rest;
      if (!schema)
        return null;
      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
    }).filter((x) => !!x);
    if (ctx.common.async) {
      return Promise.all(items).then((results2) => {
        return ParseStatus.mergeArray(status, results2);
      });
    } else {
      return ParseStatus.mergeArray(status, items);
    }
  }
  get items() {
    return this._def.items;
  }
  rest(rest) {
    return new _ZodTuple({
      ...this._def,
      rest
    });
  }
};
ZodTuple.create = (schemas, params) => {
  if (!Array.isArray(schemas)) {
    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
  }
  return new ZodTuple({
    items: schemas,
    typeName: ZodFirstPartyTypeKind.ZodTuple,
    rest: null,
    ...processCreateParams(params)
  });
};
var ZodRecord2 = class _ZodRecord extends ZodType2 {
  get keySchema() {
    return this._def.keyType;
  }
  get valueSchema() {
    return this._def.valueType;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType.object) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.object,
        received: ctx.parsedType
      });
      return INVALID;
    }
    const pairs = [];
    const keyType = this._def.keyType;
    const valueType = this._def.valueType;
    for (const key in ctx.data) {
      pairs.push({
        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
        alwaysSet: key in ctx.data
      });
    }
    if (ctx.common.async) {
      return ParseStatus.mergeObjectAsync(status, pairs);
    } else {
      return ParseStatus.mergeObjectSync(status, pairs);
    }
  }
  get element() {
    return this._def.valueType;
  }
  static create(first, second, third) {
    if (second instanceof ZodType2) {
      return new _ZodRecord({
        keyType: first,
        valueType: second,
        typeName: ZodFirstPartyTypeKind.ZodRecord,
        ...processCreateParams(third)
      });
    }
    return new _ZodRecord({
      keyType: ZodString2.create(),
      valueType: first,
      typeName: ZodFirstPartyTypeKind.ZodRecord,
      ...processCreateParams(second)
    });
  }
};
var ZodMap = class extends ZodType2 {
  get keySchema() {
    return this._def.keyType;
  }
  get valueSchema() {
    return this._def.valueType;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType.map) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.map,
        received: ctx.parsedType
      });
      return INVALID;
    }
    const keyType = this._def.keyType;
    const valueType = this._def.valueType;
    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
      return {
        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
      };
    });
    if (ctx.common.async) {
      const finalMap = /* @__PURE__ */ new Map();
      return Promise.resolve().then(async () => {
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          if (key.status === "aborted" || value.status === "aborted") {
            return INVALID;
          }
          if (key.status === "dirty" || value.status === "dirty") {
            status.dirty();
          }
          finalMap.set(key.value, value.value);
        }
        return { status: status.value, value: finalMap };
      });
    } else {
      const finalMap = /* @__PURE__ */ new Map();
      for (const pair of pairs) {
        const key = pair.key;
        const value = pair.value;
        if (key.status === "aborted" || value.status === "aborted") {
          return INVALID;
        }
        if (key.status === "dirty" || value.status === "dirty") {
          status.dirty();
        }
        finalMap.set(key.value, value.value);
      }
      return { status: status.value, value: finalMap };
    }
  }
};
ZodMap.create = (keyType, valueType, params) => {
  return new ZodMap({
    valueType,
    keyType,
    typeName: ZodFirstPartyTypeKind.ZodMap,
    ...processCreateParams(params)
  });
};
var ZodSet = class _ZodSet extends ZodType2 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType.set) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.set,
        received: ctx.parsedType
      });
      return INVALID;
    }
    const def = this._def;
    if (def.minSize !== null) {
      if (ctx.data.size < def.minSize.value) {
        addIssueToContext(ctx, {
          code: ZodIssueCode.too_small,
          minimum: def.minSize.value,
          type: "set",
          inclusive: true,
          exact: false,
          message: def.minSize.message
        });
        status.dirty();
      }
    }
    if (def.maxSize !== null) {
      if (ctx.data.size > def.maxSize.value) {
        addIssueToContext(ctx, {
          code: ZodIssueCode.too_big,
          maximum: def.maxSize.value,
          type: "set",
          inclusive: true,
          exact: false,
          message: def.maxSize.message
        });
        status.dirty();
      }
    }
    const valueType = this._def.valueType;
    function finalizeSet(elements2) {
      const parsedSet = /* @__PURE__ */ new Set();
      for (const element of elements2) {
        if (element.status === "aborted")
          return INVALID;
        if (element.status === "dirty")
          status.dirty();
        parsedSet.add(element.value);
      }
      return { status: status.value, value: parsedSet };
    }
    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
    if (ctx.common.async) {
      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
    } else {
      return finalizeSet(elements);
    }
  }
  min(minSize, message) {
    return new _ZodSet({
      ...this._def,
      minSize: { value: minSize, message: errorUtil.toString(message) }
    });
  }
  max(maxSize, message) {
    return new _ZodSet({
      ...this._def,
      maxSize: { value: maxSize, message: errorUtil.toString(message) }
    });
  }
  size(size, message) {
    return this.min(size, message).max(size, message);
  }
  nonempty(message) {
    return this.min(1, message);
  }
};
ZodSet.create = (valueType, params) => {
  return new ZodSet({
    valueType,
    minSize: null,
    maxSize: null,
    typeName: ZodFirstPartyTypeKind.ZodSet,
    ...processCreateParams(params)
  });
};
var ZodFunction = class _ZodFunction extends ZodType2 {
  constructor() {
    super(...arguments);
    this.validate = this.implement;
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType.function) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.function,
        received: ctx.parsedType
      });
      return INVALID;
    }
    function makeArgsIssue(args, error3) {
      return makeIssue({
        data: args,
        path: ctx.path,
        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default2].filter((x) => !!x),
        issueData: {
          code: ZodIssueCode.invalid_arguments,
          argumentsError: error3
        }
      });
    }
    function makeReturnsIssue(returns, error3) {
      return makeIssue({
        data: returns,
        path: ctx.path,
        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default2].filter((x) => !!x),
        issueData: {
          code: ZodIssueCode.invalid_return_type,
          returnTypeError: error3
        }
      });
    }
    const params = { errorMap: ctx.common.contextualErrorMap };
    const fn = ctx.data;
    if (this._def.returns instanceof ZodPromise) {
      const me = this;
      return OK(async function(...args) {
        const error3 = new ZodError2([]);
        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
          error3.addIssue(makeArgsIssue(args, e));
          throw error3;
        });
        const result = await Reflect.apply(fn, this, parsedArgs);
        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
          error3.addIssue(makeReturnsIssue(result, e));
          throw error3;
        });
        return parsedReturns;
      });
    } else {
      const me = this;
      return OK(function(...args) {
        const parsedArgs = me._def.args.safeParse(args, params);
        if (!parsedArgs.success) {
          throw new ZodError2([makeArgsIssue(args, parsedArgs.error)]);
        }
        const result = Reflect.apply(fn, this, parsedArgs.data);
        const parsedReturns = me._def.returns.safeParse(result, params);
        if (!parsedReturns.success) {
          throw new ZodError2([makeReturnsIssue(result, parsedReturns.error)]);
        }
        return parsedReturns.data;
      });
    }
  }
  parameters() {
    return this._def.args;
  }
  returnType() {
    return this._def.returns;
  }
  args(...items) {
    return new _ZodFunction({
      ...this._def,
      args: ZodTuple.create(items).rest(ZodUnknown2.create())
    });
  }
  returns(returnType) {
    return new _ZodFunction({
      ...this._def,
      returns: returnType
    });
  }
  implement(func) {
    const validatedFunc = this.parse(func);
    return validatedFunc;
  }
  strictImplement(func) {
    const validatedFunc = this.parse(func);
    return validatedFunc;
  }
  static create(args, returns, params) {
    return new _ZodFunction({
      args: args ? args : ZodTuple.create([]).rest(ZodUnknown2.create()),
      returns: returns || ZodUnknown2.create(),
      typeName: ZodFirstPartyTypeKind.ZodFunction,
      ...processCreateParams(params)
    });
  }
};
var ZodLazy = class extends ZodType2 {
  get schema() {
    return this._def.getter();
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const lazySchema = this._def.getter();
    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
  }
};
ZodLazy.create = (getter, params) => {
  return new ZodLazy({
    getter,
    typeName: ZodFirstPartyTypeKind.ZodLazy,
    ...processCreateParams(params)
  });
};
var ZodLiteral2 = class extends ZodType2 {
  _parse(input) {
    if (input.data !== this._def.value) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext(ctx, {
        received: ctx.data,
        code: ZodIssueCode.invalid_literal,
        expected: this._def.value
      });
      return INVALID;
    }
    return { status: "valid", value: input.data };
  }
  get value() {
    return this._def.value;
  }
};
ZodLiteral2.create = (value, params) => {
  return new ZodLiteral2({
    value,
    typeName: ZodFirstPartyTypeKind.ZodLiteral,
    ...processCreateParams(params)
  });
};
function createZodEnum(values, params) {
  return new ZodEnum2({
    values,
    typeName: ZodFirstPartyTypeKind.ZodEnum,
    ...processCreateParams(params)
  });
}
var ZodEnum2 = class _ZodEnum extends ZodType2 {
  _parse(input) {
    if (typeof input.data !== "string") {
      const ctx = this._getOrReturnCtx(input);
      const expectedValues = this._def.values;
      addIssueToContext(ctx, {
        expected: util.joinValues(expectedValues),
        received: ctx.parsedType,
        code: ZodIssueCode.invalid_type
      });
      return INVALID;
    }
    if (!this._cache) {
      this._cache = new Set(this._def.values);
    }
    if (!this._cache.has(input.data)) {
      const ctx = this._getOrReturnCtx(input);
      const expectedValues = this._def.values;
      addIssueToContext(ctx, {
        received: ctx.data,
        code: ZodIssueCode.invalid_enum_value,
        options: expectedValues
      });
      return INVALID;
    }
    return OK(input.data);
  }
  get options() {
    return this._def.values;
  }
  get enum() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  get Values() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  get Enum() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  extract(values, newDef = this._def) {
    return _ZodEnum.create(values, {
      ...this._def,
      ...newDef
    });
  }
  exclude(values, newDef = this._def) {
    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
      ...this._def,
      ...newDef
    });
  }
};
ZodEnum2.create = createZodEnum;
var ZodNativeEnum = class extends ZodType2 {
  _parse(input) {
    const nativeEnumValues = util.getValidEnumValues(this._def.values);
    const ctx = this._getOrReturnCtx(input);
    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
      const expectedValues = util.objectValues(nativeEnumValues);
      addIssueToContext(ctx, {
        expected: util.joinValues(expectedValues),
        received: ctx.parsedType,
        code: ZodIssueCode.invalid_type
      });
      return INVALID;
    }
    if (!this._cache) {
      this._cache = new Set(util.getValidEnumValues(this._def.values));
    }
    if (!this._cache.has(input.data)) {
      const expectedValues = util.objectValues(nativeEnumValues);
      addIssueToContext(ctx, {
        received: ctx.data,
        code: ZodIssueCode.invalid_enum_value,
        options: expectedValues
      });
      return INVALID;
    }
    return OK(input.data);
  }
  get enum() {
    return this._def.values;
  }
};
ZodNativeEnum.create = (values, params) => {
  return new ZodNativeEnum({
    values,
    typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
    ...processCreateParams(params)
  });
};
var ZodPromise = class extends ZodType2 {
  unwrap() {
    return this._def.type;
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.promise,
        received: ctx.parsedType
      });
      return INVALID;
    }
    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
    return OK(promisified.then((data) => {
      return this._def.type.parseAsync(data, {
        path: ctx.path,
        errorMap: ctx.common.contextualErrorMap
      });
    }));
  }
};
ZodPromise.create = (schema, params) => {
  return new ZodPromise({
    type: schema,
    typeName: ZodFirstPartyTypeKind.ZodPromise,
    ...processCreateParams(params)
  });
};
var ZodEffects = class extends ZodType2 {
  innerType() {
    return this._def.schema;
  }
  sourceType() {
    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    const effect = this._def.effect || null;
    const checkCtx = {
      addIssue: (arg) => {
        addIssueToContext(ctx, arg);
        if (arg.fatal) {
          status.abort();
        } else {
          status.dirty();
        }
      },
      get path() {
        return ctx.path;
      }
    };
    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
    if (effect.type === "preprocess") {
      const processed = effect.transform(ctx.data, checkCtx);
      if (ctx.common.async) {
        return Promise.resolve(processed).then(async (processed2) => {
          if (status.value === "aborted")
            return INVALID;
          const result = await this._def.schema._parseAsync({
            data: processed2,
            path: ctx.path,
            parent: ctx
          });
          if (result.status === "aborted")
            return INVALID;
          if (result.status === "dirty")
            return DIRTY(result.value);
          if (status.value === "dirty")
            return DIRTY(result.value);
          return result;
        });
      } else {
        if (status.value === "aborted")
          return INVALID;
        const result = this._def.schema._parseSync({
          data: processed,
          path: ctx.path,
          parent: ctx
        });
        if (result.status === "aborted")
          return INVALID;
        if (result.status === "dirty")
          return DIRTY(result.value);
        if (status.value === "dirty")
          return DIRTY(result.value);
        return result;
      }
    }
    if (effect.type === "refinement") {
      const executeRefinement = (acc) => {
        const result = effect.refinement(acc, checkCtx);
        if (ctx.common.async) {
          return Promise.resolve(result);
        }
        if (result instanceof Promise) {
          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
        }
        return acc;
      };
      if (ctx.common.async === false) {
        const inner = this._def.schema._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (inner.status === "aborted")
          return INVALID;
        if (inner.status === "dirty")
          status.dirty();
        executeRefinement(inner.value);
        return { status: status.value, value: inner.value };
      } else {
        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
          if (inner.status === "aborted")
            return INVALID;
          if (inner.status === "dirty")
            status.dirty();
          return executeRefinement(inner.value).then(() => {
            return { status: status.value, value: inner.value };
          });
        });
      }
    }
    if (effect.type === "transform") {
      if (ctx.common.async === false) {
        const base = this._def.schema._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (!isValid(base))
          return INVALID;
        const result = effect.transform(base.value, checkCtx);
        if (result instanceof Promise) {
          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
        }
        return { status: status.value, value: result };
      } else {
        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
          if (!isValid(base))
            return INVALID;
          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
            status: status.value,
            value: result
          }));
        });
      }
    }
    util.assertNever(effect);
  }
};
ZodEffects.create = (schema, effect, params) => {
  return new ZodEffects({
    schema,
    typeName: ZodFirstPartyTypeKind.ZodEffects,
    effect,
    ...processCreateParams(params)
  });
};
ZodEffects.createWithPreprocess = (preprocess2, schema, params) => {
  return new ZodEffects({
    schema,
    effect: { type: "preprocess", transform: preprocess2 },
    typeName: ZodFirstPartyTypeKind.ZodEffects,
    ...processCreateParams(params)
  });
};
var ZodOptional2 = class extends ZodType2 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 === ZodParsedType.undefined) {
      return OK(void 0);
    }
    return this._def.innerType._parse(input);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodOptional2.create = (type, params) => {
  return new ZodOptional2({
    innerType: type,
    typeName: ZodFirstPartyTypeKind.ZodOptional,
    ...processCreateParams(params)
  });
};
var ZodNullable2 = class extends ZodType2 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 === ZodParsedType.null) {
      return OK(null);
    }
    return this._def.innerType._parse(input);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodNullable2.create = (type, params) => {
  return new ZodNullable2({
    innerType: type,
    typeName: ZodFirstPartyTypeKind.ZodNullable,
    ...processCreateParams(params)
  });
};
var ZodDefault2 = class extends ZodType2 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    let data = ctx.data;
    if (ctx.parsedType === ZodParsedType.undefined) {
      data = this._def.defaultValue();
    }
    return this._def.innerType._parse({
      data,
      path: ctx.path,
      parent: ctx
    });
  }
  removeDefault() {
    return this._def.innerType;
  }
};
ZodDefault2.create = (type, params) => {
  return new ZodDefault2({
    innerType: type,
    typeName: ZodFirstPartyTypeKind.ZodDefault,
    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
    ...processCreateParams(params)
  });
};
var ZodCatch2 = class extends ZodType2 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const newCtx = {
      ...ctx,
      common: {
        ...ctx.common,
        issues: []
      }
    };
    const result = this._def.innerType._parse({
      data: newCtx.data,
      path: newCtx.path,
      parent: {
        ...newCtx
      }
    });
    if (isAsync(result)) {
      return result.then((result2) => {
        return {
          status: "valid",
          value: result2.status === "valid" ? result2.value : this._def.catchValue({
            get error() {
              return new ZodError2(newCtx.common.issues);
            },
            input: newCtx.data
          })
        };
      });
    } else {
      return {
        status: "valid",
        value: result.status === "valid" ? result.value : this._def.catchValue({
          get error() {
            return new ZodError2(newCtx.common.issues);
          },
          input: newCtx.data
        })
      };
    }
  }
  removeCatch() {
    return this._def.innerType;
  }
};
ZodCatch2.create = (type, params) => {
  return new ZodCatch2({
    innerType: type,
    typeName: ZodFirstPartyTypeKind.ZodCatch,
    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
    ...processCreateParams(params)
  });
};
var ZodNaN = class extends ZodType2 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType.nan) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext(ctx, {
        code: ZodIssueCode.invalid_type,
        expected: ZodParsedType.nan,
        received: ctx.parsedType
      });
      return INVALID;
    }
    return { status: "valid", value: input.data };
  }
};
ZodNaN.create = (params) => {
  return new ZodNaN({
    typeName: ZodFirstPartyTypeKind.ZodNaN,
    ...processCreateParams(params)
  });
};
var BRAND = Symbol("zod_brand");
var ZodBranded = class extends ZodType2 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const data = ctx.data;
    return this._def.type._parse({
      data,
      path: ctx.path,
      parent: ctx
    });
  }
  unwrap() {
    return this._def.type;
  }
};
var ZodPipeline = class _ZodPipeline extends ZodType2 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.common.async) {
      const handleAsync = async () => {
        const inResult = await this._def.in._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (inResult.status === "aborted")
          return INVALID;
        if (inResult.status === "dirty") {
          status.dirty();
          return DIRTY(inResult.value);
        } else {
          return this._def.out._parseAsync({
            data: inResult.value,
            path: ctx.path,
            parent: ctx
          });
        }
      };
      return handleAsync();
    } else {
      const inResult = this._def.in._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
      if (inResult.status === "aborted")
        return INVALID;
      if (inResult.status === "dirty") {
        status.dirty();
        return {
          status: "dirty",
          value: inResult.value
        };
      } else {
        return this._def.out._parseSync({
          data: inResult.value,
          path: ctx.path,
          parent: ctx
        });
      }
    }
  }
  static create(a, b) {
    return new _ZodPipeline({
      in: a,
      out: b,
      typeName: ZodFirstPartyTypeKind.ZodPipeline
    });
  }
};
var ZodReadonly2 = class extends ZodType2 {
  _parse(input) {
    const result = this._def.innerType._parse(input);
    const freeze = (data) => {
      if (isValid(data)) {
        data.value = Object.freeze(data.value);
      }
      return data;
    };
    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodReadonly2.create = (type, params) => {
  return new ZodReadonly2({
    innerType: type,
    typeName: ZodFirstPartyTypeKind.ZodReadonly,
    ...processCreateParams(params)
  });
};
var late = {
  object: ZodObject2.lazycreate
};
var ZodFirstPartyTypeKind;
(function(ZodFirstPartyTypeKind4) {
  ZodFirstPartyTypeKind4["ZodString"] = "ZodString";
  ZodFirstPartyTypeKind4["ZodNumber"] = "ZodNumber";
  ZodFirstPartyTypeKind4["ZodNaN"] = "ZodNaN";
  ZodFirstPartyTypeKind4["ZodBigInt"] = "ZodBigInt";
  ZodFirstPartyTypeKind4["ZodBoolean"] = "ZodBoolean";
  ZodFirstPartyTypeKind4["ZodDate"] = "ZodDate";
  ZodFirstPartyTypeKind4["ZodSymbol"] = "ZodSymbol";
  ZodFirstPartyTypeKind4["ZodUndefined"] = "ZodUndefined";
  ZodFirstPartyTypeKind4["ZodNull"] = "ZodNull";
  ZodFirstPartyTypeKind4["ZodAny"] = "ZodAny";
  ZodFirstPartyTypeKind4["ZodUnknown"] = "ZodUnknown";
  ZodFirstPartyTypeKind4["ZodNever"] = "ZodNever";
  ZodFirstPartyTypeKind4["ZodVoid"] = "ZodVoid";
  ZodFirstPartyTypeKind4["ZodArray"] = "ZodArray";
  ZodFirstPartyTypeKind4["ZodObject"] = "ZodObject";
  ZodFirstPartyTypeKind4["ZodUnion"] = "ZodUnion";
  ZodFirstPartyTypeKind4["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
  ZodFirstPartyTypeKind4["ZodIntersection"] = "ZodIntersection";
  ZodFirstPartyTypeKind4["ZodTuple"] = "ZodTuple";
  ZodFirstPartyTypeKind4["ZodRecord"] = "ZodRecord";
  ZodFirstPartyTypeKind4["ZodMap"] = "ZodMap";
  ZodFirstPartyTypeKind4["ZodSet"] = "ZodSet";
  ZodFirstPartyTypeKind4["ZodFunction"] = "ZodFunction";
  ZodFirstPartyTypeKind4["ZodLazy"] = "ZodLazy";
  ZodFirstPartyTypeKind4["ZodLiteral"] = "ZodLiteral";
  ZodFirstPartyTypeKind4["ZodEnum"] = "ZodEnum";
  ZodFirstPartyTypeKind4["ZodEffects"] = "ZodEffects";
  ZodFirstPartyTypeKind4["ZodNativeEnum"] = "ZodNativeEnum";
  ZodFirstPartyTypeKind4["ZodOptional"] = "ZodOptional";
  ZodFirstPartyTypeKind4["ZodNullable"] = "ZodNullable";
  ZodFirstPartyTypeKind4["ZodDefault"] = "ZodDefault";
  ZodFirstPartyTypeKind4["ZodCatch"] = "ZodCatch";
  ZodFirstPartyTypeKind4["ZodPromise"] = "ZodPromise";
  ZodFirstPartyTypeKind4["ZodBranded"] = "ZodBranded";
  ZodFirstPartyTypeKind4["ZodPipeline"] = "ZodPipeline";
  ZodFirstPartyTypeKind4["ZodReadonly"] = "ZodReadonly";
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
var stringType = ZodString2.create;
var numberType = ZodNumber2.create;
var nanType = ZodNaN.create;
var bigIntType = ZodBigInt.create;
var booleanType = ZodBoolean2.create;
var dateType = ZodDate.create;
var symbolType = ZodSymbol.create;
var undefinedType = ZodUndefined.create;
var nullType = ZodNull2.create;
var anyType = ZodAny.create;
var unknownType = ZodUnknown2.create;
var neverType = ZodNever2.create;
var voidType = ZodVoid.create;
var arrayType = ZodArray2.create;
var objectType = ZodObject2.create;
var strictObjectType = ZodObject2.strictCreate;
var unionType = ZodUnion2.create;
var discriminatedUnionType = ZodDiscriminatedUnion2.create;
var intersectionType = ZodIntersection2.create;
var tupleType = ZodTuple.create;
var recordType = ZodRecord2.create;
var mapType = ZodMap.create;
var setType = ZodSet.create;
var functionType = ZodFunction.create;
var lazyType = ZodLazy.create;
var literalType = ZodLiteral2.create;
var enumType = ZodEnum2.create;
var nativeEnumType = ZodNativeEnum.create;
var promiseType = ZodPromise.create;
var effectsType = ZodEffects.create;
var optionalType = ZodOptional2.create;
var nullableType = ZodNullable2.create;
var preprocessType = ZodEffects.createWithPreprocess;
var pipelineType = ZodPipeline.create;

// node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/mini/schemas.js
var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
  if (!inst._zod)
    throw new Error("Uninitialized schema in ZodMiniType.");
  $ZodType.init(inst, def);
  inst.def = def;
  inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
  inst.safeParse = (data, params) => safeParse(inst, data, params);
  inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
  inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
  inst.check = (...checks) => {
    return inst.clone(
      {
        ...def,
        checks: [
          ...def.checks ?? [],
          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
        ]
      }
      // { parent: true }
    );
  };
  inst.clone = (_def, params) => clone(inst, _def, params);
  inst.brand = () => inst;
  inst.register = ((reg, meta) => {
    reg.add(inst, meta);
    return inst;
  });
});
var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
  $ZodObject.init(inst, def);
  ZodMiniType.init(inst, def);
  util_exports.defineLazy(inst, "shape", () => def.shape);
});
function object2(shape, params) {
  const def = {
    type: "object",
    get shape() {
      util_exports.assignProp(this, "shape", { ...shape });
      return this.shape;
    },
    ...util_exports.normalizeParams(params)
  };
  return new ZodMiniObject(def);
}

// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
function isZ4Schema(s) {
  const schema = s;
  return !!schema._zod;
}
function objectFromShape(shape) {
  const values = Object.values(shape);
  if (values.length === 0)
    return object2({});
  const allV4 = values.every(isZ4Schema);
  const allV3 = values.every((s) => !isZ4Schema(s));
  if (allV4)
    return object2(shape);
  if (allV3)
    return objectType(shape);
  throw new Error("Mixed Zod versions detected in object shape.");
}
function safeParse3(schema, data) {
  if (isZ4Schema(schema)) {
    const result2 = safeParse(schema, data);
    return result2;
  }
  const v3Schema = schema;
  const result = v3Schema.safeParse(data);
  return result;
}
async function safeParseAsync3(schema, data) {
  if (isZ4Schema(schema)) {
    const result2 = await safeParseAsync(schema, data);
    return result2;
  }
  const v3Schema = schema;
  const result = await v3Schema.safeParseAsync(data);
  return result;
}
function getObjectShape(schema) {
  if (!schema)
    return void 0;
  let rawShape;
  if (isZ4Schema(schema)) {
    const v4Schema = schema;
    rawShape = v4Schema._zod?.def?.shape;
  } else {
    const v3Schema = schema;
    rawShape = v3Schema.shape;
  }
  if (!rawShape)
    return void 0;
  if (typeof rawShape === "function") {
    try {
      return rawShape();
    } catch {
      return void 0;
    }
  }
  return rawShape;
}
function normalizeObjectSchema(schema) {
  if (!schema)
    return void 0;
  if (typeof schema === "object") {
    const asV3 = schema;
    const asV4 = schema;
    if (!asV3._def && !asV4._zod) {
      const values = Object.values(schema);
      if (values.length > 0 && values.every((v) => typeof v === "object" && v !== null && (v._def !== void 0 || v._zod !== void 0 || typeof v.parse === "function"))) {
        return objectFromShape(schema);
      }
    }
  }
  if (isZ4Schema(schema)) {
    const v4Schema = schema;
    const def = v4Schema._zod?.def;
    if (def && (def.type === "object" || def.shape !== void 0)) {
      return schema;
    }
  } else {
    const v3Schema = schema;
    if (v3Schema.shape !== void 0) {
      return schema;
    }
  }
  return void 0;
}
function getParseErrorMessage(error3) {
  if (error3 && typeof error3 === "object") {
    if ("message" in error3 && typeof error3.message === "string") {
      return error3.message;
    }
    if ("issues" in error3 && Array.isArray(error3.issues) && error3.issues.length > 0) {
      const firstIssue = error3.issues[0];
      if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) {
        return String(firstIssue.message);
      }
    }
    try {
      return JSON.stringify(error3);
    } catch {
      return String(error3);
    }
  }
  return String(error3);
}
function getSchemaDescription(schema) {
  return schema.description;
}
function isSchemaOptional(schema) {
  if (isZ4Schema(schema)) {
    const v4Schema = schema;
    return v4Schema._zod?.def?.type === "optional";
  }
  const v3Schema = schema;
  if (typeof schema.isOptional === "function") {
    return schema.isOptional();
  }
  return v3Schema._def?.typeName === "ZodOptional";
}
function getLiteralValue(schema) {
  if (isZ4Schema(schema)) {
    const v4Schema = schema;
    const def2 = v4Schema._zod?.def;
    if (def2) {
      if (def2.value !== void 0)
        return def2.value;
      if (Array.isArray(def2.values) && def2.values.length > 0) {
        return def2.values[0];
      }
    }
  }
  const v3Schema = schema;
  const def = v3Schema._def;
  if (def) {
    if (def.value !== void 0)
      return def.value;
    if (Array.isArray(def.values) && def.values.length > 0) {
      return def.values[0];
    }
  }
  const directValue = schema.value;
  if (directValue !== void 0)
    return directValue;
  return void 0;
}

// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
function isTerminal(status) {
  return status === "completed" || status === "failed" || status === "cancelled";
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/Options.js
var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
var defaultOptions = {
  name: void 0,
  $refStrategy: "root",
  basePath: ["#"],
  effectStrategy: "input",
  pipeStrategy: "all",
  dateStrategy: "format:date-time",
  mapStrategy: "entries",
  removeAdditionalStrategy: "passthrough",
  allowedAdditionalProperties: true,
  rejectedAdditionalProperties: false,
  definitionPath: "definitions",
  target: "jsonSchema7",
  strictUnions: false,
  definitions: {},
  errorMessages: false,
  markdownDescription: false,
  patternStrategy: "escape",
  applyRegexFlags: false,
  emailStrategy: "format:email",
  base64Strategy: "contentEncoding:base64",
  nameStrategy: "ref",
  openAiAnyTypeName: "OpenAiAnyType"
};
var getDefaultOptions = (options) => typeof options === "string" ? {
  ...defaultOptions,
  name: options
} : {
  ...defaultOptions,
  ...options
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/Refs.js
var getRefs = (options) => {
  const _options = getDefaultOptions(options);
  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
  return {
    ..._options,
    flags: { hasReferencedOpenAiAnyType: false },
    currentPath,
    propertyPath: void 0,
    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
      def._def,
      {
        def: def._def,
        path: [..._options.basePath, _options.definitionPath, name],
        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
        jsonSchema: void 0
      }
    ]))
  };
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
function addErrorMessage(res, key, errorMessage, refs) {
  if (!refs?.errorMessages)
    return;
  if (errorMessage) {
    res.errorMessage = {
      ...res.errorMessage,
      [key]: errorMessage
    };
  }
}
function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
  res[key] = value;
  addErrorMessage(res, key, errorMessage, refs);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
var getRelativePath = (pathA, pathB) => {
  let i = 0;
  for (; i < pathA.length && i < pathB.length; i++) {
    if (pathA[i] !== pathB[i])
      break;
  }
  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
function parseAnyDef(refs) {
  if (refs.target !== "openAi") {
    return {};
  }
  const anyDefinitionPath = [
    ...refs.basePath,
    refs.definitionPath,
    refs.openAiAnyTypeName
  ];
  refs.flags.hasReferencedOpenAiAnyType = true;
  return {
    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
function parseArrayDef(def, refs) {
  const res = {
    type: "array"
  };
  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
    res.items = parseDef(def.type._def, {
      ...refs,
      currentPath: [...refs.currentPath, "items"]
    });
  }
  if (def.minLength) {
    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
  }
  if (def.maxLength) {
    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
  }
  if (def.exactLength) {
    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
  }
  return res;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
function parseBigintDef(def, refs) {
  const res = {
    type: "integer",
    format: "int64"
  };
  if (!def.checks)
    return res;
  for (const check2 of def.checks) {
    switch (check2.kind) {
      case "min":
        if (refs.target === "jsonSchema7") {
          if (check2.inclusive) {
            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
          } else {
            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
          }
        } else {
          if (!check2.inclusive) {
            res.exclusiveMinimum = true;
          }
          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
        }
        break;
      case "max":
        if (refs.target === "jsonSchema7") {
          if (check2.inclusive) {
            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
          } else {
            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
          }
        } else {
          if (!check2.inclusive) {
            res.exclusiveMaximum = true;
          }
          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
        }
        break;
      case "multipleOf":
        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
        break;
    }
  }
  return res;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
function parseBooleanDef() {
  return {
    type: "boolean"
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
function parseBrandedDef(_def, refs) {
  return parseDef(_def.type._def, refs);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
var parseCatchDef = (def, refs) => {
  return parseDef(def.innerType._def, refs);
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
function parseDateDef(def, refs, overrideDateStrategy) {
  const strategy = overrideDateStrategy ?? refs.dateStrategy;
  if (Array.isArray(strategy)) {
    return {
      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
    };
  }
  switch (strategy) {
    case "string":
    case "format:date-time":
      return {
        type: "string",
        format: "date-time"
      };
    case "format:date":
      return {
        type: "string",
        format: "date"
      };
    case "integer":
      return integerDateParser(def, refs);
  }
}
var integerDateParser = (def, refs) => {
  const res = {
    type: "integer",
    format: "unix-time"
  };
  if (refs.target === "openApi3") {
    return res;
  }
  for (const check2 of def.checks) {
    switch (check2.kind) {
      case "min":
        setResponseValueAndErrors(
          res,
          "minimum",
          check2.value,
          // This is in milliseconds
          check2.message,
          refs
        );
        break;
      case "max":
        setResponseValueAndErrors(
          res,
          "maximum",
          check2.value,
          // This is in milliseconds
          check2.message,
          refs
        );
        break;
    }
  }
  return res;
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
function parseDefaultDef(_def, refs) {
  return {
    ...parseDef(_def.innerType._def, refs),
    default: _def.defaultValue()
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
function parseEffectsDef(_def, refs) {
  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
function parseEnumDef(def) {
  return {
    type: "string",
    enum: Array.from(def.values)
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
var isJsonSchema7AllOfType = (type) => {
  if ("type" in type && type.type === "string")
    return false;
  return "allOf" in type;
};
function parseIntersectionDef(def, refs) {
  const allOf = [
    parseDef(def.left._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "0"]
    }),
    parseDef(def.right._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "1"]
    })
  ].filter((x) => !!x);
  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
  const mergedAllOf = [];
  allOf.forEach((schema) => {
    if (isJsonSchema7AllOfType(schema)) {
      mergedAllOf.push(...schema.allOf);
      if (schema.unevaluatedProperties === void 0) {
        unevaluatedProperties = void 0;
      }
    } else {
      let nestedSchema = schema;
      if ("additionalProperties" in schema && schema.additionalProperties === false) {
        const { additionalProperties, ...rest } = schema;
        nestedSchema = rest;
      } else {
        unevaluatedProperties = void 0;
      }
      mergedAllOf.push(nestedSchema);
    }
  });
  return mergedAllOf.length ? {
    allOf: mergedAllOf,
    ...unevaluatedProperties
  } : void 0;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
function parseLiteralDef(def, refs) {
  const parsedType2 = typeof def.value;
  if (parsedType2 !== "bigint" && parsedType2 !== "number" && parsedType2 !== "boolean" && parsedType2 !== "string") {
    return {
      type: Array.isArray(def.value) ? "array" : "object"
    };
  }
  if (refs.target === "openApi3") {
    return {
      type: parsedType2 === "bigint" ? "integer" : parsedType2,
      enum: [def.value]
    };
  }
  return {
    type: parsedType2 === "bigint" ? "integer" : parsedType2,
    const: def.value
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
var emojiRegex2 = void 0;
var zodPatterns = {
  /**
   * `c` was changed to `[cC]` to replicate /i flag
   */
  cuid: /^[cC][^\s-]{8,}$/,
  cuid2: /^[0-9a-z]+$/,
  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
  /**
   * `a-z` was added to replicate /i flag
   */
  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
  /**
   * Constructed a valid Unicode RegExp
   *
   * Lazily instantiate since this type of regex isn't supported
   * in all envs (e.g. React Native).
   *
   * See:
   * https://github.com/colinhacks/zod/issues/2433
   * Fix in Zod:
   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
   */
  emoji: () => {
    if (emojiRegex2 === void 0) {
      emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
    }
    return emojiRegex2;
  },
  /**
   * Unused
   */
  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
  /**
   * Unused
   */
  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
  /**
   * Unused
   */
  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
  nanoid: /^[a-zA-Z0-9_-]{21}$/,
  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
};
function parseStringDef(def, refs) {
  const res = {
    type: "string"
  };
  if (def.checks) {
    for (const check2 of def.checks) {
      switch (check2.kind) {
        case "min":
          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
          break;
        case "max":
          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
          break;
        case "email":
          switch (refs.emailStrategy) {
            case "format:email":
              addFormat(res, "email", check2.message, refs);
              break;
            case "format:idn-email":
              addFormat(res, "idn-email", check2.message, refs);
              break;
            case "pattern:zod":
              addPattern(res, zodPatterns.email, check2.message, refs);
              break;
          }
          break;
        case "url":
          addFormat(res, "uri", check2.message, refs);
          break;
        case "uuid":
          addFormat(res, "uuid", check2.message, refs);
          break;
        case "regex":
          addPattern(res, check2.regex, check2.message, refs);
          break;
        case "cuid":
          addPattern(res, zodPatterns.cuid, check2.message, refs);
          break;
        case "cuid2":
          addPattern(res, zodPatterns.cuid2, check2.message, refs);
          break;
        case "startsWith":
          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check2.value, refs)}`), check2.message, refs);
          break;
        case "endsWith":
          addPattern(res, RegExp(`${escapeLiteralCheckValue(check2.value, refs)}$`), check2.message, refs);
          break;
        case "datetime":
          addFormat(res, "date-time", check2.message, refs);
          break;
        case "date":
          addFormat(res, "date", check2.message, refs);
          break;
        case "time":
          addFormat(res, "time", check2.message, refs);
          break;
        case "duration":
          addFormat(res, "duration", check2.message, refs);
          break;
        case "length":
          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
          break;
        case "includes": {
          addPattern(res, RegExp(escapeLiteralCheckValue(check2.value, refs)), check2.message, refs);
          break;
        }
        case "ip": {
          if (check2.version !== "v6") {
            addFormat(res, "ipv4", check2.message, refs);
          }
          if (check2.version !== "v4") {
            addFormat(res, "ipv6", check2.message, refs);
          }
          break;
        }
        case "base64url":
          addPattern(res, zodPatterns.base64url, check2.message, refs);
          break;
        case "jwt":
          addPattern(res, zodPatterns.jwt, check2.message, refs);
          break;
        case "cidr": {
          if (check2.version !== "v6") {
            addPattern(res, zodPatterns.ipv4Cidr, check2.message, refs);
          }
          if (check2.version !== "v4") {
            addPattern(res, zodPatterns.ipv6Cidr, check2.message, refs);
          }
          break;
        }
        case "emoji":
          addPattern(res, zodPatterns.emoji(), check2.message, refs);
          break;
        case "ulid": {
          addPattern(res, zodPatterns.ulid, check2.message, refs);
          break;
        }
        case "base64": {
          switch (refs.base64Strategy) {
            case "format:binary": {
              addFormat(res, "binary", check2.message, refs);
              break;
            }
            case "contentEncoding:base64": {
              setResponseValueAndErrors(res, "contentEncoding", "base64", check2.message, refs);
              break;
            }
            case "pattern:zod": {
              addPattern(res, zodPatterns.base64, check2.message, refs);
              break;
            }
          }
          break;
        }
        case "nanoid": {
          addPattern(res, zodPatterns.nanoid, check2.message, refs);
        }
        case "toLowerCase":
        case "toUpperCase":
        case "trim":
          break;
        default:
          /* @__PURE__ */ ((_) => {
          })(check2);
      }
    }
  }
  return res;
}
function escapeLiteralCheckValue(literal2, refs) {
  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal2) : literal2;
}
var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
function escapeNonAlphaNumeric(source) {
  let result = "";
  for (let i = 0; i < source.length; i++) {
    if (!ALPHA_NUMERIC.has(source[i])) {
      result += "\\";
    }
    result += source[i];
  }
  return result;
}
function addFormat(schema, value, message, refs) {
  if (schema.format || schema.anyOf?.some((x) => x.format)) {
    if (!schema.anyOf) {
      schema.anyOf = [];
    }
    if (schema.format) {
      schema.anyOf.push({
        format: schema.format,
        ...schema.errorMessage && refs.errorMessages && {
          errorMessage: { format: schema.errorMessage.format }
        }
      });
      delete schema.format;
      if (schema.errorMessage) {
        delete schema.errorMessage.format;
        if (Object.keys(schema.errorMessage).length === 0) {
          delete schema.errorMessage;
        }
      }
    }
    schema.anyOf.push({
      format: value,
      ...message && refs.errorMessages && { errorMessage: { format: message } }
    });
  } else {
    setResponseValueAndErrors(schema, "format", value, message, refs);
  }
}
function addPattern(schema, regex, message, refs) {
  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
    if (!schema.allOf) {
      schema.allOf = [];
    }
    if (schema.pattern) {
      schema.allOf.push({
        pattern: schema.pattern,
        ...schema.errorMessage && refs.errorMessages && {
          errorMessage: { pattern: schema.errorMessage.pattern }
        }
      });
      delete schema.pattern;
      if (schema.errorMessage) {
        delete schema.errorMessage.pattern;
        if (Object.keys(schema.errorMessage).length === 0) {
          delete schema.errorMessage;
        }
      }
    }
    schema.allOf.push({
      pattern: stringifyRegExpWithFlags(regex, refs),
      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
    });
  } else {
    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
  }
}
function stringifyRegExpWithFlags(regex, refs) {
  if (!refs.applyRegexFlags || !regex.flags) {
    return regex.source;
  }
  const flags = {
    i: regex.flags.includes("i"),
    m: regex.flags.includes("m"),
    s: regex.flags.includes("s")
    // `.` matches newlines
  };
  const source = flags.i ? regex.source.toLowerCase() : regex.source;
  let pattern = "";
  let isEscaped = false;
  let inCharGroup = false;
  let inCharRange = false;
  for (let i = 0; i < source.length; i++) {
    if (isEscaped) {
      pattern += source[i];
      isEscaped = false;
      continue;
    }
    if (flags.i) {
      if (inCharGroup) {
        if (source[i].match(/[a-z]/)) {
          if (inCharRange) {
            pattern += source[i];
            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
            inCharRange = false;
          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
            pattern += source[i];
            inCharRange = true;
          } else {
            pattern += `${source[i]}${source[i].toUpperCase()}`;
          }
          continue;
        }
      } else if (source[i].match(/[a-z]/)) {
        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
        continue;
      }
    }
    if (flags.m) {
      if (source[i] === "^") {
        pattern += `(^|(?<=[\r
]))`;
        continue;
      } else if (source[i] === "$") {
        pattern += `($|(?=[\r
]))`;
        continue;
      }
    }
    if (flags.s && source[i] === ".") {
      pattern += inCharGroup ? `${source[i]}\r
` : `[${source[i]}\r
]`;
      continue;
    }
    pattern += source[i];
    if (source[i] === "\\") {
      isEscaped = true;
    } else if (inCharGroup && source[i] === "]") {
      inCharGroup = false;
    } else if (!inCharGroup && source[i] === "[") {
      inCharGroup = true;
    }
  }
  try {
    new RegExp(pattern);
  } catch {
    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
    return regex.source;
  }
  return pattern;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
function parseRecordDef(def, refs) {
  if (refs.target === "openAi") {
    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
  }
  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
    return {
      type: "object",
      required: def.keyType._def.values,
      properties: def.keyType._def.values.reduce((acc, key) => ({
        ...acc,
        [key]: parseDef(def.valueType._def, {
          ...refs,
          currentPath: [...refs.currentPath, "properties", key]
        }) ?? parseAnyDef(refs)
      }), {}),
      additionalProperties: refs.rejectedAdditionalProperties
    };
  }
  const schema = {
    type: "object",
    additionalProperties: parseDef(def.valueType._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    }) ?? refs.allowedAdditionalProperties
  };
  if (refs.target === "openApi3") {
    return schema;
  }
  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
    return {
      ...schema,
      propertyNames: keyType
    };
  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
    return {
      ...schema,
      propertyNames: {
        enum: def.keyType._def.values
      }
    };
  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
    return {
      ...schema,
      propertyNames: keyType
    };
  }
  return schema;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
function parseMapDef(def, refs) {
  if (refs.mapStrategy === "record") {
    return parseRecordDef(def, refs);
  }
  const keys = parseDef(def.keyType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "0"]
  }) || parseAnyDef(refs);
  const values = parseDef(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "1"]
  }) || parseAnyDef(refs);
  return {
    type: "array",
    maxItems: 125,
    items: {
      type: "array",
      items: [keys, values],
      minItems: 2,
      maxItems: 2
    }
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
function parseNativeEnumDef(def) {
  const object3 = def.values;
  const actualKeys = Object.keys(def.values).filter((key) => {
    return typeof object3[object3[key]] !== "number";
  });
  const actualValues = actualKeys.map((key) => object3[key]);
  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
  return {
    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
    enum: actualValues
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
function parseNeverDef(refs) {
  return refs.target === "openAi" ? void 0 : {
    not: parseAnyDef({
      ...refs,
      currentPath: [...refs.currentPath, "not"]
    })
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
function parseNullDef(refs) {
  return refs.target === "openApi3" ? {
    enum: ["null"],
    nullable: true
  } : {
    type: "null"
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
var primitiveMappings = {
  ZodString: "string",
  ZodNumber: "number",
  ZodBigInt: "integer",
  ZodBoolean: "boolean",
  ZodNull: "null"
};
function parseUnionDef(def, refs) {
  if (refs.target === "openApi3")
    return asAnyOf(def, refs);
  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
    const types = options.reduce((types2, x) => {
      const type = primitiveMappings[x._def.typeName];
      return type && !types2.includes(type) ? [...types2, type] : types2;
    }, []);
    return {
      type: types.length > 1 ? types : types[0]
    };
  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
    const types = options.reduce((acc, x) => {
      const type = typeof x._def.value;
      switch (type) {
        case "string":
        case "number":
        case "boolean":
          return [...acc, type];
        case "bigint":
          return [...acc, "integer"];
        case "object":
          if (x._def.value === null)
            return [...acc, "null"];
        case "symbol":
        case "undefined":
        case "function":
        default:
          return acc;
      }
    }, []);
    if (types.length === options.length) {
      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
      return {
        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
        enum: options.reduce((acc, x) => {
          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
        }, [])
      };
    }
  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
    return {
      type: "string",
      enum: options.reduce((acc, x) => [
        ...acc,
        ...x._def.values.filter((x2) => !acc.includes(x2))
      ], [])
    };
  }
  return asAnyOf(def, refs);
}
var asAnyOf = (def, refs) => {
  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
    ...refs,
    currentPath: [...refs.currentPath, "anyOf", `${i}`]
  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
  return anyOf.length ? { anyOf } : void 0;
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
function parseNullableDef(def, refs) {
  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
    if (refs.target === "openApi3") {
      return {
        type: primitiveMappings[def.innerType._def.typeName],
        nullable: true
      };
    }
    return {
      type: [
        primitiveMappings[def.innerType._def.typeName],
        "null"
      ]
    };
  }
  if (refs.target === "openApi3") {
    const base2 = parseDef(def.innerType._def, {
      ...refs,
      currentPath: [...refs.currentPath]
    });
    if (base2 && "$ref" in base2)
      return { allOf: [base2], nullable: true };
    return base2 && { ...base2, nullable: true };
  }
  const base = parseDef(def.innerType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "anyOf", "0"]
  });
  return base && { anyOf: [base, { type: "null" }] };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
function parseNumberDef(def, refs) {
  const res = {
    type: "number"
  };
  if (!def.checks)
    return res;
  for (const check2 of def.checks) {
    switch (check2.kind) {
      case "int":
        res.type = "integer";
        addErrorMessage(res, "type", check2.message, refs);
        break;
      case "min":
        if (refs.target === "jsonSchema7") {
          if (check2.inclusive) {
            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
          } else {
            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
          }
        } else {
          if (!check2.inclusive) {
            res.exclusiveMinimum = true;
          }
          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
        }
        break;
      case "max":
        if (refs.target === "jsonSchema7") {
          if (check2.inclusive) {
            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
          } else {
            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
          }
        } else {
          if (!check2.inclusive) {
            res.exclusiveMaximum = true;
          }
          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
        }
        break;
      case "multipleOf":
        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
        break;
    }
  }
  return res;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
function parseObjectDef(def, refs) {
  const forceOptionalIntoNullable = refs.target === "openAi";
  const result = {
    type: "object",
    properties: {}
  };
  const required2 = [];
  const shape = def.shape();
  for (const propName in shape) {
    let propDef = shape[propName];
    if (propDef === void 0 || propDef._def === void 0) {
      continue;
    }
    let propOptional = safeIsOptional(propDef);
    if (propOptional && forceOptionalIntoNullable) {
      if (propDef._def.typeName === "ZodOptional") {
        propDef = propDef._def.innerType;
      }
      if (!propDef.isNullable()) {
        propDef = propDef.nullable();
      }
      propOptional = false;
    }
    const parsedDef = parseDef(propDef._def, {
      ...refs,
      currentPath: [...refs.currentPath, "properties", propName],
      propertyPath: [...refs.currentPath, "properties", propName]
    });
    if (parsedDef === void 0) {
      continue;
    }
    result.properties[propName] = parsedDef;
    if (!propOptional) {
      required2.push(propName);
    }
  }
  if (required2.length) {
    result.required = required2;
  }
  const additionalProperties = decideAdditionalProperties(def, refs);
  if (additionalProperties !== void 0) {
    result.additionalProperties = additionalProperties;
  }
  return result;
}
function decideAdditionalProperties(def, refs) {
  if (def.catchall._def.typeName !== "ZodNever") {
    return parseDef(def.catchall._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    });
  }
  switch (def.unknownKeys) {
    case "passthrough":
      return refs.allowedAdditionalProperties;
    case "strict":
      return refs.rejectedAdditionalProperties;
    case "strip":
      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
  }
}
function safeIsOptional(schema) {
  try {
    return schema.isOptional();
  } catch {
    return true;
  }
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
var parseOptionalDef = (def, refs) => {
  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
    return parseDef(def.innerType._def, refs);
  }
  const innerSchema = parseDef(def.innerType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "anyOf", "1"]
  });
  return innerSchema ? {
    anyOf: [
      {
        not: parseAnyDef(refs)
      },
      innerSchema
    ]
  } : parseAnyDef(refs);
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
var parsePipelineDef = (def, refs) => {
  if (refs.pipeStrategy === "input") {
    return parseDef(def.in._def, refs);
  } else if (refs.pipeStrategy === "output") {
    return parseDef(def.out._def, refs);
  }
  const a = parseDef(def.in._def, {
    ...refs,
    currentPath: [...refs.currentPath, "allOf", "0"]
  });
  const b = parseDef(def.out._def, {
    ...refs,
    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
  });
  return {
    allOf: [a, b].filter((x) => x !== void 0)
  };
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
function parsePromiseDef(def, refs) {
  return parseDef(def.type._def, refs);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
function parseSetDef(def, refs) {
  const items = parseDef(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items"]
  });
  const schema = {
    type: "array",
    uniqueItems: true,
    items
  };
  if (def.minSize) {
    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
  }
  if (def.maxSize) {
    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
  }
  return schema;
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
function parseTupleDef(def, refs) {
  if (def.rest) {
    return {
      type: "array",
      minItems: def.items.length,
      items: def.items.map((x, i) => parseDef(x._def, {
        ...refs,
        currentPath: [...refs.currentPath, "items", `${i}`]
      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
      additionalItems: parseDef(def.rest._def, {
        ...refs,
        currentPath: [...refs.currentPath, "additionalItems"]
      })
    };
  } else {
    return {
      type: "array",
      minItems: def.items.length,
      maxItems: def.items.length,
      items: def.items.map((x, i) => parseDef(x._def, {
        ...refs,
        currentPath: [...refs.currentPath, "items", `${i}`]
      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
    };
  }
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
function parseUndefinedDef(refs) {
  return {
    not: parseAnyDef(refs)
  };
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
function parseUnknownDef(refs) {
  return parseAnyDef(refs);
}

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
var parseReadonlyDef = (def, refs) => {
  return parseDef(def.innerType._def, refs);
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/selectParser.js
var selectParser = (def, typeName, refs) => {
  switch (typeName) {
    case ZodFirstPartyTypeKind.ZodString:
      return parseStringDef(def, refs);
    case ZodFirstPartyTypeKind.ZodNumber:
      return parseNumberDef(def, refs);
    case ZodFirstPartyTypeKind.ZodObject:
      return parseObjectDef(def, refs);
    case ZodFirstPartyTypeKind.ZodBigInt:
      return parseBigintDef(def, refs);
    case ZodFirstPartyTypeKind.ZodBoolean:
      return parseBooleanDef();
    case ZodFirstPartyTypeKind.ZodDate:
      return parseDateDef(def, refs);
    case ZodFirstPartyTypeKind.ZodUndefined:
      return parseUndefinedDef(refs);
    case ZodFirstPartyTypeKind.ZodNull:
      return parseNullDef(refs);
    case ZodFirstPartyTypeKind.ZodArray:
      return parseArrayDef(def, refs);
    case ZodFirstPartyTypeKind.ZodUnion:
    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
      return parseUnionDef(def, refs);
    case ZodFirstPartyTypeKind.ZodIntersection:
      return parseIntersectionDef(def, refs);
    case ZodFirstPartyTypeKind.ZodTuple:
      return parseTupleDef(def, refs);
    case ZodFirstPartyTypeKind.ZodRecord:
      return parseRecordDef(def, refs);
    case ZodFirstPartyTypeKind.ZodLiteral:
      return parseLiteralDef(def, refs);
    case ZodFirstPartyTypeKind.ZodEnum:
      return parseEnumDef(def);
    case ZodFirstPartyTypeKind.ZodNativeEnum:
      return parseNativeEnumDef(def);
    case ZodFirstPartyTypeKind.ZodNullable:
      return parseNullableDef(def, refs);
    case ZodFirstPartyTypeKind.ZodOptional:
      return parseOptionalDef(def, refs);
    case ZodFirstPartyTypeKind.ZodMap:
      return parseMapDef(def, refs);
    case ZodFirstPartyTypeKind.ZodSet:
      return parseSetDef(def, refs);
    case ZodFirstPartyTypeKind.ZodLazy:
      return () => def.getter()._def;
    case ZodFirstPartyTypeKind.ZodPromise:
      return parsePromiseDef(def, refs);
    case ZodFirstPartyTypeKind.ZodNaN:
    case ZodFirstPartyTypeKind.ZodNever:
      return parseNeverDef(refs);
    case ZodFirstPartyTypeKind.ZodEffects:
      return parseEffectsDef(def, refs);
    case ZodFirstPartyTypeKind.ZodAny:
      return parseAnyDef(refs);
    case ZodFirstPartyTypeKind.ZodUnknown:
      return parseUnknownDef(refs);
    case ZodFirstPartyTypeKind.ZodDefault:
      return parseDefaultDef(def, refs);
    case ZodFirstPartyTypeKind.ZodBranded:
      return parseBrandedDef(def, refs);
    case ZodFirstPartyTypeKind.ZodReadonly:
      return parseReadonlyDef(def, refs);
    case ZodFirstPartyTypeKind.ZodCatch:
      return parseCatchDef(def, refs);
    case ZodFirstPartyTypeKind.ZodPipeline:
      return parsePipelineDef(def, refs);
    case ZodFirstPartyTypeKind.ZodFunction:
    case ZodFirstPartyTypeKind.ZodVoid:
    case ZodFirstPartyTypeKind.ZodSymbol:
      return void 0;
    default:
      return /* @__PURE__ */ ((_) => void 0)(typeName);
  }
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parseDef.js
function parseDef(def, refs, forceResolution = false) {
  const seenItem = refs.seen.get(def);
  if (refs.override) {
    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
    if (overrideResult !== ignoreOverride) {
      return overrideResult;
    }
  }
  if (seenItem && !forceResolution) {
    const seenSchema = get$ref(seenItem, refs);
    if (seenSchema !== void 0) {
      return seenSchema;
    }
  }
  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
  refs.seen.set(def, newItem);
  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
  if (jsonSchema) {
    addMeta(def, refs, jsonSchema);
  }
  if (refs.postProcess) {
    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
    newItem.jsonSchema = jsonSchema;
    return postProcessResult;
  }
  newItem.jsonSchema = jsonSchema;
  return jsonSchema;
}
var get$ref = (item, refs) => {
  switch (refs.$refStrategy) {
    case "root":
      return { $ref: item.path.join("/") };
    case "relative":
      return { $ref: getRelativePath(refs.currentPath, item.path) };
    case "none":
    case "seen": {
      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
        return parseAnyDef(refs);
      }
      return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
    }
  }
};
var addMeta = (def, refs, jsonSchema) => {
  if (def.description) {
    jsonSchema.description = def.description;
    if (refs.markdownDescription) {
      jsonSchema.markdownDescription = def.description;
    }
  }
  return jsonSchema;
};

// node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
var zodToJsonSchema = (schema, options) => {
  const refs = getRefs(options);
  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
    ...acc,
    [name2]: parseDef(schema2._def, {
      ...refs,
      currentPath: [...refs.basePath, refs.definitionPath, name2]
    }, true) ?? parseAnyDef(refs)
  }), {}) : void 0;
  const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
  const main = parseDef(schema._def, name === void 0 ? refs : {
    ...refs,
    currentPath: [...refs.basePath, refs.definitionPath, name]
  }, false) ?? parseAnyDef(refs);
  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
  if (title !== void 0) {
    main.title = title;
  }
  if (refs.flags.hasReferencedOpenAiAnyType) {
    if (!definitions) {
      definitions = {};
    }
    if (!definitions[refs.openAiAnyTypeName]) {
      definitions[refs.openAiAnyTypeName] = {
        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
        type: ["string", "number", "integer", "boolean", "array", "null"],
        items: {
          $ref: refs.$refStrategy === "relative" ? "1" : [
            ...refs.basePath,
            refs.definitionPath,
            refs.openAiAnyTypeName
          ].join("/")
        }
      };
    }
  }
  const combined = name === void 0 ? definitions ? {
    ...main,
    [refs.definitionPath]: definitions
  } : main : {
    $ref: [
      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
      refs.definitionPath,
      name
    ].join("/"),
    [refs.definitionPath]: {
      ...definitions,
      [name]: main
    }
  };
  if (refs.target === "jsonSchema7") {
    combined.$schema = "http://json-schema.org/draft-07/schema#";
  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
  }
  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
  }
  return combined;
};

// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
function mapMiniTarget(t) {
  if (!t)
    return "draft-7";
  if (t === "jsonSchema7" || t === "draft-7")
    return "draft-7";
  if (t === "jsonSchema2019-09" || t === "draft-2020-12")
    return "draft-2020-12";
  return "draft-7";
}
function toJsonSchemaCompat(schema, opts) {
  if (isZ4Schema(schema)) {
    return toJSONSchema(schema, {
      target: mapMiniTarget(opts?.target),
      io: opts?.pipeStrategy ?? "input"
    });
  }
  return zodToJsonSchema(schema, {
    strictUnions: opts?.strictUnions ?? true,
    pipeStrategy: opts?.pipeStrategy ?? "input"
  });
}
function getMethodLiteral(schema) {
  const shape = getObjectShape(schema);
  const methodSchema = shape?.method;
  if (!methodSchema) {
    throw new Error("Schema is missing a method literal");
  }
  const value = getLiteralValue(methodSchema);
  if (typeof value !== "string") {
    throw new Error("Schema method literal must be a string");
  }
  return value;
}
function parseWithCompat(schema, data) {
  const result = safeParse3(schema, data);
  if (!result.success) {
    throw result.error;
  }
  return result.data;
}

// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
var Protocol = class {
  constructor(_options) {
    this._options = _options;
    this._requestMessageId = 0;
    this._requestHandlers = /* @__PURE__ */ new Map();
    this._requestHandlerAbortControllers = /* @__PURE__ */ new Map();
    this._notificationHandlers = /* @__PURE__ */ new Map();
    this._responseHandlers = /* @__PURE__ */ new Map();
    this._progressHandlers = /* @__PURE__ */ new Map();
    this._timeoutInfo = /* @__PURE__ */ new Map();
    this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
    this._taskProgressTokens = /* @__PURE__ */ new Map();
    this._requestResolvers = /* @__PURE__ */ new Map();
    this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
      this._oncancel(notification);
    });
    this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
      this._onprogress(notification);
    });
    this.setRequestHandler(
      PingRequestSchema,
      // Automatic pong by default.
      (_request) => ({})
    );
    this._taskStore = _options?.taskStore;
    this._taskMessageQueue = _options?.taskMessageQueue;
    if (this._taskStore) {
      this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
        const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
        if (!task) {
          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
        }
        return {
          ...task
        };
      });
      this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
        const handleTaskResult = async () => {
          const taskId = request.params.taskId;
          if (this._taskMessageQueue) {
            let queuedMessage;
            while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
              if (queuedMessage.type === "response" || queuedMessage.type === "error") {
                const message = queuedMessage.message;
                const requestId = message.id;
                const resolver = this._requestResolvers.get(requestId);
                if (resolver) {
                  this._requestResolvers.delete(requestId);
                  if (queuedMessage.type === "response") {
                    resolver(message);
                  } else {
                    const errorMessage = message;
                    const error3 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
                    resolver(error3);
                  }
                } else {
                  const messageType = queuedMessage.type === "response" ? "Response" : "Error";
                  this._onerror(new Error(`${messageType} handler missing for request ${requestId}`));
                }
                continue;
              }
              await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
            }
          }
          const task = await this._taskStore.getTask(taskId, extra.sessionId);
          if (!task) {
            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
          }
          if (!isTerminal(task.status)) {
            await this._waitForTaskUpdate(taskId, extra.signal);
            return await handleTaskResult();
          }
          if (isTerminal(task.status)) {
            const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
            this._clearTaskQueue(taskId);
            return {
              ...result,
              _meta: {
                ...result._meta,
                [RELATED_TASK_META_KEY]: {
                  taskId
                }
              }
            };
          }
          return await handleTaskResult();
        };
        return await handleTaskResult();
      });
      this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
        try {
          const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
          return {
            tasks,
            nextCursor,
            _meta: {}
          };
        } catch (error3) {
          throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error3 instanceof Error ? error3.message : String(error3)}`);
        }
      });
      this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
        try {
          const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
          if (!task) {
            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
          }
          if (isTerminal(task.status)) {
            throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
          }
          await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
          this._clearTaskQueue(request.params.taskId);
          const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
          if (!cancelledTask) {
            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
          }
          return {
            _meta: {},
            ...cancelledTask
          };
        } catch (error3) {
          if (error3 instanceof McpError) {
            throw error3;
          }
          throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error3 instanceof Error ? error3.message : String(error3)}`);
        }
      });
    }
  }
  async _oncancel(notification) {
    if (!notification.params.requestId) {
      return;
    }
    const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
    controller?.abort(notification.params.reason);
  }
  _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
    this._timeoutInfo.set(messageId, {
      timeoutId: setTimeout(onTimeout, timeout),
      startTime: Date.now(),
      timeout,
      maxTotalTimeout,
      resetTimeoutOnProgress,
      onTimeout
    });
  }
  _resetTimeout(messageId) {
    const info = this._timeoutInfo.get(messageId);
    if (!info)
      return false;
    const totalElapsed = Date.now() - info.startTime;
    if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
      this._timeoutInfo.delete(messageId);
      throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
        maxTotalTimeout: info.maxTotalTimeout,
        totalElapsed
      });
    }
    clearTimeout(info.timeoutId);
    info.timeoutId = setTimeout(info.onTimeout, info.timeout);
    return true;
  }
  _cleanupTimeout(messageId) {
    const info = this._timeoutInfo.get(messageId);
    if (info) {
      clearTimeout(info.timeoutId);
      this._timeoutInfo.delete(messageId);
    }
  }
  /**
   * Attaches to the given transport, starts it, and starts listening for messages.
   *
   * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
   */
  async connect(transport) {
    if (this._transport) {
      throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
    }
    this._transport = transport;
    const _onclose = this.transport?.onclose;
    this._transport.onclose = () => {
      _onclose?.();
      this._onclose();
    };
    const _onerror = this.transport?.onerror;
    this._transport.onerror = (error3) => {
      _onerror?.(error3);
      this._onerror(error3);
    };
    const _onmessage = this._transport?.onmessage;
    this._transport.onmessage = (message, extra) => {
      _onmessage?.(message, extra);
      if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
        this._onresponse(message);
      } else if (isJSONRPCRequest(message)) {
        this._onrequest(message, extra);
      } else if (isJSONRPCNotification(message)) {
        this._onnotification(message);
      } else {
        this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`));
      }
    };
    await this._transport.start();
  }
  _onclose() {
    const responseHandlers = this._responseHandlers;
    this._responseHandlers = /* @__PURE__ */ new Map();
    this._progressHandlers.clear();
    this._taskProgressTokens.clear();
    this._pendingDebouncedNotifications.clear();
    for (const info of this._timeoutInfo.values()) {
      clearTimeout(info.timeoutId);
    }
    this._timeoutInfo.clear();
    for (const controller of this._requestHandlerAbortControllers.values()) {
      controller.abort();
    }
    this._requestHandlerAbortControllers.clear();
    const error3 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
    this._transport = void 0;
    this.onclose?.();
    for (const handler of responseHandlers.values()) {
      handler(error3);
    }
  }
  _onerror(error3) {
    this.onerror?.(error3);
  }
  _onnotification(notification) {
    const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
    if (handler === void 0) {
      return;
    }
    Promise.resolve().then(() => handler(notification)).catch((error3) => this._onerror(new Error(`Uncaught error in notification handler: ${error3}`)));
  }
  _onrequest(request, extra) {
    const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
    const capturedTransport = this._transport;
    const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
    if (handler === void 0) {
      const errorResponse = {
        jsonrpc: "2.0",
        id: request.id,
        error: {
          code: ErrorCode.MethodNotFound,
          message: "Method not found"
        }
      };
      if (relatedTaskId && this._taskMessageQueue) {
        this._enqueueTaskMessage(relatedTaskId, {
          type: "error",
          message: errorResponse,
          timestamp: Date.now()
        }, capturedTransport?.sessionId).catch((error3) => this._onerror(new Error(`Failed to enqueue error response: ${error3}`)));
      } else {
        capturedTransport?.send(errorResponse).catch((error3) => this._onerror(new Error(`Failed to send an error response: ${error3}`)));
      }
      return;
    }
    const abortController = new AbortController();
    this._requestHandlerAbortControllers.set(request.id, abortController);
    const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0;
    const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : void 0;
    const fullExtra = {
      signal: abortController.signal,
      sessionId: capturedTransport?.sessionId,
      _meta: request.params?._meta,
      sendNotification: async (notification) => {
        if (abortController.signal.aborted)
          return;
        const notificationOptions = { relatedRequestId: request.id };
        if (relatedTaskId) {
          notificationOptions.relatedTask = { taskId: relatedTaskId };
        }
        await this.notification(notification, notificationOptions);
      },
      sendRequest: async (r, resultSchema, options) => {
        if (abortController.signal.aborted) {
          throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
        }
        const requestOptions = { ...options, relatedRequestId: request.id };
        if (relatedTaskId && !requestOptions.relatedTask) {
          requestOptions.relatedTask = { taskId: relatedTaskId };
        }
        const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
        if (effectiveTaskId && taskStore) {
          await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
        }
        return await this.request(r, resultSchema, requestOptions);
      },
      authInfo: extra?.authInfo,
      requestId: request.id,
      requestInfo: extra?.requestInfo,
      taskId: relatedTaskId,
      taskStore,
      taskRequestedTtl: taskCreationParams?.ttl,
      closeSSEStream: extra?.closeSSEStream,
      closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
    };
    Promise.resolve().then(() => {
      if (taskCreationParams) {
        this.assertTaskHandlerCapability(request.method);
      }
    }).then(() => handler(request, fullExtra)).then(async (result) => {
      if (abortController.signal.aborted) {
        return;
      }
      const response = {
        result,
        jsonrpc: "2.0",
        id: request.id
      };
      if (relatedTaskId && this._taskMessageQueue) {
        await this._enqueueTaskMessage(relatedTaskId, {
          type: "response",
          message: response,
          timestamp: Date.now()
        }, capturedTransport?.sessionId);
      } else {
        await capturedTransport?.send(response);
      }
    }, async (error3) => {
      if (abortController.signal.aborted) {
        return;
      }
      const errorResponse = {
        jsonrpc: "2.0",
        id: request.id,
        error: {
          code: Number.isSafeInteger(error3["code"]) ? error3["code"] : ErrorCode.InternalError,
          message: error3.message ?? "Internal error",
          ...error3["data"] !== void 0 && { data: error3["data"] }
        }
      };
      if (relatedTaskId && this._taskMessageQueue) {
        await this._enqueueTaskMessage(relatedTaskId, {
          type: "error",
          message: errorResponse,
          timestamp: Date.now()
        }, capturedTransport?.sessionId);
      } else {
        await capturedTransport?.send(errorResponse);
      }
    }).catch((error3) => this._onerror(new Error(`Failed to send response: ${error3}`))).finally(() => {
      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
        this._requestHandlerAbortControllers.delete(request.id);
      }
    });
  }
  _onprogress(notification) {
    const { progressToken, ...params } = notification.params;
    const messageId = Number(progressToken);
    const handler = this._progressHandlers.get(messageId);
    if (!handler) {
      this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
      return;
    }
    const responseHandler = this._responseHandlers.get(messageId);
    const timeoutInfo = this._timeoutInfo.get(messageId);
    if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) {
      try {
        this._resetTimeout(messageId);
      } catch (error3) {
        this._responseHandlers.delete(messageId);
        this._progressHandlers.delete(messageId);
        this._cleanupTimeout(messageId);
        responseHandler(error3);
        return;
      }
    }
    handler(params);
  }
  _onresponse(response) {
    const messageId = Number(response.id);
    const resolver = this._requestResolvers.get(messageId);
    if (resolver) {
      this._requestResolvers.delete(messageId);
      if (isJSONRPCResultResponse(response)) {
        resolver(response);
      } else {
        const error3 = new McpError(response.error.code, response.error.message, response.error.data);
        resolver(error3);
      }
      return;
    }
    const handler = this._responseHandlers.get(messageId);
    if (handler === void 0) {
      this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
      return;
    }
    this._responseHandlers.delete(messageId);
    this._cleanupTimeout(messageId);
    let isTaskResponse = false;
    if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
      const result = response.result;
      if (result.task && typeof result.task === "object") {
        const task = result.task;
        if (typeof task.taskId === "string") {
          isTaskResponse = true;
          this._taskProgressTokens.set(task.taskId, messageId);
        }
      }
    }
    if (!isTaskResponse) {
      this._progressHandlers.delete(messageId);
    }
    if (isJSONRPCResultResponse(response)) {
      handler(response);
    } else {
      const error3 = McpError.fromError(response.error.code, response.error.message, response.error.data);
      handler(error3);
    }
  }
  get transport() {
    return this._transport;
  }
  /**
   * Closes the connection.
   */
  async close() {
    await this._transport?.close();
  }
  /**
   * Sends a request and returns an AsyncGenerator that yields response messages.
   * The generator is guaranteed to end with either a 'result' or 'error' message.
   *
   * @example
   * ```typescript
   * const stream = protocol.requestStream(request, resultSchema, options);
   * for await (const message of stream) {
   *   switch (message.type) {
   *     case 'taskCreated':
   *       console.log('Task created:', message.task.taskId);
   *       break;
   *     case 'taskStatus':
   *       console.log('Task status:', message.task.status);
   *       break;
   *     case 'result':
   *       console.log('Final result:', message.result);
   *       break;
   *     case 'error':
   *       console.error('Error:', message.error);
   *       break;
   *   }
   * }
   * ```
   *
   * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
   */
  async *requestStream(request, resultSchema, options) {
    const { task } = options ?? {};
    if (!task) {
      try {
        const result = await this.request(request, resultSchema, options);
        yield { type: "result", result };
      } catch (error3) {
        yield {
          type: "error",
          error: error3 instanceof McpError ? error3 : new McpError(ErrorCode.InternalError, String(error3))
        };
      }
      return;
    }
    let taskId;
    try {
      const createResult = await this.request(request, CreateTaskResultSchema, options);
      if (createResult.task) {
        taskId = createResult.task.taskId;
        yield { type: "taskCreated", task: createResult.task };
      } else {
        throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
      }
      while (true) {
        const task2 = await this.getTask({ taskId }, options);
        yield { type: "taskStatus", task: task2 };
        if (isTerminal(task2.status)) {
          if (task2.status === "completed") {
            const result = await this.getTaskResult({ taskId }, resultSchema, options);
            yield { type: "result", result };
          } else if (task2.status === "failed") {
            yield {
              type: "error",
              error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
            };
          } else if (task2.status === "cancelled") {
            yield {
              type: "error",
              error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
            };
          }
          return;
        }
        if (task2.status === "input_required") {
          const result = await this.getTaskResult({ taskId }, resultSchema, options);
          yield { type: "result", result };
          return;
        }
        const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
        options?.signal?.throwIfAborted();
      }
    } catch (error3) {
      yield {
        type: "error",
        error: error3 instanceof McpError ? error3 : new McpError(ErrorCode.InternalError, String(error3))
      };
    }
  }
  /**
   * Sends a request and waits for a response.
   *
   * Do not use this method to emit notifications! Use notification() instead.
   */
  request(request, resultSchema, options) {
    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
    return new Promise((resolve3, reject) => {
      const earlyReject = (error3) => {
        reject(error3);
      };
      if (!this._transport) {
        earlyReject(new Error("Not connected"));
        return;
      }
      if (this._options?.enforceStrictCapabilities === true) {
        try {
          this.assertCapabilityForMethod(request.method);
          if (task) {
            this.assertTaskCapability(request.method);
          }
        } catch (e) {
          earlyReject(e);
          return;
        }
      }
      options?.signal?.throwIfAborted();
      const messageId = this._requestMessageId++;
      const jsonrpcRequest = {
        ...request,
        jsonrpc: "2.0",
        id: messageId
      };
      if (options?.onprogress) {
        this._progressHandlers.set(messageId, options.onprogress);
        jsonrpcRequest.params = {
          ...request.params,
          _meta: {
            ...request.params?._meta || {},
            progressToken: messageId
          }
        };
      }
      if (task) {
        jsonrpcRequest.params = {
          ...jsonrpcRequest.params,
          task
        };
      }
      if (relatedTask) {
        jsonrpcRequest.params = {
          ...jsonrpcRequest.params,
          _meta: {
            ...jsonrpcRequest.params?._meta || {},
            [RELATED_TASK_META_KEY]: relatedTask
          }
        };
      }
      const cancel = (reason) => {
        this._responseHandlers.delete(messageId);
        this._progressHandlers.delete(messageId);
        this._cleanupTimeout(messageId);
        this._transport?.send({
          jsonrpc: "2.0",
          method: "notifications/cancelled",
          params: {
            requestId: messageId,
            reason: String(reason)
          }
        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error4) => this._onerror(new Error(`Failed to send cancellation: ${error4}`)));
        const error3 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
        reject(error3);
      };
      this._responseHandlers.set(messageId, (response) => {
        if (options?.signal?.aborted) {
          return;
        }
        if (response instanceof Error) {
          return reject(response);
        }
        try {
          const parseResult = safeParse3(resultSchema, response.result);
          if (!parseResult.success) {
            reject(parseResult.error);
          } else {
            resolve3(parseResult.data);
          }
        } catch (error3) {
          reject(error3);
        }
      });
      options?.signal?.addEventListener("abort", () => {
        cancel(options?.signal?.reason);
      });
      const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
      const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
      this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
      const relatedTaskId = relatedTask?.taskId;
      if (relatedTaskId) {
        const responseResolver = (response) => {
          const handler = this._responseHandlers.get(messageId);
          if (handler) {
            handler(response);
          } else {
            this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
          }
        };
        this._requestResolvers.set(messageId, responseResolver);
        this._enqueueTaskMessage(relatedTaskId, {
          type: "request",
          message: jsonrpcRequest,
          timestamp: Date.now()
        }).catch((error3) => {
          this._cleanupTimeout(messageId);
          reject(error3);
        });
      } else {
        this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error3) => {
          this._cleanupTimeout(messageId);
          reject(error3);
        });
      }
    });
  }
  /**
   * Gets the current status of a task.
   *
   * @experimental Use `client.experimental.tasks.getTask()` to access this method.
   */
  async getTask(params, options) {
    return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
  }
  /**
   * Retrieves the result of a completed task.
   *
   * @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
   */
  async getTaskResult(params, resultSchema, options) {
    return this.request({ method: "tasks/result", params }, resultSchema, options);
  }
  /**
   * Lists tasks, optionally starting from a pagination cursor.
   *
   * @experimental Use `client.experimental.tasks.listTasks()` to access this method.
   */
  async listTasks(params, options) {
    return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
  }
  /**
   * Cancels a specific task.
   *
   * @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
   */
  async cancelTask(params, options) {
    return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
  }
  /**
   * Emits a notification, which is a one-way message that does not expect a response.
   */
  async notification(notification, options) {
    if (!this._transport) {
      throw new Error("Not connected");
    }
    this.assertNotificationCapability(notification.method);
    const relatedTaskId = options?.relatedTask?.taskId;
    if (relatedTaskId) {
      const jsonrpcNotification2 = {
        ...notification,
        jsonrpc: "2.0",
        params: {
          ...notification.params,
          _meta: {
            ...notification.params?._meta || {},
            [RELATED_TASK_META_KEY]: options.relatedTask
          }
        }
      };
      await this._enqueueTaskMessage(relatedTaskId, {
        type: "notification",
        message: jsonrpcNotification2,
        timestamp: Date.now()
      });
      return;
    }
    const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask;
    if (canDebounce) {
      if (this._pendingDebouncedNotifications.has(notification.method)) {
        return;
      }
      this._pendingDebouncedNotifications.add(notification.method);
      Promise.resolve().then(() => {
        this._pendingDebouncedNotifications.delete(notification.method);
        if (!this._transport) {
          return;
        }
        let jsonrpcNotification2 = {
          ...notification,
          jsonrpc: "2.0"
        };
        if (options?.relatedTask) {
          jsonrpcNotification2 = {
            ...jsonrpcNotification2,
            params: {
              ...jsonrpcNotification2.params,
              _meta: {
                ...jsonrpcNotification2.params?._meta || {},
                [RELATED_TASK_META_KEY]: options.relatedTask
              }
            }
          };
        }
        this._transport?.send(jsonrpcNotification2, options).catch((error3) => this._onerror(error3));
      });
      return;
    }
    let jsonrpcNotification = {
      ...notification,
      jsonrpc: "2.0"
    };
    if (options?.relatedTask) {
      jsonrpcNotification = {
        ...jsonrpcNotification,
        params: {
          ...jsonrpcNotification.params,
          _meta: {
            ...jsonrpcNotification.params?._meta || {},
            [RELATED_TASK_META_KEY]: options.relatedTask
          }
        }
      };
    }
    await this._transport.send(jsonrpcNotification, options);
  }
  /**
   * Registers a handler to invoke when this protocol object receives a request with the given method.
   *
   * Note that this will replace any previous request handler for the same method.
   */
  setRequestHandler(requestSchema, handler) {
    const method = getMethodLiteral(requestSchema);
    this.assertRequestHandlerCapability(method);
    this._requestHandlers.set(method, (request, extra) => {
      const parsed = parseWithCompat(requestSchema, request);
      return Promise.resolve(handler(parsed, extra));
    });
  }
  /**
   * Removes the request handler for the given method.
   */
  removeRequestHandler(method) {
    this._requestHandlers.delete(method);
  }
  /**
   * Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
   */
  assertCanSetRequestHandler(method) {
    if (this._requestHandlers.has(method)) {
      throw new Error(`A request handler for ${method} already exists, which would be overridden`);
    }
  }
  /**
   * Registers a handler to invoke when this protocol object receives a notification with the given method.
   *
   * Note that this will replace any previous notification handler for the same method.
   */
  setNotificationHandler(notificationSchema, handler) {
    const method = getMethodLiteral(notificationSchema);
    this._notificationHandlers.set(method, (notification) => {
      const parsed = parseWithCompat(notificationSchema, notification);
      return Promise.resolve(handler(parsed));
    });
  }
  /**
   * Removes the notification handler for the given method.
   */
  removeNotificationHandler(method) {
    this._notificationHandlers.delete(method);
  }
  /**
   * Cleans up the progress handler associated with a task.
   * This should be called when a task reaches a terminal status.
   */
  _cleanupTaskProgressHandler(taskId) {
    const progressToken = this._taskProgressTokens.get(taskId);
    if (progressToken !== void 0) {
      this._progressHandlers.delete(progressToken);
      this._taskProgressTokens.delete(taskId);
    }
  }
  /**
   * Enqueues a task-related message for side-channel delivery via tasks/result.
   * @param taskId The task ID to associate the message with
   * @param message The message to enqueue
   * @param sessionId Optional session ID for binding the operation to a specific session
   * @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
   *
   * Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
   * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
   * simply propagates the error.
   */
  async _enqueueTaskMessage(taskId, message, sessionId) {
    if (!this._taskStore || !this._taskMessageQueue) {
      throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
    }
    const maxQueueSize = this._options?.maxTaskQueueSize;
    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
  }
  /**
   * Clears the message queue for a task and rejects any pending request resolvers.
   * @param taskId The task ID whose queue should be cleared
   * @param sessionId Optional session ID for binding the operation to a specific session
   */
  async _clearTaskQueue(taskId, sessionId) {
    if (this._taskMessageQueue) {
      const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
      for (const message of messages) {
        if (message.type === "request" && isJSONRPCRequest(message.message)) {
          const requestId = message.message.id;
          const resolver = this._requestResolvers.get(requestId);
          if (resolver) {
            resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
            this._requestResolvers.delete(requestId);
          } else {
            this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
          }
        }
      }
    }
  }
  /**
   * Waits for a task update (new messages or status change) with abort signal support.
   * Uses polling to check for updates at the task's configured poll interval.
   * @param taskId The task ID to wait for
   * @param signal Abort signal to cancel the wait
   * @returns Promise that resolves when an update occurs or rejects if aborted
   */
  async _waitForTaskUpdate(taskId, signal) {
    let interval = this._options?.defaultTaskPollInterval ?? 1e3;
    try {
      const task = await this._taskStore?.getTask(taskId);
      if (task?.pollInterval) {
        interval = task.pollInterval;
      }
    } catch {
    }
    return new Promise((resolve3, reject) => {
      if (signal.aborted) {
        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
        return;
      }
      const timeoutId = setTimeout(resolve3, interval);
      signal.addEventListener("abort", () => {
        clearTimeout(timeoutId);
        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
      }, { once: true });
    });
  }
  requestTaskStore(request, sessionId) {
    const taskStore = this._taskStore;
    if (!taskStore) {
      throw new Error("No task store configured");
    }
    return {
      createTask: async (taskParams) => {
        if (!request) {
          throw new Error("No request provided");
        }
        return await taskStore.createTask(taskParams, request.id, {
          method: request.method,
          params: request.params
        }, sessionId);
      },
      getTask: async (taskId) => {
        const task = await taskStore.getTask(taskId, sessionId);
        if (!task) {
          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
        }
        return task;
      },
      storeTaskResult: async (taskId, status, result) => {
        await taskStore.storeTaskResult(taskId, status, result, sessionId);
        const task = await taskStore.getTask(taskId, sessionId);
        if (task) {
          const notification = TaskStatusNotificationSchema.parse({
            method: "notifications/tasks/status",
            params: task
          });
          await this.notification(notification);
          if (isTerminal(task.status)) {
            this._cleanupTaskProgressHandler(taskId);
          }
        }
      },
      getTaskResult: (taskId) => {
        return taskStore.getTaskResult(taskId, sessionId);
      },
      updateTaskStatus: async (taskId, status, statusMessage) => {
        const task = await taskStore.getTask(taskId, sessionId);
        if (!task) {
          throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
        }
        if (isTerminal(task.status)) {
          throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
        }
        await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
        const updatedTask = await taskStore.getTask(taskId, sessionId);
        if (updatedTask) {
          const notification = TaskStatusNotificationSchema.parse({
            method: "notifications/tasks/status",
            params: updatedTask
          });
          await this.notification(notification);
          if (isTerminal(updatedTask.status)) {
            this._cleanupTaskProgressHandler(taskId);
          }
        }
      },
      listTasks: (cursor) => {
        return taskStore.listTasks(cursor, sessionId);
      }
    };
  }
};
function isPlainObject2(value) {
  return value !== null && typeof value === "object" && !Array.isArray(value);
}
function mergeCapabilities(base, additional) {
  const result = { ...base };
  for (const key in additional) {
    const k = key;
    const addValue = additional[k];
    if (addValue === void 0)
      continue;
    const baseValue = result[k];
    if (isPlainObject2(baseValue) && isPlainObject2(addValue)) {
      result[k] = { ...baseValue, ...addValue };
    } else {
      result[k] = addValue;
    }
  }
  return result;
}

// node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
var import_ajv = __toESM(require_ajv(), 1);
var import_ajv_formats = __toESM(require_dist(), 1);
function createDefaultAjvInstance() {
  const ajv = new import_ajv.default({
    strict: false,
    validateFormats: true,
    validateSchema: false,
    allErrors: true
  });
  const addFormats = import_ajv_formats.default;
  addFormats(ajv);
  return ajv;
}
var AjvJsonSchemaValidator = class {
  /**
   * Create an AJV validator
   *
   * @param ajv - Optional pre-configured AJV instance. If not provided, a default instance will be created.
   *
   * @example
   * ```typescript
   * // Use default configuration (recommended for most cases)
   * import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
   * const validator = new AjvJsonSchemaValidator();
   *
   * // Or provide custom AJV instance for advanced configuration
   * import { Ajv } from 'ajv';
   * import addFormats from 'ajv-formats';
   *
   * const ajv = new Ajv({ validateFormats: true });
   * addFormats(ajv);
   * const validator = new AjvJsonSchemaValidator(ajv);
   * ```
   */
  constructor(ajv) {
    this._ajv = ajv ?? createDefaultAjvInstance();
  }
  /**
   * Create a validator for the given JSON Schema
   *
   * The validator is compiled once and can be reused multiple times.
   * If the schema has an $id, it will be cached by AJV automatically.
   *
   * @param schema - Standard JSON Schema object
   * @returns A validator function that validates input data
   */
  getValidator(schema) {
    const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
    return (input) => {
      const valid = ajvValidator(input);
      if (valid) {
        return {
          valid: true,
          data: input,
          errorMessage: void 0
        };
      } else {
        return {
          valid: false,
          data: void 0,
          errorMessage: this._ajv.errorsText(ajvValidator.errors)
        };
      }
    };
  }
};

// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
var ExperimentalServerTasks = class {
  constructor(_server) {
    this._server = _server;
  }
  /**
   * Sends a request and returns an AsyncGenerator that yields response messages.
   * The generator is guaranteed to end with either a 'result' or 'error' message.
   *
   * This method provides streaming access to request processing, allowing you to
   * observe intermediate task status updates for task-augmented requests.
   *
   * @param request - The request to send
   * @param resultSchema - Zod schema for validating the result
   * @param options - Optional request options (timeout, signal, task creation params, etc.)
   * @returns AsyncGenerator that yields ResponseMessage objects
   *
   * @experimental
   */
  requestStream(request, resultSchema, options) {
    return this._server.requestStream(request, resultSchema, options);
  }
  /**
   * Sends a sampling request and returns an AsyncGenerator that yields response messages.
   * The generator is guaranteed to end with either a 'result' or 'error' message.
   *
   * For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
   * before the final result.
   *
   * @example
   * ```typescript
   * const stream = server.experimental.tasks.createMessageStream({
   *     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
   *     maxTokens: 100
   * }, {
   *     onprogress: (progress) => {
   *         // Handle streaming tokens via progress notifications
   *         console.log('Progress:', progress.message);
   *     }
   * });
   *
   * for await (const message of stream) {
   *     switch (message.type) {
   *         case 'taskCreated':
   *             console.log('Task created:', message.task.taskId);
   *             break;
   *         case 'taskStatus':
   *             console.log('Task status:', message.task.status);
   *             break;
   *         case 'result':
   *             console.log('Final result:', message.result);
   *             break;
   *         case 'error':
   *             console.error('Error:', message.error);
   *             break;
   *     }
   * }
   * ```
   *
   * @param params - The sampling request parameters
   * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
   * @returns AsyncGenerator that yields ResponseMessage objects
   *
   * @experimental
   */
  createMessageStream(params, options) {
    const clientCapabilities = this._server.getClientCapabilities();
    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
      throw new Error("Client does not support sampling tools capability.");
    }
    if (params.messages.length > 0) {
      const lastMessage = params.messages[params.messages.length - 1];
      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
      if (hasToolResults) {
        if (lastContent.some((c) => c.type !== "tool_result")) {
          throw new Error("The last message must contain only tool_result content if any is present");
        }
        if (!hasPreviousToolUse) {
          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
        }
      }
      if (hasPreviousToolUse) {
        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
        }
      }
    }
    return this.requestStream({
      method: "sampling/createMessage",
      params
    }, CreateMessageResultSchema, options);
  }
  /**
   * Sends an elicitation request and returns an AsyncGenerator that yields response messages.
   * The generator is guaranteed to end with either a 'result' or 'error' message.
   *
   * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
   * and 'taskStatus' messages before the final result.
   *
   * @example
   * ```typescript
   * const stream = server.experimental.tasks.elicitInputStream({
   *     mode: 'url',
   *     message: 'Please authenticate',
   *     elicitationId: 'auth-123',
   *     url: 'https://example.com/auth'
   * }, {
   *     task: { ttl: 300000 } // Task-augmented for long-running auth flow
   * });
   *
   * for await (const message of stream) {
   *     switch (message.type) {
   *         case 'taskCreated':
   *             console.log('Task created:', message.task.taskId);
   *             break;
   *         case 'taskStatus':
   *             console.log('Task status:', message.task.status);
   *             break;
   *         case 'result':
   *             console.log('User action:', message.result.action);
   *             break;
   *         case 'error':
   *             console.error('Error:', message.error);
   *             break;
   *     }
   * }
   * ```
   *
   * @param params - The elicitation request parameters
   * @param options - Optional request options (timeout, signal, task creation params, etc.)
   * @returns AsyncGenerator that yields ResponseMessage objects
   *
   * @experimental
   */
  elicitInputStream(params, options) {
    const clientCapabilities = this._server.getClientCapabilities();
    const mode = params.mode ?? "form";
    switch (mode) {
      case "url": {
        if (!clientCapabilities?.elicitation?.url) {
          throw new Error("Client does not support url elicitation.");
        }
        break;
      }
      case "form": {
        if (!clientCapabilities?.elicitation?.form) {
          throw new Error("Client does not support form elicitation.");
        }
        break;
      }
    }
    const normalizedParams = mode === "form" && params.mode === void 0 ? { ...params, mode: "form" } : params;
    return this.requestStream({
      method: "elicitation/create",
      params: normalizedParams
    }, ElicitResultSchema, options);
  }
  /**
   * Gets the current status of a task.
   *
   * @param taskId - The task identifier
   * @param options - Optional request options
   * @returns The task status
   *
   * @experimental
   */
  async getTask(taskId, options) {
    return this._server.getTask({ taskId }, options);
  }
  /**
   * Retrieves the result of a completed task.
   *
   * @param taskId - The task identifier
   * @param resultSchema - Zod schema for validating the result
   * @param options - Optional request options
   * @returns The task result
   *
   * @experimental
   */
  async getTaskResult(taskId, resultSchema, options) {
    return this._server.getTaskResult({ taskId }, resultSchema, options);
  }
  /**
   * Lists tasks with optional pagination.
   *
   * @param cursor - Optional pagination cursor
   * @param options - Optional request options
   * @returns List of tasks with optional next cursor
   *
   * @experimental
   */
  async listTasks(cursor, options) {
    return this._server.listTasks(cursor ? { cursor } : void 0, options);
  }
  /**
   * Cancels a running task.
   *
   * @param taskId - The task identifier
   * @param options - Optional request options
   *
   * @experimental
   */
  async cancelTask(taskId, options) {
    return this._server.cancelTask({ taskId }, options);
  }
};

// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
function assertToolsCallTaskCapability(requests2, method, entityName) {
  if (!requests2) {
    throw new Error(`${entityName} does not support task creation (required for ${method})`);
  }
  switch (method) {
    case "tools/call":
      if (!requests2.tools?.call) {
        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
      }
      break;
    default:
      break;
  }
}
function assertClientRequestTaskCapability(requests2, method, entityName) {
  if (!requests2) {
    throw new Error(`${entityName} does not support task creation (required for ${method})`);
  }
  switch (method) {
    case "sampling/createMessage":
      if (!requests2.sampling?.createMessage) {
        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
      }
      break;
    case "elicitation/create":
      if (!requests2.elicitation?.create) {
        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
      }
      break;
    default:
      break;
  }
}

// node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
var Server = class extends Protocol {
  /**
   * Initializes this server with the given name and version information.
   */
  constructor(_serverInfo, options) {
    super(options);
    this._serverInfo = _serverInfo;
    this._loggingLevels = /* @__PURE__ */ new Map();
    this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
    this.isMessageIgnored = (level, sessionId) => {
      const currentLevel = this._loggingLevels.get(sessionId);
      return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
    };
    this._capabilities = options?.capabilities ?? {};
    this._instructions = options?.instructions;
    this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
    this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
    this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
    if (this._capabilities.logging) {
      this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
        const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0;
        const { level } = request.params;
        const parseResult = LoggingLevelSchema.safeParse(level);
        if (parseResult.success) {
          this._loggingLevels.set(transportSessionId, parseResult.data);
        }
        return {};
      });
    }
  }
  /**
   * Access experimental features.
   *
   * WARNING: These APIs are experimental and may change without notice.
   *
   * @experimental
   */
  get experimental() {
    if (!this._experimental) {
      this._experimental = {
        tasks: new ExperimentalServerTasks(this)
      };
    }
    return this._experimental;
  }
  /**
   * Registers new capabilities. This can only be called before connecting to a transport.
   *
   * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
   */
  registerCapabilities(capabilities) {
    if (this.transport) {
      throw new Error("Cannot register capabilities after connecting to transport");
    }
    this._capabilities = mergeCapabilities(this._capabilities, capabilities);
  }
  /**
   * Override request handler registration to enforce server-side validation for tools/call.
   */
  setRequestHandler(requestSchema, handler) {
    const shape = getObjectShape(requestSchema);
    const methodSchema = shape?.method;
    if (!methodSchema) {
      throw new Error("Schema is missing a method literal");
    }
    let methodValue;
    if (isZ4Schema(methodSchema)) {
      const v4Schema = methodSchema;
      const v4Def = v4Schema._zod?.def;
      methodValue = v4Def?.value ?? v4Schema.value;
    } else {
      const v3Schema = methodSchema;
      const legacyDef = v3Schema._def;
      methodValue = legacyDef?.value ?? v3Schema.value;
    }
    if (typeof methodValue !== "string") {
      throw new Error("Schema method literal must be a string");
    }
    const method = methodValue;
    if (method === "tools/call") {
      const wrappedHandler = async (request, extra) => {
        const validatedRequest = safeParse3(CallToolRequestSchema, request);
        if (!validatedRequest.success) {
          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
        }
        const { params } = validatedRequest.data;
        const result = await Promise.resolve(handler(request, extra));
        if (params.task) {
          const taskValidationResult = safeParse3(CreateTaskResultSchema, result);
          if (!taskValidationResult.success) {
            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
          }
          return taskValidationResult.data;
        }
        const validationResult = safeParse3(CallToolResultSchema, result);
        if (!validationResult.success) {
          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
        }
        return validationResult.data;
      };
      return super.setRequestHandler(requestSchema, wrappedHandler);
    }
    return super.setRequestHandler(requestSchema, handler);
  }
  assertCapabilityForMethod(method) {
    switch (method) {
      case "sampling/createMessage":
        if (!this._clientCapabilities?.sampling) {
          throw new Error(`Client does not support sampling (required for ${method})`);
        }
        break;
      case "elicitation/create":
        if (!this._clientCapabilities?.elicitation) {
          throw new Error(`Client does not support elicitation (required for ${method})`);
        }
        break;
      case "roots/list":
        if (!this._clientCapabilities?.roots) {
          throw new Error(`Client does not support listing roots (required for ${method})`);
        }
        break;
      case "ping":
        break;
    }
  }
  assertNotificationCapability(method) {
    switch (method) {
      case "notifications/message":
        if (!this._capabilities.logging) {
          throw new Error(`Server does not support logging (required for ${method})`);
        }
        break;
      case "notifications/resources/updated":
      case "notifications/resources/list_changed":
        if (!this._capabilities.resources) {
          throw new Error(`Server does not support notifying about resources (required for ${method})`);
        }
        break;
      case "notifications/tools/list_changed":
        if (!this._capabilities.tools) {
          throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
        }
        break;
      case "notifications/prompts/list_changed":
        if (!this._capabilities.prompts) {
          throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
        }
        break;
      case "notifications/elicitation/complete":
        if (!this._clientCapabilities?.elicitation?.url) {
          throw new Error(`Client does not support URL elicitation (required for ${method})`);
        }
        break;
      case "notifications/cancelled":
        break;
      case "notifications/progress":
        break;
    }
  }
  assertRequestHandlerCapability(method) {
    if (!this._capabilities) {
      return;
    }
    switch (method) {
      case "completion/complete":
        if (!this._capabilities.completions) {
          throw new Error(`Server does not support completions (required for ${method})`);
        }
        break;
      case "logging/setLevel":
        if (!this._capabilities.logging) {
          throw new Error(`Server does not support logging (required for ${method})`);
        }
        break;
      case "prompts/get":
      case "prompts/list":
        if (!this._capabilities.prompts) {
          throw new Error(`Server does not support prompts (required for ${method})`);
        }
        break;
      case "resources/list":
      case "resources/templates/list":
      case "resources/read":
        if (!this._capabilities.resources) {
          throw new Error(`Server does not support resources (required for ${method})`);
        }
        break;
      case "tools/call":
      case "tools/list":
        if (!this._capabilities.tools) {
          throw new Error(`Server does not support tools (required for ${method})`);
        }
        break;
      case "tasks/get":
      case "tasks/list":
      case "tasks/result":
      case "tasks/cancel":
        if (!this._capabilities.tasks) {
          throw new Error(`Server does not support tasks capability (required for ${method})`);
        }
        break;
      case "ping":
      case "initialize":
        break;
    }
  }
  assertTaskCapability(method) {
    assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
  }
  assertTaskHandlerCapability(method) {
    if (!this._capabilities) {
      return;
    }
    assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
  }
  async _oninitialize(request) {
    const requestedVersion = request.params.protocolVersion;
    this._clientCapabilities = request.params.capabilities;
    this._clientVersion = request.params.clientInfo;
    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
    return {
      protocolVersion,
      capabilities: this.getCapabilities(),
      serverInfo: this._serverInfo,
      ...this._instructions && { instructions: this._instructions }
    };
  }
  /**
   * After initialization has completed, this will be populated with the client's reported capabilities.
   */
  getClientCapabilities() {
    return this._clientCapabilities;
  }
  /**
   * After initialization has completed, this will be populated with information about the client's name and version.
   */
  getClientVersion() {
    return this._clientVersion;
  }
  getCapabilities() {
    return this._capabilities;
  }
  async ping() {
    return this.request({ method: "ping" }, EmptyResultSchema);
  }
  // Implementation
  async createMessage(params, options) {
    if (params.tools || params.toolChoice) {
      if (!this._clientCapabilities?.sampling?.tools) {
        throw new Error("Client does not support sampling tools capability.");
      }
    }
    if (params.messages.length > 0) {
      const lastMessage = params.messages[params.messages.length - 1];
      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
      if (hasToolResults) {
        if (lastContent.some((c) => c.type !== "tool_result")) {
          throw new Error("The last message must contain only tool_result content if any is present");
        }
        if (!hasPreviousToolUse) {
          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
        }
      }
      if (hasPreviousToolUse) {
        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
        }
      }
    }
    if (params.tools) {
      return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
    }
    return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
  }
  /**
   * Creates an elicitation request for the given parameters.
   * For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
   * @param params The parameters for the elicitation request.
   * @param options Optional request options.
   * @returns The result of the elicitation request.
   */
  async elicitInput(params, options) {
    const mode = params.mode ?? "form";
    switch (mode) {
      case "url": {
        if (!this._clientCapabilities?.elicitation?.url) {
          throw new Error("Client does not support url elicitation.");
        }
        const urlParams = params;
        return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
      }
      case "form": {
        if (!this._clientCapabilities?.elicitation?.form) {
          throw new Error("Client does not support form elicitation.");
        }
        const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
        const result = await this.request({ method: "elicitation/create", params: formParams }, ElicitResultSchema, options);
        if (result.action === "accept" && result.content && formParams.requestedSchema) {
          try {
            const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);
            const validationResult = validator(result.content);
            if (!validationResult.valid) {
              throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
            }
          } catch (error3) {
            if (error3 instanceof McpError) {
              throw error3;
            }
            throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error3 instanceof Error ? error3.message : String(error3)}`);
          }
        }
        return result;
      }
    }
  }
  /**
   * Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
   * notification for the specified elicitation ID.
   *
   * @param elicitationId The ID of the elicitation to mark as complete.
   * @param options Optional notification options. Useful when the completion notification should be related to a prior request.
   * @returns A function that emits the completion notification when awaited.
   */
  createElicitationCompletionNotifier(elicitationId, options) {
    if (!this._clientCapabilities?.elicitation?.url) {
      throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
    }
    return () => this.notification({
      method: "notifications/elicitation/complete",
      params: {
        elicitationId
      }
    }, options);
  }
  async listRoots(params, options) {
    return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
  }
  /**
   * Sends a logging message to the client, if connected.
   * Note: You only need to send the parameters object, not the entire JSON RPC message
   * @see LoggingMessageNotification
   * @param params
   * @param sessionId optional for stateless and backward compatibility
   */
  async sendLoggingMessage(params, sessionId) {
    if (this._capabilities.logging) {
      if (!this.isMessageIgnored(params.level, sessionId)) {
        return this.notification({ method: "notifications/message", params });
      }
    }
  }
  async sendResourceUpdated(params) {
    return this.notification({
      method: "notifications/resources/updated",
      params
    });
  }
  async sendResourceListChanged() {
    return this.notification({
      method: "notifications/resources/list_changed"
    });
  }
  async sendToolListChanged() {
    return this.notification({ method: "notifications/tools/list_changed" });
  }
  async sendPromptListChanged() {
    return this.notification({ method: "notifications/prompts/list_changed" });
  }
};

// node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
function isCompletable(schema) {
  return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
}
function getCompleter(schema) {
  const meta = schema[COMPLETABLE_SYMBOL];
  return meta?.complete;
}
var McpZodTypeKind;
(function(McpZodTypeKind2) {
  McpZodTypeKind2["Completable"] = "McpCompletable";
})(McpZodTypeKind || (McpZodTypeKind = {}));

// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
function validateToolName(name) {
  const warnings = [];
  if (name.length === 0) {
    return {
      isValid: false,
      warnings: ["Tool name cannot be empty"]
    };
  }
  if (name.length > 128) {
    return {
      isValid: false,
      warnings: [`Tool name exceeds maximum length of 128 characters (current: ${name.length})`]
    };
  }
  if (name.includes(" ")) {
    warnings.push("Tool name contains spaces, which may cause parsing issues");
  }
  if (name.includes(",")) {
    warnings.push("Tool name contains commas, which may cause parsing issues");
  }
  if (name.startsWith("-") || name.endsWith("-")) {
    warnings.push("Tool name starts or ends with a dash, which may cause parsing issues in some contexts");
  }
  if (name.startsWith(".") || name.endsWith(".")) {
    warnings.push("Tool name starts or ends with a dot, which may cause parsing issues in some contexts");
  }
  if (!TOOL_NAME_REGEX.test(name)) {
    const invalidChars = name.split("").filter((char) => !/[A-Za-z0-9._-]/.test(char)).filter((char, index, arr) => arr.indexOf(char) === index);
    warnings.push(`Tool name contains invalid characters: ${invalidChars.map((c) => `"${c}"`).join(", ")}`, "Allowed characters are: A-Z, a-z, 0-9, underscore (_), dash (-), and dot (.)");
    return {
      isValid: false,
      warnings
    };
  }
  return {
    isValid: true,
    warnings
  };
}
function issueToolNameWarning(name, warnings) {
  if (warnings.length > 0) {
    console.warn(`Tool name validation warning for "${name}":`);
    for (const warning of warnings) {
      console.warn(`  - ${warning}`);
    }
    console.warn("Tool registration will proceed, but this may cause compatibility issues.");
    console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
    console.warn("See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details.");
  }
}
function validateAndWarnToolName(name) {
  const result = validateToolName(name);
  issueToolNameWarning(name, result.warnings);
  return result.isValid;
}

// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
var ExperimentalMcpServerTasks = class {
  constructor(_mcpServer) {
    this._mcpServer = _mcpServer;
  }
  registerToolTask(name, config2, handler) {
    const execution = { taskSupport: "required", ...config2.execution };
    if (execution.taskSupport === "forbidden") {
      throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
    }
    const mcpServerInternal = this._mcpServer;
    return mcpServerInternal._createRegisteredTool(name, config2.title, config2.description, config2.inputSchema, config2.outputSchema, config2.annotations, execution, config2._meta, handler);
  }
};

// node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
var McpServer = class {
  constructor(serverInfo, options) {
    this._registeredResources = {};
    this._registeredResourceTemplates = {};
    this._registeredTools = {};
    this._registeredPrompts = {};
    this._toolHandlersInitialized = false;
    this._completionHandlerInitialized = false;
    this._resourceHandlersInitialized = false;
    this._promptHandlersInitialized = false;
    this.server = new Server(serverInfo, options);
  }
  /**
   * Access experimental features.
   *
   * WARNING: These APIs are experimental and may change without notice.
   *
   * @experimental
   */
  get experimental() {
    if (!this._experimental) {
      this._experimental = {
        tasks: new ExperimentalMcpServerTasks(this)
      };
    }
    return this._experimental;
  }
  /**
   * Attaches to the given transport, starts it, and starts listening for messages.
   *
   * The `server` object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
   */
  async connect(transport) {
    return await this.server.connect(transport);
  }
  /**
   * Closes the connection.
   */
  async close() {
    await this.server.close();
  }
  setToolRequestHandlers() {
    if (this._toolHandlersInitialized) {
      return;
    }
    this.server.assertCanSetRequestHandler(getMethodValue(ListToolsRequestSchema));
    this.server.assertCanSetRequestHandler(getMethodValue(CallToolRequestSchema));
    this.server.registerCapabilities({
      tools: {
        listChanged: true
      }
    });
    this.server.setRequestHandler(ListToolsRequestSchema, () => ({
      tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
        const toolDefinition = {
          name,
          title: tool.title,
          description: tool.description,
          inputSchema: (() => {
            const obj = normalizeObjectSchema(tool.inputSchema);
            return obj ? toJsonSchemaCompat(obj, {
              strictUnions: true,
              pipeStrategy: "input"
            }) : EMPTY_OBJECT_JSON_SCHEMA;
          })(),
          annotations: tool.annotations,
          execution: tool.execution,
          _meta: tool._meta
        };
        if (tool.outputSchema) {
          const obj = normalizeObjectSchema(tool.outputSchema);
          if (obj) {
            toolDefinition.outputSchema = toJsonSchemaCompat(obj, {
              strictUnions: true,
              pipeStrategy: "output"
            });
          }
        }
        return toolDefinition;
      })
    }));
    this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
      try {
        const tool = this._registeredTools[request.params.name];
        if (!tool) {
          throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
        }
        if (!tool.enabled) {
          throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
        }
        const isTaskRequest = !!request.params.task;
        const taskSupport = tool.execution?.taskSupport;
        const isTaskHandler = "createTask" in tool.handler;
        if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
          throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
        }
        if (taskSupport === "required" && !isTaskRequest) {
          throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
        }
        if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
          return await this.handleAutomaticTaskPolling(tool, request, extra);
        }
        const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
        const result = await this.executeToolHandler(tool, args, extra);
        if (isTaskRequest) {
          return result;
        }
        await this.validateToolOutput(tool, result, request.params.name);
        return result;
      } catch (error3) {
        if (error3 instanceof McpError) {
          if (error3.code === ErrorCode.UrlElicitationRequired) {
            throw error3;
          }
        }
        return this.createToolError(error3 instanceof Error ? error3.message : String(error3));
      }
    });
    this._toolHandlersInitialized = true;
  }
  /**
   * Creates a tool error result.
   *
   * @param errorMessage - The error message.
   * @returns The tool error result.
   */
  createToolError(errorMessage) {
    return {
      content: [
        {
          type: "text",
          text: errorMessage
        }
      ],
      isError: true
    };
  }
  /**
   * Validates tool input arguments against the tool's input schema.
   */
  async validateToolInput(tool, args, toolName) {
    if (!tool.inputSchema) {
      return void 0;
    }
    const inputObj = normalizeObjectSchema(tool.inputSchema);
    const schemaToParse = inputObj ?? tool.inputSchema;
    const parseResult = await safeParseAsync3(schemaToParse, args);
    if (!parseResult.success) {
      const error3 = "error" in parseResult ? parseResult.error : "Unknown error";
      const errorMessage = getParseErrorMessage(error3);
      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
    }
    return parseResult.data;
  }
  /**
   * Validates tool output against the tool's output schema.
   */
  async validateToolOutput(tool, result, toolName) {
    if (!tool.outputSchema) {
      return;
    }
    if (!("content" in result)) {
      return;
    }
    if (result.isError) {
      return;
    }
    if (!result.structuredContent) {
      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
    }
    const outputObj = normalizeObjectSchema(tool.outputSchema);
    const parseResult = await safeParseAsync3(outputObj, result.structuredContent);
    if (!parseResult.success) {
      const error3 = "error" in parseResult ? parseResult.error : "Unknown error";
      const errorMessage = getParseErrorMessage(error3);
      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
    }
  }
  /**
   * Executes a tool handler (either regular or task-based).
   */
  async executeToolHandler(tool, args, extra) {
    const handler = tool.handler;
    const isTaskHandler = "createTask" in handler;
    if (isTaskHandler) {
      if (!extra.taskStore) {
        throw new Error("No task store provided.");
      }
      const taskExtra = { ...extra, taskStore: extra.taskStore };
      if (tool.inputSchema) {
        const typedHandler = handler;
        return await Promise.resolve(typedHandler.createTask(args, taskExtra));
      } else {
        const typedHandler = handler;
        return await Promise.resolve(typedHandler.createTask(taskExtra));
      }
    }
    if (tool.inputSchema) {
      const typedHandler = handler;
      return await Promise.resolve(typedHandler(args, extra));
    } else {
      const typedHandler = handler;
      return await Promise.resolve(typedHandler(extra));
    }
  }
  /**
   * Handles automatic task polling for tools with taskSupport 'optional'.
   */
  async handleAutomaticTaskPolling(tool, request, extra) {
    if (!extra.taskStore) {
      throw new Error("No task store provided for task-capable tool.");
    }
    const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
    const handler = tool.handler;
    const taskExtra = { ...extra, taskStore: extra.taskStore };
    const createTaskResult = args ? await Promise.resolve(handler.createTask(args, taskExtra)) : (
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      await Promise.resolve(handler.createTask(taskExtra))
    );
    const taskId = createTaskResult.task.taskId;
    let task = createTaskResult.task;
    const pollInterval = task.pollInterval ?? 5e3;
    while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
      await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
      const updatedTask = await extra.taskStore.getTask(taskId);
      if (!updatedTask) {
        throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
      }
      task = updatedTask;
    }
    return await extra.taskStore.getTaskResult(taskId);
  }
  setCompletionRequestHandler() {
    if (this._completionHandlerInitialized) {
      return;
    }
    this.server.assertCanSetRequestHandler(getMethodValue(CompleteRequestSchema));
    this.server.registerCapabilities({
      completions: {}
    });
    this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
      switch (request.params.ref.type) {
        case "ref/prompt":
          assertCompleteRequestPrompt(request);
          return this.handlePromptCompletion(request, request.params.ref);
        case "ref/resource":
          assertCompleteRequestResourceTemplate(request);
          return this.handleResourceCompletion(request, request.params.ref);
        default:
          throw new McpError(ErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
      }
    });
    this._completionHandlerInitialized = true;
  }
  async handlePromptCompletion(request, ref) {
    const prompt = this._registeredPrompts[ref.name];
    if (!prompt) {
      throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
    }
    if (!prompt.enabled) {
      throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
    }
    if (!prompt.argsSchema) {
      return EMPTY_COMPLETION_RESULT;
    }
    const promptShape = getObjectShape(prompt.argsSchema);
    const field = promptShape?.[request.params.argument.name];
    if (!isCompletable(field)) {
      return EMPTY_COMPLETION_RESULT;
    }
    const completer = getCompleter(field);
    if (!completer) {
      return EMPTY_COMPLETION_RESULT;
    }
    const suggestions = await completer(request.params.argument.value, request.params.context);
    return createCompletionResult(suggestions);
  }
  async handleResourceCompletion(request, ref) {
    const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
    if (!template) {
      if (this._registeredResources[ref.uri]) {
        return EMPTY_COMPLETION_RESULT;
      }
      throw new McpError(ErrorCode.InvalidParams, `Resource template ${request.params.ref.uri} not found`);
    }
    const completer = template.resourceTemplate.completeCallback(request.params.argument.name);
    if (!completer) {
      return EMPTY_COMPLETION_RESULT;
    }
    const suggestions = await completer(request.params.argument.value, request.params.context);
    return createCompletionResult(suggestions);
  }
  setResourceRequestHandlers() {
    if (this._resourceHandlersInitialized) {
      return;
    }
    this.server.assertCanSetRequestHandler(getMethodValue(ListResourcesRequestSchema));
    this.server.assertCanSetRequestHandler(getMethodValue(ListResourceTemplatesRequestSchema));
    this.server.assertCanSetRequestHandler(getMethodValue(ReadResourceRequestSchema));
    this.server.registerCapabilities({
      resources: {
        listChanged: true
      }
    });
    this.server.setRequestHandler(ListResourcesRequestSchema, async (request, extra) => {
      const resources = Object.entries(this._registeredResources).filter(([_, resource]) => resource.enabled).map(([uri, resource]) => ({
        uri,
        name: resource.name,
        ...resource.metadata
      }));
      const templateResources = [];
      for (const template of Object.values(this._registeredResourceTemplates)) {
        if (!template.resourceTemplate.listCallback) {
          continue;
        }
        const result = await template.resourceTemplate.listCallback(extra);
        for (const resource of result.resources) {
          templateResources.push({
            ...template.metadata,
            // the defined resource metadata should override the template metadata if present
            ...resource
          });
        }
      }
      return { resources: [...resources, ...templateResources] };
    });
    this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
      const resourceTemplates = Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
        name,
        uriTemplate: template.resourceTemplate.uriTemplate.toString(),
        ...template.metadata
      }));
      return { resourceTemplates };
    });
    this.server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => {
      const uri = new URL(request.params.uri);
      const resource = this._registeredResources[uri.toString()];
      if (resource) {
        if (!resource.enabled) {
          throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} disabled`);
        }
        return resource.readCallback(uri, extra);
      }
      for (const template of Object.values(this._registeredResourceTemplates)) {
        const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
        if (variables) {
          return template.readCallback(uri, variables, extra);
        }
      }
      throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} not found`);
    });
    this._resourceHandlersInitialized = true;
  }
  setPromptRequestHandlers() {
    if (this._promptHandlersInitialized) {
      return;
    }
    this.server.assertCanSetRequestHandler(getMethodValue(ListPromptsRequestSchema));
    this.server.assertCanSetRequestHandler(getMethodValue(GetPromptRequestSchema));
    this.server.registerCapabilities({
      prompts: {
        listChanged: true
      }
    });
    this.server.setRequestHandler(ListPromptsRequestSchema, () => ({
      prompts: Object.entries(this._registeredPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
        return {
          name,
          title: prompt.title,
          description: prompt.description,
          arguments: prompt.argsSchema ? promptArgumentsFromSchema(prompt.argsSchema) : void 0
        };
      })
    }));
    this.server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
      const prompt = this._registeredPrompts[request.params.name];
      if (!prompt) {
        throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
      }
      if (!prompt.enabled) {
        throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
      }
      if (prompt.argsSchema) {
        const argsObj = normalizeObjectSchema(prompt.argsSchema);
        const parseResult = await safeParseAsync3(argsObj, request.params.arguments);
        if (!parseResult.success) {
          const error3 = "error" in parseResult ? parseResult.error : "Unknown error";
          const errorMessage = getParseErrorMessage(error3);
          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
        }
        const args = parseResult.data;
        const cb = prompt.callback;
        return await Promise.resolve(cb(args, extra));
      } else {
        const cb = prompt.callback;
        return await Promise.resolve(cb(extra));
      }
    });
    this._promptHandlersInitialized = true;
  }
  resource(name, uriOrTemplate, ...rest) {
    let metadata;
    if (typeof rest[0] === "object") {
      metadata = rest.shift();
    }
    const readCallback = rest[0];
    if (typeof uriOrTemplate === "string") {
      if (this._registeredResources[uriOrTemplate]) {
        throw new Error(`Resource ${uriOrTemplate} is already registered`);
      }
      const registeredResource = this._createRegisteredResource(name, void 0, uriOrTemplate, metadata, readCallback);
      this.setResourceRequestHandlers();
      this.sendResourceListChanged();
      return registeredResource;
    } else {
      if (this._registeredResourceTemplates[name]) {
        throw new Error(`Resource template ${name} is already registered`);
      }
      const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, void 0, uriOrTemplate, metadata, readCallback);
      this.setResourceRequestHandlers();
      this.sendResourceListChanged();
      return registeredResourceTemplate;
    }
  }
  registerResource(name, uriOrTemplate, config2, readCallback) {
    if (typeof uriOrTemplate === "string") {
      if (this._registeredResources[uriOrTemplate]) {
        throw new Error(`Resource ${uriOrTemplate} is already registered`);
      }
      const registeredResource = this._createRegisteredResource(name, config2.title, uriOrTemplate, config2, readCallback);
      this.setResourceRequestHandlers();
      this.sendResourceListChanged();
      return registeredResource;
    } else {
      if (this._registeredResourceTemplates[name]) {
        throw new Error(`Resource template ${name} is already registered`);
      }
      const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config2.title, uriOrTemplate, config2, readCallback);
      this.setResourceRequestHandlers();
      this.sendResourceListChanged();
      return registeredResourceTemplate;
    }
  }
  _createRegisteredResource(name, title, uri, metadata, readCallback) {
    const registeredResource = {
      name,
      title,
      metadata,
      readCallback,
      enabled: true,
      disable: () => registeredResource.update({ enabled: false }),
      enable: () => registeredResource.update({ enabled: true }),
      remove: () => registeredResource.update({ uri: null }),
      update: (updates) => {
        if (typeof updates.uri !== "undefined" && updates.uri !== uri) {
          delete this._registeredResources[uri];
          if (updates.uri)
            this._registeredResources[updates.uri] = registeredResource;
        }
        if (typeof updates.name !== "undefined")
          registeredResource.name = updates.name;
        if (typeof updates.title !== "undefined")
          registeredResource.title = updates.title;
        if (typeof updates.metadata !== "undefined")
          registeredResource.metadata = updates.metadata;
        if (typeof updates.callback !== "undefined")
          registeredResource.readCallback = updates.callback;
        if (typeof updates.enabled !== "undefined")
          registeredResource.enabled = updates.enabled;
        this.sendResourceListChanged();
      }
    };
    this._registeredResources[uri] = registeredResource;
    return registeredResource;
  }
  _createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
    const registeredResourceTemplate = {
      resourceTemplate: template,
      title,
      metadata,
      readCallback,
      enabled: true,
      disable: () => registeredResourceTemplate.update({ enabled: false }),
      enable: () => registeredResourceTemplate.update({ enabled: true }),
      remove: () => registeredResourceTemplate.update({ name: null }),
      update: (updates) => {
        if (typeof updates.name !== "undefined" && updates.name !== name) {
          delete this._registeredResourceTemplates[name];
          if (updates.name)
            this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
        }
        if (typeof updates.title !== "undefined")
          registeredResourceTemplate.title = updates.title;
        if (typeof updates.template !== "undefined")
          registeredResourceTemplate.resourceTemplate = updates.template;
        if (typeof updates.metadata !== "undefined")
          registeredResourceTemplate.metadata = updates.metadata;
        if (typeof updates.callback !== "undefined")
          registeredResourceTemplate.readCallback = updates.callback;
        if (typeof updates.enabled !== "undefined")
          registeredResourceTemplate.enabled = updates.enabled;
        this.sendResourceListChanged();
      }
    };
    this._registeredResourceTemplates[name] = registeredResourceTemplate;
    const variableNames = template.uriTemplate.variableNames;
    const hasCompleter = Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v));
    if (hasCompleter) {
      this.setCompletionRequestHandler();
    }
    return registeredResourceTemplate;
  }
  _createRegisteredPrompt(name, title, description, argsSchema, callback) {
    const registeredPrompt = {
      title,
      description,
      argsSchema: argsSchema === void 0 ? void 0 : objectFromShape(argsSchema),
      callback,
      enabled: true,
      disable: () => registeredPrompt.update({ enabled: false }),
      enable: () => registeredPrompt.update({ enabled: true }),
      remove: () => registeredPrompt.update({ name: null }),
      update: (updates) => {
        if (typeof updates.name !== "undefined" && updates.name !== name) {
          delete this._registeredPrompts[name];
          if (updates.name)
            this._registeredPrompts[updates.name] = registeredPrompt;
        }
        if (typeof updates.title !== "undefined")
          registeredPrompt.title = updates.title;
        if (typeof updates.description !== "undefined")
          registeredPrompt.description = updates.description;
        if (typeof updates.argsSchema !== "undefined")
          registeredPrompt.argsSchema = objectFromShape(updates.argsSchema);
        if (typeof updates.callback !== "undefined")
          registeredPrompt.callback = updates.callback;
        if (typeof updates.enabled !== "undefined")
          registeredPrompt.enabled = updates.enabled;
        this.sendPromptListChanged();
      }
    };
    this._registeredPrompts[name] = registeredPrompt;
    if (argsSchema) {
      const hasCompletable = Object.values(argsSchema).some((field) => {
        const inner = field instanceof ZodOptional2 ? field._def?.innerType : field;
        return isCompletable(inner);
      });
      if (hasCompletable) {
        this.setCompletionRequestHandler();
      }
    }
    return registeredPrompt;
  }
  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
    validateAndWarnToolName(name);
    const registeredTool = {
      title,
      description,
      inputSchema: getZodSchemaObject(inputSchema),
      outputSchema: getZodSchemaObject(outputSchema),
      annotations,
      execution,
      _meta,
      handler,
      enabled: true,
      disable: () => registeredTool.update({ enabled: false }),
      enable: () => registeredTool.update({ enabled: true }),
      remove: () => registeredTool.update({ name: null }),
      update: (updates) => {
        if (typeof updates.name !== "undefined" && updates.name !== name) {
          if (typeof updates.name === "string") {
            validateAndWarnToolName(updates.name);
          }
          delete this._registeredTools[name];
          if (updates.name)
            this._registeredTools[updates.name] = registeredTool;
        }
        if (typeof updates.title !== "undefined")
          registeredTool.title = updates.title;
        if (typeof updates.description !== "undefined")
          registeredTool.description = updates.description;
        if (typeof updates.paramsSchema !== "undefined")
          registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
        if (typeof updates.outputSchema !== "undefined")
          registeredTool.outputSchema = objectFromShape(updates.outputSchema);
        if (typeof updates.callback !== "undefined")
          registeredTool.handler = updates.callback;
        if (typeof updates.annotations !== "undefined")
          registeredTool.annotations = updates.annotations;
        if (typeof updates._meta !== "undefined")
          registeredTool._meta = updates._meta;
        if (typeof updates.enabled !== "undefined")
          registeredTool.enabled = updates.enabled;
        this.sendToolListChanged();
      }
    };
    this._registeredTools[name] = registeredTool;
    this.setToolRequestHandlers();
    this.sendToolListChanged();
    return registeredTool;
  }
  /**
   * tool() implementation. Parses arguments passed to overrides defined above.
   */
  tool(name, ...rest) {
    if (this._registeredTools[name]) {
      throw new Error(`Tool ${name} is already registered`);
    }
    let description;
    let inputSchema;
    let outputSchema;
    let annotations;
    if (typeof rest[0] === "string") {
      description = rest.shift();
    }
    if (rest.length > 1) {
      const firstArg = rest[0];
      if (isZodRawShapeCompat(firstArg)) {
        inputSchema = rest.shift();
        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
          annotations = rest.shift();
        }
      } else if (typeof firstArg === "object" && firstArg !== null) {
        if (Object.values(firstArg).some((v) => typeof v === "object" && v !== null)) {
          throw new Error(`Tool ${name} expected a Zod schema or ToolAnnotations, but received an unrecognized object`);
        }
        annotations = rest.shift();
      }
    }
    const callback = rest[0];
    return this._createRegisteredTool(name, void 0, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
  }
  /**
   * Registers a tool with a config object and callback.
   */
  registerTool(name, config2, cb) {
    if (this._registeredTools[name]) {
      throw new Error(`Tool ${name} is already registered`);
    }
    const { title, description, inputSchema, outputSchema, annotations, _meta } = config2;
    return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
  }
  prompt(name, ...rest) {
    if (this._registeredPrompts[name]) {
      throw new Error(`Prompt ${name} is already registered`);
    }
    let description;
    if (typeof rest[0] === "string") {
      description = rest.shift();
    }
    let argsSchema;
    if (rest.length > 1) {
      argsSchema = rest.shift();
    }
    const cb = rest[0];
    const registeredPrompt = this._createRegisteredPrompt(name, void 0, description, argsSchema, cb);
    this.setPromptRequestHandlers();
    this.sendPromptListChanged();
    return registeredPrompt;
  }
  /**
   * Registers a prompt with a config object and callback.
   */
  registerPrompt(name, config2, cb) {
    if (this._registeredPrompts[name]) {
      throw new Error(`Prompt ${name} is already registered`);
    }
    const { title, description, argsSchema } = config2;
    const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb);
    this.setPromptRequestHandlers();
    this.sendPromptListChanged();
    return registeredPrompt;
  }
  /**
   * Checks if the server is connected to a transport.
   * @returns True if the server is connected
   */
  isConnected() {
    return this.server.transport !== void 0;
  }
  /**
   * Sends a logging message to the client, if connected.
   * Note: You only need to send the parameters object, not the entire JSON RPC message
   * @see LoggingMessageNotification
   * @param params
   * @param sessionId optional for stateless and backward compatibility
   */
  async sendLoggingMessage(params, sessionId) {
    return this.server.sendLoggingMessage(params, sessionId);
  }
  /**
   * Sends a resource list changed event to the client, if connected.
   */
  sendResourceListChanged() {
    if (this.isConnected()) {
      this.server.sendResourceListChanged();
    }
  }
  /**
   * Sends a tool list changed event to the client, if connected.
   */
  sendToolListChanged() {
    if (this.isConnected()) {
      this.server.sendToolListChanged();
    }
  }
  /**
   * Sends a prompt list changed event to the client, if connected.
   */
  sendPromptListChanged() {
    if (this.isConnected()) {
      this.server.sendPromptListChanged();
    }
  }
};
var EMPTY_OBJECT_JSON_SCHEMA = {
  type: "object",
  properties: {}
};
function isZodTypeLike(value) {
  return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
}
function isZodSchemaInstance(obj) {
  return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
}
function isZodRawShapeCompat(obj) {
  if (typeof obj !== "object" || obj === null) {
    return false;
  }
  if (isZodSchemaInstance(obj)) {
    return false;
  }
  if (Object.keys(obj).length === 0) {
    return true;
  }
  return Object.values(obj).some(isZodTypeLike);
}
function getZodSchemaObject(schema) {
  if (!schema) {
    return void 0;
  }
  if (isZodRawShapeCompat(schema)) {
    return objectFromShape(schema);
  }
  if (!isZodSchemaInstance(schema)) {
    throw new Error("inputSchema must be a Zod schema or raw shape, received an unrecognized object");
  }
  return schema;
}
function promptArgumentsFromSchema(schema) {
  const shape = getObjectShape(schema);
  if (!shape)
    return [];
  return Object.entries(shape).map(([name, field]) => {
    const description = getSchemaDescription(field);
    const isOptional = isSchemaOptional(field);
    return {
      name,
      description,
      required: !isOptional
    };
  });
}
function getMethodValue(schema) {
  const shape = getObjectShape(schema);
  const methodSchema = shape?.method;
  if (!methodSchema) {
    throw new Error("Schema is missing a method literal");
  }
  const value = getLiteralValue(methodSchema);
  if (typeof value === "string") {
    return value;
  }
  throw new Error("Schema method literal must be a string");
}
function createCompletionResult(suggestions) {
  return {
    completion: {
      values: suggestions.slice(0, 100),
      total: suggestions.length,
      hasMore: suggestions.length > 100
    }
  };
}
var EMPTY_COMPLETION_RESULT = {
  completion: {
    values: [],
    hasMore: false
  }
};

// packages/board-schema/node_modules/zod/lib/index.mjs
var util2;
(function(util4) {
  util4.assertEqual = (val) => val;
  function assertIs2(_arg) {
  }
  util4.assertIs = assertIs2;
  function assertNever2(_x) {
    throw new Error();
  }
  util4.assertNever = assertNever2;
  util4.arrayToEnum = (items) => {
    const obj = {};
    for (const item of items) {
      obj[item] = item;
    }
    return obj;
  };
  util4.getValidEnumValues = (obj) => {
    const validKeys = util4.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
    const filtered = {};
    for (const k of validKeys) {
      filtered[k] = obj[k];
    }
    return util4.objectValues(filtered);
  };
  util4.objectValues = (obj) => {
    return util4.objectKeys(obj).map(function(e) {
      return obj[e];
    });
  };
  util4.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
    const keys = [];
    for (const key in object3) {
      if (Object.prototype.hasOwnProperty.call(object3, key)) {
        keys.push(key);
      }
    }
    return keys;
  };
  util4.find = (arr, checker) => {
    for (const item of arr) {
      if (checker(item))
        return item;
    }
    return void 0;
  };
  util4.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
  function joinValues2(array2, separator = " | ") {
    return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
  }
  util4.joinValues = joinValues2;
  util4.jsonStringifyReplacer = (_, value) => {
    if (typeof value === "bigint") {
      return value.toString();
    }
    return value;
  };
})(util2 || (util2 = {}));
var objectUtil2;
(function(objectUtil4) {
  objectUtil4.mergeShapes = (first, second) => {
    return {
      ...first,
      ...second
      // second overwrites first
    };
  };
})(objectUtil2 || (objectUtil2 = {}));
var ZodParsedType2 = util2.arrayToEnum([
  "string",
  "nan",
  "number",
  "integer",
  "float",
  "boolean",
  "date",
  "bigint",
  "symbol",
  "function",
  "undefined",
  "null",
  "array",
  "object",
  "unknown",
  "promise",
  "void",
  "never",
  "map",
  "set"
]);
var getParsedType3 = (data) => {
  const t = typeof data;
  switch (t) {
    case "undefined":
      return ZodParsedType2.undefined;
    case "string":
      return ZodParsedType2.string;
    case "number":
      return isNaN(data) ? ZodParsedType2.nan : ZodParsedType2.number;
    case "boolean":
      return ZodParsedType2.boolean;
    case "function":
      return ZodParsedType2.function;
    case "bigint":
      return ZodParsedType2.bigint;
    case "symbol":
      return ZodParsedType2.symbol;
    case "object":
      if (Array.isArray(data)) {
        return ZodParsedType2.array;
      }
      if (data === null) {
        return ZodParsedType2.null;
      }
      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
        return ZodParsedType2.promise;
      }
      if (typeof Map !== "undefined" && data instanceof Map) {
        return ZodParsedType2.map;
      }
      if (typeof Set !== "undefined" && data instanceof Set) {
        return ZodParsedType2.set;
      }
      if (typeof Date !== "undefined" && data instanceof Date) {
        return ZodParsedType2.date;
      }
      return ZodParsedType2.object;
    default:
      return ZodParsedType2.unknown;
  }
};
var ZodIssueCode2 = util2.arrayToEnum([
  "invalid_type",
  "invalid_literal",
  "custom",
  "invalid_union",
  "invalid_union_discriminator",
  "invalid_enum_value",
  "unrecognized_keys",
  "invalid_arguments",
  "invalid_return_type",
  "invalid_date",
  "invalid_string",
  "too_small",
  "too_big",
  "invalid_intersection_types",
  "not_multiple_of",
  "not_finite"
]);
var quotelessJson = (obj) => {
  const json = JSON.stringify(obj, null, 2);
  return json.replace(/"([^"]+)":/g, "$1:");
};
var ZodError3 = class _ZodError extends Error {
  constructor(issues) {
    super();
    this.issues = [];
    this.addIssue = (sub) => {
      this.issues = [...this.issues, sub];
    };
    this.addIssues = (subs = []) => {
      this.issues = [...this.issues, ...subs];
    };
    const actualProto = new.target.prototype;
    if (Object.setPrototypeOf) {
      Object.setPrototypeOf(this, actualProto);
    } else {
      this.__proto__ = actualProto;
    }
    this.name = "ZodError";
    this.issues = issues;
  }
  get errors() {
    return this.issues;
  }
  format(_mapper) {
    const mapper = _mapper || function(issue2) {
      return issue2.message;
    };
    const fieldErrors = { _errors: [] };
    const processError = (error3) => {
      for (const issue2 of error3.issues) {
        if (issue2.code === "invalid_union") {
          issue2.unionErrors.map(processError);
        } else if (issue2.code === "invalid_return_type") {
          processError(issue2.returnTypeError);
        } else if (issue2.code === "invalid_arguments") {
          processError(issue2.argumentsError);
        } else if (issue2.path.length === 0) {
          fieldErrors._errors.push(mapper(issue2));
        } else {
          let curr = fieldErrors;
          let i = 0;
          while (i < issue2.path.length) {
            const el = issue2.path[i];
            const terminal = i === issue2.path.length - 1;
            if (!terminal) {
              curr[el] = curr[el] || { _errors: [] };
            } else {
              curr[el] = curr[el] || { _errors: [] };
              curr[el]._errors.push(mapper(issue2));
            }
            curr = curr[el];
            i++;
          }
        }
      }
    };
    processError(this);
    return fieldErrors;
  }
  static assert(value) {
    if (!(value instanceof _ZodError)) {
      throw new Error(`Not a ZodError: ${value}`);
    }
  }
  toString() {
    return this.message;
  }
  get message() {
    return JSON.stringify(this.issues, util2.jsonStringifyReplacer, 2);
  }
  get isEmpty() {
    return this.issues.length === 0;
  }
  flatten(mapper = (issue2) => issue2.message) {
    const fieldErrors = {};
    const formErrors = [];
    for (const sub of this.issues) {
      if (sub.path.length > 0) {
        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
        fieldErrors[sub.path[0]].push(mapper(sub));
      } else {
        formErrors.push(mapper(sub));
      }
    }
    return { formErrors, fieldErrors };
  }
  get formErrors() {
    return this.flatten();
  }
};
ZodError3.create = (issues) => {
  const error3 = new ZodError3(issues);
  return error3;
};
var errorMap2 = (issue2, _ctx) => {
  let message;
  switch (issue2.code) {
    case ZodIssueCode2.invalid_type:
      if (issue2.received === ZodParsedType2.undefined) {
        message = "Required";
      } else {
        message = `Expected ${issue2.expected}, received ${issue2.received}`;
      }
      break;
    case ZodIssueCode2.invalid_literal:
      message = `Invalid literal value, expected ${JSON.stringify(issue2.expected, util2.jsonStringifyReplacer)}`;
      break;
    case ZodIssueCode2.unrecognized_keys:
      message = `Unrecognized key(s) in object: ${util2.joinValues(issue2.keys, ", ")}`;
      break;
    case ZodIssueCode2.invalid_union:
      message = `Invalid input`;
      break;
    case ZodIssueCode2.invalid_union_discriminator:
      message = `Invalid discriminator value. Expected ${util2.joinValues(issue2.options)}`;
      break;
    case ZodIssueCode2.invalid_enum_value:
      message = `Invalid enum value. Expected ${util2.joinValues(issue2.options)}, received '${issue2.received}'`;
      break;
    case ZodIssueCode2.invalid_arguments:
      message = `Invalid function arguments`;
      break;
    case ZodIssueCode2.invalid_return_type:
      message = `Invalid function return type`;
      break;
    case ZodIssueCode2.invalid_date:
      message = `Invalid date`;
      break;
    case ZodIssueCode2.invalid_string:
      if (typeof issue2.validation === "object") {
        if ("includes" in issue2.validation) {
          message = `Invalid input: must include "${issue2.validation.includes}"`;
          if (typeof issue2.validation.position === "number") {
            message = `${message} at one or more positions greater than or equal to ${issue2.validation.position}`;
          }
        } else if ("startsWith" in issue2.validation) {
          message = `Invalid input: must start with "${issue2.validation.startsWith}"`;
        } else if ("endsWith" in issue2.validation) {
          message = `Invalid input: must end with "${issue2.validation.endsWith}"`;
        } else {
          util2.assertNever(issue2.validation);
        }
      } else if (issue2.validation !== "regex") {
        message = `Invalid ${issue2.validation}`;
      } else {
        message = "Invalid";
      }
      break;
    case ZodIssueCode2.too_small:
      if (issue2.type === "array")
        message = `Array must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `more than`} ${issue2.minimum} element(s)`;
      else if (issue2.type === "string")
        message = `String must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `over`} ${issue2.minimum} character(s)`;
      else if (issue2.type === "number")
        message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`;
      else if (issue2.type === "date")
        message = `Date must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue2.minimum))}`;
      else
        message = "Invalid input";
      break;
    case ZodIssueCode2.too_big:
      if (issue2.type === "array")
        message = `Array must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `less than`} ${issue2.maximum} element(s)`;
      else if (issue2.type === "string")
        message = `String must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `under`} ${issue2.maximum} character(s)`;
      else if (issue2.type === "number")
        message = `Number must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`;
      else if (issue2.type === "bigint")
        message = `BigInt must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`;
      else if (issue2.type === "date")
        message = `Date must be ${issue2.exact ? `exactly` : issue2.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue2.maximum))}`;
      else
        message = "Invalid input";
      break;
    case ZodIssueCode2.custom:
      message = `Invalid input`;
      break;
    case ZodIssueCode2.invalid_intersection_types:
      message = `Intersection results could not be merged`;
      break;
    case ZodIssueCode2.not_multiple_of:
      message = `Number must be a multiple of ${issue2.multipleOf}`;
      break;
    case ZodIssueCode2.not_finite:
      message = "Number must be finite";
      break;
    default:
      message = _ctx.defaultError;
      util2.assertNever(issue2);
  }
  return { message };
};
var overrideErrorMap2 = errorMap2;
function setErrorMap(map) {
  overrideErrorMap2 = map;
}
function getErrorMap2() {
  return overrideErrorMap2;
}
var makeIssue2 = (params) => {
  const { data, path, errorMaps, issueData } = params;
  const fullPath = [...path, ...issueData.path || []];
  const fullIssue = {
    ...issueData,
    path: fullPath
  };
  if (issueData.message !== void 0) {
    return {
      ...issueData,
      path: fullPath,
      message: issueData.message
    };
  }
  let errorMessage = "";
  const maps = errorMaps.filter((m) => !!m).slice().reverse();
  for (const map of maps) {
    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
  }
  return {
    ...issueData,
    path: fullPath,
    message: errorMessage
  };
};
var EMPTY_PATH = [];
function addIssueToContext2(ctx, issueData) {
  const overrideMap = getErrorMap2();
  const issue2 = makeIssue2({
    issueData,
    data: ctx.data,
    path: ctx.path,
    errorMaps: [
      ctx.common.contextualErrorMap,
      ctx.schemaErrorMap,
      overrideMap,
      overrideMap === errorMap2 ? void 0 : errorMap2
      // then global default map
    ].filter((x) => !!x)
  });
  ctx.common.issues.push(issue2);
}
var ParseStatus2 = class _ParseStatus {
  constructor() {
    this.value = "valid";
  }
  dirty() {
    if (this.value === "valid")
      this.value = "dirty";
  }
  abort() {
    if (this.value !== "aborted")
      this.value = "aborted";
  }
  static mergeArray(status, results2) {
    const arrayValue = [];
    for (const s of results2) {
      if (s.status === "aborted")
        return INVALID2;
      if (s.status === "dirty")
        status.dirty();
      arrayValue.push(s.value);
    }
    return { status: status.value, value: arrayValue };
  }
  static async mergeObjectAsync(status, pairs) {
    const syncPairs = [];
    for (const pair of pairs) {
      const key = await pair.key;
      const value = await pair.value;
      syncPairs.push({
        key,
        value
      });
    }
    return _ParseStatus.mergeObjectSync(status, syncPairs);
  }
  static mergeObjectSync(status, pairs) {
    const finalObject = {};
    for (const pair of pairs) {
      const { key, value } = pair;
      if (key.status === "aborted")
        return INVALID2;
      if (value.status === "aborted")
        return INVALID2;
      if (key.status === "dirty")
        status.dirty();
      if (value.status === "dirty")
        status.dirty();
      if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
        finalObject[key.value] = value.value;
      }
    }
    return { status: status.value, value: finalObject };
  }
};
var INVALID2 = Object.freeze({
  status: "aborted"
});
var DIRTY2 = (value) => ({ status: "dirty", value });
var OK2 = (value) => ({ status: "valid", value });
var isAborted2 = (x) => x.status === "aborted";
var isDirty2 = (x) => x.status === "dirty";
var isValid2 = (x) => x.status === "valid";
var isAsync2 = (x) => typeof Promise !== "undefined" && x instanceof Promise;
function __classPrivateFieldGet(receiver, state, kind, f) {
  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
  if (kind === "m") throw new TypeError("Private method is not writable");
  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
}
var errorUtil2;
(function(errorUtil4) {
  errorUtil4.errToObj = (message) => typeof message === "string" ? { message } : message || {};
  errorUtil4.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
})(errorUtil2 || (errorUtil2 = {}));
var _ZodEnum_cache;
var _ZodNativeEnum_cache;
var ParseInputLazyPath2 = class {
  constructor(parent, value, path, key) {
    this._cachedPath = [];
    this.parent = parent;
    this.data = value;
    this._path = path;
    this._key = key;
  }
  get path() {
    if (!this._cachedPath.length) {
      if (this._key instanceof Array) {
        this._cachedPath.push(...this._path, ...this._key);
      } else {
        this._cachedPath.push(...this._path, this._key);
      }
    }
    return this._cachedPath;
  }
};
var handleResult2 = (ctx, result) => {
  if (isValid2(result)) {
    return { success: true, data: result.value };
  } else {
    if (!ctx.common.issues.length) {
      throw new Error("Validation failed but no issues detected.");
    }
    return {
      success: false,
      get error() {
        if (this._error)
          return this._error;
        const error3 = new ZodError3(ctx.common.issues);
        this._error = error3;
        return this._error;
      }
    };
  }
};
function processCreateParams2(params) {
  if (!params)
    return {};
  const { errorMap: errorMap4, invalid_type_error, required_error, description } = params;
  if (errorMap4 && (invalid_type_error || required_error)) {
    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
  }
  if (errorMap4)
    return { errorMap: errorMap4, description };
  const customMap = (iss, ctx) => {
    var _a, _b;
    const { message } = params;
    if (iss.code === "invalid_enum_value") {
      return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
    }
    if (typeof ctx.data === "undefined") {
      return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
    }
    if (iss.code !== "invalid_type")
      return { message: ctx.defaultError };
    return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
  };
  return { errorMap: customMap, description };
}
var ZodType3 = class {
  constructor(def) {
    this.spa = this.safeParseAsync;
    this._def = def;
    this.parse = this.parse.bind(this);
    this.safeParse = this.safeParse.bind(this);
    this.parseAsync = this.parseAsync.bind(this);
    this.safeParseAsync = this.safeParseAsync.bind(this);
    this.spa = this.spa.bind(this);
    this.refine = this.refine.bind(this);
    this.refinement = this.refinement.bind(this);
    this.superRefine = this.superRefine.bind(this);
    this.optional = this.optional.bind(this);
    this.nullable = this.nullable.bind(this);
    this.nullish = this.nullish.bind(this);
    this.array = this.array.bind(this);
    this.promise = this.promise.bind(this);
    this.or = this.or.bind(this);
    this.and = this.and.bind(this);
    this.transform = this.transform.bind(this);
    this.brand = this.brand.bind(this);
    this.default = this.default.bind(this);
    this.catch = this.catch.bind(this);
    this.describe = this.describe.bind(this);
    this.pipe = this.pipe.bind(this);
    this.readonly = this.readonly.bind(this);
    this.isNullable = this.isNullable.bind(this);
    this.isOptional = this.isOptional.bind(this);
  }
  get description() {
    return this._def.description;
  }
  _getType(input) {
    return getParsedType3(input.data);
  }
  _getOrReturnCtx(input, ctx) {
    return ctx || {
      common: input.parent.common,
      data: input.data,
      parsedType: getParsedType3(input.data),
      schemaErrorMap: this._def.errorMap,
      path: input.path,
      parent: input.parent
    };
  }
  _processInputParams(input) {
    return {
      status: new ParseStatus2(),
      ctx: {
        common: input.parent.common,
        data: input.data,
        parsedType: getParsedType3(input.data),
        schemaErrorMap: this._def.errorMap,
        path: input.path,
        parent: input.parent
      }
    };
  }
  _parseSync(input) {
    const result = this._parse(input);
    if (isAsync2(result)) {
      throw new Error("Synchronous parse encountered promise.");
    }
    return result;
  }
  _parseAsync(input) {
    const result = this._parse(input);
    return Promise.resolve(result);
  }
  parse(data, params) {
    const result = this.safeParse(data, params);
    if (result.success)
      return result.data;
    throw result.error;
  }
  safeParse(data, params) {
    var _a;
    const ctx = {
      common: {
        issues: [],
        async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
      },
      path: (params === null || params === void 0 ? void 0 : params.path) || [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType3(data)
    };
    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
    return handleResult2(ctx, result);
  }
  async parseAsync(data, params) {
    const result = await this.safeParseAsync(data, params);
    if (result.success)
      return result.data;
    throw result.error;
  }
  async safeParseAsync(data, params) {
    const ctx = {
      common: {
        issues: [],
        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
        async: true
      },
      path: (params === null || params === void 0 ? void 0 : params.path) || [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType3(data)
    };
    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
    const result = await (isAsync2(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
    return handleResult2(ctx, result);
  }
  refine(check2, message) {
    const getIssueProperties = (val) => {
      if (typeof message === "string" || typeof message === "undefined") {
        return { message };
      } else if (typeof message === "function") {
        return message(val);
      } else {
        return message;
      }
    };
    return this._refinement((val, ctx) => {
      const result = check2(val);
      const setError = () => ctx.addIssue({
        code: ZodIssueCode2.custom,
        ...getIssueProperties(val)
      });
      if (typeof Promise !== "undefined" && result instanceof Promise) {
        return result.then((data) => {
          if (!data) {
            setError();
            return false;
          } else {
            return true;
          }
        });
      }
      if (!result) {
        setError();
        return false;
      } else {
        return true;
      }
    });
  }
  refinement(check2, refinementData) {
    return this._refinement((val, ctx) => {
      if (!check2(val)) {
        ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
        return false;
      } else {
        return true;
      }
    });
  }
  _refinement(refinement) {
    return new ZodEffects2({
      schema: this,
      typeName: ZodFirstPartyTypeKind2.ZodEffects,
      effect: { type: "refinement", refinement }
    });
  }
  superRefine(refinement) {
    return this._refinement(refinement);
  }
  optional() {
    return ZodOptional3.create(this, this._def);
  }
  nullable() {
    return ZodNullable3.create(this, this._def);
  }
  nullish() {
    return this.nullable().optional();
  }
  array() {
    return ZodArray3.create(this, this._def);
  }
  promise() {
    return ZodPromise2.create(this, this._def);
  }
  or(option) {
    return ZodUnion3.create([this, option], this._def);
  }
  and(incoming) {
    return ZodIntersection3.create(this, incoming, this._def);
  }
  transform(transform2) {
    return new ZodEffects2({
      ...processCreateParams2(this._def),
      schema: this,
      typeName: ZodFirstPartyTypeKind2.ZodEffects,
      effect: { type: "transform", transform: transform2 }
    });
  }
  default(def) {
    const defaultValueFunc = typeof def === "function" ? def : () => def;
    return new ZodDefault3({
      ...processCreateParams2(this._def),
      innerType: this,
      defaultValue: defaultValueFunc,
      typeName: ZodFirstPartyTypeKind2.ZodDefault
    });
  }
  brand() {
    return new ZodBranded2({
      typeName: ZodFirstPartyTypeKind2.ZodBranded,
      type: this,
      ...processCreateParams2(this._def)
    });
  }
  catch(def) {
    const catchValueFunc = typeof def === "function" ? def : () => def;
    return new ZodCatch3({
      ...processCreateParams2(this._def),
      innerType: this,
      catchValue: catchValueFunc,
      typeName: ZodFirstPartyTypeKind2.ZodCatch
    });
  }
  describe(description) {
    const This = this.constructor;
    return new This({
      ...this._def,
      description
    });
  }
  pipe(target) {
    return ZodPipeline2.create(this, target);
  }
  readonly() {
    return ZodReadonly3.create(this);
  }
  isOptional() {
    return this.safeParse(void 0).success;
  }
  isNullable() {
    return this.safeParse(null).success;
  }
};
var cuidRegex2 = /^c[^\s-]{8,}$/i;
var cuid2Regex2 = /^[0-9a-z]+$/;
var ulidRegex2 = /^[0-9A-HJKMNP-TV-Z]{26}$/;
var uuidRegex2 = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
var nanoidRegex2 = /^[a-z0-9_-]{21}$/i;
var durationRegex2 = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
var emailRegex2 = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
var _emojiRegex2 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
var emojiRegex3;
var ipv4Regex2 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv6Regex2 = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;
var base64Regex2 = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
var dateRegexSource2 = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
var dateRegex2 = new RegExp(`^${dateRegexSource2}$`);
function timeRegexSource2(args) {
  let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
  if (args.precision) {
    regex = `${regex}\\.\\d{${args.precision}}`;
  } else if (args.precision == null) {
    regex = `${regex}(\\.\\d+)?`;
  }
  return regex;
}
function timeRegex2(args) {
  return new RegExp(`^${timeRegexSource2(args)}$`);
}
function datetimeRegex2(args) {
  let regex = `${dateRegexSource2}T${timeRegexSource2(args)}`;
  const opts = [];
  opts.push(args.local ? `Z?` : `Z`);
  if (args.offset)
    opts.push(`([+-]\\d{2}:?\\d{2})`);
  regex = `${regex}(${opts.join("|")})`;
  return new RegExp(`^${regex}$`);
}
function isValidIP2(ip, version2) {
  if ((version2 === "v4" || !version2) && ipv4Regex2.test(ip)) {
    return true;
  }
  if ((version2 === "v6" || !version2) && ipv6Regex2.test(ip)) {
    return true;
  }
  return false;
}
var ZodString3 = class _ZodString2 extends ZodType3 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = String(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.string) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext2(ctx2, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.string,
        received: ctx2.parsedType
      });
      return INVALID2;
    }
    const status = new ParseStatus2();
    let ctx = void 0;
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        if (input.data.length < check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_small,
            minimum: check2.value,
            type: "string",
            inclusive: true,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        if (input.data.length > check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_big,
            maximum: check2.value,
            type: "string",
            inclusive: true,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "length") {
        const tooBig = input.data.length > check2.value;
        const tooSmall = input.data.length < check2.value;
        if (tooBig || tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          if (tooBig) {
            addIssueToContext2(ctx, {
              code: ZodIssueCode2.too_big,
              maximum: check2.value,
              type: "string",
              inclusive: true,
              exact: true,
              message: check2.message
            });
          } else if (tooSmall) {
            addIssueToContext2(ctx, {
              code: ZodIssueCode2.too_small,
              minimum: check2.value,
              type: "string",
              inclusive: true,
              exact: true,
              message: check2.message
            });
          }
          status.dirty();
        }
      } else if (check2.kind === "email") {
        if (!emailRegex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "email",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "emoji") {
        if (!emojiRegex3) {
          emojiRegex3 = new RegExp(_emojiRegex2, "u");
        }
        if (!emojiRegex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "emoji",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "uuid") {
        if (!uuidRegex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "uuid",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "nanoid") {
        if (!nanoidRegex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "nanoid",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cuid") {
        if (!cuidRegex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "cuid",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cuid2") {
        if (!cuid2Regex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "cuid2",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "ulid") {
        if (!ulidRegex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "ulid",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "url") {
        try {
          new URL(input.data);
        } catch (_a) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "url",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "regex") {
        check2.regex.lastIndex = 0;
        const testResult = check2.regex.test(input.data);
        if (!testResult) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "regex",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "trim") {
        input.data = input.data.trim();
      } else if (check2.kind === "includes") {
        if (!input.data.includes(check2.value, check2.position)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.invalid_string,
            validation: { includes: check2.value, position: check2.position },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "toLowerCase") {
        input.data = input.data.toLowerCase();
      } else if (check2.kind === "toUpperCase") {
        input.data = input.data.toUpperCase();
      } else if (check2.kind === "startsWith") {
        if (!input.data.startsWith(check2.value)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.invalid_string,
            validation: { startsWith: check2.value },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "endsWith") {
        if (!input.data.endsWith(check2.value)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.invalid_string,
            validation: { endsWith: check2.value },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "datetime") {
        const regex = datetimeRegex2(check2);
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.invalid_string,
            validation: "datetime",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "date") {
        const regex = dateRegex2;
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.invalid_string,
            validation: "date",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "time") {
        const regex = timeRegex2(check2);
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.invalid_string,
            validation: "time",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "duration") {
        if (!durationRegex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "duration",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "ip") {
        if (!isValidIP2(input.data, check2.version)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "ip",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "base64") {
        if (!base64Regex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            validation: "base64",
            code: ZodIssueCode2.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util2.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  _regex(regex, validation, message) {
    return this.refinement((data) => regex.test(data), {
      validation,
      code: ZodIssueCode2.invalid_string,
      ...errorUtil2.errToObj(message)
    });
  }
  _addCheck(check2) {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  email(message) {
    return this._addCheck({ kind: "email", ...errorUtil2.errToObj(message) });
  }
  url(message) {
    return this._addCheck({ kind: "url", ...errorUtil2.errToObj(message) });
  }
  emoji(message) {
    return this._addCheck({ kind: "emoji", ...errorUtil2.errToObj(message) });
  }
  uuid(message) {
    return this._addCheck({ kind: "uuid", ...errorUtil2.errToObj(message) });
  }
  nanoid(message) {
    return this._addCheck({ kind: "nanoid", ...errorUtil2.errToObj(message) });
  }
  cuid(message) {
    return this._addCheck({ kind: "cuid", ...errorUtil2.errToObj(message) });
  }
  cuid2(message) {
    return this._addCheck({ kind: "cuid2", ...errorUtil2.errToObj(message) });
  }
  ulid(message) {
    return this._addCheck({ kind: "ulid", ...errorUtil2.errToObj(message) });
  }
  base64(message) {
    return this._addCheck({ kind: "base64", ...errorUtil2.errToObj(message) });
  }
  ip(options) {
    return this._addCheck({ kind: "ip", ...errorUtil2.errToObj(options) });
  }
  datetime(options) {
    var _a, _b;
    if (typeof options === "string") {
      return this._addCheck({
        kind: "datetime",
        precision: null,
        offset: false,
        local: false,
        message: options
      });
    }
    return this._addCheck({
      kind: "datetime",
      precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
      offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
      local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false,
      ...errorUtil2.errToObj(options === null || options === void 0 ? void 0 : options.message)
    });
  }
  date(message) {
    return this._addCheck({ kind: "date", message });
  }
  time(options) {
    if (typeof options === "string") {
      return this._addCheck({
        kind: "time",
        precision: null,
        message: options
      });
    }
    return this._addCheck({
      kind: "time",
      precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
      ...errorUtil2.errToObj(options === null || options === void 0 ? void 0 : options.message)
    });
  }
  duration(message) {
    return this._addCheck({ kind: "duration", ...errorUtil2.errToObj(message) });
  }
  regex(regex, message) {
    return this._addCheck({
      kind: "regex",
      regex,
      ...errorUtil2.errToObj(message)
    });
  }
  includes(value, options) {
    return this._addCheck({
      kind: "includes",
      value,
      position: options === null || options === void 0 ? void 0 : options.position,
      ...errorUtil2.errToObj(options === null || options === void 0 ? void 0 : options.message)
    });
  }
  startsWith(value, message) {
    return this._addCheck({
      kind: "startsWith",
      value,
      ...errorUtil2.errToObj(message)
    });
  }
  endsWith(value, message) {
    return this._addCheck({
      kind: "endsWith",
      value,
      ...errorUtil2.errToObj(message)
    });
  }
  min(minLength, message) {
    return this._addCheck({
      kind: "min",
      value: minLength,
      ...errorUtil2.errToObj(message)
    });
  }
  max(maxLength, message) {
    return this._addCheck({
      kind: "max",
      value: maxLength,
      ...errorUtil2.errToObj(message)
    });
  }
  length(len, message) {
    return this._addCheck({
      kind: "length",
      value: len,
      ...errorUtil2.errToObj(message)
    });
  }
  /**
   * @deprecated Use z.string().min(1) instead.
   * @see {@link ZodString.min}
   */
  nonempty(message) {
    return this.min(1, errorUtil2.errToObj(message));
  }
  trim() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "trim" }]
    });
  }
  toLowerCase() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "toLowerCase" }]
    });
  }
  toUpperCase() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "toUpperCase" }]
    });
  }
  get isDatetime() {
    return !!this._def.checks.find((ch) => ch.kind === "datetime");
  }
  get isDate() {
    return !!this._def.checks.find((ch) => ch.kind === "date");
  }
  get isTime() {
    return !!this._def.checks.find((ch) => ch.kind === "time");
  }
  get isDuration() {
    return !!this._def.checks.find((ch) => ch.kind === "duration");
  }
  get isEmail() {
    return !!this._def.checks.find((ch) => ch.kind === "email");
  }
  get isURL() {
    return !!this._def.checks.find((ch) => ch.kind === "url");
  }
  get isEmoji() {
    return !!this._def.checks.find((ch) => ch.kind === "emoji");
  }
  get isUUID() {
    return !!this._def.checks.find((ch) => ch.kind === "uuid");
  }
  get isNANOID() {
    return !!this._def.checks.find((ch) => ch.kind === "nanoid");
  }
  get isCUID() {
    return !!this._def.checks.find((ch) => ch.kind === "cuid");
  }
  get isCUID2() {
    return !!this._def.checks.find((ch) => ch.kind === "cuid2");
  }
  get isULID() {
    return !!this._def.checks.find((ch) => ch.kind === "ulid");
  }
  get isIP() {
    return !!this._def.checks.find((ch) => ch.kind === "ip");
  }
  get isBase64() {
    return !!this._def.checks.find((ch) => ch.kind === "base64");
  }
  get minLength() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxLength() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
};
ZodString3.create = (params) => {
  var _a;
  return new ZodString3({
    checks: [],
    typeName: ZodFirstPartyTypeKind2.ZodString,
    coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
    ...processCreateParams2(params)
  });
};
function floatSafeRemainder3(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepDecCount = (step.toString().split(".")[1] || "").length;
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / Math.pow(10, decCount);
}
var ZodNumber3 = class _ZodNumber extends ZodType3 {
  constructor() {
    super(...arguments);
    this.min = this.gte;
    this.max = this.lte;
    this.step = this.multipleOf;
  }
  _parse(input) {
    if (this._def.coerce) {
      input.data = Number(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.number) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext2(ctx2, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.number,
        received: ctx2.parsedType
      });
      return INVALID2;
    }
    let ctx = void 0;
    const status = new ParseStatus2();
    for (const check2 of this._def.checks) {
      if (check2.kind === "int") {
        if (!util2.isInteger(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: "integer",
            received: "float",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "min") {
        const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
        if (tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_small,
            minimum: check2.value,
            type: "number",
            inclusive: check2.inclusive,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
        if (tooBig) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_big,
            maximum: check2.value,
            type: "number",
            inclusive: check2.inclusive,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "multipleOf") {
        if (floatSafeRemainder3(input.data, check2.value) !== 0) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.not_multiple_of,
            multipleOf: check2.value,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "finite") {
        if (!Number.isFinite(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.not_finite,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util2.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  gte(value, message) {
    return this.setLimit("min", value, true, errorUtil2.toString(message));
  }
  gt(value, message) {
    return this.setLimit("min", value, false, errorUtil2.toString(message));
  }
  lte(value, message) {
    return this.setLimit("max", value, true, errorUtil2.toString(message));
  }
  lt(value, message) {
    return this.setLimit("max", value, false, errorUtil2.toString(message));
  }
  setLimit(kind, value, inclusive, message) {
    return new _ZodNumber({
      ...this._def,
      checks: [
        ...this._def.checks,
        {
          kind,
          value,
          inclusive,
          message: errorUtil2.toString(message)
        }
      ]
    });
  }
  _addCheck(check2) {
    return new _ZodNumber({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  int(message) {
    return this._addCheck({
      kind: "int",
      message: errorUtil2.toString(message)
    });
  }
  positive(message) {
    return this._addCheck({
      kind: "min",
      value: 0,
      inclusive: false,
      message: errorUtil2.toString(message)
    });
  }
  negative(message) {
    return this._addCheck({
      kind: "max",
      value: 0,
      inclusive: false,
      message: errorUtil2.toString(message)
    });
  }
  nonpositive(message) {
    return this._addCheck({
      kind: "max",
      value: 0,
      inclusive: true,
      message: errorUtil2.toString(message)
    });
  }
  nonnegative(message) {
    return this._addCheck({
      kind: "min",
      value: 0,
      inclusive: true,
      message: errorUtil2.toString(message)
    });
  }
  multipleOf(value, message) {
    return this._addCheck({
      kind: "multipleOf",
      value,
      message: errorUtil2.toString(message)
    });
  }
  finite(message) {
    return this._addCheck({
      kind: "finite",
      message: errorUtil2.toString(message)
    });
  }
  safe(message) {
    return this._addCheck({
      kind: "min",
      inclusive: true,
      value: Number.MIN_SAFE_INTEGER,
      message: errorUtil2.toString(message)
    })._addCheck({
      kind: "max",
      inclusive: true,
      value: Number.MAX_SAFE_INTEGER,
      message: errorUtil2.toString(message)
    });
  }
  get minValue() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxValue() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
  get isInt() {
    return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util2.isInteger(ch.value));
  }
  get isFinite() {
    let max = null, min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
        return true;
      } else if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      } else if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return Number.isFinite(min) && Number.isFinite(max);
  }
};
ZodNumber3.create = (params) => {
  return new ZodNumber3({
    checks: [],
    typeName: ZodFirstPartyTypeKind2.ZodNumber,
    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
    ...processCreateParams2(params)
  });
};
var ZodBigInt2 = class _ZodBigInt extends ZodType3 {
  constructor() {
    super(...arguments);
    this.min = this.gte;
    this.max = this.lte;
  }
  _parse(input) {
    if (this._def.coerce) {
      input.data = BigInt(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.bigint) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext2(ctx2, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.bigint,
        received: ctx2.parsedType
      });
      return INVALID2;
    }
    let ctx = void 0;
    const status = new ParseStatus2();
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
        if (tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_small,
            type: "bigint",
            minimum: check2.value,
            inclusive: check2.inclusive,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
        if (tooBig) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_big,
            type: "bigint",
            maximum: check2.value,
            inclusive: check2.inclusive,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "multipleOf") {
        if (input.data % check2.value !== BigInt(0)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.not_multiple_of,
            multipleOf: check2.value,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util2.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  gte(value, message) {
    return this.setLimit("min", value, true, errorUtil2.toString(message));
  }
  gt(value, message) {
    return this.setLimit("min", value, false, errorUtil2.toString(message));
  }
  lte(value, message) {
    return this.setLimit("max", value, true, errorUtil2.toString(message));
  }
  lt(value, message) {
    return this.setLimit("max", value, false, errorUtil2.toString(message));
  }
  setLimit(kind, value, inclusive, message) {
    return new _ZodBigInt({
      ...this._def,
      checks: [
        ...this._def.checks,
        {
          kind,
          value,
          inclusive,
          message: errorUtil2.toString(message)
        }
      ]
    });
  }
  _addCheck(check2) {
    return new _ZodBigInt({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  positive(message) {
    return this._addCheck({
      kind: "min",
      value: BigInt(0),
      inclusive: false,
      message: errorUtil2.toString(message)
    });
  }
  negative(message) {
    return this._addCheck({
      kind: "max",
      value: BigInt(0),
      inclusive: false,
      message: errorUtil2.toString(message)
    });
  }
  nonpositive(message) {
    return this._addCheck({
      kind: "max",
      value: BigInt(0),
      inclusive: true,
      message: errorUtil2.toString(message)
    });
  }
  nonnegative(message) {
    return this._addCheck({
      kind: "min",
      value: BigInt(0),
      inclusive: true,
      message: errorUtil2.toString(message)
    });
  }
  multipleOf(value, message) {
    return this._addCheck({
      kind: "multipleOf",
      value,
      message: errorUtil2.toString(message)
    });
  }
  get minValue() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxValue() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
};
ZodBigInt2.create = (params) => {
  var _a;
  return new ZodBigInt2({
    checks: [],
    typeName: ZodFirstPartyTypeKind2.ZodBigInt,
    coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
    ...processCreateParams2(params)
  });
};
var ZodBoolean3 = class extends ZodType3 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = Boolean(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.boolean) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.boolean,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    return OK2(input.data);
  }
};
ZodBoolean3.create = (params) => {
  return new ZodBoolean3({
    typeName: ZodFirstPartyTypeKind2.ZodBoolean,
    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
    ...processCreateParams2(params)
  });
};
var ZodDate2 = class _ZodDate extends ZodType3 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = new Date(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.date) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext2(ctx2, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.date,
        received: ctx2.parsedType
      });
      return INVALID2;
    }
    if (isNaN(input.data.getTime())) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext2(ctx2, {
        code: ZodIssueCode2.invalid_date
      });
      return INVALID2;
    }
    const status = new ParseStatus2();
    let ctx = void 0;
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        if (input.data.getTime() < check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_small,
            message: check2.message,
            inclusive: true,
            exact: false,
            minimum: check2.value,
            type: "date"
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        if (input.data.getTime() > check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.too_big,
            message: check2.message,
            inclusive: true,
            exact: false,
            maximum: check2.value,
            type: "date"
          });
          status.dirty();
        }
      } else {
        util2.assertNever(check2);
      }
    }
    return {
      status: status.value,
      value: new Date(input.data.getTime())
    };
  }
  _addCheck(check2) {
    return new _ZodDate({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  min(minDate, message) {
    return this._addCheck({
      kind: "min",
      value: minDate.getTime(),
      message: errorUtil2.toString(message)
    });
  }
  max(maxDate, message) {
    return this._addCheck({
      kind: "max",
      value: maxDate.getTime(),
      message: errorUtil2.toString(message)
    });
  }
  get minDate() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min != null ? new Date(min) : null;
  }
  get maxDate() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max != null ? new Date(max) : null;
  }
};
ZodDate2.create = (params) => {
  return new ZodDate2({
    checks: [],
    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
    typeName: ZodFirstPartyTypeKind2.ZodDate,
    ...processCreateParams2(params)
  });
};
var ZodSymbol2 = class extends ZodType3 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.symbol) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.symbol,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    return OK2(input.data);
  }
};
ZodSymbol2.create = (params) => {
  return new ZodSymbol2({
    typeName: ZodFirstPartyTypeKind2.ZodSymbol,
    ...processCreateParams2(params)
  });
};
var ZodUndefined2 = class extends ZodType3 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.undefined) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.undefined,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    return OK2(input.data);
  }
};
ZodUndefined2.create = (params) => {
  return new ZodUndefined2({
    typeName: ZodFirstPartyTypeKind2.ZodUndefined,
    ...processCreateParams2(params)
  });
};
var ZodNull3 = class extends ZodType3 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.null) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.null,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    return OK2(input.data);
  }
};
ZodNull3.create = (params) => {
  return new ZodNull3({
    typeName: ZodFirstPartyTypeKind2.ZodNull,
    ...processCreateParams2(params)
  });
};
var ZodAny2 = class extends ZodType3 {
  constructor() {
    super(...arguments);
    this._any = true;
  }
  _parse(input) {
    return OK2(input.data);
  }
};
ZodAny2.create = (params) => {
  return new ZodAny2({
    typeName: ZodFirstPartyTypeKind2.ZodAny,
    ...processCreateParams2(params)
  });
};
var ZodUnknown3 = class extends ZodType3 {
  constructor() {
    super(...arguments);
    this._unknown = true;
  }
  _parse(input) {
    return OK2(input.data);
  }
};
ZodUnknown3.create = (params) => {
  return new ZodUnknown3({
    typeName: ZodFirstPartyTypeKind2.ZodUnknown,
    ...processCreateParams2(params)
  });
};
var ZodNever3 = class extends ZodType3 {
  _parse(input) {
    const ctx = this._getOrReturnCtx(input);
    addIssueToContext2(ctx, {
      code: ZodIssueCode2.invalid_type,
      expected: ZodParsedType2.never,
      received: ctx.parsedType
    });
    return INVALID2;
  }
};
ZodNever3.create = (params) => {
  return new ZodNever3({
    typeName: ZodFirstPartyTypeKind2.ZodNever,
    ...processCreateParams2(params)
  });
};
var ZodVoid2 = class extends ZodType3 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.undefined) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.void,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    return OK2(input.data);
  }
};
ZodVoid2.create = (params) => {
  return new ZodVoid2({
    typeName: ZodFirstPartyTypeKind2.ZodVoid,
    ...processCreateParams2(params)
  });
};
var ZodArray3 = class _ZodArray extends ZodType3 {
  _parse(input) {
    const { ctx, status } = this._processInputParams(input);
    const def = this._def;
    if (ctx.parsedType !== ZodParsedType2.array) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.array,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    if (def.exactLength !== null) {
      const tooBig = ctx.data.length > def.exactLength.value;
      const tooSmall = ctx.data.length < def.exactLength.value;
      if (tooBig || tooSmall) {
        addIssueToContext2(ctx, {
          code: tooBig ? ZodIssueCode2.too_big : ZodIssueCode2.too_small,
          minimum: tooSmall ? def.exactLength.value : void 0,
          maximum: tooBig ? def.exactLength.value : void 0,
          type: "array",
          inclusive: true,
          exact: true,
          message: def.exactLength.message
        });
        status.dirty();
      }
    }
    if (def.minLength !== null) {
      if (ctx.data.length < def.minLength.value) {
        addIssueToContext2(ctx, {
          code: ZodIssueCode2.too_small,
          minimum: def.minLength.value,
          type: "array",
          inclusive: true,
          exact: false,
          message: def.minLength.message
        });
        status.dirty();
      }
    }
    if (def.maxLength !== null) {
      if (ctx.data.length > def.maxLength.value) {
        addIssueToContext2(ctx, {
          code: ZodIssueCode2.too_big,
          maximum: def.maxLength.value,
          type: "array",
          inclusive: true,
          exact: false,
          message: def.maxLength.message
        });
        status.dirty();
      }
    }
    if (ctx.common.async) {
      return Promise.all([...ctx.data].map((item, i) => {
        return def.type._parseAsync(new ParseInputLazyPath2(ctx, item, ctx.path, i));
      })).then((result2) => {
        return ParseStatus2.mergeArray(status, result2);
      });
    }
    const result = [...ctx.data].map((item, i) => {
      return def.type._parseSync(new ParseInputLazyPath2(ctx, item, ctx.path, i));
    });
    return ParseStatus2.mergeArray(status, result);
  }
  get element() {
    return this._def.type;
  }
  min(minLength, message) {
    return new _ZodArray({
      ...this._def,
      minLength: { value: minLength, message: errorUtil2.toString(message) }
    });
  }
  max(maxLength, message) {
    return new _ZodArray({
      ...this._def,
      maxLength: { value: maxLength, message: errorUtil2.toString(message) }
    });
  }
  length(len, message) {
    return new _ZodArray({
      ...this._def,
      exactLength: { value: len, message: errorUtil2.toString(message) }
    });
  }
  nonempty(message) {
    return this.min(1, message);
  }
};
ZodArray3.create = (schema, params) => {
  return new ZodArray3({
    type: schema,
    minLength: null,
    maxLength: null,
    exactLength: null,
    typeName: ZodFirstPartyTypeKind2.ZodArray,
    ...processCreateParams2(params)
  });
};
function deepPartialify2(schema) {
  if (schema instanceof ZodObject3) {
    const newShape = {};
    for (const key in schema.shape) {
      const fieldSchema = schema.shape[key];
      newShape[key] = ZodOptional3.create(deepPartialify2(fieldSchema));
    }
    return new ZodObject3({
      ...schema._def,
      shape: () => newShape
    });
  } else if (schema instanceof ZodArray3) {
    return new ZodArray3({
      ...schema._def,
      type: deepPartialify2(schema.element)
    });
  } else if (schema instanceof ZodOptional3) {
    return ZodOptional3.create(deepPartialify2(schema.unwrap()));
  } else if (schema instanceof ZodNullable3) {
    return ZodNullable3.create(deepPartialify2(schema.unwrap()));
  } else if (schema instanceof ZodTuple2) {
    return ZodTuple2.create(schema.items.map((item) => deepPartialify2(item)));
  } else {
    return schema;
  }
}
var ZodObject3 = class _ZodObject extends ZodType3 {
  constructor() {
    super(...arguments);
    this._cached = null;
    this.nonstrict = this.passthrough;
    this.augment = this.extend;
  }
  _getCached() {
    if (this._cached !== null)
      return this._cached;
    const shape = this._def.shape();
    const keys = util2.objectKeys(shape);
    return this._cached = { shape, keys };
  }
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.object) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext2(ctx2, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.object,
        received: ctx2.parsedType
      });
      return INVALID2;
    }
    const { status, ctx } = this._processInputParams(input);
    const { shape, keys: shapeKeys } = this._getCached();
    const extraKeys = [];
    if (!(this._def.catchall instanceof ZodNever3 && this._def.unknownKeys === "strip")) {
      for (const key in ctx.data) {
        if (!shapeKeys.includes(key)) {
          extraKeys.push(key);
        }
      }
    }
    const pairs = [];
    for (const key of shapeKeys) {
      const keyValidator = shape[key];
      const value = ctx.data[key];
      pairs.push({
        key: { status: "valid", value: key },
        value: keyValidator._parse(new ParseInputLazyPath2(ctx, value, ctx.path, key)),
        alwaysSet: key in ctx.data
      });
    }
    if (this._def.catchall instanceof ZodNever3) {
      const unknownKeys = this._def.unknownKeys;
      if (unknownKeys === "passthrough") {
        for (const key of extraKeys) {
          pairs.push({
            key: { status: "valid", value: key },
            value: { status: "valid", value: ctx.data[key] }
          });
        }
      } else if (unknownKeys === "strict") {
        if (extraKeys.length > 0) {
          addIssueToContext2(ctx, {
            code: ZodIssueCode2.unrecognized_keys,
            keys: extraKeys
          });
          status.dirty();
        }
      } else if (unknownKeys === "strip") ;
      else {
        throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
      }
    } else {
      const catchall = this._def.catchall;
      for (const key of extraKeys) {
        const value = ctx.data[key];
        pairs.push({
          key: { status: "valid", value: key },
          value: catchall._parse(
            new ParseInputLazyPath2(ctx, value, ctx.path, key)
            //, ctx.child(key), value, getParsedType(value)
          ),
          alwaysSet: key in ctx.data
        });
      }
    }
    if (ctx.common.async) {
      return Promise.resolve().then(async () => {
        const syncPairs = [];
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          syncPairs.push({
            key,
            value,
            alwaysSet: pair.alwaysSet
          });
        }
        return syncPairs;
      }).then((syncPairs) => {
        return ParseStatus2.mergeObjectSync(status, syncPairs);
      });
    } else {
      return ParseStatus2.mergeObjectSync(status, pairs);
    }
  }
  get shape() {
    return this._def.shape();
  }
  strict(message) {
    errorUtil2.errToObj;
    return new _ZodObject({
      ...this._def,
      unknownKeys: "strict",
      ...message !== void 0 ? {
        errorMap: (issue2, ctx) => {
          var _a, _b, _c, _d;
          const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue2, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
          if (issue2.code === "unrecognized_keys")
            return {
              message: (_d = errorUtil2.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError
            };
          return {
            message: defaultError
          };
        }
      } : {}
    });
  }
  strip() {
    return new _ZodObject({
      ...this._def,
      unknownKeys: "strip"
    });
  }
  passthrough() {
    return new _ZodObject({
      ...this._def,
      unknownKeys: "passthrough"
    });
  }
  // const AugmentFactory =
  //   <Def extends ZodObjectDef>(def: Def) =>
  //   <Augmentation extends ZodRawShape>(
  //     augmentation: Augmentation
  //   ): ZodObject<
  //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
  //     Def["unknownKeys"],
  //     Def["catchall"]
  //   > => {
  //     return new ZodObject({
  //       ...def,
  //       shape: () => ({
  //         ...def.shape(),
  //         ...augmentation,
  //       }),
  //     }) as any;
  //   };
  extend(augmentation) {
    return new _ZodObject({
      ...this._def,
      shape: () => ({
        ...this._def.shape(),
        ...augmentation
      })
    });
  }
  /**
   * Prior to zod@1.0.12 there was a bug in the
   * inferred type of merged objects. Please
   * upgrade if you are experiencing issues.
   */
  merge(merging) {
    const merged = new _ZodObject({
      unknownKeys: merging._def.unknownKeys,
      catchall: merging._def.catchall,
      shape: () => ({
        ...this._def.shape(),
        ...merging._def.shape()
      }),
      typeName: ZodFirstPartyTypeKind2.ZodObject
    });
    return merged;
  }
  // merge<
  //   Incoming extends AnyZodObject,
  //   Augmentation extends Incoming["shape"],
  //   NewOutput extends {
  //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
  //       ? Augmentation[k]["_output"]
  //       : k extends keyof Output
  //       ? Output[k]
  //       : never;
  //   },
  //   NewInput extends {
  //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
  //       ? Augmentation[k]["_input"]
  //       : k extends keyof Input
  //       ? Input[k]
  //       : never;
  //   }
  // >(
  //   merging: Incoming
  // ): ZodObject<
  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
  //   Incoming["_def"]["unknownKeys"],
  //   Incoming["_def"]["catchall"],
  //   NewOutput,
  //   NewInput
  // > {
  //   const merged: any = new ZodObject({
  //     unknownKeys: merging._def.unknownKeys,
  //     catchall: merging._def.catchall,
  //     shape: () =>
  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
  //     typeName: ZodFirstPartyTypeKind.ZodObject,
  //   }) as any;
  //   return merged;
  // }
  setKey(key, schema) {
    return this.augment({ [key]: schema });
  }
  // merge<Incoming extends AnyZodObject>(
  //   merging: Incoming
  // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
  // ZodObject<
  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
  //   Incoming["_def"]["unknownKeys"],
  //   Incoming["_def"]["catchall"]
  // > {
  //   // const mergedShape = objectUtil.mergeShapes(
  //   //   this._def.shape(),
  //   //   merging._def.shape()
  //   // );
  //   const merged: any = new ZodObject({
  //     unknownKeys: merging._def.unknownKeys,
  //     catchall: merging._def.catchall,
  //     shape: () =>
  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
  //     typeName: ZodFirstPartyTypeKind.ZodObject,
  //   }) as any;
  //   return merged;
  // }
  catchall(index) {
    return new _ZodObject({
      ...this._def,
      catchall: index
    });
  }
  pick(mask) {
    const shape = {};
    util2.objectKeys(mask).forEach((key) => {
      if (mask[key] && this.shape[key]) {
        shape[key] = this.shape[key];
      }
    });
    return new _ZodObject({
      ...this._def,
      shape: () => shape
    });
  }
  omit(mask) {
    const shape = {};
    util2.objectKeys(this.shape).forEach((key) => {
      if (!mask[key]) {
        shape[key] = this.shape[key];
      }
    });
    return new _ZodObject({
      ...this._def,
      shape: () => shape
    });
  }
  /**
   * @deprecated
   */
  deepPartial() {
    return deepPartialify2(this);
  }
  partial(mask) {
    const newShape = {};
    util2.objectKeys(this.shape).forEach((key) => {
      const fieldSchema = this.shape[key];
      if (mask && !mask[key]) {
        newShape[key] = fieldSchema;
      } else {
        newShape[key] = fieldSchema.optional();
      }
    });
    return new _ZodObject({
      ...this._def,
      shape: () => newShape
    });
  }
  required(mask) {
    const newShape = {};
    util2.objectKeys(this.shape).forEach((key) => {
      if (mask && !mask[key]) {
        newShape[key] = this.shape[key];
      } else {
        const fieldSchema = this.shape[key];
        let newField = fieldSchema;
        while (newField instanceof ZodOptional3) {
          newField = newField._def.innerType;
        }
        newShape[key] = newField;
      }
    });
    return new _ZodObject({
      ...this._def,
      shape: () => newShape
    });
  }
  keyof() {
    return createZodEnum2(util2.objectKeys(this.shape));
  }
};
ZodObject3.create = (shape, params) => {
  return new ZodObject3({
    shape: () => shape,
    unknownKeys: "strip",
    catchall: ZodNever3.create(),
    typeName: ZodFirstPartyTypeKind2.ZodObject,
    ...processCreateParams2(params)
  });
};
ZodObject3.strictCreate = (shape, params) => {
  return new ZodObject3({
    shape: () => shape,
    unknownKeys: "strict",
    catchall: ZodNever3.create(),
    typeName: ZodFirstPartyTypeKind2.ZodObject,
    ...processCreateParams2(params)
  });
};
ZodObject3.lazycreate = (shape, params) => {
  return new ZodObject3({
    shape,
    unknownKeys: "strip",
    catchall: ZodNever3.create(),
    typeName: ZodFirstPartyTypeKind2.ZodObject,
    ...processCreateParams2(params)
  });
};
var ZodUnion3 = class extends ZodType3 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const options = this._def.options;
    function handleResults(results2) {
      for (const result of results2) {
        if (result.result.status === "valid") {
          return result.result;
        }
      }
      for (const result of results2) {
        if (result.result.status === "dirty") {
          ctx.common.issues.push(...result.ctx.common.issues);
          return result.result;
        }
      }
      const unionErrors = results2.map((result) => new ZodError3(result.ctx.common.issues));
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_union,
        unionErrors
      });
      return INVALID2;
    }
    if (ctx.common.async) {
      return Promise.all(options.map(async (option) => {
        const childCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          },
          parent: null
        };
        return {
          result: await option._parseAsync({
            data: ctx.data,
            path: ctx.path,
            parent: childCtx
          }),
          ctx: childCtx
        };
      })).then(handleResults);
    } else {
      let dirty = void 0;
      const issues = [];
      for (const option of options) {
        const childCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          },
          parent: null
        };
        const result = option._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: childCtx
        });
        if (result.status === "valid") {
          return result;
        } else if (result.status === "dirty" && !dirty) {
          dirty = { result, ctx: childCtx };
        }
        if (childCtx.common.issues.length) {
          issues.push(childCtx.common.issues);
        }
      }
      if (dirty) {
        ctx.common.issues.push(...dirty.ctx.common.issues);
        return dirty.result;
      }
      const unionErrors = issues.map((issues2) => new ZodError3(issues2));
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_union,
        unionErrors
      });
      return INVALID2;
    }
  }
  get options() {
    return this._def.options;
  }
};
ZodUnion3.create = (types, params) => {
  return new ZodUnion3({
    options: types,
    typeName: ZodFirstPartyTypeKind2.ZodUnion,
    ...processCreateParams2(params)
  });
};
var getDiscriminator2 = (type) => {
  if (type instanceof ZodLazy2) {
    return getDiscriminator2(type.schema);
  } else if (type instanceof ZodEffects2) {
    return getDiscriminator2(type.innerType());
  } else if (type instanceof ZodLiteral3) {
    return [type.value];
  } else if (type instanceof ZodEnum3) {
    return type.options;
  } else if (type instanceof ZodNativeEnum2) {
    return util2.objectValues(type.enum);
  } else if (type instanceof ZodDefault3) {
    return getDiscriminator2(type._def.innerType);
  } else if (type instanceof ZodUndefined2) {
    return [void 0];
  } else if (type instanceof ZodNull3) {
    return [null];
  } else if (type instanceof ZodOptional3) {
    return [void 0, ...getDiscriminator2(type.unwrap())];
  } else if (type instanceof ZodNullable3) {
    return [null, ...getDiscriminator2(type.unwrap())];
  } else if (type instanceof ZodBranded2) {
    return getDiscriminator2(type.unwrap());
  } else if (type instanceof ZodReadonly3) {
    return getDiscriminator2(type.unwrap());
  } else if (type instanceof ZodCatch3) {
    return getDiscriminator2(type._def.innerType);
  } else {
    return [];
  }
};
var ZodDiscriminatedUnion3 = class _ZodDiscriminatedUnion extends ZodType3 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType2.object) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.object,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    const discriminator = this.discriminator;
    const discriminatorValue = ctx.data[discriminator];
    const option = this.optionsMap.get(discriminatorValue);
    if (!option) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_union_discriminator,
        options: Array.from(this.optionsMap.keys()),
        path: [discriminator]
      });
      return INVALID2;
    }
    if (ctx.common.async) {
      return option._parseAsync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
    } else {
      return option._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
    }
  }
  get discriminator() {
    return this._def.discriminator;
  }
  get options() {
    return this._def.options;
  }
  get optionsMap() {
    return this._def.optionsMap;
  }
  /**
   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
   * have a different value for each object in the union.
   * @param discriminator the name of the discriminator property
   * @param types an array of object schemas
   * @param params
   */
  static create(discriminator, options, params) {
    const optionsMap = /* @__PURE__ */ new Map();
    for (const type of options) {
      const discriminatorValues = getDiscriminator2(type.shape[discriminator]);
      if (!discriminatorValues.length) {
        throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
      }
      for (const value of discriminatorValues) {
        if (optionsMap.has(value)) {
          throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
        }
        optionsMap.set(value, type);
      }
    }
    return new _ZodDiscriminatedUnion({
      typeName: ZodFirstPartyTypeKind2.ZodDiscriminatedUnion,
      discriminator,
      options,
      optionsMap,
      ...processCreateParams2(params)
    });
  }
};
function mergeValues3(a, b) {
  const aType = getParsedType3(a);
  const bType = getParsedType3(b);
  if (a === b) {
    return { valid: true, data: a };
  } else if (aType === ZodParsedType2.object && bType === ZodParsedType2.object) {
    const bKeys = util2.objectKeys(b);
    const sharedKeys = util2.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues3(a[key], b[key]);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  } else if (aType === ZodParsedType2.array && bType === ZodParsedType2.array) {
    if (a.length !== b.length) {
      return { valid: false };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues3(itemA, itemB);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  } else if (aType === ZodParsedType2.date && bType === ZodParsedType2.date && +a === +b) {
    return { valid: true, data: a };
  } else {
    return { valid: false };
  }
}
var ZodIntersection3 = class extends ZodType3 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    const handleParsed = (parsedLeft, parsedRight) => {
      if (isAborted2(parsedLeft) || isAborted2(parsedRight)) {
        return INVALID2;
      }
      const merged = mergeValues3(parsedLeft.value, parsedRight.value);
      if (!merged.valid) {
        addIssueToContext2(ctx, {
          code: ZodIssueCode2.invalid_intersection_types
        });
        return INVALID2;
      }
      if (isDirty2(parsedLeft) || isDirty2(parsedRight)) {
        status.dirty();
      }
      return { status: status.value, value: merged.data };
    };
    if (ctx.common.async) {
      return Promise.all([
        this._def.left._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        }),
        this._def.right._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        })
      ]).then(([left, right]) => handleParsed(left, right));
    } else {
      return handleParsed(this._def.left._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      }), this._def.right._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      }));
    }
  }
};
ZodIntersection3.create = (left, right, params) => {
  return new ZodIntersection3({
    left,
    right,
    typeName: ZodFirstPartyTypeKind2.ZodIntersection,
    ...processCreateParams2(params)
  });
};
var ZodTuple2 = class _ZodTuple extends ZodType3 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType2.array) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.array,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    if (ctx.data.length < this._def.items.length) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.too_small,
        minimum: this._def.items.length,
        inclusive: true,
        exact: false,
        type: "array"
      });
      return INVALID2;
    }
    const rest = this._def.rest;
    if (!rest && ctx.data.length > this._def.items.length) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.too_big,
        maximum: this._def.items.length,
        inclusive: true,
        exact: false,
        type: "array"
      });
      status.dirty();
    }
    const items = [...ctx.data].map((item, itemIndex) => {
      const schema = this._def.items[itemIndex] || this._def.rest;
      if (!schema)
        return null;
      return schema._parse(new ParseInputLazyPath2(ctx, item, ctx.path, itemIndex));
    }).filter((x) => !!x);
    if (ctx.common.async) {
      return Promise.all(items).then((results2) => {
        return ParseStatus2.mergeArray(status, results2);
      });
    } else {
      return ParseStatus2.mergeArray(status, items);
    }
  }
  get items() {
    return this._def.items;
  }
  rest(rest) {
    return new _ZodTuple({
      ...this._def,
      rest
    });
  }
};
ZodTuple2.create = (schemas, params) => {
  if (!Array.isArray(schemas)) {
    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
  }
  return new ZodTuple2({
    items: schemas,
    typeName: ZodFirstPartyTypeKind2.ZodTuple,
    rest: null,
    ...processCreateParams2(params)
  });
};
var ZodRecord3 = class _ZodRecord extends ZodType3 {
  get keySchema() {
    return this._def.keyType;
  }
  get valueSchema() {
    return this._def.valueType;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType2.object) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.object,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    const pairs = [];
    const keyType = this._def.keyType;
    const valueType = this._def.valueType;
    for (const key in ctx.data) {
      pairs.push({
        key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, key)),
        value: valueType._parse(new ParseInputLazyPath2(ctx, ctx.data[key], ctx.path, key)),
        alwaysSet: key in ctx.data
      });
    }
    if (ctx.common.async) {
      return ParseStatus2.mergeObjectAsync(status, pairs);
    } else {
      return ParseStatus2.mergeObjectSync(status, pairs);
    }
  }
  get element() {
    return this._def.valueType;
  }
  static create(first, second, third) {
    if (second instanceof ZodType3) {
      return new _ZodRecord({
        keyType: first,
        valueType: second,
        typeName: ZodFirstPartyTypeKind2.ZodRecord,
        ...processCreateParams2(third)
      });
    }
    return new _ZodRecord({
      keyType: ZodString3.create(),
      valueType: first,
      typeName: ZodFirstPartyTypeKind2.ZodRecord,
      ...processCreateParams2(second)
    });
  }
};
var ZodMap2 = class extends ZodType3 {
  get keySchema() {
    return this._def.keyType;
  }
  get valueSchema() {
    return this._def.valueType;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType2.map) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.map,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    const keyType = this._def.keyType;
    const valueType = this._def.valueType;
    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
      return {
        key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, [index, "key"])),
        value: valueType._parse(new ParseInputLazyPath2(ctx, value, ctx.path, [index, "value"]))
      };
    });
    if (ctx.common.async) {
      const finalMap = /* @__PURE__ */ new Map();
      return Promise.resolve().then(async () => {
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          if (key.status === "aborted" || value.status === "aborted") {
            return INVALID2;
          }
          if (key.status === "dirty" || value.status === "dirty") {
            status.dirty();
          }
          finalMap.set(key.value, value.value);
        }
        return { status: status.value, value: finalMap };
      });
    } else {
      const finalMap = /* @__PURE__ */ new Map();
      for (const pair of pairs) {
        const key = pair.key;
        const value = pair.value;
        if (key.status === "aborted" || value.status === "aborted") {
          return INVALID2;
        }
        if (key.status === "dirty" || value.status === "dirty") {
          status.dirty();
        }
        finalMap.set(key.value, value.value);
      }
      return { status: status.value, value: finalMap };
    }
  }
};
ZodMap2.create = (keyType, valueType, params) => {
  return new ZodMap2({
    valueType,
    keyType,
    typeName: ZodFirstPartyTypeKind2.ZodMap,
    ...processCreateParams2(params)
  });
};
var ZodSet2 = class _ZodSet extends ZodType3 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType2.set) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.set,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    const def = this._def;
    if (def.minSize !== null) {
      if (ctx.data.size < def.minSize.value) {
        addIssueToContext2(ctx, {
          code: ZodIssueCode2.too_small,
          minimum: def.minSize.value,
          type: "set",
          inclusive: true,
          exact: false,
          message: def.minSize.message
        });
        status.dirty();
      }
    }
    if (def.maxSize !== null) {
      if (ctx.data.size > def.maxSize.value) {
        addIssueToContext2(ctx, {
          code: ZodIssueCode2.too_big,
          maximum: def.maxSize.value,
          type: "set",
          inclusive: true,
          exact: false,
          message: def.maxSize.message
        });
        status.dirty();
      }
    }
    const valueType = this._def.valueType;
    function finalizeSet(elements2) {
      const parsedSet = /* @__PURE__ */ new Set();
      for (const element of elements2) {
        if (element.status === "aborted")
          return INVALID2;
        if (element.status === "dirty")
          status.dirty();
        parsedSet.add(element.value);
      }
      return { status: status.value, value: parsedSet };
    }
    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath2(ctx, item, ctx.path, i)));
    if (ctx.common.async) {
      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
    } else {
      return finalizeSet(elements);
    }
  }
  min(minSize, message) {
    return new _ZodSet({
      ...this._def,
      minSize: { value: minSize, message: errorUtil2.toString(message) }
    });
  }
  max(maxSize, message) {
    return new _ZodSet({
      ...this._def,
      maxSize: { value: maxSize, message: errorUtil2.toString(message) }
    });
  }
  size(size, message) {
    return this.min(size, message).max(size, message);
  }
  nonempty(message) {
    return this.min(1, message);
  }
};
ZodSet2.create = (valueType, params) => {
  return new ZodSet2({
    valueType,
    minSize: null,
    maxSize: null,
    typeName: ZodFirstPartyTypeKind2.ZodSet,
    ...processCreateParams2(params)
  });
};
var ZodFunction2 = class _ZodFunction extends ZodType3 {
  constructor() {
    super(...arguments);
    this.validate = this.implement;
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType2.function) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.function,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    function makeArgsIssue(args, error3) {
      return makeIssue2({
        data: args,
        path: ctx.path,
        errorMaps: [
          ctx.common.contextualErrorMap,
          ctx.schemaErrorMap,
          getErrorMap2(),
          errorMap2
        ].filter((x) => !!x),
        issueData: {
          code: ZodIssueCode2.invalid_arguments,
          argumentsError: error3
        }
      });
    }
    function makeReturnsIssue(returns, error3) {
      return makeIssue2({
        data: returns,
        path: ctx.path,
        errorMaps: [
          ctx.common.contextualErrorMap,
          ctx.schemaErrorMap,
          getErrorMap2(),
          errorMap2
        ].filter((x) => !!x),
        issueData: {
          code: ZodIssueCode2.invalid_return_type,
          returnTypeError: error3
        }
      });
    }
    const params = { errorMap: ctx.common.contextualErrorMap };
    const fn = ctx.data;
    if (this._def.returns instanceof ZodPromise2) {
      const me = this;
      return OK2(async function(...args) {
        const error3 = new ZodError3([]);
        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
          error3.addIssue(makeArgsIssue(args, e));
          throw error3;
        });
        const result = await Reflect.apply(fn, this, parsedArgs);
        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
          error3.addIssue(makeReturnsIssue(result, e));
          throw error3;
        });
        return parsedReturns;
      });
    } else {
      const me = this;
      return OK2(function(...args) {
        const parsedArgs = me._def.args.safeParse(args, params);
        if (!parsedArgs.success) {
          throw new ZodError3([makeArgsIssue(args, parsedArgs.error)]);
        }
        const result = Reflect.apply(fn, this, parsedArgs.data);
        const parsedReturns = me._def.returns.safeParse(result, params);
        if (!parsedReturns.success) {
          throw new ZodError3([makeReturnsIssue(result, parsedReturns.error)]);
        }
        return parsedReturns.data;
      });
    }
  }
  parameters() {
    return this._def.args;
  }
  returnType() {
    return this._def.returns;
  }
  args(...items) {
    return new _ZodFunction({
      ...this._def,
      args: ZodTuple2.create(items).rest(ZodUnknown3.create())
    });
  }
  returns(returnType) {
    return new _ZodFunction({
      ...this._def,
      returns: returnType
    });
  }
  implement(func) {
    const validatedFunc = this.parse(func);
    return validatedFunc;
  }
  strictImplement(func) {
    const validatedFunc = this.parse(func);
    return validatedFunc;
  }
  static create(args, returns, params) {
    return new _ZodFunction({
      args: args ? args : ZodTuple2.create([]).rest(ZodUnknown3.create()),
      returns: returns || ZodUnknown3.create(),
      typeName: ZodFirstPartyTypeKind2.ZodFunction,
      ...processCreateParams2(params)
    });
  }
};
var ZodLazy2 = class extends ZodType3 {
  get schema() {
    return this._def.getter();
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const lazySchema = this._def.getter();
    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
  }
};
ZodLazy2.create = (getter, params) => {
  return new ZodLazy2({
    getter,
    typeName: ZodFirstPartyTypeKind2.ZodLazy,
    ...processCreateParams2(params)
  });
};
var ZodLiteral3 = class extends ZodType3 {
  _parse(input) {
    if (input.data !== this._def.value) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext2(ctx, {
        received: ctx.data,
        code: ZodIssueCode2.invalid_literal,
        expected: this._def.value
      });
      return INVALID2;
    }
    return { status: "valid", value: input.data };
  }
  get value() {
    return this._def.value;
  }
};
ZodLiteral3.create = (value, params) => {
  return new ZodLiteral3({
    value,
    typeName: ZodFirstPartyTypeKind2.ZodLiteral,
    ...processCreateParams2(params)
  });
};
function createZodEnum2(values, params) {
  return new ZodEnum3({
    values,
    typeName: ZodFirstPartyTypeKind2.ZodEnum,
    ...processCreateParams2(params)
  });
}
var ZodEnum3 = class _ZodEnum extends ZodType3 {
  constructor() {
    super(...arguments);
    _ZodEnum_cache.set(this, void 0);
  }
  _parse(input) {
    if (typeof input.data !== "string") {
      const ctx = this._getOrReturnCtx(input);
      const expectedValues = this._def.values;
      addIssueToContext2(ctx, {
        expected: util2.joinValues(expectedValues),
        received: ctx.parsedType,
        code: ZodIssueCode2.invalid_type
      });
      return INVALID2;
    }
    if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f")) {
      __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values), "f");
    }
    if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f").has(input.data)) {
      const ctx = this._getOrReturnCtx(input);
      const expectedValues = this._def.values;
      addIssueToContext2(ctx, {
        received: ctx.data,
        code: ZodIssueCode2.invalid_enum_value,
        options: expectedValues
      });
      return INVALID2;
    }
    return OK2(input.data);
  }
  get options() {
    return this._def.values;
  }
  get enum() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  get Values() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  get Enum() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  extract(values, newDef = this._def) {
    return _ZodEnum.create(values, {
      ...this._def,
      ...newDef
    });
  }
  exclude(values, newDef = this._def) {
    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
      ...this._def,
      ...newDef
    });
  }
};
_ZodEnum_cache = /* @__PURE__ */ new WeakMap();
ZodEnum3.create = createZodEnum2;
var ZodNativeEnum2 = class extends ZodType3 {
  constructor() {
    super(...arguments);
    _ZodNativeEnum_cache.set(this, void 0);
  }
  _parse(input) {
    const nativeEnumValues = util2.getValidEnumValues(this._def.values);
    const ctx = this._getOrReturnCtx(input);
    if (ctx.parsedType !== ZodParsedType2.string && ctx.parsedType !== ZodParsedType2.number) {
      const expectedValues = util2.objectValues(nativeEnumValues);
      addIssueToContext2(ctx, {
        expected: util2.joinValues(expectedValues),
        received: ctx.parsedType,
        code: ZodIssueCode2.invalid_type
      });
      return INVALID2;
    }
    if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f")) {
      __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util2.getValidEnumValues(this._def.values)), "f");
    }
    if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f").has(input.data)) {
      const expectedValues = util2.objectValues(nativeEnumValues);
      addIssueToContext2(ctx, {
        received: ctx.data,
        code: ZodIssueCode2.invalid_enum_value,
        options: expectedValues
      });
      return INVALID2;
    }
    return OK2(input.data);
  }
  get enum() {
    return this._def.values;
  }
};
_ZodNativeEnum_cache = /* @__PURE__ */ new WeakMap();
ZodNativeEnum2.create = (values, params) => {
  return new ZodNativeEnum2({
    values,
    typeName: ZodFirstPartyTypeKind2.ZodNativeEnum,
    ...processCreateParams2(params)
  });
};
var ZodPromise2 = class extends ZodType3 {
  unwrap() {
    return this._def.type;
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType2.promise && ctx.common.async === false) {
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.promise,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    const promisified = ctx.parsedType === ZodParsedType2.promise ? ctx.data : Promise.resolve(ctx.data);
    return OK2(promisified.then((data) => {
      return this._def.type.parseAsync(data, {
        path: ctx.path,
        errorMap: ctx.common.contextualErrorMap
      });
    }));
  }
};
ZodPromise2.create = (schema, params) => {
  return new ZodPromise2({
    type: schema,
    typeName: ZodFirstPartyTypeKind2.ZodPromise,
    ...processCreateParams2(params)
  });
};
var ZodEffects2 = class extends ZodType3 {
  innerType() {
    return this._def.schema;
  }
  sourceType() {
    return this._def.schema._def.typeName === ZodFirstPartyTypeKind2.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    const effect = this._def.effect || null;
    const checkCtx = {
      addIssue: (arg) => {
        addIssueToContext2(ctx, arg);
        if (arg.fatal) {
          status.abort();
        } else {
          status.dirty();
        }
      },
      get path() {
        return ctx.path;
      }
    };
    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
    if (effect.type === "preprocess") {
      const processed = effect.transform(ctx.data, checkCtx);
      if (ctx.common.async) {
        return Promise.resolve(processed).then(async (processed2) => {
          if (status.value === "aborted")
            return INVALID2;
          const result = await this._def.schema._parseAsync({
            data: processed2,
            path: ctx.path,
            parent: ctx
          });
          if (result.status === "aborted")
            return INVALID2;
          if (result.status === "dirty")
            return DIRTY2(result.value);
          if (status.value === "dirty")
            return DIRTY2(result.value);
          return result;
        });
      } else {
        if (status.value === "aborted")
          return INVALID2;
        const result = this._def.schema._parseSync({
          data: processed,
          path: ctx.path,
          parent: ctx
        });
        if (result.status === "aborted")
          return INVALID2;
        if (result.status === "dirty")
          return DIRTY2(result.value);
        if (status.value === "dirty")
          return DIRTY2(result.value);
        return result;
      }
    }
    if (effect.type === "refinement") {
      const executeRefinement = (acc) => {
        const result = effect.refinement(acc, checkCtx);
        if (ctx.common.async) {
          return Promise.resolve(result);
        }
        if (result instanceof Promise) {
          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
        }
        return acc;
      };
      if (ctx.common.async === false) {
        const inner = this._def.schema._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (inner.status === "aborted")
          return INVALID2;
        if (inner.status === "dirty")
          status.dirty();
        executeRefinement(inner.value);
        return { status: status.value, value: inner.value };
      } else {
        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
          if (inner.status === "aborted")
            return INVALID2;
          if (inner.status === "dirty")
            status.dirty();
          return executeRefinement(inner.value).then(() => {
            return { status: status.value, value: inner.value };
          });
        });
      }
    }
    if (effect.type === "transform") {
      if (ctx.common.async === false) {
        const base = this._def.schema._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (!isValid2(base))
          return base;
        const result = effect.transform(base.value, checkCtx);
        if (result instanceof Promise) {
          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
        }
        return { status: status.value, value: result };
      } else {
        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
          if (!isValid2(base))
            return base;
          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
        });
      }
    }
    util2.assertNever(effect);
  }
};
ZodEffects2.create = (schema, effect, params) => {
  return new ZodEffects2({
    schema,
    typeName: ZodFirstPartyTypeKind2.ZodEffects,
    effect,
    ...processCreateParams2(params)
  });
};
ZodEffects2.createWithPreprocess = (preprocess2, schema, params) => {
  return new ZodEffects2({
    schema,
    effect: { type: "preprocess", transform: preprocess2 },
    typeName: ZodFirstPartyTypeKind2.ZodEffects,
    ...processCreateParams2(params)
  });
};
var ZodOptional3 = class extends ZodType3 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 === ZodParsedType2.undefined) {
      return OK2(void 0);
    }
    return this._def.innerType._parse(input);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodOptional3.create = (type, params) => {
  return new ZodOptional3({
    innerType: type,
    typeName: ZodFirstPartyTypeKind2.ZodOptional,
    ...processCreateParams2(params)
  });
};
var ZodNullable3 = class extends ZodType3 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 === ZodParsedType2.null) {
      return OK2(null);
    }
    return this._def.innerType._parse(input);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodNullable3.create = (type, params) => {
  return new ZodNullable3({
    innerType: type,
    typeName: ZodFirstPartyTypeKind2.ZodNullable,
    ...processCreateParams2(params)
  });
};
var ZodDefault3 = class extends ZodType3 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    let data = ctx.data;
    if (ctx.parsedType === ZodParsedType2.undefined) {
      data = this._def.defaultValue();
    }
    return this._def.innerType._parse({
      data,
      path: ctx.path,
      parent: ctx
    });
  }
  removeDefault() {
    return this._def.innerType;
  }
};
ZodDefault3.create = (type, params) => {
  return new ZodDefault3({
    innerType: type,
    typeName: ZodFirstPartyTypeKind2.ZodDefault,
    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
    ...processCreateParams2(params)
  });
};
var ZodCatch3 = class extends ZodType3 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const newCtx = {
      ...ctx,
      common: {
        ...ctx.common,
        issues: []
      }
    };
    const result = this._def.innerType._parse({
      data: newCtx.data,
      path: newCtx.path,
      parent: {
        ...newCtx
      }
    });
    if (isAsync2(result)) {
      return result.then((result2) => {
        return {
          status: "valid",
          value: result2.status === "valid" ? result2.value : this._def.catchValue({
            get error() {
              return new ZodError3(newCtx.common.issues);
            },
            input: newCtx.data
          })
        };
      });
    } else {
      return {
        status: "valid",
        value: result.status === "valid" ? result.value : this._def.catchValue({
          get error() {
            return new ZodError3(newCtx.common.issues);
          },
          input: newCtx.data
        })
      };
    }
  }
  removeCatch() {
    return this._def.innerType;
  }
};
ZodCatch3.create = (type, params) => {
  return new ZodCatch3({
    innerType: type,
    typeName: ZodFirstPartyTypeKind2.ZodCatch,
    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
    ...processCreateParams2(params)
  });
};
var ZodNaN2 = class extends ZodType3 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType2.nan) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext2(ctx, {
        code: ZodIssueCode2.invalid_type,
        expected: ZodParsedType2.nan,
        received: ctx.parsedType
      });
      return INVALID2;
    }
    return { status: "valid", value: input.data };
  }
};
ZodNaN2.create = (params) => {
  return new ZodNaN2({
    typeName: ZodFirstPartyTypeKind2.ZodNaN,
    ...processCreateParams2(params)
  });
};
var BRAND2 = Symbol("zod_brand");
var ZodBranded2 = class extends ZodType3 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const data = ctx.data;
    return this._def.type._parse({
      data,
      path: ctx.path,
      parent: ctx
    });
  }
  unwrap() {
    return this._def.type;
  }
};
var ZodPipeline2 = class _ZodPipeline extends ZodType3 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.common.async) {
      const handleAsync = async () => {
        const inResult = await this._def.in._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (inResult.status === "aborted")
          return INVALID2;
        if (inResult.status === "dirty") {
          status.dirty();
          return DIRTY2(inResult.value);
        } else {
          return this._def.out._parseAsync({
            data: inResult.value,
            path: ctx.path,
            parent: ctx
          });
        }
      };
      return handleAsync();
    } else {
      const inResult = this._def.in._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
      if (inResult.status === "aborted")
        return INVALID2;
      if (inResult.status === "dirty") {
        status.dirty();
        return {
          status: "dirty",
          value: inResult.value
        };
      } else {
        return this._def.out._parseSync({
          data: inResult.value,
          path: ctx.path,
          parent: ctx
        });
      }
    }
  }
  static create(a, b) {
    return new _ZodPipeline({
      in: a,
      out: b,
      typeName: ZodFirstPartyTypeKind2.ZodPipeline
    });
  }
};
var ZodReadonly3 = class extends ZodType3 {
  _parse(input) {
    const result = this._def.innerType._parse(input);
    const freeze = (data) => {
      if (isValid2(data)) {
        data.value = Object.freeze(data.value);
      }
      return data;
    };
    return isAsync2(result) ? result.then((data) => freeze(data)) : freeze(result);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodReadonly3.create = (type, params) => {
  return new ZodReadonly3({
    innerType: type,
    typeName: ZodFirstPartyTypeKind2.ZodReadonly,
    ...processCreateParams2(params)
  });
};
function custom2(check2, params = {}, fatal) {
  if (check2)
    return ZodAny2.create().superRefine((data, ctx) => {
      var _a, _b;
      if (!check2(data)) {
        const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
        const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
        const p2 = typeof p === "string" ? { message: p } : p;
        ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
      }
    });
  return ZodAny2.create();
}
var late2 = {
  object: ZodObject3.lazycreate
};
var ZodFirstPartyTypeKind2;
(function(ZodFirstPartyTypeKind4) {
  ZodFirstPartyTypeKind4["ZodString"] = "ZodString";
  ZodFirstPartyTypeKind4["ZodNumber"] = "ZodNumber";
  ZodFirstPartyTypeKind4["ZodNaN"] = "ZodNaN";
  ZodFirstPartyTypeKind4["ZodBigInt"] = "ZodBigInt";
  ZodFirstPartyTypeKind4["ZodBoolean"] = "ZodBoolean";
  ZodFirstPartyTypeKind4["ZodDate"] = "ZodDate";
  ZodFirstPartyTypeKind4["ZodSymbol"] = "ZodSymbol";
  ZodFirstPartyTypeKind4["ZodUndefined"] = "ZodUndefined";
  ZodFirstPartyTypeKind4["ZodNull"] = "ZodNull";
  ZodFirstPartyTypeKind4["ZodAny"] = "ZodAny";
  ZodFirstPartyTypeKind4["ZodUnknown"] = "ZodUnknown";
  ZodFirstPartyTypeKind4["ZodNever"] = "ZodNever";
  ZodFirstPartyTypeKind4["ZodVoid"] = "ZodVoid";
  ZodFirstPartyTypeKind4["ZodArray"] = "ZodArray";
  ZodFirstPartyTypeKind4["ZodObject"] = "ZodObject";
  ZodFirstPartyTypeKind4["ZodUnion"] = "ZodUnion";
  ZodFirstPartyTypeKind4["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
  ZodFirstPartyTypeKind4["ZodIntersection"] = "ZodIntersection";
  ZodFirstPartyTypeKind4["ZodTuple"] = "ZodTuple";
  ZodFirstPartyTypeKind4["ZodRecord"] = "ZodRecord";
  ZodFirstPartyTypeKind4["ZodMap"] = "ZodMap";
  ZodFirstPartyTypeKind4["ZodSet"] = "ZodSet";
  ZodFirstPartyTypeKind4["ZodFunction"] = "ZodFunction";
  ZodFirstPartyTypeKind4["ZodLazy"] = "ZodLazy";
  ZodFirstPartyTypeKind4["ZodLiteral"] = "ZodLiteral";
  ZodFirstPartyTypeKind4["ZodEnum"] = "ZodEnum";
  ZodFirstPartyTypeKind4["ZodEffects"] = "ZodEffects";
  ZodFirstPartyTypeKind4["ZodNativeEnum"] = "ZodNativeEnum";
  ZodFirstPartyTypeKind4["ZodOptional"] = "ZodOptional";
  ZodFirstPartyTypeKind4["ZodNullable"] = "ZodNullable";
  ZodFirstPartyTypeKind4["ZodDefault"] = "ZodDefault";
  ZodFirstPartyTypeKind4["ZodCatch"] = "ZodCatch";
  ZodFirstPartyTypeKind4["ZodPromise"] = "ZodPromise";
  ZodFirstPartyTypeKind4["ZodBranded"] = "ZodBranded";
  ZodFirstPartyTypeKind4["ZodPipeline"] = "ZodPipeline";
  ZodFirstPartyTypeKind4["ZodReadonly"] = "ZodReadonly";
})(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {}));
var instanceOfType = (cls, params = {
  message: `Input not instance of ${cls.name}`
}) => custom2((data) => data instanceof cls, params);
var stringType2 = ZodString3.create;
var numberType2 = ZodNumber3.create;
var nanType2 = ZodNaN2.create;
var bigIntType2 = ZodBigInt2.create;
var booleanType2 = ZodBoolean3.create;
var dateType2 = ZodDate2.create;
var symbolType2 = ZodSymbol2.create;
var undefinedType2 = ZodUndefined2.create;
var nullType2 = ZodNull3.create;
var anyType2 = ZodAny2.create;
var unknownType2 = ZodUnknown3.create;
var neverType2 = ZodNever3.create;
var voidType2 = ZodVoid2.create;
var arrayType2 = ZodArray3.create;
var objectType2 = ZodObject3.create;
var strictObjectType2 = ZodObject3.strictCreate;
var unionType2 = ZodUnion3.create;
var discriminatedUnionType2 = ZodDiscriminatedUnion3.create;
var intersectionType2 = ZodIntersection3.create;
var tupleType2 = ZodTuple2.create;
var recordType2 = ZodRecord3.create;
var mapType2 = ZodMap2.create;
var setType2 = ZodSet2.create;
var functionType2 = ZodFunction2.create;
var lazyType2 = ZodLazy2.create;
var literalType2 = ZodLiteral3.create;
var enumType2 = ZodEnum3.create;
var nativeEnumType2 = ZodNativeEnum2.create;
var promiseType2 = ZodPromise2.create;
var effectsType2 = ZodEffects2.create;
var optionalType2 = ZodOptional3.create;
var nullableType2 = ZodNullable3.create;
var preprocessType2 = ZodEffects2.createWithPreprocess;
var pipelineType2 = ZodPipeline2.create;
var ostring = () => stringType2().optional();
var onumber = () => numberType2().optional();
var oboolean = () => booleanType2().optional();
var coerce = {
  string: ((arg) => ZodString3.create({ ...arg, coerce: true })),
  number: ((arg) => ZodNumber3.create({ ...arg, coerce: true })),
  boolean: ((arg) => ZodBoolean3.create({
    ...arg,
    coerce: true
  })),
  bigint: ((arg) => ZodBigInt2.create({ ...arg, coerce: true })),
  date: ((arg) => ZodDate2.create({ ...arg, coerce: true }))
};
var NEVER2 = INVALID2;
var z = /* @__PURE__ */ Object.freeze({
  __proto__: null,
  defaultErrorMap: errorMap2,
  setErrorMap,
  getErrorMap: getErrorMap2,
  makeIssue: makeIssue2,
  EMPTY_PATH,
  addIssueToContext: addIssueToContext2,
  ParseStatus: ParseStatus2,
  INVALID: INVALID2,
  DIRTY: DIRTY2,
  OK: OK2,
  isAborted: isAborted2,
  isDirty: isDirty2,
  isValid: isValid2,
  isAsync: isAsync2,
  get util() {
    return util2;
  },
  get objectUtil() {
    return objectUtil2;
  },
  ZodParsedType: ZodParsedType2,
  getParsedType: getParsedType3,
  ZodType: ZodType3,
  datetimeRegex: datetimeRegex2,
  ZodString: ZodString3,
  ZodNumber: ZodNumber3,
  ZodBigInt: ZodBigInt2,
  ZodBoolean: ZodBoolean3,
  ZodDate: ZodDate2,
  ZodSymbol: ZodSymbol2,
  ZodUndefined: ZodUndefined2,
  ZodNull: ZodNull3,
  ZodAny: ZodAny2,
  ZodUnknown: ZodUnknown3,
  ZodNever: ZodNever3,
  ZodVoid: ZodVoid2,
  ZodArray: ZodArray3,
  ZodObject: ZodObject3,
  ZodUnion: ZodUnion3,
  ZodDiscriminatedUnion: ZodDiscriminatedUnion3,
  ZodIntersection: ZodIntersection3,
  ZodTuple: ZodTuple2,
  ZodRecord: ZodRecord3,
  ZodMap: ZodMap2,
  ZodSet: ZodSet2,
  ZodFunction: ZodFunction2,
  ZodLazy: ZodLazy2,
  ZodLiteral: ZodLiteral3,
  ZodEnum: ZodEnum3,
  ZodNativeEnum: ZodNativeEnum2,
  ZodPromise: ZodPromise2,
  ZodEffects: ZodEffects2,
  ZodTransformer: ZodEffects2,
  ZodOptional: ZodOptional3,
  ZodNullable: ZodNullable3,
  ZodDefault: ZodDefault3,
  ZodCatch: ZodCatch3,
  ZodNaN: ZodNaN2,
  BRAND: BRAND2,
  ZodBranded: ZodBranded2,
  ZodPipeline: ZodPipeline2,
  ZodReadonly: ZodReadonly3,
  custom: custom2,
  Schema: ZodType3,
  ZodSchema: ZodType3,
  late: late2,
  get ZodFirstPartyTypeKind() {
    return ZodFirstPartyTypeKind2;
  },
  coerce,
  any: anyType2,
  array: arrayType2,
  bigint: bigIntType2,
  boolean: booleanType2,
  date: dateType2,
  discriminatedUnion: discriminatedUnionType2,
  effect: effectsType2,
  "enum": enumType2,
  "function": functionType2,
  "instanceof": instanceOfType,
  intersection: intersectionType2,
  lazy: lazyType2,
  literal: literalType2,
  map: mapType2,
  nan: nanType2,
  nativeEnum: nativeEnumType2,
  never: neverType2,
  "null": nullType2,
  nullable: nullableType2,
  number: numberType2,
  object: objectType2,
  oboolean,
  onumber,
  optional: optionalType2,
  ostring,
  pipeline: pipelineType2,
  preprocess: preprocessType2,
  promise: promiseType2,
  record: recordType2,
  set: setType2,
  strictObject: strictObjectType2,
  string: stringType2,
  symbol: symbolType2,
  transformer: effectsType2,
  tuple: tupleType2,
  "undefined": undefinedType2,
  union: unionType2,
  unknown: unknownType2,
  "void": voidType2,
  NEVER: NEVER2,
  ZodIssueCode: ZodIssueCode2,
  quotelessJson,
  ZodError: ZodError3
});

// packages/board-schema/src/protocol-version.ts
var PROTOCOL_VERSION = 1;
var PROTOCOL_SEMVER = "1.0.0";
var ProtocolVersionSchemaV1 = z.literal(PROTOCOL_VERSION);

// packages/board-schema/src/catalogs.ts
var NODE_TYPES_V1 = [
  "layout.split",
  "layout.grid",
  "layout.tabs",
  "layout.canvas",
  "content.markdown",
  "content.code",
  "content.table",
  "content.chart",
  "content.map",
  "content.drawing",
  "content.status",
  "content.image",
  "content.progress",
  "content.hitl",
  "content.artifact"
];
var BOARD_MUTATION_COMMAND_TYPES_V1 = [
  "scene.replace",
  "scene.clear",
  "scene.restore",
  "hitl.request",
  "hitl.respond",
  "artifact.publish",
  "artifact.stop"
];
var BOARD_MUTATION_COMMAND_TYPES_V2 = [
  ...BOARD_MUTATION_COMMAND_TYPES_V1,
  "document.replace"
];
var BOARD_OPERATION_TYPES_V1 = [
  "board.list",
  "board.get",
  "board.create",
  "board.archive",
  "capabilities.get",
  "history.list",
  "history.get",
  "artifact.get",
  "hitl.read"
];
var BOARD_EVENT_TYPES_V1 = [
  "board.snapshot",
  "board.revision.created",
  "hitl.updated",
  "artifact.status.changed",
  "presence.updated",
  "stream.resync.required",
  "stream.heartbeat",
  "stream.error"
];
var CLIENT_GRANT_CAPABILITIES_V1 = [
  "artifact.control",
  "artifact.publish",
  "board.history.read",
  "board.hitl.request",
  "board.hitl.respond",
  "board.media.write",
  "board.read",
  "board.write"
];
var ACCOUNT_API_KEY_SCOPES_V1 = [
  "artifact:control",
  "artifact:publish",
  "board:archive",
  "board:create",
  "board:hitl:request",
  "board:hitl:respond",
  "board:media:write",
  "board:read",
  "board:write",
  "export:read",
  "history:read"
];
var ACCOUNT_API_KEY_SCOPE_BITS_V1 = {
  "artifact:control": 1 << 6,
  "artifact:publish": 1 << 7,
  "board:archive": 1 << 0,
  "board:create": 1 << 1,
  "board:hitl:request": 1 << 8,
  "board:hitl:respond": 1 << 9,
  "board:media:write": 1 << 10,
  "board:read": 1 << 2,
  "board:write": 1 << 3,
  "export:read": 1 << 4,
  "history:read": 1 << 5
};
var ACCOUNT_API_KEY_SCOPE_MASK_MAX_V1 = Object.values(
  ACCOUNT_API_KEY_SCOPE_BITS_V1
).reduce((mask, bit) => mask | bit, 0);
var CLIENT_GRANT_SCOPE_ORDER_V1 = [
  "board.read",
  "board.write",
  "board.history.read",
  "board.hitl.request",
  "board.hitl.respond",
  "board.media.write",
  "artifact.publish",
  "artifact.control"
];
var BOARD_AUTHORIZATION_CAPABILITIES_V1 = [
  "account.board.create",
  "artifact.control",
  "artifact.publish",
  "board.admin",
  "board.analytics.read",
  "board.history.read",
  "board.hitl.request",
  "board.hitl.respond",
  "board.media.write",
  "board.members.manage",
  "board.read",
  "board.share.manage",
  "board.write",
  "connection.manage.own",
  "export.read"
];
var BOARD_AUTHORIZATION_OPERATION_TYPES_V1 = [
  "board.list",
  "board.get",
  "capabilities.get",
  "artifact.get",
  "hitl.read",
  "history.list",
  "history.get",
  "board.create",
  "board.rename",
  "document.replace",
  "page.add",
  "page.update",
  "page.remove",
  "page.reorder",
  "page.default.set",
  "scene.replace",
  "scene.clear",
  "scene.restore",
  "hitl.request",
  "hitl.respond",
  "artifact.publish",
  "artifact.stop",
  "connection.create",
  "connection.update",
  "connection.revoke",
  "board.archive",
  "board.delete",
  "membership.list",
  "membership.invite",
  "membership.role.update",
  "membership.remove",
  "ownership.transfer",
  "share.list",
  "share.publish",
  "share.update",
  "share.rotate",
  "share.revoke",
  "share.password.enable",
  "share.password.regenerate",
  "share.password.disable",
  "media.upload",
  "analytics.report.get",
  "export.render"
];
var SHARE_STATUSES_V1 = ["active", "revoked", "archived"];
var SHARE_ACCESS_POLICIES_V1 = ["L", "P"];
var SHARE_MANAGEMENT_OPERATION_TYPES_V1 = [
  "create",
  "republish",
  "update",
  "rotate",
  "revoke",
  "password.enable",
  "password.regenerate",
  "password.disable"
];
var SHARE_ERROR_CODES_V1 = [
  "INVALID_REQUEST",
  "UNAUTHENTICATED",
  "BOARD_NOT_FOUND",
  "SHARE_STATE_CONFLICT",
  "SHARE_GENERATION_EXHAUSTED",
  "IDEMPOTENCY_KEY_REUSED",
  "SHARE_PASSWORD_ALREADY_ENABLED",
  "SHARE_PASSWORD_STATE_CONFLICT",
  "SHARE_PASSWORD_LOCKED",
  "RATE_LIMITED",
  "SERVICE_UNAVAILABLE"
];
var BOARD_AUTHORIZATION_SURFACES_V1 = ["browser", "mcp", "account_api_key"];
var BOARD_MEMBERSHIP_ROLES_V1 = ["owner", "editor", "viewer"];
var BOARD_MEMBERSHIP_STATES_V1 = ["active", "inactive"];
var ARTIFACT_REQUEST_CAPABILITIES_V1 = [
  "clipboard.write",
  "download",
  "fullscreen",
  "network.fetch"
];
var HITL_KINDS_V1 = ["info", "choice", "form", "confirmation"];
var BOARD_ERROR_CODES_V1 = [
  "INVALID_PAYLOAD",
  "PROTOCOL_VERSION_MISMATCH",
  "UNKNOWN_NODE_TYPE",
  "UNKNOWN_COMMAND_TYPE",
  "UNKNOWN_OPERATION_TYPE",
  "INVALID_LAYOUT",
  "DUPLICATE_NODE_ID",
  "LIMIT_EXCEEDED",
  "PAYLOAD_TOO_LARGE",
  "UNAUTHENTICATED",
  "FORBIDDEN",
  "CAPABILITY_DENIED",
  "BOARD_NOT_FOUND",
  "REVISION_NOT_FOUND",
  "ARTIFACT_NOT_FOUND",
  "HITL_REQUEST_NOT_FOUND",
  "BOARD_ALREADY_ARCHIVED",
  "REVISION_CONFLICT",
  "IDEMPOTENCY_KEY_REUSED",
  "HITL_REQUEST_ID_CONFLICT",
  "HITL_RESPONSE_CONFLICT",
  "HITL_REQUEST_EXPIRED",
  "RATE_LIMITED",
  "SERVICE_UNAVAILABLE",
  "INTERNAL_ERROR"
];
var BOARD_ERROR_CODES_V2 = [
  ...BOARD_ERROR_CODES_V1,
  "DOCUMENT_VERSION_MISMATCH",
  "IDEMPOTENCY_RESULT_EXPIRED",
  "INVALID_DOCUMENT",
  "INVALID_MEDIA_UPLOAD",
  "INVALID_MEDIA_REFERENCE",
  "INVALID_REQUEST",
  "METHOD_NOT_ALLOWED",
  "RANGE_NOT_SATISFIABLE"
];
var BOARD_ERROR_CODES_V3 = [...BOARD_ERROR_CODES_V2, "UPGRADE_REQUIRED"];

// packages/board-schema/src/json.ts
var hasLoneSurrogateV1 = (value) => {
  for (let index = 0; index < value.length; index += 1) {
    const code = value.charCodeAt(index);
    if (code >= 55296 && code <= 56319) {
      const next = value.charCodeAt(index + 1);
      if (!Number.isInteger(next) || next < 56320 || next > 57343) return true;
      index += 1;
    } else if (code >= 56320 && code <= 57343) {
      return true;
    }
  }
  return false;
};
var scalarLengthV1 = (value) => Array.from(value).length;
var compareUnicodeScalarsV1 = (left, right) => {
  const leftScalars = Array.from(left, (value) => value.codePointAt(0) ?? 0);
  const rightScalars = Array.from(right, (value) => value.codePointAt(0) ?? 0);
  const count = Math.min(leftScalars.length, rightScalars.length);
  for (let index = 0; index < count; index += 1) {
    const difference = (leftScalars[index] ?? 0) - (rightScalars[index] ?? 0);
    if (difference !== 0) return difference;
  }
  return leftScalars.length - rightScalars.length;
};
var serializeJsonStringV1 = (value) => JSON.stringify(value);
var serializeJsonNumberV1 = (value) => Object.is(value, -0) ? "0" : JSON.stringify(value);

// packages/board-schema/src/limits.ts
var MAX_ENVELOPE_BYTES = 1048576;
var MAX_SCENE_BYTES = 786432;
var MAX_SCENE_DEPTH = 12;
var MAX_SCENE_NODES = 500;
var MAX_JSON_DEPTH = 64;
var MAX_JSON_CONTAINER_ENTRIES = 1e4;
var MAX_SPLIT_CHILDREN = 12;
var MAX_GRID_COLUMNS = 24;
var MAX_GRID_ROWS = 100;
var MAX_GRID_ITEMS = 200;
var MAX_TABS = 20;
var MAX_CANVAS_ITEMS = 200;
var MAX_CANVAS_EXTENT = 1e5;
var MAX_TITLE_CHARS = 200;
var MAX_IMAGE_ALT_CHARS = 500;
var MAX_MARKDOWN_CHARS = 1e5;
var MAX_CODE_CHARS = 2e5;
var MAX_TABLE_COLUMNS = 50;
var MAX_TABLE_ROWS = 500;
var MAX_TABLE_CELLS = 1e4;
var MAX_CHART_SERIES = 32;
var MAX_CHART_POINTS = 1e4;
var MAX_MAP_FEATURES = 5e3;
var MAX_DRAWING_ELEMENTS = 5e3;
var MAX_ARTIFACT_RESOURCES = 128;
var MAX_ARTIFACT_RESOURCE_BYTES = 5242880;
var MAX_ARTIFACT_TOTAL_BYTES = 10485760;
var MAX_BOARD_ARTIFACTS = 100;
var MAX_BOARD_ARTIFACT_VERSIONS = 1e3;
var MAX_BOARD_ARTIFACT_RESOURCE_ROWS = 1e4;
var MAX_BOARD_ARTIFACT_CHARGED_BYTES = 536870912;
var MAX_HITL_OPTIONS = 50;
var MAX_HITL_FIELDS = 50;
var MAX_HITL_TEXT_CHARS = 6e4;
var MAX_HITL_RESPONSE_BYTES = 65536;
var MAX_PAGE_SIZE = 100;
var MAX_PAGE_CURSOR_CHARS = 512;
var MAX_HITL_WAIT_MS = 3e4;
var MAX_DOCUMENT_PAGES = 100;
var MAX_DOCUMENT_BYTES = 20971520;
var MAX_DOCUMENT_PAGE_BYTES = 1048576;
var MAX_DOCUMENT_NODES = 5e3;
var MAX_DOCUMENT_ENVELOPE_BYTES = 33554432;
var MAX_MEDIA_BYTES = 10485760;
var MAX_MEDIA_PIXELS = 4e7;
var MAX_BOARD_MEDIA_BYTES = 536870912;
var MAX_MEDIA_REFERENCES = 5e3;
var MAX_ARTIFACT_REFERENCE_OCCURRENCES = 500;
var BOARD_LIMITS_V1 = {
  maxEnvelopeBytes: MAX_ENVELOPE_BYTES,
  maxSceneBytes: MAX_SCENE_BYTES,
  maxSceneDepth: MAX_SCENE_DEPTH,
  maxSceneNodes: MAX_SCENE_NODES,
  maxJsonDepth: MAX_JSON_DEPTH,
  maxJsonContainerEntries: MAX_JSON_CONTAINER_ENTRIES,
  maxSplitChildren: MAX_SPLIT_CHILDREN,
  maxGridColumns: MAX_GRID_COLUMNS,
  maxGridRows: MAX_GRID_ROWS,
  maxGridItems: MAX_GRID_ITEMS,
  maxTabs: MAX_TABS,
  maxCanvasItems: MAX_CANVAS_ITEMS,
  maxCanvasExtent: MAX_CANVAS_EXTENT,
  maxTitleChars: MAX_TITLE_CHARS,
  maxImageAltChars: MAX_IMAGE_ALT_CHARS,
  maxMarkdownChars: MAX_MARKDOWN_CHARS,
  maxCodeChars: MAX_CODE_CHARS,
  maxTableColumns: MAX_TABLE_COLUMNS,
  maxTableRows: MAX_TABLE_ROWS,
  maxTableCells: MAX_TABLE_CELLS,
  maxChartSeries: MAX_CHART_SERIES,
  maxChartPoints: MAX_CHART_POINTS,
  maxMapFeatures: MAX_MAP_FEATURES,
  maxDrawingElements: MAX_DRAWING_ELEMENTS,
  maxArtifactResources: MAX_ARTIFACT_RESOURCES,
  maxArtifactResourceBytes: MAX_ARTIFACT_RESOURCE_BYTES,
  maxArtifactTotalBytes: MAX_ARTIFACT_TOTAL_BYTES,
  maxBoardArtifacts: MAX_BOARD_ARTIFACTS,
  maxBoardArtifactVersions: MAX_BOARD_ARTIFACT_VERSIONS,
  maxBoardArtifactResourceRows: MAX_BOARD_ARTIFACT_RESOURCE_ROWS,
  maxBoardArtifactChargedBytes: MAX_BOARD_ARTIFACT_CHARGED_BYTES,
  maxHitlOptions: MAX_HITL_OPTIONS,
  maxHitlFields: MAX_HITL_FIELDS,
  maxHitlTextChars: MAX_HITL_TEXT_CHARS,
  maxHitlResponseBytes: MAX_HITL_RESPONSE_BYTES,
  maxPageSize: MAX_PAGE_SIZE,
  maxPageCursorChars: MAX_PAGE_CURSOR_CHARS,
  maxHitlWaitMs: MAX_HITL_WAIT_MS
};
var BOARD_DOCUMENT_LIMITS_V2 = {
  ...BOARD_LIMITS_V1,
  maxDocumentPages: MAX_DOCUMENT_PAGES,
  maxDocumentBytes: MAX_DOCUMENT_BYTES,
  maxDocumentPageBytes: MAX_DOCUMENT_PAGE_BYTES,
  maxDocumentNodes: MAX_DOCUMENT_NODES,
  maxDocumentEnvelopeBytes: MAX_DOCUMENT_ENVELOPE_BYTES,
  maxMediaBytes: MAX_MEDIA_BYTES,
  maxMediaPixels: MAX_MEDIA_PIXELS,
  maxBoardMediaBytes: MAX_BOARD_MEDIA_BYTES,
  maxMediaReferences: MAX_MEDIA_REFERENCES
};
var BOARD_DOCUMENT_LIMITS_V3 = {
  ...BOARD_DOCUMENT_LIMITS_V2,
  maxArtifactReferenceOccurrences: MAX_ARTIFACT_REFERENCE_OCCURRENCES
};

// packages/board-schema/src/identifiers.ts
var GLOBAL_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
var LOCAL_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
var TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
var GlobalIdStringSchemaV1 = z.string().regex(GLOBAL_ID_PATTERN);
var globalId = (_name) => GlobalIdStringSchemaV1.brand();
var BoardIdSchemaV1 = globalId("BoardId");
var RevisionIdSchemaV1 = globalId("RevisionId");
var RequestIdSchemaV1 = globalId("RequestId");
var PrincipalIdSchemaV1 = globalId("PrincipalId");
var GrantIdSchemaV1 = globalId("GrantId");
var EventIdSchemaV1 = globalId("EventId");
var ArtifactIdSchemaV1 = globalId("ArtifactId");
var ArtifactVersionIdSchemaV1 = globalId("ArtifactVersionId");
var MediaIdSchemaV1 = globalId("MediaId");
var HitlRequestIdSchemaV1 = globalId("HitlRequestId");
var PageIdSchemaV1 = globalId("PageId");
var NodeIdSchemaV1 = z.string().regex(LOCAL_ID_PATTERN).brand();
var TabIdSchemaV1 = z.string().regex(LOCAL_ID_PATTERN).brand();
var LocalFieldIdSchemaV1 = z.string().regex(LOCAL_ID_PATTERN).brand();
var IdempotencyKeySchemaV1 = z.string().min(16).max(128).regex(/^[A-Za-z0-9._:-]+$/).brand();
var TimestampSchemaV1 = z.string().regex(TIMESTAMP_PATTERN).refine((value) => {
  const instant = Date.parse(value);
  return Number.isFinite(instant) && new Date(instant).toISOString() === value;
}).brand();
var createScalarTextSchemaV1 = (minimum, maximum) => z.string().refine((value) => !hasLoneSurrogateV1(value), "lone surrogate is not allowed").refine((value) => {
  const count = scalarLengthV1(value);
  return count >= minimum && count <= maximum;
}, `must contain ${minimum}-${maximum} Unicode scalar values`);
var ShortTextSchemaV1 = z.string().refine((value) => !hasLoneSurrogateV1(value), "lone surrogate is not allowed").refine((value) => scalarLengthV1(value) >= 1, "must contain at least one Unicode scalar value").refine(
  (value) => scalarLengthV1(value) <= MAX_TITLE_CHARS,
  "[LIMIT:maxTitleChars] text is too long"
);
var ContentTextSchemaV1 = z.string().refine((value) => !hasLoneSurrogateV1(value), "lone surrogate is not allowed").refine(
  (value) => scalarLengthV1(value) <= MAX_CODE_CHARS,
  "[LIMIT:maxCodeChars] text is too long"
);
var RevisionOriginTypeSchemaV1 = z.enum([
  "board.create",
  "scene.replace",
  "scene.clear",
  "scene.restore",
  "document.replace"
]);
var RevisionSummarySchemaV1 = z.object({
  revisionId: RevisionIdSchemaV1,
  revisionNumber: z.number().int().safe().positive(),
  createdAt: TimestampSchemaV1
}).strict();

// packages/board-schema/src/actors.ts
var ClientGrantCapabilitySchemaV1 = z.enum(CLIENT_GRANT_CAPABILITIES_V1);
var isSortedUniqueScopesV1 = (scopes) => scopes.every((scope, index) => index === 0 || (scopes[index - 1] ?? "") < scope);
var ActorContextSchemaV1 = z.object({
  principalKind: z.enum(["user", "mcp_client", "service"]),
  principalId: PrincipalIdSchemaV1,
  grantId: GrantIdSchemaV1.nullable(),
  scopes: z.array(ClientGrantCapabilitySchemaV1).superRefine((scopes, context) => {
    if (!isSortedUniqueScopesV1(scopes)) {
      context.addIssue({
        code: z.ZodIssueCode.custom,
        message: "scopes must be sorted and unique"
      });
    }
  })
}).strict();
var ActorReferenceSchemaV1 = z.object({
  principalKind: z.enum(["user", "mcp_client", "service"]),
  principalId: PrincipalIdSchemaV1
}).strict();

// packages/board-schema/src/memberships.ts
var BoardMembershipSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("board.membership"),
  membershipId: GlobalIdStringSchemaV1,
  boardId: BoardIdSchemaV1,
  accountId: PrincipalIdSchemaV1,
  role: z.enum(BOARD_MEMBERSHIP_ROLES_V1),
  state: z.enum(BOARD_MEMBERSHIP_STATES_V1),
  version: z.number().int().safe().positive(),
  createdAt: TimestampSchemaV1,
  updatedAt: TimestampSchemaV1
}).strict().superRefine((membership, context) => {
  if (membership.updatedAt < membership.createdAt)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["updatedAt"],
      message: "membership update must not predate creation"
    });
});
var BoardAuthorizationPrincipalSchemaV1 = z.discriminatedUnion("kind", [
  z.object({
    kind: z.literal("account"),
    accountId: PrincipalIdSchemaV1
  }).strict(),
  z.object({
    kind: z.literal("share_viewer"),
    shareId: GlobalIdStringSchemaV1
  }).strict()
]);

// packages/board-schema/src/shares.ts
var ShareStatusSchemaV1 = z.enum(SHARE_STATUSES_V1);
var ShareAccessPolicySchemaV1 = z.enum(SHARE_ACCESS_POLICIES_V1);
var ShareManagementOperationSchemaV1 = z.enum(SHARE_MANAGEMENT_OPERATION_TYPES_V1);
var ShareIdempotencyKeySchemaV1 = z.string().min(16).max(128).regex(/^[\x20-\x7e]+$/u);
var ShareLinkTokenSchemaV1 = z.string().regex(/^[A-Za-z0-9_-]{43}$/u);
var ShareManagementViewSchemaV1 = z.object({
  shareId: GlobalIdStringSchemaV1,
  status: ShareStatusSchemaV1,
  accessPolicy: ShareAccessPolicySchemaV1,
  pinnedRevisionId: RevisionIdSchemaV1,
  publicationGeneration: z.number().int().safe().positive(),
  accessGeneration: z.number().int().safe().positive(),
  version: z.number().int().safe().positive(),
  createdAt: TimestampSchemaV1,
  updatedAt: TimestampSchemaV1
}).strict();
var ShareListResultSchemaV1 = z.object({ shares: z.array(ShareManagementViewSchemaV1).max(1) }).strict();
var SharePublishRequestSchemaV1 = z.object({ pinnedRevisionId: RevisionIdSchemaV1 }).strict();
var ShareUpdateRequestSchemaV1 = z.object({
  pinnedRevisionId: RevisionIdSchemaV1,
  expectedVersion: z.number().int().safe().positive()
}).strict();
var ShareVersionRequestSchemaV1 = z.object({ expectedVersion: z.number().int().safe().positive() }).strict();
var SharePasswordAdmissionRequestSchemaV1 = z.object({ password: z.string().min(1).max(128) }).strict();
var ShareFingerprintInputSchemaV1 = z.object({
  operation: ShareManagementOperationSchemaV1,
  shareId: GlobalIdStringSchemaV1.nullable(),
  expectedVersion: z.number().int().safe().positive().nullable(),
  pinnedRevisionId: RevisionIdSchemaV1.nullable()
}).strict();
var ShareSecretReplayResultSchemaV1 = z.object({
  status: z.enum(["already-created", "already-republished", "already-rotated"]),
  shareId: GlobalIdStringSchemaV1,
  copySecretAvailable: z.literal(false),
  rotateRequired: z.literal(true)
}).strict();
var SharePublishSuccessSchemaV1 = z.object({
  status: z.enum(["created", "republished"]),
  share: ShareManagementViewSchemaV1,
  linkToken: ShareLinkTokenSchemaV1
}).strict();
var ShareRotateSuccessSchemaV1 = z.object({
  status: z.literal("rotated"),
  share: ShareManagementViewSchemaV1,
  linkToken: ShareLinkTokenSchemaV1
}).strict();
var ShareUpdateSuccessSchemaV1 = z.object({
  status: z.enum(["updated", "unchanged"]),
  share: ShareManagementViewSchemaV1
}).strict();
var SharePasswordSuccessSchemaV1 = z.object({
  status: z.enum(["enabled", "regenerated"]),
  share: ShareManagementViewSchemaV1,
  password: z.string().regex(/^[23456789ABCDEFGHJKLMNPQRSTUVWXYZ]{24}$/u)
}).strict();
var SharePasswordReplayResultSchemaV1 = z.object({
  status: z.enum(["already-enabled", "already-regenerated"]),
  shareId: GlobalIdStringSchemaV1,
  copySecretAvailable: z.literal(false),
  regenerateRequired: z.literal(true)
}).strict();
var ShareErrorBaseShapeV1 = {
  code: z.enum(SHARE_ERROR_CODES_V1),
  message: z.string().min(1).max(256),
  requestId: GlobalIdStringSchemaV1
};
var ShareErrorSchemaV1 = z.union([
  z.object({
    ...ShareErrorBaseShapeV1,
    code: z.literal("INVALID_REQUEST"),
    details: z.object({ reason: z.enum(["body", "csrf"]) }).strict()
  }).strict(),
  z.object({
    ...ShareErrorBaseShapeV1,
    code: z.enum(
      SHARE_ERROR_CODES_V1.filter(
        (code) => code !== "INVALID_REQUEST"
      )
    )
  }).strict()
]);
var ShareErrorEnvelopeSchemaV1 = z.object({ error: ShareErrorSchemaV1 }).strict();

// packages/board-schema/src/media.ts
var MAX_MEDIA_ALT_CHARS = 500;
var MAX_MEDIA_CAPTION_CHARS = 500;
var MediaAltSchemaV1 = createScalarTextSchemaV1(1, MAX_MEDIA_ALT_CHARS);
var MediaCaptionSchemaV1 = createScalarTextSchemaV1(1, MAX_MEDIA_CAPTION_CHARS);
var MediaSourceSchemaV1 = z.object({
  type: z.literal("media"),
  mediaId: MediaIdSchemaV1
}).strict();
var MEDIA_MIME_TYPES_V1 = ["image/png", "image/jpeg", "image/webp"];
var MediaMimeSchemaV1 = z.enum(MEDIA_MIME_TYPES_V1);
var MediaSha256SchemaV1 = z.string().regex(/^[0-9a-f]{64}$/u);
var MediaIngestResultSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("media.ingest.result"),
  requestId: RequestIdSchemaV1,
  status: z.enum(["created", "replayed"]),
  media: z.object({
    mediaId: MediaIdSchemaV1,
    sha256: MediaSha256SchemaV1,
    mime: MediaMimeSchemaV1,
    width: z.number().int().positive().max(16384),
    height: z.number().int().positive().max(16384),
    bytes: z.number().int().positive().max(MAX_MEDIA_BYTES)
  }).strict()
}).strict();

// packages/board-schema/src/nodes/base.ts
var NodeBaseShapeV1 = {
  id: NodeIdSchemaV1,
  title: ShortTextSchemaV1.optional()
};
var PointSchemaV1 = z.object({ x: z.number().finite(), y: z.number().finite() }).strict();

// packages/board-schema/src/nodes/drawing.ts
var color = z.string().regex(/^#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/);
var DrawingStyleSchemaV1 = z.object({
  stroke: color.optional(),
  fill: color.optional(),
  strokeWidth: z.number().finite().positive().optional(),
  opacity: z.number().finite().min(0).max(1).optional()
}).strict();
var PathSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("path"),
  points: z.array(PointSchemaV1).min(2),
  closed: z.boolean(),
  style: DrawingStyleSchemaV1
}).strict();
var RectSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("rect"),
  x: z.number().finite(),
  y: z.number().finite(),
  width: z.number().finite().positive(),
  height: z.number().finite().positive(),
  style: DrawingStyleSchemaV1
}).strict();
var EllipseSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("ellipse"),
  cx: z.number().finite(),
  cy: z.number().finite(),
  rx: z.number().finite().positive(),
  ry: z.number().finite().positive(),
  style: DrawingStyleSchemaV1
}).strict();
var LineSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("line"),
  from: PointSchemaV1,
  to: PointSchemaV1,
  style: DrawingStyleSchemaV1
}).strict();
var TextSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("text"),
  x: z.number().finite(),
  y: z.number().finite(),
  text: ShortTextSchemaV1,
  style: DrawingStyleSchemaV1
}).strict();
var DrawingElementSchemaV1 = z.discriminatedUnion("type", [
  PathSchemaV1,
  RectSchemaV1,
  EllipseSchemaV1,
  LineSchemaV1,
  TextSchemaV1
]);
var DrawingNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.drawing"),
  viewBox: z.object({
    x: z.number().finite(),
    y: z.number().finite(),
    width: z.number().finite().positive(),
    height: z.number().finite().positive()
  }).strict(),
  elements: z.array(DrawingElementSchemaV1).max(MAX_DRAWING_ELEMENTS)
}).strict();

// packages/board-schema/src/artifacts.ts
var ArtifactRequestCapabilitySchemaV1 = z.enum(ARTIFACT_REQUEST_CAPABILITIES_V1);
var BoardErrorCodeSchemaV1 = z.enum(BOARD_ERROR_CODES_V1);
var isNormalizedArtifactPathV1 = (path) => path.length > 0 && !path.startsWith("/") && !path.includes("\\") && !path.includes("\0") && path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
var ArtifactPathSchemaV1 = z.string().refine(isNormalizedArtifactPathV1, "artifact path must be normalized");
var ArtifactDigestSchemaV1 = z.string().regex(/^[0-9a-f]{64}$/);
var ArtifactReferenceSchemaV1 = z.object({
  artifactId: ArtifactIdSchemaV1,
  versionId: ArtifactVersionIdSchemaV1
}).strict();
var ArtifactResourceSchemaV1 = z.object({
  path: ArtifactPathSchemaV1,
  mediaType: z.string().regex(/^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]{1,127}$/),
  sha256: ArtifactDigestSchemaV1,
  byteLength: z.number().int().safe().min(0).max(MAX_ARTIFACT_RESOURCE_BYTES)
}).strict();
var ArtifactManifestSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("artifact.manifest"),
  artifact: ArtifactReferenceSchemaV1,
  entryPath: ArtifactPathSchemaV1,
  resources: z.array(ArtifactResourceSchemaV1).min(1).max(MAX_ARTIFACT_RESOURCES),
  requestedCapabilities: z.array(ArtifactRequestCapabilitySchemaV1).max(ARTIFACT_REQUEST_CAPABILITIES_V1.length)
}).strict().superRefine((manifest, context) => {
  const paths = /* @__PURE__ */ new Set();
  let totalBytes = 0;
  for (let index = 0; index < manifest.resources.length; index += 1) {
    const resource = manifest.resources[index];
    if (!resource) continue;
    if (paths.has(resource.path))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["resources", index, "path"],
        message: "duplicate artifact resource path"
      });
    paths.add(resource.path);
    totalBytes += resource.byteLength;
  }
  if (!paths.has(manifest.entryPath))
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["entryPath"],
      message: "entryPath must reference a resource"
    });
  if (totalBytes > MAX_ARTIFACT_TOTAL_BYTES)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["resources"],
      message: "[LIMIT:maxArtifactTotalBytes] artifact total bytes exceeded"
    });
  for (let index = 0; index < manifest.requestedCapabilities.length; index += 1) {
    if (index > 0 && (manifest.requestedCapabilities[index - 1] ?? "") >= (manifest.requestedCapabilities[index] ?? "")) {
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["requestedCapabilities"],
        message: "requestedCapabilities must be sorted and unique"
      });
      break;
    }
  }
});
var ArtifactRuntimeSummarySchemaV1 = z.object({
  artifact: ArtifactReferenceSchemaV1,
  status: z.enum(["ready", "running", "stopped", "failed", "blocked"]),
  updatedAt: TimestampSchemaV1,
  failure: z.object({ code: BoardErrorCodeSchemaV1, message: ShortTextSchemaV1 }).strict().nullable()
}).strict().superRefine((summary2, context) => {
  const requiresFailure = summary2.status === "failed" || summary2.status === "blocked";
  if (requiresFailure !== (summary2.failure !== null))
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["failure"],
      message: "failure must match artifact status"
    });
});

// packages/board-schema/src/nodes/geojson.ts
var PositionSchemaV1 = z.tuple([
  z.number().finite().min(-180).max(180),
  z.number().finite().min(-90).max(90)
]);
var PointGeometrySchemaV1 = z.object({ type: z.literal("Point"), coordinates: PositionSchemaV1 }).strict();
var LineGeometrySchemaV1 = z.object({ type: z.literal("LineString"), coordinates: z.array(PositionSchemaV1).min(2) }).strict();
var PolygonGeometrySchemaV1 = z.object({
  type: z.literal("Polygon"),
  coordinates: z.array(z.array(PositionSchemaV1).min(4)).min(1)
}).strict();
var GeoJsonGeometrySchemaV1 = z.discriminatedUnion("type", [
  PointGeometrySchemaV1,
  LineGeometrySchemaV1,
  PolygonGeometrySchemaV1
]);
var GeoJsonFeatureCollectionSchemaV1 = z.object({
  type: z.literal("FeatureCollection"),
  features: z.array(
    z.object({
      type: z.literal("Feature"),
      id: z.union([z.string(), z.number().finite()]).optional(),
      properties: z.record(z.unknown()),
      geometry: GeoJsonGeometrySchemaV1
    }).strict()
  ).max(MAX_MAP_FEATURES)
}).strict();

// packages/board-schema/src/nodes/content.ts
var MarkdownTextSchemaV1 = ContentTextSchemaV1.refine(
  (value) => scalarLengthV1(value) <= MAX_MARKDOWN_CHARS,
  "[LIMIT:maxMarkdownChars] markdown text is too long"
);
var CodeTextSchemaV1 = ContentTextSchemaV1.refine(
  (value) => scalarLengthV1(value) <= MAX_CODE_CHARS,
  "[LIMIT:maxCodeChars] code text is too long"
);
var ImageAltSchemaV1 = ContentTextSchemaV1.refine(
  (value) => scalarLengthV1(value) <= MAX_IMAGE_ALT_CHARS,
  "[LIMIT:maxImageAltChars] image alt text is too long"
);
var MarkdownNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.markdown"),
  markdown: MarkdownTextSchemaV1
}).strict();
var CodeNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.code"),
  language: z.string().regex(/^[A-Za-z0-9_+.#-]{1,64}$/),
  code: CodeTextSchemaV1,
  showLineNumbers: z.boolean(),
  wrap: z.boolean()
}).strict();
var TableColumnSchemaV1 = z.object({
  key: LocalFieldIdSchemaV1,
  label: ShortTextSchemaV1,
  valueType: z.enum(["string", "number", "boolean", "datetime"])
}).strict();
var TableCellSchemaV1 = z.union([z.string(), z.number().finite(), z.boolean(), z.null()]);
var TableRowSchemaV1 = z.object({ id: LocalFieldIdSchemaV1, cells: z.record(LocalFieldIdSchemaV1, TableCellSchemaV1) }).strict();
var TableNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.table"),
  columns: z.array(TableColumnSchemaV1).min(1).max(MAX_TABLE_COLUMNS),
  rows: z.array(TableRowSchemaV1).max(MAX_TABLE_ROWS)
}).strict();
var ChartPointSchemaV1 = z.object({ x: z.union([z.string(), z.number().finite()]), y: z.number().finite().nullable() }).strict();
var ChartSeriesSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  label: ShortTextSchemaV1,
  points: z.array(ChartPointSchemaV1).max(MAX_CHART_POINTS)
}).strict();
var ChartNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.chart"),
  chartType: z.enum(["line", "bar", "area", "pie", "scatter"]),
  xAxis: z.object({
    valueType: z.enum(["category", "number", "datetime"]),
    label: ShortTextSchemaV1.optional()
  }).strict(),
  yAxis: z.object({
    label: ShortTextSchemaV1.optional(),
    min: z.number().finite().optional(),
    max: z.number().finite().optional()
  }).strict(),
  series: z.array(ChartSeriesSchemaV1).min(1).max(MAX_CHART_SERIES)
}).strict();
var MapNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.map"),
  viewport: z.object({
    longitude: z.number().finite().min(-180).max(180),
    latitude: z.number().finite().min(-90).max(90),
    zoom: z.number().finite().min(0).max(24)
  }).strict(),
  data: GeoJsonFeatureCollectionSchemaV1
}).strict();
var StatusNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.status"),
  status: z.enum(["neutral", "info", "success", "warning", "error"]),
  label: ShortTextSchemaV1,
  detail: MarkdownTextSchemaV1.optional()
}).strict();
var ArtifactImageSourceSchemaV1 = z.object({
  type: z.literal("artifact.resource"),
  artifact: ArtifactReferenceSchemaV1,
  path: ArtifactPathSchemaV1,
  sha256: ArtifactDigestSchemaV1
}).strict();
var ImageNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.image"),
  source: z.union([ArtifactImageSourceSchemaV1, MediaSourceSchemaV1]),
  decorative: z.boolean().optional(),
  alt: ImageAltSchemaV1,
  caption: MediaCaptionSchemaV1.optional(),
  fit: z.enum(["contain", "cover", "fill", "none"])
}).strict();
var ProgressNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.progress"),
  state: z.enum(["active", "paused", "complete", "failed"]),
  value: z.number().finite().min(0).max(1).nullable(),
  label: ShortTextSchemaV1,
  detail: ShortTextSchemaV1.optional()
}).strict();
var HitlNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.hitl"),
  hitlRequestId: HitlRequestIdSchemaV1
}).strict();
var ArtifactNodeSchemaV1 = z.object({
  ...NodeBaseShapeV1,
  type: z.literal("content.artifact"),
  artifact: ArtifactReferenceSchemaV1,
  fallbackText: ShortTextSchemaV1
}).strict();
var isTimestampCellV1 = (value) => TimestampSchemaV1.safeParse(value).success;

// packages/board-schema/src/nodes/layout.ts
var createLayoutSchemasV1 = (node) => {
  const split = z.object({
    ...NodeBaseShapeV1,
    type: z.literal("layout.split"),
    direction: z.enum(["horizontal", "vertical"]),
    gap: z.number().finite().min(0).max(MAX_CANVAS_EXTENT),
    children: z.array(z.object({ node, weight: z.number().finite().positive() }).strict()).min(2).max(MAX_SPLIT_CHILDREN)
  }).strict();
  const grid = z.object({
    ...NodeBaseShapeV1,
    type: z.literal("layout.grid"),
    columns: z.number().int().min(1).max(MAX_GRID_COLUMNS),
    rows: z.number().int().min(1).max(MAX_GRID_ROWS),
    gap: z.number().finite().min(0).max(MAX_CANVAS_EXTENT),
    children: z.array(
      z.object({
        node,
        column: z.number().int().min(1),
        row: z.number().int().min(1),
        columnSpan: z.number().int().min(1),
        rowSpan: z.number().int().min(1)
      }).strict()
    ).min(1).max(MAX_GRID_ITEMS)
  }).strict();
  const tabs = z.object({
    ...NodeBaseShapeV1,
    type: z.literal("layout.tabs"),
    activeTabId: TabIdSchemaV1,
    tabs: z.array(z.object({ tabId: TabIdSchemaV1, label: ShortTextSchemaV1, node }).strict()).min(1).max(MAX_TABS)
  }).strict();
  const canvas = z.object({
    ...NodeBaseShapeV1,
    type: z.literal("layout.canvas"),
    width: z.number().finite().positive().max(MAX_CANVAS_EXTENT),
    height: z.number().finite().positive().max(MAX_CANVAS_EXTENT),
    children: z.array(
      z.object({
        node,
        x: z.number().finite().min(0),
        y: z.number().finite().min(0),
        width: z.number().finite().positive(),
        height: z.number().finite().positive(),
        zIndex: z.number().int().safe()
      }).strict()
    ).min(1).max(MAX_CANVAS_ITEMS)
  }).strict();
  return { split, grid, tabs, canvas };
};

// packages/board-schema/src/scene.ts
var BoardNodeSchemaInternalV1 = z.lazy(() => {
  const layouts = createLayoutSchemasV1(BoardNodeSchemaInternalV1);
  return z.discriminatedUnion("type", [
    layouts.split,
    layouts.grid,
    layouts.tabs,
    layouts.canvas,
    MarkdownNodeSchemaV1,
    CodeNodeSchemaV1,
    TableNodeSchemaV1,
    ChartNodeSchemaV1,
    MapNodeSchemaV1,
    DrawingNodeSchemaV1,
    StatusNodeSchemaV1,
    ImageNodeSchemaV1,
    ProgressNodeSchemaV1,
    HitlNodeSchemaV1,
    ArtifactNodeSchemaV1
  ]);
});
var childItems = (node, path, depth) => {
  if (node.type === "layout.split" || node.type === "layout.grid" || node.type === "layout.canvas") {
    return (node.children ?? []).map(
      (item, index) => ({
        node: item.node,
        path: [...path, "children", index, "node"],
        depth: depth + 1
      })
    );
  }
  if (node.type === "layout.tabs") {
    return (node.tabs ?? []).map((item, index) => ({
      node: item.node,
      path: [...path, "tabs", index, "node"],
      depth: depth + 1
    }));
  }
  return [];
};
var collectSceneNodesV1 = (root) => {
  if (root === null) return [];
  const output = [];
  const stack = [{ node: root, path: ["root"], depth: 1 }];
  while (stack.length > 0) {
    const current = stack.pop();
    if (!current) break;
    output.push(current);
    const children = childItems(current.node, current.path, current.depth);
    for (let index = children.length - 1; index >= 0; index -= 1) {
      const child = children[index];
      if (child) stack.push(child);
    }
  }
  return output;
};
var addLayoutIssue = (context, path, message) => context.addIssue({ code: z.ZodIssueCode.custom, path, message: `[INVALID_LAYOUT] ${message}` });
var validateNodeRelationsV1 = (root, context, prefix = []) => {
  const nodes = collectSceneNodesV1(root);
  if (nodes.length > MAX_SCENE_NODES)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: [...prefix, "root"],
      message: "[LIMIT:maxSceneNodes] scene node count exceeded"
    });
  const ids = /* @__PURE__ */ new Map();
  for (const item of nodes) {
    const path = [...prefix, ...item.path];
    if (item.depth > MAX_SCENE_DEPTH)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path,
        message: "[LIMIT:maxSceneDepth] scene depth exceeded"
      });
    const first = ids.get(item.node.id);
    if (first)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [...path, "id"],
        message: `[DUPLICATE_NODE_ID:${item.node.id}:${JSON.stringify(first)}] duplicate node ID`
      });
    else ids.set(item.node.id, [...path, "id"]);
    if (item.node.type === "layout.tabs") {
      const tabs = item.node.tabs;
      if (new Set(tabs.map((tab) => tab.tabId)).size !== tabs.length)
        addLayoutIssue(context, [...path, "tabs"], "tab IDs must be unique");
      if (!tabs.some((tab) => tab.tabId === item.node.activeTabId))
        addLayoutIssue(context, [...path, "activeTabId"], "active tab is missing");
    } else if (item.node.type === "layout.grid") {
      const placements = item.node.children;
      const occupied = /* @__PURE__ */ new Set();
      placements.forEach((placement, index) => {
        if (placement.column + placement.columnSpan - 1 > item.node.columns || placement.row + placement.rowSpan - 1 > item.node.rows)
          addLayoutIssue(context, [...path, "children", index], "grid item is outside tracks");
        for (let row = placement.row; row < placement.row + placement.rowSpan; row += 1)
          for (let column = placement.column; column < placement.column + placement.columnSpan; column += 1) {
            const key = `${row}:${column}`;
            if (occupied.has(key))
              addLayoutIssue(context, [...path, "children", index], "grid items overlap");
            occupied.add(key);
          }
      });
    } else if (item.node.type === "layout.canvas") {
      const width = item.node.width;
      const height = item.node.height;
      item.node.children.forEach((placement, index) => {
        if (placement.x + placement.width > width || placement.y + placement.height > height)
          addLayoutIssue(context, [...path, "children", index], "canvas item is outside bounds");
      });
    } else if (item.node.type === "content.table") {
      const columns = item.node.columns;
      const rows = item.node.rows;
      const keys = columns.map((column) => column.key);
      if (new Set(keys).size !== keys.length)
        addLayoutIssue(context, [...path, "columns"], "table column keys must be unique");
      if (new Set(rows.map((row) => row.id)).size !== rows.length)
        addLayoutIssue(context, [...path, "rows"], "table row IDs must be unique");
      if (columns.length * rows.length > MAX_TABLE_CELLS)
        context.addIssue({
          code: z.ZodIssueCode.custom,
          path: [...path, "rows"],
          message: "[LIMIT:maxTableCells] table cell count exceeded"
        });
      rows.forEach((row, rowIndex) => {
        if (Object.keys(row.cells).length !== keys.length || keys.some((key) => !Object.hasOwn(row.cells, key)))
          addLayoutIssue(
            context,
            [...path, "rows", rowIndex, "cells"],
            "table cells must match columns"
          );
        columns.forEach((column) => {
          const value = row.cells[column.key];
          if (value === null) return;
          const valid = column.valueType === "string" ? typeof value === "string" : column.valueType === "number" ? typeof value === "number" : column.valueType === "boolean" ? typeof value === "boolean" : typeof value === "string" && isTimestampCellV1(value);
          if (!valid)
            addLayoutIssue(
              context,
              [...path, "rows", rowIndex, "cells", column.key],
              "table cell type does not match column"
            );
        });
      });
    } else if (item.node.type === "content.image") {
      const image = item.node;
      if (image.source.type === "artifact.resource") {
        if (image.decorative !== void 0)
          addLayoutIssue(context, [...path, "decorative"], "legacy image forbids decorative");
        if (image.caption !== void 0 && !ShortTextSchemaV1.safeParse(image.caption).success)
          addLayoutIssue(context, [...path, "caption"], "legacy image caption is invalid");
      } else if (image.decorative === true) {
        if (image.alt !== "")
          addLayoutIssue(context, [...path, "alt"], "decorative media image requires empty alt");
        if (image.caption !== void 0)
          addLayoutIssue(context, [...path, "caption"], "decorative media image forbids caption");
      } else if (!MediaAltSchemaV1.safeParse(image.alt).success) {
        addLayoutIssue(context, [...path, "alt"], "media image alt is invalid");
      }
    } else if (item.node.type === "content.chart") {
      const chart = item.node;
      if (chart.yAxis.min !== void 0 && chart.yAxis.max !== void 0 && chart.yAxis.min > chart.yAxis.max)
        addLayoutIssue(context, [...path, "yAxis", "max"], "axis bounds are invalid");
      const totalPoints = chart.series.reduce((total, series) => total + series.points.length, 0);
      if (totalPoints > MAX_CHART_POINTS)
        context.addIssue({
          code: z.ZodIssueCode.custom,
          path: [...path, "series"],
          message: "[LIMIT:maxChartPoints] chart point count exceeded"
        });
      if (chart.chartType === "pie" && (chart.series.length !== 1 || chart.xAxis.valueType !== "category" || chart.series[0]?.points.some((point) => point.y === null || point.y < 0)))
        addLayoutIssue(context, [...path, "series"], "pie chart requirements are invalid");
      if (chart.chartType === "scatter" && chart.xAxis.valueType !== "number")
        addLayoutIssue(context, [...path, "xAxis", "valueType"], "scatter x axis must be numeric");
      chart.series.forEach(
        (series, seriesIndex) => series.points.forEach((point, pointIndex) => {
          const validX = chart.xAxis.valueType === "number" ? typeof point.x === "number" : chart.xAxis.valueType === "datetime" ? typeof point.x === "string" && isTimestampCellV1(point.x) : typeof point.x === "string";
          if (!validX)
            addLayoutIssue(
              context,
              [...path, "series", seriesIndex, "points", pointIndex, "x"],
              "chart x value does not match axis"
            );
        })
      );
    } else if (item.node.type === "content.map") {
      const features = item.node.data.features;
      if (features.length > MAX_MAP_FEATURES)
        context.addIssue({
          code: z.ZodIssueCode.custom,
          path: [...path, "data", "features"],
          message: "[LIMIT:maxMapFeatures] map feature count exceeded"
        });
      features.forEach((feature, featureIndex) => {
        if (feature.geometry.type === "Polygon") {
          feature.geometry.coordinates.forEach(
            (ring, ringIndex) => {
              const first2 = ring[0];
              const last = ring.at(-1);
              if (!first2 || !last || first2[0] !== last[0] || first2[1] !== last[1])
                addLayoutIssue(
                  context,
                  [...path, "data", "features", featureIndex, "geometry", "coordinates", ringIndex],
                  "polygon ring must be closed"
                );
            }
          );
        }
      });
    } else if (item.node.type === "content.progress") {
      const state = item.node.state;
      const value = item.node.value;
      if (state === "complete" ? value !== 1 : state !== "active" && state !== "paused" && value === null)
        addLayoutIssue(context, [...path, "value"], "progress value does not match state");
    }
  }
};
var BoardNodeSchemaV1 = BoardNodeSchemaInternalV1.superRefine(
  (node, context) => validateNodeRelationsV1(node, context, [])
).describe("BoardNodeV1");
var SceneSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("scene"),
  root: BoardNodeSchemaInternalV1.nullable()
}).strict().superRefine(
  (scene, context) => validateNodeRelationsV1(scene.root, context)
);

// packages/board-schema/src/documents.ts
var PageDisplayModeSchemaV1 = z.enum(["fit-page", "fit-width", "actual-size"]);
var PresentationFormatSchemaV1 = z.enum([
  "wide_16_9",
  "standard_4_3",
  "a4_portrait",
  "a4_landscape"
]);
var BoardPageSchemaV2 = z.object({
  pageId: PageIdSchemaV1,
  title: createScalarTextSchemaV1(0, MAX_TITLE_CHARS),
  displayMode: PageDisplayModeSchemaV1,
  scene: SceneSchemaV1
}).strict();
var invalidDocument = (context, path, reason, message) => context.addIssue({
  code: z.ZodIssueCode.custom,
  path,
  message: `[INVALID_DOCUMENT:${reason}] ${message}`
});
var validateDocumentPages = (document, context) => {
  if (document.pages.length < 1 || document.pages.length > MAX_DOCUMENT_PAGES)
    invalidDocument(context, ["pages"], "page_count", "document page count is invalid");
  const pageIds = /* @__PURE__ */ new Set();
  const nodeIds = /* @__PURE__ */ new Map();
  const artifactReferenceCounts = /* @__PURE__ */ new Map();
  let nodeCount = 0;
  document.pages.forEach((page, pageIndex2) => {
    if (pageIds.has(page.pageId))
      invalidDocument(
        context,
        ["pages", pageIndex2, "pageId"],
        "duplicate_page_id",
        "page IDs must be unique"
      );
    pageIds.add(page.pageId);
    for (const item of collectSceneNodesV1(page.scene.root)) {
      const node = item.node;
      nodeCount += 1;
      const path = ["pages", pageIndex2, "scene", ...item.path, "id"];
      const firstPath = nodeIds.get(item.node.id);
      if (firstPath)
        invalidDocument(
          context,
          path,
          "duplicate_node_id",
          `duplicate node ID ${item.node.id}; first path ${JSON.stringify(firstPath)}`
        );
      else nodeIds.set(item.node.id, path);
      const reference = node.type === "content.artifact" ? { artifact: node.artifact, code: "A" } : node.type === "content.image" && node.source.type === "artifact.resource" ? { artifact: node.source.artifact, code: "I" } : null;
      if (reference !== null) {
        const key = `${reference.artifact.artifactId}\0${reference.artifact.versionId}\0${reference.code}`;
        const occurrenceCount = (artifactReferenceCounts.get(key) ?? 0) + 1;
        artifactReferenceCounts.set(key, occurrenceCount);
        if (occurrenceCount === MAX_ARTIFACT_REFERENCE_OCCURRENCES + 1)
          invalidDocument(
            context,
            ["pages", pageIndex2, "scene", ...item.path],
            "limit",
            "artifact reference occurrence count exceeded"
          );
      }
    }
  });
  if (!pageIds.has(document.defaultPageId))
    invalidDocument(
      context,
      ["defaultPageId"],
      "default_page_missing",
      "default page is not present"
    );
  if (nodeCount > MAX_DOCUMENT_NODES)
    invalidDocument(context, ["pages"], "limit", "document node count exceeded");
};
var BoardDocumentSchemaV2 = z.object({
  schemaVersion: z.literal(2),
  defaultPageId: PageIdSchemaV1,
  pages: z.array(BoardPageSchemaV2).min(1).max(MAX_DOCUMENT_PAGES)
}).strict().superRefine(validateDocumentPages);
var BoardDocumentSchemaV3 = z.object({
  schemaVersion: z.literal(3),
  format: PresentationFormatSchemaV1,
  defaultPageId: PageIdSchemaV1,
  pages: z.array(BoardPageSchemaV2).min(1).max(MAX_DOCUMENT_PAGES)
}).strict().superRefine(validateDocumentPages);
var projectDocumentV2ToV3 = (document, format = "wide_16_9") => BoardDocumentSchemaV3.parse({
  schemaVersion: 3,
  format,
  defaultPageId: document.defaultPageId,
  pages: document.pages
});
var projectDocumentV3ToV2 = (document) => BoardDocumentSchemaV2.parse({
  schemaVersion: 2,
  defaultPageId: document.defaultPageId,
  pages: document.pages
});
var collectDocumentNodesV2 = (document) => {
  const output = [];
  document.pages.forEach((page, pageIndex2) => {
    for (const item of collectSceneNodesV1(page.scene.root))
      output.push({
        page,
        pageIndex: pageIndex2,
        node: item.node,
        path: ["document", "pages", pageIndex2, "scene", ...item.path]
      });
  });
  return output;
};

// packages/board-schema/src/public-shares.ts
var canonicalBase64Url32 = (value) => {
  if (!/^[A-Za-z0-9_-]{43}$/u.test(value)) return false;
  try {
    const decoded = atob(`${value.replaceAll("-", "+").replaceAll("_", "/")}=`);
    if (decoded.length !== 32) return false;
    return btoa(decoded).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "") === value;
  } catch {
    return false;
  }
};
var PublicShareTokenSchemaV1 = z.string().refine(
  (value) => canonicalBase64Url32(value) || /^share_[A-Za-z0-9_-]{22}_g[1-9][0-9]{0,15}$/u.test(value),
  "share token must be a canonical secret token or persistent share locator"
);
var PublicContextIdSchemaV1 = z.string().refine(canonicalBase64Url32, "context ID must be canonical unpadded base64url");
var ShareCsrfTokenSchemaV1 = z.string().min(1).max(512).regex(/^[\x21-\x7e]+$/u);
var PUBLIC_ARTIFACT_PATH = /^\/api\/v1\/public\/shares\/[A-Za-z0-9_-]{1,128}\/revisions\/[A-Za-z0-9_-]{1,128}\/g\/[1-9][0-9]{0,15}\/[1-9][0-9]{0,15}\/artifacts\/[A-Za-z0-9_-]{1,128}\/versions\/[A-Za-z0-9_-]{1,128}\/package\?contextId=[A-Za-z0-9_-]{43}$/u;
var PUBLIC_MEDIA_PATH = /^\/api\/v1\/public\/shares\/[A-Za-z0-9_-]{1,128}\/revisions\/[A-Za-z0-9_-]{1,128}\/g\/[1-9][0-9]{0,15}\/[1-9][0-9]{0,15}\/media\/[A-Za-z0-9_-]{1,128}\?contextId=[A-Za-z0-9_-]{43}$/u;
var PublicRelativeUrlSchemaV1 = z.string().max(2048).refine(
  (value) => /^[\x21-\x7e]+$/u.test(value) && !value.includes("%") && (PUBLIC_ARTIFACT_PATH.test(value) || PUBLIC_MEDIA_PATH.test(value)),
  "public resource URL must use an exact relative route"
);
var QuotedSha256EtagSchemaV1 = z.string().regex(/^"sha256-[0-9a-f]{64}"$/u);
var PublicShareContextSchemaV1 = z.object({
  contextId: PublicContextIdSchemaV1,
  validUntil: TimestampSchemaV1
}).strict();
var PublicArtifactIdentityShapeV1 = {
  artifactId: ArtifactIdSchemaV1,
  versionId: ArtifactVersionIdSchemaV1
};
var PublicArtifactSummarySchemaV1 = z.union([
  z.object({
    ...PublicArtifactIdentityShapeV1,
    status: z.literal("ready"),
    packageUrl: PublicRelativeUrlSchemaV1
  }).strict(),
  z.object({
    ...PublicArtifactIdentityShapeV1,
    status: z.enum(["running", "stopped", "failed", "blocked"]),
    packageUrl: z.null()
  }).strict()
]);
var PublicMediaResourceSchemaV1 = z.object({
  mediaId: MediaIdSchemaV1,
  url: PublicRelativeUrlSchemaV1,
  mime: z.enum(["image/png", "image/jpeg", "image/webp"]),
  width: z.number().int().safe().positive(),
  height: z.number().int().safe().positive(),
  etag: QuotedSha256EtagSchemaV1
}).strict().superRefine((value, context) => {
  if (value.width * value.height > MAX_MEDIA_PIXELS)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["width"],
      message: "media pixel limit exceeded"
    });
});
var PublicBoardProjectionSchemaV1 = z.object({
  shareId: GlobalIdStringSchemaV1,
  boardId: BoardIdSchemaV1,
  revisionId: RevisionIdSchemaV1,
  publicationGeneration: z.number().int().safe().positive(),
  accessGeneration: z.number().int().safe().positive(),
  title: ShortTextSchemaV1,
  document: z.union([BoardDocumentSchemaV2, BoardDocumentSchemaV3]),
  artifacts: z.array(PublicArtifactSummarySchemaV1).max(MAX_MEDIA_REFERENCES),
  media: z.array(PublicMediaResourceSchemaV1).max(MAX_MEDIA_REFERENCES)
}).strict().superRefine((projection, context) => {
  const artifactIds = /* @__PURE__ */ new Set();
  projection.artifacts.forEach((artifact, index) => {
    const key = `${artifact.artifactId}\0${artifact.versionId}`;
    if (artifactIds.has(key))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["artifacts", index],
        message: "duplicate public artifact"
      });
    artifactIds.add(key);
  });
  const mediaIds = /* @__PURE__ */ new Set();
  projection.media.forEach((media, index) => {
    if (mediaIds.has(media.mediaId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["media", index],
        message: "duplicate public media"
      });
    mediaIds.add(media.mediaId);
  });
});
var expectedArtifactUrl = (projection, contextId, artifact) => `/api/v1/public/shares/${projection.shareId}/revisions/${projection.revisionId}/g/${projection.publicationGeneration}/${projection.accessGeneration}/artifacts/${artifact.artifactId}/versions/${artifact.versionId}/package?contextId=${contextId}`;
var expectedMediaUrl = (projection, contextId, mediaId) => `/api/v1/public/shares/${projection.shareId}/revisions/${projection.revisionId}/g/${projection.publicationGeneration}/${projection.accessGeneration}/media/${mediaId}?contextId=${contextId}`;
var PublicShareStateSchemaV1 = z.union([
  z.object({
    state: z.literal("ready"),
    projection: PublicBoardProjectionSchemaV1,
    context: PublicShareContextSchemaV1
  }).strict(),
  z.object({
    state: z.literal("password-required"),
    csrfToken: ShareCsrfTokenSchemaV1
  }).strict(),
  z.object({ state: z.literal("unavailable") }).strict(),
  z.object({
    state: z.literal("rate-limited"),
    retryAfterSeconds: z.number().int().min(1).max(900)
  }).strict()
]).superRefine((state, context) => {
  if (state.state !== "ready") return;
  state.projection.artifacts.forEach((artifact, index) => {
    if (artifact.status === "ready" && artifact.packageUrl !== expectedArtifactUrl(state.projection, state.context.contextId, artifact))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["projection", "artifacts", index, "packageUrl"],
        message: "artifact URL does not match the projection context"
      });
  });
  state.projection.media.forEach((media, index) => {
    if (media.url !== expectedMediaUrl(state.projection, state.context.contextId, media.mediaId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["projection", "media", index, "url"],
        message: "media URL does not match the projection context"
      });
  });
});

// packages/board-schema/src/share-analytics.ts
var DateOnlySchemaV1 = z.string().regex(/^\d{4}-\d{2}-\d{2}$/u).refine((value) => {
  const instant = Date.parse(`${value}T00:00:00.000Z`);
  return Number.isFinite(instant) && new Date(instant).toISOString().slice(0, 10) === value;
});
var CountSchemaV1 = z.number().int().safe().nonnegative();
var GenerationSchemaV1 = z.number().int().safe().positive();
var ViewContextIdSchemaV1 = GlobalIdStringSchemaV1;
var ViewCsrfTokenSchemaV1 = z.string().min(32).max(512).regex(/^[\x21-\x7e]+$/u);
var ShareAnalyticsContextRequestSchemaV1 = z.object({}).strict();
var ShareAnalyticsContextSchemaV1 = z.object({
  viewContextId: ViewContextIdSchemaV1,
  revisionId: RevisionIdSchemaV1,
  publicationGeneration: GenerationSchemaV1,
  accessGeneration: GenerationSchemaV1,
  pageIds: z.array(PageIdSchemaV1).min(1).max(1e3),
  expiresAt: TimestampSchemaV1,
  csrfToken: ViewCsrfTokenSchemaV1
}).strict().superRefine((value, context) => {
  const seen = /* @__PURE__ */ new Set();
  value.pageIds.forEach((pageId, index) => {
    if (seen.has(pageId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["pageIds", index],
        message: "duplicate page ID"
      });
    seen.add(pageId);
  });
});
var ShareAnalyticsEventSchemaV1 = z.object({
  viewContextId: ViewContextIdSchemaV1,
  eventKind: z.enum(["first-visible", "page-visible"]),
  pageId: PageIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV1
}).strict();
var ShareAnalyticsEventResultSchemaV1 = z.object({
  status: z.enum(["counted", "deduped"]),
  replayed: z.boolean()
}).strict();
var AggregateSummarySchemaV1 = z.object({
  boardOpens: CountSchemaV1,
  pageViews: CountSchemaV1,
  estimatedDailyReach: CountSchemaV1,
  lastAggregatedAt: TimestampSchemaV1.nullable()
}).strict();
var ShareAnalyticsPageReportSchemaV1 = z.object({
  pageId: PageIdSchemaV1,
  pageOrdinal: z.number().int().safe().nonnegative(),
  titleLabel: ShortTextSchemaV1,
  pageViews: CountSchemaV1,
  pageReachBasisPoints: z.number().int().min(0).max(1e4).nullable()
}).strict();
var ShareAnalyticsPublicationReportSchemaV1 = z.object({
  shareId: GlobalIdStringSchemaV1,
  publicationGeneration: GenerationSchemaV1,
  revisionId: RevisionIdSchemaV1,
  ...AggregateSummarySchemaV1.shape,
  pages: z.array(ShareAnalyticsPageReportSchemaV1).max(1e3)
}).strict();
var ShareAnalyticsReportSchemaV1 = z.object({
  boardId: BoardIdSchemaV1,
  from: DateOnlySchemaV1,
  to: DateOnlySchemaV1,
  totals: AggregateSummarySchemaV1,
  publications: z.array(ShareAnalyticsPublicationReportSchemaV1).max(1e4)
}).strict().refine((value) => value.from <= value.to, {
  path: ["to"],
  message: "to must be on or after from"
});
var SHARE_ANALYTICS_ERROR_CODES_V1 = [
  "INVALID_PAYLOAD",
  "UNAUTHENTICATED",
  "CSRF_INVALID",
  "SHARE_VIEW_UNAVAILABLE",
  "BOARD_NOT_FOUND",
  "IDEMPOTENCY_KEY_REUSED",
  "RATE_LIMITED",
  "SERVICE_UNAVAILABLE"
];
var ShareAnalyticsErrorCodeSchemaV1 = z.enum(SHARE_ANALYTICS_ERROR_CODES_V1);
var ShareAnalyticsErrorEnvelopeSchemaV1 = z.object({
  error: z.object({
    code: ShareAnalyticsErrorCodeSchemaV1,
    message: z.string().min(1).max(128),
    requestId: GlobalIdStringSchemaV1
  }).strict()
}).strict();

// packages/board-schema/src/public-presentation-sessions.ts
var PUBLIC_PRESENTATION_MAX_SESSIONS_V1 = 5;
var PUBLIC_PRESENTATION_MAX_STROKES_V1 = 64;
var PUBLIC_PRESENTATION_MAX_POINTS_PER_STROKE_V1 = 128;
var PUBLIC_PRESENTATION_MAX_POINTS_V1 = 1024;
var PublicPresentationSessionIdSchemaV1 = PublicContextIdSchemaV1;
var PublicPresentationRoleSchemaV1 = z.enum(["presenter", "viewer"]);
var PublicPresentationStatusSchemaV1 = z.enum(["active", "ended"]);
var PublicPresentationPointSchemaV1 = z.object({
  x: z.number().finite().min(0).max(1),
  y: z.number().finite().min(0).max(1)
}).strict();
var PublicPresentationStrokeSchemaV1 = z.object({
  id: z.string().min(1).max(128).regex(/^[\x21-\x7e]+$/u),
  points: z.array(PublicPresentationPointSchemaV1).min(1).max(PUBLIC_PRESENTATION_MAX_POINTS_PER_STROKE_V1),
  color: z.string().regex(/^#[0-9a-fA-F]{6}$/u),
  width: z.union([z.literal(2), z.literal(4), z.literal(8)])
}).strict();
var PublicPresentationAnnotationSchemaV1 = z.object({
  pageId: PageIdSchemaV1,
  strokes: z.array(PublicPresentationStrokeSchemaV1).max(PUBLIC_PRESENTATION_MAX_STROKES_V1)
}).strict().superRefine((annotation, context) => {
  const totalPoints = annotation.strokes.reduce((sum, stroke) => sum + stroke.points.length, 0);
  if (totalPoints > PUBLIC_PRESENTATION_MAX_POINTS_V1)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["strokes"],
      message: "presentation point limit exceeded"
    });
  const ids = /* @__PURE__ */ new Set();
  annotation.strokes.forEach((stroke, index) => {
    if (ids.has(stroke.id))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["strokes", index, "id"],
        message: "duplicate presentation stroke ID"
      });
    ids.add(stroke.id);
  });
});
var PublicPresentationSessionSummarySchemaV1 = z.object({
  sessionId: PublicPresentationSessionIdSchemaV1,
  role: PublicPresentationRoleSchemaV1,
  startedAt: TimestampSchemaV1,
  updatedAt: TimestampSchemaV1,
  expiresAt: TimestampSchemaV1
}).strict();
var PublicPresentationSessionListSchemaV1 = z.object({
  sessions: z.array(PublicPresentationSessionSummarySchemaV1).max(PUBLIC_PRESENTATION_MAX_SESSIONS_V1)
}).strict();
var PublicPresentationStartRequestSchemaV1 = z.object({ currentPageId: PageIdSchemaV1 }).strict();
var PublicPresentationSnapshotSchemaV1 = z.object({
  sessionId: PublicPresentationSessionIdSchemaV1,
  role: PublicPresentationRoleSchemaV1,
  status: PublicPresentationStatusSchemaV1,
  version: z.number().int().safe().min(0),
  currentPageId: PageIdSchemaV1,
  annotation: PublicPresentationAnnotationSchemaV1,
  startedAt: TimestampSchemaV1,
  updatedAt: TimestampSchemaV1,
  expiresAt: TimestampSchemaV1
}).strict().superRefine((snapshot, context) => {
  if (snapshot.annotation.pageId !== snapshot.currentPageId)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["annotation", "pageId"],
      message: "annotation page must match current page"
    });
});
var PublicPresentationUpdateRequestSchemaV1 = z.object({
  expectedVersion: z.number().int().safe().min(0),
  currentPageId: PageIdSchemaV1,
  annotation: PublicPresentationAnnotationSchemaV1
}).strict().superRefine((update, context) => {
  if (update.annotation.pageId !== update.currentPageId)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["annotation", "pageId"],
      message: "annotation page must match current page"
    });
});
var PublicPresentationEventSchemaV1 = z.object({
  type: z.literal("presentation.state.v1"),
  snapshot: PublicPresentationSnapshotSchemaV1
}).strict();
var PublicPresentationEndResultSchemaV1 = z.object({
  sessionId: PublicPresentationSessionIdSchemaV1,
  status: z.literal("ended")
}).strict();

// packages/board-schema/src/invitations.ts
var InvitationRoleSchemaV1 = z.enum(["editor", "viewer"]);
var InvitationStateSchemaV1 = z.enum([
  "pending",
  "accepted",
  "revoked",
  "expired",
  "superseded"
]);
var MemberCandidateSchemaV1 = z.discriminatedUnion("kind", [
  z.object({
    kind: z.literal("account"),
    accountId: PrincipalIdSchemaV1,
    displayName: z.string().min(1).max(100)
  }).strict(),
  z.object({
    kind: z.literal("email"),
    email: z.string().email().max(254)
  }).strict()
]);
var MemberCandidateListSchemaV1 = z.object({
  candidates: z.array(MemberCandidateSchemaV1).max(20)
}).strict();
var BoardInvitationSchemaV1 = z.object({
  inviteId: GlobalIdStringSchemaV1,
  role: InvitationRoleSchemaV1,
  expiresAt: TimestampSchemaV1,
  state: InvitationStateSchemaV1
}).strict();
var BoardInvitationEnvelopeSchemaV1 = z.object({
  invitation: BoardInvitationSchemaV1
}).strict();
var InvitationMembershipSchemaV1 = z.object({
  boardId: BoardIdSchemaV1,
  accountId: PrincipalIdSchemaV1,
  role: InvitationRoleSchemaV1,
  version: z.number().int().safe().positive()
}).strict();
var InvitationAcceptanceSchemaV1 = z.object({
  membership: InvitationMembershipSchemaV1,
  replayed: z.boolean()
}).strict();
var ManagedMembershipSchemaV1 = z.object({
  accountId: PrincipalIdSchemaV1,
  role: InvitationRoleSchemaV1,
  version: z.number().int().safe().positive()
}).strict();
var ManagedMembershipEnvelopeSchemaV1 = z.object({
  membership: ManagedMembershipSchemaV1,
  capabilityEpoch: z.number().int().safe().min(0)
}).strict();
var ManagedMemberSummarySchemaV1 = z.object({
  memberId: GlobalIdStringSchemaV1,
  accountId: PrincipalIdSchemaV1,
  role: InvitationRoleSchemaV1,
  version: z.number().int().safe().positive()
}).strict();
var PendingInvitationSummarySchemaV1 = z.object({
  inviteId: GlobalIdStringSchemaV1,
  role: InvitationRoleSchemaV1,
  expiresAt: TimestampSchemaV1,
  state: z.literal("pending")
}).strict();
var AccessManagementListSchemaV1 = z.object({
  members: z.array(ManagedMemberSummarySchemaV1).max(500),
  invitations: z.array(PendingInvitationSummarySchemaV1).max(500)
}).strict();

// packages/board-schema/src/capabilities.ts
var exactCatalog = (catalog) => z.array(z.enum(catalog)).length(catalog.length).superRefine((values, context) => {
  if (values.some((value, index) => value !== catalog[index]))
    context.addIssue({
      code: z.ZodIssueCode.custom,
      message: "catalog order must match protocol"
    });
});
var sortedSubset = (catalog) => z.array(z.enum(catalog)).superRefine((values, context) => {
  for (let index = 1; index < values.length; index += 1)
    if ((values[index - 1] ?? "") >= (values[index] ?? "")) {
      context.addIssue({
        code: z.ZodIssueCode.custom,
        message: "capabilities must be sorted and unique"
      });
      break;
    }
});
var BoardAuthorizationCapabilitySchemaV1 = z.enum(BOARD_AUTHORIZATION_CAPABILITIES_V1);
var ConnectionLifecyclePermissionSchemaV1 = z.enum(["board.archive", "board.create"]);
var BoardSessionAccessSchemaV1 = z.object({
  protocolVersion: z.literal(PROTOCOL_VERSION),
  type: z.literal("board.session.access"),
  capabilityEpoch: z.number().int().safe().min(0),
  authorizationCapabilities: sortedSubset(BOARD_AUTHORIZATION_CAPABILITIES_V1),
  connectionGrantCeiling: z.object({
    scopes: sortedSubset(CLIENT_GRANT_CAPABILITIES_V1),
    lifecyclePermissions: z.array(ConnectionLifecyclePermissionSchemaV1).superRefine((values, context) => {
      for (let index = 1; index < values.length; index += 1)
        if ((values[index - 1] ?? "") >= (values[index] ?? "")) {
          context.addIssue({
            code: z.ZodIssueCode.custom,
            message: "lifecycle permissions must be sorted and unique"
          });
          break;
        }
    })
  }).strict()
}).strict();
var BoardLimitsSchemaV1 = z.object(
  Object.fromEntries(
    Object.entries(BOARD_LIMITS_V1).map(([key, value]) => [key, z.literal(value)])
  )
).strict();
var BoardLimitsSchemaV2 = z.object(
  Object.fromEntries(
    Object.entries(BOARD_DOCUMENT_LIMITS_V2).map(([key, value]) => [key, z.literal(value)])
  )
).strict();
var BoardLimitsSchemaV3 = z.object(
  Object.fromEntries(
    Object.entries(BOARD_DOCUMENT_LIMITS_V3).map(([key, value]) => [key, z.literal(value)])
  )
).strict();
var BoardCapabilitiesSchemaV1 = z.object({
  protocolVersion: z.literal(PROTOCOL_VERSION),
  type: z.literal("board.capabilities"),
  schemaVersion: z.literal(PROTOCOL_SEMVER),
  compatibilityMode: z.literal("frozen-major"),
  supported: z.object({
    nodeTypes: exactCatalog(NODE_TYPES_V1),
    commandTypes: exactCatalog(BOARD_MUTATION_COMMAND_TYPES_V1),
    operationTypes: exactCatalog(BOARD_OPERATION_TYPES_V1),
    eventTypes: exactCatalog(BOARD_EVENT_TYPES_V1),
    hitlKinds: exactCatalog(HITL_KINDS_V1),
    artifactRequestCapabilities: exactCatalog(ARTIFACT_REQUEST_CAPABILITIES_V1)
  }).strict(),
  limits: BoardLimitsSchemaV1,
  grantedCapabilities: sortedSubset(CLIENT_GRANT_CAPABILITIES_V1),
  allowedArtifactRequestCapabilities: sortedSubset(ARTIFACT_REQUEST_CAPABILITIES_V1)
}).strict();
var DEFAULT_BOARD_CAPABILITIES_V1 = {
  protocolVersion: PROTOCOL_VERSION,
  type: "board.capabilities",
  schemaVersion: PROTOCOL_SEMVER,
  compatibilityMode: "frozen-major",
  supported: {
    nodeTypes: [...NODE_TYPES_V1],
    commandTypes: [...BOARD_MUTATION_COMMAND_TYPES_V1],
    operationTypes: [...BOARD_OPERATION_TYPES_V1],
    eventTypes: [...BOARD_EVENT_TYPES_V1],
    hitlKinds: [...HITL_KINDS_V1],
    artifactRequestCapabilities: [...ARTIFACT_REQUEST_CAPABILITIES_V1]
  },
  limits: { ...BOARD_LIMITS_V1 },
  grantedCapabilities: [],
  allowedArtifactRequestCapabilities: []
};
var BoardCapabilitiesSchemaV2 = z.object({
  protocolVersion: z.literal(PROTOCOL_VERSION),
  type: z.literal("board.capabilities"),
  schemaVersion: z.literal("1.1.0"),
  compatibilityMode: z.literal("frozen-major"),
  supported: z.object({
    nodeTypes: exactCatalog(NODE_TYPES_V1),
    commandTypes: exactCatalog(BOARD_MUTATION_COMMAND_TYPES_V2),
    operationTypes: exactCatalog(BOARD_OPERATION_TYPES_V1),
    eventTypes: exactCatalog(BOARD_EVENT_TYPES_V1),
    hitlKinds: exactCatalog(HITL_KINDS_V1),
    artifactRequestCapabilities: exactCatalog(ARTIFACT_REQUEST_CAPABILITIES_V1)
  }).strict(),
  limits: BoardLimitsSchemaV2,
  grantedCapabilities: sortedSubset(CLIENT_GRANT_CAPABILITIES_V1),
  allowedArtifactRequestCapabilities: sortedSubset(ARTIFACT_REQUEST_CAPABILITIES_V1)
}).strict();
var DEFAULT_BOARD_CAPABILITIES_V2 = {
  protocolVersion: PROTOCOL_VERSION,
  type: "board.capabilities",
  schemaVersion: "1.1.0",
  compatibilityMode: "frozen-major",
  supported: {
    nodeTypes: [...NODE_TYPES_V1],
    commandTypes: [...BOARD_MUTATION_COMMAND_TYPES_V2],
    operationTypes: [...BOARD_OPERATION_TYPES_V1],
    eventTypes: [...BOARD_EVENT_TYPES_V1],
    hitlKinds: [...HITL_KINDS_V1],
    artifactRequestCapabilities: [...ARTIFACT_REQUEST_CAPABILITIES_V1]
  },
  limits: { ...BOARD_DOCUMENT_LIMITS_V2 },
  grantedCapabilities: [],
  allowedArtifactRequestCapabilities: []
};
var BoardCapabilitiesSchemaV3 = z.object({
  protocolVersion: z.literal(PROTOCOL_VERSION),
  type: z.literal("board.capabilities"),
  schemaVersion: z.literal("1.2.0"),
  compatibilityMode: z.literal("frozen-major"),
  supported: z.object({
    nodeTypes: exactCatalog(NODE_TYPES_V1),
    commandTypes: exactCatalog(BOARD_MUTATION_COMMAND_TYPES_V2),
    operationTypes: exactCatalog(BOARD_OPERATION_TYPES_V1),
    eventTypes: exactCatalog(BOARD_EVENT_TYPES_V1),
    hitlKinds: exactCatalog(HITL_KINDS_V1),
    artifactRequestCapabilities: exactCatalog(ARTIFACT_REQUEST_CAPABILITIES_V1)
  }).strict(),
  limits: BoardLimitsSchemaV3,
  grantedCapabilities: sortedSubset(CLIENT_GRANT_CAPABILITIES_V1),
  allowedArtifactRequestCapabilities: sortedSubset(ARTIFACT_REQUEST_CAPABILITIES_V1)
}).strict();
var DEFAULT_BOARD_CAPABILITIES_V3 = {
  ...DEFAULT_BOARD_CAPABILITIES_V2,
  schemaVersion: "1.2.0",
  limits: { ...BOARD_DOCUMENT_LIMITS_V3 }
};
var BoardCapabilitiesSchema = z.union([
  BoardCapabilitiesSchemaV1,
  BoardCapabilitiesSchemaV2,
  BoardCapabilitiesSchemaV3
]);

// packages/board-schema/src/hitl.ts
var HitlContentSchemaV1 = ContentTextSchemaV1.refine(
  (value) => scalarLengthV1(value) <= MAX_MARKDOWN_CHARS,
  "[LIMIT:maxMarkdownChars] HITL body is too long"
);
var HitlTextValueSchemaV1 = ContentTextSchemaV1.refine(
  (value) => scalarLengthV1(value) <= MAX_HITL_TEXT_CHARS,
  "[LIMIT:maxHitlTextChars] HITL text is too long"
);
var HitlOptionSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  label: ShortTextSchemaV1,
  description: ShortTextSchemaV1.optional()
}).strict();
var uniqueOptions = (options) => new Set(options.map((option) => option.id)).size === options.length;
var TextFieldSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("text"),
  label: ShortTextSchemaV1,
  required: z.boolean(),
  defaultValue: HitlTextValueSchemaV1.nullable(),
  minLength: z.number().int().safe().min(0).max(MAX_HITL_TEXT_CHARS),
  maxLength: z.number().int().safe().min(1).max(MAX_HITL_TEXT_CHARS)
}).strict();
var NumberFieldSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("number"),
  label: ShortTextSchemaV1,
  required: z.boolean(),
  defaultValue: z.number().finite().nullable(),
  min: z.number().finite().nullable(),
  max: z.number().finite().nullable()
}).strict();
var BooleanFieldSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("boolean"),
  label: ShortTextSchemaV1,
  required: z.boolean(),
  defaultValue: z.boolean().nullable()
}).strict();
var SelectFieldSchemaV1 = z.object({
  id: LocalFieldIdSchemaV1,
  type: z.literal("select"),
  label: ShortTextSchemaV1,
  required: z.boolean(),
  defaultValue: LocalFieldIdSchemaV1.nullable(),
  options: z.array(HitlOptionSchemaV1).min(1).max(MAX_HITL_OPTIONS)
}).strict();
var HitlFieldSchemaV1 = z.discriminatedUnion("type", [
  TextFieldSchemaV1,
  NumberFieldSchemaV1,
  BooleanFieldSchemaV1,
  SelectFieldSchemaV1
]);
var InfoRequestSchemaV1 = z.object({
  kind: z.literal("info"),
  title: ShortTextSchemaV1,
  body: HitlContentSchemaV1,
  acknowledgeLabel: ShortTextSchemaV1
}).strict();
var ChoiceRequestSchemaV1 = z.object({
  kind: z.literal("choice"),
  title: ShortTextSchemaV1,
  body: HitlContentSchemaV1.optional(),
  multiple: z.boolean(),
  minSelections: z.number().int().safe().min(1).max(MAX_HITL_OPTIONS),
  maxSelections: z.number().int().safe().min(1).max(MAX_HITL_OPTIONS),
  options: z.array(HitlOptionSchemaV1).min(1).max(MAX_HITL_OPTIONS)
}).strict();
var FormRequestSchemaV1 = z.object({
  kind: z.literal("form"),
  title: ShortTextSchemaV1,
  body: HitlContentSchemaV1.optional(),
  fields: z.array(HitlFieldSchemaV1).min(1).max(MAX_HITL_FIELDS),
  submitLabel: ShortTextSchemaV1
}).strict();
var ConfirmationRequestSchemaV1 = z.object({
  kind: z.literal("confirmation"),
  title: ShortTextSchemaV1,
  body: HitlContentSchemaV1,
  impact: z.enum(["standard", "destructive"]),
  confirmLabel: ShortTextSchemaV1,
  cancelLabel: ShortTextSchemaV1
}).strict();
var HitlRequestDefinitionSchemaV1 = z.discriminatedUnion("kind", [
  InfoRequestSchemaV1,
  ChoiceRequestSchemaV1,
  FormRequestSchemaV1,
  ConfirmationRequestSchemaV1
]).superRefine((definition, context) => {
  if (definition.kind === "choice") {
    if (!uniqueOptions(definition.options))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["options"],
        message: "option IDs must be unique"
      });
    if (!definition.multiple && (definition.minSelections !== 1 || definition.maxSelections !== 1))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["minSelections"],
        message: "single choice requires bounds of one"
      });
    if (definition.minSelections > definition.maxSelections || definition.maxSelections > definition.options.length)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["maxSelections"],
        message: "selection bounds are invalid"
      });
  }
  if (definition.kind === "form") {
    const ids = /* @__PURE__ */ new Set();
    definition.fields.forEach((field, index) => {
      if (ids.has(field.id))
        context.addIssue({
          code: z.ZodIssueCode.custom,
          path: ["fields", index, "id"],
          message: "field IDs must be unique"
        });
      ids.add(field.id);
      if (field.type === "text") {
        if (field.minLength > field.maxLength)
          context.addIssue({
            code: z.ZodIssueCode.custom,
            path: ["fields", index, "maxLength"],
            message: "text bounds are invalid"
          });
        if (field.defaultValue !== null) {
          const length = Array.from(field.defaultValue).length;
          if (length < field.minLength || length > field.maxLength)
            context.addIssue({
              code: z.ZodIssueCode.custom,
              path: ["fields", index, "defaultValue"],
              message: "text default is outside bounds"
            });
        }
      } else if (field.type === "number") {
        if (field.min !== null && field.max !== null && field.min > field.max)
          context.addIssue({
            code: z.ZodIssueCode.custom,
            path: ["fields", index, "max"],
            message: "number bounds are invalid"
          });
        if (field.defaultValue !== null && (field.min !== null && field.defaultValue < field.min || field.max !== null && field.defaultValue > field.max))
          context.addIssue({
            code: z.ZodIssueCode.custom,
            path: ["fields", index, "defaultValue"],
            message: "number default is outside bounds"
          });
      } else if (field.type === "select") {
        if (!uniqueOptions(field.options))
          context.addIssue({
            code: z.ZodIssueCode.custom,
            path: ["fields", index, "options"],
            message: "option IDs must be unique"
          });
        if (field.defaultValue !== null && !field.options.some((option) => option.id === field.defaultValue))
          context.addIssue({
            code: z.ZodIssueCode.custom,
            path: ["fields", index, "defaultValue"],
            message: "select default is unknown"
          });
      }
    });
  }
});
var InfoResponseSchemaV1 = z.object({ kind: z.literal("info"), acknowledged: z.literal(true) }).strict();
var ChoiceResponseSchemaV1 = z.object({
  kind: z.literal("choice"),
  selectedOptionIds: z.array(LocalFieldIdSchemaV1).min(1).max(MAX_HITL_OPTIONS)
}).strict();
var FormResponseSchemaV1 = z.object({
  kind: z.literal("form"),
  values: z.record(
    LocalFieldIdSchemaV1,
    z.union([HitlTextValueSchemaV1, z.number().finite(), z.boolean(), z.null()])
  )
}).strict();
var ConfirmationResponseSchemaV1 = z.object({ kind: z.literal("confirmation"), confirmed: z.boolean() }).strict();
var HitlResponseSchemaV1 = z.discriminatedUnion("kind", [
  InfoResponseSchemaV1,
  ChoiceResponseSchemaV1,
  FormResponseSchemaV1,
  ConfirmationResponseSchemaV1
]).superRefine((response, context) => {
  if (response.kind === "choice" && new Set(response.selectedOptionIds).size !== response.selectedOptionIds.length)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["selectedOptionIds"],
      message: "selected option IDs must be unique"
    });
  if (response.kind === "form") {
    const count = Object.keys(response.values).length;
    if (count < 1 || count > MAX_HITL_FIELDS)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["values"],
        message: "[LIMIT:maxHitlFields] form value count is invalid"
      });
  }
});
var validateResponseAgainstDefinition = (definition, response) => {
  if (definition.kind !== response.kind) return "response kind does not match definition";
  if (definition.kind === "choice" && response.kind === "choice") {
    const known = new Set(definition.options.map((option) => option.id));
    if (response.selectedOptionIds.some((id) => !known.has(id)))
      return "response contains an unknown option";
    if (response.selectedOptionIds.length < definition.minSelections || response.selectedOptionIds.length > definition.maxSelections)
      return "response selection count is outside bounds";
  }
  if (definition.kind === "form" && response.kind === "form") {
    const keys = Object.keys(response.values);
    if (keys.length !== definition.fields.length || definition.fields.some((field) => !Object.hasOwn(response.values, field.id)))
      return "form response keys do not match fields";
    for (const field of definition.fields) {
      const value = response.values[field.id];
      if (value === null) {
        if (field.required) return "required form value is null";
        continue;
      }
      if (field.type === "text") {
        if (typeof value !== "string") return "text field value has wrong type";
        const length = Array.from(value).length;
        if (length < field.minLength || length > field.maxLength)
          return "text field value is outside bounds";
      } else if (field.type === "number") {
        if (typeof value !== "number") return "number field value has wrong type";
        if (field.min !== null && value < field.min || field.max !== null && value > field.max)
          return "number field value is outside bounds";
      } else if (field.type === "boolean") {
        if (typeof value !== "boolean") return "boolean field value has wrong type";
      } else if (typeof value !== "string" || !field.options.some((option) => option.id === value))
        return "select field value is unknown";
    }
  }
  return null;
};
var HitlInteractionSchemaV1 = z.object({
  hitlRequestId: HitlRequestIdSchemaV1,
  definition: HitlRequestDefinitionSchemaV1,
  state: z.enum(["open", "answered", "superseded", "expired", "cancelled"]),
  createdAt: TimestampSchemaV1,
  expiresAt: TimestampSchemaV1.nullable(),
  stateUpdatedAt: TimestampSchemaV1,
  response: HitlResponseSchemaV1.nullable(),
  answeredAt: TimestampSchemaV1.nullable()
}).strict().superRefine((interaction, context) => {
  const created = Date.parse(interaction.createdAt);
  const updated = Date.parse(interaction.stateUpdatedAt);
  const expires = interaction.expiresAt === null ? null : Date.parse(interaction.expiresAt);
  const answered = interaction.answeredAt === null ? null : Date.parse(interaction.answeredAt);
  if (expires !== null && expires <= created)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["expiresAt"],
      message: "expiry must follow creation"
    });
  if (interaction.state === "open") {
    if (interaction.response !== null || interaction.answeredAt !== null || updated !== created)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["stateUpdatedAt"],
        message: "open chronology is invalid"
      });
  } else if (interaction.state === "answered") {
    if (interaction.response === null || answered === null || answered <= created || updated !== answered || expires !== null && answered >= expires)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["answeredAt"],
        message: "answered chronology is invalid"
      });
    else {
      const problem = validateResponseAgainstDefinition(
        interaction.definition,
        interaction.response
      );
      if (problem)
        context.addIssue({ code: z.ZodIssueCode.custom, path: ["response"], message: problem });
    }
  } else if (interaction.state === "expired") {
    if (interaction.response !== null || interaction.answeredAt !== null || expires === null || updated < expires)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["expiresAt"],
        message: "expired chronology is invalid"
      });
  } else if (interaction.response !== null || interaction.answeredAt !== null || updated <= created || expires !== null && updated >= expires)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["stateUpdatedAt"],
      message: "terminal chronology is invalid"
    });
});
var HitlRequestSuccessSchemaV1 = HitlInteractionSchemaV1.refine(
  (interaction) => interaction.state === "open",
  { path: ["state"], message: "request success must be open" }
);
var HitlRespondSuccessSchemaV1 = HitlInteractionSchemaV1.refine(
  (interaction) => interaction.state === "answered",
  { path: ["state"], message: "respond success must be answered" }
);

// packages/board-schema/src/commands.ts
var SceneReplaceCommandSchemaV1 = z.object({ type: z.literal("scene.replace"), scene: SceneSchemaV1 }).strict();
var SceneClearCommandSchemaV1 = z.object({ type: z.literal("scene.clear") }).strict();
var SceneRestoreCommandSchemaV1 = z.object({ type: z.literal("scene.restore"), sourceRevisionId: RevisionIdSchemaV1 }).strict();
var HitlRequestCommandSchemaV1 = z.object({
  type: z.literal("hitl.request"),
  hitlRequestId: HitlRequestIdSchemaV1,
  request: HitlRequestDefinitionSchemaV1
}).strict();
var HitlRespondCommandSchemaV1 = z.object({
  type: z.literal("hitl.respond"),
  hitlRequestId: HitlRequestIdSchemaV1,
  response: HitlResponseSchemaV1
}).strict();
var ArtifactPublishCommandSchemaV1 = z.object({ type: z.literal("artifact.publish"), manifest: ArtifactManifestSchemaV1 }).strict();
var ArtifactStopCommandSchemaV1 = z.object({
  type: z.literal("artifact.stop"),
  artifact: ArtifactReferenceSchemaV1,
  reason: ShortTextSchemaV1.optional()
}).strict();
var DocumentReplaceCommandSchemaV2 = z.object({ type: z.literal("document.replace"), document: BoardDocumentSchemaV2 }).strict();
var DocumentReplaceCommandSchemaV3 = z.object({ type: z.literal("document.replace"), document: BoardDocumentSchemaV3 }).strict();
var BoardMutationCommandSchemaV1 = z.discriminatedUnion("type", [
  SceneReplaceCommandSchemaV1,
  SceneClearCommandSchemaV1,
  SceneRestoreCommandSchemaV1,
  HitlRequestCommandSchemaV1,
  HitlRespondCommandSchemaV1,
  ArtifactPublishCommandSchemaV1,
  ArtifactStopCommandSchemaV1
]);
var BoardMutationCommandSchemaV2 = z.discriminatedUnion("type", [
  SceneReplaceCommandSchemaV1,
  SceneClearCommandSchemaV1,
  SceneRestoreCommandSchemaV1,
  HitlRequestCommandSchemaV1,
  HitlRespondCommandSchemaV1,
  ArtifactPublishCommandSchemaV1,
  ArtifactStopCommandSchemaV1,
  DocumentReplaceCommandSchemaV2
]);
var BoardMutationCommandSchemaV3 = z.discriminatedUnion("type", [
  SceneReplaceCommandSchemaV1,
  SceneClearCommandSchemaV1,
  SceneRestoreCommandSchemaV1,
  HitlRequestCommandSchemaV1,
  HitlRespondCommandSchemaV1,
  ArtifactPublishCommandSchemaV1,
  ArtifactStopCommandSchemaV1,
  DocumentReplaceCommandSchemaV3
]);
var MutationRequestShapeV1 = {
  protocolVersion: z.literal(1),
  requestId: RequestIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV1,
  boardId: BoardIdSchemaV1,
  expectedRevisionId: RevisionIdSchemaV1,
  command: BoardMutationCommandSchemaV1
};
var MutationRequestShapeV2 = {
  ...MutationRequestShapeV1,
  command: BoardMutationCommandSchemaV2
};
var MutationRequestShapeV3 = {
  ...MutationRequestShapeV1,
  command: BoardMutationCommandSchemaV3
};
var MutationRequestSchemaV1 = z.object(MutationRequestShapeV1).strict();
var MutationEnvelopeSchemaV1 = z.object({ ...MutationRequestShapeV1, actor: ActorContextSchemaV1 }).strict();
var MutationRequestSchemaV2 = z.object(MutationRequestShapeV2).strict();
var MutationEnvelopeSchemaV2 = z.object({ ...MutationRequestShapeV2, actor: ActorContextSchemaV1 }).strict();
var MutationRequestSchemaV3 = z.object(MutationRequestShapeV3).strict();
var MutationEnvelopeSchemaV3 = z.object({ ...MutationRequestShapeV3, actor: ActorContextSchemaV1 }).strict();
var MutationResultDataSchemaV1 = z.discriminatedUnion("type", [
  z.object({ type: z.literal("scene.replace"), revision: RevisionSummarySchemaV1 }).strict(),
  z.object({ type: z.literal("scene.clear"), revision: RevisionSummarySchemaV1 }).strict(),
  z.object({
    type: z.literal("scene.restore"),
    sourceRevisionId: RevisionIdSchemaV1,
    revision: RevisionSummarySchemaV1
  }).strict(),
  z.object({ type: z.literal("hitl.request"), hitl: HitlRequestSuccessSchemaV1 }).strict(),
  z.object({ type: z.literal("hitl.respond"), hitl: HitlRespondSuccessSchemaV1 }).strict(),
  z.object({ type: z.literal("artifact.publish"), artifact: ArtifactRuntimeSummarySchemaV1 }).strict(),
  z.object({ type: z.literal("artifact.stop"), artifact: ArtifactRuntimeSummarySchemaV1 }).strict()
]);
var DocumentReplaceResultDataSchemaV2 = z.object({
  type: z.literal("document.replace"),
  revision: RevisionSummarySchemaV1,
  originType: z.literal("document.replace"),
  sourceRevisionId: z.null(),
  document: BoardDocumentSchemaV2
}).strict();
var MutationResultDataSchemaV2 = z.discriminatedUnion("type", [
  ...MutationResultDataSchemaV1.options,
  DocumentReplaceResultDataSchemaV2
]);
var DocumentReplaceResultDataSchemaV3 = z.object({
  type: z.literal("document.replace"),
  revision: RevisionSummarySchemaV1,
  originType: z.literal("document.replace"),
  sourceRevisionId: z.null(),
  document: BoardDocumentSchemaV3
}).strict();
var MutationResultDataSchemaV3 = z.discriminatedUnion("type", [
  ...MutationResultDataSchemaV1.options,
  DocumentReplaceResultDataSchemaV3
]);
var mutationResultSchema = (result) => z.object({
  protocolVersion: z.literal(1),
  type: z.literal("mutation.result"),
  requestId: RequestIdSchemaV1,
  boardId: BoardIdSchemaV1,
  replayed: z.boolean(),
  eventIds: z.array(EventIdSchemaV1),
  result
}).strict().superRefine((envelope, context) => {
  if (new Set(envelope.eventIds).size !== envelope.eventIds.length)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["eventIds"],
      message: "event IDs must be unique"
    });
});
var MutationResultSchemaV1 = mutationResultSchema(MutationResultDataSchemaV1);
var MutationResultSchemaV2 = mutationResultSchema(MutationResultDataSchemaV2);
var MutationResultSchemaV3 = mutationResultSchema(MutationResultDataSchemaV3);

// packages/board-schema/src/snapshots.ts
var SnapshotRevisionSchemaV1 = RevisionSummarySchemaV1.extend({
  previousRevisionId: RevisionIdSchemaV1.nullable(),
  originType: RevisionOriginTypeSchemaV1,
  sourceRevisionId: RevisionIdSchemaV1.nullable(),
  actor: ActorReferenceSchemaV1
}).strict();
var artifactKey = (artifact) => `${artifact.artifactId}\0${artifact.versionId}`;
var BoardSnapshotSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("board.snapshot"),
  boardId: BoardIdSchemaV1,
  revision: SnapshotRevisionSchemaV1,
  scene: SceneSchemaV1,
  hitl: z.array(HitlInteractionSchemaV1),
  artifacts: z.array(ArtifactRuntimeSummarySchemaV1),
  capabilities: BoardCapabilitiesSchemaV1,
  lastEventSequence: z.number().int().safe().min(0)
}).strict().superRefine((snapshot, context) => {
  if (snapshot.revision.revisionNumber === 1) {
    if (snapshot.revision.previousRevisionId !== null || snapshot.revision.originType !== "board.create" || snapshot.revision.sourceRevisionId !== null)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["revision"],
        message: "[INVALID_LAYOUT] initial revision metadata is invalid"
      });
  } else if (snapshot.revision.previousRevisionId === null || snapshot.revision.originType === "board.create" || snapshot.revision.originType === "scene.restore" !== (snapshot.revision.sourceRevisionId !== null))
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["revision"],
      message: "[INVALID_LAYOUT] revision lineage is invalid"
    });
  const hitlIds = /* @__PURE__ */ new Set();
  snapshot.hitl.forEach((interaction, index) => {
    if (hitlIds.has(interaction.hitlRequestId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["hitl", index, "hitlRequestId"],
        message: "[INVALID_LAYOUT] duplicate HITL interaction"
      });
    hitlIds.add(interaction.hitlRequestId);
  });
  const artifactKeys = /* @__PURE__ */ new Set();
  snapshot.artifacts.forEach((runtime, index) => {
    const key = artifactKey(runtime.artifact);
    if (artifactKeys.has(key))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["artifacts", index, "artifact"],
        message: "[INVALID_LAYOUT] duplicate artifact runtime summary"
      });
    artifactKeys.add(key);
  });
  for (const item of collectSceneNodesV1(snapshot.scene.root)) {
    if (item.node.type === "content.hitl" && !hitlIds.has(item.node.hitlRequestId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["scene", ...item.path, "hitlRequestId"],
        message: "[INVALID_LAYOUT] unresolved HITL reference"
      });
    const reference = item.node.type === "content.artifact" ? item.node.artifact : item.node.type === "content.image" ? item.node.source.artifact : null;
    if (reference && !artifactKeys.has(artifactKey(reference)))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [
          "scene",
          ...item.path,
          ...item.node.type === "content.image" ? ["source", "artifact"] : ["artifact"]
        ],
        message: "[INVALID_LAYOUT] unresolved artifact reference"
      });
  }
});
var BoardSnapshotSchemaV2 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("board.snapshot"),
  boardId: BoardIdSchemaV1,
  revision: SnapshotRevisionSchemaV1,
  document: BoardDocumentSchemaV2,
  hitl: z.array(HitlInteractionSchemaV1),
  artifacts: z.array(ArtifactRuntimeSummarySchemaV1),
  capabilities: BoardCapabilitiesSchemaV2,
  lastEventSequence: z.number().int().safe().min(0)
}).strict().superRefine((snapshot, context) => {
  if (snapshot.revision.revisionNumber === 1) {
    if (snapshot.revision.previousRevisionId !== null || snapshot.revision.originType !== "board.create" || snapshot.revision.sourceRevisionId !== null)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["revision"],
        message: "[INVALID_LAYOUT] initial revision metadata is invalid"
      });
  } else if (snapshot.revision.previousRevisionId === null || snapshot.revision.originType === "board.create" || snapshot.revision.originType === "scene.restore" !== (snapshot.revision.sourceRevisionId !== null))
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["revision"],
      message: "[INVALID_LAYOUT] revision lineage is invalid"
    });
  const hitlIds = /* @__PURE__ */ new Set();
  snapshot.hitl.forEach((interaction, index) => {
    if (hitlIds.has(interaction.hitlRequestId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["hitl", index, "hitlRequestId"],
        message: "[INVALID_LAYOUT] duplicate HITL interaction"
      });
    hitlIds.add(interaction.hitlRequestId);
  });
  const artifactKeys = /* @__PURE__ */ new Set();
  snapshot.artifacts.forEach((runtime, index) => {
    const key = artifactKey(runtime.artifact);
    if (artifactKeys.has(key))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["artifacts", index, "artifact"],
        message: "[INVALID_LAYOUT] duplicate artifact runtime summary"
      });
    artifactKeys.add(key);
  });
  for (const item of collectDocumentNodesV2(snapshot.document)) {
    if (item.node.type === "content.hitl" && !hitlIds.has(item.node.hitlRequestId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [...item.path, "hitlRequestId"],
        message: "[INVALID_DOCUMENT:unresolved_reference] unresolved HITL reference"
      });
    const reference = item.node.type === "content.artifact" ? item.node.artifact : item.node.type === "content.image" && item.node.source.type === "artifact.resource" ? item.node.source.artifact : null;
    if (reference && !artifactKeys.has(artifactKey(reference)))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [
          ...item.path,
          ...item.node.type === "content.image" ? ["source", "artifact"] : ["artifact"]
        ],
        message: "[INVALID_DOCUMENT:unresolved_reference] unresolved artifact reference"
      });
  }
});
var BoardSnapshotSchemaV3 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("board.snapshot"),
  boardId: BoardIdSchemaV1,
  revision: SnapshotRevisionSchemaV1,
  document: BoardDocumentSchemaV3,
  hitl: z.array(HitlInteractionSchemaV1),
  artifacts: z.array(ArtifactRuntimeSummarySchemaV1),
  capabilities: BoardCapabilitiesSchemaV3,
  lastEventSequence: z.number().int().safe().min(0)
}).strict().superRefine((snapshot, context) => {
  if (snapshot.revision.revisionNumber === 1) {
    if (snapshot.revision.previousRevisionId !== null || snapshot.revision.originType !== "board.create" || snapshot.revision.sourceRevisionId !== null)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["revision"],
        message: "[INVALID_LAYOUT] initial revision metadata is invalid"
      });
  } else if (snapshot.revision.previousRevisionId === null || snapshot.revision.originType === "board.create" || snapshot.revision.originType === "scene.restore" !== (snapshot.revision.sourceRevisionId !== null))
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["revision"],
      message: "[INVALID_LAYOUT] revision lineage is invalid"
    });
  const hitlIds = /* @__PURE__ */ new Set();
  snapshot.hitl.forEach((interaction, index) => {
    if (hitlIds.has(interaction.hitlRequestId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["hitl", index, "hitlRequestId"],
        message: "[INVALID_LAYOUT] duplicate HITL interaction"
      });
    hitlIds.add(interaction.hitlRequestId);
  });
  const artifactKeys = /* @__PURE__ */ new Set();
  snapshot.artifacts.forEach((runtime, index) => {
    const key = artifactKey(runtime.artifact);
    if (artifactKeys.has(key))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["artifacts", index, "artifact"],
        message: "[INVALID_LAYOUT] duplicate artifact runtime summary"
      });
    artifactKeys.add(key);
  });
  for (const item of collectDocumentNodesV2(snapshot.document)) {
    if (item.node.type === "content.hitl" && !hitlIds.has(item.node.hitlRequestId))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [...item.path, "hitlRequestId"],
        message: "[INVALID_DOCUMENT:unresolved_reference] unresolved HITL reference"
      });
    const reference = item.node.type === "content.artifact" ? item.node.artifact : item.node.type === "content.image" && item.node.source.type === "artifact.resource" ? item.node.source.artifact : null;
    if (reference && !artifactKeys.has(artifactKey(reference)))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [
          ...item.path,
          ...item.node.type === "content.image" ? ["source", "artifact"] : ["artifact"]
        ],
        message: "[INVALID_DOCUMENT:unresolved_reference] unresolved artifact reference"
      });
  }
});
var BoardSnapshotSchema = z.any().transform((value, context) => {
  const record2 = value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
  const hasScene = record2 ? Object.hasOwn(record2, "scene") : false;
  const hasDocument = record2 ? Object.hasOwn(record2, "document") : false;
  if (hasScene && hasDocument) {
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: [],
      message: "snapshot must contain exactly one of scene or document"
    });
    return z.NEVER;
  }
  const parsed = (hasDocument ? record2?.document !== null && typeof record2?.document === "object" && !Array.isArray(record2.document) && record2.document.schemaVersion === 3 ? BoardSnapshotSchemaV3 : BoardSnapshotSchemaV2 : BoardSnapshotSchemaV1).safeParse(value);
  if (!parsed.success) {
    parsed.error.issues.forEach((issue2) => context.addIssue(issue2));
    return z.NEVER;
  }
  return parsed.data;
});

// packages/board-schema/src/operations.ts
var policy = (operation, surfaces, requiredCapabilities, roles, runtimeOwner, viewerResourceScope = "none") => Object.freeze({
  operation,
  surfaces: Object.freeze([...surfaces]),
  requiredCapabilities: Object.freeze([...requiredCapabilities]),
  roles: Object.freeze({ ...roles }),
  viewerResourceScope,
  runtimeOwner
});
var allRoles = Object.freeze({ owner: true, editor: true, viewer: true });
var editors = Object.freeze({ owner: true, editor: true, viewer: false });
var owners = Object.freeze({ owner: true, editor: false, viewer: false });
var account = Object.freeze({ owner: false, editor: false, viewer: false });
var BOARD_OPERATION_AUTHORIZATION_MATRIX_V1 = Object.freeze([
  policy("board.list", ["browser", "mcp", "account_api_key"], ["board.read"], allRoles, "I-27"),
  policy(
    "board.get",
    ["browser", "mcp", "account_api_key"],
    ["board.read"],
    allRoles,
    "I-27",
    "all"
  ),
  policy(
    "capabilities.get",
    ["browser", "mcp", "account_api_key"],
    ["board.read"],
    allRoles,
    "I-27",
    "all"
  ),
  policy(
    "artifact.get",
    ["browser", "mcp", "account_api_key"],
    ["board.read"],
    allRoles,
    "I-27",
    "current_head"
  ),
  policy(
    "hitl.read",
    ["browser", "mcp", "account_api_key"],
    ["board.read"],
    allRoles,
    "I-27",
    "current_head"
  ),
  policy(
    "history.list",
    ["browser", "mcp", "account_api_key"],
    ["board.history.read"],
    editors,
    "I-27"
  ),
  policy(
    "history.get",
    ["browser", "mcp", "account_api_key"],
    ["board.history.read"],
    editors,
    "I-27"
  ),
  policy(
    "board.create",
    ["browser", "mcp", "account_api_key"],
    ["account.board.create"],
    account,
    "I-27"
  ),
  policy("board.rename", ["browser", "account_api_key"], ["board.write"], editors, "I-27"),
  policy(
    "document.replace",
    ["browser", "mcp", "account_api_key"],
    ["board.write"],
    editors,
    "I-19"
  ),
  policy("page.add", ["browser", "mcp"], ["board.write"], editors, "I-19"),
  policy("page.update", ["browser", "mcp"], ["board.write"], editors, "I-19"),
  policy("page.remove", ["browser", "mcp"], ["board.write"], editors, "I-19"),
  policy("page.reorder", ["browser", "mcp"], ["board.write"], editors, "I-19"),
  policy("page.default.set", ["browser", "mcp"], ["board.write"], editors, "I-19"),
  policy("scene.replace", ["browser", "mcp", "account_api_key"], ["board.write"], editors, "I-27"),
  policy("scene.clear", ["browser", "mcp", "account_api_key"], ["board.write"], editors, "I-27"),
  policy(
    "scene.restore",
    ["browser", "mcp", "account_api_key"],
    ["board.history.read", "board.write"],
    editors,
    "I-27"
  ),
  policy(
    "hitl.request",
    ["browser", "mcp", "account_api_key"],
    ["board.hitl.request"],
    editors,
    "I-27"
  ),
  policy(
    "hitl.respond",
    ["browser", "mcp", "account_api_key"],
    ["board.hitl.respond"],
    editors,
    "I-27"
  ),
  policy(
    "artifact.publish",
    ["browser", "mcp", "account_api_key"],
    ["artifact.publish"],
    editors,
    "I-27"
  ),
  policy(
    "artifact.stop",
    ["browser", "mcp", "account_api_key"],
    ["artifact.control"],
    editors,
    "I-27"
  ),
  policy("connection.create", ["browser"], ["connection.manage.own"], editors, "existing"),
  policy("connection.update", ["browser"], ["connection.manage.own"], editors, "existing"),
  policy("connection.revoke", ["browser"], ["connection.manage.own"], editors, "existing"),
  policy("board.archive", ["browser", "mcp", "account_api_key"], ["board.admin"], owners, "I-27"),
  policy("board.delete", ["browser"], ["board.admin"], owners, "I-27"),
  policy("membership.list", ["browser"], ["board.members.manage"], owners, "I-28"),
  policy("membership.invite", ["browser"], ["board.members.manage"], owners, "I-28"),
  policy("membership.role.update", ["browser"], ["board.members.manage"], owners, "I-28"),
  policy("membership.remove", ["browser"], ["board.members.manage"], owners, "I-28"),
  policy("ownership.transfer", ["browser"], ["board.members.manage"], owners, "I-28"),
  policy("share.list", ["browser"], ["board.share.manage"], owners, "I-29"),
  policy("share.publish", ["browser"], ["board.share.manage"], owners, "I-29"),
  policy("share.update", ["browser"], ["board.share.manage"], owners, "I-29"),
  policy("share.rotate", ["browser"], ["board.share.manage"], owners, "I-29"),
  policy("share.revoke", ["browser"], ["board.share.manage"], owners, "I-29"),
  policy("share.password.enable", ["browser"], ["board.share.manage"], owners, "I-30"),
  policy("share.password.regenerate", ["browser"], ["board.share.manage"], owners, "I-30"),
  policy("share.password.disable", ["browser"], ["board.share.manage"], owners, "I-30"),
  policy(
    "media.upload",
    ["browser", "mcp", "account_api_key"],
    ["board.media.write"],
    editors,
    "I-36/I-40"
  ),
  policy("analytics.report.get", ["browser"], ["board.analytics.read"], owners, "I-42"),
  policy("export.render", ["browser", "account_api_key"], ["export.read"], owners, "I-50", "all")
]);
var BoardOperationAuthorizationPolicySchemaV1 = z.object({
  operation: z.enum(BOARD_AUTHORIZATION_OPERATION_TYPES_V1),
  surfaces: z.array(z.enum(BOARD_AUTHORIZATION_SURFACES_V1)).min(1).superRefine((values, context) => {
    if (new Set(values).size !== values.length)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        message: "authorization surfaces must be unique"
      });
  }),
  requiredCapabilities: z.array(z.enum(BOARD_AUTHORIZATION_CAPABILITIES_V1)).min(1).superRefine((values, context) => {
    if (new Set(values).size !== values.length)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        message: "authorization capabilities must be unique"
      });
  }),
  roles: z.object({
    owner: z.boolean(),
    editor: z.boolean(),
    viewer: z.boolean()
  }).strict(),
  viewerResourceScope: z.enum(["none", "current_head", "all"]),
  runtimeOwner: z.string().min(1).max(64)
}).strict();
var BoardOperationAuthorizationMatrixSchemaV1 = z.array(BoardOperationAuthorizationPolicySchemaV1).length(BOARD_AUTHORIZATION_OPERATION_TYPES_V1.length).superRefine((rows, context) => {
  for (const [index, operation] of BOARD_AUTHORIZATION_OPERATION_TYPES_V1.entries()) {
    const row = rows[index];
    const expected = BOARD_OPERATION_AUTHORIZATION_MATRIX_V1[index];
    if (row?.operation !== operation)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [index, "operation"],
        message: "authorization matrix must exactly match operation catalog order"
      });
    if (row !== void 0 && expected !== void 0 && JSON.stringify(row) !== JSON.stringify(expected))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: [index],
        message: "authorization matrix row must exactly match the shared policy"
      });
  }
});
var PageCursorSchemaV1 = z.string().min(1).max(MAX_PAGE_CURSOR_CHARS).regex(/^[A-Za-z0-9_-]+$/).brand();
var BoardSummarySchemaV1 = z.object({
  boardId: BoardIdSchemaV1,
  title: ShortTextSchemaV1,
  createdAt: TimestampSchemaV1,
  updatedAt: TimestampSchemaV1,
  archivedAt: TimestampSchemaV1.nullable(),
  headRevision: RevisionSummarySchemaV1
}).strict();
var HistoryEntrySchemaV1 = z.object({
  revision: RevisionSummarySchemaV1,
  previousRevisionId: RevisionIdSchemaV1.nullable(),
  originType: RevisionOriginTypeSchemaV1,
  sourceRevisionId: RevisionIdSchemaV1.nullable(),
  actor: ActorReferenceSchemaV1
}).strict();
var requests = [
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("board.list"),
    cursor: PageCursorSchemaV1.nullable(),
    limit: z.number().int().min(1).max(MAX_PAGE_SIZE),
    includeArchived: z.boolean()
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("board.get"),
    boardId: BoardIdSchemaV1
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("board.create"),
    idempotencyKey: IdempotencyKeySchemaV1,
    title: ShortTextSchemaV1
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("board.archive"),
    idempotencyKey: IdempotencyKeySchemaV1,
    boardId: BoardIdSchemaV1,
    confirm: z.literal(true)
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("capabilities.get"),
    boardId: BoardIdSchemaV1
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("history.list"),
    boardId: BoardIdSchemaV1,
    cursor: PageCursorSchemaV1.nullable(),
    limit: z.number().int().min(1).max(MAX_PAGE_SIZE)
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("history.get"),
    boardId: BoardIdSchemaV1,
    revisionId: RevisionIdSchemaV1
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("artifact.get"),
    boardId: BoardIdSchemaV1,
    artifact: ArtifactReferenceSchemaV1
  }).strict(),
  z.object({
    protocolVersion: z.literal(1),
    requestId: RequestIdSchemaV1,
    type: z.literal("hitl.read"),
    boardId: BoardIdSchemaV1,
    hitlRequestId: HitlRequestIdSchemaV1,
    wait: z.object({
      afterStateUpdatedAt: TimestampSchemaV1,
      timeoutMs: z.number().int().min(0).max(MAX_HITL_WAIT_MS)
    }).strict().nullable()
  }).strict()
];
var BoardOperationRequestSchemaV1 = z.discriminatedUnion("type", [...requests]);
var BoardOperationEnvelopeSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("board.operation.envelope"),
  request: BoardOperationRequestSchemaV1,
  actor: ActorContextSchemaV1
}).strict();
var results = [
  z.object({
    type: z.literal("board.list"),
    boards: z.array(BoardSummarySchemaV1).max(MAX_PAGE_SIZE),
    nextCursor: PageCursorSchemaV1.nullable()
  }).strict(),
  z.object({
    type: z.literal("board.get"),
    board: BoardSummarySchemaV1,
    snapshot: BoardSnapshotSchema
  }).strict(),
  z.object({
    type: z.literal("board.create"),
    board: BoardSummarySchemaV1,
    snapshot: BoardSnapshotSchema
  }).strict(),
  z.object({ type: z.literal("board.archive"), board: BoardSummarySchemaV1 }).strict(),
  z.object({
    type: z.literal("capabilities.get"),
    capabilities: BoardCapabilitiesSchema,
    sessionAccess: BoardSessionAccessSchemaV1
  }).strict(),
  z.object({
    type: z.literal("history.list"),
    entries: z.array(HistoryEntrySchemaV1).max(MAX_PAGE_SIZE),
    nextCursor: PageCursorSchemaV1.nullable()
  }).strict(),
  z.object({
    type: z.literal("history.get"),
    entry: HistoryEntrySchemaV1,
    snapshot: BoardSnapshotSchema
  }).strict(),
  z.object({
    type: z.literal("artifact.get"),
    manifest: ArtifactManifestSchemaV1,
    runtime: ArtifactRuntimeSummarySchemaV1
  }).strict(),
  z.object({ type: z.literal("hitl.read"), changed: z.boolean(), hitl: HitlInteractionSchemaV1 }).strict()
];
var BoardOperationResultDataSchemaV1 = z.discriminatedUnion("type", [...results]);
var BoardOperationResultSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("board.operation.result"),
  requestId: RequestIdSchemaV1,
  replayed: z.boolean(),
  result: BoardOperationResultDataSchemaV1
}).strict().superRefine((envelope, context) => {
  const result = envelope.result;
  if (result.type !== "board.create" && result.type !== "board.archive" && envelope.replayed)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["replayed"],
      message: "read operation results cannot be replayed"
    });
  if (result.type === "board.get" || result.type === "board.create") {
    if (result.board.boardId !== result.snapshot.boardId || result.board.headRevision.revisionId !== result.snapshot.revision.revisionId)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["result", "snapshot"],
        message: "[INVALID_LAYOUT] board and snapshot do not correlate"
      });
    if (result.type === "board.create" && (result.snapshot.revision.revisionNumber !== 1 || ("scene" in result.snapshot ? result.snapshot.scene.root !== null : result.snapshot.document.pages.some(
      (page) => page.scene.root !== null
    ))))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["result", "snapshot"],
        message: "[INVALID_LAYOUT] create snapshot must be initial empty head"
      });
  } else if (result.type === "history.get" && result.entry.revision.revisionId !== result.snapshot.revision.revisionId)
    context.addIssue({
      code: z.ZodIssueCode.custom,
      path: ["result", "snapshot", "revision", "revisionId"],
      message: "[INVALID_LAYOUT] history revision does not correlate"
    });
  else if (result.type === "artifact.get") {
    const expected = `${result.manifest.artifact.artifactId}\0${result.manifest.artifact.versionId}`;
    const actual = `${result.runtime.artifact.artifactId}\0${result.runtime.artifact.versionId}`;
    if (expected !== actual)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["result", "runtime", "artifact"],
        message: "[INVALID_LAYOUT] artifact result does not correlate"
      });
  }
});

// packages/board-schema/src/errors.ts
var PathSchemaV12 = z.array(z.union([z.string(), z.number().int().min(0)]));
var ErrorBaseShapeV1 = {
  protocolVersion: z.literal(1),
  type: z.literal("board.error"),
  message: ShortTextSchemaV1
};
var branch = (code, category, retryable, httpStatusHint, details) => z.object({
  ...ErrorBaseShapeV1,
  code: z.literal(code),
  category: z.literal(category),
  retryable: z.literal(retryable),
  httpStatusHint: z.literal(httpStatusHint),
  details
}).strict();
var MutationReuseDetailsSchemaV1 = z.discriminatedUnion("scope", [
  z.object({
    scope: z.literal("board.mutation"),
    boardId: BoardIdSchemaV1,
    operationType: z.enum(BOARD_MUTATION_COMMAND_TYPES_V1),
    reason: z.enum([
      "grant_changed",
      "scopes_changed",
      "expected_revision_changed",
      "payload_changed"
    ])
  }).strict(),
  z.object({
    scope: z.literal("board.create"),
    boardId: z.null(),
    operationType: z.literal("board.create"),
    reason: z.enum(["grant_changed", "scopes_changed", "title_changed"])
  }).strict(),
  z.object({
    scope: z.literal("board.archive"),
    boardId: BoardIdSchemaV1,
    operationType: z.literal("board.archive"),
    reason: z.enum(["grant_changed", "scopes_changed"])
  }).strict()
]);
var LimitKeySchemaV1 = z.enum(
  Object.keys(BOARD_LIMITS_V1)
);
var AnyCapabilitySchemaV1 = z.union([
  z.enum(CLIENT_GRANT_CAPABILITIES_V1),
  z.enum(ARTIFACT_REQUEST_CAPABILITIES_V1)
]);
var BoardErrorSchemaV1 = z.discriminatedUnion("code", [
  branch(
    "INVALID_PAYLOAD",
    "validation",
    false,
    400,
    z.object({ path: PathSchemaV12, issue: ShortTextSchemaV1 }).strict()
  ),
  branch(
    "PROTOCOL_VERSION_MISMATCH",
    "protocol",
    false,
    409,
    z.object({
      reason: z.enum(["major", "schema_revision", "catalog", "limit"]),
      supportedMajor: z.literal(1),
      receivedMajor: z.number().int().min(0).nullable(),
      field: z.string().nullable()
    }).strict()
  ),
  branch(
    "UNKNOWN_NODE_TYPE",
    "validation",
    false,
    422,
    z.object({ path: PathSchemaV12, receivedType: z.string() }).strict()
  ),
  branch(
    "UNKNOWN_COMMAND_TYPE",
    "validation",
    false,
    422,
    z.object({ path: PathSchemaV12, receivedType: z.string() }).strict()
  ),
  branch(
    "UNKNOWN_OPERATION_TYPE",
    "validation",
    false,
    422,
    z.object({ path: PathSchemaV12, receivedType: z.string() }).strict()
  ),
  branch(
    "INVALID_LAYOUT",
    "validation",
    false,
    422,
    z.object({
      path: PathSchemaV12,
      reason: z.enum(["bounds", "overlap", "reference", "geometry"])
    }).strict()
  ),
  branch(
    "DUPLICATE_NODE_ID",
    "validation",
    false,
    422,
    z.object({ nodeId: NodeIdSchemaV1, firstPath: PathSchemaV12, duplicatePath: PathSchemaV12 }).strict()
  ),
  branch(
    "LIMIT_EXCEEDED",
    "validation",
    false,
    422,
    z.object({
      limit: LimitKeySchemaV1,
      actual: z.number().finite().min(0),
      maximum: z.number().finite().min(0),
      path: PathSchemaV12
    }).strict()
  ),
  branch(
    "PAYLOAD_TOO_LARGE",
    "validation",
    false,
    413,
    z.object({
      scope: z.enum([
        "envelope",
        "scene",
        "hitl.response",
        "artifact.resource",
        "artifact.total",
        "document",
        "document.page",
        "document.envelope"
      ]),
      actualBytes: z.number().int().safe().min(0),
      maximumBytes: z.number().int().safe().positive()
    }).strict()
  ),
  branch("UNAUTHENTICATED", "auth", false, 401, z.null()),
  branch("FORBIDDEN", "auth", false, 403, z.null()),
  branch(
    "CAPABILITY_DENIED",
    "auth",
    false,
    403,
    z.object({ capability: AnyCapabilitySchemaV1 }).strict()
  ),
  branch("BOARD_NOT_FOUND", "not_found", false, 404, z.null()),
  branch(
    "REVISION_NOT_FOUND",
    "not_found",
    false,
    404,
    z.object({ revisionId: RevisionIdSchemaV1 }).strict()
  ),
  branch(
    "ARTIFACT_NOT_FOUND",
    "not_found",
    false,
    404,
    z.object({ artifact: ArtifactReferenceSchemaV1 }).strict()
  ),
  branch(
    "HITL_REQUEST_NOT_FOUND",
    "not_found",
    false,
    404,
    z.object({ hitlRequestId: HitlRequestIdSchemaV1 }).strict()
  ),
  branch(
    "BOARD_ALREADY_ARCHIVED",
    "conflict",
    false,
    409,
    z.object({ boardId: BoardIdSchemaV1, archivedAt: TimestampSchemaV1 }).strict()
  ),
  branch(
    "REVISION_CONFLICT",
    "conflict",
    false,
    409,
    z.object({
      boardId: BoardIdSchemaV1,
      expectedRevisionId: RevisionIdSchemaV1,
      actualRevisionId: RevisionIdSchemaV1,
      actualRevisionNumber: z.number().int().safe().positive(),
      recovery: z.literal("fetch_latest_then_retry")
    }).strict()
  ),
  branch("IDEMPOTENCY_KEY_REUSED", "conflict", false, 409, MutationReuseDetailsSchemaV1),
  branch(
    "HITL_REQUEST_ID_CONFLICT",
    "conflict",
    false,
    409,
    z.object({ hitlRequestId: HitlRequestIdSchemaV1 }).strict()
  ),
  branch(
    "HITL_RESPONSE_CONFLICT",
    "conflict",
    false,
    409,
    z.object({
      hitlRequestId: HitlRequestIdSchemaV1,
      state: z.enum(["answered", "superseded", "cancelled"])
    }).strict()
  ),
  branch(
    "HITL_REQUEST_EXPIRED",
    "conflict",
    false,
    410,
    z.object({ hitlRequestId: HitlRequestIdSchemaV1, expiredAt: TimestampSchemaV1 }).strict()
  ),
  branch(
    "RATE_LIMITED",
    "rate_limit",
    true,
    429,
    z.object({ retryAfterSeconds: z.number().finite().positive() }).strict()
  ),
  branch(
    "SERVICE_UNAVAILABLE",
    "availability",
    true,
    503,
    z.object({ retryAfterSeconds: z.number().finite().positive().nullable() }).strict()
  ),
  branch("INTERNAL_ERROR", "internal", false, 500, z.null())
]);
var BoardErrorSchemaV2Only = z.discriminatedUnion("code", [
  branch(
    "INVALID_REQUEST",
    "validation",
    false,
    400,
    z.object({
      reason: z.enum([
        "request_id",
        "framing",
        "content_type",
        "length",
        "digest",
        "idempotency_key"
      ])
    }).strict()
  ),
  branch(
    "IDEMPOTENCY_KEY_REUSED",
    "conflict",
    false,
    409,
    z.discriminatedUnion("scope", [
      z.object({
        scope: z.literal("board.mutation"),
        boardId: BoardIdSchemaV1,
        operationType: z.enum(BOARD_MUTATION_COMMAND_TYPES_V2),
        reason: z.enum([
          "grant_changed",
          "scopes_changed",
          "expected_revision_changed",
          "payload_changed"
        ])
      }).strict(),
      z.object({ scope: z.literal("media.ingest") }).strict()
    ])
  ),
  branch(
    "DOCUMENT_VERSION_MISMATCH",
    "conflict",
    false,
    409,
    z.object({
      headSchemaVersion: z.union([z.literal(1), z.literal(2)]),
      commandSchemaVersion: z.union([z.literal(1), z.literal(2)]),
      commandType: z.enum(["scene.replace", "scene.clear", "scene.restore", "document.replace"])
    }).strict()
  ),
  branch(
    "INVALID_DOCUMENT",
    "validation",
    false,
    422,
    z.object({
      path: PathSchemaV12,
      reason: z.enum([
        "page_count",
        "duplicate_page_id",
        "default_page_missing",
        "invalid_display_mode",
        "duplicate_node_id",
        "unresolved_reference",
        "limit"
      ])
    }).strict()
  ),
  branch(
    "INVALID_MEDIA_REFERENCE",
    "validation",
    false,
    400,
    z.object({ reason: z.literal("unavailable") }).strict()
  ),
  branch(
    "IDEMPOTENCY_RESULT_EXPIRED",
    "conflict",
    false,
    409,
    z.object({ scope: z.literal("media.ingest") }).strict()
  ),
  branch(
    "PAYLOAD_TOO_LARGE",
    "validation",
    false,
    413,
    z.object({ limitBytes: z.literal(10485760) }).strict()
  ),
  branch(
    "INVALID_MEDIA_UPLOAD",
    "validation",
    false,
    422,
    z.object({
      reason: z.enum([
        "format",
        "dimensions",
        "pixels",
        "ratio",
        "animated",
        "canonical_size",
        "decode",
        "quota"
      ])
    }).strict()
  ),
  branch(
    "RANGE_NOT_SATISFIABLE",
    "validation",
    false,
    416,
    z.object({ length: z.number().int().safe().positive() }).strict()
  ),
  branch(
    "METHOD_NOT_ALLOWED",
    "validation",
    false,
    405,
    z.object({ allow: z.literal("GET") }).strict()
  )
]);
var UpgradeRequiredErrorSchemaV3 = branch(
  "UPGRADE_REQUIRED",
  "conflict",
  false,
  409,
  z.union([
    z.object({
      headSchemaVersion: z.literal(3),
      requestedDocumentSchemaVersion: z.union([z.literal(1), z.literal(2)]),
      operationType: z.enum(BOARD_MUTATION_COMMAND_TYPES_V2)
    }).strict(),
    z.object({
      headSchemaVersion: z.literal(3),
      requestedDocumentSchemaVersion: z.union([z.literal(1), z.literal(2)]),
      surface: z.enum(["board.get", "board.stream", "history"])
    }).strict()
  ])
);
var BoardErrorSchema = z.union([
  BoardErrorSchemaV1,
  BoardErrorSchemaV2Only,
  UpgradeRequiredErrorSchemaV3
]);

// packages/board-schema/src/events.ts
var PresenceSummarySchemaV1 = z.object({
  principal: ActorReferenceSchemaV1,
  state: z.enum(["online", "away"]),
  lastSeenAt: TimestampSchemaV1
}).strict();
var BoardEventDataSchemaV1 = z.discriminatedUnion("type", [
  z.object({ type: z.literal("board.snapshot"), snapshot: BoardSnapshotSchemaV1 }).strict(),
  z.object({
    type: z.literal("board.revision.created"),
    revision: RevisionSummarySchemaV1,
    originType: RevisionOriginTypeSchemaV1,
    sourceRevisionId: RevisionIdSchemaV1.nullable()
  }).strict(),
  z.object({ type: z.literal("hitl.updated"), hitl: HitlInteractionSchemaV1 }).strict(),
  z.object({
    type: z.literal("artifact.status.changed"),
    artifact: ArtifactRuntimeSummarySchemaV1
  }).strict(),
  z.object({ type: z.literal("presence.updated"), presence: z.array(PresenceSummarySchemaV1) }).strict(),
  z.object({
    type: z.literal("stream.resync.required"),
    durableHeadRevisionId: RevisionIdSchemaV1,
    lastUsableSequence: z.number().int().safe().min(0),
    reason: z.enum(["gap", "expired_cursor", "server_reset"])
  }).strict(),
  z.object({ type: z.literal("stream.heartbeat"), sentAt: TimestampSchemaV1 }).strict(),
  z.object({ type: z.literal("stream.error"), error: BoardErrorSchemaV1 }).strict()
]);
var BoardEventDataSchemaV2 = z.discriminatedUnion("type", [
  z.object({ type: z.literal("board.snapshot"), snapshot: BoardSnapshotSchema }).strict(),
  z.object({
    type: z.literal("board.revision.created"),
    revision: RevisionSummarySchemaV1,
    originType: RevisionOriginTypeSchemaV1,
    sourceRevisionId: RevisionIdSchemaV1.nullable()
  }).strict(),
  z.object({ type: z.literal("hitl.updated"), hitl: HitlInteractionSchemaV1 }).strict(),
  z.object({
    type: z.literal("artifact.status.changed"),
    artifact: ArtifactRuntimeSummarySchemaV1
  }).strict(),
  z.object({ type: z.literal("presence.updated"), presence: z.array(PresenceSummarySchemaV1) }).strict(),
  z.object({
    type: z.literal("stream.resync.required"),
    durableHeadRevisionId: RevisionIdSchemaV1,
    lastUsableSequence: z.number().int().safe().min(0),
    reason: z.enum(["gap", "expired_cursor", "server_reset"])
  }).strict(),
  z.object({ type: z.literal("stream.heartbeat"), sentAt: TimestampSchemaV1 }).strict(),
  z.object({ type: z.literal("stream.error"), error: BoardErrorSchema }).strict()
]);
var validateBoardEventEnvelope = (event, context) => {
  const data = event.data;
  if (data.type === "board.snapshot") {
    if (event.boardId !== data.snapshot.boardId)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["data", "snapshot", "boardId"],
        message: "[INVALID_LAYOUT:reference] snapshot board ID mismatch"
      });
    if (event.revisionId !== data.snapshot.revision.revisionId)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["revisionId"],
        message: "[INVALID_LAYOUT:reference] snapshot revision mismatch"
      });
    if (event.sequence !== data.snapshot.lastEventSequence)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["data", "snapshot", "lastEventSequence"],
        message: "[INVALID_LAYOUT:reference] snapshot watermark mismatch"
      });
  } else if (data.type === "board.revision.created") {
    if (event.revisionId !== data.revision.revisionId)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["revisionId"],
        message: "[INVALID_LAYOUT:reference] revision event mismatch"
      });
    if (data.originType === "scene.restore" !== (data.sourceRevisionId !== null))
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["data", "sourceRevisionId"],
        message: "[INVALID_LAYOUT:reference] restore source mismatch"
      });
  } else {
    if (event.revisionId !== null)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["revisionId"],
        message: "[INVALID_LAYOUT:reference] control event revision must be null"
      });
    if (data.type === "stream.resync.required" && data.lastUsableSequence >= event.sequence)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["data", "lastUsableSequence"],
        message: "[INVALID_LAYOUT:reference] resync sequence is stale"
      });
    if (data.type === "stream.heartbeat" && data.sentAt !== event.occurredAt)
      context.addIssue({
        code: z.ZodIssueCode.custom,
        path: ["data", "sentAt"],
        message: "[INVALID_LAYOUT:reference] heartbeat timestamp mismatch"
      });
    if (data.type === "presence.updated") {
      const keys = data.presence.map(
        ({ principal }) => `${principal.principalKind}\0${principal.principalId}`
      );
      for (let index = 1; index < keys.length; index += 1)
        if ((keys[index - 1] ?? "") >= (keys[index] ?? "")) {
          context.addIssue({
            code: z.ZodIssueCode.custom,
            path: ["data", "presence"],
            message: "[INVALID_LAYOUT:reference] presence must be sorted and unique"
          });
          break;
        }
    }
  }
};
var createBoardEventEnvelopeSchema = (dataSchema) => z.object({
  protocolVersion: z.literal(1),
  type: z.literal("board.event"),
  boardId: BoardIdSchemaV1,
  eventId: EventIdSchemaV1,
  sequence: z.number().int().safe().positive(),
  occurredAt: TimestampSchemaV1,
  revisionId: RevisionIdSchemaV1.nullable(),
  data: dataSchema
}).strict().superRefine(
  (event, context) => validateBoardEventEnvelope(event, context)
);
var BoardEventEnvelopeSchemaV1 = createBoardEventEnvelopeSchema(BoardEventDataSchemaV1);
var BoardEventEnvelopeSchemaV2 = createBoardEventEnvelopeSchema(BoardEventDataSchemaV2);

// packages/board-schema/src/history.ts
var PrintableAscii160SchemaV1 = z.string().min(1).max(160).regex(/^[\x20-\x7e]+$/u);
var RetainedHistoryActorLabelSchemaV1 = z.enum(["self", "owner", "editor", "system"]);
var RetainedHistoryMetadataSchemaV1 = z.object({
  protocolVersion: z.literal(1),
  type: z.literal("history.retained-metadata"),
  entries: z.array(
    z.object({
      revisionId: RevisionIdSchemaV1,
      label: PrintableAscii160SchemaV1,
      actorLabel: RetainedHistoryActorLabelSchemaV1,
      summary: PrintableAscii160SchemaV1,
      schemaVersion: z.enum(["1.0.0", "2.0.0", "3.0.0"])
    }).strict()
  ).max(100),
  boundary: z.object({
    truncatedBefore: z.boolean(),
    oldestRetainedRevisionId: RevisionIdSchemaV1
  }).strict(),
  navigation: z.object({
    revisionId: RevisionIdSchemaV1,
    previous: z.union([
      z.object({ kind: z.literal("revision"), revisionId: RevisionIdSchemaV1 }).strict(),
      z.object({ kind: z.literal("truncated") }).strict()
    ]).nullable(),
    nextRevisionId: RevisionIdSchemaV1.nullable(),
    latestRevisionId: RevisionIdSchemaV1
  }).strict().nullable()
}).strict();

// packages/board-schema/src/parser-kernel.ts
var isPlainObject3 = (value) => {
  const prototype = Object.getPrototypeOf(value);
  return prototype === Object.prototype || prototype === null;
};
var validateJsonValueV1 = (input) => {
  const active = /* @__PURE__ */ new WeakSet();
  const stack = [{ value: input, path: [], depth: 1 }];
  while (stack.length > 0) {
    const frame = stack.pop();
    if (!frame) break;
    const { value, path, depth } = frame;
    if (frame.exiting && typeof value === "object" && value !== null) {
      active.delete(value);
      continue;
    }
    if (depth > MAX_JSON_DEPTH) {
      return {
        ok: false,
        issue: {
          kind: "json_depth",
          path,
          message: "JSON depth exceeded",
          actual: depth,
          maximum: MAX_JSON_DEPTH
        }
      };
    }
    if (value === null || typeof value === "boolean") continue;
    if (typeof value === "number") {
      if (!Number.isFinite(value))
        return {
          ok: false,
          issue: { kind: "invalid_json", path, message: "number must be finite" }
        };
      continue;
    }
    if (typeof value === "string") {
      if (hasLoneSurrogateV1(value))
        return {
          ok: false,
          issue: { kind: "invalid_json", path, message: "lone surrogate is not allowed" }
        };
      continue;
    }
    if (typeof value !== "object")
      return { ok: false, issue: { kind: "invalid_json", path, message: "value is not JSON" } };
    if (active.has(value))
      return {
        ok: false,
        issue: { kind: "invalid_json", path, message: "cyclic values are not allowed" }
      };
    if (Object.getOwnPropertySymbols(value).length > 0) {
      return {
        ok: false,
        issue: { kind: "invalid_json", path, message: "symbol keys are not allowed" }
      };
    }
    if (!Array.isArray(value) && !isPlainObject3(value)) {
      return {
        ok: false,
        issue: { kind: "invalid_json", path, message: "object must have a plain prototype" }
      };
    }
    const keys = Object.keys(value);
    const ownStringKeys = Object.getOwnPropertyNames(value).filter(
      (key) => !Array.isArray(value) || key !== "length"
    );
    if (ownStringKeys.length !== keys.length) {
      return {
        ok: false,
        issue: { kind: "invalid_json", path, message: "non-enumerable properties are not allowed" }
      };
    }
    if (keys.length > MAX_JSON_CONTAINER_ENTRIES) {
      return {
        ok: false,
        issue: {
          kind: "json_container_entries",
          path,
          message: "JSON container entries exceeded",
          actual: keys.length,
          maximum: MAX_JSON_CONTAINER_ENTRIES
        }
      };
    }
    if (Array.isArray(value) && keys.length !== value.length) {
      return {
        ok: false,
        issue: { kind: "invalid_json", path, message: "sparse arrays are not allowed" }
      };
    }
    const descriptors = Object.getOwnPropertyDescriptors(value);
    for (const key of keys) {
      const descriptor = descriptors[key];
      if (!descriptor || descriptor.get || descriptor.set) {
        return {
          ok: false,
          issue: {
            kind: "invalid_json",
            path: [...path, key],
            message: "accessors are not allowed"
          }
        };
      }
      if (hasLoneSurrogateV1(key)) {
        return {
          ok: false,
          issue: {
            kind: "invalid_json",
            path: [...path, key],
            message: "lone surrogate key is not allowed"
          }
        };
      }
    }
    active.add(value);
    stack.push({ ...frame, exiting: true });
    for (let index = keys.length - 1; index >= 0; index -= 1) {
      const key = keys[index];
      if (key === void 0) continue;
      stack.push({
        value: value[key],
        path: [...path, Array.isArray(value) ? Number(key) : key],
        depth: depth + 1
      });
    }
  }
  return {
    ok: true,
    value: input,
    canonicalBytes: canonicalBytesV1(input)
  };
};
var canonicalBytesV1 = (input) => {
  const output = [];
  const stack = [{ kind: "value", value: input }];
  while (stack.length > 0) {
    const task = stack.pop();
    if (!task) break;
    if (task.kind === "token") {
      output.push(task.value);
      continue;
    }
    const { value } = task;
    if (value === null) output.push("null");
    else if (typeof value === "boolean") output.push(value ? "true" : "false");
    else if (typeof value === "number") output.push(serializeJsonNumberV1(value));
    else if (typeof value === "string") output.push(serializeJsonStringV1(value));
    else if (Array.isArray(value)) {
      stack.push({ kind: "token", value: "]" });
      for (let index = value.length - 1; index >= 0; index -= 1) {
        stack.push({ kind: "value", value: value[index] });
        if (index > 0) stack.push({ kind: "token", value: "," });
      }
      stack.push({ kind: "token", value: "[" });
    } else {
      const keys = Object.keys(value).sort(compareUnicodeScalarsV1);
      stack.push({ kind: "token", value: "}" });
      for (let index = keys.length - 1; index >= 0; index -= 1) {
        const key = keys[index];
        if (key === void 0) continue;
        stack.push({ kind: "value", value: value[key] });
        stack.push({ kind: "token", value: ":" });
        stack.push({ kind: "token", value: serializeJsonStringV1(key) });
        if (index > 0) stack.push({ kind: "token", value: "," });
      }
      stack.push({ kind: "token", value: "{" });
    }
  }
  return new TextEncoder().encode(output.join(""));
};
var hasDuplicateObjectKeysV1 = (source) => {
  const stack = [];
  for (let index = 0; index < source.length; index += 1) {
    const character = source[index];
    if (character === '"') {
      let end = index + 1;
      while (end < source.length) {
        if (source[end] === "\\") end += 2;
        else if (source[end] === '"') break;
        else end += 1;
      }
      const frame = stack.at(-1);
      if (frame?.kind === "object" && frame.expectsKey) {
        try {
          const key = JSON.parse(source.slice(index, end + 1));
          if (frame.keys?.has(key)) return true;
          frame.keys?.add(key);
        } catch {
          return false;
        }
      }
      index = end;
    } else if (character === "{") stack.push({ kind: "object", keys: /* @__PURE__ */ new Set(), expectsKey: true });
    else if (character === "[") stack.push({ kind: "array" });
    else if (character === "}" || character === "]") stack.pop();
    else if (character === ":") {
      const frame = stack.at(-1);
      if (frame?.kind === "object") frame.expectsKey = false;
    } else if (character === ",") {
      const frame = stack.at(-1);
      if (frame?.kind === "object") frame.expectsKey = true;
    }
  }
  return false;
};
var runDecodedKernelV1 = validateJsonValueV1;
var runBytesKernel = (bytes, maximumBytes, message) => {
  if (bytes.byteLength > maximumBytes) {
    return {
      ok: false,
      issue: {
        kind: "payload_too_large",
        path: [],
        message,
        actual: bytes.byteLength,
        maximum: maximumBytes
      }
    };
  }
  let source;
  try {
    source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
  } catch {
    return { ok: false, issue: { kind: "invalid_json", path: [], message: "malformed UTF-8" } };
  }
  if (hasDuplicateObjectKeysV1(source)) {
    return {
      ok: false,
      issue: { kind: "invalid_json", path: [], message: "duplicate object member" }
    };
  }
  let input;
  try {
    input = JSON.parse(source);
  } catch {
    return { ok: false, issue: { kind: "invalid_json", path: [], message: "malformed JSON" } };
  }
  return validateJsonValueV1(input);
};
var runBytesKernelV1 = (bytes) => runBytesKernel(bytes, MAX_ENVELOPE_BYTES, "envelope byte limit exceeded");
var runDocumentBytesKernelV2 = (bytes) => runBytesKernel(bytes, MAX_DOCUMENT_ENVELOPE_BYTES, "document envelope byte limit exceeded");
var applySchemaV1 = (schema, kernel) => {
  if (!kernel.ok) return kernel;
  const parsed = schema.safeParse(kernel.value);
  if (!parsed.success) {
    const issue2 = parsed.error.issues[0];
    return {
      ok: false,
      issue: {
        kind: "schema",
        path: issue2?.path ?? [],
        message: issue2?.message ?? "invalid payload"
      }
    };
  }
  return { ok: true, value: parsed.data, canonicalBytes: kernel.canonicalBytes };
};

// packages/board-schema/src/parsers.ts
var invalidPayload = (path, issue2) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "INVALID_PAYLOAD",
  message: "Invalid payload",
  category: "validation",
  retryable: false,
  httpStatusHint: 400,
  details: { path, issue: issue2.slice(0, 200) || "invalid payload" }
});
var protocolMismatch = (receivedMajor, reason = "major", field = "protocolVersion") => ({
  protocolVersion: 1,
  type: "board.error",
  code: "PROTOCOL_VERSION_MISMATCH",
  message: "Protocol version mismatch",
  category: "protocol",
  retryable: false,
  httpStatusHint: 409,
  details: { reason, supportedMajor: 1, receivedMajor, field }
});
var payloadTooLarge = (scope, actualBytes, maximumBytes) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "PAYLOAD_TOO_LARGE",
  message: "Payload is too large",
  category: "validation",
  retryable: false,
  httpStatusHint: 413,
  details: { scope, actualBytes, maximumBytes }
});
var limitExceeded = (limit, actual, path) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "LIMIT_EXCEEDED",
  message: "Contract limit exceeded",
  category: "validation",
  retryable: false,
  httpStatusHint: 422,
  details: { limit, actual, maximum: BOARD_LIMITS_V1[limit], path }
});
var invalidLayout = (path, reason) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "INVALID_LAYOUT",
  message: "Layout correlation is invalid",
  category: "validation",
  retryable: false,
  httpStatusHint: 422,
  details: { path, reason }
});
var kernelError = (issue2, documentProfile = false) => {
  if (issue2.kind === "payload_too_large")
    return payloadTooLarge(
      documentProfile ? "document.envelope" : "envelope",
      issue2.actual ?? 0,
      issue2.maximum ?? (documentProfile ? MAX_DOCUMENT_ENVELOPE_BYTES : BOARD_LIMITS_V1.maxEnvelopeBytes)
    );
  if (issue2.kind === "json_depth")
    return limitExceeded(
      "maxJsonDepth",
      issue2.actual ?? BOARD_LIMITS_V1.maxJsonDepth + 1,
      issue2.path
    );
  if (issue2.kind === "json_container_entries")
    return limitExceeded(
      "maxJsonContainerEntries",
      issue2.actual ?? BOARD_LIMITS_V1.maxJsonContainerEntries + 1,
      issue2.path
    );
  return invalidPayload(issue2.path, issue2.message);
};
var kernelErrorV1 = (issue2) => kernelError(issue2);
var valueAtPath = (input, path) => path.reduce(
  (value, key) => value !== null && typeof value === "object" ? value[key] : void 0,
  input
);
var actualSize = (value) => Array.isArray(value) ? value.length : typeof value === "string" ? scalarLengthV1(value) : value !== null && typeof value === "object" ? Object.keys(value).length : typeof value === "number" ? value : 0;
var actualForLimit = (input, path, limit) => {
  const value = valueAtPath(input, path);
  if (limit === "maxArtifactTotalBytes" && Array.isArray(value)) {
    return value.reduce(
      (total, resource) => total + (isRecord2(resource) && typeof resource.byteLength === "number" ? resource.byteLength : 0),
      0
    );
  }
  if (limit === "maxTableCells") {
    const table = valueAtPath(input, path.slice(0, -1));
    if (isRecord2(table) && Array.isArray(table.columns) && Array.isArray(table.rows))
      return table.columns.length * table.rows.length;
  }
  if (limit === "maxChartPoints" && Array.isArray(value)) {
    return value.reduce(
      (total, series) => total + (isRecord2(series) && Array.isArray(series.points) ? series.points.length : 0),
      0
    );
  }
  return actualSize(value);
};
var inferLimitKey = (input, path, message) => {
  if (!/at most|less than or equal|too_big/i.test(message)) return null;
  const field = path.at(-1);
  const parent = valueAtPath(input, path.slice(0, -1));
  const parentType = isRecord2(parent) && typeof parent.type === "string" ? parent.type : null;
  if (field === "children") {
    if (parentType === "layout.split") return "maxSplitChildren";
    if (parentType === "layout.grid") return "maxGridItems";
    if (parentType === "layout.canvas") return "maxCanvasItems";
  }
  if (field === "tabs") return "maxTabs";
  if (field === "columns")
    return parentType === "layout.grid" ? "maxGridColumns" : "maxTableColumns";
  if (field === "rows") return parentType === "layout.grid" ? "maxGridRows" : "maxTableRows";
  if (field === "width" || field === "height" || field === "gap") return "maxCanvasExtent";
  if (field === "options" || field === "selectedOptionIds") return "maxHitlOptions";
  if (field === "fields" || field === "values") return "maxHitlFields";
  if (field === "minLength" || field === "maxLength") return "maxHitlTextChars";
  if (field === "resources") return "maxArtifactResources";
  if (field === "series") return "maxChartSeries";
  if (field === "features") return "maxMapFeatures";
  if (field === "elements") return "maxDrawingElements";
  if (field === "byteLength") return "maxArtifactResourceBytes";
  if (field === "limit" || field === "boards" || field === "entries") return "maxPageSize";
  if (field === "cursor") return "maxPageCursorChars";
  if (field === "timeoutMs") return "maxHitlWaitMs";
  return null;
};
var invalidDocument2 = (path, reason) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "INVALID_DOCUMENT",
  message: "Invalid document",
  category: "validation",
  retryable: false,
  httpStatusHint: 422,
  details: { path, reason }
});
var mapSchemaIssue = (input, issue2, kind) => {
  const documentMatch = /^\[INVALID_DOCUMENT:([^\]]+)\]/u.exec(issue2.message);
  if (documentMatch)
    return invalidDocument2(
      issue2.path,
      documentMatch[1]
    );
  const knownDocument = kind === "document" || findDocumentValues(input).some(
    ({ value }) => value.schemaVersion === 2 || value.schemaVersion === 3
  );
  if (knownDocument) {
    if (issue2.path.at(-1) === "displayMode")
      return invalidDocument2(issue2.path, "invalid_display_mode");
    if (issue2.message.startsWith("[DUPLICATE_NODE_ID:"))
      return invalidDocument2(issue2.path, "duplicate_node_id");
    if (issue2.message.includes("reference") || issue2.message.includes("missing"))
      return invalidDocument2(issue2.path, "unresolved_reference");
    return invalidDocument2(issue2.path, "limit");
  }
  const limitMatch = /^\[LIMIT:([^\]]+)\]/.exec(issue2.message);
  if (limitMatch) {
    const key = limitMatch[1];
    if (Object.hasOwn(BOARD_LIMITS_V1, key))
      return limitExceeded(key, actualForLimit(input, issue2.path, key), issue2.path);
  }
  const inferredLimit = inferLimitKey(input, issue2.path, issue2.message);
  if (inferredLimit)
    return limitExceeded(inferredLimit, actualSize(valueAtPath(input, issue2.path)), issue2.path);
  if (issue2.message.startsWith("[DUPLICATE_NODE_ID:")) {
    const match = /^\[DUPLICATE_NODE_ID:([^:]+):(.*)\]/.exec(issue2.message);
    const duplicatePath = issue2.path;
    let firstPath = [];
    try {
      firstPath = JSON.parse(match?.[2] ?? "[]");
    } catch {
      firstPath = [];
    }
    return {
      protocolVersion: 1,
      type: "board.error",
      code: "DUPLICATE_NODE_ID",
      message: "Duplicate node ID",
      category: "validation",
      retryable: false,
      httpStatusHint: 422,
      details: { nodeId: match?.[1] ?? "node", firstPath, duplicatePath }
    };
  }
  if (issue2.message.startsWith("[INVALID_LAYOUT")) {
    const reason = issue2.message.includes(":reference") || issue2.message.includes("reference") || issue2.message.includes("correlate") || issue2.message.includes("missing") ? "reference" : issue2.message.includes("overlap") ? "overlap" : issue2.message.includes("geometry") || issue2.message.includes("polygon") ? "geometry" : "bounds";
    return invalidLayout(issue2.path, reason);
  }
  if (issue2.message.includes("Invalid discriminator value")) {
    const received = valueAtPath(input, issue2.path);
    if (kind === "node" || issue2.path.at(-1) === "type" && issue2.path.some((part) => part === "root" || part === "node"))
      return {
        protocolVersion: 1,
        type: "board.error",
        code: "UNKNOWN_NODE_TYPE",
        message: "Unknown node type",
        category: "validation",
        retryable: false,
        httpStatusHint: 422,
        details: { path: issue2.path, receivedType: String(received ?? "") }
      };
    if (kind === "mutation")
      return {
        protocolVersion: 1,
        type: "board.error",
        code: "UNKNOWN_COMMAND_TYPE",
        message: "Unknown command type",
        category: "validation",
        retryable: false,
        httpStatusHint: 422,
        details: { path: issue2.path, receivedType: String(received ?? "") }
      };
    if (kind === "operation")
      return {
        protocolVersion: 1,
        type: "board.error",
        code: "UNKNOWN_OPERATION_TYPE",
        message: "Unknown operation type",
        category: "validation",
        retryable: false,
        httpStatusHint: 422,
        details: { path: issue2.path, receivedType: String(received ?? "") }
      };
  }
  return invalidPayload(issue2.path, issue2.message);
};
var isRecord2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
var findSceneValues = (input) => {
  const scenes = [];
  const stack = [
    { value: input, path: [] }
  ];
  while (stack.length > 0) {
    const current = stack.pop();
    if (!current) break;
    if (isRecord2(current.value) && current.value.type === "scene" && Object.hasOwn(current.value, "root"))
      scenes.push({ value: current.value, path: current.path });
    if (Array.isArray(current.value))
      current.value.forEach(
        (value, index) => stack.push({ value, path: [...current.path, index] })
      );
    else if (isRecord2(current.value))
      Object.entries(current.value).forEach(
        ([key, value]) => stack.push({ value, path: [...current.path, key] })
      );
  }
  return scenes;
};
var guardSceneLimits = (input, kind) => {
  const scenes = findSceneValues(input);
  if (kind === "scene" && scenes.length === 0 && isRecord2(input))
    scenes.push({ value: input, path: [] });
  for (const scene of scenes) {
    const canonical = runDecodedKernelV1(scene.value);
    if (canonical.ok && canonical.canonicalBytes.byteLength > MAX_SCENE_BYTES)
      return payloadTooLarge("scene", canonical.canonicalBytes.byteLength, MAX_SCENE_BYTES);
    const root = scene.value.root;
    if (root === null || !isRecord2(root)) continue;
    let count = 0;
    const stack = [{ node: root, path: [...scene.path, "root"], depth: 1 }];
    while (stack.length > 0) {
      const current = stack.pop();
      if (!current) break;
      count += 1;
      if (current.depth > BOARD_LIMITS_V1.maxSceneDepth)
        return limitExceeded("maxSceneDepth", current.depth, current.path);
      const type = current.node.type;
      if (type === "content.table" && Array.isArray(current.node.rows) && current.node.rows.length > BOARD_LIMITS_V1.maxTableRows)
        return limitExceeded("maxTableRows", current.node.rows.length, [...current.path, "rows"]);
      if (type === "content.chart" && Array.isArray(current.node.series)) {
        const points = current.node.series.reduce(
          (total, series) => total + (isRecord2(series) && Array.isArray(series.points) ? series.points.length : 0),
          0
        );
        if (points > BOARD_LIMITS_V1.maxChartPoints)
          return limitExceeded("maxChartPoints", points, [...current.path, "series"]);
      }
      const children = type === "layout.tabs" ? current.node.tabs : current.node.children;
      if (Array.isArray(children))
        children.forEach((item, index) => {
          if (isRecord2(item) && isRecord2(item.node))
            stack.push({
              node: item.node,
              path: [...current.path, type === "layout.tabs" ? "tabs" : "children", index, "node"],
              depth: current.depth + 1
            });
        });
    }
    if (count > BOARD_LIMITS_V1.maxSceneNodes)
      return limitExceeded("maxSceneNodes", count, [...scene.path, "root"]);
    const unknownStack = [
      { node: root, path: [...scene.path, "root"] }
    ];
    while (unknownStack.length > 0) {
      const current = unknownStack.pop();
      if (!current) break;
      if (typeof current.node.type === "string" && !NODE_TYPES_V1.includes(current.node.type))
        return {
          protocolVersion: 1,
          type: "board.error",
          code: "UNKNOWN_NODE_TYPE",
          message: "Unknown node type",
          category: "validation",
          retryable: false,
          httpStatusHint: 422,
          details: { path: [...current.path, "type"], receivedType: current.node.type }
        };
      const children = current.node.type === "layout.tabs" ? current.node.tabs : current.node.children;
      if (Array.isArray(children))
        children.forEach((item, index) => {
          if (isRecord2(item) && isRecord2(item.node))
            unknownStack.push({
              node: item.node,
              path: [
                ...current.path,
                current.node.type === "layout.tabs" ? "tabs" : "children",
                index,
                "node"
              ]
            });
        });
    }
  }
  return null;
};
var findDocumentValues = (input) => {
  const documents = [];
  const stack = [
    { value: input, path: [] }
  ];
  while (stack.length > 0) {
    const current = stack.pop();
    if (!current) break;
    if (isRecord2(current.value) && Object.hasOwn(current.value, "schemaVersion") && Object.hasOwn(current.value, "pages") && Object.hasOwn(current.value, "defaultPageId"))
      documents.push({ value: current.value, path: current.path });
    if (Array.isArray(current.value))
      current.value.forEach(
        (value, index) => stack.push({ value, path: [...current.path, index] })
      );
    else if (isRecord2(current.value))
      Object.entries(current.value).forEach(
        ([key, value]) => stack.push({ value, path: [...current.path, key] })
      );
  }
  return documents;
};
var guardDocumentLimits = (input, kind, documentSchemaVersions) => {
  const documents = findDocumentValues(input);
  if (kind === "document" && documents.length === 0 && isRecord2(input))
    documents.push({ value: input, path: [] });
  for (const document of documents) {
    if (typeof document.value.schemaVersion !== "number" || !documentSchemaVersions.includes(document.value.schemaVersion))
      return protocolMismatch(1, "schema_revision", "document.schemaVersion");
    const canonical = runDecodedKernelV1(document.value);
    if (canonical.ok && canonical.canonicalBytes.byteLength > MAX_DOCUMENT_BYTES)
      return payloadTooLarge("document", canonical.canonicalBytes.byteLength, MAX_DOCUMENT_BYTES);
    const pages = document.value.pages;
    if (!Array.isArray(pages)) continue;
    if (pages.length < 1 || pages.length > BOARD_DOCUMENT_LIMITS_V2.maxDocumentPages)
      return invalidDocument2([...document.path, "pages"], "page_count");
    let nodeCount = 0;
    for (let pageIndex2 = 0; pageIndex2 < pages.length; pageIndex2 += 1) {
      const page = pages[pageIndex2];
      const pageCanonical = runDecodedKernelV1(page);
      if (pageCanonical.ok && pageCanonical.canonicalBytes.byteLength > MAX_DOCUMENT_PAGE_BYTES)
        return payloadTooLarge(
          "document.page",
          pageCanonical.canonicalBytes.byteLength,
          MAX_DOCUMENT_PAGE_BYTES
        );
      if (!isRecord2(page) || !isRecord2(page.scene)) continue;
      const root = page.scene.root;
      if (root === null || !isRecord2(root)) continue;
      const stack = [root];
      while (stack.length > 0) {
        const node = stack.pop();
        if (!node) break;
        nodeCount += 1;
        const children = node.type === "layout.tabs" ? node.tabs : node.children;
        if (Array.isArray(children))
          children.forEach((item) => {
            if (isRecord2(item) && isRecord2(item.node)) stack.push(item.node);
          });
      }
    }
    if (nodeCount > BOARD_DOCUMENT_LIMITS_V2.maxDocumentNodes)
      return invalidDocument2([...document.path, "pages"], "limit");
  }
  return null;
};
var guardHitlResponseBytes = (input, kind) => {
  const candidates = kind === "hitl-response" ? [input] : [];
  const stack = [input];
  while (stack.length > 0) {
    const value = stack.pop();
    if (Array.isArray(value)) stack.push(...value);
    else if (isRecord2(value)) {
      for (const [key, child] of Object.entries(value)) {
        if (key === "response" && isRecord2(child) && typeof child.kind === "string")
          candidates.push(child);
        stack.push(child);
      }
    }
  }
  for (const candidate of candidates) {
    const canonical = runDecodedKernelV1(candidate);
    if (canonical.ok && canonical.canonicalBytes.byteLength > MAX_HITL_RESPONSE_BYTES)
      return payloadTooLarge(
        "hitl.response",
        canonical.canonicalBytes.byteLength,
        MAX_HITL_RESPONSE_BYTES
      );
  }
  return null;
};
var processKernel = (schema, kernel, kind, documentProfile = false, documentSchemaVersions = [2]) => {
  if (!kernel.ok) return { ok: false, error: kernelError(kernel.issue, documentProfile) };
  const input = kernel.value;
  if (isRecord2(input) && Object.hasOwn(input, "protocolVersion") && input.protocolVersion !== 1)
    return {
      ok: false,
      error: protocolMismatch(
        typeof input.protocolVersion === "number" && Number.isInteger(input.protocolVersion) && input.protocolVersion >= 0 ? input.protocolVersion : null
      )
    };
  const sceneIssue = guardSceneLimits(input, kind);
  if (sceneIssue) return { ok: false, error: sceneIssue };
  const documentIssue = guardDocumentLimits(input, kind, documentSchemaVersions);
  if (documentIssue) return { ok: false, error: documentIssue };
  const hitlByteIssue = guardHitlResponseBytes(input, kind);
  if (hitlByteIssue) return { ok: false, error: hitlByteIssue };
  const result = applySchemaV1(schema, kernel);
  if (!result.ok) return { ok: false, error: mapSchemaIssue(input, result.issue, kind) };
  return { ok: true, data: { value: result.value, canonicalBytes: result.canonicalBytes } };
};
var createParser = (schema, kind = "generic", documentProfile = false, documentSchemaVersions = [2]) => ({
  parse: (input) => processKernel(schema, runDecodedKernelV1(input), kind, documentProfile, documentSchemaVersions),
  parseBytes: (bytes) => processKernel(
    schema,
    documentProfile ? runDocumentBytesKernelV2(bytes) : runBytesKernelV1(bytes),
    kind,
    documentProfile,
    documentSchemaVersions
  )
});
var createParserV1 = (schema, kind = "generic") => createParser(schema, kind);
var GlobalIdStringParserV1 = createParserV1(GlobalIdStringSchemaV1);
var BoardIdParserV1 = createParserV1(BoardIdSchemaV1);
var MediaIdParserV1 = createParserV1(MediaIdSchemaV1);
var MediaIngestResultParserV1 = createParserV1(MediaIngestResultSchemaV1);
var GrantIdParserV1 = createParserV1(GrantIdSchemaV1);
var PrincipalIdParserV1 = createParserV1(PrincipalIdSchemaV1);
var NodeIdParserV1 = createParserV1(NodeIdSchemaV1);
var PageIdParserV1 = createParserV1(PageIdSchemaV1);
var ShortTextParserV1 = createParserV1(ShortTextSchemaV1);
var SceneParserV1 = createParserV1(SceneSchemaV1, "scene");
var BoardNodeParserV1 = createParserV1(BoardNodeSchemaV1, "node");
var MutationRequestParserV1 = createParserV1(MutationRequestSchemaV1, "mutation");
var MutationEnvelopeParserV1 = createParserV1(MutationEnvelopeSchemaV1, "mutation");
var MutationResultParserV1 = createParserV1(MutationResultSchemaV1, "mutation");
var BoardOperationRequestParserV1 = createParserV1(
  BoardOperationRequestSchemaV1,
  "operation"
);
var BoardOperationEnvelopeParserV1 = createParserV1(
  BoardOperationEnvelopeSchemaV1,
  "operation"
);
var BoardOperationResultParserV1 = createParserV1(
  BoardOperationResultSchemaV1,
  "operation"
);
var BoardSnapshotParserV1 = createParserV1(BoardSnapshotSchemaV1, "scene");
var BoardEventEnvelopeParserV1 = createParserV1(BoardEventEnvelopeSchemaV1, "event");
var BoardCapabilitiesParserV1 = createParserV1(BoardCapabilitiesSchemaV1);
var BoardSessionAccessParserV1 = createParserV1(BoardSessionAccessSchemaV1);
var ArtifactReferenceParserV1 = createParserV1(ArtifactReferenceSchemaV1);
var ArtifactResourceParserV1 = createParserV1(ArtifactResourceSchemaV1);
var ArtifactManifestParserV1 = createParserV1(ArtifactManifestSchemaV1);
var ArtifactRuntimeSummaryParserV1 = createParserV1(ArtifactRuntimeSummarySchemaV1);
var HitlRequestDefinitionParserV1 = createParserV1(HitlRequestDefinitionSchemaV1);
var HitlResponseParserV1 = createParserV1(HitlResponseSchemaV1, "hitl-response");
var HitlInteractionParserV1 = createParserV1(HitlInteractionSchemaV1);
var RetainedHistoryMetadataParserV1 = createParserV1(RetainedHistoryMetadataSchemaV1);
var BoardMembershipParserV1 = createParserV1(BoardMembershipSchemaV1);
var MemberCandidateParserV1 = createParserV1(MemberCandidateSchemaV1);
var MemberCandidateListParserV1 = createParserV1(MemberCandidateListSchemaV1);
var BoardInvitationParserV1 = createParserV1(BoardInvitationSchemaV1);
var BoardInvitationEnvelopeParserV1 = createParserV1(BoardInvitationEnvelopeSchemaV1);
var InvitationAcceptanceParserV1 = createParserV1(InvitationAcceptanceSchemaV1);
var ManagedMembershipEnvelopeParserV1 = createParserV1(ManagedMembershipEnvelopeSchemaV1);
var AccessManagementListParserV1 = createParserV1(AccessManagementListSchemaV1);
var ShareManagementViewParserV1 = createParserV1(ShareManagementViewSchemaV1);
var ShareListResultParserV1 = createParserV1(ShareListResultSchemaV1);
var SharePublishRequestParserV1 = createParserV1(SharePublishRequestSchemaV1);
var ShareUpdateRequestParserV1 = createParserV1(ShareUpdateRequestSchemaV1);
var ShareVersionRequestParserV1 = createParserV1(ShareVersionRequestSchemaV1);
var SharePasswordAdmissionRequestParserV1 = createParserV1(
  SharePasswordAdmissionRequestSchemaV1
);
var SharePublishSuccessParserV1 = createParserV1(SharePublishSuccessSchemaV1);
var ShareRotateSuccessParserV1 = createParserV1(ShareRotateSuccessSchemaV1);
var ShareUpdateSuccessParserV1 = createParserV1(ShareUpdateSuccessSchemaV1);
var ShareSecretReplayResultParserV1 = createParserV1(ShareSecretReplayResultSchemaV1);
var SharePasswordSuccessParserV1 = createParserV1(SharePasswordSuccessSchemaV1);
var SharePasswordReplayResultParserV1 = createParserV1(SharePasswordReplayResultSchemaV1);
var ShareErrorParserV1 = createParserV1(ShareErrorSchemaV1);
var ShareErrorEnvelopeParserV1 = createParserV1(ShareErrorEnvelopeSchemaV1);
var ShareFingerprintInputParserV1 = createParserV1(ShareFingerprintInputSchemaV1);
var ShareIdempotencyKeyParserV1 = createParserV1(ShareIdempotencyKeySchemaV1);
var ShareLinkTokenParserV1 = createParserV1(ShareLinkTokenSchemaV1);
var PublicShareTokenParserV1 = createParserV1(PublicShareTokenSchemaV1);
var PublicContextIdParserV1 = createParserV1(PublicContextIdSchemaV1);
var PublicRelativeUrlParserV1 = createParserV1(PublicRelativeUrlSchemaV1);
var QuotedSha256EtagParserV1 = createParserV1(QuotedSha256EtagSchemaV1);
var PublicShareContextParserV1 = createParserV1(PublicShareContextSchemaV1);
var PublicArtifactSummaryParserV1 = createParserV1(PublicArtifactSummarySchemaV1);
var PublicMediaResourceParserV1 = createParserV1(PublicMediaResourceSchemaV1);
var PublicBoardProjectionParserV1 = createParser(
  PublicBoardProjectionSchemaV1,
  "generic",
  true,
  [2, 3]
);
var PublicShareStateParserV1 = createParser(
  PublicShareStateSchemaV1,
  "generic",
  true,
  [2, 3]
);
var PublicPresentationSessionIdParserV1 = createParserV1(
  PublicPresentationSessionIdSchemaV1
);
var PublicPresentationAnnotationParserV1 = createParserV1(
  PublicPresentationAnnotationSchemaV1
);
var PublicPresentationSessionListParserV1 = createParserV1(
  PublicPresentationSessionListSchemaV1
);
var PublicPresentationStartRequestParserV1 = createParserV1(
  PublicPresentationStartRequestSchemaV1
);
var PublicPresentationSnapshotParserV1 = createParserV1(
  PublicPresentationSnapshotSchemaV1
);
var PublicPresentationUpdateRequestParserV1 = createParserV1(
  PublicPresentationUpdateRequestSchemaV1
);
var PublicPresentationEventParserV1 = createParserV1(PublicPresentationEventSchemaV1);
var PublicPresentationEndResultParserV1 = createParserV1(
  PublicPresentationEndResultSchemaV1
);
var ShareAnalyticsContextRequestParserV1 = createParserV1(
  ShareAnalyticsContextRequestSchemaV1
);
var ShareAnalyticsContextParserV1 = createParserV1(ShareAnalyticsContextSchemaV1);
var ShareAnalyticsEventParserV1 = createParserV1(ShareAnalyticsEventSchemaV1);
var ShareAnalyticsEventResultParserV1 = createParserV1(ShareAnalyticsEventResultSchemaV1);
var ShareAnalyticsReportParserV1 = createParserV1(ShareAnalyticsReportSchemaV1);
var ShareAnalyticsErrorEnvelopeParserV1 = createParserV1(
  ShareAnalyticsErrorEnvelopeSchemaV1
);
var BoardAuthorizationPrincipalParserV1 = createParserV1(
  BoardAuthorizationPrincipalSchemaV1
);
var BoardAuthorizationCapabilityParserV1 = createParserV1(
  BoardAuthorizationCapabilitySchemaV1
);
var BoardOperationAuthorizationPolicyParserV1 = createParserV1(
  BoardOperationAuthorizationPolicySchemaV1
);
var BoardOperationAuthorizationMatrixParserV1 = createParserV1(
  BoardOperationAuthorizationMatrixSchemaV1
);
var BoardErrorParserV1 = createParserV1(BoardErrorSchemaV1);
var BoardDocumentParserV2 = createParser(BoardDocumentSchemaV2, "document", true);
var BoardDocumentParserV3 = createParser(BoardDocumentSchemaV3, "document", true, [3]);
var MutationRequestParserV2 = createParser(MutationRequestSchemaV2, "mutation", true);
var MutationEnvelopeParserV2 = createParser(MutationEnvelopeSchemaV2, "mutation", true);
var MutationResultParserV2 = createParser(MutationResultSchemaV2, "mutation", true);
var MutationRequestParserV3 = createParser(MutationRequestSchemaV3, "mutation", true, [3]);
var MutationEnvelopeParserV3 = createParser(
  MutationEnvelopeSchemaV3,
  "mutation",
  true,
  [3]
);
var MutationResultParserV3 = createParser(MutationResultSchemaV3, "mutation", true, [3]);
var BoardOperationResultParserV2 = createParser(
  BoardOperationResultSchemaV1,
  "operation",
  true
);
var BoardOperationResultParserV3 = createParser(
  BoardOperationResultSchemaV1,
  "operation",
  true,
  [3]
);
var BoardSnapshotParserV2 = createParser(BoardSnapshotSchemaV2, "document", true);
var BoardSnapshotParserV3 = createParser(BoardSnapshotSchemaV3, "document", true, [3]);
var BoardSnapshotParser = createParser(BoardSnapshotSchema, "generic", true, [2, 3]);
var BoardEventEnvelopeParserV2 = createParser(BoardEventEnvelopeSchemaV2, "event", true);
var BoardEventEnvelopeParserV3 = createParser(
  BoardEventEnvelopeSchemaV2,
  "event",
  true,
  [3]
);
var BoardCapabilitiesParserV2 = createParser(BoardCapabilitiesSchemaV2);
var BoardCapabilitiesParserV3 = createParser(BoardCapabilitiesSchemaV3);
var BoardCapabilitiesParser = createParser(BoardCapabilitiesSchema);
var BoardErrorParser = createParser(BoardErrorSchema);
var canonicalizeJsonV1 = (input) => {
  const result = runDecodedKernelV1(input);
  return result.ok ? { ok: true, data: { value: result.value, canonicalBytes: result.canonicalBytes } } : { ok: false, error: kernelErrorV1(result.issue) };
};
var ActorCandidateSchemaV1 = z.object({
  principalKind: z.enum(["user", "mcp_client", "service"]),
  principalId: PrincipalIdSchemaV1,
  grantId: GrantIdSchemaV1.nullable(),
  scopes: z.array(z.enum(CLIENT_GRANT_CAPABILITIES_V1))
}).strict();

// packages/board-sdk/src/http/strict-json-response.ts
var hasDuplicateMembers = (source) => {
  const stack = [];
  let inString = false;
  let escaped = false;
  let stringStart = 0;
  for (let index = 0; index < source.length; index += 1) {
    const character = source[index];
    if (inString) {
      if (escaped) escaped = false;
      else if (character === "\\") escaped = true;
      else if (character === '"') {
        inString = false;
        const frame = stack.at(-1);
        if (frame?.kind === "object" && frame.expectsKey) {
          let key;
          try {
            key = JSON.parse(source.slice(stringStart, index + 1));
          } catch {
            return false;
          }
          if (typeof key === "string") {
            if (frame.keys.has(key)) return true;
            frame.keys.add(key);
          }
        }
      }
      continue;
    }
    if (character === '"') {
      inString = true;
      stringStart = index;
    } else if (character === "{") stack.push({ kind: "object", keys: /* @__PURE__ */ new Set(), expectsKey: true });
    else if (character === "[") stack.push({ kind: "array" });
    else if (character === "}" || character === "]") stack.pop();
    else if (character === ":") {
      const frame = stack.at(-1);
      if (frame?.kind === "object") frame.expectsKey = false;
    } else if (character === ",") {
      const frame = stack.at(-1);
      if (frame?.kind === "object") frame.expectsKey = true;
    }
  }
  return false;
};
var parseStrictJsonBytesV1 = (bytes) => {
  let source;
  try {
    source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
  } catch {
    return { ok: false, reason: "utf8" };
  }
  if (hasDuplicateMembers(source)) return { ok: false, reason: "duplicate_member" };
  try {
    return { ok: true, value: JSON.parse(source) };
  } catch {
    return { ok: false, reason: "json" };
  }
};

// packages/board-sdk/src/http/http-result.parser.ts
var isRecord3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
var hasExactKeys2 = (value, keys) => {
  const actual = Object.keys(value).sort();
  const expected = [...keys].sort();
  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
};
var validLabel = (value) => typeof value === "string" && [...value].length >= 1 && [...value].length <= 200 && !/[\u0000-\u001f\u007f\uD800-\uDFFF]/u.test(value);
var parseRevisionId = (value) => {
  if (typeof value !== "string") return null;
  const parsed = GlobalIdStringParserV1.parse(value);
  return parsed.ok ? value : null;
};
var parseHistory = (value) => {
  const retained = RetainedHistoryMetadataParserV1.parse(value);
  if (retained.ok) return retained.data.value;
  if (!isRecord3(value) || !hasExactKeys2(value, ["protocolVersion", "type", "entries", "navigation"]) || value.protocolVersion !== 1 || value.type !== "history.adapter-metadata" || !Array.isArray(value.entries) || value.entries.length > 100)
    return null;
  const entries = [];
  for (const entry of value.entries) {
    if (!isRecord3(entry) || !hasExactKeys2(entry, ["revisionId", "label"]) || !validLabel(entry.label))
      return null;
    const revisionId = parseRevisionId(entry.revisionId);
    if (revisionId === null) return null;
    entries.push({ revisionId, label: entry.label });
  }
  let navigation = null;
  if (value.navigation !== null) {
    const candidate = value.navigation;
    if (!isRecord3(candidate) || !hasExactKeys2(candidate, [
      "revisionId",
      "previousRevisionId",
      "nextRevisionId",
      "latestRevisionId"
    ]))
      return null;
    const revisionId = parseRevisionId(candidate.revisionId);
    const latestRevisionId = parseRevisionId(candidate.latestRevisionId);
    const previousRevisionId = candidate.previousRevisionId === null ? null : parseRevisionId(candidate.previousRevisionId);
    const nextRevisionId = candidate.nextRevisionId === null ? null : parseRevisionId(candidate.nextRevisionId);
    if (revisionId === null || latestRevisionId === null || candidate.previousRevisionId !== null && previousRevisionId === null || candidate.nextRevisionId !== null && nextRevisionId === null)
      return null;
    navigation = { revisionId, previousRevisionId, nextRevisionId, latestRevisionId };
  }
  const metadata = {
    protocolVersion: 1,
    type: "history.adapter-metadata",
    entries,
    navigation
  };
  const canonical = canonicalizeJsonV1(metadata);
  return canonical.ok && canonical.data.canonicalBytes.byteLength <= 131072 ? metadata : null;
};
var historyCorrelates = (result, metadata) => {
  if (result.result.type === "history.list") {
    return metadata !== null && metadata.navigation === null && result.result.entries.length === metadata.entries.length && result.result.entries.every(
      (entry, index) => entry.revision.revisionId === metadata.entries[index]?.revisionId
    );
  }
  if (result.result.type === "history.get") {
    const revisionId = result.result.entry.revision.revisionId;
    return metadata !== null && metadata.entries.length === 1 && metadata.entries[0]?.revisionId === revisionId && metadata.navigation?.revisionId === revisionId;
  }
  return metadata === null;
};
var pathCorrelates = (result, expectation) => {
  if (result.result.type !== expectation.resultType) return false;
  if (expectation.boardId !== void 0) {
    if (result.type === "mutation.result" && result.boardId !== expectation.boardId) return false;
    if ((result.result.type === "board.get" || result.result.type === "board.create") && result.result.board.boardId !== expectation.boardId)
      return false;
    if (result.result.type === "board.archive" && result.result.board.boardId !== expectation.boardId)
      return false;
    if (result.result.type === "history.get" && result.result.snapshot.boardId !== expectation.boardId)
      return false;
  }
  if (expectation.artifact !== void 0) {
    if (result.result.type !== "artifact.get" || result.result.manifest.artifact.artifactId !== expectation.artifact.artifactId || result.result.manifest.artifact.versionId !== expectation.artifact.versionId)
      return false;
  }
  if (expectation.revisionId !== void 0 && result.result.type === "history.get") {
    return result.result.entry.revision.revisionId === expectation.revisionId;
  }
  return true;
};
var parseBoardHttpResultV1 = (bytes, expectation) => {
  const strict = parseStrictJsonBytesV1(bytes);
  if (!strict.ok) return strict;
  const decoded = strict.value;
  if (!isRecord3(decoded)) return { ok: false, reason: "schema" };
  if (hasExactKeys2(decoded, ["error"])) {
    const error3 = BoardErrorParserV1.parse(decoded.error);
    if (!error3.ok) return { ok: false, reason: "schema" };
    if (expectation.status !== error3.data.value.httpStatusHint)
      return { ok: false, reason: "correlation" };
    return { ok: true, value: { ok: false, error: error3.data.value } };
  }
  if (!hasExactKeys2(decoded, ["protocolVersion", "type", "requestId", "result", "metadata"]) || decoded.protocolVersion !== 1 || decoded.type !== "board.http.success" || decoded.requestId !== expectation.requestId || !isRecord3(decoded.metadata) || !hasExactKeys2(decoded.metadata, ["history"]))
    return { ok: false, reason: "schema" };
  const operation = BoardOperationResultParserV1.parse(decoded.result);
  const mutation = operation.ok ? null : MutationResultParserV1.parse(decoded.result);
  const result = operation.ok ? operation.data.value : mutation?.ok ? mutation.data.value : null;
  if (result === null) return { ok: false, reason: "schema" };
  if (result.requestId !== expectation.requestId || !pathCorrelates(result, expectation)) {
    return { ok: false, reason: "correlation" };
  }
  const historyValue = decoded.metadata.history;
  const history = historyValue === null ? null : parseHistory(historyValue);
  if (historyValue !== null && history === null || !historyCorrelates(result, history)) {
    return { ok: false, reason: "correlation" };
  }
  const successStatus = result.result.type === "board.create" && !result.replayed ? 201 : 200;
  if (expectation.status !== successStatus) return { ok: false, reason: "correlation" };
  return {
    ok: true,
    value: {
      ok: true,
      value: {
        protocolVersion: 1,
        type: "board.http.success",
        requestId: expectation.requestId,
        result,
        metadata: { history }
      }
    }
  };
};
var parseBoardOperationHttpResultV2 = (bytes, expectation) => {
  const strict = parseStrictJsonBytesV1(bytes);
  if (!strict.ok) return strict;
  const decoded = strict.value;
  if (!isRecord3(decoded)) return { ok: false, reason: "schema" };
  if (hasExactKeys2(decoded, ["error"])) {
    const error3 = BoardErrorParser.parse(decoded.error);
    if (!error3.ok) return { ok: false, reason: "schema" };
    if (expectation.status !== error3.data.value.httpStatusHint)
      return { ok: false, reason: "correlation" };
    return { ok: true, value: { ok: false, error: error3.data.value } };
  }
  if (!hasExactKeys2(decoded, ["protocolVersion", "type", "requestId", "result", "metadata"]) || decoded.protocolVersion !== 1 || decoded.type !== "board.http.success" || decoded.requestId !== expectation.requestId || !isRecord3(decoded.metadata) || !hasExactKeys2(decoded.metadata, ["history"]))
    return { ok: false, reason: "schema" };
  const operation = BoardOperationResultParserV2.parse(decoded.result);
  if (!operation.ok) return { ok: false, reason: "schema" };
  const result = operation.data.value;
  if (result.requestId !== expectation.requestId || !pathCorrelates(result, expectation))
    return { ok: false, reason: "correlation" };
  const historyValue = decoded.metadata.history;
  const history = historyValue === null ? null : parseHistory(historyValue);
  if (historyValue !== null && history === null || !historyCorrelates(result, history))
    return { ok: false, reason: "correlation" };
  if (expectation.status !== 200) return { ok: false, reason: "correlation" };
  return {
    ok: true,
    value: {
      ok: true,
      value: {
        protocolVersion: 1,
        type: "board.http.success",
        requestId: expectation.requestId,
        result,
        metadata: { history }
      }
    }
  };
};
var parseBoardOperationHttpResultV3 = (bytes, expectation) => {
  const strict = parseStrictJsonBytesV1(bytes);
  if (!strict.ok) return strict;
  const decoded = strict.value;
  if (!isRecord3(decoded)) return { ok: false, reason: "schema" };
  if (hasExactKeys2(decoded, ["error"])) {
    const error3 = BoardErrorParser.parse(decoded.error);
    if (!error3.ok) return { ok: false, reason: "schema" };
    if (expectation.status !== error3.data.value.httpStatusHint)
      return { ok: false, reason: "correlation" };
    return { ok: true, value: { ok: false, error: error3.data.value } };
  }
  if (!hasExactKeys2(decoded, ["protocolVersion", "type", "requestId", "result", "metadata"]) || decoded.protocolVersion !== 1 || decoded.type !== "board.http.success" || decoded.requestId !== expectation.requestId || !isRecord3(decoded.metadata) || !hasExactKeys2(decoded.metadata, ["history"]))
    return { ok: false, reason: "schema" };
  const operation = BoardOperationResultParserV3.parse(decoded.result);
  if (!operation.ok) return { ok: false, reason: "schema" };
  const result = operation.data.value;
  if (result.requestId !== expectation.requestId || !pathCorrelates(result, expectation))
    return { ok: false, reason: "correlation" };
  const historyValue = decoded.metadata.history;
  const history = historyValue === null ? null : parseHistory(historyValue);
  if (historyValue !== null && history === null || !historyCorrelates(result, history))
    return { ok: false, reason: "correlation" };
  if (expectation.status !== 200) return { ok: false, reason: "correlation" };
  return {
    ok: true,
    value: {
      ok: true,
      value: {
        protocolVersion: 1,
        type: "board.http.success",
        requestId: expectation.requestId,
        result,
        metadata: { history }
      }
    }
  };
};
var parseBoardDocumentHttpResultV2 = (bytes, expectation) => {
  const strict = parseStrictJsonBytesV1(bytes);
  if (!strict.ok) return strict;
  const decoded = strict.value;
  if (!isRecord3(decoded)) return { ok: false, reason: "schema" };
  if (hasExactKeys2(decoded, ["error"])) {
    const error3 = BoardErrorParser.parse(decoded.error);
    if (!error3.ok) return { ok: false, reason: "schema" };
    if (expectation.status !== error3.data.value.httpStatusHint)
      return { ok: false, reason: "correlation" };
    return { ok: true, value: { ok: false, error: error3.data.value } };
  }
  if (!hasExactKeys2(decoded, ["protocolVersion", "type", "requestId", "result", "metadata"]) || decoded.protocolVersion !== 1 || decoded.type !== "board.http.success" || decoded.requestId !== expectation.requestId || !isRecord3(decoded.metadata) || !hasExactKeys2(decoded.metadata, ["history"]) || decoded.metadata.history !== null)
    return { ok: false, reason: "schema" };
  const parsed = MutationResultParserV2.parse(decoded.result);
  if (!parsed.ok || parsed.data.value.result.type !== "document.replace")
    return { ok: false, reason: "schema" };
  const result = parsed.data.value;
  if (result.requestId !== expectation.requestId || result.boardId !== expectation.boardId || expectation.status !== (result.replayed ? 200 : 201))
    return { ok: false, reason: "correlation" };
  return {
    ok: true,
    value: {
      ok: true,
      value: {
        protocolVersion: 1,
        type: "board.http.success",
        requestId: expectation.requestId,
        result,
        metadata: { history: null }
      }
    }
  };
};
var parseBoardDocumentHttpResultV3 = (bytes, expectation) => {
  const strict = parseStrictJsonBytesV1(bytes);
  if (!strict.ok) return strict;
  const decoded = strict.value;
  if (!isRecord3(decoded)) return { ok: false, reason: "schema" };
  if (hasExactKeys2(decoded, ["error"])) {
    const error3 = BoardErrorParser.parse(decoded.error);
    if (!error3.ok) return { ok: false, reason: "schema" };
    if (expectation.status !== error3.data.value.httpStatusHint)
      return { ok: false, reason: "correlation" };
    return { ok: true, value: { ok: false, error: error3.data.value } };
  }
  if (!hasExactKeys2(decoded, ["protocolVersion", "type", "requestId", "result", "metadata"]) || decoded.protocolVersion !== 1 || decoded.type !== "board.http.success" || decoded.requestId !== expectation.requestId || !isRecord3(decoded.metadata) || !hasExactKeys2(decoded.metadata, ["history"]) || decoded.metadata.history !== null)
    return { ok: false, reason: "schema" };
  const parsed = MutationResultParserV3.parse(decoded.result);
  if (!parsed.ok || parsed.data.value.result.type !== "document.replace")
    return { ok: false, reason: "schema" };
  const result = parsed.data.value;
  if (result.requestId !== expectation.requestId || result.boardId !== expectation.boardId || expectation.status !== (result.replayed ? 200 : 201))
    return { ok: false, reason: "correlation" };
  return {
    ok: true,
    value: {
      ok: true,
      value: {
        protocolVersion: 1,
        type: "board.http.success",
        requestId: expectation.requestId,
        result,
        metadata: { history: null }
      }
    }
  };
};

// packages/board-sdk/src/http/bounded-response.ts
var readBoundedResponseBodyV1 = async (response, limit, signal) => {
  const contentLength = response.headers.get("content-length");
  if (contentLength !== null && /^(0|[1-9][0-9]*)$/.test(contentLength)) {
    const length = Number(contentLength);
    if (Number.isSafeInteger(length) && length > limit) {
      await response.body?.cancel().catch(() => void 0);
      return "body_too_large";
    }
  }
  if (response.body === null) return "response";
  const reader = response.body.getReader();
  const chunks = [];
  let total = 0;
  const onAbort = () => {
    void reader.cancel(signal.reason).catch(() => void 0);
  };
  signal.addEventListener("abort", onAbort, { once: true });
  try {
    while (true) {
      const next = await reader.read();
      if (next.done) break;
      if (next.value.byteLength === 0) continue;
      total += next.value.byteLength;
      if (total > limit) {
        await reader.cancel().catch(() => void 0);
        return "body_too_large";
      }
      chunks.push(next.value);
    }
  } catch {
    return "response";
  } finally {
    signal.removeEventListener("abort", onAbort);
    reader.releaseLock();
  }
  const bytes = new Uint8Array(total);
  let offset = 0;
  for (const chunk of chunks) {
    bytes.set(chunk, offset);
    offset += chunk.byteLength;
  }
  return bytes;
};

// packages/board-sdk/src/http/monotonic-deadline.ts
var createMonotonicDeadlineV1 = (timeoutMs, outerSignal) => {
  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
    throw new TypeError("timeoutMs must be a positive safe integer");
  }
  const startedAt = performance.now();
  const controller = new AbortController();
  let timeoutReached = false;
  const onOuterAbort = () => controller.abort(outerSignal?.reason);
  if (outerSignal?.aborted) onOuterAbort();
  else outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
  const timer = setTimeout(() => {
    timeoutReached = true;
    controller.abort(new DOMException("Deadline exceeded", "TimeoutError"));
  }, timeoutMs);
  const remainingMs = () => Math.max(0, timeoutMs - (performance.now() - startedAt));
  const dispose = () => {
    clearTimeout(timer);
    outerSignal?.removeEventListener("abort", onOuterAbort);
  };
  return { signal: controller.signal, remainingMs, timedOut: () => timeoutReached, dispose };
};

// packages/board-sdk/src/http/retry-policy.ts
var protectedRetryDelayMsV1 = (completedAttempt, random = Math.random) => {
  if (completedAttempt !== 1 && completedAttempt !== 2) {
    throw new TypeError("completedAttempt must be 1 or 2");
  }
  const sample = random();
  if (!Number.isFinite(sample) || sample < 0 || sample >= 1) {
    throw new TypeError("random sample must be in [0, 1)");
  }
  return (completedAttempt === 1 ? 100 : 300) + Math.floor(sample * 51);
};
var sleepWithinDeadlineV1 = async (milliseconds, remainingMs, signal) => {
  if (!Number.isFinite(milliseconds) || milliseconds < 0 || milliseconds >= remainingMs() || signal.aborted) {
    return false;
  }
  return new Promise((resolve3) => {
    const timer = setTimeout(() => done(true), milliseconds);
    const onAbort = () => done(false);
    const done = (completed) => {
      clearTimeout(timer);
      signal.removeEventListener("abort", onAbort);
      resolve3(completed);
    };
    signal.addEventListener("abort", onAbort, { once: true });
  });
};

// packages/board-sdk/src/http/board-sdk-http.client.ts
var SUCCESS_BODY_LIMIT = 2097152;
var ERROR_BODY_LIMIT = 65536;
var DOCUMENT_MEDIA_TYPE = "application/vnd.sceneboard.document+json;version=2";
var DOCUMENT_MEDIA_TYPE_V3 = "application/vnd.sceneboard.document+json;version=3";
var TOKEN_PATTERN = /^(?:lcbg_v1|sbk_v1)\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}$/;
var localFailure = (error3) => ({
  ok: false,
  error: error3
});
var validateBaseUrl = (value) => {
  let url;
  try {
    url = new URL(value);
  } catch {
    throw new TypeError("baseUrl must be a canonical bare origin");
  }
  const loopback = url.hostname === "127.0.0.1" || url.hostname === "[::1]" || url.hostname === "::1";
  if (url.origin !== value || url.pathname !== "/" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
    throw new TypeError("baseUrl must be HTTPS or an exact HTTP loopback origin");
  }
  return url.origin;
};
var retryDelayFromError = (error3) => {
  const seconds = error3.code === "RATE_LIMITED" ? error3.details.retryAfterSeconds : error3.code === "SERVICE_UNAVAILABLE" ? error3.details.retryAfterSeconds : null;
  return seconds === null ? null : seconds * 1e3;
};
var shouldRetryError = (error3) => error3.retryable && (error3.code === "RATE_LIMITED" || error3.code === "SERVICE_UNAVAILABLE");
var settleCredentialWithinDeadlineV1 = async (provider, signal) => {
  if (signal.aborted) return { kind: "aborted" };
  let onAbort = null;
  const aborted2 = new Promise((resolve3) => {
    onAbort = () => resolve3({ kind: "aborted" });
    signal.addEventListener("abort", onAbort, { once: true });
  });
  const credential = Promise.resolve().then(provider).then(
    (value) => ({ kind: "value", value }),
    () => ({ kind: "error" })
  );
  try {
    return await Promise.race([credential, aborted2]);
  } finally {
    if (onAbort !== null) signal.removeEventListener("abort", onAbort);
  }
};
var BoardSdkHttpClient = class {
  static readBoundedResponseBodyV1 = readBoundedResponseBodyV1;
  static parseStrictJsonBytesV1 = parseStrictJsonBytesV1;
  #baseUrl;
  #fetch;
  #bearerTokenProvider;
  #timeoutMs;
  #logger;
  constructor(options) {
    this.#baseUrl = validateBaseUrl(options.baseUrl);
    if (typeof options.fetch !== "function") throw new TypeError("fetch is required");
    if (typeof options.bearerTokenProvider !== "function")
      throw new TypeError("bearerTokenProvider is required");
    if (!Number.isSafeInteger(options.timeoutPolicy?.timeoutMs) || options.timeoutPolicy.timeoutMs < 1) {
      throw new TypeError("timeoutPolicy.timeoutMs must be a positive safe integer");
    }
    if (typeof options.logger?.log !== "function") throw new TypeError("logger.log is required");
    this.#fetch = options.fetch;
    this.#bearerTokenProvider = options.bearerTokenProvider;
    this.#timeoutMs = options.timeoutPolicy.timeoutMs;
    this.#logger = options.logger;
  }
  listBoards(request, signal) {
    const parsed = this.#operation(request, "board.list");
    const query = new URLSearchParams({
      requestId: parsed.requestId,
      limit: String(parsed.limit),
      includeArchived: String(parsed.includeArchived)
    });
    if (parsed.cursor !== null) query.set("cursor", parsed.cursor);
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards",
        path: "/api/v1/boards",
        query,
        body: null,
        requestId: parsed.requestId,
        resultType: "board.list",
        retryKind: "read"
      },
      signal
    );
  }
  getBoard(request, signal) {
    const parsed = this.#operation(request, "board.get");
    return this.#operationGet(
      parsed,
      `/api/v1/boards/${parsed.boardId}`,
      "/api/v1/boards/:boardId",
      signal
    );
  }
  getDocumentBoard(request, signal) {
    const parsed = this.#operation(request, "board.get");
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId",
        path: `/api/v1/boards/${parsed.boardId}`,
        query: new URLSearchParams({
          requestId: parsed.requestId,
          documentSchemaVersion: "2"
        }),
        body: null,
        requestId: parsed.requestId,
        resultType: "board.get",
        boardId: parsed.boardId,
        retryKind: "read",
        profile: "document-v2"
      },
      signal
    );
  }
  getDocumentBoardV3(request, signal) {
    const parsed = this.#operation(request, "board.get");
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId",
        path: `/api/v1/boards/${parsed.boardId}`,
        query: new URLSearchParams({
          requestId: parsed.requestId,
          documentSchemaVersion: "3"
        }),
        body: null,
        requestId: parsed.requestId,
        resultType: "board.get",
        boardId: parsed.boardId,
        retryKind: "read",
        profile: "document-v3"
      },
      signal
    );
  }
  createBoard(request, signal) {
    const parsed = this.#operation(request, "board.create");
    return this.#call(
      {
        method: "POST",
        routeTemplate: "/api/v1/boards",
        path: "/api/v1/boards",
        body: this.#operationBytes(parsed),
        requestId: parsed.requestId,
        resultType: "board.create",
        retryKind: "mutation"
      },
      signal
    );
  }
  archiveBoard(request, signal) {
    const parsed = this.#operation(request, "board.archive");
    return this.#call(
      {
        method: "POST",
        routeTemplate: "/api/v1/boards/:boardId/archive",
        path: `/api/v1/boards/${parsed.boardId}/archive`,
        body: this.#operationBytes(parsed),
        requestId: parsed.requestId,
        resultType: "board.archive",
        boardId: parsed.boardId,
        retryKind: "mutation"
      },
      signal
    );
  }
  getCapabilities(request, signal) {
    const parsed = this.#operation(request, "capabilities.get");
    return this.#operationGet(
      parsed,
      `/api/v1/boards/${parsed.boardId}/capabilities`,
      "/api/v1/boards/:boardId/capabilities",
      signal
    );
  }
  mutateBoard(request, signal) {
    const parsed = MutationRequestParserV1.parse(request);
    if (!parsed.ok || parsed.data.value.command.type !== request.command.type)
      throw new TypeError("invalid D1 mutation request");
    return this.#call(
      {
        method: "POST",
        routeTemplate: "/api/v1/boards/:boardId/mutations",
        path: `/api/v1/boards/${parsed.data.value.boardId}/mutations`,
        body: parsed.data.canonicalBytes,
        requestId: parsed.data.value.requestId,
        resultType: request.command.type,
        boardId: parsed.data.value.boardId,
        retryKind: "mutation"
      },
      signal
    );
  }
  mutateDocument(request, signal) {
    const parsed = MutationRequestParserV2.parse(request);
    if (!parsed.ok || parsed.data.value.command.type !== "document.replace")
      throw new TypeError("invalid document.replace request");
    return this.#call(
      {
        method: "POST",
        routeTemplate: "/api/v1/boards/:boardId/mutations",
        path: `/api/v1/boards/${parsed.data.value.boardId}/mutations`,
        query: new URLSearchParams({ documentSchemaVersion: "2" }),
        body: parsed.data.canonicalBytes,
        requestId: parsed.data.value.requestId,
        resultType: "document.replace",
        boardId: parsed.data.value.boardId,
        retryKind: "mutation",
        profile: "document-v2"
      },
      signal
    );
  }
  mutateDocumentV3(request, signal) {
    const parsed = MutationRequestParserV3.parse(request);
    if (!parsed.ok || parsed.data.value.command.type !== "document.replace")
      throw new TypeError("invalid document.replace V3 request");
    return this.#call(
      {
        method: "POST",
        routeTemplate: "/api/v1/boards/:boardId/mutations",
        path: `/api/v1/boards/${parsed.data.value.boardId}/mutations`,
        query: new URLSearchParams({ documentSchemaVersion: "3" }),
        body: parsed.data.canonicalBytes,
        requestId: parsed.data.value.requestId,
        resultType: "document.replace",
        boardId: parsed.data.value.boardId,
        retryKind: "mutation",
        profile: "document-v3"
      },
      signal
    );
  }
  restoreRevision(request, signal) {
    const parsed = MutationRequestParserV1.parse(request);
    if (!parsed.ok || parsed.data.value.command.type !== "scene.restore")
      throw new TypeError("invalid scene.restore request");
    const body = new TextEncoder().encode(
      JSON.stringify({
        protocolVersion: 1,
        requestId: parsed.data.value.requestId,
        idempotencyKey: parsed.data.value.idempotencyKey,
        expectedRevisionId: parsed.data.value.expectedRevisionId,
        confirm: true
      })
    );
    return this.#call(
      {
        method: "POST",
        routeTemplate: "/api/v1/boards/:boardId/revisions/:revisionId/restore",
        path: `/api/v1/boards/${parsed.data.value.boardId}/revisions/${parsed.data.value.command.sourceRevisionId}/restore`,
        body,
        requestId: parsed.data.value.requestId,
        resultType: "scene.restore",
        boardId: parsed.data.value.boardId,
        revisionId: parsed.data.value.command.sourceRevisionId,
        retryKind: "mutation"
      },
      signal
    );
  }
  listHistory(request, signal) {
    const parsed = this.#operation(request, "history.list");
    const query = new URLSearchParams({ requestId: parsed.requestId, limit: String(parsed.limit) });
    if (parsed.cursor !== null) query.set("cursor", parsed.cursor);
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId/revisions",
        path: `/api/v1/boards/${parsed.boardId}/revisions`,
        query,
        body: null,
        requestId: parsed.requestId,
        resultType: "history.list",
        boardId: parsed.boardId,
        retryKind: "read"
      },
      signal
    );
  }
  listDocumentHistoryV3(request, signal) {
    const parsed = this.#operation(request, "history.list");
    const query = new URLSearchParams({
      requestId: parsed.requestId,
      limit: String(parsed.limit),
      documentSchemaVersion: "3"
    });
    if (parsed.cursor !== null) query.set("cursor", parsed.cursor);
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId/revisions",
        path: `/api/v1/boards/${parsed.boardId}/revisions`,
        query,
        body: null,
        requestId: parsed.requestId,
        resultType: "history.list",
        boardId: parsed.boardId,
        retryKind: "read",
        profile: "document-v3"
      },
      signal
    );
  }
  getHistory(request, signal) {
    const parsed = this.#operation(request, "history.get");
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId/revisions/:revisionId",
        path: `/api/v1/boards/${parsed.boardId}/revisions/${parsed.revisionId}`,
        query: new URLSearchParams({ requestId: parsed.requestId }),
        body: null,
        requestId: parsed.requestId,
        resultType: "history.get",
        boardId: parsed.boardId,
        revisionId: parsed.revisionId,
        retryKind: "read"
      },
      signal
    );
  }
  getDocumentHistory(request, signal) {
    const parsed = this.#operation(request, "history.get");
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId/revisions/:revisionId",
        path: `/api/v1/boards/${parsed.boardId}/revisions/${parsed.revisionId}`,
        query: new URLSearchParams({
          requestId: parsed.requestId,
          documentSchemaVersion: "2"
        }),
        body: null,
        requestId: parsed.requestId,
        resultType: "history.get",
        boardId: parsed.boardId,
        revisionId: parsed.revisionId,
        retryKind: "read",
        profile: "document-v2"
      },
      signal
    );
  }
  getDocumentHistoryV3(request, signal) {
    const parsed = this.#operation(request, "history.get");
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId/revisions/:revisionId",
        path: `/api/v1/boards/${parsed.boardId}/revisions/${parsed.revisionId}`,
        query: new URLSearchParams({
          requestId: parsed.requestId,
          documentSchemaVersion: "3"
        }),
        body: null,
        requestId: parsed.requestId,
        resultType: "history.get",
        boardId: parsed.boardId,
        revisionId: parsed.revisionId,
        retryKind: "read",
        profile: "document-v3"
      },
      signal
    );
  }
  getArtifact(request, signal) {
    const parsed = this.#operation(request, "artifact.get");
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId/artifacts/:artifactId/versions/:versionId",
        path: `/api/v1/boards/${parsed.boardId}/artifacts/${parsed.artifact.artifactId}/versions/${parsed.artifact.versionId}`,
        query: new URLSearchParams({ requestId: parsed.requestId }),
        body: null,
        requestId: parsed.requestId,
        resultType: "artifact.get",
        boardId: parsed.boardId,
        artifact: parsed.artifact,
        retryKind: "read"
      },
      signal
    );
  }
  putArtifact(requestId, source, signal) {
    const body = new TextEncoder().encode(
      JSON.stringify({
        boardId: source.boardId,
        expectedRevisionId: source.expectedRevisionId,
        idempotencyKey: source.idempotencyKey,
        artifactId: source.artifactId,
        html: source.html,
        css: source.css,
        javascript: source.javascript,
        requestedCapabilities: source.requestedCapabilities
      })
    );
    return this.#call(
      {
        method: "POST",
        routeTemplate: "/api/v1/boards/:boardId/artifacts",
        path: `/api/v1/boards/${source.boardId}/artifacts`,
        body,
        requestId,
        resultType: "artifact.publish",
        boardId: source.boardId,
        retryKind: "mutation"
      },
      signal
    );
  }
  getInteraction(request, signal) {
    const parsed = this.#operation(request, "hitl.read");
    const query = new URLSearchParams({ requestId: parsed.requestId });
    if (parsed.wait !== null) {
      query.set("afterStateUpdatedAt", parsed.wait.afterStateUpdatedAt);
      query.set("timeoutMs", String(parsed.wait.timeoutMs));
    }
    return this.#call(
      {
        method: "GET",
        routeTemplate: "/api/v1/boards/:boardId/interactions/:hitlRequestId",
        path: `/api/v1/boards/${parsed.boardId}/interactions/${parsed.hitlRequestId}`,
        query,
        body: null,
        requestId: parsed.requestId,
        resultType: "hitl.read",
        boardId: parsed.boardId,
        retryKind: "read"
      },
      signal
    );
  }
  #operation(request, kind) {
    const parsed = BoardOperationRequestParserV1.parse(request);
    if (!parsed.ok || parsed.data.value.type !== kind)
      throw new TypeError(`invalid ${kind} request`);
    return parsed.data.value;
  }
  #operationBytes(request) {
    const parsed = BoardOperationRequestParserV1.parse(request);
    if (!parsed.ok) throw new TypeError("invalid D1 operation request");
    return parsed.data.canonicalBytes;
  }
  #operationGet(request, path, routeTemplate, signal) {
    return this.#call(
      {
        method: "GET",
        routeTemplate,
        path,
        query: new URLSearchParams({ requestId: request.requestId }),
        body: null,
        requestId: request.requestId,
        resultType: request.type,
        boardId: request.boardId,
        retryKind: "read"
      },
      signal
    );
  }
  async #call(spec, outerSignal) {
    const deadline = createMonotonicDeadlineV1(this.#timeoutMs, outerSignal);
    const maximumAttempts = spec.retryKind === "read" ? 3 : 2;
    try {
      for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
        if (deadline.signal.aborted) {
          return deadline.timedOut() ? localFailure({ code: "TIMEOUT", retryable: true, timeoutMs: this.#timeoutMs }) : localFailure({ code: "CANCELLED", retryable: false });
        }
        const startedAt = performance.now();
        let token;
        const credential = await settleCredentialWithinDeadlineV1(
          this.#bearerTokenProvider,
          deadline.signal
        );
        if (credential.kind === "aborted") {
          return deadline.timedOut() ? localFailure({ code: "TIMEOUT", retryable: true, timeoutMs: this.#timeoutMs }) : localFailure({ code: "CANCELLED", retryable: false });
        }
        if (credential.kind === "error") {
          return localFailure({ code: "TRANSPORT_ERROR", retryable: true, phase: "credential" });
        }
        token = credential.value;
        if (!TOKEN_PATTERN.test(token)) {
          return localFailure({ code: "TRANSPORT_ERROR", retryable: true, phase: "credential" });
        }
        const url = new URL(spec.path, this.#baseUrl);
        if (spec.query !== void 0) url.search = spec.query.toString();
        let response;
        try {
          response = await this.#fetch(url, {
            method: spec.method,
            redirect: "manual",
            headers: {
              Accept: "application/json",
              Authorization: `Bearer ${token}`,
              "X-Request-Id": spec.requestId,
              ...spec.body === null ? {} : {
                "Content-Type": spec.profile === "document-v3" ? DOCUMENT_MEDIA_TYPE_V3 : spec.profile === "document-v2" ? DOCUMENT_MEDIA_TYPE : "application/json"
              }
            },
            ...spec.body === null ? {} : { body: spec.body.slice().buffer },
            signal: deadline.signal
          });
        } catch {
          const result = deadline.signal.aborted ? deadline.timedOut() ? localFailure({ code: "TIMEOUT", retryable: true, timeoutMs: this.#timeoutMs }) : localFailure({ code: "CANCELLED", retryable: false }) : localFailure({ code: "TRANSPORT_ERROR", retryable: true, phase: "request" });
          if (!result.error.retryable || attempt >= maximumAttempts) return result;
          const delay = protectedRetryDelayMsV1(attempt);
          if (!await sleepWithinDeadlineV1(delay, deadline.remainingMs, deadline.signal))
            return result;
          continue;
        } finally {
          token = "";
        }
        if (response.redirected || response.status >= 300 && response.status < 400) {
          await response.body?.cancel().catch(() => void 0);
          return localFailure({ code: "RESPONSE_INVALID", retryable: false, reason: "status" });
        }
        if (response.headers.get("content-type")?.toLowerCase() !== "application/json; charset=utf-8") {
          await response.body?.cancel().catch(() => void 0);
          return localFailure({
            code: "RESPONSE_INVALID",
            retryable: false,
            reason: "content_type"
          });
        }
        const cap = response.status >= 200 && response.status < 300 ? spec.profile === "document-v2" || spec.profile === "document-v3" ? BOARD_DOCUMENT_LIMITS_V2.maxDocumentEnvelopeBytes : SUCCESS_BODY_LIMIT : ERROR_BODY_LIMIT;
        const bytes = await readBoundedResponseBodyV1(response, cap, deadline.signal);
        if (bytes === "body_too_large")
          return localFailure({
            code: "RESPONSE_INVALID",
            retryable: false,
            reason: "body_too_large"
          });
        if (bytes === "response") {
          const result = deadline.signal.aborted ? deadline.timedOut() ? localFailure({ code: "TIMEOUT", retryable: true, timeoutMs: this.#timeoutMs }) : localFailure({ code: "CANCELLED", retryable: false }) : localFailure({ code: "TRANSPORT_ERROR", retryable: true, phase: "response" });
          if (!result.error.retryable || attempt >= maximumAttempts) return result;
          const delay = protectedRetryDelayMsV1(attempt);
          if (!await sleepWithinDeadlineV1(delay, deadline.remainingMs, deadline.signal))
            return result;
          continue;
        }
        if (response.headers.get("x-request-id") !== spec.requestId) {
          return localFailure({
            code: "RESPONSE_INVALID",
            retryable: false,
            reason: "correlation"
          });
        }
        const parsed = spec.profile === "document-v3" && spec.resultType === "document.replace" ? parseBoardDocumentHttpResultV3(bytes, {
          status: response.status,
          requestId: spec.requestId,
          boardId: spec.boardId
        }) : spec.profile === "document-v3" ? parseBoardOperationHttpResultV3(bytes, {
          status: response.status,
          requestId: spec.requestId,
          resultType: spec.resultType,
          ...spec.boardId === void 0 ? {} : { boardId: spec.boardId },
          ...spec.revisionId === void 0 ? {} : { revisionId: spec.revisionId }
        }) : spec.profile === "document-v2" && spec.resultType === "document.replace" ? parseBoardDocumentHttpResultV2(bytes, {
          status: response.status,
          requestId: spec.requestId,
          boardId: spec.boardId
        }) : spec.profile === "document-v2" ? parseBoardOperationHttpResultV2(bytes, {
          status: response.status,
          requestId: spec.requestId,
          resultType: spec.resultType,
          ...spec.boardId === void 0 ? {} : { boardId: spec.boardId },
          ...spec.revisionId === void 0 ? {} : { revisionId: spec.revisionId }
        }) : parseBoardHttpResultV1(bytes, {
          status: response.status,
          requestId: spec.requestId,
          resultType: spec.resultType,
          ...spec.boardId === void 0 ? {} : { boardId: spec.boardId },
          ...spec.artifact === void 0 ? {} : { artifact: spec.artifact },
          ...spec.revisionId === void 0 ? {} : { revisionId: spec.revisionId }
        });
        if (!parsed.ok)
          return localFailure({
            code: "RESPONSE_INVALID",
            retryable: false,
            reason: parsed.reason
          });
        if (!parsed.value.ok) {
          const error3 = parsed.value.error;
          this.#logger.log({
            route: spec.routeTemplate,
            attempt,
            durationMs: performance.now() - startedAt,
            requestId: spec.requestId,
            resultCode: error3.code
          });
          if (shouldRetryError(error3) && attempt < maximumAttempts) {
            const serverDelay = retryDelayFromError(error3);
            const delay = serverDelay ?? protectedRetryDelayMsV1(attempt);
            if (await sleepWithinDeadlineV1(delay, deadline.remainingMs, deadline.signal)) continue;
          }
          return { ok: false, error: error3 };
        }
        this.#logger.log({
          route: spec.routeTemplate,
          attempt,
          durationMs: performance.now() - startedAt,
          requestId: spec.requestId,
          resultCode: spec.resultType
        });
        return {
          ok: true,
          result: parsed.value.value.result,
          metadata: parsed.value.value.metadata
        };
      }
      return localFailure({ code: "TRANSPORT_ERROR", retryable: true, phase: "request" });
    } finally {
      deadline.dispose();
    }
  }
};

// sceneboard-mcp/src/connection/connection-http.client.ts
var TOKEN_PATTERN2 = /^(?:lcbg_v1|sbk_v1)\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}$/;
var TIMESTAMP_PATTERN2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
var LIFECYCLE_PERMISSIONS = ["board.create", "board.archive"];
var exactRecord = (value, keys) => {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
  const record2 = value;
  const actual = Object.keys(record2).sort();
  const expected = [...keys].sort();
  return actual.length === expected.length && actual.every((key, index) => key === expected[index]) ? record2 : null;
};
var validTimestamp = (value) => {
  if (typeof value !== "string" || !TIMESTAMP_PATTERN2.test(value)) return false;
  const instant = Date.parse(value);
  return Number.isFinite(instant) && new Date(instant).toISOString() === value;
};
var exactCatalogSubset = (value, catalog, minimum) => {
  if (!Array.isArray(value) || value.length < minimum || value.length > catalog.length) return null;
  const result = [];
  let lastIndex = -1;
  for (const item of value) {
    const index = typeof item === "string" ? catalog.indexOf(item) : -1;
    if (index <= lastIndex) return null;
    lastIndex = index;
    result.push(item);
  }
  return result;
};
var parseGlobalId = (value) => {
  const parsed = GlobalIdStringParserV1.parse(value);
  return parsed.ok ? parsed.data.value : null;
};
var parseBoardAndCapabilities = (board, capabilities, requestId, boardId) => {
  const boardResult = BoardOperationResultParserV1.parse({
    protocolVersion: 1,
    type: "board.operation.result",
    requestId,
    replayed: false,
    result: { type: "board.list", boards: [board], nextCursor: null }
  });
  const parsedCapabilities = BoardCapabilitiesParserV1.parse(capabilities);
  if (!boardResult.ok || boardResult.data.value.result.type !== "board.list" || !parsedCapabilities.ok)
    return null;
  const parsedBoard = boardResult.data.value.result.boards[0];
  if (parsedBoard === void 0 || parsedBoard.boardId !== boardId) return null;
  return {
    board: parsedBoard,
    capabilities: parsedCapabilities.data.value
  };
};
var parsePairingConnection = (value, requestId, boardId) => {
  const root = exactRecord(value, ["principal", "grant", "selectedBoard", "versions"]);
  if (root === null) return null;
  const principal = exactRecord(root.principal, ["principalKind", "principalId", "grantId"]);
  const grant = exactRecord(root.grant, [
    "grantId",
    "client",
    "scopes",
    "lifecyclePermissions",
    "boardIds",
    "lifetime",
    "status",
    "activatedAt",
    "expiresAt"
  ]);
  const versions = exactRecord(root.versions, ["mcpServer", "boardProtocol", "api"]);
  if (principal === null || grant === null || versions === null || principal.principalKind !== "mcp_client" || versions.mcpServer !== "0.0.0" || versions.boardProtocol !== "1.0.0" || versions.api !== "v1")
    return null;
  const parsedPrincipalId = PrincipalIdParserV1.parse(principal.principalId);
  const parsedPrincipalGrantId = GrantIdParserV1.parse(principal.grantId);
  const parsedGrantId = GrantIdParserV1.parse(grant.grantId);
  const client = exactRecord(grant.client, ["clientId", "clientName", "installationFingerprint"]);
  const clientId = client === null ? null : parseGlobalId(client.clientId);
  if (!parsedPrincipalId.ok || !parsedPrincipalGrantId.ok || !parsedGrantId.ok || client === null || clientId === null || parsedPrincipalGrantId.data.value !== parsedGrantId.data.value || parsedPrincipalId.data.value !== clientId || typeof client.clientName !== "string" || [...client.clientName].length < 1 || [...client.clientName].length > 100 || /[\u0000-\u001f\u007f-\u009f\uD800-\uDFFF]/u.test(client.clientName) || typeof client.installationFingerprint !== "string" || !/^[A-Za-z0-9_-]{16}$/.test(client.installationFingerprint))
    return null;
  const scopes = exactCatalogSubset(grant.scopes, CLIENT_GRANT_SCOPE_ORDER_V1, 1);
  const lifecyclePermissions = exactCatalogSubset(
    grant.lifecyclePermissions,
    LIFECYCLE_PERMISSIONS,
    0
  );
  if (scopes === null || lifecyclePermissions === null || !Array.isArray(grant.boardIds) || grant.boardIds.length > 50 || grant.boardIds.length === 0 && (!scopes.includes("board.write") || !lifecyclePermissions.includes("board.create")) || grant.lifetime !== "session" && grant.lifetime !== "persistent" || grant.status !== "active" || !validTimestamp(grant.activatedAt) || !validTimestamp(grant.expiresAt))
    return null;
  const parsedBoardIds = [];
  let previousBoardId = "";
  for (const candidate of grant.boardIds) {
    const parsed = parseGlobalId(candidate);
    if (parsed === null || parsed <= previousBoardId) return null;
    previousBoardId = parsed;
    parsedBoardIds.push(parsed);
  }
  let selectedBoard = null;
  if (root.selectedBoard !== null) {
    if (boardId === null) return null;
    const selected = exactRecord(root.selectedBoard, [
      "board",
      "capabilities",
      "browserPresence",
      "capabilityEpoch"
    ]);
    if (selected === null || !["online", "offline", "unknown"].includes(String(selected.browserPresence)) || !Number.isSafeInteger(selected.capabilityEpoch) || Number(selected.capabilityEpoch) < 0)
      return null;
    const projection = parseBoardAndCapabilities(
      selected.board,
      selected.capabilities,
      requestId,
      boardId
    );
    if (projection === null || !parsedBoardIds.includes(projection.board.boardId)) return null;
    selectedBoard = {
      ...projection,
      browserPresence: selected.browserPresence,
      capabilityEpoch: Number(selected.capabilityEpoch)
    };
  } else if (boardId !== null) return null;
  return {
    principal: {
      principalKind: "mcp_client",
      principalId: parsedPrincipalId.data.value,
      grantId: parsedPrincipalGrantId.data.value
    },
    grant: {
      grantId: parsedGrantId.data.value,
      client: {
        clientId,
        clientName: client.clientName,
        installationFingerprint: client.installationFingerprint
      },
      scopes,
      lifecyclePermissions,
      boardIds: parsedBoardIds,
      lifetime: grant.lifetime,
      status: "active",
      activatedAt: grant.activatedAt,
      expiresAt: grant.expiresAt
    },
    selectedBoard,
    versions: { mcpServer: "0.0.0", boardProtocol: "1.0.0", api: "v1" }
  };
};
var parseApiKeyConnection = (value, requestId, boardId) => {
  const root = exactRecord(value, ["principal", "credential", "selectedBoard", "versions"]);
  if (root === null) return null;
  const principal = exactRecord(root.principal, ["principalKind", "principalId", "grantId"]);
  const credential = exactRecord(root.credential, ["keyPublicId", "scopes", "status", "expiresAt"]);
  const versions = exactRecord(root.versions, ["mcpServer", "boardProtocol", "api"]);
  if (principal === null || credential === null || versions === null || principal.principalKind !== "service" || principal.grantId !== null || credential.status !== "active" || !validTimestamp(credential.expiresAt) || versions.mcpServer !== "0.0.0" || versions.boardProtocol !== "1.0.0" || versions.api !== "v1")
    return null;
  const principalId = PrincipalIdParserV1.parse(principal.principalId);
  const keyPublicId = PrincipalIdParserV1.parse(credential.keyPublicId);
  const scopes = exactCatalogSubset(credential.scopes, ACCOUNT_API_KEY_SCOPES_V1, 1);
  if (!principalId.ok || !keyPublicId.ok || principalId.data.value !== keyPublicId.data.value || scopes === null)
    return null;
  let selectedBoard = null;
  if (root.selectedBoard !== null) {
    if (boardId === null) return null;
    const selected = exactRecord(root.selectedBoard, ["board", "capabilities"]);
    if (selected === null) return null;
    selectedBoard = parseBoardAndCapabilities(
      selected.board,
      selected.capabilities,
      requestId,
      boardId
    );
    if (selectedBoard === null) return null;
  } else if (boardId !== null) return null;
  return {
    principal: {
      principalKind: "service",
      principalId: principalId.data.value,
      grantId: null
    },
    credential: {
      keyPublicId: keyPublicId.data.value,
      scopes,
      status: "active",
      expiresAt: credential.expiresAt
    },
    selectedBoard,
    versions: { mcpServer: "0.0.0", boardProtocol: "1.0.0", api: "v1" }
  };
};
var parseAuthorizedConnectionProjectionV1 = (value, requestId, boardId, expectedCredentialMode) => {
  return expectedCredentialMode === "pairing" ? parsePairingConnection(value, requestId, boardId) : parseApiKeyConnection(value, requestId, boardId);
};
var parseAuthorizedConnectionV1 = (value, requestId, boardId, expectedCredentialMode, now) => {
  if (!Number.isFinite(now)) return null;
  const projection = parseAuthorizedConnectionProjectionV1(
    value,
    requestId,
    boardId,
    expectedCredentialMode
  );
  if (projection === null || expectedCredentialMode === "api_key" && "credential" in projection && Date.parse(projection.credential.expiresAt) <= now)
    return null;
  return projection;
};
var local = (error3) => ({
  ok: false,
  source: "local",
  error: error3
});
var ConnectionHttpClientV1 = class {
  constructor(options) {
    this.options = options;
  }
  async get(boardId, requestId, accessToken, outerSignal, expectedCredentialMode, authorizationOperation) {
    if (!TOKEN_PATTERN2.test(accessToken))
      return local({ code: "TRANSPORT_ERROR", retryable: true, phase: "connect" });
    const tokenCredentialMode = accessToken.startsWith("sbk_v1.") ? "api_key" : "pairing";
    const responseCredentialMode = expectedCredentialMode ?? tokenCredentialMode;
    if (responseCredentialMode !== tokenCredentialMode)
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: "schema" });
    const timeoutSignal = AbortSignal.timeout(this.options.timeoutMs);
    const signal = outerSignal === void 0 ? timeoutSignal : AbortSignal.any([outerSignal, timeoutSignal]);
    if (signal.aborted) return local({ code: "CANCELLED", retryable: false });
    const query = new URLSearchParams({ requestId });
    if (boardId !== null) query.set("boardId", boardId);
    if (authorizationOperation !== void 0)
      query.set("authorizationOperation", authorizationOperation);
    const url = new URL("/api/v1/mcp/connection", this.options.baseUrl);
    url.search = query.toString();
    const startedAt = performance.now();
    let response;
    try {
      response = await this.options.fetch(url, {
        method: "GET",
        redirect: "manual",
        headers: { Accept: "application/json", Authorization: `Bearer ${accessToken}` },
        signal
      });
    } catch {
      if (outerSignal?.aborted) return local({ code: "CANCELLED", retryable: false });
      if (timeoutSignal.aborted)
        return local({ code: "TIMEOUT", retryable: true, timeoutMs: this.options.timeoutMs });
      return local({ code: "TRANSPORT_ERROR", retryable: true, phase: "request" });
    }
    if (response.redirected || response.status >= 300 && response.status < 400) {
      await response.body?.cancel().catch(() => void 0);
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: "status" });
    }
    if (response.headers.get("content-type")?.toLowerCase() !== "application/json; charset=utf-8") {
      await response.body?.cancel().catch(() => void 0);
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: "content_type" });
    }
    if (response.headers.get("cache-control") !== "no-store, private" || response.headers.get("pragma") !== "no-cache" || response.headers.get("vary") !== "Origin, Cookie, Authorization") {
      await response.body?.cancel().catch(() => void 0);
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: "schema" });
    }
    const bytes = await BoardSdkHttpClient.readBoundedResponseBodyV1(
      response,
      response.status === 200 ? 2097152 : 65536,
      signal
    );
    if (bytes === "body_too_large")
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: "body_too_large" });
    if (bytes === "response") {
      if (outerSignal?.aborted) return local({ code: "CANCELLED", retryable: false });
      if (timeoutSignal.aborted)
        return local({ code: "TIMEOUT", retryable: true, timeoutMs: this.options.timeoutMs });
      return local({ code: "TRANSPORT_ERROR", retryable: true, phase: "response" });
    }
    if (response.headers.get("x-request-id") !== requestId) {
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: "correlation" });
    }
    const parsed = BoardSdkHttpClient.parseStrictJsonBytesV1(bytes);
    if (!parsed.ok)
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: parsed.reason });
    if (response.status === 200) {
      const value = parseAuthorizedConnectionV1(
        parsed.value,
        requestId,
        boardId,
        responseCredentialMode,
        this.options.now?.() ?? Date.now()
      );
      if (value === null)
        return local({ code: "RESPONSE_INVALID", retryable: false, reason: "schema" });
      this.options.logger.log({
        route: "/api/v1/mcp/connection",
        attempt: 1,
        durationMs: performance.now() - startedAt,
        requestId,
        resultCode: "connected"
      });
      return { ok: true, value };
    }
    const body = exactRecord(parsed.value, ["error"]);
    const error3 = body === null ? null : BoardErrorParserV1.parse(body.error);
    if (error3 === null || !error3.ok || error3.data.value.httpStatusHint !== response.status) {
      return local({ code: "RESPONSE_INVALID", retryable: false, reason: "status" });
    }
    this.options.logger.log({
      route: "/api/v1/mcp/connection",
      attempt: 1,
      durationMs: performance.now() - startedAt,
      requestId,
      resultCode: error3.data.value.code
    });
    return { ok: false, source: "board", error: error3.data.value };
  }
};

// sceneboard-mcp/src/connection/connection-status.service.ts
import { randomBytes as randomBytes3 } from "node:crypto";
var summary = (loaded, hasToken) => ({
  source: loaded.source,
  profile: loaded.config.profile,
  baseOrigin: loaded.config.baseUrl,
  timeoutMs: loaded.config.timeoutMs,
  hasToken
});
var localValue = (error3) => {
  if (error3.code === "CANCELLED")
    return {
      code: "BOARD_MCP_CANCELLED",
      message: "Connection check was cancelled",
      retryable: false,
      details: null
    };
  if (error3.code === "TIMEOUT")
    return {
      code: "BOARD_MCP_TIMEOUT",
      message: "SceneBoard connection timed out",
      retryable: true,
      details: { timeoutMs: error3.timeoutMs }
    };
  if (error3.code === "TRANSPORT_ERROR")
    return {
      code: "BOARD_MCP_TRANSPORT_ERROR",
      message: "SceneBoard transport is unavailable",
      retryable: true,
      details: { phase: error3.phase }
    };
  return {
    code: "BOARD_MCP_RESPONSE_INVALID",
    message: "SceneBoard response is invalid",
    retryable: false,
    details: { reason: error3.reason }
  };
};
var statusDeadline = (timeoutMs, callerSignal) => {
  const controller = new AbortController();
  let cause = null;
  const abortFromCaller = () => {
    if (cause !== null) return;
    cause = "caller";
    controller.abort(callerSignal?.reason);
  };
  if (callerSignal?.aborted) abortFromCaller();
  else callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
  const timer = setTimeout(() => {
    if (cause !== null) return;
    cause = "timeout";
    controller.abort(new DOMException("Connection deadline exceeded", "TimeoutError"));
  }, timeoutMs);
  return {
    signal: controller.signal,
    cause: () => cause,
    dispose: () => {
      clearTimeout(timer);
      callerSignal?.removeEventListener("abort", abortFromCaller);
    }
  };
};
var waitWithinDeadline = async (operation, signal) => {
  signal.throwIfAborted();
  return new Promise((resolve3, reject) => {
    const cleanup = () => signal.removeEventListener("abort", onAbort);
    const onAbort = () => {
      cleanup();
      reject(signal.reason);
    };
    signal.addEventListener("abort", onAbort, { once: true });
    operation.then(
      (value) => {
        cleanup();
        if (signal.aborted) reject(signal.reason);
        else resolve3(value);
      },
      (error3) => {
        cleanup();
        reject(error3);
      }
    );
  });
};
var cancelledResult = () => ({
  ok: false,
  source: "mcp",
  value: localValue({ code: "CANCELLED", retryable: false })
});
var ConnectionStatusServiceV1 = class {
  constructor(loaded, tokens, client) {
    this.loaded = loaded;
    this.tokens = tokens;
    this.client = client;
  }
  async status(boardId, requestId, signal) {
    const deadline = statusDeadline(this.loaded.config.timeoutMs, signal);
    try {
      let snapshot;
      try {
        deadline.signal.throwIfAborted();
        snapshot = await waitWithinDeadline(this.tokens.snapshot(deadline.signal), deadline.signal);
      } catch {
        if (deadline.cause() === "caller") return cancelledResult();
        if (deadline.cause() === "timeout")
          return {
            ok: true,
            value: {
              state: "backend_unavailable",
              config: summary(this.loaded, false),
              connection: null,
              lastErrorCode: "BOARD_MCP_TIMEOUT"
            }
          };
        return {
          ok: false,
          source: "mcp",
          value: {
            code: "BOARD_MCP_INTERNAL_ERROR",
            message: "Connection state is unavailable",
            retryable: false,
            details: { incidentId: randomBytes3(16).toString("base64url") }
          }
        };
      }
      if (snapshot === null)
        return {
          ok: true,
          value: {
            state: "credential_missing",
            config: summary(this.loaded, false),
            connection: null,
            lastErrorCode: null
          }
        };
      let result;
      try {
        result = await waitWithinDeadline(
          this.client.get(boardId, requestId, snapshot.accessToken, deadline.signal, "pairing"),
          deadline.signal
        );
      } catch {
        if (deadline.cause() === "caller") return cancelledResult();
        if (deadline.cause() === "timeout")
          return {
            ok: true,
            value: {
              state: "backend_unavailable",
              config: summary(this.loaded, true),
              connection: null,
              lastErrorCode: "BOARD_MCP_TIMEOUT"
            }
          };
        throw new Error("connection deadline invariant failed");
      }
      if (deadline.cause() === "caller") return cancelledResult();
      if (deadline.cause() === "timeout")
        return {
          ok: true,
          value: {
            state: "backend_unavailable",
            config: summary(this.loaded, true),
            connection: null,
            lastErrorCode: "BOARD_MCP_TIMEOUT"
          }
        };
      if (result.ok)
        return {
          ok: true,
          value: {
            state: "connected",
            config: summary(this.loaded, true),
            connection: result.value,
            lastErrorCode: null
          }
        };
      if (result.source === "board") {
        if (result.error.code !== "UNAUTHENTICATED") {
          return {
            ok: false,
            source: "board",
            value: result.error
          };
        }
        try {
          await waitWithinDeadline(
            this.tokens.invalidate(snapshot, deadline.signal),
            deadline.signal
          );
        } catch {
          if (deadline.cause() === "caller") return cancelledResult();
          if (deadline.cause() === "timeout")
            return {
              ok: true,
              value: {
                state: "backend_unavailable",
                config: summary(this.loaded, true),
                connection: null,
                lastErrorCode: "BOARD_MCP_TIMEOUT"
              }
            };
        }
        return {
          ok: true,
          value: {
            state: "credential_invalid",
            config: summary(this.loaded, false),
            connection: null,
            lastErrorCode: "UNAUTHENTICATED"
          }
        };
      }
      if (result.error.code === "CANCELLED") return cancelledResult();
      const translated = localValue(result.error);
      return {
        ok: true,
        value: {
          state: "backend_unavailable",
          config: summary(this.loaded, true),
          connection: null,
          lastErrorCode: translated.code
        }
      };
    } finally {
      deadline.dispose();
    }
  }
  async probeWithToken(accessToken, signal) {
    const requestId = randomBytes3(16).toString("base64url");
    return (await this.client.get(null, requestId, accessToken, signal, "pairing")).ok;
  }
};
var ApiKeyConnectionStatusServiceV1 = class {
  constructor(loaded, tokens, client) {
    this.loaded = loaded;
    this.tokens = tokens;
    this.client = client;
  }
  config(referenceConfigured) {
    return {
      source: this.loaded.config.accessTokenRef === "env://SCENEBOARD_API_KEY" ? "env" : "private_store",
      referenceConfigured
    };
  }
  state(state, referenceConfigured, lastErrorCode, retryable) {
    return {
      ok: true,
      value: {
        credentialMode: "api_key",
        state,
        config: this.config(referenceConfigured),
        connection: null,
        lastErrorCode,
        retryable
      }
    };
  }
  async status(boardId, requestId, signal) {
    const deadline = statusDeadline(this.loaded.config.timeoutMs, signal);
    try {
      let snapshot;
      try {
        deadline.signal.throwIfAborted();
        snapshot = await waitWithinDeadline(this.tokens.snapshot(deadline.signal), deadline.signal);
      } catch {
        if (deadline.cause() === "caller") return cancelledResult();
        if (deadline.cause() === "timeout")
          return this.state("backend_unavailable", true, "API_KEY_BACKEND_UNAVAILABLE", true);
        return this.state("credential_invalid", true, "API_KEY_CREDENTIAL_INVALID", false);
      }
      if (snapshot === null && "credentialInvalidated" in this.tokens && typeof this.tokens.credentialInvalidated === "function" && this.tokens.credentialInvalidated())
        return this.state("credential_invalid", true, "API_KEY_CREDENTIAL_INVALID", false);
      if (snapshot === null)
        return this.state("credential_missing", false, "API_KEY_CREDENTIAL_MISSING", false);
      let result;
      try {
        result = await waitWithinDeadline(
          this.client.get(
            boardId,
            requestId,
            snapshot.accessToken,
            deadline.signal,
            "api_key",
            boardId === null ? void 0 : "board.get"
          ),
          deadline.signal
        );
      } catch {
        if (deadline.cause() === "caller") return cancelledResult();
        if (deadline.cause() === "timeout")
          return this.state("backend_unavailable", true, "API_KEY_BACKEND_UNAVAILABLE", true);
        throw new Error("connection deadline invariant failed");
      }
      if (deadline.cause() === "caller") return cancelledResult();
      if (deadline.cause() === "timeout")
        return this.state("backend_unavailable", true, "API_KEY_BACKEND_UNAVAILABLE", true);
      if (result.ok) {
        if (!("credential" in result.value))
          return this.state("backend_unavailable", true, "API_KEY_BACKEND_RESPONSE_INVALID", true);
        return {
          ok: true,
          value: {
            credentialMode: "api_key",
            state: "connected",
            config: this.config(true),
            connection: result.value,
            lastErrorCode: null,
            retryable: false
          }
        };
      }
      if (result.source === "board") {
        if (result.error.code !== "UNAUTHENTICATED")
          return {
            ok: false,
            source: "board",
            value: result.error
          };
        try {
          await waitWithinDeadline(
            this.tokens.invalidate(snapshot, deadline.signal),
            deadline.signal
          );
        } catch {
          if (deadline.cause() === "caller") return cancelledResult();
          if (deadline.cause() === "timeout")
            return this.state("backend_unavailable", true, "API_KEY_BACKEND_UNAVAILABLE", true);
        }
        return this.state("credential_invalid", true, "API_KEY_CREDENTIAL_INVALID", false);
      }
      if (result.error.code === "CANCELLED") return cancelledResult();
      return this.state(
        "backend_unavailable",
        true,
        result.error.code === "RESPONSE_INVALID" ? "API_KEY_BACKEND_RESPONSE_INVALID" : "API_KEY_BACKEND_UNAVAILABLE",
        true
      );
    } finally {
      deadline.dispose();
    }
  }
};
var UnconfiguredConnectionStatusServiceV1 = class {
  async status(_boardId, _requestId, _signal) {
    return {
      ok: true,
      value: {
        state: "not_configured",
        config: null,
        connection: null,
        lastErrorCode: "BOARD_MCP_CONFIG_INVALID"
      }
    };
  }
};

// sceneboard-mcp/src/credentials/installation-identity.store.ts
import { randomBytes as randomBytes4 } from "node:crypto";
import { lstat as lstat2, readFile as readFile2 } from "node:fs/promises";
import { join as join5 } from "node:path";
var FILE_NAME = "installation.json";
var INSTALLATION_PATTERN = /^[A-Za-z0-9._:-]{16,128}$/;
var parseInstallation = (bytes) => {
  if (bytes.byteLength === 0 || bytes.byteLength > 256) throw new Error("installation record is invalid");
  let source;
  try {
    source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
  } catch {
    throw new Error("installation record is invalid");
  }
  let value;
  try {
    value = JSON.parse(source);
  } catch {
    throw new Error("installation record is invalid");
  }
  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("installation record is invalid");
  const record2 = value;
  if (Object.keys(record2).sort().join("\0") !== ["installationId", "version"].join("\0") || record2.version !== 1 || typeof record2.installationId !== "string" || !INSTALLATION_PATTERN.test(record2.installationId) || JSON.stringify(record2) !== source) {
    throw new Error("installation record is invalid");
  }
  return record2.installationId;
};
var InstallationIdentityStoreV1 = class {
  constructor(stateDirectory) {
    this.stateDirectory = stateDirectory;
  }
  async getOrCreate() {
    const path = join5(this.stateDirectory, FILE_NAME);
    try {
      const status = await lstat2(path);
      if (!status.isFile() || status.isSymbolicLink() || status.uid !== process.geteuid?.() || (status.mode & 511) !== 384 || status.nlink !== 1) throw new Error("installation record is invalid");
      return parseInstallation(await readFile2(path));
    } catch (error3) {
      if (error3.code !== "ENOENT") throw error3;
    }
    const installationId = `install_${randomBytes4(24).toString("base64url")}`;
    const bytes = new TextEncoder().encode(JSON.stringify({ version: 1, installationId }));
    await atomicPrivateWriteV1(this.stateDirectory, FILE_NAME, bytes);
    return installationId;
  }
};

// sceneboard-mcp/src/credentials/linux-profile-lease-helper.adapter.ts
import { createHash, randomBytes as randomBytes5 } from "node:crypto";
import { spawn } from "node:child_process";
import { constants as constants4 } from "node:fs";
import { lstat as lstat3, open as open4, readFile as readFile3 } from "node:fs/promises";

// sceneboard-mcp/src/credentials/profile-state.lease.ts
var ProfileLeaseErrorV1 = class extends Error {
  constructor(reason) {
    super("Profile lease is unavailable");
    this.reason = reason;
    this.name = "ProfileLeaseErrorV1";
  }
};

// sceneboard-mcp/src/credentials/linux-profile-lease-helper.adapter.ts
var FRAME_LIMIT = 64;
var waitForFrame = async (child, signal) => new Promise((resolve3, reject) => {
  signal?.throwIfAborted();
  let bytes = Buffer.alloc(0);
  const cleanup = () => {
    clearTimeout(timer);
    child.stdout.off("data", onData);
    child.stdout.off("end", onEnd);
    child.off("error", onError);
    signal?.removeEventListener("abort", onAbort);
  };
  const onAbort = () => {
    cleanup();
    reject(signal?.reason);
  };
  const onTimeout = () => {
    cleanup();
    reject(new ProfileLeaseErrorV1("liveness_unknown"));
  };
  const onError = () => {
    cleanup();
    reject(new ProfileLeaseErrorV1("liveness_unknown"));
  };
  const onEnd = () => {
    cleanup();
    reject(new ProfileLeaseErrorV1("liveness_unknown"));
  };
  const onData = (chunk) => {
    bytes = Buffer.concat([bytes, chunk]);
    if (bytes.byteLength > FRAME_LIMIT) {
      cleanup();
      reject(new ProfileLeaseErrorV1("lease_corrupt"));
      return;
    }
    const newline = bytes.indexOf(10);
    if (newline < 0) return;
    cleanup();
    resolve3(bytes.subarray(0, newline).toString("ascii"));
  };
  child.stdout.on("data", onData);
  child.stdout.once("end", onEnd);
  child.once("error", onError);
  signal?.addEventListener("abort", onAbort, { once: true });
  const timer = setTimeout(onTimeout, 2e3);
  timer.unref();
});
var LinuxProfileLeaseHelperAdapterV1 = class {
  constructor(helperPath, digestPath) {
    this.helperPath = helperPath;
    this.digestPath = digestPath;
  }
  async verify(signal) {
    signal?.throwIfAborted();
    if (process.platform !== "linux") return false;
    try {
      const [status, digestStatus, bytes, expected] = await Promise.all([
        lstat3(this.helperPath),
        lstat3(this.digestPath),
        readFile3(this.helperPath, { signal }),
        readFile3(this.digestPath, { encoding: "utf8", signal })
      ]);
      signal?.throwIfAborted();
      if (!status.isFile() || status.isSymbolicLink() || (status.mode & 511) !== 320 || status.uid !== process.geteuid?.())
        return false;
      if (!digestStatus.isFile() || digestStatus.isSymbolicLink() || digestStatus.uid !== process.geteuid?.())
        return false;
      return createHash("sha256").update(bytes).digest("hex") === expected.trim();
    } catch {
      if (signal?.aborted) signal.throwIfAborted();
      return false;
    }
  }
  async acquire(stateDirectory, signal) {
    signal?.throwIfAborted();
    if (!await this.verify(signal)) throw new ProfileLeaseErrorV1("liveness_unknown");
    signal?.throwIfAborted();
    const directory = await open4(
      stateDirectory,
      constants4.O_RDONLY | constants4.O_DIRECTORY | constants4.O_NOFOLLOW
    );
    if (signal?.aborted) {
      await directory.close();
      signal.throwIfAborted();
    }
    let spawned;
    try {
      spawned = spawn(this.helperPath, [], {
        stdio: ["pipe", "pipe", "pipe", directory.fd],
        env: {}
      });
    } catch {
      await directory.close();
      throw new ProfileLeaseErrorV1("liveness_unknown");
    }
    await directory.close();
    if (spawned.stdin === null || spawned.stdout === null || spawned.stderr === null) {
      spawned.kill("SIGTERM");
      throw new ProfileLeaseErrorV1("liveness_unknown");
    }
    const child = spawned;
    child.stderr.resume();
    const record2 = JSON.stringify({
      version: 1,
      state: "live",
      nonce: randomBytes5(16).toString("base64url"),
      pid: process.pid
    });
    child.stdin.write(`${record2}
`);
    let frame;
    try {
      frame = await waitForFrame(child, signal);
    } catch (error3) {
      child.kill("SIGTERM");
      throw error3;
    }
    if (frame === "busy") {
      child.stdin.end();
      throw new ProfileLeaseErrorV1("active_owner");
    }
    if (frame === "corrupt") {
      child.stdin.end();
      throw new ProfileLeaseErrorV1("lease_corrupt");
    }
    if (frame !== "ready") {
      child.stdin.end();
      throw new ProfileLeaseErrorV1("liveness_unknown");
    }
    if (signal?.aborted) {
      child.kill("SIGTERM");
      signal.throwIfAborted();
    }
    let released = false;
    return {
      release: async (releaseSignal) => {
        if (released) return;
        released = true;
        if (releaseSignal?.aborted) {
          child.kill("SIGTERM");
          return;
        }
        child.stdin.end();
        await new Promise((resolve3) => {
          if (child.exitCode !== null) {
            resolve3();
            return;
          }
          const cleanup = () => {
            clearTimeout(timer);
            child.off("exit", onExit);
            releaseSignal?.removeEventListener("abort", onAbort);
          };
          const finish = () => {
            cleanup();
            resolve3();
          };
          const onExit = () => finish();
          const onAbort = () => {
            child.kill("SIGTERM");
            finish();
          };
          const timer = setTimeout(() => {
            child.kill("SIGTERM");
            finish();
          }, 2e3);
          timer.unref();
          child.once("exit", onExit);
          releaseSignal?.addEventListener("abort", onAbort, { once: true });
        });
      }
    };
  }
};

// sceneboard-mcp/src/credentials/profile-lease.provider.ts
var ProfileLeaseProviderV1 = class {
  constructor(adapter) {
    this.adapter = adapter;
  }
  verify(signal) {
    return this.adapter.verify(signal);
  }
  acquire(stateDirectory, signal) {
    return this.adapter.acquire(stateDirectory, signal);
  }
};

// sceneboard-mcp/src/credentials/token-provider.ts
var waitForCredentialOperation = async (operation, signal) => {
  if (signal === void 0) return operation;
  signal.throwIfAborted();
  return new Promise((resolve3, reject) => {
    const cleanup = () => signal.removeEventListener("abort", onAbort);
    const onAbort = () => {
      cleanup();
      reject(signal.reason);
    };
    signal.addEventListener("abort", onAbort, { once: true });
    operation.then(
      (value) => {
        cleanup();
        if (signal.aborted) reject(signal.reason);
        else resolve3(value);
      },
      (error3) => {
        cleanup();
        reject(error3);
      }
    );
  });
};
var EnvironmentTokenProviderV1 = class {
  constructor(token) {
    this.token = token;
    if (token !== void 0 && token !== "" && !ACCESS_TOKEN_PATTERN_V1.test(token)) {
      throw new Error("provisioned credential is invalid");
    }
  }
  invalidated = false;
  async snapshot(signal) {
    signal?.throwIfAborted();
    if (this.invalidated || this.token === void 0 || this.token === "") return null;
    return { version: 1, generation: "environment_v1_token", accessToken: this.token };
  }
  async invalidate(snapshot, signal) {
    signal?.throwIfAborted();
    if (snapshot.generation === "environment_v1_token" && snapshot.accessToken === this.token)
      this.invalidated = true;
  }
};
var StoredTokenProviderV1 = class {
  constructor(store, leases) {
    this.store = store;
    this.leases = leases;
  }
  async snapshot(signal) {
    signal?.throwIfAborted();
    const lease = await waitForCredentialOperation(
      this.leases.acquire(this.store.stateDirectory, signal),
      signal
    );
    try {
      const snapshot = await waitForCredentialOperation(this.store.read(signal), signal);
      signal?.throwIfAborted();
      return snapshot;
    } finally {
      await lease.release(signal);
    }
  }
  async invalidate(snapshot, signal) {
    signal?.throwIfAborted();
    const lease = await waitForCredentialOperation(
      this.leases.acquire(this.store.stateDirectory, signal),
      signal
    );
    try {
      await waitForCredentialOperation(this.store.deleteIfCurrent(snapshot, signal), signal);
    } finally {
      await lease.release(signal);
    }
  }
};
var ApiKeyTokenProviderV1 = class {
  constructor(source) {
    this.source = source;
    this.malformedEnvironmentCredential = source.kind === "environment" && source.apiKey !== void 0 && source.apiKey !== "" && !ACCOUNT_API_KEY_PATTERN_V1.test(source.apiKey);
  }
  invalidated = false;
  cached;
  malformedEnvironmentCredential;
  async snapshot(signal) {
    signal?.throwIfAborted();
    if (this.invalidated) return null;
    if (this.malformedEnvironmentCredential) throw new Error("provisioned API key is invalid");
    if (this.cached !== void 0) return this.cached;
    if (this.source.kind === "environment") {
      this.cached = this.source.apiKey === void 0 || this.source.apiKey === "" ? null : {
        version: 1,
        generation: "environment_v1_token",
        accessToken: this.source.apiKey
      };
      return this.cached;
    }
    const record2 = await waitForCredentialOperation(
      this.source.store.read(signal),
      signal
    );
    this.cached = record2 === null ? null : {
      version: 1,
      generation: record2.generation,
      accessToken: record2.apiKey
    };
    return this.cached;
  }
  async invalidate(snapshot, signal) {
    const current = await this.snapshot(signal);
    signal?.throwIfAborted();
    if (current !== null && current.generation === snapshot.generation && current.accessToken === snapshot.accessToken) {
      this.invalidated = true;
      this.cached = null;
    }
  }
  credentialInvalidated() {
    return this.invalidated;
  }
};

// sceneboard-mcp/src/diagnostics/redact-secrets.ts
var SECRET_KEY = /(authorization|token|proof|challenge|code|password|cookie|secret|path|generation)/i;
var TOKEN_PATTERN3 = /(?:lcbg_v1|sbk_v1)\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}/g;
var PAIRING_PROOF_PATTERN = /PairingProof\s+[A-Za-z0-9_-]+/gi;
var EMBEDDED_SECRET_PATTERN = /Bearer\s+[A-Za-z0-9_-]{43}|sk-[A-Za-z0-9_-]{43}|[A-Z]{6}-[A-Z]{6}/g;
var redactSecretsV1 = (value, depth = 0) => {
  if (depth > 8) return "[REDACTED]";
  if (typeof value === "string") {
    return value.replace(TOKEN_PATTERN3, "[REDACTED]").replace(PAIRING_PROOF_PATTERN, "PairingProof [REDACTED]").replace(EMBEDDED_SECRET_PATTERN, "[REDACTED]");
  }
  if (Array.isArray(value)) return value.map((item) => redactSecretsV1(item, depth + 1));
  if (value !== null && typeof value === "object") {
    const result = {};
    for (const [key, item] of Object.entries(value)) {
      result[key] = SECRET_KEY.test(key) ? "[REDACTED]" : redactSecretsV1(item, depth + 1);
    }
    return result;
  }
  return value;
};

// sceneboard-mcp/src/diagnostics/safe-logger.ts
var SafeStderrLoggerV1 = class {
  constructor(write = (line) => process.stderr.write(line)) {
    this.write = write;
  }
  log(event) {
    const safe = redactSecretsV1(event);
    this.write(`${JSON.stringify(safe)}
`);
  }
};

// sceneboard-mcp/node_modules/zod/v3/external.js
var external_exports = {};
__export(external_exports, {
  BRAND: () => BRAND3,
  DIRTY: () => DIRTY3,
  EMPTY_PATH: () => EMPTY_PATH2,
  INVALID: () => INVALID3,
  NEVER: () => NEVER3,
  OK: () => OK3,
  ParseStatus: () => ParseStatus3,
  Schema: () => ZodType4,
  ZodAny: () => ZodAny3,
  ZodArray: () => ZodArray4,
  ZodBigInt: () => ZodBigInt3,
  ZodBoolean: () => ZodBoolean4,
  ZodBranded: () => ZodBranded3,
  ZodCatch: () => ZodCatch4,
  ZodDate: () => ZodDate3,
  ZodDefault: () => ZodDefault4,
  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion4,
  ZodEffects: () => ZodEffects3,
  ZodEnum: () => ZodEnum4,
  ZodError: () => ZodError4,
  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind3,
  ZodFunction: () => ZodFunction3,
  ZodIntersection: () => ZodIntersection4,
  ZodIssueCode: () => ZodIssueCode3,
  ZodLazy: () => ZodLazy3,
  ZodLiteral: () => ZodLiteral4,
  ZodMap: () => ZodMap3,
  ZodNaN: () => ZodNaN3,
  ZodNativeEnum: () => ZodNativeEnum3,
  ZodNever: () => ZodNever4,
  ZodNull: () => ZodNull4,
  ZodNullable: () => ZodNullable4,
  ZodNumber: () => ZodNumber4,
  ZodObject: () => ZodObject4,
  ZodOptional: () => ZodOptional4,
  ZodParsedType: () => ZodParsedType3,
  ZodPipeline: () => ZodPipeline3,
  ZodPromise: () => ZodPromise3,
  ZodReadonly: () => ZodReadonly4,
  ZodRecord: () => ZodRecord4,
  ZodSchema: () => ZodType4,
  ZodSet: () => ZodSet3,
  ZodString: () => ZodString4,
  ZodSymbol: () => ZodSymbol3,
  ZodTransformer: () => ZodEffects3,
  ZodTuple: () => ZodTuple3,
  ZodType: () => ZodType4,
  ZodUndefined: () => ZodUndefined3,
  ZodUnion: () => ZodUnion4,
  ZodUnknown: () => ZodUnknown4,
  ZodVoid: () => ZodVoid3,
  addIssueToContext: () => addIssueToContext3,
  any: () => anyType3,
  array: () => arrayType3,
  bigint: () => bigIntType3,
  boolean: () => booleanType3,
  coerce: () => coerce2,
  custom: () => custom3,
  date: () => dateType3,
  datetimeRegex: () => datetimeRegex3,
  defaultErrorMap: () => en_default3,
  discriminatedUnion: () => discriminatedUnionType3,
  effect: () => effectsType3,
  enum: () => enumType3,
  function: () => functionType3,
  getErrorMap: () => getErrorMap3,
  getParsedType: () => getParsedType4,
  instanceof: () => instanceOfType2,
  intersection: () => intersectionType3,
  isAborted: () => isAborted3,
  isAsync: () => isAsync3,
  isDirty: () => isDirty3,
  isValid: () => isValid3,
  late: () => late3,
  lazy: () => lazyType3,
  literal: () => literalType3,
  makeIssue: () => makeIssue3,
  map: () => mapType3,
  nan: () => nanType3,
  nativeEnum: () => nativeEnumType3,
  never: () => neverType3,
  null: () => nullType3,
  nullable: () => nullableType3,
  number: () => numberType3,
  object: () => objectType3,
  objectUtil: () => objectUtil3,
  oboolean: () => oboolean2,
  onumber: () => onumber2,
  optional: () => optionalType3,
  ostring: () => ostring2,
  pipeline: () => pipelineType3,
  preprocess: () => preprocessType3,
  promise: () => promiseType3,
  quotelessJson: () => quotelessJson2,
  record: () => recordType3,
  set: () => setType3,
  setErrorMap: () => setErrorMap2,
  strictObject: () => strictObjectType3,
  string: () => stringType3,
  symbol: () => symbolType3,
  transformer: () => effectsType3,
  tuple: () => tupleType3,
  undefined: () => undefinedType3,
  union: () => unionType3,
  unknown: () => unknownType3,
  util: () => util3,
  void: () => voidType3
});

// sceneboard-mcp/node_modules/zod/v3/helpers/util.js
var util3;
(function(util4) {
  util4.assertEqual = (_) => {
  };
  function assertIs2(_arg) {
  }
  util4.assertIs = assertIs2;
  function assertNever2(_x) {
    throw new Error();
  }
  util4.assertNever = assertNever2;
  util4.arrayToEnum = (items) => {
    const obj = {};
    for (const item of items) {
      obj[item] = item;
    }
    return obj;
  };
  util4.getValidEnumValues = (obj) => {
    const validKeys = util4.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
    const filtered = {};
    for (const k of validKeys) {
      filtered[k] = obj[k];
    }
    return util4.objectValues(filtered);
  };
  util4.objectValues = (obj) => {
    return util4.objectKeys(obj).map(function(e) {
      return obj[e];
    });
  };
  util4.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
    const keys = [];
    for (const key in object3) {
      if (Object.prototype.hasOwnProperty.call(object3, key)) {
        keys.push(key);
      }
    }
    return keys;
  };
  util4.find = (arr, checker) => {
    for (const item of arr) {
      if (checker(item))
        return item;
    }
    return void 0;
  };
  util4.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
  function joinValues2(array2, separator = " | ") {
    return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
  }
  util4.joinValues = joinValues2;
  util4.jsonStringifyReplacer = (_, value) => {
    if (typeof value === "bigint") {
      return value.toString();
    }
    return value;
  };
})(util3 || (util3 = {}));
var objectUtil3;
(function(objectUtil4) {
  objectUtil4.mergeShapes = (first, second) => {
    return {
      ...first,
      ...second
      // second overwrites first
    };
  };
})(objectUtil3 || (objectUtil3 = {}));
var ZodParsedType3 = util3.arrayToEnum([
  "string",
  "nan",
  "number",
  "integer",
  "float",
  "boolean",
  "date",
  "bigint",
  "symbol",
  "function",
  "undefined",
  "null",
  "array",
  "object",
  "unknown",
  "promise",
  "void",
  "never",
  "map",
  "set"
]);
var getParsedType4 = (data) => {
  const t = typeof data;
  switch (t) {
    case "undefined":
      return ZodParsedType3.undefined;
    case "string":
      return ZodParsedType3.string;
    case "number":
      return Number.isNaN(data) ? ZodParsedType3.nan : ZodParsedType3.number;
    case "boolean":
      return ZodParsedType3.boolean;
    case "function":
      return ZodParsedType3.function;
    case "bigint":
      return ZodParsedType3.bigint;
    case "symbol":
      return ZodParsedType3.symbol;
    case "object":
      if (Array.isArray(data)) {
        return ZodParsedType3.array;
      }
      if (data === null) {
        return ZodParsedType3.null;
      }
      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
        return ZodParsedType3.promise;
      }
      if (typeof Map !== "undefined" && data instanceof Map) {
        return ZodParsedType3.map;
      }
      if (typeof Set !== "undefined" && data instanceof Set) {
        return ZodParsedType3.set;
      }
      if (typeof Date !== "undefined" && data instanceof Date) {
        return ZodParsedType3.date;
      }
      return ZodParsedType3.object;
    default:
      return ZodParsedType3.unknown;
  }
};

// sceneboard-mcp/node_modules/zod/v3/ZodError.js
var ZodIssueCode3 = util3.arrayToEnum([
  "invalid_type",
  "invalid_literal",
  "custom",
  "invalid_union",
  "invalid_union_discriminator",
  "invalid_enum_value",
  "unrecognized_keys",
  "invalid_arguments",
  "invalid_return_type",
  "invalid_date",
  "invalid_string",
  "too_small",
  "too_big",
  "invalid_intersection_types",
  "not_multiple_of",
  "not_finite"
]);
var quotelessJson2 = (obj) => {
  const json = JSON.stringify(obj, null, 2);
  return json.replace(/"([^"]+)":/g, "$1:");
};
var ZodError4 = class _ZodError extends Error {
  get errors() {
    return this.issues;
  }
  constructor(issues) {
    super();
    this.issues = [];
    this.addIssue = (sub) => {
      this.issues = [...this.issues, sub];
    };
    this.addIssues = (subs = []) => {
      this.issues = [...this.issues, ...subs];
    };
    const actualProto = new.target.prototype;
    if (Object.setPrototypeOf) {
      Object.setPrototypeOf(this, actualProto);
    } else {
      this.__proto__ = actualProto;
    }
    this.name = "ZodError";
    this.issues = issues;
  }
  format(_mapper) {
    const mapper = _mapper || function(issue2) {
      return issue2.message;
    };
    const fieldErrors = { _errors: [] };
    const processError = (error3) => {
      for (const issue2 of error3.issues) {
        if (issue2.code === "invalid_union") {
          issue2.unionErrors.map(processError);
        } else if (issue2.code === "invalid_return_type") {
          processError(issue2.returnTypeError);
        } else if (issue2.code === "invalid_arguments") {
          processError(issue2.argumentsError);
        } else if (issue2.path.length === 0) {
          fieldErrors._errors.push(mapper(issue2));
        } else {
          let curr = fieldErrors;
          let i = 0;
          while (i < issue2.path.length) {
            const el = issue2.path[i];
            const terminal = i === issue2.path.length - 1;
            if (!terminal) {
              curr[el] = curr[el] || { _errors: [] };
            } else {
              curr[el] = curr[el] || { _errors: [] };
              curr[el]._errors.push(mapper(issue2));
            }
            curr = curr[el];
            i++;
          }
        }
      }
    };
    processError(this);
    return fieldErrors;
  }
  static assert(value) {
    if (!(value instanceof _ZodError)) {
      throw new Error(`Not a ZodError: ${value}`);
    }
  }
  toString() {
    return this.message;
  }
  get message() {
    return JSON.stringify(this.issues, util3.jsonStringifyReplacer, 2);
  }
  get isEmpty() {
    return this.issues.length === 0;
  }
  flatten(mapper = (issue2) => issue2.message) {
    const fieldErrors = {};
    const formErrors = [];
    for (const sub of this.issues) {
      if (sub.path.length > 0) {
        const firstEl = sub.path[0];
        fieldErrors[firstEl] = fieldErrors[firstEl] || [];
        fieldErrors[firstEl].push(mapper(sub));
      } else {
        formErrors.push(mapper(sub));
      }
    }
    return { formErrors, fieldErrors };
  }
  get formErrors() {
    return this.flatten();
  }
};
ZodError4.create = (issues) => {
  const error3 = new ZodError4(issues);
  return error3;
};

// sceneboard-mcp/node_modules/zod/v3/locales/en.js
var errorMap3 = (issue2, _ctx) => {
  let message;
  switch (issue2.code) {
    case ZodIssueCode3.invalid_type:
      if (issue2.received === ZodParsedType3.undefined) {
        message = "Required";
      } else {
        message = `Expected ${issue2.expected}, received ${issue2.received}`;
      }
      break;
    case ZodIssueCode3.invalid_literal:
      message = `Invalid literal value, expected ${JSON.stringify(issue2.expected, util3.jsonStringifyReplacer)}`;
      break;
    case ZodIssueCode3.unrecognized_keys:
      message = `Unrecognized key(s) in object: ${util3.joinValues(issue2.keys, ", ")}`;
      break;
    case ZodIssueCode3.invalid_union:
      message = `Invalid input`;
      break;
    case ZodIssueCode3.invalid_union_discriminator:
      message = `Invalid discriminator value. Expected ${util3.joinValues(issue2.options)}`;
      break;
    case ZodIssueCode3.invalid_enum_value:
      message = `Invalid enum value. Expected ${util3.joinValues(issue2.options)}, received '${issue2.received}'`;
      break;
    case ZodIssueCode3.invalid_arguments:
      message = `Invalid function arguments`;
      break;
    case ZodIssueCode3.invalid_return_type:
      message = `Invalid function return type`;
      break;
    case ZodIssueCode3.invalid_date:
      message = `Invalid date`;
      break;
    case ZodIssueCode3.invalid_string:
      if (typeof issue2.validation === "object") {
        if ("includes" in issue2.validation) {
          message = `Invalid input: must include "${issue2.validation.includes}"`;
          if (typeof issue2.validation.position === "number") {
            message = `${message} at one or more positions greater than or equal to ${issue2.validation.position}`;
          }
        } else if ("startsWith" in issue2.validation) {
          message = `Invalid input: must start with "${issue2.validation.startsWith}"`;
        } else if ("endsWith" in issue2.validation) {
          message = `Invalid input: must end with "${issue2.validation.endsWith}"`;
        } else {
          util3.assertNever(issue2.validation);
        }
      } else if (issue2.validation !== "regex") {
        message = `Invalid ${issue2.validation}`;
      } else {
        message = "Invalid";
      }
      break;
    case ZodIssueCode3.too_small:
      if (issue2.type === "array")
        message = `Array must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `more than`} ${issue2.minimum} element(s)`;
      else if (issue2.type === "string")
        message = `String must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `over`} ${issue2.minimum} character(s)`;
      else if (issue2.type === "number")
        message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`;
      else if (issue2.type === "bigint")
        message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`;
      else if (issue2.type === "date")
        message = `Date must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue2.minimum))}`;
      else
        message = "Invalid input";
      break;
    case ZodIssueCode3.too_big:
      if (issue2.type === "array")
        message = `Array must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `less than`} ${issue2.maximum} element(s)`;
      else if (issue2.type === "string")
        message = `String must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `under`} ${issue2.maximum} character(s)`;
      else if (issue2.type === "number")
        message = `Number must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`;
      else if (issue2.type === "bigint")
        message = `BigInt must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`;
      else if (issue2.type === "date")
        message = `Date must be ${issue2.exact ? `exactly` : issue2.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue2.maximum))}`;
      else
        message = "Invalid input";
      break;
    case ZodIssueCode3.custom:
      message = `Invalid input`;
      break;
    case ZodIssueCode3.invalid_intersection_types:
      message = `Intersection results could not be merged`;
      break;
    case ZodIssueCode3.not_multiple_of:
      message = `Number must be a multiple of ${issue2.multipleOf}`;
      break;
    case ZodIssueCode3.not_finite:
      message = "Number must be finite";
      break;
    default:
      message = _ctx.defaultError;
      util3.assertNever(issue2);
  }
  return { message };
};
var en_default3 = errorMap3;

// sceneboard-mcp/node_modules/zod/v3/errors.js
var overrideErrorMap3 = en_default3;
function setErrorMap2(map) {
  overrideErrorMap3 = map;
}
function getErrorMap3() {
  return overrideErrorMap3;
}

// sceneboard-mcp/node_modules/zod/v3/helpers/parseUtil.js
var makeIssue3 = (params) => {
  const { data, path, errorMaps, issueData } = params;
  const fullPath = [...path, ...issueData.path || []];
  const fullIssue = {
    ...issueData,
    path: fullPath
  };
  if (issueData.message !== void 0) {
    return {
      ...issueData,
      path: fullPath,
      message: issueData.message
    };
  }
  let errorMessage = "";
  const maps = errorMaps.filter((m) => !!m).slice().reverse();
  for (const map of maps) {
    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
  }
  return {
    ...issueData,
    path: fullPath,
    message: errorMessage
  };
};
var EMPTY_PATH2 = [];
function addIssueToContext3(ctx, issueData) {
  const overrideMap = getErrorMap3();
  const issue2 = makeIssue3({
    issueData,
    data: ctx.data,
    path: ctx.path,
    errorMaps: [
      ctx.common.contextualErrorMap,
      // contextual error map is first priority
      ctx.schemaErrorMap,
      // then schema-bound map if available
      overrideMap,
      // then global override map
      overrideMap === en_default3 ? void 0 : en_default3
      // then global default map
    ].filter((x) => !!x)
  });
  ctx.common.issues.push(issue2);
}
var ParseStatus3 = class _ParseStatus {
  constructor() {
    this.value = "valid";
  }
  dirty() {
    if (this.value === "valid")
      this.value = "dirty";
  }
  abort() {
    if (this.value !== "aborted")
      this.value = "aborted";
  }
  static mergeArray(status, results2) {
    const arrayValue = [];
    for (const s of results2) {
      if (s.status === "aborted")
        return INVALID3;
      if (s.status === "dirty")
        status.dirty();
      arrayValue.push(s.value);
    }
    return { status: status.value, value: arrayValue };
  }
  static async mergeObjectAsync(status, pairs) {
    const syncPairs = [];
    for (const pair of pairs) {
      const key = await pair.key;
      const value = await pair.value;
      syncPairs.push({
        key,
        value
      });
    }
    return _ParseStatus.mergeObjectSync(status, syncPairs);
  }
  static mergeObjectSync(status, pairs) {
    const finalObject = {};
    for (const pair of pairs) {
      const { key, value } = pair;
      if (key.status === "aborted")
        return INVALID3;
      if (value.status === "aborted")
        return INVALID3;
      if (key.status === "dirty")
        status.dirty();
      if (value.status === "dirty")
        status.dirty();
      if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
        finalObject[key.value] = value.value;
      }
    }
    return { status: status.value, value: finalObject };
  }
};
var INVALID3 = Object.freeze({
  status: "aborted"
});
var DIRTY3 = (value) => ({ status: "dirty", value });
var OK3 = (value) => ({ status: "valid", value });
var isAborted3 = (x) => x.status === "aborted";
var isDirty3 = (x) => x.status === "dirty";
var isValid3 = (x) => x.status === "valid";
var isAsync3 = (x) => typeof Promise !== "undefined" && x instanceof Promise;

// sceneboard-mcp/node_modules/zod/v3/helpers/errorUtil.js
var errorUtil3;
(function(errorUtil4) {
  errorUtil4.errToObj = (message) => typeof message === "string" ? { message } : message || {};
  errorUtil4.toString = (message) => typeof message === "string" ? message : message?.message;
})(errorUtil3 || (errorUtil3 = {}));

// sceneboard-mcp/node_modules/zod/v3/types.js
var ParseInputLazyPath3 = class {
  constructor(parent, value, path, key) {
    this._cachedPath = [];
    this.parent = parent;
    this.data = value;
    this._path = path;
    this._key = key;
  }
  get path() {
    if (!this._cachedPath.length) {
      if (Array.isArray(this._key)) {
        this._cachedPath.push(...this._path, ...this._key);
      } else {
        this._cachedPath.push(...this._path, this._key);
      }
    }
    return this._cachedPath;
  }
};
var handleResult3 = (ctx, result) => {
  if (isValid3(result)) {
    return { success: true, data: result.value };
  } else {
    if (!ctx.common.issues.length) {
      throw new Error("Validation failed but no issues detected.");
    }
    return {
      success: false,
      get error() {
        if (this._error)
          return this._error;
        const error3 = new ZodError4(ctx.common.issues);
        this._error = error3;
        return this._error;
      }
    };
  }
};
function processCreateParams3(params) {
  if (!params)
    return {};
  const { errorMap: errorMap4, invalid_type_error, required_error, description } = params;
  if (errorMap4 && (invalid_type_error || required_error)) {
    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
  }
  if (errorMap4)
    return { errorMap: errorMap4, description };
  const customMap = (iss, ctx) => {
    const { message } = params;
    if (iss.code === "invalid_enum_value") {
      return { message: message ?? ctx.defaultError };
    }
    if (typeof ctx.data === "undefined") {
      return { message: message ?? required_error ?? ctx.defaultError };
    }
    if (iss.code !== "invalid_type")
      return { message: ctx.defaultError };
    return { message: message ?? invalid_type_error ?? ctx.defaultError };
  };
  return { errorMap: customMap, description };
}
var ZodType4 = class {
  get description() {
    return this._def.description;
  }
  _getType(input) {
    return getParsedType4(input.data);
  }
  _getOrReturnCtx(input, ctx) {
    return ctx || {
      common: input.parent.common,
      data: input.data,
      parsedType: getParsedType4(input.data),
      schemaErrorMap: this._def.errorMap,
      path: input.path,
      parent: input.parent
    };
  }
  _processInputParams(input) {
    return {
      status: new ParseStatus3(),
      ctx: {
        common: input.parent.common,
        data: input.data,
        parsedType: getParsedType4(input.data),
        schemaErrorMap: this._def.errorMap,
        path: input.path,
        parent: input.parent
      }
    };
  }
  _parseSync(input) {
    const result = this._parse(input);
    if (isAsync3(result)) {
      throw new Error("Synchronous parse encountered promise.");
    }
    return result;
  }
  _parseAsync(input) {
    const result = this._parse(input);
    return Promise.resolve(result);
  }
  parse(data, params) {
    const result = this.safeParse(data, params);
    if (result.success)
      return result.data;
    throw result.error;
  }
  safeParse(data, params) {
    const ctx = {
      common: {
        issues: [],
        async: params?.async ?? false,
        contextualErrorMap: params?.errorMap
      },
      path: params?.path || [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType4(data)
    };
    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
    return handleResult3(ctx, result);
  }
  "~validate"(data) {
    const ctx = {
      common: {
        issues: [],
        async: !!this["~standard"].async
      },
      path: [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType4(data)
    };
    if (!this["~standard"].async) {
      try {
        const result = this._parseSync({ data, path: [], parent: ctx });
        return isValid3(result) ? {
          value: result.value
        } : {
          issues: ctx.common.issues
        };
      } catch (err) {
        if (err?.message?.toLowerCase()?.includes("encountered")) {
          this["~standard"].async = true;
        }
        ctx.common = {
          issues: [],
          async: true
        };
      }
    }
    return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid3(result) ? {
      value: result.value
    } : {
      issues: ctx.common.issues
    });
  }
  async parseAsync(data, params) {
    const result = await this.safeParseAsync(data, params);
    if (result.success)
      return result.data;
    throw result.error;
  }
  async safeParseAsync(data, params) {
    const ctx = {
      common: {
        issues: [],
        contextualErrorMap: params?.errorMap,
        async: true
      },
      path: params?.path || [],
      schemaErrorMap: this._def.errorMap,
      parent: null,
      data,
      parsedType: getParsedType4(data)
    };
    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
    const result = await (isAsync3(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
    return handleResult3(ctx, result);
  }
  refine(check2, message) {
    const getIssueProperties = (val) => {
      if (typeof message === "string" || typeof message === "undefined") {
        return { message };
      } else if (typeof message === "function") {
        return message(val);
      } else {
        return message;
      }
    };
    return this._refinement((val, ctx) => {
      const result = check2(val);
      const setError = () => ctx.addIssue({
        code: ZodIssueCode3.custom,
        ...getIssueProperties(val)
      });
      if (typeof Promise !== "undefined" && result instanceof Promise) {
        return result.then((data) => {
          if (!data) {
            setError();
            return false;
          } else {
            return true;
          }
        });
      }
      if (!result) {
        setError();
        return false;
      } else {
        return true;
      }
    });
  }
  refinement(check2, refinementData) {
    return this._refinement((val, ctx) => {
      if (!check2(val)) {
        ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
        return false;
      } else {
        return true;
      }
    });
  }
  _refinement(refinement) {
    return new ZodEffects3({
      schema: this,
      typeName: ZodFirstPartyTypeKind3.ZodEffects,
      effect: { type: "refinement", refinement }
    });
  }
  superRefine(refinement) {
    return this._refinement(refinement);
  }
  constructor(def) {
    this.spa = this.safeParseAsync;
    this._def = def;
    this.parse = this.parse.bind(this);
    this.safeParse = this.safeParse.bind(this);
    this.parseAsync = this.parseAsync.bind(this);
    this.safeParseAsync = this.safeParseAsync.bind(this);
    this.spa = this.spa.bind(this);
    this.refine = this.refine.bind(this);
    this.refinement = this.refinement.bind(this);
    this.superRefine = this.superRefine.bind(this);
    this.optional = this.optional.bind(this);
    this.nullable = this.nullable.bind(this);
    this.nullish = this.nullish.bind(this);
    this.array = this.array.bind(this);
    this.promise = this.promise.bind(this);
    this.or = this.or.bind(this);
    this.and = this.and.bind(this);
    this.transform = this.transform.bind(this);
    this.brand = this.brand.bind(this);
    this.default = this.default.bind(this);
    this.catch = this.catch.bind(this);
    this.describe = this.describe.bind(this);
    this.pipe = this.pipe.bind(this);
    this.readonly = this.readonly.bind(this);
    this.isNullable = this.isNullable.bind(this);
    this.isOptional = this.isOptional.bind(this);
    this["~standard"] = {
      version: 1,
      vendor: "zod",
      validate: (data) => this["~validate"](data)
    };
  }
  optional() {
    return ZodOptional4.create(this, this._def);
  }
  nullable() {
    return ZodNullable4.create(this, this._def);
  }
  nullish() {
    return this.nullable().optional();
  }
  array() {
    return ZodArray4.create(this);
  }
  promise() {
    return ZodPromise3.create(this, this._def);
  }
  or(option) {
    return ZodUnion4.create([this, option], this._def);
  }
  and(incoming) {
    return ZodIntersection4.create(this, incoming, this._def);
  }
  transform(transform2) {
    return new ZodEffects3({
      ...processCreateParams3(this._def),
      schema: this,
      typeName: ZodFirstPartyTypeKind3.ZodEffects,
      effect: { type: "transform", transform: transform2 }
    });
  }
  default(def) {
    const defaultValueFunc = typeof def === "function" ? def : () => def;
    return new ZodDefault4({
      ...processCreateParams3(this._def),
      innerType: this,
      defaultValue: defaultValueFunc,
      typeName: ZodFirstPartyTypeKind3.ZodDefault
    });
  }
  brand() {
    return new ZodBranded3({
      typeName: ZodFirstPartyTypeKind3.ZodBranded,
      type: this,
      ...processCreateParams3(this._def)
    });
  }
  catch(def) {
    const catchValueFunc = typeof def === "function" ? def : () => def;
    return new ZodCatch4({
      ...processCreateParams3(this._def),
      innerType: this,
      catchValue: catchValueFunc,
      typeName: ZodFirstPartyTypeKind3.ZodCatch
    });
  }
  describe(description) {
    const This = this.constructor;
    return new This({
      ...this._def,
      description
    });
  }
  pipe(target) {
    return ZodPipeline3.create(this, target);
  }
  readonly() {
    return ZodReadonly4.create(this);
  }
  isOptional() {
    return this.safeParse(void 0).success;
  }
  isNullable() {
    return this.safeParse(null).success;
  }
};
var cuidRegex3 = /^c[^\s-]{8,}$/i;
var cuid2Regex3 = /^[0-9a-z]+$/;
var ulidRegex3 = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
var uuidRegex3 = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
var nanoidRegex3 = /^[a-z0-9_-]{21}$/i;
var jwtRegex2 = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
var durationRegex3 = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
var emailRegex3 = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
var _emojiRegex3 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
var emojiRegex4;
var ipv4Regex3 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv4CidrRegex2 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
var ipv6Regex3 = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
var ipv6CidrRegex2 = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64Regex3 = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
var base64urlRegex2 = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
var dateRegexSource3 = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
var dateRegex3 = new RegExp(`^${dateRegexSource3}$`);
function timeRegexSource3(args) {
  let secondsRegexSource = `[0-5]\\d`;
  if (args.precision) {
    secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
  } else if (args.precision == null) {
    secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
  }
  const secondsQuantifier = args.precision ? "+" : "?";
  return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
}
function timeRegex3(args) {
  return new RegExp(`^${timeRegexSource3(args)}$`);
}
function datetimeRegex3(args) {
  let regex = `${dateRegexSource3}T${timeRegexSource3(args)}`;
  const opts = [];
  opts.push(args.local ? `Z?` : `Z`);
  if (args.offset)
    opts.push(`([+-]\\d{2}:?\\d{2})`);
  regex = `${regex}(${opts.join("|")})`;
  return new RegExp(`^${regex}$`);
}
function isValidIP3(ip, version2) {
  if ((version2 === "v4" || !version2) && ipv4Regex3.test(ip)) {
    return true;
  }
  if ((version2 === "v6" || !version2) && ipv6Regex3.test(ip)) {
    return true;
  }
  return false;
}
function isValidJWT3(jwt, alg) {
  if (!jwtRegex2.test(jwt))
    return false;
  try {
    const [header] = jwt.split(".");
    if (!header)
      return false;
    const base642 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
    const decoded = JSON.parse(atob(base642));
    if (typeof decoded !== "object" || decoded === null)
      return false;
    if ("typ" in decoded && decoded?.typ !== "JWT")
      return false;
    if (!decoded.alg)
      return false;
    if (alg && decoded.alg !== alg)
      return false;
    return true;
  } catch {
    return false;
  }
}
function isValidCidr2(ip, version2) {
  if ((version2 === "v4" || !version2) && ipv4CidrRegex2.test(ip)) {
    return true;
  }
  if ((version2 === "v6" || !version2) && ipv6CidrRegex2.test(ip)) {
    return true;
  }
  return false;
}
var ZodString4 = class _ZodString2 extends ZodType4 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = String(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.string) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext3(ctx2, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.string,
        received: ctx2.parsedType
      });
      return INVALID3;
    }
    const status = new ParseStatus3();
    let ctx = void 0;
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        if (input.data.length < check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_small,
            minimum: check2.value,
            type: "string",
            inclusive: true,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        if (input.data.length > check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_big,
            maximum: check2.value,
            type: "string",
            inclusive: true,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "length") {
        const tooBig = input.data.length > check2.value;
        const tooSmall = input.data.length < check2.value;
        if (tooBig || tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          if (tooBig) {
            addIssueToContext3(ctx, {
              code: ZodIssueCode3.too_big,
              maximum: check2.value,
              type: "string",
              inclusive: true,
              exact: true,
              message: check2.message
            });
          } else if (tooSmall) {
            addIssueToContext3(ctx, {
              code: ZodIssueCode3.too_small,
              minimum: check2.value,
              type: "string",
              inclusive: true,
              exact: true,
              message: check2.message
            });
          }
          status.dirty();
        }
      } else if (check2.kind === "email") {
        if (!emailRegex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "email",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "emoji") {
        if (!emojiRegex4) {
          emojiRegex4 = new RegExp(_emojiRegex3, "u");
        }
        if (!emojiRegex4.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "emoji",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "uuid") {
        if (!uuidRegex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "uuid",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "nanoid") {
        if (!nanoidRegex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "nanoid",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cuid") {
        if (!cuidRegex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "cuid",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cuid2") {
        if (!cuid2Regex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "cuid2",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "ulid") {
        if (!ulidRegex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "ulid",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "url") {
        try {
          new URL(input.data);
        } catch {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "url",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "regex") {
        check2.regex.lastIndex = 0;
        const testResult = check2.regex.test(input.data);
        if (!testResult) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "regex",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "trim") {
        input.data = input.data.trim();
      } else if (check2.kind === "includes") {
        if (!input.data.includes(check2.value, check2.position)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.invalid_string,
            validation: { includes: check2.value, position: check2.position },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "toLowerCase") {
        input.data = input.data.toLowerCase();
      } else if (check2.kind === "toUpperCase") {
        input.data = input.data.toUpperCase();
      } else if (check2.kind === "startsWith") {
        if (!input.data.startsWith(check2.value)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.invalid_string,
            validation: { startsWith: check2.value },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "endsWith") {
        if (!input.data.endsWith(check2.value)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.invalid_string,
            validation: { endsWith: check2.value },
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "datetime") {
        const regex = datetimeRegex3(check2);
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.invalid_string,
            validation: "datetime",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "date") {
        const regex = dateRegex3;
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.invalid_string,
            validation: "date",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "time") {
        const regex = timeRegex3(check2);
        if (!regex.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.invalid_string,
            validation: "time",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "duration") {
        if (!durationRegex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "duration",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "ip") {
        if (!isValidIP3(input.data, check2.version)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "ip",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "jwt") {
        if (!isValidJWT3(input.data, check2.alg)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "jwt",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "cidr") {
        if (!isValidCidr2(input.data, check2.version)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "cidr",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "base64") {
        if (!base64Regex3.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "base64",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "base64url") {
        if (!base64urlRegex2.test(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            validation: "base64url",
            code: ZodIssueCode3.invalid_string,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util3.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  _regex(regex, validation, message) {
    return this.refinement((data) => regex.test(data), {
      validation,
      code: ZodIssueCode3.invalid_string,
      ...errorUtil3.errToObj(message)
    });
  }
  _addCheck(check2) {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  email(message) {
    return this._addCheck({ kind: "email", ...errorUtil3.errToObj(message) });
  }
  url(message) {
    return this._addCheck({ kind: "url", ...errorUtil3.errToObj(message) });
  }
  emoji(message) {
    return this._addCheck({ kind: "emoji", ...errorUtil3.errToObj(message) });
  }
  uuid(message) {
    return this._addCheck({ kind: "uuid", ...errorUtil3.errToObj(message) });
  }
  nanoid(message) {
    return this._addCheck({ kind: "nanoid", ...errorUtil3.errToObj(message) });
  }
  cuid(message) {
    return this._addCheck({ kind: "cuid", ...errorUtil3.errToObj(message) });
  }
  cuid2(message) {
    return this._addCheck({ kind: "cuid2", ...errorUtil3.errToObj(message) });
  }
  ulid(message) {
    return this._addCheck({ kind: "ulid", ...errorUtil3.errToObj(message) });
  }
  base64(message) {
    return this._addCheck({ kind: "base64", ...errorUtil3.errToObj(message) });
  }
  base64url(message) {
    return this._addCheck({
      kind: "base64url",
      ...errorUtil3.errToObj(message)
    });
  }
  jwt(options) {
    return this._addCheck({ kind: "jwt", ...errorUtil3.errToObj(options) });
  }
  ip(options) {
    return this._addCheck({ kind: "ip", ...errorUtil3.errToObj(options) });
  }
  cidr(options) {
    return this._addCheck({ kind: "cidr", ...errorUtil3.errToObj(options) });
  }
  datetime(options) {
    if (typeof options === "string") {
      return this._addCheck({
        kind: "datetime",
        precision: null,
        offset: false,
        local: false,
        message: options
      });
    }
    return this._addCheck({
      kind: "datetime",
      precision: typeof options?.precision === "undefined" ? null : options?.precision,
      offset: options?.offset ?? false,
      local: options?.local ?? false,
      ...errorUtil3.errToObj(options?.message)
    });
  }
  date(message) {
    return this._addCheck({ kind: "date", message });
  }
  time(options) {
    if (typeof options === "string") {
      return this._addCheck({
        kind: "time",
        precision: null,
        message: options
      });
    }
    return this._addCheck({
      kind: "time",
      precision: typeof options?.precision === "undefined" ? null : options?.precision,
      ...errorUtil3.errToObj(options?.message)
    });
  }
  duration(message) {
    return this._addCheck({ kind: "duration", ...errorUtil3.errToObj(message) });
  }
  regex(regex, message) {
    return this._addCheck({
      kind: "regex",
      regex,
      ...errorUtil3.errToObj(message)
    });
  }
  includes(value, options) {
    return this._addCheck({
      kind: "includes",
      value,
      position: options?.position,
      ...errorUtil3.errToObj(options?.message)
    });
  }
  startsWith(value, message) {
    return this._addCheck({
      kind: "startsWith",
      value,
      ...errorUtil3.errToObj(message)
    });
  }
  endsWith(value, message) {
    return this._addCheck({
      kind: "endsWith",
      value,
      ...errorUtil3.errToObj(message)
    });
  }
  min(minLength, message) {
    return this._addCheck({
      kind: "min",
      value: minLength,
      ...errorUtil3.errToObj(message)
    });
  }
  max(maxLength, message) {
    return this._addCheck({
      kind: "max",
      value: maxLength,
      ...errorUtil3.errToObj(message)
    });
  }
  length(len, message) {
    return this._addCheck({
      kind: "length",
      value: len,
      ...errorUtil3.errToObj(message)
    });
  }
  /**
   * Equivalent to `.min(1)`
   */
  nonempty(message) {
    return this.min(1, errorUtil3.errToObj(message));
  }
  trim() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "trim" }]
    });
  }
  toLowerCase() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "toLowerCase" }]
    });
  }
  toUpperCase() {
    return new _ZodString2({
      ...this._def,
      checks: [...this._def.checks, { kind: "toUpperCase" }]
    });
  }
  get isDatetime() {
    return !!this._def.checks.find((ch) => ch.kind === "datetime");
  }
  get isDate() {
    return !!this._def.checks.find((ch) => ch.kind === "date");
  }
  get isTime() {
    return !!this._def.checks.find((ch) => ch.kind === "time");
  }
  get isDuration() {
    return !!this._def.checks.find((ch) => ch.kind === "duration");
  }
  get isEmail() {
    return !!this._def.checks.find((ch) => ch.kind === "email");
  }
  get isURL() {
    return !!this._def.checks.find((ch) => ch.kind === "url");
  }
  get isEmoji() {
    return !!this._def.checks.find((ch) => ch.kind === "emoji");
  }
  get isUUID() {
    return !!this._def.checks.find((ch) => ch.kind === "uuid");
  }
  get isNANOID() {
    return !!this._def.checks.find((ch) => ch.kind === "nanoid");
  }
  get isCUID() {
    return !!this._def.checks.find((ch) => ch.kind === "cuid");
  }
  get isCUID2() {
    return !!this._def.checks.find((ch) => ch.kind === "cuid2");
  }
  get isULID() {
    return !!this._def.checks.find((ch) => ch.kind === "ulid");
  }
  get isIP() {
    return !!this._def.checks.find((ch) => ch.kind === "ip");
  }
  get isCIDR() {
    return !!this._def.checks.find((ch) => ch.kind === "cidr");
  }
  get isBase64() {
    return !!this._def.checks.find((ch) => ch.kind === "base64");
  }
  get isBase64url() {
    return !!this._def.checks.find((ch) => ch.kind === "base64url");
  }
  get minLength() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxLength() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
};
ZodString4.create = (params) => {
  return new ZodString4({
    checks: [],
    typeName: ZodFirstPartyTypeKind3.ZodString,
    coerce: params?.coerce ?? false,
    ...processCreateParams3(params)
  });
};
function floatSafeRemainder4(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepDecCount = (step.toString().split(".")[1] || "").length;
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
var ZodNumber4 = class _ZodNumber extends ZodType4 {
  constructor() {
    super(...arguments);
    this.min = this.gte;
    this.max = this.lte;
    this.step = this.multipleOf;
  }
  _parse(input) {
    if (this._def.coerce) {
      input.data = Number(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.number) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext3(ctx2, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.number,
        received: ctx2.parsedType
      });
      return INVALID3;
    }
    let ctx = void 0;
    const status = new ParseStatus3();
    for (const check2 of this._def.checks) {
      if (check2.kind === "int") {
        if (!util3.isInteger(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.invalid_type,
            expected: "integer",
            received: "float",
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "min") {
        const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
        if (tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_small,
            minimum: check2.value,
            type: "number",
            inclusive: check2.inclusive,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
        if (tooBig) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_big,
            maximum: check2.value,
            type: "number",
            inclusive: check2.inclusive,
            exact: false,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "multipleOf") {
        if (floatSafeRemainder4(input.data, check2.value) !== 0) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.not_multiple_of,
            multipleOf: check2.value,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "finite") {
        if (!Number.isFinite(input.data)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.not_finite,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util3.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  gte(value, message) {
    return this.setLimit("min", value, true, errorUtil3.toString(message));
  }
  gt(value, message) {
    return this.setLimit("min", value, false, errorUtil3.toString(message));
  }
  lte(value, message) {
    return this.setLimit("max", value, true, errorUtil3.toString(message));
  }
  lt(value, message) {
    return this.setLimit("max", value, false, errorUtil3.toString(message));
  }
  setLimit(kind, value, inclusive, message) {
    return new _ZodNumber({
      ...this._def,
      checks: [
        ...this._def.checks,
        {
          kind,
          value,
          inclusive,
          message: errorUtil3.toString(message)
        }
      ]
    });
  }
  _addCheck(check2) {
    return new _ZodNumber({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  int(message) {
    return this._addCheck({
      kind: "int",
      message: errorUtil3.toString(message)
    });
  }
  positive(message) {
    return this._addCheck({
      kind: "min",
      value: 0,
      inclusive: false,
      message: errorUtil3.toString(message)
    });
  }
  negative(message) {
    return this._addCheck({
      kind: "max",
      value: 0,
      inclusive: false,
      message: errorUtil3.toString(message)
    });
  }
  nonpositive(message) {
    return this._addCheck({
      kind: "max",
      value: 0,
      inclusive: true,
      message: errorUtil3.toString(message)
    });
  }
  nonnegative(message) {
    return this._addCheck({
      kind: "min",
      value: 0,
      inclusive: true,
      message: errorUtil3.toString(message)
    });
  }
  multipleOf(value, message) {
    return this._addCheck({
      kind: "multipleOf",
      value,
      message: errorUtil3.toString(message)
    });
  }
  finite(message) {
    return this._addCheck({
      kind: "finite",
      message: errorUtil3.toString(message)
    });
  }
  safe(message) {
    return this._addCheck({
      kind: "min",
      inclusive: true,
      value: Number.MIN_SAFE_INTEGER,
      message: errorUtil3.toString(message)
    })._addCheck({
      kind: "max",
      inclusive: true,
      value: Number.MAX_SAFE_INTEGER,
      message: errorUtil3.toString(message)
    });
  }
  get minValue() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxValue() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
  get isInt() {
    return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util3.isInteger(ch.value));
  }
  get isFinite() {
    let max = null;
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
        return true;
      } else if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      } else if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return Number.isFinite(min) && Number.isFinite(max);
  }
};
ZodNumber4.create = (params) => {
  return new ZodNumber4({
    checks: [],
    typeName: ZodFirstPartyTypeKind3.ZodNumber,
    coerce: params?.coerce || false,
    ...processCreateParams3(params)
  });
};
var ZodBigInt3 = class _ZodBigInt extends ZodType4 {
  constructor() {
    super(...arguments);
    this.min = this.gte;
    this.max = this.lte;
  }
  _parse(input) {
    if (this._def.coerce) {
      try {
        input.data = BigInt(input.data);
      } catch {
        return this._getInvalidInput(input);
      }
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.bigint) {
      return this._getInvalidInput(input);
    }
    let ctx = void 0;
    const status = new ParseStatus3();
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
        if (tooSmall) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_small,
            type: "bigint",
            minimum: check2.value,
            inclusive: check2.inclusive,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
        if (tooBig) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_big,
            type: "bigint",
            maximum: check2.value,
            inclusive: check2.inclusive,
            message: check2.message
          });
          status.dirty();
        }
      } else if (check2.kind === "multipleOf") {
        if (input.data % check2.value !== BigInt(0)) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.not_multiple_of,
            multipleOf: check2.value,
            message: check2.message
          });
          status.dirty();
        }
      } else {
        util3.assertNever(check2);
      }
    }
    return { status: status.value, value: input.data };
  }
  _getInvalidInput(input) {
    const ctx = this._getOrReturnCtx(input);
    addIssueToContext3(ctx, {
      code: ZodIssueCode3.invalid_type,
      expected: ZodParsedType3.bigint,
      received: ctx.parsedType
    });
    return INVALID3;
  }
  gte(value, message) {
    return this.setLimit("min", value, true, errorUtil3.toString(message));
  }
  gt(value, message) {
    return this.setLimit("min", value, false, errorUtil3.toString(message));
  }
  lte(value, message) {
    return this.setLimit("max", value, true, errorUtil3.toString(message));
  }
  lt(value, message) {
    return this.setLimit("max", value, false, errorUtil3.toString(message));
  }
  setLimit(kind, value, inclusive, message) {
    return new _ZodBigInt({
      ...this._def,
      checks: [
        ...this._def.checks,
        {
          kind,
          value,
          inclusive,
          message: errorUtil3.toString(message)
        }
      ]
    });
  }
  _addCheck(check2) {
    return new _ZodBigInt({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  positive(message) {
    return this._addCheck({
      kind: "min",
      value: BigInt(0),
      inclusive: false,
      message: errorUtil3.toString(message)
    });
  }
  negative(message) {
    return this._addCheck({
      kind: "max",
      value: BigInt(0),
      inclusive: false,
      message: errorUtil3.toString(message)
    });
  }
  nonpositive(message) {
    return this._addCheck({
      kind: "max",
      value: BigInt(0),
      inclusive: true,
      message: errorUtil3.toString(message)
    });
  }
  nonnegative(message) {
    return this._addCheck({
      kind: "min",
      value: BigInt(0),
      inclusive: true,
      message: errorUtil3.toString(message)
    });
  }
  multipleOf(value, message) {
    return this._addCheck({
      kind: "multipleOf",
      value,
      message: errorUtil3.toString(message)
    });
  }
  get minValue() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min;
  }
  get maxValue() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max;
  }
};
ZodBigInt3.create = (params) => {
  return new ZodBigInt3({
    checks: [],
    typeName: ZodFirstPartyTypeKind3.ZodBigInt,
    coerce: params?.coerce ?? false,
    ...processCreateParams3(params)
  });
};
var ZodBoolean4 = class extends ZodType4 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = Boolean(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.boolean) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.boolean,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    return OK3(input.data);
  }
};
ZodBoolean4.create = (params) => {
  return new ZodBoolean4({
    typeName: ZodFirstPartyTypeKind3.ZodBoolean,
    coerce: params?.coerce || false,
    ...processCreateParams3(params)
  });
};
var ZodDate3 = class _ZodDate extends ZodType4 {
  _parse(input) {
    if (this._def.coerce) {
      input.data = new Date(input.data);
    }
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.date) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext3(ctx2, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.date,
        received: ctx2.parsedType
      });
      return INVALID3;
    }
    if (Number.isNaN(input.data.getTime())) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext3(ctx2, {
        code: ZodIssueCode3.invalid_date
      });
      return INVALID3;
    }
    const status = new ParseStatus3();
    let ctx = void 0;
    for (const check2 of this._def.checks) {
      if (check2.kind === "min") {
        if (input.data.getTime() < check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_small,
            message: check2.message,
            inclusive: true,
            exact: false,
            minimum: check2.value,
            type: "date"
          });
          status.dirty();
        }
      } else if (check2.kind === "max") {
        if (input.data.getTime() > check2.value) {
          ctx = this._getOrReturnCtx(input, ctx);
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.too_big,
            message: check2.message,
            inclusive: true,
            exact: false,
            maximum: check2.value,
            type: "date"
          });
          status.dirty();
        }
      } else {
        util3.assertNever(check2);
      }
    }
    return {
      status: status.value,
      value: new Date(input.data.getTime())
    };
  }
  _addCheck(check2) {
    return new _ZodDate({
      ...this._def,
      checks: [...this._def.checks, check2]
    });
  }
  min(minDate, message) {
    return this._addCheck({
      kind: "min",
      value: minDate.getTime(),
      message: errorUtil3.toString(message)
    });
  }
  max(maxDate, message) {
    return this._addCheck({
      kind: "max",
      value: maxDate.getTime(),
      message: errorUtil3.toString(message)
    });
  }
  get minDate() {
    let min = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "min") {
        if (min === null || ch.value > min)
          min = ch.value;
      }
    }
    return min != null ? new Date(min) : null;
  }
  get maxDate() {
    let max = null;
    for (const ch of this._def.checks) {
      if (ch.kind === "max") {
        if (max === null || ch.value < max)
          max = ch.value;
      }
    }
    return max != null ? new Date(max) : null;
  }
};
ZodDate3.create = (params) => {
  return new ZodDate3({
    checks: [],
    coerce: params?.coerce || false,
    typeName: ZodFirstPartyTypeKind3.ZodDate,
    ...processCreateParams3(params)
  });
};
var ZodSymbol3 = class extends ZodType4 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.symbol) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.symbol,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    return OK3(input.data);
  }
};
ZodSymbol3.create = (params) => {
  return new ZodSymbol3({
    typeName: ZodFirstPartyTypeKind3.ZodSymbol,
    ...processCreateParams3(params)
  });
};
var ZodUndefined3 = class extends ZodType4 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.undefined) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.undefined,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    return OK3(input.data);
  }
};
ZodUndefined3.create = (params) => {
  return new ZodUndefined3({
    typeName: ZodFirstPartyTypeKind3.ZodUndefined,
    ...processCreateParams3(params)
  });
};
var ZodNull4 = class extends ZodType4 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.null) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.null,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    return OK3(input.data);
  }
};
ZodNull4.create = (params) => {
  return new ZodNull4({
    typeName: ZodFirstPartyTypeKind3.ZodNull,
    ...processCreateParams3(params)
  });
};
var ZodAny3 = class extends ZodType4 {
  constructor() {
    super(...arguments);
    this._any = true;
  }
  _parse(input) {
    return OK3(input.data);
  }
};
ZodAny3.create = (params) => {
  return new ZodAny3({
    typeName: ZodFirstPartyTypeKind3.ZodAny,
    ...processCreateParams3(params)
  });
};
var ZodUnknown4 = class extends ZodType4 {
  constructor() {
    super(...arguments);
    this._unknown = true;
  }
  _parse(input) {
    return OK3(input.data);
  }
};
ZodUnknown4.create = (params) => {
  return new ZodUnknown4({
    typeName: ZodFirstPartyTypeKind3.ZodUnknown,
    ...processCreateParams3(params)
  });
};
var ZodNever4 = class extends ZodType4 {
  _parse(input) {
    const ctx = this._getOrReturnCtx(input);
    addIssueToContext3(ctx, {
      code: ZodIssueCode3.invalid_type,
      expected: ZodParsedType3.never,
      received: ctx.parsedType
    });
    return INVALID3;
  }
};
ZodNever4.create = (params) => {
  return new ZodNever4({
    typeName: ZodFirstPartyTypeKind3.ZodNever,
    ...processCreateParams3(params)
  });
};
var ZodVoid3 = class extends ZodType4 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.undefined) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.void,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    return OK3(input.data);
  }
};
ZodVoid3.create = (params) => {
  return new ZodVoid3({
    typeName: ZodFirstPartyTypeKind3.ZodVoid,
    ...processCreateParams3(params)
  });
};
var ZodArray4 = class _ZodArray extends ZodType4 {
  _parse(input) {
    const { ctx, status } = this._processInputParams(input);
    const def = this._def;
    if (ctx.parsedType !== ZodParsedType3.array) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.array,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    if (def.exactLength !== null) {
      const tooBig = ctx.data.length > def.exactLength.value;
      const tooSmall = ctx.data.length < def.exactLength.value;
      if (tooBig || tooSmall) {
        addIssueToContext3(ctx, {
          code: tooBig ? ZodIssueCode3.too_big : ZodIssueCode3.too_small,
          minimum: tooSmall ? def.exactLength.value : void 0,
          maximum: tooBig ? def.exactLength.value : void 0,
          type: "array",
          inclusive: true,
          exact: true,
          message: def.exactLength.message
        });
        status.dirty();
      }
    }
    if (def.minLength !== null) {
      if (ctx.data.length < def.minLength.value) {
        addIssueToContext3(ctx, {
          code: ZodIssueCode3.too_small,
          minimum: def.minLength.value,
          type: "array",
          inclusive: true,
          exact: false,
          message: def.minLength.message
        });
        status.dirty();
      }
    }
    if (def.maxLength !== null) {
      if (ctx.data.length > def.maxLength.value) {
        addIssueToContext3(ctx, {
          code: ZodIssueCode3.too_big,
          maximum: def.maxLength.value,
          type: "array",
          inclusive: true,
          exact: false,
          message: def.maxLength.message
        });
        status.dirty();
      }
    }
    if (ctx.common.async) {
      return Promise.all([...ctx.data].map((item, i) => {
        return def.type._parseAsync(new ParseInputLazyPath3(ctx, item, ctx.path, i));
      })).then((result2) => {
        return ParseStatus3.mergeArray(status, result2);
      });
    }
    const result = [...ctx.data].map((item, i) => {
      return def.type._parseSync(new ParseInputLazyPath3(ctx, item, ctx.path, i));
    });
    return ParseStatus3.mergeArray(status, result);
  }
  get element() {
    return this._def.type;
  }
  min(minLength, message) {
    return new _ZodArray({
      ...this._def,
      minLength: { value: minLength, message: errorUtil3.toString(message) }
    });
  }
  max(maxLength, message) {
    return new _ZodArray({
      ...this._def,
      maxLength: { value: maxLength, message: errorUtil3.toString(message) }
    });
  }
  length(len, message) {
    return new _ZodArray({
      ...this._def,
      exactLength: { value: len, message: errorUtil3.toString(message) }
    });
  }
  nonempty(message) {
    return this.min(1, message);
  }
};
ZodArray4.create = (schema, params) => {
  return new ZodArray4({
    type: schema,
    minLength: null,
    maxLength: null,
    exactLength: null,
    typeName: ZodFirstPartyTypeKind3.ZodArray,
    ...processCreateParams3(params)
  });
};
function deepPartialify3(schema) {
  if (schema instanceof ZodObject4) {
    const newShape = {};
    for (const key in schema.shape) {
      const fieldSchema = schema.shape[key];
      newShape[key] = ZodOptional4.create(deepPartialify3(fieldSchema));
    }
    return new ZodObject4({
      ...schema._def,
      shape: () => newShape
    });
  } else if (schema instanceof ZodArray4) {
    return new ZodArray4({
      ...schema._def,
      type: deepPartialify3(schema.element)
    });
  } else if (schema instanceof ZodOptional4) {
    return ZodOptional4.create(deepPartialify3(schema.unwrap()));
  } else if (schema instanceof ZodNullable4) {
    return ZodNullable4.create(deepPartialify3(schema.unwrap()));
  } else if (schema instanceof ZodTuple3) {
    return ZodTuple3.create(schema.items.map((item) => deepPartialify3(item)));
  } else {
    return schema;
  }
}
var ZodObject4 = class _ZodObject extends ZodType4 {
  constructor() {
    super(...arguments);
    this._cached = null;
    this.nonstrict = this.passthrough;
    this.augment = this.extend;
  }
  _getCached() {
    if (this._cached !== null)
      return this._cached;
    const shape = this._def.shape();
    const keys = util3.objectKeys(shape);
    this._cached = { shape, keys };
    return this._cached;
  }
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.object) {
      const ctx2 = this._getOrReturnCtx(input);
      addIssueToContext3(ctx2, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.object,
        received: ctx2.parsedType
      });
      return INVALID3;
    }
    const { status, ctx } = this._processInputParams(input);
    const { shape, keys: shapeKeys } = this._getCached();
    const extraKeys = [];
    if (!(this._def.catchall instanceof ZodNever4 && this._def.unknownKeys === "strip")) {
      for (const key in ctx.data) {
        if (!shapeKeys.includes(key)) {
          extraKeys.push(key);
        }
      }
    }
    const pairs = [];
    for (const key of shapeKeys) {
      const keyValidator = shape[key];
      const value = ctx.data[key];
      pairs.push({
        key: { status: "valid", value: key },
        value: keyValidator._parse(new ParseInputLazyPath3(ctx, value, ctx.path, key)),
        alwaysSet: key in ctx.data
      });
    }
    if (this._def.catchall instanceof ZodNever4) {
      const unknownKeys = this._def.unknownKeys;
      if (unknownKeys === "passthrough") {
        for (const key of extraKeys) {
          pairs.push({
            key: { status: "valid", value: key },
            value: { status: "valid", value: ctx.data[key] }
          });
        }
      } else if (unknownKeys === "strict") {
        if (extraKeys.length > 0) {
          addIssueToContext3(ctx, {
            code: ZodIssueCode3.unrecognized_keys,
            keys: extraKeys
          });
          status.dirty();
        }
      } else if (unknownKeys === "strip") {
      } else {
        throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
      }
    } else {
      const catchall = this._def.catchall;
      for (const key of extraKeys) {
        const value = ctx.data[key];
        pairs.push({
          key: { status: "valid", value: key },
          value: catchall._parse(
            new ParseInputLazyPath3(ctx, value, ctx.path, key)
            //, ctx.child(key), value, getParsedType(value)
          ),
          alwaysSet: key in ctx.data
        });
      }
    }
    if (ctx.common.async) {
      return Promise.resolve().then(async () => {
        const syncPairs = [];
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          syncPairs.push({
            key,
            value,
            alwaysSet: pair.alwaysSet
          });
        }
        return syncPairs;
      }).then((syncPairs) => {
        return ParseStatus3.mergeObjectSync(status, syncPairs);
      });
    } else {
      return ParseStatus3.mergeObjectSync(status, pairs);
    }
  }
  get shape() {
    return this._def.shape();
  }
  strict(message) {
    errorUtil3.errToObj;
    return new _ZodObject({
      ...this._def,
      unknownKeys: "strict",
      ...message !== void 0 ? {
        errorMap: (issue2, ctx) => {
          const defaultError = this._def.errorMap?.(issue2, ctx).message ?? ctx.defaultError;
          if (issue2.code === "unrecognized_keys")
            return {
              message: errorUtil3.errToObj(message).message ?? defaultError
            };
          return {
            message: defaultError
          };
        }
      } : {}
    });
  }
  strip() {
    return new _ZodObject({
      ...this._def,
      unknownKeys: "strip"
    });
  }
  passthrough() {
    return new _ZodObject({
      ...this._def,
      unknownKeys: "passthrough"
    });
  }
  // const AugmentFactory =
  //   <Def extends ZodObjectDef>(def: Def) =>
  //   <Augmentation extends ZodRawShape>(
  //     augmentation: Augmentation
  //   ): ZodObject<
  //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
  //     Def["unknownKeys"],
  //     Def["catchall"]
  //   > => {
  //     return new ZodObject({
  //       ...def,
  //       shape: () => ({
  //         ...def.shape(),
  //         ...augmentation,
  //       }),
  //     }) as any;
  //   };
  extend(augmentation) {
    return new _ZodObject({
      ...this._def,
      shape: () => ({
        ...this._def.shape(),
        ...augmentation
      })
    });
  }
  /**
   * Prior to zod@1.0.12 there was a bug in the
   * inferred type of merged objects. Please
   * upgrade if you are experiencing issues.
   */
  merge(merging) {
    const merged = new _ZodObject({
      unknownKeys: merging._def.unknownKeys,
      catchall: merging._def.catchall,
      shape: () => ({
        ...this._def.shape(),
        ...merging._def.shape()
      }),
      typeName: ZodFirstPartyTypeKind3.ZodObject
    });
    return merged;
  }
  // merge<
  //   Incoming extends AnyZodObject,
  //   Augmentation extends Incoming["shape"],
  //   NewOutput extends {
  //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
  //       ? Augmentation[k]["_output"]
  //       : k extends keyof Output
  //       ? Output[k]
  //       : never;
  //   },
  //   NewInput extends {
  //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
  //       ? Augmentation[k]["_input"]
  //       : k extends keyof Input
  //       ? Input[k]
  //       : never;
  //   }
  // >(
  //   merging: Incoming
  // ): ZodObject<
  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
  //   Incoming["_def"]["unknownKeys"],
  //   Incoming["_def"]["catchall"],
  //   NewOutput,
  //   NewInput
  // > {
  //   const merged: any = new ZodObject({
  //     unknownKeys: merging._def.unknownKeys,
  //     catchall: merging._def.catchall,
  //     shape: () =>
  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
  //     typeName: ZodFirstPartyTypeKind.ZodObject,
  //   }) as any;
  //   return merged;
  // }
  setKey(key, schema) {
    return this.augment({ [key]: schema });
  }
  // merge<Incoming extends AnyZodObject>(
  //   merging: Incoming
  // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
  // ZodObject<
  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
  //   Incoming["_def"]["unknownKeys"],
  //   Incoming["_def"]["catchall"]
  // > {
  //   // const mergedShape = objectUtil.mergeShapes(
  //   //   this._def.shape(),
  //   //   merging._def.shape()
  //   // );
  //   const merged: any = new ZodObject({
  //     unknownKeys: merging._def.unknownKeys,
  //     catchall: merging._def.catchall,
  //     shape: () =>
  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
  //     typeName: ZodFirstPartyTypeKind.ZodObject,
  //   }) as any;
  //   return merged;
  // }
  catchall(index) {
    return new _ZodObject({
      ...this._def,
      catchall: index
    });
  }
  pick(mask) {
    const shape = {};
    for (const key of util3.objectKeys(mask)) {
      if (mask[key] && this.shape[key]) {
        shape[key] = this.shape[key];
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => shape
    });
  }
  omit(mask) {
    const shape = {};
    for (const key of util3.objectKeys(this.shape)) {
      if (!mask[key]) {
        shape[key] = this.shape[key];
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => shape
    });
  }
  /**
   * @deprecated
   */
  deepPartial() {
    return deepPartialify3(this);
  }
  partial(mask) {
    const newShape = {};
    for (const key of util3.objectKeys(this.shape)) {
      const fieldSchema = this.shape[key];
      if (mask && !mask[key]) {
        newShape[key] = fieldSchema;
      } else {
        newShape[key] = fieldSchema.optional();
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => newShape
    });
  }
  required(mask) {
    const newShape = {};
    for (const key of util3.objectKeys(this.shape)) {
      if (mask && !mask[key]) {
        newShape[key] = this.shape[key];
      } else {
        const fieldSchema = this.shape[key];
        let newField = fieldSchema;
        while (newField instanceof ZodOptional4) {
          newField = newField._def.innerType;
        }
        newShape[key] = newField;
      }
    }
    return new _ZodObject({
      ...this._def,
      shape: () => newShape
    });
  }
  keyof() {
    return createZodEnum3(util3.objectKeys(this.shape));
  }
};
ZodObject4.create = (shape, params) => {
  return new ZodObject4({
    shape: () => shape,
    unknownKeys: "strip",
    catchall: ZodNever4.create(),
    typeName: ZodFirstPartyTypeKind3.ZodObject,
    ...processCreateParams3(params)
  });
};
ZodObject4.strictCreate = (shape, params) => {
  return new ZodObject4({
    shape: () => shape,
    unknownKeys: "strict",
    catchall: ZodNever4.create(),
    typeName: ZodFirstPartyTypeKind3.ZodObject,
    ...processCreateParams3(params)
  });
};
ZodObject4.lazycreate = (shape, params) => {
  return new ZodObject4({
    shape,
    unknownKeys: "strip",
    catchall: ZodNever4.create(),
    typeName: ZodFirstPartyTypeKind3.ZodObject,
    ...processCreateParams3(params)
  });
};
var ZodUnion4 = class extends ZodType4 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const options = this._def.options;
    function handleResults(results2) {
      for (const result of results2) {
        if (result.result.status === "valid") {
          return result.result;
        }
      }
      for (const result of results2) {
        if (result.result.status === "dirty") {
          ctx.common.issues.push(...result.ctx.common.issues);
          return result.result;
        }
      }
      const unionErrors = results2.map((result) => new ZodError4(result.ctx.common.issues));
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_union,
        unionErrors
      });
      return INVALID3;
    }
    if (ctx.common.async) {
      return Promise.all(options.map(async (option) => {
        const childCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          },
          parent: null
        };
        return {
          result: await option._parseAsync({
            data: ctx.data,
            path: ctx.path,
            parent: childCtx
          }),
          ctx: childCtx
        };
      })).then(handleResults);
    } else {
      let dirty = void 0;
      const issues = [];
      for (const option of options) {
        const childCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          },
          parent: null
        };
        const result = option._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: childCtx
        });
        if (result.status === "valid") {
          return result;
        } else if (result.status === "dirty" && !dirty) {
          dirty = { result, ctx: childCtx };
        }
        if (childCtx.common.issues.length) {
          issues.push(childCtx.common.issues);
        }
      }
      if (dirty) {
        ctx.common.issues.push(...dirty.ctx.common.issues);
        return dirty.result;
      }
      const unionErrors = issues.map((issues2) => new ZodError4(issues2));
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_union,
        unionErrors
      });
      return INVALID3;
    }
  }
  get options() {
    return this._def.options;
  }
};
ZodUnion4.create = (types, params) => {
  return new ZodUnion4({
    options: types,
    typeName: ZodFirstPartyTypeKind3.ZodUnion,
    ...processCreateParams3(params)
  });
};
var getDiscriminator3 = (type) => {
  if (type instanceof ZodLazy3) {
    return getDiscriminator3(type.schema);
  } else if (type instanceof ZodEffects3) {
    return getDiscriminator3(type.innerType());
  } else if (type instanceof ZodLiteral4) {
    return [type.value];
  } else if (type instanceof ZodEnum4) {
    return type.options;
  } else if (type instanceof ZodNativeEnum3) {
    return util3.objectValues(type.enum);
  } else if (type instanceof ZodDefault4) {
    return getDiscriminator3(type._def.innerType);
  } else if (type instanceof ZodUndefined3) {
    return [void 0];
  } else if (type instanceof ZodNull4) {
    return [null];
  } else if (type instanceof ZodOptional4) {
    return [void 0, ...getDiscriminator3(type.unwrap())];
  } else if (type instanceof ZodNullable4) {
    return [null, ...getDiscriminator3(type.unwrap())];
  } else if (type instanceof ZodBranded3) {
    return getDiscriminator3(type.unwrap());
  } else if (type instanceof ZodReadonly4) {
    return getDiscriminator3(type.unwrap());
  } else if (type instanceof ZodCatch4) {
    return getDiscriminator3(type._def.innerType);
  } else {
    return [];
  }
};
var ZodDiscriminatedUnion4 = class _ZodDiscriminatedUnion extends ZodType4 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType3.object) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.object,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    const discriminator = this.discriminator;
    const discriminatorValue = ctx.data[discriminator];
    const option = this.optionsMap.get(discriminatorValue);
    if (!option) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_union_discriminator,
        options: Array.from(this.optionsMap.keys()),
        path: [discriminator]
      });
      return INVALID3;
    }
    if (ctx.common.async) {
      return option._parseAsync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
    } else {
      return option._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
    }
  }
  get discriminator() {
    return this._def.discriminator;
  }
  get options() {
    return this._def.options;
  }
  get optionsMap() {
    return this._def.optionsMap;
  }
  /**
   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
   * have a different value for each object in the union.
   * @param discriminator the name of the discriminator property
   * @param types an array of object schemas
   * @param params
   */
  static create(discriminator, options, params) {
    const optionsMap = /* @__PURE__ */ new Map();
    for (const type of options) {
      const discriminatorValues = getDiscriminator3(type.shape[discriminator]);
      if (!discriminatorValues.length) {
        throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
      }
      for (const value of discriminatorValues) {
        if (optionsMap.has(value)) {
          throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
        }
        optionsMap.set(value, type);
      }
    }
    return new _ZodDiscriminatedUnion({
      typeName: ZodFirstPartyTypeKind3.ZodDiscriminatedUnion,
      discriminator,
      options,
      optionsMap,
      ...processCreateParams3(params)
    });
  }
};
function mergeValues4(a, b) {
  const aType = getParsedType4(a);
  const bType = getParsedType4(b);
  if (a === b) {
    return { valid: true, data: a };
  } else if (aType === ZodParsedType3.object && bType === ZodParsedType3.object) {
    const bKeys = util3.objectKeys(b);
    const sharedKeys = util3.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues4(a[key], b[key]);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  } else if (aType === ZodParsedType3.array && bType === ZodParsedType3.array) {
    if (a.length !== b.length) {
      return { valid: false };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues4(itemA, itemB);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  } else if (aType === ZodParsedType3.date && bType === ZodParsedType3.date && +a === +b) {
    return { valid: true, data: a };
  } else {
    return { valid: false };
  }
}
var ZodIntersection4 = class extends ZodType4 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    const handleParsed = (parsedLeft, parsedRight) => {
      if (isAborted3(parsedLeft) || isAborted3(parsedRight)) {
        return INVALID3;
      }
      const merged = mergeValues4(parsedLeft.value, parsedRight.value);
      if (!merged.valid) {
        addIssueToContext3(ctx, {
          code: ZodIssueCode3.invalid_intersection_types
        });
        return INVALID3;
      }
      if (isDirty3(parsedLeft) || isDirty3(parsedRight)) {
        status.dirty();
      }
      return { status: status.value, value: merged.data };
    };
    if (ctx.common.async) {
      return Promise.all([
        this._def.left._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        }),
        this._def.right._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        })
      ]).then(([left, right]) => handleParsed(left, right));
    } else {
      return handleParsed(this._def.left._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      }), this._def.right._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      }));
    }
  }
};
ZodIntersection4.create = (left, right, params) => {
  return new ZodIntersection4({
    left,
    right,
    typeName: ZodFirstPartyTypeKind3.ZodIntersection,
    ...processCreateParams3(params)
  });
};
var ZodTuple3 = class _ZodTuple extends ZodType4 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType3.array) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.array,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    if (ctx.data.length < this._def.items.length) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.too_small,
        minimum: this._def.items.length,
        inclusive: true,
        exact: false,
        type: "array"
      });
      return INVALID3;
    }
    const rest = this._def.rest;
    if (!rest && ctx.data.length > this._def.items.length) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.too_big,
        maximum: this._def.items.length,
        inclusive: true,
        exact: false,
        type: "array"
      });
      status.dirty();
    }
    const items = [...ctx.data].map((item, itemIndex) => {
      const schema = this._def.items[itemIndex] || this._def.rest;
      if (!schema)
        return null;
      return schema._parse(new ParseInputLazyPath3(ctx, item, ctx.path, itemIndex));
    }).filter((x) => !!x);
    if (ctx.common.async) {
      return Promise.all(items).then((results2) => {
        return ParseStatus3.mergeArray(status, results2);
      });
    } else {
      return ParseStatus3.mergeArray(status, items);
    }
  }
  get items() {
    return this._def.items;
  }
  rest(rest) {
    return new _ZodTuple({
      ...this._def,
      rest
    });
  }
};
ZodTuple3.create = (schemas, params) => {
  if (!Array.isArray(schemas)) {
    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
  }
  return new ZodTuple3({
    items: schemas,
    typeName: ZodFirstPartyTypeKind3.ZodTuple,
    rest: null,
    ...processCreateParams3(params)
  });
};
var ZodRecord4 = class _ZodRecord extends ZodType4 {
  get keySchema() {
    return this._def.keyType;
  }
  get valueSchema() {
    return this._def.valueType;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType3.object) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.object,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    const pairs = [];
    const keyType = this._def.keyType;
    const valueType = this._def.valueType;
    for (const key in ctx.data) {
      pairs.push({
        key: keyType._parse(new ParseInputLazyPath3(ctx, key, ctx.path, key)),
        value: valueType._parse(new ParseInputLazyPath3(ctx, ctx.data[key], ctx.path, key)),
        alwaysSet: key in ctx.data
      });
    }
    if (ctx.common.async) {
      return ParseStatus3.mergeObjectAsync(status, pairs);
    } else {
      return ParseStatus3.mergeObjectSync(status, pairs);
    }
  }
  get element() {
    return this._def.valueType;
  }
  static create(first, second, third) {
    if (second instanceof ZodType4) {
      return new _ZodRecord({
        keyType: first,
        valueType: second,
        typeName: ZodFirstPartyTypeKind3.ZodRecord,
        ...processCreateParams3(third)
      });
    }
    return new _ZodRecord({
      keyType: ZodString4.create(),
      valueType: first,
      typeName: ZodFirstPartyTypeKind3.ZodRecord,
      ...processCreateParams3(second)
    });
  }
};
var ZodMap3 = class extends ZodType4 {
  get keySchema() {
    return this._def.keyType;
  }
  get valueSchema() {
    return this._def.valueType;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType3.map) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.map,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    const keyType = this._def.keyType;
    const valueType = this._def.valueType;
    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
      return {
        key: keyType._parse(new ParseInputLazyPath3(ctx, key, ctx.path, [index, "key"])),
        value: valueType._parse(new ParseInputLazyPath3(ctx, value, ctx.path, [index, "value"]))
      };
    });
    if (ctx.common.async) {
      const finalMap = /* @__PURE__ */ new Map();
      return Promise.resolve().then(async () => {
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          if (key.status === "aborted" || value.status === "aborted") {
            return INVALID3;
          }
          if (key.status === "dirty" || value.status === "dirty") {
            status.dirty();
          }
          finalMap.set(key.value, value.value);
        }
        return { status: status.value, value: finalMap };
      });
    } else {
      const finalMap = /* @__PURE__ */ new Map();
      for (const pair of pairs) {
        const key = pair.key;
        const value = pair.value;
        if (key.status === "aborted" || value.status === "aborted") {
          return INVALID3;
        }
        if (key.status === "dirty" || value.status === "dirty") {
          status.dirty();
        }
        finalMap.set(key.value, value.value);
      }
      return { status: status.value, value: finalMap };
    }
  }
};
ZodMap3.create = (keyType, valueType, params) => {
  return new ZodMap3({
    valueType,
    keyType,
    typeName: ZodFirstPartyTypeKind3.ZodMap,
    ...processCreateParams3(params)
  });
};
var ZodSet3 = class _ZodSet extends ZodType4 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType3.set) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.set,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    const def = this._def;
    if (def.minSize !== null) {
      if (ctx.data.size < def.minSize.value) {
        addIssueToContext3(ctx, {
          code: ZodIssueCode3.too_small,
          minimum: def.minSize.value,
          type: "set",
          inclusive: true,
          exact: false,
          message: def.minSize.message
        });
        status.dirty();
      }
    }
    if (def.maxSize !== null) {
      if (ctx.data.size > def.maxSize.value) {
        addIssueToContext3(ctx, {
          code: ZodIssueCode3.too_big,
          maximum: def.maxSize.value,
          type: "set",
          inclusive: true,
          exact: false,
          message: def.maxSize.message
        });
        status.dirty();
      }
    }
    const valueType = this._def.valueType;
    function finalizeSet(elements2) {
      const parsedSet = /* @__PURE__ */ new Set();
      for (const element of elements2) {
        if (element.status === "aborted")
          return INVALID3;
        if (element.status === "dirty")
          status.dirty();
        parsedSet.add(element.value);
      }
      return { status: status.value, value: parsedSet };
    }
    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath3(ctx, item, ctx.path, i)));
    if (ctx.common.async) {
      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
    } else {
      return finalizeSet(elements);
    }
  }
  min(minSize, message) {
    return new _ZodSet({
      ...this._def,
      minSize: { value: minSize, message: errorUtil3.toString(message) }
    });
  }
  max(maxSize, message) {
    return new _ZodSet({
      ...this._def,
      maxSize: { value: maxSize, message: errorUtil3.toString(message) }
    });
  }
  size(size, message) {
    return this.min(size, message).max(size, message);
  }
  nonempty(message) {
    return this.min(1, message);
  }
};
ZodSet3.create = (valueType, params) => {
  return new ZodSet3({
    valueType,
    minSize: null,
    maxSize: null,
    typeName: ZodFirstPartyTypeKind3.ZodSet,
    ...processCreateParams3(params)
  });
};
var ZodFunction3 = class _ZodFunction extends ZodType4 {
  constructor() {
    super(...arguments);
    this.validate = this.implement;
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType3.function) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.function,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    function makeArgsIssue(args, error3) {
      return makeIssue3({
        data: args,
        path: ctx.path,
        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap3(), en_default3].filter((x) => !!x),
        issueData: {
          code: ZodIssueCode3.invalid_arguments,
          argumentsError: error3
        }
      });
    }
    function makeReturnsIssue(returns, error3) {
      return makeIssue3({
        data: returns,
        path: ctx.path,
        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap3(), en_default3].filter((x) => !!x),
        issueData: {
          code: ZodIssueCode3.invalid_return_type,
          returnTypeError: error3
        }
      });
    }
    const params = { errorMap: ctx.common.contextualErrorMap };
    const fn = ctx.data;
    if (this._def.returns instanceof ZodPromise3) {
      const me = this;
      return OK3(async function(...args) {
        const error3 = new ZodError4([]);
        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
          error3.addIssue(makeArgsIssue(args, e));
          throw error3;
        });
        const result = await Reflect.apply(fn, this, parsedArgs);
        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
          error3.addIssue(makeReturnsIssue(result, e));
          throw error3;
        });
        return parsedReturns;
      });
    } else {
      const me = this;
      return OK3(function(...args) {
        const parsedArgs = me._def.args.safeParse(args, params);
        if (!parsedArgs.success) {
          throw new ZodError4([makeArgsIssue(args, parsedArgs.error)]);
        }
        const result = Reflect.apply(fn, this, parsedArgs.data);
        const parsedReturns = me._def.returns.safeParse(result, params);
        if (!parsedReturns.success) {
          throw new ZodError4([makeReturnsIssue(result, parsedReturns.error)]);
        }
        return parsedReturns.data;
      });
    }
  }
  parameters() {
    return this._def.args;
  }
  returnType() {
    return this._def.returns;
  }
  args(...items) {
    return new _ZodFunction({
      ...this._def,
      args: ZodTuple3.create(items).rest(ZodUnknown4.create())
    });
  }
  returns(returnType) {
    return new _ZodFunction({
      ...this._def,
      returns: returnType
    });
  }
  implement(func) {
    const validatedFunc = this.parse(func);
    return validatedFunc;
  }
  strictImplement(func) {
    const validatedFunc = this.parse(func);
    return validatedFunc;
  }
  static create(args, returns, params) {
    return new _ZodFunction({
      args: args ? args : ZodTuple3.create([]).rest(ZodUnknown4.create()),
      returns: returns || ZodUnknown4.create(),
      typeName: ZodFirstPartyTypeKind3.ZodFunction,
      ...processCreateParams3(params)
    });
  }
};
var ZodLazy3 = class extends ZodType4 {
  get schema() {
    return this._def.getter();
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const lazySchema = this._def.getter();
    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
  }
};
ZodLazy3.create = (getter, params) => {
  return new ZodLazy3({
    getter,
    typeName: ZodFirstPartyTypeKind3.ZodLazy,
    ...processCreateParams3(params)
  });
};
var ZodLiteral4 = class extends ZodType4 {
  _parse(input) {
    if (input.data !== this._def.value) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext3(ctx, {
        received: ctx.data,
        code: ZodIssueCode3.invalid_literal,
        expected: this._def.value
      });
      return INVALID3;
    }
    return { status: "valid", value: input.data };
  }
  get value() {
    return this._def.value;
  }
};
ZodLiteral4.create = (value, params) => {
  return new ZodLiteral4({
    value,
    typeName: ZodFirstPartyTypeKind3.ZodLiteral,
    ...processCreateParams3(params)
  });
};
function createZodEnum3(values, params) {
  return new ZodEnum4({
    values,
    typeName: ZodFirstPartyTypeKind3.ZodEnum,
    ...processCreateParams3(params)
  });
}
var ZodEnum4 = class _ZodEnum extends ZodType4 {
  _parse(input) {
    if (typeof input.data !== "string") {
      const ctx = this._getOrReturnCtx(input);
      const expectedValues = this._def.values;
      addIssueToContext3(ctx, {
        expected: util3.joinValues(expectedValues),
        received: ctx.parsedType,
        code: ZodIssueCode3.invalid_type
      });
      return INVALID3;
    }
    if (!this._cache) {
      this._cache = new Set(this._def.values);
    }
    if (!this._cache.has(input.data)) {
      const ctx = this._getOrReturnCtx(input);
      const expectedValues = this._def.values;
      addIssueToContext3(ctx, {
        received: ctx.data,
        code: ZodIssueCode3.invalid_enum_value,
        options: expectedValues
      });
      return INVALID3;
    }
    return OK3(input.data);
  }
  get options() {
    return this._def.values;
  }
  get enum() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  get Values() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  get Enum() {
    const enumValues = {};
    for (const val of this._def.values) {
      enumValues[val] = val;
    }
    return enumValues;
  }
  extract(values, newDef = this._def) {
    return _ZodEnum.create(values, {
      ...this._def,
      ...newDef
    });
  }
  exclude(values, newDef = this._def) {
    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
      ...this._def,
      ...newDef
    });
  }
};
ZodEnum4.create = createZodEnum3;
var ZodNativeEnum3 = class extends ZodType4 {
  _parse(input) {
    const nativeEnumValues = util3.getValidEnumValues(this._def.values);
    const ctx = this._getOrReturnCtx(input);
    if (ctx.parsedType !== ZodParsedType3.string && ctx.parsedType !== ZodParsedType3.number) {
      const expectedValues = util3.objectValues(nativeEnumValues);
      addIssueToContext3(ctx, {
        expected: util3.joinValues(expectedValues),
        received: ctx.parsedType,
        code: ZodIssueCode3.invalid_type
      });
      return INVALID3;
    }
    if (!this._cache) {
      this._cache = new Set(util3.getValidEnumValues(this._def.values));
    }
    if (!this._cache.has(input.data)) {
      const expectedValues = util3.objectValues(nativeEnumValues);
      addIssueToContext3(ctx, {
        received: ctx.data,
        code: ZodIssueCode3.invalid_enum_value,
        options: expectedValues
      });
      return INVALID3;
    }
    return OK3(input.data);
  }
  get enum() {
    return this._def.values;
  }
};
ZodNativeEnum3.create = (values, params) => {
  return new ZodNativeEnum3({
    values,
    typeName: ZodFirstPartyTypeKind3.ZodNativeEnum,
    ...processCreateParams3(params)
  });
};
var ZodPromise3 = class extends ZodType4 {
  unwrap() {
    return this._def.type;
  }
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    if (ctx.parsedType !== ZodParsedType3.promise && ctx.common.async === false) {
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.promise,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    const promisified = ctx.parsedType === ZodParsedType3.promise ? ctx.data : Promise.resolve(ctx.data);
    return OK3(promisified.then((data) => {
      return this._def.type.parseAsync(data, {
        path: ctx.path,
        errorMap: ctx.common.contextualErrorMap
      });
    }));
  }
};
ZodPromise3.create = (schema, params) => {
  return new ZodPromise3({
    type: schema,
    typeName: ZodFirstPartyTypeKind3.ZodPromise,
    ...processCreateParams3(params)
  });
};
var ZodEffects3 = class extends ZodType4 {
  innerType() {
    return this._def.schema;
  }
  sourceType() {
    return this._def.schema._def.typeName === ZodFirstPartyTypeKind3.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
  }
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    const effect = this._def.effect || null;
    const checkCtx = {
      addIssue: (arg) => {
        addIssueToContext3(ctx, arg);
        if (arg.fatal) {
          status.abort();
        } else {
          status.dirty();
        }
      },
      get path() {
        return ctx.path;
      }
    };
    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
    if (effect.type === "preprocess") {
      const processed = effect.transform(ctx.data, checkCtx);
      if (ctx.common.async) {
        return Promise.resolve(processed).then(async (processed2) => {
          if (status.value === "aborted")
            return INVALID3;
          const result = await this._def.schema._parseAsync({
            data: processed2,
            path: ctx.path,
            parent: ctx
          });
          if (result.status === "aborted")
            return INVALID3;
          if (result.status === "dirty")
            return DIRTY3(result.value);
          if (status.value === "dirty")
            return DIRTY3(result.value);
          return result;
        });
      } else {
        if (status.value === "aborted")
          return INVALID3;
        const result = this._def.schema._parseSync({
          data: processed,
          path: ctx.path,
          parent: ctx
        });
        if (result.status === "aborted")
          return INVALID3;
        if (result.status === "dirty")
          return DIRTY3(result.value);
        if (status.value === "dirty")
          return DIRTY3(result.value);
        return result;
      }
    }
    if (effect.type === "refinement") {
      const executeRefinement = (acc) => {
        const result = effect.refinement(acc, checkCtx);
        if (ctx.common.async) {
          return Promise.resolve(result);
        }
        if (result instanceof Promise) {
          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
        }
        return acc;
      };
      if (ctx.common.async === false) {
        const inner = this._def.schema._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (inner.status === "aborted")
          return INVALID3;
        if (inner.status === "dirty")
          status.dirty();
        executeRefinement(inner.value);
        return { status: status.value, value: inner.value };
      } else {
        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
          if (inner.status === "aborted")
            return INVALID3;
          if (inner.status === "dirty")
            status.dirty();
          return executeRefinement(inner.value).then(() => {
            return { status: status.value, value: inner.value };
          });
        });
      }
    }
    if (effect.type === "transform") {
      if (ctx.common.async === false) {
        const base = this._def.schema._parseSync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (!isValid3(base))
          return INVALID3;
        const result = effect.transform(base.value, checkCtx);
        if (result instanceof Promise) {
          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
        }
        return { status: status.value, value: result };
      } else {
        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
          if (!isValid3(base))
            return INVALID3;
          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
            status: status.value,
            value: result
          }));
        });
      }
    }
    util3.assertNever(effect);
  }
};
ZodEffects3.create = (schema, effect, params) => {
  return new ZodEffects3({
    schema,
    typeName: ZodFirstPartyTypeKind3.ZodEffects,
    effect,
    ...processCreateParams3(params)
  });
};
ZodEffects3.createWithPreprocess = (preprocess2, schema, params) => {
  return new ZodEffects3({
    schema,
    effect: { type: "preprocess", transform: preprocess2 },
    typeName: ZodFirstPartyTypeKind3.ZodEffects,
    ...processCreateParams3(params)
  });
};
var ZodOptional4 = class extends ZodType4 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 === ZodParsedType3.undefined) {
      return OK3(void 0);
    }
    return this._def.innerType._parse(input);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodOptional4.create = (type, params) => {
  return new ZodOptional4({
    innerType: type,
    typeName: ZodFirstPartyTypeKind3.ZodOptional,
    ...processCreateParams3(params)
  });
};
var ZodNullable4 = class extends ZodType4 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 === ZodParsedType3.null) {
      return OK3(null);
    }
    return this._def.innerType._parse(input);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodNullable4.create = (type, params) => {
  return new ZodNullable4({
    innerType: type,
    typeName: ZodFirstPartyTypeKind3.ZodNullable,
    ...processCreateParams3(params)
  });
};
var ZodDefault4 = class extends ZodType4 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    let data = ctx.data;
    if (ctx.parsedType === ZodParsedType3.undefined) {
      data = this._def.defaultValue();
    }
    return this._def.innerType._parse({
      data,
      path: ctx.path,
      parent: ctx
    });
  }
  removeDefault() {
    return this._def.innerType;
  }
};
ZodDefault4.create = (type, params) => {
  return new ZodDefault4({
    innerType: type,
    typeName: ZodFirstPartyTypeKind3.ZodDefault,
    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
    ...processCreateParams3(params)
  });
};
var ZodCatch4 = class extends ZodType4 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const newCtx = {
      ...ctx,
      common: {
        ...ctx.common,
        issues: []
      }
    };
    const result = this._def.innerType._parse({
      data: newCtx.data,
      path: newCtx.path,
      parent: {
        ...newCtx
      }
    });
    if (isAsync3(result)) {
      return result.then((result2) => {
        return {
          status: "valid",
          value: result2.status === "valid" ? result2.value : this._def.catchValue({
            get error() {
              return new ZodError4(newCtx.common.issues);
            },
            input: newCtx.data
          })
        };
      });
    } else {
      return {
        status: "valid",
        value: result.status === "valid" ? result.value : this._def.catchValue({
          get error() {
            return new ZodError4(newCtx.common.issues);
          },
          input: newCtx.data
        })
      };
    }
  }
  removeCatch() {
    return this._def.innerType;
  }
};
ZodCatch4.create = (type, params) => {
  return new ZodCatch4({
    innerType: type,
    typeName: ZodFirstPartyTypeKind3.ZodCatch,
    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
    ...processCreateParams3(params)
  });
};
var ZodNaN3 = class extends ZodType4 {
  _parse(input) {
    const parsedType2 = this._getType(input);
    if (parsedType2 !== ZodParsedType3.nan) {
      const ctx = this._getOrReturnCtx(input);
      addIssueToContext3(ctx, {
        code: ZodIssueCode3.invalid_type,
        expected: ZodParsedType3.nan,
        received: ctx.parsedType
      });
      return INVALID3;
    }
    return { status: "valid", value: input.data };
  }
};
ZodNaN3.create = (params) => {
  return new ZodNaN3({
    typeName: ZodFirstPartyTypeKind3.ZodNaN,
    ...processCreateParams3(params)
  });
};
var BRAND3 = Symbol("zod_brand");
var ZodBranded3 = class extends ZodType4 {
  _parse(input) {
    const { ctx } = this._processInputParams(input);
    const data = ctx.data;
    return this._def.type._parse({
      data,
      path: ctx.path,
      parent: ctx
    });
  }
  unwrap() {
    return this._def.type;
  }
};
var ZodPipeline3 = class _ZodPipeline extends ZodType4 {
  _parse(input) {
    const { status, ctx } = this._processInputParams(input);
    if (ctx.common.async) {
      const handleAsync = async () => {
        const inResult = await this._def.in._parseAsync({
          data: ctx.data,
          path: ctx.path,
          parent: ctx
        });
        if (inResult.status === "aborted")
          return INVALID3;
        if (inResult.status === "dirty") {
          status.dirty();
          return DIRTY3(inResult.value);
        } else {
          return this._def.out._parseAsync({
            data: inResult.value,
            path: ctx.path,
            parent: ctx
          });
        }
      };
      return handleAsync();
    } else {
      const inResult = this._def.in._parseSync({
        data: ctx.data,
        path: ctx.path,
        parent: ctx
      });
      if (inResult.status === "aborted")
        return INVALID3;
      if (inResult.status === "dirty") {
        status.dirty();
        return {
          status: "dirty",
          value: inResult.value
        };
      } else {
        return this._def.out._parseSync({
          data: inResult.value,
          path: ctx.path,
          parent: ctx
        });
      }
    }
  }
  static create(a, b) {
    return new _ZodPipeline({
      in: a,
      out: b,
      typeName: ZodFirstPartyTypeKind3.ZodPipeline
    });
  }
};
var ZodReadonly4 = class extends ZodType4 {
  _parse(input) {
    const result = this._def.innerType._parse(input);
    const freeze = (data) => {
      if (isValid3(data)) {
        data.value = Object.freeze(data.value);
      }
      return data;
    };
    return isAsync3(result) ? result.then((data) => freeze(data)) : freeze(result);
  }
  unwrap() {
    return this._def.innerType;
  }
};
ZodReadonly4.create = (type, params) => {
  return new ZodReadonly4({
    innerType: type,
    typeName: ZodFirstPartyTypeKind3.ZodReadonly,
    ...processCreateParams3(params)
  });
};
function cleanParams(params, data) {
  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
  const p2 = typeof p === "string" ? { message: p } : p;
  return p2;
}
function custom3(check2, _params = {}, fatal) {
  if (check2)
    return ZodAny3.create().superRefine((data, ctx) => {
      const r = check2(data);
      if (r instanceof Promise) {
        return r.then((r2) => {
          if (!r2) {
            const params = cleanParams(_params, data);
            const _fatal = params.fatal ?? fatal ?? true;
            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
          }
        });
      }
      if (!r) {
        const params = cleanParams(_params, data);
        const _fatal = params.fatal ?? fatal ?? true;
        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
      }
      return;
    });
  return ZodAny3.create();
}
var late3 = {
  object: ZodObject4.lazycreate
};
var ZodFirstPartyTypeKind3;
(function(ZodFirstPartyTypeKind4) {
  ZodFirstPartyTypeKind4["ZodString"] = "ZodString";
  ZodFirstPartyTypeKind4["ZodNumber"] = "ZodNumber";
  ZodFirstPartyTypeKind4["ZodNaN"] = "ZodNaN";
  ZodFirstPartyTypeKind4["ZodBigInt"] = "ZodBigInt";
  ZodFirstPartyTypeKind4["ZodBoolean"] = "ZodBoolean";
  ZodFirstPartyTypeKind4["ZodDate"] = "ZodDate";
  ZodFirstPartyTypeKind4["ZodSymbol"] = "ZodSymbol";
  ZodFirstPartyTypeKind4["ZodUndefined"] = "ZodUndefined";
  ZodFirstPartyTypeKind4["ZodNull"] = "ZodNull";
  ZodFirstPartyTypeKind4["ZodAny"] = "ZodAny";
  ZodFirstPartyTypeKind4["ZodUnknown"] = "ZodUnknown";
  ZodFirstPartyTypeKind4["ZodNever"] = "ZodNever";
  ZodFirstPartyTypeKind4["ZodVoid"] = "ZodVoid";
  ZodFirstPartyTypeKind4["ZodArray"] = "ZodArray";
  ZodFirstPartyTypeKind4["ZodObject"] = "ZodObject";
  ZodFirstPartyTypeKind4["ZodUnion"] = "ZodUnion";
  ZodFirstPartyTypeKind4["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
  ZodFirstPartyTypeKind4["ZodIntersection"] = "ZodIntersection";
  ZodFirstPartyTypeKind4["ZodTuple"] = "ZodTuple";
  ZodFirstPartyTypeKind4["ZodRecord"] = "ZodRecord";
  ZodFirstPartyTypeKind4["ZodMap"] = "ZodMap";
  ZodFirstPartyTypeKind4["ZodSet"] = "ZodSet";
  ZodFirstPartyTypeKind4["ZodFunction"] = "ZodFunction";
  ZodFirstPartyTypeKind4["ZodLazy"] = "ZodLazy";
  ZodFirstPartyTypeKind4["ZodLiteral"] = "ZodLiteral";
  ZodFirstPartyTypeKind4["ZodEnum"] = "ZodEnum";
  ZodFirstPartyTypeKind4["ZodEffects"] = "ZodEffects";
  ZodFirstPartyTypeKind4["ZodNativeEnum"] = "ZodNativeEnum";
  ZodFirstPartyTypeKind4["ZodOptional"] = "ZodOptional";
  ZodFirstPartyTypeKind4["ZodNullable"] = "ZodNullable";
  ZodFirstPartyTypeKind4["ZodDefault"] = "ZodDefault";
  ZodFirstPartyTypeKind4["ZodCatch"] = "ZodCatch";
  ZodFirstPartyTypeKind4["ZodPromise"] = "ZodPromise";
  ZodFirstPartyTypeKind4["ZodBranded"] = "ZodBranded";
  ZodFirstPartyTypeKind4["ZodPipeline"] = "ZodPipeline";
  ZodFirstPartyTypeKind4["ZodReadonly"] = "ZodReadonly";
})(ZodFirstPartyTypeKind3 || (ZodFirstPartyTypeKind3 = {}));
var instanceOfType2 = (cls, params = {
  message: `Input not instance of ${cls.name}`
}) => custom3((data) => data instanceof cls, params);
var stringType3 = ZodString4.create;
var numberType3 = ZodNumber4.create;
var nanType3 = ZodNaN3.create;
var bigIntType3 = ZodBigInt3.create;
var booleanType3 = ZodBoolean4.create;
var dateType3 = ZodDate3.create;
var symbolType3 = ZodSymbol3.create;
var undefinedType3 = ZodUndefined3.create;
var nullType3 = ZodNull4.create;
var anyType3 = ZodAny3.create;
var unknownType3 = ZodUnknown4.create;
var neverType3 = ZodNever4.create;
var voidType3 = ZodVoid3.create;
var arrayType3 = ZodArray4.create;
var objectType3 = ZodObject4.create;
var strictObjectType3 = ZodObject4.strictCreate;
var unionType3 = ZodUnion4.create;
var discriminatedUnionType3 = ZodDiscriminatedUnion4.create;
var intersectionType3 = ZodIntersection4.create;
var tupleType3 = ZodTuple3.create;
var recordType3 = ZodRecord4.create;
var mapType3 = ZodMap3.create;
var setType3 = ZodSet3.create;
var functionType3 = ZodFunction3.create;
var lazyType3 = ZodLazy3.create;
var literalType3 = ZodLiteral4.create;
var enumType3 = ZodEnum4.create;
var nativeEnumType3 = ZodNativeEnum3.create;
var promiseType3 = ZodPromise3.create;
var effectsType3 = ZodEffects3.create;
var optionalType3 = ZodOptional4.create;
var nullableType3 = ZodNullable4.create;
var preprocessType3 = ZodEffects3.createWithPreprocess;
var pipelineType3 = ZodPipeline3.create;
var ostring2 = () => stringType3().optional();
var onumber2 = () => numberType3().optional();
var oboolean2 = () => booleanType3().optional();
var coerce2 = {
  string: ((arg) => ZodString4.create({ ...arg, coerce: true })),
  number: ((arg) => ZodNumber4.create({ ...arg, coerce: true })),
  boolean: ((arg) => ZodBoolean4.create({
    ...arg,
    coerce: true
  })),
  bigint: ((arg) => ZodBigInt3.create({ ...arg, coerce: true })),
  date: ((arg) => ZodDate3.create({ ...arg, coerce: true }))
};
var NEVER3 = INVALID3;

// sceneboard-mcp/src/pairing/pairing-http.client.ts
var GlobalIdSchema = external_exports.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
var TimestampSchema = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/).refine((value) => new Date(value).toISOString() === value);
var ScopeSchema = external_exports.enum(CLIENT_GRANT_SCOPE_ORDER_V1);
var LifecycleSchema = external_exports.enum(["board.create", "board.archive"]);
var ClientSchema = external_exports.object({
  clientId: GlobalIdSchema,
  clientName: external_exports.string().min(1).max(100),
  installationFingerprint: external_exports.string().regex(/^[A-Za-z0-9_-]{16}$/)
}).strict();
var ClaimResponseSchema = external_exports.object({
  pairingId: GlobalIdSchema,
  state: external_exports.literal("pending"),
  decisionExpiresAt: TimestampSchema,
  pollAfterSeconds: external_exports.literal(2)
}).strict();
var StatusResponseSchema = external_exports.object({
  pairingId: GlobalIdSchema,
  state: external_exports.enum(["pending", "approved", "redeemed", "denied", "cancelled", "expired"]),
  retryAfterSeconds: external_exports.union([external_exports.literal(2), external_exports.literal(5), external_exports.literal(10)]).nullable(),
  decisionExpiresAt: TimestampSchema.nullable(),
  redeemExpiresAt: TimestampSchema.nullable()
}).strict().superRefine((value, context) => {
  if (value.decisionExpiresAt === null)
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["decisionExpiresAt"],
      message: "decision deadline is required"
    });
  if (value.state === "pending" && (value.retryAfterSeconds === null || value.redeemExpiresAt !== null)) {
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["state"],
      message: "pending status is inconsistent"
    });
  }
  if (value.state !== "pending" && value.retryAfterSeconds !== null) {
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["retryAfterSeconds"],
      message: "terminal delay is not allowed"
    });
  }
  if ((value.state === "approved" || value.state === "redeemed") && value.redeemExpiresAt === null) {
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["redeemExpiresAt"],
      message: "redeem deadline is required"
    });
  }
  if (value.state === "denied" && value.redeemExpiresAt !== null) {
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["redeemExpiresAt"],
      message: "denied status has no redeem deadline"
    });
  }
});
var GrantSchema = external_exports.object({
  grantId: GlobalIdSchema,
  client: ClientSchema,
  scopes: external_exports.array(ScopeSchema).min(1).max(8),
  lifecyclePermissions: external_exports.array(LifecycleSchema).max(2),
  boardIds: external_exports.array(GlobalIdSchema).max(50),
  lifetime: external_exports.enum(["session", "persistent"]),
  status: external_exports.literal("active"),
  createdAt: TimestampSchema,
  activatedAt: TimestampSchema,
  lastUsedAt: TimestampSchema.nullable(),
  expiresAt: TimestampSchema,
  revokedAt: external_exports.null()
}).strict().superRefine((value, context) => {
  if (value.boardIds.length === 0 && (!value.scopes.includes("board.write") || !value.lifecyclePermissions.includes("board.create"))) {
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["boardIds"],
      message: "an empty board set requires board.write and board.create"
    });
  }
});
var RedeemResponseSchema = external_exports.object({
  tokenType: external_exports.literal("Bearer"),
  accessToken: external_exports.string().regex(/^lcbg_v1\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}$/),
  grant: GrantSchema
}).strict();
var ErrorSchema = external_exports.object({
  error: external_exports.object({
    code: external_exports.enum([
      "INVALID_PAYLOAD",
      "PAIRING_UNAVAILABLE",
      "PAIRING_PROOF_INVALID",
      "PAIRING_NOT_READY",
      "PAIRING_TERMINAL",
      "RATE_LIMITED",
      "SERVICE_UNAVAILABLE"
    ]),
    message: external_exports.string().min(1).max(200).refine((value) => !/[\u0000-\u001f\u007f-\u009f]/u.test(value))
  }).strict()
}).strict();
var expectedStatus = {
  claim: 202,
  status: 200,
  redeem: 200
};
var allowedErrorStatus = {
  INVALID_PAYLOAD: 400,
  PAIRING_UNAVAILABLE: 400,
  PAIRING_PROOF_INVALID: 401,
  PAIRING_NOT_READY: 409,
  PAIRING_TERMINAL: 410,
  RATE_LIMITED: 429,
  SERVICE_UNAVAILABLE: 503
};
var parseRetryAfter = (response) => {
  const value = response.headers.get("retry-after");
  if (value === null) return null;
  if (!/^(?:[1-9]|[1-9][0-9]|1[01][0-9]|120)$/.test(value)) return "invalid";
  return Number(value);
};
var validSecurityHeaders = (response, route) => {
  if (response.headers.get("cache-control") !== "no-store, private" || response.headers.get("pragma") !== "no-cache")
    return false;
  const vary = response.headers.get("vary");
  return route === "claim" ? vary === null : vary === "Authorization";
};
var PairingHttpClientV1 = class {
  #baseUrl;
  #fetch;
  #timeoutMs;
  #proofHeaderProvider;
  constructor(options) {
    const url = new URL(options.baseUrl);
    if (url.origin !== options.baseUrl)
      throw new TypeError("pairing base URL must be a canonical origin");
    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1e3 || options.timeoutMs > 12e4) {
      throw new TypeError("pairing timeout is invalid");
    }
    this.#baseUrl = options.baseUrl;
    this.#fetch = options.fetch;
    this.#timeoutMs = options.timeoutMs;
    this.#proofHeaderProvider = options.proofHeaderProvider;
  }
  claim(request, signal) {
    return this.#call(
      "claim",
      "/api/v1/pairings/claim",
      "POST",
      request,
      ClaimResponseSchema,
      signal
    );
  }
  clientStatus(pairingId, signal) {
    return this.#call(
      "status",
      `/api/v1/pairings/${encodeURIComponent(pairingId)}/client-status`,
      "GET",
      null,
      StatusResponseSchema,
      signal
    );
  }
  redeem(pairingId, signal) {
    return this.#call(
      "redeem",
      `/api/v1/pairings/${encodeURIComponent(pairingId)}/redeem`,
      "POST",
      {},
      RedeemResponseSchema,
      signal
    );
  }
  async #call(route, path, method, body, schema, outerSignal) {
    const timeoutSignal = AbortSignal.timeout(this.#timeoutMs);
    const signal = outerSignal === void 0 ? timeoutSignal : AbortSignal.any([outerSignal, timeoutSignal]);
    if (signal.aborted) return { ok: false, source: "local", error: { code: "CANCELLED" } };
    let proof = "";
    const headers = { Accept: "application/json" };
    if (body !== null) headers["Content-Type"] = "application/json";
    if (route !== "claim") {
      try {
        proof = this.#proofHeaderProvider();
      } catch {
        return { ok: false, source: "local", error: { code: "TRANSPORT_ERROR", phase: "status" } };
      }
      if (!/^[A-Za-z0-9_-]{43}$/.test(proof)) {
        proof = "";
        return {
          ok: false,
          source: "local",
          error: { code: "RESPONSE_INVALID", reason: "schema" }
        };
      }
      headers.Authorization = `PairingProof ${proof}`;
    }
    let response;
    try {
      response = await this.#fetch(new URL(path, this.#baseUrl), {
        method,
        redirect: "manual",
        headers,
        ...body === null ? {} : { body: JSON.stringify(body) },
        signal
      });
    } catch {
      proof = "";
      if (outerSignal?.aborted) return { ok: false, source: "local", error: { code: "CANCELLED" } };
      if (timeoutSignal.aborted)
        return {
          ok: false,
          source: "local",
          error: { code: "TIMEOUT", timeoutMs: this.#timeoutMs }
        };
      return route === "status" ? { ok: false, source: "local", error: { code: "TRANSPORT_ERROR", phase: "status" } } : {
        ok: false,
        source: "local",
        error: { code: "TRANSPORT_OUTCOME_UNKNOWN", phase: route }
      };
    } finally {
      proof = "";
      delete headers.Authorization;
    }
    if (response.redirected || response.status >= 300 && response.status < 400) {
      await response.body?.cancel().catch(() => void 0);
      return { ok: false, source: "local", error: { code: "RESPONSE_INVALID", reason: "status" } };
    }
    if (response.headers.get("content-type")?.toLowerCase() !== "application/json; charset=utf-8") {
      await response.body?.cancel().catch(() => void 0);
      return {
        ok: false,
        source: "local",
        error: { code: "RESPONSE_INVALID", reason: "content_type" }
      };
    }
    if (!validSecurityHeaders(response, route)) {
      await response.body?.cancel().catch(() => void 0);
      return { ok: false, source: "local", error: { code: "RESPONSE_INVALID", reason: "headers" } };
    }
    const bytes = await BoardSdkHttpClient.readBoundedResponseBodyV1(response, 65536, signal);
    if (typeof bytes === "string") {
      return {
        ok: false,
        source: "local",
        error: { code: "RESPONSE_INVALID", reason: bytes === "body_too_large" ? bytes : "schema" }
      };
    }
    const parsed = BoardSdkHttpClient.parseStrictJsonBytesV1(bytes);
    if (!parsed.ok)
      return {
        ok: false,
        source: "local",
        error: { code: "RESPONSE_INVALID", reason: parsed.reason }
      };
    if (response.status === expectedStatus[route]) {
      const success = schema.safeParse(parsed.value);
      return success.success ? { ok: true, value: success.data } : { ok: false, source: "local", error: { code: "RESPONSE_INVALID", reason: "schema" } };
    }
    const failure = ErrorSchema.safeParse(parsed.value);
    if (!failure.success || allowedErrorStatus[failure.data.error.code] !== response.status) {
      return { ok: false, source: "local", error: { code: "RESPONSE_INVALID", reason: "status" } };
    }
    const retryAfter = parseRetryAfter(response);
    const requiresRetry = failure.data.error.code === "PAIRING_NOT_READY" || failure.data.error.code === "RATE_LIMITED";
    if (retryAfter === "invalid" || requiresRetry !== (retryAfter !== null)) {
      return { ok: false, source: "local", error: { code: "RESPONSE_INVALID", reason: "headers" } };
    }
    return {
      ok: false,
      source: "pairing",
      error: { ...failure.data.error, retryAfterSeconds: retryAfter }
    };
  }
};

// sceneboard-mcp/src/pairing/pairing-session.owner.ts
import { createHash as createHash2, randomBytes as randomBytes6 } from "node:crypto";
var sleep = async (milliseconds, signal) => {
  if (milliseconds <= 0) return true;
  return new Promise((resolve3) => {
    const timer = setTimeout(() => {
      signal?.removeEventListener("abort", onAbort);
      resolve3(true);
    }, milliseconds);
    const onAbort = () => {
      clearTimeout(timer);
      resolve3(false);
    };
    signal?.addEventListener("abort", onAbort, { once: true });
  });
};
var safeGrant = (response) => ({
  grantId: response.grant.grantId,
  client: response.grant.client,
  scopes: response.grant.scopes,
  lifecyclePermissions: response.grant.lifecyclePermissions,
  boardIds: response.grant.boardIds,
  lifetime: response.grant.lifetime,
  status: "active",
  activatedAt: response.grant.activatedAt,
  expiresAt: response.grant.expiresAt
});
var PairingSessionOwnerV1 = class {
  constructor(store, installations, leases, clientFactory, connectionProbe) {
    this.store = store;
    this.installations = installations;
    this.leases = leases;
    this.clientFactory = clientFactory;
    this.connectionProbe = connectionProbe;
  }
  session = null;
  async request(input, signal) {
    if (this.session !== null) {
      return {
        ok: false,
        source: "local",
        error: { code: "PROFILE_BUSY", reason: "active_owner" }
      };
    }
    if (!await this.leases.verify())
      return { ok: false, source: "local", error: { code: "PAIRING_SINK_UNAVAILABLE" } };
    try {
      await this.store.preflight();
    } catch {
      return { ok: false, source: "local", error: { code: "PAIRING_SINK_UNAVAILABLE" } };
    }
    let lease;
    try {
      lease = await this.leases.acquire(this.store.stateDirectory);
    } catch (error3) {
      if (error3 instanceof ProfileLeaseErrorV1 && error3.reason === "active_owner") {
        return {
          ok: false,
          source: "local",
          error: { code: "PROFILE_BUSY", reason: "active_owner" }
        };
      }
      if (error3 instanceof ProfileLeaseErrorV1 && error3.reason === "lease_corrupt") {
        return { ok: false, source: "local", error: { code: "PROFILE_LEASE_CORRUPT" } };
      }
      return {
        ok: false,
        source: "local",
        error: { code: "PROFILE_BUSY", reason: "liveness_unknown" }
      };
    }
    try {
      await this.store.read();
    } catch {
      await lease.release();
      return { ok: false, source: "local", error: { code: "PAIRING_SINK_UNAVAILABLE" } };
    }
    const proof = randomBytes6(32);
    const client = this.clientFactory(() => proof.toString("base64url"));
    let installationId;
    try {
      installationId = await this.installations.getOrCreate();
    } catch {
      proof.fill(0);
      await lease.release();
      return { ok: false, source: "local", error: { code: "PAIRING_SINK_UNAVAILABLE" } };
    }
    const challenge = createHash2("sha256").update(proof).digest("base64url");
    const claimed = await client.claim(
      {
        code: input.code,
        installationId,
        clientName: input.clientName,
        requestedScopes: input.requestedScopes,
        requestedLifecyclePermissions: input.requestedLifecyclePermissions,
        clientProofChallenge: challenge
      },
      signal
    );
    installationId = "";
    if (!claimed.ok) {
      proof.fill(0);
      await lease.release();
      if (claimed.source === "local" && claimed.error.code === "TRANSPORT_OUTCOME_UNKNOWN") {
        return { ok: false, source: "local", error: { code: "PAIRING_CLAIM_OUTCOME_UNKNOWN" } };
      }
      return claimed;
    }
    this.session = {
      pairingId: claimed.value.pairingId,
      decisionExpiresAt: claimed.value.decisionExpiresAt,
      proof,
      lease,
      client,
      redeemAttempts: 0
    };
    return { ok: true, value: { ...claimed.value, hasToken: false } };
  }
  async status(pairingId, waitTimeoutMs, signal) {
    const session = this.session;
    if (session === null || session.pairingId !== pairingId) {
      return { ok: false, source: "local", error: { code: "PAIRING_STATE_LOST" } };
    }
    const deadline = performance.now() + waitTimeoutMs;
    while (true) {
      const result = await session.client.clientStatus(pairingId, signal);
      if (!result.ok) {
        if (result.source === "pairing" && result.error.code === "PAIRING_PROOF_INVALID")
          await this.teardown(session);
        return result;
      }
      const status = result.value;
      if (status.state === "pending" && performance.now() < deadline) {
        const remaining = Math.max(0, deadline - performance.now());
        const delay = Math.min(status.retryAfterSeconds * 1e3, remaining);
        if (delay > 0 && await sleep(delay, signal)) continue;
      }
      return this.#resolveStatus(session, status, signal);
    }
  }
  async close() {
    if (this.session !== null) await this.teardown(this.session);
  }
  async #resolveStatus(session, status, signal) {
    const decisionExpiresAt = status.decisionExpiresAt;
    if (status.state === "pending") {
      return {
        ok: true,
        value: {
          pairingId: status.pairingId,
          state: "pending",
          retryAfterSeconds: status.retryAfterSeconds,
          decisionExpiresAt,
          redeemExpiresAt: null,
          grant: null,
          hasToken: false
        }
      };
    }
    if (status.state === "denied") {
      const value = {
        pairingId: status.pairingId,
        state: "denied",
        retryAfterSeconds: null,
        decisionExpiresAt,
        redeemExpiresAt: null,
        grant: null,
        hasToken: false
      };
      await this.teardown(session);
      return { ok: true, value };
    }
    if (status.state === "cancelled" || status.state === "expired") {
      const value = {
        pairingId: status.pairingId,
        state: status.state,
        retryAfterSeconds: null,
        decisionExpiresAt,
        redeemExpiresAt: status.redeemExpiresAt,
        grant: null,
        hasToken: false
      };
      await this.teardown(session);
      return { ok: true, value };
    }
    if (status.state === "redeemed") {
      await this.teardown(session);
      return { ok: false, source: "local", error: { code: "PAIRING_CREDENTIAL_UNRECOVERABLE" } };
    }
    if (session.redeemAttempts >= 2) {
      return { ok: false, source: "local", error: { code: "TRANSPORT_ERROR", phase: "status" } };
    }
    return this.#redeem(session, decisionExpiresAt, status.redeemExpiresAt, signal);
  }
  async #redeem(session, decisionExpiresAt, redeemExpiresAt, signal) {
    session.redeemAttempts += 1;
    const result = await session.client.redeem(session.pairingId, signal);
    if (!result.ok) {
      if (result.source === "local" && result.error.code === "TRANSPORT_OUTCOME_UNKNOWN") {
        const resolution = await session.client.clientStatus(session.pairingId, signal);
        if (!resolution.ok) return resolution;
        if (resolution.value.state === "approved" && session.redeemAttempts < 2) {
          return this.#redeem(session, decisionExpiresAt, redeemExpiresAt, signal);
        }
        return this.#resolveStatus(session, resolution.value, signal);
      }
      return result;
    }
    const record2 = await this.store.replace(result.value.accessToken);
    const reloaded = await this.store.read();
    if (reloaded === null || !sameCredentialV1(record2, reloaded)) {
      return { ok: false, source: "local", error: { code: "PAIRING_CREDENTIAL_UNRECOVERABLE" } };
    }
    const connected = await this.connectionProbe(record2.accessToken, signal).catch(() => false);
    if (!connected) {
      return { ok: false, source: "local", error: { code: "TRANSPORT_ERROR", phase: "status" } };
    }
    const grant = safeGrant(result.value);
    await this.teardown(session);
    return {
      ok: true,
      value: {
        pairingId: session.pairingId,
        state: "redeemed",
        retryAfterSeconds: null,
        decisionExpiresAt,
        redeemExpiresAt,
        grant,
        hasToken: true
      }
    };
  }
  async teardown(session) {
    if (this.session === session) this.session = null;
    session.proof.fill(0);
    await session.lease.release();
  }
};

// sceneboard-mcp/src/pairing/unavailable-pairing.coordinator.ts
var UnavailablePairingCoordinatorV1 = class {
  constructor(reason) {
    this.reason = reason;
  }
  async request(_input, _signal) {
    return {
      ok: false,
      source: "local",
      error: {
        code: this.reason === "read_only" ? "PAIRING_SINK_READ_ONLY" : "PAIRING_SINK_UNAVAILABLE"
      }
    };
  }
  async status(_pairingId, _waitTimeoutMs, _signal) {
    return { ok: false, source: "local", error: { code: "PAIRING_STATE_LOST" } };
  }
  async close() {
  }
};

// sceneboard-mcp/src/tools/protected-board.gateway.ts
import { randomBytes as randomBytes7 } from "node:crypto";

// sceneboard-mcp/src/connection/connection-media-http.client.ts
var local2 = (error3) => ({ ok: false, error: error3 });
var exactRecord2 = (value, keys) => {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
  const record2 = value;
  const actual = Object.keys(record2).sort();
  const expected = [...keys].sort();
  return actual.length === expected.length && actual.every((key, index) => key === expected[index]) ? record2 : null;
};
var ConnectionMediaHttpClientV1 = class {
  constructor(options) {
    this.options = options;
  }
  async upload(input, outerSignal) {
    const timeoutSignal = AbortSignal.timeout(this.options.timeoutMs);
    const signal = outerSignal === void 0 ? timeoutSignal : AbortSignal.any([outerSignal, timeoutSignal]);
    if (signal.aborted) return local2({ code: "CANCELLED", retryable: false });
    const url = new URL(
      `/api/v1/boards/${encodeURIComponent(input.boardId)}/media`,
      this.options.baseUrl
    );
    url.search = new URLSearchParams({ requestId: input.requestId }).toString();
    const startedAt = performance.now();
    let response;
    try {
      response = await this.options.fetch(url, {
        method: "POST",
        redirect: "manual",
        headers: {
          Accept: "application/json",
          Authorization: `Bearer ${input.accessToken}`,
          "Content-Type": input.mime,
          "Content-Length": String(input.bytes.length),
          "Content-Digest": `sha-256=:${input.digestBase64}:`,
          "Idempotency-Key": input.idempotencyKey
        },
        body: input.bytes,
        signal
      });
    } catch {
      if (outerSignal?.aborted) return local2({ code: "CANCELLED", retryable: false });
      if (timeoutSignal.aborted)
        return local2({ code: "TIMEOUT", retryable: true, timeoutMs: this.options.timeoutMs });
      return local2({ code: "TRANSPORT_ERROR", retryable: true, phase: "request" });
    }
    if (response.redirected || response.status >= 300 && response.status < 400) {
      await response.body?.cancel().catch(() => void 0);
      return local2({ code: "RESPONSE_INVALID", retryable: false, reason: "status" });
    }
    if (response.headers.get("content-type")?.toLowerCase() !== "application/json; charset=utf-8") {
      await response.body?.cancel().catch(() => void 0);
      return local2({ code: "RESPONSE_INVALID", retryable: false, reason: "content_type" });
    }
    const successStatus = response.status === 200 || response.status === 201;
    const body = await BoardSdkHttpClient.readBoundedResponseBodyV1(
      response,
      successStatus ? 2097152 : 65536,
      signal
    );
    if (body === "body_too_large")
      return local2({ code: "RESPONSE_INVALID", retryable: false, reason: "body_too_large" });
    if (body === "response") {
      if (outerSignal?.aborted) return local2({ code: "CANCELLED", retryable: false });
      if (timeoutSignal.aborted)
        return local2({ code: "TIMEOUT", retryable: true, timeoutMs: this.options.timeoutMs });
      return local2({ code: "TRANSPORT_ERROR", retryable: true, phase: "response" });
    }
    if (response.headers.get("x-request-id") !== input.requestId)
      return local2({ code: "RESPONSE_INVALID", retryable: false, reason: "correlation" });
    const parsed = BoardSdkHttpClient.parseStrictJsonBytesV1(body);
    if (!parsed.ok)
      return local2({ code: "RESPONSE_INVALID", retryable: false, reason: parsed.reason });
    if (successStatus) {
      const envelope2 = exactRecord2(parsed.value, [
        "protocolVersion",
        "type",
        "requestId",
        "result"
      ]);
      const result = envelope2 === null ? null : MediaIngestResultParserV1.parse(envelope2.result);
      if (envelope2 === null || envelope2.protocolVersion !== 1 || envelope2.type !== "board.http.success" || envelope2.requestId !== input.requestId || result === null || !result.ok || result.data.value.requestId !== input.requestId || response.status === 201 && result.data.value.status !== "created" || response.status === 200 && result.data.value.status !== "replayed")
        return local2({ code: "RESPONSE_INVALID", retryable: false, reason: "correlation" });
      this.options.logger.log({
        route: "/api/v1/boards/:boardId/media",
        attempt: 1,
        durationMs: performance.now() - startedAt,
        requestId: input.requestId,
        resultCode: result.data.value.status
      });
      return { ok: true, result: result.data.value, metadata: null };
    }
    const envelope = exactRecord2(parsed.value, ["error"]);
    const error3 = envelope === null ? null : BoardErrorParser.parse(envelope.error);
    if (error3 === null || !error3.ok || error3.data.value.httpStatusHint !== response.status || ![
      "INVALID_REQUEST",
      "UNAUTHENTICATED",
      "FORBIDDEN",
      "BOARD_NOT_FOUND",
      "IDEMPOTENCY_KEY_REUSED",
      "IDEMPOTENCY_RESULT_EXPIRED",
      "PAYLOAD_TOO_LARGE",
      "INVALID_MEDIA_UPLOAD",
      "RATE_LIMITED",
      "SERVICE_UNAVAILABLE"
    ].includes(error3.data.value.code))
      return local2({ code: "RESPONSE_INVALID", retryable: false, reason: "status" });
    this.options.logger.log({
      route: "/api/v1/boards/:boardId/media",
      attempt: 1,
      durationMs: performance.now() - startedAt,
      requestId: input.requestId,
      resultCode: error3.data.value.code
    });
    return { ok: false, error: error3.data.value };
  }
};

// sceneboard-mcp/src/tools/account-api-key-tool-policy.ts
var operationPlan = (operations, scopes) => Object.freeze({ operations: Object.freeze(operations), scopes: Object.freeze(scopes) });
var toolPolicy = (...operationPlans) => Object.freeze({ operationPlans: Object.freeze(operationPlans) });
var readModifyWritePlan = (operation) => operationPlan(["board.get", operation], ["board:read", "board:write"]);
var ACCOUNT_API_KEY_TOOL_POLICIES_V1 = Object.freeze({
  board_list: toolPolicy(operationPlan(["board.list"], ["board:read"])),
  board_get: toolPolicy(operationPlan(["board.get"], ["board:read"])),
  board_scene_get: toolPolicy(
    operationPlan(["board.get"], ["board:read"]),
    operationPlan(["history.get"], ["history:read"])
  ),
  board_document_get: toolPolicy(
    operationPlan(["board.get"], ["board:read"]),
    operationPlan(["history.get"], ["history:read"])
  ),
  board_create: toolPolicy(operationPlan(["board.create"], ["board:create"])),
  board_rename: toolPolicy(operationPlan(["board.rename"], ["board:write"])),
  board_archive: toolPolicy(operationPlan(["board.archive"], ["board:archive"])),
  board_capabilities_get: toolPolicy(operationPlan(["capabilities.get"], ["board:read"])),
  board_scene_replace: toolPolicy(operationPlan(["scene.replace"], ["board:write"])),
  board_scene_patch: toolPolicy(readModifyWritePlan("scene.replace")),
  board_scene_clear: toolPolicy(operationPlan(["scene.clear"], ["board:write"])),
  board_document_replace: toolPolicy(readModifyWritePlan("document.replace")),
  board_page_add: toolPolicy(readModifyWritePlan("document.replace")),
  board_page_remove: toolPolicy(readModifyWritePlan("document.replace")),
  board_page_reorder: toolPolicy(readModifyWritePlan("document.replace")),
  board_page_update: toolPolicy(readModifyWritePlan("document.replace")),
  board_page_default_set: toolPolicy(readModifyWritePlan("document.replace")),
  board_history_list: toolPolicy(operationPlan(["history.list"], ["history:read"])),
  board_history_get: toolPolicy(operationPlan(["history.get"], ["history:read"])),
  board_history_restore: toolPolicy(
    operationPlan(["scene.restore"], ["board:write", "history:read"])
  ),
  board_artifact_get: toolPolicy(operationPlan(["artifact.get"], ["board:read"])),
  board_artifact_put: toolPolicy(operationPlan(["artifact.publish"], ["artifact:publish"])),
  board_artifact_stop: toolPolicy(operationPlan(["artifact.stop"], ["artifact:control"])),
  board_interaction_request: toolPolicy(operationPlan(["hitl.request"], ["board:hitl:request"])),
  board_interaction_status: toolPolicy(operationPlan(["hitl.read"], ["board:read"])),
  board_interaction_respond: toolPolicy(operationPlan(["hitl.respond"], ["board:hitl:respond"])),
  sceneboard_media_upload: toolPolicy(operationPlan(["media.upload"], ["board:media:write"])),
  sceneboard_media_place: toolPolicy(
    operationPlan(["history.get", "document.replace"], ["history:read", "board:write"])
  ),
  board_export: toolPolicy(operationPlan(["export.render"], ["export:read"]))
});
var accountApiKeyToolPolicyV1 = (toolName) => {
  if (!Object.hasOwn(ACCOUNT_API_KEY_TOOL_POLICIES_V1, toolName)) return null;
  const policy2 = ACCOUNT_API_KEY_TOOL_POLICIES_V1[toolName];
  return {
    operationPlans: policy2.operationPlans
  };
};

// sceneboard-mcp/src/exports/local-export-file.ts
import { spawn as spawn2 } from "node:child_process";
import { createHash as createHash3 } from "node:crypto";
import {
  closeSync,
  constants as fsConstants,
  fstatSync,
  lstatSync,
  openSync,
  readFileSync
} from "node:fs";
import { basename, isAbsolute as isAbsolute3, normalize, posix, resolve as resolve2 } from "node:path";
var LOCAL_EXPORT_MAX_BYTES_V1 = 536870912;
var LOCAL_EXPORT_MAX_STDERR_BYTES_V1 = 4096;
var LOCAL_EXPORT_MAX_STDOUT_BYTES_V1 = 128;
var LINUX_O_DIRECTORY = 65536;
var LINUX_O_CLOEXEC = 524288;
var error2 = (code) => {
  const messages = {
    LOCAL_EXPORT_UNAVAILABLE: "Secure local export is unavailable on this platform",
    LOCAL_EXPORT_INVALID_PATH: "Local export path is invalid",
    LOCAL_EXPORT_EXISTS: "Local export target already exists",
    LOCAL_EXPORT_IO: "Local export could not be published",
    LOCAL_EXPORT_SHORT: "Export download ended before completion",
    LOCAL_EXPORT_CORRUPT: "Export download or local helper response is invalid",
    LOCAL_EXPORT_CANCELLED: "Local export was cancelled"
  };
  return Object.freeze({ code, message: messages[code], retryable: false, details: null });
};
var transportErrorV1 = () => Object.freeze({
  code: "BOARD_MCP_TRANSPORT_ERROR",
  message: "SceneBoard transport is unavailable",
  retryable: true,
  details: Object.freeze({ phase: "response" })
});
var detectGlibcV1 = () => {
  try {
    const report = process.report?.getReport();
    const header = report !== void 0 && typeof report === "object" ? report.header : void 0;
    return header !== void 0 && typeof header.glibcVersionRuntime === "string";
  } catch {
    return false;
  }
};
var exactManifestV1 = (value) => {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
  const root = value;
  if (Object.keys(root).sort().join("\0") !== ["targets", "version"].join("\0")) return null;
  if (root.version !== 1 || root.targets === null || typeof root.targets !== "object") return null;
  const targets = root.targets;
  if (Object.keys(targets).join("\0") !== "linux-x64-gnu") return null;
  const target = targets["linux-x64-gnu"];
  if (target === null || typeof target !== "object" || Array.isArray(target)) return null;
  const entry = target;
  if (Object.keys(entry).sort().join("\0") !== ["mode", "path", "sha256"].join("\0")) return null;
  if (entry.path !== "linux-x64-gnu/local-export-helper" || entry.mode !== "0500" || typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256))
    return null;
  return value;
};
var safeDisplayNameV1 = (path) => {
  const safe = basename(path).replace(/[^A-Za-z0-9._-]+/gu, "-").replace(/-+/gu, "-").replace(/^[._-]+|[._-]+$/gu, "").slice(0, 120);
  return safe === "" ? "sceneboard-export" : safe;
};
var parseAbsolutePathV1 = (outputFile, format) => {
  if (outputFile.length === 0 || outputFile !== outputFile.normalize("NFC") || !isAbsolute3(outputFile) || !outputFile.startsWith("/") || normalize(outputFile) !== outputFile || outputFile.endsWith("/") || /[*?[\]{}!]/u.test(outputFile))
    return null;
  const components = outputFile.slice(1).split("/");
  if (components.length === 0 || components.length > 64 || components.some((component) => {
    const bytes = Buffer.byteLength(component, "utf8");
    return component === "" || component === "." || component === ".." || component !== component.normalize("NFC") || component.includes("\0") || bytes === 0 || bytes > 255;
  }))
    return null;
  const normalizedPathBytes = Buffer.byteLength(outputFile, "utf8");
  const expectedExtension = format === "pdf" ? ".pdf" : ".pptx";
  if (normalizedPathBytes > 4096 || !components.at(-1)?.endsWith(expectedExtension) || components.at(-1) === expectedExtension)
    return null;
  return Object.freeze({
    format,
    components: Object.freeze(components),
    normalizedPathBytes,
    displayName: safeDisplayNameV1(outputFile)
  });
};
var writeU64BeV1 = (buffer, offset, value) => {
  const big = BigInt(value);
  buffer.writeUInt32BE(Number(big >> 32n & 0xffffffffn), offset);
  buffer.writeUInt32BE(Number(big & 0xffffffffn), offset + 4);
};
var encodeLocalExportControlFrameV1 = (intent, expectedBytes) => {
  if (!Number.isSafeInteger(expectedBytes) || expectedBytes < 1 || expectedBytes > LOCAL_EXPORT_MAX_BYTES_V1)
    throw new TypeError("invalid local export byte count");
  const encoded = intent.components.map((component) => Buffer.from(component, "utf8"));
  const frameBytes = 24 + encoded.reduce((total, component) => total + 2 + component.byteLength, 0);
  if (frameBytes > 65532) throw new TypeError("local export control frame is too large");
  const frame = Buffer.allocUnsafe(4 + frameBytes);
  frame.writeUInt32BE(frameBytes, 0);
  frame.write("SBEX", 4, 4, "ascii");
  frame.writeUInt16BE(1, 8);
  frame.writeUInt16BE(0, 10);
  frame.writeUInt8(intent.format === "pdf" ? 1 : 2, 12);
  frame.writeUInt8(encoded.length, 13);
  frame.writeUInt16BE(0, 14);
  writeU64BeV1(frame, 16, expectedBytes);
  frame.writeUInt32BE(intent.normalizedPathBytes, 24);
  let cursor = 28;
  for (const component of encoded) {
    frame.writeUInt16BE(component.byteLength, cursor);
    cursor += 2;
    component.copy(frame, cursor);
    cursor += component.byteLength;
  }
  return frame;
};
var signatureMatchesV1 = (format, bytes) => format === "pdf" ? bytes.subarray(0, 5).equals(Buffer.from("%PDF-", "ascii")) : bytes.subarray(0, 4).equals(Buffer.from([80, 75, 3, 4]));
var writeWithBackpressureV1 = async (child, bytes, signal) => {
  signal?.throwIfAborted();
  if (child.stdin.write(bytes)) return;
  await new Promise((resolveDrain, reject) => {
    const cleanup = () => {
      child.stdin.off("drain", drained);
      child.stdin.off("error", failed2);
      signal?.removeEventListener("abort", aborted2);
    };
    const drained = () => {
      cleanup();
      resolveDrain();
    };
    const failed2 = (streamError) => {
      cleanup();
      reject(streamError);
    };
    const aborted2 = () => {
      cleanup();
      reject(signal?.reason);
    };
    child.stdin.once("drain", drained);
    child.stdin.once("error", failed2);
    if (signal?.aborted) aborted2();
    else signal?.addEventListener("abort", aborted2, { once: true });
  });
};
var collectBoundedV1 = (child, stream, limit, onOverflow, signal) => new Promise((resolveBytes, reject) => {
  const chunks = [];
  let size = 0;
  const cleanup = () => {
    stream.off("data", received);
    stream.off("error", failed2);
    stream.off("end", ended);
    child.off("error", failed2);
    signal?.removeEventListener("abort", aborted2);
  };
  const failed2 = (streamError) => {
    cleanup();
    reject(streamError);
  };
  const ended = () => {
    cleanup();
    resolveBytes(Buffer.concat(chunks, size));
  };
  const aborted2 = () => {
    cleanup();
    reject(signal?.reason);
  };
  const received = (chunk) => {
    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
    size += bytes.byteLength;
    if (size > limit) {
      cleanup();
      onOverflow();
      reject(new Error("local export helper output overflow"));
      return;
    }
    chunks.push(bytes);
  };
  stream.on("data", received);
  stream.once("error", failed2);
  stream.once("end", ended);
  child.once("error", failed2);
  if (signal?.aborted) aborted2();
  else signal?.addEventListener("abort", aborted2, { once: true });
});
var waitForExitV1 = (child, signal) => new Promise((resolveExit, reject) => {
  const cleanup = () => {
    child.off("error", failed2);
    child.off("exit", exited);
    signal?.removeEventListener("abort", aborted2);
  };
  const failed2 = (childError) => {
    cleanup();
    reject(childError);
  };
  const exited = (code, exitSignal) => {
    cleanup();
    resolveExit({ code, signal: exitSignal });
  };
  const aborted2 = () => {
    cleanup();
    reject(signal?.reason);
  };
  child.once("error", failed2);
  child.once("exit", exited);
  if (signal?.aborted) aborted2();
  else signal?.addEventListener("abort", aborted2, { once: true });
});
var endWritableV1 = (stream, bytes, signal) => new Promise((resolveEnd, reject) => {
  const cleanup = () => {
    stream.removeListener("error", failed2);
    signal?.removeEventListener("abort", aborted2);
  };
  const failed2 = (streamError) => {
    cleanup();
    reject(streamError);
  };
  const ended = () => {
    cleanup();
    resolveEnd();
  };
  const aborted2 = () => {
    cleanup();
    reject(signal?.reason);
  };
  stream.once("error", failed2);
  if (signal?.aborted) aborted2();
  else {
    signal?.addEventListener("abort", aborted2, { once: true });
    stream.end(bytes, ended);
  }
});
var readWithSignalV1 = async (reader, signal) => {
  signal?.throwIfAborted();
  return new Promise((resolveRead, reject) => {
    const cleanup = () => signal?.removeEventListener("abort", aborted2);
    const aborted2 = () => {
      cleanup();
      reject(signal?.reason);
    };
    reader.read().then(
      (value) => {
        cleanup();
        if (signal?.aborted) reject(signal.reason);
        else resolveRead(value);
      },
      (readError) => {
        cleanup();
        reject(readError);
      }
    );
    signal?.addEventListener("abort", aborted2, { once: true });
  });
};
var cancelReaderBestEffortV1 = (reader) => {
  void reader.cancel().catch(() => void 0);
};
var destroyStreamV1 = (stream) => {
  if (stream !== null && "destroy" in stream && typeof stream.destroy === "function")
    stream.destroy();
};
var waitForChildExitBoundedV1 = async (child, timeoutMs) => {
  if (child.exitCode !== null || child.signalCode !== null) return true;
  return new Promise((resolveExit) => {
    const cleanup = () => {
      clearTimeout(timer);
      child.off("exit", exited);
      child.off("error", exited);
    };
    const exited = () => {
      cleanup();
      resolveExit(true);
    };
    const timer = setTimeout(() => {
      cleanup();
      resolveExit(false);
    }, timeoutMs);
    child.once("exit", exited);
    child.once("error", exited);
  });
};
var waitForReadableClosureBoundedV1 = async (stream, timeoutMs) => {
  const readable = stream;
  if (readable.destroyed === true || readable.readableEnded === true) return true;
  return new Promise((resolveClosure) => {
    const cleanup = () => {
      clearTimeout(timer);
      stream.removeListener("close", closed);
      stream.removeListener("end", closed);
      stream.removeListener("error", closed);
    };
    const closed = () => {
      cleanup();
      resolveClosure(true);
    };
    const timer = setTimeout(() => {
      cleanup();
      resolveClosure(false);
    }, timeoutMs);
    stream.once("close", closed);
    stream.once("end", closed);
    stream.once("error", closed);
  });
};
var terminateChildV1 = async (child, control, publicationMayExist) => {
  destroyStreamV1(control ?? null);
  destroyStreamV1(child.stdin);
  if (!publicationMayExist) {
    destroyStreamV1(child.stdout);
    destroyStreamV1(child.stderr);
  }
  const waitForPublicationClosure = async () => {
    if (!publicationMayExist) return;
    await Promise.all([
      waitForReadableClosureBoundedV1(child.stdout, 750),
      waitForReadableClosureBoundedV1(child.stderr, 750)
    ]);
  };
  if (child.exitCode !== null || child.signalCode !== null) {
    await waitForPublicationClosure();
    return;
  }
  child.kill("SIGTERM");
  if (await waitForChildExitBoundedV1(child, 250)) {
    await waitForPublicationClosure();
    return;
  }
  child.kill("SIGKILL");
  await Promise.all([waitForChildExitBoundedV1(child, 250), waitForPublicationClosure()]);
};
var LocalExportFileV1 = class {
  constructor(options) {
    this.options = options;
    this.platform = options.platform ?? process.platform;
    this.architecture = options.architecture ?? process.arch;
    this.glibc = options.glibc ?? detectGlibcV1();
    this.spawnProcess = options.spawn ?? spawn2;
    this.effectiveUserId = options.effectiveUserId ?? process.geteuid?.();
  }
  platform;
  architecture;
  glibc;
  spawnProcess;
  effectiveUserId;
  preflight(outputFile, format) {
    if (this.platform !== "linux" || this.architecture !== "x64" || !this.glibc)
      return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
    const parsedPath = parseAbsolutePathV1(outputFile, format);
    if (parsedPath === null) return { ok: false, error: error2("LOCAL_EXPORT_INVALID_PATH") };
    let descriptor = -1;
    let manifestDescriptor = -1;
    try {
      const manifestPathStatus = lstatSync(this.options.manifestPath);
      if (!manifestPathStatus.isFile() || manifestPathStatus.isSymbolicLink() || (manifestPathStatus.mode & 511) !== 256 || manifestPathStatus.uid !== this.effectiveUserId)
        return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
      manifestDescriptor = openSync(
        this.options.manifestPath,
        fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW | LINUX_O_CLOEXEC
      );
      const manifestStatus = fstatSync(manifestDescriptor);
      if (!manifestStatus.isFile() || manifestStatus.dev !== manifestPathStatus.dev || manifestStatus.ino !== manifestPathStatus.ino || (manifestStatus.mode & 511) !== 256 || manifestStatus.uid !== this.effectiveUserId) {
        closeSync(manifestDescriptor);
        manifestDescriptor = -1;
        return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
      }
      const manifest = exactManifestV1(JSON.parse(readFileSync(manifestDescriptor, "utf8")));
      closeSync(manifestDescriptor);
      manifestDescriptor = -1;
      if (manifest === null) return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
      const helperPath = resolve2(
        posix.dirname(this.options.manifestPath),
        manifest.targets["linux-x64-gnu"].path
      );
      const pathStatus = lstatSync(helperPath);
      if (!pathStatus.isFile() || pathStatus.isSymbolicLink() || (pathStatus.mode & 511) !== 320 || pathStatus.uid !== this.effectiveUserId)
        return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
      descriptor = openSync(
        helperPath,
        fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW | LINUX_O_CLOEXEC
      );
      const helperStatus = fstatSync(descriptor);
      const digest = createHash3("sha256").update(readFileSync(descriptor)).digest("hex");
      if (!helperStatus.isFile() || helperStatus.dev !== pathStatus.dev || helperStatus.ino !== pathStatus.ino || (helperStatus.mode & 511) !== 320 || helperStatus.uid !== this.effectiveUserId || digest !== manifest.targets["linux-x64-gnu"].sha256) {
        closeSync(descriptor);
        descriptor = -1;
        return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
      }
      return {
        ok: true,
        value: Object.freeze({
          ...parsedPath,
          helperHandle: { descriptor, released: false }
        })
      };
    } catch {
      if (manifestDescriptor >= 0) closeSync(manifestDescriptor);
      if (descriptor >= 0) closeSync(descriptor);
      return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
    }
  }
  release(intent) {
    if (intent.helperHandle.released) return;
    intent.helperHandle.released = true;
    closeSync(intent.helperHandle.descriptor);
  }
  async publish(intent, artifact, signal) {
    const closed = (result) => {
      this.release(intent);
      return result;
    };
    if (artifact.format !== intent.format || !Number.isSafeInteger(artifact.contentLength) || artifact.contentLength < 1 || artifact.contentLength > LOCAL_EXPORT_MAX_BYTES_V1)
      return closed({ ok: false, error: error2("LOCAL_EXPORT_CORRUPT") });
    const expectedContentType = intent.format === "pdf" ? "application/pdf" : "application/vnd.openxmlformats-officedocument.presentationml.presentation";
    if (artifact.contentType !== expectedContentType)
      return closed({ ok: false, error: error2("LOCAL_EXPORT_CORRUPT") });
    let reader;
    try {
      reader = artifact.body.getReader();
    } catch {
      return closed({ ok: false, error: error2("LOCAL_EXPORT_CORRUPT") });
    }
    let rootDescriptor = -1;
    let child;
    let control;
    let overflow = false;
    let downloadFailed = false;
    let payloadForwarded = false;
    const abort = () => {
      child?.kill("SIGTERM");
      if (child !== void 0 && !payloadForwarded) {
        destroyStreamV1(control ?? null);
        destroyStreamV1(child.stdin);
      } else if (child !== void 0) {
        void waitForChildExitBoundedV1(child, 250).then((exited) => {
          if (!exited) child?.kill("SIGKILL");
        });
      }
    };
    signal?.addEventListener("abort", abort, { once: true });
    if (signal?.aborted) abort();
    try {
      const readNext = async () => {
        try {
          return await readWithSignalV1(reader, signal);
        } catch (readError) {
          if (signal?.aborted !== true) downloadFailed = true;
          throw readError;
        }
      };
      const prefix = [];
      let prefixBytes = 0;
      while (prefixBytes < 5) {
        const next = await readNext();
        if (next.done) return { ok: false, error: error2("LOCAL_EXPORT_SHORT") };
        const bytes2 = Buffer.from(next.value);
        prefix.push(bytes2);
        prefixBytes += bytes2.byteLength;
      }
      const initial = Buffer.concat(prefix, prefixBytes);
      if (!signatureMatchesV1(intent.format, initial)) {
        this.release(intent);
        cancelReaderBestEffortV1(reader);
        return { ok: false, error: error2("LOCAL_EXPORT_CORRUPT") };
      }
      signal?.throwIfAborted();
      rootDescriptor = openSync("/", fsConstants.O_RDONLY | LINUX_O_DIRECTORY | LINUX_O_CLOEXEC);
      if (intent.helperHandle.released)
        return { ok: false, error: error2("LOCAL_EXPORT_UNAVAILABLE") };
      const spawned = this.spawnProcess("/proc/self/fd/5", [], {
        stdio: ["pipe", "pipe", "pipe", rootDescriptor, "pipe", intent.helperHandle.descriptor],
        windowsHide: true,
        env: { PATH: "/usr/bin:/bin" }
      });
      this.release(intent);
      if (spawned.stdin === null || spawned.stdout === null || spawned.stderr === null || spawned.stdio[4] === null)
        throw new Error("local export helper descriptors unavailable");
      child = spawned;
      control = child.stdio[4];
      child.stdin.on("error", () => void 0);
      const stdoutPromise = collectBoundedV1(
        child,
        child.stdout,
        LOCAL_EXPORT_MAX_STDOUT_BYTES_V1,
        () => {
          overflow = true;
          child?.kill("SIGTERM");
        }
      );
      const stderrPromise = collectBoundedV1(
        child,
        child.stderr,
        LOCAL_EXPORT_MAX_STDERR_BYTES_V1,
        () => {
          overflow = true;
          child?.kill("SIGTERM");
        }
      );
      const exitPromise = waitForExitV1(child);
      const completion = Promise.all([stdoutPromise, stderrPromise, exitPromise]);
      void completion.catch(() => void 0);
      await endWritableV1(
        control,
        encodeLocalExportControlFrameV1(intent, artifact.contentLength),
        signal
      );
      let received = 0;
      const forward = async (bytes2) => {
        received += bytes2.byteLength;
        if (received > artifact.contentLength || received > LOCAL_EXPORT_MAX_BYTES_V1) {
          overflow = true;
          child?.kill("SIGTERM");
          return;
        }
        await writeWithBackpressureV1(child, bytes2, signal);
      };
      await forward(initial);
      while (!overflow) {
        const next = await readNext();
        if (next.done) break;
        await forward(Buffer.from(next.value));
      }
      payloadForwarded = true;
      await endWritableV1(child.stdin, Buffer.alloc(0));
      const [stdout, stderr, exited] = await completion;
      const diagnosticText = new TextDecoder("utf-8", { fatal: true }).decode(stderr);
      if (diagnosticText !== "" && !/^(?:SBEX\/1 io (?:openat|fstat|write|fsync|publish|unlink) errno=[0-9]+\n)+$/u.test(
        diagnosticText
      ))
        return { ok: false, error: error2("LOCAL_EXPORT_CORRUPT") };
      if (overflow || received > artifact.contentLength)
        return { ok: false, error: error2("LOCAL_EXPORT_CORRUPT") };
      if (received < artifact.contentLength)
        return { ok: false, error: error2("LOCAL_EXPORT_SHORT") };
      const line = stdout.toString("ascii");
      const match = /^SBEX\/1 (ok|exists|invalid|unsupported|io|short|corrupt) (0|[1-9][0-9]*)\n$/u.exec(line);
      if (match === null) {
        if (signal?.aborted === true) return { ok: false, error: error2("LOCAL_EXPORT_CANCELLED") };
        return { ok: false, error: error2("LOCAL_EXPORT_CORRUPT") };
      }
      const resultCode = match[1];
      const bytes = Number(match[2]);
      if (resultCode === "ok") {
        if (bytes !== artifact.contentLength)
          return { ok: false, error: error2("LOCAL_EXPORT_CORRUPT") };
        return {
          ok: true,
          value: { format: intent.format, bytes, fileName: intent.displayName }
        };
      }
      if (exited.signal !== null || exited.code !== 0) {
        if (signal?.aborted === true) return { ok: false, error: error2("LOCAL_EXPORT_CANCELLED") };
        return { ok: false, error: error2("LOCAL_EXPORT_CORRUPT") };
      }
      if (signal?.aborted === true) return { ok: false, error: error2("LOCAL_EXPORT_CANCELLED") };
      if (bytes !== 0) return { ok: false, error: error2("LOCAL_EXPORT_CORRUPT") };
      const mapped = {
        exists: "LOCAL_EXPORT_EXISTS",
        invalid: "LOCAL_EXPORT_INVALID_PATH",
        unsupported: "LOCAL_EXPORT_UNAVAILABLE",
        io: "LOCAL_EXPORT_IO",
        short: "LOCAL_EXPORT_SHORT",
        corrupt: "LOCAL_EXPORT_CORRUPT"
      };
      return {
        ok: false,
        error: error2(mapped[resultCode])
      };
    } catch {
      if (child !== void 0)
        await terminateChildV1(child, control, payloadForwarded).catch(() => void 0);
      this.release(intent);
      if (rootDescriptor >= 0) {
        closeSync(rootDescriptor);
        rootDescriptor = -1;
      }
      cancelReaderBestEffortV1(reader);
      return {
        ok: false,
        error: signal?.aborted === true ? error2("LOCAL_EXPORT_CANCELLED") : downloadFailed ? transportErrorV1() : overflow ? error2("LOCAL_EXPORT_CORRUPT") : error2("LOCAL_EXPORT_IO")
      };
    } finally {
      this.release(intent);
      signal?.removeEventListener("abort", abort);
      if (rootDescriptor >= 0) closeSync(rootDescriptor);
      try {
        reader.releaseLock();
      } catch {
        cancelReaderBestEffortV1(reader);
      }
    }
  }
};

// sceneboard-mcp/src/tools/protected-board.gateway.ts
var EXPORT_HTTP_FAILURES_V1 = Object.freeze({
  EXPORT_INVALID_REQUEST: [400, false, "Invalid export request"],
  EXPORT_UNAUTHENTICATED: [401, false, "Authentication is required"],
  EXPORT_FORBIDDEN: [403, false, "Export is not allowed"],
  EXPORT_NOT_FOUND: [404, false, "Board or revision not found"],
  EXPORT_REQUIRED_CONTENT_UNSUPPORTED: [422, false, "Required content cannot be exported"],
  EXPORT_BOUNDS_EXCEEDED: [413, false, "Export bounds exceeded"],
  EXPORT_RATE_LIMITED: [429, true, "Export capacity is temporarily unavailable"],
  EXPORT_RENDERER_UNAVAILABLE: [503, true, "Export renderer is unavailable"],
  EXPORT_RENDER_TIMEOUT: [504, true, "Export timed out"],
  EXPORT_ENCODE_FAILED: [500, true, "Export encoding failed"],
  EXPORT_INTERNAL_ERROR: [500, true, "Export failed"]
});
var EXPORT_PREFLIGHT_FAILURE_CODES_V1 = Object.freeze({
  UNAUTHENTICATED: "EXPORT_UNAUTHENTICATED",
  FORBIDDEN: "EXPORT_FORBIDDEN",
  BOARD_NOT_FOUND: "EXPORT_NOT_FOUND",
  RATE_LIMITED: "EXPORT_RATE_LIMITED",
  SERVICE_UNAVAILABLE: "EXPORT_RENDERER_UNAVAILABLE",
  INTERNAL_ERROR: "EXPORT_INTERNAL_ERROR"
});
var exportPreflightFailureV1 = (value) => {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
  const root = value;
  if (root.ok !== false || Object.hasOwn(root, "source")) return null;
  if (Object.keys(root).sort().join("\0") !== ["error", "ok"].join("\0"))
    return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
  const parsed = BoardErrorParserV1.parse(root.error);
  if (!parsed.ok) return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
  const boardCode = parsed.data.value.code;
  if (!Object.hasOwn(EXPORT_PREFLIGHT_FAILURE_CODES_V1, boardCode))
    return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
  const exportCode = EXPORT_PREFLIGHT_FAILURE_CODES_V1[boardCode];
  const definition = EXPORT_HTTP_FAILURES_V1[exportCode];
  return {
    ok: false,
    source: "board",
    error: {
      code: exportCode,
      message: definition[2],
      retryable: definition[1]
    }
  };
};
var EXPORT_CONTENT_TYPES_V1 = Object.freeze({
  pdf: "application/pdf",
  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
});
var RENAME_TIMESTAMP_PATTERN_V1 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
var canonicalRenameTimestampV1 = (value) => {
  if (typeof value !== "string" || !RENAME_TIMESTAMP_PATTERN_V1.test(value)) return false;
  const instant = Date.parse(value);
  return Number.isFinite(instant) && new Date(instant).toISOString() === value;
};
var EXPORT_PUBLICATION_SETTLEMENT_TIMEOUT_MS_V1 = 1e3;
var gatewayDeadlineV1 = (timeoutMs, callerSignal) => {
  const controller = new AbortController();
  let cause = null;
  const abortFromCaller = () => {
    if (cause !== null) return;
    cause = "caller";
    controller.abort(callerSignal?.reason);
  };
  if (callerSignal?.aborted) abortFromCaller();
  else callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
  const timer = setTimeout(() => {
    if (cause !== null) return;
    cause = "timeout";
    controller.abort(new DOMException("Protected operation deadline exceeded", "TimeoutError"));
  }, timeoutMs);
  return {
    signal: controller.signal,
    cause: () => cause,
    dispose: () => {
      clearTimeout(timer);
      callerSignal?.removeEventListener("abort", abortFromCaller);
    }
  };
};
var waitWithinGatewayDeadlineV1 = async (operation, signal, terminalArbitration) => {
  return new Promise((resolve3, reject) => {
    let settlementTimer = null;
    let awaitingTerminalSettlement = false;
    const cleanup = () => {
      signal.removeEventListener("abort", onAbort);
      if (settlementTimer !== null) clearTimeout(settlementTimer);
    };
    const onAbort = () => {
      if (terminalArbitration?.awaitAfterAbort() === true) {
        awaitingTerminalSettlement = true;
        signal.removeEventListener("abort", onAbort);
        settlementTimer = setTimeout(() => {
          cleanup();
          reject(signal.reason);
        }, terminalArbitration.settlementTimeoutMs);
        return;
      }
      cleanup();
      reject(signal.reason);
    };
    operation.then(
      (value) => {
        cleanup();
        if (signal.aborted && !awaitingTerminalSettlement) reject(signal.reason);
        else resolve3(value);
      },
      (error3) => {
        cleanup();
        reject(error3);
      }
    );
    if (signal.aborted) onAbort();
    else signal.addEventListener("abort", onAbort, { once: true });
  });
};
var sdkDeadlineFailureV1 = (cause, timeoutMs) => ({
  ok: false,
  error: cause === "caller" ? { code: "CANCELLED", retryable: false } : { code: "TIMEOUT", retryable: true, timeoutMs }
});
var connectionDeadlineFailureV1 = (cause, timeoutMs) => cause === "caller" ? { code: "CANCELLED", retryable: false } : { code: "TIMEOUT", retryable: true, timeoutMs };
var ProtectedBoardGatewayV1 = class {
  constructor(options) {
    this.options = options;
  }
  client(snapshot) {
    return new BoardSdkHttpClient({
      baseUrl: this.options.baseUrl,
      fetch: this.options.fetch,
      timeoutPolicy: { timeoutMs: this.options.timeoutMs },
      bearerTokenProvider: () => snapshot.accessToken,
      logger: this.options.logger
    });
  }
  async call(toolOrOperation, operationPlanOrOperation, optionsOrOperation, operationOrUndefined) {
    const toolName = typeof toolOrOperation === "string" ? toolOrOperation : null;
    const requestedOperations = typeof toolOrOperation !== "string" ? null : typeof operationPlanOrOperation === "string" ? [operationPlanOrOperation] : Array.isArray(operationPlanOrOperation) ? operationPlanOrOperation : null;
    const options = typeof toolOrOperation === "string" ? typeof optionsOrOperation === "function" ? { signal: void 0 } : optionsOrOperation ?? { signal: void 0 } : operationPlanOrOperation ?? {
      signal: void 0
    };
    const operation = typeof toolOrOperation === "string" ? typeof optionsOrOperation === "function" ? optionsOrOperation : operationOrUndefined : toolOrOperation;
    if (operation === void 0) return { connected: false };
    return this.callWithinDeadline(
      toolName,
      requestedOperations,
      operation,
      options.signal,
      options.authorization,
      this.options.timeoutMs,
      (cause) => sdkDeadlineFailureV1(cause, this.options.timeoutMs)
    );
  }
  async callWithinDeadline(toolName, requestedOperations, operation, callerSignal, authorization, timeoutMs, deadlineFailure, terminalArbitration) {
    const deadline = gatewayDeadlineV1(timeoutMs, callerSignal);
    try {
      deadline.signal.throwIfAborted();
      const snapshot = await waitWithinGatewayDeadlineV1(
        this.options.tokens.snapshot(deadline.signal),
        deadline.signal
      );
      if (snapshot === null) return { connected: false };
      if (this.options.credentialMode === "api_key") {
        if (toolName === null || requestedOperations === null) return { connected: false };
        const policy2 = accountApiKeyToolPolicyV1(toolName);
        const operationPlan2 = policy2?.operationPlans.find(
          ({ operations }) => operations.length === requestedOperations.length && operations.every((operation2, index) => operation2 === requestedOperations[index])
        );
        if (operationPlan2 === void 0) return { connected: false };
        const targetRequired = operationPlan2.operations.some(
          (requestedOperation) => requestedOperation !== "board.list" && requestedOperation !== "board.create"
        );
        if (targetRequired !== (authorization !== void 0) || authorization !== void 0 && !operationPlan2.operations.includes(authorization.operation))
          return { connected: false };
        const connection = await waitWithinGatewayDeadlineV1(
          new ConnectionHttpClientV1({
            baseUrl: this.options.baseUrl,
            fetch: this.options.fetch,
            timeoutMs,
            logger: this.options.logger,
            ...this.options.now === void 0 ? {} : { now: this.options.now }
          }).get(
            authorization?.boardId ?? null,
            randomBytes7(16).toString("base64url"),
            snapshot.accessToken,
            deadline.signal,
            "api_key",
            authorization?.operation
          ),
          deadline.signal
        );
        const preflightCause = deadline.cause();
        if (preflightCause !== null)
          return { connected: true, value: deadlineFailure(preflightCause) };
        if (!connection.ok) {
          if (connection.source === "board") {
            if (connection.error.code === "UNAUTHENTICATED")
              await waitWithinGatewayDeadlineV1(
                this.options.tokens.invalidate(snapshot, deadline.signal),
                deadline.signal
              );
            return {
              connected: true,
              value: { ok: false, error: connection.error }
            };
          }
          return { connected: false };
        }
        const credential = "credential" in connection.value ? connection.value.credential : null;
        if (credential === null || !operationPlan2.scopes.every((scope) => credential.scopes.includes(scope)))
          return {
            connected: true,
            value: {
              ok: false,
              error: {
                protocolVersion: 1,
                type: "board.error",
                code: "FORBIDDEN",
                message: "Insufficient API key scope",
                category: "auth",
                retryable: false,
                httpStatusHint: 403,
                details: null
              }
            }
          };
      }
      const client = this.client(snapshot);
      const value = await waitWithinGatewayDeadlineV1(
        operation(client, snapshot, deadline.signal),
        deadline.signal,
        terminalArbitration
      );
      const operationCause = deadline.cause();
      if (operationCause !== null && terminalArbitration?.acceptAfterAbort(value) !== true)
        return { connected: true, value: deadlineFailure(operationCause) };
      if (value !== null && typeof value === "object" && "ok" in value && value.ok === false && "error" in value && value.error !== null && typeof value.error === "object" && "code" in value.error && value.error.code === "UNAUTHENTICATED") {
        await waitWithinGatewayDeadlineV1(
          this.options.tokens.invalidate(snapshot, deadline.signal),
          deadline.signal
        );
      }
      return { connected: true, value };
    } catch (error3) {
      const cause = deadline.cause();
      if (cause !== null) return { connected: true, value: deadlineFailure(cause) };
      throw error3;
    } finally {
      deadline.dispose();
    }
  }
  async renameBoard(input) {
    const result = await this.callWithinDeadline(
      "board_rename",
      ["board.rename"],
      async (_client, snapshot, signal) => {
        let response;
        try {
          response = await this.options.fetch(
            new URL(
              `/api/v1/boards/${encodeURIComponent(input.boardId)}/title`,
              this.options.baseUrl
            ),
            {
              method: "POST",
              redirect: "manual",
              headers: {
                Accept: "application/json",
                Authorization: `Bearer ${snapshot.accessToken}`,
                "Content-Type": "application/json; charset=utf-8"
              },
              body: JSON.stringify({ title: input.title }),
              signal
            }
          );
        } catch {
          return {
            ok: false,
            source: "local",
            error: { code: "TRANSPORT_ERROR" }
          };
        }
        if (response.redirected || response.status >= 300 && response.status < 400 || response.headers.get("content-type")?.toLowerCase() !== "application/json; charset=utf-8") {
          await response.body?.cancel().catch(() => void 0);
          return {
            ok: false,
            source: "local",
            error: { code: "RESPONSE_INVALID" }
          };
        }
        const bytes = await BoardSdkHttpClient.readBoundedResponseBodyV1(
          response,
          response.status === 200 ? 65536 : 65536,
          signal
        );
        if (bytes === "body_too_large" || bytes === "response")
          return {
            ok: false,
            source: "local",
            error: { code: "RESPONSE_INVALID" }
          };
        const parsed = BoardSdkHttpClient.parseStrictJsonBytesV1(bytes);
        if (!parsed.ok)
          return {
            ok: false,
            source: "local",
            error: { code: "RESPONSE_INVALID" }
          };
        if (response.status !== 200) {
          const body = parsed.value !== null && typeof parsed.value === "object" && !Array.isArray(parsed.value) && Object.keys(parsed.value).length === 1 ? parsed.value.error : null;
          const error3 = BoardErrorParserV1.parse(body);
          if (!error3.ok || error3.data.value.httpStatusHint !== response.status)
            return {
              ok: false,
              source: "local",
              error: { code: "RESPONSE_INVALID" }
            };
          return { ok: false, source: "board", error: error3.data.value };
        }
        const value = parsed.value !== null && typeof parsed.value === "object" && !Array.isArray(parsed.value) ? parsed.value : null;
        if (value === null || Object.keys(value).sort().join("\0") !== ["boardId", "title", "updatedAt"].join("\0") || value.boardId !== input.boardId || value.title !== input.title || !canonicalRenameTimestampV1(value.updatedAt))
          return {
            ok: false,
            source: "local",
            error: { code: "RESPONSE_INVALID" }
          };
        return {
          ok: true,
          value: {
            boardId: value.boardId,
            title: value.title,
            updatedAt: value.updatedAt
          }
        };
      },
      input.signal,
      { boardId: input.boardId, operation: "board.rename" },
      this.options.timeoutMs,
      (cause) => ({
        ok: false,
        source: "local",
        error: cause === "caller" ? { code: "CANCELLED" } : { code: "TIMEOUT", timeoutMs: this.options.timeoutMs }
      })
    );
    const rawValue = result.connected ? result.value : null;
    const rawError = rawValue !== null && rawValue.ok === false && !Object.hasOwn(rawValue, "source") && rawValue.error !== null && typeof rawValue.error === "object" ? rawValue.error : null;
    if (rawError !== null && "protocolVersion" in rawError)
      return {
        connected: true,
        value: {
          ok: false,
          source: "board",
          error: rawError
        }
      };
    return result;
  }
  async exportBoard(input) {
    let publicationStarted = false;
    const result = await this.callWithinDeadline(
      "board_export",
      ["export.render"],
      async (_client, snapshot, signal) => {
        let response;
        try {
          response = await this.options.fetch(
            new URL(
              `/api/v1/boards/${encodeURIComponent(input.boardId)}/exports`,
              this.options.baseUrl
            ),
            {
              method: "POST",
              redirect: "manual",
              headers: {
                Accept: EXPORT_CONTENT_TYPES_V1[input.format],
                Authorization: `Bearer ${snapshot.accessToken}`,
                "Content-Type": "application/json; charset=utf-8"
              },
              body: JSON.stringify({
                format: input.format,
                revisionId: input.revisionId
              }),
              signal
            }
          );
        } catch {
          if (input.signal?.aborted === true)
            return { ok: false, source: "local", error: { code: "CANCELLED" } };
          if (signal.aborted)
            return {
              ok: false,
              source: "local",
              error: { code: "TIMEOUT", timeoutMs: 12e4 }
            };
          return { ok: false, source: "local", error: { code: "TRANSPORT_ERROR" } };
        }
        if (response.redirected || response.status >= 300 && response.status < 400) {
          await response.body?.cancel().catch(() => void 0);
          return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
        }
        const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
        if (response.status === 200) {
          const contentLengthText = response.headers.get("content-length");
          const contentLength = contentLengthText !== null && /^(?:[1-9][0-9]*)$/u.test(contentLengthText) ? Number(contentLengthText) : Number.NaN;
          if (contentType !== EXPORT_CONTENT_TYPES_V1[input.format] || !Number.isSafeInteger(contentLength) || contentLength < 1 || contentLength > LOCAL_EXPORT_MAX_BYTES_V1 || response.body === null) {
            await response.body?.cancel().catch(() => void 0);
            return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
          }
          publicationStarted = true;
          const published = await input.publish(
            {
              format: input.format,
              contentType,
              contentLength,
              body: response.body
            },
            signal
          );
          return published.ok ? published : { ok: false, source: "publication", error: published.error };
        }
        if (contentType !== "application/json; charset=utf-8") {
          await response.body?.cancel().catch(() => void 0);
          return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
        }
        const bytes = await BoardSdkHttpClient.readBoundedResponseBodyV1(response, 65536, signal);
        if (bytes === "response") {
          if (input.signal?.aborted === true)
            return { ok: false, source: "local", error: { code: "CANCELLED" } };
          if (signal.aborted)
            return {
              ok: false,
              source: "local",
              error: { code: "TIMEOUT", timeoutMs: 12e4 }
            };
          return { ok: false, source: "local", error: { code: "TRANSPORT_ERROR" } };
        }
        if (bytes === "body_too_large")
          return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
        const parsed = BoardSdkHttpClient.parseStrictJsonBytesV1(bytes);
        const root = parsed.ok && parsed.value !== null && typeof parsed.value === "object" && !Array.isArray(parsed.value) ? parsed.value : null;
        const rawError = root !== null && Object.keys(root).sort().join("\0") === ["error", "ok"].join("\0") && root.ok === false && root.error !== null && typeof root.error === "object" && !Array.isArray(root.error) ? root.error : null;
        const definition = rawError !== null && typeof rawError.code === "string" && Object.hasOwn(EXPORT_HTTP_FAILURES_V1, rawError.code) ? EXPORT_HTTP_FAILURES_V1[rawError.code] : null;
        if (rawError === null || Object.keys(rawError).sort().join("\0") !== ["code", "message", "retryable"].join("\0") || typeof rawError.code !== "string" || definition === null || definition[0] !== response.status || rawError.retryable !== definition[1] || rawError.message !== definition[2])
          return { ok: false, source: "local", error: { code: "RESPONSE_INVALID" } };
        if (rawError.code === "EXPORT_UNAUTHENTICATED")
          await this.options.tokens.invalidate(snapshot, signal);
        return {
          ok: false,
          source: "board",
          error: {
            code: rawError.code,
            message: definition[2],
            retryable: definition[1]
          }
        };
      },
      input.signal,
      { boardId: input.boardId, operation: "export.render" },
      this.options.exportTimeoutMs ?? 12e4,
      (cause) => ({
        ok: false,
        source: "local",
        error: cause === "caller" ? { code: "CANCELLED" } : { code: "TIMEOUT", timeoutMs: 12e4 }
      }),
      {
        awaitAfterAbort: () => publicationStarted,
        acceptAfterAbort: (value) => value.ok,
        settlementTimeoutMs: EXPORT_PUBLICATION_SETTLEMENT_TIMEOUT_MS_V1
      }
    );
    if (!result.connected) return result;
    const preflightFailure = exportPreflightFailureV1(result.value);
    return preflightFailure === null ? result : { connected: true, value: preflightFailure };
  }
  async withAuthorizedBoardOperation(input, operation) {
    const deadline = gatewayDeadlineV1(this.options.timeoutMs, input.signal);
    try {
      let rawSnapshot;
      try {
        deadline.signal.throwIfAborted();
        rawSnapshot = await waitWithinGatewayDeadlineV1(
          this.options.tokens.snapshot(deadline.signal),
          deadline.signal
        );
      } catch {
        const cause = deadline.cause();
        if (cause !== null)
          return {
            authorized: false,
            reason: "local",
            error: connectionDeadlineFailureV1(cause, this.options.timeoutMs)
          };
        return { authorized: false, reason: "credential_unavailable" };
      }
      if (rawSnapshot === null) return { authorized: false, reason: "not_connected" };
      if (rawSnapshot.version !== 1 || typeof rawSnapshot.generation !== "string" || !GENERATION_PATTERN_V1.test(rawSnapshot.generation) || typeof rawSnapshot.accessToken !== "string" || this.options.credentialMode !== "api_key" && !ACCESS_TOKEN_PATTERN_V1.test(rawSnapshot.accessToken))
        return { authorized: false, reason: "credential_unavailable" };
      const snapshot = Object.freeze({ ...rawSnapshot });
      const credentialMode = this.options.credentialMode ?? "pairing";
      const requestedOperations = input.apiKeyOperationPlan === void 0 ? null : typeof input.apiKeyOperationPlan === "string" ? [input.apiKeyOperationPlan] : input.apiKeyOperationPlan;
      const apiKeyPolicy = input.apiKeyToolName === void 0 ? null : accountApiKeyToolPolicyV1(input.apiKeyToolName);
      const apiKeyPlan = apiKeyPolicy?.operationPlans.find(
        ({ operations }) => requestedOperations !== null && operations.length === requestedOperations.length && operations.every((operation2, index) => operation2 === requestedOperations[index])
      );
      if (credentialMode === "api_key" && (apiKeyPlan === void 0 || input.apiKeyAuthorizationOperation === void 0 || !apiKeyPlan.operations.includes(input.apiKeyAuthorizationOperation)))
        return { authorized: false, reason: "credential_unavailable" };
      const connection = await waitWithinGatewayDeadlineV1(
        new ConnectionHttpClientV1({
          baseUrl: this.options.baseUrl,
          fetch: this.options.fetch,
          timeoutMs: this.options.timeoutMs,
          logger: this.options.logger,
          ...this.options.now === void 0 ? {} : { now: this.options.now }
        }).get(
          input.boardId,
          input.requestId,
          snapshot.accessToken,
          deadline.signal,
          credentialMode,
          credentialMode === "api_key" ? input.apiKeyAuthorizationOperation : void 0
        ),
        deadline.signal
      );
      const connectionCause = deadline.cause();
      if (connectionCause !== null)
        return {
          authorized: false,
          reason: "local",
          error: connectionDeadlineFailureV1(connectionCause, this.options.timeoutMs)
        };
      if (!connection.ok) {
        if (connection.source === "board") {
          if (connection.error.code === "UNAUTHENTICATED")
            await waitWithinGatewayDeadlineV1(
              this.options.tokens.invalidate(snapshot, deadline.signal),
              deadline.signal
            );
          return { authorized: false, reason: "board", error: connection.error };
        }
        return { authorized: false, reason: "local", error: connection.error };
      }
      if (credentialMode === "api_key") {
        const credential = "credential" in connection.value ? connection.value.credential : null;
        if (credential === null || apiKeyPlan === void 0 || !apiKeyPlan.scopes.every((scope) => credential.scopes.includes(scope)))
          return {
            authorized: false,
            reason: "board",
            error: {
              protocolVersion: 1,
              type: "board.error",
              code: "FORBIDDEN",
              message: "Insufficient API key scope",
              category: "auth",
              retryable: false,
              httpStatusHint: 403,
              details: null
            }
          };
      } else {
        if (!("grant" in connection.value))
          return { authorized: false, reason: "credential_unavailable" };
        const selected = connection.value.selectedBoard;
        const grant = connection.value.grant;
        if (selected === null || !input.requiredCapabilities.every(
          (capability) => grant.scopes.includes(capability) && selected.capabilities.grantedCapabilities.includes(capability)
        ))
          return {
            authorized: false,
            reason: "board",
            error: {
              protocolVersion: 1,
              type: "board.error",
              code: "BOARD_NOT_FOUND",
              message: "Board not found",
              category: "not_found",
              retryable: false,
              httpStatusHint: 404,
              details: null
            }
          };
      }
      const value = await waitWithinGatewayDeadlineV1(
        operation({
          snapshot,
          client: this.client(snapshot),
          media: new ConnectionMediaHttpClientV1({
            baseUrl: this.options.baseUrl,
            fetch: this.options.fetch,
            timeoutMs: this.options.timeoutMs,
            logger: this.options.logger
          }),
          signal: deadline.signal
        }),
        deadline.signal
      );
      const operationCause = deadline.cause();
      if (operationCause !== null)
        return {
          authorized: false,
          reason: "local",
          error: connectionDeadlineFailureV1(operationCause, this.options.timeoutMs)
        };
      return { authorized: true, value };
    } catch (error3) {
      const cause = deadline.cause();
      if (cause !== null)
        return {
          authorized: false,
          reason: "local",
          error: connectionDeadlineFailureV1(cause, this.options.timeoutMs)
        };
      throw error3;
    } finally {
      deadline.dispose();
    }
  }
};

// sceneboard-mcp/src/tools/register-tools.ts
import { randomBytes as randomBytes10 } from "node:crypto";

// packages/board-sdk/src/document-transform/document-transform.ts
var invalidDocument3 = (path, reason) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "INVALID_DOCUMENT",
  message: "Invalid document",
  category: "validation",
  retryable: false,
  httpStatusHint: 422,
  details: { path, reason }
});
var failed = (error3) => ({ ok: false, error: error3 });
var exactKeys = (value, keys) => {
  const actual = Object.keys(value).sort();
  const expected = [...keys].sort();
  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
};
var safeIndex = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
var pageIndex = (document, pageId) => document.pages.findIndex((page) => page.pageId === pageId);
var finiteCanvasPlacement = (placement) => Number.isFinite(placement.x) && Number.isFinite(placement.y) && Number.isFinite(placement.width) && Number.isFinite(placement.height) && placement.x >= 0 && placement.y >= 0 && placement.width > 0 && placement.height > 0 && Number.isSafeInteger(placement.zIndex);
var placeMediaImageOnPageV2 = (input) => {
  const source = BoardDocumentParserV2.parse(input.document);
  if (!source.ok) return source;
  const current = source.data.value;
  const index = pageIndex(current, input.pageId);
  if (index < 0) return failed(invalidDocument3(["pageId"], "unresolved_reference"));
  if (input.image.type !== "content.image" || input.image.source.type !== "media")
    return failed(invalidDocument3(["image"], "limit"));
  const ids = new Set(collectDocumentNodesV2(current).map(({ node }) => node.id));
  if (ids.has(input.image.id)) return failed(invalidDocument3(["image", "id"], "limit"));
  if (input.placement.kind === "page-end" && (input.placement.wrapperNodeId === input.image.id || ids.has(input.placement.wrapperNodeId)))
    return failed(invalidDocument3(["placement", "wrapperNodeId"], "limit"));
  const page = current.pages[index];
  if (page === void 0) return failed(invalidDocument3(["pageId"], "unresolved_reference"));
  const root = page.scene.root;
  let nextRoot;
  if (root?.type === "layout.canvas") {
    if (input.placement.kind !== "canvas" || !finiteCanvasPlacement(input.placement))
      return failed(invalidDocument3(["placement"], "limit"));
    if (root.children.length >= BOARD_LIMITS_V1.maxCanvasItems)
      return failed(invalidDocument3(["placement"], "limit"));
    if (input.placement.x + input.placement.width > root.width || input.placement.y + input.placement.height > root.height)
      return failed(invalidDocument3(["placement"], "limit"));
    nextRoot = {
      ...root,
      children: [
        ...root.children,
        {
          node: input.image,
          x: input.placement.x,
          y: input.placement.y,
          width: input.placement.width,
          height: input.placement.height,
          zIndex: input.placement.zIndex
        }
      ]
    };
  } else {
    if (input.placement.kind !== "page-end") return failed(invalidDocument3(["placement"], "limit"));
    if (root === null) nextRoot = input.image;
    else if (root.type === "layout.split" && root.direction === "vertical") {
      if (root.children.length >= BOARD_LIMITS_V1.maxSplitChildren)
        return failed(invalidDocument3(["placement"], "limit"));
      nextRoot = {
        ...root,
        children: [...root.children, { node: input.image, weight: 1 }]
      };
    } else {
      nextRoot = {
        id: input.placement.wrapperNodeId,
        type: "layout.split",
        direction: "vertical",
        gap: 16,
        children: [
          { node: root, weight: 1 },
          { node: input.image, weight: 1 }
        ]
      };
    }
  }
  const pages = [...current.pages];
  pages[index] = { ...page, scene: { ...page.scene, root: nextRoot } };
  return BoardDocumentParserV2.parse({ ...current, pages });
};
function placeMediaImageOnPageV1(input) {
  if (input.document.schemaVersion === 2) return placeMediaImageOnPageV2(input);
  const source = BoardDocumentParserV3.parse(input.document);
  if (!source.ok) return source;
  const transformed = placeMediaImageOnPageV2({
    ...input,
    document: projectDocumentV3ToV2(source.data.value)
  });
  if (!transformed.ok) return transformed;
  return BoardDocumentParserV3.parse(
    projectDocumentV2ToV3(transformed.data.value, source.data.value.format)
  );
}
var applyDocumentTransformV2 = (source, operation) => {
  const document = BoardDocumentParserV2.parse(source);
  if (!document.ok) return document;
  if (operation === null || typeof operation !== "object" || Array.isArray(operation))
    return failed(invalidDocument3(["operation"], "limit"));
  if (operation.type === "document.replace") {
    if (!exactKeys(operation, ["type", "document"]))
      return failed(invalidDocument3(["operation"], "limit"));
    return BoardDocumentParserV2.parse(operation.document);
  }
  const current = document.data.value;
  if (operation.type === "page.add") {
    if (!exactKeys(operation, ["type", "page", "index"]) || !safeIndex(operation.index))
      return failed(invalidDocument3(["operation", "index"], "limit"));
    if (operation.index > current.pages.length)
      return failed(invalidDocument3(["operation", "index"], "page_count"));
    const pages = [...current.pages];
    pages.splice(operation.index, 0, operation.page);
    return BoardDocumentParserV2.parse({ ...current, pages });
  }
  if (operation.type === "page.remove") {
    if (!exactKeys(operation, ["type", "pageId"]))
      return failed(invalidDocument3(["operation"], "limit"));
    const index = pageIndex(current, operation.pageId);
    if (index < 0) return failed(invalidDocument3(["operation", "pageId"], "unresolved_reference"));
    if (current.pages.length === 1)
      return failed(invalidDocument3(["operation", "pageId"], "page_count"));
    if (operation.pageId === current.defaultPageId)
      return failed(invalidDocument3(["operation", "pageId"], "default_page_missing"));
    return BoardDocumentParserV2.parse({
      ...current,
      pages: current.pages.filter((_, pagePosition) => pagePosition !== index)
    });
  }
  if (operation.type === "page.reorder") {
    if (!exactKeys(operation, ["type", "pageId", "toIndex"]) || !safeIndex(operation.toIndex) || operation.toIndex >= current.pages.length)
      return failed(invalidDocument3(["operation", "toIndex"], "page_count"));
    const index = pageIndex(current, operation.pageId);
    if (index < 0) return failed(invalidDocument3(["operation", "pageId"], "unresolved_reference"));
    if (index === operation.toIndex) return document;
    const pages = [...current.pages];
    const [selected] = pages.splice(index, 1);
    if (selected === void 0) return failed(invalidDocument3(["operation", "pageId"], "limit"));
    pages.splice(operation.toIndex, 0, selected);
    return BoardDocumentParserV2.parse({ ...current, pages });
  }
  if (operation.type === "page.update") {
    const allowed = /* @__PURE__ */ new Set(["type", "pageId", "title", "displayMode", "scene"]);
    const keys = Object.keys(operation);
    if (keys.some((key) => !allowed.has(key)) || !Object.hasOwn(operation, "pageId") || !Object.hasOwn(operation, "type") || !["title", "displayMode", "scene"].some((key) => Object.hasOwn(operation, key)))
      return failed(invalidDocument3(["operation"], "limit"));
    const index = pageIndex(current, operation.pageId);
    if (index < 0) return failed(invalidDocument3(["operation", "pageId"], "unresolved_reference"));
    const existing2 = current.pages[index];
    if (existing2 === void 0)
      return failed(invalidDocument3(["operation", "pageId"], "unresolved_reference"));
    const updated = {
      ...existing2,
      ...operation.title === void 0 ? {} : { title: operation.title },
      ...operation.displayMode === void 0 ? {} : { displayMode: operation.displayMode },
      ...operation.scene === void 0 ? {} : { scene: operation.scene }
    };
    const pages = [...current.pages];
    pages[index] = updated;
    return BoardDocumentParserV2.parse({ ...current, pages });
  }
  if (operation.type === "page.default.set") {
    if (!exactKeys(operation, ["type", "pageId"]))
      return failed(invalidDocument3(["operation"], "limit"));
    if (pageIndex(current, operation.pageId) < 0)
      return failed(invalidDocument3(["operation", "pageId"], "unresolved_reference"));
    return BoardDocumentParserV2.parse({ ...current, defaultPageId: operation.pageId });
  }
  return failed(invalidDocument3(["operation", "type"], "limit"));
};

// sceneboard-mcp/src/tools/tool-schemas.ts
import { randomBytes as randomBytes8 } from "node:crypto";
var GlobalIdSchemaV1 = external_exports.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
var IdempotencyKeySchemaV12 = external_exports.string().min(16).max(128).regex(/^[A-Za-z0-9._:-]+$/);
var ShortTextSchemaV12 = external_exports.string().refine((value) => {
  const length = [...value].length;
  return length >= 1 && length <= 200 && !/[\u0000-\u001f\u007f-\u009f\uD800-\uDFFF]/u.test(value);
});
var LocalIdSchema = external_exports.string().regex(/^[A-Za-z][A-Za-z0-9_-]{0,63}$/);
var PlacementSchema = external_exports.discriminatedUnion("parentType", [
  external_exports.object({ parentType: external_exports.literal("layout.split"), weight: external_exports.number().finite().positive() }).strict(),
  external_exports.object({
    parentType: external_exports.literal("layout.grid"),
    column: external_exports.number().int().positive(),
    row: external_exports.number().int().positive(),
    columnSpan: external_exports.number().int().positive(),
    rowSpan: external_exports.number().int().positive()
  }).strict(),
  external_exports.object({
    parentType: external_exports.literal("layout.tabs"),
    tabId: LocalIdSchema,
    label: ShortTextSchemaV12
  }).strict(),
  external_exports.object({
    parentType: external_exports.literal("layout.canvas"),
    x: external_exports.number().finite().nonnegative(),
    y: external_exports.number().finite().nonnegative(),
    width: external_exports.number().finite().positive(),
    height: external_exports.number().finite().positive(),
    zIndex: external_exports.number().int().safe()
  }).strict()
]);
var SceneTransformOperationSchemaV1 = external_exports.discriminatedUnion("type", [
  external_exports.object({ type: external_exports.literal("replace_root"), root: external_exports.unknown().nullable() }).strict(),
  external_exports.object({ type: external_exports.literal("replace_node"), nodeId: LocalIdSchema, node: external_exports.unknown() }).strict(),
  external_exports.object({ type: external_exports.literal("remove_node"), nodeId: LocalIdSchema }).strict(),
  external_exports.object({
    type: external_exports.literal("insert_child"),
    parentNodeId: LocalIdSchema,
    index: external_exports.number().int().safe().nonnegative(),
    node: external_exports.unknown(),
    placement: PlacementSchema
  }).strict(),
  external_exports.object({
    type: external_exports.literal("move_child"),
    sourceParentNodeId: LocalIdSchema,
    destinationParentNodeId: LocalIdSchema,
    nodeId: LocalIdSchema,
    destinationIndex: external_exports.number().int().safe().nonnegative(),
    placement: PlacementSchema
  }).strict(),
  external_exports.object({
    type: external_exports.literal("set_split_weight"),
    splitNodeId: LocalIdSchema,
    childNodeId: LocalIdSchema,
    weight: external_exports.number().finite().positive()
  }).strict(),
  external_exports.object({
    type: external_exports.literal("set_grid_placement"),
    gridNodeId: LocalIdSchema,
    childNodeId: LocalIdSchema,
    column: external_exports.number().int().positive(),
    row: external_exports.number().int().positive(),
    columnSpan: external_exports.number().int().positive(),
    rowSpan: external_exports.number().int().positive()
  }).strict(),
  external_exports.object({
    type: external_exports.literal("set_canvas_rect"),
    canvasNodeId: LocalIdSchema,
    childNodeId: LocalIdSchema,
    x: external_exports.number().finite().nonnegative(),
    y: external_exports.number().finite().nonnegative(),
    width: external_exports.number().finite().positive(),
    height: external_exports.number().finite().positive(),
    zIndex: external_exports.number().int().safe()
  }).strict(),
  external_exports.object({ type: external_exports.literal("set_active_tab"), tabsNodeId: LocalIdSchema, tabId: LocalIdSchema }).strict(),
  external_exports.object({
    type: external_exports.literal("upsert_drawing_element"),
    drawingNodeId: LocalIdSchema,
    element: external_exports.unknown()
  }).strict(),
  external_exports.object({
    type: external_exports.literal("remove_drawing_element"),
    drawingNodeId: LocalIdSchema,
    elementId: LocalIdSchema
  }).strict()
]);
var descriptorInputSchemaV1 = (schema) => {
  const descriptor = Object.create(schema);
  Object.defineProperty(descriptor, "safeParseAsync", {
    value: async (input) => ({ success: true, data: input })
  });
  return descriptor;
};
var createRequestIdV1 = () => randomBytes8(16).toString("base64url");

// sceneboard-mcp/src/tools/tool-result.ts
var GlobalIdSchema2 = external_exports.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
var LOCAL_ERROR_CODES_V1 = [
  "BOARD_MCP_INPUT_INVALID",
  "BOARD_MCP_CONFIG_INVALID",
  "BOARD_MCP_CREDENTIAL_UNAVAILABLE",
  "BOARD_MCP_PROFILE_BUSY",
  "BOARD_MCP_PROFILE_LEASE_CORRUPT",
  "BOARD_MCP_NOT_CONNECTED",
  "BOARD_MCP_PAIRING_STATE_LOST",
  "BOARD_MCP_PAIRING_CLAIM_OUTCOME_UNKNOWN",
  "BOARD_MCP_PAIRING_CREDENTIAL_UNRECOVERABLE",
  "BOARD_MCP_TRANSPORT_ERROR",
  "BOARD_MCP_TIMEOUT",
  "BOARD_MCP_CANCELLED",
  "BOARD_MCP_RESPONSE_INVALID",
  "BOARD_MCP_LOCAL_FILE_CHANGED",
  "BOARD_MCP_LOCAL_FILE_PLATFORM_UNSUPPORTED",
  "BOARD_MCP_LOCAL_FILE_TOO_LARGE",
  "BOARD_MCP_LOCAL_MEDIA_UNSUPPORTED",
  "LOCAL_EXPORT_UNAVAILABLE",
  "LOCAL_EXPORT_INVALID_PATH",
  "LOCAL_EXPORT_EXISTS",
  "LOCAL_EXPORT_IO",
  "LOCAL_EXPORT_SHORT",
  "LOCAL_EXPORT_CORRUPT",
  "LOCAL_EXPORT_CANCELLED",
  "BOARD_MCP_INTERNAL_ERROR"
];
var GENERIC_LOCAL_ERROR_CODES_V1 = LOCAL_ERROR_CODES_V1.filter(
  (code) => code !== "BOARD_MCP_LOCAL_FILE_CHANGED" && code !== "BOARD_MCP_LOCAL_FILE_PLATFORM_UNSUPPORTED" && code !== "BOARD_MCP_LOCAL_FILE_TOO_LARGE" && code !== "BOARD_MCP_LOCAL_MEDIA_UNSUPPORTED"
);
var D1_RESULT_TYPES_V1 = {
  board_list: ["board.list"],
  board_get: ["board.get"],
  board_create: ["board.create"],
  board_archive: ["board.archive"],
  board_capabilities_get: ["capabilities.get"],
  board_scene_get: ["board.get", "history.get"],
  board_scene_replace: ["scene.replace"],
  board_scene_patch: ["scene.replace"],
  board_scene_clear: ["scene.clear"],
  board_document_get: ["board.get", "history.get"],
  board_document_replace: ["document.replace"],
  board_page_add: ["document.replace"],
  board_page_remove: ["document.replace"],
  board_page_reorder: ["document.replace"],
  board_page_update: ["document.replace"],
  board_page_default_set: ["document.replace"],
  board_artifact_get: ["artifact.get"],
  board_artifact_put: ["artifact.publish"],
  board_artifact_stop: ["artifact.stop"],
  board_history_list: ["history.list"],
  board_history_get: ["history.get"],
  board_history_restore: ["scene.restore"],
  board_interaction_request: ["hitl.request"],
  board_interaction_status: ["hitl.read"],
  board_interaction_respond: ["hitl.respond"],
  sceneboard_media_upload: ["media.ingest.result"],
  sceneboard_media_place: ["document.replace"]
};
var LOCAL_EXPORT_MESSAGES_V1 = Object.freeze({
  LOCAL_EXPORT_UNAVAILABLE: "Secure local export is unavailable on this platform",
  LOCAL_EXPORT_INVALID_PATH: "Local export path is invalid",
  LOCAL_EXPORT_EXISTS: "Local export target already exists",
  LOCAL_EXPORT_IO: "Local export could not be published",
  LOCAL_EXPORT_SHORT: "Export download ended before completion",
  LOCAL_EXPORT_CORRUPT: "Export download or local helper response is invalid",
  LOCAL_EXPORT_CANCELLED: "Local export was cancelled"
});
var TIMESTAMP_PATTERN_V1 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
var PROFILE_PATTERN_V1 = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
var exactKeysV1 = (value, keys) => {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
  const actual = Object.keys(value).sort();
  const expected = [...keys].sort();
  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
};
var canonicalTimestampV1 = (value) => {
  if (typeof value !== "string" || !TIMESTAMP_PATTERN_V1.test(value)) return false;
  const instant = Date.parse(value);
  return Number.isFinite(instant) && new Date(instant).toISOString() === value;
};
var canonicalBaseOriginV1 = (value) => {
  if (typeof value !== "string" || value.length < 1 || value.length > 2048) return false;
  try {
    const url = new URL(value);
    const loopback = url.hostname === "127.0.0.1" || url.hostname === "[::1]" || url.hostname === "::1";
    return url.origin === value && url.pathname === "/" && url.username === "" && url.password === "" && url.search === "" && url.hash === "" && (url.protocol === "https:" || url.protocol === "http:" && loopback);
  } catch {
    return false;
  }
};
var connectionBoardIdV1 = (connection) => {
  if (!exactKeysV1(connection.selectedBoard, ["board", "capabilities"])) return null;
  const board = connection.selectedBoard.board;
  return exactKeysV1(board, [
    "boardId",
    "title",
    "createdAt",
    "updatedAt",
    "archivedAt",
    "headRevision"
  ]) && typeof board.boardId === "string" ? board.boardId : null;
};
var exactPairingConfigV1 = (value) => exactKeysV1(value, ["source", "profile", "baseOrigin", "timeoutMs", "hasToken"]) && [
  "process_option",
  "board_config_env",
  "nearest_board_file",
  "user_config_file",
  "environment"
].includes(String(value.source)) && typeof value.profile === "string" && PROFILE_PATTERN_V1.test(value.profile) && canonicalBaseOriginV1(value.baseOrigin) && Number.isSafeInteger(value.timeoutMs) && Number(value.timeoutMs) >= 1e3 && Number(value.timeoutMs) <= 12e4 && typeof value.hasToken === "boolean";
var exactConnectionStatusResultV1 = (value, requestId) => {
  if (value.credentialMode === "api_key") {
    if (!exactKeysV1(value, [
      "credentialMode",
      "state",
      "config",
      "connection",
      "lastErrorCode",
      "retryable"
    ]) || !exactKeysV1(value.config, ["source", "referenceConfigured"]) || value.config.source !== "env" && value.config.source !== "private_store" || typeof value.config.referenceConfigured !== "boolean" || typeof value.retryable !== "boolean")
      return false;
    if (value.state === "connected") {
      if (value.config.referenceConfigured !== true || value.lastErrorCode !== null || value.retryable !== false || !exactKeysV1(value.connection, ["principal", "credential", "selectedBoard", "versions"]))
        return false;
      return parseAuthorizedConnectionProjectionV1(
        value.connection,
        requestId,
        connectionBoardIdV1(value.connection),
        "api_key"
      ) !== null;
    }
    if (value.connection !== null) return false;
    if (value.state === "credential_missing")
      return value.config.referenceConfigured === false && value.lastErrorCode === "API_KEY_CREDENTIAL_MISSING" && value.retryable === false;
    if (value.state === "credential_invalid")
      return value.config.referenceConfigured === true && value.lastErrorCode === "API_KEY_CREDENTIAL_INVALID" && value.retryable === false;
    return value.state === "backend_unavailable" && value.config.referenceConfigured === true && (value.lastErrorCode === "API_KEY_BACKEND_UNAVAILABLE" || value.lastErrorCode === "API_KEY_BACKEND_RESPONSE_INVALID") && value.retryable === true;
  }
  if (!exactKeysV1(value, ["state", "config", "connection", "lastErrorCode"])) return false;
  if (value.state === "not_configured")
    return value.config === null && value.connection === null && value.lastErrorCode === "BOARD_MCP_CONFIG_INVALID";
  if (!exactPairingConfigV1(value.config)) return false;
  if (value.state === "connected") {
    if (value.config.hasToken !== true || value.lastErrorCode !== null || !exactKeysV1(value.connection, ["principal", "grant", "selectedBoard", "versions"]))
      return false;
    const selectedBoard = value.connection.selectedBoard;
    const boardId = exactKeysV1(selectedBoard, ["board", "capabilities", "browserPresence", "capabilityEpoch"]) && exactKeysV1(selectedBoard.board, [
      "boardId",
      "title",
      "createdAt",
      "updatedAt",
      "archivedAt",
      "headRevision"
    ]) && typeof selectedBoard.board.boardId === "string" ? selectedBoard.board.boardId : null;
    return parseAuthorizedConnectionProjectionV1(value.connection, requestId, boardId, "pairing") !== null;
  }
  if (value.connection !== null) return false;
  if (value.state === "credential_missing")
    return value.config.hasToken === false && value.lastErrorCode === null;
  if (value.state === "credential_invalid")
    return value.config.hasToken === false && value.lastErrorCode === "UNAUTHENTICATED";
  return value.state === "backend_unavailable" && (value.lastErrorCode === "BOARD_MCP_TIMEOUT" || value.lastErrorCode === "BOARD_MCP_TRANSPORT_ERROR" || value.lastErrorCode === "BOARD_MCP_RESPONSE_INVALID");
};
var exactRenameResultV1 = (value) => {
  if (!exactKeysV1(value, ["boardId", "title", "updatedAt"]) || typeof value.boardId !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(value.boardId) || typeof value.title !== "string" || [...value.title].length < 1 || [...value.title].length > 200 || /[\u0000-\u001f\u007f-\u009f\uD800-\uDFFF]/u.test(value.title))
    return false;
  return canonicalTimestampV1(value.updatedAt);
};
var toolOutputSchemaV1 = (tool, reachableCodes) => {
  const upstreamCode = external_exports.enum(reachableCodes);
  const value = (code) => external_exports.object({ code }).passthrough();
  const localValue2 = external_exports.union([
    value(external_exports.enum(GENERIC_LOCAL_ERROR_CODES_V1)),
    external_exports.object({
      code: external_exports.literal("BOARD_MCP_LOCAL_FILE_CHANGED"),
      message: external_exports.literal("Local media file changed during capture"),
      retryable: external_exports.literal(false),
      details: external_exports.null()
    }).strict(),
    external_exports.object({
      code: external_exports.literal("BOARD_MCP_LOCAL_FILE_PLATFORM_UNSUPPORTED"),
      message: external_exports.literal("Secure local media capture is unavailable on this platform"),
      retryable: external_exports.literal(false),
      details: external_exports.null()
    }).strict(),
    external_exports.object({
      code: external_exports.literal("BOARD_MCP_LOCAL_FILE_TOO_LARGE"),
      message: external_exports.literal("Local media file exceeds the upload limit"),
      retryable: external_exports.literal(false),
      details: external_exports.object({ limitBytes: external_exports.literal(10485760) }).strict()
    }).strict(),
    external_exports.object({
      code: external_exports.literal("BOARD_MCP_LOCAL_MEDIA_UNSUPPORTED"),
      message: external_exports.literal("Local media file format is unsupported"),
      retryable: external_exports.literal(false),
      details: external_exports.object({
        allowedMimeTypes: external_exports.tuple([
          external_exports.literal("image/png"),
          external_exports.literal("image/jpeg"),
          external_exports.literal("image/webp")
        ])
      }).strict()
    }).strict()
  ]);
  const error3 = external_exports.discriminatedUnion("source", [
    external_exports.object({ source: external_exports.literal("board"), value: value(upstreamCode) }).strict(),
    external_exports.object({ source: external_exports.literal("pairing"), value: value(upstreamCode) }).strict(),
    external_exports.object({ source: external_exports.literal("mcp"), value: localValue2 }).strict()
  ]);
  const descriptor = external_exports.object({
    ok: external_exports.boolean(),
    tool: external_exports.literal(tool),
    requestId: GlobalIdSchema2,
    result: external_exports.record(external_exports.unknown()).optional(),
    metadata: external_exports.unknown().optional(),
    error: error3.optional()
  }).strict();
  const validator = descriptor.superRefine((output, context) => {
    if (output.ok) {
      if (output.result === void 0) {
        context.addIssue({
          code: external_exports.ZodIssueCode.custom,
          path: ["result"],
          message: "success result is required"
        });
        return;
      }
      if (output.error !== void 0) {
        context.addIssue({
          code: external_exports.ZodIssueCode.custom,
          path: ["error"],
          message: "success cannot contain an error"
        });
      }
      if (!Object.hasOwn(output, "metadata")) {
        context.addIssue({
          code: external_exports.ZodIssueCode.custom,
          path: ["metadata"],
          message: "success metadata is required"
        });
      }
      if (typeof output.result.requestId === "string" && output.result.requestId !== output.requestId) {
        context.addIssue({
          code: external_exports.ZodIssueCode.custom,
          path: ["result", "requestId"],
          message: "request IDs must match"
        });
      }
      if (tool === "board_connection_status") {
        if (!exactConnectionStatusResultV1(output.result, output.requestId) || output.metadata !== null)
          context.addIssue({
            code: external_exports.ZodIssueCode.custom,
            path: ["result"],
            message: "connection status result is invalid"
          });
        return;
      }
      if (tool === "board_rename") {
        if (!exactRenameResultV1(output.result) || output.metadata !== null)
          context.addIssue({
            code: external_exports.ZodIssueCode.custom,
            path: ["result"],
            message: "board rename result is invalid"
          });
        return;
      }
      if (tool === "board_export") {
        if (Object.keys(output.result).sort().join("\0") !== ["bytes", "fileName", "format"].join("\0") || output.result.format !== "pdf" && output.result.format !== "pptx" || !Number.isSafeInteger(output.result.bytes) || output.result.bytes < 1 || output.result.bytes > 536870912 || typeof output.result.fileName !== "string" || output.result.fileName.length < 1 || output.result.fileName.length > 120 || /[/\\]/u.test(output.result.fileName) || output.metadata !== null)
          context.addIssue({
            code: external_exports.ZodIssueCode.custom,
            path: ["result"],
            message: "local export result is invalid"
          });
        return;
      }
      const expected = D1_RESULT_TYPES_V1[tool];
      if (expected !== void 0) {
        if (tool === "sceneboard_media_upload") {
          const media = MediaIngestResultParserV1.parse(output.result);
          if (!media.ok) {
            context.addIssue({
              code: external_exports.ZodIssueCode.custom,
              path: ["result"],
              message: "result is not an exact media ingest result"
            });
          }
          if (output.metadata !== null) {
            context.addIssue({
              code: external_exports.ZodIssueCode.custom,
              path: ["metadata"],
              message: "media ingest metadata must be null"
            });
          }
          return;
        }
        const documentTool = tool === "board_document_replace" || tool === "board_page_add" || tool === "board_page_remove" || tool === "board_page_reorder" || tool === "board_page_update" || tool === "board_page_default_set" || tool === "sceneboard_media_place";
        const documentReadTool = tool === "board_document_get";
        const parsed = output.result.type === "mutation.result" ? documentTool ? MutationResultParserV2.parse(output.result) : MutationResultParserV1.parse(output.result) : documentReadTool ? BoardOperationResultParserV2.parse(output.result) : BoardOperationResultParserV1.parse(output.result);
        if (!parsed.ok) {
          context.addIssue({
            code: external_exports.ZodIssueCode.custom,
            path: ["result"],
            message: "result is not an exact D1 envelope"
          });
        }
        const nested = output.result.result;
        if (nested === null || typeof nested !== "object" || Array.isArray(nested) || !expected.includes(nested.type)) {
          context.addIssue({
            code: external_exports.ZodIssueCode.custom,
            path: ["result", "result", "type"],
            message: "tool result type does not match"
          });
        }
        const nestedType = nested?.type;
        const historyMetadata = nestedType === "history.list" || nestedType === "history.get";
        if (tool === "board_scene_patch") {
          const metadata = output.metadata;
          if (metadata === null || typeof metadata !== "object" || metadata.type !== "scene-transform" || typeof metadata.transformedFromRevisionId !== "string" || Object.keys(metadata).length !== 2) {
            context.addIssue({
              code: external_exports.ZodIssueCode.custom,
              path: ["metadata"],
              message: "scene patch metadata is invalid"
            });
          }
        } else if (historyMetadata) {
          const metadata = output.metadata;
          if (metadata === null || typeof metadata !== "object" || metadata.type !== "history" || metadata.history === null || typeof metadata.history !== "object" || Object.keys(metadata).length !== 2) {
            context.addIssue({
              code: external_exports.ZodIssueCode.custom,
              path: ["metadata"],
              message: "history metadata is invalid"
            });
          }
        } else if (output.metadata !== null) {
          context.addIssue({
            code: external_exports.ZodIssueCode.custom,
            path: ["metadata"],
            message: "non-history metadata must be null"
          });
        }
      }
      return;
    }
    if (output.error === void 0) {
      context.addIssue({
        code: external_exports.ZodIssueCode.custom,
        path: ["error"],
        message: "failure error is required"
      });
    } else if ((tool === "board_pair_request" || tool === "board_pair_status") && output.error.source === "board") {
      context.addIssue({
        code: external_exports.ZodIssueCode.custom,
        path: ["error", "source"],
        message: "pairing tools cannot emit board errors"
      });
    } else if (tool !== "board_pair_request" && tool !== "board_pair_status" && output.error.source === "pairing") {
      context.addIssue({
        code: external_exports.ZodIssueCode.custom,
        path: ["error", "source"],
        message: "non-pairing tools cannot emit pairing errors"
      });
    }
    if (tool === "board_export" && output.error?.source === "mcp" && typeof output.error.value.code === "string" && Object.hasOwn(LOCAL_EXPORT_MESSAGES_V1, output.error.value.code)) {
      const code = output.error.value.code;
      if (Object.keys(output.error.value).sort().join("\0") !== ["code", "details", "message", "retryable"].join("\0") || output.error.value.message !== LOCAL_EXPORT_MESSAGES_V1[code] || output.error.value.retryable !== false || output.error.value.details !== null)
        context.addIssue({
          code: external_exports.ZodIssueCode.custom,
          path: ["error", "value"],
          message: "local export error is invalid"
        });
    }
    if (output.result !== void 0 || Object.hasOwn(output, "metadata")) {
      context.addIssue({
        code: external_exports.ZodIssueCode.custom,
        path: ["result"],
        message: "failure cannot contain result metadata"
      });
    }
  });
  const schema = Object.create(descriptor);
  Object.defineProperties(schema, {
    safeParse: { value: (input) => validator.safeParse(input) },
    safeParseAsync: { value: (input) => validator.safeParseAsync(input) },
    parse: { value: (input) => validator.parse(input) },
    parseAsync: { value: (input) => validator.parseAsync(input) }
  });
  return schema;
};
var inputInvalidV1 = (path, issue2) => ({
  code: "BOARD_MCP_INPUT_INVALID",
  message: "Tool input is invalid",
  retryable: false,
  details: { path: path.slice(0, 32), issue: issue2.slice(0, 200) }
});
var notConnectedV1 = () => ({
  code: "BOARD_MCP_NOT_CONNECTED",
  message: "SceneBoard is not connected",
  retryable: false,
  details: null
});
var credentialUnavailableV1 = () => ({
  code: "BOARD_MCP_CREDENTIAL_UNAVAILABLE",
  message: "SceneBoard credential is unavailable",
  retryable: false,
  details: null
});
var localMediaErrorV1 = (code) => {
  if (code === "LOCAL_FILE_CHANGED")
    return {
      code: "BOARD_MCP_LOCAL_FILE_CHANGED",
      message: "Local media file changed during capture",
      retryable: false,
      details: null
    };
  if (code === "LOCAL_FILE_PLATFORM_UNSUPPORTED")
    return {
      code: "BOARD_MCP_LOCAL_FILE_PLATFORM_UNSUPPORTED",
      message: "Secure local media capture is unavailable on this platform",
      retryable: false,
      details: null
    };
  if (code === "LOCAL_FILE_TOO_LARGE")
    return {
      code: "BOARD_MCP_LOCAL_FILE_TOO_LARGE",
      message: "Local media file exceeds the upload limit",
      retryable: false,
      details: { limitBytes: 10485760 }
    };
  return {
    code: "BOARD_MCP_LOCAL_MEDIA_UNSUPPORTED",
    message: "Local media file format is unsupported",
    retryable: false,
    details: { allowedMimeTypes: ["image/png", "image/jpeg", "image/webp"] }
  };
};
var internalToolErrorV1 = (incidentId) => ({
  code: "BOARD_MCP_INTERNAL_ERROR",
  message: "SceneBoard tool execution failed",
  retryable: false,
  details: { incidentId }
});
var localFromSdkErrorV1 = (error3) => {
  if ("protocolVersion" in error3)
    throw new TypeError("D1 errors must not be translated as local errors");
  if (error3.code === "CANCELLED")
    return {
      code: "BOARD_MCP_CANCELLED",
      message: "Tool call was cancelled",
      retryable: false,
      details: null
    };
  if (error3.code === "TIMEOUT")
    return {
      code: "BOARD_MCP_TIMEOUT",
      message: "SceneBoard request timed out",
      retryable: true,
      details: { timeoutMs: error3.timeoutMs }
    };
  if (error3.code === "TRANSPORT_ERROR")
    return {
      code: "BOARD_MCP_TRANSPORT_ERROR",
      message: "SceneBoard transport is unavailable",
      retryable: true,
      details: { phase: error3.phase === "credential" ? "connect" : error3.phase }
    };
  return {
    code: "BOARD_MCP_RESPONSE_INVALID",
    message: "SceneBoard response is invalid",
    retryable: false,
    details: { reason: error3.reason }
  };
};
var asCallResult = (structuredContent, isError, text) => ({
  isError,
  content: [{ type: "text", text }],
  structuredContent
});
var toolSuccessV1 = (tool, requestId, result, metadata) => asCallResult(
  { ok: true, tool, requestId, result, metadata },
  false,
  `${tool} completed (${requestId})`
);
var toolFailureV1 = (tool, requestId, source, value) => {
  const safeValue = redactSecretsV1(value);
  if (typeof value.code === "string") safeValue.code = value.code;
  const preserveSchemaPaths = (sourceValue, safe) => {
    if (sourceValue === null || safe === null || typeof sourceValue !== "object" || typeof safe !== "object" || Array.isArray(sourceValue) || Array.isArray(safe))
      return;
    const sourceRecord = sourceValue;
    const safeRecord = safe;
    for (const [key, nested] of Object.entries(sourceRecord)) {
      if (key === "path" && Array.isArray(nested) && nested.every(
        (segment) => typeof segment === "string" && /^[A-Za-z0-9_-]{1,128}$/u.test(segment) || Number.isSafeInteger(segment) && Number(segment) >= 0
      )) {
        safeRecord.path = [...nested];
      } else {
        preserveSchemaPaths(nested, safeRecord[key]);
      }
    }
  };
  preserveSchemaPaths(value, safeValue);
  return asCallResult(
    { ok: false, tool, requestId, error: { source, value: safeValue } },
    true,
    `${tool} failed: ${String(safeValue.code ?? "UNKNOWN")} (${requestId})`
  );
};
var sdkToolResultV1 = (tool, requestId, result, metadata) => {
  if (result.ok)
    return toolSuccessV1(
      tool,
      requestId,
      result.result,
      metadata
    );
  if ("protocolVersion" in result.error)
    return toolFailureV1(
      tool,
      requestId,
      "board",
      result.error
    );
  return toolFailureV1(
    tool,
    requestId,
    "mcp",
    localFromSdkErrorV1(result.error)
  );
};
var validationFailureV1 = (tool, requestId, error3) => {
  const issue2 = error3.issues[0];
  return toolFailureV1(
    tool,
    requestId,
    "mcp",
    inputInvalidV1(issue2?.path ?? [], issue2?.message ?? "invalid input")
  );
};

// sceneboard-mcp/src/tools/document.tools.ts
var CommonMutationShape = {
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12
};
var DocumentGetInputSchemaV2 = external_exports.object({ boardId: GlobalIdSchemaV1, revisionId: GlobalIdSchemaV1.nullable() }).strict();
var DocumentReplaceInputSchemaV2 = external_exports.object({ ...CommonMutationShape, document: external_exports.unknown() }).strict();
var PageAddInputSchemaV2 = external_exports.object({
  ...CommonMutationShape,
  page: external_exports.unknown(),
  index: external_exports.number().int().safe().nonnegative()
}).strict();
var PageRemoveInputSchemaV2 = external_exports.object({ ...CommonMutationShape, pageId: GlobalIdSchemaV1 }).strict();
var PageReorderInputSchemaV2 = external_exports.object({
  ...CommonMutationShape,
  pageId: GlobalIdSchemaV1,
  toIndex: external_exports.number().int().safe().nonnegative()
}).strict();
var PageUpdateInputSchemaV2 = external_exports.object({
  ...CommonMutationShape,
  pageId: GlobalIdSchemaV1,
  title: external_exports.string().optional(),
  displayMode: external_exports.enum(["fit-page", "fit-width", "actual-size"]).optional(),
  scene: external_exports.unknown().optional()
}).strict().refine(
  (value) => Object.hasOwn(value, "title") || Object.hasOwn(value, "displayMode") || Object.hasOwn(value, "scene"),
  { message: "at least one page update member is required" }
);
var PageDefaultSetInputSchemaV2 = external_exports.object({ ...CommonMutationShape, pageId: GlobalIdSchemaV1 }).strict();
var mismatch = (tool, requestId, commandType) => toolFailureV1(tool, requestId, "board", {
  protocolVersion: 1,
  type: "board.error",
  code: "DOCUMENT_VERSION_MISMATCH",
  message: "Document version mismatch",
  category: "conflict",
  retryable: false,
  httpStatusHint: 409,
  details: {
    headSchemaVersion: commandType === "document.replace" ? 1 : 2,
    commandSchemaVersion: commandType === "document.replace" ? 2 : 1,
    commandType
  }
});
var disconnected = (tool, requestId) => toolFailureV1(tool, requestId, "mcp", notConnectedV1());
var isCallToolResult = (value) => value !== null && typeof value === "object" && !("ok" in value) && "content" in value && Array.isArray(value.content);
var DocumentToolHandlersV2 = class {
  constructor(gateway) {
    this.gateway = gateway;
  }
  async get(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = DocumentGetInputSchemaV2.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_document_get", requestId, parsed.error);
    const result = parsed.data.revisionId === null ? await this.gateway.call(
      "board_document_get",
      ["board.get"],
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "board.get" }
      },
      (client, _snapshot, operationSignal) => client.getDocumentBoard(
        {
          protocolVersion: 1,
          requestId,
          type: "board.get",
          boardId: parsed.data.boardId
        },
        operationSignal
      )
    ) : await this.gateway.call(
      "board_document_get",
      ["history.get"],
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "history.get" }
      },
      (client, _snapshot, operationSignal) => client.getDocumentHistory(
        {
          protocolVersion: 1,
          requestId,
          type: "history.get",
          boardId: parsed.data.boardId,
          revisionId: parsed.data.revisionId
        },
        operationSignal
      )
    );
    if (!result.connected) return disconnected("board_document_get", requestId);
    if (!result.value.ok)
      return sdkToolResultV1("board_document_get", requestId, result.value, null);
    const nested = result.value.result.result;
    const snapshot = nested.type === "board.get" ? nested.snapshot : nested.type === "history.get" ? nested.snapshot : null;
    if (snapshot === null) throw new Error("document get result invariant failed");
    if (!("document" in snapshot))
      return mismatch("board_document_get", requestId, "document.replace");
    return sdkToolResultV1(
      "board_document_get",
      requestId,
      result.value,
      nested.type === "history.get" ? { type: "history", history: result.value.metadata.history } : null
    );
  }
  replace(raw, signal) {
    return this.mutate(
      "board_document_replace",
      DocumentReplaceInputSchemaV2,
      raw,
      (value) => ({
        type: "document.replace",
        document: value.document
      }),
      signal
    );
  }
  add(raw, signal) {
    return this.mutate(
      "board_page_add",
      PageAddInputSchemaV2,
      raw,
      (value) => ({
        type: "page.add",
        page: value.page,
        index: value.index
      }),
      signal
    );
  }
  remove(raw, signal) {
    return this.mutate(
      "board_page_remove",
      PageRemoveInputSchemaV2,
      raw,
      (value) => ({ type: "page.remove", pageId: value.pageId }),
      signal
    );
  }
  reorder(raw, signal) {
    return this.mutate(
      "board_page_reorder",
      PageReorderInputSchemaV2,
      raw,
      (value) => ({
        type: "page.reorder",
        pageId: value.pageId,
        toIndex: value.toIndex
      }),
      signal
    );
  }
  update(raw, signal) {
    return this.mutate(
      "board_page_update",
      PageUpdateInputSchemaV2,
      raw,
      (value) => ({
        type: "page.update",
        pageId: value.pageId,
        ...Object.hasOwn(value, "title") ? { title: value.title } : {},
        ...Object.hasOwn(value, "displayMode") ? { displayMode: value.displayMode } : {},
        ...Object.hasOwn(value, "scene") ? { scene: value.scene } : {}
      }),
      signal
    );
  }
  defaultSet(raw, signal) {
    return this.mutate(
      "board_page_default_set",
      PageDefaultSetInputSchemaV2,
      raw,
      (value) => ({ type: "page.default.set", pageId: value.pageId }),
      signal
    );
  }
  async mutate(tool, schema, raw, operation, signal) {
    const requestId = createRequestIdV1();
    const parsed = schema.safeParse(raw);
    if (!parsed.success) return validationFailureV1(tool, requestId, parsed.error);
    const value = parsed.data;
    const result = await this.gateway.call(
      tool,
      ["board.get", "document.replace"],
      {
        signal,
        authorization: { boardId: value.boardId, operation: "document.replace" }
      },
      async (client, _snapshot, operationSignal) => {
        const head = await client.getDocumentBoard(
          {
            protocolVersion: 1,
            requestId,
            type: "board.get",
            boardId: value.boardId
          },
          operationSignal
        );
        if (!head.ok) return head;
        const nested = head.result.result;
        if (nested.type !== "board.get") throw new Error("board.get result invariant failed");
        if (!("document" in nested.snapshot)) return mismatch(tool, requestId, "document.replace");
        if (nested.snapshot.revision.revisionId !== value.expectedRevisionId)
          return toolFailureV1(tool, requestId, "board", {
            protocolVersion: 1,
            type: "board.error",
            code: "REVISION_CONFLICT",
            message: "Revision conflict",
            category: "conflict",
            retryable: false,
            httpStatusHint: 409,
            details: {
              boardId: value.boardId,
              expectedRevisionId: value.expectedRevisionId,
              actualRevisionId: nested.snapshot.revision.revisionId,
              actualRevisionNumber: nested.snapshot.revision.revisionNumber,
              recovery: "fetch_latest_then_retry"
            }
          });
        const source = BoardDocumentParserV2.parse(nested.snapshot.document);
        if (!source.ok)
          return toolFailureV1(
            tool,
            requestId,
            "board",
            source.error
          );
        const transformed = applyDocumentTransformV2(source.data.value, operation(value));
        if (!transformed.ok)
          return toolFailureV1(
            tool,
            requestId,
            "board",
            transformed.error
          );
        return client.mutateDocument(
          {
            protocolVersion: 1,
            requestId,
            boardId: value.boardId,
            expectedRevisionId: value.expectedRevisionId,
            idempotencyKey: value.idempotencyKey,
            command: { type: "document.replace", document: transformed.data.value }
          },
          operationSignal
        );
      }
    );
    if (!result.connected) return disconnected(tool, requestId);
    if (isCallToolResult(result.value)) return result.value;
    return sdkToolResultV1(tool, requestId, result.value, null);
  }
};

// sceneboard-mcp/src/tools/artifact.tools.ts
var SourceTextSchemaV1 = external_exports.string().refine((value) => !/[\uD800-\uDFFF]/u.test(value), "lone surrogate is not allowed");
var RequestedCapabilitiesSchemaV1 = external_exports.array(external_exports.enum(ARTIFACT_REQUEST_CAPABILITIES_V1)).max(ARTIFACT_REQUEST_CAPABILITIES_V1.length).superRefine((capabilities, context) => {
  for (let index = 1; index < capabilities.length; index += 1) {
    if (capabilities[index - 1] >= capabilities[index]) {
      context.addIssue({
        code: external_exports.ZodIssueCode.custom,
        path: [index],
        message: "requested capabilities must be strictly sorted and unique"
      });
    }
  }
});
var ArtifactGetInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  artifactId: GlobalIdSchemaV1,
  versionId: GlobalIdSchemaV1
}).strict();
var ArtifactPutInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12,
  artifactId: GlobalIdSchemaV1.nullable(),
  html: SourceTextSchemaV1,
  css: SourceTextSchemaV1.nullable(),
  javascript: SourceTextSchemaV1.nullable(),
  requestedCapabilities: RequestedCapabilitiesSchemaV1
}).strict();
var ArtifactStopInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12,
  artifactId: GlobalIdSchemaV1,
  versionId: GlobalIdSchemaV1,
  reason: ShortTextSchemaV12
}).strict();
var ArtifactToolHandlersV1 = class {
  constructor(gateway) {
    this.gateway = gateway;
  }
  async get(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = ArtifactGetInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_artifact_get", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_artifact_get",
      "artifact.get",
      { signal, authorization: { boardId: parsed.data.boardId, operation: "artifact.get" } },
      (client, _snapshot, operationSignal) => client.getArtifact(
        {
          protocolVersion: 1,
          requestId,
          type: "artifact.get",
          boardId: parsed.data.boardId,
          artifact: {
            artifactId: parsed.data.artifactId,
            versionId: parsed.data.versionId
          }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_artifact_get", requestId, result.value, null) : toolFailureV1(
      "board_artifact_get",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async put(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = ArtifactPutInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_artifact_put", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_artifact_put",
      "artifact.publish",
      { signal, authorization: { boardId: parsed.data.boardId, operation: "artifact.publish" } },
      (client, _snapshot, operationSignal) => client.putArtifact(
        requestId,
        {
          boardId: parsed.data.boardId,
          expectedRevisionId: parsed.data.expectedRevisionId,
          idempotencyKey: parsed.data.idempotencyKey,
          artifactId: parsed.data.artifactId,
          html: parsed.data.html,
          css: parsed.data.css,
          javascript: parsed.data.javascript,
          requestedCapabilities: parsed.data.requestedCapabilities
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_artifact_put", requestId, result.value, null) : toolFailureV1(
      "board_artifact_put",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async stop(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = ArtifactStopInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_artifact_stop", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_artifact_stop",
      "artifact.stop",
      { signal, authorization: { boardId: parsed.data.boardId, operation: "artifact.stop" } },
      (client, _snapshot, operationSignal) => client.mutateBoard(
        {
          protocolVersion: 1,
          requestId,
          boardId: parsed.data.boardId,
          expectedRevisionId: parsed.data.expectedRevisionId,
          idempotencyKey: parsed.data.idempotencyKey,
          command: {
            type: "artifact.stop",
            artifact: {
              artifactId: parsed.data.artifactId,
              versionId: parsed.data.versionId
            },
            reason: parsed.data.reason
          }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_artifact_stop", requestId, result.value, null) : toolFailureV1(
      "board_artifact_stop",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
};

// sceneboard-mcp/src/tools/board.tools.ts
var BoardListInputSchemaV1 = external_exports.object({
  cursor: external_exports.string().min(1).max(512).regex(/^[A-Za-z0-9_-]+$/).nullable(),
  limit: external_exports.number().int().min(1).max(100),
  includeArchived: external_exports.boolean()
}).strict();
var BoardGetInputSchemaV1 = external_exports.object({ boardId: GlobalIdSchemaV1 }).strict();
var BoardCreateInputSchemaV1 = external_exports.object({ title: ShortTextSchemaV12, idempotencyKey: IdempotencyKeySchemaV12 }).strict();
var BoardRenameInputSchemaV1 = external_exports.object({ boardId: GlobalIdSchemaV1, title: ShortTextSchemaV12 }).strict();
var BoardArchiveInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  confirm: external_exports.literal(true),
  idempotencyKey: IdempotencyKeySchemaV12
}).strict();
var BoardCapabilitiesInputSchemaV1 = BoardGetInputSchemaV1;
var invalid = (tool, requestId, parsed) => validationFailureV1(tool, requestId, parsed.error);
var disconnected2 = (tool, requestId) => toolFailureV1(tool, requestId, "mcp", notConnectedV1());
var BoardToolHandlersV1 = class {
  constructor(gateway) {
    this.gateway = gateway;
  }
  async list(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = BoardListInputSchemaV1.safeParse(raw);
    if (!parsed.success) return invalid("board_list", requestId, parsed);
    const result = await this.gateway.call(
      "board_list",
      "board.list",
      { signal },
      (client, _snapshot, operationSignal) => client.listBoards(
        {
          protocolVersion: 1,
          requestId,
          type: "board.list",
          cursor: parsed.data.cursor,
          limit: parsed.data.limit,
          includeArchived: parsed.data.includeArchived
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_list", requestId, result.value, null) : disconnected2("board_list", requestId);
  }
  async get(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = BoardGetInputSchemaV1.safeParse(raw);
    if (!parsed.success) return invalid("board_get", requestId, parsed);
    const result = await this.gateway.call(
      "board_get",
      "board.get",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "board.get" }
      },
      (client, _snapshot, operationSignal) => client.getBoard(
        {
          protocolVersion: 1,
          requestId,
          type: "board.get",
          boardId: parsed.data.boardId
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_get", requestId, result.value, null) : disconnected2("board_get", requestId);
  }
  async create(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = BoardCreateInputSchemaV1.safeParse(raw);
    if (!parsed.success) return invalid("board_create", requestId, parsed);
    const result = await this.gateway.call(
      "board_create",
      "board.create",
      { signal },
      (client, _snapshot, operationSignal) => client.createBoard(
        {
          protocolVersion: 1,
          requestId,
          type: "board.create",
          title: parsed.data.title,
          idempotencyKey: parsed.data.idempotencyKey
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_create", requestId, result.value, null) : disconnected2("board_create", requestId);
  }
  async rename(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = BoardRenameInputSchemaV1.safeParse(raw);
    if (!parsed.success) return invalid("board_rename", requestId, parsed);
    const result = await this.gateway.renameBoard({
      boardId: parsed.data.boardId,
      title: parsed.data.title,
      ...signal === void 0 ? {} : { signal }
    });
    if (!result.connected) return disconnected2("board_rename", requestId);
    if (result.value.ok) return toolSuccessV1("board_rename", requestId, result.value.value, null);
    if (result.value.source === "board")
      return toolFailureV1(
        "board_rename",
        requestId,
        "board",
        result.value.error
      );
    return toolFailureV1("board_rename", requestId, "mcp", {
      code: result.value.error.code === "CANCELLED" ? "BOARD_MCP_CANCELLED" : result.value.error.code === "TIMEOUT" ? "BOARD_MCP_TIMEOUT" : result.value.error.code === "TRANSPORT_ERROR" ? "BOARD_MCP_TRANSPORT_ERROR" : "BOARD_MCP_RESPONSE_INVALID",
      message: result.value.error.code === "CANCELLED" ? "Tool call was cancelled" : result.value.error.code === "TIMEOUT" ? "SceneBoard request timed out" : result.value.error.code === "TRANSPORT_ERROR" ? "SceneBoard transport is unavailable" : "SceneBoard response is invalid",
      retryable: result.value.error.code === "TIMEOUT" || result.value.error.code === "TRANSPORT_ERROR",
      details: result.value.error.code === "TIMEOUT" ? { timeoutMs: result.value.error.timeoutMs } : null
    });
  }
  async archive(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = BoardArchiveInputSchemaV1.safeParse(raw);
    if (!parsed.success) return invalid("board_archive", requestId, parsed);
    const result = await this.gateway.call(
      "board_archive",
      "board.archive",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "board.archive" }
      },
      (client, _snapshot, operationSignal) => client.archiveBoard(
        {
          protocolVersion: 1,
          requestId,
          type: "board.archive",
          boardId: parsed.data.boardId,
          confirm: true,
          idempotencyKey: parsed.data.idempotencyKey
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_archive", requestId, result.value, null) : disconnected2("board_archive", requestId);
  }
  async capabilities(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = BoardCapabilitiesInputSchemaV1.safeParse(raw);
    if (!parsed.success) return invalid("board_capabilities_get", requestId, parsed);
    const result = await this.gateway.call(
      "board_capabilities_get",
      "capabilities.get",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "capabilities.get" }
      },
      (client, _snapshot, operationSignal) => client.getCapabilities(
        {
          protocolVersion: 1,
          requestId,
          type: "capabilities.get",
          boardId: parsed.data.boardId
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_capabilities_get", requestId, result.value, null) : disconnected2("board_capabilities_get", requestId);
  }
};

// sceneboard-mcp/src/tools/connection.tools.ts
var ScopeSchema2 = external_exports.enum(CLIENT_GRANT_SCOPE_ORDER_V1);
var LifecycleSchema2 = external_exports.enum(["board.create", "board.archive"]);
var catalogOrderedSubset = (values, catalog) => {
  let prior = -1;
  for (const value of values) {
    const index = catalog.indexOf(value);
    if (index <= prior) return false;
    prior = index;
  }
  return true;
};
var ConnectionStatusInputSchemaV1 = external_exports.object({ boardId: GlobalIdSchemaV1.nullable() }).strict();
var PairRequestInputSchemaV1 = external_exports.object({
  code: external_exports.string().regex(/^(?:SB-)?[0-9A-HJKMNP-TV-Z]{6}-[0-9A-HJKMNP-TV-Z]{6}$/i),
  clientName: ShortTextSchemaV12,
  requestedScopes: external_exports.array(ScopeSchema2).min(1).max(8),
  requestedLifecyclePermissions: external_exports.array(LifecycleSchema2).max(2)
}).strict().superRefine((value, context) => {
  if (!catalogOrderedSubset(value.requestedScopes, CLIENT_GRANT_SCOPE_ORDER_V1))
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["requestedScopes"],
      message: "requested scopes must be a unique catalog-ordered subset"
    });
  if (!catalogOrderedSubset(value.requestedLifecyclePermissions, ["board.create", "board.archive"]))
    context.addIssue({
      code: external_exports.ZodIssueCode.custom,
      path: ["requestedLifecyclePermissions"],
      message: "requested lifecycle permissions must be a unique catalog-ordered subset"
    });
});
var PairStatusInputSchemaV1 = external_exports.object({
  pairingId: GlobalIdSchemaV1,
  waitTimeoutMs: external_exports.number().int().safe().min(0).max(12e4)
}).strict();
var pairLocalError = (error3) => {
  if (error3.code === "PAIRING_SINK_READ_ONLY" || error3.code === "PAIRING_SINK_UNAVAILABLE")
    return {
      code: "BOARD_MCP_CREDENTIAL_UNAVAILABLE",
      message: "Pairing credential storage is unavailable",
      retryable: false,
      details: {
        reason: error3.code === "PAIRING_SINK_READ_ONLY" ? "pairing_sink_read_only" : "pairing_sink_unavailable",
        recovery: "select_writable_store_or_provision_token_out_of_band"
      }
    };
  if (error3.code === "PROFILE_BUSY")
    return {
      code: "BOARD_MCP_PROFILE_BUSY",
      message: "The SceneBoard profile is busy",
      retryable: true,
      details: error3.reason === "active_owner" ? { reason: "active_owner", recovery: "close_other_client_or_retry" } : { reason: "liveness_unknown", recovery: "check_host_then_retry" }
    };
  if (error3.code === "PROFILE_LEASE_CORRUPT")
    return {
      code: "BOARD_MCP_PROFILE_LEASE_CORRUPT",
      message: "The profile lease is invalid",
      retryable: false,
      details: { recovery: "repair_profile_lease_out_of_band" }
    };
  if (error3.code === "PAIRING_STATE_LOST")
    return {
      code: "BOARD_MCP_PAIRING_STATE_LOST",
      message: "The pairing session is unavailable",
      retryable: false,
      details: { recovery: "start_new_pairing" }
    };
  if (error3.code === "PAIRING_CLAIM_OUTCOME_UNKNOWN")
    return {
      code: "BOARD_MCP_PAIRING_CLAIM_OUTCOME_UNKNOWN",
      message: "The pairing claim outcome is unknown",
      retryable: false,
      details: { recovery: "owner_cancel_or_wait_then_create_new_code" }
    };
  if (error3.code === "PAIRING_CREDENTIAL_UNRECOVERABLE")
    return {
      code: "BOARD_MCP_PAIRING_CREDENTIAL_UNRECOVERABLE",
      message: "The redeemed credential cannot be recovered",
      retryable: false,
      details: { recovery: "owner_rotate_or_revoke_and_repair" }
    };
  if (error3.code === "TIMEOUT")
    return {
      code: "BOARD_MCP_TIMEOUT",
      message: "Pairing timed out",
      retryable: true,
      details: { timeoutMs: error3.timeoutMs }
    };
  if (error3.code === "CANCELLED")
    return {
      code: "BOARD_MCP_CANCELLED",
      message: "Pairing was cancelled",
      retryable: false,
      details: null
    };
  if (error3.code === "RESPONSE_INVALID")
    return {
      code: "BOARD_MCP_RESPONSE_INVALID",
      message: "Pairing response is invalid",
      retryable: false,
      details: { reason: error3.reason }
    };
  return {
    code: "BOARD_MCP_TRANSPORT_ERROR",
    message: "Pairing transport is unavailable",
    retryable: true,
    details: { phase: error3.code === "TRANSPORT_OUTCOME_UNKNOWN" ? error3.phase : "request" }
  };
};
var ConnectionToolHandlersV1 = class {
  constructor(connections, pairing, onConnectionState) {
    this.connections = connections;
    this.pairing = pairing;
    this.onConnectionState = onConnectionState;
  }
  async status(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = ConnectionStatusInputSchemaV1.safeParse(raw);
    if (!parsed.success)
      return validationFailureV1("board_connection_status", requestId, parsed.error);
    const result = await this.connections.status(parsed.data.boardId, requestId, signal);
    if (!result.ok)
      return toolFailureV1("board_connection_status", requestId, result.source, result.value);
    if (result.value.state === "connected") this.onConnectionState(true);
    else if (result.value.state === "not_configured" || result.value.state === "credential_missing" || result.value.state === "credential_invalid")
      this.onConnectionState(false);
    return toolSuccessV1("board_connection_status", requestId, result.value, null);
  }
  async pairRequest(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = PairRequestInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_pair_request", requestId, parsed.error);
    const result = await this.pairing.request(
      {
        code: parsed.data.code.toUpperCase(),
        clientName: parsed.data.clientName,
        requestedScopes: parsed.data.requestedScopes,
        requestedLifecyclePermissions: parsed.data.requestedLifecyclePermissions
      },
      signal
    );
    if (result.ok)
      return toolSuccessV1(
        "board_pair_request",
        requestId,
        result.value,
        null
      );
    return result.source === "pairing" ? toolFailureV1(
      "board_pair_request",
      requestId,
      "pairing",
      result.error
    ) : toolFailureV1(
      "board_pair_request",
      requestId,
      "mcp",
      pairLocalError(result.error)
    );
  }
  async pairStatus(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = PairStatusInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_pair_status", requestId, parsed.error);
    const result = await this.pairing.status(
      parsed.data.pairingId,
      parsed.data.waitTimeoutMs,
      signal
    );
    if (result.ok) {
      if (result.value.state === "redeemed") this.onConnectionState(true);
      return toolSuccessV1(
        "board_pair_status",
        requestId,
        result.value,
        null
      );
    }
    return result.source === "pairing" ? toolFailureV1(
      "board_pair_status",
      requestId,
      "pairing",
      result.error
    ) : toolFailureV1(
      "board_pair_status",
      requestId,
      "mcp",
      pairLocalError(result.error)
    );
  }
};

// sceneboard-mcp/src/tools/history.tools.ts
var HistoryListInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  cursor: external_exports.string().min(1).max(512).regex(/^[A-Za-z0-9_-]+$/).nullable(),
  limit: external_exports.number().int().min(1).max(100)
}).strict();
var HistoryGetInputSchemaV1 = external_exports.object({ boardId: GlobalIdSchemaV1, revisionId: GlobalIdSchemaV1 }).strict();
var HistoryRestoreInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  revisionId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  confirm: external_exports.literal(true),
  idempotencyKey: IdempotencyKeySchemaV12
}).strict();
var HistoryToolHandlersV1 = class {
  constructor(gateway) {
    this.gateway = gateway;
  }
  async list(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = HistoryListInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_history_list", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_history_list",
      "history.list",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "history.list" }
      },
      (client, _snapshot, operationSignal) => client.listHistory(
        {
          protocolVersion: 1,
          requestId,
          type: "history.list",
          boardId: parsed.data.boardId,
          cursor: parsed.data.cursor,
          limit: parsed.data.limit
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1(
      "board_history_list",
      requestId,
      result.value,
      result.value.ok ? { type: "history", history: result.value.metadata.history } : null
    ) : toolFailureV1(
      "board_history_list",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async get(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = HistoryGetInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_history_get", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_history_get",
      "history.get",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "history.get" }
      },
      (client, _snapshot, operationSignal) => client.getHistory(
        {
          protocolVersion: 1,
          requestId,
          type: "history.get",
          boardId: parsed.data.boardId,
          revisionId: parsed.data.revisionId
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1(
      "board_history_get",
      requestId,
      result.value,
      result.value.ok ? { type: "history", history: result.value.metadata.history } : null
    ) : toolFailureV1(
      "board_history_get",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async restore(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = HistoryRestoreInputSchemaV1.safeParse(raw);
    if (!parsed.success)
      return validationFailureV1("board_history_restore", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_history_restore",
      "scene.restore",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "scene.restore" }
      },
      (client, _snapshot, operationSignal) => client.restoreRevision(
        {
          protocolVersion: 1,
          requestId,
          boardId: parsed.data.boardId,
          expectedRevisionId: parsed.data.expectedRevisionId,
          idempotencyKey: parsed.data.idempotencyKey,
          command: {
            type: "scene.restore",
            sourceRevisionId: parsed.data.revisionId
          }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_history_restore", requestId, result.value, null) : toolFailureV1(
      "board_history_restore",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
};

// sceneboard-mcp/src/tools/export.tools.ts
var BoardExportInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  revisionId: GlobalIdSchemaV1,
  format: external_exports.enum(["pdf", "pptx"]),
  outputFile: external_exports.string().min(1).max(4096)
}).strict();
var localTransportErrorV1 = (value) => {
  if (value.code === "CANCELLED")
    return {
      code: "BOARD_MCP_CANCELLED",
      message: "Tool call was cancelled",
      retryable: false,
      details: null
    };
  if (value.code === "TIMEOUT")
    return {
      code: "BOARD_MCP_TIMEOUT",
      message: "SceneBoard request timed out",
      retryable: true,
      details: { timeoutMs: value.timeoutMs }
    };
  if (value.code === "TRANSPORT_ERROR")
    return {
      code: "BOARD_MCP_TRANSPORT_ERROR",
      message: "SceneBoard transport is unavailable",
      retryable: true,
      details: { phase: "response" }
    };
  return {
    code: "BOARD_MCP_RESPONSE_INVALID",
    message: "SceneBoard response is invalid",
    retryable: false,
    details: null
  };
};
var ExportToolHandlersV1 = class {
  constructor(gateway, localFiles) {
    this.gateway = gateway;
    this.localFiles = localFiles;
  }
  async export(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = BoardExportInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_export", requestId, parsed.error);
    if (this.localFiles === null)
      return toolFailureV1("board_export", requestId, "mcp", {
        code: "LOCAL_EXPORT_UNAVAILABLE",
        message: "Secure local export is unavailable on this platform",
        retryable: false,
        details: null
      });
    const prepared = this.localFiles.preflight(parsed.data.outputFile, parsed.data.format);
    if (!prepared.ok)
      return toolFailureV1(
        "board_export",
        requestId,
        "mcp",
        prepared.error
      );
    try {
      const remote = await this.gateway.exportBoard({
        boardId: parsed.data.boardId,
        revisionId: parsed.data.revisionId,
        format: parsed.data.format,
        publish: (artifact, operationSignal) => this.localFiles.publish(prepared.value, artifact, operationSignal),
        ...signal === void 0 ? {} : { signal }
      });
      if (!remote.connected)
        return toolFailureV1(
          "board_export",
          requestId,
          "mcp",
          notConnectedV1()
        );
      if (!remote.value.ok) {
        if (remote.value.source === "board")
          return toolFailureV1(
            "board_export",
            requestId,
            "board",
            remote.value.error
          );
        if (remote.value.source === "publication")
          return toolFailureV1(
            "board_export",
            requestId,
            "mcp",
            remote.value.error
          );
        return toolFailureV1(
          "board_export",
          requestId,
          "mcp",
          localTransportErrorV1(remote.value.error)
        );
      }
      return toolSuccessV1(
        "board_export",
        requestId,
        remote.value.value,
        null
      );
    } finally {
      this.localFiles.release(prepared.value);
    }
  }
};

// sceneboard-mcp/src/tools/interaction.tools.ts
var LocalFieldIdSchemaV12 = external_exports.string().regex(/^[A-Za-z][A-Za-z0-9_-]{0,63}$/);
var TimestampSchemaV12 = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/).refine(
  (value) => Number.isFinite(Date.parse(value)) && new Date(Date.parse(value)).toISOString() === value
);
var ContentSchemaV1 = external_exports.string().refine((value) => !/[\uD800-\uDFFF]/u.test(value), "lone surrogate is not allowed").refine(
  (value) => [...value].length <= BOARD_LIMITS_V1.maxMarkdownChars,
  "HITL body is too long"
);
var ResponseTextSchemaV1 = external_exports.string().refine((value) => !/[\uD800-\uDFFF]/u.test(value), "lone surrogate is not allowed").refine(
  (value) => [...value].length <= BOARD_LIMITS_V1.maxHitlTextChars,
  "HITL text is too long"
);
var HitlOptionSchemaV12 = external_exports.object({
  id: LocalFieldIdSchemaV12,
  label: ShortTextSchemaV12,
  description: ShortTextSchemaV12.optional()
}).strict();
var HitlFieldSchemaV12 = external_exports.discriminatedUnion("type", [
  external_exports.object({
    id: LocalFieldIdSchemaV12,
    type: external_exports.literal("text"),
    label: ShortTextSchemaV12,
    required: external_exports.boolean(),
    defaultValue: ResponseTextSchemaV1.nullable(),
    minLength: external_exports.number().int().safe().min(0).max(BOARD_LIMITS_V1.maxHitlTextChars),
    maxLength: external_exports.number().int().safe().min(1).max(BOARD_LIMITS_V1.maxHitlTextChars)
  }).strict(),
  external_exports.object({
    id: LocalFieldIdSchemaV12,
    type: external_exports.literal("number"),
    label: ShortTextSchemaV12,
    required: external_exports.boolean(),
    defaultValue: external_exports.number().finite().nullable(),
    min: external_exports.number().finite().nullable(),
    max: external_exports.number().finite().nullable()
  }).strict(),
  external_exports.object({
    id: LocalFieldIdSchemaV12,
    type: external_exports.literal("boolean"),
    label: ShortTextSchemaV12,
    required: external_exports.boolean(),
    defaultValue: external_exports.boolean().nullable()
  }).strict(),
  external_exports.object({
    id: LocalFieldIdSchemaV12,
    type: external_exports.literal("select"),
    label: ShortTextSchemaV12,
    required: external_exports.boolean(),
    defaultValue: LocalFieldIdSchemaV12.nullable(),
    options: external_exports.array(HitlOptionSchemaV12).min(1).max(BOARD_LIMITS_V1.maxHitlOptions)
  }).strict()
]);
var HitlDefinitionSchemaV1 = external_exports.discriminatedUnion("kind", [
  external_exports.object({
    kind: external_exports.literal("info"),
    title: ShortTextSchemaV12,
    body: ContentSchemaV1,
    acknowledgeLabel: ShortTextSchemaV12
  }).strict(),
  external_exports.object({
    kind: external_exports.literal("choice"),
    title: ShortTextSchemaV12,
    body: ContentSchemaV1.optional(),
    multiple: external_exports.boolean(),
    minSelections: external_exports.number().int().safe().min(1).max(BOARD_LIMITS_V1.maxHitlOptions),
    maxSelections: external_exports.number().int().safe().min(1).max(BOARD_LIMITS_V1.maxHitlOptions),
    options: external_exports.array(HitlOptionSchemaV12).min(1).max(BOARD_LIMITS_V1.maxHitlOptions)
  }).strict(),
  external_exports.object({
    kind: external_exports.literal("form"),
    title: ShortTextSchemaV12,
    body: ContentSchemaV1.optional(),
    fields: external_exports.array(HitlFieldSchemaV12).min(1).max(BOARD_LIMITS_V1.maxHitlFields),
    submitLabel: ShortTextSchemaV12
  }).strict(),
  external_exports.object({
    kind: external_exports.literal("confirmation"),
    title: ShortTextSchemaV12,
    body: ContentSchemaV1,
    impact: external_exports.enum(["standard", "destructive"]),
    confirmLabel: ShortTextSchemaV12,
    cancelLabel: ShortTextSchemaV12
  }).strict()
]);
var HitlResponseSchemaV12 = external_exports.discriminatedUnion("kind", [
  external_exports.object({ kind: external_exports.literal("info"), acknowledged: external_exports.literal(true) }).strict(),
  external_exports.object({
    kind: external_exports.literal("choice"),
    selectedOptionIds: external_exports.array(LocalFieldIdSchemaV12).min(1).max(BOARD_LIMITS_V1.maxHitlOptions)
  }).strict(),
  external_exports.object({
    kind: external_exports.literal("form"),
    values: external_exports.record(
      LocalFieldIdSchemaV12,
      external_exports.union([ResponseTextSchemaV1, external_exports.number().finite(), external_exports.boolean(), external_exports.null()])
    )
  }).strict(),
  external_exports.object({ kind: external_exports.literal("confirmation"), confirmed: external_exports.boolean() }).strict()
]);
var InteractionRequestInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12,
  hitlRequestId: GlobalIdSchemaV1,
  definition: HitlDefinitionSchemaV1
}).strict();
var InteractionStatusInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  hitlRequestId: GlobalIdSchemaV1,
  wait: external_exports.object({
    afterStateUpdatedAt: TimestampSchemaV12,
    timeoutMs: external_exports.number().int().safe().min(0).max(BOARD_LIMITS_V1.maxHitlWaitMs)
  }).strict().nullable()
}).strict();
var InteractionRespondInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12,
  hitlRequestId: GlobalIdSchemaV1,
  response: HitlResponseSchemaV12
}).strict();
var InteractionToolHandlersV1 = class {
  constructor(gateway) {
    this.gateway = gateway;
  }
  async request(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = InteractionRequestInputSchemaV1.safeParse(raw);
    if (!parsed.success)
      return validationFailureV1("board_interaction_request", requestId, parsed.error);
    const definition = HitlRequestDefinitionParserV1.parse(parsed.data.definition);
    if (!definition.ok)
      return toolFailureV1(
        "board_interaction_request",
        requestId,
        "board",
        definition.error
      );
    const result = await this.gateway.call(
      "board_interaction_request",
      "hitl.request",
      { signal, authorization: { boardId: parsed.data.boardId, operation: "hitl.request" } },
      (client, _snapshot, operationSignal) => client.mutateBoard(
        {
          protocolVersion: 1,
          requestId,
          boardId: parsed.data.boardId,
          expectedRevisionId: parsed.data.expectedRevisionId,
          idempotencyKey: parsed.data.idempotencyKey,
          command: {
            type: "hitl.request",
            hitlRequestId: parsed.data.hitlRequestId,
            request: definition.data.value
          }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_interaction_request", requestId, result.value, null) : toolFailureV1(
      "board_interaction_request",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async status(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = InteractionStatusInputSchemaV1.safeParse(raw);
    if (!parsed.success)
      return validationFailureV1("board_interaction_status", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_interaction_status",
      "hitl.read",
      { signal, authorization: { boardId: parsed.data.boardId, operation: "hitl.read" } },
      (client, _snapshot, operationSignal) => client.getInteraction(
        {
          protocolVersion: 1,
          requestId,
          type: "hitl.read",
          boardId: parsed.data.boardId,
          hitlRequestId: parsed.data.hitlRequestId,
          wait: parsed.data.wait === null ? null : {
            afterStateUpdatedAt: parsed.data.wait.afterStateUpdatedAt,
            timeoutMs: parsed.data.wait.timeoutMs
          }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_interaction_status", requestId, result.value, null) : toolFailureV1(
      "board_interaction_status",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async respond(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = InteractionRespondInputSchemaV1.safeParse(raw);
    if (!parsed.success)
      return validationFailureV1("board_interaction_respond", requestId, parsed.error);
    const response = HitlResponseParserV1.parse(parsed.data.response);
    if (!response.ok)
      return toolFailureV1(
        "board_interaction_respond",
        requestId,
        "board",
        response.error
      );
    const result = await this.gateway.call(
      "board_interaction_respond",
      "hitl.respond",
      { signal, authorization: { boardId: parsed.data.boardId, operation: "hitl.respond" } },
      (client, _snapshot, operationSignal) => client.mutateBoard(
        {
          protocolVersion: 1,
          requestId,
          boardId: parsed.data.boardId,
          expectedRevisionId: parsed.data.expectedRevisionId,
          idempotencyKey: parsed.data.idempotencyKey,
          command: {
            type: "hitl.respond",
            hitlRequestId: parsed.data.hitlRequestId,
            response: response.data.value
          }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_interaction_respond", requestId, result.value, null) : toolFailureV1(
      "board_interaction_respond",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
};

// sceneboard-mcp/src/tools/media.tools.ts
import { randomBytes as randomBytes9 } from "node:crypto";

// sceneboard-mcp/src/media/local-media-file.ts
import { createHash as createHash4 } from "node:crypto";
import { constants as constants5 } from "node:fs";
import { lstat as lstat4, open as open5 } from "node:fs/promises";
import { isAbsolute as isAbsolute4, normalize as normalize2, parse as parse4, sep } from "node:path";
var LOCAL_MEDIA_MAX_BYTES_V1 = 10485760;
var identity = (stat) => ({
  dev: stat.dev,
  ino: stat.ino,
  mode: stat.mode,
  size: stat.size,
  mtimeNs: stat.mtimeNs,
  ctimeNs: stat.ctimeNs
});
var sameIdentity = (left, right) => left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
var lexicalPathValid = (value) => value.length > 0 && !value.includes("\0") && !/[*?[\]{}!]/u.test(value) && isAbsolute4(value) && value !== parse4(value).root && !value.endsWith(sep) && normalize2(value) === value;
var detectedMime = (bytes) => {
  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
    return "image/png";
  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255)
    return "image/jpeg";
  if (bytes.length >= 12 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP")
    return "image/webp";
  return null;
};
var changed = () => ({ ok: false, code: "LOCAL_FILE_CHANGED" });
var captureLocalMediaFileV1 = async (path) => {
  if (!lexicalPathValid(path)) return { ok: false, code: "INPUT_INVALID" };
  if (process.platform === "win32" || typeof constants5.O_NOFOLLOW !== "number" || typeof constants5.O_NONBLOCK !== "number")
    return { ok: false, code: "LOCAL_FILE_PLATFORM_UNSUPPORTED" };
  let handle = null;
  let bytes = null;
  let retained = false;
  try {
    handle = await open5(path, constants5.O_RDONLY | constants5.O_NOFOLLOW | constants5.O_NONBLOCK);
    const before = await handle.stat({ bigint: true });
    if (!before.isFile()) return changed();
    if (before.size < 1n) return changed();
    if (before.size > BigInt(LOCAL_MEDIA_MAX_BYTES_V1))
      return { ok: false, code: "LOCAL_FILE_TOO_LARGE" };
    const first = identity(before);
    const length = Number(before.size);
    bytes = Buffer.allocUnsafe(length);
    let offset = 0;
    while (offset < length) {
      const read = await handle.read(bytes, offset, length - offset, offset);
      if (read.bytesRead <= 0) return changed();
      offset += read.bytesRead;
    }
    const probe = Buffer.allocUnsafe(1);
    try {
      const extra = await handle.read(probe, 0, 1, length);
      if (extra.bytesRead !== 0) return changed();
    } finally {
      probe.fill(0);
    }
    const mime = detectedMime(bytes);
    if (mime === null) return { ok: false, code: "LOCAL_MEDIA_UNSUPPORTED" };
    const digest = createHash4("sha256").update(bytes).digest();
    const afterDescriptor = await handle.stat({ bigint: true });
    const afterPath = await lstat4(path, { bigint: true });
    if (!afterDescriptor.isFile() || !afterPath.isFile() || afterPath.isSymbolicLink() || !sameIdentity(first, identity(afterDescriptor)) || !sameIdentity(first, identity(afterPath)))
      return changed();
    retained = true;
    let released = false;
    const owned = bytes;
    return {
      ok: true,
      value: {
        bytes: owned,
        mime,
        sha256: digest.toString("hex"),
        digestBase64: digest.toString("base64"),
        release: () => {
          if (released) return;
          released = true;
          owned.fill(0);
        }
      }
    };
  } catch {
    return changed();
  } finally {
    await handle?.close().catch(() => void 0);
    if (!retained) bytes?.fill(0);
  }
};

// sceneboard-mcp/src/tools/media.tools.ts
var FitSchema = external_exports.enum(["contain", "cover", "fill", "none"]);
var MediaTextSchema = external_exports.string().refine((value) => {
  const length = [...value].length;
  return length >= 1 && length <= 500 && !/[\u0000-\u001f\u007f-\u009f\uD800-\uDFFF]/u.test(value);
});
var MeaningfulImageSchema = external_exports.object({
  nodeId: GlobalIdSchemaV1,
  mediaId: GlobalIdSchemaV1,
  decorative: external_exports.literal(false),
  alt: MediaTextSchema,
  caption: MediaTextSchema.optional(),
  fit: FitSchema.optional()
}).strict();
var DecorativeImageSchema = external_exports.object({
  nodeId: GlobalIdSchemaV1,
  mediaId: GlobalIdSchemaV1,
  decorative: external_exports.literal(true),
  alt: external_exports.literal(""),
  fit: FitSchema.optional()
}).strict();
var MediaUploadInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  path: external_exports.string(),
  idempotencyKey: IdempotencyKeySchemaV12
}).strict();
var MediaPlaceInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  pageId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12,
  image: external_exports.discriminatedUnion("decorative", [MeaningfulImageSchema, DecorativeImageSchema]),
  placement: external_exports.discriminatedUnion("kind", [
    external_exports.object({ kind: external_exports.literal("page-end"), wrapperNodeId: GlobalIdSchemaV1 }).strict(),
    external_exports.object({
      kind: external_exports.literal("canvas"),
      x: external_exports.number().finite().nonnegative(),
      y: external_exports.number().finite().nonnegative(),
      width: external_exports.number().finite().positive(),
      height: external_exports.number().finite().positive(),
      zIndex: external_exports.number().int().safe()
    }).strict()
  ])
}).strict();
var localConnectionError = (error3) => localFromSdkErrorV1(
  error3.code === "TRANSPORT_ERROR" && error3.phase === "connect" ? { ...error3, phase: "credential" } : error3
);
var authorizationFailure = (tool, requestId, result) => {
  if (result.reason === "not_connected")
    return toolFailureV1(tool, requestId, "mcp", notConnectedV1());
  if (result.reason === "credential_unavailable")
    return toolFailureV1(
      tool,
      requestId,
      "mcp",
      credentialUnavailableV1()
    );
  if (result.reason === "board") return toolFailureV1(tool, requestId, "board", result.error);
  if (!("error" in result))
    return toolFailureV1(
      tool,
      requestId,
      "mcp",
      credentialUnavailableV1()
    );
  return toolFailureV1(
    tool,
    requestId,
    "mcp",
    localConnectionError(result.error)
  );
};
var internalFailure = (tool, requestId) => toolFailureV1(
  tool,
  requestId,
  "mcp",
  internalToolErrorV1(randomBytes9(16).toString("base64url"))
);
var boardFailure = (tool, requestId, value) => toolFailureV1(tool, requestId, "board", value);
var MediaToolHandlersV1 = class {
  constructor(gateway) {
    this.gateway = gateway;
  }
  async upload(raw, signal) {
    const requestId = createRequestIdV1();
    try {
      const parsed = MediaUploadInputSchemaV1.safeParse(raw);
      if (!parsed.success)
        return validationFailureV1("sceneboard_media_upload", requestId, parsed.error);
      const authorized = await this.gateway.withAuthorizedBoardOperation(
        {
          boardId: parsed.data.boardId,
          requestId,
          requiredCapabilities: ["board.media.write"],
          apiKeyToolName: "sceneboard_media_upload",
          apiKeyOperationPlan: "media.upload",
          apiKeyAuthorizationOperation: "media.upload",
          ...signal === void 0 ? {} : { signal }
        },
        async ({ snapshot, media, signal: operationSignal }) => {
          const captured = await captureLocalMediaFileV1(parsed.data.path);
          if (!captured.ok) return { kind: "capture_error", code: captured.code };
          try {
            return {
              kind: "http",
              value: await media.upload(
                {
                  boardId: parsed.data.boardId,
                  requestId,
                  idempotencyKey: parsed.data.idempotencyKey,
                  accessToken: snapshot.accessToken,
                  mime: captured.value.mime,
                  digestBase64: captured.value.digestBase64,
                  bytes: captured.value.bytes
                },
                operationSignal
              )
            };
          } finally {
            captured.value.release();
          }
        }
      );
      if (!authorized.authorized)
        return authorizationFailure("sceneboard_media_upload", requestId, authorized);
      if (authorized.value.kind === "capture_error") {
        if (authorized.value.code === "INPUT_INVALID")
          return toolFailureV1(
            "sceneboard_media_upload",
            requestId,
            "mcp",
            inputInvalidV1(["path"], "absolute local media path is invalid")
          );
        return toolFailureV1(
          "sceneboard_media_upload",
          requestId,
          "mcp",
          localMediaErrorV1(authorized.value.code)
        );
      }
      const result = authorized.value.value;
      if (result.ok)
        return toolSuccessV1("sceneboard_media_upload", requestId, result.result, null);
      if ("protocolVersion" in result.error)
        return boardFailure(
          "sceneboard_media_upload",
          requestId,
          result.error
        );
      return toolFailureV1(
        "sceneboard_media_upload",
        requestId,
        "mcp",
        localFromSdkErrorV1(result.error)
      );
    } catch {
      return internalFailure("sceneboard_media_upload", requestId);
    }
  }
  async place(raw, signal) {
    const requestId = createRequestIdV1();
    try {
      const parsed = MediaPlaceInputSchemaV1.safeParse(raw);
      if (!parsed.success)
        return validationFailureV1("sceneboard_media_place", requestId, parsed.error);
      const authorized = await this.gateway.withAuthorizedBoardOperation(
        {
          boardId: parsed.data.boardId,
          requestId,
          requiredCapabilities: ["board.history.read", "board.write"],
          apiKeyToolName: "sceneboard_media_place",
          apiKeyOperationPlan: ["history.get", "document.replace"],
          apiKeyAuthorizationOperation: "document.replace",
          ...signal === void 0 ? {} : { signal }
        },
        async ({ client, signal: operationSignal }) => {
          const history = await client.getDocumentHistory(
            {
              protocolVersion: 1,
              requestId,
              type: "history.get",
              boardId: parsed.data.boardId,
              revisionId: parsed.data.expectedRevisionId
            },
            operationSignal
          );
          if (!history.ok) return { kind: "sdk", value: history };
          const nested = history.result.result;
          if (nested.type !== "history.get") throw new Error("history result invariant failed");
          if (nested.snapshot.revision.revisionId !== parsed.data.expectedRevisionId || !("document" in nested.snapshot))
            return {
              kind: "mismatch",
              version: !("document" in nested.snapshot)
            };
          const document = BoardDocumentParserV2.parse(nested.snapshot.document);
          if (!document.ok)
            return {
              kind: "board",
              error: document.error
            };
          const source = parsed.data.image;
          const image = {
            id: source.nodeId,
            type: "content.image",
            source: { type: "media", mediaId: source.mediaId },
            decorative: source.decorative,
            alt: source.alt,
            ...source.decorative === false && source.caption !== void 0 ? { caption: source.caption } : {},
            fit: source.fit ?? "contain"
          };
          const transformed = placeMediaImageOnPageV1({
            document: document.data.value,
            pageId: parsed.data.pageId,
            image,
            placement: parsed.data.placement.kind === "page-end" ? {
              kind: "page-end",
              wrapperNodeId: parsed.data.placement.wrapperNodeId
            } : parsed.data.placement
          });
          if (!transformed.ok)
            return {
              kind: "board",
              error: transformed.error
            };
          return {
            kind: "sdk",
            value: await client.mutateDocument(
              {
                protocolVersion: 1,
                requestId,
                boardId: parsed.data.boardId,
                expectedRevisionId: parsed.data.expectedRevisionId,
                idempotencyKey: parsed.data.idempotencyKey,
                command: { type: "document.replace", document: transformed.data.value }
              },
              operationSignal
            )
          };
        }
      );
      if (!authorized.authorized)
        return authorizationFailure("sceneboard_media_place", requestId, authorized);
      const outcome = authorized.value;
      if (outcome.kind === "sdk")
        return sdkToolResultV1("sceneboard_media_place", requestId, outcome.value, null);
      if (outcome.kind === "board")
        return boardFailure(
          "sceneboard_media_place",
          requestId,
          outcome.error
        );
      return boardFailure("sceneboard_media_place", requestId, {
        protocolVersion: 1,
        type: "board.error",
        code: "DOCUMENT_VERSION_MISMATCH",
        message: "Document version mismatch",
        category: "conflict",
        retryable: false,
        httpStatusHint: 409,
        details: {
          headSchemaVersion: 1,
          commandSchemaVersion: 2,
          commandType: "document.replace"
        }
      });
    } catch {
      return internalFailure("sceneboard_media_place", requestId);
    }
  }
};

// packages/board-sdk/src/scene-transform/scene-transform.ts
var LOCAL_ID_PATTERN2 = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
var invalid2 = (operationIndex, field, issue2) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "INVALID_PAYLOAD",
  message: "Invalid payload",
  category: "validation",
  retryable: false,
  httpStatusHint: 400,
  details: { path: ["operations", operationIndex, field], issue: issue2 }
});
var invalidLayout2 = (operationIndex, field, reason) => ({
  protocolVersion: 1,
  type: "board.error",
  code: "INVALID_LAYOUT",
  message: "Layout correlation is invalid",
  category: "validation",
  retryable: false,
  httpStatusHint: 422,
  details: { path: ["operations", operationIndex, field], reason }
});
var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
var isBoardError = (value) => value.type === "board.error";
var isLayoutNode = (node) => node.type.startsWith("layout.");
var hasExactKeys3 = (value, keys) => {
  const actual = Object.keys(value).sort();
  const expected = [...keys].sort();
  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
};
var isSafeIndex = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
var isFinitePositive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
var isFiniteNonNegative = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
var isLocalId = (value) => typeof value === "string" && LOCAL_ID_PATTERN2.test(value);
var scalarLength = (value) => [...value].length;
var isShortText = (value) => typeof value === "string" && !/[\uD800-\uDFFF]/u.test(value.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/gu, "")) && scalarLength(value) >= 1 && scalarLength(value) <= BOARD_LIMITS_V1.maxTitleChars;
var childrenOf = (node) => {
  if (node.type === "layout.split" || node.type === "layout.grid" || node.type === "layout.canvas") {
    return node.children;
  }
  if (node.type === "layout.tabs") return node.tabs;
  return null;
};
var buildIndex = (root) => {
  const index = /* @__PURE__ */ new Map();
  if (root === null) return index;
  const stack = [{ node: root, parent: null, collection: null, index: null }];
  while (stack.length > 0) {
    const current = stack.pop();
    if (current === void 0) break;
    if (index.has(current.node.id)) throw new Error("duplicate node ID");
    index.set(current.node.id, current);
    const children = childrenOf(current.node);
    if (children === null) continue;
    if (!isLayoutNode(current.node)) throw new Error("invalid layout node");
    const collection = current.node.type === "layout.tabs" ? "tabs" : "children";
    for (let childIndex = children.length - 1; childIndex >= 0; childIndex -= 1) {
      const child = children[childIndex];
      if (child !== void 0) {
        stack.push({
          node: child.node,
          parent: current.node,
          collection,
          index: childIndex
        });
      }
    }
  }
  return index;
};
var layoutEntries = (node) => {
  const children = childrenOf(node);
  return children === null ? null : children;
};
var validateNode = (value, operationIndex, field) => {
  const parsed = BoardNodeParserV1.parse(value);
  if (!parsed.ok) return prefixError(parsed.error, operationIndex, field);
  return parsed.data.value;
};
var prefixError = (error3, operationIndex, field) => {
  if (error3.code === "INVALID_PAYLOAD" || error3.code === "INVALID_LAYOUT" || error3.code === "LIMIT_EXCEEDED") {
    return {
      ...error3,
      details: {
        ...error3.details,
        path: ["operations", operationIndex, field, ...error3.details.path]
      }
    };
  }
  return error3;
};
var validateParent = (parent, operationIndex) => {
  const parsed = BoardNodeParserV1.parse(parent);
  return parsed.ok ? null : prefixError(parsed.error, operationIndex, "placement");
};
var placementEntry = (parent, node, placement, operationIndex) => {
  if (!isRecord4(placement) || placement.parentType !== parent.type) {
    return invalidLayout2(operationIndex, "placement", "reference");
  }
  if (parent.type === "layout.split") {
    if (!hasExactKeys3(placement, ["parentType", "weight"]) || !isFinitePositive(placement.weight)) {
      return invalid2(operationIndex, "placement", "invalid split placement");
    }
    return { node, weight: placement.weight };
  }
  if (parent.type === "layout.grid") {
    const keys2 = ["parentType", "column", "row", "columnSpan", "rowSpan"];
    if (!hasExactKeys3(placement, keys2) || !isSafeIndex(placement.column) || placement.column < 1 || !isSafeIndex(placement.row) || placement.row < 1 || !isSafeIndex(placement.columnSpan) || placement.columnSpan < 1 || !isSafeIndex(placement.rowSpan) || placement.rowSpan < 1) {
      return invalid2(operationIndex, "placement", "invalid grid placement");
    }
    return {
      node,
      column: placement.column,
      row: placement.row,
      columnSpan: placement.columnSpan,
      rowSpan: placement.rowSpan
    };
  }
  if (parent.type === "layout.tabs") {
    if (!hasExactKeys3(placement, ["parentType", "tabId", "label"]) || !isLocalId(placement.tabId) || !isShortText(placement.label)) {
      return invalid2(operationIndex, "placement", "invalid tab placement");
    }
    return { node, tabId: placement.tabId, label: placement.label };
  }
  const keys = ["parentType", "x", "y", "width", "height", "zIndex"];
  if (!hasExactKeys3(placement, keys) || !isFiniteNonNegative(placement.x) || !isFiniteNonNegative(placement.y) || !isFinitePositive(placement.width) || !isFinitePositive(placement.height) || !Number.isSafeInteger(placement.zIndex)) {
    return invalid2(operationIndex, "placement", "invalid canvas placement");
  }
  return {
    node,
    x: placement.x,
    y: placement.y,
    width: placement.width,
    height: placement.height,
    zIndex: placement.zIndex
  };
};
var directChildIndex = (parent, childNodeId) => {
  if (!isLocalId(childNodeId)) return -1;
  return (childrenOf(parent) ?? []).findIndex((entry) => entry.node.id === childNodeId);
};
var removeLocatedNode = (location) => {
  if (location.parent === null || location.index === null) throw new Error("cannot remove root");
  const entries = layoutEntries(location.parent);
  if (entries === null) throw new Error("invalid parent");
  entries.splice(location.index, 1);
};
var errorResult = (error3) => ({ ok: false, error: error3 });
var applyOperation = (scene, operation, operationIndex) => {
  if (!isRecord4(operation) || typeof operation.type !== "string") {
    return invalid2(operationIndex, "type", "operation must be a strict object");
  }
  let index;
  try {
    index = buildIndex(scene.root);
  } catch {
    return invalid2(operationIndex, "nodeId", "scene contains duplicate node IDs");
  }
  if (operation.type === "replace_root") {
    if (!hasExactKeys3(operation, ["type", "root"]))
      return invalid2(operationIndex, "type", "unknown operation field");
    if (operation.root === null) {
      scene.root = null;
      return null;
    }
    const node = validateNode(operation.root, operationIndex, "root");
    if (isBoardError(node)) return node;
    scene.root = structuredClone(node);
    return null;
  }
  if (operation.type === "replace_node") {
    if (!hasExactKeys3(operation, ["type", "nodeId", "node"]) || !isLocalId(operation.nodeId)) {
      return invalid2(operationIndex, "nodeId", "invalid replace_node operation");
    }
    const location = index.get(operation.nodeId);
    if (location === void 0) return invalid2(operationIndex, "nodeId", "node was not found");
    const node = validateNode(operation.node, operationIndex, "node");
    if (isBoardError(node)) return node;
    if (node.id !== operation.nodeId) return invalidLayout2(operationIndex, "node", "reference");
    const replacement = structuredClone(node);
    if (location.parent === null) scene.root = replacement;
    else {
      const entries = layoutEntries(location.parent);
      if (entries === null || location.index === null)
        return invalidLayout2(operationIndex, "nodeId", "reference");
      entries[location.index] = { ...entries[location.index], node: replacement };
      const parentError = validateParent(location.parent, operationIndex);
      if (parentError !== null) return parentError;
    }
    return null;
  }
  if (operation.type === "remove_node") {
    if (!hasExactKeys3(operation, ["type", "nodeId"]) || !isLocalId(operation.nodeId)) {
      return invalid2(operationIndex, "nodeId", "invalid remove_node operation");
    }
    const location = index.get(operation.nodeId);
    if (location === void 0) return invalid2(operationIndex, "nodeId", "node was not found");
    if (location.parent === null) return invalidLayout2(operationIndex, "nodeId", "reference");
    removeLocatedNode(location);
    return validateParent(location.parent, operationIndex);
  }
  if (operation.type === "insert_child") {
    if (!hasExactKeys3(operation, ["type", "parentNodeId", "index", "node", "placement"]) || !isLocalId(operation.parentNodeId) || !isSafeIndex(operation.index)) {
      return invalid2(operationIndex, "index", "invalid insert_child operation");
    }
    const parentLocation = index.get(operation.parentNodeId);
    if (parentLocation === void 0)
      return invalid2(operationIndex, "parentNodeId", "parent was not found");
    const entries = layoutEntries(parentLocation.node);
    if (entries === null || operation.index > entries.length)
      return invalidLayout2(operationIndex, "index", "bounds");
    const node = validateNode(operation.node, operationIndex, "node");
    if (isBoardError(node)) return node;
    if (index.has(node.id)) return invalid2(operationIndex, "node", "node ID already exists");
    if (!isLayoutNode(parentLocation.node))
      return invalidLayout2(operationIndex, "parentNodeId", "reference");
    const entry = placementEntry(
      parentLocation.node,
      structuredClone(node),
      operation.placement,
      operationIndex
    );
    if (isBoardError(entry)) return entry;
    entries.splice(operation.index, 0, entry);
    return validateParent(parentLocation.node, operationIndex);
  }
  if (operation.type === "move_child") {
    const keys = [
      "type",
      "sourceParentNodeId",
      "destinationParentNodeId",
      "nodeId",
      "destinationIndex",
      "placement"
    ];
    if (!hasExactKeys3(operation, keys) || !isLocalId(operation.sourceParentNodeId) || !isLocalId(operation.destinationParentNodeId) || !isLocalId(operation.nodeId) || !isSafeIndex(operation.destinationIndex)) {
      return invalid2(operationIndex, "nodeId", "invalid move_child operation");
    }
    const source = index.get(operation.sourceParentNodeId)?.node;
    const destination = index.get(operation.destinationParentNodeId)?.node;
    const moved = index.get(operation.nodeId);
    if (source === void 0 || destination === void 0 || moved === void 0) {
      return invalid2(operationIndex, "nodeId", "move target was not found");
    }
    const sourceEntries = layoutEntries(source);
    const destinationEntries = layoutEntries(destination);
    const sourceIndex = source.type.startsWith("layout.") ? directChildIndex(source, operation.nodeId) : -1;
    if (sourceEntries === null || destinationEntries === null || sourceIndex < 0) {
      return invalidLayout2(operationIndex, "sourceParentNodeId", "reference");
    }
    let ancestor = index.get(operation.destinationParentNodeId);
    while (ancestor !== void 0) {
      if (ancestor.node.id === operation.nodeId)
        return invalidLayout2(operationIndex, "destinationParentNodeId", "reference");
      ancestor = ancestor.parent === null ? void 0 : index.get(ancestor.parent.id);
    }
    const movedNode = sourceEntries[sourceIndex]?.node;
    if (movedNode === void 0) return invalidLayout2(operationIndex, "nodeId", "reference");
    sourceEntries.splice(sourceIndex, 1);
    const maximumDestination = destinationEntries.length;
    if (operation.destinationIndex > maximumDestination)
      return invalidLayout2(operationIndex, "destinationIndex", "bounds");
    if (!isLayoutNode(source) || !isLayoutNode(destination)) {
      return invalidLayout2(operationIndex, "destinationParentNodeId", "reference");
    }
    const entry = placementEntry(destination, movedNode, operation.placement, operationIndex);
    if (isBoardError(entry)) return entry;
    destinationEntries.splice(operation.destinationIndex, 0, entry);
    const sourceError = validateParent(source, operationIndex);
    if (sourceError !== null) return sourceError;
    if (source !== destination) return validateParent(destination, operationIndex);
    return null;
  }
  if (operation.type === "set_split_weight") {
    const keys = ["type", "splitNodeId", "childNodeId", "weight"];
    if (!hasExactKeys3(operation, keys) || !isLocalId(operation.splitNodeId) || !isLocalId(operation.childNodeId) || !isFinitePositive(operation.weight)) {
      return invalid2(operationIndex, "weight", "invalid split weight operation");
    }
    const node = index.get(operation.splitNodeId)?.node;
    if (node?.type !== "layout.split")
      return invalidLayout2(operationIndex, "splitNodeId", "reference");
    const childIndex = directChildIndex(node, operation.childNodeId);
    if (childIndex < 0 || node.children[childIndex] === void 0)
      return invalidLayout2(operationIndex, "childNodeId", "reference");
    node.children[childIndex].weight = operation.weight;
    return validateParent(node, operationIndex);
  }
  if (operation.type === "set_grid_placement") {
    const keys = ["type", "gridNodeId", "childNodeId", "column", "row", "columnSpan", "rowSpan"];
    if (!hasExactKeys3(operation, keys) || !isLocalId(operation.gridNodeId) || !isLocalId(operation.childNodeId) || !isSafeIndex(operation.column) || operation.column < 1 || !isSafeIndex(operation.row) || operation.row < 1 || !isSafeIndex(operation.columnSpan) || operation.columnSpan < 1 || !isSafeIndex(operation.rowSpan) || operation.rowSpan < 1) {
      return invalid2(operationIndex, "column", "invalid grid placement operation");
    }
    const node = index.get(operation.gridNodeId)?.node;
    if (node?.type !== "layout.grid")
      return invalidLayout2(operationIndex, "gridNodeId", "reference");
    const childIndex = directChildIndex(node, operation.childNodeId);
    const child = node.children[childIndex];
    if (childIndex < 0 || child === void 0)
      return invalidLayout2(operationIndex, "childNodeId", "reference");
    Object.assign(child, {
      column: operation.column,
      row: operation.row,
      columnSpan: operation.columnSpan,
      rowSpan: operation.rowSpan
    });
    return validateParent(node, operationIndex);
  }
  if (operation.type === "set_canvas_rect") {
    const keys = ["type", "canvasNodeId", "childNodeId", "x", "y", "width", "height", "zIndex"];
    if (!hasExactKeys3(operation, keys) || !isLocalId(operation.canvasNodeId) || !isLocalId(operation.childNodeId) || !isFiniteNonNegative(operation.x) || !isFiniteNonNegative(operation.y) || !isFinitePositive(operation.width) || !isFinitePositive(operation.height) || !Number.isSafeInteger(operation.zIndex)) {
      return invalid2(operationIndex, "x", "invalid canvas rectangle operation");
    }
    const node = index.get(operation.canvasNodeId)?.node;
    if (node?.type !== "layout.canvas")
      return invalidLayout2(operationIndex, "canvasNodeId", "reference");
    const childIndex = directChildIndex(node, operation.childNodeId);
    const child = node.children[childIndex];
    if (childIndex < 0 || child === void 0)
      return invalidLayout2(operationIndex, "childNodeId", "reference");
    Object.assign(child, {
      x: operation.x,
      y: operation.y,
      width: operation.width,
      height: operation.height,
      zIndex: operation.zIndex
    });
    return validateParent(node, operationIndex);
  }
  if (operation.type === "set_active_tab") {
    if (!hasExactKeys3(operation, ["type", "tabsNodeId", "tabId"]) || !isLocalId(operation.tabsNodeId) || !isLocalId(operation.tabId)) {
      return invalid2(operationIndex, "tabId", "invalid active-tab operation");
    }
    const node = index.get(operation.tabsNodeId)?.node;
    if (node?.type !== "layout.tabs" || !node.tabs.some((tab) => tab.tabId === operation.tabId)) {
      return invalidLayout2(operationIndex, "tabId", "reference");
    }
    node.activeTabId = operation.tabId;
    return validateParent(node, operationIndex);
  }
  if (operation.type === "upsert_drawing_element") {
    if (!hasExactKeys3(operation, ["type", "drawingNodeId", "element"]) || !isLocalId(operation.drawingNodeId)) {
      return invalid2(operationIndex, "drawingNodeId", "invalid drawing element operation");
    }
    const node = index.get(operation.drawingNodeId)?.node;
    const elementCandidate = operation.element;
    if (node?.type !== "content.drawing" || !isRecord4(elementCandidate) || !isLocalId(elementCandidate.id)) {
      return invalidLayout2(operationIndex, "drawingNodeId", "reference");
    }
    const elementIndex = node.elements.findIndex((element2) => element2.id === elementCandidate.id);
    const element = structuredClone(elementCandidate);
    if (elementIndex < 0) node.elements.push(element);
    else node.elements[elementIndex] = element;
    const parsed = BoardNodeParserV1.parse(node);
    return parsed.ok ? null : prefixError(parsed.error, operationIndex, "element");
  }
  if (operation.type === "remove_drawing_element") {
    if (!hasExactKeys3(operation, ["type", "drawingNodeId", "elementId"]) || !isLocalId(operation.drawingNodeId) || !isLocalId(operation.elementId)) {
      return invalid2(operationIndex, "elementId", "invalid drawing element removal");
    }
    const node = index.get(operation.drawingNodeId)?.node;
    if (node?.type !== "content.drawing")
      return invalidLayout2(operationIndex, "drawingNodeId", "reference");
    const elementIndex = node.elements.findIndex((element) => element.id === operation.elementId);
    if (elementIndex < 0)
      return invalid2(operationIndex, "elementId", "drawing element was not found");
    node.elements.splice(elementIndex, 1);
    return null;
  }
  return invalid2(operationIndex, "type", "unknown scene transform operation");
};
var applySceneTransformV1 = (scene, operations) => {
  const source = SceneParserV1.parse(scene);
  if (!source.ok) return source;
  if (!Array.isArray(operations) || operations.length < 1) {
    return errorResult(invalid2(0, "type", "at least one operation is required"));
  }
  if (operations.length > BOARD_LIMITS_V1.maxJsonContainerEntries) {
    return errorResult({
      protocolVersion: 1,
      type: "board.error",
      code: "LIMIT_EXCEEDED",
      message: "Contract limit exceeded",
      category: "validation",
      retryable: false,
      httpStatusHint: 422,
      details: {
        limit: "maxJsonContainerEntries",
        actual: operations.length,
        maximum: BOARD_LIMITS_V1.maxJsonContainerEntries,
        path: ["operations"]
      }
    });
  }
  const canonicalOperations = canonicalizeJsonV1({ operations });
  if (!canonicalOperations.ok) return canonicalOperations;
  if (canonicalOperations.data.canonicalBytes.byteLength > BOARD_LIMITS_V1.maxEnvelopeBytes) {
    return errorResult({
      protocolVersion: 1,
      type: "board.error",
      code: "PAYLOAD_TOO_LARGE",
      message: "Payload is too large",
      category: "validation",
      retryable: false,
      httpStatusHint: 413,
      details: {
        scope: "envelope",
        actualBytes: canonicalOperations.data.canonicalBytes.byteLength,
        maximumBytes: BOARD_LIMITS_V1.maxEnvelopeBytes
      }
    });
  }
  let working;
  try {
    working = structuredClone(source.data.value);
  } catch {
    return errorResult(invalid2(0, "type", "scene cannot be cloned"));
  }
  for (let operationIndex = 0; operationIndex < operations.length; operationIndex += 1) {
    const error3 = applyOperation(working, operations[operationIndex], operationIndex);
    if (error3 !== null) return errorResult(error3);
  }
  return SceneParserV1.parse(working);
};

// sceneboard-mcp/src/tools/scene.tools.ts
var SceneGetInputSchemaV1 = external_exports.object({ boardId: GlobalIdSchemaV1, revisionId: GlobalIdSchemaV1.nullable() }).strict();
var SceneReplaceInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12,
  scene: external_exports.unknown()
}).strict();
var ScenePatchInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12,
  operations: external_exports.array(SceneTransformOperationSchemaV1).min(1).max(1e3)
}).strict();
var SceneClearInputSchemaV1 = external_exports.object({
  boardId: GlobalIdSchemaV1,
  expectedRevisionId: GlobalIdSchemaV1,
  idempotencyKey: IdempotencyKeySchemaV12
}).strict();
var documentMismatch = (tool, requestId) => toolFailureV1(tool, requestId, "board", {
  protocolVersion: 1,
  type: "board.error",
  code: "DOCUMENT_VERSION_MISMATCH",
  message: "Document version mismatch",
  category: "conflict",
  retryable: false,
  httpStatusHint: 409,
  details: {
    headSchemaVersion: 2,
    commandSchemaVersion: 1,
    commandType: "scene.replace"
  }
});
var isCallToolResult2 = (value) => value !== null && typeof value === "object" && !("ok" in value) && "content" in value && Array.isArray(value.content);
var SceneToolHandlersV1 = class {
  constructor(gateway) {
    this.gateway = gateway;
  }
  async get(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = SceneGetInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_scene_get", requestId, parsed.error);
    if (parsed.data.revisionId === null) {
      const result2 = await this.gateway.call(
        "board_scene_get",
        ["board.get"],
        {
          signal,
          authorization: { boardId: parsed.data.boardId, operation: "board.get" }
        },
        (client, _snapshot, operationSignal) => client.getBoard(
          {
            protocolVersion: 1,
            requestId,
            type: "board.get",
            boardId: parsed.data.boardId
          },
          operationSignal
        )
      );
      if (result2.connected && result2.value.ok && result2.value.result.result.type === "board.get" && "document" in result2.value.result.result.snapshot)
        return documentMismatch("board_scene_get", requestId);
      return result2.connected ? sdkToolResultV1("board_scene_get", requestId, result2.value, null) : toolFailureV1(
        "board_scene_get",
        requestId,
        "mcp",
        notConnectedV1()
      );
    }
    const result = await this.gateway.call(
      "board_scene_get",
      ["history.get"],
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "history.get" }
      },
      (client, _snapshot, operationSignal) => client.getHistory(
        {
          protocolVersion: 1,
          requestId,
          type: "history.get",
          boardId: parsed.data.boardId,
          revisionId: parsed.data.revisionId
        },
        operationSignal
      )
    );
    if (result.connected && result.value.ok && result.value.result.result.type === "history.get" && "document" in result.value.result.result.snapshot)
      return documentMismatch("board_scene_get", requestId);
    return result.connected ? sdkToolResultV1(
      "board_scene_get",
      requestId,
      result.value,
      result.value.ok ? { type: "history", history: result.value.metadata.history } : null
    ) : toolFailureV1(
      "board_scene_get",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async replace(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = SceneReplaceInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_scene_replace", requestId, parsed.error);
    const scene = SceneParserV1.parse(parsed.data.scene);
    if (!scene.ok)
      return toolFailureV1(
        "board_scene_replace",
        requestId,
        "board",
        scene.error
      );
    const result = await this.gateway.call(
      "board_scene_replace",
      "scene.replace",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "scene.replace" }
      },
      (client, _snapshot, operationSignal) => client.mutateBoard(
        {
          protocolVersion: 1,
          requestId,
          boardId: parsed.data.boardId,
          expectedRevisionId: parsed.data.expectedRevisionId,
          idempotencyKey: parsed.data.idempotencyKey,
          command: { type: "scene.replace", scene: scene.data.value }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_scene_replace", requestId, result.value, null) : toolFailureV1(
      "board_scene_replace",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
  async patch(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = ScenePatchInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_scene_patch", requestId, parsed.error);
    let transformedFromRevisionId = null;
    const result = await this.gateway.call(
      "board_scene_patch",
      ["board.get", "scene.replace"],
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "scene.replace" }
      },
      async (client, _snapshot, operationSignal) => {
        const head = await client.getBoard(
          {
            protocolVersion: 1,
            requestId,
            type: "board.get",
            boardId: parsed.data.boardId
          },
          operationSignal
        );
        if (!head.ok) return head;
        const snapshot = head.result.result;
        if (snapshot.type !== "board.get") throw new Error("board.get result invariant failed");
        if ("document" in snapshot.snapshot)
          return documentMismatch("board_scene_patch", requestId);
        const transformed = applySceneTransformV1(
          snapshot.snapshot.scene,
          parsed.data.operations
        );
        if (!transformed.ok)
          return toolFailureV1(
            "board_scene_patch",
            requestId,
            "board",
            transformed.error
          );
        transformedFromRevisionId = snapshot.snapshot.revision.revisionId;
        return client.mutateBoard(
          {
            protocolVersion: 1,
            requestId,
            boardId: parsed.data.boardId,
            expectedRevisionId: parsed.data.expectedRevisionId,
            idempotencyKey: parsed.data.idempotencyKey,
            command: { type: "scene.replace", scene: transformed.data.value }
          },
          operationSignal
        );
      }
    );
    if (!result.connected)
      return toolFailureV1(
        "board_scene_patch",
        requestId,
        "mcp",
        notConnectedV1()
      );
    if (isCallToolResult2(result.value)) return result.value;
    if (result.value.ok && transformedFromRevisionId === null)
      throw new Error("scene transform metadata invariant failed");
    return sdkToolResultV1(
      "board_scene_patch",
      requestId,
      result.value,
      result.value.ok ? { type: "scene-transform", transformedFromRevisionId } : null
    );
  }
  async clear(raw, signal) {
    const requestId = createRequestIdV1();
    const parsed = SceneClearInputSchemaV1.safeParse(raw);
    if (!parsed.success) return validationFailureV1("board_scene_clear", requestId, parsed.error);
    const result = await this.gateway.call(
      "board_scene_clear",
      "scene.clear",
      {
        signal,
        authorization: { boardId: parsed.data.boardId, operation: "scene.clear" }
      },
      (client, _snapshot, operationSignal) => client.mutateBoard(
        {
          protocolVersion: 1,
          requestId,
          boardId: parsed.data.boardId,
          expectedRevisionId: parsed.data.expectedRevisionId,
          idempotencyKey: parsed.data.idempotencyKey,
          command: { type: "scene.clear" }
        },
        operationSignal
      )
    );
    return result.connected ? sdkToolResultV1("board_scene_clear", requestId, result.value, null) : toolFailureV1(
      "board_scene_clear",
      requestId,
      "mcp",
      notConnectedV1()
    );
  }
};

// sceneboard-mcp/src/tools/register-tools.ts
var CORE_TOOL_NAMES_V1 = [
  "board_connection_status",
  "board_pair_request",
  "board_pair_status",
  "board_list",
  "board_get",
  "board_create",
  "board_archive",
  "board_capabilities_get",
  "board_scene_get",
  "board_scene_replace",
  "board_scene_patch",
  "board_scene_clear",
  "board_document_get",
  "board_document_replace",
  "board_page_add",
  "board_page_remove",
  "board_page_reorder",
  "board_page_update",
  "board_page_default_set",
  "sceneboard_media_upload",
  "sceneboard_media_place",
  "board_history_list",
  "board_history_get",
  "board_history_restore"
];
var SAFE_TOOL_NAMES_V1 = CORE_TOOL_NAMES_V1.slice(0, 3);
var PROTECTED_CORE_TOOL_NAMES_V1 = CORE_TOOL_NAMES_V1.slice(3);
var DOWNSTREAM_TOOL_NAMES_V1 = [
  "board_artifact_get",
  "board_artifact_put",
  "board_artifact_stop",
  "board_interaction_request",
  "board_interaction_status",
  "board_interaction_respond"
];
var BOARD_TOOL_NAMES_V1 = [
  ...CORE_TOOL_NAMES_V1.slice(0, 21),
  ...DOWNSTREAM_TOOL_NAMES_V1.slice(0, 3),
  ...CORE_TOOL_NAMES_V1.slice(21),
  ...DOWNSTREAM_TOOL_NAMES_V1.slice(3)
];
var API_KEY_TOOL_NAMES_V1 = [
  "board_connection_status",
  "board_list",
  "board_get",
  "board_create",
  "board_rename",
  "board_archive",
  "board_capabilities_get",
  "board_scene_get",
  "board_scene_replace",
  "board_scene_patch",
  "board_scene_clear",
  "board_document_get",
  "board_document_replace",
  "board_page_add",
  "board_page_remove",
  "board_page_reorder",
  "board_page_update",
  "board_page_default_set",
  "board_history_list",
  "board_history_get",
  "board_history_restore",
  "sceneboard_media_upload",
  "sceneboard_media_place",
  "board_artifact_get",
  "board_artifact_put",
  "board_artifact_stop",
  "board_interaction_request",
  "board_interaction_status",
  "board_interaction_respond",
  "board_export"
];
var BOARD_TOOL_ERROR_CODES_V1 = {
  board_connection_status: [
    "INVALID_PAYLOAD",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_pair_request: [
    "INVALID_PAYLOAD",
    "PAIRING_UNAVAILABLE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE"
  ],
  board_pair_status: [
    "INVALID_PAYLOAD",
    "PAIRING_PROOF_INVALID",
    "PAIRING_NOT_READY",
    "PAIRING_TERMINAL",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE"
  ],
  board_list: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_get: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_create: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "IDEMPOTENCY_KEY_REUSED",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_rename: [
    "INVALID_PAYLOAD",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_archive: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "BOARD_ALREADY_ARCHIVED",
    "IDEMPOTENCY_KEY_REUSED",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_capabilities_get: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_scene_get: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_NOT_FOUND",
    "DOCUMENT_VERSION_MISMATCH",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_scene_replace: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_scene_patch: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_scene_clear: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_document_get: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_NOT_FOUND",
    "DOCUMENT_VERSION_MISMATCH",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_document_replace: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "INVALID_DOCUMENT",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_page_add: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "INVALID_DOCUMENT",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_page_remove: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "INVALID_DOCUMENT",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_page_reorder: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "INVALID_DOCUMENT",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_page_update: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "INVALID_DOCUMENT",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_page_default_set: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "INVALID_DOCUMENT",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  sceneboard_media_upload: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "INVALID_REQUEST",
    "IDEMPOTENCY_KEY_REUSED",
    "IDEMPOTENCY_RESULT_EXPIRED",
    "PAYLOAD_TOO_LARGE",
    "INVALID_MEDIA_UPLOAD",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  sceneboard_media_place: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "DOCUMENT_VERSION_MISMATCH",
    "INVALID_DOCUMENT",
    "UNKNOWN_NODE_TYPE",
    "INVALID_LAYOUT",
    "DUPLICATE_NODE_ID",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_history_list: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_history_get: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_history_restore: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_export: [
    "EXPORT_INVALID_REQUEST",
    "EXPORT_UNAUTHENTICATED",
    "EXPORT_FORBIDDEN",
    "EXPORT_NOT_FOUND",
    "EXPORT_REQUIRED_CONTENT_UNSUPPORTED",
    "EXPORT_BOUNDS_EXCEEDED",
    "EXPORT_RATE_LIMITED",
    "EXPORT_RENDERER_UNAVAILABLE",
    "EXPORT_RENDER_TIMEOUT",
    "EXPORT_ENCODE_FAILED",
    "EXPORT_INTERNAL_ERROR"
  ],
  board_artifact_get: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "ARTIFACT_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_artifact_put: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "CAPABILITY_DENIED",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_artifact_stop: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "ARTIFACT_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_interaction_request: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "HITL_REQUEST_ID_CONFLICT",
    "LIMIT_EXCEEDED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_interaction_status: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "HITL_REQUEST_NOT_FOUND",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ],
  board_interaction_respond: [
    "INVALID_PAYLOAD",
    "PROTOCOL_VERSION_MISMATCH",
    "UNAUTHENTICATED",
    "FORBIDDEN",
    "BOARD_NOT_FOUND",
    "REVISION_CONFLICT",
    "IDEMPOTENCY_KEY_REUSED",
    "HITL_REQUEST_NOT_FOUND",
    "HITL_RESPONSE_CONFLICT",
    "HITL_REQUEST_EXPIRED",
    "PAYLOAD_TOO_LARGE",
    "RATE_LIMITED",
    "SERVICE_UNAVAILABLE",
    "INTERNAL_ERROR"
  ]
};
var registerCoreToolsV1 = (server, options) => {
  const registered = /* @__PURE__ */ new Map();
  const boards = new BoardToolHandlersV1(options.gateway);
  const scenes = new SceneToolHandlersV1(options.gateway);
  const documents = new DocumentToolHandlersV2(options.gateway);
  const history = new HistoryToolHandlersV1(options.gateway);
  const artifacts = new ArtifactToolHandlersV1(options.gateway);
  const interactions = new InteractionToolHandlersV1(options.gateway);
  const media = new MediaToolHandlersV1(options.gateway);
  const exports = new ExportToolHandlersV1(options.gateway, options.localExports ?? null);
  const credentialMode = options.credentialMode ?? "pairing";
  const names = credentialMode === "api_key" ? API_KEY_TOOL_NAMES_V1 : options.downstreamReady === true ? BOARD_TOOL_NAMES_V1 : CORE_TOOL_NAMES_V1;
  const protectedNames = names.filter(
    (name) => !SAFE_TOOL_NAMES_V1.includes(name)
  );
  let protectedEnabled = options.authenticated;
  const setProtectedEnabled = (enabled) => {
    if (protectedEnabled === enabled) return;
    protectedEnabled = enabled;
    for (const name of protectedNames) {
      const tool = registered.get(name);
      if (enabled) tool?.enable();
      else tool?.disable();
    }
  };
  const connection = new ConnectionToolHandlersV1(
    options.connections,
    options.pairing,
    (connected) => setProtectedEnabled(connected)
  );
  const add = (name, description, inputSchema, handler, protectedTool = false) => {
    const tool = server.registerTool(
      name,
      {
        description,
        inputSchema: descriptorInputSchemaV1(inputSchema),
        outputSchema: toolOutputSchemaV1(name, BOARD_TOOL_ERROR_CODES_V1[name])
      },
      async (raw, extra) => {
        let result;
        try {
          result = await handler(raw, extra.signal);
        } catch {
          result = toolFailureV1(name, randomBytes10(16).toString("base64url"), "mcp", {
            code: "BOARD_MCP_INTERNAL_ERROR",
            message: "SceneBoard tool execution failed",
            retryable: false,
            details: { incidentId: randomBytes10(16).toString("base64url") }
          });
        }
        const structured = result.structuredContent;
        const error3 = structured?.error;
        if (error3?.source === "board" && (error3.value?.code === "UNAUTHENTICATED" || error3.value?.code === "EXPORT_UNAUTHENTICATED"))
          setProtectedEnabled(false);
        return result;
      }
    );
    registered.set(name, tool);
    if (protectedTool && !protectedEnabled) tool.disable();
  };
  add(
    "board_connection_status",
    "Report redacted SceneBoard connection state for an explicit board ID or null.",
    ConnectionStatusInputSchemaV1,
    (raw, signal) => connection.status(raw, signal)
  );
  if (credentialMode === "pairing") {
    add(
      "board_pair_request",
      "Claim a human-created pairing code using the configured private credential sink.",
      PairRequestInputSchemaV1,
      (raw, signal) => connection.pairRequest(raw, signal)
    );
    add(
      "board_pair_status",
      "Wait for or read the current proof-authenticated pairing state.",
      PairStatusInputSchemaV1,
      (raw, signal) => connection.pairStatus(raw, signal)
    );
  }
  add(
    "board_list",
    "List authorized SceneBoard boards.",
    BoardListInputSchemaV1,
    (raw, signal) => boards.list(raw, signal),
    true
  );
  add(
    "board_get",
    "Read one current board summary and snapshot.",
    BoardGetInputSchemaV1,
    (raw, signal) => boards.get(raw, signal),
    true
  );
  add(
    "board_create",
    "Create an empty board with caller-owned idempotency.",
    BoardCreateInputSchemaV1,
    (raw, signal) => boards.create(raw, signal),
    true
  );
  if (credentialMode === "api_key") {
    add(
      "board_rename",
      "Rename one owner board.",
      BoardRenameInputSchemaV1,
      (raw, signal) => boards.rename(raw, signal),
      true
    );
  }
  add(
    "board_archive",
    "Archive one board with explicit confirmation.",
    BoardArchiveInputSchemaV1,
    (raw, signal) => boards.archive(raw, signal),
    true
  );
  add(
    "board_capabilities_get",
    "Read current server-authorized capabilities for one board.",
    BoardCapabilitiesInputSchemaV1,
    (raw, signal) => boards.capabilities(raw, signal),
    true
  );
  add(
    "board_scene_get",
    "Read a live or exact historical scene.",
    SceneGetInputSchemaV1,
    (raw, signal) => scenes.get(raw, signal),
    true
  );
  add(
    "board_scene_replace",
    "Replace a scene at an explicitly observed head.",
    SceneReplaceInputSchemaV1,
    (raw, signal) => scenes.replace(raw, signal),
    true
  );
  add(
    "board_scene_patch",
    "Apply the closed local transform catalog and submit one scene replacement.",
    ScenePatchInputSchemaV1,
    (raw, signal) => scenes.patch(raw, signal),
    true
  );
  add(
    "board_scene_clear",
    "Clear a scene and create a restorable checkpoint.",
    SceneClearInputSchemaV1,
    (raw, signal) => scenes.clear(raw, signal),
    true
  );
  add(
    "board_document_get",
    "Read one exact current or historical V2 document snapshot.",
    DocumentGetInputSchemaV2,
    (raw, signal) => documents.get(raw, signal),
    true
  );
  add(
    "board_document_replace",
    "Replace one V2 document at an explicitly observed head.",
    DocumentReplaceInputSchemaV2,
    (raw, signal) => documents.replace(raw, signal),
    true
  );
  add(
    "board_page_add",
    "Add one caller-identified page through a whole-document replacement.",
    PageAddInputSchemaV2,
    (raw, signal) => documents.add(raw, signal),
    true
  );
  add(
    "board_page_remove",
    "Remove one explicit non-default page through a whole-document replacement.",
    PageRemoveInputSchemaV2,
    (raw, signal) => documents.remove(raw, signal),
    true
  );
  add(
    "board_page_reorder",
    "Move one explicit page to a resulting-list index.",
    PageReorderInputSchemaV2,
    (raw, signal) => documents.reorder(raw, signal),
    true
  );
  add(
    "board_page_update",
    "Update one page title, display mode, or scene through a whole-document replacement.",
    PageUpdateInputSchemaV2,
    (raw, signal) => documents.update(raw, signal),
    true
  );
  add(
    "board_page_default_set",
    "Set the existing default page through a whole-document replacement.",
    PageDefaultSetInputSchemaV2,
    (raw, signal) => documents.defaultSet(raw, signal),
    true
  );
  if (credentialMode === "pairing" || credentialMode === "api_key") {
    add(
      "sceneboard_media_upload",
      "Upload one explicitly authorized local PNG, JPEG, or WebP file.",
      MediaUploadInputSchemaV1,
      (raw, signal) => media.upload(raw, signal),
      true
    );
    add(
      "sceneboard_media_place",
      "Place one immutable media image in an exact V2 document revision.",
      MediaPlaceInputSchemaV1,
      (raw, signal) => media.place(raw, signal),
      true
    );
  }
  if (options.downstreamReady === true) {
    add(
      "board_artifact_get",
      "Read one exact immutable artifact/version manifest and runtime state.",
      ArtifactGetInputSchemaV1,
      (raw, signal) => artifacts.get(raw, signal),
      true
    );
    add(
      "board_artifact_put",
      "Publish a bounded HTML/CSS/JavaScript source bundle as one immutable artifact version.",
      ArtifactPutInputSchemaV1,
      (raw, signal) => artifacts.put(raw, signal),
      true
    );
    add(
      "board_artifact_stop",
      "Stop one exact artifact runtime without removing its scene placement.",
      ArtifactStopInputSchemaV1,
      (raw, signal) => artifacts.stop(raw, signal),
      true
    );
  }
  add(
    "board_history_list",
    "List immutable board revisions newest first.",
    HistoryListInputSchemaV1,
    (raw, signal) => history.list(raw, signal),
    true
  );
  add(
    "board_history_get",
    "Read one immutable revision and aligned navigation metadata.",
    HistoryGetInputSchemaV1,
    (raw, signal) => history.get(raw, signal),
    true
  );
  add(
    "board_history_restore",
    "Copy-forward an immutable revision into a new head.",
    HistoryRestoreInputSchemaV1,
    (raw, signal) => history.restore(raw, signal),
    true
  );
  if (credentialMode === "api_key") {
    add(
      "board_export",
      "Export one explicit retained board revision to a new no-clobber local PDF or PPTX file.",
      BoardExportInputSchemaV1,
      (raw, signal) => exports.export(raw, signal),
      true
    );
  }
  if (options.downstreamReady === true) {
    add(
      "board_interaction_request",
      "Create an exact human interaction, then immediately await it with board_interaction_status.",
      InteractionRequestInputSchemaV1,
      (raw, signal) => interactions.request(raw, signal),
      true
    );
    add(
      "board_interaction_status",
      "Read or bounded-wait for an interaction; bounded wait is the primary response delivery path.",
      InteractionStatusInputSchemaV1,
      (raw, signal) => interactions.status(raw, signal),
      true
    );
    add(
      "board_interaction_respond",
      "Record one exact typed response with server-owned chronology and conflict checks.",
      InteractionRespondInputSchemaV1,
      (raw, signal) => interactions.respond(raw, signal),
      true
    );
  }
  return { names, setProtectedEnabled };
};

// sceneboard-mcp/src/server.ts
var MissingTokenProviderV1 = class {
  async snapshot(signal) {
    signal?.throwIfAborted();
    return null;
  }
  async invalidate(_snapshot, signal) {
    signal?.throwIfAborted();
  }
};
var configuredParts = async (loaded, env, fetchImplementation, logger) => {
  const reference = resolveSecretReferenceV1(loaded.config, env);
  const credentialMode = loaded.config.credentialMode ?? "pairing";
  let tokens;
  let pairing;
  const connectionClient = new ConnectionHttpClientV1({
    baseUrl: loaded.config.baseUrl,
    fetch: fetchImplementation,
    timeoutMs: loaded.config.timeoutMs,
    logger
  });
  if (credentialMode === "api_key") {
    if (reference.kind === "environment") {
      tokens = new ApiKeyTokenProviderV1({
        kind: "environment",
        apiKey: env.SCENEBOARD_API_KEY
      });
    } else {
      const store = new PrivateFileApiKeyStoreV1(reference.stateDirectory);
      tokens = new ApiKeyTokenProviderV1({ kind: "store", store });
    }
    pairing = new UnavailablePairingCoordinatorV1("read_only");
    return {
      loaded,
      tokens,
      pairing,
      connections: new ApiKeyConnectionStatusServiceV1(loaded, tokens, connectionClient),
      credentialMode
    };
  }
  if (reference.kind === "environment") {
    tokens = new EnvironmentTokenProviderV1(env.SCENEBOARD_ACCESS_TOKEN);
    pairing = new UnavailablePairingCoordinatorV1("read_only");
  } else {
    const helperPath = fileURLToPath(new URL("../native/profile-lease-helper", import.meta.url));
    const digestPath = fileURLToPath(
      new URL("../native/profile-lease-helper.sha256", import.meta.url)
    );
    const leases = new ProfileLeaseProviderV1(
      new LinuxProfileLeaseHelperAdapterV1(helperPath, digestPath)
    );
    const store = new PrivateFileCredentialStoreV1(reference.stateDirectory);
    const available = await leases.verify().catch(() => false) && await store.preflight().then(
      () => true,
      () => false
    );
    if (!available) {
      tokens = new MissingTokenProviderV1();
      pairing = new UnavailablePairingCoordinatorV1("unavailable");
    } else {
      tokens = new StoredTokenProviderV1(store, leases);
      const installations = new InstallationIdentityStoreV1(reference.stateDirectory);
      let connectionProbe = async () => false;
      pairing = new PairingSessionOwnerV1(
        store,
        installations,
        leases,
        (proofHeaderProvider) => new PairingHttpClientV1({
          baseUrl: loaded.config.baseUrl,
          fetch: fetchImplementation,
          timeoutMs: loaded.config.timeoutMs,
          proofHeaderProvider
        }),
        (accessToken, signal) => connectionProbe(accessToken, signal)
      );
      const connections = new ConnectionStatusServiceV1(loaded, tokens, connectionClient);
      connectionProbe = (accessToken, signal) => connections.probeWithToken(accessToken, signal);
      return { loaded, tokens, pairing, connections, credentialMode };
    }
  }
  return {
    loaded,
    tokens,
    pairing,
    connections: new ConnectionStatusServiceV1(loaded, tokens, connectionClient),
    credentialMode
  };
};
var createBoardMcpServerV1 = async (options = {}) => {
  const env = options.env ?? process.env;
  const logger = new SafeStderrLoggerV1(options.stderr);
  const fetchImplementation = options.fetch ?? globalThis.fetch;
  let pairing = new UnavailablePairingCoordinatorV1("unavailable");
  let connections = new UnconfiguredConnectionStatusServiceV1();
  let gateway = new ProtectedBoardGatewayV1({
    baseUrl: "http://127.0.0.1:1",
    fetch: async () => {
      throw new Error("unconfigured");
    },
    timeoutMs: 1e3,
    tokens: new MissingTokenProviderV1(),
    logger
  });
  let authenticated = false;
  let credentialMode = "pairing";
  try {
    const loaded = await discoverBoardConfigV1({
      argv: options.argv ?? process.argv.slice(2),
      cwd: options.cwd ?? process.cwd(),
      env
    });
    const parts = await configuredParts(loaded, env, fetchImplementation, logger);
    credentialMode = parts.credentialMode;
    pairing = parts.pairing;
    connections = parts.connections;
    gateway = new ProtectedBoardGatewayV1({
      baseUrl: parts.loaded.config.baseUrl,
      fetch: fetchImplementation,
      timeoutMs: parts.loaded.config.timeoutMs,
      tokens: parts.tokens,
      logger,
      credentialMode
    });
    if (options.probeOnStart !== false) {
      const probe = await parts.connections.status(null, randomBytes11(16).toString("base64url"));
      authenticated = probe.ok && probe.value.state === "connected";
    }
  } catch (error3) {
    logger.log({
      event: error3 instanceof BoardConfigError ? "config_invalid" : "startup_boundary_unavailable"
    });
  }
  const server = new McpServer(
    { name: "SceneBoard", version: "0.0.0" },
    {
      capabilities: { tools: { listChanged: true } }
    }
  );
  const registry2 = registerCoreToolsV1(server, {
    gateway,
    pairing,
    connections,
    authenticated,
    downstreamReady: true,
    credentialMode,
    localExports: new LocalExportFileV1({
      manifestPath: fileURLToPath(
        new URL("../native/local-export-helper.manifest.json", import.meta.url)
      )
    })
  });
  let closed = false;
  return {
    server,
    registry: registry2,
    authenticated,
    connect: (transport) => server.connect(transport),
    close: async () => {
      if (closed) return;
      closed = true;
      await pairing.close().catch(() => void 0);
      await server.close().catch(() => void 0);
    }
  };
};

// sceneboard-mcp/src/index.ts
var command = await runApiKeyCredentialCommandV1({
  argv: process.argv.slice(2),
  cwd: process.cwd(),
  env: process.env,
  stdin: process.stdin,
  stdout: (value) => process.stdout.write(value),
  stderr: (value) => process.stderr.write(value)
});
if (command.handled) {
  process.exitCode = command.exitCode;
} else {
  const runtime = await createBoardMcpServerV1();
  const transport = new StdioServerTransport();
  let closing = false;
  const shutdown = async () => {
    if (closing) return;
    closing = true;
    await runtime.close();
  };
  process.stdin.once("end", () => {
    void shutdown();
  });
  process.once("SIGINT", () => {
    void shutdown();
  });
  process.once("SIGTERM", () => {
    void shutdown();
  });
  try {
    await runtime.connect(transport);
  } catch {
    process.stderr.write('{"event":"mcp_start_failed"}\n');
    process.exitCode = 1;
    await shutdown();
  }
}
