@psnext/slingcli 3.1.20260904-1 → 3.3.20260914-1

package/node_modules/zod/src/v4/classic/tests/from-json-schema.test.ts

@@ -1308,3 +1308,160 @@ test("__proto__ annotation key reaches the registry", () => {
   expect(Object.prototype.hasOwnProperty.call(meta, "__proto__")).toBe(true);
   expect(meta.__proto__).toEqual({ custom: 1 });
 });
+
+test("minProperties and maxProperties count the raw input", () => {
+  const schema = fromJSONSchema({
+    type: "object",
+    properties: { a: { type: "string" } },
+    minProperties: 1,
+    maxProperties: 2,
+  });
+  expect(schema.safeParse({ a: "x" }).success).toBe(true);
+  expect(schema.safeParse({}).error!.issues[0]).toMatchObject({ code: "too_small", origin: "object", minimum: 1 });
+  expect(schema.safeParse({ a: "x", b: 1, c: 2 }).error!.issues[0]).toMatchObject({
+    code: "too_big",
+    origin: "object",
+    maximum: 2,
+  });
+  // raw input: a defaulted property does not satisfy the minimum, and a dropped __proto__ still counts
+  const defaulted = fromJSONSchema({
+    type: "object",
+    properties: { a: { type: "string", default: "x" } },
+    minProperties: 1,
+  });
+  expect(defaulted.safeParse({}).success).toBe(false);
+  const capped = fromJSONSchema({ type: "object", maxProperties: 1 });
+  expect(capped.safeParse(JSON.parse('{"__proto__":1,"a":1}')).success).toBe(false);
+  expect(z.toJSONSchema(schema)).toMatchObject({ minProperties: 1, maxProperties: 2 });
+});
+
+test("minProperties composes with propertyNames in one guard", () => {
+  const schema = fromJSONSchema({ type: "object", propertyNames: { pattern: "^a" }, minProperties: 1 });
+  expect(schema.safeParse({}).error!.issues[0]!.code).toBe("too_small");
+  expect(schema.safeParse({ b: 1 }).error!.issues[0]!.code).toBe("invalid_key");
+  expect(schema.safeParse({ a: 1 }).success).toBe(true);
+});
+
+test("uniqueItems rejects structural duplicates", () => {
+  const schema = fromJSONSchema({ type: "array", uniqueItems: true });
+  expect(
+    schema.safeParse([
+      { a: 1, b: 2 },
+      { b: 2, a: 1 },
+    ]).error!.issues[0]
+  ).toMatchObject({
+    code: "custom",
+    path: [1],
+  });
+  expect(schema.safeParse([1, "1", true, 1]).success).toBe(false);
+  expect(schema.safeParse([{ a: 1 }, { a: 2 }, [1], [2]]).success).toBe(true);
+  expect(z.toJSONSchema(schema)).toMatchObject({ uniqueItems: true });
+});
+
+test("contains with minContains and maxContains", () => {
+  const schema = fromJSONSchema({ type: "array", contains: { type: "integer" } });
+  expect(schema.safeParse(["a"]).success).toBe(false);
+  expect(schema.safeParse(["a", 1]).success).toBe(true);
+  const bounded = fromJSONSchema({ type: "array", contains: { type: "integer" }, minContains: 2, maxContains: 3 });
+  expect(bounded.safeParse([1, "a"]).success).toBe(false);
+  expect(bounded.safeParse([1, 2, "a"]).success).toBe(true);
+  expect(bounded.safeParse([1, 2, 3, 4]).success).toBe(false);
+  // minContains: 0 accepts an array with no matches at all
+  expect(fromJSONSchema({ type: "array", contains: { type: "integer" }, minContains: 0 }).safeParse([]).success).toBe(
+    true
+  );
+  expect(z.toJSONSchema(bounded)).toMatchObject({ contains: { type: "integer" }, minContains: 2, maxContains: 3 });
+});
+
+test("uniqueItems and contains see the raw instance, not the parsed output", () => {
+  const items = { type: "object", properties: { a: { type: "string", default: "x" } } } as const;
+  // no instance item carries `a`; the default must not synthesize the match
+  const contains = fromJSONSchema({
+    type: "array",
+    items,
+    contains: { type: "object", properties: { a: { const: "x" } }, required: ["a"] },
+  });
+  expect(contains.safeParse([{}]).success).toBe(false);
+  expect(contains.safeParse([{ a: "x" }]).success).toBe(true);
+  // the instance items differ; the default must not collapse them into duplicates
+  const unique = fromJSONSchema({ type: "array", items, uniqueItems: true });
+  expect(unique.safeParse([{ a: "x" }, {}]).success).toBe(true);
+  expect(unique.safeParse([{}, {}]).error!.issues[0]).toMatchObject({ code: "custom", path: [1] });
+});
+
+test("a guard keyword takes precedence over the length keywords", () => {
+  const schema = fromJSONSchema({ type: "array", items: { type: "integer" }, minItems: 3, uniqueItems: true });
+  // the guard runs on the input side of the pipe, so its issue aborts before minItems is reached
+  expect(schema.safeParse([1, 1]).error!.issues.map((i) => i.code)).toEqual(["custom"]);
+  expect(schema.safeParse([1, 2]).error!.issues.map((i) => i.code)).toEqual(["too_small"]);
+});
+
+test("a guard keyword drops default and examples from the input-mode document", () => {
+  // the guard is a transform on the pipe's input side, and toJSONSchema strips annotations from a transforming schema in input mode
+  const schema = fromJSONSchema({ type: "array", uniqueItems: true, default: [], examples: [[1]] });
+  expect(z.toJSONSchema(schema, { io: "input" })).not.toHaveProperty("default");
+  expect(z.toJSONSchema(schema, { io: "output" })).toMatchObject({ default: [], examples: [[1]] });
+  // without a guard keyword both modes carry them
+  const plain = fromJSONSchema({ type: "array", default: [], examples: [[1]] });
+  expect(z.toJSONSchema(plain, { io: "input" })).toMatchObject({ default: [], examples: [[1]] });
+});
+
+test("uniqueItems equality follows JSON semantics", () => {
+  const schema = fromJSONSchema({ type: "array", uniqueItems: true });
+  expect(schema.safeParse([1, "1", true, null]).success).toBe(true);
+  expect(schema.safeParse([{ a: undefined }, {}]).success).toBe(true);
+  expect(
+    schema.safeParse([
+      [1, [2]],
+      [1, [2]],
+    ]).success
+  ).toBe(false);
+  expect(schema.safeParse([{ a: "b=c" }, { "a=b": "c" }]).success).toBe(true);
+  // every duplicate is reported against the first element it matches
+  expect(schema.safeParse([1, 1, 1]).error!.issues.map((i) => i.path[0])).toEqual([1, 2]);
+  // a cycle cannot be compared, so it is never called a duplicate rather than hanging
+  const cyclic: any = {};
+  cyclic.self = cyclic;
+  expect(schema.safeParse([cyclic, cyclic]).success).toBe(true);
+});
+
+test("a carried subschema that references $defs is dropped rather than emitted dangling", () => {
+  const schema = fromJSONSchema({
+    type: "array",
+    contains: { $ref: "#/$defs/Hit" },
+    $defs: { Hit: { type: "object", properties: { id: { type: "string" } }, required: ["id"] } },
+  });
+  // enforcement is unaffected; only the round trip gives the keyword up
+  expect(schema.safeParse([{ id: "a" }]).success).toBe(true);
+  expect(schema.safeParse([{}]).success).toBe(false);
+  expect(JSON.stringify(z.toJSONSchema(schema))).not.toContain("$ref");
+  expect(z.toJSONSchema(schema)).not.toHaveProperty("contains");
+  // an inline subschema is self-contained, so it still round-trips
+  const inline = fromJSONSchema({ type: "array", contains: { type: "integer" } });
+  expect(z.toJSONSchema(inline)).toMatchObject({ contains: { type: "integer" } });
+  // only schema positions are walked, so a `$ref` key in instance data or an unknown annotation still travels
+  for (const annotation of [{ default: { $ref: "literal" } }, { "x-note": { $ref: "literal" } }]) {
+    const annotated = fromJSONSchema({ type: "array", contains: { type: "integer", ...annotation } });
+    expect(annotated.safeParse(["x"]).success).toBe(false);
+    expect(z.toJSONSchema(annotated)).toMatchObject({ contains: { type: "integer" } });
+  }
+  // draft-7 `dependencies` is a schema map; its array form names properties and holds no reference
+  const dependent = fromJSONSchema({
+    type: "array",
+    contains: { type: "object", dependencies: { a: { $ref: "#/definitions/Hit" } } },
+    definitions: { Hit: { type: "object" } },
+  });
+  expect(z.toJSONSchema(dependent)).not.toHaveProperty("contains");
+  const named = fromJSONSchema({
+    type: "array",
+    contains: { type: "object", dependencies: { a: ["b"] } },
+  });
+  expect(z.toJSONSchema(named)).toMatchObject({ contains: { dependencies: { a: ["b"] } } });
+  // a reference nested in a schema position is still caught
+  const nested = fromJSONSchema({
+    type: "array",
+    contains: { type: "array", items: { $ref: "#/$defs/Hit" } },
+    $defs: { Hit: { type: "string" } },
+  });
+  expect(z.toJSONSchema(nested)).not.toHaveProperty("contains");
+});

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

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "vitest";
+import * as z from "zod";
+
+describe("z.iban", () => {
+  const valid: [string, string][] = [
+    ["Norway (15, minimum)", "NO9386011117947"],
+    ["Belgium (16)", "BE68539007547034"],
+    ["Netherlands (18)", "NL91ABNA0417164300"],
+    ["Germany (22)", "DE89370400440532013000"],
+    ["Great Britain (22)", "GB29NWBK60161331926819"],
+    ["Turkey (26)", "TR610000100000000000000001"],
+    ["France (27)", "FR1420041010050500013M02606"],
+    ["Cyprus (28)", "CY17002001280000001200527600"],
+    ["Malta (31)", "MT84MALT011000012345MTLCAST001S"],
+    ["Maximum length (34)", "AA73AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"],
+    ["Maximum length mixed (34)", "ZZ560123456789ABCDEFGHIJKLMNOPQRST"],
+  ];
+
+  test.each(valid)("accepts %s", (_label, n) => {
+    expect(z.iban().parse(n)).toBe(n);
+  });
+
+  test("rejects lowercase characters", () => {
+    expect(() => z.iban().parse("no9386011117947")).toThrow();
+    expect(() => z.iban().parse("de89370400440532013000")).toThrow();
+    expect(() => z.iban().parse("FR1420041010050500013m02606")).toThrow();
+  });
+
+  test("rejects spaces and hyphens", () => {
+    expect(() => z.iban().parse("NO93 8601 1117 947")).toThrow();
+    expect(() => z.iban().parse(" DE89370400440532013000")).toThrow();
+    expect(() => z.iban().parse("DE89370400440532013000 ")).toThrow();
+    expect(() => z.iban().parse("NO93-8601-1117-947")).toThrow();
+    expect(() => z.iban().parse("DE89-3704-0044-0532-0130-00")).toThrow();
+  });
+
+  test("rejects special characters", () => {
+    expect(() => z.iban().parse("NO938601111794!")).toThrow();
+    expect(() => z.iban().parse("DE8937040044053201300@")).toThrow();
+    expect(() => z.iban().parse("")).toThrow();
+  });
+
+  test("rejects inputs outside length bounds (15-34)", () => {
+    expect(() => z.iban().parse("NO938601111794")).toThrow();
+    expect(() => z.iban().parse("AA73AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")).toThrow();
+  });
+
+  test("rejects invalid check digits (checksum failure)", () => {
+    expect(() => z.iban().parse("NO9386011117948")).toThrow();
+    expect(() => z.iban().parse("DE89370400440532013001")).toThrow();
+    expect(() => z.iban().parse("FR1420041010050500013M02607")).toThrow();
+  });
+
+  test("rejects check digits outside 02-98", () => {
+    // mod 97 alone accepts all three; `98 - remainder` can only ever emit 02-98
+    expect(() => z.iban().parse("DE00000000000000000066")).toThrow();
+    expect(() => z.iban().parse("DE01000000000000000048")).toThrow();
+    expect(() => z.iban().parse("DE99000000000000000030")).toThrow();
+  });
+
+  test("carries the shape regex as its JSON Schema pattern", () => {
+    expect(z.toJSONSchema(z.iban())).toMatchObject({
+      format: "iban",
+      pattern: z.regexes.iban.source,
+    });
+  });
+
+  test("round-trips through JSON Schema with the checksum intact", () => {
+    const schema = z.fromJSONSchema(z.toJSONSchema(z.iban()));
+    expect(schema.safeParse("DE89370400440532013000").success).toBe(true);
+    expect(schema.safeParse("DE89370400440532013001").success).toBe(false);
+  });
+
+  test("error message references IBAN", () => {
+    const result = z.iban().safeParse("not-an-iban");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toMatch(/IBAN/i);
+    }
+  });
+});

package/node_modules/zod/src/v4/classic/tests/instance-footprint.test.ts

@@ -105,6 +105,28 @@ test("deferred initializers are released after construction", () => {
   expect(z.object({ a: z.string() })._zod.deferred).toEqual(undefined);
 });
 
+test("trait initializers run once per instance across repeated entry", () => {
+  const calls: string[] = [];
+  const Base: core.$constructor<any> = core.$constructor<any>("CountedBase", () => calls.push("base"));
+  const Child: core.$constructor<any> = core.$constructor<any>("CountedChild", (inst, def) => {
+    calls.push("child");
+    Base.init(inst, def);
+    Base.init(inst, def);
+  });
+  const constructed = new Child({});
+  Child.init(constructed, {});
+  const direct = Object.create({});
+  Child.init(direct, {});
+  Child.init(direct, {});
+  expect(calls).toEqual(["child", "base", "child", "base"]);
+  for (const inst of [constructed, direct]) {
+    expect([...inst._zod.traits]).toEqual(["CountedChild", "CountedBase"]);
+    expect(inst instanceof Base).toBe(true);
+    expect(inst instanceof Child).toBe(true);
+  }
+  expect(constructed._zod.traits).not.toBe(direct._zod.traits);
+});
+
 test("a trait initializer called directly still installs its members", () => {
   // a direct `init` installs onto the receiver's own prototype, since it is not below the constructor's
   z.string();
@@ -152,10 +174,16 @@ test("a live member keeps the descriptor a prototype member had", () => {
   const proto = Object.getPrototypeOf(z.string());
   expect(Object.getOwnPropertyDescriptor(proto, "description")?.enumerable).toBe(false);
   expect(Object.getOwnPropertyDescriptor(proto, "_def")?.enumerable).toBe(false);
+  // a derived member installs like a literal's accessor: not enumerable, still configurable
+  expect(Object.getOwnPropertyDescriptor(proto, "minLength")).toMatchObject({ enumerable: false, configurable: true });
 
+  // the derived metadata members live on the prototype and shadow as own data on first read
+  const schema = z.string();
   const keys: string[] = [];
-  for (const k in z.string()) keys.push(k);
-  expect(keys).toEqual(["def", "type", "format", "minLength", "maxLength"]);
+  for (const k in schema) keys.push(k);
+  expect(keys).toEqual(["def", "type"]);
+  expect(schema.minLength).toBe(null);
+  expect(Object.keys(schema)).toContain("minLength");
 });
 
 test("a live member is not cached per instance", () => {
@@ -221,6 +249,16 @@ test("a hand-written getter member accepts assignment", () => {
   const mini: any = zm.string();
   mini.with = () => "WITH";
   expect(mini.with()).toBe("WITH");
+
+  // a derived metadata member accepts assignment before its first read, as it did as an own property
+  const derived = z.number().min(2);
+  derived.minValue = 99;
+  expect(derived.minValue).toBe(99);
+  expect(Object.keys(derived)).toContain("minValue");
+
+  // and, like every prototype member, recomputes after deletion rather than staying absent
+  delete (derived as any).minValue;
+  expect(derived.minValue).toBe(2);
 });
 
 test("shape is lazy and stays out of Object.keys", () => {

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

@@ -62,7 +62,7 @@ test("instanceof respects customError", () => {
 test("z.properties", () => {
   const httpsUrl = z.instanceof(URL).check(
     ...z.properties({
-      protocol: z.literal("https:" as string),
+      protocol: z.literal("https:"),
       hostname: z.string().regex(z.regexes.domain),
     })
   );
@@ -70,9 +70,9 @@ test("z.properties", () => {
   expectTypeOf<URL>().toEqualTypeOf<z.infer<typeof httpsUrl>>();
   expect(httpsUrl.safeParse(new URL("https://example.com")).success).toBe(true);
 
-  // Checks abort on the first failure, exactly as the equivalent chain of z.property() calls does.
+  // One check iterates the whole shape, so every failing property reports — unlike the equivalent chain of z.property() calls, which aborts on the first.
   const both = httpsUrl.safeParse(new URL("http://localhost"));
-  expect(both.error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
+  expect(both.error!.issues.map((i) => i.path)).toEqual([["protocol"], ["hostname"]]);
 
   // A failing base schema yields its own issue and no property issues.
   for (const input of ["not a url", null]) {
@@ -85,12 +85,12 @@ test("z.properties", () => {
     .object({ a: z.string(), b: z.string() })
     .check(...z.properties({ a: z.literal("x"), b: z.literal("y") }));
   expect(obj.safeParse({ a: "x", b: "y" }).success).toBe(true);
-  expect(obj.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"]]);
+  expect(obj.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
   for (const input of [null, undefined, 5]) {
     expect(obj.safeParse(input).error!.issues.map((i) => [i.code, i.path])).toEqual([["invalid_type", []]]);
   }
 
-  // Known looseness versus the longhand, pinned so it stays deliberate: every element is typed over the whole shape, and `$ZodCheckInternals.check()` is a method, so TypeScript compares it bivariantly and accepts a check type that is a subtype of the target. Naming a key the target lacks therefore compiles here and fails at parse time, where the equivalent chain of `z.property()` calls rejects it outright. Typing each element over only its own key fixes that and breaks every valid call, since a union argument must satisfy the target on its own.
+  // Known looseness versus the longhand, pinned so it stays deliberate: the check is typed over the whole shape, and `$ZodCheckInternals.check()` is a method, so TypeScript compares it bivariantly and accepts a check type that is a subtype of the target. Naming a key the target lacks therefore compiles here and fails at parse time, where the equivalent chain of `z.property()` calls rejects it outright.
   z.object({ a: z.string() }).check(...z.properties({ a: z.literal("x"), b: z.literal("y") }));
   expect(
     z
@@ -100,8 +100,28 @@ test("z.properties", () => {
       .error!.issues.map((i) => [i.code, i.path])
   ).toEqual([["invalid_value", ["b"]]]);
 
-  // Plain property checks carry no `when`, so the schema stays on the compiled fast path.
+  // literal and enum inputs widen to their primitive, so a `string`/`boolean` property accepts them without a cast, while a genuine type mismatch or an unknown key still fails to compile
+  z.instanceof(URL).check(z.property("protocol", z.literal("https:")));
+  z.instanceof(Request).check(...z.properties({ method: z.enum(["POST", "PUT"]), bodyUsed: z.literal(false) }));
+  // @ts-expect-error length is a number
+  z.string().check(z.property("length", z.string()));
+  // @ts-expect-error no such key
+  z.instanceof(URL).check(z.property("nope", z.string()));
+
+  // the check feeds the property value into its schema, so it is typed over the input side rather than the output
+  const stringToLength = z.property(
+    "a",
+    z.string().transform((s) => s.length)
+  );
+  z.object({ a: z.string() }).check(stringToLength);
+  // @ts-expect-error a is a number, the schema takes a string
+  z.object({ a: z.number() }).check(stringToLength);
+
+  // The properties check carries no `when`, so the schema stays on the compiled fast path.
   const compiled = z.compile(httpsUrl);
   expect(compiled.safeParse(new URL("https://example.com")).success).toBe(true);
-  expect(compiled.safeParse(new URL("http://localhost")).error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
+  expect(compiled.safeParse(new URL("http://localhost")).error!.issues.map((i) => i.path)).toEqual([
+    ["protocol"],
+    ["hostname"],
+  ]);
 });

package/node_modules/zod/src/v4/classic/tests/issue-schema.test.ts

@@ -5,6 +5,9 @@ afterEach(() => {
   z.config({ customError: undefined });
 });
 
+/** Error maps run on the first read of `error`, so a test that only observes them reads it. */
+const fail = (r: { error?: unknown }) => r.error;
+
 /** Collects the owning schema's registered metadata for every issue an error map sees. */
 function captureMeta(): { seen: (z.core.GlobalMeta | undefined)[] } {
   const seen: (z.core.GlobalMeta | undefined)[] = [];
@@ -20,11 +23,11 @@ function captureMeta(): { seen: (z.core.GlobalMeta | undefined)[] } {
 test("check-originated issues expose the owning schema", () => {
   const { seen } = captureMeta();
 
-  z.object({ name: z.string().min(5).meta({ title: "Name" }) }).safeParse({ name: "ab" });
-  z.string().max(2).meta({ title: "Max" }).safeParse("abc");
-  z.email().meta({ title: "Email" }).safeParse("nope");
-  z.number().multipleOf(3).meta({ title: "Multiple" }).safeParse(4);
-  z.array(z.string()).min(2).meta({ title: "Array" }).safeParse([]);
+  fail(z.object({ name: z.string().min(5).meta({ title: "Name" }) }).safeParse({ name: "ab" }));
+  fail(z.string().max(2).meta({ title: "Max" }).safeParse("abc"));
+  fail(z.email().meta({ title: "Email" }).safeParse("nope"));
+  fail(z.number().multipleOf(3).meta({ title: "Multiple" }).safeParse(4));
+  fail(z.array(z.string()).min(2).meta({ title: "Array" }).safeParse([]));
 
   expect(seen).toEqual([
     { title: "Name" },
@@ -38,8 +41,8 @@ test("check-originated issues expose the owning schema", () => {
 test("schema-originated issues expose the owning schema", () => {
   const { seen } = captureMeta();
 
-  z.object({ name: z.string().min(5).meta({ title: "Name" }) }).safeParse({ name: 123 });
-  z.email().meta({ title: "Email" }).safeParse(123);
+  fail(z.object({ name: z.string().min(5).meta({ title: "Name" }) }).safeParse({ name: 123 }));
+  fail(z.email().meta({ title: "Email" }).safeParse(123));
 
   expect(seen).toEqual([{ title: "Name" }, { title: "Email" }]);
 });
@@ -47,14 +50,20 @@ test("schema-originated issues expose the owning schema", () => {
 test("refinements attribute to the refined schema, not the internal check schema", () => {
   const { seen } = captureMeta();
 
-  z.string()
-    .refine(() => false)
-    .meta({ title: "Refine" })
-    .safeParse("abc");
-  z.string()
-    .superRefine((_, ctx) => ctx.addIssue({ code: "custom", message: "" }))
-    .meta({ title: "SuperRefine" })
-    .safeParse("abc");
+  fail(
+    z
+      .string()
+      .refine(() => false)
+      .meta({ title: "Refine" })
+      .safeParse("abc")
+  );
+  fail(
+    z
+      .string()
+      .superRefine((_, ctx) => ctx.addIssue({ code: "custom", message: "" }))
+      .meta({ title: "SuperRefine" })
+      .safeParse("abc")
+  );
 
   expect(seen).toEqual([{ title: "Refine" }, { title: "SuperRefine" }]);
 });
@@ -62,17 +71,26 @@ test("refinements attribute to the refined schema, not the internal check schema
 test("the innermost schema owns the issue", () => {
   const { seen } = captureMeta();
 
-  z.array(z.string().min(5).meta({ title: "Element" }))
-    .meta({ title: "Array" })
-    .safeParse(["ab"]);
-  z.string()
-    .pipe(z.string().min(5).meta({ title: "Target" }))
-    .meta({ title: "Pipe" })
-    .safeParse("ab");
-  z.looseObject({})
-    .check(z.property("a", z.string().meta({ title: "Property" })))
-    .meta({ title: "Object" })
-    .safeParse({ a: 1 });
+  fail(
+    z
+      .array(z.string().min(5).meta({ title: "Element" }))
+      .meta({ title: "Array" })
+      .safeParse(["ab"])
+  );
+  fail(
+    z
+      .string()
+      .pipe(z.string().min(5).meta({ title: "Target" }))
+      .meta({ title: "Pipe" })
+      .safeParse("ab")
+  );
+  fail(
+    z
+      .looseObject({})
+      .check(z.property("a", z.string().meta({ title: "Property" })))
+      .meta({ title: "Object" })
+      .safeParse({ a: 1 })
+  );
 
   expect(seen).toEqual([{ title: "Element" }, { title: "Target" }, { title: "Property" }]);
 });
@@ -81,12 +99,15 @@ test("issues carrying no usable `inst` still get the owning schema", () => {
   const { seen } = captureMeta();
 
   // A hand-pushed issue may carry no inst at all, and ctx.addIssue(string) puts the check's def — not a Zod object — on inst.
-  z.string()
-    .check((payload) => {
-      payload.issues.push({ code: "custom", input: payload.value });
-    })
-    .meta({ title: "Bare" })
-    .safeParse("abc");
+  fail(
+    z
+      .string()
+      .check((payload) => {
+        payload.issues.push({ code: "custom", input: payload.value });
+      })
+      .meta({ title: "Bare" })
+      .safeParse("abc")
+  );
   const shorthand = z
     .string()
     .superRefine((_, ctx) => ctx.addIssue("bad stuff"))
@@ -100,11 +121,13 @@ test("issues carrying no usable `inst` still get the owning schema", () => {
 test("async checks expose the owning schema", async () => {
   const { seen } = captureMeta();
 
-  await z
-    .string()
-    .refine(async () => false)
-    .meta({ title: "Async" })
-    .safeParseAsync("abc");
+  fail(
+    await z
+      .string()
+      .refine(async () => false)
+      .meta({ title: "Async" })
+      .safeParseAsync("abc")
+  );
 
   expect(seen).toEqual([{ title: "Async" }]);
 });
@@ -120,7 +143,7 @@ test("the owning schema is the clone `.meta()` registered, not the pre-metadata
     },
   });
 
-  labeled.safeParse("ab");
+  fail(labeled.safeParse("ab"));
 
   expect(seen).toEqual([true]);
 });
@@ -134,12 +157,12 @@ test("`inst` keeps its meaning and `schema` stays off the finalized issue", () =
     },
   });
 
-  const tooSmall = z.string().min(5).safeParse("ab");
-  const wrongType = z.string().safeParse(123);
+  const tooSmall = z.string().min(5).safeParse("ab").error!;
+  const wrongType = z.string().safeParse(123).error!;
 
   expect(insts).toEqual(["$ZodCheckMinLength", "ZodString"]);
-  expect(Object.keys(tooSmall.error!.issues[0])).not.toContain("schema");
-  expect(Object.keys(wrongType.error!.issues[0])).not.toContain("schema");
+  expect(Object.keys(tooSmall.issues[0])).not.toContain("schema");
+  expect(Object.keys(wrongType.issues[0])).not.toContain("schema");
 });
 
 test("every error map kind receives the owning schema", () => {
@@ -149,28 +172,37 @@ test("every error map kind receives the owning schema", () => {
     return undefined;
   };
 
-  z.string()
-    .min(5, { error: capture("check") })
-    .meta({ title: "Check" })
-    .safeParse("ab");
+  fail(
+    z
+      .string()
+      .min(5, { error: capture("check") })
+      .meta({ title: "Check" })
+      .safeParse("ab")
+  );
 
   // A schema-bound map is only consulted for issues the schema itself raised, so this one needs a type error.
-  z.string({ error: capture("schema") })
-    .meta({ title: "Schema" })
-    .safeParse(123);
-
-  z.string()
-    .min(5)
-    .meta({ title: "Parse" })
-    .safeParse("ab", { error: capture("parse") });
+  fail(
+    z
+      .string({ error: capture("schema") })
+      .meta({ title: "Schema" })
+      .safeParse(123)
+  );
+
+  fail(
+    z
+      .string()
+      .min(5)
+      .meta({ title: "Parse" })
+      .safeParse("ab", { error: capture("parse") })
+  );
 
   z.config({ customError: capture("customError") });
-  z.string().min(5).meta({ title: "Custom" }).safeParse("ab");
+  fail(z.string().min(5).meta({ title: "Custom" }).safeParse("ab"));
 
   // localeError carries the default English locale, so it is restored rather than cleared.
   const localeError = z.config().localeError;
   z.config({ customError: undefined, localeError: capture("localeError") });
-  z.string().min(5).meta({ title: "Locale" }).safeParse("ab");
+  fail(z.string().min(5).meta({ title: "Locale" }).safeParse("ab"));
   z.config({ localeError });
 
   expect(seen).toEqual({

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

@@ -2,6 +2,45 @@ import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
+test("number factory checks", () => {
+  const schema = z.number({ checks: [z.gte(1), z.lte(3)] as const });
+  const chained = z.number().min(1).max(3);
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<number>();
+  for (const value of [0, 1, 3, 4, Number.NaN, "2", undefined]) {
+    expect(z.validate(schema, value)).toBe(z.validate(chained, value));
+    expect(schema.safeParse(value)).toEqual(chained.safeParse(value));
+  }
+  expect(z.toJSONSchema(schema)).toEqual(z.toJSONSchema(chained));
+  expect(schema.minValue).toBe(1);
+  expect(schema.maxValue).toBe(3);
+  expect(z.coerce.number({ checks: [z.gte(1)] }).parse("2")).toBe(2);
+  const overwritten = z.number({ checks: [z.overwrite<number>((value) => value + 1), z.gte(2)] });
+  expect(overwritten.parse(1)).toBe(2);
+  expect(z.validate(overwritten, 0)).toBe(false);
+  // @ts-expect-error length checks cannot validate numbers
+  z.number({ checks: [z.minLength(1)] });
+});
+
+test("number factory checks snapshot caller arrays", () => {
+  for (const factory of [z.number, z.coerce.number]) {
+    const checks = [z.gte(1)];
+    const schema = factory({ checks });
+    let reads = 0;
+    factory({
+      get checks() {
+        if (++reads > 1) throw new Error("checks read twice");
+        return checks;
+      },
+    });
+    expect(reads).toBe(1);
+    const before = z.toJSONSchema(schema);
+    checks.push(z.gte(10));
+    expect(z.validate(schema, 3)).toBe(true);
+    expect(z.validate(z.compile(schema), 3)).toBe(true);
+    expect(z.toJSONSchema(schema)).toEqual(before);
+  }
+});
+
 test("z.number() basic validation", () => {
   const schema = z.number();
   expect(schema.parse(1234)).toEqual(1234);