@openclaw/feishu 2026.9.4 → 2026.9.5

package/node_modules/zod/v4/core/util.js

@@ -6,6 +6,9 @@ export function assertEqual(val) {
 export function assertNotEqual(val) {
     return val;
 }
+export function toZod() {
+    return (schema) => schema;
+}
 export function assertIs(_arg) { }
 export function assertNever(_x) {
     throw new Error("Unexpected value in exhaustive check");
@@ -50,8 +53,8 @@ export function cleanRegex(source) {
 export function floatSafeRemainder(val, step) {
     const ratio = val / step;
     const roundedRatio = Math.round(ratio);
-    // Use a relative epsilon scaled to the magnitude of the result
-    const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
+    // `val` and `step` each round to a double before the division rounds again, so a true decimal multiple's quotient can sit up to 1.5 of these scaled epsilons from the integer. A 1x tolerance therefore rejected 2.03 as a multiple of 0.07; 4x covers the worst case with margin.
+    const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
     if (Math.abs(ratio - roundedRatio) < tolerance)
         return 0;
     return ratio - roundedRatio;
@@ -143,8 +146,7 @@ export function isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 export const allowsEval = /* @__PURE__*/ cached(() => {
-    // Skip the probe under `jitless`: strict CSPs report the caught `new Function`
-    // as a `securitypolicyviolation` even though the throw is swallowed.
+    // Skip the probe under `jitless`: strict CSPs report the caught `new Function` as a `securitypolicyviolation` even though the throw is swallowed.
     if (globalConfig.jitless) {
         return false;
     }
@@ -322,16 +324,17 @@ export function stringifyPrimitive(value) {
 }
 export function optionalKeys(shape) {
     return Object.keys(shape).filter((k) => {
-        return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+        return shape[k]._zod.optin !== undefined && shape[k]._zod.optout === "optional";
     });
 }
-export const NUMBER_FORMAT_RANGES = {
+// Wrapped in a `@__PURE__` IIFE: esbuild never tree-shakes a top-level initializer that contains a member access on `Number`, so the bare object literal survived into every bundle.
+export const NUMBER_FORMAT_RANGES = /*@__PURE__*/ (() => ({
     safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
     int32: [-2147483648, 2147483647],
     uint32: [0, 4294967295],
     float32: [-3.4028234663852886e38, 3.4028234663852886e38],
     float64: [-Number.MAX_VALUE, Number.MAX_VALUE],
-};
+}))();
 export const BIGINT_FORMAT_RANGES = {
     int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
     uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
@@ -346,13 +349,14 @@ export function pick(schema, mask) {
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = {};
-            for (const key in mask) {
-                if (!(key in currDef.shape)) {
-                    throw new Error(`Unrecognized key: "${key}"`);
+            // `for...in` skips symbols, so a symbol in the mask would select nothing
+            for (const key of Reflect.ownKeys(mask)) {
+                if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
+                    throw new Error(`Unrecognized key: "${String(key)}"`);
                 }
                 if (!mask[key])
                     continue;
-                newShape[key] = currDef.shape[key];
+                assignProp(newShape, key, currDef.shape[key]);
             }
             assignProp(this, "shape", newShape); // self-caching
             return newShape;
@@ -371,9 +375,9 @@ export function omit(schema, mask) {
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = { ...schema._zod.def.shape };
-            for (const key in mask) {
-                if (!(key in currDef.shape)) {
-                    throw new Error(`Unrecognized key: "${key}"`);
+            for (const key of Reflect.ownKeys(mask)) {
+                if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
+                    throw new Error(`Unrecognized key: "${String(key)}"`);
                 }
                 if (!mask[key])
                     continue;
@@ -393,10 +397,9 @@ export function extend(schema, shape) {
     const checks = schema._zod.def.checks;
     const hasChecks = checks && checks.length > 0;
     if (hasChecks) {
-        // Only throw if new shape overlaps with existing shape
-        // Use getOwnPropertyDescriptor to check key existence without accessing values
+        // Only throw if new shape overlaps with existing shape. Use getOwnPropertyDescriptor to check key existence without accessing values
         const existingShape = schema._zod.def.shape;
-        for (const key in shape) {
+        for (const key of Reflect.ownKeys(shape)) {
             if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
                 throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
             }
@@ -425,6 +428,9 @@ export function safeExtend(schema, shape) {
     return clone(schema, def);
 }
 export function merge(a, b) {
+    if (!b?._zod?.def) {
+        throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
+    }
     if (a._zod.def.checks?.length) {
         throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
     }
@@ -441,21 +447,21 @@ export function merge(a, b) {
     });
     return clone(a, def);
 }
-export function partial(Class, schema, mask) {
+export function partial(Class, schema, mask, name = "partial") {
     const currDef = schema._zod.def;
     const checks = currDef.checks;
     const hasChecks = checks && checks.length > 0;
     if (hasChecks) {
-        throw new Error(".partial() cannot be used on object schemas containing refinements");
+        throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
     }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const oldShape = schema._zod.def.shape;
             const shape = { ...oldShape };
             if (mask) {
-                for (const key in mask) {
-                    if (!(key in oldShape)) {
-                        throw new Error(`Unrecognized key: "${key}"`);
+                for (const key of Reflect.ownKeys(mask)) {
+                    if (!Object.prototype.hasOwnProperty.call(oldShape, key)) {
+                        throw new Error(`Unrecognized key: "${String(key)}"`);
                     }
                     if (!mask[key])
                         continue;
@@ -469,7 +475,8 @@ export function partial(Class, schema, mask) {
                 }
             }
             else {
-                for (const key in oldShape) {
+                // the spread copies symbol keys; `for...in` would not reach them
+                for (const key of Reflect.ownKeys(oldShape)) {
                     // if (oldShape[key]!._zod.optin === "optional") continue;
                     shape[key] = Class
                         ? new Class({
@@ -492,9 +499,9 @@ export function required(Class, schema, mask) {
             const oldShape = schema._zod.def.shape;
             const shape = { ...oldShape };
             if (mask) {
-                for (const key in mask) {
-                    if (!(key in shape)) {
-                        throw new Error(`Unrecognized key: "${key}"`);
+                for (const key of Reflect.ownKeys(mask)) {
+                    if (!Object.prototype.hasOwnProperty.call(shape, key)) {
+                        throw new Error(`Unrecognized key: "${String(key)}"`);
                     }
                     if (!mask[key])
                         continue;
@@ -506,7 +513,7 @@ export function required(Class, schema, mask) {
                 }
             }
             else {
-                for (const key in oldShape) {
+                for (const key of Reflect.ownKeys(oldShape)) {
                     // overwrite with non-optional
                     shape[key] = new Class({
                         type: "nonoptional",
@@ -531,8 +538,7 @@ export function aborted(x, startIndex = 0) {
     }
     return false;
 }
-// Checks for explicit abort (continue === false), as opposed to implicit abort (continue === undefined).
-// Used to respect `abort: true` in .refine() even for checks that have a `when` function.
+// Checks for explicit abort (continue === false), as opposed to implicit abort (continue === undefined). Used to respect `abort: true` in .refine() even for checks that have a `when` function.
 export function explicitlyAborted(x, startIndex = 0) {
     if (x.aborted === true)
         return true;
@@ -554,15 +560,34 @@ export function prefixIssues(path, issues) {
 export function unwrapMessage(message) {
     return typeof message === "string" ? message : message?.message;
 }
+/* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
+export function attachSchema(issues, start, inst) {
+    var _a;
+    for (let i = start; i < issues.length; i++) {
+        (_a = issues[i]).schema ?? (_a.schema = inst);
+    }
+}
 export function finalizeIssue(iss, ctx, config) {
+    var _a;
+    // A schema that raised an issue itself owns it outright, and outranks any stamp an enclosing check left in `attachSchema`. String formats and z.custom() are schema and check at once, so when they act as a check they defer to that stamp instead.
+    const traits = iss.inst?._zod?.traits;
+    if (traits?.has("$ZodType")) {
+        if (traits.has("$ZodCheck"))
+            (_a = iss).schema ?? (_a.schema = iss.inst);
+        else
+            iss.schema = iss.inst;
+    }
+    // Decreasing specificity, first map to return a message wins. `inst` is whatever raised the issue, so a check's own map outranks the owning schema's.
+    const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : undefined;
     const message = iss.message
         ? iss.message
         : (unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
+            unwrapMessage(schemaError?.(iss)) ??
             unwrapMessage(ctx?.error?.(iss)) ??
             unwrapMessage(config.customError?.(iss)) ??
             unwrapMessage(config.localeError?.(iss)) ??
             "Invalid input");
-    const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
+    const { inst: _inst, schema: _schema, continue: _continue, input: _input, ...rest } = iss;
     rest.path ?? (rest.path = []);
     rest.message = message;
     if (ctx?.reportInput) {
@@ -580,6 +605,21 @@ export function getSizableOrigin(input) {
         return "file";
     return "unknown";
 }
+const highSurrogate = /[\uD800-\uDBFF]/;
+// Code points in `str`: a surrogate pair counts once, a lone surrogate as itself. Hand-rolled because the string iterator allocates and runs ~250x slower on this path; the regex probe exits ~50x quicker for a string with no astral characters.
+export function codePointLength(str) {
+    const units = str.length;
+    if (!highSurrogate.test(str))
+        return units;
+    let count = units;
+    for (let i = 0; i < units - 1; i++) {
+        if ((str.charCodeAt(i) & 0xfc00) === 0xd800 && (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
+            count--;
+            i++;
+        }
+    }
+    return count;
+}
 export function getLengthableOrigin(input) {
     if (Array.isArray(input))
         return "array";
@@ -672,3 +712,135 @@ export function uint8ArrayToHex(bytes) {
 export class Class {
     constructor(..._args) { }
 }
+//////////    PROTOTYPE INSTALLERS     //////////
+//
+// Members live on the prototype and materialize per instance on first read, which keeps own-property count under the step where V8 stops using inline slots. Changing anything here means re-measuring runtime, memory and bundle size together — see "The three axes" in AGENTS.md.
+/**
+ * Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
+ *
+ * Call this from a `proto` initializer, which runs once per prototype — never per instance.
+ */
+export function members(proto, table) {
+    for (const key in table) {
+        const desc = Object.getOwnPropertyDescriptor(table, key);
+        // a getter installs as written, so it stays live: `description` reads through to the registry on every access. not enumerable: an object literal's is, and a prototype member never was
+        if (desc.get)
+            Object.defineProperty(proto, key, { ...desc, enumerable: false });
+        // a method materializes bound on first read, which is what keeps a detached member working: `const opt = schema.optional; opt()`
+        else
+            defineBound(proto, key, desc.value);
+    }
+}
+/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
+export function own(inst, key, value, enumerable = true) {
+    Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
+    return value;
+}
+/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
+export function hide(inst, key, value) {
+    return own(inst, key, value, false);
+}
+function defineBound(proto, key, fn) {
+    Object.defineProperty(proto, key, {
+        configurable: true,
+        get() {
+            // vitest's spyOn calls a prototype getter bare to find the function it wraps, so a nullish receiver answers the raw method
+            return this == null ? fn : own(this, key, fn.bind(this));
+        },
+        set(value) {
+            own(this, key, value);
+        },
+    });
+}
+/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */
+function claim(inst, sentinel) {
+    const proto = Object.getPrototypeOf(inst);
+    // Runs on every construction, so `in` rather than the costlier `hasOwnProperty.call`. Sentinels are keys the group itself defines.
+    return sentinel in proto ? undefined : proto;
+}
+// The internals whose init chain is installing. A second call for the same one is a derived constructor overriding its base, so it must not construct another schema in between or the override is dropped.
+let installing;
+// Set while a getter is running, so a value that resolved through a recursion break is not memoized. One shared descriptor shadows the key for the duration, which costs no per-key allocation.
+let broke = false;
+const breaker = {
+    configurable: true,
+    get() {
+        broke = true;
+        return undefined;
+    },
+};
+/**
+ * Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
+ * constructor, computed from the internals object itself and cached there on
+ * first read. One accessor per constructor rather than one per instance.
+ */
+export function defineLazyInternal(inst, key, compute) {
+    const proto = Object.getPrototypeOf(inst._zod);
+    if (key in proto && installing !== inst._zod) {
+        // A repeat construction: everything is installed already. Cleared here so the reference is not held past the first construction of every type.
+        installing = undefined;
+        return;
+    }
+    installing = inst._zod;
+    Object.defineProperty(proto, key, {
+        configurable: true,
+        get() {
+            // Shadowed before computing so a re-entrant read from a recursive schema resolves to undefined instead of running the getter again.
+            Object.defineProperty(this, key, breaker);
+            const outer = broke;
+            broke = false;
+            try {
+                const value = compute(this);
+                // A result that resolved through a recursion break is recomputed once the graph is complete; everything else memoizes, undefined included.
+                if (broke)
+                    delete this[key];
+                else
+                    Object.defineProperty(this, key, { configurable: true, writable: true, value });
+                broke = broke || outer;
+                return value;
+            }
+            catch (err) {
+                // A compute that threw memoizes nothing, so a later read runs it again and fails the same way. The shadow goes with it, since leaving it installed would answer undefined for every later read.
+                delete this[key];
+                broke = broke || outer;
+                throw err;
+            }
+        },
+        set(value) {
+            Object.defineProperty(this, key, { configurable: true, writable: true, value });
+        },
+    });
+}
+/**
+ * Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
+ * data property. One accessor per constructor rather than one per instance, because an own accessor
+ * puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
+ */
+export function installLazyProp(inst, key, make, enumerable) {
+    const proto = claim(inst, key);
+    if (!proto)
+        return;
+    Object.defineProperty(proto, key, {
+        configurable: true,
+        get() {
+            // Shadowed before computing, so a re-entrant read from a self-referential shape resolves to undefined instead of running the getter again. A data property rather than an accessor: an own accessor is the dictionary-mode transition this exists to avoid.
+            const desc = { configurable: true, writable: true, enumerable, value: undefined };
+            Object.defineProperty(this, key, desc);
+            // a compute that throws leaves the shadow behind, so later reads answer undefined instead of re-throwing; `defineLazy` did the same, and `defineLazyInternal`'s delete-on-catch would cost bytes in every bundle for a case only a throwing user getter reaches
+            desc.value = make(this);
+            Object.defineProperty(this, key, desc);
+            return desc.value;
+        },
+        set(value) {
+            Object.defineProperty(this, key, { configurable: true, writable: true, enumerable, value });
+        },
+    });
+}
+/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */
+export const CONSTANT_CATCH = "~constantCatch";
+/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */
+export function constantCatch(value) {
+    const fn = () => value;
+    fn[CONSTANT_CATCH] = true;
+    return fn;
+}

package/node_modules/zod/v4/core/versions.cjs

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 exports.version = {
     major: 4,
-    minor: 4,
-    patch: 3,
+    minor: 5,
+    patch: 4,
 };

package/node_modules/zod/v4/core/versions.d.cts

@@ -1,5 +1,5 @@
 export declare const version: {
     readonly major: 4;
-    readonly minor: 4;
+    readonly minor: 5;
     readonly patch: number;
 };

package/node_modules/zod/v4/core/versions.d.ts

@@ -1,5 +1,5 @@
 export declare const version: {
     readonly major: 4;
-    readonly minor: 4;
+    readonly minor: 5;
     readonly patch: number;
 };

package/node_modules/zod/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
-    minor: 4,
-    patch: 3,
+    minor: 5,
+    patch: 4,
 };

package/node_modules/zod/v4/core/visit.cjs

@@ -0,0 +1,195 @@
+"use strict";
+// Traversal pattern adapted from Jaen's v3 `mapOnSchema` (Apache-2.0): https://gist.github.com/jaens/7e15ae1984bb338c86eb5e452dee3010
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visit = visit;
+const schemas = __importStar(require("./schemas.cjs"));
+const util_js_1 = require("./util.cjs");
+const RESOLVING = Symbol("z.visit/resolving");
+function visit(schema, fnOrHandlers) {
+    const fn = typeof fnOrHandlers === "function"
+        ? fnOrHandlers
+        : (node, rewritten) => {
+            // A union of handlers isn't callable with one argument; handler `K` only ever sees kind `K`.
+            const h = fnOrHandlers[node._zod.def.type];
+            return h ? h(node, rewritten) : node;
+        };
+    const cache = new Map();
+    function run(s) {
+        const cached = cache.get(s);
+        if (cached === RESOLVING) {
+            // Non-lazy cycle. Defer to parse time, when the cache holds the finished node.
+            return new schemas.$ZodLazy({
+                type: "lazy",
+                getter: () => cache.get(s),
+            });
+        }
+        if (cached !== undefined)
+            return cached;
+        cache.set(s, RESOLVING);
+        const inner = mapInner(s);
+        const mapped = fn(inner, inner !== s);
+        cache.set(s, mapped);
+        return mapped;
+    }
+    function mapInner(s) {
+        const def = s._zod.def;
+        const kind = def.type;
+        switch (kind) {
+            case "object": {
+                const oldShape = def.shape;
+                const keys = Object.keys(oldShape);
+                let changed = false;
+                const newShape = {};
+                for (const k of keys) {
+                    const mapped = run(oldShape[k]);
+                    if (mapped !== oldShape[k])
+                        changed = true;
+                    newShape[k] = mapped;
+                }
+                let newCatchall = def.catchall;
+                if (def.catchall) {
+                    newCatchall = run(def.catchall);
+                    if (newCatchall !== def.catchall)
+                        changed = true;
+                }
+                return changed ? (0, util_js_1.clone)(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
+            }
+            case "array": {
+                const mapped = run(def.element);
+                return mapped === def.element ? s : (0, util_js_1.clone)(s, { ...def, element: mapped });
+            }
+            case "tuple": {
+                const oldItems = def.items;
+                let changed = false;
+                const newItems = [];
+                for (const item of oldItems) {
+                    const mapped = run(item);
+                    if (mapped !== item)
+                        changed = true;
+                    newItems.push(mapped);
+                }
+                let newRest = def.rest;
+                if (def.rest) {
+                    newRest = run(def.rest);
+                    if (newRest !== def.rest)
+                        changed = true;
+                }
+                return changed ? (0, util_js_1.clone)(s, { ...def, items: newItems, rest: newRest }) : s;
+            }
+            case "record":
+            case "map": {
+                const newKey = run(def.keyType);
+                const newVal = run(def.valueType);
+                return newKey === def.keyType && newVal === def.valueType
+                    ? s
+                    : (0, util_js_1.clone)(s, { ...def, keyType: newKey, valueType: newVal });
+            }
+            case "set": {
+                const newVal = run(def.valueType);
+                return newVal === def.valueType ? s : (0, util_js_1.clone)(s, { ...def, valueType: newVal });
+            }
+            case "union": {
+                const oldOptions = def.options;
+                let changed = false;
+                const newOptions = [];
+                for (const opt of oldOptions) {
+                    const mapped = run(opt);
+                    if (mapped !== opt)
+                        changed = true;
+                    newOptions.push(mapped);
+                }
+                return changed ? (0, util_js_1.clone)(s, { ...def, options: newOptions }) : s;
+            }
+            case "intersection": {
+                const newLeft = run(def.left);
+                const newRight = run(def.right);
+                return newLeft === def.left && newRight === def.right
+                    ? s
+                    : (0, util_js_1.clone)(s, { ...def, left: newLeft, right: newRight });
+            }
+            case "optional":
+            case "nullable":
+            case "default":
+            case "prefault":
+            case "catch":
+            case "readonly":
+            case "nonoptional":
+            case "promise":
+            case "success": {
+                const newInner = run(def.innerType);
+                return newInner === def.innerType ? s : (0, util_js_1.clone)(s, { ...def, innerType: newInner });
+            }
+            case "pipe": {
+                const newIn = run(def.in);
+                const newOut = run(def.out);
+                return newIn === def.in && newOut === def.out ? s : (0, util_js_1.clone)(s, { ...def, in: newIn, out: newOut });
+            }
+            case "function": {
+                const newInput = run(def.input);
+                const newOutput = run(def.output);
+                return newInput === def.input && newOutput === def.output
+                    ? s
+                    : (0, util_js_1.clone)(s, { ...def, input: newInput, output: newOutput });
+            }
+            case "lazy": {
+                // Invoking the getter here would trip the cycle check, so lazy nodes always re-clone.
+                const original = def.getter;
+                // Drop the memo, or it shadows the new getter forever.
+                const { _cachedInner, ...rest } = def;
+                return (0, util_js_1.clone)(s, { ...rest, getter: () => run(original()) });
+            }
+            // A leaf by choice: `parts` are regex fragments, not data positions.
+            case "template_literal":
+            // Leaves.
+            case "string":
+            case "number":
+            case "int":
+            case "boolean":
+            case "bigint":
+            case "symbol":
+            case "undefined":
+            case "null":
+            case "void":
+            case "never":
+            case "any":
+            case "unknown":
+            case "date":
+            case "nan":
+            case "enum":
+            case "literal":
+            case "file":
+            case "transform":
+            case "custom":
+                return s;
+            default: {
+                // A new built-in kind becomes a compile error here; unknown user kinds fall through.
+                kind;
+                return s;
+            }
+        }
+    }
+    return run(schema);
+}

package/node_modules/zod/v4/core/visit.d.cts

@@ -0,0 +1,30 @@
+import * as schemas from "./schemas.cjs";
+type AnyZod = schemas.$ZodType;
+type Kind = schemas.$ZodTypeDef["type"];
+/** The concrete schema class for a `def.type`, or `$ZodType` for kinds with no dedicated class. */
+type SchemaOfKind<K extends Kind> = [Extract<schemas.$ZodTypes, {
+    _zod: {
+        def: {
+            type: K;
+        };
+    };
+}>] extends [never] ? AnyZod : Extract<schemas.$ZodTypes, {
+    _zod: {
+        def: {
+            type: K;
+        };
+    };
+}>;
+export type VisitFn = (node: AnyZod, rewritten: boolean) => AnyZod;
+export type VisitHandlers = {
+    [K in Kind]?: (node: SchemaOfKind<K>, rewritten: boolean) => AnyZod;
+};
+/**
+ * @internal Bottom-up rewrite of a schema tree. Unhandled kinds and unchanged branches keep their
+ * identity. Returns `$ZodType`: a visitor can swap in a schema of any type, so callers declare
+ * their own return type. `rewritten` tells a handler whether the traversal replaced anything
+ * below the node it is looking at.
+ */
+export declare function visit(schema: schemas.SomeType, fn: VisitFn): AnyZod;
+export declare function visit(schema: schemas.SomeType, handlers: VisitHandlers): AnyZod;
+export {};

package/node_modules/zod/v4/core/visit.d.ts

@@ -0,0 +1,30 @@
+import * as schemas from "./schemas.js";
+type AnyZod = schemas.$ZodType;
+type Kind = schemas.$ZodTypeDef["type"];
+/** The concrete schema class for a `def.type`, or `$ZodType` for kinds with no dedicated class. */
+type SchemaOfKind<K extends Kind> = [Extract<schemas.$ZodTypes, {
+    _zod: {
+        def: {
+            type: K;
+        };
+    };
+}>] extends [never] ? AnyZod : Extract<schemas.$ZodTypes, {
+    _zod: {
+        def: {
+            type: K;
+        };
+    };
+}>;
+export type VisitFn = (node: AnyZod, rewritten: boolean) => AnyZod;
+export type VisitHandlers = {
+    [K in Kind]?: (node: SchemaOfKind<K>, rewritten: boolean) => AnyZod;
+};
+/**
+ * @internal Bottom-up rewrite of a schema tree. Unhandled kinds and unchanged branches keep their
+ * identity. Returns `$ZodType`: a visitor can swap in a schema of any type, so callers declare
+ * their own return type. `rewritten` tells a handler whether the traversal replaced anything
+ * below the node it is looking at.
+ */
+export declare function visit(schema: schemas.SomeType, fn: VisitFn): AnyZod;
+export declare function visit(schema: schemas.SomeType, handlers: VisitHandlers): AnyZod;
+export {};