@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

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

@@ -57,3 +57,30 @@ test("The callback's return value becomes the apply's return value.", () => {
   expect(result).toBe(symbol);
   expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
 });
+
+test("apply forwards extra args to the callback", () => {
+  const withDefault = <TSchema extends z.ZodType>(schema: TSchema, defaultValue: z.output<TSchema>) => {
+    return schema.nullish().transform((x) => x ?? defaultValue);
+  };
+
+  const schema = z.string().apply(withDefault, "default-id");
+
+  expect(schema.parse(undefined)).toBe("default-id");
+  expect(schema.parse(null)).toBe("default-id");
+  expect(schema.parse("value")).toBe("value");
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<string>();
+});
+
+test("apply type-checks the extra args", () => {
+  const withMin = (schema: z.ZodString, n: number) => schema.min(n);
+
+  expect(z.string().apply(withMin, 3).parse("abcd")).toBe("abcd");
+  expectTypeOf(z.number().apply<z.ZodNumber>((schema) => schema.min(0))).toEqualTypeOf<z.ZodNumber>();
+
+  // @ts-expect-error wrong arg type
+  z.string().apply(withMin, "3");
+  // @ts-expect-error missing arg
+  z.string().apply(withMin);
+  // @ts-expect-error extra arg for a single-parameter callback
+  z.string().apply((schema: z.ZodString) => schema, 3);
+});

package/node_modules/zod/src/v4/classic/tests/array.test.ts

@@ -51,7 +51,7 @@ test("array length", () => {
         "code": "too_small",
         "exact": true,
         "inclusive": true,
-        "message": "Too small: expected array to have >=2 items",
+        "message": "Too small: expected array to have exactly 2 items",
         "minimum": 2,
         "origin": "array",
         "path": [],
@@ -68,7 +68,7 @@ test("array length", () => {
         "exact": true,
         "inclusive": true,
         "maximum": 2,
-        "message": "Too big: expected array to have <=2 items",
+        "message": "Too big: expected array to have exactly 2 items",
         "origin": "array",
         "path": [],
       },

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

@@ -1,6 +1,7 @@
 import { expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
+import * as core from "zod/v4/core";
 
 test("assignability", () => {
   // $ZodString
@@ -162,6 +163,140 @@ test("assignability", () => {
   z.file() satisfies z.ZodFile;
 });
 
+test("toZod", () => {
+  type Company = {
+    id: string;
+    name: string;
+    webAddress: string | null;
+  };
+
+  const CompanySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    webAddress: z.string().url().nullable(),
+  });
+  const Company = z.toZod<Company>()(CompanySchema);
+
+  Company.shape.id.min(1);
+  expectTypeOf<z.output<typeof Company>>().toEqualTypeOf<Company>();
+
+  const CoreCompany = core.toZod<Company>()(CompanySchema);
+  expectTypeOf<core.output<typeof CoreCompany>>().toEqualTypeOf<Company>();
+
+  const UtilCompany = z.core.util.toZod<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof UtilCompany>>().toEqualTypeOf<Company>();
+
+  type Complex = {
+    kind: "company";
+    nested: {
+      founded: Date;
+      tags: string[];
+    };
+    scores: Record<"a" | "b", number>;
+    tuple: [string, number];
+    status: "active" | "inactive";
+  };
+
+  const Complex = z.toZod<Complex>()(
+    z.object({
+      kind: z.literal("company"),
+      nested: z.object({
+        founded: z.date(),
+        tags: z.array(z.string()),
+      }),
+      scores: z.record(z.enum(["a", "b"]), z.number()),
+      tuple: z.tuple([z.string(), z.number()]),
+      status: z.union([z.literal("active"), z.literal("inactive")]),
+    })
+  );
+  expectTypeOf<z.output<typeof Complex>>().toEqualTypeOf<Complex>();
+
+  type Items = {
+    items: { value: string }[];
+  };
+
+  const Items = z.toZod<Items>()(
+    z.object({
+      items: z.array(z.object({ value: z.string() })),
+    })
+  );
+  expectTypeOf<z.output<typeof Items>>().toEqualTypeOf<Items>();
+
+  type ReadonlyItem = Readonly<{
+    id: string;
+  }>;
+
+  const ReadonlyItem = z.toZod<ReadonlyItem>()(z.object({ id: z.string() }).readonly());
+  expectTypeOf<z.output<typeof ReadonlyItem>>().toEqualTypeOf<ReadonlyItem>();
+
+  const Transformed = z.toZod<{ count: number }>()(
+    z.object({
+      count: z.string().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.string().url().nullable(),
+      extra: z.string(),
+    })
+  );
+
+  z.toZod<Company>()(
+    // @ts-expect-error wrong property output fails matching
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      webAddress: z.string().url().nullable(),
+    })
+  );
+
+  z.toZod<ReadonlyItem>()(
+    // @ts-expect-error readonly output is required
+    z.object({
+      id: z.string(),
+    })
+  );
+
+  // @ts-expect-error any is only an exact match for any
+  z.toZod<string>()(z.any());
+
+  // @ts-expect-error toZod checks output, not input
+  z.toZod<string>()(z.string().transform((value) => value.length));
+
+  // Exact equality is deliberately the only mode. A bidirectional-assignability mode would accept both of the two cases above — `any` is assignable in both directions by construction, and `readonly` is not part of assignability — so it would silently drop the guarantees the rest of this test pins. The cost is the asymmetry below: an intersection target matches `.and()` but not `.safeExtend()`, and a flat target matches `.safeExtend()` but not `.and()`. Flattening the target with a mapped type switches which spelling matches rather than accepting both.
+  type Intersected = { a: number } & { b: string };
+  type Flatten<T> = { [K in keyof T]: T[K] } & {};
+  const viaAnd = z.object({ a: z.number() }).and(z.object({ b: z.string() }));
+  const viaExtend = z.object({ a: z.number() }).safeExtend({ b: z.string() });
+
+  z.toZod<Intersected>()(viaAnd);
+  z.toZod<{ a: number; b: string }>()(viaExtend);
+  z.toZod<Flatten<Intersected>>()(viaExtend);
+
+  // @ts-expect-error flattening the target does not make `.and()` match as well
+  z.toZod<Flatten<Intersected>>()(viaAnd);
+
+  // @ts-expect-error .safeExtend() produces a flat object type, not an intersection
+  z.toZod<Intersected>()(viaExtend);
+
+  // @ts-expect-error .and() produces an intersection, not a flat object type
+  z.toZod<{ a: number; b: string }>()(viaAnd);
+});
+
 test("checks", () => {
   const _a: z.core.$ZodCheck = {} as any as z.core.$ZodChecks;
   const _b: z.core.$ZodCheck = {} as any as z.core.$ZodStringFormatChecks;

package/node_modules/zod/src/v4/classic/tests/bigint.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -52,3 +52,32 @@ test("min max getters", () => {
   expect(z.bigint().max(BigInt(5)).maxValue).toEqual(BigInt(5));
   expect(z.bigint().max(BigInt(5)).max(BigInt(1)).maxValue).toEqual(BigInt(1));
 });
+
+test("bigint formats are distinct at the type level", () => {
+  expectTypeOf(z.int64()._zod.def.format).toEqualTypeOf<"int64">();
+  expectTypeOf(z.uint64()._zod.def.format).toEqualTypeOf<"uint64">();
+
+  z.int64() satisfies z.ZodBigIntFormat;
+  z.int64() satisfies z.ZodBigInt;
+
+  // @ts-expect-error a uint64 schema is not a ZodInt64
+  z.uint64() satisfies z.ZodInt64;
+});
+
+test("multipleOf(0n) does not throw from safeParse", () => {
+  // `value % 0n` throws RangeError, so the compiled path declines and the runtime reports the failure
+  const schema = z.bigint().multipleOf(BigInt(0));
+  const result = schema.safeParse(BigInt(10));
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].code).toEqual("not_multiple_of");
+  expect(schema.safeParse(BigInt(0)).success).toBe(false);
+
+  // matches the number equivalent
+  expect(z.number().multipleOf(0).safeParse(10).success).toBe(false);
+  expect(z.number().multipleOf(0).safeParse(0).success).toBe(false);
+
+  // a zero divisor nested in an object must not break the surrounding parse
+  const obj = z.object({ a: z.bigint().multipleOf(BigInt(0)), b: z.bigint() });
+  expect(obj.safeParse({ a: BigInt(1), b: BigInt(2) }).success).toBe(false);
+  expect(obj.safeParse({ a: BigInt(1), b: 2 }).success).toBe(false);
+});

package/node_modules/zod/src/v4/classic/tests/catch.test.ts

@@ -253,6 +253,136 @@ test("ctx.input", () => {
   expect(schema.parse(123)).toEqual("123");
 });
 
+test("ctx.value is the input to the catch, not what the inner schema made of it", async () => {
+  const seen: unknown[] = [];
+  const cb = (ctx: z.core.$ZodCatchCtx) => {
+    seen.push(ctx.value, ctx.input);
+    return -1;
+  };
+
+  expect(z.coerce.number().min(10).catch(cb).parse("5")).toBe(-1);
+  expect(
+    await z.coerce
+      .number()
+      .refine(async (n) => n >= 10)
+      .catch(cb)
+      .parseAsync("6")
+  ).toBe(-1);
+  expect(
+    z
+      .string()
+      .transform((s) => s.length)
+      .refine((n) => n > 10)
+      .catch(cb)
+      .parse("abc")
+  ).toBe(-1);
+
+  expect(seen).toEqual(["5", "5", "6", "6", "abc", "abc"]);
+});
+
+test("ctx.issues outlives the callback", () => {
+  let stashed!: z.core.$ZodRawIssue[];
+  z.string()
+    .min(10)
+    .catch((ctx) => {
+      stashed = ctx.issues;
+      return "fallback";
+    })
+    .parse("hi");
+
+  expect(stashed).toHaveLength(1);
+  expect(stashed[0].code).toBe("too_small");
+});
+
+test("catch ctx carries the rest of the payload through", () => {
+  let seen!: z.core.$ZodCatchCtx;
+  z.string()
+    .min(10)
+    .pipe(z.string())
+    .catch((ctx) => {
+      seen = ctx;
+      return "fallback";
+    })
+    .parse("hi");
+
+  expect(seen.aborted).toBe(true);
+});
+
+test("catch does not swallow an issue it did not cause", () => {
+  // A pipe hands its `out` schema the caller's issues array so an unrecognized key can survive to an enclosing intersection. The catch must not read that as its own inner failing.
+  const result = z.strictObject({ a: z.string() }).pipe(z.any().catch("CAUGHT")).safeParse({ a: "x", extra: 1 });
+
+  expect(result.success).toBe(false);
+  expect(result.error!.issues.map((i) => i.code)).toEqual(["unrecognized_keys"]);
+});
+
+test("catch does not break intersection reconciliation", () => {
+  // Forwarding the unrecognized key is what lets the intersection reconcile it. A catch that fired on it substituted its fallback into one side, and the merge threw out of safeParse.
+  const schema = z.intersection(
+    z.strictObject({ a: z.string() }).pipe(z.any().catch("CAUGHT")),
+    z.strictObject({ b: z.string() })
+  );
+
+  expect(schema.parse({ a: "x", b: "y" })).toEqual({ a: "x", b: "y" });
+});
+
+test("catch propagates a back-edge to whatever wraps it", () => {
+  // The memoizer marks a payload whose value is a node still being parsed. That mark has to survive the catch: an enclosing readonly must not freeze a half-built object, and the node's checks belong to the node itself rather than to the back-edge.
+  const Node: any = z.object({
+    get self() {
+      return z
+        .lazy(() => Node)
+        .catch(null)
+        .readonly()
+        .optional();
+    },
+  });
+  const cyclic: any = {};
+  cyclic.self = cyclic;
+  const frozen = Node.safeParse(cyclic);
+  expect(frozen.success).toBe(true);
+  expect(Object.keys(frozen.data)).toEqual(["self"]);
+
+  let checks = 0;
+  const Checked: any = z.object({
+    get self() {
+      return z
+        .lazy(() => Checked)
+        .catch(null)
+        .refine(() => {
+          checks++;
+          return true;
+        })
+        .optional();
+    },
+  });
+  const cyclic2: any = {};
+  cyclic2.self = cyclic2;
+  Checked.safeParse(cyclic2);
+  expect(checks).toBe(0);
+});
+
+test("a catch that fires does not rescue an issue from outside it", () => {
+  // The callback still runs and still computes its fallback — the inner schema really did fail. What it cannot do is answer for the unrecognized key the pipe forwarded past it, so the parse fails anyway.
+  let fired = 0;
+  const result = z
+    .strictObject({ a: z.string() })
+    .pipe(
+      z
+        .object({ a: z.string() })
+        .refine(() => false)
+        .catch(() => {
+          fired++;
+          return { a: "FALLBACK" };
+        })
+    )
+    .safeParse({ a: "x", extra: 1 });
+
+  expect(fired).toBe(1);
+  expect(result.success).toBe(false);
+  expect(result.error!.issues.map((i) => i.code)).toEqual(["unrecognized_keys"]);
+});
+
 test("direction-aware catch", () => {
   const schema = z.string().catch("fallback");
 
@@ -324,3 +454,151 @@ test("optional clobbers catch through pipe boundaries", () => {
       .parse(123)
   ).toBe("X!");
 });
+
+test("catch does not resurrect issues an inner optional already resolved", () => {
+  // `.catch()` reads issues off the payload it passed down, so an optional that resolved a failure without clearing that array let the failure resurface. The pipe rows matter: a pipe shares the array with a different payload object.
+  const chains: [string, () => z.ZodType][] = [
+    [
+      "prefault.optional",
+      () =>
+        z
+          .undefined()
+          .prefault(null as any)
+          .optional(),
+    ],
+    [
+      "default.optional",
+      () =>
+        z
+          .undefined()
+          .default(null as any)
+          .optional(),
+    ],
+    ["prefault.pipe.optional", () => z.string().prefault("abc").pipe(z.string().min(10)).optional()],
+    ["default.pipe.optional", () => z.string().default("abc").pipe(z.string().min(10)).optional()],
+    [
+      "prefault.optional.optional",
+      () =>
+        z
+          .undefined()
+          .prefault(null as any)
+          .optional()
+          .optional(),
+    ],
+    [
+      "prefault.pipe.optional.optional",
+      () => z.string().prefault("abc").pipe(z.string().min(10)).optional().optional(),
+    ],
+  ];
+
+  for (const [name, make] of chains) {
+    expect(make().safeParse(undefined).success, `${name} without catch`).toBe(true);
+    expect((make() as any).catch(null).safeParse(undefined).success, `${name} + catch(value)`).toBe(true);
+    expect((make() as any).catch(() => null).safeParse(undefined).success, `${name} + catch(callback)`).toBe(true);
+  }
+
+  expect(
+    z
+      .object({
+        a: z
+          .undefined()
+          .prefault(null as any)
+          .optional()
+          .catch(null as any),
+      })
+      .safeParse({ a: undefined }).success
+  ).toBe(true);
+
+  expect(z.string().catch("FB").parse(123)).toBe("FB");
+  expect(z.string().optional().safeParse(123).success).toBe(false);
+});
+
+test("resolving an optional's failure clears the abort flag with it", () => {
+  // A pipe marks the payload aborted when its `in` fails, and `util.aborted` tests that flag alone, so leaving it set skips every check after the optional.
+  const schema = z
+    .string()
+    .min(10)
+    .prefault("abc")
+    .pipe(z.string())
+    .optional()
+    .refine(() => false, "REFINE RAN");
+
+  const result = schema.safeParse(undefined);
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0]?.message).toBe("REFINE RAN");
+});
+
+test("catch clears the abort flag along with the issues", () => {
+  // Same as the optional case one wrapper over: a catch that clears only the issues leaves the flag set, skipping every check after it.
+  const schema = z
+    .string()
+    .min(10)
+    .pipe(z.string())
+    .catch("FB")
+    .refine(() => false, "REFINE RAN");
+
+  const result = schema.safeParse("abc");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0]?.message).toBe("REFINE RAN");
+
+  expect(
+    z
+      .string()
+      .min(2)
+      .pipe(z.string())
+      .catch("FB")
+      .refine(() => false, "REFINE RAN")
+      .safeParse("abcdef").success
+  ).toBe(false);
+  expect(
+    z
+      .string()
+      .min(10)
+      .catch("FB")
+      .refine(() => false, "REFINE RAN")
+      .safeParse("abc").success
+  ).toBe(false);
+});
+
+test("catch clears the abort flag on the async branch too", () => {
+  // Reaching the async branch needs the catch's own inner to be async; an async refinement outside it leaves the inner sync.
+  const schema = z
+    .string()
+    .refine(async () => false, "INNER")
+    .pipe(z.string())
+    .catch("FB")
+    .refine(() => false, "REFINE RAN");
+
+  return expect(schema.safeParseAsync("abc")).resolves.toMatchObject({
+    success: false,
+    error: { issues: [{ message: "REFINE RAN" }] },
+  });
+});
+
+test("catch resolves the issues array itself, so an outer catch does not resurrect them", () => {
+  // A pipe runs its `out` on a payload sharing the caller's issues array, so a catch that rebinds its own reference leaves the caller's copy dirty.
+  const inner = z.string().pipe(z.string().min(10).catch("FB"));
+
+  expect(inner.safeParse("abc")).toMatchObject({ success: true, data: "FB" });
+  expect(inner.catch("FB2").safeParse("abc")).toMatchObject({ success: true, data: "FB" });
+
+  expect(z.string().catch("FB").parse(123)).toBe("FB");
+  expect(z.string().catch("FB").parse("ok")).toBe("ok");
+  expect(
+    z
+      .string()
+      .catch((ctx) => `n=${ctx.error.issues.length}`)
+      .parse(123)
+  ).toBe("n=1");
+});
+
+test("catch resolves the issues array on the async branch too", () => {
+  const inner = z.string().pipe(
+    z
+      .string()
+      .refine(async () => false, "INNER")
+      .catch("FB")
+  );
+
+  return expect(inner.catch("FB2").safeParseAsync("abc")).resolves.toMatchObject({ success: true, data: "FB" });
+});

package/node_modules/zod/src/v4/classic/tests/codec-examples.test.ts

@@ -554,8 +554,7 @@ test("codec transform error handling", () => {
     expect(validResult.data).toEqual({ valid: "json" });
   }
 
-  // Test invalid JSON that should create a single "invalid_format" issue
-  // Verifies that the transform error aborts before reaching the output schema
+  // Test invalid JSON that should create a single "invalid_format" issue. Verifies that the transform error aborts before reaching the output schema
   const invalidResult = z.safeDecode(anyJSON, '{"invalid":,}');
   expect(invalidResult.success).toBe(false);
   if (!invalidResult.success) {

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

@@ -100,7 +100,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))$/",
         },
       ]
     `);
@@ -241,6 +241,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: "",

package/node_modules/zod/src/v4/classic/tests/continuability.test.ts

@@ -230,7 +230,7 @@ test("continuability", () => {
         "message": "Invalid emoji",
         "origin": "string",
         "path": [],
-        "pattern": "/^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$/u",
+        "pattern": "/^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$/u",
       },
       {
         "code": "custom",
@@ -318,7 +318,7 @@ test("continuability", () => {
         "message": "Invalid ULID",
         "origin": "string",
         "path": [],
-        "pattern": "/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/",
+        "pattern": "/^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/",
       },
       {
         "code": "custom",

package/node_modules/zod/src/v4/classic/tests/credit-card.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "vitest";
+import * as z from "zod";
+
+describe("z.creditCard", () => {
+  // Luhn-valid PANs. The last four are the schemes an issuer allowlist would turn away — validation is shape plus Luhn only, so the BIN is never consulted.
+  const valid: [string, string][] = [
+    ["Visa", "4111111111111111"],
+    ["Visa (13)", "4007000000027"],
+    ["Mastercard", "5555555555554444"],
+    ["AmEx", "378282246310005"],
+    ["Discover", "6011111111111117"],
+    ["JCB", "3530111333300000"],
+    ["Diners Club", "30569309025904"],
+    ["UnionPay", "6200000000000005"],
+    ["Mir", "2200000000000004"],
+    ["Elo", "6362000000000009"],
+    ["Discover 644-649", "6450000000000002"],
+    ["Troy", "9792000000000003"],
+  ];
+
+  test.each(valid)("accepts %s", (_label, n) => {
+    expect(z.creditCard().parse(n)).toBe(n);
+  });
+
+  test("accepts single space or hyphen separators", () => {
+    expect(z.creditCard().parse("4111 1111 1111 1111")).toBe("4111 1111 1111 1111");
+    expect(z.creditCard().parse("4111-1111-1111-1111")).toBe("4111-1111-1111-1111");
+  });
+
+  test("rejects other separator shapes", () => {
+    for (const n of ["4111  1111 1111 1111", " 4111111111111111", "4111111111111111 ", "4111.1111.1111.1111"]) {
+      expect(() => z.creditCard().parse(n)).toThrow();
+    }
+  });
+
+  test("accepts the 12- and 19-digit length bounds", () => {
+    expect(z.creditCard().parse("400000000002")).toBe("400000000002");
+    expect(z.creditCard().parse("6250000000000000005")).toBe("6250000000000000005");
+  });
+
+  test("rejects Luhn-valid input outside 12-19 digits", () => {
+    expect(() => z.creditCard().parse("40000000006")).toThrow();
+    expect(() => z.creditCard().parse("40000000000000000002")).toThrow();
+  });
+
+  test("rejects when Luhn fails (right shape, wrong checksum)", () => {
+    expect(() => z.creditCard().parse("4111111111111112")).toThrow();
+  });
+
+  test("rejects non-digit input", () => {
+    expect(() => z.creditCard().parse("not-a-card")).toThrow();
+    expect(() => z.creditCard().parse("")).toThrow();
+  });
+
+  test("carries the shape regex as its JSON Schema pattern", () => {
+    // Luhn is not expressible as a pattern, so `pattern` covers length and separators only.
+    expect(z.toJSONSchema(z.creditCard())).toMatchObject({
+      format: "credit_card",
+      pattern: z.regexes.creditCard.source,
+    });
+  });
+
+  test("round-trips through JSON Schema with the checksum intact", () => {
+    const schema = z.fromJSONSchema(z.toJSONSchema(z.creditCard()));
+    expect(schema.safeParse("4111111111111111").success).toBe(true);
+    expect(schema.safeParse("4111111111111112").success).toBe(false);
+  });
+
+  test("error message references credit card", () => {
+    const result = z.creditCard().safeParse("not-a-card");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toMatch(/credit card/i);
+    }
+  });
+});