@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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:"), 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/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/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: [{}] });
+  });
+});

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

@@ -11,12 +11,31 @@ test("no locale by default", () => {
 test("error inheritance", () => {
   const e1 = z.string().safeParse(123).error!;
   expect(e1).toBeInstanceOf(z.core.$ZodError);
-  // expect(e1).not.toBeInstanceOf(Error);
+  expect(e1).toBeInstanceOf(Error);
 
+  let e2: unknown;
   try {
     z.string().parse(123);
-  } catch (e2) {
-    expect(e2).toBeInstanceOf(z.core.$ZodRealError);
-    expect(e2).toBeInstanceOf(Error);
+  } catch (err) {
+    e2 = err;
   }
+  expect(e2).toBeInstanceOf(z.core.$ZodRealError);
+  expect(e2).toBeInstanceOf(Error);
+});
+
+test("a thrown error carries a stack rooted at the parse call site", () => {
+  function callSite() {
+    z.parse(z.string(), 123);
+  }
+
+  let thrown: unknown;
+  try {
+    callSite();
+  } catch (err) {
+    thrown = err;
+  }
+  expect(thrown).toBeInstanceOf(Error);
+  const stack = (thrown as Error).stack!;
+  expect(stack.startsWith("$ZodError: [")).toBe(true);
+  expect(stack).toContain("callSite");
 });

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

@@ -1,5 +1,14 @@
 import { expect, test } from "vitest";
+import * as z from "zod/mini";
 
 test("z.function", () => {
   expect(true).toEqual(true);
 });
+
+test("implement exposes the function schema at runtime", () => {
+  const schema = z.function({ input: [z.string()], output: z.number() });
+  const fn = schema.implement((s) => s.length);
+
+  expect((fn as any)._zod).toBe(schema._zod);
+  expect(fn("asdf")).toBe(4);
+});

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);
@@ -247,9 +325,42 @@ test("z.union([]) / z.xor([]) / z.discriminatedUnion(_, []) construct and reject
   }
 });
 
-test("z.discriminatedUnion rejects object options missing the discriminator at type level", () => {
-  // @ts-expect-error missing discriminator property
-  z.discriminatedUnion("type", [z.object({ value: z.string() })]);
+test("z.discriminatedUnion rejects object options missing the discriminator", () => {
+  expect(() => z.discriminatedUnion("type", [z.object({ value: z.string() })])).toThrow(
+    /Invalid discriminated union option at index "0"/
+  );
+
+  // An option whose shape cannot be listed without resolving it is left to the lookup map, on the first object parsed.
+  const viaPipe = z.discriminatedUnion("type", [
+    z.pipe(z.object({ value: z.literal("x") }), z.object({ value: z.literal("x") })),
+  ]);
+  expect(() => z.safeParse(viaPipe, { value: "x" })).toThrow(/Invalid discriminated union option at index "0"/);
+});
+
+test("z.discriminatedUnion infers mutually-recursive getter options", () => {
+  const variantA = z.object({
+    kind: z.literal("a"),
+    get child() {
+      return z.optional(tree);
+    },
+  });
+
+  const variantB = z.object({
+    kind: z.literal("b"),
+    get sibling() {
+      return z.optional(tree);
+    },
+  });
+
+  const tree = z.discriminatedUnion("kind", [variantA, variantB]);
+
+  type _Tree = { kind: "a"; child?: _Tree | undefined } | { kind: "b"; sibling?: _Tree | undefined };
+
+  expectTypeOf<z.input<typeof tree>>().toEqualTypeOf<_Tree>();
+  expectTypeOf<z.input<typeof tree>>().not.toBeAny();
+
+  expect(z.parse(tree, { kind: "a", child: { kind: "b" } })).toEqual({ kind: "a", child: { kind: "b" } });
+  expect(() => z.parse(tree, { kind: "c" })).toThrow();
 });
 
 test("z.intersection", () => {
@@ -344,6 +455,15 @@ test("z.record", () => {
     [Enum.B]: "world",
   });
 
+  const partial = z.partialRecord(z.enum(["__proto__", "b"]), z.string());
+  type partial = z.output<typeof partial>;
+  expectTypeOf<partial>().toEqualTypeOf<Partial<Record<"__proto__" | "b", string>>>();
+  const parsed: any = z.parse(partial, Object.fromEntries([["__proto__", "declared"]]));
+  expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
+  expect(Object.prototype.hasOwnProperty.call(parsed, "__proto__")).toBe(false);
+  expect(parsed).toEqual({});
+  expect(z.parse(partial, {})).toEqual({});
+
   // v3-compat single-arg form: z.record(valueType) defaults keyType to z.string()
   const f = (z.record as any)(z.number());
   expect(f._zod.def.keyType._zod.def.type).toEqual("string");
@@ -449,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", () => {
@@ -679,8 +807,7 @@ test("z.custom", () => {
 });
 
 test("z.check", () => {
-  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic
-  // the function should return core.$ZodResult
+  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic the function should return core.$ZodResult
   const a = z.any().check(
     z.check<string>((ctx) => {
       if (typeof ctx.value === "string") return;
@@ -871,12 +998,15 @@ test("z.stringbool", () => {
   expect(z.parse(b, "n")).toEqual(false);
   expect(z.safeParse(b, "true")).toMatchObject({ success: false });
   expect(z.safeParse(b, "false")).toMatchObject({ success: false });
+  expect(b._zod.bag.truthy).toEqual(["y"]);
+  expect(b._zod.bag.falsy).toEqual(["n"]);
 
   const c = z.stringbool({
     case: "sensitive",
   });
   expect(z.parse(c, "true")).toEqual(true);
   expect(z.safeParse(c, "TRUE")).toMatchObject({ success: false });
+  expect(c._zod.bag.case).toEqual("sensitive");
 });
 
 // promise
@@ -991,3 +1121,26 @@ test("type narrowing works with type property", () => {
     expect(arraySchema.def.element).toBeDefined();
   }
 });
+
+test("getDiscriminatedOption", () => {
+  const a = z.object({ type: z.literal("a"), x: z.string() });
+  const b = z.object({ type: z.literal("b"), y: z.number() });
+  const schema = z.discriminatedUnion("type", [a, b]);
+
+  expect(z.getDiscriminatedOption(schema, "a")).toBe(a);
+  expect(z.getDiscriminatedOption(schema, "b")).toBe(b);
+  expectTypeOf(z.getDiscriminatedOption(schema, "a")).toEqualTypeOf<typeof a>();
+});
+
+test("z.partial on a tuple", () => {
+  const schema = z.partial(z.tuple([z.string(), z.number()]));
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<[(string | undefined)?, (number | undefined)?]>();
+
+  expect(z.safeParse(schema, []).success).toEqual(true);
+  expect(z.safeParse(schema, ["a"]).success).toEqual(true);
+  expect(z.safeParse(schema, ["a", 1]).success).toEqual(true);
+  expect(z.safeParse(schema, ["a", "b"]).success).toEqual(false);
+
+  const refined = z.tuple([z.string(), z.number()]).check(z.refine(([a]) => a.length > 0));
+  expect(() => z.partial(refined)).toThrow("cannot be used on tuple schemas containing refinements");
+});

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