zod-compiler 1.23.0 → 1.23.2

package/dist/core/codegen/fast-size.js

@@ -1,278 +1,203 @@
+//#region src/core/codegen/fast-size.ts
 /**
- * Fast-path size estimation, used to bound the size of each emitted fast-check
- * function. V8's TurboFan refuses to optimize functions whose bytecode exceeds
- * ~60KB and falls back to the weaker Maglev tier — measured ~1.3-1.8x slower on
- * deeply-nested schemas whose monolithic fast-check crosses that budget. By
- * extracting large, self-contained sub-schemas into their own boolean helpers
- * (`generateFast`), each function stays small enough to TurboFan.
- *
- * `estimateFastCost` is a path-agnostic subtree estimate in approximate
- * generated-character units (it can't see the access-path prefix the node will
- * be emitted under, since that lives in the call site, not the IR). The actual
- * emitted size of an inlined node grows with that prefix length — `input["a"]
- * ["b"]["c"]…` repeated per check — so the extraction decision scales the
- * estimate by `1 + inputLen/PATH_GROWTH_DIVISOR` (see `predictedInlineSize`).
- * The accumulator itself (generateFast) tracks EXACT emitted chars via the
- * returned string length, so only the look-ahead prediction is approximate.
- */
+* Per-function soft size cap, in emitted characters. Once the fast-check being
+* assembled would exceed this, the next large hoistable sub-schema is split into
+* its own helper. Set below the ~60KB bytecode point where TurboFan bails (chars
+* over-approximate bytecode) with margin for one look-ahead mis-prediction.
+*/
+const EXTRACT_CAP = 38e3;
 /**
- * Per-function soft size cap, in emitted characters. Once the fast-check being
- * assembled would exceed this, the next large hoistable sub-schema is split into
- * its own helper. Set below the ~60KB bytecode point where TurboFan bails (chars
- * over-approximate bytecode) with margin for one look-ahead mis-prediction.
- */
-export const EXTRACT_CAP = 38_000;
-/**
- * Each nesting level lengthens every access path inside a node (`x["a"]` →
- * `x["a"]["b"]`), inflating real emitted chars above the path-agnostic estimate.
- * The extraction look-ahead multiplies the estimate by `1 + inputLen/this` so a
- * deep subtree is split before it inlines into an over-budget function. Smaller
- * ⇒ more eager splitting at depth. Calibrated against deeply-nested fixtures.
- */
+* Each nesting level lengthens every access path inside a node (`x["a"]` →
+* `x["a"]["b"]`), inflating real emitted chars above the path-agnostic estimate.
+* The extraction look-ahead multiplies the estimate by `1 + inputLen/this` so a
+* deep subtree is split before it inlines into an over-budget function. Smaller
+* ⇒ more eager splitting at depth. Calibrated against deeply-nested fixtures.
+*/
 const PATH_GROWTH_DIVISOR = 26;
 /**
- * Predicted emitted size of inlining `ir` at a call site whose input expression
- * is `inputLen` chars long — the path-agnostic subtree estimate scaled up for
- * the access-path prefix that estimate omits. Used only for the extract/inline
- * decision; the running total uses exact emitted lengths.
- */
-export function predictedInlineSize(ir, inputLen, cache) {
-    return estimateFastCost(ir, cache) * (1 + inputLen / PATH_GROWTH_DIVISOR);
+* Predicted emitted size of inlining `ir` at a call site whose input expression
+* is `inputLen` chars long — the path-agnostic subtree estimate scaled up for
+* the access-path prefix that estimate omits. Used only for the extract/inline
+* decision; the running total uses exact emitted lengths.
+*/
+function predictedInlineSize(ir, inputLen, cache) {
+	return estimateFastCost(ir, cache) * (1 + inputLen / PATH_GROWTH_DIVISOR);
 }
 /**
- * Floor for extraction: never hoist a sub-schema smaller than this even when
- * the enclosing function is over the cap — a tiny helper trades a real call for
- * no optimization benefit. Only sub-schemas big enough to matter are split.
- */
-export const MIN_EXTRACT = 1_200;
+* Floor for extraction: never hoist a sub-schema smaller than this even when
+* the enclosing function is over the cap — a tiny helper trades a real call for
+* no optimization benefit. Only sub-schemas big enough to matter are split.
+*/
+const MIN_EXTRACT = 1200;
 /** Approximate size contributed to the enclosing function by an extracted call `__fo_N(expr)`. */
-export const CALL_COST = 24;
+const CALL_COST = 24;
 /**
- * Node types whose fast-check is a self-contained boolean over a single input
- * expression and large enough to be worth hoisting into `function f(p){return …}`.
- * Thin wrappers (optional/nullable/default/…) are omitted: their inner schema is
- * visited through `generateFast` and gets hoisted on its own when large.
- */
-export const HOISTABLE = new Set([
-    "object",
-    "record",
-    "tuple",
-    "discriminatedUnion",
-    "union",
-    "intersection",
+* Node types whose fast-check is a self-contained boolean over a single input
+* expression and large enough to be worth hoisting into `function f(p){return …}`.
+* Thin wrappers (optional/nullable/default/…) are omitted: their inner schema is
+* visited through `generateFast` and gets hoisted on its own when large.
+*/
+const HOISTABLE = /* @__PURE__ */ new Set([
+	"object",
+	"record",
+	"tuple",
+	"discriminatedUnion",
+	"union",
+	"intersection"
 ]);
 /** A node's own contribution to the emitted fast-check, EXCLUDING its children. */
 function shallowFastCost(ir) {
-    switch (ir.type) {
-        case "object":
-            return 50 + Object.keys(ir.properties).length * 25 + (ir.strict ? 120 : 0);
-        case "string":
-            return 20 + ir.checks.length * 35;
-        case "number":
-            return 25 + ir.checks.length * 30;
-        case "bigint":
-        case "date":
-            return 25 + (ir.checks?.length ?? 0) * 25;
-        case "enum":
-            return 15 + ir.values.length * 12;
-        case "tuple":
-            return 40 + ir.items.length * 15;
-        case "union":
-            return 12 + ir.options.length * 6;
-        case "discriminatedUnion":
-            return 45 + ir.cases.length * 12;
-        case "array":
-        case "record":
-        case "set":
-        case "map":
-            return 55;
-        case "file":
-        case "templateLiteral":
-            return 40;
-        case "literal":
-        case "optional":
-        case "nullable":
-        case "default":
-            return 22;
-        case "recursiveRef":
-        case "recursionTarget":
-            // Both emit just a call to a hosted helper; the target's `inner` is sized
-            // independently when its own helper body is generated, so it is NOT
-            // counted against the enclosing function here (see fastChildren).
-            return 15;
-        default:
-            return 18;
-    }
+	switch (ir.type) {
+		case "object": return 50 + Object.keys(ir.properties).length * 25 + (ir.strict ? 120 : 0);
+		case "string": return 20 + ir.checks.length * 35;
+		case "number": return 25 + ir.checks.length * 30;
+		case "bigint":
+		case "date": return 25 + (ir.checks?.length ?? 0) * 25;
+		case "enum": return 15 + ir.values.length * 12;
+		case "tuple": return 40 + ir.items.length * 15;
+		case "union": return 12 + ir.options.length * 6;
+		case "discriminatedUnion": return 45 + ir.cases.length * 12;
+		case "array":
+		case "record":
+		case "set":
+		case "map": return 55;
+		case "file":
+		case "templateLiteral": return 40;
+		case "literal":
+		case "optional":
+		case "nullable":
+		case "default": return 22;
+		case "recursiveRef":
+		case "recursionTarget": return 15;
+		default: return 18;
+	}
 }
 /** Child IR nodes that the fast generator recurses into (mirrors the fast schema generators). */
 function fastChildren(ir) {
-    switch (ir.type) {
-        case "object":
-            return Object.values(ir.properties);
-        case "array":
-            return [ir.element];
-        case "tuple":
-            return ir.rest !== null ? [...ir.items, ir.rest] : ir.items;
-        case "record":
-        case "map":
-            return [ir.keyType, ir.valueType];
-        case "set":
-            return [ir.valueType];
-        case "union":
-        case "discriminatedUnion":
-            return ir.options;
-        case "intersection":
-            return [ir.left, ir.right];
-        case "pipe":
-            return [ir.in, ir.out];
-        case "optional":
-        case "nullable":
-        case "readonly":
-        case "default":
-        case "catch":
-            return [ir.inner];
-        default:
-            return [];
-    }
+	switch (ir.type) {
+		case "object": return Object.values(ir.properties);
+		case "array": return [ir.element];
+		case "tuple": return ir.rest !== null ? [...ir.items, ir.rest] : ir.items;
+		case "record":
+		case "map": return [ir.keyType, ir.valueType];
+		case "set": return [ir.valueType];
+		case "union":
+		case "discriminatedUnion": return ir.options;
+		case "intersection": return [ir.left, ir.right];
+		case "pipe": return [ir.in, ir.out];
+		case "optional":
+		case "nullable":
+		case "readonly":
+		case "default":
+		case "catch": return [ir.inner];
+		default: return [];
+	}
 }
 /**
- * Estimated total size of a node's fast-check (the node plus everything inlined
- * beneath it). Memoized per IR node: schemas dedupe shared sub-trees and the
- * estimate is consulted at every nesting level, so without the cache a deep tree
- * would be re-walked quadratically.
- */
-export function estimateFastCost(ir, cache) {
-    const cached = cache.get(ir);
-    if (cached !== undefined)
-        return cached;
-    // Defensive cycle break (the IR is a tree today; recursiveRef is a leaf).
-    cache.set(ir, 0);
-    let total = shallowFastCost(ir);
-    for (const child of fastChildren(ir))
-        total += estimateFastCost(child, cache);
-    cache.set(ir, total);
-    return total;
+* Estimated total size of a node's fast-check (the node plus everything inlined
+* beneath it). Memoized per IR node: schemas dedupe shared sub-trees and the
+* estimate is consulted at every nesting level, so without the cache a deep tree
+* would be re-walked quadratically.
+*/
+function estimateFastCost(ir, cache) {
+	const cached = cache.get(ir);
+	if (cached !== void 0) return cached;
+	cache.set(ir, 0);
+	let total = shallowFastCost(ir);
+	for (const child of fastChildren(ir)) total += estimateFastCost(child, cache);
+	cache.set(ir, total);
+	return total;
 }
-// ─── Runtime cost (check ordering) ───────────────────────────────────────────
 /**
- * Assumed element count for unbounded collections, used only to weight a
- * container against its siblings when ordering an `&&` chain.
- */
+* Assumed element count for unbounded collections, used only to weight a
+* container against its siblings when ordering an `&&` chain.
+*/
 const ASSUMED_ELEMENTS = 4;
 /** Runtime weight of one check on an already-type-confirmed value. */
 function checkRuntimeCost(kind) {
-    switch (kind) {
-        // A `.test()` call costs ~9 ns of dispatch before it matches a character —
-        // an order of magnitude above every other check, and the reason ordering
-        // matters at all.
-        case "string_format":
-            return 100;
-        // Zero-capture user predicate: a real call, cheaper than a regex.
-        case "refine_effect":
-            return 20;
-        case "includes":
-        case "starts_with":
-        case "ends_with":
-            return 6;
-        case "multiple_of":
-        case "bigint_multiple_of":
-            return 4;
-        default:
-            // length/size/range comparisons: a load and a compare.
-            return 1;
-    }
+	switch (kind) {
+		case "string_format": return 100;
+		case "refine_effect": return 20;
+		case "includes":
+		case "starts_with":
+		case "ends_with": return 6;
+		case "multiple_of":
+		case "bigint_multiple_of": return 4;
+		default: return 1;
+	}
 }
 /** A node's own runtime weight, EXCLUDING its children. */
 function shallowRuntimeCost(ir) {
-    switch (ir.type) {
-        case "string":
-        case "number":
-            return 2 + ir.checks.reduce((sum, c) => sum + checkRuntimeCost(c.kind), 0);
-        case "bigint":
-        case "date":
-            return 3 + (ir.checks?.length ?? 0);
-        case "file":
-            return 3 + (ir.checks?.length ?? 0) * 2;
-        case "enum":
-            // Inlined `===` chain (or one hashed lookup) — sub-nanosecond either way.
-            return 1 + Math.min(ir.values.length, 8);
-        case "object":
-            // Type guard, plus the strict pass's per-key membership test.
-            return 3 + (ir.strict === true ? Object.keys(ir.properties).length : 0);
-        case "array":
-        case "set":
-        case "record":
-        case "map":
-        case "tuple":
-            return 3;
-        case "templateLiteral":
-            return 100;
-        case "recursiveRef":
-        case "recursionTarget":
-            // A recursive call expands into an unknown amount of work; treat it as
-            // the most expensive sibling so it is probed last.
-            return 200;
-        default:
-            return 1;
-    }
+	switch (ir.type) {
+		case "string":
+		case "number": return 2 + ir.checks.reduce((sum, c) => sum + checkRuntimeCost(c.kind), 0);
+		case "bigint":
+		case "date": return 3 + (ir.checks?.length ?? 0);
+		case "file": return 3 + (ir.checks?.length ?? 0) * 2;
+		case "enum": return 1 + Math.min(ir.values.length, 8);
+		case "object": return 3 + (ir.strict === true ? Object.keys(ir.properties).length : 0);
+		case "array":
+		case "set":
+		case "record":
+		case "map":
+		case "tuple": return 3;
+		case "templateLiteral": return 100;
+		case "recursiveRef":
+		case "recursionTarget": return 200;
+		default: return 1;
+	}
 }
 /** estimateRuntimeCost against the per-compile memo hanging off the context. */
 function runtimeCostOf(ir, ctx) {
-    return estimateRuntimeCost(ir, (ctx.fastRuntimeCostCache ??= new WeakMap()));
+	return estimateRuntimeCost(ir, ctx.fastRuntimeCostCache ??= /* @__PURE__ */ new WeakMap());
 }
 /**
- * Sort a fast-check's sibling conjuncts (or union options) cheapest-first.
- * Returns a new array; ties keep source order (Array#sort is stable), so a
- * schema whose members all cost the same emits byte-identical output.
- */
-export function orderByRuntimeCost(items, irOf, ctx) {
-    if (items.length < 2)
-        return [...items];
-    return [...items].sort((a, b) => runtimeCostOf(irOf(a), ctx) - runtimeCostOf(irOf(b), ctx));
+* Sort a fast-check's sibling conjuncts (or union options) cheapest-first.
+* Returns a new array; ties keep source order (Array#sort is stable), so a
+* schema whose members all cost the same emits byte-identical output.
+*/
+function orderByRuntimeCost(items, irOf, ctx) {
+	if (items.length < 2) return [...items];
+	return [...items].sort((a, b) => runtimeCostOf(irOf(a), ctx) - runtimeCostOf(irOf(b), ctx));
 }
 /**
- * Estimated runtime cost of a node's fast-check, in arbitrary units calibrated
- * so a regex format check dominates a handful of type guards. Memoized per IR
- * node, like estimateFastCost — the estimate is consulted at every nesting
- * level, and shared sub-trees are common.
- *
- * Used to order the conjuncts of an `&&` chain cheapest-first. Accepting input
- * runs every conjunct regardless, so ordering is free there; REJECTING input
- * stops at the first false one, which is where a schema pays for probing a
- * `z.email()` before the `kind` literal that actually discriminates. Measured
- * on a 3-option union of objects that each declare `{email, kind, note}`:
- * 102 ns → 39 ns for an input matching the last option, and 102 ns → 6 ns for
- * one matching none.
- */
+* Estimated runtime cost of a node's fast-check, in arbitrary units calibrated
+* so a regex format check dominates a handful of type guards. Memoized per IR
+* node, like estimateFastCost — the estimate is consulted at every nesting
+* level, and shared sub-trees are common.
+*
+* Used to order the conjuncts of an `&&` chain cheapest-first. Accepting input
+* runs every conjunct regardless, so ordering is free there; REJECTING input
+* stops at the first false one, which is where a schema pays for probing a
+* `z.email()` before the `kind` literal that actually discriminates. Measured
+* on a 3-option union of objects that each declare `{email, kind, note}`:
+* 102 ns → 39 ns for an input matching the last option, and 102 ns → 6 ns for
+* one matching none.
+*/
 function estimateRuntimeCost(ir, cache) {
-    const cached = cache.get(ir);
-    if (cached !== undefined)
-        return cached;
-    cache.set(ir, 0); // cycle break (mirrors estimateFastCost)
-    let total = shallowRuntimeCost(ir);
-    const children = fastChildren(ir);
-    switch (ir.type) {
-        case "array":
-        case "set":
-        case "record":
-        case "map":
-            // Per-element work, repeated for an assumed handful of entries.
-            for (const child of children)
-                total += estimateRuntimeCost(child, cache) * ASSUMED_ELEMENTS;
-            break;
-        case "discriminatedUnion":
-            // O(1) switch: only the matched case runs. Charge the priciest option so
-            // the estimate stays an upper bound.
-            total += children.reduce((max, c) => Math.max(max, estimateRuntimeCost(c, cache)), 0);
-            break;
-        default:
-            // object/tuple/union/intersection/wrappers: every child is on the path
-            // (a union probes options until one matches — worst case, all of them).
-            for (const child of children)
-                total += estimateRuntimeCost(child, cache);
-            break;
-    }
-    cache.set(ir, total);
-    return total;
+	const cached = cache.get(ir);
+	if (cached !== void 0) return cached;
+	cache.set(ir, 0);
+	let total = shallowRuntimeCost(ir);
+	const children = fastChildren(ir);
+	switch (ir.type) {
+		case "array":
+		case "set":
+		case "record":
+		case "map":
+			for (const child of children) total += estimateRuntimeCost(child, cache) * ASSUMED_ELEMENTS;
+			break;
+		case "discriminatedUnion":
+			total += children.reduce((max, c) => Math.max(max, estimateRuntimeCost(c, cache)), 0);
+			break;
+		default:
+			for (const child of children) total += estimateRuntimeCost(child, cache);
+			break;
+	}
+	cache.set(ir, total);
+	return total;
 }
+//#endregion
+export { CALL_COST, EXTRACT_CAP, HOISTABLE, MIN_EXTRACT, estimateFastCost, orderByRuntimeCost, predictedInlineSize };
+
 //# sourceMappingURL=fast-size.js.map

package/dist/core/codegen/fast-size.js.map

@@ -1 +1 @@
-{"version":3,"file":"fast-size.js","sourceRoot":"","sources":["../../../src/core/codegen/fast-size.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fast-size.js","names":[],"sources":["../../../src/core/codegen/fast-size.ts"],"sourcesContent":["/**\n * Fast-path size estimation, used to bound the size of each emitted fast-check\n * function. V8's TurboFan refuses to optimize functions whose bytecode exceeds\n * ~60KB and falls back to the weaker Maglev tier — measured ~1.3-1.8x slower on\n * deeply-nested schemas whose monolithic fast-check crosses that budget. By\n * extracting large, self-contained sub-schemas into their own boolean helpers\n * (`generateFast`), each function stays small enough to TurboFan.\n *\n * `estimateFastCost` is a path-agnostic subtree estimate in approximate\n * generated-character units (it can't see the access-path prefix the node will\n * be emitted under, since that lives in the call site, not the IR). The actual\n * emitted size of an inlined node grows with that prefix length — `input[\"a\"]\n * [\"b\"][\"c\"]…` repeated per check — so the extraction decision scales the\n * estimate by `1 + inputLen/PATH_GROWTH_DIVISOR` (see `predictedInlineSize`).\n * The accumulator itself (generateFast) tracks EXACT emitted chars via the\n * returned string length, so only the look-ahead prediction is approximate.\n */\n\nimport type { SchemaIR } from \"../types.js\";\nimport type { CodeGenContext } from \"./context.js\";\n\n/**\n * Per-function soft size cap, in emitted characters. Once the fast-check being\n * assembled would exceed this, the next large hoistable sub-schema is split into\n * its own helper. Set below the ~60KB bytecode point where TurboFan bails (chars\n * over-approximate bytecode) with margin for one look-ahead mis-prediction.\n */\nexport const EXTRACT_CAP = 38_000;\n\n/**\n * Each nesting level lengthens every access path inside a node (`x[\"a\"]` →\n * `x[\"a\"][\"b\"]`), inflating real emitted chars above the path-agnostic estimate.\n * The extraction look-ahead multiplies the estimate by `1 + inputLen/this` so a\n * deep subtree is split before it inlines into an over-budget function. Smaller\n * ⇒ more eager splitting at depth. Calibrated against deeply-nested fixtures.\n */\nconst PATH_GROWTH_DIVISOR = 26;\n\n/**\n * Predicted emitted size of inlining `ir` at a call site whose input expression\n * is `inputLen` chars long — the path-agnostic subtree estimate scaled up for\n * the access-path prefix that estimate omits. Used only for the extract/inline\n * decision; the running total uses exact emitted lengths.\n */\nexport function predictedInlineSize(\n  ir: SchemaIR,\n  inputLen: number,\n  cache: WeakMap<SchemaIR, number>,\n): number {\n  return estimateFastCost(ir, cache) * (1 + inputLen / PATH_GROWTH_DIVISOR);\n}\n\n/**\n * Floor for extraction: never hoist a sub-schema smaller than this even when\n * the enclosing function is over the cap — a tiny helper trades a real call for\n * no optimization benefit. Only sub-schemas big enough to matter are split.\n */\nexport const MIN_EXTRACT = 1_200;\n\n/** Approximate size contributed to the enclosing function by an extracted call `__fo_N(expr)`. */\nexport const CALL_COST = 24;\n\n/**\n * Node types whose fast-check is a self-contained boolean over a single input\n * expression and large enough to be worth hoisting into `function f(p){return …}`.\n * Thin wrappers (optional/nullable/default/…) are omitted: their inner schema is\n * visited through `generateFast` and gets hoisted on its own when large.\n */\nexport const HOISTABLE: ReadonlySet<SchemaIR[\"type\"]> = new Set([\n  \"object\",\n  \"record\",\n  \"tuple\",\n  \"discriminatedUnion\",\n  \"union\",\n  \"intersection\",\n]);\n\n/** A node's own contribution to the emitted fast-check, EXCLUDING its children. */\nfunction shallowFastCost(ir: SchemaIR): number {\n  switch (ir.type) {\n    case \"object\":\n      return 50 + Object.keys(ir.properties).length * 25 + (ir.strict ? 120 : 0);\n    case \"string\":\n      return 20 + ir.checks.length * 35;\n    case \"number\":\n      return 25 + ir.checks.length * 30;\n    case \"bigint\":\n    case \"date\":\n      return 25 + (ir.checks?.length ?? 0) * 25;\n    case \"enum\":\n      return 15 + ir.values.length * 12;\n    case \"tuple\":\n      return 40 + ir.items.length * 15;\n    case \"union\":\n      return 12 + ir.options.length * 6;\n    case \"discriminatedUnion\":\n      return 45 + ir.cases.length * 12;\n    case \"array\":\n    case \"record\":\n    case \"set\":\n    case \"map\":\n      return 55;\n    case \"file\":\n    case \"templateLiteral\":\n      return 40;\n    case \"literal\":\n    case \"optional\":\n    case \"nullable\":\n    case \"default\":\n      return 22;\n    case \"recursiveRef\":\n    case \"recursionTarget\":\n      // Both emit just a call to a hosted helper; the target's `inner` is sized\n      // independently when its own helper body is generated, so it is NOT\n      // counted against the enclosing function here (see fastChildren).\n      return 15;\n    default:\n      return 18;\n  }\n}\n\n/** Child IR nodes that the fast generator recurses into (mirrors the fast schema generators). */\nfunction fastChildren(ir: SchemaIR): readonly SchemaIR[] {\n  switch (ir.type) {\n    case \"object\":\n      return Object.values(ir.properties);\n    case \"array\":\n      return [ir.element];\n    case \"tuple\":\n      return ir.rest !== null ? [...ir.items, ir.rest] : ir.items;\n    case \"record\":\n    case \"map\":\n      return [ir.keyType, ir.valueType];\n    case \"set\":\n      return [ir.valueType];\n    case \"union\":\n    case \"discriminatedUnion\":\n      return ir.options;\n    case \"intersection\":\n      return [ir.left, ir.right];\n    case \"pipe\":\n      return [ir.in, ir.out];\n    case \"optional\":\n    case \"nullable\":\n    case \"readonly\":\n    case \"default\":\n    case \"catch\":\n      return [ir.inner];\n    default:\n      return [];\n  }\n}\n\n/**\n * Estimated total size of a node's fast-check (the node plus everything inlined\n * beneath it). Memoized per IR node: schemas dedupe shared sub-trees and the\n * estimate is consulted at every nesting level, so without the cache a deep tree\n * would be re-walked quadratically.\n */\nexport function estimateFastCost(ir: SchemaIR, cache: WeakMap<SchemaIR, number>): number {\n  const cached = cache.get(ir);\n  if (cached !== undefined) return cached;\n  // Defensive cycle break (the IR is a tree today; recursiveRef is a leaf).\n  cache.set(ir, 0);\n  let total = shallowFastCost(ir);\n  for (const child of fastChildren(ir)) total += estimateFastCost(child, cache);\n  cache.set(ir, total);\n  return total;\n}\n\n// ─── Runtime cost (check ordering) ───────────────────────────────────────────\n\n/**\n * Assumed element count for unbounded collections, used only to weight a\n * container against its siblings when ordering an `&&` chain.\n */\nconst ASSUMED_ELEMENTS = 4;\n\n/** Runtime weight of one check on an already-type-confirmed value. */\nfunction checkRuntimeCost(kind: string): number {\n  switch (kind) {\n    // A `.test()` call costs ~9 ns of dispatch before it matches a character —\n    // an order of magnitude above every other check, and the reason ordering\n    // matters at all.\n    case \"string_format\":\n      return 100;\n    // Zero-capture user predicate: a real call, cheaper than a regex.\n    case \"refine_effect\":\n      return 20;\n    case \"includes\":\n    case \"starts_with\":\n    case \"ends_with\":\n      return 6;\n    case \"multiple_of\":\n    case \"bigint_multiple_of\":\n      return 4;\n    default:\n      // length/size/range comparisons: a load and a compare.\n      return 1;\n  }\n}\n\n/** A node's own runtime weight, EXCLUDING its children. */\nfunction shallowRuntimeCost(ir: SchemaIR): number {\n  switch (ir.type) {\n    case \"string\":\n    case \"number\":\n      return 2 + ir.checks.reduce((sum, c) => sum + checkRuntimeCost(c.kind), 0);\n    case \"bigint\":\n    case \"date\":\n      return 3 + (ir.checks?.length ?? 0);\n    case \"file\":\n      return 3 + (ir.checks?.length ?? 0) * 2;\n    case \"enum\":\n      // Inlined `===` chain (or one hashed lookup) — sub-nanosecond either way.\n      return 1 + Math.min(ir.values.length, 8);\n    case \"object\":\n      // Type guard, plus the strict pass's per-key membership test.\n      return 3 + (ir.strict === true ? Object.keys(ir.properties).length : 0);\n    case \"array\":\n    case \"set\":\n    case \"record\":\n    case \"map\":\n    case \"tuple\":\n      return 3;\n    case \"templateLiteral\":\n      return 100;\n    case \"recursiveRef\":\n    case \"recursionTarget\":\n      // A recursive call expands into an unknown amount of work; treat it as\n      // the most expensive sibling so it is probed last.\n      return 200;\n    default:\n      return 1;\n  }\n}\n\n/** estimateRuntimeCost against the per-compile memo hanging off the context. */\nfunction runtimeCostOf(ir: SchemaIR, ctx: CodeGenContext): number {\n  return estimateRuntimeCost(ir, (ctx.fastRuntimeCostCache ??= new WeakMap<SchemaIR, number>()));\n}\n\n/**\n * Sort a fast-check's sibling conjuncts (or union options) cheapest-first.\n * Returns a new array; ties keep source order (Array#sort is stable), so a\n * schema whose members all cost the same emits byte-identical output.\n */\nexport function orderByRuntimeCost<T>(\n  items: readonly T[],\n  irOf: (item: T) => SchemaIR,\n  ctx: CodeGenContext,\n): T[] {\n  if (items.length < 2) return [...items];\n  return [...items].sort((a, b) => runtimeCostOf(irOf(a), ctx) - runtimeCostOf(irOf(b), ctx));\n}\n\n/**\n * Estimated runtime cost of a node's fast-check, in arbitrary units calibrated\n * so a regex format check dominates a handful of type guards. Memoized per IR\n * node, like estimateFastCost — the estimate is consulted at every nesting\n * level, and shared sub-trees are common.\n *\n * Used to order the conjuncts of an `&&` chain cheapest-first. Accepting input\n * runs every conjunct regardless, so ordering is free there; REJECTING input\n * stops at the first false one, which is where a schema pays for probing a\n * `z.email()` before the `kind` literal that actually discriminates. Measured\n * on a 3-option union of objects that each declare `{email, kind, note}`:\n * 102 ns → 39 ns for an input matching the last option, and 102 ns → 6 ns for\n * one matching none.\n */\nfunction estimateRuntimeCost(ir: SchemaIR, cache: WeakMap<SchemaIR, number>): number {\n  const cached = cache.get(ir);\n  if (cached !== undefined) return cached;\n  cache.set(ir, 0); // cycle break (mirrors estimateFastCost)\n  let total = shallowRuntimeCost(ir);\n  const children = fastChildren(ir);\n  switch (ir.type) {\n    case \"array\":\n    case \"set\":\n    case \"record\":\n    case \"map\":\n      // Per-element work, repeated for an assumed handful of entries.\n      for (const child of children) total += estimateRuntimeCost(child, cache) * ASSUMED_ELEMENTS;\n      break;\n    case \"discriminatedUnion\":\n      // O(1) switch: only the matched case runs. Charge the priciest option so\n      // the estimate stays an upper bound.\n      total += children.reduce((max, c) => Math.max(max, estimateRuntimeCost(c, cache)), 0);\n      break;\n    default:\n      // object/tuple/union/intersection/wrappers: every child is on the path\n      // (a union probes options until one matches — worst case, all of them).\n      for (const child of children) total += estimateRuntimeCost(child, cache);\n      break;\n  }\n  cache.set(ir, total);\n  return total;\n}\n"],"mappings":"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"}

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

@@ -1,25 +1,25 @@
-import type { SchemaIR } from "../types.js";
-import type { CodeGenResult, CodegenMode } from "./context.js";
-import type { SharedSchemaPlan } from "./dedupe.js";
-export type { CodeGenResult } from "./context.js";
-export interface GenerateValidatorOptions {
-    refCount?: number;
-    /** Codegen output mode. Defaults to "inline". */
-    mode?: CodegenMode;
-    /**
-     * File-level shared slow-walk plan (schema deduplication). Applied only to
-     * mutation-free schemas, so shared walks stay on the deferred cold path.
-     */
-    sharedSchemas?: SharedSchemaPlan | undefined;
-    /**
-     * Compact mode (`output: "compact"`). Drop the compiled slow walk for
-     * mutation-free schemas with a TOTAL fast path and delegate the cold error
-     * path to the retained Zod schema (`__zcFinZ`). The fast (hot) path is
-     * unchanged; only the bulky error-collecting walk — 64–77% of generated
-     * bytes — is replaced by a few bytes of zod delegation. See
-     * {@link CodeGenResult.rootDelegateRefIndex}.
-     */
-    compact?: boolean | undefined;
+import { SchemaIR } from "../types.js";
+import { SharedSchemaPlan } from "./dedupe.js";
+import { CodeGenResult, CodegenMode } from "./context.js";
+//#region src/core/codegen/index.d.ts
+interface GenerateValidatorOptions {
+  refCount?: number;
+  /** Codegen output mode. Defaults to "inline". */
+  mode?: CodegenMode;
+  /**
+   * File-level shared slow-walk plan (schema deduplication). Applied only to
+   * mutation-free schemas, so shared walks stay on the deferred cold path.
+   */
+  sharedSchemas?: SharedSchemaPlan | undefined;
+  /**
+   * Compact mode (`output: "compact"`). Drop the compiled slow walk for
+   * mutation-free schemas with a TOTAL fast path and delegate the cold error
+   * path to the retained Zod schema (`__zcFinZ`). The fast (hot) path is
+   * unchanged; only the bulky error-collecting walk — 64–77% of generated
+   * bytes — is replaced by a few bytes of zod delegation. See
+   * {@link CodeGenResult.rootDelegateRefIndex}.
+   */
+  compact?: boolean | undefined;
 }
 /**
  * Generate optimized validation code from SchemaIR.
@@ -30,5 +30,7 @@ export interface GenerateValidatorOptions {
  *
  * Usage: `new Function(code + "\nreturn " + functionDef + ";")()`
  */
-export declare function generateValidator(ir: SchemaIR, name: string, options?: GenerateValidatorOptions): CodeGenResult;
+declare function generateValidator(ir: SchemaIR, name: string, options?: GenerateValidatorOptions): CodeGenResult;
+//#endregion
+export { type CodeGenResult, GenerateValidatorOptions, generateValidator };
 //# sourceMappingURL=index.d.ts.map

package/dist/core/codegen/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAkB,aAAa,EAAE,WAAW,EAAgB,MAAM,cAAc,CAAC;AAG7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC7C;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,wBAAwB,GACjC,aAAa,CAqYf"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/core/codegen/index.ts"],"mappings":";;;;UAUiB;EACf;;EAEA,OAAO;;;;;EAKP,gBAAgB;;;;;;;;;EAShB;;;;;;;;;;;iBAYc,kBACd,IAAI,UACJ,cACA,UAAU,2BACT"}