cross-seed 7.0.0-21 → 7.0.0-23

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

@@ -93,3 +93,17 @@ test("z.uint64", () => {
   // expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
   // expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
 });
+
+test("number and bigint formats are distinct at the type level", () => {
+  expectTypeOf(z.int()._zod.def.format).toEqualTypeOf<"safeint">();
+  expectTypeOf(z.uint32()._zod.def.format).toEqualTypeOf<"uint32">();
+  expectTypeOf(z.int64()._zod.def.format).toEqualTypeOf<"int64">();
+
+  z.int32() satisfies z.ZodMiniInt32;
+  z.uint64() satisfies z.ZodMiniUInt64;
+
+  // @ts-expect-error a float64 schema is not a ZodMiniFloat32
+  z.float64() satisfies z.ZodMiniFloat32;
+  // @ts-expect-error a uint64 schema is not a ZodMiniInt64
+  z.uint64() satisfies z.ZodMiniInt64;
+});

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

@@ -17,7 +17,7 @@ test("z.object", () => {
   expectTypeOf<a>().toEqualTypeOf<{
     name: string;
     age: number;
-    points?: number;
+    points?: number | undefined;
     "test?": boolean;
   }>();
   expect(z.parse(a, { name: "john", age: 30, "test?": true })).toEqual({
@@ -109,18 +109,39 @@ test("z.extend", () => {
   expectTypeOf<ExtendedUser>().toEqualTypeOf<{
     name: string;
     age: number;
-    email?: string;
+    email?: string | undefined;
     isAdmin: boolean;
   }>();
   expect(extendedSchema).toBeDefined();
   expect(z.safeParse(extendedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
 });
 
+test("z.merge", () => {
+  const mergedSchema = z.merge(userSchema, z.object({ isAdmin: z.boolean() }));
+  type MergedUser = z.infer<typeof mergedSchema>;
+  expectTypeOf<MergedUser>().toEqualTypeOf<{
+    name: string;
+    age: number;
+    email?: string | undefined;
+    isAdmin: boolean;
+  }>();
+  expect(z.safeParse(mergedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
+
+  // the second schema's catchall wins, matching classic
+  const strict = z.merge(userSchema, z.strictObject({ isAdmin: z.boolean() }));
+  expect(z.safeParse(strict, { name: "John", age: 30, isAdmin: true, extra: 1 }).success).toBe(false);
+
+  expect(() =>
+    // @ts-expect-error second argument is a schema, not a shape
+    z.merge(userSchema, { isAdmin: z.boolean() })
+  ).toThrow("Invalid input to merge");
+});
+
 test("z.safeExtend", () => {
   const extended = z.safeExtend(userSchema, { name: z.string() });
   expect(z.safeParse(extended, { name: "John", age: 30 }).success).toBe(true);
   type Extended = z.infer<typeof extended>;
-  expectTypeOf<Extended>().toEqualTypeOf<{ name: string; age: number; email?: string }>();
+  expectTypeOf<Extended>().toEqualTypeOf<{ name: string; age: number; email?: string | undefined }>();
   // @ts-expect-error
   z.safeExtend(userSchema, { name: z.number() });
 });
@@ -128,7 +149,7 @@ test("z.safeExtend", () => {
 test("z.pick", () => {
   const pickedSchema = z.pick(userSchema, { name: true, email: true });
   type PickedUser = z.infer<typeof pickedSchema>;
-  expectTypeOf<PickedUser>().toEqualTypeOf<{ name: string; email?: string }>();
+  expectTypeOf<PickedUser>().toEqualTypeOf<{ name: string; email?: string | undefined }>();
   expect(pickedSchema).toBeDefined();
   expect(z.safeParse(pickedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
 });
@@ -149,9 +170,9 @@ test("z.partial", () => {
   const partialSchema = z.partial(userSchema);
   type PartialUser = z.infer<typeof partialSchema>;
   expectTypeOf<PartialUser>().toEqualTypeOf<{
-    name?: string;
-    age?: number;
-    email?: string;
+    name?: string | undefined;
+    age?: number | undefined;
+    email?: string | undefined;
   }>();
   expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
 });
@@ -160,14 +181,58 @@ test("z.partial with mask", () => {
   const partialSchemaWithMask = z.partial(userSchema, { name: true });
   type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
   expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
-    name?: string;
+    name?: string | undefined;
     age: number;
-    email?: string;
+    email?: string | undefined;
   }>();
   expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
   expect(z.safeParse(partialSchemaWithMask, { name: "John" }).success).toBe(false);
 });
 
+test("z.exactPartial", () => {
+  const partialSchema = z.exactPartial(userSchema);
+  type PartialUser = z.infer<typeof partialSchema>;
+  expectTypeOf<PartialUser>().toEqualTypeOf<{
+    name?: string;
+    age?: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
+  expect(z.safeParse(partialSchema, {}).success).toBe(true);
+  expect(z.safeParse(partialSchema, { name: undefined }).success).toBe(false);
+  expect(z.safeParse(partialSchema, { email: undefined }).success).toBe(true);
+});
+
+test("z.exactPartial with mask", () => {
+  const partialSchemaWithMask = z.exactPartial(userSchema, { name: true });
+  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
+  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
+    name?: string;
+    age: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
+  expect(z.safeParse(partialSchemaWithMask, { age: 30, name: undefined }).success).toBe(false);
+});
+
+test("z.required", () => {
+  const requiredSchema = z.required(userSchema);
+  type RequiredUser = z.infer<typeof requiredSchema>;
+  expectTypeOf<RequiredUser>().toEqualTypeOf<{ name: string; age: number; email: string }>();
+  expect(requiredSchema.shape.email).toBeInstanceOf(z.ZodMiniNonOptional);
+  expect(z.safeParse(requiredSchema, { name: "John", age: 30 }).success).toBe(false);
+  expect(z.safeParse(requiredSchema, { name: "John", age: 30, email: "john@example.com" }).success).toBe(true);
+});
+
+test("z.required with mask", () => {
+  const schema = z.object({ name: z.optional(z.string()), age: z.optional(z.number()) });
+  const requiredSchemaWithMask = z.required(schema, { name: true });
+  type RequiredWithMask = z.infer<typeof requiredSchemaWithMask>;
+  expectTypeOf<RequiredWithMask>().toEqualTypeOf<{ name: string; age?: number | undefined }>();
+  expect(requiredSchemaWithMask.shape.name).toBeInstanceOf(z.ZodMiniNonOptional);
+  expect(requiredSchemaWithMask.shape.age).toBeInstanceOf(z.ZodMiniOptional);
+});
+
 test("z.pick/omit/partial/required - do not allow unknown keys", () => {
   const schema = z.object({
     name: z.string(),

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",
@@ -33,7 +49,7 @@ test("recursion with z.lazy", () => {
   type Category = z.infer<typeof Category>;
   interface _Category {
     name: string;
-    subcategories?: _Category[];
+    subcategories?: _Category[] | undefined;
   }
   expectTypeOf<Category>().toEqualTypeOf<_Category>();
 });
@@ -273,3 +289,53 @@ test("recursion compatibility", () => {
     },
   });
 });
+
+test("shape stays writeable through object/strictObject/looseObject/extend with getters", () => {
+  const Cat = z.object({
+    name: z.string(),
+    get sub(): z.ZodMiniArray<typeof Cat> {
+      return z.array(Cat);
+    },
+  });
+  type CatShape = (typeof Cat)["shape"];
+  expectTypeOf<CatShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof Cat>;
+  }>();
+
+  const StrictCat = z.strictObject({
+    name: z.string(),
+    get sub(): z.ZodMiniArray<typeof StrictCat> {
+      return z.array(StrictCat);
+    },
+  });
+  type StrictShape = (typeof StrictCat)["shape"];
+  expectTypeOf<StrictShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof StrictCat>;
+  }>();
+
+  const LooseCat = z.looseObject({
+    name: z.string(),
+    get sub(): z.ZodMiniArray<typeof LooseCat> {
+      return z.array(LooseCat);
+    },
+  });
+  type LooseShape = (typeof LooseCat)["shape"];
+  expectTypeOf<LooseShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof LooseCat>;
+  }>();
+
+  const Base = z.object({ name: z.string() });
+  const Extended = z.extend(Base, {
+    get sub(): z.ZodMiniArray<typeof Extended> {
+      return z.array(Extended);
+    },
+  });
+  type ExtendedShape = (typeof Extended)["shape"];
+  expectTypeOf<ExtendedShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof Extended>;
+  }>();
+});

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

@@ -177,6 +177,13 @@ test("z.nanoid", () => {
   expect(() => z.parse(a, "abc")).toThrow();
 });
 
+test("z.nanoid custom length", () => {
+  const a = z.nanoid({ length: 64 });
+  const id = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  expect(z.parse(a, id)).toEqual(id);
+  expect(() => z.parse(a, "8FHZpIxleEK3axQRBNNjN")).toThrow();
+});
+
 test("z.cuid", () => {
   const a = z.cuid();
   expect(z.parse(a, "cixs7y0c0000f7x3b1z6m3w6r")).toEqual("cixs7y0c0000f7x3b1z6m3w6r");
@@ -282,6 +289,11 @@ test("z.base64", () => {
   expect(() => z.parse(a, "SGVsbG8gd29ybGQ")).toThrow();
   expect(() => z.parse(a, "U29tZSBvdGhlciBzdHJpbmc")).toThrow();
   expect(() => z.parse(a, "hello")).toThrow();
+  // whitespace is not allowed (atob would otherwise strip it)
+  expect(() => z.parse(a, "123 ")).toThrow();
+  expect(() => z.parse(a, "SGVsbG8gd29ybGQ= ")).toThrow();
+  expect(() => z.parse(a, "SGVsbG8gd29ybGQ=\n")).toThrow();
+  expect(() => z.parse(a, "SGVs bG8gd29ybGQ=")).toThrow();
   // wrong type
   expect(() => z.parse(a, 123)).toThrow();
 });
@@ -312,6 +324,36 @@ test("z.e164", () => {
   expect(() => z.parse(a, 123)).toThrow();
 });
 
+test("z.creditCard", () => {
+  const a = z.creditCard();
+  // valid credit card
+  expect(z.parse(a, "4111111111111111")).toEqual("4111111111111111");
+  expect(z.parse(a, "4111 1111 1111 1111")).toEqual("4111 1111 1111 1111");
+  // failed Luhn checksum
+  expect(() => z.parse(a, "4111111111111112")).toThrow();
+  // outside the 12-19 digit range
+  expect(() => z.parse(a, "40000000006")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  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
@@ -345,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

@@ -75,21 +75,31 @@ class ZodError extends Error {
                     while (i < issue.path.length) {
                         const el = issue.path[i];
                         const terminal = i === issue.path.length - 1;
-                        if (!terminal) {
-                            curr[el] = curr[el] || { _errors: [] };
-                            // if (typeof el === "string") {
-                            //   curr[el] = curr[el] || { _errors: [] };
-                            // } else if (typeof el === "number") {
-                            //   const errorArray: any = [];
-                            //   errorArray._errors = [];
-                            //   curr[el] = curr[el] || errorArray;
-                            // }
+                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
+                        if (el === "_errors") {
+                            if (terminal)
+                                curr._errors.push(mapper(issue));
+                            i++;
+                            continue;
                         }
-                        else {
-                            curr[el] = curr[el] || { _errors: [] };
-                            curr[el]._errors.push(mapper(issue));
+                        // Create `el` as an own data property. A segment naming an inherited member ("toString", "constructor") would otherwise read through to the prototype, and assigning "__proto__" would hit the setter and walk into Object.prototype.
+                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+                            if (el === "__proto__") {
+                                Object.defineProperty(curr, el, {
+                                    value: { _errors: [] },
+                                    writable: true,
+                                    enumerable: true,
+                                    configurable: true,
+                                });
+                            }
+                            else {
+                                curr[el] = { _errors: [] };
+                            }
                         }
                         curr = curr[el];
+                        if (terminal) {
+                            curr._errors.push(mapper(issue));
+                        }
                         i++;
                     }
                 }
@@ -136,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/ZodError.d.cts

@@ -10,13 +10,13 @@ export type typeToFlattenedError<T, U = string> = {
     };
 };
 export declare const ZodIssueCode: {
-    custom: "custom";
     invalid_type: "invalid_type";
     too_big: "too_big";
     too_small: "too_small";
     not_multiple_of: "not_multiple_of";
     unrecognized_keys: "unrecognized_keys";
     invalid_union: "invalid_union";
+    custom: "custom";
     invalid_literal: "invalid_literal";
     invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";

package/node_modules/zod/v3/ZodError.d.ts

@@ -10,13 +10,13 @@ export type typeToFlattenedError<T, U = string> = {
     };
 };
 export declare const ZodIssueCode: {
-    custom: "custom";
     invalid_type: "invalid_type";
     too_big: "too_big";
     too_small: "too_small";
     not_multiple_of: "not_multiple_of";
     unrecognized_keys: "unrecognized_keys";
     invalid_union: "invalid_union";
+    custom: "custom";
     invalid_literal: "invalid_literal";
     invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";

package/node_modules/zod/v3/ZodError.js

@@ -71,21 +71,31 @@ export class ZodError extends Error {
                     while (i < issue.path.length) {
                         const el = issue.path[i];
                         const terminal = i === issue.path.length - 1;
-                        if (!terminal) {
-                            curr[el] = curr[el] || { _errors: [] };
-                            // if (typeof el === "string") {
-                            //   curr[el] = curr[el] || { _errors: [] };
-                            // } else if (typeof el === "number") {
-                            //   const errorArray: any = [];
-                            //   errorArray._errors = [];
-                            //   curr[el] = curr[el] || errorArray;
-                            // }
+                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
+                        if (el === "_errors") {
+                            if (terminal)
+                                curr._errors.push(mapper(issue));
+                            i++;
+                            continue;
                         }
-                        else {
-                            curr[el] = curr[el] || { _errors: [] };
-                            curr[el]._errors.push(mapper(issue));
+                        // Create `el` as an own data property. A segment naming an inherited member ("toString", "constructor") would otherwise read through to the prototype, and assigning "__proto__" would hit the setter and walk into Object.prototype.
+                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+                            if (el === "__proto__") {
+                                Object.defineProperty(curr, el, {
+                                    value: { _errors: [] },
+                                    writable: true,
+                                    enumerable: true,
+                                    configurable: true,
+                                });
+                            }
+                            else {
+                                curr[el] = { _errors: [] };
+                            }
                         }
                         curr = curr[el];
+                        if (terminal) {
+                            curr._errors.push(mapper(issue));
+                        }
                         i++;
                     }
                 }

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);
+})();