zod 4.5.3 → 4.6.0

package/src/v4/classic/tests/properties.test.ts

@@ -0,0 +1,225 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("z.properties is a schema", () => {
+  const p = z.properties({ a: z.literal("x"), b: z.literal("y") });
+
+  expectTypeOf<z.infer<typeof p>>().toEqualTypeOf<{ a: "x"; b: "y" }>();
+
+  // asserts in place: the parse returns the input identity, extra keys pass
+  const ok = { a: "x", b: "y", extra: 1 };
+  expect(p.parse(ok)).toBe(ok);
+
+  // every failing key reports
+  expect(p.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
+
+  // as a schema it is the type gate and infers an object shape, so a primitive is a type error
+  for (const input of [null, undefined, 5, "abc"]) {
+    expect(p.safeParse(input).error!.issues.map((i) => [i.code, i.path])).toEqual([["invalid_type", []]]);
+  }
+
+  // as a check the base already typed the value, so the properties are asserted on whatever it produced — a string's length, as z.property() does
+  const long = z.string().check(...z.properties({ length: z.number().min(3) }));
+  expect(long.parse("abc")).toBe("abc");
+  expect(long.safeParse("ab").error!.issues.map((i) => i.path)).toEqual([["length"]]);
+  expect(
+    z
+      .compile(long)
+      .safeParse("ab")
+      .error!.issues.map((i) => i.path)
+  ).toEqual([["length"]]);
+
+  // an optional key may be absent
+  const opt = z.properties({ a: z.string().optional() });
+  expect(opt.safeParse({}).success).toBe(true);
+  expectTypeOf<z.infer<typeof opt>>().toEqualTypeOf<{ a?: string | undefined }>();
+});
+
+test("z.properties discards transformed output", () => {
+  // asserts and never writes back, exactly as z.property() behaves; a nested object schema rebuilds its output even without transforms, so identity cannot distinguish the two
+  const p = z.properties({ a: z.string().transform((s) => s.toUpperCase()) });
+  const input = { a: "hi" };
+  expect(p.parse(input)).toBe(input);
+  expect(input.a).toBe("hi");
+});
+
+test("z.properties narrows through intersection", () => {
+  const httpsUrl = z.instanceof(URL).and(z.properties({ protocol: z.literal("https:") }));
+  expectTypeOf<z.infer<typeof httpsUrl>>().toEqualTypeOf<URL & { protocol: "https:" }>();
+
+  const u = new URL("https://example.com");
+  expect(httpsUrl.parse(u)).toBe(u);
+  expect(httpsUrl.safeParse(new URL("http://example.com")).success).toBe(false);
+});
+
+test("z.instanceof().properties()", () => {
+  const httpsUrl = z.instanceof(URL).properties({ protocol: z.literal("https:") });
+  expectTypeOf<z.infer<typeof httpsUrl>>().toEqualTypeOf<URL & { protocol: "https:" }>();
+
+  const u = new URL("https://example.com");
+  expect(httpsUrl.parse(u)).toBe(u);
+  expect(httpsUrl.safeParse(new URL("http://example.com")).error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
+
+  // chains, and each call narrows further
+  const chained = httpsUrl.properties({ port: z.literal("") });
+  expectTypeOf<z.infer<typeof chained>>().toEqualTypeOf<URL & { protocol: "https:" } & { port: "" }>();
+  expect(chained.safeParse(u).success).toBe(true);
+  expect(chained.safeParse(new URL("https://example.com:8443")).error!.issues.map((i) => i.path)).toEqual([["port"]]);
+});
+
+test("z.properties spreads into .check()", () => {
+  // the pre-4.6 array call sites: the schema yields itself from Symbol.iterator
+  const p = z.properties({ a: z.literal("x") });
+  const spread = [...p];
+  expect(spread).toEqual([p]);
+
+  const s = z.object({ a: z.string() }).check(...z.properties({ a: z.literal("x") }));
+  expect(s.safeParse({ a: "x" }).success).toBe(true);
+  expect(s.safeParse({ a: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"]]);
+});
+
+test("z.properties JSON Schema", () => {
+  const p = z.properties({ a: z.string(), b: z.number().optional() });
+  expect(z.toJSONSchema(p)).toEqual({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: { a: { type: "string" }, b: { type: "number" } },
+    required: ["a"],
+  });
+});
+
+test("z.properties compiles", () => {
+  const p = z.properties({ a: z.literal("x"), b: z.literal("y") });
+  const compiled = z.compile(p);
+  const ok = { a: "x", b: "y", extra: 1 };
+  expect(compiled.parse(ok)).toBe(ok);
+  expect(compiled.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
+  expect(compiled.safeParse(null).error!.issues.map((i) => [i.code, i.path])).toEqual([["invalid_type", []]]);
+
+  // nested in a container
+  const outer = z.compile(z.object({ url: z.instanceof(URL).properties({ protocol: z.literal("https:") }) }));
+  expect(outer.safeParse({ url: new URL("http://example.com") }).error!.issues.map((i) => i.path)).toEqual([
+    ["url", "protocol"],
+  ]);
+});
+
+test("z.properties async", async () => {
+  const p = z.properties({ a: z.string().refine(async (s) => s.length > 1) });
+  const ok = { a: "hi" };
+  await expect(p.parseAsync(ok)).resolves.toBe(ok);
+  const bad = await p.safeParseAsync({ a: "!" });
+  expect(bad.error!.issues.map((i) => i.path)).toEqual([["a"]]);
+});
+
+test("z.properties infers the input side", () => {
+  // nothing is written back, so an output-typed inference would lie for every shape entry whose output differs from its input
+  const withDefault = z.properties({ a: z.string().default("x") });
+  expectTypeOf<z.infer<typeof withDefault>>().toEqualTypeOf<{ a?: string | undefined }>();
+  expect(withDefault.parse({})).toEqual({});
+
+  const withTransform = z.properties({ a: z.string().transform((s) => s.length) });
+  expectTypeOf<z.infer<typeof withTransform>>().toEqualTypeOf<{ a: string }>();
+  expect(withTransform.parse({ a: "hi" })).toEqual({ a: "hi" });
+
+  // a plain schema has the same input and output, so the documented narrowing is unchanged
+  const W = z.instanceof(URL).properties({ protocol: z.literal("https:") });
+  expectTypeOf<z.infer<typeof W>>().toEqualTypeOf<URL & { protocol: "https:" }>();
+});
+
+test("z.properties validates symbol keys", () => {
+  const sym = Symbol("tag");
+  const p = z.properties({ [sym]: z.string() });
+  expect(p.safeParse({ [sym]: "ok" }).success).toBe(true);
+  expect(p.safeParse({ [sym]: 123 }).error!.issues.map((i) => i.path)).toEqual([[sym]]);
+  expect(
+    z
+      .compile(p)
+      .safeParse({ [sym]: 123 })
+      .error!.issues.map((i) => i.path)
+  ).toEqual([[sym]]);
+});
+
+test("z.properties compiled and interpreted agree on a nullish value", () => {
+  // a base that permits null reaches the check role with one; the compiled property read must not throw where the runtime reports an issue
+  const s = z.any().check(...z.properties({ a: z.string() }));
+  const expected = [["invalid_type", []]];
+  expect(s.safeParse(null).error!.issues.map((i) => [i.code, i.path])).toEqual(expected);
+  expect(
+    z
+      .compile(s)
+      .safeParse(null)
+      .error!.issues.map((i) => [i.code, i.path])
+  ).toEqual(expected);
+});
+
+test("z.properties with a custom when refuses to compile", () => {
+  // `when` is not publicly settable, since it gates a check inside the run loop and means nothing to a parsed schema. A hand-built def can still carry one, and compiling it must refuse rather than run the shape unconditionally: a union branch compiles to its own IIFE, so a wrong rejection is absorbed as a branch failure with no fallback.
+  const p = new z.core.$ZodProperties({
+    type: "properties",
+    check: "properties",
+    shape: { a: z.literal("x") },
+    when: () => false,
+  });
+  const s = z.union([p as unknown as z.ZodType, z.object({ b: z.string() })]);
+  const input = { a: "wrong", b: "hello" };
+  expect(z.compile(s).safeParse(input)).toEqual(s.safeParse(input));
+});
+
+test("z.properties parses cyclic input", () => {
+  // the input is its own output, so it registers as its own memo entry; without that a cycle re-enters forever
+  const Node: z.ZodType<{ id: string; next?: unknown }> = z.lazy(() =>
+    z.properties({ id: z.string(), next: Node.optional() })
+  );
+  const cyclic: Record<string, unknown> = { id: "a" };
+  cyclic.next = cyclic;
+  expect(Node.parse(cyclic)).toBe(cyclic);
+  expect(z.compile(Node).parse(cyclic)).toBe(cyclic);
+
+  // the cycle guard must not swallow a real failure further down
+  expect(Node.safeParse({ id: "a", next: { id: 1 } }).error!.issues.map((i) => i.path)).toEqual([["next", "id"]]);
+});
+
+test("z.properties asserts forward while encoding", () => {
+  // both sides declare the shape's input type, so encoding must still check the value against it; running the children backward would encode them and reject that type
+  const codec = z.codec(z.string(), z.number(), { decode: (s) => Number(s), encode: (n) => String(n) });
+  const p = z.properties({ a: codec, b: z.string().transform((s) => s.length) });
+  const value = { a: "1", b: "hi" };
+  expect(z.decode(p, value)).toBe(value);
+  expect(z.encode(p, value)).toBe(value);
+  expect(z.safeEncode(p, { a: 1, b: "hi" } as never).error!.issues.map((i) => i.path)).toEqual([["a"]]);
+});
+
+test("z.properties parses a cyclic callable", () => {
+  // property reads work on a function too, so the cycle guard has to recognize one as a reference
+  const Fn: z.ZodType<{ self?: unknown }> = z.lazy(() => z.properties({ self: Fn.optional() }));
+  const fn = (() => {}) as unknown as Record<string, unknown>;
+  fn.self = fn;
+  expect(Fn.parse(fn)).toBe(fn);
+});
+
+test("z.properties survives shape mutation", () => {
+  // key and schema are snapshotted together; caching one and reading the other live paired a stale key with a missing schema
+  const shape: Record<string, z.ZodType> = { a: z.string() };
+  const p = z.properties(shape);
+  expect(p.safeParse({ a: "x" }).success).toBe(true);
+  delete shape.a;
+  expect(p.safeParse({ a: "x" }).success).toBe(true);
+  shape.b = z.string();
+  expect(p.safeParse({ a: "x" }).success).toBe(true);
+});
+
+test("z.properties JSON Schema describes the input side", () => {
+  // the parsed value is the input, so a defaulted key that stays absent must not be required of the output either
+  const p = z.properties({ a: z.string().default("x") });
+  expect(p.parse({})).toEqual({});
+  expect(z.toJSONSchema(p, { io: "output" })).toEqual({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: { a: { default: "x", type: "string" } },
+  });
+
+  // an output mode emission for a transforming child would describe a value this schema never returns
+  const t = z.properties({ a: z.string().transform((s) => s.length) });
+  expect(() => z.toJSONSchema(t, { io: "output" })).toThrow(/cannot be represented/);
+  expect(z.toJSONSchema(t, { io: "input" })).toMatchObject({ properties: { a: { type: "string" } }, required: ["a"] });
+});

package/src/v4/classic/tests/recursive-types.test.ts

@@ -556,7 +556,7 @@ test("recursive object with .check()", () => {
   expect(() => Category.parse(invalidData)).toThrow();
 });
 
-// biome-ignore lint: sadf
+// biome-ignore lint/suspicious/noExportsInTest: unexported it trips noUnusedVariables instead
 export type RecursiveA = z.ZodUnion<
   [
     z.ZodObject<{

package/src/v4/classic/tests/standard-schema.test.ts

@@ -132,3 +132,22 @@ test("z.toJSONSchema() returns StandardJSONSchemaV1", async () => {
 		}
 	`);
 });
+
+test("a failing validate reports the same issues as safeParse, without a ZodError", async () => {
+  const schema = z.object({ name: z.string().min(3), age: z.number().refine(async (n) => n > 0) });
+  const input = { name: "ab", age: -1 };
+  const result = (await schema["~standard"].validate(input)) as { issues: unknown[] };
+  expect(result.issues).toEqual((await schema.safeParseAsync(input)).error!.issues);
+  expect(result).not.toHaveProperty("error");
+  const sync = z.string().min(3)["~standard"].validate("ab") as { issues: unknown[] };
+  expect(sync.issues).toEqual(z.string().min(3).safeParse("ab").error!.issues);
+});
+
+test("a synchronously throwing check rejects through ~standard instead of throwing", async () => {
+  const schema = z.string().refine(() => {
+    throw new Error("boom");
+  });
+  const result = schema["~standard"].validate("abc");
+  expect(result).toBeInstanceOf(Promise);
+  await expect(result as Promise<unknown>).rejects.toThrow("boom");
+});

package/src/v4/classic/tests/string.test.ts

@@ -264,6 +264,7 @@ test("base64url validations", () => {
 
   const invalidBase64URLStrings = [
     "w7/Dv8O+w74K", // Has + and / characters (is base64)
+    "A", // Invalid length (1 mod 4 carries no whole byte)
     "12345", // Invalid length (not a multiple of 4 characters when adding allowed number of padding characters)
     "12345===", // Not padded correctly
     "!UGF0aWVuY2UgaXMgdGhlIGtleSB0byBzdWNjZXNz", // Invalid character '!'
@@ -291,6 +292,18 @@ test("big base64 and base64url", () => {
   z.base64().parse(bigbase64);
   const bigbase64url = randomBytes(1024 * 1024 * 10).toString("base64url");
   z.base64url().parse(bigbase64url);
+
+  // template literals compose def.pattern and test it on every parse; the quantified block forms overflowed the regex stack here
+  expect(z.templateLiteral(["id-", z.base64()]).safeParse(`id-${bigbase64}`).success).toBe(true);
+  expect(z.templateLiteral(["id-", z.base64url()]).safeParse(`id-${bigbase64url}`).success).toBe(true);
+});
+
+test("template literal composes base64 without alternation leaks", () => {
+  // the ^$| alternation in regexes.base64 used to leak: "AAAA" matched with the prefix dropped and "id-AAAA" was rejected
+  const tl = z.templateLiteral(["id-", z.base64()]);
+  expect(tl.safeParse("id-AAAA").success).toBe(true);
+  expect(tl.safeParse("id-").success).toBe(true);
+  expect(tl.safeParse("AAAA").success).toBe(false);
 });
 
 function makeJwt(header: object, payload: object) {
@@ -552,6 +565,18 @@ test("emoji validations", () => {
   expect(() => emoji.parse("😀 is an emoji")).toThrow();
   expect(() => emoji.parse("😀stuff")).toThrow();
   expect(() => emoji.parse("stuff😀")).toThrow();
+
+  emoji.parse("1\u{FE0F}\u{20E3}"); // keycap sequences stay valid
+  emoji.parse("#\u{FE0F}\u{20E3}");
+
+  // `\p{Emoji_Component}` alone covers ASCII digits, "#", "*", ZWJ, variation selectors and skin tone modifiers; none is an emoji without a base, so a component-only string is not one either
+  expect(() => emoji.parse("123")).toThrow();
+  expect(() => emoji.parse("#")).toThrow();
+  expect(() => emoji.parse("*")).toThrow();
+  expect(() => emoji.parse("\u{200D}")).toThrow();
+  expect(() => emoji.parse("\u{FE0F}")).toThrow();
+  expect(() => emoji.parse("\u{1F3FD}")).toThrow();
+  expect(() => emoji.parse("1\u{FE0F}")).toThrow();
 });
 
 test("nanoid", () => {

package/src/v4/classic/tests/template-literal.test.ts

@@ -565,7 +565,7 @@ test("regexes", () => {
     `"^(?:(?:\\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))$"`
   );
   expect(email._zod.pattern.source).toMatchInlineSnapshot(
-    `"^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"`
+    `"^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"`
   );
   // expect(ip._zod.pattern.source).toMatchInlineSnapshot(
   //   `"^(^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$)|(^(([a-fA-F0-9]{1,4}:){7}|::([a-fA-F0-9]{1,4}:){0,6}|([a-fA-F0-9]{1,4}:){1}:([a-fA-F0-9]{1,4}:){0,5}|([a-fA-F0-9]{1,4}:){2}:([a-fA-F0-9]{1,4}:){0,4}|([a-fA-F0-9]{1,4}:){3}:([a-fA-F0-9]{1,4}:){0,3}|([a-fA-F0-9]{1,4}:){4}:([a-fA-F0-9]{1,4}:){0,2}|([a-fA-F0-9]{1,4}:){5}:([a-fA-F0-9]{1,4}:){0,1})([a-fA-F0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$)$"`
@@ -778,3 +778,35 @@ test("template literal parsing - failure - issue format", () => {
     }
   `);
 });
+
+test("part patterns fold checks through wrappers and unions", () => {
+  // a constrained string keeps its bounds under a wrapper and inside a union
+  const wrapped = z.templateLiteral(["a-", z.string().min(2).max(3).optional()]);
+  expect(wrapped.safeParse("a-").success).toBe(true);
+  expect(wrapped.safeParse("a-xy").success).toBe(true);
+  expect(wrapped.safeParse("a-x").success).toBe(false);
+  expect(wrapped.safeParse("a-wxyz").success).toBe(false);
+
+  const union = z.templateLiteral(["", z.union([z.string().regex(/^[a-c]+$/), z.number().int()])]);
+  expect(union.safeParse("abc").success).toBe(true);
+  expect(union.safeParse("12").success).toBe(true);
+  expect(union.safeParse("xyz").success).toBe(false);
+  expect(union.safeParse("1.5").success).toBe(false);
+
+  // an empty length range matches nothing rather than building an invalid quantifier
+  const empty = z.templateLiteral(["", z.string().min(8).length(5)]);
+  expect(empty.safeParse("abcde").success).toBe(false);
+
+  // lazy resolves its inner schema on the internals, not the def
+  const lazy = z.templateLiteral(["", z.lazy(() => z.string().min(2)).optional()]);
+  expect(lazy.safeParse("x").success).toBe(false);
+  expect(lazy.safeParse("xy").success).toBe(true);
+});
+
+test("an embedded email does not constrain the other parts", () => {
+  const schema = z.templateLiteral([z.email(), "|", z.string()]);
+  expect(schema.safeParse("a@b.cc|a..b").success).toBe(true);
+  expect(schema.safeParse("a@b.cc|xy").success).toBe(true);
+  expect(schema.safeParse("a..b@b.cc|xy").success).toBe(false);
+  expect(schema.safeParse(".a@b.cc|xy").success).toBe(false);
+});

package/src/v4/classic/tests/to-json-schema.test.ts

@@ -79,7 +79,7 @@ describe("toJSONSchema", () => {
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "format": "email",
-        "pattern": "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$",
+        "pattern": "^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$",
         "type": "string",
       }
     `);
@@ -218,6 +218,15 @@ describe("toJSONSchema", () => {
         "type": "string",
       }
     `);
+    expect(z.toJSONSchema(z.base64url())).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "contentEncoding": "base64url",
+        "format": "base64url",
+        "pattern": "^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$",
+        "type": "string",
+      }
+    `);
     expect(z.toJSONSchema(z.cuid())).toMatchInlineSnapshot(`
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -231,7 +240,7 @@ describe("toJSONSchema", () => {
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "format": "emoji",
-        "pattern": "^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$",
+        "pattern": "^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$",
         "type": "string",
       }
     `);
@@ -356,7 +365,7 @@ describe("toJSONSchema", () => {
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "format": "email",
-        "pattern": "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$",
+        "pattern": "^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$",
         "type": "string",
       }
     `);
@@ -482,6 +491,30 @@ describe("toJSONSchema", () => {
     `);
   });
 
+  test("base64url pattern agrees with parse", () => {
+    const schema = z.base64url();
+    const pattern = new RegExp(z.toJSONSchema(schema).pattern!);
+    // lengths 1 (mod 4) carry no whole byte; the emitted pattern must reject them like parse does
+    for (const s of ["", "A", "AA", "AAA", "AAAA", "AAAAA"]) {
+      expect(pattern.test(s)).toBe(schema.safeParse(s).success);
+    }
+  });
+
+  test("base64 pattern agrees with parse", () => {
+    const schema = z.base64();
+    const pattern = new RegExp(z.toJSONSchema(schema).pattern!);
+    // the runtime def.pattern is lax; the emitted pattern must still carry the block structure parse enforces
+    for (const s of ["", "A", "AA", "AAA", "AAAA", "AAAAA", "AA==", "AAA=", "A===", "=", "AAAA=="]) {
+      expect(pattern.test(s)).toBe(schema.safeParse(s).success);
+    }
+  });
+
+  test("looseRecord with a format key emits the exact pattern", () => {
+    // recordProcessor reads bag.patterns directly; it must apply the same lax-to-exact swap as stringProcessor
+    const json = z.toJSONSchema(z.looseRecord(z.base64url(), z.number()));
+    expect(Object.keys(json.patternProperties!)).toEqual([z.regexes.base64url.source]);
+  });
+
   test("string patterns", () => {
     expect(
       z.toJSONSchema(
@@ -724,6 +757,117 @@ describe("toJSONSchema", () => {
     `);
   });
 
+  test("number constraints order independence with int()", () => {
+    // .int() applied last should not overwrite the tighter bounds .min()/.max() already stored
+    expect(z.toJSONSchema(z.number().int().min(0).max(23))).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "maximum": 23,
+        "minimum": 0,
+        "type": "integer",
+      }
+    `);
+    expect(z.toJSONSchema(z.number().min(0).max(23).int())).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "maximum": 23,
+        "minimum": 0,
+        "type": "integer",
+      }
+    `);
+  });
+
+  test("chained multipleOf divisors emit the whole conjunction", () => {
+    // runtime rejects 4 (not a multiple of 3), so the emitted schema must too
+    expect(z.toJSONSchema(z.number().multipleOf(2).multipleOf(3))).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "allOf": [
+          {
+            "multipleOf": 3,
+          },
+        ],
+        "multipleOf": 2,
+        "type": "number",
+      }
+    `);
+  });
+
+  test("length() does not overwrite a tighter earlier bound", () => {
+    // min(8) + length(5) matches nothing at runtime; the emitted bounds stay honest about that
+    expect(z.toJSONSchema(z.string().min(8).length(5))).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "maxLength": 5,
+        "minLength": 8,
+        "type": "string",
+      }
+    `);
+  });
+
+  test("an integer format keeps the emitted type integer whatever format lands last", () => {
+    // runtime rejects 1.5 in both orders, so both must emit type integer
+    const after = z.number().int().check(z.float32());
+    expect(after.safeParse(1.5).success).toBe(false);
+    expect(z.toJSONSchema(after).type).toBe("integer");
+    expect(z.toJSONSchema(z.number().check(z.float32()).int()).type).toBe("integer");
+  });
+
+  test("disjoint mime checks emit a false schema, not an unconstrained file", () => {
+    const file = z.file().mime("image/png").mime("text/plain");
+    expect(z.toJSONSchema(file)).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "contentEncoding": "binary",
+        "format": "binary",
+        "not": {},
+        "type": "string",
+      }
+    `);
+  });
+
+  test("a custom mime narrowing via onattach intersects with built-in mime checks", () => {
+    const check = {
+      _zod: {
+        def: { check: "custom_mime" },
+        onattach: [
+          (inst: any) => {
+            inst._zod.bag.mime = ["text/plain"];
+          },
+        ],
+        check: () => {},
+      },
+    };
+    const file = z
+      .file()
+      .mime(["image/png", "text/plain"])
+      .check(check as any);
+    expect(z.toJSONSchema(file).contentMediaType).toBe("text/plain");
+  });
+
+  test("a custom check contributing via onattach still lands", () => {
+    // third-party checks have no converter handler; their bag writes are merged in as a fallback
+    const check = {
+      _zod: {
+        def: { check: "custom_range" },
+        onattach: [
+          (inst: any) => {
+            const bag = inst._zod.bag;
+            if (bag.minimum === undefined || 5 > bag.minimum) bag.minimum = 5;
+          },
+        ],
+        check: () => {},
+      },
+    };
+    expect(z.toJSONSchema(z.number().check(check as any))).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "minimum": 5,
+        "type": "number",
+      }
+    `);
+  });
+
   test("target normalization draft-04 and draft-07", () => {
     // Test that both old (draft-4, draft-7) and new (draft-04, draft-07) target formats work