zod-compiler 1.23.0 → 1.23.2

package/dist/core/codegen/context.d.ts

@@ -1,201 +1,202 @@
-import type { BigIntCheckIR, CheckIR, DateCheckIR, SchemaIR, SetCheckIR } from "../types.js";
-import type { SharedSchemaPlan } from "./dedupe.js";
+import { BigIntCheckIR, CheckIR, DateCheckIR, SchemaIR, SetCheckIR } from "../types.js";
+import { SharedSchemaPlan } from "./dedupe.js";
+//#region src/core/codegen/context.d.ts
 /** Codegen output mode. "inline" emits self-contained code (CLI .compiled.ts). "lean" emits references to imports from "virtual:zod-compiler/runtime" (unplugin). */
-export type CodegenMode = "inline" | "lean";
-export interface CodeGenResult {
-    code: string;
-    functionDef: string;
-    /** Number of fallback schemas referenced by __rf[N] in the generated code. 0 = no fallbacks. */
-    refCount: number;
-    /**
-     * Helper names referenced by this schema in lean mode (e.g. "__zcTS", "__zcReEmail").
-     * Used by the unplugin transform to construct the `import { ... } from "virtual:zod-compiler/runtime"` line.
-     * Always empty in inline mode.
-     */
-    usedHelpers: Set<string>;
-    /**
-     * Name of the hosted fast-check boolean function in the preamble (null when
-     * the schema has no Fast Path). generateIIFE passes it to __zcMkv so parse()
-     * and parseAsync() can return valid input without allocating an
-     * intermediate SafeParseResult.
-     */
-    fastFnName: string | null;
-    /**
-     * True when `fastFnName` is a TOTAL predicate: `fc(input) === true` iff the
-     * schema accepts `input` (mutation-free schemas, where a fast-check failure
-     * can never become a slow-path success). generateIIFE installs it as the
-     * zero-allocation `.is()` guard. False for partial fast paths
-     * (default/catch/coerce — `fc` only shortcuts present-and-valid input, so a
-     * `false` result does NOT imply rejection) and for schemas with no fast path;
-     * `.is()` then derives from `safeParse(input).success`.
-     */
-    fastTotal: boolean;
-    /**
-     * Hosted predicate installed as `.is()`, when it differs from `fastFnName`.
-     * A schema that rebuilds its output has no by-reference shortcut (so
-     * `fastFnName` is null) yet still has an exact acceptance predicate, because
-     * stripping reshapes the payload and never the verdict.
-     */
-    isFnName?: string | null;
-    /**
-     * Compact mode only: the `__rf[N]` index this validator delegates its cold
-     * error path to (the schema itself, captured as a fresh root RefEntry). When
-     * set, the pipeline appends a `{ schema, accessPath: "" }` entry at this index
-     * so `generateIIFE` materializes `__rf[N]` as the original Zod schema. Absent
-     * for every non-compact (fully compiled) validator.
-     */
-    rootDelegateRefIndex?: number;
+type CodegenMode = "inline" | "lean";
+interface CodeGenResult {
+  code: string;
+  functionDef: string;
+  /** Number of fallback schemas referenced by __rf[N] in the generated code. 0 = no fallbacks. */
+  refCount: number;
+  /**
+   * Helper names referenced by this schema in lean mode (e.g. "__zcTS", "__zcReEmail").
+   * Used by the unplugin transform to construct the `import { ... } from "virtual:zod-compiler/runtime"` line.
+   * Always empty in inline mode.
+   */
+  usedHelpers: Set<string>;
+  /**
+   * Name of the hosted fast-check boolean function in the preamble (null when
+   * the schema has no Fast Path). generateIIFE passes it to __zcMkv so parse()
+   * and parseAsync() can return valid input without allocating an
+   * intermediate SafeParseResult.
+   */
+  fastFnName: string | null;
+  /**
+   * True when `fastFnName` is a TOTAL predicate: `fc(input) === true` iff the
+   * schema accepts `input` (mutation-free schemas, where a fast-check failure
+   * can never become a slow-path success). generateIIFE installs it as the
+   * zero-allocation `.is()` guard. False for partial fast paths
+   * (default/catch — `fc` only shortcuts present-and-valid input, so a `false`
+   * result does NOT imply rejection) and for schemas with no fast path, such as
+   * coercion; `.is()` then derives from `safeParse(input).success`.
+   */
+  fastTotal: boolean;
+  /**
+   * Hosted predicate installed as `.is()`, when it differs from `fastFnName`.
+   * A schema that rebuilds its output has no by-reference shortcut (so
+   * `fastFnName` is null) yet still has an exact acceptance predicate, because
+   * stripping reshapes the payload and never the verdict.
+   */
+  isFnName?: string | null;
+  /**
+   * Compact mode only: the `__rf[N]` index this validator delegates its cold
+   * error path to (the schema itself, captured as a fresh root RefEntry). When
+   * set, the pipeline appends a `{ schema, accessPath: "" }` entry at this index
+   * so `generateIIFE` materializes `__rf[N]` as the original Zod schema. Absent
+   * for every non-compact (fully compiled) validator.
+   */
+  rootDelegateRefIndex?: number;
 }
 /** Hosted-validator names for one recursion target (see CodeGenContext.recTargets). */
-export interface RecTargetGen {
-    /** True for the root target (refId 0) — reuses the schema's own functions. */
-    isRoot: boolean;
-    /**
-     * safeParse-shaped slow validator name: `safeParse_<name>` for the root,
-     * `__rsp_N` for a non-root target. `slowRecursiveRef` calls this.
-     */
-    slowName: string;
-    /**
-     * Boolean fast-check name (`__fcr_N`). Allocated lazily for the root (mirrors
-     * recFastName), eagerly for non-root targets. Absent until the fast path
-     * reaches a ref to this target.
-     */
-    fastName?: string;
-    /** Inner IR hosted as the standalone validator body (non-root targets only). */
-    inner?: SchemaIR;
+interface RecTargetGen {
+  /** True for the root target (refId 0) — reuses the schema's own functions. */
+  isRoot: boolean;
+  /**
+   * safeParse-shaped slow validator name: `safeParse_<name>` for the root,
+   * `__rsp_N` for a non-root target. `slowRecursiveRef` calls this.
+   */
+  slowName: string;
+  /**
+   * Boolean fast-check name (`__fcr_N`). Allocated lazily for the root (mirrors
+   * recFastName), eagerly for non-root targets. Absent until the fast path
+   * reaches a ref to this target.
+   */
+  fastName?: string;
+  /** Inner IR hosted as the standalone validator body (non-root targets only). */
+  inner?: SchemaIR;
 }
 /** Shared mutable state for code generation. Fast and slow paths share the same instance. */
-export interface CodeGenContext {
-    preamble: string[];
-    counter: number;
-    fnName: string;
-    /** Deduplicates regex patterns: same pattern string → same preamble variable name. */
-    regexCache: Map<string, string>;
-    /** Codegen output mode. */
-    mode: CodegenMode;
-    /** Names of helpers from "virtual:zod-compiler/runtime" referenced in this schema (lean mode only). */
-    usedHelpers: Set<string>;
-    /**
-     * Name of the fast-path boolean helper for the ROOT recursion target
-     * (refId 0), allocated on first fastRecursiveRef visit. generateValidator
-     * wraps the root fast expression as `function <name>(input){return <expr>;}`
-     * so recursive refs can call it. undefined = root has no recursion on the
-     * fast path.
-     */
-    recFastName?: string;
-    /**
-     * Hosted-validator name table for recursion targets, keyed by refId. Entry 0
-     * is the root (the schema's own `safeParse_<name>` / `recFastName`); entries
-     * ≥ 1 are non-root targets hosted as standalone `__rsp_N` (slow) / `__fcr_N`
-     * (fast) helpers. `recursiveRef`/`recursionTarget` generators look up the
-     * call target here. Undefined when not generating a full validator (e.g. unit
-     * tests calling a single generator) — treated as root-only.
-     */
-    recTargets?: Map<number, RecTargetGen>;
-    /** Dedup cache for hosted zero-capture effect functions: source text → preamble var. */
-    effectFnCache?: Map<string, string>;
-    /** Dedup cache for constant preamble declarations: initializer text → preamble var. */
-    valueCache?: Map<string, string>;
-    /** Name of the build path's FAIL sentinel, declared once per validator. */
-    buildFailName?: string;
-    /** Hosted build-function name per recursion target refId, so back-edges resolve. */
-    buildRecNames?: Map<number, string>;
-    /**
-     * Set by the build path when it emitted a `.default()` substitution. Such a
-     * schema ACCEPTS an input its fast expression rejects — `fastDefault` demands a
-     * present value, since the fast path's contract is `data === input` and a
-     * substituted default is not the input — so the expression is no longer an
-     * exact acceptance predicate and must not be installed as `.is()`. Stripping,
-     * by contrast, reshapes only the payload, which is why a build-path schema
-     * otherwise still hands its predicate over.
-     */
-    buildSubstitutesValue?: boolean;
-    /** Memo for estimateFastCost (size-gated fast-check extraction). Lazily created. */
-    fastSizeCache?: WeakMap<SchemaIR, number>;
-    /** Memo for estimateRuntimeCost (cheapest-first check ordering). Lazily created. */
-    fastRuntimeCostCache?: WeakMap<SchemaIR, number>;
-    /**
-     * File-level shared slow-walk plan. Set only when generating a mutation-free
-     * schema (so shared walks stay on the deferred cold path); the slow-path
-     * visit() consults it to replace a repeated sub-IR with a `__zcSw_N` call.
-     */
-    sharedSchemas?: SharedSchemaPlan;
+interface CodeGenContext {
+  preamble: string[];
+  counter: number;
+  fnName: string;
+  /** Deduplicates regex patterns: same pattern string → same preamble variable name. */
+  regexCache: Map<string, string>;
+  /** Codegen output mode. */
+  mode: CodegenMode;
+  /** Names of helpers from "virtual:zod-compiler/runtime" referenced in this schema (lean mode only). */
+  usedHelpers: Set<string>;
+  /**
+   * Name of the fast-path boolean helper for the ROOT recursion target
+   * (refId 0), allocated on first fastRecursiveRef visit. generateValidator
+   * wraps the root fast expression as `function <name>(input){return <expr>;}`
+   * so recursive refs can call it. undefined = root has no recursion on the
+   * fast path.
+   */
+  recFastName?: string;
+  /**
+   * Hosted-validator name table for recursion targets, keyed by refId. Entry 0
+   * is the root (the schema's own `safeParse_<name>` / `recFastName`); entries
+   * ≥ 1 are non-root targets hosted as standalone `__rsp_N` (slow) / `__fcr_N`
+   * (fast) helpers. `recursiveRef`/`recursionTarget` generators look up the
+   * call target here. Undefined when not generating a full validator (e.g. unit
+   * tests calling a single generator) — treated as root-only.
+   */
+  recTargets?: Map<number, RecTargetGen>;
+  /** Dedup cache for hosted zero-capture effect functions: source text → preamble var. */
+  effectFnCache?: Map<string, string>;
+  /** Dedup cache for constant preamble declarations: initializer text → preamble var. */
+  valueCache?: Map<string, string>;
+  /** Name of the build path's FAIL sentinel, declared once per validator. */
+  buildFailName?: string;
+  /** Hosted build-function name per recursion target refId, so back-edges resolve. */
+  buildRecNames?: Map<number, string>;
+  /**
+   * Set by the build path when it emitted a `.default()` substitution. Such a
+   * schema ACCEPTS an input its fast expression rejects — `fastDefault` demands a
+   * present value, since the fast path's contract is `data === input` and a
+   * substituted default is not the input — so the expression is no longer an
+   * exact acceptance predicate and must not be installed as `.is()`. Stripping,
+   * by contrast, reshapes only the payload, which is why a build-path schema
+   * otherwise still hands its predicate over.
+   */
+  buildSubstitutesValue?: boolean;
+  /** Memo for estimateFastCost (size-gated fast-check extraction). Lazily created. */
+  fastSizeCache?: WeakMap<SchemaIR, number>;
+  /** Memo for estimateRuntimeCost (cheapest-first check ordering). Lazily created. */
+  fastRuntimeCostCache?: WeakMap<SchemaIR, number>;
+  /**
+   * File-level shared slow-walk plan. Set only when generating a mutation-free
+   * schema (so shared walks stay on the deferred cold path); the slow-path
+   * visit() consults it to replace a repeated sub-IR with a `__zcSw_N` call.
+   */
+  sharedSchemas?: SharedSchemaPlan;
 }
 /** Context object for slow-path (error-collecting) generator functions. */
-export interface SlowGen {
-    readonly input: string;
-    readonly output: string;
-    readonly path: string;
-    readonly issues: string;
-    readonly ctx: CodeGenContext;
-    /**
-     * Schema-level static error message of the node being generated
-     * (z.string({ error: "..." })). Default message for issues this node emits
-     * when the individual check has no message of its own. Set by generateSlow()
-     * from ir.typeMessage; never inherited by child nodes.
-     */
-    readonly typeMsg?: string | undefined;
-    /**
-     * Name of a boolean variable that this node sets to `true` when it aborts in
-     * the zod sense (`payload.aborted`) — currently only a pipe/codec whose `in`
-     * step fails (zod's `handlePipeResult` sets `left.aborted = true`). A `union`
-     * allocates one per option and reads it during pruning so a pipe option whose
-     * `in` failed counts as aborted even when its only issue is a non-aborting
-     * `custom`/check-level code. Undefined when the node is not inside an
-     * abort-tracking option, in which case the abort is a no-op.
-     *
-     * Unlike input/output/path/issues, this is NOT inherited by `visit()`: it is
-     * cleared at every boundary unless a node explicitly forwards it (the
-     * pass-through wrappers optional/nullable/readonly do), mirroring how zod
-     * propagates `payload.aborted` through transparent wrappers but not across
-     * container boundaries.
-     */
-    readonly aborted?: string | undefined;
-    /**
-     * Recursively generate validation for a child IR node.
-     * input/output/path/issues are inherited from parent unless overridden;
-     * `aborted` is the exception — it is only set when explicitly passed (see the
-     * `aborted` field doc), so it never leaks into container children.
-     * Union generators use `{ issues }` to redirect child errors to temporary arrays.
-     * Container generators use `{ input, output, path }` for element traversal.
-     */
-    visit(ir: SchemaIR, overrides?: {
-        input?: string;
-        output?: string;
-        path?: string;
-        issues?: string;
-        aborted?: string | undefined;
-    }): string;
-    /** Generate a unique temp variable name: `__${prefix}_${counter++}` */
-    temp(prefix: string): string;
-    /** Add a regex to preamble and return the variable name. */
-    regex(prefix: string, pattern: string, flags?: string): string;
-    /** Add a Set to preamble and return the variable name. */
-    set(prefix: string, values: readonly unknown[]): string;
+interface SlowGen {
+  readonly input: string;
+  readonly output: string;
+  readonly path: string;
+  readonly issues: string;
+  readonly ctx: CodeGenContext;
+  /**
+   * Schema-level static error message of the node being generated
+   * (z.string({ error: "..." })). Default message for issues this node emits
+   * when the individual check has no message of its own. Set by generateSlow()
+   * from ir.typeMessage; never inherited by child nodes.
+   */
+  readonly typeMsg?: string | undefined;
+  /**
+   * Name of a boolean variable that this node sets to `true` when it aborts in
+   * the zod sense (`payload.aborted`) — currently only a pipe/codec whose `in`
+   * step fails (zod's `handlePipeResult` sets `left.aborted = true`). A `union`
+   * allocates one per option and reads it during pruning so a pipe option whose
+   * `in` failed counts as aborted even when its only issue is a non-aborting
+   * `custom`/check-level code. Undefined when the node is not inside an
+   * abort-tracking option, in which case the abort is a no-op.
+   *
+   * Unlike input/output/path/issues, this is NOT inherited by `visit()`: it is
+   * cleared at every boundary unless a node explicitly forwards it (the
+   * pass-through wrappers optional/nullable/readonly do), mirroring how zod
+   * propagates `payload.aborted` through transparent wrappers but not across
+   * container boundaries.
+   */
+  readonly aborted?: string | undefined;
+  /**
+   * Recursively generate validation for a child IR node.
+   * input/output/path/issues are inherited from parent unless overridden;
+   * `aborted` is the exception — it is only set when explicitly passed (see the
+   * `aborted` field doc), so it never leaks into container children.
+   * Union generators use `{ issues }` to redirect child errors to temporary arrays.
+   * Container generators use `{ input, output, path }` for element traversal.
+   */
+  visit(ir: SchemaIR, overrides?: {
+    input?: string;
+    output?: string;
+    path?: string;
+    issues?: string;
+    aborted?: string | undefined;
+  }): string;
+  /** Generate a unique temp variable name: `__${prefix}_${counter++}` */
+  temp(prefix: string): string;
+  /** Add a regex to preamble and return the variable name. */
+  regex(prefix: string, pattern: string, flags?: string): string;
+  /** Add a Set to preamble and return the variable name. */
+  set(prefix: string, values: readonly unknown[]): string;
 }
 /** Slow-path generator function signature — registered in slowRegistry. */
-export type SlowGenerator<T extends SchemaIR = SchemaIR> = (ir: T, g: SlowGen) => string;
+type SlowGenerator<T extends SchemaIR = SchemaIR> = (ir: T, g: SlowGen) => string;
 /**
  * Per-emitted-function size accumulator for size-gated fast-check extraction.
  * Shared by every node inlined into the same function; a fresh instance starts
  * each hosted helper (and the root). See fast-size.ts / generateFast.
  */
-export interface FastScope {
-    used: number;
-    /**
-     * `var` temps that the function this scope is assembling must declare, in
-     * allocation order. Populated by {@link FastGen.local}; every site that
-     * materializes a function body from a fresh scope emits
-     * {@link declareFastTemps} at the top of that body.
-     *
-     * Function-scoped (never module-scoped) is load-bearing: a recursive
-     * validator re-enters itself while an outer frame still holds a live temp,
-     * and each invocation needs its own binding.
-     */
-    temps: string[];
+interface FastScope {
+  used: number;
+  /**
+   * `var` temps that the function this scope is assembling must declare, in
+   * allocation order. Populated by {@link FastGen.local}; every site that
+   * materializes a function body from a fresh scope emits
+   * {@link declareFastTemps} at the top of that body.
+   *
+   * Function-scoped (never module-scoped) is load-bearing: a recursive
+   * validator re-enters itself while an outer frame still holds a live temp,
+   * and each invocation needs its own binding.
+   */
+  temps: string[];
 }
 /** `var a,b;` declaration for a scope's temps, or "" when it allocated none. */
-export declare function declareFastTemps(scope: FastScope): string;
+declare function declareFastTemps(scope: FastScope): string;
 /**
  * Fast check for a wrapper that compares its input against a sentinel and
  * otherwise delegates to an inner schema — `optional` (`===undefined`),
@@ -215,59 +216,59 @@ export declare function declareFastTemps(scope: FastScope): string;
  * element variable, a record value) is already a single load, so it keeps the
  * shorter form and byte-identical output.
  */
-export declare function fastSentinelWrapper(g: FastGen, innerIR: SchemaIR, sentinel: string, joiner: "&&" | "||"): string | null;
+declare function fastSentinelWrapper(g: FastGen, innerIR: SchemaIR, sentinel: string, joiner: "&&" | "||"): string | null;
 /** Context object for fast-path (boolean expression) generator functions. */
-export interface FastGen {
-    readonly input: string;
-    readonly ctx: CodeGenContext;
-    /**
-     * Whether the CURRENT node may be hoisted into its own boolean helper when it
-     * (with the already-emitted siblings) would overflow the function size cap.
-     * False for the root and for a helper's own top node — those are already their
-     * own function — but their children are extractable. See generateFast.
-     */
-    readonly extractable: boolean;
-    /** Accumulated size (≈ chars) of the function currently being assembled. */
-    readonly scope: FastScope;
-    /**
-     * Set on the gen for a discriminated-union option only: the discriminator
-     * key. Signals `fastObject` to omit its type-guard and skip re-checking that
-     * property (the switch already matched its value). Never propagated to child
-     * nodes — nested objects keep their own guard.
-     */
-    readonly discSkipKey?: string | undefined;
-    /**
-     * Recursively generate fast-check expression for a child IR node.
-     * Returns null if any child is ineligible for fast path.
-     */
-    visit(ir: SchemaIR, overrides?: {
-        input?: string;
-        discSkipKey?: string;
-    }): string | null;
-    /**
-     * A FastGen for emitting a SEPARATE function body (a hand-built preamble
-     * helper such as a discriminated-union switch or an array-element loop). It
-     * carries a FRESH size accumulator, so the helper's own content is size-gated
-     * against the cap independently of the caller — without this, a helper's body
-     * accrues to the caller's scope while the helper itself grows unbounded.
-     */
-    scoped(input: string): FastGen;
-    /** Generate a unique temp variable name. */
-    temp(prefix: string): string;
-    /**
-     * Allocate a unique name AND record it on this scope so the enclosing
-     * emitted function declares it as a `var` (see {@link FastScope.temps}).
-     * Use for a value bound inside an expression — `(t=x["k"])===undefined` —
-     * where `temp()` alone would leave the name undeclared.
-     */
-    local(prefix: string): string;
-    /** Add a regex to preamble and return the variable name. */
-    regex(prefix: string, pattern: string, flags?: string): string;
+interface FastGen {
+  readonly input: string;
+  readonly ctx: CodeGenContext;
+  /**
+   * Whether the CURRENT node may be hoisted into its own boolean helper when it
+   * (with the already-emitted siblings) would overflow the function size cap.
+   * False for the root and for a helper's own top node — those are already their
+   * own function — but their children are extractable. See generateFast.
+   */
+  readonly extractable: boolean;
+  /** Accumulated size (≈ chars) of the function currently being assembled. */
+  readonly scope: FastScope;
+  /**
+   * Set on the gen for a discriminated-union option only: the discriminator
+   * key. Signals `fastObject` to omit its type-guard and skip re-checking that
+   * property (the switch already matched its value). Never propagated to child
+   * nodes — nested objects keep their own guard.
+   */
+  readonly discSkipKey?: string | undefined;
+  /**
+   * Recursively generate fast-check expression for a child IR node.
+   * Returns null if any child is ineligible for fast path.
+   */
+  visit(ir: SchemaIR, overrides?: {
+    input?: string;
+    discSkipKey?: string;
+  }): string | null;
+  /**
+   * A FastGen for emitting a SEPARATE function body (a hand-built preamble
+   * helper such as a discriminated-union switch or an array-element loop). It
+   * carries a FRESH size accumulator, so the helper's own content is size-gated
+   * against the cap independently of the caller — without this, a helper's body
+   * accrues to the caller's scope while the helper itself grows unbounded.
+   */
+  scoped(input: string): FastGen;
+  /** Generate a unique temp variable name. */
+  temp(prefix: string): string;
+  /**
+   * Allocate a unique name AND record it on this scope so the enclosing
+   * emitted function declares it as a `var` (see {@link FastScope.temps}).
+   * Use for a value bound inside an expression — `(t=x["k"])===undefined` —
+   * where `temp()` alone would leave the name undeclared.
+   */
+  local(prefix: string): string;
+  /** Add a regex to preamble and return the variable name. */
+  regex(prefix: string, pattern: string, flags?: string): string;
 }
 /** Fast-path generator function signature — registered in fastRegistry. */
-export type FastGenerator<T extends SchemaIR = SchemaIR> = (ir: T, g: FastGen) => string | null;
+type FastGenerator<T extends SchemaIR = SchemaIR> = (ir: T, g: FastGen) => string | null;
 /** Allocate a fresh `__${prefix}_${n}` identifier and bump the shared counter. */
-export declare function emitTemp(ctx: CodeGenContext, prefix: string): string;
+declare function emitTemp(ctx: CodeGenContext, prefix: string): string;
 /**
  * Host a zero-capture effect function (refine predicate, transform,
  * overwrite) in the preamble and return its variable name. The inline
@@ -280,7 +281,7 @@ export declare function emitTemp(ctx: CodeGenContext, prefix: string): string;
  * a single preamble binding is semantically identical. Deduped per schema
  * by source text.
  */
-export declare function emitEffectFn(ctx: CodeGenContext, source: string): string;
+declare function emitEffectFn(ctx: CodeGenContext, source: string): string;
 /**
  * Callable expression for a user callback — a refine predicate or a transform.
  *
@@ -291,9 +292,9 @@ export declare function emitEffectFn(ctx: CodeGenContext, source: string): strin
  * re-read per call, for the same reason call-invoked helpers are (a per-call
  * array element load is not a foldable callee).
  */
-export declare function emitEffectCallable(ctx: CodeGenContext, effect: {
-    refIndex?: number | undefined;
-    source?: string | undefined;
+declare function emitEffectCallable(ctx: CodeGenContext, effect: {
+  refIndex?: number | undefined;
+  source?: string | undefined;
 }): string;
 /**
  * Pristine fallback delegate: declare `var __rfp_N=__rf[N].safeParse.bind(__rf[N]);`
@@ -312,14 +313,14 @@ export declare function emitEffectCallable(ctx: CodeGenContext, effect: {
  * compiled validator (whose own delegates were captured even earlier), never
  * a cycle.
  */
-export declare function emitRfDelegate(ctx: CodeGenContext, refIndex: number): string;
+declare function emitRfDelegate(ctx: CodeGenContext, refIndex: number): string;
 /**
  * Resolve a regex pattern to a runtime variable name.
  * Lean mode short-circuits well-known patterns to virtual-module names so the
  * bundler can dedup across files; everything else is cached + declared in the
  * per-IIFE preamble exactly once per pattern.
  */
-export declare function emitRegex(ctx: CodeGenContext, prefix: string, pattern: string, flags?: string): string;
+declare function emitRegex(ctx: CodeGenContext, prefix: string, pattern: string, flags?: string): string;
 /**
  * Resolve the ORIGINAL `/source/flags` pattern string of a regex for issue
  * reporting. Only needed when emitRegex swapped in a faster equivalent test
@@ -327,7 +328,7 @@ export declare function emitRegex(ctx: CodeGenContext, prefix: string, pattern:
  * references the shared `<name>Src` virtual export so the original pattern
  * stays a single bundle-wide string; inline mode declares it once per IIFE.
  */
-export declare function emitRegexSourceString(ctx: CodeGenContext, pattern: string): string;
+declare function emitRegexSourceString(ctx: CodeGenContext, pattern: string): string;
 /**
  * Declare a constant value in the preamble and return its variable name,
  * reusing an earlier declaration of the SAME initializer.
@@ -339,9 +340,9 @@ export declare function emitRegexSourceString(ctx: CodeGenContext, pattern: stri
  * 20-value enum schema's generated bytes, 16% for an object with two identical
  * enums. Keyed by initializer text, so only identical payloads collapse.
  */
-export declare function emitConstant(ctx: CodeGenContext, prefix: string, initializer: string): string;
+declare function emitConstant(ctx: CodeGenContext, prefix: string, initializer: string): string;
 /** Declare a `new Set([...])` in the preamble and return its variable name. */
-export declare function emitSet(ctx: CodeGenContext, prefix: string, values: readonly unknown[]): string;
+declare function emitSet(ctx: CodeGenContext, prefix: string, values: readonly unknown[]): string;
 /**
  * Shape-key count at or below which the unknown-key pass compares with an
  * inline `===` chain rather than a hashed lookup.
@@ -361,7 +362,7 @@ export declare function emitSet(ctx: CodeGenContext, prefix: string, values: rea
  * only loses past ~96, where `Set.has` (not the table, which never wins at any
  * size) takes over. 64 sits below that crossover and above any realistic shape.
  */
-export declare const KEY_MEMBERSHIP_INLINE_THRESHOLD = 64;
+declare const KEY_MEMBERSHIP_INLINE_THRESHOLD = 64;
 /**
  * Boolean membership test for one key variable against a fixed key list.
  * Empty list recognizes nothing.
@@ -371,7 +372,7 @@ export declare const KEY_MEMBERSHIP_INLINE_THRESHOLD = 64;
  * by an object literal, so that key would silently read as unknown), which the
  * Set has no trouble with.
  */
-export declare function keyMembershipTest(ctx: CodeGenContext, keys: readonly string[], keyVar: string): string;
+declare function keyMembershipTest(ctx: CodeGenContext, keys: readonly string[], keyVar: string): string;
 /**
  * Enum values at or below this count use inline === checks instead of Set.has().
  * Measured on V8: for ≤5 values, an === chain beats Set.has by up to ~3x with
@@ -379,21 +380,21 @@ export declare function keyMembershipTest(ctx: CodeGenContext, keys: readonly st
  * successful comparison, making subsequent arms pointer-equality — and is no
  * worse than Set.has even with adversarial shared-prefix values.
  */
-export declare const ENUM_INLINE_THRESHOLD = 5;
-export declare function escapeString(s: string | number): string;
+declare const ENUM_INLINE_THRESHOLD = 5;
+declare function escapeString(s: string | number): string;
 /**
  * JS source for a primitive literal value (literal schemas, discriminator
  * case labels). JSON.stringify covers string/number/boolean/null; bigint
  * needs the `n` suffix (JSON.stringify throws and String(5n) renders a
  * number literal that never strict-equals a bigint); undefined isn't JSON.
  */
-export declare function literalToJs(v: string | number | boolean | null | bigint | undefined): string;
+declare function literalToJs(v: string | number | boolean | null | bigint | undefined): string;
 /**
  * Reference a shared runtime helper (e.g. __zcFsr) from generated code.
  * Lean mode: registers it for the `virtual:zod-compiler/runtime` import.
  * Inline mode: declares it once in the per-IIFE preamble.
  */
-export declare function emitRuntimeHelper(ctx: CodeGenContext, name: string, decl: string): string;
+declare function emitRuntimeHelper(ctx: CodeGenContext, name: string, decl: string): string;
 /**
  * Extend a path expression with one or more scalar segment expressions
  * (escaped string literals, numeric literals, or loop-variable names).
@@ -405,11 +406,11 @@ export declare function emitRuntimeHelper(ctx: CodeGenContext, name: string, dec
  * (`["data"].concat("items").concat(__i_7)`). Opaque expressions fall back
  * to .concat().
  */
-export declare function extendPath(parentPath: string, segExpr: string): string;
+declare function extendPath(parentPath: string, segExpr: string): string;
 /** Extend a path expression with a static string key. */
-export declare function extendStaticPath(parentPath: string, key: string): string;
+declare function extendStaticPath(parentPath: string, key: string): string;
 /** Extend a path expression with a numeric index. */
-export declare function extendStaticPathIndex(parentPath: string, index: number): string;
+declare function extendStaticPathIndex(parentPath: string, index: number): string;
 /**
  * Check if a SchemaIR tree produces output that is not the input itself —
  * either value-mutating operations (coerce, default, catch, overwrite) that
@@ -419,7 +420,7 @@ export declare function extendStaticPathIndex(parentPath: string, index: number)
  * input), by generateValidator to keep such schemas off the by-reference fast
  * path, and by the shared-walk dedup + intersection extractor to exclude them.
  */
-export declare function hasMutation(ir: SchemaIR): boolean;
+declare function hasMutation(ir: SchemaIR): boolean;
 /**
  * Is a defaulted property's key guaranteed to appear in the stripped output?
  *
@@ -433,7 +434,7 @@ export declare function hasMutation(ir: SchemaIR): boolean;
  * branch runs only when `input[key] !== undefined`, which implies `key in input`
  * — so zod's presence test keeps the key whatever the inner produced.
  */
-export declare function outputAlwaysDefined(ir: SchemaIR): boolean;
+declare function outputAlwaysDefined(ir: SchemaIR): boolean;
 /**
  * Does this schema reject `undefined` outright?
  *
@@ -442,10 +443,12 @@ export declare function outputAlwaysDefined(ir: SchemaIR): boolean;
  * `optin: "optional"` and accepts a shorter array. Conservative: anything that
  * might accept, produce, or default to `undefined` answers false.
  */
-export declare function rejectsUndefined(ir: SchemaIR): boolean;
+declare function rejectsUndefined(ir: SchemaIR): boolean;
 /**
  * Sort comparator for CheckIR: cheapest/most-discriminating checks first.
  * Used by fast-path generators after filtering out refine_effect entries.
  */
-export declare function checkPriority(a: CheckIR | BigIntCheckIR | DateCheckIR | SetCheckIR, b: CheckIR | BigIntCheckIR | DateCheckIR | SetCheckIR): number;
+declare function checkPriority(a: CheckIR | BigIntCheckIR | DateCheckIR | SetCheckIR, b: CheckIR | BigIntCheckIR | DateCheckIR | SetCheckIR): number;
+//#endregion
+export { CodeGenContext, CodeGenResult, CodegenMode, ENUM_INLINE_THRESHOLD, FastGen, FastGenerator, FastScope, KEY_MEMBERSHIP_INLINE_THRESHOLD, RecTargetGen, SlowGen, SlowGenerator, checkPriority, declareFastTemps, emitConstant, emitEffectCallable, emitEffectFn, emitRegex, emitRegexSourceString, emitRfDelegate, emitRuntimeHelper, emitSet, emitTemp, escapeString, extendPath, extendStaticPath, extendStaticPathIndex, fastSentinelWrapper, hasMutation, keyMembershipTest, literalToJs, outputAlwaysDefined, rejectsUndefined };
 //# sourceMappingURL=context.d.ts.map