@openclaw/matrix 2026.9.5 → 2026.9.7

package/node_modules/zod/src/v4/mini/schemas.ts

@@ -1,5 +1,6 @@
 import * as core from "../core/index.js";
 import type { $ZodBigIntFormats } from "../core/index.js";
+import * as regexes from "../core/regexes.js";
 import * as util from "../core/util.js";
 import * as parse from "./parse.js";
 
@@ -224,8 +225,8 @@ export function url(params?: string | core.$ZodURLParams): ZodMiniURL {
 // @__NO_SIDE_EFFECTS__
 export function httpUrl(params?: string | Omit<core.$ZodURLParams, "protocol" | "hostname">): ZodMiniURL {
   return core._url(ZodMiniURL, {
-    protocol: core.regexes.httpProtocol,
-    hostname: core.regexes.domain,
+    protocol: regexes.httpProtocol,
+    hostname: regexes.domain,
     ...util.normalizeParams(params),
   });
 }
@@ -509,6 +510,21 @@ export function creditCard(params?: string | core.$ZodCreditCardParams): ZodMini
   return core._creditCard(ZodMiniCreditCard, params);
 }
 
+// ZodMiniIBAN
+export interface ZodMiniIBAN extends _ZodMiniString<core.$ZodIBANInternals> {}
+export const ZodMiniIBAN: core.$constructor<ZodMiniIBAN> = /*@__PURE__*/ core.$constructor(
+  "ZodMiniIBAN",
+  (inst, def) => {
+    core.$ZodIBAN.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function iban(params?: string | core.$ZodIBANParams): ZodMiniIBAN {
+  return core._iban(ZodMiniIBAN, params);
+}
+
 // ZodMiniJWT
 export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
   // _zod: core.$ZodJWTInternals;
@@ -548,12 +564,19 @@ export function stringFormat<Format extends string>(
 
 // @__NO_SIDE_EFFECTS__
 export function hostname(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hostname"> {
-  return core._stringFormat(ZodMiniCustomStringFormat, "hostname", core.regexes.hostname, _params) as any;
+  return core._stringFormat(ZodMiniCustomStringFormat, "hostname", regexes.hostname, _params) as any;
 }
 
 // @__NO_SIDE_EFFECTS__
 export function hex(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hex"> {
-  return core._stringFormat(ZodMiniCustomStringFormat, "hex", core.regexes.hex, _params) as any;
+  return core._stringFormat(ZodMiniCustomStringFormat, "hex", regexes.hex, _params) as any;
+}
+
+// @__NO_SIDE_EFFECTS__
+export function currencyCode(
+  _params?: string | core.$ZodStringFormatParams
+): ZodMiniCustomStringFormat<"currency_code"> {
+  return core._stringFormat(ZodMiniCustomStringFormat, "currency_code", regexes.currencyCode, _params) as any;
 }
 
 // @__NO_SIDE_EFFECTS__
@@ -1094,7 +1117,8 @@ export function catchall<T extends ZodMiniObject, U extends SomeType>(
   inst: T,
   catchall: U
 ): ZodMiniObject<T["shape"], core.$catchall<U>> {
-  return inst.clone({ ...inst._zod.def, catchall: catchall as any }) as any;
+  // `mergeDefs` rather than a spread: spreading reads `shape`, and resolving it can mint a whole fresh subtree
+  return inst.clone(util.mergeDefs(inst._zod.def, { catchall: catchall as any })) as any;
 }
 
 // ZodMiniUnion
@@ -1362,7 +1386,8 @@ export const ZodMiniEnum: core.$constructor<ZodMiniEnum> = /*@__PURE__*/ core.$c
     core.$ZodEnum.init(inst, def);
     ZodMiniType.init(inst, def);
 
-    inst.options = Object.values(def.entries);
+    // reuse the parsed value set so a numeric TS enum's reverse-mapping keys stay out
+    inst.options = [...inst._zod.values] as util.EnumValue[];
   }
 );
 
@@ -1580,7 +1605,7 @@ export const ZodMiniPrefault: core.$constructor<ZodMiniPrefault> = /*@__PURE__*/
 // @__NO_SIDE_EFFECTS__
 export function prefault<T extends SomeType>(
   innerType: T,
-  defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)
+  defaultValue: core.input<T> | (() => core.input<T>)
 ): ZodMiniPrefault<T> {
   return new ZodMiniPrefault({
     type: "prefault",

package/node_modules/zod/src/v4/mini/tests/checks.test.ts

@@ -141,7 +141,7 @@ test("z.overwrite", () => {
 // property
 
 test("z.properties", () => {
-  const a = z.instanceof(URL).check(...z.properties({ protocol: z.literal("https:" as string), hostname: z.string() }));
+  const a = z.instanceof(URL).check(...z.properties({ protocol: z.literal("https:"), hostname: z.string() }));
   expect(z.safeParse(a, new URL("https://example.com")).success).toEqual(true);
   expect(z.safeParse(a, new URL("http://example.com")).error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
 });

package/node_modules/zod/src/v4/mini/tests/computed.test.ts

@@ -2,35 +2,29 @@ import { expect, test } from "vitest";
 import * as z from "zod/mini";
 import { util as zc } from "zod/v4/core";
 
+// checks no longer write metadata into the bag at attach time; the converter folds the checks itself, so the derived values are asserted through it
+
 test("min/max", () => {
   const a = z.number().check(z.minimum(5), z.minimum(6), z.minimum(7), z.maximum(10), z.maximum(11), z.maximum(12));
-
-  expect(a._zod.bag.minimum).toEqual(7);
-  expect(a._zod.bag.maximum).toEqual(10);
+  expect(z.toJSONSchema(a)).toMatchObject({ minimum: 7, maximum: 10 });
+  expect(a._zod.bag).toEqual({});
 });
 
 test("multipleOf", () => {
   const b = z.number().check(z.multipleOf(5));
-  expect(b._zod.bag.multipleOf).toEqual(5);
-});
-
-test("int64 format", () => {
-  const c = z.int64();
-  expect(c._zod.bag.format).toEqual("int64");
-  expect(c._zod.bag.minimum).toEqual(zc.BIGINT_FORMAT_RANGES.int64[0]);
-  expect(c._zod.bag.maximum).toEqual(zc.BIGINT_FORMAT_RANGES.int64[1]);
+  expect(z.toJSONSchema(b)).toMatchObject({ multipleOf: 5 });
 });
 
 test("int32 format", () => {
   const d = z.int32();
-  expect(d._zod.bag.format).toEqual("int32");
-  expect(d._zod.bag.minimum).toEqual(zc.NUMBER_FORMAT_RANGES.int32[0]);
-  expect(d._zod.bag.maximum).toEqual(zc.NUMBER_FORMAT_RANGES.int32[1]);
+  expect(z.toJSONSchema(d)).toMatchObject({
+    type: "integer",
+    minimum: zc.NUMBER_FORMAT_RANGES.int32[0],
+    maximum: zc.NUMBER_FORMAT_RANGES.int32[1],
+  });
 });
 
 test("array size", () => {
   const e = z.array(z.string()).check(z.length(5));
-  expect(e._zod.bag.length).toEqual(5);
-  expect(e._zod.bag.minimum).toEqual(5);
-  expect(e._zod.bag.maximum).toEqual(5);
+  expect(z.toJSONSchema(e)).toMatchObject({ minItems: 5, maxItems: 5 });
 });

package/node_modules/zod/src/v4/mini/tests/index.test.ts

@@ -2,6 +2,62 @@ import { expect, expectTypeOf, test } from "vitest";
 import * as z from "zod/mini";
 import type { util } from "zod/v4/core";
 
+test("factory checks", () => {
+  const string = z.string({ checks: [z.minLength(1), z.maxLength(3)] as const });
+  const number = z.number({ checks: [z.minimum(1), z.maximum(3)] as const });
+  expectTypeOf<z.output<typeof string>>().toEqualTypeOf<string>();
+  expectTypeOf<z.output<typeof number>>().toEqualTypeOf<number>();
+  for (const [schema, valid, invalid] of [
+    [string, "ab", ""],
+    [number, 2, 4],
+  ] as const) {
+    expect(z.validate(schema, valid)).toBe(true);
+    expect(z.validate(schema, invalid)).toBe(false);
+    expect(schema._zod.parent).toBeUndefined();
+    expect(z.validate(z.compile(schema), valid)).toBe(true);
+    expect(z.validate(z.compile(schema), invalid)).toBe(false);
+  }
+  // @ts-expect-error numeric checks cannot validate strings
+  z.string({ checks: [z.minimum(1)] });
+  // @ts-expect-error length checks cannot validate numbers
+  z.number({ checks: [z.minLength(1)] });
+});
+
+test("factory checks snapshot caller arrays", () => {
+  for (const factory of [z.string, z.coerce.string]) {
+    const checks = [z.minLength(1)];
+    const schema = factory({ checks });
+    let reads = 0;
+    factory({
+      get checks() {
+        if (++reads > 1) throw new Error("checks read twice");
+        return checks;
+      },
+    });
+    expect(reads).toBe(1);
+    checks.push(z.minLength(10));
+    expect(z.validate(schema, "long")).toBe(true);
+    expect(z.validate(z.compile(schema), "long")).toBe(true);
+    expect(z.toJSONSchema(schema).minLength).toBe(1);
+  }
+  for (const factory of [z.number, z.coerce.number]) {
+    const checks = [z.minimum(1)];
+    const schema = factory({ checks });
+    let reads = 0;
+    factory({
+      get checks() {
+        if (++reads > 1) throw new Error("checks read twice");
+        return checks;
+      },
+    });
+    expect(reads).toBe(1);
+    checks.push(z.minimum(10));
+    expect(z.validate(schema, 3)).toBe(true);
+    expect(z.validate(z.compile(schema), 3)).toBe(true);
+    expect(z.toJSONSchema(schema).minimum).toBe(1);
+  }
+});
+
 test("z.boolean", () => {
   const a = z.boolean();
   expect(z.parse(a, true)).toEqual(true);
@@ -165,6 +221,28 @@ test("z.iso.duration", () => {
   expect(z.safeParse(b, d2).success).toEqual(false);
 });
 
+test("z.prefault preserves undefined output", async () => {
+  const field = z.prefault(z.union([z.string(), z.undefined()]), () => undefined);
+  const schema = z.object({ a: field });
+  expectTypeOf<z.output<typeof field>>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: string | undefined }>();
+  expect(z.parse(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: undefined })).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: "value" })).toStrictEqual({ a: "value" });
+  expect(z.safeParse(schema, { a: 123 }).success).toBe(false);
+  expect(await z.parseAsync(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(z.object({ a: z.prefault(z.optional(z.string()), undefined) }), {})).toStrictEqual({ a: undefined });
+  const transformed = z.prefault(
+    z.pipe(
+      z.string(),
+      z.transform(() => undefined)
+    ),
+    "fallback"
+  );
+  expectTypeOf<z.output<typeof transformed>>().toEqualTypeOf<undefined>();
+  expect(z.parse(z.object({ a: transformed }), {})).toStrictEqual({ a: undefined });
+});
+
 test("z.undefined", () => {
   const a = z.undefined();
   expect(z.parse(a, undefined)).toEqual(undefined);
@@ -491,6 +569,14 @@ test("z.enum - native", () => {
   // expect(a.enum.A).toEqual(NativeEnum.A);
   // expect(a.enum.B).toEqual(NativeEnum.B);
   // expect(a.enum.C).toEqual(NativeEnum.C);
+
+  enum NumericEnum {
+    A = 0,
+    B = 1,
+  }
+
+  // numeric enums carry reverse-mapping keys; options lists only what parse accepts
+  expect(z.enum(NumericEnum).options).toEqual([NumericEnum.A, NumericEnum.B]);
 });
 
 test("z.nativeEnum", () => {

package/node_modules/zod/src/v4/mini/tests/recursive-types.test.ts

@@ -1,6 +1,22 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/mini";
 
+test("recursive object schema type aliases", () => {
+  type ObjectField = z.ZodMiniObject<{ [k: string]: ObjectField }>;
+  type Field = z.ZodMiniString<string> | z.ZodMiniObject<{ [k: string]: Field }>;
+  type ObjectValue = { [k: string]: ObjectValue };
+  type Value = string | { [k: string]: Value };
+  expectTypeOf<z.input<ObjectField>>().toEqualTypeOf<ObjectValue>();
+  expectTypeOf<z.output<ObjectField>>().toEqualTypeOf<ObjectValue>();
+  expectTypeOf<keyof z.input<ObjectField>>().toEqualTypeOf<string>();
+  expectTypeOf<keyof z.output<ObjectField>>().toEqualTypeOf<string>();
+  expectTypeOf<z.input<Field>>().toEqualTypeOf<Value>();
+  expectTypeOf<z.output<Field>>().toEqualTypeOf<Value>();
+  const schema: Field = z.object({ nested: z.object({ name: z.string() }) });
+  expect(schema.parse({ nested: { name: "a", extra: true } })).toEqual({ nested: { name: "a" } });
+  expect(schema.safeParse({ nested: { name: 123 } }).success).toBe(false);
+});
+
 test("recursion with z.lazy", () => {
   const data = {
     name: "I",

package/node_modules/zod/src/v4/mini/tests/string.test.ts

@@ -338,6 +338,22 @@ test("z.creditCard", () => {
   expect(() => z.parse(a, 123)).toThrow();
 });
 
+test("z.iban", () => {
+  const a = z.iban();
+  // valid iban
+  expect(z.parse(a, "DE89370400440532013000")).toEqual("DE89370400440532013000");
+  expect(z.parse(a, "NO9386011117947")).toEqual("NO9386011117947");
+  // failed mod 97 checksum
+  expect(() => z.parse(a, "DE89370400440532013001")).toThrow();
+  // formatting violations
+  expect(() => z.parse(a, "de89370400440532013000")).toThrow();
+  expect(() => z.parse(a, "DE89 3704 0044 0532 0130 00")).toThrow();
+  expect(() => z.parse(a, "NO938601111794")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
 test("z.jwt", () => {
   const a = z.jwt();
   // valid jwt
@@ -371,3 +387,10 @@ test("z.hash generic format", () => {
     z.ZodMiniCustomStringFormat<"sha384_base64url">
   >();
 });
+
+test("z.currencyCode", () => {
+  const a = z.currencyCode();
+  expectTypeOf(a).toEqualTypeOf<z.ZodMiniCustomStringFormat<"currency_code">>();
+  expect(z.parse(a, "EUR")).toBe("EUR");
+  expect(z.safeParse(a, "eur")).toMatchObject(FAIL);
+});

package/node_modules/zod/v3/ZodError.cjs

@@ -146,3 +146,22 @@ ZodError.create = (issues) => {
     const error = new ZodError(issues);
     return error;
 };
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/errors.cjs

@@ -15,3 +15,22 @@ function setErrorMap(map) {
 function getErrorMap() {
     return overrideErrorMap;
 }
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/external.cjs

@@ -20,3 +20,22 @@ __exportStar(require("./helpers/typeAliases.cjs"), exports);
 __exportStar(require("./helpers/util.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);
 __exportStar(require("./ZodError.cjs"), exports);
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/helpers/enumUtil.cjs

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/helpers/errorUtil.cjs

@@ -4,6 +4,25 @@ exports.errorUtil = void 0;
 var errorUtil;
 (function (errorUtil) {
     errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-    // biome-ignore lint:
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: renaming churns 31 v3 call sites
     errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (exports.errorUtil = errorUtil = {}));
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/helpers/errorUtil.js

@@ -1,6 +1,6 @@
 export var errorUtil;
 (function (errorUtil) {
     errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-    // biome-ignore lint:
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: renaming churns 31 v3 call sites
     errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));

package/node_modules/zod/v3/helpers/parseUtil.cjs

@@ -122,3 +122,22 @@ const isValid = (x) => x.status === "valid";
 exports.isValid = isValid;
 const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 exports.isAsync = isAsync;
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/helpers/partialUtil.cjs

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/helpers/typeAliases.cjs

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/helpers/util.cjs

@@ -135,3 +135,22 @@ const getParsedType = (data) => {
     }
 };
 exports.getParsedType = getParsedType;
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/index.cjs

@@ -31,3 +31,22 @@ const z = __importStar(require("./external.cjs"));
 exports.z = z;
 __exportStar(require("./external.cjs"), exports);
 exports.default = z;
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/standard-schema.cjs

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v3/types.cjs

@@ -3777,3 +3777,22 @@ exports.coerce = {
     date: ((arg) => ZodDate.create({ ...arg, coerce: true })),
 };
 exports.NEVER = parseUtil_js_1.INVALID;
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v4/classic/checks.cjs

@@ -32,3 +32,22 @@ Object.defineProperty(exports, "trim", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "toLowerCase", { enumerable: true, get: function () { return index_js_1._toLowerCase; } });
 Object.defineProperty(exports, "toUpperCase", { enumerable: true, get: function () { return index_js_1._toUpperCase; } });
 Object.defineProperty(exports, "slugify", { enumerable: true, get: function () { return index_js_1._slugify; } });
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/node_modules/zod/v4/classic/coerce.cjs

@@ -45,3 +45,22 @@ function bigint(params) {
 function date(params) {
     return core._coercedDate(schemas.ZodDate, params);
 }
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();