zod 4.6.2 → 4.6.3

package/src/v4/core/schemas.ts

@@ -96,8 +96,7 @@ export interface $ZodTypeDef {
     | "promise"
     | "lazy"
     | "function"
-    | "custom"
-    | "properties";
+    | "custom";
   error?: errors.$ZodErrorMap<never> | undefined;
   checks?: checks.$ZodCheck<never>[];
 }
@@ -5096,101 +5095,6 @@ function handleRefineResult(result: unknown, payload: ParsePayload, input: unkno
   }
 }
 
-////////////////////////////////////////
-////////////////////////////////////////
-//////////                    //////////
-//////////  $ZodProperties    //////////
-//////////                    //////////
-////////////////////////////////////////
-////////////////////////////////////////
-export interface $ZodPropertiesDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef, checks.$ZodCheckDef {
-  type: "properties";
-  check: "properties";
-  shape: Shape;
-}
-
-// both sides infer the INPUT type: the shape is asserted and its results discarded, so a default, catch or transform inside it would make an output-typed inference a lie. The check side widens a literal to its primitive, so spreading over a `string` property still type-checks (#6520).
-export interface $ZodPropertiesInternals<Shape extends $ZodShape = $ZodShape>
-  extends $ZodTypeInternals<$InferObjectInput<Shape, {}>, $InferObjectInput<Shape, {}>>,
-    checks.$ZodCheckInternals<{ -readonly [k in keyof Shape]: util.Widen<core.input<Shape[k]>> }> {
-  def: $ZodPropertiesDef<Shape>;
-  isst: errors.$ZodIssueInvalidType;
-  issc: errors.$ZodIssue;
-}
-
-export interface $ZodProperties<Shape extends $ZodShape = $ZodShape> extends $ZodType {
-  _zod: $ZodPropertiesInternals<Shape>;
-  // yields the schema itself, so pre-4.6 `.check(...z.properties(shape))` spread call sites keep working
-  [Symbol.iterator](): Iterator<this>;
-}
-
-// asserts in place: the child result's value is discarded, matching z.property(), because a nested object or array schema rebuilds its output even when nothing transformed
-function handlePropertiesResult(result: ParsePayload, payload: ParsePayload, key: string | symbol): void {
-  if (result.issues.length) {
-    payload.issues.push(...util.prefixIssues(key, result.issues));
-  }
-}
-
-export const $ZodProperties: core.$constructor<$ZodProperties> = /*@__PURE__*/ core.$constructor(
-  "$ZodProperties",
-  (inst, def) => {
-    // $ZodType.init prepends an instance that already carries the $ZodCheck trait to its own `checks`, which would run the shape a second time and cost the parse context. Initializing the check trait after it keeps the schema role in `parse`, where the context arrives.
-    $ZodType.init(inst, def);
-    checks.$ZodCheck.init(inst, def);
-
-    const memo = core.globalConfig.memoizer;
-    memo?.attach(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, $ZodType][];
-    const runShape = (payload: ParsePayload, ctx: ParseContextInternal): util.MaybeAsync<void> => {
-      entries ??= Reflect.ownKeys(def.shape).map((key) => [key, (def.shape as any)[key] as $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: [] }, ctx);
-        if (result instanceof Promise) {
-          proms ??= [];
-          proms.push(result.then((result) => handlePropertiesResult(result, payload, key)));
-        } else {
-          handlePropertiesResult(result, payload, key);
-        }
-      }
-      if (proms) return Promise.all(proms).then(() => undefined);
-      return undefined;
-    };
-
-    inst._zod.parse = (payload, ctx) => {
-      const input = payload.value;
-      // as a schema this is the type gate, and it infers an object shape, so a primitive is a type error. A function passes: its properties read like any other object's, and z.instanceof allows one.
-      if (input === null || (typeof input !== "object" && typeof input !== "function")) {
-        payload.issues.push({ expected: "object", code: "invalid_type", input, inst });
-        return payload;
-      }
-      // both sides declare the shape's input type, so the assertion runs forward in either direction; encoding the children backward would reject the very type this schema claims to take
-      if (ctx.direction === "backward") ctx = { ...ctx, direction: "forward" };
-      // the input is its own output here, so it registers as its own memo entry: a cycle re-entering this node hits the bucket instead of recursing forever
-      if (memo) memo.alloc(inst, payload, input, ctx);
-      const result = runShape(payload, ctx);
-      return result instanceof Promise ? result.then(() => payload) : payload;
-    };
-
-    // as a check the base schema already typed the value, so this only asserts the properties — which read on a primitive too, matching z.property() on a string's length. It gets no context of its own, so a cycle through a spread schema is not tracked.
-    inst._zod.check = (payload) => {
-      if (payload.value == null) {
-        payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
-        return undefined;
-      }
-      return runShape(payload, {});
-    };
-  },
-  {
-    *[Symbol.iterator]() {
-      yield this;
-    },
-  }
-);
-
 export type $ZodTypes =
   | $ZodString
   | $ZodNumber
@@ -5223,7 +5127,6 @@ export type $ZodTypes =
   | $ZodPrefault
   | $ZodTemplateLiteral
   | $ZodCustom
-  | $ZodProperties
   | $ZodTransform
   | $ZodNonOptional
   | $ZodReadonly

package/src/v4/core/to-json-schema.ts

@@ -757,7 +757,7 @@ export function finalize<T extends schemas.$ZodType>(
   }
 }
 
-export function isTransforming(
+function isTransforming(
   _schema: schemas.$ZodType,
   _ctx?: {
     seen: Set<schemas.$ZodType>;

package/src/v4/core/util.ts

@@ -1125,10 +1125,6 @@ export function members(proto: object, table: object): void {
     // a method materializes bound on first read, which is what keeps a detached member working: `const opt = schema.optional; opt()`
     else defineBound(proto, key, desc.value);
   }
-  // for..in sees no symbol keys, so well-known members like Symbol.iterator install here
-  for (const sym of Object.getOwnPropertySymbols(table)) {
-    defineBound(proto, sym, (table as any)[sym]);
-  }
 }
 
 /** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 6,
-  patch: 2 as number,
+  patch: 3 as number,
 } as const;

package/src/v4/core/visit.ts

@@ -158,17 +158,6 @@ export function visit(schema: schemas.SomeType, fnOrHandlers: VisitFn | VisitHan
         const { _cachedInner, ...rest } = def;
         return clone(s, { ...rest, getter: () => run(original()) });
       }
-      case "properties": {
-        const oldShape = def.shape as Record<string | symbol, AnyZod>;
-        let changed = false;
-        const newShape: Record<string | symbol, AnyZod> = {};
-        for (const k of Reflect.ownKeys(oldShape)) {
-          const mapped = run(oldShape[k]!);
-          if (mapped !== oldShape[k]) changed = true;
-          newShape[k] = mapped;
-        }
-        return changed ? clone(s, { ...def, shape: newShape }) : s;
-      }
       // A leaf by choice: `parts` are regex fragments, not data positions.
       case "template_literal":
       // Leaves.

package/src/v4/mini/checks.ts

@@ -23,6 +23,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/mini/schemas.ts

@@ -1866,25 +1866,6 @@ export const ZodMiniCustom: core.$constructor<ZodMiniCustom> = /*@__PURE__*/ cor
   }
 );
 
-// ZodMiniProperties
-export interface ZodMiniProperties<Shape extends core.$ZodShape = core.$ZodShape>
-  extends _ZodMiniType<core.$ZodPropertiesInternals<Shape>>,
-    core.$ZodProperties<Shape> {}
-export const ZodMiniProperties: core.$constructor<ZodMiniProperties> = /*@__PURE__*/ core.$constructor(
-  "ZodMiniProperties",
-  (inst, def) => {
-    core.$ZodProperties.init(inst, def);
-    ZodMiniType.init(inst, def);
-  }
-);
-
-export function properties<Shape extends core.$ZodShape>(
-  shape: Shape,
-  params?: string | core.$ZodPropertiesParams
-): ZodMiniProperties<Shape> {
-  return core._properties(ZodMiniProperties, shape, params) as any;
-}
-
 // custom checks
 // @__NO_SIDE_EFFECTS__
 export function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O> {

package/v4/classic/checks.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.slugify = exports.toUpperCase = exports.toLowerCase = exports.trim = exports.normalize = exports.overwrite = exports.mime = exports.property = exports.endsWith = exports.startsWith = exports.includes = exports.uppercase = exports.lowercase = exports.regex = exports.length = exports.minLength = exports.maxLength = exports.size = exports.minSize = exports.maxSize = exports.multipleOf = exports.nonnegative = exports.nonpositive = exports.negative = exports.positive = exports.gte = exports.gt = exports.lte = exports.lt = void 0;
+exports.slugify = exports.toUpperCase = exports.toLowerCase = exports.trim = exports.normalize = exports.overwrite = exports.mime = exports.properties = exports.property = exports.endsWith = exports.startsWith = exports.includes = exports.uppercase = exports.lowercase = exports.regex = exports.length = exports.minLength = exports.maxLength = exports.size = exports.minSize = exports.maxSize = exports.multipleOf = exports.nonnegative = exports.nonpositive = exports.negative = exports.positive = exports.gte = exports.gt = exports.lte = exports.lt = void 0;
 var index_js_1 = require("../core/index.cjs");
 Object.defineProperty(exports, "lt", { enumerable: true, get: function () { return index_js_1._lt; } });
 Object.defineProperty(exports, "lte", { enumerable: true, get: function () { return index_js_1._lte; } });
@@ -24,6 +24,7 @@ Object.defineProperty(exports, "includes", { enumerable: true, get: function ()
 Object.defineProperty(exports, "startsWith", { enumerable: true, get: function () { return index_js_1._startsWith; } });
 Object.defineProperty(exports, "endsWith", { enumerable: true, get: function () { return index_js_1._endsWith; } });
 Object.defineProperty(exports, "property", { enumerable: true, get: function () { return index_js_1._property; } });
+Object.defineProperty(exports, "properties", { enumerable: true, get: function () { return index_js_1._properties; } });
 Object.defineProperty(exports, "mime", { enumerable: true, get: function () { return index_js_1._mime; } });
 Object.defineProperty(exports, "overwrite", { enumerable: true, get: function () { return index_js_1._overwrite; } });
 Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return index_js_1._normalize; } });

package/v4/classic/checks.d.cts

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.cjs";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _properties as properties, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.cjs";

package/v4/classic/checks.d.ts

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _properties as properties, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";

package/v4/classic/checks.js

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, } from "../core/index.js";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _properties as properties, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, } from "../core/index.js";

package/v4/classic/schemas.cjs

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodXor = exports.ZodUnion = exports.ZodObject = exports.ZodArray = exports.ZodDate = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodSymbol = exports.ZodBigIntFormat = exports.ZodBigInt = exports.ZodBoolean = exports.ZodNumberFormat = exports.ZodNumber = exports.ZodCustomStringFormat = exports.ZodJWT = exports.ZodIBAN = exports.ZodCreditCard = exports.ZodE164 = exports.ZodBase64URL = exports.ZodBase64 = exports.ZodCIDRv6 = exports.ZodCIDRv4 = exports.ZodIPv6 = exports.ZodMAC = exports.ZodIPv4 = exports.ZodKSUID = exports.ZodXID = exports.ZodULID = exports.ZodCUID2 = exports.ZodCUID = exports.ZodNanoID = exports.ZodEmoji = exports.ZodURL = exports.ZodUUID = exports.ZodGUID = exports.ZodEmail = exports.ZodISODuration = exports.ZodISOTime = exports.ZodISODate = exports.ZodISODateTime = exports.ZodStringFormat = exports.ZodString = exports._ZodString = exports.ZodType = void 0;
-exports.stringbool = exports.ZodInstanceOf = exports.meta = exports.describe = exports.ZodProperties = exports.ZodCustom = exports.ZodFunction = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodPreprocess = exports.ZodCodec = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodPrefault = exports.ZodDefault = exports.ZodNullable = exports.ZodExactOptional = exports.ZodOptional = exports.ZodTransform = exports.ZodFile = exports.ZodLiteral = exports.ZodEnum = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = void 0;
+exports.stringbool = exports.ZodInstanceOf = exports.meta = exports.describe = exports.ZodCustom = exports.ZodFunction = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodPreprocess = exports.ZodCodec = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodPrefault = exports.ZodDefault = exports.ZodNullable = exports.ZodExactOptional = exports.ZodOptional = exports.ZodTransform = exports.ZodFile = exports.ZodLiteral = exports.ZodEnum = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = void 0;
 exports.string = string;
 exports.email = email;
 exports.guid = guid;
@@ -118,7 +118,6 @@ exports._function = _function;
 exports.function = _function;
 exports._function = _function;
 exports.function = _function;
-exports.properties = properties;
 exports.check = check;
 exports.custom = custom;
 exports.refine = refine;
@@ -1577,14 +1576,6 @@ exports.ZodCustom = core.$constructor("ZodCustom", (inst, def) => {
     exports.ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
 });
-exports.ZodProperties = core.$constructor("ZodProperties", (inst, def) => {
-    _ensureDefaultMemoizer();
-    core.$ZodProperties.init(inst, def);
-    exports.ZodType.init(inst, def);
-});
-function properties(shape, params) {
-    return core._properties(exports.ZodProperties, shape, params);
-}
 // custom checks
 function check(fn) {
     const ch = new core.$ZodCheck({
@@ -1612,7 +1603,7 @@ exports.ZodInstanceOf = core.$constructor("ZodInstanceOf", (inst, def) => {
 }, {
     properties(shape, params) {
         // asserts in place, so the narrowed output type is truthful without a wrapper
-        return this.check(properties(shape, params));
+        return this.check(core._properties(shape, params));
     },
 });
 function _instanceof(cls, params = {}) {

package/v4/classic/schemas.d.cts

@@ -779,11 +779,6 @@ export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodC
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
-export interface ZodProperties<Shape extends core.$ZodShape = core.$ZodShape> extends _ZodType<core.$ZodPropertiesInternals<Shape>>, core.$ZodProperties<Shape> {
-    "~standard": ZodStandardSchemaWithJSON<this>;
-}
-export declare const ZodProperties: core.$constructor<ZodProperties>;
-export declare function properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodProperties<Shape>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
@@ -792,7 +787,7 @@ export declare const describe: typeof core.describe;
 export declare const meta: typeof core.meta;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
-    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodCheckPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
 }
 export declare const ZodInstanceOf: core.$constructor<ZodInstanceOf>;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;

package/v4/classic/schemas.d.ts

@@ -779,11 +779,6 @@ export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodC
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
-export interface ZodProperties<Shape extends core.$ZodShape = core.$ZodShape> extends _ZodType<core.$ZodPropertiesInternals<Shape>>, core.$ZodProperties<Shape> {
-    "~standard": ZodStandardSchemaWithJSON<this>;
-}
-export declare const ZodProperties: core.$constructor<ZodProperties>;
-export declare function properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodProperties<Shape>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
@@ -792,7 +787,7 @@ export declare const describe: typeof core.describe;
 export declare const meta: typeof core.meta;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
-    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodCheckPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
 }
 export declare const ZodInstanceOf: core.$constructor<ZodInstanceOf>;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;

package/v4/classic/schemas.js

@@ -1455,14 +1455,6 @@ export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
 });
-export const ZodProperties = /*@__PURE__*/ core.$constructor("ZodProperties", (inst, def) => {
-    _ensureDefaultMemoizer();
-    core.$ZodProperties.init(inst, def);
-    ZodType.init(inst, def);
-});
-export function properties(shape, params) {
-    return core._properties(ZodProperties, shape, params);
-}
 // custom checks
 export function check(fn) {
     const ch = new core.$ZodCheck({
@@ -1490,7 +1482,7 @@ export const ZodInstanceOf = /*@__PURE__*/ core.$constructor("ZodInstanceOf", (i
 }, {
     properties(shape, params) {
         // asserts in place, so the narrowed output type is truthful without a wrapper
-        return this.check(properties(shape, params));
+        return this.check(core._properties(shape, params));
     },
 });
 function _instanceof(cls, params = {}) {

package/v4/core/api.cjs

@@ -831,9 +831,8 @@ function _property(property, schema, params) {
     });
 }
 // @__NO_SIDE_EFFECTS__
-function _properties(Class, shape, params) {
-    return new Class({
-        type: "properties",
+function _properties(shape, params) {
+    return new checks.$ZodCheckProperties({
         check: "properties",
         shape,
         ...util.normalizeParams(params),

package/v4/core/api.d.cts

@@ -216,8 +216,8 @@ export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "pro
 export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
     [k in K]: util.Widen<core.input<T>>;
 }>;
-export type $ZodPropertiesParams = CheckTypeParams<schemas.$ZodProperties, "shape" | "when">;
-export declare function _properties<Shape extends schemas.$ZodShape>(Class: util.SchemaClass<schemas.$ZodProperties>, shape: Shape, params?: string | $ZodPropertiesParams): schemas.$ZodProperties<Shape>;
+export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
+export declare function _properties<Shape extends schemas.$ZodShape>(shape: Shape, params?: string | $ZodCheckPropertiesParams): checks.$ZodCheckProperties<Shape>;
 export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
 export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
 export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;

package/v4/core/api.d.ts

@@ -216,8 +216,8 @@ export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "pro
 export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
     [k in K]: util.Widen<core.input<T>>;
 }>;
-export type $ZodPropertiesParams = CheckTypeParams<schemas.$ZodProperties, "shape" | "when">;
-export declare function _properties<Shape extends schemas.$ZodShape>(Class: util.SchemaClass<schemas.$ZodProperties>, shape: Shape, params?: string | $ZodPropertiesParams): schemas.$ZodProperties<Shape>;
+export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
+export declare function _properties<Shape extends schemas.$ZodShape>(shape: Shape, params?: string | $ZodCheckPropertiesParams): checks.$ZodCheckProperties<Shape>;
 export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
 export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
 export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;

package/v4/core/api.js

@@ -688,9 +688,8 @@ export function _property(property, schema, params) {
     });
 }
 // @__NO_SIDE_EFFECTS__
-export function _properties(Class, shape, params) {
-    return new Class({
-        type: "properties",
+export function _properties(shape, params) {
+    return new checks.$ZodCheckProperties({
         check: "properties",
         shape,
         ...util.normalizeParams(params),

package/v4/core/checks.cjs

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.$ZodCheckOverwrite = exports.$ZodCheckMimeType = exports.$ZodCheckProperty = exports.$ZodCheckEndsWith = exports.$ZodCheckStartsWith = exports.$ZodCheckIncludes = exports.$ZodCheckUpperCase = exports.$ZodCheckLowerCase = exports.$ZodCheckRegex = exports.$ZodCheckStringFormat = exports.$ZodCheckLengthEquals = exports.$ZodCheckMinLength = exports.$ZodCheckMaxLength = exports.$ZodCheckSizeEquals = exports.$ZodCheckMinSize = exports.$ZodCheckMaxSize = exports.$ZodCheckBigIntFormat = exports.$ZodCheckNumberFormat = exports.$ZodCheckMultipleOf = exports.$ZodCheckGreaterThan = exports.$ZodCheckLessThan = exports.$ZodCheck = void 0;
+exports.$ZodCheckOverwrite = exports.$ZodCheckMimeType = exports.$ZodCheckProperties = exports.$ZodCheckProperty = exports.$ZodCheckEndsWith = exports.$ZodCheckStartsWith = exports.$ZodCheckIncludes = exports.$ZodCheckUpperCase = exports.$ZodCheckLowerCase = exports.$ZodCheckRegex = exports.$ZodCheckStringFormat = exports.$ZodCheckLengthEquals = exports.$ZodCheckMinLength = exports.$ZodCheckMaxLength = exports.$ZodCheckSizeEquals = exports.$ZodCheckMinSize = exports.$ZodCheckMaxSize = exports.$ZodCheckBigIntFormat = exports.$ZodCheckNumberFormat = exports.$ZodCheckMultipleOf = exports.$ZodCheckGreaterThan = exports.$ZodCheckLessThan = exports.$ZodCheck = void 0;
 const core = __importStar(require("./core.cjs"));
 const regexes = __importStar(require("./regexes.cjs"));
 const util = __importStar(require("./util.cjs"));
@@ -488,6 +488,37 @@ exports.$ZodCheckProperty = core.$constructor("$ZodCheckProperty", (inst, def) =
         return;
     };
 });
+exports.$ZodCheckProperties = core.$constructor("$ZodCheckProperties", (inst, def) => {
+    exports.$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;
+    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 ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
+        const input = payload.value;
+        let proms;
+        for (const [key, schema] of entries) {
+            const result = schema._zod.run({ value: input[key], issues: [] }, {});
+            if (result instanceof Promise) {
+                proms ?? (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;
+    };
+});
 exports.$ZodCheckMimeType = core.$constructor("$ZodCheckMimeType", (inst, def) => {
     exports.$ZodCheck.init(inst, def);
     const mimeSet = new Set(def.mime);

package/v4/core/checks.d.cts

@@ -250,6 +250,22 @@ export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<
     _zod: $ZodCheckPropertyInternals<T>;
 }
 export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
+export interface $ZodCheckPropertiesDef<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckDef {
+    check: "properties";
+    shape: Shape;
+}
+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>;
+    [Symbol.iterator](): Iterator<this>;
+}
+export declare const $ZodCheckProperties: core.$constructor<$ZodCheckProperties>;
 export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
     check: "mime_type";
     mime: util.MimeTypes[];

package/v4/core/checks.d.ts

@@ -250,6 +250,22 @@ export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<
     _zod: $ZodCheckPropertyInternals<T>;
 }
 export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
+export interface $ZodCheckPropertiesDef<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckDef {
+    check: "properties";
+    shape: Shape;
+}
+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>;
+    [Symbol.iterator](): Iterator<this>;
+}
+export declare const $ZodCheckProperties: core.$constructor<$ZodCheckProperties>;
 export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
     check: "mime_type";
     mime: util.MimeTypes[];

package/v4/core/checks.js

@@ -462,6 +462,37 @@ export const $ZodCheckProperty = /*@__PURE__*/ core.$constructor("$ZodCheckPrope
         return;
     };
 });
+export const $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;
+    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 ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
+        const input = payload.value;
+        let proms;
+        for (const [key, schema] of entries) {
+            const result = schema._zod.run({ value: input[key], issues: [] }, {});
+            if (result instanceof Promise) {
+                proms ?? (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;
+    };
+});
 export const $ZodCheckMimeType = /*@__PURE__*/ core.$constructor("$ZodCheckMimeType", (inst, def) => {
     $ZodCheck.init(inst, def);
     const mimeSet = new Set(def.mime);

package/v4/core/compile.cjs

@@ -361,7 +361,7 @@ function generateChecks(doc, ctx, schema, accessor) {
                 generatePropertyCheck(doc, ctx, def, currentAccessor);
                 break;
             case "properties":
-                generatePropertiesChecks(doc, ctx, def, currentAccessor, false);
+                generatePropertiesChecks(doc, ctx, def, currentAccessor);
                 break;
             case "overwrite": {
                 // Overwrite transforms the value - create new variable for transformed result
@@ -489,15 +489,13 @@ function generateMimeTypeCheck(doc, ctx, def, accessor) {
     }
 }
 // asserts each named property in place; children compile assert-only because z.properties never rebuilds its input
-function generatePropertiesChecks(doc, ctx, def, accessor, schemaRole) {
-    // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen the way the check role does
+function generatePropertiesChecks(doc, ctx, def, accessor) {
+    // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen
     if (def.when) {
         throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
     }
-    // matches the runtime gate for whichever role this is: a schema rejects a primitive outright, a check only a nullish value
-    doc.write(schemaRole
-        ? `if (${accessor} === null || (typeof ${accessor} !== "object" && typeof ${accessor} !== "function")) return INVALID;`
-        : `if (${accessor} == null) return INVALID;`);
+    // matches the runtime gate: the base schema already typed the value, so only a nullish one is rejected
+    doc.write(`if (${accessor} == null) return INVALID;`);
     const shape = def.shape;
     for (const key of Reflect.ownKeys(shape)) {
         // a symbol has no source literal, so it is hoisted as a constant
@@ -848,10 +846,6 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
         case "custom":
             typeAccessor = generateCustomCheck(doc, ctx, schema, accessor);
             break;
-        case "properties":
-            generatePropertiesChecks(doc, ctx, schema._zod.def, accessor, true);
-            typeAccessor = accessor;
-            break;
         case "transform":
             typeAccessor = generateTransformCheck(doc, ctx, schema, accessor);
             break;

package/v4/core/compile.js

@@ -330,7 +330,7 @@ function generateChecks(doc, ctx, schema, accessor) {
                 generatePropertyCheck(doc, ctx, def, currentAccessor);
                 break;
             case "properties":
-                generatePropertiesChecks(doc, ctx, def, currentAccessor, false);
+                generatePropertiesChecks(doc, ctx, def, currentAccessor);
                 break;
             case "overwrite": {
                 // Overwrite transforms the value - create new variable for transformed result
@@ -458,15 +458,13 @@ function generateMimeTypeCheck(doc, ctx, def, accessor) {
     }
 }
 // asserts each named property in place; children compile assert-only because z.properties never rebuilds its input
-function generatePropertiesChecks(doc, ctx, def, accessor, schemaRole) {
-    // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen the way the check role does
+function generatePropertiesChecks(doc, ctx, def, accessor) {
+    // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen
     if (def.when) {
         throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
     }
-    // matches the runtime gate for whichever role this is: a schema rejects a primitive outright, a check only a nullish value
-    doc.write(schemaRole
-        ? `if (${accessor} === null || (typeof ${accessor} !== "object" && typeof ${accessor} !== "function")) return INVALID;`
-        : `if (${accessor} == null) return INVALID;`);
+    // matches the runtime gate: the base schema already typed the value, so only a nullish one is rejected
+    doc.write(`if (${accessor} == null) return INVALID;`);
     const shape = def.shape;
     for (const key of Reflect.ownKeys(shape)) {
         // a symbol has no source literal, so it is hoisted as a constant
@@ -817,10 +815,6 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
         case "custom":
             typeAccessor = generateCustomCheck(doc, ctx, schema, accessor);
             break;
-        case "properties":
-            generatePropertiesChecks(doc, ctx, schema._zod.def, accessor, true);
-            typeAccessor = accessor;
-            break;
         case "transform":
             typeAccessor = generateTransformCheck(doc, ctx, schema, accessor);
             break;