zod 4.6.2 → 4.6.4

package/README.md

@@ -155,13 +155,13 @@ try {
         expected: 'string',
         code: 'invalid_type',
         path: [ 'username' ],
-        message: 'Invalid input: expected string'
+        message: 'Invalid input: expected string, received number'
       },
       {
         expected: 'number',
         code: 'invalid_type',
         path: [ 'xp' ],
-        message: 'Invalid input: expected number'
+        message: 'Invalid input: expected number, received string'
       }
     ] */
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.6.2",
+  "version": "4.6.4",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/checks.ts

@@ -21,6 +21,7 @@ export {
   _startsWith as startsWith,
   _endsWith as endsWith,
   _property as property,
+  _properties as properties,
   _mime as mime,
   _overwrite as overwrite,
   _normalize as normalize,

package/src/v4/classic/schemas.ts

@@ -2,6 +2,7 @@ import type { $ZodBigIntFormats } from "../core/checks.js";
 import * as core from "../core/index.js";
 import { util, type $ZodNumberFormats } from "../core/index.js";
 import * as processors from "../core/json-schema-processors.js";
+import * as regexes from "../core/regexes.js";
 import type { StandardSchemaWithJSONProps } from "../core/standard-schema.js";
 import { createStandardJSONSchemaMethod, createToJSONSchemaMethod } from "../core/to-json-schema.js";
 import en from "../locales/en.js";
@@ -770,8 +771,8 @@ export function url(params?: string | core.$ZodURLParams): ZodURL {
 
 export function httpUrl(params?: string | Omit<core.$ZodURLParams, "protocol" | "hostname">): ZodURL {
   return core._url(ZodURL, {
-    protocol: core.regexes.httpProtocol,
-    hostname: core.regexes.domain,
+    protocol: regexes.httpProtocol,
+    hostname: regexes.domain,
     ...util.normalizeParams(params),
   });
 }
@@ -1081,11 +1082,15 @@ export function stringFormat<Format extends string>(
 }
 
 export function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname"> {
-  return core._stringFormat(ZodCustomStringFormat, "hostname", core.regexes.hostname, _params) as any;
+  return core._stringFormat(ZodCustomStringFormat, "hostname", regexes.hostname, _params) as any;
 }
 
 export function hex(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hex"> {
-  return core._stringFormat(ZodCustomStringFormat, "hex", core.regexes.hex, _params) as any;
+  return core._stringFormat(ZodCustomStringFormat, "hex", regexes.hex, _params) as any;
+}
+
+export function currencyCode(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"currency_code"> {
+  return core._stringFormat(ZodCustomStringFormat, "currency_code", regexes.currencyCode, _params) as any;
 }
 
 export function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(
@@ -2791,28 +2796,6 @@ export const ZodCustom: core.$constructor<ZodCustom> = /*@__PURE__*/ core.$const
   inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
 });
 
-// ZodProperties
-export interface ZodProperties<Shape extends core.$ZodShape = core.$ZodShape>
-  extends _ZodType<core.$ZodPropertiesInternals<Shape>>,
-    core.$ZodProperties<Shape> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-}
-export const ZodProperties: core.$constructor<ZodProperties> = /*@__PURE__*/ core.$constructor(
-  "ZodProperties",
-  (inst, def) => {
-    _ensureDefaultMemoizer();
-    core.$ZodProperties.init(inst, def);
-    ZodType.init(inst, def);
-  }
-);
-
-export function properties<Shape extends core.$ZodShape>(
-  shape: Shape,
-  params?: string | core.$ZodPropertiesParams
-): ZodProperties<Shape> {
-  return core._properties(ZodProperties, shape, params) as any;
-}
-
 // custom checks
 export function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O> {
   const ch = new core.$ZodCheck({
@@ -2860,7 +2843,7 @@ type ZodInstanceOfParams = core.Params<
 export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
   properties<Shape extends core.$ZodShape>(
     shape: Shape,
-    params?: string | core.$ZodPropertiesParams
+    params?: string | core.$ZodCheckPropertiesParams
   ): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
 }
 export const ZodInstanceOf: core.$constructor<ZodInstanceOf> = /*@__PURE__*/ core.$constructor(
@@ -2869,9 +2852,9 @@ export const ZodInstanceOf: core.$constructor<ZodInstanceOf> = /*@__PURE__*/ cor
     ZodCustom.init(inst, def);
   },
   {
-    properties(shape: core.$ZodShape, params?: string | core.$ZodPropertiesParams) {
+    properties(shape: core.$ZodShape, params?: string | core.$ZodCheckPropertiesParams) {
       // asserts in place, so the narrowed output type is truthful without a wrapper
-      return this.check(properties(shape, params)) as any;
+      return this.check(core._properties(shape, params)) as any;
     },
   }
 );

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

@@ -352,6 +352,7 @@ test("checks", () => {
   const _b: z.core.$ZodCheck = {} as any as z.core.$ZodStringFormatChecks;
   const _c: z.core.$ZodType = {} as any as z.core.$ZodTypes;
   const _d: z.core.$ZodType = {} as any as z.core.$ZodStringFormatTypes;
+  z.currencyCode() satisfies z.core.$ZodStringFormatTypes;
 });
 
 test("assignability to $ZodType", () => {

package/src/v4/classic/tests/cyclic-data.test.ts

@@ -924,17 +924,8 @@ test("a deferred edge stops being assumed a cycle once the graph resolves", () =
   expect(z.core.isRecursiveSchema(Cyclic)).toBe(true);
 });
 
-// `z.object` resolves its shape by spread, so a non-enumerable key is no part of it; `z.properties` reads every own key, so one there is still parsed and can still close a cycle
-test("a non-enumerable key counts for z.properties and not for z.object", () => {
-  const props = (enumerable: boolean) => {
-    const shape: Record<string, any> = { id: z.number() };
-    const P = z.properties(shape);
-    Object.defineProperty(shape, "next", { value: z.lazy(() => z.optional(P)), enumerable, configurable: true });
-    return P;
-  };
-  expect(z.core.isRecursiveSchema(props(true) as any)).toBe(true);
-  expect(z.core.isRecursiveSchema(props(false) as any)).toBe(true);
-
+// `z.object` resolves its shape by spread, so a non-enumerable key is no part of it
+test("a non-enumerable key does not count for z.object", () => {
   const object = (enumerable: boolean) => {
     const shape: Record<string, any> = { id: z.number() };
     const O: any = z.object(shape);

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

@@ -80,8 +80,6 @@ test("first party switch", () => {
       break;
     case "file":
       break;
-    case "properties":
-      break;
     case "lazy":
       break;
     case "function":
@@ -172,8 +170,6 @@ test("$ZodSchemaTypes", () => {
       break;
     case "lazy":
       break;
-    case "properties":
-      break;
     case "function":
       break;
 

package/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();

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

@@ -90,7 +90,7 @@ test("z.properties", () => {
     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: the schema-as-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.
+  // 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

package/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);

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

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

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

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -12,6 +12,63 @@ const includesFromIndex2 = z.string().includes("includes", { position: 2 });
 const startsWith = z.string().startsWith("startsWith");
 const endsWith = z.string().endsWith("endsWith");
 
+test("string factory checks", async () => {
+  const schema = z.string({ checks: [z.minLength(1), z.maxLength(3)] as const });
+  const chained = z.string().min(1).max(3);
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<string>();
+  for (const value of ["", "ab", "abcd", 1, 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.minLength).toBe(1);
+  expect(schema.maxLength).toBe(3);
+  expect(schema._zod.parent).toBeUndefined();
+  expect([...schema._zod.traits]).toEqual([...chained._zod.traits]);
+  const extended = schema.max(2);
+  expect(extended._zod.parent).toBe(schema);
+  expect(z.validate(schema, "abc")).toBe(true);
+  expect(z.validate(extended, "abc")).toBe(false);
+  const coerce = z.coerce.string({ checks: [z.minLength(2)] });
+  expect(coerce.parse(12)).toBe("12");
+  expect(z.validate(coerce, 1)).toBe(false);
+  const asyncSchema = z.string({
+    checks: [
+      z.check<string>(async (ctx) => {
+        if (ctx.value !== "ok") ctx.issues.push({ code: "custom", input: ctx.value });
+      }),
+    ],
+  });
+  expect(await asyncSchema.safeParseAsync("ok")).toEqual({ success: true, data: "ok" });
+  expect((await asyncSchema.safeParseAsync("bad")).success).toBe(false);
+  // @ts-expect-error numeric checks cannot validate strings
+  z.string({ checks: [z.gte(1)] });
+});
+
+test("factory checks snapshot caller arrays", () => {
+  for (const factory of [z.string, z.coerce.string]) {
+    for (const initial of [[], [z.minLength(1)]]) {
+      const schema = factory({ checks: initial });
+      let reads = 0;
+      const getterSchema = factory({
+        get checks() {
+          if (++reads > 1) throw new Error("checks read twice");
+          return initial;
+        },
+      });
+      expect(reads).toBe(1);
+      expect(z.validate(getterSchema, "long")).toBe(true);
+      const before = z.toJSONSchema(schema);
+      initial.push(z.minLength(10));
+      expect(schema._zod.def.checks).not.toBe(initial);
+      expect(z.validate(schema, "long")).toBe(true);
+      expect(z.validate(z.compile(schema), "long")).toBe(true);
+      expect(z.toJSONSchema(schema)).toEqual(before);
+      expect(z.validate(schema.check(z.minLength(2)), "long")).toBe(true);
+    }
+  }
+});
+
 test("length checks", () => {
   minFive.parse("12345");
   minFive.parse("123456");
@@ -1289,6 +1346,18 @@ test("hostname", () => {
   expect(() => hostname.parse("example..com")).toThrow();
 });
 
+test("currency code", () => {
+  const currency = z.currencyCode();
+  for (const code of ["USD", "EUR", "XXX", "XCG", "XAD"]) expect(currency.parse(code)).toBe(code);
+  for (const input of ["", "usd", "US", "USDX", " USD", "ANG", "BGN"])
+    expect(currency.safeParse(input).success).toBe(false);
+  expect(currency.safeParse("usd").error!.issues[0]).toMatchObject({
+    code: "invalid_format",
+    format: "currency_code",
+    message: "Invalid currency code",
+  });
+});
+
 test("hash validation", () => {
   // MD5 tests
   const md5hex = z.hash("md5");