zod-compiler 1.23.0 → 1.23.2

package/dist/core/codegen/schemas/discriminated-union.js

@@ -1,205 +1,180 @@
-import { declareFastTemps, emitConstant, escapeString, extendPath, hasMutation, literalToJs, } from "../context.js";
+import { declareFastTemps, emitConstant, escapeString, extendPath, hasMutation, literalToJs } from "../context.js";
 import { emit } from "../emit.js";
 import { invalidType } from "../emit-issue.js";
-export function slowDiscriminatedUnion(ir, g) {
-    const discKey = escapeString(ir.discriminator);
-    let code = emit `
+//#region src/core/codegen/schemas/discriminated-union.ts
+function slowDiscriminatedUnion(ir, g) {
+	const discKey = escapeString(ir.discriminator);
+	let code = emit`
     if(typeof ${g.input}!=="object"||${g.input}===null||Array.isArray(${g.input})){
       ${invalidType(g, "object")}
     }else{`;
-    const objVar = g.temp("du");
-    code += `var ${objVar}=${g.input};switch(${objVar}[${discKey}]){`;
-    for (const { value, option: index } of ir.cases) {
-        const option = ir.options[index];
-        code += emit `
+	const objVar = g.temp("du");
+	code += `var ${objVar}=${g.input};switch(${objVar}[${discKey}]){`;
+	for (const { value, option: index } of ir.cases) {
+		const option = ir.options[index];
+		code += emit`
       case ${literalToJs(value)}:
-        ${g.visit(option, { input: objVar, output: objVar })}
+        ${g.visit(option, {
+			input: objVar,
+			output: objVar
+		})}
         break;`;
-    }
-    const validValues = ir.cases.map((c) => literalToJs(c.value)).join(",");
-    const msgProp = g.typeMsg === undefined ? "" : `,message:${JSON.stringify(g.typeMsg)}`;
-    code += emit `
+	}
+	const validValues = ir.cases.map((c) => literalToJs(c.value)).join(",");
+	const msgProp = g.typeMsg === void 0 ? "" : `,message:${JSON.stringify(g.typeMsg)}`;
+	code += emit`
     default:
       ${g.issues}.push({code:"invalid_union",errors:[],note:"No matching discriminator",discriminator:${discKey},options:[${validValues}]${msgProp},input:${g.input},path:${extendPath(g.path, discKey)}});
     }`;
-    // Propagate option-applied mutations (defaults, coercions, transforms,
-    // overwrite checks, stringbool) back to the output location. Each option is
-    // visited with output:objVar — a fresh local — so a mutating option's clone is
-    // reassigned into objVar and stranded there; without this write-back the caller
-    // returns the ORIGINAL input by reference and the mutation is silently lost.
-    // Gated on mutation so a pure-validation union stays a zero-write pass-through
-    // (objVar still aliases the input). On the no-match/failure paths objVar equals
-    // the input, so the write is a harmless self-assignment.
-    if (ir.options.some(hasMutation)) {
-        code += `${g.output}=${objVar};`;
-    }
-    code += `}`;
-    return `${code}\n`;
+	if (ir.options.some(hasMutation)) code += `${g.output}=${objVar};`;
+	code += `}`;
+	return `${code}\n`;
 }
 /**
- * Emit an O(1) switch-dispatch fast-check for a discriminated union — real
- * (`z.discriminatedUnion`) or one detected inside a plain `z.union`
- * (see {@link detectUnionDiscriminator}). Both share this so the detected case
- * inherits the size-gating and the per-case guard strip.
- *
- * `discSkipKey` tells each object option to drop its own type-guard and
- * discriminator re-check: the caller's guard (`typeof x==="object"&&…` below)
- * already proved object-ness, and the matched switch case has fixed the
- * discriminator value, so re-emitting either is pure redundancy the optimizer
- * only removes when it inlines this helper — which a union large enough to
- * matter won't. Routed through the normal `visit` so size-gated extraction
- * still bounds the switch (the strip survives into any hoisted helper);
- * non-object options ignore the hint and keep their own guard.
- *
- * Returns null if any option is fast-path-ineligible.
- */
-export function emitFastDiscriminatedSwitch(g, discriminator, cases, options) {
-    const x = g.input;
-    const discKey = escapeString(discriminator);
-    const helperName = g.temp("du");
-    const helperParam = g.temp("dx");
-    // The switch body is its own function: size-gate the options against the cap
-    // in a fresh scope, otherwise many small options accumulate into the caller's
-    // scope while this helper itself grows unbounded past the TurboFan budget.
-    const body = g.scoped(helperParam);
-    const table = stringDispatchTable(cases);
-    if (table === null) {
-        const caseStrs = [];
-        for (const { value, option: index } of cases) {
-            const check = body.visit(options[index], { discSkipKey: discriminator });
-            if (check === null)
-                return null;
-            caseStrs.push(`case ${literalToJs(value)}:return ${check};`);
-        }
-        g.ctx.preamble.push(`function ${helperName}(${helperParam}){${declareFastTemps(body.scope)}switch(${helperParam}[${discKey}]){${caseStrs.join("")}default:return false;}}`);
-    }
-    else {
-        // Dispatch through a string→ordinal table, then switch on the ordinal. V8
-        // compiles a switch over STRING labels as sequential `===` comparisons, so
-        // the plain form costs ~0.5 ns per preceding case: measured 4.1 ns (2
-        // variants), 11.4 (8), 52.1 (80). A dense integer switch becomes a jump
-        // table, leaving the lookup flat — 5.9 ns (8) and 15.1 (80), i.e. 1.9x to
-        // 3.5x, for a table that adds ~1.3% to a union's generated bytes.
-        //
-        // `typeof t==="string"` is load-bearing: property access would coerce a
-        // non-string discriminator (an object's toString, a number) into a key that
-        // could hit a case whose own discriminator check the switch has stripped.
-        // Strict equality never matched those, so the guard keeps the verdict.
-        const caseStrs = [];
-        for (const [optionIndex, ordinal] of table.ordinals) {
-            const check = body.visit(options[optionIndex], { discSkipKey: discriminator });
-            if (check === null)
-                return null;
-            caseStrs.push(`case ${ordinal}:return ${check};`);
-        }
-        const tableVar = emitConstant(g.ctx, "dt", table.initializer);
-        const t = g.temp("dv");
-        g.ctx.preamble.push(`function ${helperName}(${helperParam}){${declareFastTemps(body.scope)}var ${t}=${helperParam}[${discKey}];` +
-            `switch(typeof ${t}==="string"?${tableVar}[${t}]:0){${caseStrs.join("")}default:return false;}}`);
-    }
-    return `typeof ${x}==="object"&&${x}!==null&&!Array.isArray(${x})&&${helperName}(${x})`;
+* Emit an O(1) switch-dispatch fast-check for a discriminated union — real
+* (`z.discriminatedUnion`) or one detected inside a plain `z.union`
+* (see {@link detectUnionDiscriminator}). Both share this so the detected case
+* inherits the size-gating and the per-case guard strip.
+*
+* `discSkipKey` tells each object option to drop its own type-guard and
+* discriminator re-check: the caller's guard (`typeof x==="object"&&…` below)
+* already proved object-ness, and the matched switch case has fixed the
+* discriminator value, so re-emitting either is pure redundancy the optimizer
+* only removes when it inlines this helper — which a union large enough to
+* matter won't. Routed through the normal `visit` so size-gated extraction
+* still bounds the switch (the strip survives into any hoisted helper);
+* non-object options ignore the hint and keep their own guard.
+*
+* Returns null if any option is fast-path-ineligible.
+*/
+function emitFastDiscriminatedSwitch(g, discriminator, cases, options) {
+	const x = g.input;
+	const discKey = escapeString(discriminator);
+	const helperName = g.temp("du");
+	const helperParam = g.temp("dx");
+	const body = g.scoped(helperParam);
+	const table = stringDispatchTable(cases);
+	if (table === null) {
+		const caseStrs = [];
+		for (const { value, option: index } of cases) {
+			const check = body.visit(options[index], { discSkipKey: discriminator });
+			if (check === null) return null;
+			caseStrs.push(`case ${literalToJs(value)}:return ${check};`);
+		}
+		g.ctx.preamble.push(`function ${helperName}(${helperParam}){${declareFastTemps(body.scope)}switch(${helperParam}[${discKey}]){${caseStrs.join("")}default:return false;}}`);
+	} else {
+		const caseStrs = [];
+		for (const [optionIndex, ordinal] of table.ordinals) {
+			const check = body.visit(options[optionIndex], { discSkipKey: discriminator });
+			if (check === null) return null;
+			caseStrs.push(`case ${ordinal}:return ${check};`);
+		}
+		const tableVar = emitConstant(g.ctx, "dt", table.initializer);
+		const t = g.temp("dv");
+		g.ctx.preamble.push(`function ${helperName}(${helperParam}){${declareFastTemps(body.scope)}var ${t}=${helperParam}[${discKey}];switch(typeof ${t}==="string"?${tableVar}[${t}]:0){${caseStrs.join("")}default:return false;}}`);
+	}
+	return `typeof ${x}==="object"&&${x}!==null&&!Array.isArray(${x})&&${helperName}(${x})`;
 }
 /**
- * Minimum case count for ordinal dispatch. Measured crossover is 3: at 2 cases
- * the string switch is one comparison and beats the extra table lookup
- * (4.1 ns vs 4.5), at 3 the table already wins (6.1 vs 4.6).
- */
+* Minimum case count for ordinal dispatch. Measured crossover is 3: at 2 cases
+* the string switch is one comparison and beats the extra table lookup
+* (4.1 ns vs 4.5), at 3 the table already wins (6.1 vs 4.6).
+*/
 const MIN_TABLE_DISPATCH = 3;
 /**
- * Build the `{value: ordinal}` dispatch table for a set of cases, or null when
- * the plain string switch should be kept. Requires every discriminator value to
- * be a string — mixed types would collide once coerced to property keys (`5`
- * and `"5"`) — and excludes `__proto__`, which an object literal cannot hold as
- * an own key. Values that select the SAME option share one ordinal, so a
- * multi-value literal emits its check once instead of per value.
- */
+* Build the `{value: ordinal}` dispatch table for a set of cases, or null when
+* the plain string switch should be kept. Requires every discriminator value to
+* be a string — mixed types would collide once coerced to property keys (`5`
+* and `"5"`) — and excludes `__proto__`, which an object literal cannot hold as
+* an own key. Values that select the SAME option share one ordinal, so a
+* multi-value literal emits its check once instead of per value.
+*/
 function stringDispatchTable(cases) {
-    if (cases.length < MIN_TABLE_DISPATCH)
-        return null;
-    if (!cases.every((c) => typeof c.value === "string" && c.value !== "__proto__"))
-        return null;
-    const ordinals = new Map();
-    const entries = [];
-    for (const { value, option } of cases) {
-        let ordinal = ordinals.get(option);
-        if (ordinal === undefined) {
-            ordinal = ordinals.size + 1;
-            ordinals.set(option, ordinal);
-        }
-        entries.push(`${escapeString(value)}:${ordinal}`);
-    }
-    return { initializer: `{${entries.join(",")}}`, ordinals };
+	if (cases.length < MIN_TABLE_DISPATCH) return null;
+	if (!cases.every((c) => typeof c.value === "string" && c.value !== "__proto__")) return null;
+	const ordinals = /* @__PURE__ */ new Map();
+	const entries = [];
+	for (const { value, option } of cases) {
+		let ordinal = ordinals.get(option);
+		if (ordinal === void 0) {
+			ordinal = ordinals.size + 1;
+			ordinals.set(option, ordinal);
+		}
+		entries.push(`${escapeString(value)}:${ordinal}`);
+	}
+	return {
+		initializer: `{${entries.join(",")}}`,
+		ordinals
+	};
 }
-export function fastDiscriminatedUnion(ir, g) {
-    return emitFastDiscriminatedSwitch(g, ir.discriminator, ir.cases, ir.options);
+function fastDiscriminatedUnion(ir, g) {
+	return emitFastDiscriminatedSwitch(g, ir.discriminator, ir.cases, ir.options);
 }
 /**
- * Minimum option count for rewriting a plain `z.union` to switch dispatch. Below
- * this the switch helper's fixed call overhead loses to a fully-inlined
- * `||`-chain that V8 keeps flat: measured crossover is ~4 options (n=3 can hit
- * 0.6x — a regression — while n=5 is 1.27x and n=32 is 2.34x), so 5 captures the
- * stable wins with margin and never regresses a small union. Real
- * `z.discriminatedUnion` is unaffected — it dispatches via switch by construction
- * regardless of size.
- */
+* Minimum option count for rewriting a plain `z.union` to switch dispatch. Below
+* this the switch helper's fixed call overhead loses to a fully-inlined
+* `||`-chain that V8 keeps flat: measured crossover is ~4 options (n=3 can hit
+* 0.6x — a regression — while n=5 is 1.27x and n=32 is 2.34x), so 5 captures the
+* stable wins with margin and never regresses a small union. Real
+* `z.discriminatedUnion` is unaffected — it dispatches via switch by construction
+* regardless of size.
+*/
 const MIN_AUTO_DISCRIMINATE_OPTIONS = 5;
 /** Values that switch correctly under `===` (excludes `undefined` and `NaN`). */
 function isSwitchableDiscriminant(v) {
-    return (v === null ||
-        typeof v === "string" ||
-        typeof v === "boolean" ||
-        typeof v === "bigint" ||
-        (typeof v === "number" && !Number.isNaN(v)));
+	return v === null || typeof v === "string" || typeof v === "boolean" || typeof v === "bigint" || typeof v === "number" && !Number.isNaN(v);
 }
 /**
- * Detect whether a plain (untagged) `z.union` is *structurally* a discriminated
- * union, so its fast path can use O(1) switch dispatch instead of probing every
- * arm. Returns the discriminator + dispatch table, or null to keep the
- * `||`-chain.
- *
- * Requires (proving the switch accepts exactly what the `||`-chain would): every
- * option is a plain object that pins one shared key to a REQUIRED literal
- * (`prop.type === "literal"` — an optional/non-literal key is rejected), and the
- * literal values are pairwise DISJOINT across options. Disjointness is the crux:
- * it guarantees at most one option can accept any given input, so dispatching to
- * that single option is equivalent to trying them all. Any value shared by two
- * options (ambiguous), a non-switchable value (`undefined`/`NaN`), or a
- * non-object option makes detection bail to the safe `||`-chain.
- *
- * Fast-path only: the slow path keeps `z.union`'s sequential trial and its
- * `invalid_union` error shape, so failure output stays byte-identical to Zod.
- */
-export function detectUnionDiscriminator(options) {
-    if (options.length < MIN_AUTO_DISCRIMINATE_OPTIONS)
-        return null;
-    const objects = [];
-    for (const option of options) {
-        if (option.type !== "object")
-            return null;
-        objects.push(option);
-    }
-    const first = objects[0];
-    if (first === undefined)
-        return null; // unreachable (length checked above)
-    // Only keys present in the first option can be shared by all; try each.
-    candidate: for (const key of Object.keys(first.properties)) {
-        const seen = new Set();
-        const cases = [];
-        for (const [i, object] of objects.entries()) {
-            const prop = object.properties[key];
-            if (prop === undefined || prop.type !== "literal")
-                continue candidate;
-            for (const value of prop.values) {
-                if (!isSwitchableDiscriminant(value))
-                    continue candidate;
-                if (seen.has(value))
-                    continue candidate; // shared value → ambiguous dispatch
-                seen.add(value);
-                cases.push({ value, option: i });
-            }
-        }
-        return { discriminator: key, cases };
-    }
-    return null;
+* Detect whether a plain (untagged) `z.union` is *structurally* a discriminated
+* union, so its fast path can use O(1) switch dispatch instead of probing every
+* arm. Returns the discriminator + dispatch table, or null to keep the
+* `||`-chain.
+*
+* Requires (proving the switch accepts exactly what the `||`-chain would): every
+* option is a plain object that pins one shared key to a REQUIRED literal
+* (`prop.type === "literal"` — an optional/non-literal key is rejected), and the
+* literal values are pairwise DISJOINT across options. Disjointness is the crux:
+* it guarantees at most one option can accept any given input, so dispatching to
+* that single option is equivalent to trying them all. Any value shared by two
+* options (ambiguous), a non-switchable value (`undefined`/`NaN`), or a
+* non-object option makes detection bail to the safe `||`-chain.
+*
+* Fast-path only: the slow path keeps `z.union`'s sequential trial and its
+* `invalid_union` error shape, so failure output stays byte-identical to Zod.
+*/
+function detectUnionDiscriminator(options) {
+	if (options.length < MIN_AUTO_DISCRIMINATE_OPTIONS) return null;
+	const objects = [];
+	for (const option of options) {
+		if (option.type !== "object") return null;
+		objects.push(option);
+	}
+	const first = objects[0];
+	if (first === void 0) return null;
+	candidate: for (const key of Object.keys(first.properties)) {
+		const seen = /* @__PURE__ */ new Set();
+		const cases = [];
+		for (const [i, object] of objects.entries()) {
+			const prop = object.properties[key];
+			if (prop === void 0 || prop.type !== "literal") continue candidate;
+			for (const value of prop.values) {
+				if (!isSwitchableDiscriminant(value)) continue candidate;
+				if (seen.has(value)) continue candidate;
+				seen.add(value);
+				cases.push({
+					value,
+					option: i
+				});
+			}
+		}
+		return {
+			discriminator: key,
+			cases
+		};
+	}
+	return null;
 }
+//#endregion
+export { detectUnionDiscriminator, emitFastDiscriminatedSwitch, fastDiscriminatedUnion, slowDiscriminatedUnion };
+
 //# sourceMappingURL=discriminated-union.js.map

package/dist/core/codegen/schemas/discriminated-union.js.map

@@ -1 +1 @@
-{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/discriminated-union.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"discriminated-union.js","names":[],"sources":["../../../../src/core/codegen/schemas/discriminated-union.ts"],"sourcesContent":["import type { DiscriminatedUnionIR, ObjectIR, SchemaIR } from \"../../types.js\";\nimport type { FastGen, SlowGen } from \"../context.js\";\nimport {\n  declareFastTemps,\n  emitConstant,\n  escapeString,\n  extendPath,\n  hasMutation,\n  literalToJs,\n} from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidType } from \"../emit-issue.js\";\n\n/** One `discriminator value → option index` dispatch entry. */\ntype DiscriminatorCase = DiscriminatedUnionIR[\"cases\"][number];\n\nexport function slowDiscriminatedUnion(\n  ir: SchemaIR & { type: \"discriminatedUnion\" },\n  g: SlowGen,\n): string {\n  const discKey = escapeString(ir.discriminator);\n\n  let code = emit`\n    if(typeof ${g.input}!==\"object\"||${g.input}===null||Array.isArray(${g.input})){\n      ${invalidType(g, \"object\")}\n    }else{`;\n\n  const objVar = g.temp(\"du\");\n  code += `var ${objVar}=${g.input};switch(${objVar}[${discKey}]){`;\n\n  for (const { value, option: index } of ir.cases) {\n    const option = ir.options[index] as SchemaIR;\n    code += emit`\n      case ${literalToJs(value)}:\n        ${g.visit(option, { input: objVar, output: objVar })}\n        break;`;\n  }\n\n  const validValues = ir.cases.map((c) => literalToJs(c.value)).join(\",\");\n  const msgProp = g.typeMsg === undefined ? \"\" : `,message:${JSON.stringify(g.typeMsg)}`;\n  code += emit`\n    default:\n      ${g.issues}.push({code:\"invalid_union\",errors:[],note:\"No matching discriminator\",discriminator:${discKey},options:[${validValues}]${msgProp},input:${g.input},path:${extendPath(g.path, discKey)}});\n    }`;\n  // Propagate option-applied mutations (defaults, coercions, transforms,\n  // overwrite checks, stringbool) back to the output location. Each option is\n  // visited with output:objVar — a fresh local — so a mutating option's clone is\n  // reassigned into objVar and stranded there; without this write-back the caller\n  // returns the ORIGINAL input by reference and the mutation is silently lost.\n  // Gated on mutation so a pure-validation union stays a zero-write pass-through\n  // (objVar still aliases the input). On the no-match/failure paths objVar equals\n  // the input, so the write is a harmless self-assignment.\n  if (ir.options.some(hasMutation)) {\n    code += `${g.output}=${objVar};`;\n  }\n  code += `}`;\n  return `${code}\\n`;\n}\n\n/**\n * Emit an O(1) switch-dispatch fast-check for a discriminated union — real\n * (`z.discriminatedUnion`) or one detected inside a plain `z.union`\n * (see {@link detectUnionDiscriminator}). Both share this so the detected case\n * inherits the size-gating and the per-case guard strip.\n *\n * `discSkipKey` tells each object option to drop its own type-guard and\n * discriminator re-check: the caller's guard (`typeof x===\"object\"&&…` below)\n * already proved object-ness, and the matched switch case has fixed the\n * discriminator value, so re-emitting either is pure redundancy the optimizer\n * only removes when it inlines this helper — which a union large enough to\n * matter won't. Routed through the normal `visit` so size-gated extraction\n * still bounds the switch (the strip survives into any hoisted helper);\n * non-object options ignore the hint and keep their own guard.\n *\n * Returns null if any option is fast-path-ineligible.\n */\nexport function emitFastDiscriminatedSwitch(\n  g: FastGen,\n  discriminator: string,\n  cases: readonly DiscriminatorCase[],\n  options: readonly SchemaIR[],\n): string | null {\n  const x = g.input;\n  const discKey = escapeString(discriminator);\n  const helperName = g.temp(\"du\");\n  const helperParam = g.temp(\"dx\");\n\n  // The switch body is its own function: size-gate the options against the cap\n  // in a fresh scope, otherwise many small options accumulate into the caller's\n  // scope while this helper itself grows unbounded past the TurboFan budget.\n  const body = g.scoped(helperParam);\n  const table = stringDispatchTable(cases);\n\n  if (table === null) {\n    const caseStrs: string[] = [];\n    for (const { value, option: index } of cases) {\n      const check = body.visit(options[index] as SchemaIR, { discSkipKey: discriminator });\n      if (check === null) return null;\n      caseStrs.push(`case ${literalToJs(value)}:return ${check};`);\n    }\n    g.ctx.preamble.push(\n      `function ${helperName}(${helperParam}){${declareFastTemps(body.scope)}switch(${helperParam}[${discKey}]){${caseStrs.join(\"\")}default:return false;}}`,\n    );\n  } else {\n    // Dispatch through a string→ordinal table, then switch on the ordinal. V8\n    // compiles a switch over STRING labels as sequential `===` comparisons, so\n    // the plain form costs ~0.5 ns per preceding case: measured 4.1 ns (2\n    // variants), 11.4 (8), 52.1 (80). A dense integer switch becomes a jump\n    // table, leaving the lookup flat — 5.9 ns (8) and 15.1 (80), i.e. 1.9x to\n    // 3.5x, for a table that adds ~1.3% to a union's generated bytes.\n    //\n    // `typeof t===\"string\"` is load-bearing: property access would coerce a\n    // non-string discriminator (an object's toString, a number) into a key that\n    // could hit a case whose own discriminator check the switch has stripped.\n    // Strict equality never matched those, so the guard keeps the verdict.\n    const caseStrs: string[] = [];\n    for (const [optionIndex, ordinal] of table.ordinals) {\n      const check = body.visit(options[optionIndex] as SchemaIR, { discSkipKey: discriminator });\n      if (check === null) return null;\n      caseStrs.push(`case ${ordinal}:return ${check};`);\n    }\n    const tableVar = emitConstant(g.ctx, \"dt\", table.initializer);\n    const t = g.temp(\"dv\");\n    g.ctx.preamble.push(\n      `function ${helperName}(${helperParam}){${declareFastTemps(body.scope)}var ${t}=${helperParam}[${discKey}];` +\n        `switch(typeof ${t}===\"string\"?${tableVar}[${t}]:0){${caseStrs.join(\"\")}default:return false;}}`,\n    );\n  }\n\n  return `typeof ${x}===\"object\"&&${x}!==null&&!Array.isArray(${x})&&${helperName}(${x})`;\n}\n\n/**\n * Minimum case count for ordinal dispatch. Measured crossover is 3: at 2 cases\n * the string switch is one comparison and beats the extra table lookup\n * (4.1 ns vs 4.5), at 3 the table already wins (6.1 vs 4.6).\n */\nconst MIN_TABLE_DISPATCH = 3;\n\n/**\n * Build the `{value: ordinal}` dispatch table for a set of cases, or null when\n * the plain string switch should be kept. Requires every discriminator value to\n * be a string — mixed types would collide once coerced to property keys (`5`\n * and `\"5\"`) — and excludes `__proto__`, which an object literal cannot hold as\n * an own key. Values that select the SAME option share one ordinal, so a\n * multi-value literal emits its check once instead of per value.\n */\nfunction stringDispatchTable(\n  cases: readonly DiscriminatorCase[],\n): { initializer: string; ordinals: Map<number, number> } | null {\n  if (cases.length < MIN_TABLE_DISPATCH) return null;\n  if (!cases.every((c) => typeof c.value === \"string\" && c.value !== \"__proto__\")) return null;\n\n  const ordinals = new Map<number, number>();\n  const entries: string[] = [];\n  for (const { value, option } of cases) {\n    let ordinal = ordinals.get(option);\n    if (ordinal === undefined) {\n      ordinal = ordinals.size + 1;\n      ordinals.set(option, ordinal);\n    }\n    entries.push(`${escapeString(value as string)}:${ordinal}`);\n  }\n  return { initializer: `{${entries.join(\",\")}}`, ordinals };\n}\n\nexport function fastDiscriminatedUnion(ir: DiscriminatedUnionIR, g: FastGen): string | null {\n  return emitFastDiscriminatedSwitch(g, ir.discriminator, ir.cases, ir.options);\n}\n\n/**\n * Minimum option count for rewriting a plain `z.union` to switch dispatch. Below\n * this the switch helper's fixed call overhead loses to a fully-inlined\n * `||`-chain that V8 keeps flat: measured crossover is ~4 options (n=3 can hit\n * 0.6x — a regression — while n=5 is 1.27x and n=32 is 2.34x), so 5 captures the\n * stable wins with margin and never regresses a small union. Real\n * `z.discriminatedUnion` is unaffected — it dispatches via switch by construction\n * regardless of size.\n */\nconst MIN_AUTO_DISCRIMINATE_OPTIONS = 5;\n\n/** Values that switch correctly under `===` (excludes `undefined` and `NaN`). */\nfunction isSwitchableDiscriminant(\n  v: string | number | boolean | null | bigint | undefined,\n): v is string | number | boolean | bigint | null {\n  return (\n    v === null ||\n    typeof v === \"string\" ||\n    typeof v === \"boolean\" ||\n    typeof v === \"bigint\" ||\n    (typeof v === \"number\" && !Number.isNaN(v))\n  );\n}\n\n/**\n * Detect whether a plain (untagged) `z.union` is *structurally* a discriminated\n * union, so its fast path can use O(1) switch dispatch instead of probing every\n * arm. Returns the discriminator + dispatch table, or null to keep the\n * `||`-chain.\n *\n * Requires (proving the switch accepts exactly what the `||`-chain would): every\n * option is a plain object that pins one shared key to a REQUIRED literal\n * (`prop.type === \"literal\"` — an optional/non-literal key is rejected), and the\n * literal values are pairwise DISJOINT across options. Disjointness is the crux:\n * it guarantees at most one option can accept any given input, so dispatching to\n * that single option is equivalent to trying them all. Any value shared by two\n * options (ambiguous), a non-switchable value (`undefined`/`NaN`), or a\n * non-object option makes detection bail to the safe `||`-chain.\n *\n * Fast-path only: the slow path keeps `z.union`'s sequential trial and its\n * `invalid_union` error shape, so failure output stays byte-identical to Zod.\n */\nexport function detectUnionDiscriminator(\n  options: readonly SchemaIR[],\n): { discriminator: string; cases: DiscriminatorCase[] } | null {\n  if (options.length < MIN_AUTO_DISCRIMINATE_OPTIONS) return null;\n  const objects: ObjectIR[] = [];\n  for (const option of options) {\n    if (option.type !== \"object\") return null;\n    objects.push(option);\n  }\n  const first = objects[0];\n  if (first === undefined) return null; // unreachable (length checked above)\n\n  // Only keys present in the first option can be shared by all; try each.\n  candidate: for (const key of Object.keys(first.properties)) {\n    const seen = new Set<string | number | boolean | bigint | null>();\n    const cases: DiscriminatorCase[] = [];\n    for (const [i, object] of objects.entries()) {\n      const prop = object.properties[key];\n      if (prop === undefined || prop.type !== \"literal\") continue candidate;\n      for (const value of prop.values) {\n        if (!isSwitchableDiscriminant(value)) continue candidate;\n        if (seen.has(value)) continue candidate; // shared value → ambiguous dispatch\n        seen.add(value);\n        cases.push({ value, option: i });\n      }\n    }\n    return { discriminator: key, cases };\n  }\n  return null;\n}\n"],"mappings":"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"}

package/dist/core/codegen/schemas/effect.d.ts

@@ -1,10 +1,11 @@
-import type { RefineEffectCheckIR, SuperRefineEffectCheckIR, TransformEffectIR } from "../../types.js";
-import type { FastGen, SlowGen } from "../context.js";
+import { RefineEffectCheckIR, SuperRefineEffectCheckIR, TransformEffectIR } from "../../types.js";
+import { FastGen, SlowGen } from "../context.js";
+//#region src/core/codegen/schemas/effect.d.ts
 /**
  * Generate code for a TransformEffectIR node.
  * Validates the inner schema, then applies the transform function and writes back the result.
  */
-export declare function slowEffect(ir: TransformEffectIR, g: SlowGen): string;
+declare function slowEffect(ir: TransformEffectIR, g: SlowGen): string;
 /**
  * Generate code for a RefineEffectCheckIR (inline refine function call).
  * Called from string/number/object check loops when a refine_effect is encountered.
@@ -13,12 +14,12 @@ export declare function slowEffect(ir: TransformEffectIR, g: SlowGen): string;
  * @param expr - The expression to validate (may differ from g.input, e.g. objVar in object generators)
  * @param g - SlowGen context (provides path, issues)
  */
-export declare function refineCheck(check: RefineEffectCheckIR, expr: string, g: SlowGen): string;
+declare function refineCheck(check: RefineEffectCheckIR, expr: string, g: SlowGen): string;
 /**
  * Fast-path test for a SuperRefineEffectCheckIR: a boolean term reporting that
  * the callback added no issue and left the value alone (see ZC_SR_OK_DECL).
  */
-export declare function superRefineFastTest(check: SuperRefineEffectCheckIR, expr: string, g: FastGen): string;
+declare function superRefineFastTest(check: SuperRefineEffectCheckIR, expr: string, g: FastGen): string;
 /**
  * Generate code for a SuperRefineEffectCheckIR: call the payload-taking
  * callback with a synthesized `{ value, issues }` and merge what it collected.
@@ -31,5 +32,7 @@ export declare function superRefineFastTest(check: SuperRefineEffectCheckIR, exp
  * (the node reports as mutating, see hasMutation), so the write-back lands on
  * every parse that reaches it — not only on failures.
  */
-export declare function superRefineCheck(check: SuperRefineEffectCheckIR, expr: string, g: SlowGen): string;
+declare function superRefineCheck(check: SuperRefineEffectCheckIR, expr: string, g: SlowGen): string;
+//#endregion
+export { refineCheck, slowEffect, superRefineCheck, superRefineFastTest };
 //# sourceMappingURL=effect.d.ts.map

package/dist/core/codegen/schemas/effect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAUtD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,iBAAiB,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAgBpE;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAmBxF;AAaD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,wBAAwB,EAC/B,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,OAAO,GACT,MAAM,CAIR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,wBAAwB,EAC/B,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,OAAO,GACT,MAAM,CAUR"}
+{"version":3,"file":"effect.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/effect.ts"],"mappings":";;;;;;;iBAmBgB,WAAW,IAAI,mBAAmB,GAAG;;;;;;;;;iBA0BrC,YAAY,OAAO,qBAAqB,cAAc,GAAG;;;;;iBAoCzD,oBACd,OAAO,0BACP,cACA,GAAG;;;;;;;;;;;;;iBAmBW,iBACd,OAAO,0BACP,cACA,GAAG"}

package/dist/core/codegen/schemas/effect.js

@@ -1,19 +1,16 @@
-import { emitEffectCallable, emitRuntimeHelper, extendStaticPath, extendStaticPathIndex, } from "../context.js";
+import { emitEffectCallable, emitRuntimeHelper, extendStaticPath, extendStaticPathIndex } from "../context.js";
 import { emit } from "../emit.js";
 import { ZC_SR_DECL, ZC_SR_OK_DECL, ZC_SR_RUN_DECL } from "../issue-decls.js";
+//#region src/core/codegen/schemas/effect.ts
 /**
- * Generate code for a TransformEffectIR node.
- * Validates the inner schema, then applies the transform function and writes back the result.
- */
-export function slowEffect(ir, g) {
-    const beforeVar = g.temp("ib");
-    const innerCode = g.visit(ir.inner);
-    // A transform is `inner.transform(fn)` = a pipe(inner, transform): zod's
-    // handlePipeResult aborts when `inner` produces any issue. Inside a union the
-    // option must therefore count as aborted even if `inner`'s only issue is a
-    // non-aborting `custom`/check-level code (mirrors slowPipe's abort branch).
-    const abortBranch = g.aborted ? `else{${g.aborted}=true;}` : "";
-    return `${emit `
+* Generate code for a TransformEffectIR node.
+* Validates the inner schema, then applies the transform function and writes back the result.
+*/
+function slowEffect(ir, g) {
+	const beforeVar = g.temp("ib");
+	const innerCode = g.visit(ir.inner);
+	const abortBranch = g.aborted ? `else{${g.aborted}=true;}` : "";
+	return `${emit`
     var ${beforeVar}=${g.issues}.length;
     ${innerCode}
     if(${g.issues}.length===${beforeVar}){
@@ -22,69 +19,59 @@ export function slowEffect(ir, g) {
   `}\n`;
 }
 /**
- * Generate code for a RefineEffectCheckIR (inline refine function call).
- * Called from string/number/object check loops when a refine_effect is encountered.
- *
- * @param check - The refine effect check IR
- * @param expr - The expression to validate (may differ from g.input, e.g. objVar in object generators)
- * @param g - SlowGen context (provides path, issues)
- */
-export function refineCheck(check, expr, g) {
-    // Custom issues are created by the refine check instance, so only the
-    // refine's own message applies (never the schema-level error). With no
-    // message baked in, __zcFin applies the locale default ("Invalid input").
-    const messageProp = check.message === undefined ? "" : `,message:${JSON.stringify(check.message)}`;
-    // `.refine(fn, { path })` reports against a member of the refined value, so
-    // the configured segments extend this node's path.
-    const path = (check.path ?? []).reduce((acc, segment) => typeof segment === "number"
-        ? extendStaticPathIndex(acc, segment)
-        : extendStaticPath(acc, segment), g.path);
-    return emit `
+* Generate code for a RefineEffectCheckIR (inline refine function call).
+* Called from string/number/object check loops when a refine_effect is encountered.
+*
+* @param check - The refine effect check IR
+* @param expr - The expression to validate (may differ from g.input, e.g. objVar in object generators)
+* @param g - SlowGen context (provides path, issues)
+*/
+function refineCheck(check, expr, g) {
+	const messageProp = check.message === void 0 ? "" : `,message:${JSON.stringify(check.message)}`;
+	const path = (check.path ?? []).reduce((acc, segment) => typeof segment === "number" ? extendStaticPathIndex(acc, segment) : extendStaticPath(acc, segment), g.path);
+	return emit`
     if(!${emitEffectCallable(g.ctx, check)}(${expr})){
       ${g.issues}.push({code:"custom",path:${path}${messageProp},input:${expr}});
     }`;
 }
 /**
- * Declare the shared invoker both superRefine helpers call. It is module-local
- * rather than an imported helper (lean mode declares it in the runtime module
- * beside them), so inline mode must place it in the preamble itself.
- */
+* Declare the shared invoker both superRefine helpers call. It is module-local
+* rather than an imported helper (lean mode declares it in the runtime module
+* beside them), so inline mode must place it in the preamble itself.
+*/
 function emitSuperRefineRunner(ctx) {
-    if (ctx.mode !== "lean" && !ctx.preamble.includes(ZC_SR_RUN_DECL)) {
-        ctx.preamble.push(ZC_SR_RUN_DECL);
-    }
+	if (ctx.mode !== "lean" && !ctx.preamble.includes("function __zcSrRun(f,p){var r=f(p);if(r&&typeof r.then===\"function\"){throw new __zcCore.$ZodAsyncError();}}")) ctx.preamble.push(ZC_SR_RUN_DECL);
 }
 /**
- * Fast-path test for a SuperRefineEffectCheckIR: a boolean term reporting that
- * the callback added no issue and left the value alone (see ZC_SR_OK_DECL).
- */
-export function superRefineFastTest(check, expr, g) {
-    emitSuperRefineRunner(g.ctx);
-    const ok = emitRuntimeHelper(g.ctx, "__zcSrOk", ZC_SR_OK_DECL);
-    return `${ok}(${emitEffectCallable(g.ctx, check)},${expr})`;
+* Fast-path test for a SuperRefineEffectCheckIR: a boolean term reporting that
+* the callback added no issue and left the value alone (see ZC_SR_OK_DECL).
+*/
+function superRefineFastTest(check, expr, g) {
+	emitSuperRefineRunner(g.ctx);
+	return `${emitRuntimeHelper(g.ctx, "__zcSrOk", ZC_SR_OK_DECL)}(${emitEffectCallable(g.ctx, check)},${expr})`;
 }
 /**
- * Generate code for a SuperRefineEffectCheckIR: call the payload-taking
- * callback with a synthesized `{ value, issues }` and merge what it collected.
- * zod's own wrapper installs `addIssue` and normalizes the result, so the
- * issues are zod's — the helper only reprojects them onto this node's path and
- * strips the internal bookkeeping zod deletes before they become visible.
- *
- * The payload's `value` is writable public API, so it is written back to the
- * output slot the way an overwrite effect is. This walk is always the eager one
- * (the node reports as mutating, see hasMutation), so the write-back lands on
- * every parse that reaches it — not only on failures.
- */
-export function superRefineCheck(check, expr, g) {
-    emitSuperRefineRunner(g.ctx);
-    const helper = emitRuntimeHelper(g.ctx, "__zcSr", ZC_SR_DECL);
-    const fn = emitEffectCallable(g.ctx, check);
-    const p = g.temp("sp");
-    let code = `var ${p}=${helper}(${fn},${expr},${g.path},${g.issues});${g.output}=${p}.value;`;
-    // Inside a union option, an aborting issue must mark the option aborted so
-    // pruning matches zod (see ZC_SR_DECL); elsewhere the flag is unobserved.
-    if (g.aborted)
-        code += `if(${p}.aborted){${g.aborted}=true;}`;
-    return code;
+* Generate code for a SuperRefineEffectCheckIR: call the payload-taking
+* callback with a synthesized `{ value, issues }` and merge what it collected.
+* zod's own wrapper installs `addIssue` and normalizes the result, so the
+* issues are zod's — the helper only reprojects them onto this node's path and
+* strips the internal bookkeeping zod deletes before they become visible.
+*
+* The payload's `value` is writable public API, so it is written back to the
+* output slot the way an overwrite effect is. This walk is always the eager one
+* (the node reports as mutating, see hasMutation), so the write-back lands on
+* every parse that reaches it — not only on failures.
+*/
+function superRefineCheck(check, expr, g) {
+	emitSuperRefineRunner(g.ctx);
+	const helper = emitRuntimeHelper(g.ctx, "__zcSr", ZC_SR_DECL);
+	const fn = emitEffectCallable(g.ctx, check);
+	const p = g.temp("sp");
+	let code = `var ${p}=${helper}(${fn},${expr},${g.path},${g.issues});${g.output}=${p}.value;`;
+	if (g.aborted) code += `if(${p}.aborted){${g.aborted}=true;}`;
+	return code;
 }
+//#endregion
+export { refineCheck, slowEffect, superRefineCheck, superRefineFastTest };
+
 //# sourceMappingURL=effect.js.map