@openclaw/matrix 2026.9.4 → 2026.9.6

package/node_modules/zod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.4.3",
+  "version": "4.6.5",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",
@@ -10,7 +10,11 @@
   "llmsFull": "https://zod.dev/llms-full.txt",
   "mcpServer": "https://mcp.inkeep.com/zod/mcp",
   "funding": "https://github.com/sponsors/colinhacks",
-  "sideEffects": false,
+  "sideEffects": [
+    "./compile.js",
+    "./compile.cjs",
+    "./src/compile.ts"
+  ],
   "files": [
     "src",
     "**/*.js",
@@ -36,6 +40,7 @@
       "./package.json": "./package.json",
       ".": "./src/index.ts",
       "./mini": "./src/mini/index.ts",
+      "./compile": "./src/compile.ts",
       "./locales": "./src/locales/index.ts",
       "./v3": "./src/v3/index.ts",
       "./v4": "./src/v4/index.ts",
@@ -47,7 +52,8 @@
     },
     "conditions": {
       "@zod/source": "src"
-    }
+    },
+    "sealCjsExports": true
   },
   "exports": {
     "./package.json": "./package.json",
@@ -63,6 +69,12 @@
       "import": "./mini/index.js",
       "require": "./mini/index.cjs"
     },
+    "./compile": {
+      "@zod/source": "./src/compile.ts",
+      "types": "./compile.d.cts",
+      "import": "./compile.js",
+      "require": "./compile.cjs"
+    },
     "./locales": {
       "@zod/source": "./src/locales/index.ts",
       "types": "./locales/index.d.cts",
@@ -126,10 +138,10 @@
   },
   "scripts": {
     "clean": "git clean -xdf . -e node_modules",
-    "build": "zshy --project tsconfig.build.json",
-    "postbuild": "tsx ../../scripts/write-stub-package-jsons.ts && pnpm biome check --write .",
-    "test:watch": "pnpm vitest",
-    "test": "pnpm vitest run",
-    "prepublishOnly": "tsx ../../scripts/check-versions.ts"
+    "build": "nub exec --node zshy --project tsconfig.build.json",
+    "postbuild": "nub ../../scripts/write-stub-package-jsons.ts && nub exec --node biome check --write .",
+    "test:watch": "nub exec --node vitest",
+    "test": "nub exec --node vitest run",
+    "prepublishOnly": "nub ../../scripts/check-versions.ts"
   }
 }

package/node_modules/zod/src/compile.ts

@@ -0,0 +1,56 @@
+// Side-effect-only: installs the post-processor on `globalConfig`. Listed in `package.json`'s `sideEffects`, and nothing else references it, so apps that never import it drop the compiler.
+//
+// Usage:
+//
+//   import "zod/compile";
+//   import * as z from "zod";
+//   // every schema constructed below this is compiled on first parse
+//
+// Module evaluation order matters: schemas constructed in modules that evaluate before this import will not be compiled. Place this import in the app entry point, before any module that constructs schemas at top level.
+//
+// Failure handling: if the compiler refuses a schema (async refinement, unsupported feature, etc.) the shim permanently restores the runtime `_zod.run` for that schema. The schema continues to work via the regular runtime parser — no observable difference to the caller.
+
+import { compile } from "./v4/core/compile.js";
+import * as core from "./v4/core/index.js";
+
+let compiling = false;
+
+core.globalConfig.postProcessor = (inst: any) => {
+  if (compiling) return;
+  const originalRun = inst._zod?.run;
+  if (typeof originalRun !== "function") return;
+
+  const shim = (payload: any, ctx: any): any => {
+    // Bypass the fast path for any non-forward / non-sync / check-skipping call. The runtime owns those contracts.
+    if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks) {
+      return originalRun(payload, ctx);
+    }
+
+    compiling = true;
+    try {
+      // Respect the jitless config: it exists precisely so CSP/no-eval environments never reach `new Function`. Global mode must not bypass it (explicit z.compile calls remain an explicit opt-in).
+      if (core.globalConfig.jitless) {
+        inst._zod.run = originalRun;
+        return originalRun(payload, ctx);
+      }
+      // Strict: the shim owns its own fallback below, and a non-strict compile would hand back `inst` — whose run is this shim — and reinstall it on itself.
+      const compiled = compile(inst, { strict: true });
+      // Only the run wrapper. Copying the compiled parse/safeParse closures would make their fallback re-enter this instance and run user callbacks a third time.
+      inst._zod.run = compiled._zod.run;
+      inst._zod.bag.fallbackRun = compiled._zod.bag.fallbackRun;
+      inst._zod.bag.validator = compiled._zod.bag.validator;
+    } catch {
+      // Permanent fallback for unsupported schemas.
+      inst._zod.run = originalRun;
+    } finally {
+      compiling = false;
+    }
+
+    return inst._zod.run(payload, ctx);
+  };
+
+  // Expose the pre-shim runtime so `compile()` invoked elsewhere can unwrap past the shim and capture the source-of-truth runtime. Without this, a user calling `z.compile(s)` after global mode is enabled would capture the shim itself, which would feed the wrapper into itself on fallback.
+  (shim as any).__originalRun = originalRun;
+
+  inst._zod.run = shim;
+};

package/node_modules/zod/src/index.ts

@@ -1,4 +1,7 @@
 import * as z from "./v4/classic/external.js";
 export * from "./v4/classic/external.js";
-export { z };
-export default z;
+// Aliasing the binding, instead of `export default z`, keeps the default export a
+// re-export of `z` rather than a fresh namespace value. Rollup and Webpack can then
+// shake `import z from "zod"` as they already shake `import { z } from "zod"` — without
+// this they pull in every locale. See #6050.
+export { z, z as default };

package/node_modules/zod/src/v3/ZodError.ts

@@ -238,21 +238,31 @@ export class ZodError<T = any> extends Error {
             const el = issue.path[i]!;
             const terminal = i === issue.path.length - 1;
 
-            if (!terminal) {
-              curr[el] = curr[el] || { _errors: [] };
-              // if (typeof el === "string") {
-              //   curr[el] = curr[el] || { _errors: [] };
-              // } else if (typeof el === "number") {
-              //   const errorArray: any = [];
-              //   errorArray._errors = [];
-              //   curr[el] = curr[el] || errorArray;
-              // }
-            } else {
-              curr[el] = curr[el] || { _errors: [] };
-              curr[el]._errors.push(mapper(issue));
+            // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
+            if (el === "_errors") {
+              if (terminal) curr._errors.push(mapper(issue));
+              i++;
+              continue;
+            }
+
+            // Create `el` as an own data property. A segment naming an inherited member ("toString", "constructor") would otherwise read through to the prototype, and assigning "__proto__" would hit the setter and walk into Object.prototype.
+            if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+              if (el === "__proto__") {
+                Object.defineProperty(curr, el, {
+                  value: { _errors: [] },
+                  writable: true,
+                  enumerable: true,
+                  configurable: true,
+                });
+              } else {
+                curr[el] = { _errors: [] };
+              }
             }
 
             curr = curr[el];
+            if (terminal) {
+              curr._errors.push(mapper(issue));
+            }
             i++;
           }
         }

package/node_modules/zod/src/v3/helpers/errorUtil.ts

@@ -2,7 +2,7 @@ export namespace errorUtil {
   export type ErrMessage = string | { message?: string | undefined };
   export const errToObj = (message?: ErrMessage): { message?: string | undefined } =>
     typeof message === "string" ? { message } : message || {};
-  // biome-ignore lint:
+  // biome-ignore lint/suspicious/noShadowRestrictedNames: renaming churns 31 v3 call sites
   export const toString = (message?: ErrMessage): string | undefined =>
     typeof message === "string" ? message : message?.message;
 }

package/node_modules/zod/src/v3/tests/error.test.ts

@@ -549,3 +549,38 @@ test("when the message is falsy, it is used as is provided", () => {
 //     expect(result.error.issues.length).toEqual(2);
 //   }
 // });
+
+test("format() handles Object.prototype names in the issue path", () => {
+  const result = z
+    .record(z.string(), z.object({ pwn: z.number() }))
+    .safeParse(JSON.parse('{"__proto__": {"pwn": "x"}}'));
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    // the node must be a real own data property, not the inherited accessor
+    const node = Object.getOwnPropertyDescriptor(result.error.format(), "__proto__")!.value;
+    expect(node.pwn._errors).toHaveLength(1);
+  }
+  expect(({} as any).pwn).toBeUndefined();
+
+  const inherited = z.record(z.string(), z.string()).safeParse(JSON.parse('{"toString": 1}'));
+  expect(inherited.success).toEqual(false);
+  if (!inherited.success) {
+    expect((inherited.error.format() as any).toString._errors).toHaveLength(1);
+  }
+});
+
+test("format() handles an input-derived _errors path", () => {
+  const result = z.object({ parent: z.record(z.string()) }).safeParse({ parent: { _errors: 1 } });
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.format().parent?._errors).toEqual(["Expected string, received number"]);
+  }
+
+  const nested = z
+    .object({ parent: z.record(z.object({ child: z.string() })) })
+    .safeParse({ parent: { _errors: { child: 1 } } });
+  expect(nested.success).toEqual(false);
+  if (!nested.success) {
+    expect((nested.error.format() as any).parent.child._errors).toEqual(["Expected string, received number"]);
+  }
+});

package/node_modules/zod/src/v3/tests/intersection.test.ts

@@ -21,6 +21,24 @@ test("object intersection", () => {
   expect(() => z.intersection(BaseTeacher.strict(), HasID).parse({ ...data, extra: 12 })).toThrow();
 });
 
+test("object intersection strips __proto__ from pass-through operands", () => {
+  const cases = [
+    [
+      z.intersection(z.object({ name: z.string() }), z.unknown()),
+      JSON.parse('{"__proto__":{"isAdmin":true},"name":"alice"}'),
+      { name: "alice" },
+    ],
+    [z.intersection(z.record(z.string(), z.unknown()), z.any()), JSON.parse('{"__proto__":{},"a":1}'), { a: 1 }],
+  ] as const;
+
+  for (const [schema, input, expected] of cases) {
+    const parsed = schema.parse(input);
+    expect(parsed).toEqual(expected);
+    expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(parsed, "__proto__")).toBe(false);
+  }
+});
+
 test("deep intersection", () => {
   const Animal = z.object({
     properties: z.object({

package/node_modules/zod/src/v3/tests/language-server.test.ts

@@ -4,8 +4,7 @@ import { test } from "vitest";
 
 // import { filePath } from "./language-server.source";
 
-// The following tool is helpful for understanding the TypeScript AST associated with these tests:
-// https://ts-ast-viewer.com/ (just copy the contents of language-server.source into the viewer)
+// The following tool is helpful for understanding the TypeScript AST associated with these tests: https://ts-ast-viewer.com/ (just copy the contents of language-server.source into the viewer)
 
 test("", () => {});
 // describe("Executing Go To Definition (and therefore Find Usages and Rename Refactoring) using an IDE works on inferred object properties", () => {

package/node_modules/zod/src/v3/tests/object.test.ts

@@ -122,14 +122,12 @@ test("catchall inference", () => {
 test("catchall overrides strict", () => {
   const o1 = z.object({ first: z.string().optional() }).strict().catchall(z.number());
 
-  // should run fine
-  // setting a catchall overrides the unknownKeys behavior
+  // should run fine setting a catchall overrides the unknownKeys behavior
   o1.parse({
     asdf: 1234,
   });
 
-  // should only run catchall validation
-  // against unknown keys
+  // should only run catchall validation against unknown keys
   o1.parse({
     first: "asdf",
     asdf: 1234,
@@ -144,8 +142,7 @@ test("catchall overrides strict", () => {
     .strict()
     .catchall(z.number());
 
-  // should run fine
-  // setting a catchall overrides the unknownKeys behavior
+  // should run fine setting a catchall overrides the unknownKeys behavior
   o1.parse({
     first: "asdf",
     asdf: 1234,

package/node_modules/zod/src/v3/tests/readonly.test.ts

@@ -61,86 +61,6 @@ test("flat inference", () => {
   util.assertEqual<z.infer<(typeof schemas)[20]>, Promise<string>>(true);
 });
 
-// test("deep inference", () => {
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[0]>, string>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[1]>, number>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[2]>, number>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[3]>, bigint>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[4]>, boolean>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[5]>, Date>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[6]>, undefined>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[7]>, null>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[8]>, any>(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[9]>,
-//     Readonly<unknown>
-//   >(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[10]>, void>(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[11]>,
-//     (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[12]>,
-//     readonly string[]
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[13]>,
-//     readonly [string, number]
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[14]>,
-//     ReadonlyMap<string, Date>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[15]>,
-//     ReadonlySet<Promise<string>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[16]>,
-//     Readonly<Record<string, string>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[17]>,
-//     Readonly<Record<string, number>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[18]>,
-//     { readonly a: string; readonly 1: number }
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[19]>,
-//     Readonly<testEnum>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[20]>,
-//     Promise<string>
-//   >(true);
-
-//   util.assertEqual<
-//     z.infer<typeof crazyDeepReadonlySchema>,
-//     ReadonlyMap<
-//       ReadonlySet<readonly [string, number]>,
-//       {
-//         readonly a: {
-//           readonly [x: string]: readonly any[];
-//         };
-//         readonly b: {
-//           readonly c: {
-//             readonly d: {
-//               readonly e: {
-//                 readonly f: {
-//                   readonly g?: {};
-//                 };
-//               };
-//             };
-//           };
-//         };
-//       }
-//     >
-//   >(true);
-// });
-
 test("object freezing", () => {
   expect(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
   expect(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);

package/node_modules/zod/src/v3/tests/string.test.ts

@@ -323,6 +323,7 @@ test("url error overrides", () => {
 test("emoji validations", () => {
   const emoji = z.string().emoji();
 
+  emoji.parse("🦰🦱🦲🦳"); // both Extended_Pictographic and Emoji_Component
   emoji.parse("👋👋👋👋");
   emoji.parse("🍺👩‍🚀🫡");
   emoji.parse("💚💙💜💛❤️");
@@ -335,6 +336,11 @@ test("emoji validations", () => {
   expect(() => emoji.parse("😀 is an emoji")).toThrow();
   expect(() => emoji.parse("😀stuff")).toThrow();
   expect(() => emoji.parse("stuff😀")).toThrow();
+
+  // a failing match over the overlapping code points used to backtrack exponentially
+  const start = performance.now();
+  expect(emoji.safeParse(`${"🦰".repeat(26)} `).success).toBe(false);
+  expect(performance.now() - start).toBeLessThan(100);
 });
 
 test("uuid", () => {

package/node_modules/zod/src/v3/types.ts

@@ -619,7 +619,7 @@ const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z
 //   /^[a-z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-z0-9-]+(?:\.[a-z0-9\-]+)*$/i;
 
 // from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
-const _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+const _emojiRegex = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
 let emojiRegex: RegExp;
 
 // faster, simpler, safer
@@ -3249,7 +3249,9 @@ function mergeValues(a: any, b: any): { valid: true; data: any } | { valid: fals
     const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
 
     const newObj: any = { ...a, ...b };
+    if (Object.prototype.hasOwnProperty.call(newObj, "__proto__")) delete newObj.__proto__;
     for (const key of sharedKeys) {
+      if (key === "__proto__") continue;
       const sharedValue = mergeValues(a[key], b[key]);
       if (!sharedValue.valid) {
         return { valid: false };
@@ -3862,8 +3864,7 @@ export class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTyp
     const fn = ctx.data;
 
     if (this._def.returns instanceof ZodPromise) {
-      // Would love a way to avoid disabling this rule, but we need
-      // an alias (using an arrow function was what caused 2651).
+      // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
       // eslint-disable-next-line @typescript-eslint/no-this-alias
       const me = this;
       return OK(async function (this: any, ...args: any[]) {
@@ -3882,8 +3883,7 @@ export class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTyp
         return parsedReturns;
       });
     } else {
-      // Would love a way to avoid disabling this rule, but we need
-      // an alias (using an arrow function was what caused 2651).
+      // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
       // eslint-disable-next-line @typescript-eslint/no-this-alias
       const me = this;
       return OK(function (this: any, ...args: any[]) {

package/node_modules/zod/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/node_modules/zod/src/v4/classic/compat.ts

@@ -3,14 +3,12 @@
 import * as core from "../core/index.js";
 import type { ZodType } from "./schemas.js";
 
-export type {
-  /** @deprecated Use `z.output<T>` instead. */
-  output as TypeOf,
-  /** @deprecated Use `z.output<T>` instead. */
-  output as Infer,
-  /** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
-  $ZodTypes as ZodFirstPartySchemaTypes,
-} from "../core/index.js";
+/** @deprecated Use `z.output<T>` instead. */
+export type TypeOf<T> = core.output<T>;
+/** @deprecated Use `z.output<T>` instead. */
+export type Infer<T> = core.output<T>;
+/** @deprecated Use `z.core.$ZodTypes` instead */
+export type ZodFirstPartySchemaTypes = core.$ZodTypes;
 
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
 export const ZodIssueCode = {
@@ -27,10 +25,10 @@ export const ZodIssueCode = {
   custom: "custom",
 } as const;
 
-/** @deprecated Use `z.$ZodFlattenedError` */
+/** @deprecated Use `z.core.$ZodFlattenedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
 
-/** @deprecated Use `z.$ZodFormattedError` */
+/** @deprecated Use `z.core.$ZodFormattedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<
   core.output<T>,
   U
@@ -54,14 +52,24 @@ export function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined {
   return core.config().customError;
 }
 
-export type {
-  /** @deprecated Use z.ZodType (without generics) instead. */
-  ZodType as ZodTypeAny,
-  /** @deprecated Use `z.ZodType` */
-  ZodType as ZodSchema,
-  /** @deprecated Use `z.ZodType` */
-  ZodType as Schema,
-};
+/** @deprecated Use z.ZodType (without generics) instead. */
+export type ZodTypeAny<
+  Output = unknown,
+  Input = unknown,
+  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
+> = ZodType<Output, Input, Internals>;
+/** @deprecated Use `z.ZodType` */
+export type ZodSchema<
+  Output = unknown,
+  Input = unknown,
+  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
+> = ZodType<Output, Input, Internals>;
+/** @deprecated Use `z.ZodType` */
+export type Schema<
+  Output = unknown,
+  Input = unknown,
+  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
+> = ZodType<Output, Input, Internals>;
 
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;

package/node_modules/zod/src/v4/classic/deep-partial.ts

@@ -0,0 +1,76 @@
+import type * as core from "../core/index.js";
+import { visit } from "../core/visit.js";
+import * as schemas from "./schemas.js";
+
+/** Distributes `.partial()` through every object in a schema type, preserving the wrappers around them. */
+// biome-ignore format: preserve vertical layout for readability.
+export type DeepPartial<T extends core.SomeType> =
+  T extends schemas.ZodObject<infer Shape, infer Config>
+    ? schemas.ZodObject<
+        { -readonly [K in keyof Shape]: schemas.ZodOptional<DeepPartial<Shape[K]>> },
+        Config
+      >
+  // Must precede ZodUnion; degrades to it, matching the runtime.
+  : T extends schemas.ZodDiscriminatedUnion<infer Options, any>
+    ? schemas.ZodUnion<
+        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
+      >
+  : T extends schemas.ZodUnion<infer Options>
+    ? schemas.ZodUnion<
+        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
+      >
+  : T extends schemas.ZodArray<infer El>
+    ? schemas.ZodArray<DeepPartial<El>>
+  : T extends schemas.ZodTuple<infer Items, infer Rest>
+    ? schemas.ZodTuple<
+        { -readonly [K in keyof Items]: Items[K] extends core.SomeType ? DeepPartial<Items[K]> : Items[K] },
+        Rest extends core.SomeType ? DeepPartial<Rest> : Rest
+      >
+  : T extends schemas.ZodIntersection<infer A, infer B>
+    ? schemas.ZodIntersection<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodRecord<infer K, infer V>
+    ? schemas.ZodRecord<K, DeepPartial<V>>
+  : T extends schemas.ZodMap<infer K, infer V>
+    ? schemas.ZodMap<K, DeepPartial<V>>
+  : T extends schemas.ZodSet<infer El>
+    ? schemas.ZodSet<DeepPartial<El>>
+  : T extends schemas.ZodOptional<infer Inner>
+    ? schemas.ZodOptional<DeepPartial<Inner>>
+  : T extends schemas.ZodNullable<infer Inner>
+    ? schemas.ZodNullable<DeepPartial<Inner>>
+  : T extends schemas.ZodDefault<infer Inner>
+    ? schemas.ZodDefault<DeepPartial<Inner>>
+  : T extends schemas.ZodPrefault<infer Inner>
+    ? schemas.ZodPrefault<DeepPartial<Inner>>
+  : T extends schemas.ZodNonOptional<infer Inner>
+    ? schemas.ZodNonOptional<DeepPartial<Inner>>
+  : T extends schemas.ZodCatch<infer Inner>
+    ? schemas.ZodCatch<DeepPartial<Inner>>
+  : T extends schemas.ZodReadonly<infer Inner>
+    ? schemas.ZodReadonly<DeepPartial<Inner>>
+  : T extends schemas.ZodSuccess<infer Inner>
+    ? schemas.ZodSuccess<DeepPartial<Inner>>
+  : T extends schemas.ZodPromise<infer Inner>
+    ? schemas.ZodPromise<DeepPartial<Inner>>
+  // Must precede ZodPipe, which both extend structurally, or the subtype is lost.
+  : T extends schemas.ZodCodec<infer A, infer B>
+    ? schemas.ZodCodec<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodPreprocess<infer B>
+    ? schemas.ZodPreprocess<DeepPartial<B>>
+  : T extends schemas.ZodPipe<infer A, infer B>
+    ? schemas.ZodPipe<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodLazy<infer Inner>
+    ? schemas.ZodLazy<DeepPartial<Inner>>
+  : T;
+
+/** Returns a copy of the schema with every nested object's properties made optional. */
+export function deepPartial<T extends core.SomeType>(schema: T): DeepPartial<T> {
+  return visit(schema, {
+    object: (s) => (s as schemas.ZodObject).partial(),
+    // Every partialed option now admits `undefined`, which the constructor rejects as a duplicate.
+    union: (s) => {
+      const def = s._zod.def as core.$ZodDiscriminatedUnionDef;
+      return def.discriminator === undefined ? s : schemas.union(def.options as schemas.ZodType[]);
+    },
+  }) as unknown as DeepPartial<T>;
+}