@pi-oxide/extension-js 0.6.0 → 0.8.1

package/worker.js

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