cross-seed 7.0.0-21 → 7.0.0-23

package/node_modules/zod/src/v4/core/tests/email-regex.test.ts

@@ -0,0 +1,140 @@
+import { expect, test } from "vitest";
+
+import { regexes } from "zod/v4/core";
+
+// the lookahead form `regexes.email` had before this rewrite
+const legacy = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+
+const table: [string, boolean][] = [
+  ["a@b.cc", true],
+  ["first.last@example.com", true],
+  ["a.b.c.d@b.cc", true],
+  ["'a@b.cc", true],
+  ["a'b@b.cc", true],
+  ["a+b@b.cc", true],
+  ["a-@b.cc", true],
+  ["a_@b.cc", true],
+  ["a@0b.cc", true],
+  ["a@b.c.dd", true],
+  ["a@b-.cc", true],
+  [".a@b.cc", false],
+  ["a.@b.cc", false],
+  ["a..b@b.cc", false],
+  ["....@b.cc", false],
+  ["a@b..cc", false],
+  ["a@.b.cc", false],
+  ["a@b.cc.", false],
+  ["a'@b.cc", false],
+  ["'@b.cc", false],
+  ["@b.cc", false],
+  ["a@b.c", false],
+  ["a@b.c0", false],
+  ["a@-b.cc", false],
+  ["a@b.cc@d.ee", false],
+  ["a b@b.cc", false],
+  ["café@b.cc", false],
+  ["😀@b.cc", false],
+  ["a\0@b.cc", false],
+  // `$` is not multiline, so no trailing terminator is tolerated
+  ["a@b.cc\n", false],
+  ["a@b.cc\r", false],
+  ["\na@b.cc", false],
+];
+
+test("boundary cases", () => {
+  for (const [input, expected] of table) {
+    expect([input, regexes.email.test(input)]).toEqual([input, expected]);
+    expect([input, legacy.test(input)]).toEqual([input, expected]);
+  }
+});
+
+// one representative per character class the two grammars can tell apart
+const classes = ["a", "0", "_", "'", "-", ".", "@", "!", "\n"];
+
+test("exhaustive agreement over every string of length <= 6 in the class alphabet", () => {
+  const idx: number[] = [];
+  let accepted = 0;
+  for (let len = 0; len <= 6; len++) {
+    idx.length = len;
+    idx.fill(0);
+    for (;;) {
+      let s = "";
+      for (let i = 0; i < len; i++) s += classes[idx[i]!];
+      const a = legacy.test(s);
+      if (a !== regexes.email.test(s)) expect.unreachable(`disagreement on ${JSON.stringify(s)}`);
+      if (a) accepted++;
+      let p = len - 1;
+      while (p >= 0 && ++idx[p]! === classes.length) idx[p--] = 0;
+      if (p < 0) break;
+    }
+  }
+  // 4 chars can precede `@`, 2 can open a domain label, 1 is a letter for the TLD
+  expect(accepted).toBe(8);
+});
+
+function rng(seed: number) {
+  let s = seed >>> 0;
+  return () => {
+    s = (s + 0x6d2b79f5) >>> 0;
+    let t = s;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+const local = "abZ09_'+-.".split("");
+const domain = "abZ09-.".split("");
+const hostile = ["@", ".", "..", "...", "\n", "\r", "\0", "\t", " ", '"', "é", "😀", "\\", "<", ";", "/", "{"];
+const any = [...local, ...domain, ...hostile];
+
+function fuzz(r: () => number): string {
+  const pick = <T>(xs: T[]): T => xs[Math.floor(r() * xs.length)]!;
+  const run = (xs: string[], max: number) => {
+    let out = "";
+    for (let i = Math.floor(r() * max); i > 0; i--) out += pick(xs);
+    return out;
+  };
+  switch (Math.floor(r() * 8)) {
+    case 0:
+      return run(any, 40);
+    case 1:
+      return `${run(local, 24)}@${run(domain, 24)}`;
+    case 2:
+      return `${run(local, 8)}${".".repeat(1 + Math.floor(r() * 6))}${run(local, 8)}@${run(domain, 12)}`;
+    case 3:
+      return `${run(local, 8)}@${run(domain, 8)}${".".repeat(1 + Math.floor(r() * 6))}${run(domain, 8)}`;
+    case 4: {
+      // single-character mutation of a valid address
+      const base = `${run("abZ09_'+-".split(""), 10)}@example.com`;
+      const i = Math.floor(r() * base.length);
+      return Math.floor(r() * 3) === 0
+        ? base.slice(0, i) + pick(any) + base.slice(i)
+        : base.slice(0, i) + (Math.floor(r() * 2) ? pick(any) : "") + base.slice(i + 1);
+    }
+    case 5:
+      return (
+        "a".repeat(1 + Math.floor(r() * 60)) +
+        ".".repeat(Math.floor(r() * 4)) +
+        run(local, 4) +
+        (r() < 0.5 ? "@" : "") +
+        run(domain, 10)
+      );
+    case 6:
+      return `${run(local, 8)}@${run(domain, 6)}@${run(domain, 8)}`;
+    default:
+      return pick(["", "\n", " "]) + run(local, 8) + "@example.com" + pick(["", "\n", "\r\n", " ", "\0"]);
+  }
+}
+
+test("differential fuzz", () => {
+  const r = rng(0x5eed);
+  let accepted = 0;
+  for (let i = 0; i < 25_000; i++) {
+    const s = fuzz(r);
+    const a = legacy.test(s);
+    if (a !== regexes.email.test(s)) expect.unreachable(`disagreement on ${JSON.stringify(s)}`);
+    if (a) accepted++;
+  }
+  expect(accepted).toBeGreaterThan(500);
+});

package/node_modules/zod/src/v4/core/tests/locales/el.test.ts

@@ -0,0 +1,214 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import el from "../../../locales/el.js";
+
+test("Greek locale - too_small errors", () => {
+  z.config(el());
+
+  // Test string type translation
+  const stringSchema = z.string().min(5);
+  const stringResult = stringSchema.safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν string να έχει >=5 χαρακτήρες");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().min(10);
+  const numberResult = numberSchema.safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν number να είναι >=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).min(3);
+  const arrayResult = arraySchema.safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν array να έχει >=3 στοιχεία");
+  }
+
+  // Test set type translation
+  const setSchema = z.set(z.string()).min(2);
+  const setResult = setSchema.safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Πολύ μικρό: αναμενόταν set να έχει >=2 στοιχεία");
+  }
+});
+
+test("Greek locale - too_big errors", () => {
+  z.config(el());
+
+  // Test string type translation
+  const stringSchema = z.string().max(3);
+  const stringResult = stringSchema.safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Πολύ μεγάλο: αναμενόταν string να έχει <=3 χαρακτήρες");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().max(10);
+  const numberResult = numberSchema.safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Πολύ μεγάλο: αναμενόταν number να είναι <=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).max(2);
+  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Πολύ μεγάλο: αναμενόταν array να έχει <=2 στοιχεία");
+  }
+});
+
+test("Greek locale - invalid_type errors", () => {
+  z.config(el());
+
+  // Test string expected, number received
+  const stringSchema = z.string();
+  const stringResult = stringSchema.safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν string, λήφθηκε number");
+  }
+
+  // Test number expected, string received
+  const numberSchema = z.number();
+  const numberResult = numberSchema.safeParse("abc");
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν number, λήφθηκε string");
+  }
+
+  // Test boolean expected, null received
+  const booleanSchema = z.boolean();
+  const booleanResult = booleanSchema.safeParse(null);
+  expect(booleanResult.success).toBe(false);
+  if (!booleanResult.success) {
+    expect(booleanResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν boolean, λήφθηκε null");
+  }
+
+  // Test array expected, object received
+  const arraySchema = z.array(z.string());
+  const arrayResult = arraySchema.safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν array, λήφθηκε object");
+  }
+});
+
+test("Greek locale - other error cases", () => {
+  z.config(el());
+
+  // Test invalid_element with map (only "map" | "set" produce invalid_element)
+  const mapSchema = z.map(z.bigint(), z.number());
+  const mapResult = mapSchema.safeParse(new Map([[BigInt(123), BigInt(123)]]));
+  expect(mapResult.success).toBe(false);
+  if (!mapResult.success) {
+    expect(mapResult.error.issues[0].code).toBe("invalid_element");
+    expect(mapResult.error.issues[0].message).toBe("Μη έγκυρη τιμή στο map");
+  }
+
+  // Test invalid_key with record (only "map" | "record" produce invalid_key)
+  const recordSchema = z.record(z.number(), z.string());
+  const recordResult = recordSchema.safeParse({ notANumber: "value" });
+  expect(recordResult.success).toBe(false);
+  if (!recordResult.success) {
+    expect(recordResult.error.issues[0].code).toBe("invalid_key");
+    expect(recordResult.error.issues[0].message).toBe("Μη έγκυρο κλειδί στο record");
+  }
+
+  // Test invalid_value with enum
+  const enumSchema = z.enum(["a", "b"]);
+  const enumResult = enumSchema.safeParse("c");
+  expect(enumResult.success).toBe(false);
+  if (!enumResult.success) {
+    expect(enumResult.error.issues[0].message).toBe('Μη έγκυρη επιλογή: αναμενόταν ένα από "a"|"b"');
+  }
+
+  // Test not_multiple_of
+  const multipleSchema = z.number().multipleOf(3);
+  const multipleResult = multipleSchema.safeParse(10);
+  expect(multipleResult.success).toBe(false);
+  if (!multipleResult.success) {
+    expect(multipleResult.error.issues[0].message).toBe("Μη έγκυρος αριθμός: πρέπει να είναι πολλαπλάσιο του 3");
+  }
+
+  // Test unrecognized_keys (single key)
+  const strictSchema = z.object({ a: z.string() }).strict();
+  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
+  expect(strictResult.success).toBe(false);
+  if (!strictResult.success) {
+    expect(strictResult.error.issues[0].message).toBe('Άγνωστο κλειδί: "b"');
+  }
+
+  // Test unrecognized_keys (multiple keys)
+  const strictMultipleResult = strictSchema.safeParse({
+    a: "test",
+    b: "extra",
+    c: "another",
+  });
+  expect(strictMultipleResult.success).toBe(false);
+  if (!strictMultipleResult.success) {
+    expect(strictMultipleResult.error.issues[0].message).toBe('Άγνωστα κλειδιά: "b", "c"');
+  }
+
+  // Test invalid_union
+  const unionSchema = z.union([z.string(), z.number()]);
+  const unionResult = unionSchema.safeParse(true);
+  expect(unionResult.success).toBe(false);
+  if (!unionResult.success) {
+    expect(unionResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος");
+  }
+
+  // Test invalid_format with regex
+  const regexSchema = z.string().regex(/^[a-z]+$/);
+  const regexResult = regexSchema.safeParse("ABC123");
+  expect(regexResult.success).toBe(false);
+  if (!regexResult.success) {
+    expect(regexResult.error.issues[0].message).toBe(
+      "Μη έγκυρη συμβολοσειρά: πρέπει να ταιριάζει με το μοτίβο /^[a-z]+$/"
+    );
+  }
+
+  // Test invalid_format with startsWith
+  const startsWithSchema = z.string().startsWith("hello");
+  const startsWithResult = startsWithSchema.safeParse("world");
+  expect(startsWithResult.success).toBe(false);
+  if (!startsWithResult.success) {
+    expect(startsWithResult.error.issues[0].message).toBe('Μη έγκυρη συμβολοσειρά: πρέπει να ξεκινά με "hello"');
+  }
+
+  // Test invalid_format with endsWith
+  const endsWithSchema = z.string().endsWith("world");
+  const endsWithResult = endsWithSchema.safeParse("hello");
+  expect(endsWithResult.success).toBe(false);
+  if (!endsWithResult.success) {
+    expect(endsWithResult.error.issues[0].message).toBe('Μη έγκυρη συμβολοσειρά: πρέπει να τελειώνει με "world"');
+  }
+
+  // Test invalid_format with includes
+  const includesSchema = z.string().includes("test");
+  const includesResult = includesSchema.safeParse("hello");
+  expect(includesResult.success).toBe(false);
+  if (!includesResult.success) {
+    expect(includesResult.error.issues[0].message).toBe('Μη έγκυρη συμβολοσειρά: πρέπει να περιέχει "test"');
+  }
+});
+
+test("Greek locale - invalid_type with instanceof (class-name expected)", () => {
+  z.config(el());
+
+  // When `expected` starts with a capital letter, render an `instanceof` message, matching the convention used by most other locales (de, es, fr, it, etc.).
+  const dateSchema = z.instanceof(Date);
+  const dateResult = dateSchema.safeParse("not a date");
+  expect(dateResult.success).toBe(false);
+  if (!dateResult.success) {
+    expect(dateResult.error.issues[0].message).toBe("Μη έγκυρη είσοδος: αναμενόταν instanceof Date, λήφθηκε string");
+  }
+});

package/node_modules/zod/src/v4/core/tests/locales/es.test.ts

@@ -109,8 +109,7 @@ test("Spanish locale - type name translations in invalid_type errors", () => {
 test("Spanish locale - fallback for unknown type names", () => {
   z.config(es());
 
-  // Test with a type that's not in the TypeNames dictionary
-  // This will test the fallback behavior
+  // Test with a type that's not in the TypeNames dictionary. This will test the fallback behavior
   const dateSchema = z.date().min(new Date("2025-01-01"));
   const dateResult = dateSchema.safeParse(new Date("2024-01-01"));
   expect(dateResult.success).toBe(false);

package/node_modules/zod/src/v4/core/tests/locales/fr.test.ts

@@ -0,0 +1,72 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import fr from "../../../locales/fr.js";
+
+test("French locale - type name translations in too_small errors", () => {
+  z.config(fr());
+
+  const stringResult = z.string().min(5).safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Trop petit : chaîne de caractères doit avoir >=5 caractères");
+  }
+
+  const numberResult = z.number().min(10).safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Trop petit : nombre doit être >=10");
+  }
+
+  const arrayResult = z.array(z.string()).min(3).safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Trop petit : tableau doit avoir >=3 éléments");
+  }
+
+  const setResult = z
+    .set(z.string())
+    .min(2)
+    .safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Trop petit : ensemble doit avoir >=2 éléments");
+  }
+});
+
+test("French locale - type name translations in too_big errors", () => {
+  z.config(fr());
+
+  const stringResult = z.string().max(3).safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Trop grand : chaîne de caractères doit avoir <=3 caractères");
+  }
+
+  const numberResult = z.number().max(10).safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Trop grand : nombre doit être <=10");
+  }
+
+  const arrayResult = z.array(z.string()).max(2).safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Trop grand : tableau doit avoir <=2 éléments");
+  }
+});
+
+test("French locale - type name translations in invalid_type errors", () => {
+  z.config(fr());
+
+  const stringResult = z.string().safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Entrée invalide : chaîne de caractères attendu, nombre reçu");
+  }
+
+  const arrayResult = z.array(z.string()).safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Entrée invalide : tableau attendu, objet reçu");
+  }
+});

package/node_modules/zod/src/v4/core/tests/locales/hr.test.ts

@@ -0,0 +1,163 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import hr from "../../../locales/hr.js";
+
+test("Croatian locale - type name translations in too_small errors", () => {
+  z.config(hr());
+
+  // Test string type translation
+  const stringSchema = z.string().min(5);
+  const stringResult = stringSchema.safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Premalo: očekivano da tekst ima >=5 znakova");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().min(10);
+  const numberResult = numberSchema.safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Premalo: očekivano da broj bude >=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).min(3);
+  const arrayResult = arraySchema.safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Premalo: očekivano da niz ima >=3 stavki");
+  }
+
+  // Test set type translation
+  const setSchema = z.set(z.string()).min(2);
+  const setResult = setSchema.safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Premalo: očekivano da skup ima >=2 stavki");
+  }
+});
+
+test("Croatian locale - type name translations in too_big errors", () => {
+  z.config(hr());
+
+  // Test string type translation
+  const stringSchema = z.string().max(3);
+  const stringResult = stringSchema.safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Preveliko: očekivano da tekst ima <=3 znakova");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().max(10);
+  const numberResult = numberSchema.safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Preveliko: očekivano da broj bude <=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).max(2);
+  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Preveliko: očekivano da niz ima <=2 stavki");
+  }
+});
+
+test("Croatian locale - type name translations in invalid_type errors", () => {
+  z.config(hr());
+
+  // Test string expected, number received
+  const stringSchema = z.string();
+  const stringResult = stringSchema.safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Neispravan unos: očekuje se tekst, a primljeno je broj");
+  }
+
+  // Test number expected, string received
+  const numberSchema = z.number();
+  const numberResult = numberSchema.safeParse("abc");
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Neispravan unos: očekuje se broj, a primljeno je tekst");
+  }
+
+  // Test boolean expected, null received
+  const booleanSchema = z.boolean();
+  const booleanResult = booleanSchema.safeParse(null);
+  expect(booleanResult.success).toBe(false);
+  if (!booleanResult.success) {
+    expect(booleanResult.error.issues[0].message).toBe("Neispravan unos: očekuje se boolean, a primljeno je null");
+  }
+
+  // Test array expected, object received
+  const arraySchema = z.array(z.string());
+  const arrayResult = arraySchema.safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Neispravan unos: očekuje se niz, a primljeno je objekt");
+  }
+});
+
+test("Croatian locale - other error cases", () => {
+  z.config(hr());
+
+  // Test invalid_element with tuple
+  const tupleSchema = z.tuple([z.string(), z.number()]);
+  const tupleResult = tupleSchema.safeParse(["abc", "not a number"]);
+  expect(tupleResult.success).toBe(false);
+  if (!tupleResult.success) {
+    expect(tupleResult.error.issues[0].message).toContain("Neispravan unos");
+  }
+
+  // Test invalid_value with enum
+  const enumSchema = z.enum(["a", "b"]);
+  const enumResult = enumSchema.safeParse("c");
+  expect(enumResult.success).toBe(false);
+  if (!enumResult.success) {
+    expect(enumResult.error.issues[0].message).toBe('Neispravna opcija: očekivano jedno od "a"|"b"');
+  }
+
+  // Test not_multiple_of
+  const multipleSchema = z.number().multipleOf(3);
+  const multipleResult = multipleSchema.safeParse(10);
+  expect(multipleResult.success).toBe(false);
+  if (!multipleResult.success) {
+    expect(multipleResult.error.issues[0].message).toBe("Neispravan broj: mora biti višekratnik od 3");
+  }
+
+  // Test unrecognized_keys
+  const strictSchema = z.object({ a: z.string() }).strict();
+  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
+  expect(strictResult.success).toBe(false);
+  if (!strictResult.success) {
+    expect(strictResult.error.issues[0].message).toBe('Neprepoznat ključ: "b"');
+  }
+
+  // Test invalid_union
+  const unionSchema = z.union([z.string(), z.number()]);
+  const unionResult = unionSchema.safeParse(true);
+  expect(unionResult.success).toBe(false);
+  if (!unionResult.success) {
+    expect(unionResult.error.issues[0].message).toBe("Neispravan unos");
+  }
+
+  // Test invalid_format with regex
+  const regexSchema = z.string().regex(/^[a-z]+$/);
+  const regexResult = regexSchema.safeParse("ABC123");
+  expect(regexResult.success).toBe(false);
+  if (!regexResult.success) {
+    expect(regexResult.error.issues[0].message).toBe("Neispravan tekst: mora odgovarati uzorku /^[a-z]+$/");
+  }
+
+  // Test invalid_format with startsWith
+  const startsWithSchema = z.string().startsWith("hello");
+  const startsWithResult = startsWithSchema.safeParse("world");
+  expect(startsWithResult.success).toBe(false);
+  if (!startsWithResult.success) {
+    expect(startsWithResult.error.issues[0].message).toBe('Neispravan tekst: mora započinjati s "hello"');
+  }
+});

package/node_modules/zod/src/v4/core/tests/locales/parity.test.ts

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+
+// Every locale must carry an entry for each key `en` translates. Four keys have drifted this way already — `credit_card` (#5931), `mac` (#5440), `Sizable.map` (#5316) and Hebrew's `uuidv4`/`uuidv6`/`template_literal` — each shipped in `en` and left the rest behind, so the gap only surfaced as a raw key in a user's error message.
+//
+// The key lists are read out of `en.ts` rather than hardcoded, so adding a format to `en` extends this test automatically. That is the whole point: a hand-maintained list here would miss the next one exactly the way the last four were missed.
+
+const enSource = readFileSync(fileURLToPath(new URL("../../../locales/en.ts", import.meta.url)), "utf8");
+
+function keysOf(block: string): string[] {
+  const body = enSource.match(new RegExp(`const ${block}[^=]*= \\{([\\s\\S]*?)\\n  \\};`))?.[1];
+  if (!body) throw new Error(`could not read ${block} out of en.ts`);
+  return [...body.matchAll(/^\s{4}([a-z_0-9]+):/gm)].map((m) => m[1]!);
+}
+
+const locales = z.locales as unknown as Record<string, () => { localeError: z.core.$ZodErrorMap }>;
+const names = Object.keys(locales).filter((k) => typeof locales[k] === "function");
+const SENTINEL = "zzsentinelzz";
+
+/** True when the locale has no entry for `key`: the message is what the sentinel produces. */
+function fallsThrough(locale: string, key: string, build: (k: string) => unknown): boolean {
+  const map = locales[locale]!().localeError as (iss: unknown) => string | undefined;
+  const real = String(map(build(key)) ?? "");
+  const sentinel = String(map(build(SENTINEL)) ?? "");
+  return real === sentinel.split(SENTINEL).join(key);
+}
+
+const asFormat = (k: string) => ({ code: "invalid_format", format: k, input: "x", path: [] });
+const asSize = (k: string) => ({ code: "too_small", origin: k, minimum: 2, inclusive: true, input: null, path: [] });
+
+test.each([
+  ["FormatDictionary", keysOf("FormatDictionary"), asFormat],
+  ["Sizable", keysOf("Sizable"), asSize],
+] as const)("every locale translates each %s key that en translates", (_block, keys, build) => {
+  // A key `en` maps to its own name (emoji, nanoid, cuid, cuid2) renders identically whether or not a locale defines it, so omitting it is not drift.
+  const required = keys.filter((k) => !fallsThrough("en", k, build));
+  const gaps = required.flatMap((k) => names.filter((n) => fallsThrough(n, k, build)).map((n) => `${n}.${k}`));
+
+  expect(gaps).toEqual([]);
+});