zod 4.6.1 → 4.6.3

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.1",
+  "version": "4.6.3",
   "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

@@ -2791,28 +2791,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 +2838,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 +2847,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/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/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/prefault.test.ts

@@ -1,6 +1,76 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/v4";
 
+test.each([false, true])("undefined prefault preserves object keys (jitless: %s)", async (jitless) => {
+  const previous = z.config().jitless;
+  z.config({ jitless });
+  try {
+    let calls = 0;
+    const field = z.union([z.string(), z.undefined()]).prefault(() => {
+      calls++;
+      return undefined;
+    });
+    const schema = z.object({ a: field });
+    expectTypeOf<z.output<typeof field>>().toEqualTypeOf<string | undefined>();
+    expectTypeOf<z.input<typeof schema>>().toEqualTypeOf<{ a?: string | undefined }>();
+    expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: string | undefined }>();
+    expect(schema.parse({})).toStrictEqual({ a: undefined });
+    expect(calls).toBe(1);
+    expect(schema.parse({ a: undefined })).toStrictEqual({ a: undefined });
+    expect(calls).toBe(2);
+    expect(await schema.parseAsync({})).toStrictEqual({ a: undefined });
+    expect(calls).toBe(3);
+    expect(schema.parse({ a: "value" })).toStrictEqual({ a: "value" });
+    expect(schema.safeParse({ a: 123 }).success).toBe(false);
+    expect(calls).toBe(3);
+
+    const literal = z.prefault(z.string().optional(), undefined);
+    expect(z.core.compileFn(z.object({ a: literal }))({})).toStrictEqual({ a: undefined });
+    for (const wrapped of [literal, literal.readonly(), literal.nullable(), z.lazy(() => literal)]) {
+      expect(z.object({ a: wrapped }).parse({})).toStrictEqual({ a: undefined });
+    }
+    expect(z.object({ a: literal.optional() }).parse({})).toStrictEqual({});
+    expect(z.object({ a: literal.optional() }).parse({ a: undefined })).toStrictEqual({ a: undefined });
+    expect(z.tuple([literal]).parse([])).toStrictEqual([undefined]);
+  } finally {
+    z.config({ jitless: previous });
+  }
+});
+
+test("prefault preserves transformed undefined output", async () => {
+  const field = z
+    .string()
+    .transform(() => undefined)
+    .prefault("fallback");
+  expectTypeOf<z.output<typeof field>>().toEqualTypeOf<undefined>();
+  expect(field.parse(undefined)).toBeUndefined();
+  const schema = z.object({ a: field, optional: z.string().optional() });
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: undefined; optional?: string | undefined }>();
+  expect(schema.parse({})).toStrictEqual({ a: undefined });
+  expect(z.core.compileFn(schema)({})).toStrictEqual({ a: undefined });
+  expect(z.compile(schema).parse({})).toStrictEqual({ a: undefined });
+  expect(
+    await z
+      .object({
+        a: z
+          .string()
+          .transform(async () => undefined)
+          .prefault("fallback"),
+      })
+      .parseAsync({})
+  ).toStrictEqual({ a: undefined });
+  expect(
+    z
+      .object({
+        a: z
+          .string()
+          .prefault("fallback")
+          .transform(() => undefined),
+      })
+      .parse({})
+  ).toStrictEqual({ a: undefined });
+});
+
 test("basic prefault", () => {
   const a = z.prefault(z.string().trim(), "  default  ");
   expect(a).toBeInstanceOf(z.ZodPrefault);

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/core/api.ts

@@ -1144,16 +1144,13 @@ export function _property<K extends string, T extends schemas.$ZodType>(
   });
 }
 
-// `when` is omitted: it gates a check inside the run loop, so it means nothing when this is parsed as a schema, and honoring it in one role only would diverge silently
-export type $ZodPropertiesParams = CheckTypeParams<schemas.$ZodProperties, "shape" | "when">;
+export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
 // @__NO_SIDE_EFFECTS__
 export function _properties<Shape extends schemas.$ZodShape>(
-  Class: util.SchemaClass<schemas.$ZodProperties>,
   shape: Shape,
-  params?: string | $ZodPropertiesParams
-): schemas.$ZodProperties<Shape> {
-  return new Class({
-    type: "properties",
+  params?: string | $ZodCheckPropertiesParams
+): checks.$ZodCheckProperties<Shape> {
+  return new checks.$ZodCheckProperties({
     check: "properties",
     shape,
     ...util.normalizeParams(params),

package/src/v4/core/checks.ts

@@ -1000,7 +1000,7 @@ export const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith> = /*@__PURE
 function handleCheckPropertyResult(
   result: schemas.ParsePayload<unknown>,
   payload: schemas.ParsePayload<unknown>,
-  property: string
+  property: string | symbol
 ) {
   if (result.issues.length) {
     payload.issues.push(...util.prefixIssues(property, result.issues));
@@ -1045,6 +1045,66 @@ export const $ZodCheckProperty: core.$constructor<$ZodCheckProperty> = /*@__PURE
   }
 );
 
+/////////////////////////////////////
+/////    $ZodCheckProperties    /////
+/////////////////////////////////////
+export interface $ZodCheckPropertiesDef<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckDef {
+  check: "properties";
+  shape: Shape;
+}
+
+// typed over the input side, since each child's result is discarded; a literal widens to its primitive so spreading over a `string` property still type-checks (#6520)
+export type $ZodCheckPropertiesInput<Shape extends schemas.$ZodShape = schemas.$ZodShape> = {
+  -readonly [k in keyof Shape]: util.Widen<core.input<Shape[k]>>;
+};
+
+export interface $ZodCheckPropertiesInternals<Shape extends schemas.$ZodShape = schemas.$ZodShape>
+  extends $ZodCheckInternals<$ZodCheckPropertiesInput<Shape>> {
+  def: $ZodCheckPropertiesDef<Shape>;
+  issc: errors.$ZodIssue;
+}
+
+export interface $ZodCheckProperties<Shape extends schemas.$ZodShape = schemas.$ZodShape>
+  extends $ZodCheck<$ZodCheckPropertiesInput<Shape>> {
+  _zod: $ZodCheckPropertiesInternals<Shape>;
+  // yields the check itself, so `.check(...z.properties(shape))` spread call sites keep working
+  [Symbol.iterator](): Iterator<this>;
+}
+
+export const $ZodCheckProperties: core.$constructor<$ZodCheckProperties> = /*@__PURE__*/ core.$constructor(
+  "$ZodCheckProperties",
+  (inst, def) => {
+    $ZodCheck.init(inst, def);
+    util.hide(inst, Symbol.iterator, function* () {
+      yield inst;
+    });
+
+    // key and schema snapshotted together: reading one live and the other cached lets a later mutation of the caller's shape object pair a stale key with a missing schema
+    let entries!: [string | symbol, schemas.$ZodType][];
+    inst._zod.check = (payload) => {
+      // the base schema already typed the value, so only a nullish one is rejected here: the properties read on a primitive too, matching z.property() on a string's length
+      if (payload.value == null) {
+        payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
+        return undefined;
+      }
+      entries ??= Reflect.ownKeys(def.shape).map((key) => [key, (def.shape as any)[key] as schemas.$ZodType]);
+      const input = payload.value as any;
+      let proms: Promise<any>[] | undefined;
+      for (const [key, schema] of entries) {
+        const result = schema._zod.run({ value: input[key], issues: [] }, {});
+        if (result instanceof Promise) {
+          proms ??= [];
+          proms.push(result.then((result) => handleCheckPropertyResult(result, payload, key)));
+        } else {
+          handleCheckPropertyResult(result, payload, key);
+        }
+      }
+      if (proms) return Promise.all(proms).then(() => undefined);
+      return undefined;
+    };
+  }
+);
+
 ///////////////////////////////////
 /////    $ZodCheckMimeType    /////
 ///////////////////////////////////