zod 4.0.0-beta.20250503T014749 → 4.0.0-beta.20250504T215252

package/dist/esm/schemas.d.ts

@@ -10,14 +10,12 @@ export interface ZodType<out Output = unknown, out Input = unknown> extends core
     def: this["_zod"]["def"];
     /** @deprecated Use `.def` instead. */
     _def: this["_zod"]["def"];
-    /** @deprecated Use `z.output<typeof schema>` instead. */
-    _output: this["_zod"]["output"];
-    /** @deprecated Use `z.input<typeof schema>` instead. */
-    _input: this["_zod"]["input"];
-    check(...checks: (core.CheckFn<this["_zod"]["output"]> | core.$ZodCheck<this["_zod"]["output"]>)[]): this;
+    _output: core.output<this>;
+    _input: core.input<this>;
+    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
     clone(def?: this["_zod"]["def"]): this;
     register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$ZodRegistry<R["_meta"], this>["_meta"]?] : [core.$ZodRegistry<R["_meta"], this>["_meta"]] : ["Incompatible schema"]): this;
-    brand<T extends PropertyKey = PropertyKey>(value?: T): this & Record<"_zod", Record<"output", this["_zod"]["output"] & core.$brand<T>>>;
+    brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : this & Record<"_zod", Record<"~output", core.output<this> & core.$brand<T>>>;
     parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
     safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): parse.ZodSafeParseResult<core.output<this>>;
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
@@ -387,78 +385,9 @@ export interface ZodArray<T extends core.$ZodType = core.$ZodType> extends ZodTy
 }
 export declare const ZodArray: core.$constructor<ZodArray>;
 export declare function array<T extends core.$ZodType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
-export interface ZodObjectLike<out O = object, out I = object> extends ZodType {
-    _zod: core.$ZodObjectLikeInternals<O, I>;
-}
-export declare const ZodObjectLike: core.$constructor<ZodObjectLike>;
-export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["def"]["shape"]>;
-export declare function keyof<T extends ZodInterface>(schema: T): ZodLiteral<keyof T["_zod"]["output"]>;
-type ZodInterfacePartial<T extends ZodInterface, Keys extends keyof T["_zod"]["def"]["shape"] = keyof T["_zod"]["def"]["shape"]> = ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in Keys]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: T["_zod"]["optional"] | (string & Keys);
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}>;
-type ZodInterfaceRequired<T extends ZodInterface, Keys extends keyof T["_zod"]["def"]["shape"] = keyof T["_zod"]["def"]["shape"]> = ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in Keys]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: never;
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}>;
-export type MergeInterfaces<A extends ZodInterface, B extends ZodInterface> = ZodInterface<util.Extend<A["_zod"]["def"]["shape"], B["_zod"]["def"]["shape"]>, util.MergeInterfaceParams<A, B>>;
-export interface ZodInterface<out Shape extends core.$ZodLooseShape = core.$ZodLooseShape, out Params extends core.$ZodInterfaceNamedParams = core.$ZodInterfaceNamedParams> extends ZodType {
-    _zod: core.$ZodInterfaceInternals<Shape, Params>;
-    keyof(): ZodEnum<util.ToEnum<util.InterfaceKeys<string & keyof Shape>>>;
-    catchall<T extends core.$ZodType>(schema: T): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: Record<string, T["_zod"]["output"]>;
-    }>;
-    /** Consider `z.strictObject({ ...A.shape })` instead. */
-    strict(): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: {};
-    }>;
-    loose(): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: Record<string, unknown>;
-    }>;
-    /**  Use `z.looseObject({ ...A.shape })` instead. */
-    strip(): ZodInterface<Shape, {
-        optional: Params["optional"];
-        defaulted: Params["defaulted"];
-        extra: {};
-    }>;
-    extend<U extends ZodInterface>(int: U): MergeInterfaces<this, U>;
-    extend<U extends core.$ZodLooseShape>(shape: U): MergeInterfaces<this, ZodInterface<U, util.InitInterfaceParams<U, {}>>>;
-    /** @deprecated Use `A.extend(B)` */
-    merge<U extends ZodInterface>(incoming: U): MergeInterfaces<this, U>;
-    pick<const M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodInterface<util.Flatten<Pick<Shape, keyof Shape & keyof M>>, {
-        optional: Extract<Params["optional"], keyof M>;
-        defaulted: Extract<Params["defaulted"], keyof M>;
-        extra: Params["extra"];
-    }>;
-    omit<const M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodInterface<util.Flatten<Omit<Shape, keyof M>>, {
-        optional: Exclude<Params["optional"], keyof M>;
-        defaulted: Exclude<Params["defaulted"], keyof M>;
-        extra: Params["extra"];
-    }>;
-    partial(): ZodInterfacePartial<this>;
-    partial<M extends util.Mask<string & keyof Shape>>(mask: M): ZodInterfacePartial<this, string & keyof M>;
-    required(): ZodInterfaceRequired<this, string & keyof Shape>;
-    required<M extends util.Mask<string & keyof Shape>>(mask: M): ZodInterfaceRequired<this, string & keyof M>;
-}
-export declare const ZodInterface: core.$constructor<ZodInterface>;
-declare function _interface<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodInterfaceParams, Class?: util.Constructor<ZodInterface>): ZodInterface<util.CleanInterfaceShape<T>, util.InitInterfaceParams<T, {}>>;
-export { _interface as interface };
-export declare function strictInterface<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodInterfaceParams): ZodInterface<util.CleanInterfaceShape<T>, util.InitInterfaceParams<T, {}>>;
-export declare function looseInterface<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodInterfaceParams): ZodInterface<util.CleanInterfaceShape<T>, util.InitInterfaceParams<T, Record<string, unknown>>>;
-export interface ZodObject<out Shape extends core.$ZodShape = core.$ZodShape, Extra extends Record<string, unknown> = Record<string, unknown>> extends ZodType {
-    _zod: core.$ZodObjectInternals<Shape, Extra>;
+export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["output"]>;
+export interface ZodObject<out Shape extends core.$ZodShape = core.$ZodLooseShape, OutExtra extends Record<string, unknown> = Record<string, unknown>, InExtra extends Record<string, unknown> = Record<string, unknown>> extends ZodType {
+    _zod: core.$ZodObjectInternals<Shape, OutExtra, InExtra>;
     shape: Shape;
     keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
     /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
@@ -471,95 +400,52 @@ export interface ZodObject<out Shape extends core.$ZodShape = core.$ZodShape, Ex
     strict(): ZodObject<Shape, {}>;
     /** This is the default behavior. This method call is likely unnecessary. */
     strip(): ZodObject<Shape, {}>;
-    extend<const U extends ZodObject>(schema: U): ZodObject<util.Extend<Shape, U["_zod"]["def"]["shape"]>, Extra>;
-    extend<U extends core.$ZodShape>(shape: U): ZodObject<util.Extend<Shape, U>, Extra>;
-    /** @deprecated Use `A.extend(B.shape)` */
-    merge<U extends ZodObject<any, any>>(other: U): ZodObject<util.Flatten<util.Extend<Shape, U["_zod"]["def"]["shape"]>>, Extra>;
-    pick<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Extra>;
-    omit<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Extra>;
+    extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, OutExtra, InExtra>;
+    /**
+     * @deprecated Use destructuring to merge the shapes:
+     *
+     * ```ts
+     * z.object({
+     *    ...A.shape,
+     *    ...B.shape
+     * });
+     * ```
+     */
+    merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["outextra"], U["_zod"]["inextra"]>;
+    /**
+     * @deprecated Use destructuring to merge the shapes:
+     *
+     * ```ts
+     * z.object({
+     *    ...A.shape,
+     *    ...B.shape
+     * });
+     * ```
+     */
+    pick<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, OutExtra, InExtra>;
+    omit<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, OutExtra, InExtra>;
     partial(): ZodObject<{
         [k in keyof Shape]: ZodOptional<Shape[k]>;
-    }, Extra>;
+    }, OutExtra, InExtra>;
     partial<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];
-    }, Extra>;
+    }, OutExtra, InExtra>;
     required(): ZodObject<{
         [k in keyof Shape]: ZodNonOptional<Shape[k]>;
-    }, Extra>;
+    }, OutExtra, InExtra>;
     required<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];
-    }, Extra>;
+    }, OutExtra, InExtra>;
 }
 export declare const ZodObject: core.$constructor<ZodObject>;
-export declare function object<T extends core.$ZodShape = Record<never, core.$ZodType>>(shape?: T, params?: string | core.$ZodObjectLikeParams): ZodObject<T, {}>;
-export declare function strictObject<T extends core.$ZodShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {}>;
-export declare function looseObject<T extends core.$ZodShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {
+export declare function object<T extends core.$ZodLooseShape = Record<never, core.$ZodType>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T> & {}, {}, {}>;
+export declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {}, {}>;
+export declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, {
     [k: string]: unknown;
-}>;
-export declare function extend<T extends ZodInterface, U extends ZodInterface>(a: T, b: U): ZodInterface<util.Extend<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>, util.MergeInterfaceParams<T, U>>;
-export declare function extend<T extends ZodObject, U extends ZodObject>(a: T, b: U): ZodObject<util.Extend<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>, U["_zod"]["extra"] & T["_zod"]["extra"]>;
-export declare function extend<T extends ZodObjectLike, U extends core.$ZodLooseShape>(schema: T, shape: U): T extends ZodInterface<infer TShape, infer TParams> ? ZodInterface<util.ExtendInterfaceShape<TShape, U>, util.ExtendInterfaceParams<ZodInterface<TShape, TParams>, U>> : ZodObject<util.Extend<T["_zod"]["def"]["shape"], U>, T["_zod"]["extra"]>;
-export declare function merge<T extends ZodObjectLike, U extends core.$ZodLooseShape>(schema: T, shape: U): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Extend<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>, {
-    extra: T["_zod"]["extra"] & U["_zod"]["extra"];
-    optional: Exclude<T["_zod"]["optional"], keyof U["_zod"]["def"]["shape"]> | U["_zod"]["optional"];
-    defaulted: Exclude<T["_zod"]["defaulted"], keyof U["_zod"]["def"]["shape"]> | U["_zod"]["defaulted"];
-}> : ZodObject<util.Extend<T["_zod"]["def"]["shape"], U>, T["_zod"]["extra"]>;
-export declare function pick<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Flatten<Pick<T["_zod"]["def"]["shape"], keyof T["_zod"]["def"]["shape"] & keyof M>>, {
-    optional: Extract<T["_zod"]["optional"], keyof M>;
-    defaulted: Extract<T["_zod"]["defaulted"], keyof M>;
-    extra: T["_zod"]["extra"];
-}> : ZodObject<util.Flatten<Pick<T["_zod"]["def"]["shape"], keyof T["_zod"]["def"]["shape"] & keyof M>>, T["_zod"]["extra"]>;
-export declare function omit<T extends ZodObjectLike, const M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Flatten<Omit<T["_zod"]["def"]["shape"], keyof M>>, {
-    optional: Exclude<T["_zod"]["optional"], keyof M>;
-    defaulted: Exclude<T["_zod"]["defaulted"], keyof M>;
-    extra: T["_zod"]["extra"];
-}> : ZodObject<util.Flatten<Omit<T["_zod"]["def"]["shape"], keyof M>>, T["_zod"]["extra"]>;
-export declare function partial<T extends ZodObjectLike>(schema: T): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
 }, {
-    optional: string & keyof T["_zod"]["def"]["shape"];
-    defaulted: never;
-    extra: T["_zod"]["extra"];
-}> : ZodObject<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
-}, T["_zod"]["extra"]>;
-export declare function partial<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): T["_zod"]["def"]["type"] extends "interface" ? ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: string & (T["_zod"]["optional"] | keyof M);
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}> : ZodObject<{
-    [k in keyof T["_zod"]["def"]["shape"]]: k extends keyof M ? ZodOptional<T["_zod"]["def"]["shape"][k]> : T["_zod"]["def"]["shape"][k];
-}, T["_zod"]["extra"]>;
-export declare function required<T extends {
-    _subtype: "object";
-} & ZodObject>(schema: T): ZodObject<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>;
-export declare function required<T extends {
-    _subtype: "object";
-} & ZodObject, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(schema: T, mask: M): ZodObject<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>>;
-export declare function required<T extends {
-    _subtype: "interface";
-} & ZodInterface>(schema: T): ZodInterface<{
-    [k in keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}, {
-    optional: never;
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
-}>;
-export declare function required<T extends {
-    _subtype: "interface";
-} & ZodInterface, M extends util.Mask<keyof T["_zod"]["output"]>>(schema: T, mask: M): ZodInterface<util.Extend<T["_zod"]["def"]["shape"], {
-    [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
-}>, {
-    optional: Exclude<T["_zod"]["optional"], keyof M>;
-    defaulted: T["_zod"]["defaulted"];
-    extra: T["_zod"]["extra"];
+    [k: string]: unknown;
 }>;
+export declare function partial<T>(shape: T): Partial<T>;
 export interface ZodUnion<T extends readonly core.$ZodType[] = readonly core.$ZodType[]> extends ZodType {
     _zod: core.$ZodUnionInternals<T>;
     options: T;

package/dist/esm/schemas.js

@@ -464,96 +464,17 @@ export const ZodArray = /*@__PURE__*/ core.$constructor("ZodArray", (inst, def)
 export function array(element, params) {
     return core._array(ZodArray, element, params);
 }
-export const ZodObjectLike = /*@__PURE__*/ core.$constructor("ZodObjectLike", (inst, def) => {
-    core.$ZodObjectLike.init(inst, def);
-    ZodType.init(inst, def);
-});
+// .keyof
 export function keyof(schema) {
-    const shape = schema._zod.def.type === "interface"
-        ? util.cleanInterfaceShape(schema._zod.def.shape).shape
-        : schema._zod.def.shape;
+    const shape = schema._zod.def.shape;
     return literal(Object.keys(shape));
 }
-export const ZodInterface = /*@__PURE__*/ core.$constructor("ZodInterface", (inst, def) => {
-    core.$ZodInterface.init(inst, def);
-    ZodType.init(inst, def);
-    // util.defineLazy(inst._zod, "shape", () => def.shape);
-    inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
-    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
-    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
-    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
-    inst.extend = (incoming) => {
-        if (incoming instanceof core.$ZodInterface)
-            return util.extendObjectLike(inst, incoming);
-        return util.extendObjectLike(inst, _interface(incoming));
-    };
-    inst.merge = (other) => util.mergeObjectLike(inst, other);
-    inst.pick = (mask) => util.pick(inst, mask);
-    inst.omit = (mask) => util.omit(inst, mask);
-    inst.partial = (...args) => util.partialObjectLike(ZodOptional, inst, args[0]);
-    inst.required = (...args) => util.requiredObjectLike(ZodNonOptional, inst, args[0]);
-});
-function _interface(shape, params, Class = ZodInterface) {
-    const cleaned = util.cached(() => util.cleanInterfaceShape(shape));
-    const def = {
-        type: "interface",
-        get shape() {
-            // return cleaned.value.shape;
-            const _shape = cleaned.value.shape;
-            util.assignProp(this, "shape", _shape);
-            return _shape;
-        },
-        get optional() {
-            return cleaned.value.optional;
-        },
-        ...util.normalizeParams(params),
-    };
-    return new Class(def);
-}
-export { _interface as interface };
-// strictInterface
-export function strictInterface(shape, params) {
-    const cleaned = util.cached(() => util.cleanInterfaceShape(shape));
-    const def = {
-        type: "interface",
-        get shape() {
-            // return cleaned.value.shape;
-            const _shape = cleaned.value.shape;
-            util.assignProp(this, "shape", _shape);
-            return _shape;
-        },
-        get optional() {
-            return cleaned.value.optional;
-        },
-        catchall: never(),
-        ...util.normalizeParams(params),
-    };
-    return new ZodInterface(def);
-}
-// looseInterface
-export function looseInterface(shape, params) {
-    const cleaned = util.cached(() => util.cleanInterfaceShape(shape));
-    const def = {
-        type: "interface",
-        get optional() {
-            return cleaned.value.optional;
-        },
-        get shape() {
-            // return cleaned.value.shape;
-            const _shape = cleaned.value.shape;
-            util.assignProp(this, "shape", _shape);
-            return _shape;
-        },
-        catchall: unknown(),
-        ...util.normalizeParams(params),
-    };
-    return new ZodInterface(def);
-}
 export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     ZodType.init(inst, def);
-    inst.shape = def.shape;
+    util.defineLazy(inst, "shape", () => {
+        return Object.fromEntries(Object.entries(inst._zod.def.shape));
+    });
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
     inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
@@ -562,22 +483,20 @@ export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def
     inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
     inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
     inst.extend = (incoming) => {
-        if (incoming instanceof ZodObject)
-            return util.extendObjectLike(inst, incoming);
-        return util.extendObjectLike(inst, object(incoming));
+        return util.extend(inst, incoming);
     };
-    inst.merge = (other) => util.mergeObjectLike(inst, other);
+    inst.merge = (other) => util.merge(inst, other);
     inst.pick = (mask) => util.pick(inst, mask);
     inst.omit = (mask) => util.omit(inst, mask);
-    inst.partial = (...args) => util.partialObjectLike(ZodOptional, inst, args[0]);
-    inst.required = (...args) => util.requiredObjectLike(ZodNonOptional, inst, args[0]);
+    inst.partial = (...args) => util.partial(ZodOptional, inst, args[0]);
+    inst.required = (...args) => util.required(ZodNonOptional, inst, args[0]);
 });
 export function object(shape, params) {
     const def = {
         type: "object",
-        shape: shape ?? {},
-        get optional() {
-            return util.optionalObjectKeys(shape ?? {});
+        get shape() {
+            util.assignProp(this, "shape", { ...shape });
+            return this.shape;
         },
         ...util.normalizeParams(params),
     };
@@ -587,9 +506,9 @@ export function object(shape, params) {
 export function strictObject(shape, params) {
     return new ZodObject({
         type: "object",
-        shape: shape,
-        get optional() {
-            return util.optionalObjectKeys(shape);
+        get shape() {
+            util.assignProp(this, "shape", { ...shape });
+            return this.shape;
         },
         catchall: never(),
         ...util.normalizeParams(params),
@@ -599,39 +518,16 @@ export function strictObject(shape, params) {
 export function looseObject(shape, params) {
     return new ZodObject({
         type: "object",
-        shape: shape,
-        get optional() {
-            return util.optionalObjectKeys(shape);
+        get shape() {
+            util.assignProp(this, "shape", { ...shape });
+            return this.shape;
         },
         catchall: unknown(),
         ...util.normalizeParams(params),
     });
 }
-export function extend(schema, shape) {
-    if (shape instanceof core.$ZodType)
-        return util.mergeObjectLike(schema, shape);
-    if (schema instanceof ZodInterface) {
-        return util.mergeObjectLike(schema, _interface(shape));
-    }
-    if (schema instanceof ZodObject)
-        return util.mergeObjectLike(schema, object(shape));
-    return util.extend(schema, shape);
-}
-export function merge(a, b) {
-    return util.mergeObjectLike(a, b);
-}
-export function pick(schema, mask) {
-    // const picked = util.pick(schema, mask);
-    return util.pick(schema, mask);
-}
-export function omit(schema, mask) {
-    return util.omit(schema, mask);
-}
-export function partial(schema, mask) {
-    return util.partialObjectLike(ZodOptional, schema, mask);
-}
-export function required(schema, mask) {
-    return util.requiredObjectLike(ZodNonOptional, schema, mask);
+export function partial(shape) {
+    return shape;
 }
 export const ZodUnion = /*@__PURE__*/ core.$constructor("ZodUnion", (inst, def) => {
     core.$ZodUnion.init(inst, def);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.0.0-beta.20250503T014749",
+  "version": "4.0.0-beta.20250504T215252",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
@@ -70,7 +70,7 @@
     }
   },
   "dependencies": {
-    "@zod/core": "0.10.1"
+    "@zod/core": "0.11.0"
   },
   "scripts": {
     "clean": "rm -rf dist",