@pi-oxide/extension-js 0.6.0 → 0.7.0

package/worker.js

@@ -1,12 +1,3449 @@
-import x, { setLogLevel as L, ExtensionSession as ee, registerJsCallBatch as re } from "./extension_js.js";
-const I = {
+import Pt, { setLogLevel as Fe, ExtensionSession as Zt, registerJsCallBatch as Dt } from "./extension_js.js";
+var S;
+(function(t) {
+  t.assertEqual = (n) => {
+  };
+  function e(n) {
+  }
+  t.assertIs = e;
+  function r(n) {
+    throw new Error();
+  }
+  t.assertNever = r, t.arrayToEnum = (n) => {
+    const i = {};
+    for (const o of n)
+      i[o] = o;
+    return i;
+  }, t.getValidEnumValues = (n) => {
+    const i = t.objectKeys(n).filter((a) => typeof n[n[a]] != "number"), o = {};
+    for (const a of i)
+      o[a] = n[a];
+    return t.objectValues(o);
+  }, t.objectValues = (n) => t.objectKeys(n).map(function(i) {
+    return n[i];
+  }), t.objectKeys = typeof Object.keys == "function" ? (n) => Object.keys(n) : (n) => {
+    const i = [];
+    for (const o in n)
+      Object.prototype.hasOwnProperty.call(n, o) && i.push(o);
+    return i;
+  }, t.find = (n, i) => {
+    for (const o of n)
+      if (i(o))
+        return o;
+  }, t.isInteger = typeof Number.isInteger == "function" ? (n) => Number.isInteger(n) : (n) => typeof n == "number" && Number.isFinite(n) && Math.floor(n) === n;
+  function s(n, i = " | ") {
+    return n.map((o) => typeof o == "string" ? `'${o}'` : o).join(i);
+  }
+  t.joinValues = s, t.jsonStringifyReplacer = (n, i) => typeof i == "bigint" ? i.toString() : i;
+})(S || (S = {}));
+var ht;
+(function(t) {
+  t.mergeShapes = (e, r) => ({
+    ...e,
+    ...r
+    // second overwrites first
+  });
+})(ht || (ht = {}));
+const m = S.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]), K = (t) => {
+  switch (typeof t) {
+    case "undefined":
+      return m.undefined;
+    case "string":
+      return m.string;
+    case "number":
+      return Number.isNaN(t) ? m.nan : m.number;
+    case "boolean":
+      return m.boolean;
+    case "function":
+      return m.function;
+    case "bigint":
+      return m.bigint;
+    case "symbol":
+      return m.symbol;
+    case "object":
+      return Array.isArray(t) ? m.array : t === null ? m.null : t.then && typeof t.then == "function" && t.catch && typeof t.catch == "function" ? m.promise : typeof Map < "u" && t instanceof Map ? m.map : typeof Set < "u" && t instanceof Set ? m.set : typeof Date < "u" && t instanceof Date ? m.date : m.object;
+    default:
+      return m.unknown;
+  }
+}, u = S.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"
+]);
+class j extends Error {
+  get errors() {
+    return this.issues;
+  }
+  constructor(e) {
+    super(), this.issues = [], this.addIssue = (s) => {
+      this.issues = [...this.issues, s];
+    }, this.addIssues = (s = []) => {
+      this.issues = [...this.issues, ...s];
+    };
+    const r = new.target.prototype;
+    Object.setPrototypeOf ? Object.setPrototypeOf(this, r) : this.__proto__ = r, this.name = "ZodError", this.issues = e;
+  }
+  format(e) {
+    const r = e || function(i) {
+      return i.message;
+    }, s = { _errors: [] }, n = (i) => {
+      for (const o of i.issues)
+        if (o.code === "invalid_union")
+          o.unionErrors.map(n);
+        else if (o.code === "invalid_return_type")
+          n(o.returnTypeError);
+        else if (o.code === "invalid_arguments")
+          n(o.argumentsError);
+        else if (o.path.length === 0)
+          s._errors.push(r(o));
+        else {
+          let a = s, h = 0;
+          for (; h < o.path.length; ) {
+            const l = o.path[h];
+            h === o.path.length - 1 ? (a[l] = a[l] || { _errors: [] }, a[l]._errors.push(r(o))) : a[l] = a[l] || { _errors: [] }, a = a[l], h++;
+          }
+        }
+    };
+    return n(this), s;
+  }
+  static assert(e) {
+    if (!(e instanceof j))
+      throw new Error(`Not a ZodError: ${e}`);
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, S.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(e = (r) => r.message) {
+    const r = {}, s = [];
+    for (const n of this.issues)
+      if (n.path.length > 0) {
+        const i = n.path[0];
+        r[i] = r[i] || [], r[i].push(e(n));
+      } else
+        s.push(e(n));
+    return { formErrors: s, fieldErrors: r };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+}
+j.create = (t) => new j(t);
+const ke = (t, e) => {
+  let r;
+  switch (t.code) {
+    case u.invalid_type:
+      t.received === m.undefined ? r = "Required" : r = `Expected ${t.expected}, received ${t.received}`;
+      break;
+    case u.invalid_literal:
+      r = `Invalid literal value, expected ${JSON.stringify(t.expected, S.jsonStringifyReplacer)}`;
+      break;
+    case u.unrecognized_keys:
+      r = `Unrecognized key(s) in object: ${S.joinValues(t.keys, ", ")}`;
+      break;
+    case u.invalid_union:
+      r = "Invalid input";
+      break;
+    case u.invalid_union_discriminator:
+      r = `Invalid discriminator value. Expected ${S.joinValues(t.options)}`;
+      break;
+    case u.invalid_enum_value:
+      r = `Invalid enum value. Expected ${S.joinValues(t.options)}, received '${t.received}'`;
+      break;
+    case u.invalid_arguments:
+      r = "Invalid function arguments";
+      break;
+    case u.invalid_return_type:
+      r = "Invalid function return type";
+      break;
+    case u.invalid_date:
+      r = "Invalid date";
+      break;
+    case u.invalid_string:
+      typeof t.validation == "object" ? "includes" in t.validation ? (r = `Invalid input: must include "${t.validation.includes}"`, typeof t.validation.position == "number" && (r = `${r} at one or more positions greater than or equal to ${t.validation.position}`)) : "startsWith" in t.validation ? r = `Invalid input: must start with "${t.validation.startsWith}"` : "endsWith" in t.validation ? r = `Invalid input: must end with "${t.validation.endsWith}"` : S.assertNever(t.validation) : t.validation !== "regex" ? r = `Invalid ${t.validation}` : r = "Invalid";
+      break;
+    case u.too_small:
+      t.type === "array" ? r = `Array must contain ${t.exact ? "exactly" : t.inclusive ? "at least" : "more than"} ${t.minimum} element(s)` : t.type === "string" ? r = `String must contain ${t.exact ? "exactly" : t.inclusive ? "at least" : "over"} ${t.minimum} character(s)` : t.type === "number" ? r = `Number must be ${t.exact ? "exactly equal to " : t.inclusive ? "greater than or equal to " : "greater than "}${t.minimum}` : t.type === "bigint" ? r = `Number must be ${t.exact ? "exactly equal to " : t.inclusive ? "greater than or equal to " : "greater than "}${t.minimum}` : t.type === "date" ? r = `Date must be ${t.exact ? "exactly equal to " : t.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(t.minimum))}` : r = "Invalid input";
+      break;
+    case u.too_big:
+      t.type === "array" ? r = `Array must contain ${t.exact ? "exactly" : t.inclusive ? "at most" : "less than"} ${t.maximum} element(s)` : t.type === "string" ? r = `String must contain ${t.exact ? "exactly" : t.inclusive ? "at most" : "under"} ${t.maximum} character(s)` : t.type === "number" ? r = `Number must be ${t.exact ? "exactly" : t.inclusive ? "less than or equal to" : "less than"} ${t.maximum}` : t.type === "bigint" ? r = `BigInt must be ${t.exact ? "exactly" : t.inclusive ? "less than or equal to" : "less than"} ${t.maximum}` : t.type === "date" ? r = `Date must be ${t.exact ? "exactly" : t.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(t.maximum))}` : r = "Invalid input";
+      break;
+    case u.custom:
+      r = "Invalid input";
+      break;
+    case u.invalid_intersection_types:
+      r = "Intersection results could not be merged";
+      break;
+    case u.not_multiple_of:
+      r = `Number must be a multiple of ${t.multipleOf}`;
+      break;
+    case u.not_finite:
+      r = "Number must be finite";
+      break;
+    default:
+      r = e.defaultError, S.assertNever(t);
+  }
+  return { message: r };
+};
+let Wt = ke;
+function ze() {
+  return Wt;
+}
+const Be = (t) => {
+  const { data: e, path: r, errorMaps: s, issueData: n } = t, i = [...r, ...n.path || []], o = {
+    ...n,
+    path: i
+  };
+  if (n.message !== void 0)
+    return {
+      ...n,
+      path: i,
+      message: n.message
+    };
+  let a = "";
+  const h = s.filter((l) => !!l).slice().reverse();
+  for (const l of h)
+    a = l(o, { data: e, defaultError: a }).message;
+  return {
+    ...n,
+    path: i,
+    message: a
+  };
+};
+function p(t, e) {
+  const r = ze(), s = Be({
+    issueData: e,
+    data: t.data,
+    path: t.path,
+    errorMaps: [
+      t.common.contextualErrorMap,
+      // contextual error map is first priority
+      t.schemaErrorMap,
+      // then schema-bound map if available
+      r,
+      // then global override map
+      r === ke ? void 0 : ke
+      // then global default map
+    ].filter((n) => !!n)
+  });
+  t.common.issues.push(s);
+}
+class $ {
+  constructor() {
+    this.value = "valid";
+  }
+  dirty() {
+    this.value === "valid" && (this.value = "dirty");
+  }
+  abort() {
+    this.value !== "aborted" && (this.value = "aborted");
+  }
+  static mergeArray(e, r) {
+    const s = [];
+    for (const n of r) {
+      if (n.status === "aborted")
+        return v;
+      n.status === "dirty" && e.dirty(), s.push(n.value);
+    }
+    return { status: e.value, value: s };
+  }
+  static async mergeObjectAsync(e, r) {
+    const s = [];
+    for (const n of r) {
+      const i = await n.key, o = await n.value;
+      s.push({
+        key: i,
+        value: o
+      });
+    }
+    return $.mergeObjectSync(e, s);
+  }
+  static mergeObjectSync(e, r) {
+    const s = {};
+    for (const n of r) {
+      const { key: i, value: o } = n;
+      if (i.status === "aborted" || o.status === "aborted")
+        return v;
+      i.status === "dirty" && e.dirty(), o.status === "dirty" && e.dirty(), i.value !== "__proto__" && (typeof o.value < "u" || n.alwaysSet) && (s[i.value] = o.value);
+    }
+    return { status: e.value, value: s };
+  }
+}
+const v = Object.freeze({
+  status: "aborted"
+}), be = (t) => ({ status: "dirty", value: t }), L = (t) => ({ status: "valid", value: t }), pt = (t) => t.status === "aborted", mt = (t) => t.status === "dirty", fe = (t) => t.status === "valid", $e = (t) => typeof Promise < "u" && t instanceof Promise;
+var g;
+(function(t) {
+  t.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, t.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+})(g || (g = {}));
+class F {
+  constructor(e, r, s, n) {
+    this._cachedPath = [], this.parent = e, this.data = r, this._path = s, this._key = n;
+  }
+  get path() {
+    return this._cachedPath.length || (Array.isArray(this._key) ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+  }
+}
+const gt = (t, e) => {
+  if (fe(e))
+    return { success: !0, data: e.value };
+  if (!t.common.issues.length)
+    throw new Error("Validation failed but no issues detected.");
+  return {
+    success: !1,
+    get error() {
+      if (this._error)
+        return this._error;
+      const r = new j(t.common.issues);
+      return this._error = r, this._error;
+    }
+  };
+};
+function w(t) {
+  if (!t)
+    return {};
+  const { errorMap: e, invalid_type_error: r, required_error: s, description: n } = t;
+  if (e && (r || s))
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  return e ? { errorMap: e, description: n } : { errorMap: (o, a) => {
+    const { message: h } = t;
+    return o.code === "invalid_enum_value" ? { message: h ?? a.defaultError } : typeof a.data > "u" ? { message: h ?? s ?? a.defaultError } : o.code !== "invalid_type" ? { message: a.defaultError } : { message: h ?? r ?? a.defaultError };
+  }, description: n };
+}
+class I {
+  get description() {
+    return this._def.description;
+  }
+  _getType(e) {
+    return K(e.data);
+  }
+  _getOrReturnCtx(e, r) {
+    return r || {
+      common: e.parent.common,
+      data: e.data,
+      parsedType: K(e.data),
+      schemaErrorMap: this._def.errorMap,
+      path: e.path,
+      parent: e.parent
+    };
+  }
+  _processInputParams(e) {
+    return {
+      status: new $(),
+      ctx: {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: K(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      }
+    };
+  }
+  _parseSync(e) {
+    const r = this._parse(e);
+    if ($e(r))
+      throw new Error("Synchronous parse encountered promise.");
+    return r;
+  }
+  _parseAsync(e) {
+    const r = this._parse(e);
+    return Promise.resolve(r);
+  }
+  parse(e, r) {
+    const s = this.safeParse(e, r);
+    if (s.success)
+      return s.data;
+    throw s.error;
+  }
+  safeParse(e, r) {
+    const s = {
+      common: {
+        issues: [],
+        async: (r == null ? void 0 : r.async) ?? !1,
+        contextualErrorMap: r == null ? void 0 : r.errorMap
+      },
+      path: (r == null ? void 0 : r.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: K(e)
+    }, n = this._parseSync({ data: e, path: s.path, parent: s });
+    return gt(s, n);
+  }
+  "~validate"(e) {
+    var s, n;
+    const r = {
+      common: {
+        issues: [],
+        async: !!this["~standard"].async
+      },
+      path: [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: K(e)
+    };
+    if (!this["~standard"].async)
+      try {
+        const i = this._parseSync({ data: e, path: [], parent: r });
+        return fe(i) ? {
+          value: i.value
+        } : {
+          issues: r.common.issues
+        };
+      } catch (i) {
+        (n = (s = i == null ? void 0 : i.message) == null ? void 0 : s.toLowerCase()) != null && n.includes("encountered") && (this["~standard"].async = !0), r.common = {
+          issues: [],
+          async: !0
+        };
+      }
+    return this._parseAsync({ data: e, path: [], parent: r }).then((i) => fe(i) ? {
+      value: i.value
+    } : {
+      issues: r.common.issues
+    });
+  }
+  async parseAsync(e, r) {
+    const s = await this.safeParseAsync(e, r);
+    if (s.success)
+      return s.data;
+    throw s.error;
+  }
+  async safeParseAsync(e, r) {
+    const s = {
+      common: {
+        issues: [],
+        contextualErrorMap: r == null ? void 0 : r.errorMap,
+        async: !0
+      },
+      path: (r == null ? void 0 : r.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: K(e)
+    }, n = this._parse({ data: e, path: s.path, parent: s }), i = await ($e(n) ? n : Promise.resolve(n));
+    return gt(s, i);
+  }
+  refine(e, r) {
+    const s = (n) => typeof r == "string" || typeof r > "u" ? { message: r } : typeof r == "function" ? r(n) : r;
+    return this._refinement((n, i) => {
+      const o = e(n), a = () => i.addIssue({
+        code: u.custom,
+        ...s(n)
+      });
+      return typeof Promise < "u" && o instanceof Promise ? o.then((h) => h ? !0 : (a(), !1)) : o ? !0 : (a(), !1);
+    });
+  }
+  refinement(e, r) {
+    return this._refinement((s, n) => e(s) ? !0 : (n.addIssue(typeof r == "function" ? r(s, n) : r), !1));
+  }
+  _refinement(e) {
+    return new G({
+      schema: this,
+      typeName: k.ZodEffects,
+      effect: { type: "refinement", refinement: e }
+    });
+  }
+  superRefine(e) {
+    return this._refinement(e);
+  }
+  constructor(e) {
+    this.spa = this.safeParseAsync, this._def = e, 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: (r) => this["~validate"](r)
+    };
+  }
+  optional() {
+    return W.create(this, this._def);
+  }
+  nullable() {
+    return ee.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return D.create(this);
+  }
+  promise() {
+    return pe.create(this, this._def);
+  }
+  or(e) {
+    return Te.create([this, e], this._def);
+  }
+  and(e) {
+    return Ie.create(this, e, this._def);
+  }
+  transform(e) {
+    return new G({
+      ...w(this._def),
+      schema: this,
+      typeName: k.ZodEffects,
+      effect: { type: "transform", transform: e }
+    });
+  }
+  default(e) {
+    const r = typeof e == "function" ? e : () => e;
+    return new Ae({
+      ...w(this._def),
+      innerType: this,
+      defaultValue: r,
+      typeName: k.ZodDefault
+    });
+  }
+  brand() {
+    return new nt({
+      typeName: k.ZodBranded,
+      type: this,
+      ...w(this._def)
+    });
+  }
+  catch(e) {
+    const r = typeof e == "function" ? e : () => e;
+    return new Re({
+      ...w(this._def),
+      innerType: this,
+      catchValue: r,
+      typeName: k.ZodCatch
+    });
+  }
+  describe(e) {
+    const r = this.constructor;
+    return new r({
+      ...this._def,
+      description: e
+    });
+  }
+  pipe(e) {
+    return We.create(this, e);
+  }
+  readonly() {
+    return Ce.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+}
+const Vt = /^c[^\s-]{8,}$/i, Ut = /^[0-9a-z]+$/, Ft = /^[0-9A-HJKMNP-TV-Z]{26}$/i, zt = /^[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, Bt = /^[a-z0-9_-]{21}$/i, qt = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, Ht = /^[-+]?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)?)??$/, Gt = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, Jt = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+let Ue;
+const Yt = /^(?:(?: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])$/, Kt = /^(?:(?: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])$/, Xt = /^(([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]))$/, Qt = /^(([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])$/, er = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, tr = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, xt = "((\\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])))", rr = new RegExp(`^${xt}$`);
+function Tt(t) {
+  let e = "[0-5]\\d";
+  t.precision ? e = `${e}\\.\\d{${t.precision}}` : t.precision == null && (e = `${e}(\\.\\d+)?`);
+  const r = t.precision ? "+" : "?";
+  return `([01]\\d|2[0-3]):[0-5]\\d(:${e})${r}`;
+}
+function sr(t) {
+  return new RegExp(`^${Tt(t)}$`);
+}
+function nr(t) {
+  let e = `${xt}T${Tt(t)}`;
+  const r = [];
+  return r.push(t.local ? "Z?" : "Z"), t.offset && r.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${r.join("|")})`, new RegExp(`^${e}$`);
+}
+function ir(t, e) {
+  return !!((e === "v4" || !e) && Yt.test(t) || (e === "v6" || !e) && Xt.test(t));
+}
+function ar(t, e) {
+  if (!qt.test(t))
+    return !1;
+  try {
+    const [r] = t.split(".");
+    if (!r)
+      return !1;
+    const s = r.replace(/-/g, "+").replace(/_/g, "/").padEnd(r.length + (4 - r.length % 4) % 4, "="), n = JSON.parse(atob(s));
+    return !(typeof n != "object" || n === null || "typ" in n && (n == null ? void 0 : n.typ) !== "JWT" || !n.alg || e && n.alg !== e);
+  } catch {
+    return !1;
+  }
+}
+function or(t, e) {
+  return !!((e === "v4" || !e) && Kt.test(t) || (e === "v6" || !e) && Qt.test(t));
+}
+class U extends I {
+  _parse(e) {
+    if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== m.string) {
+      const i = this._getOrReturnCtx(e);
+      return p(i, {
+        code: u.invalid_type,
+        expected: m.string,
+        received: i.parsedType
+      }), v;
+    }
+    const s = new $();
+    let n;
+    for (const i of this._def.checks)
+      if (i.kind === "min")
+        e.data.length < i.value && (n = this._getOrReturnCtx(e, n), p(n, {
+          code: u.too_small,
+          minimum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "max")
+        e.data.length > i.value && (n = this._getOrReturnCtx(e, n), p(n, {
+          code: u.too_big,
+          maximum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "length") {
+        const o = e.data.length > i.value, a = e.data.length < i.value;
+        (o || a) && (n = this._getOrReturnCtx(e, n), o ? p(n, {
+          code: u.too_big,
+          maximum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: i.message
+        }) : a && p(n, {
+          code: u.too_small,
+          minimum: i.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: i.message
+        }), s.dirty());
+      } else if (i.kind === "email")
+        Gt.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+          validation: "email",
+          code: u.invalid_string,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "emoji")
+        Ue || (Ue = new RegExp(Jt, "u")), Ue.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+          validation: "emoji",
+          code: u.invalid_string,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "uuid")
+        zt.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+          validation: "uuid",
+          code: u.invalid_string,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "nanoid")
+        Bt.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+          validation: "nanoid",
+          code: u.invalid_string,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "cuid")
+        Vt.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+          validation: "cuid",
+          code: u.invalid_string,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "cuid2")
+        Ut.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+          validation: "cuid2",
+          code: u.invalid_string,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "ulid")
+        Ft.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+          validation: "ulid",
+          code: u.invalid_string,
+          message: i.message
+        }), s.dirty());
+      else if (i.kind === "url")
+        try {
+          new URL(e.data);
+        } catch {
+          n = this._getOrReturnCtx(e, n), p(n, {
+            validation: "url",
+            code: u.invalid_string,
+            message: i.message
+          }), s.dirty();
+        }
+      else i.kind === "regex" ? (i.regex.lastIndex = 0, i.regex.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+        validation: "regex",
+        code: u.invalid_string,
+        message: i.message
+      }), s.dirty())) : i.kind === "trim" ? e.data = e.data.trim() : i.kind === "includes" ? e.data.includes(i.value, i.position) || (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.invalid_string,
+        validation: { includes: i.value, position: i.position },
+        message: i.message
+      }), s.dirty()) : i.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : i.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : i.kind === "startsWith" ? e.data.startsWith(i.value) || (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.invalid_string,
+        validation: { startsWith: i.value },
+        message: i.message
+      }), s.dirty()) : i.kind === "endsWith" ? e.data.endsWith(i.value) || (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.invalid_string,
+        validation: { endsWith: i.value },
+        message: i.message
+      }), s.dirty()) : i.kind === "datetime" ? nr(i).test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.invalid_string,
+        validation: "datetime",
+        message: i.message
+      }), s.dirty()) : i.kind === "date" ? rr.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.invalid_string,
+        validation: "date",
+        message: i.message
+      }), s.dirty()) : i.kind === "time" ? sr(i).test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.invalid_string,
+        validation: "time",
+        message: i.message
+      }), s.dirty()) : i.kind === "duration" ? Ht.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+        validation: "duration",
+        code: u.invalid_string,
+        message: i.message
+      }), s.dirty()) : i.kind === "ip" ? ir(e.data, i.version) || (n = this._getOrReturnCtx(e, n), p(n, {
+        validation: "ip",
+        code: u.invalid_string,
+        message: i.message
+      }), s.dirty()) : i.kind === "jwt" ? ar(e.data, i.alg) || (n = this._getOrReturnCtx(e, n), p(n, {
+        validation: "jwt",
+        code: u.invalid_string,
+        message: i.message
+      }), s.dirty()) : i.kind === "cidr" ? or(e.data, i.version) || (n = this._getOrReturnCtx(e, n), p(n, {
+        validation: "cidr",
+        code: u.invalid_string,
+        message: i.message
+      }), s.dirty()) : i.kind === "base64" ? er.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+        validation: "base64",
+        code: u.invalid_string,
+        message: i.message
+      }), s.dirty()) : i.kind === "base64url" ? tr.test(e.data) || (n = this._getOrReturnCtx(e, n), p(n, {
+        validation: "base64url",
+        code: u.invalid_string,
+        message: i.message
+      }), s.dirty()) : S.assertNever(i);
+    return { status: s.value, value: e.data };
+  }
+  _regex(e, r, s) {
+    return this.refinement((n) => e.test(n), {
+      validation: r,
+      code: u.invalid_string,
+      ...g.errToObj(s)
+    });
+  }
+  _addCheck(e) {
+    return new U({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  email(e) {
+    return this._addCheck({ kind: "email", ...g.errToObj(e) });
+  }
+  url(e) {
+    return this._addCheck({ kind: "url", ...g.errToObj(e) });
+  }
+  emoji(e) {
+    return this._addCheck({ kind: "emoji", ...g.errToObj(e) });
+  }
+  uuid(e) {
+    return this._addCheck({ kind: "uuid", ...g.errToObj(e) });
+  }
+  nanoid(e) {
+    return this._addCheck({ kind: "nanoid", ...g.errToObj(e) });
+  }
+  cuid(e) {
+    return this._addCheck({ kind: "cuid", ...g.errToObj(e) });
+  }
+  cuid2(e) {
+    return this._addCheck({ kind: "cuid2", ...g.errToObj(e) });
+  }
+  ulid(e) {
+    return this._addCheck({ kind: "ulid", ...g.errToObj(e) });
+  }
+  base64(e) {
+    return this._addCheck({ kind: "base64", ...g.errToObj(e) });
+  }
+  base64url(e) {
+    return this._addCheck({
+      kind: "base64url",
+      ...g.errToObj(e)
+    });
+  }
+  jwt(e) {
+    return this._addCheck({ kind: "jwt", ...g.errToObj(e) });
+  }
+  ip(e) {
+    return this._addCheck({ kind: "ip", ...g.errToObj(e) });
+  }
+  cidr(e) {
+    return this._addCheck({ kind: "cidr", ...g.errToObj(e) });
+  }
+  datetime(e) {
+    return typeof e == "string" ? this._addCheck({
+      kind: "datetime",
+      precision: null,
+      offset: !1,
+      local: !1,
+      message: e
+    }) : this._addCheck({
+      kind: "datetime",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      offset: (e == null ? void 0 : e.offset) ?? !1,
+      local: (e == null ? void 0 : e.local) ?? !1,
+      ...g.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  date(e) {
+    return this._addCheck({ kind: "date", message: e });
+  }
+  time(e) {
+    return typeof e == "string" ? this._addCheck({
+      kind: "time",
+      precision: null,
+      message: e
+    }) : this._addCheck({
+      kind: "time",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      ...g.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  duration(e) {
+    return this._addCheck({ kind: "duration", ...g.errToObj(e) });
+  }
+  regex(e, r) {
+    return this._addCheck({
+      kind: "regex",
+      regex: e,
+      ...g.errToObj(r)
+    });
+  }
+  includes(e, r) {
+    return this._addCheck({
+      kind: "includes",
+      value: e,
+      position: r == null ? void 0 : r.position,
+      ...g.errToObj(r == null ? void 0 : r.message)
+    });
+  }
+  startsWith(e, r) {
+    return this._addCheck({
+      kind: "startsWith",
+      value: e,
+      ...g.errToObj(r)
+    });
+  }
+  endsWith(e, r) {
+    return this._addCheck({
+      kind: "endsWith",
+      value: e,
+      ...g.errToObj(r)
+    });
+  }
+  min(e, r) {
+    return this._addCheck({
+      kind: "min",
+      value: e,
+      ...g.errToObj(r)
+    });
+  }
+  max(e, r) {
+    return this._addCheck({
+      kind: "max",
+      value: e,
+      ...g.errToObj(r)
+    });
+  }
+  length(e, r) {
+    return this._addCheck({
+      kind: "length",
+      value: e,
+      ...g.errToObj(r)
+    });
+  }
+  /**
+   * Equivalent to `.min(1)`
+   */
+  nonempty(e) {
+    return this.min(1, g.errToObj(e));
+  }
+  trim() {
+    return new U({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new U({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new U({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toUpperCase" }]
+    });
+  }
+  get isDatetime() {
+    return !!this._def.checks.find((e) => e.kind === "datetime");
+  }
+  get isDate() {
+    return !!this._def.checks.find((e) => e.kind === "date");
+  }
+  get isTime() {
+    return !!this._def.checks.find((e) => e.kind === "time");
+  }
+  get isDuration() {
+    return !!this._def.checks.find((e) => e.kind === "duration");
+  }
+  get isEmail() {
+    return !!this._def.checks.find((e) => e.kind === "email");
+  }
+  get isURL() {
+    return !!this._def.checks.find((e) => e.kind === "url");
+  }
+  get isEmoji() {
+    return !!this._def.checks.find((e) => e.kind === "emoji");
+  }
+  get isUUID() {
+    return !!this._def.checks.find((e) => e.kind === "uuid");
+  }
+  get isNANOID() {
+    return !!this._def.checks.find((e) => e.kind === "nanoid");
+  }
+  get isCUID() {
+    return !!this._def.checks.find((e) => e.kind === "cuid");
+  }
+  get isCUID2() {
+    return !!this._def.checks.find((e) => e.kind === "cuid2");
+  }
+  get isULID() {
+    return !!this._def.checks.find((e) => e.kind === "ulid");
+  }
+  get isIP() {
+    return !!this._def.checks.find((e) => e.kind === "ip");
+  }
+  get isCIDR() {
+    return !!this._def.checks.find((e) => e.kind === "cidr");
+  }
+  get isBase64() {
+    return !!this._def.checks.find((e) => e.kind === "base64");
+  }
+  get isBase64url() {
+    return !!this._def.checks.find((e) => e.kind === "base64url");
+  }
+  get minLength() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e;
+  }
+  get maxLength() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e;
+  }
+}
+U.create = (t) => new U({
+  checks: [],
+  typeName: k.ZodString,
+  coerce: (t == null ? void 0 : t.coerce) ?? !1,
+  ...w(t)
+});
+function dr(t, e) {
+  const r = (t.toString().split(".")[1] || "").length, s = (e.toString().split(".")[1] || "").length, n = r > s ? r : s, i = Number.parseInt(t.toFixed(n).replace(".", "")), o = Number.parseInt(e.toFixed(n).replace(".", ""));
+  return i % o / 10 ** n;
+}
+class se extends I {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf;
+  }
+  _parse(e) {
+    if (this._def.coerce && (e.data = Number(e.data)), this._getType(e) !== m.number) {
+      const i = this._getOrReturnCtx(e);
+      return p(i, {
+        code: u.invalid_type,
+        expected: m.number,
+        received: i.parsedType
+      }), v;
+    }
+    let s;
+    const n = new $();
+    for (const i of this._def.checks)
+      i.kind === "int" ? S.isInteger(e.data) || (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: i.message
+      }), n.dirty()) : i.kind === "min" ? (i.inclusive ? e.data < i.value : e.data <= i.value) && (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.too_small,
+        minimum: i.value,
+        type: "number",
+        inclusive: i.inclusive,
+        exact: !1,
+        message: i.message
+      }), n.dirty()) : i.kind === "max" ? (i.inclusive ? e.data > i.value : e.data >= i.value) && (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.too_big,
+        maximum: i.value,
+        type: "number",
+        inclusive: i.inclusive,
+        exact: !1,
+        message: i.message
+      }), n.dirty()) : i.kind === "multipleOf" ? dr(e.data, i.value) !== 0 && (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.not_multiple_of,
+        multipleOf: i.value,
+        message: i.message
+      }), n.dirty()) : i.kind === "finite" ? Number.isFinite(e.data) || (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.not_finite,
+        message: i.message
+      }), n.dirty()) : S.assertNever(i);
+    return { status: n.value, value: e.data };
+  }
+  gte(e, r) {
+    return this.setLimit("min", e, !0, g.toString(r));
+  }
+  gt(e, r) {
+    return this.setLimit("min", e, !1, g.toString(r));
+  }
+  lte(e, r) {
+    return this.setLimit("max", e, !0, g.toString(r));
+  }
+  lt(e, r) {
+    return this.setLimit("max", e, !1, g.toString(r));
+  }
+  setLimit(e, r, s, n) {
+    return new se({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: r,
+          inclusive: s,
+          message: g.toString(n)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new se({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  int(e) {
+    return this._addCheck({
+      kind: "int",
+      message: g.toString(e)
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !1,
+      message: g.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !1,
+      message: g.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !0,
+      message: g.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !0,
+      message: g.toString(e)
+    });
+  }
+  multipleOf(e, r) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: g.toString(r)
+    });
+  }
+  finite(e) {
+    return this._addCheck({
+      kind: "finite",
+      message: g.toString(e)
+    });
+  }
+  safe(e) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: !0,
+      value: Number.MIN_SAFE_INTEGER,
+      message: g.toString(e)
+    })._addCheck({
+      kind: "max",
+      inclusive: !0,
+      value: Number.MAX_SAFE_INTEGER,
+      message: g.toString(e)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e;
+  }
+  get isInt() {
+    return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && S.isInteger(e.value));
+  }
+  get isFinite() {
+    let e = null, r = null;
+    for (const s of this._def.checks) {
+      if (s.kind === "finite" || s.kind === "int" || s.kind === "multipleOf")
+        return !0;
+      s.kind === "min" ? (r === null || s.value > r) && (r = s.value) : s.kind === "max" && (e === null || s.value < e) && (e = s.value);
+    }
+    return Number.isFinite(r) && Number.isFinite(e);
+  }
+}
+se.create = (t) => new se({
+  checks: [],
+  typeName: k.ZodNumber,
+  coerce: (t == null ? void 0 : t.coerce) || !1,
+  ...w(t)
+});
+class ne extends I {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte;
+  }
+  _parse(e) {
+    if (this._def.coerce)
+      try {
+        e.data = BigInt(e.data);
+      } catch {
+        return this._getInvalidInput(e);
+      }
+    if (this._getType(e) !== m.bigint)
+      return this._getInvalidInput(e);
+    let s;
+    const n = new $();
+    for (const i of this._def.checks)
+      i.kind === "min" ? (i.inclusive ? e.data < i.value : e.data <= i.value) && (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.too_small,
+        type: "bigint",
+        minimum: i.value,
+        inclusive: i.inclusive,
+        message: i.message
+      }), n.dirty()) : i.kind === "max" ? (i.inclusive ? e.data > i.value : e.data >= i.value) && (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.too_big,
+        type: "bigint",
+        maximum: i.value,
+        inclusive: i.inclusive,
+        message: i.message
+      }), n.dirty()) : i.kind === "multipleOf" ? e.data % i.value !== BigInt(0) && (s = this._getOrReturnCtx(e, s), p(s, {
+        code: u.not_multiple_of,
+        multipleOf: i.value,
+        message: i.message
+      }), n.dirty()) : S.assertNever(i);
+    return { status: n.value, value: e.data };
+  }
+  _getInvalidInput(e) {
+    const r = this._getOrReturnCtx(e);
+    return p(r, {
+      code: u.invalid_type,
+      expected: m.bigint,
+      received: r.parsedType
+    }), v;
+  }
+  gte(e, r) {
+    return this.setLimit("min", e, !0, g.toString(r));
+  }
+  gt(e, r) {
+    return this.setLimit("min", e, !1, g.toString(r));
+  }
+  lte(e, r) {
+    return this.setLimit("max", e, !0, g.toString(r));
+  }
+  lt(e, r) {
+    return this.setLimit("max", e, !1, g.toString(r));
+  }
+  setLimit(e, r, s, n) {
+    return new ne({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: r,
+          inclusive: s,
+          message: g.toString(n)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new ne({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !1,
+      message: g.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !1,
+      message: g.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !0,
+      message: g.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !0,
+      message: g.toString(e)
+    });
+  }
+  multipleOf(e, r) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: g.toString(r)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e;
+  }
+}
+ne.create = (t) => new ne({
+  checks: [],
+  typeName: k.ZodBigInt,
+  coerce: (t == null ? void 0 : t.coerce) ?? !1,
+  ...w(t)
+});
+class Le extends I {
+  _parse(e) {
+    if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== m.boolean) {
+      const s = this._getOrReturnCtx(e);
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.boolean,
+        received: s.parsedType
+      }), v;
+    }
+    return L(e.data);
+  }
+}
+Le.create = (t) => new Le({
+  typeName: k.ZodBoolean,
+  coerce: (t == null ? void 0 : t.coerce) || !1,
+  ...w(t)
+});
+class we extends I {
+  _parse(e) {
+    if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== m.date) {
+      const i = this._getOrReturnCtx(e);
+      return p(i, {
+        code: u.invalid_type,
+        expected: m.date,
+        received: i.parsedType
+      }), v;
+    }
+    if (Number.isNaN(e.data.getTime())) {
+      const i = this._getOrReturnCtx(e);
+      return p(i, {
+        code: u.invalid_date
+      }), v;
+    }
+    const s = new $();
+    let n;
+    for (const i of this._def.checks)
+      i.kind === "min" ? e.data.getTime() < i.value && (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.too_small,
+        message: i.message,
+        inclusive: !0,
+        exact: !1,
+        minimum: i.value,
+        type: "date"
+      }), s.dirty()) : i.kind === "max" ? e.data.getTime() > i.value && (n = this._getOrReturnCtx(e, n), p(n, {
+        code: u.too_big,
+        message: i.message,
+        inclusive: !0,
+        exact: !1,
+        maximum: i.value,
+        type: "date"
+      }), s.dirty()) : S.assertNever(i);
+    return {
+      status: s.value,
+      value: new Date(e.data.getTime())
+    };
+  }
+  _addCheck(e) {
+    return new we({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  min(e, r) {
+    return this._addCheck({
+      kind: "min",
+      value: e.getTime(),
+      message: g.toString(r)
+    });
+  }
+  max(e, r) {
+    return this._addCheck({
+      kind: "max",
+      value: e.getTime(),
+      message: g.toString(r)
+    });
+  }
+  get minDate() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e != null ? new Date(e) : null;
+  }
+  get maxDate() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e != null ? new Date(e) : null;
+  }
+}
+we.create = (t) => new we({
+  checks: [],
+  coerce: (t == null ? void 0 : t.coerce) || !1,
+  typeName: k.ZodDate,
+  ...w(t)
+});
+class yt extends I {
+  _parse(e) {
+    if (this._getType(e) !== m.symbol) {
+      const s = this._getOrReturnCtx(e);
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.symbol,
+        received: s.parsedType
+      }), v;
+    }
+    return L(e.data);
+  }
+}
+yt.create = (t) => new yt({
+  typeName: k.ZodSymbol,
+  ...w(t)
+});
+class je extends I {
+  _parse(e) {
+    if (this._getType(e) !== m.undefined) {
+      const s = this._getOrReturnCtx(e);
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.undefined,
+        received: s.parsedType
+      }), v;
+    }
+    return L(e.data);
+  }
+}
+je.create = (t) => new je({
+  typeName: k.ZodUndefined,
+  ...w(t)
+});
+class xe extends I {
+  _parse(e) {
+    if (this._getType(e) !== m.null) {
+      const s = this._getOrReturnCtx(e);
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.null,
+        received: s.parsedType
+      }), v;
+    }
+    return L(e.data);
+  }
+}
+xe.create = (t) => new xe({
+  typeName: k.ZodNull,
+  ...w(t)
+});
+class qe extends I {
+  constructor() {
+    super(...arguments), this._any = !0;
+  }
+  _parse(e) {
+    return L(e.data);
+  }
+}
+qe.create = (t) => new qe({
+  typeName: k.ZodAny,
+  ...w(t)
+});
+class re extends I {
+  constructor() {
+    super(...arguments), this._unknown = !0;
+  }
+  _parse(e) {
+    return L(e.data);
+  }
+}
+re.create = (t) => new re({
+  typeName: k.ZodUnknown,
+  ...w(t)
+});
+class X extends I {
+  _parse(e) {
+    const r = this._getOrReturnCtx(e);
+    return p(r, {
+      code: u.invalid_type,
+      expected: m.never,
+      received: r.parsedType
+    }), v;
+  }
+}
+X.create = (t) => new X({
+  typeName: k.ZodNever,
+  ...w(t)
+});
+class He extends I {
+  _parse(e) {
+    if (this._getType(e) !== m.undefined) {
+      const s = this._getOrReturnCtx(e);
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.void,
+        received: s.parsedType
+      }), v;
+    }
+    return L(e.data);
+  }
+}
+He.create = (t) => new He({
+  typeName: k.ZodVoid,
+  ...w(t)
+});
+class D extends I {
+  _parse(e) {
+    const { ctx: r, status: s } = this._processInputParams(e), n = this._def;
+    if (r.parsedType !== m.array)
+      return p(r, {
+        code: u.invalid_type,
+        expected: m.array,
+        received: r.parsedType
+      }), v;
+    if (n.exactLength !== null) {
+      const o = r.data.length > n.exactLength.value, a = r.data.length < n.exactLength.value;
+      (o || a) && (p(r, {
+        code: o ? u.too_big : u.too_small,
+        minimum: a ? n.exactLength.value : void 0,
+        maximum: o ? n.exactLength.value : void 0,
+        type: "array",
+        inclusive: !0,
+        exact: !0,
+        message: n.exactLength.message
+      }), s.dirty());
+    }
+    if (n.minLength !== null && r.data.length < n.minLength.value && (p(r, {
+      code: u.too_small,
+      minimum: n.minLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: n.minLength.message
+    }), s.dirty()), n.maxLength !== null && r.data.length > n.maxLength.value && (p(r, {
+      code: u.too_big,
+      maximum: n.maxLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: n.maxLength.message
+    }), s.dirty()), r.common.async)
+      return Promise.all([...r.data].map((o, a) => n.type._parseAsync(new F(r, o, r.path, a)))).then((o) => $.mergeArray(s, o));
+    const i = [...r.data].map((o, a) => n.type._parseSync(new F(r, o, r.path, a)));
+    return $.mergeArray(s, i);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(e, r) {
+    return new D({
+      ...this._def,
+      minLength: { value: e, message: g.toString(r) }
+    });
+  }
+  max(e, r) {
+    return new D({
+      ...this._def,
+      maxLength: { value: e, message: g.toString(r) }
+    });
+  }
+  length(e, r) {
+    return new D({
+      ...this._def,
+      exactLength: { value: e, message: g.toString(r) }
+    });
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+D.create = (t, e) => new D({
+  type: t,
+  minLength: null,
+  maxLength: null,
+  exactLength: null,
+  typeName: k.ZodArray,
+  ...w(e)
+});
+function ce(t) {
+  if (t instanceof R) {
+    const e = {};
+    for (const r in t.shape) {
+      const s = t.shape[r];
+      e[r] = W.create(ce(s));
+    }
+    return new R({
+      ...t._def,
+      shape: () => e
+    });
+  } else return t instanceof D ? new D({
+    ...t._def,
+    type: ce(t.element)
+  }) : t instanceof W ? W.create(ce(t.unwrap())) : t instanceof ee ? ee.create(ce(t.unwrap())) : t instanceof z ? z.create(t.items.map((e) => ce(e))) : t;
+}
+class R extends I {
+  constructor() {
+    super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend;
+  }
+  _getCached() {
+    if (this._cached !== null)
+      return this._cached;
+    const e = this._def.shape(), r = S.objectKeys(e);
+    return this._cached = { shape: e, keys: r }, this._cached;
+  }
+  _parse(e) {
+    if (this._getType(e) !== m.object) {
+      const l = this._getOrReturnCtx(e);
+      return p(l, {
+        code: u.invalid_type,
+        expected: m.object,
+        received: l.parsedType
+      }), v;
+    }
+    const { status: s, ctx: n } = this._processInputParams(e), { shape: i, keys: o } = this._getCached(), a = [];
+    if (!(this._def.catchall instanceof X && this._def.unknownKeys === "strip"))
+      for (const l in n.data)
+        o.includes(l) || a.push(l);
+    const h = [];
+    for (const l of o) {
+      const _ = i[l], E = n.data[l];
+      h.push({
+        key: { status: "valid", value: l },
+        value: _._parse(new F(n, E, n.path, l)),
+        alwaysSet: l in n.data
+      });
+    }
+    if (this._def.catchall instanceof X) {
+      const l = this._def.unknownKeys;
+      if (l === "passthrough")
+        for (const _ of a)
+          h.push({
+            key: { status: "valid", value: _ },
+            value: { status: "valid", value: n.data[_] }
+          });
+      else if (l === "strict")
+        a.length > 0 && (p(n, {
+          code: u.unrecognized_keys,
+          keys: a
+        }), s.dirty());
+      else if (l !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+    } else {
+      const l = this._def.catchall;
+      for (const _ of a) {
+        const E = n.data[_];
+        h.push({
+          key: { status: "valid", value: _ },
+          value: l._parse(
+            new F(n, E, n.path, _)
+            //, ctx.child(key), value, getParsedType(value)
+          ),
+          alwaysSet: _ in n.data
+        });
+      }
+    }
+    return n.common.async ? Promise.resolve().then(async () => {
+      const l = [];
+      for (const _ of h) {
+        const E = await _.key, te = await _.value;
+        l.push({
+          key: E,
+          value: te,
+          alwaysSet: _.alwaysSet
+        });
+      }
+      return l;
+    }).then((l) => $.mergeObjectSync(s, l)) : $.mergeObjectSync(s, h);
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(e) {
+    return g.errToObj, new R({
+      ...this._def,
+      unknownKeys: "strict",
+      ...e !== void 0 ? {
+        errorMap: (r, s) => {
+          var i, o;
+          const n = ((o = (i = this._def).errorMap) == null ? void 0 : o.call(i, r, s).message) ?? s.defaultError;
+          return r.code === "unrecognized_keys" ? {
+            message: g.errToObj(e).message ?? n
+          } : {
+            message: n
+          };
+        }
+      } : {}
+    });
+  }
+  strip() {
+    return new R({
+      ...this._def,
+      unknownKeys: "strip"
+    });
+  }
+  passthrough() {
+    return new R({
+      ...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(e) {
+    return new R({
+      ...this._def,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e
+      })
+    });
+  }
+  /**
+   * 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(e) {
+    return new R({
+      unknownKeys: e._def.unknownKeys,
+      catchall: e._def.catchall,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e._def.shape()
+      }),
+      typeName: k.ZodObject
+    });
+  }
+  // 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(e, r) {
+    return this.augment({ [e]: r });
+  }
+  // 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(e) {
+    return new R({
+      ...this._def,
+      catchall: e
+    });
+  }
+  pick(e) {
+    const r = {};
+    for (const s of S.objectKeys(e))
+      e[s] && this.shape[s] && (r[s] = this.shape[s]);
+    return new R({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  omit(e) {
+    const r = {};
+    for (const s of S.objectKeys(this.shape))
+      e[s] || (r[s] = this.shape[s]);
+    return new R({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  /**
+   * @deprecated
+   */
+  deepPartial() {
+    return ce(this);
+  }
+  partial(e) {
+    const r = {};
+    for (const s of S.objectKeys(this.shape)) {
+      const n = this.shape[s];
+      e && !e[s] ? r[s] = n : r[s] = n.optional();
+    }
+    return new R({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  required(e) {
+    const r = {};
+    for (const s of S.objectKeys(this.shape))
+      if (e && !e[s])
+        r[s] = this.shape[s];
+      else {
+        let i = this.shape[s];
+        for (; i instanceof W; )
+          i = i._def.innerType;
+        r[s] = i;
+      }
+    return new R({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  keyof() {
+    return It(S.objectKeys(this.shape));
+  }
+}
+R.create = (t, e) => new R({
+  shape: () => t,
+  unknownKeys: "strip",
+  catchall: X.create(),
+  typeName: k.ZodObject,
+  ...w(e)
+});
+R.strictCreate = (t, e) => new R({
+  shape: () => t,
+  unknownKeys: "strict",
+  catchall: X.create(),
+  typeName: k.ZodObject,
+  ...w(e)
+});
+R.lazycreate = (t, e) => new R({
+  shape: t,
+  unknownKeys: "strip",
+  catchall: X.create(),
+  typeName: k.ZodObject,
+  ...w(e)
+});
+class Te extends I {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e), s = this._def.options;
+    function n(i) {
+      for (const a of i)
+        if (a.result.status === "valid")
+          return a.result;
+      for (const a of i)
+        if (a.result.status === "dirty")
+          return r.common.issues.push(...a.ctx.common.issues), a.result;
+      const o = i.map((a) => new j(a.ctx.common.issues));
+      return p(r, {
+        code: u.invalid_union,
+        unionErrors: o
+      }), v;
+    }
+    if (r.common.async)
+      return Promise.all(s.map(async (i) => {
+        const o = {
+          ...r,
+          common: {
+            ...r.common,
+            issues: []
+          },
+          parent: null
+        };
+        return {
+          result: await i._parseAsync({
+            data: r.data,
+            path: r.path,
+            parent: o
+          }),
+          ctx: o
+        };
+      })).then(n);
+    {
+      let i;
+      const o = [];
+      for (const h of s) {
+        const l = {
+          ...r,
+          common: {
+            ...r.common,
+            issues: []
+          },
+          parent: null
+        }, _ = h._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: l
+        });
+        if (_.status === "valid")
+          return _;
+        _.status === "dirty" && !i && (i = { result: _, ctx: l }), l.common.issues.length && o.push(l.common.issues);
+      }
+      if (i)
+        return r.common.issues.push(...i.ctx.common.issues), i.result;
+      const a = o.map((h) => new j(h));
+      return p(r, {
+        code: u.invalid_union,
+        unionErrors: a
+      }), v;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+}
+Te.create = (t, e) => new Te({
+  options: t,
+  typeName: k.ZodUnion,
+  ...w(e)
+});
+const H = (t) => t instanceof Pe ? H(t.schema) : t instanceof G ? H(t.innerType()) : t instanceof Ee ? [t.value] : t instanceof Q ? t.options : t instanceof Ye ? S.objectValues(t.enum) : t instanceof Ae ? H(t._def.innerType) : t instanceof je ? [void 0] : t instanceof xe ? [null] : t instanceof W ? [void 0, ...H(t.unwrap())] : t instanceof ee ? [null, ...H(t.unwrap())] : t instanceof nt || t instanceof Ce ? H(t.unwrap()) : t instanceof Re ? H(t._def.innerType) : [];
+class st extends I {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== m.object)
+      return p(r, {
+        code: u.invalid_type,
+        expected: m.object,
+        received: r.parsedType
+      }), v;
+    const s = this.discriminator, n = r.data[s], i = this.optionsMap.get(n);
+    return i ? r.common.async ? i._parseAsync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }) : i._parseSync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }) : (p(r, {
+      code: u.invalid_union_discriminator,
+      options: Array.from(this.optionsMap.keys()),
+      path: [s]
+    }), v);
+  }
+  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(e, r, s) {
+    const n = /* @__PURE__ */ new Map();
+    for (const i of r) {
+      const o = H(i.shape[e]);
+      if (!o.length)
+        throw new Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`);
+      for (const a of o) {
+        if (n.has(a))
+          throw new Error(`Discriminator property ${String(e)} has duplicate value ${String(a)}`);
+        n.set(a, i);
+      }
+    }
+    return new st({
+      typeName: k.ZodDiscriminatedUnion,
+      discriminator: e,
+      options: r,
+      optionsMap: n,
+      ...w(s)
+    });
+  }
+}
+function Ge(t, e) {
+  const r = K(t), s = K(e);
+  if (t === e)
+    return { valid: !0, data: t };
+  if (r === m.object && s === m.object) {
+    const n = S.objectKeys(e), i = S.objectKeys(t).filter((a) => n.indexOf(a) !== -1), o = { ...t, ...e };
+    for (const a of i) {
+      const h = Ge(t[a], e[a]);
+      if (!h.valid)
+        return { valid: !1 };
+      o[a] = h.data;
+    }
+    return { valid: !0, data: o };
+  } else if (r === m.array && s === m.array) {
+    if (t.length !== e.length)
+      return { valid: !1 };
+    const n = [];
+    for (let i = 0; i < t.length; i++) {
+      const o = t[i], a = e[i], h = Ge(o, a);
+      if (!h.valid)
+        return { valid: !1 };
+      n.push(h.data);
+    }
+    return { valid: !0, data: n };
+  } else return r === m.date && s === m.date && +t == +e ? { valid: !0, data: t } : { valid: !1 };
+}
+class Ie extends I {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e), n = (i, o) => {
+      if (pt(i) || pt(o))
+        return v;
+      const a = Ge(i.value, o.value);
+      return a.valid ? ((mt(i) || mt(o)) && r.dirty(), { status: r.value, value: a.data }) : (p(s, {
+        code: u.invalid_intersection_types
+      }), v);
+    };
+    return s.common.async ? Promise.all([
+      this._def.left._parseAsync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      }),
+      this._def.right._parseAsync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      })
+    ]).then(([i, o]) => n(i, o)) : n(this._def.left._parseSync({
+      data: s.data,
+      path: s.path,
+      parent: s
+    }), this._def.right._parseSync({
+      data: s.data,
+      path: s.path,
+      parent: s
+    }));
+  }
+}
+Ie.create = (t, e, r) => new Ie({
+  left: t,
+  right: e,
+  typeName: k.ZodIntersection,
+  ...w(r)
+});
+class z extends I {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== m.array)
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.array,
+        received: s.parsedType
+      }), v;
+    if (s.data.length < this._def.items.length)
+      return p(s, {
+        code: u.too_small,
+        minimum: this._def.items.length,
+        inclusive: !0,
+        exact: !1,
+        type: "array"
+      }), v;
+    !this._def.rest && s.data.length > this._def.items.length && (p(s, {
+      code: u.too_big,
+      maximum: this._def.items.length,
+      inclusive: !0,
+      exact: !1,
+      type: "array"
+    }), r.dirty());
+    const i = [...s.data].map((o, a) => {
+      const h = this._def.items[a] || this._def.rest;
+      return h ? h._parse(new F(s, o, s.path, a)) : null;
+    }).filter((o) => !!o);
+    return s.common.async ? Promise.all(i).then((o) => $.mergeArray(r, o)) : $.mergeArray(r, i);
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(e) {
+    return new z({
+      ...this._def,
+      rest: e
+    });
+  }
+}
+z.create = (t, e) => {
+  if (!Array.isArray(t))
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  return new z({
+    items: t,
+    typeName: k.ZodTuple,
+    rest: null,
+    ...w(e)
+  });
+};
+class Se extends I {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== m.object)
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.object,
+        received: s.parsedType
+      }), v;
+    const n = [], i = this._def.keyType, o = this._def.valueType;
+    for (const a in s.data)
+      n.push({
+        key: i._parse(new F(s, a, s.path, a)),
+        value: o._parse(new F(s, s.data[a], s.path, a)),
+        alwaysSet: a in s.data
+      });
+    return s.common.async ? $.mergeObjectAsync(r, n) : $.mergeObjectSync(r, n);
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(e, r, s) {
+    return r instanceof I ? new Se({
+      keyType: e,
+      valueType: r,
+      typeName: k.ZodRecord,
+      ...w(s)
+    }) : new Se({
+      keyType: U.create(),
+      valueType: e,
+      typeName: k.ZodRecord,
+      ...w(r)
+    });
+  }
+}
+class Je extends I {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== m.map)
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.map,
+        received: s.parsedType
+      }), v;
+    const n = this._def.keyType, i = this._def.valueType, o = [...s.data.entries()].map(([a, h], l) => ({
+      key: n._parse(new F(s, a, s.path, [l, "key"])),
+      value: i._parse(new F(s, h, s.path, [l, "value"]))
+    }));
+    if (s.common.async) {
+      const a = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(async () => {
+        for (const h of o) {
+          const l = await h.key, _ = await h.value;
+          if (l.status === "aborted" || _.status === "aborted")
+            return v;
+          (l.status === "dirty" || _.status === "dirty") && r.dirty(), a.set(l.value, _.value);
+        }
+        return { status: r.value, value: a };
+      });
+    } else {
+      const a = /* @__PURE__ */ new Map();
+      for (const h of o) {
+        const l = h.key, _ = h.value;
+        if (l.status === "aborted" || _.status === "aborted")
+          return v;
+        (l.status === "dirty" || _.status === "dirty") && r.dirty(), a.set(l.value, _.value);
+      }
+      return { status: r.value, value: a };
+    }
+  }
+}
+Je.create = (t, e, r) => new Je({
+  valueType: e,
+  keyType: t,
+  typeName: k.ZodMap,
+  ...w(r)
+});
+class he extends I {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== m.set)
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.set,
+        received: s.parsedType
+      }), v;
+    const n = this._def;
+    n.minSize !== null && s.data.size < n.minSize.value && (p(s, {
+      code: u.too_small,
+      minimum: n.minSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: n.minSize.message
+    }), r.dirty()), n.maxSize !== null && s.data.size > n.maxSize.value && (p(s, {
+      code: u.too_big,
+      maximum: n.maxSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: n.maxSize.message
+    }), r.dirty());
+    const i = this._def.valueType;
+    function o(h) {
+      const l = /* @__PURE__ */ new Set();
+      for (const _ of h) {
+        if (_.status === "aborted")
+          return v;
+        _.status === "dirty" && r.dirty(), l.add(_.value);
+      }
+      return { status: r.value, value: l };
+    }
+    const a = [...s.data.values()].map((h, l) => i._parse(new F(s, h, s.path, l)));
+    return s.common.async ? Promise.all(a).then((h) => o(h)) : o(a);
+  }
+  min(e, r) {
+    return new he({
+      ...this._def,
+      minSize: { value: e, message: g.toString(r) }
+    });
+  }
+  max(e, r) {
+    return new he({
+      ...this._def,
+      maxSize: { value: e, message: g.toString(r) }
+    });
+  }
+  size(e, r) {
+    return this.min(e, r).max(e, r);
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+he.create = (t, e) => new he({
+  valueType: t,
+  minSize: null,
+  maxSize: null,
+  typeName: k.ZodSet,
+  ...w(e)
+});
+class ve extends I {
+  constructor() {
+    super(...arguments), this.validate = this.implement;
+  }
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== m.function)
+      return p(r, {
+        code: u.invalid_type,
+        expected: m.function,
+        received: r.parsedType
+      }), v;
+    function s(a, h) {
+      return Be({
+        data: a,
+        path: r.path,
+        errorMaps: [r.common.contextualErrorMap, r.schemaErrorMap, ze(), ke].filter((l) => !!l),
+        issueData: {
+          code: u.invalid_arguments,
+          argumentsError: h
+        }
+      });
+    }
+    function n(a, h) {
+      return Be({
+        data: a,
+        path: r.path,
+        errorMaps: [r.common.contextualErrorMap, r.schemaErrorMap, ze(), ke].filter((l) => !!l),
+        issueData: {
+          code: u.invalid_return_type,
+          returnTypeError: h
+        }
+      });
+    }
+    const i = { errorMap: r.common.contextualErrorMap }, o = r.data;
+    if (this._def.returns instanceof pe) {
+      const a = this;
+      return L(async function(...h) {
+        const l = new j([]), _ = await a._def.args.parseAsync(h, i).catch((oe) => {
+          throw l.addIssue(s(h, oe)), l;
+        }), E = await Reflect.apply(o, this, _);
+        return await a._def.returns._def.type.parseAsync(E, i).catch((oe) => {
+          throw l.addIssue(n(E, oe)), l;
+        });
+      });
+    } else {
+      const a = this;
+      return L(function(...h) {
+        const l = a._def.args.safeParse(h, i);
+        if (!l.success)
+          throw new j([s(h, l.error)]);
+        const _ = Reflect.apply(o, this, l.data), E = a._def.returns.safeParse(_, i);
+        if (!E.success)
+          throw new j([n(_, E.error)]);
+        return E.data;
+      });
+    }
+  }
+  parameters() {
+    return this._def.args;
+  }
+  returnType() {
+    return this._def.returns;
+  }
+  args(...e) {
+    return new ve({
+      ...this._def,
+      args: z.create(e).rest(re.create())
+    });
+  }
+  returns(e) {
+    return new ve({
+      ...this._def,
+      returns: e
+    });
+  }
+  implement(e) {
+    return this.parse(e);
+  }
+  strictImplement(e) {
+    return this.parse(e);
+  }
+  static create(e, r, s) {
+    return new ve({
+      args: e || z.create([]).rest(re.create()),
+      returns: r || re.create(),
+      typeName: k.ZodFunction,
+      ...w(s)
+    });
+  }
+}
+class Pe extends I {
+  get schema() {
+    return this._def.getter();
+  }
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    return this._def.getter()._parse({ data: r.data, path: r.path, parent: r });
+  }
+}
+Pe.create = (t, e) => new Pe({
+  getter: t,
+  typeName: k.ZodLazy,
+  ...w(e)
+});
+class Ee extends I {
+  _parse(e) {
+    if (e.data !== this._def.value) {
+      const r = this._getOrReturnCtx(e);
+      return p(r, {
+        received: r.data,
+        code: u.invalid_literal,
+        expected: this._def.value
+      }), v;
+    }
+    return { status: "valid", value: e.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+}
+Ee.create = (t, e) => new Ee({
+  value: t,
+  typeName: k.ZodLiteral,
+  ...w(e)
+});
+function It(t, e) {
+  return new Q({
+    values: t,
+    typeName: k.ZodEnum,
+    ...w(e)
+  });
+}
+class Q extends I {
+  _parse(e) {
+    if (typeof e.data != "string") {
+      const r = this._getOrReturnCtx(e), s = this._def.values;
+      return p(r, {
+        expected: S.joinValues(s),
+        received: r.parsedType,
+        code: u.invalid_type
+      }), v;
+    }
+    if (this._cache || (this._cache = new Set(this._def.values)), !this._cache.has(e.data)) {
+      const r = this._getOrReturnCtx(e), s = this._def.values;
+      return p(r, {
+        received: r.data,
+        code: u.invalid_enum_value,
+        options: s
+      }), v;
+    }
+    return L(e.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const e = {};
+    for (const r of this._def.values)
+      e[r] = r;
+    return e;
+  }
+  get Values() {
+    const e = {};
+    for (const r of this._def.values)
+      e[r] = r;
+    return e;
+  }
+  get Enum() {
+    const e = {};
+    for (const r of this._def.values)
+      e[r] = r;
+    return e;
+  }
+  extract(e, r = this._def) {
+    return Q.create(e, {
+      ...this._def,
+      ...r
+    });
+  }
+  exclude(e, r = this._def) {
+    return Q.create(this.options.filter((s) => !e.includes(s)), {
+      ...this._def,
+      ...r
+    });
+  }
+}
+Q.create = It;
+class Ye extends I {
+  _parse(e) {
+    const r = S.getValidEnumValues(this._def.values), s = this._getOrReturnCtx(e);
+    if (s.parsedType !== m.string && s.parsedType !== m.number) {
+      const n = S.objectValues(r);
+      return p(s, {
+        expected: S.joinValues(n),
+        received: s.parsedType,
+        code: u.invalid_type
+      }), v;
+    }
+    if (this._cache || (this._cache = new Set(S.getValidEnumValues(this._def.values))), !this._cache.has(e.data)) {
+      const n = S.objectValues(r);
+      return p(s, {
+        received: s.data,
+        code: u.invalid_enum_value,
+        options: n
+      }), v;
+    }
+    return L(e.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+}
+Ye.create = (t, e) => new Ye({
+  values: t,
+  typeName: k.ZodNativeEnum,
+  ...w(e)
+});
+class pe extends I {
+  unwrap() {
+    return this._def.type;
+  }
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== m.promise && r.common.async === !1)
+      return p(r, {
+        code: u.invalid_type,
+        expected: m.promise,
+        received: r.parsedType
+      }), v;
+    const s = r.parsedType === m.promise ? r.data : Promise.resolve(r.data);
+    return L(s.then((n) => this._def.type.parseAsync(n, {
+      path: r.path,
+      errorMap: r.common.contextualErrorMap
+    })));
+  }
+}
+pe.create = (t, e) => new pe({
+  type: t,
+  typeName: k.ZodPromise,
+  ...w(e)
+});
+class G extends I {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === k.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e), n = this._def.effect || null, i = {
+      addIssue: (o) => {
+        p(s, o), o.fatal ? r.abort() : r.dirty();
+      },
+      get path() {
+        return s.path;
+      }
+    };
+    if (i.addIssue = i.addIssue.bind(i), n.type === "preprocess") {
+      const o = n.transform(s.data, i);
+      if (s.common.async)
+        return Promise.resolve(o).then(async (a) => {
+          if (r.value === "aborted")
+            return v;
+          const h = await this._def.schema._parseAsync({
+            data: a,
+            path: s.path,
+            parent: s
+          });
+          return h.status === "aborted" ? v : h.status === "dirty" || r.value === "dirty" ? be(h.value) : h;
+        });
+      {
+        if (r.value === "aborted")
+          return v;
+        const a = this._def.schema._parseSync({
+          data: o,
+          path: s.path,
+          parent: s
+        });
+        return a.status === "aborted" ? v : a.status === "dirty" || r.value === "dirty" ? be(a.value) : a;
+      }
+    }
+    if (n.type === "refinement") {
+      const o = (a) => {
+        const h = n.refinement(a, i);
+        if (s.common.async)
+          return Promise.resolve(h);
+        if (h instanceof Promise)
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+        return a;
+      };
+      if (s.common.async === !1) {
+        const a = this._def.schema._parseSync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        return a.status === "aborted" ? v : (a.status === "dirty" && r.dirty(), o(a.value), { status: r.value, value: a.value });
+      } else
+        return this._def.schema._parseAsync({ data: s.data, path: s.path, parent: s }).then((a) => a.status === "aborted" ? v : (a.status === "dirty" && r.dirty(), o(a.value).then(() => ({ status: r.value, value: a.value }))));
+    }
+    if (n.type === "transform")
+      if (s.common.async === !1) {
+        const o = this._def.schema._parseSync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        if (!fe(o))
+          return v;
+        const a = n.transform(o.value, i);
+        if (a instanceof Promise)
+          throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+        return { status: r.value, value: a };
+      } else
+        return this._def.schema._parseAsync({ data: s.data, path: s.path, parent: s }).then((o) => fe(o) ? Promise.resolve(n.transform(o.value, i)).then((a) => ({
+          status: r.value,
+          value: a
+        })) : v);
+    S.assertNever(n);
+  }
+}
+G.create = (t, e, r) => new G({
+  schema: t,
+  typeName: k.ZodEffects,
+  effect: e,
+  ...w(r)
+});
+G.createWithPreprocess = (t, e, r) => new G({
+  schema: e,
+  effect: { type: "preprocess", transform: t },
+  typeName: k.ZodEffects,
+  ...w(r)
+});
+class W extends I {
+  _parse(e) {
+    return this._getType(e) === m.undefined ? L(void 0) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+W.create = (t, e) => new W({
+  innerType: t,
+  typeName: k.ZodOptional,
+  ...w(e)
+});
+class ee extends I {
+  _parse(e) {
+    return this._getType(e) === m.null ? L(null) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+ee.create = (t, e) => new ee({
+  innerType: t,
+  typeName: k.ZodNullable,
+  ...w(e)
+});
+class Ae extends I {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    let s = r.data;
+    return r.parsedType === m.undefined && (s = this._def.defaultValue()), this._def.innerType._parse({
+      data: s,
+      path: r.path,
+      parent: r
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+}
+Ae.create = (t, e) => new Ae({
+  innerType: t,
+  typeName: k.ZodDefault,
+  defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+  ...w(e)
+});
+class Re extends I {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e), s = {
+      ...r,
+      common: {
+        ...r.common,
+        issues: []
+      }
+    }, n = this._def.innerType._parse({
+      data: s.data,
+      path: s.path,
+      parent: {
+        ...s
+      }
+    });
+    return $e(n) ? n.then((i) => ({
+      status: "valid",
+      value: i.status === "valid" ? i.value : this._def.catchValue({
+        get error() {
+          return new j(s.common.issues);
+        },
+        input: s.data
+      })
+    })) : {
+      status: "valid",
+      value: n.status === "valid" ? n.value : this._def.catchValue({
+        get error() {
+          return new j(s.common.issues);
+        },
+        input: s.data
+      })
+    };
+  }
+  removeCatch() {
+    return this._def.innerType;
+  }
+}
+Re.create = (t, e) => new Re({
+  innerType: t,
+  typeName: k.ZodCatch,
+  catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+  ...w(e)
+});
+class Ke extends I {
+  _parse(e) {
+    if (this._getType(e) !== m.nan) {
+      const s = this._getOrReturnCtx(e);
+      return p(s, {
+        code: u.invalid_type,
+        expected: m.nan,
+        received: s.parsedType
+      }), v;
+    }
+    return { status: "valid", value: e.data };
+  }
+}
+Ke.create = (t) => new Ke({
+  typeName: k.ZodNaN,
+  ...w(t)
+});
+class nt extends I {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e), s = r.data;
+    return this._def.type._parse({
+      data: s,
+      path: r.path,
+      parent: r
+    });
+  }
+  unwrap() {
+    return this._def.type;
+  }
+}
+class We extends I {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.common.async)
+      return (async () => {
+        const i = await this._def.in._parseAsync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        return i.status === "aborted" ? v : i.status === "dirty" ? (r.dirty(), be(i.value)) : this._def.out._parseAsync({
+          data: i.value,
+          path: s.path,
+          parent: s
+        });
+      })();
+    {
+      const n = this._def.in._parseSync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      });
+      return n.status === "aborted" ? v : n.status === "dirty" ? (r.dirty(), {
+        status: "dirty",
+        value: n.value
+      }) : this._def.out._parseSync({
+        data: n.value,
+        path: s.path,
+        parent: s
+      });
+    }
+  }
+  static create(e, r) {
+    return new We({
+      in: e,
+      out: r,
+      typeName: k.ZodPipeline
+    });
+  }
+}
+class Ce extends I {
+  _parse(e) {
+    const r = this._def.innerType._parse(e), s = (n) => (fe(n) && (n.value = Object.freeze(n.value)), n);
+    return $e(r) ? r.then((n) => s(n)) : s(r);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+Ce.create = (t, e) => new Ce({
+  innerType: t,
+  typeName: k.ZodReadonly,
+  ...w(e)
+});
+var k;
+(function(t) {
+  t.ZodString = "ZodString", t.ZodNumber = "ZodNumber", t.ZodNaN = "ZodNaN", t.ZodBigInt = "ZodBigInt", t.ZodBoolean = "ZodBoolean", t.ZodDate = "ZodDate", t.ZodSymbol = "ZodSymbol", t.ZodUndefined = "ZodUndefined", t.ZodNull = "ZodNull", t.ZodAny = "ZodAny", t.ZodUnknown = "ZodUnknown", t.ZodNever = "ZodNever", t.ZodVoid = "ZodVoid", t.ZodArray = "ZodArray", t.ZodObject = "ZodObject", t.ZodUnion = "ZodUnion", t.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", t.ZodIntersection = "ZodIntersection", t.ZodTuple = "ZodTuple", t.ZodRecord = "ZodRecord", t.ZodMap = "ZodMap", t.ZodSet = "ZodSet", t.ZodFunction = "ZodFunction", t.ZodLazy = "ZodLazy", t.ZodLiteral = "ZodLiteral", t.ZodEnum = "ZodEnum", t.ZodEffects = "ZodEffects", t.ZodNativeEnum = "ZodNativeEnum", t.ZodOptional = "ZodOptional", t.ZodNullable = "ZodNullable", t.ZodDefault = "ZodDefault", t.ZodCatch = "ZodCatch", t.ZodPromise = "ZodPromise", t.ZodBranded = "ZodBranded", t.ZodPipeline = "ZodPipeline", t.ZodReadonly = "ZodReadonly";
+})(k || (k = {}));
+const d = U.create, f = se.create, B = ne.create, x = Le.create, St = xe.create, b = re.create;
+X.create;
+const A = D.create, c = R.create, T = Te.create;
+Ie.create;
+const cr = z.create, y = Se.create, lr = Ee.create, Xe = Q.create;
+pe.create;
+W.create;
+ee.create;
+const J = G.createWithPreprocess, P = () => T([B(), f().finite()]).transform((t) => BigInt(t));
+c({
+  key: d().describe("Storage key to retrieve")
+});
+c({
+  key: d().describe("Storage key to set"),
+  value: d().describe("Value to store")
+});
+c({
+  key: d().describe("Storage key to delete")
+});
+c({});
+const ur = c({
+  items: y(d()).describe("Record of key-value string pairs to store")
+});
+J((t) => t !== null && typeof t == "object" && !Array.isArray(t) && !("items" in t) ? { items: t } : t, ur);
+const fr = c({
+  keys: A(d()).describe("Array of storage keys to retrieve"),
+  defaults: y(d()).optional().describe("Default string values for missing keys")
+});
+J(
+  (t) => Array.isArray(t) ? { keys: t } : t,
+  fr
+);
+c({});
+const hr = c({
+  keys: A(d()).describe("Array of storage keys to delete")
+});
+J(
+  (t) => Array.isArray(t) ? { keys: t } : t,
+  hr
+);
+c({});
+c({});
+T([
+  cr([T([c({ text: d() }), d()])]),
+  c({ text: d().optional(), value: d().optional() })
+]);
+c({
+  url: d().describe("URL to fetch"),
+  method: d().default("GET").describe("HTTP method (GET, POST, PUT, DELETE, etc.)"),
+  headers: y(d()).default({}).describe("Request headers as key-value pairs"),
+  body: d().nullable().default(null).describe("Request body string"),
+  timeout: P().default(30000n).describe("Timeout in milliseconds"),
+  options: c({}).passthrough().optional().describe("Fetch options")
+}).passthrough();
+c({
+  duration: P().describe("Duration to sleep in milliseconds")
+});
+const ie = () => d().regex(/^e\d+$/), pr = 'use { refId: "e2" } or { label: "..." } object form, not positional arguments', it = (t, e) => {
+  if (t.__invalidPositional !== void 0) {
+    e.addIssue({
+      code: u.custom,
+      message: pr
+    });
+    return;
+  }
+  !t.refId && !t.label && e.addIssue({
+    code: u.custom,
+    message: "Either refId or label is required"
+  });
+}, Et = (t, e) => {
+  t.x !== void 0 || t.y !== void 0 || it(t, e);
+}, M = (t) => J(
+  (e) => typeof e == "string" || typeof e == "number" ? { __invalidPositional: e } : e,
+  c({
+    __invalidPositional: T([d(), f()]).optional().describe("Internal flag for positional argument rejection"),
+    refId: ie().optional().describe("Element reference ID (e.g. e2)"),
+    label: d().optional().describe("Human-readable element label"),
+    ...t
+  }).superRefine(it)
+), Oe = { tabId: T([f(), B()]).optional().describe("Target tab ID") }, ae = (t) => J(
+  (e) => typeof e == "string" || typeof e == "number" ? { __invalidPositional: e } : e,
+  c({
+    __invalidPositional: T([d(), f()]).optional().describe("Internal flag for positional argument rejection"),
+    ...Oe,
+    refId: ie().optional().describe("Element reference ID (e.g. e2)"),
+    label: d().optional().describe("Human-readable element label"),
+    ...t
+  }).superRefine(it)
+);
+c({});
+c({});
+c({
+  url: d().describe("URL to navigate to"),
+  timeout: P().optional().describe("Navigation timeout in milliseconds")
+});
+c({});
+c({});
+c({});
+c({
+  duration: P().default(1000n).describe("Duration to wait in milliseconds")
+});
+M();
+M({ value: d().describe("Value to fill into the element") });
+M({ text: d().describe("Text to type into the element") });
+M({ text: d().describe("Text to append into the element") });
+c({
+  key: d().describe("Key to press (e.g. Enter, Escape, ArrowDown)")
+});
+M({ value: d().describe("Value to select in the dropdown") });
+M({
+  checked: x().optional().describe("Desired checked state (true to check, false to uncheck)")
+});
+M();
+c({});
+c({
+  direction: d().default("down").describe("Scroll direction: up, down, left, or right"),
+  amount: f().default(300).describe("Pixels to scroll")
+});
+J(
+  (t) => typeof t == "string" || typeof t == "number" ? { __invalidPositional: t } : t,
+  c({
+    __invalidPositional: T([d(), f()]).optional().describe("Internal flag for positional argument rejection"),
+    refId: ie().optional().describe("Element reference ID (e.g. e2)"),
+    label: d().optional().describe("Human-readable element label"),
+    x: f().optional().describe("X coordinate to scroll to"),
+    y: f().optional().describe("Y coordinate to scroll to")
+  }).superRefine(Et)
+);
+M();
+c({
+  selector: d().describe("CSS selector to find elements")
+});
+c({
+  selector: d().describe("CSS selector to wait for"),
+  timeout: P().default(30000n).describe("Timeout in milliseconds")
+});
+const mr = c({
+  fields: A(d()).describe("Array of field names to extract")
+});
+J(
+  (t) => Array.isArray(t) ? { fields: t } : t,
+  mr
+);
+T([
+  f(),
+  A(c({}).passthrough()),
+  c({}).passthrough()
+]);
+c({});
+c({
+  active: x().optional().describe("Whether the tabs are active"),
+  currentWindow: x().optional().describe("Whether the tabs are in the current window"),
+  url: d().optional().describe("URL pattern to match tabs against")
+}).passthrough();
+J(
+  (t) => typeof t == "string" ? { url: t } : t,
+  c({
+    url: d().optional().describe("URL to open in the new tab"),
+    active: x().optional().describe("Whether to focus the new tab")
+  })
+);
+T([
+  f(),
+  A(c({ id: f().optional(), tabId: f().optional(), tab_id: f().optional() }).passthrough()),
+  c({ id: f().optional(), tabId: f().optional(), tab_id: f().optional() }).passthrough()
+]);
+ae();
+ae({ value: d().describe("Value to fill into the element") });
+J(
+  (t) => typeof t == "string" || typeof t == "number" ? { __invalidPositional: t } : t,
+  c({
+    __invalidPositional: T([d(), f()]).optional().describe("Internal flag for positional argument rejection"),
+    ...Oe,
+    refId: ie().optional().describe("Element reference ID (e.g. e2)"),
+    label: d().optional().describe("Human-readable element label"),
+    x: f().optional().describe("X coordinate to scroll to"),
+    y: f().optional().describe("Y coordinate to scroll to")
+  }).superRefine(Et)
+);
+ae({ text: d().describe("Text to type into the element") });
+c({
+  ...Oe,
+  key: d().describe("Key to press (e.g. Enter, Escape, ArrowDown)")
+});
+ae({ value: d().describe("Value to select in the dropdown") });
+ae({
+  checked: x().optional().describe("Desired checked state (true to check, false to uncheck)")
+});
+ae();
+c({
+  ...Oe
+});
+c({
+  ...Oe,
+  direction: d().default("down").describe("Scroll direction: up, down, left, or right"),
+  amount: f().default(300).describe("Pixels to scroll")
+});
+ae();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID"),
+  script: d().optional().describe("Script to evaluate"),
+  code: d().optional().describe("Alternative script code"),
+  js: d().optional().describe("Alternative JS code")
+}).passthrough();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID")
+}).passthrough();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID")
+}).passthrough();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID"),
+  timeout: f().optional().describe("Timeout in milliseconds")
+}).passthrough();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID"),
+  url: d().optional().describe("URL to fetch"),
+  options: c({}).passthrough().optional().describe("Fetch options")
+}).passthrough();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID"),
+  max_nodes: f().optional().describe("Maximum nodes to include"),
+  options: c({}).passthrough().optional().describe("Snapshot options")
+}).passthrough();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID"),
+  max_nodes: f().optional().describe("Maximum nodes to include"),
+  options: c({}).passthrough().optional().describe("Snapshot options")
+}).passthrough();
+c({
+  tabId: T([f(), B()]).optional().describe("Target tab ID"),
+  max_nodes: f().optional().describe("Maximum nodes to include"),
+  options: c({}).passthrough().optional().describe("Snapshot options")
+}).passthrough();
+M();
+M();
+M({
+  value: d().optional().describe("Value to fill into the element")
+});
+M({
+  text: d().optional().describe("Text to type into the element")
+});
+c({
+  key: d().optional().describe("Key to press (e.g. Enter, Escape, ArrowDown)")
+});
+M({
+  value: d().optional().describe("Value to select in the dropdown")
+});
+M({
+  checked: x().optional().describe("Desired checked state (true to check, false to uncheck)")
+});
+M();
+c({});
+c({
+  direction: d().optional().describe("Scroll direction: up, down, left, or right"),
+  amount: f().optional().describe("Pixels to scroll")
+});
+M();
+M({
+  text: d().optional().describe("Text to append into the element")
+});
+c({});
+c({});
+c({
+  duration: P().default(1000n).describe("Duration to wait in milliseconds")
+});
+c({
+  interactive_only: x().default(!1).describe("Only include interactive elements"),
+  max_nodes: P().default(500n).describe("Maximum number of nodes to include in snapshot")
+});
+c({
+  interactive_only: x().default(!1).describe("Only include interactive elements"),
+  max_nodes: P().default(500n).describe("Maximum number of nodes to include in snapshot")
+});
+c({
+  interactive_only: x().default(!1).describe("Only include interactive elements"),
+  max_nodes: P().default(500n).describe("Maximum number of nodes to include in snapshot")
+});
+c({
+  interactive_only: x().default(!1).describe("Only include interactive elements"),
+  max_nodes: P().default(500n).describe("Maximum number of nodes to include in snapshot")
+});
+c({
+  snapshot: c({}).passthrough().describe("Raw DOM snapshot data to format"),
+  format: d().optional().describe("Output format (e.g. markdown, html)")
+});
+c({
+  max_nodes: f().optional().describe("Maximum nodes to include"),
+  options: c({}).passthrough().optional().describe("Snapshot options")
+}).passthrough();
+c({
+  max_nodes: f().optional().describe("Maximum nodes to include"),
+  options: c({}).passthrough().optional().describe("Snapshot options")
+}).passthrough();
+c({
+  max_nodes: f().optional().describe("Maximum nodes to include"),
+  options: c({}).passthrough().optional().describe("Snapshot options")
+}).passthrough();
+const Y = c({
+  path: d().describe("File or directory path")
+}), bt = c({
+  from: d().describe("Source path"),
+  to: d().describe("Destination path")
+}), de = c({
+  path: d().describe("File path to write to"),
+  data: d().describe("Data to write")
+}), gr = c({
+  path: d().describe("File path to read from"),
+  offset: P().describe("Byte offset to start reading"),
+  len: f().describe("Number of bytes to read")
+}), yr = c({
+  path: d().describe("File path to update"),
+  offset: P().describe("Byte offset to start writing"),
+  data: d().describe("Data to write")
+}), br = c({
+  path: d().describe("File path to hash"),
+  algo: d().default("sha256").describe("Hash algorithm (e.g. sha256, md5)")
+});
+y(b());
+y(b());
+y(b());
+y(b());
+T([
+  f(),
+  y(b())
+]);
+T([
+  f(),
+  y(b())
+]);
+y(b());
+y(b());
+y(b());
+T([
+  d(),
+  y(b())
+]);
+y(b());
+y(
+  b()
+);
+y(b());
+y(b());
+y(b());
+T([
+  d(),
+  f(),
+  y(b())
+]);
+y(b());
+y(b());
+y(b());
+T([
+  f(),
+  y(b())
+]);
+y(b());
+y(b());
+y(b());
+y(b());
+y(b());
+A(b());
+T([
+  d(),
+  y(b())
+]);
+y(b());
+T([
+  d(),
+  y(b())
+]);
+y(b());
+T([
+  d(),
+  y(b())
+]);
+y(b());
+T([
+  d(),
+  y(b())
+]);
+y(b());
+y(b());
+T([
+  f(),
+  y(b())
+]);
+y(b());
+y(b());
+T([
+  f(),
+  y(b())
+]);
+y(
+  b()
+);
+T([
+  d(),
+  f(),
+  y(b())
+]);
+y(b());
+y(b());
+y(b());
+y(b());
+T([
+  f(),
+  y(b())
+]);
+T([
+  f(),
+  y(b())
+]);
+T([
+  f(),
+  y(b())
+]);
+T([
+  f(),
+  y(b())
+]);
+T([
+  f(),
+  y(b())
+]);
+y(b());
+y(b());
+y(b());
+c({
+  action: d().describe("Host action name"),
+  params: c({}).passthrough().optional().describe("Parameters for the host action")
+}).passthrough();
+T([
+  d(),
+  f(),
+  x(),
+  St(),
+  A(b()),
+  y(b())
+]);
+const _r = c({
+  ok: lr(!0).describe("Whether the action succeeded"),
+  action: d().describe("Action identifier (e.g. 'page_fill')"),
+  refId: ie().optional().describe("Element reference ID that was acted upon (e.g. e2)"),
+  tag: d().optional().describe("HTML tag name of the element"),
+  role: d().optional().describe("ARIA role of the element"),
+  name: d().optional().describe("Accessible name of the element"),
+  value: d().optional().describe("Final value of the element after the action"),
+  checked: x().optional().describe("Checked state after the action"),
+  disabled: x().optional().describe("Whether the element is disabled"),
+  readOnly: x().optional().describe("Whether the element is read-only"),
+  text: d().optional().describe("Text content of the element"),
+  key: d().optional().describe("Key that was pressed (for press actions)"),
+  direction: d().optional().describe("Scroll direction (for scroll actions)"),
+  amount: f().optional().describe("Scroll amount in pixels (for scroll actions)")
+});
+T([
+  _r,
+  St()
+]);
+c({
+  status: f().describe("HTTP response status code"),
+  ok: x().describe("Whether the response status is 2xx"),
+  headers: y(d()).describe("Response headers as key-value pairs"),
+  body: d().describe("Response body as string (text or base64-encoded bytes)"),
+  bodyEncoding: Xe(["text", "base64"]).describe("Encoding of the body field"),
+  byteLength: f().describe("Length of the body in bytes"),
+  contentType: d().describe("Response Content-Type header"),
+  finalUrl: d().describe("Final URL after redirects")
+});
+c({
+  data: c({}).passthrough().describe("Structured snapshot data"),
+  text: d().describe("Plain text representation of the snapshot")
+});
+c({});
+c({
+  tabId: f(),
+  url: d(),
+  title: d(),
+  contentScript: Xe(["connected", "missing"]),
+  domApis: Xe(["ok", "blocked"]),
+  mutationsReady: x(),
+  hint: d().optional(),
+  recovery: A(d()).optional()
+});
+const vr = c({
+  refId: ie().describe("Element reference ID (e.g. e2)"),
+  role: d().describe("ARIA role of the element"),
+  tag: d().describe("HTML tag name"),
+  name: d().optional().describe("Accessible name of the element"),
+  text: d().optional().describe("Visible text content of the element"),
+  value: d().optional().describe("Element value"),
+  checked: x().optional().describe("Checked state"),
+  disabled: x().optional().describe("Whether the element is disabled"),
+  readOnly: x().optional().describe("Whether the element is read-only"),
+  href: d().optional().describe("Absolute URL for link elements"),
+  src: d().optional().describe("Absolute URL for image elements"),
+  alt: d().optional().describe("Alternative text for image elements"),
+  title: d().optional().describe("Title attribute"),
+  parentRefId: ie().optional().describe("Reference ID of the parent container element"),
+  postId: d().optional().describe("Stable post identifier from data-post-id attribute"),
+  permalink: d().optional().describe("Stable permalink URL from anchor element"),
+  imageUrls: A(d()).optional().describe("Image URLs contained within this element")
+});
+c({
+  text: d().describe("Plain text representation of the page"),
+  nodes: A(vr).describe("Array of interactive nodes"),
+  url: d().describe("Current page URL"),
+  title: d().describe("Current page title"),
+  viewport: c({
+    width: f().describe("Viewport width in pixels"),
+    height: f().describe("Viewport height in pixels")
+  }).describe("Viewport dimensions")
+});
+const At = c({
+  id: f().optional().describe("Tab ID"),
+  tabId: f().optional().describe("Tab ID (added by runner)"),
+  index: f().optional().describe("Tab index in the window"),
+  windowId: f().optional().describe("Window ID"),
+  url: d().optional().describe("Tab URL"),
+  title: d().optional().describe("Tab title"),
+  status: d().optional().describe("Tab status (loading or complete)"),
+  active: x().optional().describe("Whether the tab is active"),
+  pinned: x().optional().describe("Whether the tab is pinned"),
+  highlighted: x().optional().describe("Whether the tab is highlighted"),
+  incognito: x().optional().describe("Whether the tab is incognito"),
+  favIconUrl: d().optional().describe("Favicon URL"),
+  audible: x().optional().describe("Whether the tab is audible"),
+  groupId: f().optional().describe("Group ID"),
+  openerTabId: f().optional().describe("Opener tab ID"),
+  discarded: x().optional().describe("Whether the tab is discarded"),
+  autoDiscardable: x().optional().describe("Whether the tab is auto-discardable"),
+  width: f().optional().describe("Tab width"),
+  height: f().optional().describe("Tab height"),
+  sessionId: d().optional().describe("Session ID")
+}).passthrough(), kr = A(At), Rt = c({
+  id: f().optional().describe("Window ID"),
+  focused: x().optional().describe("Whether the window is focused"),
+  top: f().optional().describe("Window top position"),
+  left: f().optional().describe("Window left position"),
+  width: f().optional().describe("Window width"),
+  height: f().optional().describe("Window height"),
+  tabs: kr.optional().describe("Array of tabs in the window"),
+  incognito: x().optional().describe("Whether the window is incognito"),
+  type: d().optional().describe("Window type"),
+  state: d().optional().describe("Window state"),
+  alwaysOnTop: x().optional().describe("Whether the window is always on top"),
+  sessionId: d().optional().describe("Session ID")
+}).passthrough();
+A(Rt);
+const wr = c({
+  name: d().describe("Cookie name"),
+  value: d().describe("Cookie value"),
+  domain: d().optional().describe("Cookie domain"),
+  hostOnly: x().optional().describe("Whether the cookie is host-only"),
+  path: d().optional().describe("Cookie path"),
+  secure: x().optional().describe("Whether the cookie is secure"),
+  httpOnly: x().optional().describe("Whether the cookie is HTTP-only"),
+  sameSite: d().optional().describe("SameSite policy"),
+  session: x().optional().describe("Whether the cookie is a session cookie"),
+  expirationDate: f().optional().describe("Expiration date as Unix timestamp"),
+  storeId: d().optional().describe("Store ID")
+}).nullable();
+A(wr.nullable().unwrap());
+const xr = c({
+  id: d().describe("Bookmark ID"),
+  parentId: d().optional().describe("Parent folder ID"),
+  index: f().optional().describe("Bookmark index"),
+  url: d().optional().describe("Bookmark URL"),
+  title: d().describe("Bookmark title"),
+  dateAdded: f().optional().describe("Date added"),
+  dateGroupModified: f().optional().describe("Date group modified"),
+  children: A(c({ id: d() }).passthrough()).optional().describe("Child bookmarks")
+}).passthrough();
+A(xr);
+const Tr = c({
+  id: d().describe("History item ID"),
+  url: d().optional().describe("URL"),
+  title: d().optional().describe("Title"),
+  lastVisitTime: f().optional().describe("Last visit time"),
+  visitCount: f().optional().describe("Visit count"),
+  typedCount: f().optional().describe("Typed count")
+}).passthrough();
+A(Tr);
+const Ir = c({
+  frameId: f().describe("Frame ID"),
+  result: b().optional().describe("Script result")
+});
+A(Ir);
+d();
+x();
+T([d(), f()]);
+x();
+const Sr = c({
+  id: f().optional().describe("Group ID"),
+  collapsed: x().optional().describe("Whether the group is collapsed"),
+  color: d().optional().describe("Group color"),
+  title: d().optional().describe("Group title"),
+  windowId: f().optional().describe("Window ID")
+}).passthrough();
+A(Sr);
+const Er = c({
+  lastModified: f().optional().describe("Last modified time"),
+  tab: At.optional().describe("Tab info"),
+  window: Rt.optional().describe("Window info")
+}).passthrough(), Ar = A(Er), Rr = c({
+  deviceName: d().optional().describe("Device name"),
+  sessions: Ar.optional().describe("Sessions")
+}).passthrough();
+A(Rr);
+const Cr = c({
+  id: f().optional().describe("Download ID"),
+  url: d().optional().describe("Download URL"),
+  filename: d().optional().describe("Filename"),
+  startTime: d().optional().describe("Start time"),
+  endTime: d().optional().describe("End time"),
+  state: d().optional().describe("Download state"),
+  danger: d().optional().describe("Danger type"),
+  paused: x().optional().describe("Whether the download is paused"),
+  error: d().optional().describe("Error message"),
+  bytesReceived: f().optional().describe("Bytes received"),
+  totalBytes: f().optional().describe("Total bytes"),
+  fileSize: f().optional().describe("File size"),
+  mime: d().optional().describe("MIME type"),
+  incognito: x().optional().describe("Whether the download is incognito"),
+  referrer: d().optional().describe("Referrer URL"),
+  byExtensionId: d().optional().describe("Extension ID"),
+  byExtensionName: d().optional().describe("Extension name")
+}).passthrough();
+A(Cr);
+f();
+c({
+  archName: d().describe("CPU architecture"),
+  modelName: d().describe("CPU model"),
+  numOfProcessors: f().describe("Number of processors"),
+  features: A(d()).describe("CPU features")
+});
+c({
+  capacity: f().describe("Total memory capacity"),
+  availableCapacity: f().describe("Available memory capacity")
+});
+A(c({
+  id: d().describe("Storage ID"),
+  name: d().describe("Storage name"),
+  type: d().describe("Storage type"),
+  capacity: f().describe("Storage capacity")
+}));
+const Ze = {
   trace: 0,
   debug: 1,
   info: 2,
   warn: 3,
   error: 4,
   none: 5
-}, te = [
+}, Or = [
   "trace",
   "debug",
   "info",
@@ -14,388 +3451,448 @@ const I = {
   "error",
   "none"
 ];
-function se(r) {
-  const e = Math.max(0, Math.min(5, Math.round(r)));
-  return te[e] ?? "error";
-}
-let P = "trace", C = null;
-function ne(r) {
-  P = r, C && C(I[r]);
-}
-function oe(r) {
-  C = r, r(I[P]);
-}
-function ae(r) {
-  return I[r] >= I[P];
-}
-function V(r, e = "info") {
-  var s;
-  if (r === null) return "null";
-  if (r === void 0) return "undefined";
-  if (typeof r == "string") return r;
-  if (typeof r == "number" || typeof r == "boolean")
-    return String(r);
-  if (typeof r == "bigint") return `${r}n`;
-  if (r instanceof Error) {
-    const t = e === "debug" || e === "trace" ? r.stack : (s = r.stack) == null ? void 0 : s.split(`
+function Nr(t) {
+  const e = Math.max(0, Math.min(5, Math.round(t)));
+  return Or[e] ?? "error";
+}
+let at = "trace", Qe = null;
+function Mr(t) {
+  at = t, Qe && Qe(Ze[t]);
+}
+function $r(t) {
+  Qe = t, t(Ze[at]);
+}
+function Lr(t) {
+  return Ze[t] >= Ze[at];
+}
+function Ct(t, e = "info") {
+  var r;
+  if (t === null) return "null";
+  if (t === void 0) return "undefined";
+  if (typeof t == "string") return t;
+  if (typeof t == "number" || typeof t == "boolean")
+    return String(t);
+  if (typeof t == "bigint") return `${t}n`;
+  if (t instanceof Error) {
+    const s = e === "debug" || e === "trace" ? t.stack : (r = t.stack) == null ? void 0 : r.split(`
 `)[0];
-    return JSON.stringify({ message: r.message, name: r.name, stack: t });
+    return JSON.stringify({ message: t.message, name: t.name, stack: s });
   }
-  if (typeof r == "function") return "[Function]";
-  if (typeof r == "symbol") return String(r);
-  if (typeof r == "object")
+  if (typeof t == "function") return "[Function]";
+  if (typeof t == "symbol") return String(t);
+  if (typeof t == "object")
     try {
-      return JSON.stringify(r);
-    } catch (t) {
-      return t instanceof TypeError && t.message.includes("circular") ? "[Circular]" : `[Unserializable: ${t instanceof Error ? t.message : String(t)}]`;
+      return JSON.stringify(t);
+    } catch (s) {
+      return s instanceof TypeError && s.message.includes("circular") ? "[Circular]" : `[Unserializable: ${s instanceof Error ? s.message : String(s)}]`;
     }
-  return String(r);
+  return String(t);
 }
-function ie(r) {
-  return `[extension-js][${r}]`;
+function jr(t) {
+  return `[extension-js][${t}]`;
 }
-function le(r, e) {
-  if (!r) return "";
-  const s = [];
+function Pr(t, e) {
+  if (!t) return "";
+  const r = [];
   try {
-    for (const [t, n] of Object.entries(r))
-      s.push(`${t}=${V(n, e)}`);
+    for (const [s, n] of Object.entries(t))
+      r.push(`${s}=${Ct(n, e)}`);
   } catch {
     return " metadata=[unreadable]";
   }
-  return s.length > 0 ? ` ${s.join(" ")}` : "";
+  return r.length > 0 ? ` ${r.join(" ")}` : "";
 }
-function b(r, e) {
-  return e.length === 0 ? { event: r } : e.length === 1 && typeof e[0] == "object" && e[0] !== null && !Array.isArray(e[0]) ? { event: r, metadata: e[0] } : {
-    event: r,
-    metadata: { _args: e.map((s) => V(s)).join(" ") }
+function ye(t, e) {
+  return e.length === 0 ? { event: t } : e.length === 1 && typeof e[0] == "object" && e[0] !== null && !Array.isArray(e[0]) ? { event: t, metadata: e[0] } : {
+    event: t,
+    metadata: { _args: e.map((r) => Ct(r)).join(" ") }
   };
 }
-class $ {
+class ot {
   constructor(e = "root") {
     this.namespace = e;
   }
-  log(e, s, t) {
+  log(e, r, s) {
     try {
-      if (!ae(e)) return;
-      const n = ie(this.namespace), a = le(t, e), i = `${n} ${s}${a}`;
+      if (!Lr(e)) return;
+      const n = jr(this.namespace), i = Pr(s, e), o = `${n} ${r}${i}`;
       switch (e) {
         case "trace":
         case "debug":
         case "info":
-          console.log(i);
+          console.log(o);
           break;
         case "warn":
-          console.warn(i);
+          console.warn(o);
           break;
         case "error":
-          console.error(i);
+          console.error(o);
           break;
         case "none":
           break;
         default: {
-          const o = e;
+          const a = e;
           break;
         }
       }
     } catch {
     }
   }
-  trace(e, ...s) {
-    const { event: t, metadata: n } = b(e, s);
-    this.log("trace", t, n);
+  trace(e, ...r) {
+    const { event: s, metadata: n } = ye(e, r);
+    this.log("trace", s, n);
   }
-  debug(e, ...s) {
-    const { event: t, metadata: n } = b(e, s);
-    this.log("debug", t, n);
+  debug(e, ...r) {
+    const { event: s, metadata: n } = ye(e, r);
+    this.log("debug", s, n);
   }
-  info(e, ...s) {
-    const { event: t, metadata: n } = b(e, s);
-    this.log("info", t, n);
+  info(e, ...r) {
+    const { event: s, metadata: n } = ye(e, r);
+    this.log("info", s, n);
   }
-  warn(e, ...s) {
-    const { event: t, metadata: n } = b(e, s);
-    this.log("warn", t, n);
+  warn(e, ...r) {
+    const { event: s, metadata: n } = ye(e, r);
+    this.log("warn", s, n);
   }
-  error(e, ...s) {
-    const { event: t, metadata: n } = b(e, s);
-    this.log("error", t, n);
+  error(e, ...r) {
+    const { event: s, metadata: n } = ye(e, r);
+    this.log("error", s, n);
   }
   child(e) {
-    return new $(`${this.namespace}.${e}`);
+    return new ot(`${this.namespace}.${e}`);
   }
-  timer(e, s, t = "info") {
-    const n = typeof performance < "u" && performance.now, a = n ? performance.now() : Date.now();
-    return (i) => {
+  timer(e, r, s = "info") {
+    const n = typeof performance < "u" && performance.now, i = n ? performance.now() : Date.now();
+    return (o) => {
       try {
-        const o = n ? performance.now() : Date.now(), g = Math.round(o - a), u = {
-          ...s,
-          ...i,
-          duration_ms: g
+        const a = n ? performance.now() : Date.now(), h = Math.round(a - i), l = {
+          ...r,
+          ...o,
+          duration_ms: h
         };
-        this.log(t, e, u);
+        this.log(s, e, l);
       } catch {
       }
     };
   }
 }
-const l = new $("root"), ce = /* @__PURE__ */ new Set();
-function ue(r) {
-  return ce.has(r);
+const C = new ot("root"), Zr = /* @__PURE__ */ new Set();
+function Dr(t) {
+  return Zr.has(t);
 }
-const J = /* @__PURE__ */ new Map();
-function de(r, e) {
-  J.set(r, e);
+const Ot = /* @__PURE__ */ new Map();
+function Wr(t, e) {
+  Ot.set(t, e);
 }
-function fe(r) {
-  return J.get(r);
+function Vr(t) {
+  return Ot.get(t);
 }
-function ge(r) {
-  return r.startsWith("tab_") ? "required" : "active";
+function Ur(t) {
+  return t.startsWith("tab_") ? "required" : "active";
 }
-function pe(r) {
-  return r === "content-script" ? "content-script" : r === "main-thread" ? "main-thread" : r === "worker" ? "worker:default" : r.startsWith("worker:") ? r : "main-thread";
+function Fr(t) {
+  return t === "content-script" ? "content-script" : t === "main-thread" ? "main-thread" : t === "worker" ? "worker:default" : t.startsWith("worker:") ? t : "main-thread";
 }
-function me(r, e) {
-  return e !== "main-thread" ? e : ue(r) ? "content-script" : e;
+function zr(t, e) {
+  return e !== "main-thread" ? e : Dr(t) ? "content-script" : e;
 }
-function ye(r, e) {
+function Br(t, e) {
   return {
-    endpoint: pe(me(r, e)),
-    tabPolicy: ge(r)
+    endpoint: Fr(zr(t, e)),
+    tabPolicy: Ur(t)
   };
 }
-function he(r) {
-  for (const e of r)
-    de(e.action, ye(e.action, e.owner));
+function qr(t) {
+  for (const e of t)
+    Wr(e.action, Br(e.action, e.owner));
 }
-function k(r) {
-  return r == null ? {} : r instanceof Map ? Object.fromEntries(
-    [...r.entries()].map(([e, s]) => [e, k(s)])
-  ) : Array.isArray(r) ? r.map(k) : r;
+function me(t) {
+  return t == null ? {} : t instanceof Map ? Object.fromEntries(
+    [...t.entries()].map(([e, r]) => [e, me(r)])
+  ) : Array.isArray(t) ? t.map(me) : t;
 }
-function Ee(r) {
+function Hr(t) {
   return {
-    action: r.action,
-    namespace: r.namespace,
-    name: r.name,
-    publicName: r.publicName,
-    description: r.description,
-    fields: r.fields,
-    aliases: (r.aliases ?? []).map((e) => ({
+    action: t.action,
+    namespace: t.namespace,
+    name: t.name,
+    publicName: t.publicName,
+    description: t.description,
+    fields: t.fields,
+    aliases: (t.aliases ?? []).map((e) => ({
       namespace: e.namespace,
       name: e.name,
       fields: e.fields
     })),
-    paramsDoc: r.paramsDoc.map((e) => ({
+    paramsDoc: t.paramsDoc.map((e) => ({
       name: e.name,
       type: e.type,
       required: e.required,
       description: e.description
     })),
     returnsDoc: {
-      type: r.returnsDoc.type,
-      description: r.returnsDoc.description
+      type: t.returnsDoc.type,
+      description: t.returnsDoc.description
     },
-    errorCode: r.errorCode,
-    errorCategory: r.errorCategory ?? null,
-    permission: r.permission ?? null,
-    example: r.example ?? null,
-    prerequisites: r.prerequisites ?? null,
-    notes: r.notes ?? null,
-    tags: r.tags ?? null,
-    relatedApis: r.relatedApis ?? null
+    errorCode: t.errorCode,
+    errorCategory: t.errorCategory ?? null,
+    permission: t.permission ?? null,
+    example: t.example ?? null,
+    prerequisites: t.prerequisites ?? null,
+    notes: t.notes ?? null,
+    tags: t.tags ?? null,
+    relatedApis: t.relatedApis ?? null
   };
 }
-l.child("tool-registry");
-let h = null, v = !1;
-const E = /* @__PURE__ */ new Map();
-function T(r, e) {
+function N(t, e = 0, r = 2) {
+  if (e > r) return "...";
+  if (t instanceof R) {
+    const s = t.shape, n = Object.keys(s).filter((o) => !o.startsWith("__"));
+    return n.length === 0 ? "{ }" : e >= r - 1 ? "{ ... }" : `{ ${n.map((o) => {
+      const a = s[o], h = a instanceof W, l = N(h ? a.unwrap() : a, e + 1, r);
+      return `${o}${h ? "?" : ""}: ${l}`;
+    }).join(", ")} }`;
+  }
+  if (t instanceof Te)
+    return t.options.map((s) => N(s, e, r)).join(" or ");
+  if (t instanceof U) return "string";
+  if (t instanceof se) return "number";
+  if (t instanceof Le) return "boolean";
+  if (t instanceof ne) return "bigint";
+  if (t instanceof xe) return "null";
+  if (t instanceof D) {
+    const s = N(t.element, e + 1, r);
+    return s === "unknown" || s === "any" ? "array" : `${s}[]`;
+  }
+  if (t instanceof z)
+    return `[${t.items.map((s) => N(s, e + 1, r)).join(", ")}]`;
+  if (t instanceof Se) {
+    const s = N(t._def.valueType, e + 1, r);
+    return s === "unknown" || s === "any" ? "{ [key: string]: unknown }" : `{ [key: string]: ${s} }`;
+  }
+  return t instanceof W ? `${N(t.unwrap(), e, r)}?` : t instanceof Ee ? JSON.stringify(t.value) : t instanceof Q ? t.options.map((s) => `"${s}"`).join(" | ") : t instanceof qe ? "any" : t instanceof re ? "unknown" : t instanceof He ? "void" : t instanceof je ? "undefined" : t instanceof G ? N(t.innerType(), e, r) : t instanceof Ae ? N(t.removeDefault(), e, r) : t instanceof ee ? `${N(t.unwrap(), e, r)} | null` : t instanceof Pe ? "lazy" : t instanceof pe ? `Promise<${N(t.unwrap(), e + 1, r)}>` : t instanceof ve ? "function" : t instanceof we ? "Date" : t instanceof Je ? "Map" : t instanceof he ? "Set" : t instanceof Ie ? `${N(t._def.left, e, r)} & ${N(t._def.right, e, r)}` : t instanceof st ? t.options.map((s) => N(s, e, r)).join(" or ") : t instanceof nt ? N(t.unwrap(), e, r) : t instanceof Ke ? "NaN" : t instanceof Re ? N(t.removeCatch(), e, r) : t instanceof We ? N(t._def.in, e, r) : t instanceof Ce ? `readonly ${N(t.unwrap(), e, r)}` : "unknown";
+}
+function Gr(t) {
+  return t === null ? "null" : t === void 0 ? "undefined" : Array.isArray(t) ? "array" : typeof t;
+}
+function Jr(t, e, r, s) {
+  const n = r.filter((a) => a.path.length === 0), i = r.filter((a) => a.path.length > 0);
+  if (n.length > 0 && i.length === 0) {
+    const a = n.some((l) => l.code === "custom"), h = n.some(
+      (l) => l.code !== "invalid_type" && l.code !== "invalid_literal" && l.code !== "invalid_union"
+    );
+    if (!a && !h) {
+      const l = N(e), _ = Gr(s);
+      return `Invalid parameters for ${t}: expected ${l}${l === "{ }" ? " or no args" : ""}, received ${_}`;
+    }
+  }
+  const o = r.map((a) => `at '${a.path.length > 0 ? a.path.join(".") : "root"}': ${a.message}`);
+  return `Invalid parameters for ${t}: ${o.join("; ")}`;
+}
+C.child("tool-registry");
+let le = null, et = !1;
+const ue = /* @__PURE__ */ new Map();
+function De(t, e) {
   try {
-    return r.postMessage(e), !0;
-  } catch (s) {
-    const t = s instanceof Error ? s.message : String(s);
-    return l.error("port_post_failed", { error: t }), !1;
+    return t.postMessage(e), !0;
+  } catch (r) {
+    const s = r instanceof Error ? r.message : String(r);
+    return C.error("port_post_failed", { error: s }), !1;
   }
 }
-const G = 1e3;
-function K(r, e, s) {
-  e === "main-thread" || e === "content-script" ? T(s, { type: "relayCancel", id: r, owner: e }) : T(s, { type: "registryCallCancel", id: r });
+const _t = 1e3;
+function Nt(t, e, r) {
+  e === "main-thread" || e === "content-script" ? De(r, { type: "relayCancel", id: t, owner: e }) : De(r, { type: "registryCallCancel", id: t });
 }
-function q(r, e) {
-  for (const [s, t] of E)
-    clearTimeout(t.timeoutId), K(s, t.owner, t.port), t.settle({
+function vt(t, e) {
+  for (const [r, s] of ue)
+    clearTimeout(s.timeoutId), Nt(r, s.owner, s.port), s.settle({
       ok: !1,
-      error: { message: e, code: r }
-    }), E.delete(s);
-}
-const _ = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
-let z = Promise.resolve(), f = null;
-function _e(r) {
-  l.trace("sessionQueue_enqueue");
-  const e = z.then(r);
-  return z = e.then(
+      error: { message: e, code: t }
+    }), ue.delete(r);
+}
+const ge = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Map();
+let kt = Promise.resolve(), Z = null;
+function Yr(t) {
+  C.trace("sessionQueue_enqueue");
+  const e = kt.then(t);
+  return kt = e.then(
     () => {
     },
     () => {
     }
   ), e;
 }
-function Y(r) {
-  f && (l.error("runCell_worker_failure", {
-    runId: f.runId,
-    callId: f.id,
-    error: r
+function Mt(t) {
+  Z && (C.error("runCell_worker_failure", {
+    runId: Z.runId,
+    callId: Z.id,
+    error: t
   }), self.postMessage({
     type: "error",
-    id: f.id,
-    error: r,
-    runId: f.runId
-  }), f = null);
-}
-self.addEventListener("error", (r) => {
-  const e = r.message || (r.error instanceof Error ? r.error.message : "Worker uncaught error");
-  l.error("worker_uncaught_error", { error: e }), Y(e);
-});
-self.addEventListener("unhandledrejection", (r) => {
-  const e = r.reason, s = e instanceof Error ? e.message : String(e ?? "Unhandled rejection");
-  l.error("worker_unhandled_rejection", { error: s }), Y(s);
-});
-function c(r, e) {
-  _.set(r, e);
-}
-function be() {
-  const r = new Uint8Array(16);
-  return crypto.getRandomValues(r), Array.from(r, (e) => e.toString(16).padStart(2, "0")).join("");
-}
-function we(r) {
-  return se(r);
-}
-const O = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Map();
-function ke(r, e) {
-  var s;
-  if (O.has(r))
-    throw new Error(`Worker port already registered for owner: ${r}`);
+    id: Z.id,
+    error: t,
+    runId: Z.runId
+  }), Z = null);
+}
+self.addEventListener("error", (t) => {
+  const e = t.message || (t.error instanceof Error ? t.error.message : "Worker uncaught error");
+  C.error("worker_uncaught_error", { error: e }), Mt(e);
+});
+self.addEventListener("unhandledrejection", (t) => {
+  const e = t.reason, r = e instanceof Error ? e.message : String(e ?? "Unhandled rejection");
+  C.error("worker_unhandled_rejection", { error: r }), Mt(r);
+});
+function Kr(t, e) {
+  ge.set(t, e);
+}
+function O(t, e, r) {
+  Kr(t, async (s, n) => {
+    const i = e.safeParse(me(s));
+    if (!i.success) {
+      const o = Jr(
+        t,
+        e,
+        i.error.issues,
+        s
+      ), a = new Error(o);
+      throw a.code = "E_INVALID_PARAMS", a;
+    }
+    return await r(i.data, n);
+  });
+}
+function Xr() {
+  const t = new Uint8Array(16);
+  return crypto.getRandomValues(t), Array.from(t, (e) => e.toString(16).padStart(2, "0")).join("");
+}
+function Qr(t) {
+  return Nr(t);
+}
+const tt = /* @__PURE__ */ new Map(), Me = /* @__PURE__ */ new Map();
+function es(t, e) {
+  var r;
+  if (tt.has(t))
+    throw new Error(`Worker port already registered for owner: ${t}`);
   if (typeof e.addEventListener != "function")
-    throw new Error(`Worker port for owner "${r}" cannot receive responses`);
-  O.set(r, e), e.addEventListener("message", async (t) => {
-    var a;
-    const n = t.data;
+    throw new Error(`Worker port for owner "${t}" cannot receive responses`);
+  tt.set(t, e), e.addEventListener("message", async (s) => {
+    var i;
+    const n = s.data;
     if (n !== null && (n.type === "asyncRelayResult" || n.type === "registryCallResult") && typeof n.id == "string") {
-      N(n.id, n.result);
+      rt(n.id, n.result);
       return;
     }
     if (n !== null && n.type === "registryCallCancel" && typeof n.id == "string") {
-      (a = A.get(n.id)) == null || a.abort(), A.delete(n.id);
+      (i = Me.get(n.id)) == null || i.abort(), Me.delete(n.id);
       return;
     }
     if (n !== null && n.type === "registryCall" && typeof n.id == "string" && typeof n.action == "string") {
-      const i = n.id, o = new AbortController();
-      A.set(i, o);
-      const g = _.get(n.action);
-      let u;
-      if (!g)
-        u = {
+      const o = n.id, a = new AbortController();
+      Me.set(o, a);
+      const h = ge.get(n.action);
+      let l;
+      if (!h)
+        l = {
           ok: !1,
           error: { message: `Unknown worker action: ${n.action}`, code: "E_UNKNOWN" }
         };
       else
         try {
-          const d = await g(n.params, {
+          const _ = await h(n.params, {
             action: n.action,
             callId: n.callId,
             runId: n.runId,
-            signal: o.signal
+            signal: a.signal
           });
-          u = o.signal.aborted ? { ok: !1, error: { message: "Relay aborted", code: "E_ABORT" } } : { ok: !0, value: d };
-        } catch (d) {
-          u = {
+          l = a.signal.aborted ? { ok: !1, error: { message: "Relay aborted", code: "E_ABORT" } } : { ok: !0, value: _ };
+        } catch (_) {
+          l = {
             ok: !1,
             error: {
-              message: d instanceof Error ? d.message : String(d),
-              code: o.signal.aborted ? "E_ABORT" : "E_WORKER_HANDLER"
+              message: _ instanceof Error ? _.message : String(_),
+              code: a.signal.aborted ? "E_ABORT" : "E_WORKER_HANDLER"
             }
           };
         }
-      A.delete(i), T(e, { type: "registryCallResult", id: i, result: u }) || N(i, {
+      Me.delete(o), De(e, { type: "registryCallResult", id: o, result: l }) || rt(o, {
         ok: !1,
         error: { message: "Failed to deliver worker handler response", code: "E_PORT" }
       });
     }
-  }), (s = e.start) == null || s.call(e);
+  }), (r = e.start) == null || r.call(e);
 }
-function N(r, e) {
-  l.trace("resolveAsyncRelayResult", { id: r });
-  const s = E.get(r);
-  return s ? (s.settle(e), !0) : (l.warn("asyncRelayResult_no_pending_relay", { id: r }), !1);
+function rt(t, e) {
+  C.trace("resolveAsyncRelayResult", { id: t });
+  const r = ue.get(t);
+  return r ? (r.settle(e), !0) : (C.warn("asyncRelayResult_no_pending_relay", { id: t }), !1);
 }
-function Me(r) {
-  if (r === "main-thread" || r === "content-script")
+function ts(t) {
+  if (t === "main-thread" || t === "content-script")
     return self;
-  const e = O.get(r);
+  const e = tt.get(t);
   return e || null;
 }
-function Q(r) {
-  const { owner: e, action: s, tabPolicy: t, resolveTimeoutMs: n } = r, a = r.timeoutMs ?? w;
-  return (i, o) => {
-    l.trace("safePostAsCall_invoke", { owner: e, action: s, callId: o == null ? void 0 : o.callId, runId: o == null ? void 0 : o.runId });
-    const g = (n == null ? void 0 : n(i)) ?? a;
-    return new Promise((u, d) => {
-      var j;
-      if ((j = o == null ? void 0 : o.signal) != null && j.aborted) {
-        const m = new Error(`Relay aborted for action: ${s}`);
-        m.code = "E_ABORT", d(m);
+function $t(t) {
+  const { owner: e, action: r, tabPolicy: s, resolveTimeoutMs: n } = t, i = t.timeoutMs ?? _e;
+  return (o, a) => {
+    C.trace("safePostAsCall_invoke", { owner: e, action: r, callId: a == null ? void 0 : a.callId, runId: a == null ? void 0 : a.runId });
+    const h = (n == null ? void 0 : n(o)) ?? i;
+    return new Promise((l, _) => {
+      var ft;
+      if ((ft = a == null ? void 0 : a.signal) != null && ft.aborted) {
+        const q = new Error(`Relay aborted for action: ${r}`);
+        q.code = "E_ABORT", _(q);
         return;
       }
-      const y = Me(e);
-      if (!y) {
-        d(new Error(`No port available for action: ${s}`));
+      const E = ts(e);
+      if (!E) {
+        _(new Error(`No port available for action: ${r}`));
         return;
       }
-      if (E.size >= G) {
-        d(new Error(
-          `Too many pending calls (${G} limit exceeded). Action: ${s}`
+      if (ue.size >= _t) {
+        _(new Error(
+          `Too many pending calls (${_t} limit exceeded). Action: ${r}`
         ));
         return;
       }
-      const M = be();
-      let W = !1;
-      const R = (m) => {
-        W || (W = !0, clearTimeout(U), o != null && o.signal && o.signal.removeEventListener("abort", S), E.delete(M), m());
-      }, D = () => {
-        K(M, e, y);
-      }, S = () => {
-        D();
-        const m = new Error(`Relay aborted for action: ${s}`);
-        m.code = "E_ABORT", R(() => d(m));
+      const te = Xr();
+      let oe = !1;
+      const Ne = (q) => {
+        oe || (oe = !0, clearTimeout(ct), a != null && a.signal && a.signal.removeEventListener("abort", Ve), ue.delete(te), q());
+      }, dt = () => {
+        Nt(te, e, E);
+      }, Ve = () => {
+        dt();
+        const q = new Error(`Relay aborted for action: ${r}`);
+        q.code = "E_ABORT", Ne(() => _(q));
       };
-      o != null && o.signal && o.signal.addEventListener("abort", S);
-      const U = setTimeout(() => {
-        D(), R(() => d(new Error(`Relay timeout for action: ${s}`)));
-      }, g);
-      E.set(M, {
-        settle: (m) => R(() => u(m)),
-        timeoutId: U,
-        abort: S,
+      a != null && a.signal && a.signal.addEventListener("abort", Ve);
+      const ct = setTimeout(() => {
+        dt(), Ne(() => _(new Error(`Relay timeout for action: ${r}`)));
+      }, h);
+      ue.set(te, {
+        settle: (q) => Ne(() => l(q)),
+        timeoutId: ct,
+        abort: Ve,
         owner: e,
-        port: y
+        port: E
       });
-      const F = o == null ? void 0 : o.runId, B = o == null ? void 0 : o.callId;
-      T(y, {
+      const lt = a == null ? void 0 : a.runId, ut = a == null ? void 0 : a.callId;
+      De(E, {
         type: e === "main-thread" || e === "content-script" ? "asyncRelay" : "registryCall",
-        id: M,
+        id: te,
         owner: e,
-        action: s,
-        params: i,
-        callId: B,
-        tabPolicy: t,
-        command: { action: s, params: i, runId: F, callId: B },
-        runId: F
-      }) || R(() => d(new Error(`Failed to post relay for action: ${s}`)));
+        action: r,
+        params: o,
+        callId: ut,
+        tabPolicy: s,
+        command: { action: r, params: o, runId: lt, callId: ut },
+        runId: lt
+      }) || Ne(() => _(new Error(`Failed to post relay for action: ${r}`)));
     });
   };
 }
-const Re = "worker", w = 3e4, H = 5e3, Ae = 500, Ie = {
+const rs = "worker", _e = 3e4, wt = 5e3, ss = 500, ns = {
   page_goto: "timeout",
   page_wait_for: "timeout",
   tab_wait_for_load: "timeout",
@@ -403,154 +3900,154 @@ const Re = "worker", w = 3e4, H = 5e3, Ae = 500, Ie = {
   sleep: "duration",
   page_wait: "duration",
   sidepanel_wait: "duration"
-}, X = /* @__PURE__ */ new Set(["page_goto"]);
-function Te(r, e) {
-  if (r === null || typeof r != "object" || Array.isArray(r))
+}, Lt = /* @__PURE__ */ new Set(["page_goto"]);
+function is(t, e) {
+  if (t === null || typeof t != "object" || Array.isArray(t))
     return null;
-  const s = r[e];
-  return typeof s == "bigint" ? Number(s) : typeof s == "number" && Number.isFinite(s) ? s : null;
-}
-function Se(r, e) {
-  return X.has(r) ? e * 2 + Ae + H : e + H;
-}
-function Z(r, e) {
-  const s = Ie[r];
-  if (!s) return w;
-  let t = Te(e, s);
-  return t === null && X.has(r) && (t = w), t === null ? w : Math.max(
-    w,
-    Se(r, t)
+  const r = t[e];
+  return typeof r == "bigint" ? Number(r) : typeof r == "number" && Number.isFinite(r) ? r : null;
+}
+function as(t, e) {
+  return Lt.has(t) ? e * 2 + ss + wt : e + wt;
+}
+function jt(t, e) {
+  const r = ns[t];
+  if (!r) return _e;
+  let s = is(e, r);
+  return s === null && Lt.has(t) && (s = _e), s === null ? _e : Math.max(
+    _e,
+    as(t, s)
   );
 }
-function Ne(r, e) {
-  var a, i;
-  r = k(r);
-  const s = e == null ? void 0 : e.action;
-  if (l.trace("extensionDispatch", { action: s, callId: e == null ? void 0 : e.callId, runId: e == null ? void 0 : e.runId }), !s)
+function us(t, e) {
+  var i, o;
+  t = me(t);
+  const r = e == null ? void 0 : e.action;
+  if (C.trace("extensionDispatch", { action: r, callId: e == null ? void 0 : e.callId, runId: e == null ? void 0 : e.runId }), !r)
     return Promise.resolve({
       ok: !1,
       error: { message: "Missing action in dispatch context", code: "E_MISSING_ACTION" }
     });
-  if (_.has(s)) {
-    const o = _.get(s), g = (e == null ? void 0 : e.signal) ?? (e != null && e.runId ? (a = p.get(e.runId)) == null ? void 0 : a.signal : void 0);
+  if (ge.has(r)) {
+    const a = ge.get(r), h = (e == null ? void 0 : e.signal) ?? (e != null && e.runId ? (i = V.get(e.runId)) == null ? void 0 : i.signal : void 0);
     return (async () => {
       try {
-        return { ok: !0, value: await o(r, { ...e, signal: g }) };
-      } catch (u) {
-        const d = u instanceof Error ? u.message : String(u), y = typeof u == "object" && u !== null && "code" in u && typeof u.code == "string" ? u.code : "E_WORKER_HANDLER";
-        return { ok: !1, error: { message: d, code: y } };
+        return { ok: !0, value: await a(t, { ...e, signal: h }) };
+      } catch (l) {
+        const _ = l instanceof Error ? l.message : String(l), E = typeof l == "object" && l !== null && "code" in l && typeof l.code == "string" ? l.code : "E_WORKER_HANDLER";
+        return { ok: !1, error: { message: _, code: E } };
       }
     })();
   }
-  const t = fe(s);
-  return t ? Q({
-    owner: t.endpoint,
-    action: s,
-    resolveTimeoutMs: (o) => Z(s, o),
-    tabPolicy: t.tabPolicy
-  })(r, {
+  const s = Vr(r);
+  return s ? $t({
+    owner: s.endpoint,
+    action: r,
+    resolveTimeoutMs: (a) => jt(r, a),
+    tabPolicy: s.tabPolicy
+  })(t, {
     ...e,
-    signal: (e == null ? void 0 : e.signal) ?? (e != null && e.runId ? (i = p.get(e.runId)) == null ? void 0 : i.signal : void 0)
+    signal: (e == null ? void 0 : e.signal) ?? (e != null && e.runId ? (o = V.get(e.runId)) == null ? void 0 : o.signal : void 0)
   }) : Promise.resolve({
     ok: !1,
-    error: { message: `No route registered for action: ${s}`, code: "E_NO_ROUTE" }
+    error: { message: `No route registered for action: ${r}`, code: "E_NO_ROUTE" }
   });
 }
-function Le(r) {
-  if (r.owner === Re) {
-    const e = _.get(r.action);
+function os(t) {
+  if (t.owner === rs) {
+    const e = ge.get(t.action);
     if (!e)
       throw new Error(
-        `No worker-local handler registered for action: ${r.action}`
+        `No worker-local handler registered for action: ${t.action}`
       );
-    return async (s, t) => {
-      var a;
-      s = k(s);
-      const n = (t == null ? void 0 : t.signal) ?? (t != null && t.runId ? (a = p.get(t.runId)) == null ? void 0 : a.signal : void 0);
+    return async (r, s) => {
+      var i;
+      r = me(r);
+      const n = (s == null ? void 0 : s.signal) ?? (s != null && s.runId ? (i = V.get(s.runId)) == null ? void 0 : i.signal : void 0);
       try {
-        return { ok: !0, value: await e(s, { ...t, action: r.action, signal: n }) };
-      } catch (i) {
-        const o = i instanceof Error ? i.message : String(i), g = typeof i == "object" && i !== null && "code" in i && typeof i.code == "string" ? i.code : r.errorCode;
-        return { ok: !1, error: { message: o, code: g } };
+        return { ok: !0, value: await e(r, { ...s, action: t.action, signal: n }) };
+      } catch (o) {
+        const a = o instanceof Error ? o.message : String(o), h = typeof o == "object" && o !== null && "code" in o && typeof o.code == "string" ? o.code : t.errorCode;
+        return { ok: !1, error: { message: a, code: h } };
       }
     };
   } else {
-    const e = Q({
-      owner: r.owner,
-      action: r.action,
-      resolveTimeoutMs: (s) => Z(r.action, s)
+    const e = $t({
+      owner: t.owner,
+      action: t.action,
+      resolveTimeoutMs: (r) => jt(t.action, r)
     });
-    return (s, t) => {
+    return (r, s) => {
       var n;
-      return e(k(s), {
-        ...t,
-        signal: (t == null ? void 0 : t.signal) ?? (t != null && t.runId ? (n = p.get(t.runId)) == null ? void 0 : n.signal : void 0)
+      return e(me(r), {
+        ...s,
+        signal: (s == null ? void 0 : s.signal) ?? (s != null && s.runId ? (n = V.get(s.runId)) == null ? void 0 : n.signal : void 0)
       });
     };
   }
 }
-function Ce(r) {
-  c("exists", (e) => r.fsExists(e)), c("stat", (e) => r.fsStat(e)), c("read", (e) => r.fsRead(e)), c("readText", (e) => r.fsReadText(e)), c("readBase64", (e) => r.fsReadBase64(e)), c("list", (e) => r.fsList(e)), c("mkdir", (e) => r.fsMkdir(e)), c("delete", (e) => r.fsDelete(e)), c("copy", (e) => r.fsCopy(e)), c("move", (e) => r.fsMove(e)), c("write", (e) => r.fsWrite(e)), c("writeText", (e) => r.fsWriteText(e)), c("writeBase64", (e) => r.fsWriteBase64(e)), c("append", (e) => r.fsAppend(e)), c("appendText", (e) => r.fsAppendText(e)), c("appendBase64", (e) => r.fsAppendBase64(e)), c("readRange", (e) => r.fsReadRange(e)), c("update", (e) => r.fsUpdate(e)), c("hash", (e) => r.fsHash(e));
+function ds(t) {
+  O("exists", Y, (e) => t.fsExists(e)), O("stat", Y, (e) => t.fsStat(e)), O("read", Y, (e) => t.fsRead(e)), O("readText", Y, (e) => t.fsReadText(e)), O("readBase64", Y, (e) => t.fsReadBase64(e)), O("list", Y, (e) => t.fsList(e)), O("mkdir", Y, (e) => t.fsMkdir(e)), O("delete", Y, (e) => t.fsDelete(e)), O("copy", bt, (e) => t.fsCopy(e)), O("move", bt, (e) => t.fsMove(e)), O("write", de, (e) => t.fsWrite(e)), O("writeText", de, (e) => t.fsWriteText(e)), O("writeBase64", de, (e) => t.fsWriteBase64(e)), O("append", de, (e) => t.fsAppend(e)), O("appendText", de, (e) => t.fsAppendText(e)), O("appendBase64", de, (e) => t.fsAppendBase64(e)), O("readRange", gr, (e) => t.fsReadRange(e)), O("update", yr, (e) => t.fsUpdate(e)), O("hash", br, (e) => t.fsHash(e));
 }
-async function ve(r, e) {
-  if (v) return;
-  await x(), h = new ee(), L(0), oe(L), l.trace("initWasm_start"), Ce(h), he(r);
-  const t = r.map((a) => ({
-    entry: Ee(a),
-    callback: Le(a)
+async function cs(t, e) {
+  if (et) return;
+  await Pt(), le = new Zt(), Fe(0), $r(Fe), C.trace("initWasm_start"), ds(le), qr(t);
+  const s = t.map((i) => ({
+    entry: Hr(i),
+    callback: os(i)
   }));
   try {
-    re(t);
-  } catch (a) {
-    const i = a instanceof Error ? a.message : String(a);
-    throw new Error(`Registry registration failed: ${i}`);
+    Dt(s);
+  } catch (i) {
+    const o = i instanceof Error ? i.message : String(i);
+    throw new Error(`Registry registration failed: ${o}`);
   }
   const { freezeManifest: n } = await import("./extension_js.js");
   try {
     n();
-  } catch (a) {
-    const i = a instanceof Error ? a.message : String(a);
-    throw new Error(`Manifest freeze failed: ${i}`);
-  }
-  if (h.injectRegistryBindings(), e) {
-    const a = JSON.stringify(e);
-    await h.runCellAsync(
-      `(function(){var r=globalThis.chrome&&globalThis.chrome.runtime;if(!r){r={};if(!globalThis.chrome)globalThis.chrome={};globalThis.chrome.runtime=r;}r.id=${a};})();`,
+  } catch (i) {
+    const o = i instanceof Error ? i.message : String(i);
+    throw new Error(`Manifest freeze failed: ${o}`);
+  }
+  if (le.injectRegistryBindings(), e) {
+    const i = JSON.stringify(e);
+    await le.runCellAsync(
+      `(function(){var r=globalThis.chrome&&globalThis.chrome.runtime;if(!r){r={};if(!globalThis.chrome)globalThis.chrome={};globalThis.chrome.runtime=r;}r.id=${i};})();`,
       "",
       "inject-runtime-id"
     );
   }
-  v = !0, l.trace("initWasm_done");
+  et = !0, C.trace("initWasm_done");
 }
-self.onmessage = async (r) => {
-  const e = r.data;
-  if (l.trace("onmessage", { type: e.type, id: "id" in e ? e.id : void 0 }), e.type === "asyncRelayResult") {
-    l.trace("asyncRelayResult", { id: e.id }), N(e.id, e.result);
+self.onmessage = async (t) => {
+  const e = t.data;
+  if (C.trace("onmessage", { type: e.type, id: "id" in e ? e.id : void 0 }), e.type === "asyncRelayResult") {
+    C.trace("asyncRelayResult", { id: e.id }), rt(e.id, e.result);
     return;
   }
   if (e.type === "registerWorkerPort") {
-    const t = r.ports[0];
-    if (!t) {
-      l.error("register_worker_port_missing", { owner: e.owner });
+    const s = t.ports[0];
+    if (!s) {
+      C.error("register_worker_port_missing", { owner: e.owner });
       return;
     }
-    ke(e.owner, t);
+    es(e.owner, s);
     return;
   }
   if (e.type === "init") {
     try {
-      await ve(e.manifest, e.extensionId), self.postMessage({ type: "ready" });
-    } catch (t) {
-      const n = t instanceof Error ? t.message : String(t);
-      l.error("worker_init_failed", { error: n }), self.postMessage({ type: "error", error: `WASM init failed: ${n}` });
+      await cs(e.manifest, e.extensionId), self.postMessage({ type: "ready" });
+    } catch (s) {
+      const n = s instanceof Error ? s.message : String(s);
+      C.error("worker_init_failed", { error: n }), self.postMessage({ type: "error", error: `WASM init failed: ${n}` });
     }
     return;
   }
   if (e.type === "setLogLevel") {
-    L(e.level), ne(we(e.level)), l.trace("set_log_level", { level: e.level });
+    Fe(e.level), Mr(Qr(e.level)), C.trace("set_log_level", { level: e.level });
     return;
   }
-  if (!v || !h) {
+  if (!et || !le) {
     self.postMessage({
       type: "error",
       id: e.id,
@@ -558,61 +4055,68 @@ self.onmessage = async (r) => {
     });
     return;
   }
-  const s = h;
-  await _e(async () => {
+  const r = le;
+  await Yr(async () => {
     switch (e.type) {
       case "runCell": {
-        const t = e.runId, n = new AbortController();
-        t && p.set(t, n), f = { id: e.id, runId: t }, l.trace("runCell_start", { runId: t, callId: e.id, codeLen: e.code.length });
+        const s = e.runId, n = new AbortController();
+        s && V.set(s, n), Z = { id: e.id, runId: s }, C.trace("runCell_start", { runId: s, callId: e.id, codeLen: e.code.length });
         try {
-          const a = await s.runCellAsync(
+          const i = await r.runCellAsync(
             e.code,
             e.stdin || "",
-            t || ""
+            s || ""
           );
-          l.trace("runCell_done", { runId: t, callId: e.id, status: a.status }), self.postMessage({
+          C.trace("runCell_done", { runId: s, callId: e.id, status: i.status }), self.postMessage({
             type: "result",
             id: e.id,
-            data: a,
-            runId: t
+            data: i,
+            runId: s
           });
-        } catch (a) {
-          const i = a instanceof Error ? a.message : String(a);
-          l.error("runCell_error", { runId: t, error: i }), self.postMessage({
+        } catch (i) {
+          const o = i instanceof Error ? i.message : String(i), a = i instanceof Error ? i.name : void 0, h = i instanceof Error ? i.stack : void 0;
+          let l;
+          if (h) {
+            const E = h.match(/:(\d+):\d+\)?$/m);
+            E && (l = parseInt(E[1], 10));
+          }
+          C.error("runCell_error", { runId: s, error: o, name: a, line: l });
+          const _ = i instanceof Error ? { name: a, message: o, stack: h, ...l !== void 0 ? { line: l } : {} } : { message: o };
+          self.postMessage({
             type: "error",
             id: e.id,
-            error: i,
-            runId: t
+            error: _,
+            runId: s
           });
         } finally {
-          (f == null ? void 0 : f.id) === e.id && (f = null), t && p.delete(t);
+          (Z == null ? void 0 : Z.id) === e.id && (Z = null), s && V.delete(s);
         }
         break;
       }
       case "reset": {
-        s.setAborted(!0);
-        for (const t of p.values()) t.abort();
-        p.clear(), q("E_RESET", "Worker reset");
+        r.setAborted(!0);
+        for (const s of V.values()) s.abort();
+        V.clear(), vt("E_RESET", "Worker reset");
         try {
-          s.reset(), self.postMessage({ type: "result", id: e.id, data: { ok: !0 } });
-        } catch (t) {
-          const n = t instanceof Error ? t.message : String(t);
+          r.reset(), self.postMessage({ type: "result", id: e.id, data: { ok: !0 } });
+        } catch (s) {
+          const n = s instanceof Error ? s.message : String(s);
           self.postMessage({ type: "error", id: e.id, error: n });
         }
         break;
       }
       case "stop": {
-        s.setAborted(!0);
-        for (const t of p.values()) t.abort();
-        p.clear(), q("E_STOPPED", "Worker stopped"), self.postMessage({ type: "result", id: e.id, data: { ok: !0 } });
+        r.setAborted(!0);
+        for (const s of V.values()) s.abort();
+        V.clear(), vt("E_STOPPED", "Worker stopped"), self.postMessage({ type: "result", id: e.id, data: { ok: !0 } });
         break;
       }
       case "setFuelLimit": {
         try {
-          s.set_fuel_limit(e.limit), e.id && self.postMessage({ type: "result", id: e.id, data: { ok: !0 } });
-        } catch (t) {
+          r.set_fuel_limit(e.limit), e.id && self.postMessage({ type: "result", id: e.id, data: { ok: !0 } });
+        } catch (s) {
           if (e.id) {
-            const n = t instanceof Error ? t.message : String(t);
+            const n = s instanceof Error ? s.message : String(s);
             self.postMessage({ type: "error", id: e.id, error: n });
           }
         }
@@ -620,37 +4124,37 @@ self.onmessage = async (r) => {
       }
       case "inspectGlobals": {
         try {
-          const t = s.inspect_globals();
-          self.postMessage({ type: "result", id: e.id, data: t });
-        } catch (t) {
-          const n = t instanceof Error ? t.message : String(t);
+          const s = r.inspect_globals();
+          self.postMessage({ type: "result", id: e.id, data: s });
+        } catch (s) {
+          const n = s instanceof Error ? s.message : String(s);
           self.postMessage({ type: "error", id: e.id, error: n });
         }
         break;
       }
       case "apiDocs": {
         try {
-          const t = s.apiDocs(e.format);
-          self.postMessage({ type: "result", id: e.id, data: t });
-        } catch (t) {
-          const n = t instanceof Error ? t.message : String(t);
+          const s = r.apiDocs(e.format);
+          self.postMessage({ type: "result", id: e.id, data: s });
+        } catch (s) {
+          const n = s instanceof Error ? s.message : String(s);
           self.postMessage({ type: "error", id: e.id, error: n });
         }
         break;
       }
       case "loadLibrary": {
         try {
-          const t = s.load_library(e.source);
-          self.postMessage({ type: "result", id: e.id, data: t });
-        } catch (t) {
-          const n = t instanceof Error ? t.message : String(t);
+          const s = r.load_library(e.source);
+          self.postMessage({ type: "result", id: e.id, data: s });
+        } catch (s) {
+          const n = s instanceof Error ? s.message : String(s);
           self.postMessage({ type: "error", id: e.id, error: n });
         }
         break;
       }
       case "fsCall": {
-        const t = _.get(e.action);
-        if (!t) {
+        const s = ge.get(e.action);
+        if (!s) {
           self.postMessage({
             type: "error",
             id: e.id,
@@ -659,29 +4163,30 @@ self.onmessage = async (r) => {
           break;
         }
         try {
-          const n = await t(e.params);
+          const n = await s(e.params);
           self.postMessage({ type: "result", id: e.id, data: n });
         } catch (n) {
-          const a = n instanceof Error ? n.message : String(n);
-          self.postMessage({ type: "error", id: e.id, error: a });
+          const i = n instanceof Error ? n.message : String(n);
+          self.postMessage({ type: "error", id: e.id, error: i });
         }
         break;
       }
       default: {
-        l.error("unhandled_worker_message", { type: e.type });
+        C.error("unhandled_worker_message", { type: e.type });
         break;
       }
     }
   });
 };
 export {
-  w as DEFAULT_RELAY_TIMEOUT_MS,
-  Le as createExecutableCallback,
-  Ne as extensionDispatch,
-  c as registerWorkerHandler,
-  ke as registerWorkerPort,
-  N as resolveAsyncRelayResult,
-  Z as resolveRelayTimeoutMs,
-  Q as safePostAsCall,
-  q as settleAllPendingRelays
+  _e as DEFAULT_RELAY_TIMEOUT_MS,
+  os as createExecutableCallback,
+  us as extensionDispatch,
+  Kr as registerWorkerHandler,
+  O as registerWorkerHandlerValidated,
+  es as registerWorkerPort,
+  rt as resolveAsyncRelayResult,
+  jt as resolveRelayTimeoutMs,
+  $t as safePostAsCall,
+  vt as settleAllPendingRelays
 };