@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

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

@@ -86,6 +86,40 @@ export type ParsedTypes =
 export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
 export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
 export type AssertExtends<T, U> = T extends U ? T : never;
+type ToZodMismatch<T, S extends schemas.$ZodType> = {
+  "types do not match": {
+    expected: T;
+    received: S["_zod"]["output"];
+  };
+};
+
+// Stays a `$ZodType` so it still satisfies the shape constraint, and carries a brand no real schema has so the offending property is the one TypeScript reports as unassignable.
+type ToZodKeyMismatch<Expected, Received> = schemas.$ZodType & {
+  "types do not match": { expected: Expected; received: Received };
+};
+
+// Rebuilds the shape with a marker on each key that disagrees, so the diagnostic names the key instead of failing the whole schema at the top level. A key the target lacks reports `expected: never`; a key the schema lacks reports `received: never`.
+type ToZodShape<Shape, T> = {
+  [K in keyof Shape]: Shape[K] extends schemas.$ZodType
+    ? K extends keyof T
+      ? AssertEqual<Shape[K]["_zod"]["output"], T[K]> extends true
+        ? Shape[K]
+        : ToZodKeyMismatch<T[K], Shape[K]["_zod"]["output"]>
+      : ToZodKeyMismatch<never, Shape[K]["_zod"]["output"]>
+    : Shape[K];
+} & { [K in Exclude<keyof T, keyof Shape>]: ToZodKeyMismatch<T[K], never> };
+
+// Forces the mapped type to display expanded, so the error prints the keys rather than the alias name.
+type ToZodExpand<X> = { [K in keyof X]: X[K] } & {};
+
+// Only localizes when a key is genuinely at fault. A whole-type difference the per-key walk cannot see — a `readonly` modifier, an intersection versus the flat object with the same keys — leaves every key agreeing, and reporting nothing there would silently accept what the top-level check rejected.
+type ToZodTarget<S extends schemas.$ZodType, T> = S extends schemas.$ZodObject<infer Shape, infer Config>
+  ? T extends object
+    ? AssertEqual<ToZodExpand<ToZodShape<Shape, T>>, ToZodExpand<Shape>> extends true
+      ? S & ToZodMismatch<T, S>
+      : schemas.$ZodObject<ToZodExpand<ToZodShape<Shape, T>>, Config>
+    : S & ToZodMismatch<T, S>
+  : S & ToZodMismatch<T, S>;
 export type IsAny<T> = 0 extends 1 & T ? true : false;
 export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
@@ -197,6 +231,12 @@ export function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<
   return val;
 }
 
+export function toZod<T>(): <S extends schemas.$ZodType>(
+  schema: AssertEqual<S["_zod"]["output"], T> extends true ? S : ToZodTarget<S, T>
+) => S {
+  return (schema) => schema as any;
+}
+
 export function assertIs<T>(_arg: T): void {}
 
 export function assertNever(_x: never): never {
@@ -248,8 +288,8 @@ export function cleanRegex(source: string): string {
 export function floatSafeRemainder(val: number, step: number): number {
   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;
 }
@@ -362,8 +402,7 @@ export function isObject(data: any): data is Record<PropertyKey, unknown> {
 }
 
 export const allowsEval: { value: boolean } = /* @__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;
   }
@@ -573,7 +612,7 @@ export function stringifyPrimitive(value: any): string {
 
 export function optionalKeys(shape: schemas.$ZodShape): string[] {
   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";
   });
 }
 
@@ -585,13 +624,14 @@ export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
   [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
 };
 
-export const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]> = {
+// 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: Record<checks.$ZodNumberFormats, [number, number]> = /*@__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: Record<checks.$ZodBigIntFormats, [bigint, bigint]> = {
   int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
@@ -610,12 +650,13 @@ export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>):
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape: Writeable<schemas.$ZodShape> = {};
-      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]!;
+        if (!mask[key as string]) continue;
+        assignProp(newShape, key as string, (currDef.shape as any)[key]!);
       }
 
       assignProp(this, "shape", newShape); // self-caching
@@ -639,13 +680,13 @@ export function omit(schema: schemas.$ZodObject, mask: object): any {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape: Writeable<schemas.$ZodShape> = { ...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 as any)[key]) continue;
 
-        delete newShape[key];
+        delete newShape[key as string];
       }
       assignProp(this, "shape", newShape); // self-caching
       return newShape;
@@ -664,10 +705,9 @@ export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): an
   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.");
       }
@@ -699,6 +739,9 @@ export function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape)
 }
 
 export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
+  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.");
   }
@@ -720,13 +763,14 @@ export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
 export function partial(
   Class: SchemaClass<schemas.$ZodOptional> | null,
   schema: schemas.$ZodObject,
-  mask: object | undefined
+  mask: object | undefined,
+  name = "partial"
 ): any {
   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, {
@@ -735,28 +779,29 @@ export function partial(
       const shape: Writeable<schemas.$ZodShape> = { ...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 as any)[key]) continue;
           // if (oldShape[key]!._zod.optin === "optional") continue;
-          shape[key] = Class
+          (shape as any)[key] = Class
             ? new Class({
                 type: "optional",
-                innerType: oldShape[key]!,
+                innerType: (oldShape as any)[key]!,
               })
-            : oldShape[key]!;
+            : (oldShape as any)[key]!;
         }
       } 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
+          (shape as any)[key] = Class
             ? new Class({
                 type: "optional",
-                innerType: oldShape[key]!,
+                innerType: (oldShape as any)[key]!,
               })
-            : oldShape[key]!;
+            : (oldShape as any)[key]!;
         }
       }
 
@@ -780,23 +825,23 @@ export function required(
       const shape: Writeable<schemas.$ZodShape> = { ...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 as any)[key]) continue;
           // overwrite with non-optional
-          shape[key] = new Class({
+          (shape as any)[key] = new Class({
             type: "nonoptional",
-            innerType: oldShape[key]!,
+            innerType: (oldShape as any)[key]!,
           });
         }
       } else {
-        for (const key in oldShape) {
+        for (const key of Reflect.ownKeys(oldShape)) {
           // overwrite with non-optional
-          shape[key] = new Class({
+          (shape as any)[key] = new Class({
             type: "nonoptional",
-            innerType: oldShape[key]!,
+            innerType: (oldShape as any)[key]!,
           });
         }
       }
@@ -822,8 +867,7 @@ export function aborted(x: schemas.ParsePayload, startIndex = 0): boolean {
   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: schemas.ParsePayload, startIndex = 0): boolean {
   if (x.aborted === true) return true;
   for (let i = startIndex; i < x.issues.length; i++) {
@@ -846,20 +890,37 @@ export function unwrapMessage(message: string | { message: string } | undefined
   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: errors.$ZodRawIssue[], start: number, inst: schemas.$ZodType): void {
+  for (let i = start; i < issues.length; i++) {
+    (issues[i] as any).schema ??= inst;
+  }
+}
+
 export function finalizeIssue(
   iss: errors.$ZodRawIssue,
   ctx: schemas.ParseContextInternal | undefined,
   config: $ZodConfig
 ): errors.$ZodIssue {
+  // 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: Set<string> | undefined = (iss.inst as any)?._zod?.traits;
+  if (traits?.has("$ZodType")) {
+    if (traits.has("$ZodCheck")) (iss as any).schema ??= iss.inst;
+    else (iss as any).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 as never)) ??
+      unwrapMessage(schemaError?.(iss as never)) ??
       unwrapMessage(ctx?.error?.(iss as never)) ??
       unwrapMessage(config.customError?.(iss)) ??
       unwrapMessage(config.localeError?.(iss)) ??
       "Invalid input");
 
-  const { inst: _inst, continue: _continue, input: _input, ...rest } = iss as any;
+  const { inst: _inst, schema: _schema, continue: _continue, input: _input, ...rest } = iss as any;
   rest.path ??= [];
   rest.message = message;
   if (ctx?.reportInput) {
@@ -876,6 +937,22 @@ export function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown"
   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: string): number {
+  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: any): "array" | "string" | "unknown" {
   if (Array.isArray(input)) return "array";
   if (typeof input === "string") return "string";
@@ -981,3 +1058,152 @@ export function uint8ArrayToHex(bytes: Uint8Array): string {
 export abstract class Class {
   constructor(..._args: any[]) {}
 }
+
+//////////    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: object, table: object): void {
+  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<T>(inst: object, key: string, value: T, enumerable = true): T {
+  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<T>(inst: object, key: string, value: T): T {
+  return own(inst, key, value, false);
+}
+
+function defineBound(proto: object, key: string, fn: AnyFunc): void {
+  Object.defineProperty(proto, key, {
+    configurable: true,
+    get(this: any) {
+      // 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(this: any, value: unknown) {
+      own(this, key, value);
+    },
+  });
+}
+
+/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */
+function claim(inst: object, sentinel: string): object | undefined {
+  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;
+}
+
+/** A trait's prototype members: a partial view of its own interface, with `this` typed as the instance. */
+export type ProtoOf<T> = {
+  // `infer R` resolves a polymorphic `this` return type to `T`, which a method written here can actually produce
+  [K in keyof T]?: (T[K] extends (...args: infer A) => infer R ? (...args: A) => R : T[K]) | undefined;
+} & ThisType<T>;
+
+// 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: object | undefined;
+
+// 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: PropertyDescriptor = {
+  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<T extends { _zod: any }>(
+  inst: T,
+  key: string,
+  compute: (zod: T["_zod"]) => unknown
+): void {
+  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(this: any) {
+      // 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(this: any, value: unknown) {
+      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: object, key: string, make: (self: any) => unknown, enumerable: boolean): void {
+  const proto = claim(inst, key);
+  if (!proto) return;
+  Object.defineProperty(proto, key, {
+    configurable: true,
+    get(this: any) {
+      // 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 as unknown };
+      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(this: any, value: unknown) {
+      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<T>(value: T): () => T {
+  const fn = () => value;
+  (fn as { [CONSTANT_CATCH]?: boolean })[CONSTANT_CATCH] = true;
+  return fn;
+}

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

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

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

@@ -0,0 +1,193 @@
+// Traversal pattern adapted from Jaen's v3 `mapOnSchema` (Apache-2.0): https://gist.github.com/jaens/7e15ae1984bb338c86eb5e452dee3010
+
+import * as schemas from "./schemas.js";
+import { clone } from "./util.js";
+
+const RESOLVING: unique symbol = Symbol("z.visit/resolving");
+type Resolving = typeof RESOLVING;
+
+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 function visit(schema: schemas.SomeType, fn: VisitFn): AnyZod;
+export function visit(schema: schemas.SomeType, handlers: VisitHandlers): AnyZod;
+export function visit(schema: schemas.SomeType, fnOrHandlers: VisitFn | VisitHandlers): AnyZod {
+  const fn: VisitFn =
+    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 as VisitHandlers)[node._zod.def.type] as
+            | ((n: AnyZod, rewritten: boolean) => AnyZod)
+            | undefined;
+          return h ? h(node, rewritten) : node;
+        };
+
+  const cache = new Map<AnyZod, AnyZod | Resolving>();
+
+  function run(s: AnyZod): AnyZod {
+    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) as AnyZod,
+      });
+    }
+    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: AnyZod): AnyZod {
+    const def = s._zod.def as any;
+    const kind = def.type as Kind;
+    switch (kind) {
+      case "object": {
+        const oldShape = def.shape as Record<string, AnyZod>;
+        const keys = Object.keys(oldShape);
+        let changed = false;
+        const newShape: Record<string, AnyZod> = {};
+        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 ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
+      }
+      case "array": {
+        const mapped = run(def.element);
+        return mapped === def.element ? s : clone(s, { ...def, element: mapped });
+      }
+      case "tuple": {
+        const oldItems = def.items as AnyZod[];
+        let changed = false;
+        const newItems: AnyZod[] = [];
+        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 ? 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
+          : clone(s, { ...def, keyType: newKey, valueType: newVal });
+      }
+      case "set": {
+        const newVal = run(def.valueType);
+        return newVal === def.valueType ? s : clone(s, { ...def, valueType: newVal });
+      }
+      case "union": {
+        const oldOptions = def.options as AnyZod[];
+        let changed = false;
+        const newOptions: AnyZod[] = [];
+        for (const opt of oldOptions) {
+          const mapped = run(opt);
+          if (mapped !== opt) changed = true;
+          newOptions.push(mapped);
+        }
+        return changed ? 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
+          : 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 : 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 : 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
+          : 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 as () => AnyZod;
+        // Drop the memo, or it shadows the new getter forever.
+        const { _cachedInner, ...rest } = def;
+        return 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 satisfies never;
+        return s;
+      }
+    }
+  }
+
+  return run(schema as AnyZod);
+}