zod 3.26.0-canary.20250616T185210 → 3.26.0-canary.20250616T222346

package/dist/cjs/v4/classic/schemas.js

@@ -582,9 +582,7 @@ function keyof(schema) {
 exports.ZodObject = core.$constructor("ZodObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     exports.ZodType.init(inst, def);
-    core_1.util.defineLazy(inst, "shape", () => {
-        return Object.fromEntries(Object.entries(inst._zod.def.shape));
-    });
+    core_1.util.defineLazy(inst, "shape", () => def.shape);
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall });
     inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });

package/dist/cjs/v4/mini/schemas.js

@@ -427,6 +427,7 @@ function keyof(schema) {
 exports.ZodMiniObject = core.$constructor("ZodMiniObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     exports.ZodMiniType.init(inst, def);
+    core_1.util.defineLazy(inst, "shape", () => def.shape);
 });
 function object(shape, params) {
     const def = {

package/dist/esm/v4/classic/schemas.js

@@ -478,9 +478,7 @@ export function keyof(schema) {
 export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     ZodType.init(inst, def);
-    util.defineLazy(inst, "shape", () => {
-        return Object.fromEntries(Object.entries(inst._zod.def.shape));
-    });
+    util.defineLazy(inst, "shape", () => def.shape);
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall });
     inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });

package/dist/esm/v4/mini/schemas.js

@@ -318,6 +318,7 @@ export function keyof(schema) {
 export const ZodMiniObject = /*@__PURE__*/ core.$constructor("ZodMiniObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     ZodMiniType.init(inst, def);
+    util.defineLazy(inst, "shape", () => def.shape);
 });
 export function object(shape, params) {
     const def = {

package/dist/types/v4/classic/schemas.d.ts

@@ -392,10 +392,10 @@ export interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodT
 }
 export declare const ZodArray: core.$constructor<ZodArray>;
 export declare function array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
-export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["output"]>;
+export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<Exclude<keyof T["_zod"]["output"], symbol>>;
 export interface ZodObject<
 /** @ts-ignore Cast variance */
-out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
+out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
     shape: Shape;
     keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
     /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
@@ -505,7 +505,7 @@ export { _enum as enum };
  * ```
  */
 export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T>;
-export interface ZodLiteral<T extends util.Primitive = util.Primitive> extends _ZodType<core.$ZodLiteralInternals<T>>, core.$ZodLiteral<T> {
+export interface ZodLiteral<T extends util.Literal = util.Literal> extends _ZodType<core.$ZodLiteralInternals<T>>, core.$ZodLiteral<T> {
     values: Set<T>;
     /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
     value: T;

package/dist/types/v4/core/schemas.d.ts

@@ -718,17 +718,17 @@ export interface $ZodEnum<T extends util.EnumLike = util.EnumLike> extends $ZodT
     _zod: $ZodEnumInternals<T>;
 }
 export declare const $ZodEnum: core.$constructor<$ZodEnum>;
-export interface $ZodLiteralDef extends $ZodTypeDef {
+export interface $ZodLiteralDef<T extends util.Literal> extends $ZodTypeDef {
     type: "literal";
-    values: util.LiteralArray;
+    values: T[];
 }
-export interface $ZodLiteralInternals<T extends util.Primitive = util.Primitive> extends $ZodTypeInternals<T, T> {
-    def: $ZodLiteralDef;
+export interface $ZodLiteralInternals<T extends util.Literal = util.Literal> extends $ZodTypeInternals<T, T> {
+    def: $ZodLiteralDef<T>;
     values: Set<T>;
     pattern: RegExp;
     isst: errors.$ZodIssueInvalidValue;
 }
-export interface $ZodLiteral<T extends util.Primitive = util.Primitive> extends $ZodType {
+export interface $ZodLiteral<T extends util.Literal = util.Literal> extends $ZodType {
     _zod: $ZodLiteralInternals<T>;
 }
 export declare const $ZodLiteral: core.$constructor<$ZodLiteral>;

package/dist/types/v4/mini/schemas.d.ts

@@ -173,10 +173,10 @@ export interface ZodMiniArray<T extends SomeType = core.$ZodType> extends _ZodMi
 }
 export declare const ZodMiniArray: core.$constructor<ZodMiniArray>;
 export declare function array<T extends SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodMiniArray<T>;
-export declare function keyof<T extends ZodMiniObject>(schema: T): ZodMiniLiteral<keyof T["shape"]>;
+export declare function keyof<T extends ZodMiniObject>(schema: T): ZodMiniLiteral<Exclude<keyof T["shape"], symbol>>;
 export interface ZodMiniObject<
 /** @ts-ignore Cast variance */
-out Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends ZodMiniType<any, any, core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
+out Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$strip> extends ZodMiniType<any, any, core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
     shape: Shape;
 }
 export declare const ZodMiniObject: core.$constructor<ZodMiniObject>;
@@ -252,7 +252,7 @@ export { _enum as enum };
  * ```
  */
 export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<T>;
-export interface ZodMiniLiteral<T extends util.Primitive = util.Primitive> extends _ZodMiniType<core.$ZodLiteralInternals<T>> {
+export interface ZodMiniLiteral<T extends util.Literal = util.Literal> extends _ZodMiniType<core.$ZodLiteralInternals<T>> {
 }
 export declare const ZodMiniLiteral: core.$constructor<ZodMiniLiteral>;
 export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T[number]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.26.0-canary.20250616T185210",
+  "version": "3.26.0-canary.20250616T222346",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",