zod-compiler 1.26.0 → 1.26.1

package/dist/core/codegen/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/core/codegen/index.ts"],"sourcesContent":["import type { SchemaIR } from \"../types.js\";\nimport type { CodeGenContext, CodeGenResult, CodegenMode, RecTargetGen } from \"./context.js\";\nimport { fastResultIsInput, generateBuild, rebuildsOutput } from \"./build-path.js\";\nimport { declareFastTemps, emitRfDelegate, hasMutation } from \"./context.js\";\nimport type { SharedSchemaPlan } from \"./dedupe.js\";\nimport { createFastGen, generateFast } from \"./fast-path.js\";\nimport { createSlowGen, generateSlow } from \"./slow-path.js\";\n\nexport type { CodeGenResult } from \"./context.js\";\n\nexport interface GenerateValidatorOptions {\n  refCount?: number;\n  /** Codegen output mode. Defaults to \"inline\". */\n  mode?: CodegenMode;\n  /**\n   * File-level shared slow-walk plan (schema deduplication). Applied only to\n   * mutation-free schemas, so shared walks stay on the deferred cold path.\n   */\n  sharedSchemas?: SharedSchemaPlan | undefined;\n  /**\n   * Compact mode (`output: \"compact\"`). Drop the compiled slow walk for\n   * mutation-free schemas with a TOTAL fast path and delegate the cold error\n   * path to the retained Zod schema (`__zcFinZ`). The fast (hot) path is\n   * unchanged; only the bulky error-collecting walk — 64–77% of generated\n   * bytes — is replaced by a few bytes of zod delegation. See\n   * {@link CodeGenResult.rootDelegateRefIndex}.\n   */\n  compact?: boolean | undefined;\n}\n\n/**\n * Generate optimized validation code from SchemaIR.\n *\n * - `code`: preamble declarations (Sets, RegExps, etc.) — deterministic for the same IR\n * - `functionDef`: full function expression string referencing preamble vars via closure\n * - `usedHelpers`: helper names from \"virtual:zod-compiler/runtime\" referenced (lean mode only)\n *\n * Usage: `new Function(code + \"\\nreturn \" + functionDef + \";\")()`\n */\nexport function generateValidator(\n  ir: SchemaIR,\n  name: string,\n  options?: GenerateValidatorOptions,\n): CodeGenResult {\n  const fnName = `safeParse_${name}`;\n  const mode: CodegenMode = options?.mode ?? \"inline\";\n  const ctx: CodeGenContext = {\n    preamble: [],\n    counter: 0,\n    fnName,\n    regexCache: new Map(),\n    mode,\n    usedHelpers: new Set(),\n  };\n\n  // Slow-walk sharing. The plan already excludes any shape that would reach for\n  // this export's `__rf[]`, and a shared walk returns its parsed value, so a\n  // rewriting shape (a stripping object above all) delivers its result through\n  // the call. Nothing left to gate on here.\n  if (options?.sharedSchemas !== undefined) {\n    ctx.sharedSchemas = options.sharedSchemas;\n  }\n\n  // Root-level fallback: the whole schema delegates to Zod, so zod's own\n  // safeParse result IS the result. Returning it directly skips the issue\n  // copy loop (which would force zod's eager ZodError construction), the\n  // pointless [].concat(path) rewrites, and the __zcFin re-wrap. Delegation\n  // goes through the pre-mutation capture (emitRfDelegate) — here __rf[0]\n  // and the __zcMkv target are routinely the SAME object.\n  if (ir.type === \"fallback\" && ir.refIndex !== undefined) {\n    const delegate = emitRfDelegate(ctx, ir.refIndex);\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: `function ${fnName}(input){return ${delegate}(input);}`,\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n    };\n  }\n\n  // Recursion-target table. The root (refId 0) reuses the schema's own\n  // `safeParse_<name>` / hosted fast-check, so it needs no separate helper and\n  // its fast name is allocated lazily during the walk (recFastName). Non-root\n  // targets — recursive sub-schemas nested in a larger root, multiple distinct\n  // recursive shapes, mutual recursion — are each hosted as a standalone\n  // `__rsp_N` (slow) / `__fcr_N` (fast) validator the cycle calls by name.\n  // Common directly-self-recursive schemas have no non-root targets, so this\n  // leaves their generated output byte-identical.\n  const nonRootTargets = collectRecursionTargets(ir);\n  ctx.recTargets = new Map<number, RecTargetGen>([[0, { isRoot: true, slowName: fnName }]]);\n  for (const [refId, inner] of nonRootTargets) {\n    ctx.recTargets.set(refId, {\n      isRoot: false,\n      inner,\n      slowName: `__rsp_${ctx.counter++}`,\n      fastName: `__fcr_${ctx.counter++}`,\n    });\n  }\n  const hasNonRootTargets = nonRootTargets.size > 0;\n\n  // Fast Path: generate a boolean expression for eligible schemas.\n  //\n  // generateFast mutates ctx as it walks (extracted __fo_ helpers + regex/effect\n  // decls pushed to the preamble, a recursive __fcr_ name reserved, dedup caches\n  // populated). The walk is all-or-nothing: a later fast-ineligible node makes it\n  // return null AFTER those side effects already landed. Without a rollback the\n  // discarded fast path leaves dead __fo_ helpers in the output — and, when one\n  // referenced the recursive __fcr_ host that the `fastExpr !== null` branch below\n  // never emits, a dangling reference to an undefined identifier. Snapshot the\n  // mutable state and restore it on abort so the slow path re-declares from clean.\n  const fastPreambleLen = ctx.preamble.length;\n  const fastRegexCache = new Map(ctx.regexCache);\n  const fastEffectCache = ctx.effectFnCache && new Map(ctx.effectFnCache);\n  const fastValueCache = ctx.valueCache && new Map(ctx.valueCache);\n  const fastRecName = ctx.recFastName;\n  const fg = createFastGen(\"input\", ctx);\n  let fastExpr = generateFast(ir, fg);\n  if (fastExpr !== null && hasNonRootTargets) {\n    // Host each non-root recursion target as a boolean fast-check helper. A\n    // single fast-ineligible target (e.g. one whose recursive shape contains a\n    // fallback) disables the WHOLE fast path: the root expression already emits\n    // calls to these names, so a missing body would dangle. The shared\n    // rollback below then restores clean state for the slow-only path.\n    for (const t of ctx.recTargets.values()) {\n      if (t.isRoot) continue;\n      const targetGen = createFastGen(\"input\", ctx, false);\n      const body = generateFast(t.inner as SchemaIR, targetGen);\n      if (body === null) {\n        fastExpr = null;\n        break;\n      }\n      ctx.preamble.push(\n        `function ${t.fastName}(input){${declareFastTemps(targetGen.scope)}return ${body};}`,\n      );\n    }\n  }\n  if (fastExpr === null) {\n    ctx.preamble.length = fastPreambleLen;\n    ctx.regexCache = fastRegexCache;\n    if (fastEffectCache === undefined) delete ctx.effectFnCache;\n    else ctx.effectFnCache = fastEffectCache;\n    // Value declarations the abandoned walk emitted are truncated above, so\n    // their cache entries would name identifiers that no longer exist.\n    if (fastValueCache === undefined) delete ctx.valueCache;\n    else ctx.valueCache = fastValueCache;\n    if (fastRecName === undefined) delete ctx.recFastName;\n    else ctx.recFastName = fastRecName;\n  }\n\n  // Host the fast expression in a named boolean helper. Self-recursive\n  // schemas need it so recursive refs can call it; every other eligible\n  // schema benefits too: __zcMkv wires it into parse()/parseAsync(), whose\n  // success paths then return the input directly — no intermediate\n  // SafeParseResult allocation (the safeParse function body is far past\n  // V8's inlining budget, so escape analysis never removes it).\n  let fastFnName: string | null = null;\n  if (fastExpr !== null && fastExpr !== \"true\") {\n    fastFnName = ctx.recFastName ?? `__fc_${ctx.counter++}`;\n    ctx.preamble.push(\n      `function ${fastFnName}(input){${declareFastTemps(fg.scope)}return ${fastExpr};}`,\n    );\n    fastExpr = `${fastFnName}(input)`;\n  }\n\n  // Build Path: one pass that validates and assembles rewritten output, bailing\n  // on the first failure (see build-path). Null unless every mutation in the\n  // schema is modelled — so this emits nothing for the mutation-free schemas\n  // the compact branch takes.\n  const buildFnName = generateBuild(ir, ctx);\n\n  // A zodDelegate with a rebuilding inner exists only to accelerate that\n  // build. If an unmodelled descendant made the all-or-nothing build decline,\n  // preserve the old root-fallback shape instead of wrapping the same pristine\n  // Zod call in an issues array/copy/finalizer. This keeps unsupported object\n  // intersections neutral rather than making compilation slower than Zod.\n  if (ir.type === \"zodDelegate\" && rebuildsOutput(ir.inner) && buildFnName === null) {\n    ctx.preamble.length = 0;\n    ctx.usedHelpers.clear();\n    ctx.regexCache.clear();\n    ctx.effectFnCache?.clear();\n    ctx.valueCache?.clear();\n    const delegate = emitRfDelegate(ctx, ir.refIndex);\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: `function ${fnName}(input){return ${delegate}(input);}`,\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n    };\n  }\n\n  // `.is()` for a build-path schema is the fast expression — stripping reshapes\n  // the payload, never the verdict. A substituted `.default()` breaks that: the\n  // fast check demands a present value where the schema accepts its absence, so\n  // the predicate is partial and `.is()` falls back to safeParse().success\n  // (which runs the build pass, so it is no slower than the eager walk was).\n  const buildIsFnName = ctx.buildSubstitutesValue === true ? null : fastFnName;\n\n  const baseRefCount = options?.refCount ?? 0;\n\n  // Compact mode: a mutation-free schema with a TOTAL fast path needs no\n  // compiled slow walk — its only purpose is reproducing zod's issues on\n  // failure, and the original zod schema (retained in `output: \"compact\"`) does\n  // that exactly. Emit the fast check and, on failure, delegate to a fresh root\n  // RefEntry (the schema itself) via the pristine-bound safeParse capture, then\n  // wrap it in the lazy `__zcFinZ` failure. Drops 64–77% of generated bytes\n  // with zero hot-path cost (fc and `.is()` are unchanged) and zod-identical\n  // errors. Excluded: schemas with non-root recursion targets (mutual/nested\n  // recursion still hosts standalone slow validators) and any non-total fast\n  // path (mutation/default/catch/fallback) — those keep the compiled path.\n  if (\n    options?.compact === true &&\n    fastExpr !== null &&\n    fastExpr !== \"true\" &&\n    !hasMutation(ir) &&\n    !hasNonRootTargets\n  ) {\n    const delegate = emitRfDelegate(ctx, baseRefCount);\n    ctx.usedHelpers.add(\"__zcFinZ\");\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinZ(${delegate},input);`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: baseRefCount + 1,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName,\n      // Mutation-free total fast path: fc(input) ⟺ accepts(input), so `.is()`\n      // installs fc directly (compact never weakens the guard).\n      fastTotal: true,\n      rootDelegateRefIndex: baseRefCount,\n    };\n  }\n\n  // Compact + Build Path: same bargain for a schema with modelled rewrites. The\n  // build pass still has to run (it produces the payload, which zod's schema\n  // would only reproduce by parsing again), but the compiled issue walk is what\n  // compact drops, and delegating that to the retained zod schema costs a few\n  // bytes.\n  if (\n    options?.compact === true &&\n    buildFnName !== null &&\n    ctx.buildFailName !== undefined &&\n    !hasNonRootTargets\n  ) {\n    const delegate = emitRfDelegate(ctx, baseRefCount);\n    ctx.usedHelpers.add(\"__zcFinZ\");\n    const built = `__bd_${ctx.counter++}`;\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `var ${built}=${buildFnName}(input);`,\n        `if(${built}!==${ctx.buildFailName}){return{success:true,data:${built}};}`,\n        `return __zcFinZ(${delegate},input);`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: baseRefCount + 1,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n      isFnName: buildIsFnName,\n      rootDelegateRefIndex: baseRefCount,\n    };\n  }\n\n  // Host each non-root recursion target as a safeParse-shaped slow validator,\n  // mirroring the root's eager body: collect issues, return success+data or a\n  // deferred-error result. Always emitted (the slow path always exists); the\n  // recursion call sites read `.success` / `.error.issues` / `.data`. Hoisted\n  // function declarations, so their order relative to the root is irrelevant.\n  if (hasNonRootTargets) {\n    for (const t of ctx.recTargets.values()) {\n      if (t.isRoot) continue;\n      const body = generateSlow(t.inner as SchemaIR, createSlowGen(\"_d\", \"_d\", \"[]\", \"_e\", ctx));\n      ctx.usedHelpers.add(\"__zcFin\");\n      ctx.preamble.push(\n        `function ${t.slowName}(input){var _e=[];\\nvar _d=input;\\n${body}\\n` +\n          `if(_e.length===0){return{success:true,data:_d};}\\nreturn __zcFin(_e,_d);}`,\n      );\n    }\n  }\n\n  const sg = createSlowGen(\"_d\", \"_d\", \"[]\", \"_e\", ctx);\n  // When the root schema's own shape is shared (it recurs as a sub-schema of\n  // another export, or as a duplicate root), its slow walk delegates to the\n  // shared function instead of emitting a second full copy. The fast path is\n  // still generated inline above — only the cold walk is shared.\n  const rootRef = ctx.sharedSchemas?.refFor(ir);\n  const slowCode = rootRef !== undefined ? `_d=${rootRef.name}(_d,[],_e);` : generateSlow(ir, sg);\n\n  const buildCode = (): string => [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\");\n\n  const functionDefParts = [`function ${fnName}(input){`];\n\n  // Build Path: every mutation is modelled, so one pass can validate and\n  // assemble the output together and bail on the first failure, leaving the\n  // issue-producing walk deferred behind `.error` (see build-path).\n  // The fast check stays out of `safeParse` entirely — running it first would\n  // read every property twice — but it is still an EXACT acceptance predicate\n  // (stripping reshapes the output, never the verdict), so `.is()` installs it.\n  if (buildFnName !== null && ctx.buildFailName !== undefined) {\n    ctx.usedHelpers.add(\"__zcFinD\");\n    const built = `__bd_${ctx.counter++}`;\n    // A self-recursive walk calls this validator BY NAME (slowRecursiveRef),\n    // and that binding exists only inside the named function expression — so\n    // there the walk stays a per-call closure. Everything else hosts it in the\n    // preamble, keeping safeParse to three statements. Mirrors the same split\n    // in the mutation-free branch below.\n    const recursive = slowCode.includes(fnName);\n    let deferred: string;\n    if (recursive) {\n      deferred = `__zcFinD(function(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;},input)`;\n    } else {\n      const walkName = `__sw_${ctx.counter++}`;\n      ctx.preamble.push(\n        `function ${walkName}(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;}`,\n      );\n      deferred = `__zcFinD(${walkName},input)`;\n    }\n    return {\n      code: buildCode(),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `var ${built}=${buildFnName}(input);`,\n        `if(${built}!==${ctx.buildFailName}){return{success:true,data:${built}};}`,\n        `return ${deferred};`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      // No by-reference shortcut: `data` is the freshly built object, so\n      // parse() must go through safeParse rather than returning its input.\n      fastFnName: null,\n      // `fastTotal` qualifies `fastFnName`, which is null here; the predicate\n      // travels in `isFnName` instead.\n      fastTotal: false,\n      isFnName: buildIsFnName,\n    };\n  }\n\n  if (fastExpr === \"true\") {\n    // Schema always succeeds (any/unknown) — skip slow path entirely\n    functionDefParts.push(`return{success:true,data:input};`);\n    functionDefParts.push(`}`);\n    return {\n      code: buildCode(),\n      functionDef: functionDefParts.join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      // any/unknown always succeed; `.is()` derives `true` from the fn fallback.\n      fastTotal: false,\n    };\n  }\n\n  if (fastExpr !== null && !hasMutation(ir)) {\n    // Mutation-free schemas with a fast path: a fast-check failure can never\n    // become a slow-path success (both are generated from the same checks —\n    // unlike default/catch schemas, whose partial fast path requires value\n    // presence while the slow path SUCCEEDS by applying the fallback).\n    // The slow path's only output is therefore the issues array, observable\n    // solely through `.error` — defer the whole re-walk into the cached\n    // accessor (__zcFinD): a failed safeParse whose `.error` is never read\n    // costs the fast check alone.\n    //\n    // The walk is HOSTED as a named preamble function rather than a per-call\n    // closure, for two measured reasons: (1) a failed safeParse no longer\n    // allocates a closure environment + function object before the deferral\n    // even starts; (2) the safeParse body shrinks to two statements, putting\n    // it within V8's inlining budget — callers in hot loops get the\n    // success-path result object escape-analyzed away entirely, which the\n    // old shape (slow walk inlined into the body) made impossible.\n    ctx.usedHelpers.add(\"__zcFinD\");\n    if (slowCode.includes(fnName)) {\n      // Self-recursive slow paths call the safeParse function by NAME\n      // (slowRecursiveRef) — that binding exists only inside the named\n      // function expression under the documented evaluation contract\n      // (`new Function(code + \"return \" + functionDef)`), so the walk stays\n      // a per-call closure for recursive schemas. Recursion is the rare\n      // shape; everything else gets the hosted walk.\n      functionDefParts.push(\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinD(function(input){`,\n        `var _e=[];`,\n        `var _d=input;`,\n        slowCode,\n        `return _e;`,\n        `},input);`,\n        `}`,\n      );\n    } else {\n      const walkName = `__sw_${ctx.counter++}`;\n      ctx.preamble.push(\n        `function ${walkName}(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;}`,\n      );\n      functionDefParts.push(\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinD(${walkName},input);`,\n        `}`,\n      );\n    }\n    return {\n      code: buildCode(),\n      functionDef: functionDefParts.join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName,\n      // Total predicate: mutation-free fast path, fc(input) ⟺ accepts(input).\n      // generateIIFE installs fc directly as the zero-allocation `.is()`.\n      fastTotal: true,\n    };\n  }\n\n  if (fastExpr !== null && fastResultIsInput(ir)) {\n    // Partial fast path (default/catch/... present-value shortcut): the slow\n    // path must run eagerly — it can succeed where the fast check failed.\n    //\n    // Withheld when the schema rebuilds its output: there the fast check is a\n    // sound VERDICT but says nothing about the payload, and `data:input` would\n    // hand back the unstripped input. Such schemas reach here only when the\n    // build path declined them, so the eager walk produces the output instead.\n    functionDefParts.push(`if(${fastExpr}){return{success:true,data:input};}`);\n  }\n\n  // Success branch inlined at the call site instead of inside __zcFin: the\n  // eager path (mutation schemas — coerce/default/trim/transform) returns\n  // here on EVERY parse, and the inline literal keeps the hot exit free of a\n  // cross-function call; __zcFin is reached only on failure.\n  functionDefParts.push(\n    `var _e=[];`,\n    `var _d=input;`,\n    slowCode,\n    `if(_e.length===0){return{success:true,data:_d};}`,\n    `return __zcFin(_e,_d);`,\n    `}`,\n  );\n\n  const functionDef = functionDefParts.join(\"\\n\");\n\n  return {\n    code: buildCode(),\n    functionDef,\n    refCount: options?.refCount ?? 0,\n    usedHelpers: ctx.usedHelpers,\n    // `fc` carries a stronger contract than \"accepts\": `__zcMkv` returns the\n    // INPUT from `parse()`/`parseAsync()`/`~standard` whenever it holds, so it\n    // may only be published when a passing check implies `data === input`. A\n    // rebuilding schema breaks that even though its safeParse is correct, and so\n    // does a union whose options can rewrite — see `fastResultIsInput` for both.\n    // Same guard as the `data: input` shortcut above, which is the other reader\n    // of the same contract.\n    fastFnName: fastResultIsInput(ir) ? fastFnName : null,\n    // Partial fast path (default/catch) or none (including coercion): a false fc\n    // result does not imply rejection, so `.is()` derives from\n    // safeParse(input).success.\n    fastTotal: false,\n  };\n}\n\n/**\n * Find every non-root recursion target (a `recursionTarget` node, refId ≥ 1)\n * reachable from `root`, mapping refId → the inner IR to host as a standalone\n * validator. The root target (refId 0) is the schema's own function and is\n * never wrapped, so it never appears here. The same target may be wrapped at\n * several sites (a recursive schema reached from sibling positions); the first\n * inner wins — they are structurally identical extractions of one schema.\n */\nfunction collectRecursionTargets(root: SchemaIR): Map<number, SchemaIR> {\n  const out = new Map<number, SchemaIR>();\n  const seen = new Set<SchemaIR>();\n  const walk = (ir: SchemaIR): void => {\n    if (seen.has(ir)) return;\n    seen.add(ir);\n    if (ir.type === \"recursionTarget\" && !out.has(ir.refId)) {\n      out.set(ir.refId, ir.inner);\n    }\n    for (const child of childIRs(ir)) walk(child);\n  };\n  walk(root);\n  return out;\n}\n\n/** Direct child SchemaIR nodes, covering every node type (including the new wrapper). */\nfunction childIRs(ir: SchemaIR): readonly SchemaIR[] {\n  switch (ir.type) {\n    case \"object\":\n      return Object.values(ir.properties);\n    case \"array\":\n      return [ir.element];\n    case \"tuple\":\n      return ir.rest === null ? ir.items : [...ir.items, ir.rest];\n    case \"record\":\n    case \"map\":\n      return [ir.keyType, ir.valueType];\n    case \"set\":\n      return [ir.valueType];\n    case \"union\":\n    case \"discriminatedUnion\":\n      return ir.options;\n    case \"intersection\":\n      return [ir.left, ir.right];\n    case \"optional\":\n    case \"nullable\":\n    case \"readonly\":\n    case \"default\":\n    case \"catch\":\n    case \"effect\":\n    case \"recursionTarget\":\n    case \"zodDelegate\":\n      return [ir.inner];\n    case \"pipe\":\n      return [ir.in, ir.out];\n    default:\n      return [];\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/core/codegen/index.ts"],"sourcesContent":["import type { SchemaIR } from \"../types.js\";\nimport type {\n  CodeGenContext,\n  CodeGenResult,\n  CodegenMode,\n  GeneratedSetConstant,\n  RecTargetGen,\n} from \"./context.js\";\nimport { fastResultIsInput, generateBuild, rebuildsOutput } from \"./build-path.js\";\nimport { declareFastTemps, emitRfDelegate, emitRfMethod, hasMutation } from \"./context.js\";\nimport type { SharedSchemaPlan } from \"./dedupe.js\";\nimport { createFastGen, generateFast } from \"./fast-path.js\";\nimport { createSlowGen, generateSlow } from \"./slow-path.js\";\n\nexport type { CodeGenResult } from \"./context.js\";\n\nexport interface GenerateValidatorOptions {\n  refCount?: number;\n  /** Codegen output mode. Defaults to \"inline\". */\n  mode?: CodegenMode;\n  /**\n   * File-level shared slow-walk plan (schema deduplication). Applied only to\n   * mutation-free schemas, so shared walks stay on the deferred cold path.\n   */\n  sharedSchemas?: SharedSchemaPlan | undefined;\n  /**\n   * Compact mode (`output: \"compact\"`). Drop the compiled slow walk for\n   * mutation-free schemas with a TOTAL fast path and delegate the cold error\n   * path to the retained Zod schema (`__zcFinZ`). The fast (hot) path is\n   * unchanged; only the bulky error-collecting walk — 64–77% of generated\n   * bytes — is replaced by a few bytes of zod delegation. See\n   * {@link CodeGenResult.rootDelegateRefIndex}.\n   */\n  compact?: boolean | undefined;\n  /** Internal file-pipeline hook for sharing exact Set initializers across validators. */\n  onSetConstant?: ((constant: GeneratedSetConstant) => void) | undefined;\n  /** Internal exact-initializer plan used by the file pipeline's final generation pass. */\n  sharedSetNames?: ReadonlyMap<string, string> | undefined;\n}\n\n/**\n * Generate optimized validation code from SchemaIR.\n *\n * - `code`: preamble declarations (Sets, RegExps, etc.) — deterministic for the same IR\n * - `functionDef`: full function expression string referencing preamble vars via closure\n * - `usedHelpers`: helper names from \"virtual:zod-compiler/runtime\" referenced (lean mode only)\n *\n * Usage: `new Function(code + \"\\nreturn \" + functionDef + \";\")()`\n */\nexport function generateValidator(\n  ir: SchemaIR,\n  name: string,\n  options?: GenerateValidatorOptions,\n): CodeGenResult {\n  const fnName = `safeParse_${name}`;\n  const mode: CodegenMode = options?.mode ?? \"inline\";\n  const ctx: CodeGenContext = {\n    preamble: [],\n    counter: 0,\n    fnName,\n    regexCache: new Map(),\n    mode,\n    usedHelpers: new Set(),\n    onSetConstant: options?.onSetConstant,\n    sharedSetNames: options?.sharedSetNames,\n  };\n\n  // Slow-walk sharing. The plan already excludes any shape that would reach for\n  // this export's `__rf[]`, and a shared walk returns its parsed value, so a\n  // rewriting shape (a stripping object above all) delivers its result through\n  // the call. Nothing left to gate on here.\n  if (options?.sharedSchemas !== undefined) {\n    ctx.sharedSchemas = options.sharedSchemas;\n  }\n\n  // Root-level fallback: the whole schema delegates to Zod, so zod's own\n  // safeParse result IS the result. Returning it directly skips the issue\n  // copy loop (which would force zod's eager ZodError construction), the\n  // pointless [].concat(path) rewrites, and the __zcFin re-wrap. Delegation\n  // goes through the pre-mutation capture (emitRfDelegate) — here __rf[0]\n  // and the __zcMkv target are routinely the SAME object.\n  if (ir.type === \"fallback\" && ir.refIndex !== undefined) {\n    const delegate = emitRfDelegate(ctx, ir.refIndex);\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: `function ${fnName}(input){return ${delegate}(input);}`,\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n    };\n  }\n\n  // Recursion-target table. The root (refId 0) reuses the schema's own\n  // `safeParse_<name>` / hosted fast-check, so it needs no separate helper and\n  // its fast name is allocated lazily during the walk (recFastName). Non-root\n  // targets — recursive sub-schemas nested in a larger root, multiple distinct\n  // recursive shapes, mutual recursion — are each hosted as a standalone\n  // `__rsp_N` (slow) / `__fcr_N` (fast) validator the cycle calls by name.\n  // Common directly-self-recursive schemas have no non-root targets, so this\n  // leaves their generated output byte-identical.\n  const nonRootTargets = collectRecursionTargets(ir);\n  ctx.recTargets = new Map<number, RecTargetGen>([[0, { isRoot: true, slowName: fnName }]]);\n  for (const [refId, inner] of nonRootTargets) {\n    ctx.recTargets.set(refId, {\n      isRoot: false,\n      inner,\n      slowName: `__rsp_${ctx.counter++}`,\n      fastName: `__fcr_${ctx.counter++}`,\n    });\n  }\n  const hasNonRootTargets = nonRootTargets.size > 0;\n\n  // Fast Path: generate a boolean expression for eligible schemas.\n  //\n  // generateFast mutates ctx as it walks (extracted __fo_ helpers + regex/effect\n  // decls pushed to the preamble, a recursive __fcr_ name reserved, dedup caches\n  // populated). The walk is all-or-nothing: a later fast-ineligible node makes it\n  // return null AFTER those side effects already landed. Without a rollback the\n  // discarded fast path leaves dead __fo_ helpers in the output — and, when one\n  // referenced the recursive __fcr_ host that the `fastExpr !== null` branch below\n  // never emits, a dangling reference to an undefined identifier. Snapshot the\n  // mutable state and restore it on abort so the slow path re-declares from clean.\n  const fastPreambleLen = ctx.preamble.length;\n  const fastRegexCache = new Map(ctx.regexCache);\n  const fastEffectCache = ctx.effectFnCache && new Map(ctx.effectFnCache);\n  const fastValueCache = ctx.valueCache && new Map(ctx.valueCache);\n  const fastRecName = ctx.recFastName;\n  const fg = createFastGen(\"input\", ctx);\n  let fastExpr = generateFast(ir, fg);\n  if (fastExpr !== null && hasNonRootTargets) {\n    // Host each non-root recursion target as a boolean fast-check helper. A\n    // single fast-ineligible target (e.g. one whose recursive shape contains a\n    // fallback) disables the WHOLE fast path: the root expression already emits\n    // calls to these names, so a missing body would dangle. The shared\n    // rollback below then restores clean state for the slow-only path.\n    for (const t of ctx.recTargets.values()) {\n      if (t.isRoot) continue;\n      const targetGen = createFastGen(\"input\", ctx, false);\n      const body = generateFast(t.inner as SchemaIR, targetGen);\n      if (body === null) {\n        fastExpr = null;\n        break;\n      }\n      ctx.preamble.push(\n        `function ${t.fastName}(input){${declareFastTemps(targetGen.scope)}return ${body};}`,\n      );\n    }\n  }\n  if (fastExpr === null) {\n    ctx.preamble.length = fastPreambleLen;\n    ctx.regexCache = fastRegexCache;\n    if (fastEffectCache === undefined) delete ctx.effectFnCache;\n    else ctx.effectFnCache = fastEffectCache;\n    // Value declarations the abandoned walk emitted are truncated above, so\n    // their cache entries would name identifiers that no longer exist.\n    if (fastValueCache === undefined) delete ctx.valueCache;\n    else ctx.valueCache = fastValueCache;\n    if (fastRecName === undefined) delete ctx.recFastName;\n    else ctx.recFastName = fastRecName;\n  }\n\n  // Host the fast expression in a named boolean helper. Self-recursive\n  // schemas need it so recursive refs can call it; every other eligible\n  // schema benefits too: __zcMkv wires it into parse()/parseAsync(), whose\n  // success paths then return the input directly — no intermediate\n  // SafeParseResult allocation (the safeParse function body is far past\n  // V8's inlining budget, so escape analysis never removes it).\n  let fastFnName: string | null = null;\n  if (fastExpr !== null && fastExpr !== \"true\") {\n    fastFnName = ctx.recFastName ?? `__fc_${ctx.counter++}`;\n    ctx.preamble.push(\n      `function ${fastFnName}(input){${declareFastTemps(fg.scope)}return ${fastExpr};}`,\n    );\n    fastExpr = `${fastFnName}(input)`;\n  }\n\n  // Build Path: one pass that validates and assembles rewritten output, bailing\n  // on the first failure (see build-path). Null unless every mutation in the\n  // schema is modelled — so this emits nothing for the mutation-free schemas\n  // the compact branch takes.\n  const buildFnName = generateBuild(ir, ctx);\n\n  // A zodDelegate with a rebuilding inner exists only to accelerate that\n  // build. If an unmodelled descendant made the all-or-nothing build decline,\n  // preserve the old root-fallback shape instead of wrapping the same pristine\n  // Zod call in an issues array/copy/finalizer. This keeps unsupported object\n  // intersections neutral rather than making compilation slower than Zod.\n  if (ir.type === \"zodDelegate\" && rebuildsOutput(ir.inner) && buildFnName === null) {\n    ctx.preamble.length = 0;\n    ctx.usedHelpers.clear();\n    ctx.regexCache.clear();\n    ctx.effectFnCache?.clear();\n    ctx.valueCache?.clear();\n    const delegate = emitRfDelegate(ctx, ir.refIndex);\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: `function ${fnName}(input){return ${delegate}(input);}`,\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n    };\n  }\n\n  // `.is()` for a build-path schema is the fast expression — stripping reshapes\n  // the payload, never the verdict. A substituted `.default()` breaks that: the\n  // fast check demands a present value where the schema accepts its absence, so\n  // the predicate is partial and `.is()` falls back to safeParse().success\n  // (which runs the build pass, so it is no slower than the eager walk was).\n  const buildIsFnName = ctx.buildSubstitutesValue === true ? null : fastFnName;\n\n  const baseRefCount = options?.refCount ?? 0;\n\n  // Compact mode: a mutation-free schema with a TOTAL fast path needs no\n  // compiled slow walk — its only purpose is reproducing zod's issues on\n  // failure, and the original zod schema (retained in `output: \"compact\"`) does\n  // that exactly. Emit the fast check and, on failure, delegate to a fresh root\n  // RefEntry (the schema itself) via the pristine safeParse method capture, then\n  // wrap it in the lazy `__zcFinZ` failure. Drops 64–77% of generated bytes\n  // with zero hot-path cost (fc and `.is()` are unchanged) and zod-identical\n  // errors. Excluded: schemas with non-root recursion targets (mutual/nested\n  // recursion still hosts standalone slow validators) and any non-total fast\n  // path (mutation/default/catch/fallback) — those keep the compiled path.\n  if (\n    options?.compact === true &&\n    fastExpr !== null &&\n    fastExpr !== \"true\" &&\n    !hasMutation(ir) &&\n    !hasNonRootTargets\n  ) {\n    const delegate = emitRfMethod(ctx, baseRefCount);\n    ctx.usedHelpers.add(\"__zcFinZ\");\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinZ(${delegate},__rf[${baseRefCount}],input);`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: baseRefCount + 1,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName,\n      // Mutation-free total fast path: fc(input) ⟺ accepts(input), so `.is()`\n      // installs fc directly (compact never weakens the guard).\n      fastTotal: true,\n      rootDelegateRefIndex: baseRefCount,\n    };\n  }\n\n  // Compact + Build Path: same bargain for a schema with modelled rewrites. The\n  // build pass still has to run (it produces the payload, which zod's schema\n  // would only reproduce by parsing again), but the compiled issue walk is what\n  // compact drops, and delegating that to the retained zod schema costs a few\n  // bytes.\n  if (\n    options?.compact === true &&\n    buildFnName !== null &&\n    ctx.buildFailName !== undefined &&\n    !hasNonRootTargets\n  ) {\n    const delegate = emitRfMethod(ctx, baseRefCount);\n    ctx.usedHelpers.add(\"__zcFinZ\");\n    const built = `__bd_${ctx.counter++}`;\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `var ${built}=${buildFnName}(input);`,\n        `if(${built}!==${ctx.buildFailName}){return{success:true,data:${built}};}`,\n        `return __zcFinZ(${delegate},__rf[${baseRefCount}],input);`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: baseRefCount + 1,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n      isFnName: buildIsFnName,\n      rootDelegateRefIndex: baseRefCount,\n    };\n  }\n\n  // Host each non-root recursion target as a safeParse-shaped slow validator,\n  // mirroring the root's eager body: collect issues, return success+data or a\n  // deferred-error result. Always emitted (the slow path always exists); the\n  // recursion call sites read `.success` / `.error.issues` / `.data`. Hoisted\n  // function declarations, so their order relative to the root is irrelevant.\n  if (hasNonRootTargets) {\n    for (const t of ctx.recTargets.values()) {\n      if (t.isRoot) continue;\n      const body = generateSlow(t.inner as SchemaIR, createSlowGen(\"_d\", \"_d\", \"[]\", \"_e\", ctx));\n      ctx.usedHelpers.add(\"__zcFin\");\n      ctx.preamble.push(\n        `function ${t.slowName}(input){var _e=[];\\nvar _d=input;\\n${body}\\n` +\n          `if(_e.length===0){return{success:true,data:_d};}\\nreturn __zcFin(_e,_d);}`,\n      );\n    }\n  }\n\n  const sg = createSlowGen(\"_d\", \"_d\", \"[]\", \"_e\", ctx);\n  // When the root schema's own shape is shared (it recurs as a sub-schema of\n  // another export, or as a duplicate root), its slow walk delegates to the\n  // shared function instead of emitting a second full copy. The fast path is\n  // still generated inline above — only the cold walk is shared.\n  const rootRef = ctx.sharedSchemas?.refFor(ir);\n  const slowCode = rootRef !== undefined ? `_d=${rootRef.name}(_d,[],_e);` : generateSlow(ir, sg);\n\n  const buildCode = (): string => [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\");\n\n  const functionDefParts = [`function ${fnName}(input){`];\n\n  // Build Path: every mutation is modelled, so one pass can validate and\n  // assemble the output together and bail on the first failure, leaving the\n  // issue-producing walk deferred behind `.error` (see build-path).\n  // The fast check stays out of `safeParse` entirely — running it first would\n  // read every property twice — but it is still an EXACT acceptance predicate\n  // (stripping reshapes the output, never the verdict), so `.is()` installs it.\n  if (buildFnName !== null && ctx.buildFailName !== undefined) {\n    ctx.usedHelpers.add(\"__zcFinD\");\n    const built = `__bd_${ctx.counter++}`;\n    // A self-recursive walk calls this validator BY NAME (slowRecursiveRef),\n    // and that binding exists only inside the named function expression — so\n    // there the walk stays a per-call closure. Everything else hosts it in the\n    // preamble, keeping safeParse to three statements. Mirrors the same split\n    // in the mutation-free branch below.\n    const recursive = slowCode.includes(fnName);\n    let deferred: string;\n    if (recursive) {\n      deferred = `__zcFinD(function(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;},input)`;\n    } else {\n      const walkName = `__sw_${ctx.counter++}`;\n      ctx.preamble.push(\n        `function ${walkName}(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;}`,\n      );\n      deferred = `__zcFinD(${walkName},input)`;\n    }\n    return {\n      code: buildCode(),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `var ${built}=${buildFnName}(input);`,\n        `if(${built}!==${ctx.buildFailName}){return{success:true,data:${built}};}`,\n        `return ${deferred};`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      // No by-reference shortcut: `data` is the freshly built object, so\n      // parse() must go through safeParse rather than returning its input.\n      fastFnName: null,\n      // `fastTotal` qualifies `fastFnName`, which is null here; the predicate\n      // travels in `isFnName` instead.\n      fastTotal: false,\n      isFnName: buildIsFnName,\n    };\n  }\n\n  if (fastExpr === \"true\") {\n    // Schema always succeeds (any/unknown) — skip slow path entirely\n    functionDefParts.push(`return{success:true,data:input};`);\n    functionDefParts.push(`}`);\n    return {\n      code: buildCode(),\n      functionDef: functionDefParts.join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      // any/unknown always succeed; `.is()` derives `true` from the fn fallback.\n      fastTotal: false,\n    };\n  }\n\n  if (fastExpr !== null && !hasMutation(ir)) {\n    // Mutation-free schemas with a fast path: a fast-check failure can never\n    // become a slow-path success (both are generated from the same checks —\n    // unlike default/catch schemas, whose partial fast path requires value\n    // presence while the slow path SUCCEEDS by applying the fallback).\n    // The slow path's only output is therefore the issues array, observable\n    // solely through `.error` — defer the whole re-walk into the cached\n    // accessor (__zcFinD): a failed safeParse whose `.error` is never read\n    // costs the fast check alone.\n    //\n    // The walk is HOSTED as a named preamble function rather than a per-call\n    // closure, for two measured reasons: (1) a failed safeParse no longer\n    // allocates a closure environment + function object before the deferral\n    // even starts; (2) the safeParse body shrinks to two statements, putting\n    // it within V8's inlining budget — callers in hot loops get the\n    // success-path result object escape-analyzed away entirely, which the\n    // old shape (slow walk inlined into the body) made impossible.\n    ctx.usedHelpers.add(\"__zcFinD\");\n    if (slowCode.includes(fnName)) {\n      // Self-recursive slow paths call the safeParse function by NAME\n      // (slowRecursiveRef) — that binding exists only inside the named\n      // function expression under the documented evaluation contract\n      // (`new Function(code + \"return \" + functionDef)`), so the walk stays\n      // a per-call closure for recursive schemas. Recursion is the rare\n      // shape; everything else gets the hosted walk.\n      functionDefParts.push(\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinD(function(input){`,\n        `var _e=[];`,\n        `var _d=input;`,\n        slowCode,\n        `return _e;`,\n        `},input);`,\n        `}`,\n      );\n    } else {\n      const walkName = `__sw_${ctx.counter++}`;\n      ctx.preamble.push(\n        `function ${walkName}(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;}`,\n      );\n      functionDefParts.push(\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinD(${walkName},input);`,\n        `}`,\n      );\n    }\n    return {\n      code: buildCode(),\n      functionDef: functionDefParts.join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName,\n      // Total predicate: mutation-free fast path, fc(input) ⟺ accepts(input).\n      // generateIIFE installs fc directly as the zero-allocation `.is()`.\n      fastTotal: true,\n    };\n  }\n\n  if (fastExpr !== null && fastResultIsInput(ir)) {\n    // Partial fast path (default/catch/... present-value shortcut): the slow\n    // path must run eagerly — it can succeed where the fast check failed.\n    //\n    // Withheld when the schema rebuilds its output: there the fast check is a\n    // sound VERDICT but says nothing about the payload, and `data:input` would\n    // hand back the unstripped input. Such schemas reach here only when the\n    // build path declined them, so the eager walk produces the output instead.\n    functionDefParts.push(`if(${fastExpr}){return{success:true,data:input};}`);\n  }\n\n  // Success branch inlined at the call site instead of inside __zcFin: the\n  // eager path (mutation schemas — coerce/default/trim/transform) returns\n  // here on EVERY parse, and the inline literal keeps the hot exit free of a\n  // cross-function call; __zcFin is reached only on failure.\n  functionDefParts.push(\n    `var _e=[];`,\n    `var _d=input;`,\n    slowCode,\n    `if(_e.length===0){return{success:true,data:_d};}`,\n    `return __zcFin(_e,_d);`,\n    `}`,\n  );\n\n  const functionDef = functionDefParts.join(\"\\n\");\n\n  return {\n    code: buildCode(),\n    functionDef,\n    refCount: options?.refCount ?? 0,\n    usedHelpers: ctx.usedHelpers,\n    // `fc` carries a stronger contract than \"accepts\": `__zcMkv` returns the\n    // INPUT from `parse()`/`parseAsync()`/`~standard` whenever it holds, so it\n    // may only be published when a passing check implies `data === input`. A\n    // rebuilding schema breaks that even though its safeParse is correct, and so\n    // does a union whose options can rewrite — see `fastResultIsInput` for both.\n    // Same guard as the `data: input` shortcut above, which is the other reader\n    // of the same contract.\n    fastFnName: fastResultIsInput(ir) ? fastFnName : null,\n    // Partial fast path (default/catch) or none (including coercion): a false fc\n    // result does not imply rejection, so `.is()` derives from\n    // safeParse(input).success.\n    fastTotal: false,\n  };\n}\n\n/**\n * Find every non-root recursion target (a `recursionTarget` node, refId ≥ 1)\n * reachable from `root`, mapping refId → the inner IR to host as a standalone\n * validator. The root target (refId 0) is the schema's own function and is\n * never wrapped, so it never appears here. The same target may be wrapped at\n * several sites (a recursive schema reached from sibling positions); the first\n * inner wins — they are structurally identical extractions of one schema.\n */\nfunction collectRecursionTargets(root: SchemaIR): Map<number, SchemaIR> {\n  const out = new Map<number, SchemaIR>();\n  const seen = new Set<SchemaIR>();\n  const walk = (ir: SchemaIR): void => {\n    if (seen.has(ir)) return;\n    seen.add(ir);\n    if (ir.type === \"recursionTarget\" && !out.has(ir.refId)) {\n      out.set(ir.refId, ir.inner);\n    }\n    for (const child of childIRs(ir)) walk(child);\n  };\n  walk(root);\n  return out;\n}\n\n/** Direct child SchemaIR nodes, covering every node type (including the new wrapper). */\nfunction childIRs(ir: SchemaIR): readonly SchemaIR[] {\n  switch (ir.type) {\n    case \"object\":\n      return Object.values(ir.properties);\n    case \"array\":\n      return [ir.element];\n    case \"tuple\":\n      return ir.rest === null ? ir.items : [...ir.items, ir.rest];\n    case \"record\":\n    case \"map\":\n      return [ir.keyType, ir.valueType];\n    case \"set\":\n      return [ir.valueType];\n    case \"union\":\n    case \"discriminatedUnion\":\n      return ir.options;\n    case \"intersection\":\n      return [ir.left, ir.right];\n    case \"optional\":\n    case \"nullable\":\n    case \"readonly\":\n    case \"default\":\n    case \"catch\":\n    case \"effect\":\n    case \"recursionTarget\":\n    case \"zodDelegate\":\n      return [ir.inner];\n    case \"pipe\":\n      return [ir.in, ir.out];\n    default:\n      return [];\n  }\n}\n"],"mappings":"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"}

package/dist/core/iife.d.ts

@@ -101,10 +101,11 @@ declare const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(
  * path is produced by the retained Zod schema itself (`zod` is the source of
  * truth, so the issues are byte-identical — no second validation engine).
  *
- * `_z` is the schema's PRISTINE bound safeParse (`__rf[N].safeParse.bind(...)`,
- * captured pre-`__zcMkv` by emitRfDelegate — see context.ts — so it is zod's
- * own implementation, never the compiled delegate, avoiding infinite
- * recursion). The zod parse is deferred until `.error` is read and cached, so
+ * `_z` is the schema's PRISTINE safeParse method and `_r` is its receiver. Both
+ * are captured pre-`__zcMkv` by emitRfMethod — see context.ts — so the method is
+ * zod's own implementation, never the compiled delegate, avoiding infinite
+ * recursion without allocating a bound function. The zod parse is deferred
+ * until `.error` is read and cached, so
  * the common `safeParse(x).success`/`.is(x)` checks on invalid input cost only
  * the fast check (zod never runs) — the same deferral boundary `__zcFinD`
  * establishes for the compiled slow walk. Sound because compact mode is gated
@@ -116,8 +117,8 @@ declare const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(
  * the unaltered schema would have produced.
  */
 declare const FAILZ_CLASS_DECL: string;
-/** Compact-mode finalizer: wrap a pristine bound safeParse + input into a lazy delegated failure. */
-declare const FINZ_DECL = "function __zcFinZ(z,i){return new __ZcFailZ(z,i);}";
+/** Compact-mode finalizer: retain a pristine safeParse, its receiver, and input lazily. */
+declare const FINZ_DECL = "function __zcFinZ(z,r,i){return new __ZcFailZ(z,r,i);}";
 /**
  * Validator factory. Inline mode (CLI emitter) declares it once per compiled
  * file; lean mode (all unplugin bundlers) exports it once per bundle from the

package/dist/core/iife.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iife.d.ts","names":[],"sources":["../../src/core/iife.ts"],"mappings":";;;;;;;;cAaa;;;;;;;;;;;;;;;;;;;;cAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CA;;;cAUA;;;;;;;;;;;;;;;;;;;;;;;cAyBA;;;;;;;;;;;;;;;;;;;;;;;cAwBA;;cAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0EA;;;;;;;;;iBAsBG,aACd,oBACA,QAAQ,oBACR;EAAY"}
+{"version":3,"file":"iife.d.ts","names":[],"sources":["../../src/core/iife.ts"],"mappings":";;;;;;;;cAaa;;;;;;;;;;;;;;;;;;;;cAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CA;;;cAUA;;;;;;;;;;;;;;;;;;;;;;;cAyBA;;;;;;;;;;;;;;;;;;;;;;;;cAyBA;;cAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0EA;;;;;;;;;iBAsBG,aACd,oBACA,QAAQ,oBACR;EAAY"}

package/dist/core/iife.js

@@ -100,10 +100,11 @@ const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(null,f,i
 * path is produced by the retained Zod schema itself (`zod` is the source of
 * truth, so the issues are byte-identical — no second validation engine).
 *
-* `_z` is the schema's PRISTINE bound safeParse (`__rf[N].safeParse.bind(...)`,
-* captured pre-`__zcMkv` by emitRfDelegate — see context.ts — so it is zod's
-* own implementation, never the compiled delegate, avoiding infinite
-* recursion). The zod parse is deferred until `.error` is read and cached, so
+* `_z` is the schema's PRISTINE safeParse method and `_r` is its receiver. Both
+* are captured pre-`__zcMkv` by emitRfMethod — see context.ts — so the method is
+* zod's own implementation, never the compiled delegate, avoiding infinite
+* recursion without allocating a bound function. The zod parse is deferred
+* until `.error` is read and cached, so
 * the common `safeParse(x).success`/`.is(x)` checks on invalid input cost only
 * the fast check (zod never runs) — the same deferral boundary `__zcFinD`
 * establishes for the compiled slow walk. Sound because compact mode is gated
@@ -114,9 +115,9 @@ const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(null,f,i
 * re-wrap — zod already finalized it), so a delegated failure is exactly what
 * the unaltered schema would have produced.
 */
-const FAILZ_CLASS_DECL = "function __ZcFailZ(z,i){this.success=false;this._z=z;this._i=i;this._c=undefined;}Object.defineProperty(__ZcFailZ.prototype,\"error\",{configurable:true,get:function(){return this._c||(this._c=this._z(this._i).error);}});";
-/** Compact-mode finalizer: wrap a pristine bound safeParse + input into a lazy delegated failure. */
-const FINZ_DECL = "function __zcFinZ(z,i){return new __ZcFailZ(z,i);}";
+const FAILZ_CLASS_DECL = "function __ZcFailZ(z,r,i){this.success=false;this._z=z;this._r=r;this._i=i;this._c=undefined;}Object.defineProperty(__ZcFailZ.prototype,\"error\",{configurable:true,get:function(){return this._c||(this._c=this._z.call(this._r,this._i).error);}});";
+/** Compact-mode finalizer: retain a pristine safeParse, its receiver, and input lazily. */
+const FINZ_DECL = "function __zcFinZ(z,r,i){return new __ZcFailZ(z,r,i);}";
 /**
 * Validator factory. Inline mode (CLI emitter) declares it once per compiled
 * file; lean mode (all unplugin bundlers) exports it once per bundle from the
@@ -206,12 +207,14 @@ function extractFunctionName(functionDef) {
 function generateIIFE(schemaExpr, schema, options) {
 	const { codegenResult, refEntries } = schema;
 	const fnName = extractFunctionName(codegenResult.functionDef);
-	const schemaArg = options?.zodCompat !== false ? schemaExpr : "null";
+	const zodCompat = options?.zodCompat !== false;
+	const retainedSchema = refEntries.length > 0 ? "__zs" : schemaExpr;
+	const schemaArg = zodCompat ? retainedSchema : "null";
 	const fcArg = codegenResult.fastFnName ?? "null";
 	const isArg = codegenResult.isFnName ?? (codegenResult.fastTotal ? fcArg : "null");
 	return [
 		"/* @__PURE__ */ (() => {",
-		...refEntries.length > 0 ? [`var __rf=[${refEntries.map((fb) => `${schemaExpr}${fb.accessPath}`).join(",")}];`] : [],
+		...refEntries.length > 0 ? [`var __zs=${schemaExpr};`, `var __rf=[${refEntries.map((fb) => `${retainedSchema}${fb.accessPath}`).join(",")}];`] : [],
 		...codegenResult.code.split("\n").filter((l) => l.trim() !== "" && l.trim() !== "/* zod-compiler */"),
 		codegenResult.functionDef,
 		`return __zcMkv(${fnName},${schemaArg},${fcArg},${isArg});`,

package/dist/core/iife.js.map

@@ -1 +1 @@
-{"version":3,"file":"iife.js","names":[],"sources":["../../src/core/iife.ts"],"sourcesContent":["/**\n * Shared CompiledSchema<T> IIFE generation.\n * Used by both CLI emitter and unplugin transform.\n */\n\nimport type { CompiledSchemaInfo } from \"./pipeline.js\";\n\n/**\n * Import statement required by generateIIFE output (references\n * __zodCompilerConfig). `core` is bound for $ZodAsyncError: superRefine and\n * custom callbacks may only reveal that they are async through the promise\n * they return, at which point zod's own synchronous parse raises.\n */\nexport const ZOD_CONFIG_IMPORT =\n  'import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from \"zod\";';\n\n/**\n * File-level `__zcMsg` declaration (must appear once after ZOD_CONFIG_IMPORT):\n * the message an issue gets when nothing was baked into it at build time.\n *\n * Resolves zod's tail of `finalizeIssue` — `config.customError` then\n * `config.localeError` then \"Invalid input\" — and does it PER CALL, because the\n * config is mutable: `z.config({ localeError })` in an entry point runs after\n * the schema modules it imports, so a value snapshotted at module init misses\n * it. Reading a captured `localeError` alone also dropped `customError`\n * outright, silently ignoring the global map most i18n setups install.\n *\n * The head of zod's chain — the schema's own `error` option — is baked into the\n * issue at build time and short-circuits this. The one link that cannot be\n * reproduced is a per-CALL `ctx.error`, which would have to travel through\n * `safeParse`; that entry point sits at V8's inlining budget, where even an\n * unused extra parameter measured ~12% on every parse.\n *\n * Only ever called while building an error, never on a successful parse.\n */\nexport const ZOD_MSG_DECLARATION =\n  'function __zcUw(m){return typeof m===\"string\"?m:(m===undefined||m===null?undefined:m.message);}' +\n  \"var __zcMsg=function(iss){var c=__zodCompilerConfig(),m;\" +\n  \"if(c.customError){m=__zcUw(c.customError(iss));if(m!==undefined&&m!==null)return m;}\" +\n  \"if(c.localeError){m=__zcUw(c.localeError(iss));if(m!==undefined&&m!==null)return m;}\" +\n  'return \"Invalid input\";};';\n\n/**\n * Shared failure-result for __zcFin / __zcFinD. Inline mode (CLI emitter)\n * declares it once per compiled file; lean mode (all unplugin bundlers) declares\n * it once per bundle in the plugin-materialized runtime module (module-local —\n * generated code only ever references __zcFin/__zcFinD, never __ZcFail).\n *\n * Why a prototype getter and not `{success:false, get error(){...}}`: an object\n * literal with an inline accessor forces V8 down its slow accessor-defining\n * allocation path — ~110ns per failure, measured — which dominates the entire\n * invalid-input cost whenever callers never read `.error`. Hosting `error` on\n * the prototype turns each failure into a plain field-only instantiation (~2ns,\n * ~13x), with the lazy-cache semantics intact. (Trade-off: `error` is a\n * prototype accessor, so it no longer shows up in `Object.keys(result)` / spread\n * / JSON.stringify of the result wrapper — `.success`/`.error`/`.data` access,\n * destructuring, and `in` are unaffected.)\n *\n * One class serves both finalizers, so the instances share one hidden class:\n * __zcFin passes pre-collected issues in `_e` (with `_f===null`); __zcFinD\n * passes the hosted slow-walk in `_f` plus the input in `_i`, and the getter\n * runs the walk on first `.error` read. The whole finalization — locale fill\n * (__zcMsg applied ONLY when an issue carries no message, never overwriting a\n * baked-in custom/fallback message), input strip, and ZodError construction\n * (zod v4 JSON.stringifies every issue into `message` and captures a stack\n * trace) — stays deferred inside the cached accessor exactly as before, since\n * the issues array is observable solely through `.error`.\n *\n * `input` is `delete`d, not assigned `undefined`. Key PRESENCE is observable —\n * `\"input\" in issue`, `Object.keys(issue)`, object spread, `toStrictEqual`\n * against a zod issue — and zod's `util.finalizeIssue` does `delete full.input`\n * whenever `reportInput` is off, so assignment left every compiled issue one\n * enumerable key wider than zod's. The delete's dictionary-mode transition is\n * affordable precisely BECAUSE of the deferral above: it runs only after a\n * caller asks for `.error` on a failed parse, and is memoised in `_c`. Neither\n * a successful parse nor a `.success`/`.is()` check on a rejected one reaches\n * it — measured, the two are unchanged, while the `.error` read itself goes\n * ~3.95us -> ~4.19us per failure, i.e. ~6% of a path whose cost is already\n * dominated by the ZodError construction on the next line (stack capture plus a\n * JSON.stringify of every issue).\n */\nexport const FAIL_CLASS_DECL =\n  \"function __ZcFail(e,f,i){this.success=false;this._e=e;this._f=f;this._i=i;this._c=undefined;}\" +\n  'Object.defineProperty(__ZcFail.prototype,\"error\",{configurable:true,get:function(){' +\n  \"if(this._c)return this._c;\" +\n  \"var e=this._f!==null?this._f(this._i):this._e;\" +\n  'for(var i=0;i<e.length;i++){if(e[i].message===undefined&&typeof __zcMsg===\"function\")e[i].message=__zcMsg(e[i]);delete e[i].input;delete e[i].continue;}' +\n  \"return this._c=new __zcZodError(e);}});\";\n\n/** Eager finalizer (mutation / partial-fast-path schemas): issues already\n * collected in `e`; success short-circuits to a plain result literal. */\nexport const FIN_DECL =\n  \"function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}\";\n\n/**\n * Deferred-collection finalizer for Fast-Path-eligible schemas. When the\n * fast check fails, the ENTIRE slow path (the issue-collecting re-walk) is\n * pushed into the cached `.error` accessor instead of running eagerly:\n * fast-eligible schemas never mutate, so the walk's only output is the\n * issues array, which is observable solely through `.error` — one step\n * further along the same lazy boundary `__zcFin` already established (locale\n * fill, input strip, ZodError construction). A failed safeParse whose\n * `.error` is never read costs the fast check alone.\n *\n * Takes the schema's HOSTED slow-walk function plus the input — NOT a\n * per-call closure: `__zcFinD(__sw_N, input)` allocates only the result\n * object, where `__zcFinD(function(){...})` paid a closure environment and\n * function object per failure. Hosting the walk also shrinks safeParse to\n * two statements, within V8's inlining budget (the success-path result\n * literal becomes escape-analyzable at monomorphic call sites).\n *\n * The walk re-reads `input` at `.error`-read time; a caller that mutates\n * the input between safeParse and reading `.error` sees issues for the\n * mutated value (zod materializes at parse time). Same caveat class as the\n * documented __zcFin deferral.\n */\nexport const FIN_DEFERRED_DECL = \"function __zcFinD(f,inp){return new __ZcFail(null,f,inp);}\";\n\n/**\n * Compact-mode failure class — a lazy failure that delegates error reporting to\n * the ORIGINAL Zod schema's `safeParse`. Used by `output: \"compact\"`, where the\n * compiled slow walk is dropped entirely: a mutation-free schema's fast check\n * is the only generated validation, and on a fast-check failure the cold error\n * path is produced by the retained Zod schema itself (`zod` is the source of\n * truth, so the issues are byte-identical — no second validation engine).\n *\n * `_z` is the schema's PRISTINE bound safeParse (`__rf[N].safeParse.bind(...)`,\n * captured pre-`__zcMkv` by emitRfDelegate — see context.ts — so it is zod's\n * own implementation, never the compiled delegate, avoiding infinite\n * recursion). The zod parse is deferred until `.error` is read and cached, so\n * the common `safeParse(x).success`/`.is(x)` checks on invalid input cost only\n * the fast check (zod never runs) — the same deferral boundary `__zcFinD`\n * establishes for the compiled slow walk. Sound because compact mode is gated\n * on a TOTAL fast path: `fc(input) === false` ⟹ zod rejects, so `success:false`\n * holds without consulting zod.\n *\n * The getter returns zod's OWN ZodError verbatim (no locale fill / input strip /\n * re-wrap — zod already finalized it), so a delegated failure is exactly what\n * the unaltered schema would have produced.\n */\nexport const FAILZ_CLASS_DECL =\n  \"function __ZcFailZ(z,i){this.success=false;this._z=z;this._i=i;this._c=undefined;}\" +\n  'Object.defineProperty(__ZcFailZ.prototype,\"error\",{configurable:true,get:function(){' +\n  \"return this._c||(this._c=this._z(this._i).error);}});\";\n\n/** Compact-mode finalizer: wrap a pristine bound safeParse + input into a lazy delegated failure. */\nexport const FINZ_DECL = \"function __zcFinZ(z,i){return new __ZcFailZ(z,i);}\";\n\n/**\n * Validator factory. Inline mode (CLI emitter) declares it once per compiled\n * file; lean mode (all unplugin bundlers) exports it once per bundle from the\n * plugin-materialized runtime module — generated code never imports it from\n * the zod-compiler package itself, so zod-compiler stays a devDependency and\n * the helper set is always version-locked to the codegen that calls it.\n * Wraps a safeParse function into the CompiledSchema interface.\n *\n * IDENTITY-PRESERVING: with zodCompat (schema != null) the compiled\n * parse/safeParse/parseAsync/safeParseAsync are installed as OWN properties\n * on the original schema object, which is returned as-is. zod v4 keys\n * several APIs on object identity — toJSONSchema's ctx.seen registers the\n * object it is handed while each processor closure captures the original\n * inst (a wrapper crashes `optionalProcessor` with \"Cannot set properties\n * of undefined (setting 'ref')\" the moment a compiled schema is composed\n * into another schema), and globalRegistry/.meta() is a WeakMap keyed by\n * the schema instance (a wrapper silently loses OpenAPI titles/ids). An\n * Object.create wrapper breaks both; mutating the original breaks neither\n * (zod's internal parsing flows through _zod.run, never the public\n * methods, and derived schemas — .optional(), .extend() — are fresh\n * instances that fall back to plain zod). schema=null (zodCompat: false)\n * still produces a plain method-bag object.\n *\n * fc is the schema's hosted fast-check boolean function (null when no Fast\n * Path exists). parse()/parseAsync() try it first and return the input\n * directly on success: fc is small enough for V8 to inline, so the hot parse\n * path runs with zero allocations — calling fn would allocate an intermediate\n * SafeParseResult that escape analysis cannot remove (fn never inlines).\n * Fast-path-eligible schemas never mutate, so fc(input) ⟹ data === input.\n *\n * is is the TOTAL fast-check predicate (fc when the fast path is total, else\n * null). Installed as `.is()` — a zero-allocation boolean type guard. When\n * null (partial fast path or none) `.is()` derives from fn(input).success: a\n * partial fc can pass-through valid input but its `false` does not imply\n * rejection (a default/catch may still succeed), so it would be unsound as a\n * standalone guard.\n *\n * parseAsync/safeParseAsync wrap the SYNC validator, which is right for every\n * schema the compiler can reproduce — none of them are async. It is wrong for\n * the ones it cannot: an `async` refinement or a `z.promise()` extracts to a\n * Zod delegate, and delegating means calling Zod's SYNCHRONOUS safeParse, which\n * raises `$ZodAsyncError` by design. Wrapping that gave the compiled schema an\n * async pair that rejected with `$ZodAsyncError` for EVERY input — including\n * valid ones — where Zod resolves normally, so `await UserSchema.parseAsync(x)`\n * stopped working the moment any part of the schema went async.\n *\n * So both are guarded: a synchronous throw hands off to the schema's ORIGINAL\n * async method, captured before these are installed — the same escape hatch\n * `~standard` already uses for its throw path, and for the same reason (the\n * compiled validator has no async mode to offer, and Zod's is exact). It also\n * fixes the smaller wart that a throwing `fn` made `parseAsync` throw\n * SYNCHRONOUSLY rather than return a rejected promise. With `zodCompat: false`\n * there is no schema to delegate to and the throw propagates as before.\n *\n * `~standard` is REPLACED, not merely preserved. Zod builds it lazily as\n * `validate: (v) => safeParse(inst, v)` — the core FUNCTION, which goes straight\n * to `inst._zod.run`. It never reads the schema's own `safeParse` property, so\n * installing the compiled one leaves this route entirely uncompiled: measured\n * 271.7 ns against the compiled 26.6 ns on the same schema, i.e. Standard Schema\n * consumers (tRPC, Hono, TanStack) were getting plain Zod.\n *\n * Zod's own validate is captured first and kept as the throw path: it catches a\n * synchronous throw and retries through `safeParseAsync`, which is how an async\n * refinement resolves and how a throwing check surfaces as a rejected promise\n * rather than a synchronous throw. The compiled validator cannot reproduce that\n * (async schemas delegate to Zod anyway), so deferring to the original is both\n * simpler and exact.\n *\n * Installed with defineProperty rather than assignment: Zod's lazy setter\n * redefines the slot as non-writable, so a second `__zcMkv` on the same schema\n * object — two exports aliasing one schema — would throw under ESM strict mode.\n */\nexport const MK_VALIDATOR_DECL =\n  \"function __zcMkv(fn,schema,fc,is){var w=schema||{};var zpa=w.parseAsync,zspa=w.safeParseAsync;w.parse=fc?function(input){if(fc(input))return input;var r=fn(input);if(r.success)return r.data;throw r.error;}:function(input){var r=fn(input);if(r.success)return r.data;throw r.error;};w.safeParse=fn;w.safeParseAsync=function(input){try{return Promise.resolve(fn(input));}catch(e){if(zspa)return zspa(input);throw e;}};w.parseAsync=fc?function(input){try{if(fc(input))return Promise.resolve(input);var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}catch(e){if(zpa)return zpa(input);throw e;}}:function(input){try{var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}catch(e){if(zpa)return zpa(input);throw e;}};w.is=is||function(input){return fn(input).success;};\" +\n  'var s=w[\"~standard\"],zv=s&&s.validate;' +\n  'Object.defineProperty(w,\"~standard\",{configurable:true,value:{version:1,vendor:(s&&s.vendor)||\"zod\",validate:function(input){var r;try{if(fc&&fc(input))return{value:input};r=fn(input);}catch(e){if(zv)return zv(input);throw e;}return r.success?{value:r.data}:{issues:r.error.issues};}}});' +\n  \"return w;}\";\n\nfunction extractFunctionName(functionDef: string): string {\n  const match = /^function\\s+(\\w+)\\s*\\(/.exec(functionDef);\n  if (!match?.[1]) {\n    throw new Error(\"Cannot extract function name from generated code\");\n  }\n  return match[1];\n}\n\n/**\n * Generate a `/* @__PURE__ * /` IIFE wrapping a compiled validator.\n *\n * @param schemaExpr - Expression resolving to the original Zod schema\n *   (e.g. `\"UserSchema\"` in unplugin, `\"(__src_X as any).schema\"` in CLI)\n * @param schema\n * @param options\n */\nexport function generateIIFE(\n  schemaExpr: string,\n  schema: CompiledSchemaInfo,\n  options?: { zodCompat?: boolean | undefined },\n): string {\n  const { codegenResult, refEntries } = schema;\n  const fnName = extractFunctionName(codegenResult.functionDef);\n  const zodCompat = options?.zodCompat !== false;\n  const schemaArg = zodCompat ? schemaExpr : \"null\";\n  const fcArg = codegenResult.fastFnName ?? \"null\";\n  // `.is()` gets the fast-check directly only when it is a total predicate;\n  // partial/none falls back to safeParse().success inside __zcMkv. A rebuilding\n  // schema has no by-reference `fc` but still names its predicate separately.\n  const isArg = codegenResult.isFnName ?? (codegenResult.fastTotal ? fcArg : \"null\");\n\n  return [\n    \"/* @__PURE__ */ (() => {\",\n    ...(refEntries.length > 0\n      ? [`var __rf=[${refEntries.map((fb) => `${schemaExpr}${fb.accessPath}`).join(\",\")}];`]\n      : []),\n    ...codegenResult.code\n      .split(\"\\n\")\n      .filter((l) => l.trim() !== \"\" && l.trim() !== \"/* zod-compiler */\"),\n    codegenResult.functionDef,\n    `return __zcMkv(${fnName},${schemaArg},${fcArg},${isArg});`,\n    \"})()\",\n  ].join(\"\\n\");\n}\n"],"mappings":";;;;;;;AAaA,MAAa,oBACX;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,sBACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CF,MAAa,kBACX;;;AASF,MAAa,WACX;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;AAwBjC,MAAa,mBACX;;AAKF,MAAa,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EzB,MAAa,oBACX;AAKF,SAAS,oBAAoB,aAA6B;CACxD,MAAM,QAAQ,yBAAyB,KAAK,WAAW;CACvD,IAAI,CAAC,QAAQ,IACX,MAAM,IAAI,MAAM,kDAAkD;CAEpE,OAAO,MAAM;AACf;;;;;;;;;AAUA,SAAgB,aACd,YACA,QACA,SACQ;CACR,MAAM,EAAE,eAAe,eAAe;CACtC,MAAM,SAAS,oBAAoB,cAAc,WAAW;CAE5D,MAAM,YADY,SAAS,cAAc,QACX,aAAa;CAC3C,MAAM,QAAQ,cAAc,cAAc;CAI1C,MAAM,QAAQ,cAAc,aAAa,cAAc,YAAY,QAAQ;CAE3E,OAAO;EACL;EACA,GAAI,WAAW,SAAS,IACpB,CAAC,aAAa,WAAW,KAAK,OAAO,GAAG,aAAa,GAAG,YAAY,CAAC,CAAC,KAAK,GAAG,EAAE,GAAG,IACnF,CAAC;EACL,GAAG,cAAc,KACd,MAAM,IAAI,CAAC,CACX,QAAQ,MAAM,EAAE,KAAK,MAAM,MAAM,EAAE,KAAK,MAAM,oBAAoB;EACrE,cAAc;EACd,kBAAkB,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM;EACxD;CACF,CAAC,CAAC,KAAK,IAAI;AACb"}
+{"version":3,"file":"iife.js","names":[],"sources":["../../src/core/iife.ts"],"sourcesContent":["/**\n * Shared CompiledSchema<T> IIFE generation.\n * Used by both CLI emitter and unplugin transform.\n */\n\nimport type { CompiledSchemaInfo } from \"./pipeline.js\";\n\n/**\n * Import statement required by generateIIFE output (references\n * __zodCompilerConfig). `core` is bound for $ZodAsyncError: superRefine and\n * custom callbacks may only reveal that they are async through the promise\n * they return, at which point zod's own synchronous parse raises.\n */\nexport const ZOD_CONFIG_IMPORT =\n  'import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from \"zod\";';\n\n/**\n * File-level `__zcMsg` declaration (must appear once after ZOD_CONFIG_IMPORT):\n * the message an issue gets when nothing was baked into it at build time.\n *\n * Resolves zod's tail of `finalizeIssue` — `config.customError` then\n * `config.localeError` then \"Invalid input\" — and does it PER CALL, because the\n * config is mutable: `z.config({ localeError })` in an entry point runs after\n * the schema modules it imports, so a value snapshotted at module init misses\n * it. Reading a captured `localeError` alone also dropped `customError`\n * outright, silently ignoring the global map most i18n setups install.\n *\n * The head of zod's chain — the schema's own `error` option — is baked into the\n * issue at build time and short-circuits this. The one link that cannot be\n * reproduced is a per-CALL `ctx.error`, which would have to travel through\n * `safeParse`; that entry point sits at V8's inlining budget, where even an\n * unused extra parameter measured ~12% on every parse.\n *\n * Only ever called while building an error, never on a successful parse.\n */\nexport const ZOD_MSG_DECLARATION =\n  'function __zcUw(m){return typeof m===\"string\"?m:(m===undefined||m===null?undefined:m.message);}' +\n  \"var __zcMsg=function(iss){var c=__zodCompilerConfig(),m;\" +\n  \"if(c.customError){m=__zcUw(c.customError(iss));if(m!==undefined&&m!==null)return m;}\" +\n  \"if(c.localeError){m=__zcUw(c.localeError(iss));if(m!==undefined&&m!==null)return m;}\" +\n  'return \"Invalid input\";};';\n\n/**\n * Shared failure-result for __zcFin / __zcFinD. Inline mode (CLI emitter)\n * declares it once per compiled file; lean mode (all unplugin bundlers) declares\n * it once per bundle in the plugin-materialized runtime module (module-local —\n * generated code only ever references __zcFin/__zcFinD, never __ZcFail).\n *\n * Why a prototype getter and not `{success:false, get error(){...}}`: an object\n * literal with an inline accessor forces V8 down its slow accessor-defining\n * allocation path — ~110ns per failure, measured — which dominates the entire\n * invalid-input cost whenever callers never read `.error`. Hosting `error` on\n * the prototype turns each failure into a plain field-only instantiation (~2ns,\n * ~13x), with the lazy-cache semantics intact. (Trade-off: `error` is a\n * prototype accessor, so it no longer shows up in `Object.keys(result)` / spread\n * / JSON.stringify of the result wrapper — `.success`/`.error`/`.data` access,\n * destructuring, and `in` are unaffected.)\n *\n * One class serves both finalizers, so the instances share one hidden class:\n * __zcFin passes pre-collected issues in `_e` (with `_f===null`); __zcFinD\n * passes the hosted slow-walk in `_f` plus the input in `_i`, and the getter\n * runs the walk on first `.error` read. The whole finalization — locale fill\n * (__zcMsg applied ONLY when an issue carries no message, never overwriting a\n * baked-in custom/fallback message), input strip, and ZodError construction\n * (zod v4 JSON.stringifies every issue into `message` and captures a stack\n * trace) — stays deferred inside the cached accessor exactly as before, since\n * the issues array is observable solely through `.error`.\n *\n * `input` is `delete`d, not assigned `undefined`. Key PRESENCE is observable —\n * `\"input\" in issue`, `Object.keys(issue)`, object spread, `toStrictEqual`\n * against a zod issue — and zod's `util.finalizeIssue` does `delete full.input`\n * whenever `reportInput` is off, so assignment left every compiled issue one\n * enumerable key wider than zod's. The delete's dictionary-mode transition is\n * affordable precisely BECAUSE of the deferral above: it runs only after a\n * caller asks for `.error` on a failed parse, and is memoised in `_c`. Neither\n * a successful parse nor a `.success`/`.is()` check on a rejected one reaches\n * it — measured, the two are unchanged, while the `.error` read itself goes\n * ~3.95us -> ~4.19us per failure, i.e. ~6% of a path whose cost is already\n * dominated by the ZodError construction on the next line (stack capture plus a\n * JSON.stringify of every issue).\n */\nexport const FAIL_CLASS_DECL =\n  \"function __ZcFail(e,f,i){this.success=false;this._e=e;this._f=f;this._i=i;this._c=undefined;}\" +\n  'Object.defineProperty(__ZcFail.prototype,\"error\",{configurable:true,get:function(){' +\n  \"if(this._c)return this._c;\" +\n  \"var e=this._f!==null?this._f(this._i):this._e;\" +\n  'for(var i=0;i<e.length;i++){if(e[i].message===undefined&&typeof __zcMsg===\"function\")e[i].message=__zcMsg(e[i]);delete e[i].input;delete e[i].continue;}' +\n  \"return this._c=new __zcZodError(e);}});\";\n\n/** Eager finalizer (mutation / partial-fast-path schemas): issues already\n * collected in `e`; success short-circuits to a plain result literal. */\nexport const FIN_DECL =\n  \"function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}\";\n\n/**\n * Deferred-collection finalizer for Fast-Path-eligible schemas. When the\n * fast check fails, the ENTIRE slow path (the issue-collecting re-walk) is\n * pushed into the cached `.error` accessor instead of running eagerly:\n * fast-eligible schemas never mutate, so the walk's only output is the\n * issues array, which is observable solely through `.error` — one step\n * further along the same lazy boundary `__zcFin` already established (locale\n * fill, input strip, ZodError construction). A failed safeParse whose\n * `.error` is never read costs the fast check alone.\n *\n * Takes the schema's HOSTED slow-walk function plus the input — NOT a\n * per-call closure: `__zcFinD(__sw_N, input)` allocates only the result\n * object, where `__zcFinD(function(){...})` paid a closure environment and\n * function object per failure. Hosting the walk also shrinks safeParse to\n * two statements, within V8's inlining budget (the success-path result\n * literal becomes escape-analyzable at monomorphic call sites).\n *\n * The walk re-reads `input` at `.error`-read time; a caller that mutates\n * the input between safeParse and reading `.error` sees issues for the\n * mutated value (zod materializes at parse time). Same caveat class as the\n * documented __zcFin deferral.\n */\nexport const FIN_DEFERRED_DECL = \"function __zcFinD(f,inp){return new __ZcFail(null,f,inp);}\";\n\n/**\n * Compact-mode failure class — a lazy failure that delegates error reporting to\n * the ORIGINAL Zod schema's `safeParse`. Used by `output: \"compact\"`, where the\n * compiled slow walk is dropped entirely: a mutation-free schema's fast check\n * is the only generated validation, and on a fast-check failure the cold error\n * path is produced by the retained Zod schema itself (`zod` is the source of\n * truth, so the issues are byte-identical — no second validation engine).\n *\n * `_z` is the schema's PRISTINE safeParse method and `_r` is its receiver. Both\n * are captured pre-`__zcMkv` by emitRfMethod — see context.ts — so the method is\n * zod's own implementation, never the compiled delegate, avoiding infinite\n * recursion without allocating a bound function. The zod parse is deferred\n * until `.error` is read and cached, so\n * the common `safeParse(x).success`/`.is(x)` checks on invalid input cost only\n * the fast check (zod never runs) — the same deferral boundary `__zcFinD`\n * establishes for the compiled slow walk. Sound because compact mode is gated\n * on a TOTAL fast path: `fc(input) === false` ⟹ zod rejects, so `success:false`\n * holds without consulting zod.\n *\n * The getter returns zod's OWN ZodError verbatim (no locale fill / input strip /\n * re-wrap — zod already finalized it), so a delegated failure is exactly what\n * the unaltered schema would have produced.\n */\nexport const FAILZ_CLASS_DECL =\n  \"function __ZcFailZ(z,r,i){this.success=false;this._z=z;this._r=r;this._i=i;this._c=undefined;}\" +\n  'Object.defineProperty(__ZcFailZ.prototype,\"error\",{configurable:true,get:function(){' +\n  \"return this._c||(this._c=this._z.call(this._r,this._i).error);}});\";\n\n/** Compact-mode finalizer: retain a pristine safeParse, its receiver, and input lazily. */\nexport const FINZ_DECL = \"function __zcFinZ(z,r,i){return new __ZcFailZ(z,r,i);}\";\n\n/**\n * Validator factory. Inline mode (CLI emitter) declares it once per compiled\n * file; lean mode (all unplugin bundlers) exports it once per bundle from the\n * plugin-materialized runtime module — generated code never imports it from\n * the zod-compiler package itself, so zod-compiler stays a devDependency and\n * the helper set is always version-locked to the codegen that calls it.\n * Wraps a safeParse function into the CompiledSchema interface.\n *\n * IDENTITY-PRESERVING: with zodCompat (schema != null) the compiled\n * parse/safeParse/parseAsync/safeParseAsync are installed as OWN properties\n * on the original schema object, which is returned as-is. zod v4 keys\n * several APIs on object identity — toJSONSchema's ctx.seen registers the\n * object it is handed while each processor closure captures the original\n * inst (a wrapper crashes `optionalProcessor` with \"Cannot set properties\n * of undefined (setting 'ref')\" the moment a compiled schema is composed\n * into another schema), and globalRegistry/.meta() is a WeakMap keyed by\n * the schema instance (a wrapper silently loses OpenAPI titles/ids). An\n * Object.create wrapper breaks both; mutating the original breaks neither\n * (zod's internal parsing flows through _zod.run, never the public\n * methods, and derived schemas — .optional(), .extend() — are fresh\n * instances that fall back to plain zod). schema=null (zodCompat: false)\n * still produces a plain method-bag object.\n *\n * fc is the schema's hosted fast-check boolean function (null when no Fast\n * Path exists). parse()/parseAsync() try it first and return the input\n * directly on success: fc is small enough for V8 to inline, so the hot parse\n * path runs with zero allocations — calling fn would allocate an intermediate\n * SafeParseResult that escape analysis cannot remove (fn never inlines).\n * Fast-path-eligible schemas never mutate, so fc(input) ⟹ data === input.\n *\n * is is the TOTAL fast-check predicate (fc when the fast path is total, else\n * null). Installed as `.is()` — a zero-allocation boolean type guard. When\n * null (partial fast path or none) `.is()` derives from fn(input).success: a\n * partial fc can pass-through valid input but its `false` does not imply\n * rejection (a default/catch may still succeed), so it would be unsound as a\n * standalone guard.\n *\n * parseAsync/safeParseAsync wrap the SYNC validator, which is right for every\n * schema the compiler can reproduce — none of them are async. It is wrong for\n * the ones it cannot: an `async` refinement or a `z.promise()` extracts to a\n * Zod delegate, and delegating means calling Zod's SYNCHRONOUS safeParse, which\n * raises `$ZodAsyncError` by design. Wrapping that gave the compiled schema an\n * async pair that rejected with `$ZodAsyncError` for EVERY input — including\n * valid ones — where Zod resolves normally, so `await UserSchema.parseAsync(x)`\n * stopped working the moment any part of the schema went async.\n *\n * So both are guarded: a synchronous throw hands off to the schema's ORIGINAL\n * async method, captured before these are installed — the same escape hatch\n * `~standard` already uses for its throw path, and for the same reason (the\n * compiled validator has no async mode to offer, and Zod's is exact). It also\n * fixes the smaller wart that a throwing `fn` made `parseAsync` throw\n * SYNCHRONOUSLY rather than return a rejected promise. With `zodCompat: false`\n * there is no schema to delegate to and the throw propagates as before.\n *\n * `~standard` is REPLACED, not merely preserved. Zod builds it lazily as\n * `validate: (v) => safeParse(inst, v)` — the core FUNCTION, which goes straight\n * to `inst._zod.run`. It never reads the schema's own `safeParse` property, so\n * installing the compiled one leaves this route entirely uncompiled: measured\n * 271.7 ns against the compiled 26.6 ns on the same schema, i.e. Standard Schema\n * consumers (tRPC, Hono, TanStack) were getting plain Zod.\n *\n * Zod's own validate is captured first and kept as the throw path: it catches a\n * synchronous throw and retries through `safeParseAsync`, which is how an async\n * refinement resolves and how a throwing check surfaces as a rejected promise\n * rather than a synchronous throw. The compiled validator cannot reproduce that\n * (async schemas delegate to Zod anyway), so deferring to the original is both\n * simpler and exact.\n *\n * Installed with defineProperty rather than assignment: Zod's lazy setter\n * redefines the slot as non-writable, so a second `__zcMkv` on the same schema\n * object — two exports aliasing one schema — would throw under ESM strict mode.\n */\nexport const MK_VALIDATOR_DECL =\n  \"function __zcMkv(fn,schema,fc,is){var w=schema||{};var zpa=w.parseAsync,zspa=w.safeParseAsync;w.parse=fc?function(input){if(fc(input))return input;var r=fn(input);if(r.success)return r.data;throw r.error;}:function(input){var r=fn(input);if(r.success)return r.data;throw r.error;};w.safeParse=fn;w.safeParseAsync=function(input){try{return Promise.resolve(fn(input));}catch(e){if(zspa)return zspa(input);throw e;}};w.parseAsync=fc?function(input){try{if(fc(input))return Promise.resolve(input);var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}catch(e){if(zpa)return zpa(input);throw e;}}:function(input){try{var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}catch(e){if(zpa)return zpa(input);throw e;}};w.is=is||function(input){return fn(input).success;};\" +\n  'var s=w[\"~standard\"],zv=s&&s.validate;' +\n  'Object.defineProperty(w,\"~standard\",{configurable:true,value:{version:1,vendor:(s&&s.vendor)||\"zod\",validate:function(input){var r;try{if(fc&&fc(input))return{value:input};r=fn(input);}catch(e){if(zv)return zv(input);throw e;}return r.success?{value:r.data}:{issues:r.error.issues};}}});' +\n  \"return w;}\";\n\nfunction extractFunctionName(functionDef: string): string {\n  const match = /^function\\s+(\\w+)\\s*\\(/.exec(functionDef);\n  if (!match?.[1]) {\n    throw new Error(\"Cannot extract function name from generated code\");\n  }\n  return match[1];\n}\n\n/**\n * Generate a `/* @__PURE__ * /` IIFE wrapping a compiled validator.\n *\n * @param schemaExpr - Expression resolving to the original Zod schema\n *   (e.g. `\"UserSchema\"` in unplugin, `\"(__src_X as any).schema\"` in CLI)\n * @param schema\n * @param options\n */\nexport function generateIIFE(\n  schemaExpr: string,\n  schema: CompiledSchemaInfo,\n  options?: { zodCompat?: boolean | undefined },\n): string {\n  const { codegenResult, refEntries } = schema;\n  const fnName = extractFunctionName(codegenResult.functionDef);\n  const zodCompat = options?.zodCompat !== false;\n  // Every fallback access starts from the same source schema. Capture it once\n  // whenever refs exist so an inline initializer is not reconstructed for each\n  // path and again for the identity-preserving __zcMkv target.\n  const retainedSchema = refEntries.length > 0 ? \"__zs\" : schemaExpr;\n  const schemaArg = zodCompat ? retainedSchema : \"null\";\n  const fcArg = codegenResult.fastFnName ?? \"null\";\n  // `.is()` gets the fast-check directly only when it is a total predicate;\n  // partial/none falls back to safeParse().success inside __zcMkv. A rebuilding\n  // schema has no by-reference `fc` but still names its predicate separately.\n  const isArg = codegenResult.isFnName ?? (codegenResult.fastTotal ? fcArg : \"null\");\n\n  return [\n    \"/* @__PURE__ */ (() => {\",\n    ...(refEntries.length > 0\n      ? [\n          `var __zs=${schemaExpr};`,\n          `var __rf=[${refEntries.map((fb) => `${retainedSchema}${fb.accessPath}`).join(\",\")}];`,\n        ]\n      : []),\n    ...codegenResult.code\n      .split(\"\\n\")\n      .filter((l) => l.trim() !== \"\" && l.trim() !== \"/* zod-compiler */\"),\n    codegenResult.functionDef,\n    `return __zcMkv(${fnName},${schemaArg},${fcArg},${isArg});`,\n    \"})()\",\n  ].join(\"\\n\");\n}\n"],"mappings":";;;;;;;AAaA,MAAa,oBACX;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,sBACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CF,MAAa,kBACX;;;AASF,MAAa,WACX;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;AAyBjC,MAAa,mBACX;;AAKF,MAAa,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EzB,MAAa,oBACX;AAKF,SAAS,oBAAoB,aAA6B;CACxD,MAAM,QAAQ,yBAAyB,KAAK,WAAW;CACvD,IAAI,CAAC,QAAQ,IACX,MAAM,IAAI,MAAM,kDAAkD;CAEpE,OAAO,MAAM;AACf;;;;;;;;;AAUA,SAAgB,aACd,YACA,QACA,SACQ;CACR,MAAM,EAAE,eAAe,eAAe;CACtC,MAAM,SAAS,oBAAoB,cAAc,WAAW;CAC5D,MAAM,YAAY,SAAS,cAAc;CAIzC,MAAM,iBAAiB,WAAW,SAAS,IAAI,SAAS;CACxD,MAAM,YAAY,YAAY,iBAAiB;CAC/C,MAAM,QAAQ,cAAc,cAAc;CAI1C,MAAM,QAAQ,cAAc,aAAa,cAAc,YAAY,QAAQ;CAE3E,OAAO;EACL;EACA,GAAI,WAAW,SAAS,IACpB,CACE,YAAY,WAAW,IACvB,aAAa,WAAW,KAAK,OAAO,GAAG,iBAAiB,GAAG,YAAY,CAAC,CAAC,KAAK,GAAG,EAAE,GACrF,IACA,CAAC;EACL,GAAG,cAAc,KACd,MAAM,IAAI,CAAC,CACX,QAAQ,MAAM,EAAE,KAAK,MAAM,MAAM,EAAE,KAAK,MAAM,oBAAoB;EACrE,cAAc;EACd,kBAAkB,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM;EACxD;CACF,CAAC,CAAC,KAAK,IAAI;AACb"}

package/dist/core/pipeline.d.ts

@@ -8,9 +8,9 @@ interface CompiledSchemaInfo {
   codegenResult: CodeGenResult;
   refEntries: RefEntry[];
 }
-/** Module-scope shared-validator declarations produced by file-level dedup. */
+/** Module-scope declarations produced by file-level schema and constant dedup. */
 interface SharedSchemaBlock {
-  /** Shared `__zcSw_N` functions + their preamble. Empty string when nothing repeated. */
+  /** Shared constants and `__zcSw_N` functions. Empty string when nothing repeats. */
   code: string;
   /** Runtime helper names referenced by the shared block (lean mode imports). */
   usedHelpers: Set<string>;
@@ -38,12 +38,11 @@ interface CompileSchemasOptions {
  * Run the extract → generate pipeline for each discovered schema.
  * Shared by CLI generate and unplugin transform.
  *
- * Two passes so structurally repeated schemas can be deduplicated: pass 1
- * extracts every schema's IR, then a file-level plan hoists the slow walk of
- * any shape that recurs across schemas into a shared `__zcSw_N` function; pass
- * 2 generates each validator, calling the shared walk instead of re-inlining
- * it. Files with no repetition take the same path and produce identical output
- * to single-pass codegen (the plan is empty), paying only one linear analysis.
+ * Pass 1 extracts every schema's IR and plans repeated slow walks. Pass 2
+ * generates each validator, calling shared `__zcSw_N` functions instead of
+ * re-inlining them. Exact Set initializers reported during generation are then
+ * pooled when at least two validators use them. Files with no repetition keep
+ * their original local declarations.
  */
 declare function compileSchemas(schemas: DiscoveredSchema[], options: CompileSchemasOptions): CompileSchemasResult;
 /**

package/dist/core/pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.d.ts","names":[],"sources":["../../src/core/pipeline.ts"],"mappings":";;;;;UAQiB;EACf;EACA,eAAe;EACf,YAAY;;;UAIG;;EAEf;;EAEA,aAAa;;;UAIE;EACf,SAAS;EACT,QAAQ;;UAGO;;EAEf,MAAM;;;;;;;;EAQN;;EAEA,WAAW,oBAAoB,OAAO;;;;;;;;;;;;;iBAcxB,eACd,SAAS,oBACT,SAAS,wBACR;;;;;iBAqEa,qBAAqB,SAAS,uBAAuB"}
+{"version":3,"file":"pipeline.d.ts","names":[],"sources":["../../src/core/pipeline.ts"],"mappings":";;;;;UAQiB;EACf;EACA,eAAe;EACf,YAAY;;;UAIG;;EAEf;;EAEA,aAAa;;;UAIE;EACf,SAAS;EACT,QAAQ;;UAGO;;EAEf,MAAM;;;;;;;;EAQN;;EAEA,WAAW,oBAAoB,OAAO;;;;;;;;;;;;iBA2CxB,eACd,SAAS,oBACT,SAAS,wBACR;;;;;iBA+Ha,qBAAqB,SAAS,uBAAuB"}

package/dist/core/pipeline.js

@@ -1,17 +1,32 @@
-import { createSharedSchemaPlan } from "./codegen/dedupe.js";
+import { SHARED_BLOCK_MARKER, createSharedSchemaPlan } from "./codegen/dedupe.js";
 import { generateValidator } from "./codegen/index.js";
 import { extractSchema } from "./extract/index.js";
 //#region src/core/pipeline.ts
+/** Plan exact Set initializers used by at least two validators in this file. */
+function planSharedSetConstants(results, constantsByResult) {
+	const byInitializer = /* @__PURE__ */ new Map();
+	for (const { codegenResult } of results) for (const constant of constantsByResult.get(codegenResult) ?? []) {
+		const declaration = `var ${constant.name}=${constant.initializer};`;
+		if (!codegenResult.code.includes(declaration)) continue;
+		const users = byInitializer.get(constant.initializer);
+		if (users === void 0) byInitializer.set(constant.initializer, /* @__PURE__ */ new Set([codegenResult]));
+		else users.add(codegenResult);
+	}
+	const repeated = [...byInitializer.entries()].filter(([, users]) => users.size >= 2).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	return new Map(repeated.map(([initializer], index) => [initializer, `__zcSet_${index}`]));
+}
+function emitSharedSetConstants(sharedSetNames) {
+	return [...sharedSetNames].map(([initializer, name]) => `var ${name}=/* @__PURE__ */${initializer};`).join("\n");
+}
 /**
 * Run the extract → generate pipeline for each discovered schema.
 * Shared by CLI generate and unplugin transform.
 *
-* Two passes so structurally repeated schemas can be deduplicated: pass 1
-* extracts every schema's IR, then a file-level plan hoists the slow walk of
-* any shape that recurs across schemas into a shared `__zcSw_N` function; pass
-* 2 generates each validator, calling the shared walk instead of re-inlining
-* it. Files with no repetition take the same path and produce identical output
-* to single-pass codegen (the plan is empty), paying only one linear analysis.
+* Pass 1 extracts every schema's IR and plans repeated slow walks. Pass 2
+* generates each validator, calling shared `__zcSw_N` functions instead of
+* re-inlining them. Exact Set initializers reported during generation are then
+* pooled when at least two validators use them. Files with no repetition keep
+* their original local declarations.
 */
 function compileSchemas(schemas, options) {
 	const handle = (exportName, err) => {
@@ -32,30 +47,59 @@ function compileSchemas(schemas, options) {
 		handle(s.exportName, err);
 	}
 	const plan = options.compact ? void 0 : createSharedSchemaPlan(extracted.map((e) => e.ir), options.mode);
-	const results = [];
+	const generated = [];
+	const constantsByResult = /* @__PURE__ */ new Map();
 	for (const e of extracted) try {
+		const setConstants = /* @__PURE__ */ new Map();
 		const codegenResult = generateValidator(e.ir, e.exportName, {
 			refCount: e.refEntries.length,
 			mode: options.mode,
 			sharedSchemas: plan,
-			compact: options.compact
+			compact: options.compact,
+			onSetConstant(constant) {
+				setConstants.set(constant.name, constant);
+			}
 		});
-		if (codegenResult.rootDelegateRefIndex !== void 0) e.refEntries.push({
-			schema: e.schema,
-			accessPath: ""
-		});
-		results.push({
+		constantsByResult.set(codegenResult, [...setConstants.values()]);
+		generated.push({
 			exportName: e.exportName,
-			codegenResult,
-			refEntries: e.refEntries
+			schema: e.schema,
+			ir: e.ir,
+			refEntries: e.refEntries,
+			codegenResult
 		});
 	} catch (err) {
 		handle(e.exportName, err);
 	}
+	const sharedSetNames = planSharedSetConstants(generated.map(({ exportName, codegenResult, refEntries }) => ({
+		exportName,
+		codegenResult,
+		refEntries
+	})), constantsByResult);
+	if (sharedSetNames.size > 0) for (const entry of generated) entry.codegenResult = generateValidator(entry.ir, entry.exportName, {
+		refCount: entry.refEntries.length,
+		mode: options.mode,
+		sharedSchemas: plan,
+		compact: options.compact,
+		sharedSetNames
+	});
+	const results = generated.map((entry) => {
+		if (entry.codegenResult.rootDelegateRefIndex !== void 0) entry.refEntries.push({
+			schema: entry.schema,
+			accessPath: ""
+		});
+		return {
+			exportName: entry.exportName,
+			codegenResult: entry.codegenResult,
+			refEntries: entry.refEntries
+		};
+	});
+	const sharedSetCode = emitSharedSetConstants(sharedSetNames);
+	const slowWalkCode = plan?.code ?? "";
 	return {
 		schemas: results,
 		shared: {
-			code: plan?.code ?? "",
+			code: sharedSetCode === "" ? slowWalkCode : slowWalkCode === "" ? `${SHARED_BLOCK_MARKER}\n${sharedSetCode}` : `${slowWalkCode}\n${sharedSetCode}`,
 			usedHelpers: plan?.usedHelpers ?? /* @__PURE__ */ new Set()
 		}
 	};

package/dist/core/pipeline.js.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.js","names":[],"sources":["../../src/core/pipeline.ts"],"sourcesContent":["import type { CodeGenResult, CodegenMode } from \"./codegen/context.js\";\nimport { createSharedSchemaPlan } from \"./codegen/dedupe.js\";\nimport { generateValidator } from \"./codegen/index.js\";\nimport type { RefEntry } from \"./extract/index.js\";\nimport { extractSchema } from \"./extract/index.js\";\nimport type { DiscoveredSchema, SchemaIR } from \"./types.js\";\n\n/** Result of compiling a single discovered schema through extract → generate pipeline. */\nexport interface CompiledSchemaInfo {\n  exportName: string;\n  codegenResult: CodeGenResult;\n  refEntries: RefEntry[];\n}\n\n/** Module-scope shared-validator declarations produced by file-level dedup. */\nexport interface SharedSchemaBlock {\n  /** Shared `__zcSw_N` functions + their preamble. Empty string when nothing repeated. */\n  code: string;\n  /** Runtime helper names referenced by the shared block (lean mode imports). */\n  usedHelpers: Set<string>;\n}\n\n/** Output of {@link compileSchemas}: per-schema validators plus the file's shared block. */\nexport interface CompileSchemasResult {\n  schemas: CompiledSchemaInfo[];\n  shared: SharedSchemaBlock;\n}\n\nexport interface CompileSchemasOptions {\n  /** \"inline\" for CLI .compiled.ts; \"lean\" for unplugin (imports from virtual:zod-compiler/runtime). */\n  mode: CodegenMode;\n  /**\n   * Compact output (`output: \"compact\"`). Drop the compiled slow walk for\n   * mutation-free, total-fast-path schemas and delegate their cold error path\n   * to the retained Zod schema. Disables slow-walk sharing (delegated schemas\n   * never emit a walk to share) and appends a root self-RefEntry per delegated\n   * schema so `__rf[N]` resolves to the original Zod schema.\n   */\n  compact?: boolean | undefined;\n  /** When provided, per-schema failures call this and continue. Otherwise the first error throws. */\n  onError?: (exportName: string, error: Error) => void;\n}\n\n/**\n * Run the extract → generate pipeline for each discovered schema.\n * Shared by CLI generate and unplugin transform.\n *\n * Two passes so structurally repeated schemas can be deduplicated: pass 1\n * extracts every schema's IR, then a file-level plan hoists the slow walk of\n * any shape that recurs across schemas into a shared `__zcSw_N` function; pass\n * 2 generates each validator, calling the shared walk instead of re-inlining\n * it. Files with no repetition take the same path and produce identical output\n * to single-pass codegen (the plan is empty), paying only one linear analysis.\n */\nexport function compileSchemas(\n  schemas: DiscoveredSchema[],\n  options: CompileSchemasOptions,\n): CompileSchemasResult {\n  const handle = (exportName: string, err: unknown): void => {\n    if (options.onError) {\n      options.onError(exportName, err instanceof Error ? err : new Error(String(err)));\n    } else {\n      throw err;\n    }\n  };\n\n  // Pass 1: extract IR (and fallback refs) for every schema.\n  const extracted: Array<{\n    exportName: string;\n    schema: unknown;\n    ir: SchemaIR;\n    refEntries: RefEntry[];\n  }> = [];\n  for (const s of schemas) {\n    try {\n      const refEntries: RefEntry[] = [];\n      const ir = extractSchema(s.schema, refEntries);\n      extracted.push({ exportName: s.exportName, schema: s.schema, ir, refEntries });\n    } catch (err) {\n      handle(s.exportName, err);\n    }\n  }\n\n  // Compact mode delegates the cold error path of total-fast-path schemas to\n  // zod, so they emit no slow walk to share — skip the plan (and the dead\n  // shared functions it would generate for shapes that now only delegate).\n  const plan = options.compact\n    ? undefined\n    : createSharedSchemaPlan(\n        extracted.map((e) => e.ir),\n        options.mode,\n      );\n\n  // Pass 2: generate each validator, sharing repeated slow walks via the plan.\n  const results: CompiledSchemaInfo[] = [];\n  for (const e of extracted) {\n    try {\n      const codegenResult = generateValidator(e.ir, e.exportName, {\n        refCount: e.refEntries.length,\n        mode: options.mode,\n        sharedSchemas: plan,\n        compact: options.compact,\n      });\n      // Compact delegation appends the schema itself as a fresh root RefEntry\n      // (accessPath \"\" → __rf[N] = the original Zod schema, whose pristine\n      // safeParse the validator delegates to). The index was reserved as\n      // e.refEntries.length above, so this push lands exactly at it.\n      if (codegenResult.rootDelegateRefIndex !== undefined) {\n        e.refEntries.push({ schema: e.schema, accessPath: \"\" });\n      }\n      results.push({ exportName: e.exportName, codegenResult, refEntries: e.refEntries });\n    } catch (err) {\n      handle(e.exportName, err);\n    }\n  }\n\n  return {\n    schemas: results,\n    shared: { code: plan?.code ?? \"\", usedHelpers: plan?.usedHelpers ?? new Set() },\n  };\n}\n\n/**\n * Aggregate `usedHelpers` across multiple compiled schemas (typically all schemas in one file).\n * Used by the unplugin transform to construct a single import statement per file.\n */\nexport function aggregateUsedHelpers(schemas: CompiledSchemaInfo[]): Set<string> {\n  const all = new Set<string>();\n  for (const s of schemas) {\n    for (const h of s.codegenResult.usedHelpers) all.add(h);\n  }\n  return all;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAsDA,SAAgB,eACd,SACA,SACsB;CACtB,MAAM,UAAU,YAAoB,QAAuB;EACzD,IAAI,QAAQ,SACV,QAAQ,QAAQ,YAAY,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;OAE/E,MAAM;CAEV;CAGA,MAAM,YAKD,CAAC;CACN,KAAK,MAAM,KAAK,SACd,IAAI;EACF,MAAM,aAAyB,CAAC;EAChC,MAAM,KAAK,cAAc,EAAE,QAAQ,UAAU;EAC7C,UAAU,KAAK;GAAE,YAAY,EAAE;GAAY,QAAQ,EAAE;GAAQ;GAAI;EAAW,CAAC;CAC/E,SAAS,KAAK;EACZ,OAAO,EAAE,YAAY,GAAG;CAC1B;CAMF,MAAM,OAAO,QAAQ,UACjB,KAAA,IACA,uBACE,UAAU,KAAK,MAAM,EAAE,EAAE,GACzB,QAAQ,IACV;CAGJ,MAAM,UAAgC,CAAC;CACvC,KAAK,MAAM,KAAK,WACd,IAAI;EACF,MAAM,gBAAgB,kBAAkB,EAAE,IAAI,EAAE,YAAY;GAC1D,UAAU,EAAE,WAAW;GACvB,MAAM,QAAQ;GACd,eAAe;GACf,SAAS,QAAQ;EACnB,CAAC;EAKD,IAAI,cAAc,yBAAyB,KAAA,GACzC,EAAE,WAAW,KAAK;GAAE,QAAQ,EAAE;GAAQ,YAAY;EAAG,CAAC;EAExD,QAAQ,KAAK;GAAE,YAAY,EAAE;GAAY;GAAe,YAAY,EAAE;EAAW,CAAC;CACpF,SAAS,KAAK;EACZ,OAAO,EAAE,YAAY,GAAG;CAC1B;CAGF,OAAO;EACL,SAAS;EACT,QAAQ;GAAE,MAAM,MAAM,QAAQ;GAAI,aAAa,MAAM,+BAAe,IAAI,IAAI;EAAE;CAChF;AACF;;;;;AAMA,SAAgB,qBAAqB,SAA4C;CAC/E,MAAM,sBAAM,IAAI,IAAY;CAC5B,KAAK,MAAM,KAAK,SACd,KAAK,MAAM,KAAK,EAAE,cAAc,aAAa,IAAI,IAAI,CAAC;CAExD,OAAO;AACT"}
+{"version":3,"file":"pipeline.js","names":[],"sources":["../../src/core/pipeline.ts"],"sourcesContent":["import type { CodeGenResult, CodegenMode, GeneratedSetConstant } from \"./codegen/context.js\";\nimport { createSharedSchemaPlan, SHARED_BLOCK_MARKER } from \"./codegen/dedupe.js\";\nimport { generateValidator } from \"./codegen/index.js\";\nimport type { RefEntry } from \"./extract/index.js\";\nimport { extractSchema } from \"./extract/index.js\";\nimport type { DiscoveredSchema, SchemaIR } from \"./types.js\";\n\n/** Result of compiling a single discovered schema through extract → generate pipeline. */\nexport interface CompiledSchemaInfo {\n  exportName: string;\n  codegenResult: CodeGenResult;\n  refEntries: RefEntry[];\n}\n\n/** Module-scope declarations produced by file-level schema and constant dedup. */\nexport interface SharedSchemaBlock {\n  /** Shared constants and `__zcSw_N` functions. Empty string when nothing repeats. */\n  code: string;\n  /** Runtime helper names referenced by the shared block (lean mode imports). */\n  usedHelpers: Set<string>;\n}\n\n/** Output of {@link compileSchemas}: per-schema validators plus the file's shared block. */\nexport interface CompileSchemasResult {\n  schemas: CompiledSchemaInfo[];\n  shared: SharedSchemaBlock;\n}\n\nexport interface CompileSchemasOptions {\n  /** \"inline\" for CLI .compiled.ts; \"lean\" for unplugin (imports from virtual:zod-compiler/runtime). */\n  mode: CodegenMode;\n  /**\n   * Compact output (`output: \"compact\"`). Drop the compiled slow walk for\n   * mutation-free, total-fast-path schemas and delegate their cold error path\n   * to the retained Zod schema. Disables slow-walk sharing (delegated schemas\n   * never emit a walk to share) and appends a root self-RefEntry per delegated\n   * schema so `__rf[N]` resolves to the original Zod schema.\n   */\n  compact?: boolean | undefined;\n  /** When provided, per-schema failures call this and continue. Otherwise the first error throws. */\n  onError?: (exportName: string, error: Error) => void;\n}\n\n/** Plan exact Set initializers used by at least two validators in this file. */\nfunction planSharedSetConstants(\n  results: readonly CompiledSchemaInfo[],\n  constantsByResult: ReadonlyMap<CodeGenResult, readonly GeneratedSetConstant[]>,\n): ReadonlyMap<string, string> {\n  const byInitializer = new Map<string, Set<CodeGenResult>>();\n  for (const { codegenResult } of results) {\n    for (const constant of constantsByResult.get(codegenResult) ?? []) {\n      const declaration = `var ${constant.name}=${constant.initializer};`;\n      // Fast-path generation can emit a Set before a later node aborts. Its\n      // preamble is rolled back, so only collect declarations that survived.\n      if (!codegenResult.code.includes(declaration)) continue;\n      const users = byInitializer.get(constant.initializer);\n      if (users === undefined) byInitializer.set(constant.initializer, new Set([codegenResult]));\n      else users.add(codegenResult);\n    }\n  }\n\n  const repeated = [...byInitializer.entries()]\n    .filter(([, users]) => users.size >= 2)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n  return new Map(repeated.map(([initializer], index) => [initializer, `__zcSet_${index}`]));\n}\n\nfunction emitSharedSetConstants(sharedSetNames: ReadonlyMap<string, string>): string {\n  return [...sharedSetNames]\n    .map(([initializer, name]) => `var ${name}=/* @__PURE__ */${initializer};`)\n    .join(\"\\n\");\n}\n\n/**\n * Run the extract → generate pipeline for each discovered schema.\n * Shared by CLI generate and unplugin transform.\n *\n * Pass 1 extracts every schema's IR and plans repeated slow walks. Pass 2\n * generates each validator, calling shared `__zcSw_N` functions instead of\n * re-inlining them. Exact Set initializers reported during generation are then\n * pooled when at least two validators use them. Files with no repetition keep\n * their original local declarations.\n */\nexport function compileSchemas(\n  schemas: DiscoveredSchema[],\n  options: CompileSchemasOptions,\n): CompileSchemasResult {\n  const handle = (exportName: string, err: unknown): void => {\n    if (options.onError) {\n      options.onError(exportName, err instanceof Error ? err : new Error(String(err)));\n    } else {\n      throw err;\n    }\n  };\n\n  // Pass 1: extract IR (and fallback refs) for every schema.\n  const extracted: Array<{\n    exportName: string;\n    schema: unknown;\n    ir: SchemaIR;\n    refEntries: RefEntry[];\n  }> = [];\n  for (const s of schemas) {\n    try {\n      const refEntries: RefEntry[] = [];\n      const ir = extractSchema(s.schema, refEntries);\n      extracted.push({ exportName: s.exportName, schema: s.schema, ir, refEntries });\n    } catch (err) {\n      handle(s.exportName, err);\n    }\n  }\n\n  // Compact mode delegates the cold error path of total-fast-path schemas to\n  // zod, so they emit no slow walk to share — skip the plan (and the dead\n  // shared functions it would generate for shapes that now only delegate).\n  const plan = options.compact\n    ? undefined\n    : createSharedSchemaPlan(\n        extracted.map((e) => e.ir),\n        options.mode,\n      );\n\n  // Pass 2: generate each validator, sharing repeated slow walks via the plan\n  // and observing which Set declarations survive codegen rollback.\n  const generated: Array<{\n    exportName: string;\n    schema: unknown;\n    ir: SchemaIR;\n    refEntries: RefEntry[];\n    codegenResult: CodeGenResult;\n  }> = [];\n  const constantsByResult = new Map<CodeGenResult, GeneratedSetConstant[]>();\n  for (const e of extracted) {\n    try {\n      const setConstants = new Map<string, GeneratedSetConstant>();\n      const codegenResult = generateValidator(e.ir, e.exportName, {\n        refCount: e.refEntries.length,\n        mode: options.mode,\n        sharedSchemas: plan,\n        compact: options.compact,\n        onSetConstant(constant) {\n          setConstants.set(constant.name, constant);\n        },\n      });\n      constantsByResult.set(codegenResult, [...setConstants.values()]);\n      generated.push({\n        exportName: e.exportName,\n        schema: e.schema,\n        ir: e.ir,\n        refEntries: e.refEntries,\n        codegenResult,\n      });\n    } catch (err) {\n      handle(e.exportName, err);\n    }\n  }\n\n  const initialResults = generated.map(\n    ({ exportName, codegenResult, refEntries }): CompiledSchemaInfo => ({\n      exportName,\n      codegenResult,\n      refEntries,\n    }),\n  );\n  const sharedSetNames = planSharedSetConstants(initialResults, constantsByResult);\n\n  // Regenerate only when sharing is profitable. Selecting shared names before\n  // emission avoids textual rewriting of generated JavaScript, where a user\n  // enum string can legally contain text resembling a generated identifier.\n  if (sharedSetNames.size > 0) {\n    for (const entry of generated) {\n      entry.codegenResult = generateValidator(entry.ir, entry.exportName, {\n        refCount: entry.refEntries.length,\n        mode: options.mode,\n        sharedSchemas: plan,\n        compact: options.compact,\n        sharedSetNames,\n      });\n    }\n  }\n\n  const results: CompiledSchemaInfo[] = generated.map((entry) => {\n    // Compact delegation appends the schema itself as a fresh root RefEntry\n    // after the optional regeneration pass, keeping the reserved index stable.\n    if (entry.codegenResult.rootDelegateRefIndex !== undefined) {\n      entry.refEntries.push({ schema: entry.schema, accessPath: \"\" });\n    }\n    return {\n      exportName: entry.exportName,\n      codegenResult: entry.codegenResult,\n      refEntries: entry.refEntries,\n    };\n  });\n\n  const sharedSetCode = emitSharedSetConstants(sharedSetNames);\n  const slowWalkCode = plan?.code ?? \"\";\n  const sharedCode =\n    sharedSetCode === \"\"\n      ? slowWalkCode\n      : slowWalkCode === \"\"\n        ? `${SHARED_BLOCK_MARKER}\\n${sharedSetCode}`\n        : `${slowWalkCode}\\n${sharedSetCode}`;\n\n  return {\n    schemas: results,\n    shared: { code: sharedCode, usedHelpers: plan?.usedHelpers ?? new Set() },\n  };\n}\n\n/**\n * Aggregate `usedHelpers` across multiple compiled schemas (typically all schemas in one file).\n * Used by the unplugin transform to construct a single import statement per file.\n */\nexport function aggregateUsedHelpers(schemas: CompiledSchemaInfo[]): Set<string> {\n  const all = new Set<string>();\n  for (const s of schemas) {\n    for (const h of s.codegenResult.usedHelpers) all.add(h);\n  }\n  return all;\n}\n"],"mappings":"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"}

package/dist/runtime.js

@@ -1,11 +1,11 @@
 import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from "zod";
 function __zcUw(m){return typeof m==="string"?m:(m===undefined||m===null?undefined:m.message);}var __zcMsg=function(iss){var c=__zodCompilerConfig(),m;if(c.customError){m=__zcUw(c.customError(iss));if(m!==undefined&&m!==null)return m;}if(c.localeError){m=__zcUw(c.localeError(iss));if(m!==undefined&&m!==null)return m;}return "Invalid input";};
 function __ZcFail(e,f,i){this.success=false;this._e=e;this._f=f;this._i=i;this._c=undefined;}Object.defineProperty(__ZcFail.prototype,"error",{configurable:true,get:function(){if(this._c)return this._c;var e=this._f!==null?this._f(this._i):this._e;for(var i=0;i<e.length;i++){if(e[i].message===undefined&&typeof __zcMsg==="function")e[i].message=__zcMsg(e[i]);delete e[i].input;delete e[i].continue;}return this._c=new __zcZodError(e);}});
-function __ZcFailZ(z,i){this.success=false;this._z=z;this._i=i;this._c=undefined;}Object.defineProperty(__ZcFailZ.prototype,"error",{configurable:true,get:function(){return this._c||(this._c=this._z(this._i).error);}});
+function __ZcFailZ(z,r,i){this.success=false;this._z=z;this._r=r;this._i=i;this._c=undefined;}Object.defineProperty(__ZcFailZ.prototype,"error",{configurable:true,get:function(){return this._c||(this._c=this._z.call(this._r,this._i).error);}});
 export function __zcMkv(fn,schema,fc,is){var w=schema||{};var zpa=w.parseAsync,zspa=w.safeParseAsync;w.parse=fc?function(input){if(fc(input))return input;var r=fn(input);if(r.success)return r.data;throw r.error;}:function(input){var r=fn(input);if(r.success)return r.data;throw r.error;};w.safeParse=fn;w.safeParseAsync=function(input){try{return Promise.resolve(fn(input));}catch(e){if(zspa)return zspa(input);throw e;}};w.parseAsync=fc?function(input){try{if(fc(input))return Promise.resolve(input);var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}catch(e){if(zpa)return zpa(input);throw e;}}:function(input){try{var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}catch(e){if(zpa)return zpa(input);throw e;}};w.is=is||function(input){return fn(input).success;};var s=w["~standard"],zv=s&&s.validate;Object.defineProperty(w,"~standard",{configurable:true,value:{version:1,vendor:(s&&s.vendor)||"zod",validate:function(input){var r;try{if(fc&&fc(input))return{value:input};r=fn(input);}catch(e){if(zv)return zv(input);throw e;}return r.success?{value:r.data}:{issues:r.error.issues};}}});return w;}
 export function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}
 export function __zcFinD(f,inp){return new __ZcFail(null,f,inp);}
-export function __zcFinZ(z,i){return new __ZcFailZ(z,i);}
+export function __zcFinZ(z,r,i){return new __ZcFailZ(z,r,i);}
 function __zcSrRun(f,p){var r=f(p);if(r&&typeof r.then==="function"){throw new __zcCore.$ZodAsyncError();}}
 export function __zcTS(m,o,i,inp,p,msg){var r={origin:o,code:"too_small",minimum:m,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}
 export function __zcTSn(m,o,inp,p,msg){var r={code:"too_small",minimum:m,origin:o,input:inp,path:p,continue:false};if(msg!==undefined)r.message=msg;return r;}