@openclaw/openshell-sandbox 2026.9.3 → 2026.9.5

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

@@ -1,4 +1,5 @@
 import * as core from "../core/index.js";
+import type { $ZodBigIntFormats } from "../core/index.js";
 import * as util from "../core/util.js";
 import * as parse from "./parse.js";
 
@@ -34,13 +35,13 @@ export interface ZodMiniType<
     data: unknown,
     params?: core.ParseContext<core.$ZodIssue>
   ): Promise<util.SafeParseResult<core.output<this>>>;
-  apply<T>(fn: (schema: this) => T): T;
+  apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
 }
 
 interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals>
   extends ZodMiniType<any, any, Internals> {}
 
-export const ZodMiniType: core.$constructor<ZodMiniType> = /*@__PURE__*/ core.$constructor(
+export const ZodMiniType: core.$constructor<ZodMiniType> = /*@__PURE__*/ core.$constructor<ZodMiniType>(
   "ZodMiniType",
   (inst, def) => {
     if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
@@ -49,36 +50,55 @@ export const ZodMiniType: core.$constructor<ZodMiniType> = /*@__PURE__*/ core.$c
 
     inst.def = def;
     inst.type = def.type;
-    inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => parse.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(): ZodMiniType["check"] {
+      return this.check;
+    },
+    set with(value: ZodMiniType["check"]) {
+      util.own(this, "with", value);
+    },
+    parse(data, params) {
+      return parse.parse(this, data, params, { callee: this.parse });
+    },
+    parseAsync(data, params) {
+      return parse.parseAsync(this, data, params, { callee: this.parseAsync });
+    },
+    safeParse(data, params) {
+      return parse.safeParse(this, data, params);
+    },
+    safeParseAsync(data, params) {
+      return parse.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
+              typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
             ),
           ],
         },
         { parent: true }
       );
-    };
-    inst.with = inst.check;
-    inst.clone = (_def, params) => core.clone(inst, _def, params);
-    inst.brand = () => inst as any;
-    inst.register = ((reg: any, meta: any) => {
-      reg.add(inst, meta);
-      return inst;
-    }) as any;
-    inst.apply = (fn) => fn(inst);
+    },
+    clone(_def, params) {
+      return core.clone(this, _def, params);
+    },
+    brand() {
+      return this as any;
+    },
+    register(reg: any, meta: any): any {
+      reg.add(this, meta);
+      return this;
+    },
+    apply(fn: any, ...args: any[]) {
+      return args.length === 0 ? fn(this) : fn(this, ...args);
+    },
   }
 );
 
@@ -474,6 +494,21 @@ export function e164(params?: string | core.$ZodE164Params): ZodMiniE164 {
   return core._e164(ZodMiniE164, params);
 }
 
+// ZodMiniCreditCard
+export interface ZodMiniCreditCard extends _ZodMiniString<core.$ZodCreditCardInternals> {}
+export const ZodMiniCreditCard: core.$constructor<ZodMiniCreditCard> = /*@__PURE__*/ core.$constructor(
+  "ZodMiniCreditCard",
+  (inst, def) => {
+    core.$ZodCreditCard.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+  }
+);
+
+// @__NO_SIDE_EFFECTS__
+export function creditCard(params?: string | core.$ZodCreditCardParams): ZodMiniCreditCard {
+  return core._creditCard(ZodMiniCreditCard, params);
+}
+
 // ZodMiniJWT
 export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
   // _zod: core.$ZodJWTInternals;
@@ -559,7 +594,9 @@ export function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<n
 }
 
 // ZodMiniNumberFormat
-export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {}
+export interface ZodMiniNumberFormat<Format extends core.$ZodNumberFormats = core.$ZodNumberFormats>
+  extends _ZodMiniNumber<core.$ZodNumberFormatInternals<Format>>,
+    core.$ZodNumberFormat<Format> {}
 export const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat> = /*@__PURE__*/ core.$constructor(
   "ZodMiniNumberFormat",
   (inst, def) => {
@@ -571,36 +608,41 @@ export const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat> = /*@__
 // int
 
 // @__NO_SIDE_EFFECTS__
-export function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {
-  return core._int(ZodMiniNumberFormat, params);
+export interface ZodMiniInt extends ZodMiniNumberFormat<"safeint"> {}
+export function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt {
+  return core._int(ZodMiniNumberFormat, params) as ZodMiniInt;
 }
 
 // float32
 
 // @__NO_SIDE_EFFECTS__
-export function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {
-  return core._float32(ZodMiniNumberFormat, params);
+export interface ZodMiniFloat32 extends ZodMiniNumberFormat<"float32"> {}
+export function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat32 {
+  return core._float32(ZodMiniNumberFormat, params) as ZodMiniFloat32;
 }
 
 // float64
 
 // @__NO_SIDE_EFFECTS__
-export function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {
-  return core._float64(ZodMiniNumberFormat, params);
+export interface ZodMiniFloat64 extends ZodMiniNumberFormat<"float64"> {}
+export function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat64 {
+  return core._float64(ZodMiniNumberFormat, params) as ZodMiniFloat64;
 }
 
 // int32
 
 // @__NO_SIDE_EFFECTS__
-export function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {
-  return core._int32(ZodMiniNumberFormat, params);
+export interface ZodMiniInt32 extends ZodMiniNumberFormat<"int32"> {}
+export function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt32 {
+  return core._int32(ZodMiniNumberFormat, params) as ZodMiniInt32;
 }
 
 // uint32
 
 // @__NO_SIDE_EFFECTS__
-export function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {
-  return core._uint32(ZodMiniNumberFormat, params);
+export interface ZodMiniUInt32 extends ZodMiniNumberFormat<"uint32"> {}
+export function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniUInt32 {
+  return core._uint32(ZodMiniNumberFormat, params) as ZodMiniUInt32;
 }
 
 // ZodMiniBoolean
@@ -640,8 +682,9 @@ export function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<b
 // bigint formats
 
 // ZodMiniBigIntFormat
-export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {
-  // _zod: core.$ZodBigIntFormatInternals;
+export interface ZodMiniBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats>
+  extends _ZodMiniType<core.$ZodBigIntFormatInternals<Format>> {
+  // _zod: core.$ZodBigIntFormatInternals<Format>;
 }
 export const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat> = /*@__PURE__*/ core.$constructor(
   "ZodMiniBigIntFormat",
@@ -654,15 +697,17 @@ export const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat> = /*@__
 // int64
 
 // @__NO_SIDE_EFFECTS__
-export function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat {
-  return core._int64(ZodMiniBigIntFormat, params);
+export interface ZodMiniInt64 extends ZodMiniBigIntFormat<"int64"> {}
+export function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniInt64 {
+  return core._int64(ZodMiniBigIntFormat, params) as ZodMiniInt64;
 }
 
 // uint64
 
 // @__NO_SIDE_EFFECTS__
-export function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat {
-  return core._uint64(ZodMiniBigIntFormat, params);
+export interface ZodMiniUInt64 extends ZodMiniBigIntFormat<"uint64"> {}
+export function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniUInt64 {
+  return core._uint64(ZodMiniBigIntFormat, params) as ZodMiniUInt64;
 }
 
 // ZodMiniSymbol
@@ -847,7 +892,7 @@ export const ZodMiniObject: core.$constructor<ZodMiniObject> = /*@__PURE__*/ cor
   (inst, def) => {
     core.$ZodObject.init(inst, def);
     ZodMiniType.init(inst, def);
-    util.defineLazy(inst, "shape", () => def.shape);
+    util.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
   }
 );
 // @__NO_SIDE_EFFECTS__
@@ -918,14 +963,15 @@ export function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShap
   return util.safeExtend(schema, shape as any);
 }
 
-/** @deprecated Identical to `z.extend(A, B)` */
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
+// @__NO_SIDE_EFFECTS__
 export function merge<T extends ZodMiniObject, U extends ZodMiniObject>(
   a: T,
   b: U
-): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, T["_zod"]["config"]>;
-// @__NO_SIDE_EFFECTS__
-export function merge(schema: ZodMiniObject, shape: any): ZodMiniObject {
-  return util.extend(schema, shape);
+): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, U["_zod"]["config"]> {
+  return util.merge(a, b) as any;
 }
 
 // @__NO_SIDE_EFFECTS__
@@ -966,8 +1012,43 @@ export function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["sh
   T["_zod"]["config"]
 >;
 // @__NO_SIDE_EFFECTS__
-export function partial(schema: ZodMiniObject, mask?: object) {
-  return util.partial(ZodMiniOptional, schema, mask);
+export function partial<T extends util.TupleItems, Rest extends SomeType | null>(
+  schema: ZodMiniTuple<T, Rest>
+): ZodMiniTuple<{ -readonly [k in keyof T]: ZodMiniOptional<T[k]> }, Rest>;
+// @__NO_SIDE_EFFECTS__
+export function partial(schema: ZodMiniObject | ZodMiniTuple, mask?: object) {
+  const def = schema._zod.def;
+  if (def.type !== "tuple") return util.partial(ZodMiniOptional, schema as ZodMiniObject, mask);
+  // a refinement was authored against the full arity; partialing would run it on a shorter array
+  if (def.checks?.length) throw new Error(".partial() cannot be used on tuple schemas containing refinements");
+  return util.clone(schema, {
+    ...def,
+    items: def.items.map((item) => new ZodMiniOptional({ type: "optional", innerType: item as core.$ZodType })),
+  });
+}
+
+// @__NO_SIDE_EFFECTS__
+export function exactPartial<T extends ZodMiniObject>(
+  schema: T
+): ZodMiniObject<
+  {
+    -readonly [k in keyof T["shape"]]: ZodMiniExactOptional<T["shape"][k]>;
+  },
+  T["_zod"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function exactPartial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(
+  schema: T,
+  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>
+): ZodMiniObject<
+  {
+    -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniExactOptional<T["shape"][k]> : T["shape"][k];
+  },
+  T["_zod"]["config"]
+>;
+// @__NO_SIDE_EFFECTS__
+export function exactPartial(schema: ZodMiniObject, mask?: object) {
+  return util.partial(ZodMiniExactOptional, schema, mask, "exactPartial");
 }
 
 export type RequiredInterfaceShape<
@@ -1083,7 +1164,7 @@ export const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUn
 
 // @__NO_SIDE_EFFECTS__
 export function discriminatedUnion<
-  Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]],
+  Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]],
   Disc extends string,
 >(
   discriminator: Disc,
@@ -1092,10 +1173,10 @@ export function discriminatedUnion<
 ): ZodMiniDiscriminatedUnion<Types, Disc> {
   return new ZodMiniDiscriminatedUnion({
     type: "union",
-    options,
+    options: options as any as core.$ZodType[],
     discriminator,
     ...util.normalizeParams(params),
-  }) as ZodMiniDiscriminatedUnion<Types, Disc>;
+  }) as any as ZodMiniDiscriminatedUnion<Types, Disc>;
 }
 
 // ZodMiniIntersection
@@ -1205,13 +1286,12 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends Some
   valueType: Value,
   params?: string | core.$ZodRecordParams
 ): ZodMiniRecord<Key & core.$partial, Value> {
-  const k = core.clone(keyType);
-  k._zod.values = undefined;
   return new ZodMiniRecord({
     type: "record",
-    keyType: k,
+    keyType,
     valueType: valueType as any,
     ...util.normalizeParams(params),
+    partial: true,
   }) as any;
 }
 
@@ -1576,7 +1656,7 @@ function _catch<T extends SomeType>(
   return new ZodMiniCatch({
     type: "catch",
     innerType: innerType as any as core.$ZodType,
-    catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue) as (
+    catchValue: (typeof catchValue === "function" ? catchValue : core.util.constantCatch(catchValue)) as (
       ctx: core.$ZodCatchCtx
     ) => core.output<T>,
   }) as any;
@@ -1781,8 +1861,7 @@ export function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$
   return ch;
 }
 
-// ZodCustom
-// custom schema
+// ZodCustom custom schema
 // @__NO_SIDE_EFFECTS__
 export function custom<O = unknown, I = O>(
   fn?: (data: O) => unknown,

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

@@ -22,3 +22,36 @@ test("The callback's return value becomes the apply's return value.", () => {
   expect(result).toBe(symbol);
   expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
 });
+
+test("apply forwards extra args to the callback", () => {
+  const calls: unknown[] = [];
+  const capture = (schema: z.ZodMiniString, ...args: unknown[]) => {
+    calls.push(schema, ...args);
+    return schema;
+  };
+
+  const schema = z.string();
+  const result = schema.apply(capture, "id", 42);
+
+  expect(calls[0]).toBe(schema);
+  expect(calls[1]).toBe("id");
+  expect(calls[2]).toBe(42);
+  expect(z.parse(result, "value")).toBe("value");
+  expectTypeOf<z.infer<typeof result>>().toEqualTypeOf<string>();
+});
+
+test("apply type-checks the extra args", () => {
+  const withMin = (schema: z.ZodMiniString, n: number) => schema.check(z.minLength(n));
+
+  expect(z.parse(z.string().apply(withMin, 3), "abcd")).toBe("abcd");
+  expectTypeOf(
+    z.number().apply<z.ZodMiniNumber>((schema) => schema.check(z.minimum(0)))
+  ).toEqualTypeOf<z.ZodMiniNumber>();
+
+  // @ts-expect-error wrong arg type
+  z.string().apply(withMin, "3");
+  // @ts-expect-error missing arg
+  z.string().apply(withMin);
+  // @ts-expect-error extra arg for a single-parameter callback
+  z.string().apply((schema: z.ZodMiniString) => schema, 3);
+});

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

@@ -1,4 +1,4 @@
-import { test } from "vitest";
+import { expectTypeOf, test } from "vitest";
 
 import * as z from "zod/mini";
 
@@ -116,6 +116,67 @@ test("assignability", () => {
   z.file() satisfies z.core.$ZodFile;
 });
 
+test("toZod", () => {
+  type Company = {
+    id: string;
+    name: string;
+    webAddress: string | null;
+  };
+
+  const CompanySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    webAddress: z.nullable(z.string()),
+  });
+  const Company = z.toZod<Company>()(CompanySchema);
+
+  expectTypeOf<z.output<typeof Company>>().toEqualTypeOf<Company>();
+
+  const CoreCompany = z.core.toZod<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof CoreCompany>>().toEqualTypeOf<Company>();
+
+  const UtilCompany = z.core.util.toZod<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof UtilCompany>>().toEqualTypeOf<Company>();
+
+  const Transformed = z.toZod<{ count: number }>()(
+    z.object({
+      count: z.pipe(
+        z.string(),
+        z.transform((value) => value.length)
+      ),
+    })
+  );
+  expectTypeOf<z.input<typeof Transformed>>().toEqualTypeOf<{ count: string }>();
+  expectTypeOf<z.output<typeof Transformed>>().toEqualTypeOf<{ count: number }>();
+
+  z.toZod<Company>()(
+    // @ts-expect-error missing optional keys still fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+  );
+
+  z.toZod<Company>()(
+    // @ts-expect-error extra keys fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      webAddress: z.nullable(z.string()),
+      extra: z.string(),
+    })
+  );
+
+  z.toZod<Company>()(
+    // @ts-expect-error wrong property output fails matching
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      webAddress: z.nullable(z.string()),
+    })
+  );
+});
+
 test("assignability with type narrowing", () => {
   type _RefinedSchema<T extends z.ZodMiniType<object> | z.ZodMiniUnion> = T extends z.ZodMiniUnion
     ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.

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

@@ -41,6 +41,14 @@ test("z.gte", () => {
   expect(z.safeParse(a, 9).success).toEqual(false);
 });
 
+test("z.gte/z.lte origin on a date schema with a numeric bound", () => {
+  const bound = new Date(Date.UTC(2022, 10, 5)).getTime();
+  const tooSmall = z.safeParse(z.date().check(z.gte(bound)), new Date(Date.UTC(2022, 10, 4)));
+  const tooBig = z.safeParse(z.date().check(z.lte(bound)), new Date(Date.UTC(2022, 10, 6)));
+  expect(tooSmall.error!.issues[0]).toMatchObject({ code: "too_small", origin: "date" });
+  expect(tooBig.error!.issues[0]).toMatchObject({ code: "too_big", origin: "date" });
+});
+
 // min;
 test("z.min", () => {
   const a = z.number().check(z.minimum(10));
@@ -132,6 +140,12 @@ test("z.overwrite", () => {
 // toUpperCase;
 // property
 
+test("z.properties", () => {
+  const a = z.instanceof(URL).check(...z.properties({ protocol: z.literal("https:" as string), 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"]]);
+});
+
 test("abort early", () => {
   const schema = z.string().check(
     z.refine((val) => val.length > 1),

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

@@ -103,7 +103,7 @@ test("safe codec operations", () => {
           "message": "Invalid ISO datetime",
           "origin": "string",
           "path": [],
-          "pattern": "/^(?:(?:\\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])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$/",
+          "pattern": "/^(?:(?:\\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])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$/",
         },
       ]
     `);
@@ -246,6 +246,7 @@ test("nested codec with object containing codec property", () => {
   `);
 
   // Test refinements at all levels
+
   // String validation (empty waypoint name)
   const emptyNameResult = z.safeDecode(waypointSchema, {
     name: "",
@@ -546,3 +547,36 @@ test("invertCodec", () => {
   const doubleInverted = z.invertCodec(z.invertCodec(isoDateCodec));
   expect(z.decode(doubleInverted, "2024-01-15T10:30:00.000Z")).toBeInstanceOf(Date);
 });
+
+test("z.output carries checks attached to a pipe", () => {
+  const c = z
+    .codec(z.string(), z.number(), { decode: Number, encode: String })
+    .check(z.refine((n) => n > 10, { error: "gt10" }));
+
+  expect(z.output(c).parse(50)).toBe(50);
+  expect(() => z.output(c).parse(5)).toThrow("gt10");
+  // The input side drops it: the check constrains a value that side never produces.
+  expect(z.input(c).parse("5")).toBe("5");
+});
+
+test("z.input resolves past a transform piped into a schema", () => {
+  const p = z.pipe(
+    z.transform((v: unknown) => String(v)),
+    z.string().check(z.minLength(5))
+  );
+
+  expect(z.input(p).parse("abcde")).toBe("abcde");
+  expect(() => z.input(p).parse(1)).toThrow();
+});
+
+test("a wrapper's stored value survives only on the side it belongs to", () => {
+  const c = z.codec(z.string(), z.number(), { decode: Number, encode: String });
+
+  expect(z.input(z._default(c, 7)).parse(undefined)).toBe(undefined);
+  expect(z.output(z._default(c, 7)).parse(undefined)).toBe(7);
+
+  // A wrapper over a pipe-free schema keeps both its value and its identity.
+  const plain = z._default(z.string(), "x");
+  expect(z.input(plain)).toBe(plain);
+  expect(z.input(plain).parse(undefined)).toBe("x");
+});

package/node_modules/zod/src/v4/mini/tests/cyclic-data.test.ts

@@ -0,0 +1,84 @@
+import { beforeEach, expect, test } from "vitest";
+import * as z from "zod/mini";
+
+// the config object lives on globalThis, so only file isolation protects it; pin the unset precondition explicitly
+beforeEach(() => {
+  delete z.config().memoizer;
+});
+
+const cyclic = (): any => {
+  const input: any = { id: 1 };
+  input.self = input;
+  return input;
+};
+
+test("cyclic input needs the memoizer opt-in", () => {
+  const Before: any = z.object({
+    id: z.number(),
+    get self() {
+      return Before;
+    },
+  });
+  expect(() => Before.parse(cyclic())).toThrow(RangeError);
+
+  z.config({ memoizer: z.memoizer() });
+  const After: any = z.object({
+    id: z.number(),
+    get self() {
+      return After;
+    },
+  });
+  const out = After.parse(cyclic());
+  expect(out.self).toBe(out);
+  expect(out).not.toBe(cyclic());
+  // read at construction, so a schema built before the opt-in keeps none
+  expect(() => Before.parse(cyclic())).toThrow(RangeError);
+});
+
+test("the opt-in reaches every core container", () => {
+  z.config({ memoizer: z.memoizer() });
+  const Arr: any = z.array(z.lazy(() => Arr));
+  const input: any = [];
+  input.push(input);
+  const out = Arr.parse(input);
+  expect(out[0]).toBe(out);
+});
+
+test("rejects a cycle that closes through a transform", () => {
+  z.config({ memoizer: z.memoizer() });
+  const Inner: any = z.object({
+    name: z.string(),
+    get self() {
+      return Wrapped;
+    },
+  });
+  const Wrapped: any = z.pipe(
+    Inner,
+    z.transform((value: any) => ({ wrapped: value }))
+  );
+
+  const input: any = { name: "x" };
+  input.self = input;
+
+  expect(() => Wrapped.parse(input)).toThrow(/reference cycle/);
+});
+
+test("leaves a transform that is not on the cycle alone", () => {
+  z.config({ memoizer: z.memoizer() });
+  const Node: any = z.object({
+    n: z.pipe(
+      z.number(),
+      z.transform((value: number) => value * 2)
+    ),
+    get self() {
+      return Node;
+    },
+  });
+
+  const input: any = { n: 21 };
+  input.self = input;
+
+  const result = Node.parse(input);
+  expect(result.n).toBe(42);
+  expect(result.self).toBe(result);
+});

package/node_modules/zod/src/v4/mini/tests/deep-partial.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/mini";
+
+describe("mini deepPartial", () => {
+  test("makes a ZodMiniObject's fields optional recursively", () => {
+    const schema = z.object({
+      name: z.string(),
+      profile: z.object({ bio: z.string(), age: z.number() }),
+    });
+    const partial = z.deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.ZodMiniObject>();
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ profile: {} })).toEqual({ profile: {} });
+    expect(partial.parse({ name: "x", profile: { bio: "b" } })).toEqual({
+      name: "x",
+      profile: { bio: "b" },
+    });
+  });
+
+  test("preserves ZodMiniObject structural type (shape accessible)", () => {
+    const schema = z.object({ a: z.string(), nested: z.object({ b: z.number() }) });
+    const partial = z.deepPartial(schema);
+    expectTypeOf(partial.shape.a).toExtend<z.ZodMiniOptional<z.ZodMiniString>>();
+    expectTypeOf(partial.shape.nested).toExtend<z.ZodMiniOptional<z.ZodMiniObject>>();
+  });
+
+  test("tuple elements stay required", () => {
+    const schema = z.tuple([z.object({ a: z.string() }), z.string()]);
+    const partial = z.deepPartial(schema);
+    expect(() => partial.parse([{}])).toThrow();
+    expect(partial.parse([{}, "x"])).toEqual([{}, "x"]);
+  });
+
+  test("ZodMiniCodec preserved through deepPartial", () => {
+    const schema = z.codec(z.object({ a: z.string() }), z.object({ a: z.string() }), {
+      decode: (v) => v,
+      encode: (v) => v,
+    });
+    const partial = z.deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.ZodMiniCodec>();
+  });
+
+  test("recursive getter-based object is typeable", () => {
+    const Category = z.object({
+      name: z.string(),
+      get subcategories() {
+        return z.optional(z.array(Category));
+      },
+    });
+    const partial = z.deepPartial(Category);
+    expectTypeOf(partial).toExtend<z.ZodMiniObject>();
+    expect(partial.parse({ subcategories: [{}] })).toEqual({ subcategories: [{}] });
+  });
+});