zod-compiler 1.23.1 → 1.23.3

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

@@ -1,642 +1,580 @@
-/**
- * Build Path: one uninstrumented pass that VALIDATES and BUILDS the stripped
- * output together, abandoning the whole parse at the first failing check.
- *
- * `z.object()` strips unknown keys, so a successful parse cannot return the
- * input by reference — it must produce a fresh object. That rules out the Fast
- * Path (whose contract is `data === input`), and before this the only remaining
- * option was the eager slow walk: a fully instrumented traversal that collects
- * issues on every parse, valid or not.
- *
- * Two passes are wasteful in either direction. Validating first and building
- * afterwards reads every property twice (measured 29.7 ns vs 21.6 for the slow
- * walk on a 6-field object). Building with issue collection pays the
- * instrumentation even when nothing fails. Doing both in ONE pass, with a
- * sentinel instead of an issues array, beats both — and a failure costs only
- * the checks up to the first bad one, because the issue-producing walk is
- * deferred into `.error` exactly as `__zcFinD` does for mutation-free schemas:
- *
- *              object clean   object invalid   array(8) invalid
- *   slow walk       21.6 ns         30.4 ns           197.5 ns
- *   build path      18.1 ns          7.7 ns             9.8 ns
- *
- * A subtree that rebuilds nothing is validated with its existing Fast Path
- * expression and passed through by reference, so only nodes that genuinely
- * produce a new value need code here; anything else returns null and keeps the
- * eager walk.
- *
- * Coverage is what decides whether this pass is reached at all, because it is
- * all-or-nothing per schema: ONE unmodelled node anywhere in the tree costs the
- * whole schema its single-pass parse. Modelled, beyond the stripping containers
- * this started with: array size checks and `.refine()`, object-level `.refine()`,
- * `.default()` substitution, ordered string rewrites (`.trim()`,
- * `.toLowerCase()`), and sync `.transform()`. Still declined, via
- * {@link mutatesBeyondStrip} — coerce, `.catch()` (its callback wants the inner
- * schema's issue list, which this pass never builds), `z.url()`, and
- * `superRefine`.
- */
-import { declareFastTemps, emitEffectCallable, emitEffectFn, emitRuntimeHelper, emitTemp, escapeString, keyMembershipTest, outputAlwaysDefined, rejectsUndefined, } from "./context.js";
-import { createFastGen, generateFast } from "./fast-path.js";
-import { EXTRACT_CAP, estimateFastCost, MIN_EXTRACT, predictedInlineSize } from "./fast-size.js";
+import { declareFastTemps, emitEffectCallable, emitEffectFn, emitRuntimeHelper, emitTemp, escapeString, keyMembershipTest, outputAlwaysDefined, rejectsUndefined } from "./context.js";
 import { ZC_HOP_DECL } from "./issue-decls.js";
 import { defaultValueExpr, needsPostInnerDefault } from "./schemas/default.js";
+import { estimateFastCost, predictedInlineSize } from "./fast-size.js";
 import { innerAppliesDefaultOnUndefined } from "./schemas/optional.js";
 import { fastStringCheck } from "./schemas/string.js";
+import { emitStringBoolMap, stringBoolUsesInline } from "./schemas/string-bool.js";
+import { createFastGen, generateFast } from "./fast-path.js";
+//#region src/core/codegen/build-path.ts
 /**
- * Which nodes of `root` produce a value that is not their input — i.e. are, or
- * contain, a stripping object. Everything else can be validated in place and
- * passed through, which is what keeps this generator small.
- *
- * Computed as a fixpoint rather than a plain walk because of recursion: a
- * `recursiveRef` is a back-edge with no children, so a local walk reads false
- * for it and would pass the whole recursive subtree through by reference —
- * leaving every nested value unstripped while the outermost one was rebuilt.
- * Resolving the ref against its target closes the cycle, and iterating to a
- * fixpoint settles the mutual dependency between the two.
- */
+* Which nodes of `root` produce a value that is not their input — a stripping
+* object, coercion, codec, default, overwrite or transform, including
+* containers that contain one. Everything else can be validated in place and
+* passed through, which is what keeps this generator small.
+*
+* Computed as a fixpoint rather than a plain walk because of recursion: a
+* `recursiveRef` is a back-edge with no children, so a local walk reads false
+* for it and would pass the whole recursive subtree through by reference —
+* leaving every nested value unstripped while the outermost one was rebuilt.
+* Resolving the ref against its target closes the cycle, and iterating to a
+* fixpoint settles the mutual dependency between the two.
+*/
 function rebuildSet(root) {
-    const targets = new Map([[0, root]]);
-    const nodes = [];
-    const seen = new Set();
-    const collect = (node) => {
-        if (seen.has(node))
-            return;
-        seen.add(node);
-        nodes.push(node);
-        if (node.type === "recursionTarget")
-            targets.set(node.refId, node.inner);
-        for (const child of children(node))
-            collect(child);
-    };
-    collect(root);
-    const rebuilds = new Set();
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const node of nodes) {
-            if (rebuilds.has(node))
-                continue;
-            const target = node.type === "recursiveRef" ? targets.get(node.refId ?? 0) : undefined;
-            const rebuild = (node.type === "object" && node.stripUnknownKeys === true) ||
-                // `.default()` substitutes its own value for `undefined`, so its output
-                // is not its input even when the inner schema passes through — it must
-                // never be handed to `passthrough`, whose fast check would reject the
-                // absent value outright.
-                node.type === "default" ||
-                // An overwrite effect (`.trim()`, `.toLowerCase()`) rewrites the string,
-                // so the node's output is a new value: it has to be BUILT rather than
-                // validated in place (see buildString).
-                (node.type === "string" && node.checks.some((c) => c.kind === "overwrite_effect")) ||
-                // `.transform(fn)` replaces the value with the callback's result.
-                node.type === "effect" ||
-                (target !== undefined && rebuilds.has(target)) ||
-                children(node).some((child) => rebuilds.has(child));
-            if (rebuild) {
-                rebuilds.add(node);
-                changed = true;
-            }
-        }
-    }
-    return rebuilds;
+	const targets = /* @__PURE__ */ new Map([[0, root]]);
+	const nodes = [];
+	const seen = /* @__PURE__ */ new Set();
+	const collect = (node) => {
+		if (seen.has(node)) return;
+		seen.add(node);
+		nodes.push(node);
+		if (node.type === "recursionTarget") targets.set(node.refId, node.inner);
+		for (const child of children(node)) collect(child);
+	};
+	collect(root);
+	const rebuilds = /* @__PURE__ */ new Set();
+	for (let changed = true; changed;) {
+		changed = false;
+		for (const node of nodes) {
+			if (rebuilds.has(node)) continue;
+			const target = node.type === "recursiveRef" ? targets.get(node.refId ?? 0) : void 0;
+			if (node.type === "object" && node.stripUnknownKeys === true || node.type === "default" || node.type === "stringBool" || node.type === "string" && (node.coerce === true || node.checks.some((c) => c.kind === "overwrite_effect")) || (node.type === "number" || node.type === "boolean" || node.type === "bigint" || node.type === "date") && node.coerce === true || node.type === "effect" || target !== void 0 && rebuilds.has(target) || children(node).some((child) => rebuilds.has(child))) {
+				rebuilds.add(node);
+				changed = true;
+			}
+		}
+	}
+	return rebuilds;
 }
 /** Does `ir`, taken as a whole schema, produce a value that is not its input? */
-export function rebuildsOutput(ir) {
-    return rebuildSet(ir).has(ir);
+function rebuildsOutput(ir) {
+	return rebuildSet(ir).has(ir);
 }
 /**
- * True when the subtree mutates for any reason the build pass cannot reproduce —
- * coerce, `.catch()`, `z.url()`, `superRefine`. Those rewrite values in ways this
- * pass (which validates, substitutes declared defaults, applies ordered string
- * rewrites and copies) does not model, so the schema keeps the eager walk.
- */
+* True when the subtree mutates for any reason the build pass cannot reproduce —
+* `.catch()`, `z.url()`, `superRefine`. Those rewrite values in ways this pass
+* (which validates, coerces, decodes string booleans, substitutes declared
+* defaults, applies ordered string rewrites and copies) does not model, so the
+* schema keeps the eager walk.
+*/
 function mutatesBeyondStrip(ir) {
-    return mutatesHere(ir) || children(ir).some(mutatesBeyondStrip);
+	return mutatesHere(ir) || children(ir).some(mutatesBeyondStrip);
 }
 /**
- * Does this node rewrite values on its own account (ignoring its children, and
- * ignoring the reshaping a strip object does)? Mirrors the node-local half of
- * `hasMutation`; the recursion above supplies the other half.
- */
+* Does this node rewrite values on its own account (ignoring its children, and
+* ignoring the reshaping a strip object does)? Mirrors the node-local half of
+* `hasMutation`; the recursion above supplies the other half.
+*/
 function mutatesHere(ir) {
-    switch (ir.type) {
-        case "string":
-            // Overwrite effects are absent: `buildString` applies them in order. A
-            // `z.url()` check still is not — it trims, normalizes and needs try/catch.
-            return (ir.coerce === true ||
-                superRefines(ir.checks) ||
-                ir.checks.some((c) => c.kind === "string_format" && c.format === "url"));
-        case "number":
-            return ir.coerce === true || superRefines(ir.checks);
-        case "boolean":
-        case "bigint":
-        case "date":
-            return ir.coerce === true;
-        // `default` and `effect` are absent: substituting a constant for `undefined`
-        // and applying a sync transform are both modelled (see buildDefault /
-        // buildEffect), and their inners are reached through `children`.
-        //
-        // `catch` is NOT: its catchValue callback receives a ctx carrying the inner
-        // schema's collected issues, and this pass produces a sentinel instead of an
-        // issue list — there is nothing to hand it.
-        case "catch":
-        case "fallback":
-        case "stringBool":
-            return true;
-        case "object":
-        case "array":
-            return superRefines(ir.checks);
-        default:
-            return false;
-    }
+	switch (ir.type) {
+		case "string": return superRefines(ir.checks) || ir.checks.some((c) => c.kind === "string_format" && c.format === "url");
+		case "number": return superRefines(ir.checks);
+		case "boolean":
+		case "bigint":
+		case "date": return false;
+		case "catch":
+		case "fallback": return true;
+		case "object":
+		case "array": return superRefines(ir.checks);
+		default: return false;
+	}
 }
 function superRefines(checks) {
-    return checks !== undefined && checks.some((c) => c.kind === "super_refine_effect");
+	return checks !== void 0 && checks.some((c) => c.kind === "super_refine_effect");
 }
 function children(ir) {
-    switch (ir.type) {
-        case "object":
-            return ir.catchall
-                ? [...Object.values(ir.properties), ir.catchall]
-                : Object.values(ir.properties);
-        case "array":
-            return [ir.element];
-        case "tuple":
-            return ir.rest === null ? ir.items : [...ir.items, ir.rest];
-        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 "optional":
-        case "nullable":
-        case "readonly":
-        case "default":
-        case "catch":
-        case "effect":
-        case "recursionTarget":
-            return [ir.inner];
-        case "pipe":
-            return [ir.in, ir.out];
-        default:
-            return [];
-    }
+	switch (ir.type) {
+		case "object": return ir.catchall ? [...Object.values(ir.properties), ir.catchall] : Object.values(ir.properties);
+		case "array": return [ir.element];
+		case "tuple": return ir.rest === null ? ir.items : [...ir.items, ir.rest];
+		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 "optional":
+		case "nullable":
+		case "readonly":
+		case "default":
+		case "catch":
+		case "effect":
+		case "recursionTarget": return [ir.inner];
+		case "pipe": return [ir.in, ir.out];
+		default: return [];
+	}
 }
 /**
- * Host the whole schema as `function NAME(input){…}` returning the built value
- * or the FAIL sentinel. Returns the function name, or null when the schema is
- * not expressible as a single build pass.
- */
-export function generateBuild(ir, ctx) {
-    const rebuilds = rebuildSet(ir);
-    if (!rebuilds.has(ir) || mutatesBeyondStrip(ir))
-        return null;
-    const fail = emitFailSentinel(ctx);
-    const scope = { temps: [], used: 0 };
-    const built = build(ir, "input", { ctx, extractable: false, fail, rebuilds, scope });
-    if (built === null)
-        return null;
-    const name = emitTemp(ctx, "vb");
-    ctx.preamble.push(`function ${name}(input){${declareFastTemps(scope)}${built.code}return ${built.value};}`);
-    return name;
+* Host the whole schema as `function NAME(input){…}` returning the built value
+* or the FAIL sentinel. Returns the function name, or null when the schema is
+* not expressible as a single build pass.
+*/
+function generateBuild(ir, ctx) {
+	const rebuilds = rebuildSet(ir);
+	if (!rebuilds.has(ir) || mutatesBeyondStrip(ir)) return null;
+	const fail = emitFailSentinel(ctx);
+	const scope = {
+		temps: [],
+		used: 0
+	};
+	const built = build(ir, "input", {
+		ctx,
+		extractable: false,
+		fail,
+		rebuilds,
+		scope
+	});
+	if (built === null) return null;
+	const name = emitTemp(ctx, "vb");
+	ctx.preamble.push(`function ${name}(input){${declareFastTemps(scope)}${built.code}return ${built.value};}`);
+	return name;
 }
 /** One `{}` per validator, compared by identity — no parse output can equal it. */
 function emitFailSentinel(ctx) {
-    if (ctx.buildFailName === undefined) {
-        ctx.buildFailName = `__bf_${ctx.counter++}`;
-        ctx.preamble.push(`var ${ctx.buildFailName}={};`);
-    }
-    return ctx.buildFailName;
+	if (ctx.buildFailName === void 0) {
+		ctx.buildFailName = `__bf_${ctx.counter++}`;
+		ctx.preamble.push(`var ${ctx.buildFailName}={};`);
+	}
+	return ctx.buildFailName;
 }
 /**
- * Statements producing the built value of `ir` read from `input`, or null.
- *
- * Size-gated exactly like the fast path: once inlining `ir` would push the
- * function being assembled past EXTRACT_CAP, the sub-build is hosted as its own
- * `__vb_N(p)` returning value-or-FAIL and replaced by a call. Without this a
- * deeply nested schema emits one enormous build function — measured at 113 KB
- * and 354 KB on the deep fixtures — far past the bytecode size where V8 stops
- * running TurboFan on it, which would forfeit the speed this path exists for.
- */
+* Statements producing the built value of `ir` read from `input`, or null.
+*
+* Size-gated exactly like the fast path: once inlining `ir` would push the
+* function being assembled past EXTRACT_CAP, the sub-build is hosted as its own
+* `__vb_N(p)` returning value-or-FAIL and replaced by a call. Without this a
+* deeply nested schema emits one enormous build function — measured at 113 KB
+* and 354 KB on the deep fixtures — far past the bytecode size where V8 stops
+* running TurboFan on it, which would forfeit the speed this path exists for.
+*/
 function build(ir, input, g) {
-    // Resolved before the passthrough shortcut below. A back-edge carries no
-    // children, so `rebuildsOutput` reads false for it — and passing it through by
-    // reference would leave every nested recursive value unstripped while the
-    // outermost one was rebuilt.
-    if (ir.type === "recursiveRef")
-        return buildRecursiveCall(ir.refId ?? 0, input, g);
-    if (ir.type === "recursionTarget")
-        return buildRecursionTarget(ir, input, g);
-    if (!g.rebuilds.has(ir))
-        return passthrough(ir, input, g);
-    const cache = (g.ctx.fastSizeCache ??= new WeakMap());
-    if (g.extractable &&
-        g.scope.used + predictedInlineSize(ir, input.length, cache) > EXTRACT_CAP &&
-        (g.scope.used > EXTRACT_CAP || estimateFastCost(ir, cache) >= MIN_EXTRACT)) {
-        const hosted = hostBuild(ir, g);
-        if (hosted !== null) {
-            const slot = local(g, "bh");
-            const code = `${slot}=${hosted}(${input});if(${slot}===${g.fail})return ${g.fail};`;
-            g.scope.used += code.length;
-            return { code, value: slot };
-        }
-    }
-    // This node's extraction decision is made; its descendants get to make their
-    // own, so an oversized hosted helper keeps splitting.
-    const before = g.scope.used;
-    const out = buildInline(ir, input, { ...g, extractable: true });
-    if (out !== null)
-        g.scope.used = before + out.code.length;
-    return out;
+	if (ir.type === "recursiveRef") return buildRecursiveCall(ir.refId ?? 0, input, g);
+	if (ir.type === "recursionTarget") return buildRecursionTarget(ir, input, g);
+	if (!g.rebuilds.has(ir)) return passthrough(ir, input, g);
+	const cache = g.ctx.fastSizeCache ??= /* @__PURE__ */ new WeakMap();
+	if (g.extractable && g.scope.used + predictedInlineSize(ir, input.length, cache) > 38e3 && (g.scope.used > 38e3 || estimateFastCost(ir, cache) >= 1200)) {
+		const hosted = hostBuild(ir, g);
+		if (hosted !== null) {
+			const slot = local(g, "bh");
+			const code = `${slot}=${hosted}(${input});if(${slot}===${g.fail})return ${g.fail};`;
+			g.scope.used += code.length;
+			return {
+				code,
+				value: slot
+			};
+		}
+	}
+	const before = g.scope.used;
+	const out = buildInline(ir, input, {
+		...g,
+		extractable: true
+	});
+	if (out !== null) g.scope.used = before + out.code.length;
+	return out;
 }
 /** Host `ir`'s build in its own function over a fresh parameter; returns its name. */
 function hostBuild(ir, g) {
-    const param = emitTemp(g.ctx, "bp");
-    const scope = { temps: [], used: 0 };
-    const inner = build(ir, param, { ...g, extractable: false, scope });
-    if (inner === null)
-        return null;
-    const name = emitTemp(g.ctx, "vb");
-    g.ctx.preamble.push(`function ${name}(${param}){${declareFastTemps(scope)}${inner.code}return ${inner.value};}`);
-    return name;
+	const param = emitTemp(g.ctx, "bp");
+	const scope = {
+		temps: [],
+		used: 0
+	};
+	const inner = build(ir, param, {
+		...g,
+		extractable: false,
+		scope
+	});
+	if (inner === null) return null;
+	const name = emitTemp(g.ctx, "vb");
+	g.ctx.preamble.push(`function ${name}(${param}){${declareFastTemps(scope)}${inner.code}return ${inner.value};}`);
+	return name;
 }
 function buildInline(ir, input, g) {
-    switch (ir.type) {
-        case "object":
-            return buildObject(ir, input, g);
-        case "array":
-            return buildArray(ir, input, g);
-        case "tuple":
-            return buildTuple(ir, input, g);
-        case "record":
-            return buildRecord(ir, input, g);
-        case "optional":
-            // A default further down the chain consumes undefined into a value, so
-            // the `undefined → undefined` shortcut must not fire — same rule (and
-            // same helper) the slow and fast paths already apply.
-            return innerAppliesDefaultOnUndefined(ir.inner)
-                ? build(ir.inner, input, g)
-                : buildSentinel(ir.inner, input, g, "===undefined", "undefined");
-        case "nullable":
-            // `null` short-circuits unconditionally in zod, whatever the inner is;
-            // undefined flows through, so an inner default still fires.
-            return buildSentinel(ir.inner, input, g, "===null", "null");
-        case "default":
-            return buildDefault(ir, input, g);
-        case "string":
-            return buildString(ir, input, g);
-        case "effect":
-            return buildEffect(ir, input, g);
-        case "readonly":
-            return build(ir.inner, input, g);
-        case "union":
-        case "discriminatedUnion":
-            return buildUnion(ir, input, g);
-        default:
-            // A rebuilding intersection, map or set: expressible in principle, but
-            // each needs its own output-shaping rules, so they keep the eager walk
-            // until there is a measured reason to add them.
-            return null;
-    }
+	switch (ir.type) {
+		case "object": return buildObject(ir, input, g);
+		case "array": return buildArray(ir, input, g);
+		case "tuple": return buildTuple(ir, input, g);
+		case "record": return buildRecord(ir, input, g);
+		case "optional": return innerAppliesDefaultOnUndefined(ir.inner) ? build(ir.inner, input, g) : buildSentinel(ir.inner, input, g, "===undefined", "undefined");
+		case "nullable": return buildSentinel(ir.inner, input, g, "===null", "null");
+		case "default": return buildDefault(ir, input, g);
+		case "string": return buildString(ir, input, g);
+		case "stringBool": return buildStringBool(ir, input, g);
+		case "number":
+		case "boolean":
+		case "bigint":
+		case "date": return buildCoercedPrimitive(ir, input, g);
+		case "effect": return buildEffect(ir, input, g);
+		case "readonly": return build(ir.inner, input, g);
+		case "union":
+		case "discriminatedUnion": return buildUnion(ir, input, g);
+		default: return null;
+	}
 }
 /**
- * Host the target's build once under a name registered BEFORE its body is
- * generated, so the back-edges inside that body resolve to it.
- */
+* Host the target's build once under a name registered BEFORE its body is
+* generated, so the back-edges inside that body resolve to it.
+*/
 function buildRecursionTarget(ir, input, g) {
-    const table = (g.ctx.buildRecNames ??= new Map());
-    if (!table.has(ir.refId)) {
-        const name = emitTemp(g.ctx, "vbr");
-        table.set(ir.refId, name);
-        const param = emitTemp(g.ctx, "bp");
-        const scope = { temps: [], used: 0 };
-        const inner = build(ir.inner, param, { ...g, extractable: false, scope });
-        if (inner === null) {
-            table.delete(ir.refId);
-            return null;
-        }
-        g.ctx.preamble.push(`function ${name}(${param}){${declareFastTemps(scope)}${inner.code}return ${inner.value};}`);
-    }
-    return buildRecursiveCall(ir.refId, input, g);
+	const table = g.ctx.buildRecNames ??= /* @__PURE__ */ new Map();
+	if (!table.has(ir.refId)) {
+		const name = emitTemp(g.ctx, "vbr");
+		table.set(ir.refId, name);
+		const param = emitTemp(g.ctx, "bp");
+		const scope = {
+			temps: [],
+			used: 0
+		};
+		const inner = build(ir.inner, param, {
+			...g,
+			extractable: false,
+			scope
+		});
+		if (inner === null) {
+			table.delete(ir.refId);
+			return null;
+		}
+		g.ctx.preamble.push(`function ${name}(${param}){${declareFastTemps(scope)}${inner.code}return ${inner.value};}`);
+	}
+	return buildRecursiveCall(ir.refId, input, g);
 }
 /** Call the hosted build for a recursion target, propagating its FAIL. */
 function buildRecursiveCall(refId, input, g) {
-    const name = g.ctx.buildRecNames?.get(refId);
-    if (name === undefined)
-        return null;
-    const slot = local(g, "bh");
-    return {
-        code: `${slot}=${name}(${input});if(${slot}===${g.fail})return ${g.fail};`,
-        value: slot,
-    };
+	const name = g.ctx.buildRecNames?.get(refId);
+	if (name === void 0) return null;
+	const slot = local(g, "bh");
+	return {
+		code: `${slot}=${name}(${input});if(${slot}===${g.fail})return ${g.fail};`,
+		value: slot
+	};
 }
 /**
- * Try each option in declaration order and take the first that builds — which
- * is what zod's union does with the first option that parses.
- *
- * Every option is HOSTED rather than inlined, and that is load-bearing: a
- * failing build signals with `return FAIL`, which inside the enclosing function
- * would abandon the whole parse instead of moving on to the next option. Behind
- * a call, the same signal is just a value to test.
- *
- * A discriminated union gets the same treatment rather than a switch: the
- * options still have to be probed by call, and its dispatch advantage is
- * already spent by the enclosing container's own work.
- */
+* Try each option in declaration order and take the first that builds — which
+* is what zod's union does with the first option that parses.
+*
+* Every option is HOSTED rather than inlined, and that is load-bearing: a
+* failing build signals with `return FAIL`, which inside the enclosing function
+* would abandon the whole parse instead of moving on to the next option. Behind
+* a call, the same signal is just a value to test.
+*
+* A discriminated union gets the same treatment rather than a switch: the
+* options still have to be probed by call, and its dispatch advantage is
+* already spent by the enclosing container's own work.
+*/
 function buildUnion(ir, input, g) {
-    const hosted = [];
-    for (const option of ir.options) {
-        const fn = g.rebuilds.has(option) ? hostBuild(option, g) : hostPassthrough(option, g);
-        if (fn === null)
-            return null;
-        hosted.push(fn);
-    }
-    if (hosted.length === 0)
-        return null;
-    const out = local(g, "bu");
-    let code = `${out}=${hosted[0]}(${input});`;
-    for (const fn of hosted.slice(1)) {
-        code += `if(${out}===${g.fail}){${out}=${fn}(${input});}`;
-    }
-    code += `if(${out}===${g.fail})return ${g.fail};`;
-    return { code, value: out };
+	const hosted = [];
+	for (const option of ir.options) {
+		const fn = g.rebuilds.has(option) ? hostBuild(option, g) : hostPassthrough(option, g);
+		if (fn === null) return null;
+		hosted.push(fn);
+	}
+	if (hosted.length === 0) return null;
+	const out = local(g, "bu");
+	let code = `${out}=${hosted[0]}(${input});`;
+	for (const fn of hosted.slice(1)) code += `if(${out}===${g.fail}){${out}=${fn}(${input});}`;
+	code += `if(${out}===${g.fail})return ${g.fail};`;
+	return {
+		code,
+		value: out
+	};
 }
 /**
- * Host a non-rebuilding option as `value-or-FAIL`, so a union can probe it with
- * the same protocol as a rebuilding one.
- */
+* Host a non-rebuilding option as `value-or-FAIL`, so a union can probe it with
+* the same protocol as a rebuilding one.
+*/
 function hostPassthrough(ir, g) {
-    const param = emitTemp(g.ctx, "bp");
-    const scope = { temps: [], used: 0 };
-    const expr = generateFast(ir, createFastGen(param, g.ctx, true, scope));
-    if (expr === null)
-        return null;
-    const name = emitTemp(g.ctx, "vp");
-    g.ctx.preamble.push(`function ${name}(${param}){${declareFastTemps(scope)}return ${expr === "true" ? param : `(${expr})?${param}:${g.fail}`};}`);
-    return name;
+	const param = emitTemp(g.ctx, "bp");
+	const scope = {
+		temps: [],
+		used: 0
+	};
+	const expr = generateFast(ir, createFastGen(param, g.ctx, true, scope));
+	if (expr === null) return null;
+	const name = emitTemp(g.ctx, "vp");
+	g.ctx.preamble.push(`function ${name}(${param}){${declareFastTemps(scope)}return ${expr === "true" ? param : `(${expr})?${param}:${g.fail}`};}`);
+	return name;
 }
 /** Validate in place with the Fast Path and hand the input straight back. */
 function passthrough(ir, input, g) {
-    const scoped = createFastGen(input, g.ctx, true, g.scope);
-    const expr = generateFast(ir, scoped);
-    if (expr === null)
-        return null;
-    return { code: expr === "true" ? "" : `if(!(${expr}))return ${g.fail};`, value: input };
+	const expr = generateFast(ir, createFastGen(input, g.ctx, true, g.scope));
+	if (expr === null) return null;
+	return {
+		code: expr === "true" ? "" : `if(!(${expr}))return ${g.fail};`,
+		value: input
+	};
 }
 /**
- * Rebuild from the declared keys. Sound for a stripping object (that IS the
- * output) and for a strict one (unknown keys are rejected, so the declared keys
- * are the whole key set). A loose object or one with a `.catchall()` keeps keys
- * this pass does not enumerate, so those bail.
- */
+* Rebuild from the declared keys. Sound for a stripping object (that IS the
+* output) and for a strict one (unknown keys are rejected, so the declared keys
+* are the whole key set). A loose object or one with a `.catchall()` keeps keys
+* this pass does not enumerate, so those bail.
+*/
 function buildObject(ir, input, g) {
-    if (ir.catchall !== undefined)
-        return null;
-    if (ir.stripUnknownKeys !== true && ir.strict !== true)
-        return null;
-    if (ir.suppressAbsentKeys !== undefined && ir.suppressAbsentKeys.length > 0)
-        return null;
-    // Object-level `.refine()` runs on the assembled output (below). superRefine
-    // rewrites the payload, which this pass does not model — mutatesBeyondStrip
-    // already rejects it, so this is a belt-and-braces narrowing of the type.
-    const refines = ir.checks ?? [];
-    if (refines.some((check) => check.kind !== "refine_effect"))
-        return null;
-    let code = `if(typeof ${input}!=="object"||${input}===null||Array.isArray(${input}))return ${g.fail};`;
-    if (ir.strict === true) {
-        const keyVar = local(g, "bk");
-        code += `for(${keyVar} in ${input}){if(!(${keyMembershipTest(g.ctx, Object.keys(ir.properties), keyVar)}))return ${g.fail};}`;
-    }
-    const slots = [];
-    for (const [key, propIR] of Object.entries(ir.properties)) {
-        const keyStr = escapeString(key);
-        const slot = local(g, "bv");
-        code += `${slot}=${input}[${keyStr}];`;
-        const propBuilt = build(propIR, slot, g);
-        if (propBuilt === null)
-            return null;
-        code += propBuilt.code;
-        slots.push({ always: outputAlwaysDefined(propIR), keyStr, value: propBuilt.value });
-    }
-    // Same assembly the eager strip walk uses: the longest LEADING run of
-    // always-present keys goes into one object literal (V8 stamps it from a
-    // cached boilerplate map in a single allocation), and everything after the
-    // first conditional key is appended so insertion order still matches zod.
-    // The per-key test is zod's own — keep the key when the parsed value is
-    // defined, or when it was present on the input at all.
-    const out = local(g, "bo");
-    const literal = [];
-    let appends = "";
-    let leading = true;
-    for (const slot of slots) {
-        if (leading && slot.always) {
-            literal.push(`${slot.keyStr}:${slot.value}`);
-            continue;
-        }
-        leading = false;
-        appends += slot.always
-            ? `${out}[${slot.keyStr}]=${slot.value};`
-            : `if(${slot.value}!==undefined||(${slot.keyStr} in ${input})){${out}[${slot.keyStr}]=${slot.value};}`;
-    }
-    code += `${out}={${literal.join(",")}};${appends}`;
-    // Zod parses the properties into the payload first and skips the check chain
-    // when that produced issues, so a bad property suppresses the refine — which
-    // this pass gets for free, having already returned FAIL at that property.
-    for (const check of refines) {
-        code += `if(!${emitEffectCallable(g.ctx, check)}(${out}))return ${g.fail};`;
-    }
-    return { code, value: out };
+	if (ir.catchall !== void 0) return null;
+	if (ir.stripUnknownKeys !== true && ir.strict !== true) return null;
+	if (ir.suppressAbsentKeys !== void 0 && ir.suppressAbsentKeys.length > 0) return null;
+	const refines = ir.checks ?? [];
+	if (refines.some((check) => check.kind !== "refine_effect")) return null;
+	let code = `if(typeof ${input}!=="object"||${input}===null||Array.isArray(${input}))return ${g.fail};`;
+	if (ir.strict === true) {
+		const keyVar = local(g, "bk");
+		code += `for(${keyVar} in ${input}){if(!(${keyMembershipTest(g.ctx, Object.keys(ir.properties), keyVar)}))return ${g.fail};}`;
+	}
+	const slots = [];
+	for (const [key, propIR] of Object.entries(ir.properties)) {
+		const keyStr = escapeString(key);
+		const slot = local(g, "bv");
+		code += `${slot}=${input}[${keyStr}];`;
+		const propBuilt = build(propIR, slot, g);
+		if (propBuilt === null) return null;
+		code += propBuilt.code;
+		slots.push({
+			always: outputAlwaysDefined(propIR),
+			keyStr,
+			value: propBuilt.value
+		});
+	}
+	const out = local(g, "bo");
+	const literal = [];
+	let appends = "";
+	let leading = true;
+	for (const slot of slots) {
+		if (leading && slot.always) {
+			literal.push(`${slot.keyStr}:${slot.value}`);
+			continue;
+		}
+		leading = false;
+		appends += slot.always ? `${out}[${slot.keyStr}]=${slot.value};` : `if(${slot.value}!==undefined||(${slot.keyStr} in ${input})){${out}[${slot.keyStr}]=${slot.value};}`;
+	}
+	code += `${out}={${literal.join(",")}};${appends}`;
+	for (const check of refines) code += `if(!${emitEffectCallable(g.ctx, check)}(${out}))return ${g.fail};`;
+	return {
+		code,
+		value: out
+	};
 }
 function buildArray(ir, input, g) {
-    // Length checks are pure predicates over `input.length`, so they hoist ahead
-    // of the element loop: a size mismatch bails before a single element is
-    // validated. Zod reports the per-element issue first when both fail, but the
-    // build pass produces no issues — only the sentinel — and the deferred walk
-    // that does produce them keeps zod's order.
-    let sizes = "";
-    const refines = [];
-    for (const check of ir.checks) {
-        switch (check.kind) {
-            case "min_length":
-                sizes += `if(${input}.length<${check.minimum})return ${g.fail};`;
-                break;
-            case "max_length":
-                sizes += `if(${input}.length>${check.maximum})return ${g.fail};`;
-                break;
-            case "length_equals":
-                sizes += `if(${input}.length!==${check.length})return ${g.fail};`;
-                break;
-            case "refine_effect":
-                refines.push(check);
-                break;
-            default:
-                // super_refine (rewrites the value) or a check kind not modelled here.
-                return null;
-        }
-    }
-    const out = local(g, "ba");
-    const index = local(g, "bi");
-    const elem = local(g, "be");
-    const inner = build(ir.element, elem, g);
-    if (inner === null)
-        return null;
-    let code = `if(!Array.isArray(${input}))return ${g.fail};` +
-        sizes +
-        `${out}=new Array(${input}.length);` +
-        `for(${index}=0;${index}<${input}.length;${index}++){` +
-        `${elem}=${input}[${index}];${inner.code}${out}[${index}]=${inner.value};}`;
-    // `.refine()` sees the parsed payload, which for a rebuilding element is the
-    // freshly assembled array — the same value zod hands its checks.
-    for (const check of refines) {
-        code += `if(!${emitEffectCallable(g.ctx, check)}(${out}))return ${g.fail};`;
-    }
-    return { code, value: out };
+	let sizes = "";
+	const refines = [];
+	for (const check of ir.checks) switch (check.kind) {
+		case "min_length":
+			sizes += `if(${input}.length<${check.minimum})return ${g.fail};`;
+			break;
+		case "max_length":
+			sizes += `if(${input}.length>${check.maximum})return ${g.fail};`;
+			break;
+		case "length_equals":
+			sizes += `if(${input}.length!==${check.length})return ${g.fail};`;
+			break;
+		case "refine_effect":
+			refines.push(check);
+			break;
+		default: return null;
+	}
+	const out = local(g, "ba");
+	const index = local(g, "bi");
+	const elem = local(g, "be");
+	const inner = build(ir.element, elem, g);
+	if (inner === null) return null;
+	let code = `if(!Array.isArray(${input}))return ${g.fail};` + sizes + `${out}=new Array(${input}.length);for(${index}=0;${index}<${input}.length;${index}++){${elem}=${input}[${index}];${inner.code}${out}[${index}]=${inner.value};}`;
+	for (const check of refines) code += `if(!${emitEffectCallable(g.ctx, check)}(${out}))return ${g.fail};`;
+	return {
+		code,
+		value: out
+	};
 }
 function buildTuple(ir, input, g) {
-    // Trailing-optional and rest handling shape the output length; keep those on
-    // the eager walk rather than restating the rules here.
-    if (ir.rest !== null)
-        return null;
-    if (ir.items.some((item) => !rejectsUndefined(item)))
-        return null;
-    let code = `if(!Array.isArray(${input})||${input}.length!==${ir.items.length})return ${g.fail};`;
-    const values = [];
-    for (const [index, itemIR] of ir.items.entries()) {
-        const slot = local(g, "bt");
-        code += `${slot}=${input}[${index}];`;
-        const inner = build(itemIR, slot, g);
-        if (inner === null)
-            return null;
-        code += inner.code;
-        values.push(inner.value);
-    }
-    const out = local(g, "bl");
-    code += `${out}=[${values.join(",")}];`;
-    return { code, value: out };
+	if (ir.rest !== null) return null;
+	if (ir.items.some((item) => !rejectsUndefined(item))) return null;
+	let code = `if(!Array.isArray(${input})||${input}.length!==${ir.items.length})return ${g.fail};`;
+	const values = [];
+	for (const [index, itemIR] of ir.items.entries()) {
+		const slot = local(g, "bt");
+		code += `${slot}=${input}[${index}];`;
+		const inner = build(itemIR, slot, g);
+		if (inner === null) return null;
+		code += inner.code;
+		values.push(inner.value);
+	}
+	const out = local(g, "bl");
+	code += `${out}=[${values.join(",")}];`;
+	return {
+		code,
+		value: out
+	};
 }
 function buildRecord(ir, input, g) {
-    const plainStringKey = ir.keyType.type === "string" && ir.keyType.checks.length === 0 && ir.keyType.coerce !== true;
-    if (!plainStringKey)
-        return null;
-    const out = local(g, "br");
-    const keyVar = local(g, "brk");
-    const valVar = local(g, "brv");
-    const inner = build(ir.valueType, valVar, g);
-    if (inner === null)
-        return null;
-    const hop = emitRuntimeHelper(g.ctx, "__zcHop", ZC_HOP_DECL);
-    const code = `if(typeof ${input}!=="object"||${input}===null||Array.isArray(${input}))return ${g.fail};` +
-        `${out}={};` +
-        `for(${keyVar} in ${input}){if(${hop}.call(${input},${keyVar})){` +
-        `${valVar}=${input}[${keyVar}];${inner.code}${out}[${keyVar}]=${inner.value};}}`;
-    return { code, value: out };
+	if (!(ir.keyType.type === "string" && ir.keyType.checks.length === 0 && ir.keyType.coerce !== true)) return null;
+	const out = local(g, "br");
+	const keyVar = local(g, "brk");
+	const valVar = local(g, "brv");
+	const inner = build(ir.valueType, valVar, g);
+	if (inner === null) return null;
+	const hop = emitRuntimeHelper(g.ctx, "__zcHop", ZC_HOP_DECL);
+	return {
+		code: `if(typeof ${input}!=="object"||${input}===null||Array.isArray(${input}))return ${g.fail};${out}={};for(${keyVar} in ${input}){if(${hop}.call(${input},${keyVar})){${valVar}=${input}[${keyVar}];${inner.code}${out}[${keyVar}]=${inner.value};}}`,
+		value: out
+	};
 }
 /**
- * `.transform(fn)`: validate the inner schema, then hand its parsed value to the
- * callback. Zod's transform is a pipe whose `in` failing aborts the whole thing,
- * which is exactly what returning FAIL from the inner build does — so the
- * callback runs only on a clean parse, as `slowEffect` guarantees with its issue
- * count.
- *
- * The IR reaches here only for a synchronous single-argument callback: a
- * `ctx`-taking or async transform is extracted as a `fallback` instead
- * (see extractPipe), so there is no parse context to reproduce.
- */
+* `.transform(fn)`: validate the inner schema, then hand its parsed value to the
+* callback. Zod's transform is a pipe whose `in` failing aborts the whole thing,
+* which is exactly what returning FAIL from the inner build does — so the
+* callback runs only on a clean parse, as `slowEffect` guarantees with its issue
+* count.
+*
+* The IR reaches here only for a synchronous single-argument callback: a
+* `ctx`-taking or async transform is extracted as a `fallback` instead
+* (see extractPipe), so there is no parse context to reproduce.
+*/
 function buildEffect(ir, input, g) {
-    const inner = build(ir.inner, input, g);
-    if (inner === null)
-        return null;
-    const out = local(g, "bx");
-    return {
-        code: `${inner.code}${out}=${emitEffectCallable(g.ctx, ir)}(${inner.value});`,
-        value: out,
-    };
+	const inner = build(ir.inner, input, g);
+	if (inner === null) return null;
+	const out = local(g, "bx");
+	return {
+		code: `${inner.code}${out}=${emitEffectCallable(g.ctx, ir)}(${inner.value});`,
+		value: out
+	};
 }
 /**
- * A string carrying an overwrite effect (`.trim()`, `.toLowerCase()`, ...): the
- * checks are emitted one statement at a time in DECLARATION order, interleaved
- * with the rewrites, because a rewrite is visible to every check after it —
- * `z.string().trim().min(1)` rejects `"  "` where `z.string().min(1).trim()`
- * accepts it. That ordering is exactly why the fast path, which sorts checks
- * cheapest-first and returns the input unchanged, has to decline these.
- *
- * Only reached for a rewriting string; a check-only one never enters the rebuild
- * set and is validated in place by `passthrough`.
- */
+* A coercing and/or overwrite string (`z.coerce.string()`, `.trim()`,
+* `.toLowerCase()`, ...): coerce first, then emit checks one statement at a time
+* in DECLARATION order, interleaved with rewrites, because a rewrite is visible
+* to every check after it — `z.string().trim().min(1)` rejects `"  "` where
+* `z.string().min(1).trim()` accepts it. That ordering is exactly why the fast
+* path, which sorts checks cheapest-first and returns the input unchanged, has
+* to decline these.
+*
+* Only reached for a rewriting string; a non-coercing, check-only one never
+* enters the rebuild set and is validated in place by `passthrough`.
+*/
 function buildString(ir, input, g) {
-    if (ir.coerce === true)
-        return null;
-    const value = local(g, "bs");
-    let code = `if(typeof ${input}!=="string")return ${g.fail};${value}=${input};`;
-    for (const check of ir.checks) {
-        switch (check.kind) {
-            case "overwrite_effect":
-                code += `${value}=${emitEffectFn(g.ctx, check.source)}(${value});`;
-                break;
-            case "refine_effect":
-                code += `if(!${emitEffectCallable(g.ctx, check)}(${value}))return ${g.fail};`;
-                break;
-            case "super_refine_effect":
-                // Rewrites through zod's payload; mutatesBeyondStrip already rejects it.
-                return null;
-            default: {
-                const expr = fastStringCheck(check, value, g.ctx);
-                if (expr === null)
-                    return null; // z.url(), unknown format
-                code += `if(!(${expr}))return ${g.fail};`;
-            }
-        }
-    }
-    return { code, value };
+	const value = local(g, "bs");
+	let code = ir.coerce === true ? `try{${value}=String(${input});}catch(_){return ${g.fail};}` : `if(typeof ${input}!=="string")return ${g.fail};${value}=${input};`;
+	for (const check of ir.checks) switch (check.kind) {
+		case "overwrite_effect":
+			code += `${value}=${emitEffectFn(g.ctx, check.source)}(${value});`;
+			break;
+		case "refine_effect":
+			code += `if(!${emitEffectCallable(g.ctx, check)}(${value}))return ${g.fail};`;
+			break;
+		case "super_refine_effect": return null;
+		default: {
+			const expr = fastStringCheck(check, value, g.ctx);
+			if (expr === null) return null;
+			code += `if(!(${expr}))return ${g.fail};`;
+		}
+	}
+	return {
+		code,
+		value
+	};
+}
+/**
+* `z.stringbool()`: normalize once, select the declared truthy/falsy side, and
+* return the boolean directly. The ordinary Fast Path cannot host this codec
+* because its contract returns the original input by reference; the build path
+* is designed for exactly this kind of small output rewrite.
+*/
+function buildStringBool(ir, input, g) {
+	let code = `if(typeof ${input}!=="string")return ${g.fail};`;
+	let normalized = input;
+	if (!ir.caseSensitive) {
+		normalized = local(g, "bn");
+		code += `${normalized}=${input}.toLowerCase();`;
+	}
+	const out = local(g, "bb");
+	if (stringBoolUsesInline(ir)) {
+		const membership = (values) => values.map((value) => `${normalized}===${escapeString(value)}`).join("||");
+		code += `if(${membership(ir.truthy)}){${out}=true;}else if(${membership(ir.falsy)}){${out}=false;}else{return ${g.fail};}`;
+	} else {
+		const lookup = emitStringBoolMap(ir, g.ctx);
+		code += `${out}=${lookup}.get(${normalized});if(${out}===undefined)return ${g.fail};`;
+	}
+	return {
+		code,
+		value: out
+	};
+}
+/**
+* Coerce once into a local, then reuse the ordinary Fast Path as the acceptance
+* predicate over the converted value. The build path only needs a verdict on
+* its hot pass; if it fails, the existing deferred slow walk reruns the original
+* coercing schema and produces Zod-identical issues.
+*
+* Number/BigInt/Date conversion can invoke user hooks and throw. Zod catches
+* those throws and reports invalid_type, so the sentinel branch does the same
+* without allocating an issue. Boolean never invokes conversion hooks.
+*/
+function buildCoercedPrimitive(ir, input, g) {
+	if (ir.coerce !== true) return null;
+	const value = local(g, "bc");
+	let conversion;
+	switch (ir.type) {
+		case "number":
+			conversion = `Number(${input})`;
+			break;
+		case "boolean":
+			conversion = `Boolean(${input})`;
+			break;
+		case "bigint":
+			conversion = `BigInt(${input})`;
+			break;
+		case "date":
+			conversion = `new Date(${input})`;
+			break;
+	}
+	const predicate = generateFast({
+		...ir,
+		coerce: false
+	}, createFastGen(value, g.ctx, true, g.scope));
+	if (predicate === null) return null;
+	const assign = `${value}=${conversion};`;
+	return {
+		code: (ir.type === "boolean" ? assign : `try{${assign}}catch(_){return ${g.fail};}`) + (predicate === "true" ? "" : `if(!(${predicate}))return ${g.fail};`),
+		value
+	};
 }
 /**
- * `.default(v)`: `undefined` yields the declared value without running the
- * inner schema, anything else parses normally — the same two branches
- * `slowDefault` emits, reading the value off the retained schema so a
- * reference-typed default keeps zod's identity (one shared object, not a copy).
- *
- * The substituted value is not validated, so it makes the fast path a PARTIAL
- * predicate (`fc(undefined)` is false where the schema accepts) — which is why
- * this records {@link CodeGenContext.buildSubstitutesValue}, on which
- * `generateValidator` withholds `.is()`.
- */
+* `.default(v)`: `undefined` yields the declared value without running the
+* inner schema, anything else parses normally — the same two branches
+* `slowDefault` emits, reading the value off the retained schema so a
+* reference-typed default keeps zod's identity (one shared object, not a copy).
+*
+* The substituted value is not validated, so it makes the fast path a PARTIAL
+* predicate (`fc(undefined)` is false where the schema accepts) — which is why
+* this records {@link CodeGenContext.buildSubstitutesValue}, on which
+* `generateValidator` withholds `.is()`.
+*/
 function buildDefault(ir, input, g) {
-    const inner = build(ir.inner, input, g);
-    if (inner === null)
-        return null;
-    // Every `default` node is in the rebuild set, so it is always BUILT and never
-    // passed through — which makes this flag an exact record of whether the
-    // finished pass substitutes a value.
-    g.ctx.buildSubstitutesValue = true;
-    const out = local(g, "bq");
-    const value = defaultValueExpr(ir);
-    // Zod re-applies the default when the inner returns undefined for a defined
-    // input; only emitted when the inner can actually do that.
-    const reapply = needsPostInnerDefault(ir) ? `if(${out}===undefined){${out}=${value};}` : "";
-    return {
-        code: `if(${input}===undefined){${out}=${value};}` +
-            `else{${inner.code}${out}=${inner.value};${reapply}}`,
-        value: out,
-    };
+	const inner = build(ir.inner, input, g);
+	if (inner === null) return null;
+	g.ctx.buildSubstitutesValue = true;
+	const out = local(g, "bq");
+	const value = defaultValueExpr(ir);
+	const reapply = needsPostInnerDefault(ir) ? `if(${out}===undefined){${out}=${value};}` : "";
+	return {
+		code: `if(${input}===undefined){${out}=${value};}else{${inner.code}${out}=${inner.value};${reapply}}`,
+		value: out
+	};
 }
 /** `optional` / `nullable` around a rebuilding inner: pass the sentinel through. */
 function buildSentinel(innerIR, input, g, test, sentinel) {
-    const inner = build(innerIR, input, g);
-    if (inner === null)
-        return null;
-    const out = local(g, "bw");
-    return {
-        code: `if(${input}${test}){${out}=${sentinel};}else{${inner.code}${out}=${inner.value};}`,
-        value: out,
-    };
+	const inner = build(innerIR, input, g);
+	if (inner === null) return null;
+	const out = local(g, "bw");
+	return {
+		code: `if(${input}${test}){${out}=${sentinel};}else{${inner.code}${out}=${inner.value};}`,
+		value: out
+	};
 }
 /** Allocate a `var` the hosted build function declares. */
 function local(g, prefix) {
-    const name = emitTemp(g.ctx, prefix);
-    g.scope.temps.push(name);
-    return name;
+	const name = emitTemp(g.ctx, prefix);
+	g.scope.temps.push(name);
+	return name;
 }
+//#endregion
+export { generateBuild, rebuildsOutput };
+
 //# sourceMappingURL=build-path.js.map