@wopee-io/wopee.wdio 5.2.5 → 6.0.1

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/extend.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("safeExtend chaining preserves and overrides properties", () => {
+  const schema1 = z.object({
+    email: z.string(),
+  });
+
+  const schema2 = schema1.safeExtend({
+    email: schema1.shape.email.check(z.email()),
+  });
+
+  const schema3 = schema2.safeExtend({
+    email: schema2.shape.email.or(z.literal("")),
+  });
+
+  schema3.parse({ email: "test@example.com" });
+});
+
+test("extend with constructor field in shape", () => {
+  const baseSchema = z.object({
+    name: z.string(),
+  });
+
+  const extendedSchema = baseSchema.extend({
+    constructor: z.string(),
+    age: z.number(),
+  });
+
+  const result = extendedSchema.parse({
+    name: "John",
+    constructor: "Person",
+    age: 30,
+  });
+
+  expect(result).toEqual({
+    name: "John",
+    constructor: "Person",
+    age: 30,
+  });
+
+  const testCases = [
+    { name: "Test", constructor: 123, age: 25 },
+    { name: "Test", constructor: null, age: 25 },
+    { name: "Test", constructor: true, age: 25 },
+    { name: "Test", constructor: {}, age: 25 },
+  ];
+
+  for (const testCase of testCases) {
+    const anyConstructorSchema = baseSchema.extend({
+      constructor: z.any(),
+      age: z.number(),
+    });
+
+    expect(() => anyConstructorSchema.parse(testCase)).not.toThrow();
+    const parsed = anyConstructorSchema.parse(testCase);
+    expect(parsed).toEqual(testCase);
+  }
+});

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/en.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import { parsedType } from "../../../locales/en.js";
+import { parsedType } from "../../util.js";
 
 test("parsedType", () => {
   expect(parsedType("string")).toBe("string");

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

@@ -0,0 +1,180 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import es from "../../../locales/es.js";
+
+test("Spanish locale - type name translations in too_small errors", () => {
+  z.config(es());
+
+  // 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(
+      "Demasiado pequeño: se esperaba que texto tuviera >=5 caracteres"
+    );
+  }
+
+  // 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("Demasiado pequeño: se esperaba que número fuera >=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(
+      "Demasiado pequeño: se esperaba que arreglo tuviera >=3 elementos"
+    );
+  }
+
+  // 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("Demasiado pequeño: se esperaba que conjunto tuviera >=2 elementos");
+  }
+});
+
+test("Spanish locale - type name translations in too_big errors", () => {
+  z.config(es());
+
+  // 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("Demasiado grande: se esperaba que texto tuviera <=3 caracteres");
+  }
+
+  // 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("Demasiado grande: se esperaba que número fuera <=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("Demasiado grande: se esperaba que arreglo tuviera <=2 elementos");
+  }
+});
+
+test("Spanish locale - type name translations in invalid_type errors", () => {
+  z.config(es());
+
+  // 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("Entrada inválida: se esperaba texto, recibido número");
+  }
+
+  // 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("Entrada inválida: se esperaba número, recibido texto");
+  }
+
+  // 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("Entrada inválida: se esperaba booleano, recibido nulo");
+  }
+
+  // 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("Entrada inválida: se esperaba arreglo, recibido objeto");
+  }
+});
+
+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
+  const dateSchema = z.date().min(new Date("2025-01-01"));
+  const dateResult = dateSchema.safeParse(new Date("2024-01-01"));
+  expect(dateResult.success).toBe(false);
+  if (!dateResult.success) {
+    // Should use "fecha" since we included it in TypeNames
+    expect(dateResult.error.issues[0].message).toContain("fecha");
+  }
+});
+
+test("Spanish locale - other error cases", () => {
+  z.config(es());
+
+  // 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("Entrada inválida");
+  }
+
+  // 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('Opción inválida: se esperaba una de "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("Número inválido: debe ser múltiplo de 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('Llave desconocida: "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("Entrada inválida");
+  }
+
+  // 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("Cadena inválida: debe coincidir con el patrón /^[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('Cadena inválida: debe comenzar con "hello"');
+  }
+});

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