@openclaw/discord 2026.7.2-beta.2 → 2026.7.2-beta.4

package/node_modules/zod/src/v4/core/checks.ts

@@ -13,7 +13,7 @@ export interface $ZodCheckDef {
   error?: errors.$ZodErrorMap<never> | undefined;
   /** If true, no later checks will be executed if this check fails. Default `false`. */
   abort?: boolean | undefined;
-  /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
+  /** If provided, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
   when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 
@@ -84,7 +84,7 @@ export const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan> = /*@__PURE
       payload.issues.push({
         origin,
         code: "too_big",
-        maximum: def.value as number,
+        maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
         input: payload.value,
         inclusive: def.inclusive,
         inst,
@@ -135,7 +135,7 @@ export const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan> = /*@
       payload.issues.push({
         origin,
         code: "too_small",
-        minimum: def.value as number,
+        minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
         input: payload.value,
         inclusive: def.inclusive,
         inst,
@@ -297,6 +297,7 @@ export const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat> = /
             expected: origin,
             format: def.format,
             code: "invalid_type",
+            continue: false,
             input,
             inst,
           });
@@ -322,6 +323,7 @@ export const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat> = /
               note: "Integers must be within the safe integer range.",
               inst,
               origin,
+              inclusive: true,
               continue: !def.abort,
             });
           } else {
@@ -333,6 +335,7 @@ export const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat> = /
               note: "Integers must be within the safe integer range.",
               inst,
               origin,
+              inclusive: true,
               continue: !def.abort,
             });
           }
@@ -359,7 +362,9 @@ export const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat> = /
           input,
           code: "too_big",
           maximum,
+          inclusive: true,
           inst,
+          continue: !def.abort,
         } as any);
       }
     };
@@ -421,7 +426,9 @@ export const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat> = /
           input,
           code: "too_big",
           maximum,
+          inclusive: true,
           inst,
+          continue: !def.abort,
         } as any);
       }
     };
@@ -469,6 +476,7 @@ export const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize> = /*@__PURE__
         origin: util.getSizableOrigin(input),
         code: "too_big",
         maximum: def.maximum,
+        inclusive: true,
         input,
         inst,
         continue: !def.abort,
@@ -518,6 +526,7 @@ export const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize> = /*@__PURE__
         origin: util.getSizableOrigin(input),
         code: "too_small",
         minimum: def.minimum,
+        inclusive: true,
         input,
         inst,
         continue: !def.abort,
@@ -1128,12 +1137,12 @@ export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
   mime: util.MimeTypes[];
 }
 
-export interface $ZodCheckMimeTypeInternals<T extends File = File> extends $ZodCheckInternals<T> {
+export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
   def: $ZodCheckMimeTypeDef;
   issc: errors.$ZodIssueInvalidValue;
 }
 
-export interface $ZodCheckMimeType<T extends File = File> extends $ZodCheck<T> {
+export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
   _zod: $ZodCheckMimeTypeInternals<T>;
 }
 
@@ -1152,6 +1161,7 @@ export const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType> = /*@__PURE
         values: def.mime,
         input: payload.value.type,
         inst,
+        continue: !def.abort,
       });
     };
   }

package/node_modules/zod/src/v4/core/core.ts

@@ -10,7 +10,7 @@ export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
 }
 
 /** A special constant with type `never` */
-export const NEVER: never = Object.freeze({
+export const NEVER: never = /*@__PURE__*/ Object.freeze({
   status: "aborted",
 }) as never;
 
@@ -20,21 +20,34 @@ export /*@__NO_SIDE_EFFECTS__*/ function $constructor<T extends ZodTrait, D = T[
   params?: { Parent?: typeof Class }
 ): $constructor<T, D> {
   function init(inst: T, def: D) {
-    Object.defineProperty(inst, "_zod", {
-      value: inst._zod ?? {},
-      enumerable: false,
-    });
+    if (!inst._zod) {
+      Object.defineProperty(inst, "_zod", {
+        value: {
+          def,
+          constr: _,
+          traits: new Set(),
+        },
+        enumerable: false,
+      });
+    }
 
-    inst._zod.traits ??= new Set();
+    if (inst._zod.traits.has(name)) {
+      return;
+    }
 
     inst._zod.traits.add(name);
+
     initializer(inst, def);
+
     // support prototype modifications
-    for (const k in _.prototype) {
-      if (!(k in inst)) Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+    const proto = _.prototype;
+    const keys = Object.keys(proto);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i]!;
+      if (!(k in inst)) {
+        (inst as any)[k] = proto[k].bind(inst);
+      }
     }
-    inst._zod.constr = _;
-    inst._zod.def = def;
   }
 
   // doesn't work if Parent has a constructor with arguments
@@ -69,8 +82,18 @@ export type $brand<T extends string | number | symbol = string | number | symbol
   [$brand]: { [k in T]: true };
 };
 
-export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T &
-  Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
+export type $ZodBranded<
+  T extends schemas.SomeType,
+  Brand extends string | number | symbol,
+  Dir extends "in" | "out" | "inout" = "out",
+> = T &
+  (Dir extends "inout"
+    ? { _zod: { input: input<T> & $brand<Brand>; output: output<T> & $brand<Brand> } }
+    : Dir extends "in"
+      ? { _zod: { input: input<T> & $brand<Brand> } }
+      : { _zod: { output: output<T> & $brand<Brand> } });
+
+export type $ZodNarrow<T extends schemas.SomeType, Out> = T & { _zod: { output: Out } };
 
 export class $ZodAsyncError extends Error {
   constructor() {
@@ -78,40 +101,21 @@ export class $ZodAsyncError extends Error {
   }
 }
 
+export class $ZodEncodeError extends Error {
+  constructor(name: string) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
+    this.name = "ZodEncodeError";
+  }
+}
+
 ////////////////////////////  TYPE HELPERS  ///////////////////////////////////
 
 // export type input<T extends schemas.$ZodType> = T["_zod"]["input"];
 // export type output<T extends schemas.$ZodType> = T["_zod"]["output"];
 // export type input<T extends schemas.$ZodType> = T["_zod"]["input"];
 // export type output<T extends schemas.$ZodType> = T["_zod"]["output"];
-export type input<T> = T extends { _zod: { input: any } } ? Required<T["_zod"]>["input"] : unknown;
-export type output<T> = T extends { _zod: { output: any } } ? Required<T["_zod"]>["output"] : unknown;
-
-// Mk2
-// export type input<T> = T extends { _zod: { "~input": any } }
-//   ? T["_zod"]["~input"]
-//   : T extends { _zod: { input: any } }
-//     ? T["_zod"]["input"]
-//     : never;
-// export type output<T> = T extends { _zod: { "~output": any } }
-//   ? T["_zod"]["~output"]
-//   : T extends { _zod: { output: any } }
-//     ? T["_zod"]["output"]
-//     : never;
-// Mk 3
-// export type input<T extends schemas.$ZodType> = T["_zod"]["input"];
-// export type output<T extends schemas.$ZodType> = T["_zod"]["output"];
-// Mk 4
-// export type input<T extends schemas.$ZodType> = T[] extends { _zod: { "~input": any } }
-//   ? T["_zod"]["~input"]
-//   : T extends { _zod: { input: any } }
-//     ? T["_zod"]["input"]
-//     : never;
-// export type output<T extends schemas.$ZodType> = T extends { _zod: { "~output": any } }
-//   ? T["_zod"]["~output"]
-//   : T extends { _zod: { output: any } }
-//     ? T["_zod"]["output"]
-//     : never;
+export type input<T> = T extends { _zod: { input: any } } ? T["_zod"]["input"] : unknown;
+export type output<T> = T extends { _zod: { output: any } } ? T["_zod"]["output"] : unknown;
 
 export type { output as infer };
 
@@ -126,7 +130,22 @@ export interface $ZodConfig {
   jitless?: boolean | undefined;
 }
 
-export const globalConfig: $ZodConfig = {};
+interface GlobalThisWithConfig {
+  /**
+   * The globalConfig instance shared across both CommonJS and ESM builds.
+   * Attached to `globalThis` (mirroring `__zod_globalRegistry`) so that a
+   * single config object is used regardless of how Zod is loaded — CJS,
+   * ESM, multiple bundles in a monorepo, etc. This means `z.config(...)`
+   * applied against any one instance is observed by all of them, and
+   * pre-populating it before Zod loads (e.g. `globalThis.__zod_globalConfig
+   * = { jitless: true }` in an inline script) takes effect immediately on
+   * import.
+   */
+  __zod_globalConfig?: $ZodConfig;
+}
+
+(globalThis as GlobalThisWithConfig).__zod_globalConfig ??= {};
+export const globalConfig: $ZodConfig = (globalThis as GlobalThisWithConfig).__zod_globalConfig!;
 
 export function config(newConfig?: Partial<$ZodConfig>): $ZodConfig {
   if (newConfig) Object.assign(globalConfig, newConfig);

package/node_modules/zod/src/v4/core/doc.ts

@@ -33,12 +33,12 @@ export class Doc {
     }
   }
 
-  compile() {
+  compile(): any {
     const F = Function;
     const args = this?.args;
     const content = this?.content ?? [``];
     const lines = [...content.map((x) => `  ${x}`)];
     // console.log(lines.join("\n"));
-    return new F(...args, lines.join("\n"));
+    return new F(...args, lines.join("\n")) as any;
   }
 }

package/node_modules/zod/src/v4/core/errors.ts

@@ -1,6 +1,7 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
+import type { StandardSchemaV1 } from "./standard-schema.js";
 import * as util from "./util.js";
 
 ///////////////////////////
@@ -11,16 +12,39 @@ export interface $ZodIssueBase {
   readonly input?: unknown;
   readonly path: PropertyKey[];
   readonly message: string;
-  // [k: string]: unknown;
 }
 
 ////////////////////////////////
 ////     issue subtypes     ////
 ////////////////////////////////
+export type $ZodInvalidTypeExpected =
+  | "string"
+  | "number"
+  | "int"
+  | "boolean"
+  | "bigint"
+  | "symbol"
+  | "undefined"
+  | "null"
+  | "never"
+  | "void"
+  | "date"
+  | "array"
+  | "object"
+  | "tuple"
+  | "record"
+  | "map"
+  | "set"
+  | "file"
+  | "nonoptional"
+  | "nan"
+  | "function"
+  | (string & {}); // class names for instanceof
+
 export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_type";
-  readonly expected: $ZodType["_zod"]["def"]["type"];
-  readonly input: Input;
+  readonly expected: $ZodInvalidTypeExpected;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
@@ -29,7 +53,7 @@ export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
   readonly maximum: number | bigint;
   readonly inclusive?: boolean;
   readonly exact?: boolean;
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
@@ -40,39 +64,52 @@ export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
   readonly inclusive?: boolean;
   /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
   readonly exact?: boolean;
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
   readonly code: "invalid_format";
   readonly format: $ZodStringFormats | (string & {});
   readonly pattern?: string;
-  readonly input: string;
+  readonly input?: string;
 }
 
 export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
   readonly code: "not_multiple_of";
   readonly divisor: number;
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
   readonly code: "unrecognized_keys";
   readonly keys: string[];
-  readonly input: Record<string, unknown>;
+  readonly input?: Record<string, unknown>;
 }
 
-export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
   readonly code: "invalid_union";
   readonly errors: $ZodIssue[][];
-  readonly input: unknown;
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly options?: util.Primitive[];
+  readonly inclusive?: true;
+}
+
+interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: [];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive: false;
 }
 
+export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
+
 export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_key";
   readonly origin: "map" | "record";
   readonly issues: $ZodIssue[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
@@ -80,19 +117,19 @@ export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase
   readonly origin: "map" | "set";
   readonly key: unknown;
   readonly issues: $ZodIssue[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_value";
   readonly values: util.Primitive[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueCustom extends $ZodIssueBase {
   readonly code: "custom";
   readonly params?: Record<string, any> | undefined;
-  readonly input: unknown;
+  readonly input?: unknown;
 }
 
 ////////////////////////////////////////////
@@ -155,17 +192,21 @@ export type $ZodIssue =
 
 export type $ZodIssueCode = $ZodIssue["code"];
 
-export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = util.Flatten<
-  util.MakePartial<T, "message" | "path"> & {
-    /** The input data */
-    readonly input?: unknown;
-    /** The schema or check that originated this issue. */
-    readonly inst?: $ZodType | $ZodCheck;
-    /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
-    readonly continue?: boolean | undefined;
-  } & Record<string, any>
->;
+export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any
+  ? util.Flatten<
+      util.MakePartial<T, "message" | "path"> & {
+        /** The input data */
+        readonly input: unknown;
+        /** The schema or check that originated this issue. */
+        readonly inst?: $ZodType | $ZodCheck;
+        /** If `true`, Zod will continue executing checks/refinements after this issue. */
+        readonly continue?: boolean | undefined;
+      } & Record<string, unknown>
+    >
+  : never;
+
+export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
 
 export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
   // biome-ignore lint:
@@ -196,13 +237,8 @@ const initializer = (inst: $ZodError, def: $ZodIssue[]): void => {
     value: def,
     enumerable: false,
   });
-  Object.defineProperty(inst, "message", {
-    get() {
-      return JSON.stringify(def, util.jsonStringifyReplacer, 2);
-    },
-    enumerable: true,
-    // configurable: false,
-  });
+  inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
+
   Object.defineProperty(inst, "toString", {
     value: () => inst.message,
     enumerable: false,
@@ -226,9 +262,9 @@ type _FlattenedError<T, U = string> = {
 
 export function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
 export function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
-export function flattenError(error: $ZodError, mapper = (issue: $ZodIssue) => issue.message): any {
-  const fieldErrors: any = {};
-  const formErrors: any[] = [];
+export function flattenError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIssue) => issue.message as U) {
+  const fieldErrors: Record<PropertyKey, any> = {};
+  const formErrors: U[] = [];
   for (const sub of error.issues) {
     if (sub.path.length > 0) {
       fieldErrors[sub.path[0]!] = fieldErrors[sub.path[0]!] || [];
@@ -254,39 +290,37 @@ export type $ZodFormattedError<T, U = string> = {
 
 export function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
 export function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
-export function formatError<T>(error: $ZodError, _mapper?: any) {
-  const mapper: (issue: $ZodIssue) => any =
-    _mapper ||
-    function (issue: $ZodIssue) {
-      return issue.message;
-    };
+export function formatError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIssue) => issue.message as U) {
   const fieldErrors: $ZodFormattedError<T> = { _errors: [] } as any;
-  const processError = (error: { issues: $ZodIssue[] }) => {
+  const processError = (error: { issues: $ZodIssue[] }, path: PropertyKey[] = []) => {
     for (const issue of error.issues) {
       if (issue.code === "invalid_union" && issue.errors.length) {
-        issue.errors.map((issues) => processError({ issues }));
+        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
       } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues });
+        processError({ issues: issue.issues }, [...path, ...issue.path]);
       } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues });
-      } else if (issue.path.length === 0) {
-        (fieldErrors as any)._errors.push(mapper(issue));
+        processError({ issues: issue.issues }, [...path, ...issue.path]);
       } else {
-        let curr: any = fieldErrors;
-        let i = 0;
-        while (i < issue.path.length) {
-          const el = issue.path[i]!;
-          const terminal = i === issue.path.length - 1;
-
-          if (!terminal) {
-            curr[el] = curr[el] || { _errors: [] };
-          } else {
-            curr[el] = curr[el] || { _errors: [] };
-            curr[el]._errors.push(mapper(issue));
+        const fullpath = [...path, ...issue.path];
+        if (fullpath.length === 0) {
+          (fieldErrors as any)._errors.push(mapper(issue));
+        } else {
+          let curr: any = fieldErrors;
+          let i = 0;
+          while (i < fullpath.length) {
+            const el = fullpath[i]!;
+            const terminal = i === fullpath.length - 1;
+
+            if (!terminal) {
+              curr[el] = curr[el] || { _errors: [] };
+            } else {
+              curr[el] = curr[el] || { _errors: [] };
+              curr[el]._errors.push(mapper(issue));
+            }
+
+            curr = curr[el];
+            i++;
           }
-
-          curr = curr[el];
-          i++;
         }
       }
     }
@@ -295,32 +329,32 @@ export function formatError<T>(error: $ZodError, _mapper?: any) {
   return fieldErrors;
 }
 
-export type $ZodErrorTree<T, U = string> = T extends [any, ...any[]]
-  ? { errors: U[]; items?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
-  : T extends any[]
-    ? { errors: U[]; items?: Array<$ZodErrorTree<T[number], U>> }
-    : T extends object
-      ? { errors: U[]; properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
-      : { errors: U[] };
+export type $ZodErrorTree<T, U = string> = T extends util.Primitive
+  ? { errors: U[] }
+  : T extends [any, ...any[]]
+    ? { errors: U[]; items?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
+    : T extends any[]
+      ? { errors: U[]; items?: Array<$ZodErrorTree<T[number], U>> }
+      : T extends object
+        ? {
+            errors: U[];
+            properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U> };
+          }
+        : { errors: U[] };
 
 export function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
 export function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
-export function treeifyError<T>(error: $ZodError, _mapper?: any) {
-  const mapper: (issue: $ZodIssue) => any =
-    _mapper ||
-    function (issue: $ZodIssue) {
-      return issue.message;
-    };
-  const result: $ZodErrorTree<T> = { errors: [] } as any;
+export function treeifyError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIssue) => issue.message as U) {
+  const result: $ZodErrorTree<T, U> = { errors: [] } as any;
   const processError = (error: { issues: $ZodIssue[] }, path: PropertyKey[] = []) => {
     for (const issue of error.issues) {
       if (issue.code === "invalid_union" && issue.errors.length) {
         // regular union error
-        issue.errors.map((issues) => processError({ issues }, issue.path));
+        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
       } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues }, issue.path);
+        processError({ issues: issue.issues }, [...path, ...issue.path]);
       } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues }, issue.path);
+        processError({ issues: issue.issues }, [...path, ...issue.path]);
       } else {
         const fullpath = [...path, ...issue.path];
         if (fullpath.length === 0) {
@@ -389,8 +423,9 @@ export function treeifyError<T>(error: $ZodError, _mapper?: any) {
  *   ✖ Invalid input: expected number
  * ```
  */
-export function toDotPath(path: (string | number | symbol)[]): string {
+export function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string {
   const segs: string[] = [];
+  const path: PropertyKey[] = _path.map((seg: any) => (typeof seg === "object" ? seg.key : seg));
   for (const seg of path) {
     if (typeof seg === "number") segs.push(`[${seg}]`);
     else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
@@ -404,14 +439,10 @@ export function toDotPath(path: (string | number | symbol)[]): string {
   return segs.join("");
 }
 
-interface BaseError {
-  issues: $ZodIssueBase[];
-}
-
-export function prettifyError(error: BaseError): string {
+export function prettifyError(error: StandardSchemaV1.FailureResult): string {
   const lines: string[] = [];
   // sort by path length
-  const issues = [...error.issues].sort((a, b) => a.path.length - b.path.length);
+  const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
 
   // Process each issue
   for (const issue of issues) {

package/node_modules/zod/src/v4/core/index.ts

@@ -9,7 +9,8 @@ export * as regexes from "./regexes.js";
 export * as locales from "../locales/index.js";
 export * from "./registries.js";
 export * from "./doc.js";
-export * from "./function.js";
 export * from "./api.js";
 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";