zod-compiler 1.23.0 → 1.23.2

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

@@ -1,13 +1,4 @@
-/**
- * Fast Path: produces a boolean expression string for eligible schemas.
- * When the expression evaluates to `true` at runtime, the input is valid and
- * safeParse can return success immediately without allocating an issues array.
- *
- * Returns `null` if the schema is not eligible for Fast Path (contains coerce,
- * default, transform, or other non-pure constructs).
- */
 import { declareFastTemps, emitRegex, emitTemp } from "./context.js";
-import { CALL_COST, EXTRACT_CAP, estimateFastCost, HOISTABLE, MIN_EXTRACT, predictedInlineSize, } from "./fast-size.js";
 import { fastAny } from "./schemas/any.js";
 import { fastArray } from "./schemas/array.js";
 import { fastBigInt } from "./schemas/bigint.js";
@@ -18,6 +9,7 @@ import { fastDefault } from "./schemas/default.js";
 import { fastDiscriminatedUnion } from "./schemas/discriminated-union.js";
 import { fastEnum } from "./schemas/enum.js";
 import { fastFile } from "./schemas/file.js";
+import { HOISTABLE, estimateFastCost, predictedInlineSize } from "./fast-size.js";
 import { fastIntersection } from "./schemas/intersection.js";
 import { fastLiteral } from "./schemas/literal.js";
 import { fastMap } from "./schemas/map.js";
@@ -41,149 +33,128 @@ import { fastUndefined } from "./schemas/undefined.js";
 import { fastUnion } from "./schemas/union.js";
 import { fastUnknown } from "./schemas/unknown.js";
 import { fastVoid } from "./schemas/void.js";
-// ─── Typed registry ─────────────────────────────────────────────────────────
-// `null` = statically ineligible (the type NEVER has a fast path).
-// Non-null function = may return null at runtime (dynamically ineligible, e.g. when coerce is present).
+//#region src/core/codegen/fast-path.ts
 const fastRegistry = {
-    // Primitives (order follows SchemaIR union in types.ts)
-    string: fastString,
-    number: fastNumber,
-    boolean: fastBoolean,
-    bigint: fastBigInt,
-    date: fastDate,
-    symbol: fastSymbol,
-    null: fastNull,
-    undefined: fastUndefined,
-    void: fastVoid,
-    nan: fastNan,
-    never: fastNever,
-    any: fastAny,
-    unknown: fastUnknown,
-    literal: fastLiteral,
-    enum: fastEnum,
-    // Containers
-    object: fastObject,
-    array: fastArray,
-    tuple: fastTuple,
-    record: fastRecord,
-    set: fastSet,
-    map: fastMap,
-    file: fastFile,
-    // Unions & Intersections
-    union: fastUnion,
-    discriminatedUnion: fastDiscriminatedUnion,
-    intersection: fastIntersection,
-    // Modifiers
-    optional: fastOptional,
-    nullable: fastNullable,
-    readonly: fastReadonly,
-    default: fastDefault,
-    pipe: fastPipe,
-    // Effects
-    effect: null, // statically ineligible
-    // Special
-    templateLiteral: fastTemplateLiteral,
-    catch: fastCatch,
-    fallback: null, // statically ineligible
-    recursiveRef: fastRecursiveRef,
-    recursionTarget: fastRecursionTarget,
-    stringBool: null, // statically ineligible — output type (boolean) differs from input (string)
+	string: fastString,
+	number: fastNumber,
+	boolean: fastBoolean,
+	bigint: fastBigInt,
+	date: fastDate,
+	symbol: fastSymbol,
+	null: fastNull,
+	undefined: fastUndefined,
+	void: fastVoid,
+	nan: fastNan,
+	never: fastNever,
+	any: fastAny,
+	unknown: fastUnknown,
+	literal: fastLiteral,
+	enum: fastEnum,
+	object: fastObject,
+	array: fastArray,
+	tuple: fastTuple,
+	record: fastRecord,
+	set: fastSet,
+	map: fastMap,
+	file: fastFile,
+	union: fastUnion,
+	discriminatedUnion: fastDiscriminatedUnion,
+	intersection: fastIntersection,
+	optional: fastOptional,
+	nullable: fastNullable,
+	readonly: fastReadonly,
+	default: fastDefault,
+	pipe: fastPipe,
+	effect: null,
+	templateLiteral: fastTemplateLiteral,
+	catch: fastCatch,
+	fallback: null,
+	recursiveRef: fastRecursiveRef,
+	recursionTarget: fastRecursionTarget,
+	stringBool: null
 };
-// ─── Factory ─────────────────────────────────────────────────────────────────
 /**
- * @param inputExpr  the input expression this node validates
- * @param ctx        shared codegen context
- * @param extractable whether THIS node may be hoisted (false for the root and a
- *   helper's own top node — see generateFast); children are always extractable
- * @param scope      size accumulator for the function being assembled (a child
- *   visit shares the parent's scope; a hoisted helper body gets a fresh one)
- * @param discSkipKey discriminated-union option marker (see FastGen.discSkipKey);
- *   carried only on the option's own node, never auto-propagated to children
- */
-export function createFastGen(inputExpr, ctx, extractable = false, scope = { temps: [], used: 0 }, discSkipKey) {
-    return {
-        input: inputExpr,
-        ctx,
-        extractable,
-        scope,
-        discSkipKey,
-        visit(ir, overrides) {
-            // A child shares this function's scope and is itself extractable. The
-            // discriminated-union skip is NOT inherited implicitly — only a caller
-            // that explicitly passes overrides.discSkipKey (fastDiscriminatedUnion)
-            // sets it, so nested objects keep their own type-guard.
-            return generateFast(ir, createFastGen(overrides?.input ?? inputExpr, ctx, true, scope, overrides?.discSkipKey));
-        },
-        scoped: (input) => createFastGen(input, ctx, true, { temps: [], used: 0 }),
-        temp: (prefix) => emitTemp(ctx, prefix),
-        local(prefix) {
-            const name = emitTemp(ctx, prefix);
-            scope.temps.push(name);
-            return name;
-        },
-        regex: (prefix, pattern, flags) => emitRegex(ctx, prefix, pattern, flags),
-    };
+* @param inputExpr  the input expression this node validates
+* @param ctx        shared codegen context
+* @param extractable whether THIS node may be hoisted (false for the root and a
+*   helper's own top node — see generateFast); children are always extractable
+* @param scope      size accumulator for the function being assembled (a child
+*   visit shares the parent's scope; a hoisted helper body gets a fresh one)
+* @param discSkipKey discriminated-union option marker (see FastGen.discSkipKey);
+*   carried only on the option's own node, never auto-propagated to children
+*/
+function createFastGen(inputExpr, ctx, extractable = false, scope = {
+	temps: [],
+	used: 0
+}, discSkipKey) {
+	return {
+		input: inputExpr,
+		ctx,
+		extractable,
+		scope,
+		discSkipKey,
+		visit(ir, overrides) {
+			return generateFast(ir, createFastGen(overrides?.input ?? inputExpr, ctx, true, scope, overrides?.discSkipKey));
+		},
+		scoped: (input) => createFastGen(input, ctx, true, {
+			temps: [],
+			used: 0
+		}),
+		temp: (prefix) => emitTemp(ctx, prefix),
+		local(prefix) {
+			const name = emitTemp(ctx, prefix);
+			scope.temps.push(name);
+			return name;
+		},
+		regex: (prefix, pattern, flags) => emitRegex(ctx, prefix, pattern, flags)
+	};
 }
-// ─── Dispatch ────────────────────────────────────────────────────────────────
 /**
- * Generate a boolean expression string that validates input against the schema.
- * Returns `null` if the schema (or any nested part) is not eligible for fast checking.
- *
- * Size-gated extraction: when inlining `ir` would push the function being
- * assembled past EXTRACT_CAP, it is hoisted into its own boolean helper
- * `function __fo_N(p){return <expr over p>;}` and replaced by a call. This keeps
- * every emitted function under V8's TurboFan optimization budget — a single
- * giant fast-check otherwise drops to the slower Maglev tier (measured ~3-4.5x
- * on deeply-nested schemas). The running total `g.scope.used` is EXACT emitted
- * chars (the returned string's length); only the extract look-ahead is an
- * estimate, scaled for access-path length. Small schemas never approach the
- * cap, so their output is byte-identical to the fully-inlined form; large
- * aggregates do split (still semantically identical — only the boolean's shape
- * changes).
- */
-export function generateFast(ir, g) {
-    const gen = fastRegistry[ir.type];
-    if (gen === null)
-        return null;
-    if (g.extractable && HOISTABLE.has(ir.type)) {
-        const cache = fastSizeCache(g.ctx);
-        const overBudget = g.scope.used + predictedInlineSize(ir, g.input.length, cache) > EXTRACT_CAP;
-        // Extract a sub-schema big enough to be worth a call; but once the function
-        // is ALREADY over budget, extract any hoistable child regardless of size —
-        // otherwise a crowd of small siblings (e.g. a discriminated union of many
-        // small options) grows the function unbounded since none alone clears
-        // MIN_EXTRACT.
-        if (overBudget && (g.scope.used > EXTRACT_CAP || estimateFastCost(ir, cache) >= MIN_EXTRACT)) {
-            const param = emitTemp(g.ctx, "op");
-            // Generate the body relative to the helper's parameter, in a fresh scope;
-            // the top node is non-extractable (it IS this helper) while its children
-            // stay extractable, so an oversized helper splits further recursively.
-            // Carry discSkipKey so an extracted discriminated-union option still drops
-            // its redundant guard inside the hoisted helper.
-            const innerGen = createFastGen(param, g.ctx, false, { temps: [], used: 0 }, g.discSkipKey);
-            const inner = generateFast(ir, innerGen);
-            if (inner === null)
-                return null; // ineligible sub-schema disables the whole fast path
-            const fnName = emitTemp(g.ctx, "fo");
-            g.ctx.preamble.push(`function ${fnName}(${param}){${declareFastTemps(innerGen.scope)}return ${inner};}`);
-            g.scope.used += CALL_COST;
-            return `${fnName}(${g.input})`;
-        }
-    }
-    // Inlined: charge the enclosing function this node's EXACT emitted size. The
-    // node's own text plus its inlined descendants is exactly the returned string;
-    // children mutated the shared scope as they were visited, but the parent's
-    // length is authoritative, so overwrite rather than add.
-    const before = g.scope.used;
-    // oxlint-disable-next-line typescript/no-explicit-any -- registry dispatch requires type erasure at call site
-    const out = gen(ir, g);
-    if (out === null)
-        return null;
-    g.scope.used = before + out.length;
-    return out;
+* Generate a boolean expression string that validates input against the schema.
+* Returns `null` if the schema (or any nested part) is not eligible for fast checking.
+*
+* Size-gated extraction: when inlining `ir` would push the function being
+* assembled past EXTRACT_CAP, it is hoisted into its own boolean helper
+* `function __fo_N(p){return <expr over p>;}` and replaced by a call. This keeps
+* every emitted function under V8's TurboFan optimization budget — a single
+* giant fast-check otherwise drops to the slower Maglev tier (measured ~3-4.5x
+* on deeply-nested schemas). The running total `g.scope.used` is EXACT emitted
+* chars (the returned string's length); only the extract look-ahead is an
+* estimate, scaled for access-path length. Small schemas never approach the
+* cap, so their output is byte-identical to the fully-inlined form; large
+* aggregates do split (still semantically identical — only the boolean's shape
+* changes).
+*/
+function generateFast(ir, g) {
+	const gen = fastRegistry[ir.type];
+	if (gen === null) return null;
+	if (g.extractable && HOISTABLE.has(ir.type)) {
+		const cache = fastSizeCache(g.ctx);
+		if (g.scope.used + predictedInlineSize(ir, g.input.length, cache) > 38e3 && (g.scope.used > 38e3 || estimateFastCost(ir, cache) >= 1200)) {
+			const param = emitTemp(g.ctx, "op");
+			const innerGen = createFastGen(param, g.ctx, false, {
+				temps: [],
+				used: 0
+			}, g.discSkipKey);
+			const inner = generateFast(ir, innerGen);
+			if (inner === null) return null;
+			const fnName = emitTemp(g.ctx, "fo");
+			g.ctx.preamble.push(`function ${fnName}(${param}){${declareFastTemps(innerGen.scope)}return ${inner};}`);
+			g.scope.used += 24;
+			return `${fnName}(${g.input})`;
+		}
+	}
+	const before = g.scope.used;
+	const out = gen(ir, g);
+	if (out === null) return null;
+	g.scope.used = before + out.length;
+	return out;
 }
 /** Per-compile memo for estimateFastCost, stashed on the shared context. */
 function fastSizeCache(ctx) {
-    return (ctx.fastSizeCache ??= new WeakMap());
+	return ctx.fastSizeCache ??= /* @__PURE__ */ new WeakMap();
 }
+//#endregion
+export { createFastGen, generateFast };
+
 //# sourceMappingURL=fast-path.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"fast-path.js","sourceRoot":"","sources":["../../../src/core/codegen/fast-path.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fast-path.js","names":[],"sources":["../../../src/core/codegen/fast-path.ts"],"sourcesContent":["/**\n * Fast Path: produces a boolean expression string for eligible schemas.\n * When the expression evaluates to `true` at runtime, the input is valid and\n * safeParse can return success immediately without allocating an issues array.\n *\n * Returns `null` if the schema is not eligible for Fast Path (contains coerce,\n * default, transform, or other non-pure constructs).\n */\n\nimport type { SchemaIR } from \"../types.js\";\nimport type { CodeGenContext, FastGen, FastGenerator, FastScope } from \"./context.js\";\nimport { declareFastTemps, emitRegex, emitTemp } from \"./context.js\";\nimport {\n  CALL_COST,\n  EXTRACT_CAP,\n  estimateFastCost,\n  HOISTABLE,\n  MIN_EXTRACT,\n  predictedInlineSize,\n} from \"./fast-size.js\";\nimport { fastAny } from \"./schemas/any.js\";\nimport { fastArray } from \"./schemas/array.js\";\nimport { fastBigInt } from \"./schemas/bigint.js\";\nimport { fastBoolean } from \"./schemas/boolean.js\";\nimport { fastCatch } from \"./schemas/catch.js\";\nimport { fastDate } from \"./schemas/date.js\";\nimport { fastDefault } from \"./schemas/default.js\";\nimport { fastDiscriminatedUnion } from \"./schemas/discriminated-union.js\";\nimport { fastEnum } from \"./schemas/enum.js\";\nimport { fastFile } from \"./schemas/file.js\";\nimport { fastIntersection } from \"./schemas/intersection.js\";\nimport { fastLiteral } from \"./schemas/literal.js\";\nimport { fastMap } from \"./schemas/map.js\";\nimport { fastNan } from \"./schemas/nan.js\";\nimport { fastNever } from \"./schemas/never.js\";\nimport { fastNull } from \"./schemas/null.js\";\nimport { fastNullable } from \"./schemas/nullable.js\";\nimport { fastNumber } from \"./schemas/number.js\";\nimport { fastObject } from \"./schemas/object.js\";\nimport { fastOptional } from \"./schemas/optional.js\";\nimport { fastPipe } from \"./schemas/pipe.js\";\nimport { fastReadonly } from \"./schemas/readonly.js\";\nimport { fastRecord } from \"./schemas/record.js\";\nimport { fastRecursionTarget, fastRecursiveRef } from \"./schemas/recursive-ref.js\";\nimport { fastSet } from \"./schemas/set.js\";\nimport { fastString } from \"./schemas/string.js\";\nimport { fastSymbol } from \"./schemas/symbol.js\";\nimport { fastTemplateLiteral } from \"./schemas/template-literal.js\";\nimport { fastTuple } from \"./schemas/tuple.js\";\nimport { fastUndefined } from \"./schemas/undefined.js\";\nimport { fastUnion } from \"./schemas/union.js\";\nimport { fastUnknown } from \"./schemas/unknown.js\";\nimport { fastVoid } from \"./schemas/void.js\";\n\n// ─── Typed registry ─────────────────────────────────────────────────────────\n// `null` = statically ineligible (the type NEVER has a fast path).\n// Non-null function = may return null at runtime (dynamically ineligible, e.g. when coerce is present).\n\nconst fastRegistry = {\n  // Primitives (order follows SchemaIR union in types.ts)\n  string: fastString,\n  number: fastNumber,\n  boolean: fastBoolean,\n  bigint: fastBigInt,\n  date: fastDate,\n  symbol: fastSymbol,\n  null: fastNull,\n  undefined: fastUndefined,\n  void: fastVoid,\n  nan: fastNan,\n  never: fastNever,\n  any: fastAny,\n  unknown: fastUnknown,\n  literal: fastLiteral,\n  enum: fastEnum,\n  // Containers\n  object: fastObject,\n  array: fastArray,\n  tuple: fastTuple,\n  record: fastRecord,\n  set: fastSet,\n  map: fastMap,\n  file: fastFile,\n  // Unions & Intersections\n  union: fastUnion,\n  discriminatedUnion: fastDiscriminatedUnion,\n  intersection: fastIntersection,\n  // Modifiers\n  optional: fastOptional,\n  nullable: fastNullable,\n  readonly: fastReadonly,\n  default: fastDefault,\n  pipe: fastPipe,\n  // Effects\n  effect: null, // statically ineligible\n  // Special\n  templateLiteral: fastTemplateLiteral,\n  catch: fastCatch,\n  fallback: null, // statically ineligible\n  recursiveRef: fastRecursiveRef,\n  recursionTarget: fastRecursionTarget,\n  stringBool: null, // statically ineligible — output type (boolean) differs from input (string)\n} satisfies {\n  [K in SchemaIR[\"type\"]]: FastGenerator<Extract<SchemaIR, { type: K }>> | null;\n};\n\n// ─── Factory ─────────────────────────────────────────────────────────────────\n\n/**\n * @param inputExpr  the input expression this node validates\n * @param ctx        shared codegen context\n * @param extractable whether THIS node may be hoisted (false for the root and a\n *   helper's own top node — see generateFast); children are always extractable\n * @param scope      size accumulator for the function being assembled (a child\n *   visit shares the parent's scope; a hoisted helper body gets a fresh one)\n * @param discSkipKey discriminated-union option marker (see FastGen.discSkipKey);\n *   carried only on the option's own node, never auto-propagated to children\n */\nexport function createFastGen(\n  inputExpr: string,\n  ctx: CodeGenContext,\n  extractable = false,\n  scope: FastScope = { temps: [], used: 0 },\n  discSkipKey?: string,\n): FastGen {\n  return {\n    input: inputExpr,\n    ctx,\n    extractable,\n    scope,\n    discSkipKey,\n    visit(ir, overrides) {\n      // A child shares this function's scope and is itself extractable. The\n      // discriminated-union skip is NOT inherited implicitly — only a caller\n      // that explicitly passes overrides.discSkipKey (fastDiscriminatedUnion)\n      // sets it, so nested objects keep their own type-guard.\n      return generateFast(\n        ir,\n        createFastGen(overrides?.input ?? inputExpr, ctx, true, scope, overrides?.discSkipKey),\n      );\n    },\n    scoped: (input) => createFastGen(input, ctx, true, { temps: [], used: 0 }),\n    temp: (prefix) => emitTemp(ctx, prefix),\n    local(prefix) {\n      const name = emitTemp(ctx, prefix);\n      scope.temps.push(name);\n      return name;\n    },\n    regex: (prefix, pattern, flags) => emitRegex(ctx, prefix, pattern, flags),\n  };\n}\n\n// ─── Dispatch ────────────────────────────────────────────────────────────────\n\n/**\n * Generate a boolean expression string that validates input against the schema.\n * Returns `null` if the schema (or any nested part) is not eligible for fast checking.\n *\n * Size-gated extraction: when inlining `ir` would push the function being\n * assembled past EXTRACT_CAP, it is hoisted into its own boolean helper\n * `function __fo_N(p){return <expr over p>;}` and replaced by a call. This keeps\n * every emitted function under V8's TurboFan optimization budget — a single\n * giant fast-check otherwise drops to the slower Maglev tier (measured ~3-4.5x\n * on deeply-nested schemas). The running total `g.scope.used` is EXACT emitted\n * chars (the returned string's length); only the extract look-ahead is an\n * estimate, scaled for access-path length. Small schemas never approach the\n * cap, so their output is byte-identical to the fully-inlined form; large\n * aggregates do split (still semantically identical — only the boolean's shape\n * changes).\n */\nexport function generateFast(ir: SchemaIR, g: FastGen): string | null {\n  const gen = fastRegistry[ir.type];\n  if (gen === null) return null;\n\n  if (g.extractable && HOISTABLE.has(ir.type)) {\n    const cache = fastSizeCache(g.ctx);\n    const overBudget = g.scope.used + predictedInlineSize(ir, g.input.length, cache) > EXTRACT_CAP;\n    // Extract a sub-schema big enough to be worth a call; but once the function\n    // is ALREADY over budget, extract any hoistable child regardless of size —\n    // otherwise a crowd of small siblings (e.g. a discriminated union of many\n    // small options) grows the function unbounded since none alone clears\n    // MIN_EXTRACT.\n    if (overBudget && (g.scope.used > EXTRACT_CAP || estimateFastCost(ir, cache) >= MIN_EXTRACT)) {\n      const param = emitTemp(g.ctx, \"op\");\n      // Generate the body relative to the helper's parameter, in a fresh scope;\n      // the top node is non-extractable (it IS this helper) while its children\n      // stay extractable, so an oversized helper splits further recursively.\n      // Carry discSkipKey so an extracted discriminated-union option still drops\n      // its redundant guard inside the hoisted helper.\n      const innerGen = createFastGen(param, g.ctx, false, { temps: [], used: 0 }, g.discSkipKey);\n      const inner = generateFast(ir, innerGen);\n      if (inner === null) return null; // ineligible sub-schema disables the whole fast path\n      const fnName = emitTemp(g.ctx, \"fo\");\n      g.ctx.preamble.push(\n        `function ${fnName}(${param}){${declareFastTemps(innerGen.scope)}return ${inner};}`,\n      );\n      g.scope.used += CALL_COST;\n      return `${fnName}(${g.input})`;\n    }\n  }\n\n  // Inlined: charge the enclosing function this node's EXACT emitted size. The\n  // node's own text plus its inlined descendants is exactly the returned string;\n  // children mutated the shared scope as they were visited, but the parent's\n  // length is authoritative, so overwrite rather than add.\n  const before = g.scope.used;\n  // oxlint-disable-next-line typescript/no-explicit-any -- registry dispatch requires type erasure at call site\n  const out = (gen as any)(ir, g) as string | null;\n  if (out === null) return null;\n  g.scope.used = before + out.length;\n  return out;\n}\n\n/** Per-compile memo for estimateFastCost, stashed on the shared context. */\nfunction fastSizeCache(ctx: CodeGenContext): WeakMap<SchemaIR, number> {\n  return (ctx.fastSizeCache ??= new WeakMap<SchemaIR, number>());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,MAAM,eAAe;CAEnB,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,MAAM;CACN,QAAQ;CACR,MAAM;CACN,WAAW;CACX,MAAM;CACN,KAAK;CACL,OAAO;CACP,KAAK;CACL,SAAS;CACT,SAAS;CACT,MAAM;CAEN,QAAQ;CACR,OAAO;CACP,OAAO;CACP,QAAQ;CACR,KAAK;CACL,KAAK;CACL,MAAM;CAEN,OAAO;CACP,oBAAoB;CACpB,cAAc;CAEd,UAAU;CACV,UAAU;CACV,UAAU;CACV,SAAS;CACT,MAAM;CAEN,QAAQ;CAER,iBAAiB;CACjB,OAAO;CACP,UAAU;CACV,cAAc;CACd,iBAAiB;CACjB,YAAY;AACd;;;;;;;;;;;AAgBA,SAAgB,cACd,WACA,KACA,cAAc,OACd,QAAmB;CAAE,OAAO,CAAC;CAAG,MAAM;AAAE,GACxC,aACS;CACT,OAAO;EACL,OAAO;EACP;EACA;EACA;EACA;EACA,MAAM,IAAI,WAAW;GAKnB,OAAO,aACL,IACA,cAAc,WAAW,SAAS,WAAW,KAAK,MAAM,OAAO,WAAW,WAAW,CACvF;EACF;EACA,SAAS,UAAU,cAAc,OAAO,KAAK,MAAM;GAAE,OAAO,CAAC;GAAG,MAAM;EAAE,CAAC;EACzE,OAAO,WAAW,SAAS,KAAK,MAAM;EACtC,MAAM,QAAQ;GACZ,MAAM,OAAO,SAAS,KAAK,MAAM;GACjC,MAAM,MAAM,KAAK,IAAI;GACrB,OAAO;EACT;EACA,QAAQ,QAAQ,SAAS,UAAU,UAAU,KAAK,QAAQ,SAAS,KAAK;CAC1E;AACF;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAa,IAAc,GAA2B;CACpE,MAAM,MAAM,aAAa,GAAG;CAC5B,IAAI,QAAQ,MAAM,OAAO;CAEzB,IAAI,EAAE,eAAe,UAAU,IAAI,GAAG,IAAI,GAAG;EAC3C,MAAM,QAAQ,cAAc,EAAE,GAAG;EAOjC,IANmB,EAAE,MAAM,OAAO,oBAAoB,IAAI,EAAE,MAAM,QAAQ,KAAK,IAAA,SAM5D,EAAE,MAAM,OAAA,QAAsB,iBAAiB,IAAI,KAAK,KAAA,OAAmB;GAC5F,MAAM,QAAQ,SAAS,EAAE,KAAK,IAAI;GAMlC,MAAM,WAAW,cAAc,OAAO,EAAE,KAAK,OAAO;IAAE,OAAO,CAAC;IAAG,MAAM;GAAE,GAAG,EAAE,WAAW;GACzF,MAAM,QAAQ,aAAa,IAAI,QAAQ;GACvC,IAAI,UAAU,MAAM,OAAO;GAC3B,MAAM,SAAS,SAAS,EAAE,KAAK,IAAI;GACnC,EAAE,IAAI,SAAS,KACb,YAAY,OAAO,GAAG,MAAM,IAAI,iBAAiB,SAAS,KAAK,EAAE,SAAS,MAAM,GAClF;GACA,EAAE,MAAM,QAAA;GACR,OAAO,GAAG,OAAO,GAAG,EAAE,MAAM;EAC9B;CACF;CAMA,MAAM,SAAS,EAAE,MAAM;CAEvB,MAAM,MAAO,IAAY,IAAI,CAAC;CAC9B,IAAI,QAAQ,MAAM,OAAO;CACzB,EAAE,MAAM,OAAO,SAAS,IAAI;CAC5B,OAAO;AACT;;AAGA,SAAS,cAAc,KAAgD;CACrE,OAAQ,IAAI,kCAAkB,IAAI,QAA0B;AAC9D"}

package/dist/core/codegen/fast-size.d.ts

@@ -1,62 +1,48 @@
-/**
- * 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.
- */
-import type { SchemaIR } from "../types.js";
-import type { CodeGenContext } from "./context.js";
+import { SchemaIR } from "../types.js";
+import { CodeGenContext } from "./context.js";
+//#region src/core/codegen/fast-size.d.ts
 /**
  * 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 declare const EXTRACT_CAP = 38000;
+declare const EXTRACT_CAP = 38000;
 /**
  * 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 declare function predictedInlineSize(ir: SchemaIR, inputLen: number, cache: WeakMap<SchemaIR, number>): number;
+declare function predictedInlineSize(ir: SchemaIR, inputLen: number, cache: WeakMap<SchemaIR, number>): number;
 /**
  * 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 declare const MIN_EXTRACT = 1200;
+declare const MIN_EXTRACT = 1200;
 /** Approximate size contributed to the enclosing function by an extracted call `__fo_N(expr)`. */
-export declare const CALL_COST = 24;
+declare 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 declare const HOISTABLE: ReadonlySet<SchemaIR["type"]>;
+declare const HOISTABLE: ReadonlySet<SchemaIR["type"]>;
 /**
  * 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 declare function estimateFastCost(ir: SchemaIR, cache: WeakMap<SchemaIR, number>): number;
+declare function estimateFastCost(ir: SchemaIR, cache: WeakMap<SchemaIR, number>): number;
 /**
  * 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 declare function orderByRuntimeCost<T>(items: readonly T[], irOf: (item: T) => SchemaIR, ctx: CodeGenContext): T[];
+declare function orderByRuntimeCost<T>(items: readonly T[], irOf: (item: T) => SchemaIR, ctx: CodeGenContext): T[];
+//#endregion
+export { CALL_COST, EXTRACT_CAP, HOISTABLE, MIN_EXTRACT, estimateFastCost, orderByRuntimeCost, predictedInlineSize };
 //# sourceMappingURL=fast-size.d.ts.map

package/dist/core/codegen/fast-size.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fast-size.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/fast-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,QAAS,CAAC;AAWlC;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,QAAQ,EACZ,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,GAC/B,MAAM,CAER;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,OAAQ,CAAC;AAEjC,kGAAkG;AAClG,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAOlD,CAAC;AA8EH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,CASvF;AA0ED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,QAAQ,EAC3B,GAAG,EAAE,cAAc,GAClB,CAAC,EAAE,CAGL"}
+{"version":3,"file":"fast-size.d.ts","names":[],"sources":["../../../src/core/codegen/fast-size.ts"],"mappings":";;;;;;;;;cA2Ba;;;;;;;iBAiBG,oBACd,IAAI,UACJ,kBACA,OAAO,QAAQ;;;;;;cAUJ;;cAGA;;;;;;;cAQA,WAAW,YAAY;;;;;;;iBA2FpB,iBAAiB,IAAI,UAAU,OAAO,QAAQ;;;;;;iBAwF9C,mBAAmB,GACjC,gBAAgB,KAChB,OAAO,MAAM,MAAM,UACnB,KAAK,iBACJ"}