@xyo-network/sdk-protocol 7.4.2 → 8.0.0

package/dist/neutral/hash/worker/wasmHash-bundle.mjs

@@ -1,79 +1,6 @@
 "use strict";
 (() => {
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
-  var _a;
-  // @__NO_SIDE_EFFECTS__
-  function $constructor(name, initializer2, params) {
-    function init(inst, def) {
-      if (!inst._zod) {
-        Object.defineProperty(inst, "_zod", {
-          value: {
-            def,
-            constr: _,
-            traits: /* @__PURE__ */ new Set()
-          },
-          enumerable: false
-        });
-      }
-      if (inst._zod.traits.has(name)) {
-        return;
-      }
-      inst._zod.traits.add(name);
-      initializer2(inst, def);
-      const proto = _.prototype;
-      const keys = Object.keys(proto);
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i];
-        if (!(k in inst)) {
-          inst[k] = proto[k].bind(inst);
-        }
-      }
-    }
-    const Parent = params?.Parent ?? Object;
-    class Definition extends Parent {
-    }
-    Object.defineProperty(Definition, "name", { value: name });
-    function _(def) {
-      var _a3;
-      const inst = params?.Parent ? new Definition() : this;
-      init(inst, def);
-      (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
-      for (const fn of inst._zod.deferred) {
-        fn();
-      }
-      return inst;
-    }
-    Object.defineProperty(_, "init", { value: init });
-    Object.defineProperty(_, Symbol.hasInstance, {
-      value: (inst) => {
-        if (params?.Parent && inst instanceof params.Parent)
-          return true;
-        return inst?._zod?.traits?.has(name);
-      }
-    });
-    Object.defineProperty(_, "name", { value: name });
-    return _;
-  }
-  var $ZodAsyncError = class extends Error {
-    constructor() {
-      super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
-    }
-  };
-  var $ZodEncodeError = class extends Error {
-    constructor(name) {
-      super(`Encountered unidirectional transform during encode: ${name}`);
-      this.name = "ZodEncodeError";
-    }
-  };
-  (_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
-  var globalConfig = globalThis.__zod_globalConfig;
-  function config(newConfig) {
-    if (newConfig)
-      Object.assign(globalConfig, newConfig);
-    return globalConfig;
-  }
-
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/util.js
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js
   function jsonStringifyReplacer(_, value) {
     if (typeof value === "bigint")
       return value.toString();
@@ -150,13 +77,6 @@
       return { ...params, error: () => params.error };
     return params;
   }
-  var NUMBER_FORMAT_RANGES = {
-    safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
-    int32: [-2147483648, 2147483647],
-    uint32: [0, 4294967295],
-    float32: [-34028234663852886e22, 34028234663852886e22],
-    float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
-  };
   function aborted(x, startIndex = 0) {
     if (x.aborted === true)
       return true;
@@ -188,15 +108,35 @@
   function unwrapMessage(message) {
     return typeof message === "string" ? message : message?.message;
   }
+  function attachSchema(issues, start, inst) {
+    var _a3;
+    for (let i = start; i < issues.length; i++) {
+      (_a3 = issues[i]).schema ?? (_a3.schema = inst);
+    }
+  }
   function finalizeIssue(iss, ctx, config2) {
-    const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
-    const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
-    rest.path ?? (rest.path = []);
-    rest.message = message;
+    var _a3;
+    const traits = iss.inst?._zod?.traits;
+    if (traits?.has("$ZodType")) {
+      if (traits.has("$ZodCheck"))
+        (_a3 = iss).schema ?? (_a3.schema = iss.inst);
+      else
+        iss.schema = iss.inst;
+    }
+    const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : void 0;
+    const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    const full = {};
+    for (const k of Object.keys(iss)) {
+      if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__")
+        continue;
+      full[k] = iss[k];
+    }
+    full.path ?? (full.path = []);
+    full.message = message;
     if (ctx?.reportInput) {
-      rest.input = _input;
+      full.input = iss.input;
     }
-    return rest;
+    return full;
   }
   function issue(...args) {
     const [iss, input, inst] = args;
@@ -210,53 +150,270 @@
     }
     return { ...iss };
   }
-
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/errors.js
-  var initializer = (inst, def) => {
-    inst.name = "$ZodError";
-    Object.defineProperty(inst, "_zod", {
-      value: inst._zod,
-      enumerable: false
+  function members(proto, table) {
+    for (const key in table) {
+      const desc = Object.getOwnPropertyDescriptor(table, key);
+      if (desc.get)
+        Object.defineProperty(proto, key, { ...desc, enumerable: false });
+      else
+        defineBound(proto, key, desc.value);
+    }
+  }
+  function own(inst, key, value, enumerable = true) {
+    Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
+    return value;
+  }
+  function hide(inst, key, value) {
+    return own(inst, key, value, false);
+  }
+  function defineBound(proto, key, fn) {
+    Object.defineProperty(proto, key, {
+      configurable: true,
+      get() {
+        return this == null ? fn : own(this, key, fn.bind(this));
+      },
+      set(value) {
+        own(this, key, value);
+      }
     });
-    Object.defineProperty(inst, "issues", {
-      value: def,
-      enumerable: false
+  }
+  var installing;
+  var broke = false;
+  var breaker = {
+    configurable: true,
+    get() {
+      broke = true;
+      return void 0;
+    }
+  };
+  function defineLazyInternal(inst, key, compute) {
+    const proto = Object.getPrototypeOf(inst._zod);
+    if (key in proto && installing !== inst._zod) {
+      installing = void 0;
+      return;
+    }
+    installing = inst._zod;
+    Object.defineProperty(proto, key, {
+      configurable: true,
+      get() {
+        Object.defineProperty(this, key, breaker);
+        const outer = broke;
+        broke = false;
+        try {
+          const value = compute(this);
+          if (broke)
+            delete this[key];
+          else
+            Object.defineProperty(this, key, { configurable: true, writable: true, value });
+          broke = broke || outer;
+          return value;
+        } catch (err) {
+          delete this[key];
+          broke = broke || outer;
+          throw err;
+        }
+      },
+      set(value) {
+        Object.defineProperty(this, key, { configurable: true, writable: true, value });
+      }
     });
-    inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
-    Object.defineProperty(inst, "toString", {
-      value: () => inst.message,
-      enumerable: false
+  }
+
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.js
+  var _a;
+  var _zodDesc = { value: void 0, enumerable: false };
+  var _E = "captureStackTrace" in Error ? Error : null;
+  function newError(Definition) {
+    const E = _E;
+    if (E) {
+      const saved = E.stackTraceLimit;
+      if (typeof saved === "number") {
+        try {
+          E.stackTraceLimit = 0;
+        } catch {
+          _E = null;
+          return new Definition();
+        }
+        try {
+          return new Definition();
+        } finally {
+          E.stackTraceLimit = saved;
+        }
+      }
+    }
+    return new Definition();
+  }
+  // @__NO_SIDE_EFFECTS__
+  function $constructor(name, initializer2, proto, params) {
+    const zodProto = {};
+    function Internals(def) {
+      this.def = def;
+      this.constr = _;
+      this.traits = /* @__PURE__ */ new Set();
+    }
+    Internals.prototype = zodProto;
+    const protoMembers = proto;
+    const initialized = protoMembers && /* @__PURE__ */ new WeakSet();
+    function init(inst, def) {
+      if (!inst._zod) {
+        _zodDesc.value = new Internals(def);
+        try {
+          Object.defineProperty(inst, "_zod", _zodDesc);
+        } finally {
+          _zodDesc.value = void 0;
+        }
+      } else if (inst._zod.traits.has(name)) {
+        return;
+      }
+      inst._zod.traits.add(name);
+      initializer2(inst, def);
+      if (initialized) {
+        const own2 = Object.getPrototypeOf(inst);
+        const ctorProto = inst._zod.constr.prototype;
+        let up = own2;
+        while (up && up !== ctorProto)
+          up = Object.getPrototypeOf(up);
+        const target = up ?? own2;
+        if (!initialized.has(target)) {
+          initialized.add(target);
+          members(target, protoMembers);
+        }
+      }
+      const proto2 = _.prototype;
+      for (const k in proto2) {
+        if (!Object.prototype.hasOwnProperty.call(proto2, k))
+          continue;
+        if (!(k in inst)) {
+          inst[k] = proto2[k].bind(inst);
+        }
+      }
+    }
+    const Parent = params?.Parent ?? Object;
+    class Definition extends Parent {
+    }
+    Object.defineProperty(Definition, "name", { value: name });
+    function _(def) {
+      const inst = params?.Parent ? newError(Definition) : this;
+      init(inst, def);
+      const deferred = inst._zod.deferred;
+      if (deferred) {
+        for (const fn of deferred) {
+          fn();
+        }
+        inst._zod.deferred = void 0;
+      }
+      const pp = globalThis.__zod_globalConfig?.postProcessor;
+      if (pp)
+        pp(inst);
+      return inst;
+    }
+    Object.defineProperty(_, "init", { value: init });
+    Object.defineProperty(_, Symbol.hasInstance, {
+      value: (inst) => {
+        if (params?.Parent && inst instanceof params.Parent)
+          return true;
+        return inst?._zod?.traits?.has(name);
+      }
     });
+    Object.defineProperty(_, "name", { value: name });
+    return _;
+  }
+  var $ZodAsyncError = class extends Error {
+    constructor() {
+      super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+    }
   };
-  var $ZodError = $constructor("$ZodError", initializer);
-  var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
-
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/parse.js
-  var _parse = (_Err) => (schema, value, _ctx, _params) => {
-    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-    const result = schema._zod.run({ value, issues: [] }, ctx);
-    if (result instanceof Promise) {
-      throw new $ZodAsyncError();
+  var $ZodEncodeError = class extends Error {
+    constructor(name) {
+      super(`Encountered unidirectional transform during encode: ${name}`);
+      this.name = "ZodEncodeError";
     }
-    if (result.issues.length) {
-      const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
-      captureStackTrace(e, _params?.callee);
-      throw e;
+  };
+  (_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
+  var globalConfig = globalThis.__zod_globalConfig;
+  function config(newConfig) {
+    if (newConfig)
+      Object.assign(globalConfig, newConfig);
+    return globalConfig;
+  }
+
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/errors.js
+  function _getMessage() {
+    const internals = this._zod;
+    internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
+    return internals.message;
+  }
+  function _setMessage(value) {
+    this._zod.message = value;
+  }
+  var _messageDesc = {
+    get: _getMessage,
+    set: _setMessage,
+    enumerable: true,
+    configurable: true
+  };
+  var _issuesDesc = { value: void 0, enumerable: false };
+  var _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
+  var initializer = (inst, def) => {
+    inst.name = "$ZodError";
+    _issuesDesc.value = def;
+    Object.defineProperty(inst, "issues", _issuesDesc);
+    _issuesDesc.value = void 0;
+    Object.defineProperty(inst, "message", _messageDesc);
+    const proto = Object.getPrototypeOf(inst);
+    if (!_installedToString.has(proto)) {
+      _installedToString.add(proto);
+      Object.defineProperty(proto, "toString", {
+        configurable: true,
+        enumerable: false,
+        get() {
+          const value = () => this.message;
+          Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
+          return value;
+        },
+        set(value) {
+          Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
+        }
+      });
     }
-    return result.value;
+  };
+  var $ZodError = $constructor("$ZodError", initializer);
+  var $ZodRealError = $constructor("$ZodError", initializer, void 0, {
+    Parent: Error
+  });
+
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/parse.js
+  var _parse = (_Err) => {
+    const fn = (schema, value, _ctx, _params) => {
+      const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+      const result = schema._zod.run({ value, issues: [] }, ctx);
+      if (result instanceof Promise) {
+        throw new $ZodAsyncError();
+      }
+      if (result.issues.length) {
+        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+        captureStackTrace(e, _params?.callee ?? fn);
+        throw e;
+      }
+      return result.value;
+    };
+    return fn;
   };
   var parse = /* @__PURE__ */ _parse($ZodRealError);
-  var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
-    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-    let result = schema._zod.run({ value, issues: [] }, ctx);
-    if (result instanceof Promise)
-      result = await result;
-    if (result.issues.length) {
-      const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
-      captureStackTrace(e, params?.callee);
-      throw e;
-    }
-    return result.value;
+  var _parseAsync = (_Err) => {
+    const fn = async (schema, value, _ctx, params) => {
+      const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+      let result = schema._zod.run({ value, issues: [] }, ctx);
+      if (result instanceof Promise)
+        result = await result;
+      if (result.issues.length) {
+        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+        captureStackTrace(e, params?.callee ?? fn);
+        throw e;
+      }
+      return result.value;
+    };
+    return fn;
   };
   var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
   var _safeParse = (_Err) => (schema, value, _ctx) => {
@@ -265,37 +422,45 @@
     if (result instanceof Promise) {
       throw new $ZodAsyncError();
     }
-    return result.issues.length ? {
-      success: false,
-      error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-    } : { success: true, data: result.value };
+    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
   };
   var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+  function failure(Err, issues, ctx) {
+    let error;
+    return {
+      success: false,
+      get error() {
+        if (!error) {
+          error = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));
+          issues = void 0;
+          ctx = void 0;
+        }
+        return error;
+      },
+      set error(e) {
+        error = e;
+        issues = void 0;
+        ctx = void 0;
+      }
+    };
+  }
   var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
     const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise)
       result = await result;
-    return result.issues.length ? {
-      success: false,
-      error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-    } : { success: true, data: result.value };
+    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
   };
   var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
 
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/regexes.js
-  var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
-  var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
-  var string = (params) => {
-    const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
-    return new RegExp(`^${regex}$`);
-  };
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/regexes.js
+  var anyString = /^[\s\S]{0,}$/;
   var bigint = /^-?\d+n?$/;
   var number = /^-?\d+(?:\.\d+)?$/;
   var boolean = /^(?:true|false)$/i;
   var _null = /^null$/i;
 
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/checks.js
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.js
   var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
     var _a3;
     inst._zod ?? (inst._zod = {});
@@ -310,22 +475,12 @@
   var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
     $ZodCheck.init(inst, def);
     const origin = numericOriginMap[typeof def.value];
-    inst._zod.onattach.push((inst2) => {
-      const bag = inst2._zod.bag;
-      const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
-      if (def.value > curr) {
-        if (def.inclusive)
-          bag.minimum = def.value;
-        else
-          bag.exclusiveMinimum = def.value;
-      }
-    });
     inst._zod.check = (payload) => {
       if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
         return;
       }
       payload.issues.push({
-        origin,
+        origin: numericOriginMap[typeof payload.value] ?? origin,
         code: "too_small",
         minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
         input: payload.value,
@@ -338,14 +493,6 @@
   var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
     var _a3, _b;
     $ZodCheck.init(inst, def);
-    inst._zod.onattach.push((inst2) => {
-      const bag = inst2._zod.bag;
-      bag.format = def.format;
-      if (def.pattern) {
-        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
-        bag.patterns.add(def.pattern);
-      }
-    });
     if (def.pattern)
       (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
         def.pattern.lastIndex = 0;
@@ -383,24 +530,22 @@
     };
   });
 
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/versions.js
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/versions.js
   var version = {
     major: 4,
-    minor: 4,
-    patch: 3
+    minor: 6,
+    patch: 5
   };
 
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/schemas.js
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/schemas.js
   var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
     var _a3;
     inst ?? (inst = {});
     inst._zod.def = def;
     inst._zod.bag = inst._zod.bag || {};
     inst._zod.version = version;
-    const checks = [...inst._zod.def.checks ?? []];
-    if (inst._zod.traits.has("$ZodCheck")) {
-      checks.unshift(inst);
-    }
+    const defChecks = inst._zod.def.checks;
+    const checks = inst._zod.traits.has("$ZodCheck") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];
     for (const ch of checks) {
       for (const fn of ch._zod.onattach) {
         fn(inst);
@@ -413,6 +558,8 @@
       });
     } else {
       const runChecks = (payload, checks2, ctx) => {
+        if (payload.memo)
+          return payload;
         let isAborted = aborted(payload);
         let asyncResult;
         for (const ch of checks2) {
@@ -436,6 +583,7 @@
               const nextLen = payload.issues.length;
               if (nextLen === currLen)
                 return;
+              attachSchema(payload.issues, currLen, inst);
               if (!isAborted)
                 isAborted = aborted(payload, currLen);
             });
@@ -443,6 +591,7 @@
             const nextLen = payload.issues.length;
             if (nextLen === currLen)
               continue;
+            attachSchema(payload.issues, currLen, inst);
             if (!isAborted)
               isAborted = aborted(payload, currLen);
           }
@@ -489,22 +638,39 @@
         return runChecks(result, checks, ctx);
       };
     }
-    defineLazy(inst, "~standard", () => ({
+  }, {
+    // Wrappers extend this by installing a richer factory over it; reading it eagerly would defeat the laziness.
+    get "~standard"() {
+      return hide(this, "~standard", standardProps(this));
+    },
+    set "~standard"(value) {
+      own(this, "~standard", value);
+    }
+  });
+  var toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value };
+  async function validateAsync(inst, value) {
+    const ctx = { async: true };
+    return toStandardResult(await inst._zod.run({ value, issues: [] }, ctx), ctx);
+  }
+  function standardProps(inst) {
+    return {
       validate: (value) => {
+        const ctx = { async: false };
         try {
-          const r = safeParse(inst, value);
-          return r.success ? { value: r.data } : { issues: r.error?.issues };
+          const r = inst._zod.run({ value, issues: [] }, ctx);
+          if (!(r instanceof Promise))
+            return toStandardResult(r, ctx);
         } catch (_) {
-          return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
         }
+        return validateAsync(inst, value);
       },
       vendor: "zod",
       version: 1
-    }));
-  });
+    };
+  }
   var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
+    inst._zod.pattern = def.pattern ?? anyString;
     inst._zod.parse = (payload, _) => {
       if (def.coerce)
         try {
@@ -524,7 +690,7 @@
   });
   var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.pattern = inst._zod.bag.pattern ?? number;
+    inst._zod.pattern = number;
     inst._zod.parse = (payload, _ctx) => {
       if (def.coerce)
         try {
@@ -535,7 +701,7 @@
       if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
         return payload;
       }
-      const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+      const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? String(input) : void 0 : void 0;
       payload.issues.push({
         expected: "number",
         code: "invalid_type",
@@ -612,6 +778,8 @@
   }
   var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     $ZodType.init(inst, def);
+    const memo = globalConfig.memoizer;
+    memo?.attach(inst);
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
       if (!Array.isArray(input)) {
@@ -623,8 +791,9 @@
         });
         return payload;
       }
-      payload.value = Array(input.length);
+      payload.value = memo ? memo.alloc(inst, payload, Array(input.length), ctx) : Array(input.length);
       const proms = [];
+      const abortEarly = ctx?.abortEarly;
       for (let i = 0; i < input.length; i++) {
         const item = input[i];
         const result = def.element._zod.run({
@@ -635,6 +804,8 @@
           proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
         } else {
           handleArrayResult(result, payload, i);
+          if (abortEarly && result.issues.length !== 0 && aborted(result))
+            break;
         }
       }
       if (proms.length) {
@@ -665,17 +836,17 @@
   }
   var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
-    defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
-    defineLazy(inst._zod, "values", () => {
-      if (def.options.every((o) => o._zod.values)) {
-        return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+    defineLazyInternal(inst, "optin", (zod) => zod.def.options.some((o) => o._zod.optin === "defaulted") ? "defaulted" : zod.def.options.some((o) => o._zod.optin !== void 0) ? "optional" : void 0);
+    defineLazyInternal(inst, "optout", (zod) => zod.def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+    defineLazyInternal(inst, "values", (zod) => {
+      if (zod.def.options.every((o) => o._zod.values)) {
+        return new Set(zod.def.options.flatMap((option) => Array.from(option._zod.values)));
       }
       return void 0;
     });
-    defineLazy(inst._zod, "pattern", () => {
-      if (def.options.every((o) => o._zod.pattern)) {
-        const patterns = def.options.map((o) => o._zod.pattern);
+    defineLazyInternal(inst, "pattern", (zod) => {
+      if (zod.def.options.every((o) => o._zod.pattern)) {
+        const patterns = zod.def.options.map((o) => o._zod.pattern);
         return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
       }
       return void 0;
@@ -710,6 +881,8 @@
   });
   var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     $ZodType.init(inst, def);
+    const memo = globalConfig.memoizer;
+    memo?.attach(inst);
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
       if (!isPlainObject(input)) {
@@ -723,12 +896,14 @@
       }
       const proms = [];
       const values = def.keyType._zod.values;
-      if (values) {
-        payload.value = {};
+      if (values && !def.partial) {
+        payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};
         const recordKeys = /* @__PURE__ */ new Set();
         for (const key of values) {
           if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
             recordKeys.add(typeof key === "number" ? key.toString() : key);
+            if (key === "__proto__")
+              continue;
             const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
             if (keyResult instanceof Promise) {
               throw new Error("Async schemas not supported in object keys currently");
@@ -745,6 +920,8 @@
               continue;
             }
             const outKey = keyResult.value;
+            if (outKey === "__proto__")
+              continue;
             const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
             if (result instanceof Promise) {
               proms.push(result.then((result2) => {
@@ -764,8 +941,14 @@
         let unrecognized;
         for (const key in input) {
           if (!recordKeys.has(key)) {
-            unrecognized = unrecognized ?? [];
-            unrecognized.push(key);
+            if (def.mode === "loose") {
+              if (key === "__proto__")
+                continue;
+              payload.value[key] = input[key];
+            } else {
+              unrecognized = unrecognized ?? [];
+              unrecognized.push(key);
+            }
           }
         }
         if (unrecognized && unrecognized.length > 0) {
@@ -773,11 +956,13 @@
             code: "unrecognized_keys",
             input,
             inst,
-            keys: unrecognized
+            keys: unrecognized,
+            continue: true
           });
         }
       } else {
-        payload.value = {};
+        payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};
+        let unrecognized;
         for (const key of Reflect.ownKeys(input)) {
           if (key === "__proto__")
             continue;
@@ -800,6 +985,9 @@
           if (keyResult.issues.length) {
             if (def.mode === "loose") {
               payload.value[key] = input[key];
+            } else if (values) {
+              unrecognized = unrecognized ?? [];
+              unrecognized.push(key);
             } else {
               payload.issues.push({
                 code: "invalid_key",
@@ -812,21 +1000,33 @@
             }
             continue;
           }
+          const outKey = keyResult.value;
+          if (outKey === "__proto__")
+            continue;
           const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
                 payload.issues.push(...prefixIssues(key, result2.issues));
               }
-              payload.value[keyResult.value] = result2.value;
+              payload.value[outKey] = result2.value;
             }));
           } else {
             if (result.issues.length) {
               payload.issues.push(...prefixIssues(key, result.issues));
             }
-            payload.value[keyResult.value] = result.value;
+            payload.value[outKey] = result.value;
           }
         }
+        if (unrecognized && unrecognized.length > 0) {
+          payload.issues.push({
+            code: "unrecognized_keys",
+            input,
+            inst,
+            keys: unrecognized,
+            continue: true
+          });
+        }
       }
       if (proms.length) {
         return Promise.all(proms).then(() => payload);
@@ -837,6 +1037,7 @@
   var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.optin = "optional";
+    globalConfig.memoizer?.guard(inst);
     inst._zod.parse = (payload, ctx) => {
       if (ctx.direction === "backward") {
         throw new $ZodEncodeError(inst.constructor.name);
@@ -846,7 +1047,6 @@
         const output = _out instanceof Promise ? _out : Promise.resolve(_out);
         return output.then((output2) => {
           payload.value = output2;
-          payload.fallback = true;
           return payload;
         });
       }
@@ -854,16 +1054,15 @@
         throw new $ZodAsyncError();
       }
       payload.value = _out;
-      payload.fallback = true;
       return payload;
     };
   });
   var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "values", () => def.in._zod.values);
-    defineLazy(inst._zod, "optin", () => def.in._zod.optin);
-    defineLazy(inst._zod, "optout", () => def.out._zod.optout);
-    defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+    defineLazyInternal(inst, "values", (zod) => zod.def.in._zod.values);
+    defineLazyInternal(inst, "optin", (zod) => zod.def.in._zod.optin);
+    defineLazyInternal(inst, "optout", (zod) => zod.def.out._zod.optout);
+    defineLazyInternal(inst, "propValues", (zod) => zod.def.in._zod.propValues);
     inst._zod.parse = (payload, ctx) => {
       if (ctx.direction === "backward") {
         const right = def.out._zod.run(payload, ctx);
@@ -880,11 +1079,11 @@
     };
   });
   function handlePipeResult(left, next, ctx) {
-    if (left.issues.length) {
+    if (left.issues.some((iss) => iss.code !== "unrecognized_keys")) {
       left.aborted = true;
       return left;
     }
-    return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
+    return next._zod.run({ value: left.value, issues: left.issues }, ctx);
   }
   var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
     $ZodType.init(inst, def);
@@ -894,10 +1093,10 @@
         d._cachedInner = def.getter();
       return d._cachedInner;
     });
-    defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
-    defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
-    defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
-    defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0);
+    defineLazyInternal(inst, "pattern", (zod) => zod.innerType?._zod?.pattern);
+    defineLazyInternal(inst, "propValues", (zod) => zod.innerType?._zod?.propValues);
+    defineLazyInternal(inst, "optin", (zod) => zod.innerType?._zod?.optin ?? void 0);
+    defineLazyInternal(inst, "optout", (zod) => zod.innerType?._zod?.optout ?? void 0);
     inst._zod.parse = (payload, ctx) => {
       const inner = inst._zod.innerType;
       return inner._zod.run(payload, ctx);
@@ -937,21 +1136,19 @@
     }
   }
 
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/api.js
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/api.js
+  function snapshotChecks(def) {
+    if (def.checks)
+      def.checks = [...def.checks];
+    return def;
+  }
   // @__NO_SIDE_EFFECTS__
   function _string(Class, params) {
-    return new Class({
-      type: "string",
-      ...normalizeParams(params)
-    });
+    return new Class(snapshotChecks({ type: "string", ...normalizeParams(params) }));
   }
   // @__NO_SIDE_EFFECTS__
   function _number(Class, params) {
-    return new Class({
-      type: "number",
-      checks: [],
-      ...normalizeParams(params)
-    });
+    return new Class(snapshotChecks({ type: "number", checks: [], ...normalizeParams(params) }));
   }
   // @__NO_SIDE_EFFECTS__
   function _boolean(Class, params) {
@@ -1007,36 +1204,56 @@
     return schema;
   }
 
-  // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/schemas.js
+  // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/mini/schemas.js
   var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
     if (!inst._zod)
       throw new Error("Uninitialized schema in ZodMiniType.");
     $ZodType.init(inst, def);
     inst.def = def;
     inst.type = def.type;
-    inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
-    inst.check = (...checks) => {
-      return inst.clone({
+  }, {
+    // `with` is an alias for `check`: the same function object, not a wrapper.
+    get with() {
+      return this.check;
+    },
+    set with(value) {
+      own(this, "with", value);
+    },
+    parse(data, params) {
+      return parse(this, data, params, { callee: this.parse });
+    },
+    parseAsync(data, params) {
+      return parseAsync(this, data, params, { callee: this.parseAsync });
+    },
+    safeParse(data, params) {
+      return safeParse(this, data, params);
+    },
+    safeParseAsync(data, params) {
+      return safeParseAsync(this, data, params);
+    },
+    check(...checks) {
+      const def = this.def;
+      return this.clone({
         ...def,
         checks: [
           ...def.checks ?? [],
-          ...checks.map((ch) => typeof ch === "function" ? {
-            _zod: { check: ch, def: { check: "custom" }, onattach: [] }
-          } : ch)
+          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
         ]
       }, { parent: true });
-    };
-    inst.with = inst.check;
-    inst.clone = (_def, params) => clone(inst, _def, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta2) => {
-      reg.add(inst, meta2);
-      return inst;
-    });
-    inst.apply = (fn) => fn(inst);
+    },
+    clone(_def, params) {
+      return clone(this, _def, params);
+    },
+    brand() {
+      return this;
+    },
+    register(reg, meta2) {
+      reg.add(this, meta2);
+      return this;
+    },
+    apply(fn, ...args) {
+      return args.length === 0 ? fn(this) : fn(this, ...args);
+    }
   });
   var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
     $ZodString.init(inst, def);
@@ -1372,7 +1589,7 @@
     }
   };
 
-  // ../../node_modules/.pnpm/@ariestools+sdk@8.1.9_@opentelemetry+api@1.9.1_zod@4.4.3/node_modules/@ariestools/sdk/dist/browser/index.mjs
+  // ../../node_modules/.pnpm/@ariestools+sdk@9.0.0_@opentelemetry+api@1.9.1_zod@4.6.5/node_modules/@ariestools/sdk/dist/browser/index.mjs
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __decorateClass = (decorators, target, key, kind) => {
@@ -1533,12 +1750,128 @@
       throw toFetchError(error, { url: url.toString(), method: init.method });
     }
   }
-  async function parseJsonResponse(response, context = {}) {
+  function validateMaxResponseBytes(maxResponseBytes) {
+    if (maxResponseBytes !== void 0 && (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)) {
+      throw new RangeError("maxResponseBytes must be a positive safe integer");
+    }
+  }
+  function abortError(signal) {
+    const reason = signal.reason;
+    let isTimeout = false;
+    try {
+      isTimeout = typeof reason === "object" && reason !== null && "name" in reason && reason.name === "TimeoutError" || classifyFetchError(reason).type === "timeout";
+    } catch {
+    }
+    return new FetchError("Response body read was aborted", {
+      type: isTimeout ? "timeout" : "aborted",
+      cause: reason
+    });
+  }
+  function readChunk(reader, signal) {
+    if (signal == null) return reader.read();
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (outcome) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        if ("error" in outcome) reject(toFetchError(outcome.error));
+        else resolve(outcome.value);
+      };
+      const onAbort = () => finish({ error: abortError(signal) });
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      try {
+        void reader.read().then((value) => signal.aborted ? onAbort() : finish({ value })).catch((error) => finish({ error }));
+      } catch (error) {
+        finish({ error });
+      }
+    });
+  }
+  function cancelReader(reader, reason) {
+    try {
+      void reader.cancel(reason).catch(() => {
+      });
+    } catch {
+    }
+  }
+  async function readStreamText(reader, maxResponseBytes, signal, response) {
+    const decoder = new TextDecoder();
+    const parts = [];
+    let bytes = 0;
+    let completed = false;
+    let failure2;
+    try {
+      while (true) {
+        const result = await readChunk(reader, signal);
+        if (signal?.aborted === true) throw abortError(signal);
+        if (result.done) {
+          parts.push(decoder.decode());
+          completed = true;
+          return parts.join("");
+        }
+        const chunk = result.value;
+        if (!ArrayBuffer.isView(chunk) || Object.prototype.toString.call(chunk) !== "[object Uint8Array]") {
+          throw new TypeError("Response body chunks must be Uint8Array values");
+        }
+        if (maxResponseBytes !== void 0) {
+          if (chunk.byteLength > maxResponseBytes - bytes) {
+            throw new FetchError("Response body exceeds maxResponseBytes", {
+              type: "response-too-large",
+              status: response.status,
+              statusText: response.statusText
+            });
+          }
+          bytes += chunk.byteLength;
+        }
+        const text = decoder.decode(chunk, { stream: true });
+        if (text !== "") parts.push(text);
+      }
+    } catch (error) {
+      failure2 = error;
+      throw error;
+    } finally {
+      if (!completed) cancelReader(reader, failure2);
+      reader.releaseLock();
+    }
+  }
+  async function readResponseText(response, options = {}) {
+    const { maxResponseBytes, signal } = options;
+    validateMaxResponseBytes(maxResponseBytes);
+    if (maxResponseBytes === void 0 && signal == null) return await response.text();
+    if (response.bodyUsed) throw new TypeError("Response body has already been consumed");
+    const body = response.body;
+    if (body === null) {
+      if (signal?.aborted === true) throw abortError(signal);
+      return "";
+    }
+    return await readStreamText(body.getReader(), maxResponseBytes, signal, response);
+  }
+  function contextualizeReadError(error, context, options) {
+    const failure2 = toFetchError(error, context);
+    if (options.maxResponseBytes === void 0 && options.signal == null) return failure2;
+    if ((failure2.url !== void 0 || context.url === void 0) && (failure2.method !== void 0 || context.method === void 0)) return failure2;
+    return new FetchError(failure2.message, {
+      body: failure2.body,
+      cause: failure2.cause,
+      code: failure2.code,
+      method: failure2.method ?? context.method,
+      response: failure2.response,
+      status: failure2.status,
+      statusText: failure2.statusText,
+      type: failure2.type,
+      url: failure2.url ?? context.url
+    });
+  }
+  async function parseJsonResponse(response, context = {}, options = {}) {
     let text;
     try {
-      text = await response.text();
+      text = await readResponseText(response, options);
     } catch (error) {
-      throw toFetchError(error, context);
+      throw contextualizeReadError(error, context, options);
     }
     if (text.trim() === "") return null;
     try {
@@ -1555,15 +1888,43 @@
       });
     }
   }
-  async function tryParseJson(response) {
+  async function tryParseJson(response, options = {}, context = {}) {
+    let text;
     try {
-      const text = await response.text();
-      if (text.trim() === "") return null;
-      return JSON.parse(text);
+      text = await readResponseText(response, options);
+    } catch (error) {
+      if (options.maxResponseBytes !== void 0 || options.signal != null) throw contextualizeReadError(error, context, options);
+      return null;
+    }
+    try {
+      return text.trim() === "" ? null : JSON.parse(text);
     } catch {
       return null;
     }
   }
+  function noop() {
+  }
+  function requestSignal(signal, timeout) {
+    if (timeout === void 0 || timeout === 0) return { signal, close: noop };
+    const timeoutSignal = AbortSignal.timeout(timeout);
+    if (signal == null) return { signal: timeoutSignal, close: noop };
+    const controller = new AbortController();
+    const close = () => {
+      signal.removeEventListener("abort", onCallerAbort);
+      timeoutSignal.removeEventListener("abort", onTimeout);
+    };
+    const abort = (source) => {
+      if (!controller.signal.aborted) controller.abort(source.reason);
+      close();
+    };
+    const onCallerAbort = () => abort(signal);
+    const onTimeout = () => abort(timeoutSignal);
+    signal.addEventListener("abort", onCallerAbort, { once: true });
+    timeoutSignal.addEventListener("abort", onTimeout, { once: true });
+    if (signal.aborted) onCallerAbort();
+    else if (timeoutSignal.aborted) onTimeout();
+    return { signal: controller.signal, close };
+  }
   var FetchClientError = class extends FetchError {
     /** Effective request configuration, including the resolved request URL. */
     config;
@@ -1671,6 +2032,7 @@
         baseURL: _baseURL,
         data: requestData,
         headers,
+        maxResponseBytes,
         method = "GET",
         params: _params,
         signal,
@@ -1679,37 +2041,44 @@
         validateStatus: validateStatusOption,
         ...requestInit
       } = merged;
-      const init = {
-        ...requestInit,
-        method,
-        headers: buildHeaders(headers, requestData !== void 0),
-        signal: timeout !== void 0 && timeout !== 0 ? AbortSignal.timeout(timeout) : signal
-      };
-      if (requestData !== void 0) {
-        init.body = JSON.stringify(requestData);
-      }
-      const response = await fetchCompress(url, init);
-      const data = response.ok ? await parseJsonResponse(response, { url, method }) : await tryParseJson(response);
-      const result = {
-        data,
-        headers: response.headers,
-        response,
-        status: response.status,
-        statusText: response.statusText
-      };
-      const validateStatus = validateStatusOption === void 0 ? (s) => s >= 200 && s < 300 : validateStatusOption;
-      if (validateStatus && !validateStatus(response.status)) {
-        throw new FetchClientError(
-          `Request failed with status ${response.status} ${response.statusText}`,
-          result,
-          {
-            ...merged,
-            method,
-            url
-          }
-        );
+      validateMaxResponseBytes(maxResponseBytes);
+      const scope = requestSignal(signal, timeout);
+      try {
+        const init = {
+          ...requestInit,
+          method,
+          headers: buildHeaders(headers, requestData !== void 0),
+          signal: scope.signal
+        };
+        if (requestData !== void 0) {
+          init.body = JSON.stringify(requestData);
+        }
+        const response = await fetchCompress(url, init);
+        const readOptions = { maxResponseBytes, signal: scope.signal };
+        const data = response.ok ? await parseJsonResponse(response, { url, method }, readOptions) : await tryParseJson(response, readOptions, { url, method });
+        const result = {
+          data,
+          headers: response.headers,
+          response,
+          status: response.status,
+          statusText: response.statusText
+        };
+        const validateStatus = validateStatusOption === void 0 ? (s) => s >= 200 && s < 300 : validateStatusOption;
+        if (validateStatus && !validateStatus(response.status)) {
+          throw new FetchClientError(
+            `Request failed with status ${response.status} ${response.statusText}`,
+            result,
+            {
+              ...merged,
+              method,
+              url
+            }
+          );
+        }
+        return result;
+      } finally {
+        scope.close();
       }
-      return result;
     }
   };
   var FetchJsonClient = class _FetchJsonClient extends FetchClient {
@@ -3093,7 +3462,7 @@
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
   };
-  function merge(target, source, options) {
+  function merge2(target, source, options) {
     if (!source || typeof source !== "object") return target;
     for (const key of Reflect.ownKeys(source)) {
       if (isUnsafeKey(key)) {
@@ -3108,7 +3477,7 @@
         if (targetValue === void 0 || targetValue === null || typeof targetValue !== "object" || !isPlainObject2(targetValue)) {
           target[key] = {};
         }
-        merge(target[key], value, options);
+        merge2(target[key], value, options);
       } else {
         target[key] = value;
       }
@@ -3119,7 +3488,7 @@
     return function deepMerge2(...objects) {
       const result = options.mutate === true ? objects[0] ?? {} : {};
       for (const obj of objects) {
-        merge(result, obj, options);
+        merge2(result, obj, options);
       }
       return result;
     };
@@ -3220,7 +3589,12 @@
   var toJsonObject = zodToFactory(JsonObjectZod, "toJsonObject");
   var subtle = globalThis.crypto?.subtle;
 
-  // ../../node_modules/.pnpm/@ariestools+threads@8.1.9_@opentelemetry+api@1.9.1_observable-fns@0.6.1_supports-color@7.2.0_zod@4.4.3/node_modules/@ariestools/threads/dist/browser/worker/worker.browser.mjs
+  // ../../node_modules/.pnpm/@ariestools+sdk@9.0.0_@opentelemetry+api@1.9.1_zod@4.6.5/node_modules/@ariestools/sdk/dist/neutral/enum.mjs
+  var Enum2 = (obj) => {
+    return obj;
+  };
+
+  // ../../node_modules/.pnpm/@ariestools+threads@9.0.0_@opentelemetry+api@1.9.1_observable-fns@0.6.1_supports-color@7.2.0_zod@4.6.5/node_modules/@ariestools/threads/dist/browser/worker/worker.browser.mjs
   var DefaultErrorSerializer = {
     deserialize: (message) => {
       const error = Object.create(Error.prototype);
@@ -3264,12 +3638,30 @@
   function isTransferDescriptor(thing) {
     return thing != null && typeof thing === "object" && Reflect.get(thing, $transferable) === true;
   }
+  var MasterMessageType = Enum2({
+    /** Cancel a previously submitted job. */
+    cancel: "cancel",
+    /** Run a job in the worker. */
+    run: "run"
+  });
+  var WorkerMessageType = Enum2({
+    /** A job failed. */
+    error: "error",
+    /** The worker exposed its callable API. */
+    init: "init",
+    /** A job produced a result. */
+    result: "result",
+    /** A job started running. */
+    running: "running",
+    /** An error escaped the worker job handler. */
+    uncaughtError: "uncaughtError"
+  });
   var isErrorEvent = (value) => value !== void 0 && value.error !== void 0;
   function createExpose(implementation, self2) {
     let exposeCalled = false;
     const activeSubscriptions = /* @__PURE__ */ new Map();
-    const isMasterJobCancelMessage = (thing) => thing?.type === "cancel";
-    const isMasterJobRunMessage = (thing) => thing?.type === "run";
+    const isMasterJobCancelMessage = (thing) => thing?.type === MasterMessageType.cancel;
+    const isMasterJobRunMessage = (thing) => thing?.type === MasterMessageType.run;
     const isObservable = (thing) => isSomeObservable(thing) || isZenObservable(thing);
     function isZenObservable(thing) {
       return thing != null && typeof thing === "object" && typeof thing.subscribe === "function";
@@ -3280,8 +3672,7 @@
     function postFunctionInitMessage() {
       const initMessage = {
         exposed: { type: "function" },
-        type: "init"
-        /* init */
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
@@ -3291,8 +3682,7 @@
           methods: methodNames,
           type: "module"
         },
-        type: "init"
-        /* init */
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
@@ -3300,7 +3690,7 @@
       const { payload: error, transferables } = deconstructTransfer(rawError);
       const errorMessage = {
         error: serialize(error),
-        type: "error",
+        type: WorkerMessageType.error,
         uid
       };
       implementation.postMessageToMaster(errorMessage, transferables);
@@ -3310,7 +3700,7 @@
       const resultMessage = {
         complete: completed ? true : void 0,
         payload,
-        type: "result",
+        type: WorkerMessageType.result,
         uid
       };
       implementation.postMessageToMaster(resultMessage, transferables);
@@ -3318,7 +3708,7 @@
     function postJobStartMessage(uid, resultType) {
       const startMessage = {
         resultType,
-        type: "running",
+        type: WorkerMessageType.running,
         uid
       };
       implementation.postMessageToMaster(startMessage);
@@ -3327,8 +3717,7 @@
       try {
         const errorMessage = {
           error: serialize(error),
-          type: "uncaughtError"
-          /* uncaughtError */
+          type: WorkerMessageType.uncaughtError
         };
         implementation.postMessageToMaster(errorMessage);
       } catch (subError) {