zod-compiler 1.23.0 → 1.23.2

package/dist/core/iife.d.ts

@@ -1,8 +1,5 @@
-/**
- * Shared CompiledSchema<T> IIFE generation.
- * Used by both CLI emitter and unplugin transform.
- */
-import type { CompiledSchemaInfo } from "./pipeline.js";
+import { CompiledSchemaInfo } from "./pipeline.js";
+//#region src/core/iife.d.ts
 /**
  * Import statement required by generateIIFE output (references
  * __zodCompilerConfig). `core` is bound for $ZodAsyncError: a superRefine
@@ -10,7 +7,7 @@ import type { CompiledSchemaInfo } from "./pipeline.js";
  * detectable by the promise it returns, at which point zod's own synchronous
  * parse raises (see ZC_SR_DECL).
  */
-export declare const ZOD_CONFIG_IMPORT = "import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from \"zod\";";
+declare const ZOD_CONFIG_IMPORT = "import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from \"zod\";";
 /**
  * File-level `__zcMsg` declaration (must appear once after ZOD_CONFIG_IMPORT):
  * the message an issue gets when nothing was baked into it at build time.
@@ -30,7 +27,7 @@ export declare const ZOD_CONFIG_IMPORT = "import { config as __zodCompilerConfig
  *
  * Only ever called while building an error, never on a successful parse.
  */
-export declare const ZOD_MSG_DECLARATION: string;
+declare const ZOD_MSG_DECLARATION: string;
 /**
  * Shared failure-result for __zcFin / __zcFinD. Inline mode (CLI emitter)
  * declares it once per compiled file; lean mode (all unplugin bundlers) declares
@@ -57,10 +54,10 @@ export declare const ZOD_MSG_DECLARATION: string;
  * trace) — stays deferred inside the cached accessor exactly as before, since
  * the issues array is observable solely through `.error`.
  */
-export declare const FAIL_CLASS_DECL: string;
+declare const FAIL_CLASS_DECL: string;
 /** Eager finalizer (mutation / partial-fast-path schemas): issues already
  * collected in `e`; success short-circuits to a plain result literal. */
-export declare const FIN_DECL = "function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}";
+declare const FIN_DECL = "function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}";
 /**
  * Deferred-collection finalizer for Fast-Path-eligible schemas. When the
  * fast check fails, the ENTIRE slow path (the issue-collecting re-walk) is
@@ -83,7 +80,7 @@ export declare const FIN_DECL = "function __zcFin(e,d){if(!e.length)return{succe
  * mutated value (zod materializes at parse time). Same caveat class as the
  * documented __zcFin deferral.
  */
-export declare const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(null,f,inp);}";
+declare const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(null,f,inp);}";
 /**
  * Compact-mode failure class — a lazy failure that delegates error reporting to
  * the ORIGINAL Zod schema's `safeParse`. Used by `output: "compact"`, where the
@@ -106,9 +103,9 @@ export declare const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __
  * re-wrap — zod already finalized it), so a delegated failure is exactly what
  * the unaltered schema would have produced.
  */
-export declare const FAILZ_CLASS_DECL: string;
+declare const FAILZ_CLASS_DECL: string;
 /** Compact-mode finalizer: wrap a pristine bound safeParse + input into a lazy delegated failure. */
-export declare const FINZ_DECL = "function __zcFinZ(z,i){return new __ZcFailZ(z,i);}";
+declare const FINZ_DECL = "function __zcFinZ(z,i){return new __ZcFailZ(z,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
@@ -164,7 +161,7 @@ export declare const FINZ_DECL = "function __zcFinZ(z,i){return new __ZcFailZ(z,
  * redefines the slot as non-writable, so a second `__zcMkv` on the same schema
  * object — two exports aliasing one schema — would throw under ESM strict mode.
  */
-export declare const MK_VALIDATOR_DECL: string;
+declare const MK_VALIDATOR_DECL: string;
 /**
  * Generate a `/* @__PURE__ * /` IIFE wrapping a compiled validator.
  *
@@ -173,7 +170,9 @@ export declare const MK_VALIDATOR_DECL: string;
  * @param schema
  * @param options
  */
-export declare function generateIIFE(schemaExpr: string, schema: CompiledSchemaInfo, options?: {
-    zodCompat?: boolean | undefined;
+declare function generateIIFE(schemaExpr: string, schema: CompiledSchemaInfo, options?: {
+  zodCompat?: boolean | undefined;
 }): string;
+//#endregion
+export { FAILZ_CLASS_DECL, FAIL_CLASS_DECL, FINZ_DECL, FIN_DECL, FIN_DEFERRED_DECL, MK_VALIDATOR_DECL, ZOD_CONFIG_IMPORT, ZOD_MSG_DECLARATION, generateIIFE };
 //# sourceMappingURL=iife.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"iife.d.ts","sourceRoot":"","sources":["../../src/core/iife.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,2GAC0E,CAAC;AAEzG;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,QAKH,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,QAMe,CAAC;AAE5C;yEACyE;AACzE,eAAO,MAAM,QAAQ,sGACgF,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,+DAA+D,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,QAG4B,CAAC;AAE1D,qGAAqG;AACrG,eAAO,MAAM,SAAS,uDAAuD,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,iBAAiB,QAIhB,CAAC;AAUf;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,GAC5C,MAAM,CAuBR"}
+{"version":3,"file":"iife.d.ts","names":[],"sources":["../../src/core/iife.ts"],"mappings":";;;;;;;;;cAca;;;;;;;;;;;;;;;;;;;;cAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCA;;;cAUA;;;;;;;;;;;;;;;;;;;;;;;cAyBA;;;;;;;;;;;;;;;;;;;;;;;cAwBA;;cAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyDA;;;;;;;;;iBAsBG,aACd,oBACA,QAAQ,oBACR;EAAY"}

package/dist/core/iife.js

@@ -1,219 +1,195 @@
+//#region src/core/iife.ts
 /**
- * Shared CompiledSchema<T> IIFE generation.
- * Used by both CLI emitter and unplugin transform.
- */
+* Import statement required by generateIIFE output (references
+* __zodCompilerConfig). `core` is bound for $ZodAsyncError: a superRefine
+* callback is reached through zod's wrapper, so an async one is only
+* detectable by the promise it returns, at which point zod's own synchronous
+* parse raises (see ZC_SR_DECL).
+*/
+const ZOD_CONFIG_IMPORT = "import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from \"zod\";";
 /**
- * Import statement required by generateIIFE output (references
- * __zodCompilerConfig). `core` is bound for $ZodAsyncError: a superRefine
- * callback is reached through zod's wrapper, so an async one is only
- * detectable by the promise it returns, at which point zod's own synchronous
- * parse raises (see ZC_SR_DECL).
- */
-export const ZOD_CONFIG_IMPORT = 'import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from "zod";';
+* File-level `__zcMsg` declaration (must appear once after ZOD_CONFIG_IMPORT):
+* the message an issue gets when nothing was baked into it at build time.
+*
+* Resolves zod's tail of `finalizeIssue` — `config.customError` then
+* `config.localeError` then "Invalid input" — and does it PER CALL, because the
+* config is mutable: `z.config({ localeError })` in an entry point runs after
+* the schema modules it imports, so a value snapshotted at module init misses
+* it. Reading a captured `localeError` alone also dropped `customError`
+* outright, silently ignoring the global map most i18n setups install.
+*
+* The head of zod's chain — the schema's own `error` option — is baked into the
+* issue at build time and short-circuits this. The one link that cannot be
+* reproduced is a per-CALL `ctx.error`, which would have to travel through
+* `safeParse`; that entry point sits at V8's inlining budget, where even an
+* unused extra parameter measured ~12% on every parse.
+*
+* Only ever called while building an error, never on a successful parse.
+*/
+const ZOD_MSG_DECLARATION = "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\";};";
 /**
- * File-level `__zcMsg` declaration (must appear once after ZOD_CONFIG_IMPORT):
- * the message an issue gets when nothing was baked into it at build time.
- *
- * Resolves zod's tail of `finalizeIssue` — `config.customError` then
- * `config.localeError` then "Invalid input" — and does it PER CALL, because the
- * config is mutable: `z.config({ localeError })` in an entry point runs after
- * the schema modules it imports, so a value snapshotted at module init misses
- * it. Reading a captured `localeError` alone also dropped `customError`
- * outright, silently ignoring the global map most i18n setups install.
- *
- * The head of zod's chain — the schema's own `error` option — is baked into the
- * issue at build time and short-circuits this. The one link that cannot be
- * reproduced is a per-CALL `ctx.error`, which would have to travel through
- * `safeParse`; that entry point sits at V8's inlining budget, where even an
- * unused extra parameter measured ~12% on every parse.
- *
- * Only ever called while building an error, never on a successful parse.
- */
-export const ZOD_MSG_DECLARATION = '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";};';
-/**
- * Shared failure-result for __zcFin / __zcFinD. Inline mode (CLI emitter)
- * declares it once per compiled file; lean mode (all unplugin bundlers) declares
- * it once per bundle in the plugin-materialized runtime module (module-local —
- * generated code only ever references __zcFin/__zcFinD, never __ZcFail).
- *
- * Why a prototype getter and not `{success:false, get error(){...}}`: an object
- * literal with an inline accessor forces V8 down its slow accessor-defining
- * allocation path — ~110ns per failure, measured — which dominates the entire
- * invalid-input cost whenever callers never read `.error`. Hosting `error` on
- * the prototype turns each failure into a plain field-only instantiation (~2ns,
- * ~13x), with the lazy-cache semantics intact. (Trade-off: `error` is a
- * prototype accessor, so it no longer shows up in `Object.keys(result)` / spread
- * / JSON.stringify of the result wrapper — `.success`/`.error`/`.data` access,
- * destructuring, and `in` are unaffected.)
- *
- * One class serves both finalizers, so the instances share one hidden class:
- * __zcFin passes pre-collected issues in `_e` (with `_f===null`); __zcFinD
- * passes the hosted slow-walk in `_f` plus the input in `_i`, and the getter
- * runs the walk on first `.error` read. The whole finalization — locale fill
- * (__zcMsg applied ONLY when an issue carries no message, never overwriting a
- * baked-in custom/fallback message), input strip, and ZodError construction
- * (zod v4 JSON.stringifies every issue into `message` and captures a stack
- * trace) — stays deferred inside the cached accessor exactly as before, since
- * the issues array is observable solely through `.error`.
- */
-export const FAIL_CLASS_DECL = "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]);e[i].input=undefined;}' +
-    "return this._c=new __zcZodError(e);}});";
+* Shared failure-result for __zcFin / __zcFinD. Inline mode (CLI emitter)
+* declares it once per compiled file; lean mode (all unplugin bundlers) declares
+* it once per bundle in the plugin-materialized runtime module (module-local —
+* generated code only ever references __zcFin/__zcFinD, never __ZcFail).
+*
+* Why a prototype getter and not `{success:false, get error(){...}}`: an object
+* literal with an inline accessor forces V8 down its slow accessor-defining
+* allocation path — ~110ns per failure, measured — which dominates the entire
+* invalid-input cost whenever callers never read `.error`. Hosting `error` on
+* the prototype turns each failure into a plain field-only instantiation (~2ns,
+* ~13x), with the lazy-cache semantics intact. (Trade-off: `error` is a
+* prototype accessor, so it no longer shows up in `Object.keys(result)` / spread
+* / JSON.stringify of the result wrapper — `.success`/`.error`/`.data` access,
+* destructuring, and `in` are unaffected.)
+*
+* One class serves both finalizers, so the instances share one hidden class:
+* __zcFin passes pre-collected issues in `_e` (with `_f===null`); __zcFinD
+* passes the hosted slow-walk in `_f` plus the input in `_i`, and the getter
+* runs the walk on first `.error` read. The whole finalization — locale fill
+* (__zcMsg applied ONLY when an issue carries no message, never overwriting a
+* baked-in custom/fallback message), input strip, and ZodError construction
+* (zod v4 JSON.stringifies every issue into `message` and captures a stack
+* trace) — stays deferred inside the cached accessor exactly as before, since
+* the issues array is observable solely through `.error`.
+*/
+const FAIL_CLASS_DECL = "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]);e[i].input=undefined;}return this._c=new __zcZodError(e);}});";
 /** Eager finalizer (mutation / partial-fast-path schemas): issues already
- * collected in `e`; success short-circuits to a plain result literal. */
-export const FIN_DECL = "function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}";
+* collected in `e`; success short-circuits to a plain result literal. */
+const FIN_DECL = "function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}";
 /**
- * Deferred-collection finalizer for Fast-Path-eligible schemas. When the
- * fast check fails, the ENTIRE slow path (the issue-collecting re-walk) is
- * pushed into the cached `.error` accessor instead of running eagerly:
- * fast-eligible schemas never mutate, so the walk's only output is the
- * issues array, which is observable solely through `.error` — one step
- * further along the same lazy boundary `__zcFin` already established (locale
- * fill, input strip, ZodError construction). A failed safeParse whose
- * `.error` is never read costs the fast check alone.
- *
- * Takes the schema's HOSTED slow-walk function plus the input — NOT a
- * per-call closure: `__zcFinD(__sw_N, input)` allocates only the result
- * object, where `__zcFinD(function(){...})` paid a closure environment and
- * function object per failure. Hosting the walk also shrinks safeParse to
- * two statements, within V8's inlining budget (the success-path result
- * literal becomes escape-analyzable at monomorphic call sites).
- *
- * The walk re-reads `input` at `.error`-read time; a caller that mutates
- * the input between safeParse and reading `.error` sees issues for the
- * mutated value (zod materializes at parse time). Same caveat class as the
- * documented __zcFin deferral.
- */
-export const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(null,f,inp);}";
+* Deferred-collection finalizer for Fast-Path-eligible schemas. When the
+* fast check fails, the ENTIRE slow path (the issue-collecting re-walk) is
+* pushed into the cached `.error` accessor instead of running eagerly:
+* fast-eligible schemas never mutate, so the walk's only output is the
+* issues array, which is observable solely through `.error` — one step
+* further along the same lazy boundary `__zcFin` already established (locale
+* fill, input strip, ZodError construction). A failed safeParse whose
+* `.error` is never read costs the fast check alone.
+*
+* Takes the schema's HOSTED slow-walk function plus the input — NOT a
+* per-call closure: `__zcFinD(__sw_N, input)` allocates only the result
+* object, where `__zcFinD(function(){...})` paid a closure environment and
+* function object per failure. Hosting the walk also shrinks safeParse to
+* two statements, within V8's inlining budget (the success-path result
+* literal becomes escape-analyzable at monomorphic call sites).
+*
+* The walk re-reads `input` at `.error`-read time; a caller that mutates
+* the input between safeParse and reading `.error` sees issues for the
+* mutated value (zod materializes at parse time). Same caveat class as the
+* documented __zcFin deferral.
+*/
+const FIN_DEFERRED_DECL = "function __zcFinD(f,inp){return new __ZcFail(null,f,inp);}";
 /**
- * Compact-mode failure class — a lazy failure that delegates error reporting to
- * the ORIGINAL Zod schema's `safeParse`. Used by `output: "compact"`, where the
- * compiled slow walk is dropped entirely: a mutation-free schema's fast check
- * is the only generated validation, and on a fast-check failure the cold error
- * 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
- * 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
- * on a TOTAL fast path: `fc(input) === false` ⟹ zod rejects, so `success:false`
- * holds without consulting zod.
- *
- * The getter returns zod's OWN ZodError verbatim (no locale fill / input strip /
- * re-wrap — zod already finalized it), so a delegated failure is exactly what
- * the unaltered schema would have produced.
- */
-export 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 failure class — a lazy failure that delegates error reporting to
+* the ORIGINAL Zod schema's `safeParse`. Used by `output: "compact"`, where the
+* compiled slow walk is dropped entirely: a mutation-free schema's fast check
+* is the only generated validation, and on a fast-check failure the cold error
+* 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
+* 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
+* on a TOTAL fast path: `fc(input) === false` ⟹ zod rejects, so `success:false`
+* holds without consulting zod.
+*
+* The getter returns zod's OWN ZodError verbatim (no locale fill / input strip /
+* 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. */
-export const FINZ_DECL = "function __zcFinZ(z,i){return new __ZcFailZ(z,i);}";
+const FINZ_DECL = "function __zcFinZ(z,i){return new __ZcFailZ(z,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
- * plugin-materialized runtime module — generated code never imports it from
- * the zod-compiler package itself, so zod-compiler stays a devDependency and
- * the helper set is always version-locked to the codegen that calls it.
- * Wraps a safeParse function into the CompiledSchema interface.
- *
- * IDENTITY-PRESERVING: with zodCompat (schema != null) the compiled
- * parse/safeParse/parseAsync/safeParseAsync are installed as OWN properties
- * on the original schema object, which is returned as-is. zod v4 keys
- * several APIs on object identity — toJSONSchema's ctx.seen registers the
- * object it is handed while each processor closure captures the original
- * inst (a wrapper crashes `optionalProcessor` with "Cannot set properties
- * of undefined (setting 'ref')" the moment a compiled schema is composed
- * into another schema), and globalRegistry/.meta() is a WeakMap keyed by
- * the schema instance (a wrapper silently loses OpenAPI titles/ids). An
- * Object.create wrapper breaks both; mutating the original breaks neither
- * (zod's internal parsing flows through _zod.run, never the public
- * methods, and derived schemas — .optional(), .extend() — are fresh
- * instances that fall back to plain zod). schema=null (zodCompat: false)
- * still produces a plain method-bag object.
- *
- * fc is the schema's hosted fast-check boolean function (null when no Fast
- * Path exists). parse()/parseAsync() try it first and return the input
- * directly on success: fc is small enough for V8 to inline, so the hot parse
- * path runs with zero allocations — calling fn would allocate an intermediate
- * SafeParseResult that escape analysis cannot remove (fn never inlines).
- * Fast-path-eligible schemas never mutate, so fc(input) ⟹ data === input.
- *
- * is is the TOTAL fast-check predicate (fc when the fast path is total, else
- * null). Installed as `.is()` — a zero-allocation boolean type guard. When
- * null (partial fast path or none) `.is()` derives from fn(input).success: a
- * partial fc can pass-through valid input but its `false` does not imply
- * rejection (a default/catch may still succeed), so it would be unsound as a
- * standalone guard.
- *
- * `~standard` is REPLACED, not merely preserved. Zod builds it lazily as
- * `validate: (v) => safeParse(inst, v)` — the core FUNCTION, which goes straight
- * to `inst._zod.run`. It never reads the schema's own `safeParse` property, so
- * installing the compiled one leaves this route entirely uncompiled: measured
- * 271.7 ns against the compiled 26.6 ns on the same schema, i.e. Standard Schema
- * consumers (tRPC, Hono, TanStack) were getting plain Zod.
- *
- * Zod's own validate is captured first and kept as the throw path: it catches a
- * synchronous throw and retries through `safeParseAsync`, which is how an async
- * refinement resolves and how a throwing check surfaces as a rejected promise
- * rather than a synchronous throw. The compiled validator cannot reproduce that
- * (async schemas delegate to Zod anyway), so deferring to the original is both
- * simpler and exact.
- *
- * Installed with defineProperty rather than assignment: Zod's lazy setter
- * redefines the slot as non-writable, so a second `__zcMkv` on the same schema
- * object — two exports aliasing one schema — would throw under ESM strict mode.
- */
-export const MK_VALIDATOR_DECL = "function __zcMkv(fn,schema,fc,is){var w=schema||{};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){return Promise.resolve(fn(input));};w.parseAsync=fc?function(input){if(fc(input))return Promise.resolve(input);var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}:function(input){var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);};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;}";
+* Validator factory. Inline mode (CLI emitter) declares it once per compiled
+* file; lean mode (all unplugin bundlers) exports it once per bundle from the
+* plugin-materialized runtime module — generated code never imports it from
+* the zod-compiler package itself, so zod-compiler stays a devDependency and
+* the helper set is always version-locked to the codegen that calls it.
+* Wraps a safeParse function into the CompiledSchema interface.
+*
+* IDENTITY-PRESERVING: with zodCompat (schema != null) the compiled
+* parse/safeParse/parseAsync/safeParseAsync are installed as OWN properties
+* on the original schema object, which is returned as-is. zod v4 keys
+* several APIs on object identity — toJSONSchema's ctx.seen registers the
+* object it is handed while each processor closure captures the original
+* inst (a wrapper crashes `optionalProcessor` with "Cannot set properties
+* of undefined (setting 'ref')" the moment a compiled schema is composed
+* into another schema), and globalRegistry/.meta() is a WeakMap keyed by
+* the schema instance (a wrapper silently loses OpenAPI titles/ids). An
+* Object.create wrapper breaks both; mutating the original breaks neither
+* (zod's internal parsing flows through _zod.run, never the public
+* methods, and derived schemas — .optional(), .extend() — are fresh
+* instances that fall back to plain zod). schema=null (zodCompat: false)
+* still produces a plain method-bag object.
+*
+* fc is the schema's hosted fast-check boolean function (null when no Fast
+* Path exists). parse()/parseAsync() try it first and return the input
+* directly on success: fc is small enough for V8 to inline, so the hot parse
+* path runs with zero allocations — calling fn would allocate an intermediate
+* SafeParseResult that escape analysis cannot remove (fn never inlines).
+* Fast-path-eligible schemas never mutate, so fc(input) ⟹ data === input.
+*
+* is is the TOTAL fast-check predicate (fc when the fast path is total, else
+* null). Installed as `.is()` — a zero-allocation boolean type guard. When
+* null (partial fast path or none) `.is()` derives from fn(input).success: a
+* partial fc can pass-through valid input but its `false` does not imply
+* rejection (a default/catch may still succeed), so it would be unsound as a
+* standalone guard.
+*
+* `~standard` is REPLACED, not merely preserved. Zod builds it lazily as
+* `validate: (v) => safeParse(inst, v)` — the core FUNCTION, which goes straight
+* to `inst._zod.run`. It never reads the schema's own `safeParse` property, so
+* installing the compiled one leaves this route entirely uncompiled: measured
+* 271.7 ns against the compiled 26.6 ns on the same schema, i.e. Standard Schema
+* consumers (tRPC, Hono, TanStack) were getting plain Zod.
+*
+* Zod's own validate is captured first and kept as the throw path: it catches a
+* synchronous throw and retries through `safeParseAsync`, which is how an async
+* refinement resolves and how a throwing check surfaces as a rejected promise
+* rather than a synchronous throw. The compiled validator cannot reproduce that
+* (async schemas delegate to Zod anyway), so deferring to the original is both
+* simpler and exact.
+*
+* Installed with defineProperty rather than assignment: Zod's lazy setter
+* redefines the slot as non-writable, so a second `__zcMkv` on the same schema
+* object — two exports aliasing one schema — would throw under ESM strict mode.
+*/
+const MK_VALIDATOR_DECL = "function __zcMkv(fn,schema,fc,is){var w=schema||{};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){return Promise.resolve(fn(input));};w.parseAsync=fc?function(input){if(fc(input))return Promise.resolve(input);var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}:function(input){var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);};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;}";
 function extractFunctionName(functionDef) {
-    const match = /^function\s+(\w+)\s*\(/.exec(functionDef);
-    if (!match?.[1]) {
-        throw new Error("Cannot extract function name from generated code");
-    }
-    return match[1];
+	const match = /^function\s+(\w+)\s*\(/.exec(functionDef);
+	if (!match?.[1]) throw new Error("Cannot extract function name from generated code");
+	return match[1];
 }
 /**
- * Generate a `/* @__PURE__ * /` IIFE wrapping a compiled validator.
- *
- * @param schemaExpr - Expression resolving to the original Zod schema
- *   (e.g. `"UserSchema"` in unplugin, `"(__src_X as any).schema"` in CLI)
- * @param schema
- * @param options
- */
-export function generateIIFE(schemaExpr, schema, options) {
-    const { codegenResult, refEntries } = schema;
-    const fnName = extractFunctionName(codegenResult.functionDef);
-    const zodCompat = options?.zodCompat !== false;
-    const schemaArg = zodCompat ? schemaExpr : "null";
-    const fcArg = codegenResult.fastFnName ?? "null";
-    // `.is()` gets the fast-check directly only when it is a total predicate;
-    // partial/none falls back to safeParse().success inside __zcMkv. A rebuilding
-    // schema has no by-reference `fc` but still names its predicate separately.
-    const isArg = codegenResult.isFnName ?? (codegenResult.fastTotal ? fcArg : "null");
-    return [
-        "/* @__PURE__ */ (() => {",
-        ...(refEntries.length > 0
-            ? [`var __rf=[${refEntries.map((fb) => `${schemaExpr}${fb.accessPath}`).join(",")}];`]
-            : []),
-        ...codegenResult.code
-            .split("\n")
-            .filter((l) => l.trim() !== "" && l.trim() !== "/* zod-compiler */"),
-        codegenResult.functionDef,
-        `return __zcMkv(${fnName},${schemaArg},${fcArg},${isArg});`,
-        "})()",
-    ].join("\n");
+* Generate a `/* @__PURE__ * /` IIFE wrapping a compiled validator.
+*
+* @param schemaExpr - Expression resolving to the original Zod schema
+*   (e.g. `"UserSchema"` in unplugin, `"(__src_X as any).schema"` in CLI)
+* @param schema
+* @param options
+*/
+function generateIIFE(schemaExpr, schema, options) {
+	const { codegenResult, refEntries } = schema;
+	const fnName = extractFunctionName(codegenResult.functionDef);
+	const schemaArg = options?.zodCompat !== false ? schemaExpr : "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(",")}];`] : [],
+		...codegenResult.code.split("\n").filter((l) => l.trim() !== "" && l.trim() !== "/* zod-compiler */"),
+		codegenResult.functionDef,
+		`return __zcMkv(${fnName},${schemaArg},${fcArg},${isArg});`,
+		"})()"
+	].join("\n");
 }
+//#endregion
+export { FAILZ_CLASS_DECL, FAIL_CLASS_DECL, FINZ_DECL, FIN_DECL, FIN_DEFERRED_DECL, MK_VALIDATOR_DECL, ZOD_CONFIG_IMPORT, ZOD_MSG_DECLARATION, generateIIFE };
+
 //# sourceMappingURL=iife.js.map

package/dist/core/iife.js.map

@@ -1 +1 @@
-{"version":3,"file":"iife.js","sourceRoot":"","sources":["../../src/core/iife.ts"],"names":[],"mappings":"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"}
+{"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: a superRefine\n * callback is reached through zod's wrapper, so an async one is only\n * detectable by the promise it returns, at which point zod's own synchronous\n * parse raises (see ZC_SR_DECL).\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 */\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]);e[i].input=undefined;}' +\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 * `~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||{};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){return Promise.resolve(fn(input));};w.parseAsync=fc?function(input){if(fc(input))return Promise.resolve(input);var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);}:function(input){var r=fn(input);if(r.success)return Promise.resolve(r.data);return Promise.reject(r.error);};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":";;;;;;;;AAcA,MAAa,oBACX;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,sBACX;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCF,MAAa,kBACX;;;AASF,MAAa,WACX;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;AAwBjC,MAAa,mBACX;;AAKF,MAAa,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDzB,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"}