@@ -0,0 +1,35 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+
+type DeepPartialValue<T> = T extends Date | RegExp | ((...args: any[]) => any)
+  ? T
+  : T extends ReadonlyArray<infer U>
+    ? T extends unknown[]
+      ? DeepPartialValue<U>[]
+      : ReadonlyArray<DeepPartialValue<U>>
+    : T extends object
+      ? { [K in keyof T]?: DeepPartialValue<T[K]> }
+      : T;
+
+/**
+ * Returns a schema where every nested object's properties are made
+ * optional, recursively. Built on {@link core.mapOnSchema}; terminates
+ * on lazy cycles and visits shared sub-schemas once. Non-object nodes
+ * (primitives, transforms, refinements, etc.) are left untouched.
+ */
+export function deepPartial<T extends core.$ZodType>(
+  schema: T
+): schemas.ZodType<DeepPartialValue<core.output<T>>, DeepPartialValue<core.input<T>>> {
+  return core.mapOnSchema(schema, (s) => {
+    const def = s._zod.def as any;
+    if (def.type === "object") return (s as schemas.ZodObject).partial();
+    // Discriminated unions: making the discriminator optional collapses
+    // the fast-path lookup (duplicate `undefined` discriminator). Fall
+    // back to a plain `union` over the already-partialed options, which
+    // still validates correctly via try-each.
+    if (def.type === "union" && def.discriminator !== undefined) {
+      return schemas.union(def.options);
+    }
+    return s;
+  }) as any;
+}
@@ -32,6 +32,8 @@ export {
 } from "../core/index.js";
 export { toJSONSchema } from "../core/json-schema-processors.js";
 export { fromJSONSchema } from "./from-json-schema.js";
+export { deepPartial } from "./deep-partial.js";
+export { mapOnSchema } from "../core/map-on-schema.js";
 
 export * as locales from "../locales/index.js";
 
 
@@ -0,0 +1,196 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import * as z from "zod";
+import * as core from "../../core/index.js";
+import { deepPartial } from "../deep-partial.js";
+
+const { mapOnSchema } = core;
+
+describe("deepPartial", () => {
+  test("makes shallow object optional", () => {
+    const schema = z.object({ a: z.string(), b: z.number() });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ a: "x" })).toEqual({ a: "x" });
+    expect(partial.parse({ a: "x", b: 1 })).toEqual({ a: "x", b: 1 });
+  });
+
+  test("makes nested object optional at every level", () => {
+    const schema = z.object({
+      name: z.string(),
+      profile: z.object({
+        bio: z.string(),
+        age: z.number(),
+      }),
+    });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ profile: {} })).toEqual({ profile: {} });
+    expect(partial.parse({ profile: { bio: "x" } })).toEqual({ profile: { bio: "x" } });
+  });
+
+  test("recurses through arrays", () => {
+    const schema = z.object({ items: z.array(z.object({ a: z.string(), b: z.number() })) });
+    const partial = deepPartial(schema);
+    expect(partial.parse({ items: [{}, { a: "x" }] })).toEqual({ items: [{}, { a: "x" }] });
+  });
+
+  test("recurses through tuples and rest", () => {
+    const schema = z.tuple([z.object({ a: z.string() }), z.object({ b: z.number() })], z.object({ c: z.boolean() }));
+    const partial = deepPartial(schema);
+    expect(partial.parse([{}, {}])).toEqual([{}, {}]);
+    expect(partial.parse([{}, {}, {}])).toEqual([{}, {}, {}]);
+  });
+
+  test("recurses through unions", () => {
+    const schema = z.union([z.object({ a: z.string() }), z.object({ b: z.number() })]);
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("recurses through optional/nullable wrappers", () => {
+    const schema = z.object({ x: z.object({ a: z.string() }).optional() });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ x: {} })).toEqual({ x: {} });
+  });
+
+  test("terminates on recursive (lazy) schemas", () => {
+    const Node: z.ZodType = z.object({
+      name: z.string(),
+      children: z.array(z.lazy(() => Node)).optional(),
+    });
+    const partial = deepPartial(Node);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ name: "root", children: [{ name: "child" }] })).toEqual({
+      name: "root",
+      children: [{ name: "child" }],
+    });
+    expect(partial.parse({ children: [{}] })).toEqual({ children: [{}] });
+  });
+
+  test("preserves primitives at leaves", () => {
+    const schema = z.object({ a: z.string().min(1), b: z.number().int() });
+    const partial = deepPartial(schema);
+    expect(() => partial.parse({ a: "" })).toThrow();
+    expect(() => partial.parse({ b: 1.5 })).toThrow();
+    expect(partial.parse({ a: "ok", b: 1 })).toEqual({ a: "ok", b: 1 });
+  });
+
+  test("keyof preserved on output type", () => {
+    const schema = z.object({
+      name: z.string(),
+      profile: z.object({ bio: z.string() }),
+    });
+    type Out = z.output<typeof schema> extends infer X ? X : never;
+    const partial = deepPartial(schema);
+    type PartialOut = z.output<typeof partial>;
+    expectTypeOf<keyof PartialOut>().toEqualTypeOf<keyof Out>();
+  });
+
+  test("3-level deep nesting", () => {
+    const schema = z.object({
+      a: z.object({
+        b: z.object({
+          c: z.object({ d: z.string() }),
+        }),
+      }),
+    });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ a: {} })).toEqual({ a: {} });
+    expect(partial.parse({ a: { b: { c: {} } } })).toEqual({ a: { b: { c: {} } } });
+  });
+
+  test("discriminated union: degrades to plain union (discriminator becomes optional)", () => {
+    const schema = z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("a"), a: z.string() }),
+      z.object({ kind: z.literal("b"), b: z.number() }),
+    ]);
+    const partial = deepPartial(schema);
+    expect(partial.parse({ kind: "a", a: "x" })).toEqual({ kind: "a", a: "x" });
+    expect(partial.parse({ kind: "b", b: 1 })).toEqual({ kind: "b", b: 1 });
+    // With discriminator partial, an empty object matches the first option.
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("intersection", () => {
+    const schema = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ a: "x" })).toEqual({ a: "x" });
+    expect(partial.parse({ b: 1 })).toEqual({ b: 1 });
+  });
+
+  test("record / map / set value schemas are recursed", () => {
+    const rec = deepPartial(z.record(z.string(), z.object({ a: z.string() })));
+    expect(rec.parse({ k: {} })).toEqual({ k: {} });
+
+    const m = deepPartial(z.map(z.string(), z.object({ a: z.string() })));
+    expect(m.parse(new Map([["k", {}]]))).toEqual(new Map([["k", {}]]));
+
+    const s = deepPartial(z.set(z.object({ a: z.string() })));
+    expect(s.parse(new Set([{}]))).toEqual(new Set([{}]));
+  });
+
+  test("wrapper composition (optional + default + readonly)", () => {
+    const schema = z.object({
+      x: z
+        .object({ a: z.string() })
+        .default({ a: "hi" })
+        .readonly(),
+    });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({ x: { a: "hi" } });
+    expect(partial.parse({ x: {} })).toEqual({ x: {} });
+  });
+
+  test("transform standalone is left untouched", () => {
+    const schema = z.object({ a: z.string().transform((s) => s.length) });
+    const partial = deepPartial(schema);
+    expect(partial.parse({ a: "hi" })).toEqual({ a: 2 });
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("pipe input and output are both recursed", () => {
+    const schema = z
+      .object({ a: z.string() })
+      .pipe(z.object({ a: z.string() }));
+    const partial = deepPartial(schema);
+    // Both sides of the pipe should accept missing fields.
+    expect(partial.parse({})).toEqual({});
+  });
+});
+
+describe("mapOnSchema", () => {
+  test("identity rewrite preserves parse semantics", () => {
+    const schema = z.object({ a: z.string(), nested: z.object({ b: z.number() }) });
+    const same = mapOnSchema(schema, (s) => s);
+    expect(same.parse({ a: "x", nested: { b: 1 } })).toEqual({ a: "x", nested: { b: 1 } });
+  });
+
+  test("can target a specific def.type", () => {
+    const schema = z.object({ a: z.string(), b: z.number() });
+    const allStrings = mapOnSchema(schema, (s) => (s._zod.def.type === "number" ? z.string() : s));
+    expect(allStrings.parse({ a: "x", b: "y" } as any)).toEqual({ a: "x", b: "y" });
+  });
+
+  test("visits shared sub-schema only once", () => {
+    // schema has 3 unique nodes: schema, inner (referenced twice), inner.shape.a (z.string()).
+    const inner = z.object({ a: z.string() });
+    const schema = z.object({ x: inner, y: inner });
+    let calls = 0;
+    mapOnSchema(schema, (s) => {
+      calls++;
+      return s;
+    });
+    expect(calls).toBe(3);
+  });
+
+  test("unknown def.type falls through unchanged", () => {
+    const customSchema: any = z.string();
+    customSchema._zod.def = { ...customSchema._zod.def, type: "myCustomType" };
+    const result = mapOnSchema(customSchema, (s) => s);
+    expect(result).toBe(customSchema);
+  });
+});
+
@@ -14,3 +14,4 @@ export * from "./to-json-schema.js";
 export { toJSONSchema } from "./json-schema-processors.js";
 export { JSONSchemaGenerator } from "./json-schema-generator.js";
 export * as JSONSchema from "./json-schema.js";
+export { mapOnSchema } from "./map-on-schema.js";
@@ -0,0 +1,89 @@
+// Traversal pattern adapted from Jaen's v3 `mapOnSchema` (Apache-2.0):
+// https://gist.github.com/jaens/7e15ae1984bb338c86eb5e452dee3010
+
+import { clone } from "./util.js";
+import type * as schemas from "./schemas.js";
+
+const RESOLVING: unique symbol = Symbol("mapOnSchema/resolving");
+type Resolving = typeof RESOLVING;
+
+type AnyZod = schemas.$ZodType;
+
+/**
+ * Bottom-up rewrite of a schema tree. `fn` runs on every node after its
+ * children have been mapped; the returned schema replaces the node.
+ * Shared sub-schemas are visited once. Direct (non-`lazy`) cycles throw.
+ *
+ * Dispatches on `_zod.def.type`, not `instanceof`, so user-defined
+ * schema types pass through. Override custom types from inside `fn`.
+ */
+export function mapOnSchema<T extends AnyZod>(schema: T, fn: (s: AnyZod) => AnyZod): T {
+  const cache = new Map<AnyZod, AnyZod | Resolving>();
+
+  function visit(s: AnyZod): AnyZod {
+    const cached = cache.get(s);
+    if (cached === RESOLVING) {
+      throw new Error("mapOnSchema: encountered a non-lazy schema cycle");
+    }
+    if (cached !== undefined) return cached;
+    cache.set(s, RESOLVING);
+    const mapped = fn(mapInner(s));
+    cache.set(s, mapped);
+    return mapped;
+  }
+
+  function patch(s: AnyZod, p: object): AnyZod {
+    return clone(s, { ...s._zod.def, ...p });
+  }
+
+  function mapInner(s: AnyZod): AnyZod {
+    const def = s._zod.def as any;
+    switch (def.type as schemas.$ZodTypeDef["type"]) {
+      case "object": {
+        const oldShape = def.shape as Record<string, AnyZod>;
+        const newShape: Record<string, AnyZod> = {};
+        for (const k in oldShape) newShape[k] = visit(oldShape[k]!);
+        return patch(s, { shape: newShape });
+      }
+      case "array":
+        return patch(s, { element: visit(def.element) });
+      case "tuple": {
+        const items = (def.items as AnyZod[]).map(visit);
+        const rest = def.rest ? visit(def.rest) : def.rest;
+        return patch(s, { items, rest });
+      }
+      case "record":
+      case "map":
+        return patch(s, { keyType: visit(def.keyType), valueType: visit(def.valueType) });
+      case "set":
+        return patch(s, { valueType: visit(def.valueType) });
+      case "union":
+        return patch(s, { options: (def.options as AnyZod[]).map(visit) });
+      case "intersection":
+        return patch(s, { left: visit(def.left), right: visit(def.right) });
+      case "optional":
+      case "nullable":
+      case "default":
+      case "prefault":
+      case "catch":
+      case "readonly":
+      case "nonoptional":
+      case "promise":
+      case "success":
+        return patch(s, { innerType: visit(def.innerType) });
+      case "pipe":
+        return patch(s, { in: visit(def.in), out: visit(def.out) });
+      case "function":
+        return patch(s, { input: visit(def.input), output: visit(def.output) });
+      case "lazy": {
+        const original = def.getter as () => AnyZod;
+        return patch(s, { getter: () => visit(original()) });
+      }
+      // Leaves: nothing to recurse into.
+      default:
+        return s;
+    }
+  }
+
+  return fn(mapInner(schema)) as T;
+}
@@ -0,0 +1,26 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+
+type DeepPartialValue<T> = T extends Date | RegExp | ((...args: any[]) => any)
+  ? T
+  : T extends ReadonlyArray<infer U>
+    ? T extends unknown[]
+      ? DeepPartialValue<U>[]
+      : ReadonlyArray<DeepPartialValue<U>>
+    : T extends object
+      ? { [K in keyof T]?: DeepPartialValue<T[K]> }
+      : T;
+
+/** See `classic/deep-partial.ts`. Mini variant uses `mini.partial(...)`. */
+export function deepPartial<T extends core.$ZodType>(
+  schema: T
+): schemas.ZodMiniType<DeepPartialValue<core.output<T>>, DeepPartialValue<core.input<T>>> {
+  return core.mapOnSchema(schema, (s) => {
+    const def = s._zod.def as any;
+    if (def.type === "object") return schemas.partial(s as schemas.ZodMiniObject);
+    if (def.type === "union" && def.discriminator !== undefined) {
+      return schemas.union(def.options);
+    }
+    return s;
+  }) as any;
+}
@@ -2,6 +2,8 @@ export * as core from "../core/index.js";
 export * from "./parse.js";
 export * from "./schemas.js";
 export * from "./checks.js";
+export { deepPartial } from "./deep-partial.js";
+export { mapOnSchema } from "../core/map-on-schema.js";
 
 export type { infer, output, input } from "../core/index.js";
 export type { JSONType } from "../core/util.js";