zod-compiler 1.23.0 → 1.23.2

package/dist/core/codegen/context.js

@@ -1,490 +1,416 @@
-import { fastTestSource, lookupWellKnownRegex, wellKnownRegexSourceName, } from "./well-known-regex.js";
+import { fastTestSource, lookupWellKnownRegex, wellKnownRegexSourceName } from "./well-known-regex.js";
+//#region src/core/codegen/context.ts
 /** `var a,b;` declaration for a scope's temps, or "" when it allocated none. */
-export function declareFastTemps(scope) {
-    return scope.temps.length > 0 ? `var ${scope.temps.join(",")};` : "";
+function declareFastTemps(scope) {
+	return scope.temps.length > 0 ? `var ${scope.temps.join(",")};` : "";
 }
 /**
- * Fast check for a wrapper that compares its input against a sentinel and
- * otherwise delegates to an inner schema — `optional` (`===undefined`),
- * `nullable` (`===null`) and `default` (`!==undefined`).
- *
- * Written naively these read the input TWICE: once for the sentinel test and
- * again inside the inner check (which may itself read it several more times —
- * `typeof x==="string"&&x.length>=3&&x.length<=20`). V8's load elimination
- * removes the repeats only while the access is monomorphic; on the polymorphic
- * and megamorphic call sites real payloads produce (an array of objects with
- * differing key order, anything out of `JSON.parse`) every repeat is a fresh
- * megamorphic lookup. Binding the value to a local once is worth 1.1-1.7x on
- * the whole object check when the optional key is present, and is neutral when
- * it is absent.
- *
- * Only hoisted when the input is a property access; a bare local (an array
- * element variable, a record value) is already a single load, so it keeps the
- * shorter form and byte-identical output.
- */
-export function fastSentinelWrapper(g, innerIR, sentinel, joiner) {
-    if (!isPropertyAccess(g.input)) {
-        const inner = g.visit(innerIR);
-        return inner === null ? null : `(${g.input}${sentinel}${joiner}(${inner}))`;
-    }
-    const value = g.local("w");
-    const inner = g.visit(innerIR, { input: value });
-    if (inner === null)
-        return null;
-    return `((${value}=${g.input})${sentinel}${joiner}(${inner}))`;
+* Fast check for a wrapper that compares its input against a sentinel and
+* otherwise delegates to an inner schema — `optional` (`===undefined`),
+* `nullable` (`===null`) and `default` (`!==undefined`).
+*
+* Written naively these read the input TWICE: once for the sentinel test and
+* again inside the inner check (which may itself read it several more times —
+* `typeof x==="string"&&x.length>=3&&x.length<=20`). V8's load elimination
+* removes the repeats only while the access is monomorphic; on the polymorphic
+* and megamorphic call sites real payloads produce (an array of objects with
+* differing key order, anything out of `JSON.parse`) every repeat is a fresh
+* megamorphic lookup. Binding the value to a local once is worth 1.1-1.7x on
+* the whole object check when the optional key is present, and is neutral when
+* it is absent.
+*
+* Only hoisted when the input is a property access; a bare local (an array
+* element variable, a record value) is already a single load, so it keeps the
+* shorter form and byte-identical output.
+*/
+function fastSentinelWrapper(g, innerIR, sentinel, joiner) {
+	if (!isPropertyAccess(g.input)) {
+		const inner = g.visit(innerIR);
+		return inner === null ? null : `(${g.input}${sentinel}${joiner}(${inner}))`;
+	}
+	const value = g.local("w");
+	const inner = g.visit(innerIR, { input: value });
+	if (inner === null) return null;
+	return `((${value}=${g.input})${sentinel}${joiner}(${inner}))`;
 }
 /** True for an expression that performs a property load (`x["a"]`, `x.a`, `x[0][1]`). */
 function isPropertyAccess(expr) {
-    return expr.includes("[") || expr.includes(".");
+	return expr.includes("[") || expr.includes(".");
 }
-// ─── Shared emit helpers (used by both slow-path and fast-path factories) ────
 /** Allocate a fresh `__${prefix}_${n}` identifier and bump the shared counter. */
-export function emitTemp(ctx, prefix) {
-    return `__${prefix}_${ctx.counter++}`;
+function emitTemp(ctx, prefix) {
+	return `__${prefix}_${ctx.counter++}`;
 }
 /**
- * Host a zero-capture effect function (refine predicate, transform,
- * overwrite) in the preamble and return its variable name. The inline
- * `(${source})(x)` form evaluates the function expression — allocating a
- * function object — on EVERY parse at every effect site, including inside
- * the "zero-allocation" fast chain. V8's escape analysis erases that in
- * optimized frames, but interpreter/baseline/deopt frames pay it, and the
- * full source text re-parses as bytecode at each site. Zero-capture sources
- * reference only their own parameters and safe globals by construction, so
- * a single preamble binding is semantically identical. Deduped per schema
- * by source text.
- */
-export function emitEffectFn(ctx, source) {
-    ctx.effectFnCache ??= new Map();
-    const cached = ctx.effectFnCache.get(source);
-    if (cached !== undefined)
-        return cached;
-    const name = `__ef_${ctx.counter++}`;
-    ctx.preamble.push(`var ${name}=(${source});`);
-    ctx.effectFnCache.set(source, name);
-    return name;
+* Host a zero-capture effect function (refine predicate, transform,
+* overwrite) in the preamble and return its variable name. The inline
+* `(${source})(x)` form evaluates the function expression — allocating a
+* function object — on EVERY parse at every effect site, including inside
+* the "zero-allocation" fast chain. V8's escape analysis erases that in
+* optimized frames, but interpreter/baseline/deopt frames pay it, and the
+* full source text re-parses as bytecode at each site. Zero-capture sources
+* reference only their own parameters and safe globals by construction, so
+* a single preamble binding is semantically identical. Deduped per schema
+* by source text.
+*/
+function emitEffectFn(ctx, source) {
+	ctx.effectFnCache ??= /* @__PURE__ */ new Map();
+	const cached = ctx.effectFnCache.get(source);
+	if (cached !== void 0) return cached;
+	const name = `__ef_${ctx.counter++}`;
+	ctx.preamble.push(`var ${name}=(${source});`);
+	ctx.effectFnCache.set(source, name);
+	return name;
 }
 /**
- * Callable expression for a user callback — a refine predicate or a transform.
- *
- * A zero-capture callback is hosted from its source text; one that CAPTURES
- * outer variables is called by reference through `__rf[N]` — the user's own
- * function object, reached from the schema — instead of costing the schema its
- * compiled path. The reference is aliased into a preamble binding rather than
- * re-read per call, for the same reason call-invoked helpers are (a per-call
- * array element load is not a foldable callee).
- */
-export function emitEffectCallable(ctx, effect) {
-    if (effect.refIndex !== undefined)
-        return emitConstant(ctx, "rfn", `__rf[${effect.refIndex}]`);
-    if (effect.source === undefined) {
-        throw new Error("effect has neither inlineable source nor a reference index");
-    }
-    return emitEffectFn(ctx, effect.source);
+* Callable expression for a user callback — a refine predicate or a transform.
+*
+* A zero-capture callback is hosted from its source text; one that CAPTURES
+* outer variables is called by reference through `__rf[N]` — the user's own
+* function object, reached from the schema — instead of costing the schema its
+* compiled path. The reference is aliased into a preamble binding rather than
+* re-read per call, for the same reason call-invoked helpers are (a per-call
+* array element load is not a foldable callee).
+*/
+function emitEffectCallable(ctx, effect) {
+	if (effect.refIndex !== void 0) return emitConstant(ctx, "rfn", `__rf[${effect.refIndex}]`);
+	if (effect.source === void 0) throw new Error("effect has neither inlineable source nor a reference index");
+	return emitEffectFn(ctx, effect.source);
 }
 /**
- * Pristine fallback delegate: declare `var __rfp_N=__rf[N].safeParse.bind(__rf[N]);`
- * in the preamble and return the variable name. Generated code must NEVER read
- * `__rf[N].safeParse` at parse time: `__zcMkv` installs the compiled safeParse as
- * an OWN property on the original schema object, and whenever `__rf[N]` is that
- * same object the read resolves to the compiled delegate itself — infinite
- * recursion (RangeError on every parse). The fallback entry and the __zcMkv
- * target ARE the same object in compile mode (schemaExpr is the compile()
- * argument identifier) and the CLI emitter ((__src_X as any).schema); in
- * autoDiscover mode they are two textually identical constructions that any
- * downstream CSE/dedup transform (babel-plugin-zod-hoist in a field incident)
- * collapses back into one. Capturing at IIFE evaluation — before the trailing
- * `return __zcMkv(...)` mutates anything — pins zod's own implementation; the
- * worst case under cross-validator merges is delegating to an equivalent
- * compiled validator (whose own delegates were captured even earlier), never
- * a cycle.
- */
-export function emitRfDelegate(ctx, refIndex) {
-    const name = `__rfp_${refIndex}`;
-    const decl = `var ${name}=__rf[${refIndex}].safeParse.bind(__rf[${refIndex}]);`;
-    if (!ctx.preamble.includes(decl)) {
-        ctx.preamble.push(decl);
-    }
-    return name;
+* Pristine fallback delegate: declare `var __rfp_N=__rf[N].safeParse.bind(__rf[N]);`
+* in the preamble and return the variable name. Generated code must NEVER read
+* `__rf[N].safeParse` at parse time: `__zcMkv` installs the compiled safeParse as
+* an OWN property on the original schema object, and whenever `__rf[N]` is that
+* same object the read resolves to the compiled delegate itself — infinite
+* recursion (RangeError on every parse). The fallback entry and the __zcMkv
+* target ARE the same object in compile mode (schemaExpr is the compile()
+* argument identifier) and the CLI emitter ((__src_X as any).schema); in
+* autoDiscover mode they are two textually identical constructions that any
+* downstream CSE/dedup transform (babel-plugin-zod-hoist in a field incident)
+* collapses back into one. Capturing at IIFE evaluation — before the trailing
+* `return __zcMkv(...)` mutates anything — pins zod's own implementation; the
+* worst case under cross-validator merges is delegating to an equivalent
+* compiled validator (whose own delegates were captured even earlier), never
+* a cycle.
+*/
+function emitRfDelegate(ctx, refIndex) {
+	const name = `__rfp_${refIndex}`;
+	const decl = `var ${name}=__rf[${refIndex}].safeParse.bind(__rf[${refIndex}]);`;
+	if (!ctx.preamble.includes(decl)) ctx.preamble.push(decl);
+	return name;
 }
 /**
- * Resolve a regex pattern to a runtime variable name.
- * Lean mode short-circuits well-known patterns to virtual-module names so the
- * bundler can dedup across files; everything else is cached + declared in the
- * per-IIFE preamble exactly once per pattern.
- */
-export function emitRegex(ctx, prefix, pattern, flags) {
-    if (ctx.mode === "lean" && !flags) {
-        const wellKnown = lookupWellKnownRegex(pattern);
-        if (wellKnown !== null) {
-            ctx.usedHelpers.add(wellKnown);
-            return wellKnown;
-        }
-    }
-    const cacheKey = flags ? `${flags}\u0000${pattern}` : pattern;
-    const cached = ctx.regexCache.get(cacheKey);
-    if (cached)
-        return cached;
-    const name = `__re_${prefix}_${ctx.counter++}`;
-    const flagsArg = flags ? `,${escapeString(flags)}` : "";
-    // Flag-less patterns may carry a faster behavior-equivalent rewrite (a
-    // well-known table entry, repeat unrolling, or both); the regex OBJECT uses
-    // it while issue sites keep reporting the original pattern (see slowString).
-    const testSource = flags ? null : fastTestSource(pattern);
-    ctx.preamble.push(`var ${name}=new RegExp(${escapeString(testSource ?? pattern)}${flagsArg});`);
-    ctx.regexCache.set(cacheKey, name);
-    return name;
+* Resolve a regex pattern to a runtime variable name.
+* Lean mode short-circuits well-known patterns to virtual-module names so the
+* bundler can dedup across files; everything else is cached + declared in the
+* per-IIFE preamble exactly once per pattern.
+*/
+function emitRegex(ctx, prefix, pattern, flags) {
+	if (ctx.mode === "lean" && !flags) {
+		const wellKnown = lookupWellKnownRegex(pattern);
+		if (wellKnown !== null) {
+			ctx.usedHelpers.add(wellKnown);
+			return wellKnown;
+		}
+	}
+	const cacheKey = flags ? `${flags}\u0000${pattern}` : pattern;
+	const cached = ctx.regexCache.get(cacheKey);
+	if (cached) return cached;
+	const name = `__re_${prefix}_${ctx.counter++}`;
+	const flagsArg = flags ? `,${escapeString(flags)}` : "";
+	const testSource = flags ? null : fastTestSource(pattern);
+	ctx.preamble.push(`var ${name}=new RegExp(${escapeString(testSource ?? pattern)}${flagsArg});`);
+	ctx.regexCache.set(cacheKey, name);
+	return name;
 }
 /**
- * Resolve the ORIGINAL `/source/flags` pattern string of a regex for issue
- * reporting. Only needed when emitRegex swapped in a faster equivalent test
- * pattern (the runtime regex's toString() would leak the rewrite). Lean mode
- * references the shared `<name>Src` virtual export so the original pattern
- * stays a single bundle-wide string; inline mode declares it once per IIFE.
- */
-export function emitRegexSourceString(ctx, pattern) {
-    if (ctx.mode === "lean") {
-        const srcName = wellKnownRegexSourceName(pattern);
-        if (srcName !== null) {
-            ctx.usedHelpers.add(srcName);
-            return srcName;
-        }
-    }
-    const cacheKey = `src\u0000${pattern}`;
-    const cached = ctx.regexCache.get(cacheKey);
-    if (cached)
-        return cached;
-    const name = `__res_${ctx.counter++}`;
-    ctx.preamble.push(`var ${name}=${escapeString(`/${pattern}/`)};`);
-    ctx.regexCache.set(cacheKey, name);
-    return name;
+* Resolve the ORIGINAL `/source/flags` pattern string of a regex for issue
+* reporting. Only needed when emitRegex swapped in a faster equivalent test
+* pattern (the runtime regex's toString() would leak the rewrite). Lean mode
+* references the shared `<name>Src` virtual export so the original pattern
+* stays a single bundle-wide string; inline mode declares it once per IIFE.
+*/
+function emitRegexSourceString(ctx, pattern) {
+	if (ctx.mode === "lean") {
+		const srcName = wellKnownRegexSourceName(pattern);
+		if (srcName !== null) {
+			ctx.usedHelpers.add(srcName);
+			return srcName;
+		}
+	}
+	const cacheKey = `src\u0000${pattern}`;
+	const cached = ctx.regexCache.get(cacheKey);
+	if (cached) return cached;
+	const name = `__res_${ctx.counter++}`;
+	ctx.preamble.push(`var ${name}=${escapeString(`/${pattern}/`)};`);
+	ctx.regexCache.set(cacheKey, name);
+	return name;
 }
 /**
- * Declare a constant value in the preamble and return its variable name,
- * reusing an earlier declaration of the SAME initializer.
- *
- * Value tables are reached from both halves of a validator — an enum's `Set`
- * from its fast check and again from its slow walk, a strict shape's key table
- * likewise — and repeat across sibling properties that share a value list. One
- * declaration per USE emitted the payload two or four times: measured 17% of a
- * 20-value enum schema's generated bytes, 16% for an object with two identical
- * enums. Keyed by initializer text, so only identical payloads collapse.
- */
-export function emitConstant(ctx, prefix, initializer) {
-    ctx.valueCache ??= new Map();
-    const cached = ctx.valueCache.get(initializer);
-    if (cached !== undefined)
-        return cached;
-    const name = `__${prefix}_${ctx.counter++}`;
-    ctx.preamble.push(`var ${name}=${initializer};`);
-    ctx.valueCache.set(initializer, name);
-    return name;
+* Declare a constant value in the preamble and return its variable name,
+* reusing an earlier declaration of the SAME initializer.
+*
+* Value tables are reached from both halves of a validator — an enum's `Set`
+* from its fast check and again from its slow walk, a strict shape's key table
+* likewise — and repeat across sibling properties that share a value list. One
+* declaration per USE emitted the payload two or four times: measured 17% of a
+* 20-value enum schema's generated bytes, 16% for an object with two identical
+* enums. Keyed by initializer text, so only identical payloads collapse.
+*/
+function emitConstant(ctx, prefix, initializer) {
+	ctx.valueCache ??= /* @__PURE__ */ new Map();
+	const cached = ctx.valueCache.get(initializer);
+	if (cached !== void 0) return cached;
+	const name = `__${prefix}_${ctx.counter++}`;
+	ctx.preamble.push(`var ${name}=${initializer};`);
+	ctx.valueCache.set(initializer, name);
+	return name;
 }
 /** Declare a `new Set([...])` in the preamble and return its variable name. */
-export function emitSet(ctx, prefix, values) {
-    return emitConstant(ctx, `set_${prefix}`, `new Set(${JSON.stringify([...values])})`);
+function emitSet(ctx, prefix, values) {
+	return emitConstant(ctx, `set_${prefix}`, `new Set(${JSON.stringify([...values])})`);
 }
 /**
- * Shape-key count at or below which the unknown-key pass compares with an
- * inline `===` chain rather than a hashed lookup.
- *
- * This is deliberately NOT {@link ENUM_INLINE_THRESHOLD}: the two look alike but
- * are different workloads. An enum compares schema literals against arbitrary
- * INPUT strings, which may be long, share prefixes, and are not necessarily
- * internalized — so a hashed set earns its keep quickly. A shape-key test
- * compares them against keys arriving from `for-in`, i.e. the object's own
- * internalized key strings, so every arm of the chain is a pointer compare that
- * V8 predicts perfectly, while `table[k]` / `set.has(k)` pays a string hash and
- * probe per key.
- *
- * Measured over a strict object's for-in pass (JSON-parsed input, 8 rotated
- * shapes), `===` chain vs the previous `{k:1}` table: 3.7x at 6 keys, 3.8x at
- * 10, 3.1x at 20, 3.1x at 48 — the chain still leads at 64 (283 ns vs 690) and
- * only loses past ~96, where `Set.has` (not the table, which never wins at any
- * size) takes over. 64 sits below that crossover and above any realistic shape.
- */
-export const KEY_MEMBERSHIP_INLINE_THRESHOLD = 64;
+* Shape-key count at or below which the unknown-key pass compares with an
+* inline `===` chain rather than a hashed lookup.
+*
+* This is deliberately NOT {@link ENUM_INLINE_THRESHOLD}: the two look alike but
+* are different workloads. An enum compares schema literals against arbitrary
+* INPUT strings, which may be long, share prefixes, and are not necessarily
+* internalized — so a hashed set earns its keep quickly. A shape-key test
+* compares them against keys arriving from `for-in`, i.e. the object's own
+* internalized key strings, so every arm of the chain is a pointer compare that
+* V8 predicts perfectly, while `table[k]` / `set.has(k)` pays a string hash and
+* probe per key.
+*
+* Measured over a strict object's for-in pass (JSON-parsed input, 8 rotated
+* shapes), `===` chain vs the previous `{k:1}` table: 3.7x at 6 keys, 3.8x at
+* 10, 3.1x at 20, 3.1x at 48 — the chain still leads at 64 (283 ns vs 690) and
+* only loses past ~96, where `Set.has` (not the table, which never wins at any
+* size) takes over. 64 sits below that crossover and above any realistic shape.
+*/
+const KEY_MEMBERSHIP_INLINE_THRESHOLD = 64;
 /**
- * Boolean membership test for one key variable against a fixed key list.
- * Empty list recognizes nothing.
- *
- * `Set.has` is the large-shape fallback rather than a `{key:1}` object table:
- * the table is also `__proto__`-hostile (an own `__proto__` key cannot be set
- * by an object literal, so that key would silently read as unknown), which the
- * Set has no trouble with.
- */
-export function keyMembershipTest(ctx, keys, keyVar) {
-    if (keys.length === 0)
-        return "false";
-    if (keys.length <= KEY_MEMBERSHIP_INLINE_THRESHOLD) {
-        return keys.map((k) => `${keyVar}===${escapeString(k)}`).join("||");
-    }
-    return `${emitSet(ctx, "ks", keys)}.has(${keyVar})`;
+* Boolean membership test for one key variable against a fixed key list.
+* Empty list recognizes nothing.
+*
+* `Set.has` is the large-shape fallback rather than a `{key:1}` object table:
+* the table is also `__proto__`-hostile (an own `__proto__` key cannot be set
+* by an object literal, so that key would silently read as unknown), which the
+* Set has no trouble with.
+*/
+function keyMembershipTest(ctx, keys, keyVar) {
+	if (keys.length === 0) return "false";
+	if (keys.length <= 64) return keys.map((k) => `${keyVar}===${escapeString(k)}`).join("||");
+	return `${emitSet(ctx, "ks", keys)}.has(${keyVar})`;
 }
 /**
- * Enum values at or below this count use inline === checks instead of Set.has().
- * Measured on V8: for ≤5 values, an === chain beats Set.has by up to ~3x with
- * realistic (distinct-prefix, JSON-parsed) values — V8 internalizes strings on
- * successful comparison, making subsequent arms pointer-equality — and is no
- * worse than Set.has even with adversarial shared-prefix values.
- */
-export const ENUM_INLINE_THRESHOLD = 5;
+* Enum values at or below this count use inline === checks instead of Set.has().
+* Measured on V8: for ≤5 values, an === chain beats Set.has by up to ~3x with
+* realistic (distinct-prefix, JSON-parsed) values — V8 internalizes strings on
+* successful comparison, making subsequent arms pointer-equality — and is no
+* worse than Set.has even with adversarial shared-prefix values.
+*/
+const ENUM_INLINE_THRESHOLD = 5;
 const CHECK_PRIORITY = {
-    // Cheapest: length/size comparisons (O(1))
-    min_length: 10,
-    max_length: 11,
-    length_equals: 12,
-    min_size: 13,
-    max_size: 14,
-    // Number format checks (comparison + bitwise)
-    number_format: 15,
-    // Range comparisons
-    greater_than: 20,
-    less_than: 21,
-    bigint_greater_than: 20,
-    bigint_less_than: 21,
-    date_greater_than: 22,
-    date_less_than: 23,
-    // Modulo
-    multiple_of: 30,
-    bigint_multiple_of: 30,
-    // String prefix/suffix (O(prefix/suffix length))
-    starts_with: 40,
-    ends_with: 41,
-    // String search (O(n·m) worst case)
-    includes: 42,
-    // Regex (most expensive)
-    string_format: 50,
+	min_length: 10,
+	max_length: 11,
+	length_equals: 12,
+	min_size: 13,
+	max_size: 14,
+	number_format: 15,
+	greater_than: 20,
+	less_than: 21,
+	bigint_greater_than: 20,
+	bigint_less_than: 21,
+	date_greater_than: 22,
+	date_less_than: 23,
+	multiple_of: 30,
+	bigint_multiple_of: 30,
+	starts_with: 40,
+	ends_with: 41,
+	includes: 42,
+	string_format: 50
 };
-export function escapeString(s) {
-    return JSON.stringify(s);
+function escapeString(s) {
+	return JSON.stringify(s);
 }
 /**
- * JS source for a primitive literal value (literal schemas, discriminator
- * case labels). JSON.stringify covers string/number/boolean/null; bigint
- * needs the `n` suffix (JSON.stringify throws and String(5n) renders a
- * number literal that never strict-equals a bigint); undefined isn't JSON.
- */
-export function literalToJs(v) {
-    if (typeof v === "bigint")
-        return `${v}n`;
-    if (v === undefined)
-        return "undefined";
-    // JSON.stringify maps NaN/±Infinity to "null"; emit them as JS expressions so a
-    // non-finite numeric literal round-trips (z.literal(Infinity) must compare
-    // against Infinity, not null). String(NaN)="NaN", String(Infinity)="Infinity",
-    // String(-Infinity)="-Infinity" — all valid JS that evaluate to the value.
-    if (typeof v === "number" && !Number.isFinite(v))
-        return String(v);
-    return JSON.stringify(v);
+* JS source for a primitive literal value (literal schemas, discriminator
+* case labels). JSON.stringify covers string/number/boolean/null; bigint
+* needs the `n` suffix (JSON.stringify throws and String(5n) renders a
+* number literal that never strict-equals a bigint); undefined isn't JSON.
+*/
+function literalToJs(v) {
+	if (typeof v === "bigint") return `${v}n`;
+	if (v === void 0) return "undefined";
+	if (typeof v === "number" && !Number.isFinite(v)) return String(v);
+	return JSON.stringify(v);
 }
 /**
- * Helpers that generated code invokes through `Function.prototype.call`, and
- * which therefore must be aliased into a module-local binding in lean mode.
- *
- * V8 folds a local `const` callee into a constant and inlines straight through
- * `x.call(...)`; an IMPORTED binding is a cell it will not fold, so the same
- * expression stays a generic property load plus a generic call — measured 4.5x
- * (5 keys) to 6.5x (20 keys) slower on the record fast path, 35.9 ns vs 7.2 ns
- * for a 5-key record. Aliasing the import into the IIFE recovers all of it
- * (7.4 ns). A DIRECT call to an imported function (`__zcFsr(v,s)`) is not
- * penalized — measured identical — and neither is an imported RegExp receiver,
- * so only the `.call` sites are listed here.
- */
-const CALL_INVOKED_HELPERS = new Set(["__zcHop"]);
+* Helpers that generated code invokes through `Function.prototype.call`, and
+* which therefore must be aliased into a module-local binding in lean mode.
+*
+* V8 folds a local `const` callee into a constant and inlines straight through
+* `x.call(...)`; an IMPORTED binding is a cell it will not fold, so the same
+* expression stays a generic property load plus a generic call — measured 4.5x
+* (5 keys) to 6.5x (20 keys) slower on the record fast path, 35.9 ns vs 7.2 ns
+* for a 5-key record. Aliasing the import into the IIFE recovers all of it
+* (7.4 ns). A DIRECT call to an imported function (`__zcFsr(v,s)`) is not
+* penalized — measured identical — and neither is an imported RegExp receiver,
+* so only the `.call` sites are listed here.
+*/
+const CALL_INVOKED_HELPERS = /* @__PURE__ */ new Set(["__zcHop"]);
 /**
- * Reference a shared runtime helper (e.g. __zcFsr) from generated code.
- * Lean mode: registers it for the `virtual:zod-compiler/runtime` import.
- * Inline mode: declares it once in the per-IIFE preamble.
- */
-export function emitRuntimeHelper(ctx, name, decl) {
-    if (ctx.mode === "lean") {
-        ctx.usedHelpers.add(name);
-        if (CALL_INVOKED_HELPERS.has(name))
-            return emitConstant(ctx, "lh", name);
-    }
-    else if (!ctx.preamble.includes(decl)) {
-        ctx.preamble.push(decl);
-    }
-    return name;
+* Reference a shared runtime helper (e.g. __zcFsr) from generated code.
+* Lean mode: registers it for the `virtual:zod-compiler/runtime` import.
+* Inline mode: declares it once in the per-IIFE preamble.
+*/
+function emitRuntimeHelper(ctx, name, decl) {
+	if (ctx.mode === "lean") {
+		ctx.usedHelpers.add(name);
+		if (CALL_INVOKED_HELPERS.has(name)) return emitConstant(ctx, "lh", name);
+	} else if (!ctx.preamble.includes(decl)) ctx.preamble.push(decl);
+	return name;
 }
 /**
- * Extend a path expression with one or more scalar segment expressions
- * (escaped string literals, numeric literals, or loop-variable names).
- *
- * Path expressions are only ever composed by these helpers starting from the
- * `[]` root, so any path that looks like an array literal IS one — the new
- * segment is spliced in to keep issue paths a single array allocation
- * (`["data","items",__i_7]`) instead of an allocation per nesting level
- * (`["data"].concat("items").concat(__i_7)`). Opaque expressions fall back
- * to .concat().
- */
-export function extendPath(parentPath, segExpr) {
-    if (parentPath === "[]")
-        return `[${segExpr}]`;
-    if (parentPath.startsWith("[") && parentPath.endsWith("]")) {
-        return `${parentPath.slice(0, -1)},${segExpr}]`;
-    }
-    return `${parentPath}.concat(${segExpr})`;
+* Extend a path expression with one or more scalar segment expressions
+* (escaped string literals, numeric literals, or loop-variable names).
+*
+* Path expressions are only ever composed by these helpers starting from the
+* `[]` root, so any path that looks like an array literal IS one — the new
+* segment is spliced in to keep issue paths a single array allocation
+* (`["data","items",__i_7]`) instead of an allocation per nesting level
+* (`["data"].concat("items").concat(__i_7)`). Opaque expressions fall back
+* to .concat().
+*/
+function extendPath(parentPath, segExpr) {
+	if (parentPath === "[]") return `[${segExpr}]`;
+	if (parentPath.startsWith("[") && parentPath.endsWith("]")) return `${parentPath.slice(0, -1)},${segExpr}]`;
+	return `${parentPath}.concat(${segExpr})`;
 }
 /** Extend a path expression with a static string key. */
-export function extendStaticPath(parentPath, key) {
-    return extendPath(parentPath, escapeString(key));
+function extendStaticPath(parentPath, key) {
+	return extendPath(parentPath, escapeString(key));
 }
 /** Extend a path expression with a numeric index. */
-export function extendStaticPathIndex(parentPath, index) {
-    return extendPath(parentPath, String(index));
+function extendStaticPathIndex(parentPath, index) {
+	return extendPath(parentPath, String(index));
 }
 /**
- * A superRefine callback receives zod's payload, whose `value` is public,
- * typed, writable API ($RefinementCtx extends ParsePayload) — so any node
- * carrying one MAY rewrite its value and must be treated as mutating. Which
- * callbacks actually do is undecidable here; the emitted fast check settles it
- * at runtime by refusing when the value changed (see ZC_SR_OK_DECL), so a
- * non-mutating callback still exits through the fast path.
- */
+* A superRefine callback receives zod's payload, whose `value` is public,
+* typed, writable API ($RefinementCtx extends ParsePayload) — so any node
+* carrying one MAY rewrite its value and must be treated as mutating. Which
+* callbacks actually do is undecidable here; the emitted fast check settles it
+* at runtime by refusing when the value changed (see ZC_SR_OK_DECL), so a
+* non-mutating callback still exits through the fast path.
+*/
 function hasSuperRefine(checks) {
-    return checks !== undefined && checks.some((c) => c.kind === "super_refine_effect");
+	return checks !== void 0 && checks.some((c) => c.kind === "super_refine_effect");
 }
 /**
- * Check if a SchemaIR tree produces output that is not the input itself —
- * either value-mutating operations (coerce, default, catch, overwrite) that
- * write back to the input expression, or a strip object that rebuilds a fresh
- * object from its known keys. Used by container generators to decide whether to
- * clone (so the rebuilt/mutated value never writes through to the caller's
- * input), by generateValidator to keep such schemas off the by-reference fast
- * path, and by the shared-walk dedup + intersection extractor to exclude them.
- */
-export function hasMutation(ir) {
-    switch (ir.type) {
-        case "string":
-            // url checks trim (and optionally normalize) the value; overwrite
-            // effects (.trim(), .toLowerCase()) rewrite it.
-            return (ir.coerce === true ||
-                hasSuperRefine(ir.checks) ||
-                ir.checks.some((c) => c.kind === "overwrite_effect" || (c.kind === "string_format" && c.format === "url")));
-        case "number":
-            return ir.coerce === true || hasSuperRefine(ir.checks);
-        case "boolean":
-        case "bigint":
-        case "date":
-            return ir.coerce === true;
-        case "default":
-        case "catch":
-        case "effect":
-        case "fallback":
-        case "stringBool":
-            return true;
-        case "object":
-            // A strip object produces a FRESH output (only the declared keys), so it
-            // mutates: parents must clone before it writes back, it never takes the
-            // by-reference fast path, and intersections of strip objects delegate to
-            // zod (see extractIntersection's hasMutation guard) — matching zod's
-            // parse-both-sides-then-merge semantics instead of over-stripping.
-            return (ir.stripUnknownKeys === true ||
-                hasSuperRefine(ir.checks) ||
-                (ir.catchall !== undefined && hasMutation(ir.catchall)) ||
-                Object.values(ir.properties).some((p) => hasMutation(p)));
-        case "array":
-            return hasSuperRefine(ir.checks) || hasMutation(ir.element);
-        case "tuple":
-            return ir.items.some(hasMutation) || (ir.rest !== null && hasMutation(ir.rest));
-        case "record":
-            return hasMutation(ir.valueType);
-        case "optional":
-        case "nullable":
-        case "readonly":
-        case "recursionTarget":
-            return hasMutation(ir.inner);
-        case "union":
-        case "discriminatedUnion":
-            return ir.options.some(hasMutation);
-        case "intersection":
-            return hasMutation(ir.left) || hasMutation(ir.right);
-        case "pipe":
-            return hasMutation(ir.in) || hasMutation(ir.out);
-        case "set":
-            return hasMutation(ir.valueType);
-        case "map":
-            return hasMutation(ir.keyType) || hasMutation(ir.valueType);
-        case "file":
-            return false;
-        default:
-            return false;
-    }
+* Check if a SchemaIR tree produces output that is not the input itself —
+* either value-mutating operations (coerce, default, catch, overwrite) that
+* write back to the input expression, or a strip object that rebuilds a fresh
+* object from its known keys. Used by container generators to decide whether to
+* clone (so the rebuilt/mutated value never writes through to the caller's
+* input), by generateValidator to keep such schemas off the by-reference fast
+* path, and by the shared-walk dedup + intersection extractor to exclude them.
+*/
+function hasMutation(ir) {
+	switch (ir.type) {
+		case "string": return ir.coerce === true || hasSuperRefine(ir.checks) || ir.checks.some((c) => c.kind === "overwrite_effect" || c.kind === "string_format" && c.format === "url");
+		case "number": return ir.coerce === true || hasSuperRefine(ir.checks);
+		case "boolean":
+		case "bigint":
+		case "date": return ir.coerce === true;
+		case "default":
+		case "catch":
+		case "effect":
+		case "fallback":
+		case "stringBool": return true;
+		case "object": return ir.stripUnknownKeys === true || hasSuperRefine(ir.checks) || ir.catchall !== void 0 && hasMutation(ir.catchall) || Object.values(ir.properties).some((p) => hasMutation(p));
+		case "array": return hasSuperRefine(ir.checks) || hasMutation(ir.element);
+		case "tuple": return ir.items.some(hasMutation) || ir.rest !== null && hasMutation(ir.rest);
+		case "record": return hasMutation(ir.valueType);
+		case "optional":
+		case "nullable":
+		case "readonly":
+		case "recursionTarget": return hasMutation(ir.inner);
+		case "union":
+		case "discriminatedUnion": return ir.options.some(hasMutation);
+		case "intersection": return hasMutation(ir.left) || hasMutation(ir.right);
+		case "pipe": return hasMutation(ir.in) || hasMutation(ir.out);
+		case "set": return hasMutation(ir.valueType);
+		case "map": return hasMutation(ir.keyType) || hasMutation(ir.valueType);
+		case "file": return false;
+		default: return false;
+	}
 }
 /**
- * Is a defaulted property's key guaranteed to appear in the stripped output?
- *
- * Distinct from {@link rejectsUndefined}, which asks whether `undefined` is
- * REJECTED — a `.default()` accepts it and yet still produces a defined value, so
- * only this question earns the key a slot in the output object literal. The two
- * answers coincide everywhere else.
- *
- * Sound for both branches of a default: the substituted value is defined
- * (`alwaysDefined`, checked against the schema at extraction time), and the inner
- * branch runs only when `input[key] !== undefined`, which implies `key in input`
- * — so zod's presence test keeps the key whatever the inner produced.
- */
-export function outputAlwaysDefined(ir) {
-    return ir.type === "default" ? ir.alwaysDefined === true : rejectsUndefined(ir);
+* Is a defaulted property's key guaranteed to appear in the stripped output?
+*
+* Distinct from {@link rejectsUndefined}, which asks whether `undefined` is
+* REJECTED — a `.default()` accepts it and yet still produces a defined value, so
+* only this question earns the key a slot in the output object literal. The two
+* answers coincide everywhere else.
+*
+* Sound for both branches of a default: the substituted value is defined
+* (`alwaysDefined`, checked against the schema at extraction time), and the inner
+* branch runs only when `input[key] !== undefined`, which implies `key in input`
+* — so zod's presence test keeps the key whatever the inner produced.
+*/
+function outputAlwaysDefined(ir) {
+	return ir.type === "default" ? ir.alwaysDefined === true : rejectsUndefined(ir);
 }
 /**
- * Does this schema reject `undefined` outright?
- *
- * Read as "can this slot be ABSENT from the input" by the tuple build, whose
- * output length depends on it — zod marks a defaulted or optional item
- * `optin: "optional"` and accepts a shorter array. Conservative: anything that
- * might accept, produce, or default to `undefined` answers false.
- */
-export function rejectsUndefined(ir) {
-    switch (ir.type) {
-        // Coercion turns undefined into a value (`String(undefined)`), so a
-        // coercing primitive is NOT a rejector.
-        case "string":
-        case "number":
-        case "boolean":
-        case "bigint":
-        case "date":
-            return ir.coerce !== true;
-        case "symbol":
-        case "null":
-        case "nan":
-        case "never":
-        case "enum":
-        case "object":
-        case "array":
-        case "tuple":
-        case "record":
-        case "set":
-        case "map":
-        case "file":
-        case "templateLiteral":
-        case "discriminatedUnion":
-        case "stringBool":
-            return true;
-        case "literal":
-            return !ir.values.includes(undefined);
-        case "union":
-            return ir.options.every(rejectsUndefined);
-        case "intersection":
-            return rejectsUndefined(ir.left) || rejectsUndefined(ir.right);
-        case "nullable":
-        case "readonly":
-        case "recursionTarget":
-            return rejectsUndefined(ir.inner);
-        default:
-            // optional / any / unknown / undefined / void / default / catch /
-            // fallback / effect / pipe / recursiveRef — each can yield undefined,
-            // or is opaque enough that we must not assume otherwise.
-            return false;
-    }
+* Does this schema reject `undefined` outright?
+*
+* Read as "can this slot be ABSENT from the input" by the tuple build, whose
+* output length depends on it — zod marks a defaulted or optional item
+* `optin: "optional"` and accepts a shorter array. Conservative: anything that
+* might accept, produce, or default to `undefined` answers false.
+*/
+function rejectsUndefined(ir) {
+	switch (ir.type) {
+		case "string":
+		case "number":
+		case "boolean":
+		case "bigint":
+		case "date": return ir.coerce !== true;
+		case "symbol":
+		case "null":
+		case "nan":
+		case "never":
+		case "enum":
+		case "object":
+		case "array":
+		case "tuple":
+		case "record":
+		case "set":
+		case "map":
+		case "file":
+		case "templateLiteral":
+		case "discriminatedUnion":
+		case "stringBool": return true;
+		case "literal": return !ir.values.includes(void 0);
+		case "union": return ir.options.every(rejectsUndefined);
+		case "intersection": return rejectsUndefined(ir.left) || rejectsUndefined(ir.right);
+		case "nullable":
+		case "readonly":
+		case "recursionTarget": return rejectsUndefined(ir.inner);
+		default: return false;
+	}
 }
 /**
- * Sort comparator for CheckIR: cheapest/most-discriminating checks first.
- * Used by fast-path generators after filtering out refine_effect entries.
- */
-export function checkPriority(a, b) {
-    return (CHECK_PRIORITY[a.kind] ?? 99) - (CHECK_PRIORITY[b.kind] ?? 99);
+* Sort comparator for CheckIR: cheapest/most-discriminating checks first.
+* Used by fast-path generators after filtering out refine_effect entries.
+*/
+function checkPriority(a, b) {
+	return (CHECK_PRIORITY[a.kind] ?? 99) - (CHECK_PRIORITY[b.kind] ?? 99);
 }
+//#endregion
+export { ENUM_INLINE_THRESHOLD, KEY_MEMBERSHIP_INLINE_THRESHOLD, checkPriority, declareFastTemps, emitConstant, emitEffectCallable, emitEffectFn, emitRegex, emitRegexSourceString, emitRfDelegate, emitRuntimeHelper, emitSet, emitTemp, escapeString, extendPath, extendStaticPath, extendStaticPathIndex, fastSentinelWrapper, hasMutation, keyMembershipTest, literalToJs, outputAlwaysDefined, rejectsUndefined };
+
 //# sourceMappingURL=context.js.map