@reactra/babel-plugin 0.1.0-alpha.0

package/dist/passes/pass-9-codegen.js

@@ -0,0 +1,2755 @@
+// Pass 9 — code-gen.
+//
+// Walks a FileGraph (output of Pass 2) and emits valid React 19 TSX as a
+// string. Implementation strategy: rather than depend on @babel/generator
+// (which has transitive deps that aren't always resolvable in this
+// sandbox), we slice expression text from the preprocessed source using
+// Babel AST positions, then assemble the output with string templates.
+//
+// Owner spec: reactra-compiler-spec.md §4 Pass 9.
+//
+// Phase-1 scope as of this commit:
+//   - components (incl. resources + await/pending/error) — Day 9a
+//   - export/route/session stores → closure factories + StoreRegistry
+//     bindings; bare `use storeX` → useReactraStore destructure (Day 9b).
+//   - services → Strategy A singleton factories + ServiceRegistry.get
+//     lookups at every `inject X` site (Day 9c).
+//   - argumented `use storeX(...)` (router lifecycle) → next session.
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { fieldLocal } from "../ast/nodes.js";
+// framework-review §B1: setter naming + await arg order + `cap` are the shared
+// emission conventions — ONE home in `conventions/`, used by Pass 9 AND the
+// language-tools shadow emitter (which previously re-derived a divergent copy).
+import { AWAIT_ARG_ORDER, cap, classifyStateSetters, setterActionTarget, setterNameFor, } from "../conventions/index.js";
+import { matchedNativeBehaviours, NATIVE_BEHAVIOURS } from "../behaviours/index.js";
+import { resolvePluginBehaviours } from "../behaviours/plugin.js";
+const traverse = (_traverse.default ?? _traverse);
+/** Slice a substring out of the preprocessed source by Babel AST positions. */
+const sliceNode = (preprocessed, node) => {
+    if (node.start == null || node.end == null)
+        return "";
+    return preprocessed.slice(node.start, node.end);
+};
+/** Boilerplate / compiler-injected text with no DSL origin. */
+const plain = (text) => ({ text, marks: [] });
+/** Concatenate emitted parts, shifting each part's marks by the running length. */
+const concatE = (parts) => {
+    let text = "";
+    const marks = [];
+    for (const p of parts) {
+        const base = text.length;
+        for (const m of p.marks)
+            marks.push({ at: base + m.at, ppOffset: m.ppOffset });
+        text += p.text;
+    }
+    return { text, marks };
+};
+/** Join emitted parts with a (plain) separator — mirrors `array.join(sep)`. */
+const joinE = (parts, sep) => {
+    const woven = [];
+    parts.forEach((p, i) => {
+        if (i > 0)
+            woven.push(plain(sep));
+        woven.push(p);
+    });
+    return concatE(woven);
+};
+/**
+ * One source mark per line of a piece list: at the body start and at the first
+ * char of every subsequent line. Within a `verbatim` piece the origin is exact
+ * (`srcStart + offset`); within a `gen` piece it anchors at the edit site. Line
+ * granularity is what breakpoint binding needs — a breakpoint on any DSL line of a
+ * multi-line body now lands on the matching compiled line, not the body's first.
+ */
+const pieceLineMarks = (pieces) => {
+    const out = [];
+    let at = 0;
+    let atLineStart = true;
+    for (const p of pieces) {
+        for (let i = 0; i < p.text.length; i++) {
+            if (atLineStart) {
+                out.push({ at, ppOffset: p.kind === "verbatim" ? p.srcStart + i : p.anchorSrc });
+                atLineStart = false;
+            }
+            if (p.text.charCodeAt(i) === 10 /* \n */)
+                atLineStart = true;
+            at++;
+        }
+    }
+    return out;
+};
+/**
+ * Assemble `prefix` + the pieces + `suffix` into an `Emitted`, attaching the
+ * per-line marks (shifted past the prefix). `.text` is byte-identical to a plain
+ * `prefix + pieces.join("") + suffix` — only the map rides alongside.
+ */
+const emitMappedPieces = (prefix, pieces, suffix) => {
+    const body = pieces.map((p) => p.text).join("");
+    const text = `${prefix}${body}${suffix}`;
+    if (body.length === 0)
+        return plain(text);
+    const marks = pieceLineMarks(pieces).map((m) => ({
+        at: prefix.length + m.at,
+        ppOffset: m.ppOffset,
+    }));
+    return { text, marks };
+};
+/**
+ * A single emitted fragment mapping one verbatim user-code slice: `prefix` + the
+ * slice text + `suffix`. The slice is copied char-for-char, so it maps per line
+ * back to its DSL origin (#10-followup §8). `node` supplies both the text
+ * (`sliceNode`) and the origin (`node.start`).
+ */
+const mappedSlice = (preprocessed, prefix, node, suffix) => {
+    const text = node ? sliceNode(preprocessed, node) : "";
+    if (node && node.start != null && text.length > 0) {
+        return emitMappedPieces(prefix, [{ kind: "verbatim", srcStart: node.start, text }], suffix);
+    }
+    return plain(`${prefix}${text}${suffix}`);
+};
+/**
+ * Maps a compound assignment operator to the arithmetic/logical operator to use
+ * in `setX(prev => prev OP (rhs))` lowering (F2 / Component DSL §2.3).
+ *
+ * Returns the binary op string, e.g. `"+="` → `"+"`. Returns `null` for operators
+ * that are NOT compound writes on a state name (plain `"="` handled separately).
+ */
+const COMPOUND_OP_MAP = {
+    "+=": "+",
+    "-=": "-",
+    "*=": "*",
+    "/=": "/",
+    "%=": "%",
+    "**=": "**",
+    "&=": "&",
+    "|=": "|",
+    "^=": "^",
+    "<<=": "<<",
+    ">>=": ">>",
+    ">>>=": ">>>",
+    "||=": "||",
+    "&&=": "&&",
+    "??=": "??",
+};
+/**
+ * Decompose a component `action` body into source-mapped pieces. Every
+ * `stateName = expr` lowers to a `set<Cap(X)>(expr)` call; compound writes
+ * (`x += e`, `x++`, etc.) lower to `setX(prev => prev OP (e))`.
+ *
+ * `set<X>(` and `)` are `gen` pieces anchored at the assignment, while the
+ * right-hand expression stays `verbatim` so it keeps a char-accurate origin
+ * (the setter is `set<Cap(X)>`, or the internal `__set<Cap(X)>` when a
+ * non-trivial `action set<Cap(X)>` owns the public name — `renamedStates`).
+ * Untouched spans between assignments are `verbatim` too. Joining the pieces'
+ * text reproduces the rewritten body exactly (#10-followup §8, Session 3).
+ *
+ * F2 (compound/update writes): compound AssignmentExpression (`+=`, `-=`, etc.)
+ * and UpdateExpression (`x++`, `++x`, `x--`, `--x`) on state names are lowered
+ * to `setX(prev => prev OP (rhs))`. Non-state targets pass through verbatim.
+ */
+const actionBodyPieces = (preprocessed, action, stateNames, renamedStates, 
+// A compiler-native behaviour (Pass 9.1) injects this statement right after the
+// body's opening `{` — e.g. undoable's `__undo.push(__snapshot());` or replay's
+// `const __t0 = …; __replay.action(…)`.
+bodyPrologue, 
+// …and this one just before the body's closing `}` — e.g. replay's
+// `__replay.snapshot({…}, __t0)` (Replay §4.1). `undoable` has no epilogue.
+bodyEpilogue) => {
+    const arrow = action.arrow;
+    if (arrow.start == null || arrow.end == null)
+        return [];
+    const substs = [];
+    // Build a path container so we can use traverse on a sub-tree.
+    traverse(t.file(t.program([t.expressionStatement(arrow)])), {
+        AssignmentExpression(path) {
+            const left = path.node.left;
+            if (!t.isIdentifier(left))
+                return;
+            if (!stateNames.has(left.name))
+                return;
+            if (path.node.start == null ||
+                path.node.end == null)
+                return;
+            const setter = setterNameFor(left.name, renamedStates);
+            if (path.node.operator === "=") {
+                // Plain assignment — verbatim RHS slice (existing behaviour).
+                if (path.node.right.start == null || path.node.right.end == null)
+                    return;
+                substs.push({
+                    start: path.node.start,
+                    end: path.node.end,
+                    setter,
+                    rhsStart: path.node.right.start,
+                    rhsEnd: path.node.right.end,
+                });
+            }
+            else {
+                // Compound assignment (+=, -=, etc.) — lower to functional setter.
+                const binOp = COMPOUND_OP_MAP[path.node.operator];
+                if (!binOp)
+                    return; // unknown operator — pass through verbatim
+                if (path.node.right.start == null || path.node.right.end == null)
+                    return;
+                const rhsText = preprocessed.slice(path.node.right.start, path.node.right.end);
+                substs.push({
+                    start: path.node.start,
+                    end: path.node.end,
+                    setter,
+                    genRhs: `prev => prev ${binOp} (${rhsText})`,
+                });
+            }
+        },
+        UpdateExpression(path) {
+            // x++ / ++x / x-- / --x on a state name → setX(prev => prev +/- 1).
+            const arg = path.node.argument;
+            if (!t.isIdentifier(arg) || !stateNames.has(arg.name))
+                return;
+            if (path.node.start == null || path.node.end == null)
+                return;
+            const setter = setterNameFor(arg.name, renamedStates);
+            const op = path.node.operator === "++" ? "+" : "-";
+            substs.push({
+                start: path.node.start,
+                end: path.node.end,
+                setter,
+                genRhs: `prev => prev ${op} 1`,
+            });
+        },
+    });
+    // Walk left-to-right, alternating verbatim source spans with the lowered
+    // setter pieces. The `s.start < cursor` guard skips a nested state assignment
+    // (e.g. `a = (b = 1)`): the outer's RHS already carries it verbatim, so we
+    // don't double-emit — robust where the prior reverse-replace would corrupt.
+    substs.sort((a, b) => a.start - b.start);
+    const pieces = [];
+    let cursor = arrow.start;
+    // Inject the prologue immediately after the body's opening `{` (the `{` sits
+    // before any state-assignment subst, so this stays ahead of the loop below).
+    if (bodyPrologue && t.isBlockStatement(arrow.body) && arrow.body.start != null) {
+        const afterBrace = arrow.body.start + 1;
+        pieces.push({ kind: "verbatim", srcStart: cursor, text: preprocessed.slice(cursor, afterBrace) });
+        pieces.push({ kind: "gen", text: ` ${bodyPrologue}`, anchorSrc: arrow.body.start });
+        cursor = afterBrace;
+    }
+    for (const s of substs) {
+        if (s.start < cursor)
+            continue;
+        if (s.start > cursor) {
+            pieces.push({ kind: "verbatim", srcStart: cursor, text: preprocessed.slice(cursor, s.start) });
+        }
+        if (s.genRhs) {
+            // Compound/update write — fully generated setter call.
+            pieces.push({ kind: "gen", text: `${s.setter}(${s.genRhs})`, anchorSrc: s.start });
+        }
+        else {
+            // Plain write — verbatim RHS.
+            pieces.push({ kind: "gen", text: `${s.setter}(`, anchorSrc: s.start });
+            pieces.push({
+                kind: "verbatim",
+                srcStart: s.rhsStart,
+                text: preprocessed.slice(s.rhsStart, s.rhsEnd),
+            });
+            pieces.push({ kind: "gen", text: `)`, anchorSrc: s.rhsEnd });
+        }
+        cursor = s.end;
+    }
+    // Final remainder. With an epilogue, split the tail so the injected statement
+    // lands just before the body's closing `}` (Replay §4.1); otherwise copy the
+    // rest verbatim (the prior behaviour — byte-identical when no epilogue).
+    if (bodyEpilogue && t.isBlockStatement(arrow.body) && arrow.body.end != null) {
+        const beforeBrace = arrow.body.end - 1; // index of the closing `}`
+        if (beforeBrace > cursor) {
+            pieces.push({ kind: "verbatim", srcStart: cursor, text: preprocessed.slice(cursor, beforeBrace) });
+        }
+        // Leading `;` separates the epilogue from the user's last (possibly
+        // unterminated, single-line) statement; safe before a `}`/`;`/newline too.
+        pieces.push({ kind: "gen", text: `; ${bodyEpilogue} `, anchorSrc: beforeBrace });
+        pieces.push({ kind: "verbatim", srcStart: beforeBrace, text: preprocessed.slice(beforeBrace, arrow.end) });
+    }
+    else if (cursor < arrow.end) {
+        pieces.push({ kind: "verbatim", srcStart: cursor, text: preprocessed.slice(cursor, arrow.end) });
+    }
+    return pieces;
+};
+/**
+ * Top-level `state = rhs` writes in an action body → `Map<stateName, rhsText>`
+ * (Replay §4.3 rule 3 — the snapshot object source). Straight-line only: writes
+ * nested in a branch/loop/callback are not collected (RLIM-08). Last write wins.
+ */
+const straightLineStateWrites = (preprocessed, a, stateNames) => {
+    const out = new Map();
+    const body = a.arrow.body;
+    if (!t.isBlockStatement(body))
+        return out;
+    for (const stmt of body.body) {
+        if (!t.isExpressionStatement(stmt))
+            continue;
+        const e = stmt.expression;
+        if (!t.isAssignmentExpression(e) || e.operator !== "=")
+            continue;
+        if (!t.isIdentifier(e.left) || !stateNames.has(e.left.name))
+            continue;
+        if (e.right.start == null || e.right.end == null)
+            continue;
+        out.set(e.left.name, preprocessed.slice(e.right.start, e.right.end));
+    }
+    return out;
+};
+/** The optimistic write-set of a command's `optimistic {}` arrow — `Map<state, rhs>` (Slice 3b). */
+const optimisticWritesOf = (preprocessed, cmd, stateNames) => cmd.optimistic
+    ? straightLineStateWrites(preprocessed, { arrow: cmd.optimistic }, stateNames)
+    : new Map();
+/** Union of every command's optimistic-written state names — these states emit a useOptimistic shadow. */
+const optimisticStatesOf = (preprocessed, c, stateNames) => {
+    const out = new Set();
+    for (const cmd of c.commands)
+        for (const k of optimisticWritesOf(preprocessed, cmd, stateNames).keys())
+            out.add(k);
+    return out;
+};
+/** Copy `from..to` of a piece, keeping a verbatim origin char-accurate. */
+const slicePiece = (p, from, to) => p.kind === "verbatim"
+    ? { kind: "verbatim", srcStart: p.srcStart + from, text: p.text.slice(from, to) }
+    : { kind: "gen", anchorSrc: p.anchorSrc, text: p.text.slice(from, to) };
+/** Drop the first `n` chars across a piece list (advances verbatim origins). */
+const dropFront = (pieces, n) => {
+    const out = [];
+    let rem = n;
+    for (const p of pieces) {
+        if (rem <= 0) {
+            out.push(p);
+            continue;
+        }
+        if (p.text.length <= rem) {
+            rem -= p.text.length;
+            continue;
+        }
+        out.push(slicePiece(p, rem, p.text.length));
+        rem = 0;
+    }
+    return out;
+};
+/** Keep only the first `n` chars across a piece list (the mirror of `dropFront`). */
+const takeFront = (pieces, n) => {
+    const out = [];
+    let rem = n;
+    for (const p of pieces) {
+        if (rem <= 0)
+            break;
+        if (p.text.length <= rem) {
+            out.push(p);
+            rem -= p.text.length;
+            continue;
+        }
+        out.push(slicePiece(p, 0, rem));
+        rem = 0;
+    }
+    return out;
+};
+/** Drop the last `n` chars across a piece list (truncates from the tail). */
+const dropBack = (pieces, n) => {
+    const out = pieces.slice();
+    let rem = n;
+    while (rem > 0 && out.length > 0) {
+        const p = out[out.length - 1]; // out.length > 0 guarded by the loop condition
+        if (p.text.length <= rem) {
+            rem -= p.text.length;
+            out.pop();
+            continue;
+        }
+        out[out.length - 1] = slicePiece(p, 0, p.text.length - rem);
+        rem = 0;
+    }
+    return out;
+};
+/**
+ * Decompose the view body into source-mapped `Piece`s: verbatim JSX spans
+ * (char-accurate origin, so each line maps back to its own DSL line) interleaved
+ * with each `{__reactra_await__(...)}` container rewritten to the Resource v0 §4
+ * Suspense + ErrorBoundary + `use(r.promise)` pattern. The await wrapper's
+ * boilerplate is `gen` (anchored at the await block), while the user's resource /
+ * success / pending / error bodies stay `verbatim` so they keep their own per-line
+ * origins. Joining the pieces' text reproduces the prior whole-body string rewrite
+ * exactly (#10-followup §8, Session 4 — replaces the single whole-view segment with
+ * per-line marks; the view body is passthrough in the preprocess hop, so per-line
+ * here composes into accurate source→compiled view mapping).
+ */
+const viewBodyPieces = (preprocessed, viewBody, 
+/** Additional substitutions to apply (e.g. inline-handler auto-wrap G6). */
+extraSubsts) => {
+    if (viewBody.start == null || viewBody.end == null)
+        return [];
+    const substs = [];
+    // Seed with extra substitutions (converted to the internal Subst format).
+    if (extraSubsts) {
+        for (const s of extraSubsts) {
+            substs.push({ start: s.start, end: s.end, pieces: [{ kind: "gen", text: s.replacement, anchorSrc: s.start }] });
+        }
+    }
+    // The synthetic wrap keeps node references stable, so `path.parent` still
+    // points at the original JSXExpressionContainer surrounding the call.
+    traverse(t.file(t.program([t.expressionStatement(viewBody)])), {
+        CallExpression(path) {
+            const callee = path.node.callee;
+            if (!t.isIdentifier(callee) || callee.name !== "__reactra_await__")
+                return;
+            if (path.node.start == null || path.node.end == null)
+                return;
+            // §B1: index via the shared AWAIT_ARG_ORDER so the resource/success/
+            // pending/error wiring can't drift between Pass 9 and the shadow.
+            const args = path.node.arguments;
+            const resourceArrow = args[AWAIT_ARG_ORDER.resource];
+            const successArrow = args[AWAIT_ARG_ORDER.success];
+            const pendingArrow = args[AWAIT_ARG_ORDER.pending];
+            const errorArrow = args[AWAIT_ARG_ORDER.error];
+            if (!t.isArrowFunctionExpression(resourceArrow) ||
+                !t.isArrowFunctionExpression(successArrow)) {
+                return;
+            }
+            const resourceText = sliceNode(preprocessed, resourceArrow.body);
+            const hasPending = t.isArrowFunctionExpression(pendingArrow);
+            const hasError = t.isArrowFunctionExpression(errorArrow);
+            let errorParam = "e";
+            if (hasError) {
+                const p = errorArrow.params[0];
+                if (p && t.isIdentifier(p))
+                    errorParam = p.name;
+            }
+            // Replace the whole `{__reactra_await__(...)}` container so the
+            // surrounding JSX text remains well-formed.
+            const parent = path.parent;
+            const start = t.isJSXExpressionContainer(parent) && parent.start != null
+                ? parent.start
+                : path.node.start;
+            const end = t.isJSXExpressionContainer(parent) && parent.end != null ? parent.end : path.node.end;
+            // Resource v0 §4 emission contract. The success body must run
+            // INSIDE a child component of <Suspense>, not as an IIFE — when
+            // `use(r.promise)` throws (the pending sentinel), React only
+            // catches it if the throw happens inside a render call that React
+            // is making. An IIFE evaluated during JSX construction throws
+            // BEFORE React sees the Suspense element, so the throw escapes
+            // the boundary and the parent component fails to mount.
+            // Wrapping in `<__AwaitInner />` defers `use()` to React's
+            // render-of-Inner, where the throw is correctly caught at the
+            // surrounding Suspense.
+            //
+            // displayName (devtools-debugging backlog issue C): the inner wrapper
+            // would otherwise show as "__AwaitInner" in React DevTools (repeated
+            // per await block). Label it after the awaited resource when that's a
+            // simple identifier (`Await(customer)`), else a plain `Await`. The
+            // label is a build-time string literal — zero runtime cost. The const
+            // keeps the `__` prefix: it's compiler-emitted + IIFE-local (R017).
+            //
+            // The wrapper text is `gen` (anchored at the await block `start`), so a
+            // breakpoint in it binds to the `await(...)` line; the user's resource /
+            // success / pending / error bodies are `verbatim`, so a breakpoint in
+            // any of them binds to its own DSL line (#10-followup §8, Session 4).
+            const awaitLabel = /^[A-Za-z_$][\w$]*$/.test(resourceText.trim())
+                ? `Await(${resourceText.trim()})`
+                : "Await";
+            const gen = (text) => ({ kind: "gen", text, anchorSrc: start });
+            const verbatim = (node) => ({
+                kind: "verbatim",
+                srcStart: node.start,
+                text: sliceNode(preprocessed, node),
+            });
+            const pieces = [];
+            if (hasError) {
+                pieces.push(gen(`<ErrorBoundary fallback={(${errorParam}) => `));
+                pieces.push(verbatim(errorArrow.body));
+                pieces.push(gen(`}>`));
+            }
+            pieces.push(gen(`<Suspense fallback={`));
+            if (hasPending)
+                pieces.push(verbatim(pendingArrow.body));
+            else
+                pieces.push(gen(`null`));
+            pieces.push(gen(`}>{(() => { const __AwaitInner = () => { use(`));
+            pieces.push(verbatim(resourceArrow.body));
+            pieces.push(gen(`.promise); return `));
+            pieces.push(verbatim(successArrow.body));
+            pieces.push(gen(` }; __AwaitInner.displayName = ${JSON.stringify(awaitLabel)}; return <__AwaitInner /> })()}</Suspense>`));
+            if (hasError)
+                pieces.push(gen(`</ErrorBoundary>`));
+            substs.push({ start, end, pieces });
+        },
+    });
+    // Walk left-to-right: verbatim gaps between await containers, the await pieces
+    // inline. The `s.start < cursor` guard drops an await nested in a prior await's
+    // body (already carried verbatim in that body's success slice) — robust where
+    // the prior reverse-replace would corrupt offsets.
+    substs.sort((a, b) => a.start - b.start);
+    const out = [];
+    let cursor = viewBody.start;
+    for (const s of substs) {
+        if (s.start < cursor)
+            continue;
+        if (s.start > cursor) {
+            out.push({ kind: "verbatim", srcStart: cursor, text: preprocessed.slice(cursor, s.start) });
+        }
+        out.push(...s.pieces);
+        cursor = s.end;
+    }
+    if (cursor < viewBody.end) {
+        out.push({ kind: "verbatim", srcStart: cursor, text: preprocessed.slice(cursor, viewBody.end) });
+    }
+    return out;
+};
+/**
+ * Replicate the legacy `view.replace(/^\(|\)$/g, "").trim()` cleanup at the piece
+ * level: strip a single leading `(` and trailing `)`, then surrounding whitespace,
+ * adjusting verbatim origins so they stay char-accurate. The joined text of the
+ * returned pieces equals the old trimmed string exactly (byte-identical output).
+ */
+const trimViewPieces = (pieces) => {
+    let s = pieces.map((p) => p.text).join("");
+    let front = 0;
+    let back = 0;
+    if (s.startsWith("(")) {
+        front += 1;
+        s = s.slice(1);
+    }
+    if (s.endsWith(")")) {
+        back += 1;
+        s = s.slice(0, -1);
+    }
+    const afterLead = s.trimStart();
+    front += s.length - afterLead.length;
+    back += afterLead.length - afterLead.trimEnd().length;
+    return dropBack(dropFront(pieces, front), back);
+};
+const extractInlineHandlers = (preprocessed, viewBody, stateNames, renamedStates) => {
+    const handlers = [];
+    const substs = [];
+    if (viewBody.start == null || viewBody.end == null)
+        return { handlers, substs };
+    // Count per event-prop name to suffix duplicates.
+    const propCount = new Map();
+    traverse(t.file(t.program([t.expressionStatement(viewBody)])), {
+        JSXAttribute(path) {
+            const attrName = path.node.name;
+            // Only `on*` event props.
+            if (!t.isJSXIdentifier(attrName) || !attrName.name.startsWith("on"))
+                return;
+            const container = path.node.value;
+            if (!t.isJSXExpressionContainer(container))
+                return;
+            const arrow = container.expression;
+            if (!t.isArrowFunctionExpression(arrow))
+                return;
+            if (arrow.start == null || arrow.end == null)
+                return;
+            // Does the body contain at least one state write (plain `=`, compound `+=`, update `++`)?
+            let hasStateWrite = false;
+            traverse(t.file(t.program([t.expressionStatement(arrow)])), {
+                AssignmentExpression(inner) {
+                    const left = inner.node.left;
+                    if (t.isIdentifier(left) && stateNames.has(left.name))
+                        hasStateWrite = true;
+                },
+                UpdateExpression(inner) {
+                    if (t.isIdentifier(inner.node.argument) && stateNames.has(inner.node.argument.name))
+                        hasStateWrite = true;
+                },
+            });
+            if (!hasStateWrite)
+                return;
+            // Synthesize a unique hoisted name.
+            const baseName = attrName.name; // e.g. "onChange"
+            const count = (propCount.get(baseName) ?? 0) + 1;
+            propCount.set(baseName, count);
+            const synName = count === 1 ? `__inline_${baseName}` : `__inline_${baseName}_${count}`;
+            const writeSubsts = [];
+            traverse(t.file(t.program([t.expressionStatement(arrow)])), {
+                AssignmentExpression(inner) {
+                    const left = inner.node.left;
+                    if (!t.isIdentifier(left) || !stateNames.has(left.name))
+                        return;
+                    if (inner.node.start == null || inner.node.end == null)
+                        return;
+                    const setter = setterNameFor(left.name, renamedStates);
+                    if (inner.node.operator === "=") {
+                        if (inner.node.right.start == null || inner.node.right.end == null)
+                            return;
+                        const rhsText = preprocessed.slice(inner.node.right.start, inner.node.right.end);
+                        writeSubsts.push({ start: inner.node.start, end: inner.node.end, replacement: `${setter}(${rhsText})` });
+                    }
+                    else {
+                        // Compound assignment — F2
+                        const binOp = COMPOUND_OP_MAP[inner.node.operator];
+                        if (!binOp)
+                            return;
+                        if (inner.node.right.start == null || inner.node.right.end == null)
+                            return;
+                        const rhsText = preprocessed.slice(inner.node.right.start, inner.node.right.end);
+                        writeSubsts.push({ start: inner.node.start, end: inner.node.end, replacement: `${setter}(prev => prev ${binOp} (${rhsText}))` });
+                    }
+                },
+                UpdateExpression(inner) {
+                    // x++ / ++x / x-- / --x — F2
+                    const arg = inner.node.argument;
+                    if (!t.isIdentifier(arg) || !stateNames.has(arg.name))
+                        return;
+                    if (inner.node.start == null || inner.node.end == null)
+                        return;
+                    const setter = setterNameFor(arg.name, renamedStates);
+                    const op = inner.node.operator === "++" ? "+" : "-";
+                    writeSubsts.push({ start: inner.node.start, end: inner.node.end, replacement: `${setter}(prev => prev ${op} 1)` });
+                },
+            });
+            writeSubsts.sort((a, b) => a.start - b.start);
+            // Rewrite the arrow source text: replace writes with setter calls.
+            let body = preprocessed.slice(arrow.start, arrow.end);
+            const base = arrow.start;
+            // Walk right-to-left so offset replacements don't shift pending positions.
+            for (let i = writeSubsts.length - 1; i >= 0; i--) {
+                const s = writeSubsts[i];
+                body = body.slice(0, s.start - base) + s.replacement + body.slice(s.end - base);
+            }
+            // Collect read-deps: align with Pass-3 collectDeps exclusions (F10):
+            // - skip plain `=` LHS (compound LHS is a read)
+            // - skip member property `obj.PROP` (not computed)
+            // - skip object key `{ KEY: val }` (not shorthand, not computed)
+            const deps = [];
+            const seenDeps = new Set();
+            traverse(t.file(t.program([t.expressionStatement(arrow)])), {
+                Identifier(inner) {
+                    const name = inner.node.name;
+                    if (!stateNames.has(name) || seenDeps.has(name))
+                        return;
+                    const parent = inner.parent;
+                    // Skip plain assignment LHS only (compound reads the value).
+                    if (t.isAssignmentExpression(parent) && parent.left === inner.node && parent.operator === "=")
+                        return;
+                    // Skip member property `obj.NAME` (not computed).
+                    if (t.isMemberExpression(parent) && parent.property === inner.node && !parent.computed)
+                        return;
+                    // Skip object key `{ NAME: val }` (not shorthand, not computed).
+                    if (t.isObjectProperty(parent) && parent.key === inner.node && !parent.computed && !parent.shorthand)
+                        return;
+                    deps.push(name);
+                    seenDeps.add(name);
+                },
+            });
+            const decl = `  const ${synName} = useCallback(${body}, [${deps.join(", ")}])`;
+            handlers.push({ name: synName, decl });
+            // Substitution: replace the whole JSXExpressionContainer span.
+            const containerStart = container.start;
+            const containerEnd = container.end;
+            if (containerStart != null && containerEnd != null) {
+                substs.push({ start: containerStart, end: containerEnd, replacement: `{${synName}}` });
+            }
+            // Stop traversing into this attribute's children.
+            path.skip();
+        },
+    });
+    return { handlers, substs };
+};
+const scanAwaits = (c) => {
+    const usage = { hasAwait: false, hasErrorBranch: false };
+    if (!c.view)
+        return usage;
+    const viewBody = c.view.body.body;
+    traverse(t.file(t.program([t.expressionStatement(viewBody)])), {
+        CallExpression(path) {
+            const callee = path.node.callee;
+            if (!t.isIdentifier(callee) || callee.name !== "__reactra_await__")
+                return;
+            usage.hasAwait = true;
+            const errorArrow = path.node.arguments[AWAIT_ARG_ORDER.error];
+            if (t.isArrowFunctionExpression(errorArrow))
+                usage.hasErrorBranch = true;
+        },
+    });
+    return usage;
+};
+/** Determine which React hooks need to be imported based on what the file uses. */
+const collectReactImports = (graph) => {
+    const needed = new Set();
+    for (const c of graph.containers) {
+        if (c.kind !== "component")
+            continue;
+        // The universal test-hook line (Testing §2 / Pass 9 v2.18) is a useEffect —
+        // every component needs the import, through this same collector path.
+        needed.add("useEffect");
+        if (c.states.length > 0)
+            needed.add("useState");
+        if (c.deriveds.length > 0)
+            needed.add("useMemo");
+        // Suppressed identity-setter actions (R016) aren't emitted, so they don't
+        // need useCallback. Async actions are never suppressed (always non-trivial).
+        const { suppressedActions } = classifyStateSetters(c);
+        if (c.actions.some((a) => !suppressedActions.has(a.name))) {
+            needed.add("useCallback");
+            if (c.actions.some((a) => a.isAsync))
+                needed.add("useTransition");
+        }
+        if (c.commands.some((cmd) => cmd.form === "block"))
+            needed.add("useActionState");
+        if (c.commands.some((cmd) => cmd.form === "arrow"))
+            needed.add("useTransition");
+        if (c.commands.some((cmd) => cmd.optimistic != null))
+            needed.add("useOptimistic");
+        // G6 — inline-handler auto-wrap emits `useCallback` declarations; check if
+        // any exist in the view body (quick scan — same state set, no full rewrite).
+        if (c.view != null && c.states.length > 0) {
+            const pp = graph.preprocessed;
+            const stateSet = new Set(c.states.map((s) => s.name));
+            const inlineResult = extractInlineHandlers(pp, c.view.body.body, stateSet, new Set());
+            if (inlineResult.handlers.length > 0)
+                needed.add("useCallback");
+        }
+        if (c.refs.length > 0)
+            needed.add("useRef");
+        if (c.effects.length > 0 ||
+            c.mounts.length > 0 ||
+            c.cleanups.length > 0 ||
+            // `meta { title }` applies the title in a useEffect (document.title).
+            c.meta !== undefined) {
+            needed.add("useEffect");
+        }
+        const usage = scanAwaits(c);
+        if (usage.hasAwait) {
+            needed.add("Suspense");
+            needed.add("use");
+        }
+        // Component-level `suspense { … }` wraps the view in <Suspense> (§7/§11).
+        if (c.suspense !== undefined)
+            needed.add("Suspense");
+        // Compiler-native behaviours (`uses undoable`/`replayable`) pull their own
+        // React hooks (e.g. undoable's preamble needs `useCallback` for undo/redo even
+        // with no actions — Undo §4.1; replayable needs `useEffect`). Pass 9.1 registry.
+        for (const b of matchedNativeBehaviours(c))
+            for (const hook of b.reactImports)
+                needed.add(hook);
+        // Wave 3 §2b — `provide X with Y` codegen needs `use(ServiceContext)`
+        // to read the parent overrides, then `useMemo` to keep the composed
+        // value stable across re-renders.
+        if (c.provides.length > 0) {
+            needed.add("use");
+            needed.add("useMemo");
+        }
+    }
+    return needed;
+};
+/** Which symbols, if any, must be imported from @reactra/resource. */
+const collectResourceImports = (graph) => {
+    const needed = new Set();
+    for (const c of graph.containers) {
+        if (c.kind === "component") {
+            if (c.resources.length > 0)
+                needed.add("useResource");
+            // A command's `invalidate [a, b]` clause refetches resources via the cache.
+            if (c.commands.some((cmd) => cmd.invalidate && cmd.invalidate.length > 0))
+                needed.add("__getResourceCache");
+            // <ErrorBoundary> is needed by an `await … error(e)` branch OR a
+            // component-level `errorBoundary(e) { … }` wrap (§7/§11).
+            if (scanAwaits(c).hasErrorBranch || c.errorBoundary !== undefined)
+                needed.add("ErrorBoundary");
+        }
+        else if (c.kind === "route-store" && c.resources.length > 0) {
+            // Stage 2 compiler — `warm(inputs, signal)` companion fans out to
+            // warmResource per declared resource (Resource v1 §8.1).
+            needed.add("warmResource");
+        }
+    }
+    return needed;
+};
+/** Which symbols, if any, must be imported from @reactra/store. */
+const collectStoreImports = (graph) => {
+    const needed = new Set();
+    for (const c of graph.containers) {
+        if (isStoreContainer(c)) {
+            needed.add("createStoreInstance");
+            // The HMR replace block at file tail calls `StoreRegistry.replace`
+            // for every store the file declares — pull the registry in.
+            needed.add("StoreRegistry");
+            // A store with `state` fields emits a `__registerStoreRestore(...)` call
+            // so devtools time-travel can re-drive it (plan store-time-travel §3.1).
+            // Only pulled in when some store in the file actually has state — a
+            // stateless store emits no call, so an unconditional import would be an
+            // unused-import diagnostic under noUnusedLocals.
+            if (c.states.length > 0)
+                needed.add("__registerStoreRestore");
+            // Each store emits `export type <name> = StoreSurface<typeof <name>>`
+            // (Store §2.5) so cross-file consumers bind via `import type`. The
+            // `type` modifier keeps it erasable under Node type-stripping + Vite.
+            needed.add("type StoreSurface");
+        }
+        if (c.kind === "component") {
+            // Both bare and argumented `use` subscribe to a live instance — they
+            // need the hook. Only argumented `use` ALSO emits routeBindings that
+            // call into StoreRegistry directly, which adds the registry import.
+            // A2: field-selected uses (`inject store X { a, b }`) emit
+            // `useReactraStoreFields` instead of the whole-store `useReactraStore`;
+            // import each only when that form is actually present (a file can have
+            // both forms in different components).
+            const isFieldSelected = (u) => !!u.fields && u.fields.length > 0;
+            if (c.storeUses.some((u) => !isFieldSelected(u)))
+                needed.add("useReactraStore");
+            if (c.storeUses.some(isFieldSelected))
+                needed.add("useReactraStoreFields");
+            if (c.storeUses.some((u) => u.classification === "argumented")) {
+                needed.add("StoreRegistry");
+            }
+        }
+    }
+    return needed;
+};
+/**
+ * Which symbols, if any, must be imported from @reactra/router. Day 10a:
+ * `useRoute` whenever a component declares any `param X` or `query X`.
+ * Path/query coercion, RouteLink, useQueryUpdater are Day 10b.
+ */
+const collectRouterImports = (graph) => {
+    const needed = new Set();
+    for (const c of graph.containers) {
+        if (c.kind !== "component")
+            continue;
+        if (c.params.length > 0 || c.queries.length > 0)
+            needed.add("useRoute");
+        // #5c-typed runtime query coercion: any query that isn't a bare
+        // string (or that carries a default) is read through `coerceQuery`.
+        if (c.queries.some(queryNeedsCoercion))
+            needed.add("coerceQuery");
+        // Day 16 / `#18b`: page components with argumented `use` emit a
+        // module-level `RouterRegistry.registerRouteBindings(…)` side effect.
+        if (c.storeUses.some((u) => u.classification === "argumented")) {
+            needed.add("RouterRegistry");
+        }
+    }
+    return needed;
+};
+/** A string-literal-union type, e.g. `"a" | "b"` or `'a' | 'b'`. */
+const ENUM_TYPE_RE = /^(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')(?:\s*\|\s*(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'))*$/;
+/** Strip a single pair of matching surrounding quotes from a literal member. */
+const stripQuotes = (s) => {
+    const t = s.trim();
+    if (t.length >= 2 && (t[0] === '"' || t[0] === "'") && t[t.length - 1] === t[0]) {
+        return t.slice(1, -1);
+    }
+    return t;
+};
+/**
+ * The `kind` argument to pass to the runtime `coerceQuery` for a declared
+ * query type: `"number"` / `"boolean"` / a JS array literal of allowed raw
+ * values for an enum / `"string"` for anything else (the passthrough case).
+ */
+const classifyQueryCoercionArg = (tsType) => {
+    const t = tsType.trim();
+    if (t === "number")
+        return `"number"`;
+    if (t === "boolean")
+        return `"boolean"`;
+    // `string[]` (repeated-key array) — distinct from an enum (which is a union of
+    // string literals); coerceQuery normalizes single→one-element-array on this kind.
+    if (t === "string[]")
+        return `"string[]"`;
+    if (ENUM_TYPE_RE.test(t)) {
+        const members = t.split("|").map((m) => JSON.stringify(stripQuotes(m)));
+        return `[${members.join(", ")}]`;
+    }
+    return `"string"`;
+};
+/**
+ * A query read needs `coerceQuery` iff its declared type is not a bare `string`,
+ * or it carries a `= default` (the default must be applied even for a string
+ * field). A plain `string` with no default is read directly. A custom parser
+ * (`from parseFoo`) replaces `coerceQuery` entirely with a `parseFoo(raw)` call.
+ */
+const queryNeedsCoercion = (q) => q.fromParser === undefined && (q.tsType.trim() !== "string" || q.defaultText !== undefined);
+/** Emit the per-query read line: a custom parser call, a `coerceQuery(...)` call, or a plain read. */
+const emitQueryRead = (q) => {
+    // Custom `from parseFoo`: the user's parser owns coercion. If a `= default`
+    // was also declared, `?? default` covers a null/undefined return.
+    if (q.fromParser !== undefined) {
+        const call = `${q.fromParser}(__route.query.${q.name})`;
+        const expr = q.defaultText !== undefined ? `(${call}) ?? (${q.defaultText})` : call;
+        return `  const ${q.name} = ${expr}`;
+    }
+    if (!queryNeedsCoercion(q))
+        return `  const ${q.name} = __route.query.${q.name}`;
+    const kindArg = classifyQueryCoercionArg(q.tsType);
+    const args = q.defaultText !== undefined
+        ? `__route.query.${q.name}, ${kindArg}, ${q.defaultText}`
+        : `__route.query.${q.name}, ${kindArg}`;
+    return `  const ${q.name} = coerceQuery(${args})`;
+};
+/**
+ * Which symbols, if any, must be imported from @reactra/service.
+ *
+ * `createServiceInstance` is needed whenever this file declares a service.
+ * `ServiceRegistry` is needed whenever any container — service, store, or
+ * component — has at least one `inject` declaration that needs runtime lookup
+ * (Strategy A: every inject compiles to `ServiceRegistry.get("X")`).
+ */
+const collectServiceImports = (graph) => {
+    const needed = new Set();
+    for (const c of graph.containers) {
+        if (c.kind === "service")
+            needed.add("createServiceInstance");
+        if (c.injects.length > 0)
+            needed.add("ServiceRegistry");
+        // The HMR replace block at file tail calls `ServiceRegistry.replace`
+        // — pull the registry in for any service-bearing file even when no
+        // component injects.
+        if (c.kind === "service")
+            needed.add("ServiceRegistry");
+        // Wave 3 §2b — Strategy B. A component-side `inject service X` flips
+        // to `useService("X")`; a `provide X with Y` block needs
+        // `ServiceContext` + `composeOverrides` (the value passed to the
+        // emitted <Provider>). `ServiceRegistry` is also pulled in for the
+        // `provide` codegen — composeOverrides accepts `{ X: ServiceRegistry
+        // .get("Y") }` for each provide pair.
+        if (c.kind === "component") {
+            const hasServiceInject = c.injects.some((i) => i.serviceKind === "service");
+            if (hasServiceInject)
+                needed.add("useService");
+            if (c.provides.length > 0) {
+                needed.add("ServiceContext");
+                needed.add("composeOverrides");
+                needed.add("ServiceRegistry");
+            }
+        }
+    }
+    return needed;
+};
+/** True for any of the three store container kinds. */
+const isStoreContainer = (c) => c.kind === "export-store" || c.kind === "route-store" || c.kind === "session-store";
+/**
+ * True when the file owns at least one Reactra store or service container.
+ * Pure-component files emit no HMR block — Vite's `@vitejs/plugin-react`
+ * already handles them via Fast Refresh (verified empirically Day 16).
+ */
+const hasHmrTargets = (graph) => graph.containers.some((c) => isStoreContainer(c) || c.kind === "service");
+/**
+ * Emit the `import.meta.hot.accept((newMod) => { … })` block per Compiler
+ * §5.3. For every store binding the file exports, call
+ * `StoreRegistry.replace(newMod.<name>)` so the registry picks up the new
+ * factory. Same shape for services via `ServiceRegistry.replace`.
+ *
+ * The `if (!newMod) return` guard handles Vite's hot-dispose path — when
+ * the module is removed from the dep graph, newMod is undefined and we
+ * have nothing to swap.
+ *
+ * Vite's HMR API allows multiple `accept` calls per module; React's plugin
+ * registers its own handler for Fast Refresh of any component exports in
+ * the same file. The mixed page+store case still falls back to full reload
+ * because Fast Refresh bails on `Object.assign`-wrapped page components —
+ * tracked as a known Phase-1 limitation.
+ */
+const emitHmrBlock = (graph) => {
+    const stores = graph.containers.filter(isStoreContainer);
+    const services = graph.containers.filter((c) => c.kind === "service");
+    const replaceLines = [
+        ...stores.map((c) => `    StoreRegistry.replace(newMod.${c.name})`),
+        ...services.map((c) => `    ServiceRegistry.replace(newMod.${c.name})`),
+    ];
+    return [
+        "if (import.meta.hot) {",
+        "  import.meta.hot.accept((newMod) => {",
+        "    if (!newMod) return",
+        ...replaceLines,
+        "  })",
+        "}",
+    ].join("\n");
+};
+/**
+ * Emit `const X = <lookup>` for an `inject X` declaration.
+ *
+ * - In a **component** body (Wave 3 §2b — Strategy B): emit
+ *   `const X = useService("X")` so any ancestor `provide X with Y` is
+ *   honoured. The hook reads `ServiceContext` and falls back to the
+ *   module-level singleton when no override is active.
+ * - In a **service** or **store** body: emit
+ *   `const X = ServiceRegistry.get("X")` directly. Service-to-service and
+ *   store-to-service injection happens outside any React render context,
+ *   so `useService` is unavailable AND unnecessary — store/service code
+ *   doesn't sit inside a `<provide>` subtree.
+ */
+const emitInjectLookup = (inj, containerKind) => {
+    // SVC015 (Requirements v14): an opaque bare `inject X` — no `store`/`service`
+    // kind qualifier and no `from` source clause — is a build error. The
+    // `from config(...)` / `from inject` forms carry a `source` and stay valid.
+    if (inj.serviceKind === undefined && inj.source === undefined) {
+        throw new Error(`[reactra:compile] SVC015: \`inject ${inj.name}\` is missing a kind qualifier. ` +
+            `Write \`inject service ${inj.name}\` (or \`inject store ${inj.name}\` for a store), ` +
+            `or add a \`from config(...)\` / \`from inject\` source clause. (Requirements v14 / Service v3 §12.)`);
+    }
+    // Strategy B applies to component-side `inject service X` only — `from`-
+    // sourced injects (config / inject-pass-through) keep their existing
+    // singleton path (the runtime equivalent of useService isn't needed).
+    // `inject service X as Y` (Service v2.3 §4.2) renames the binding; the service
+    // identity ("X") is unchanged.
+    const binding = inj.alias ?? inj.name;
+    if (containerKind === "component" && inj.serviceKind === "service") {
+        return `const ${binding} = useService("${inj.name}")`;
+    }
+    return `const ${binding} = ServiceRegistry.get("${inj.name}")`;
+};
+/**
+ * Emit `const [name, setName] = useState(init)` for a StateNode. The setter is
+ * the public `set<Cap(name)>`, except when a non-trivial `action set<Cap(name)>`
+ * owns that name — then it's the internal `__set<Cap(name)>` (improvements #4).
+ */
+const emitState = (preprocessed, s, renamedStates, optimisticStates) => {
+    const setter = setterNameFor(s.name, renamedStates);
+    // Optimistic-tracked state (a `command`'s `optimistic {}` writes it) gets a
+    // shadow pair: `__base_X` is the real useState the commit settles into, and the
+    // public `X` the view reads is the useOptimistic mirror that paints instantly
+    // and auto-reverts if the await throws (Slice 3b). The view needs no rewrite —
+    // `X` already resolves to the mirror.
+    if (optimisticStates.has(s.name)) {
+        const prefix = `const [__base_${s.name}, ${setter}] = useState(`;
+        const suffix = `)\n  const [${s.name}, __setOpt_${s.name}] = useOptimistic(__base_${s.name})`;
+        return mappedSlice(preprocessed, prefix, s.initializer, suffix);
+    }
+    const prefix = `const [${s.name}, ${setter}] = useState(`;
+    return mappedSlice(preprocessed, prefix, s.initializer, `)`);
+};
+/**
+ * Emit `const d = useMemo(() => expr, [<reactive reads>])` for a DerivedNode.
+ *
+ * F1 fix: when the thunk body is an ObjectExpression (e.g. `derived r = { a: 1 }`,
+ * which the block-derived G4 rewriter preserves as an arrow returning an object
+ * literal), the bare slice `{ a: 1 }` in arrow position is a block statement that
+ * returns `undefined`. Wrap it in parens → `() => ({ a: 1 })`.
+ * The IIFE block form (`derived r = { const t = x; return t }`) has the thunk body
+ * as a CallExpression (the IIFE), not an ObjectExpression — it is unaffected.
+ */
+const emitDerived = (preprocessed, d) => {
+    const isObjLiteral = t.isObjectExpression(d.thunk.body);
+    const prefix = `const ${d.name} = useMemo(() => ${isObjLiteral ? "(" : ""}`;
+    const suffix = `${isObjLiteral ? ")" : ""}, [${d.deps.join(", ")}])`;
+    return mappedSlice(preprocessed, prefix, d.thunk.body, suffix);
+};
+/**
+ * Emit `const r = useResource(deps, fetcher, { resourceName: "r" })` for a
+ * ResourceNode.
+ *
+ * The preprocessor emits `__reactra_resource__("r", () => (deps), (deps, ctx) => (fn(deps)))`;
+ * Pass 2 captures both arrows. Here we unwrap the deps thunk to a bare deps
+ * expression (Resource v0 §2 — `deps` is the value itself, not a thunk) and
+ * pass the fetcher arrow through verbatim. The fetcher's second parameter is
+ * named `ctx` by the preprocessor; the runtime supplies `{ signal }` — the
+ * user code in the fetcher body is whatever the DSL author wrote and may
+ * choose to ignore ctx entirely.
+ *
+ * Resource v1 (architect Q2 Path B): the binding identifier is also injected
+ * as `opts.resourceName`. This is what lets `useMutation.invalidate(["r"])`
+ * report RES014 on typos and gives the runtime a stable name for cache
+ * + warm participation. DSL-compiled callers stay cache-OFF by default —
+ * we deliberately do NOT inject `cache: true`. Per-resource cache opt-in
+ * is a separate DSL grammar extension (post v1.1); hand-written callers
+ * can still pass `cache: true` directly to `useResource` today.
+ */
+/**
+ * Wave 3 §2b Stage 5 — AbortSignal auto-injection (Service spec §8.4).
+ *
+ * Detects the canonical pattern `resource X(deps) => svc.method(args)`
+ * where:
+ *   - the fetcher's body is a single call expression on a member
+ *     (`svc.method(...)`), AND
+ *   - the receiver (`svc`) is a component-side `inject service svc`, AND
+ *   - the user did NOT explicitly use the `signal` modifier
+ *     (which would already destructure `{ signal }` in the params).
+ *
+ * When matched, returns rewritten fetcher text that adds `{ signal }` to
+ * the params and appends `signal` to the method call's arguments. Falls
+ * back to `null` (verbatim emit) otherwise — the user's complex fetcher
+ * gets emitted as-is, no surprises.
+ *
+ * The text construction slices the preprocessed source for each param
+ * and the body's call expression, then inserts `, signal` before the
+ * call's closing `)` (handling the empty-args case where no leading
+ * comma is needed).
+ */
+const autoInjectAbortSignal = (preprocessed, r, c) => {
+    const fetcher = r.fetcher;
+    // Skip when the user's `signal` modifier already destructured signal —
+    // that path is the user's explicit signal-aware fetcher.
+    for (const p of fetcher.params) {
+        if (t.isObjectPattern(p)) {
+            for (const prop of p.properties) {
+                if (t.isObjectProperty(prop) &&
+                    t.isIdentifier(prop.key) &&
+                    prop.key.name === "signal") {
+                    return null;
+                }
+            }
+        }
+    }
+    if (!t.isCallExpression(fetcher.body))
+        return null;
+    const callee = fetcher.body.callee;
+    if (!t.isMemberExpression(callee) || callee.computed)
+        return null;
+    if (!t.isIdentifier(callee.object))
+        return null;
+    const receiverName = callee.object.name;
+    const matched = c.injects.find((i) => i.name === receiverName && i.serviceKind === "service");
+    if (!matched)
+        return null;
+    // Build the new params + body text. Each param is sliced verbatim from
+    // the preprocessed source so a destructured `({ id, page })` shape is
+    // preserved exactly.
+    const paramsText = fetcher.params.length === 0
+        ? "{ signal }"
+        : fetcher.params
+            .map((p) => preprocessed.slice(p.start, p.end))
+            .join(", ") + ", { signal }";
+    const bodyText = preprocessed.slice(fetcher.body.start, fetcher.body.end);
+    // Find the `(` after the callee — that's the args-list opener. Insert
+    // `, signal` before the matching `)`. The bodyText is the FULL call
+    // expression so the last char is the close paren.
+    const openParen = bodyText.lastIndexOf("(");
+    if (openParen < 0)
+        return null;
+    const argsInside = bodyText.slice(openParen + 1, -1).trim();
+    const newArgs = argsInside === "" ? "signal" : `${argsInside}, signal`;
+    const newBody = `${bodyText.slice(0, openParen + 1)}${newArgs})`;
+    return `(${paramsText}) => ${newBody}`;
+};
+const emitResource = (preprocessed, r, c) => {
+    const injected = autoInjectAbortSignal(preprocessed, r, c);
+    if (injected !== null) {
+        // Auto-injected fetcher emitted as constructed text — source-map
+        // fidelity for the fetcher body is lost on this line in exchange
+        // for the spec §8.4 abort-safe wiring.
+        return concatE([
+            mappedSlice(preprocessed, `const ${r.name} = useResource(`, r.depsThunk.body, ``),
+            plain(`, ${injected}`),
+            plain(`, { resourceName: ${JSON.stringify(r.name)}${emitResourceOpts(r)} })`),
+        ]);
+    }
+    return concatE([
+        mappedSlice(preprocessed, `const ${r.name} = useResource(`, r.depsThunk.body, ``),
+        plain(`, `),
+        mappedSlice(preprocessed, ``, r.fetcher, ``),
+        plain(`, { resourceName: ${JSON.stringify(r.name)}${emitResourceOpts(r)} })`),
+    ]);
+};
+/**
+ * Stage 3 — emit the comma-separated tail of opt-in ResourceOptions fields
+ * (compiler-grammar-driven). Returns "" when no modifiers were declared,
+ * preserving the Stage 1 / Path B emission shape exactly. `swr` supersedes
+ * a bare `cache` (swr implies caching with `staleWhileRevalidate: true`).
+ * Parameterized forms supply their own value: `swr(D)` / `cache(ttl: D)` →
+ * `cacheTtl` (ms, validated at Pass 1.1); `cache(ttl: D)` without swr is
+ * hard-expiry; `retry(N)` → `retryCount`. Bare modifiers fall back to the
+ * defaults (`ttlMs: 60_000`, `retry: 3`, `cache: true`) — byte-identical to
+ * pre-parameterization. Custom retry backoff (`baseMs`/`jitter`) is not yet
+ * DSL-expressible (raw `useResource` callers can still pass it).
+ */
+const emitResourceOpts = (r) => {
+    const parts = [];
+    if (r.optSwr)
+        parts.push(`cache: { staleWhileRevalidate: true, ttlMs: ${r.cacheTtl ?? "60_000"} }`);
+    else if (r.optCache)
+        parts.push(r.cacheTtl !== undefined ? `cache: { ttlMs: ${r.cacheTtl} }` : `cache: true`);
+    if (r.optRetry)
+        parts.push(`retry: ${r.retryCount ?? "3"}`);
+    if (r.select !== undefined)
+        parts.push(`select: ${r.select}`);
+    return parts.length > 0 ? `, ${parts.join(", ")}` : ``;
+};
+/**
+ * Stage B — functional-setter lowering for the self-reference case. When a sync
+ * action's whole body is a single `X = expr` whose only reactive read is the
+ * assigned state `X` itself (`Pass 3` deps === `[X]`), lower it to
+ * `setX(prev => expr[X→prev])` and emit `[]` deps. This keeps a stable callback
+ * identity (the callback never closes over `X`), which matters when the action
+ * is passed to a `React.memo` child. Returns null when not eligible — async
+ * actions, compound operators, multi-statement bodies, or any other reactive
+ * read all fall back to Stage A (`actionBodyPieces` + inferred deps).
+ *
+ * Source-map fidelity for the rewritten body line is traded for the stable
+ * identity (the verbatim Stage-A path keeps its mapping); same trade as the
+ * AbortSignal auto-injection.
+ */
+const selfSetterRewrite = (preprocessed, a, stateNames, renamedStates) => {
+    if (a.isAsync)
+        return null;
+    if (a.deps.length !== 1)
+        return null; // sole reactive read must be the assigned state
+    const arrow = a.arrow;
+    const body = arrow.body;
+    if (!t.isBlockStatement(body) || body.body.length !== 1)
+        return null;
+    const stmt = body.body[0];
+    if (!t.isExpressionStatement(stmt) || !t.isAssignmentExpression(stmt.expression))
+        return null;
+    const assign = stmt.expression;
+    if (assign.operator !== "=")
+        return null; // compound `x += …` reads + writes — Stage A
+    const left = assign.left;
+    if (!t.isIdentifier(left) || !stateNames.has(left.name) || left.name !== a.deps[0])
+        return null;
+    const rhs = assign.right;
+    if (arrow.start == null ||
+        body.start == null ||
+        rhs.start == null ||
+        rhs.end == null) {
+        return null;
+    }
+    // Replace the free reads of `left.name` in the RHS with `prev` (right-to-left
+    // to preserve offsets); inner-shadowed and member-property occurrences are
+    // left alone.
+    // Capture into a local — the guard above narrowed `rhs.start` to non-null, but
+    // that narrowing is lost inside the `.map` closure (a mutable object property).
+    const rhsStart = rhs.start;
+    let rhsText = preprocessed.slice(rhsStart, rhs.end);
+    const ranges = freeStateReadRanges(rhs, left.name)
+        .map((r) => ({ start: r.start - rhsStart, end: r.end - rhsStart }))
+        .sort((x, y) => y.start - x.start);
+    for (const r of ranges)
+        rhsText = rhsText.slice(0, r.start) + "prev" + rhsText.slice(r.end);
+    const setter = setterNameFor(left.name, renamedStates);
+    const arrowHead = preprocessed.slice(arrow.start, body.start); // `(params) => `
+    return `${arrowHead}{ ${setter}(prev => ${rhsText}) }`;
+};
+/** Absolute `{start,end}` ranges of free (non-shadowed, non-property) reads of `name` in `expr`. */
+const freeStateReadRanges = (expr, name) => {
+    const out = [];
+    traverse(t.file(t.program([t.expressionStatement(expr)])), {
+        Identifier(path) {
+            const node = path.node;
+            if (node.name !== name || node.start == null || node.end == null)
+                return;
+            const parent = path.parent;
+            if (t.isMemberExpression(parent) && parent.property === node && !parent.computed)
+                return;
+            if (t.isObjectProperty(parent) &&
+                parent.key === node &&
+                !parent.computed &&
+                !parent.shorthand) {
+                return;
+            }
+            if (path.scope.hasBinding(name))
+                return; // shadowed by an inner arrow/local
+            out.push({ start: node.start, end: node.end });
+        },
+    });
+    return out;
+};
+/** True when an action body assigns to a `state` field (so `undoable` snapshots it). */
+const actionWritesState = (arrow, stateNames) => {
+    let writes = false;
+    traverse(t.file(t.program([t.expressionStatement(arrow)])), {
+        AssignmentExpression(path) {
+            const left = path.node.left;
+            if (t.isIdentifier(left) && stateNames.has(left.name))
+                writes = true;
+        },
+    });
+    return writes;
+};
+/**
+ * Wrap an async action's body in `startTransition_f(async () => …)` and append
+ * `f.isPending = isPending_f`, per Component DSL §11 (the `action async` row). The
+ * outer arrow keeps the user's params (`async (id) => …`); the inner `async () =>`
+ * runs the body INSIDE the transition so React 19 drives the pending flag, and the
+ * exposed `f.isPending` lets the view read it (`disabled={save.isPending}`). The
+ * `head` already declared `const [isPending_f, startTransition_f] = useTransition()`.
+ *
+ * Without this, the declared transition locals were unused and `f.isPending` was
+ * `undefined` — the whole pending-state feature was inert (the original BUG-1).
+ */
+/**
+ * Emit the BLOCK `command` form → React 19 `useActionState` (P3 Slice 1).
+ *
+ *   command f(args) { …return X… }
+ *
+ * lowers to a reducer that runs the user's (implicitly-async) body and folds its
+ * outcome into a `{ ok, value | error }` result, plus the `useActionState` wiring
+ * and the handle surface `f.pending` / `f.result` / `f.error`. The user's arrow is
+ * emitted verbatim (source-mapped) and IIFE-called with the dispatch payload, so
+ * no body rewrite is needed. No deps array — `useActionState` re-reads the action
+ * each render, so the reducer closes over fresh state. (Arrow + `optimistic {}` →
+ * `useOptimistic`, and the `uses replayable`/`undoable` begin/commit/rollback
+ * recording layer, are later slices.)
+ */
+const emitCommand = (preprocessed, cmd, c, stateNames, renamedStates) => {
+    const n = cmd.name;
+    // Recording layer (Slice 2): when the component `uses replayable`, the command
+    // records as ONE transaction unit via the P2 channel — begin → commit (success)
+    // | rollback (failure). The settle snapshot lists the current state (the
+    // channel's delta machinery drops an empty diff). No observability opt-in →
+    // the bare React-19 lowering.
+    const recording = c.uses?.names.includes("replayable") ?? false;
+    const stateObj = c.states.map((s) => s.name).join(", ");
+    // Arrow form (Slice 3a/3b): `command f() => fetcher` → useTransition. With an
+    // `optimistic {}` clause (Slice 3b) the tracked states are useOptimistic mirrors:
+    // apply the optimistic write before the await (`__setOpt_X` paints instantly,
+    // auto-reverts on throw), settle the real write (`setX`) only on success.
+    if (cmd.form === "arrow") {
+        const optWrites = optimisticWritesOf(preprocessed, cmd, stateNames);
+        const hasOpt = optWrites.size > 0;
+        const apply = [...optWrites].map(([nm, rhs]) => `__setOpt_${nm}(${rhs});`).join(" ");
+        const commitW = [...optWrites].map(([nm, rhs]) => `${setterNameFor(nm, renamedStates)}(${rhs});`).join(" ");
+        // The recorded delta = the optimistic write-set (so the timeline shows the
+        // intended next state); with no optimistic clause it's the whole state object.
+        const deltaObj = hasOpt ? `{ ${[...optWrites].map(([nm, rhs]) => `${nm}: ${rhs}`).join(", ")} }` : `{ ${stateObj} }`;
+        const baseObj = `{ ${stateObj} }`;
+        // `invalidate [a, b]` — refetch the listed resources after the command settles.
+        const hasInv = (cmd.invalidate?.length ?? 0) > 0;
+        const invT = hasInv ? `__getResourceCache().invalidate([${cmd.invalidate.map((nm) => JSON.stringify(nm)).join(", ")}]); ` : "";
+        const hasRb = cmd.rollback != null;
+        const decl = `const [__pending_${n}, __start_${n}] = useTransition();\n` +
+            `  const ${n} = (__payload?: unknown) => __start_${n}(async () => { `;
+        const expose = `\n  ${n}.pending = __pending_${n}`;
+        const needTry = recording || hasRb;
+        // Preamble before the await: recording begin (+ optimistic mark), then the
+        // optimistic apply (paints the mirror).
+        let pre = "";
+        if (recording) {
+            pre += `const __tx_${n} = __replay.begin("${n}", [__payload], ${baseObj}); `;
+            if (hasOpt)
+                pre += `__tx_${n}.mark(${deltaObj}); `;
+        }
+        if (hasOpt)
+            pre += `${apply} `;
+        // Success tail (after the await): commit the real setters, invalidate, channel commit.
+        let okTail = "";
+        if (hasOpt)
+            okTail += `${commitW} `;
+        if (hasInv)
+            okTail += invT;
+        if (recording)
+            okTail += hasOpt ? `__tx_${n}.commit(${deltaObj}); ` : `__tx_${n}.commit(${baseObj}); `;
+        const parts = [plain(`${decl}${pre}${needTry ? "try { " : ""}await (`)];
+        parts.push(mappedSlice(preprocessed, "", cmd.arrow, "")); // the fetcher, source-mapped
+        parts.push(plain(`)(__payload); ${okTail}`));
+        if (needTry) {
+            let catchHead = `} catch (__e) { `;
+            if (recording)
+                catchHead += `__tx_${n}.rollback(${baseObj}); `;
+            parts.push(plain(catchHead));
+            if (hasRb) {
+                // The user's rollback handler — lowered like an action body (state writes →
+                // setters), IIFE-called with the error. The failure is treated as handled.
+                const rbPieces = actionBodyPieces(preprocessed, { arrow: cmd.rollback, name: n }, stateNames, renamedStates);
+                parts.push(plain("("));
+                parts.push(emitMappedPieces("", rbPieces, ""));
+                parts.push(plain(")(__e); "));
+            }
+            else {
+                // No user handler: re-throw so the error reaches the error boundary (the
+                // transition reverts the optimistic mirror either way).
+                parts.push(plain(`throw __e; `));
+            }
+            parts.push(plain(`} });${expose}`));
+        }
+        else {
+            parts.push(plain(`});${expose}`));
+        }
+        return concatE(parts);
+    }
+    // Block form (Slice 1/2): `command f() { …return… }` → useActionState, exposing
+    // f.pending / f.result / f.error. The user's arrow is IIFE-called with the payload.
+    const begin = recording ? `const __tx_${n} = __replay.begin("${n}", [__payload], { ${stateObj} }); ` : "";
+    const commit = recording ? `__tx_${n}.commit({ ${stateObj} }); ` : "";
+    const rollback = recording ? `__tx_${n}.rollback({ ${stateObj} }); ` : "";
+    const prefix = `const __cmd_${n} = async (__prev: unknown, __payload: unknown) => { ${begin}` +
+        `try { const __v = await (`;
+    const suffix = `)(__payload); ${commit}return { ok: true as const, value: __v }; } ` +
+        `catch (__e) { ${rollback}return { ok: false as const, error: __e instanceof Error ? __e.message : String(__e) }; } };\n` +
+        `  const [__state_${n}, ${n}, __pending_${n}] = useActionState(__cmd_${n}, { ok: null as boolean | null });\n` +
+        `  ${n}.pending = __pending_${n};\n` +
+        `  ${n}.result = __state_${n}.ok === true ? __state_${n}.value : undefined;\n` +
+        `  ${n}.error = __state_${n}.ok === false ? __state_${n}.error : undefined`;
+    return mappedSlice(preprocessed, prefix, cmd.arrow, suffix);
+};
+const emitAsyncAction = (preprocessed, a, head, pieces, deps) => {
+    const arrow = a.arrow;
+    // `f.isPending = isPending_f` is re-asserted each render onto the (possibly
+    // memoised) callback, so a `pending` flip — which re-renders — refreshes it.
+    const exposeSuffix = `, [${deps}])\n  ${a.name}.isPending = isPending_${a.name}`;
+    // Split the body pieces at the block's opening `{` so the user's arrow head
+    // (`async (params) => `) stays OUTSIDE the inner transition arrow.
+    if (arrow.start == null || !t.isBlockStatement(arrow.body) || arrow.body.start == null) {
+        // Defensive — a parsed `action async f() {…}` always has a block body.
+        return emitMappedPieces(head, pieces, exposeSuffix);
+    }
+    const headLen = arrow.body.start - arrow.start; // length of `async (params) => `
+    const wrapped = [
+        ...takeFront(pieces, headLen),
+        { kind: "gen", text: `startTransition_${a.name}(async () => `, anchorSrc: arrow.body.start },
+        ...dropFront(pieces, headLen),
+        { kind: "gen", text: `)`, anchorSrc: arrow.end ?? arrow.body.start },
+    ];
+    return emitMappedPieces(head, wrapped, exposeSuffix);
+};
+const NO_AUGMENTATION = {
+    augmented: false,
+    prologue: null,
+    epilogue: null,
+    widensDeps: false,
+};
+/**
+ * Fold the matched native behaviours (Pass 9.1) into a single per-action
+ * augmentation, in `uses` source order. For `uses undoable` this yields the
+ * former `isUndoableWrite` path verbatim (prologue `__undo.push(__snapshot())` +
+ * all-state dep widening on state-writers). Multi-behaviour prologue/epilogue
+ * composition is exercised once `replayable` lands (Piece A step 2).
+ */
+const augmentationFor = (a, c, behaviours, ctx) => {
+    const applies = behaviours.filter((b) => b.augmentsAction(a, c, ctx));
+    if (applies.length === 0)
+        return NO_AUGMENTATION;
+    const prologues = applies.map((b) => b.actionPrologue(a, c, ctx)).filter((p) => p != null);
+    // Epilogues compose in reverse `uses` order so the outermost behaviour's
+    // teardown runs last (mirror of the preamble order), matching HOF nesting.
+    const epilogues = [...applies]
+        .reverse()
+        .map((b) => b.actionEpilogue(a, c, ctx))
+        .filter((p) => p != null);
+    return {
+        augmented: true,
+        // Each prologue is its own `;`-terminated statement(s) (undoable's
+        // `__undo.push(__snapshot());`, replay's `…action(…);`), so a space join keeps
+        // them as separate statements and separates the last one from the body.
+        prologue: prologues.length > 0 ? prologues.join(" ") : null,
+        epilogue: epilogues.length > 0 ? epilogues.join("; ") : null,
+        widensDeps: applies.some((b) => b.widensAugmentedActionDeps),
+    };
+};
+/** Emit `const f = useCallback(rewrittenArrow, [<reactive reads>])` for an ActionNode. */
+const emitAction = (preprocessed, a, stateNames, renamedStates, 
+// Native-behaviour augmentation for this action (Pass 9.1) — a state-writing
+// `uses undoable` action carries `__undo.push(__snapshot())` + all-state deps.
+aug = NO_AUGMENTATION) => {
+    const callbackPrefix = `const ${a.name} = useCallback(`;
+    const head = a.isAsync
+        ? `const [isPending_${a.name}, startTransition_${a.name}] = useTransition()\n  ${callbackPrefix}`
+        : callbackPrefix;
+    // Behaviour augmentation takes precedence over Stage B: snapshot-before-body,
+    // deps = all state names (Stage B's stable-identity `[]` is moot here since the
+    // snapshot already closes over every state field).
+    // Stage B — stable-identity functional-setter form (sync self-reference only;
+    // `selfSetterRewrite` bails on async, so it never collides with the transition
+    // wrap below). Skipped when a behaviour owns the body.
+    if (!aug.augmented) {
+        const rewritten = selfSetterRewrite(preprocessed, a, stateNames, renamedStates);
+        if (rewritten !== null) {
+            return emitMappedPieces(head, [{ kind: "gen", text: rewritten, anchorSrc: a.arrow.start }], `, [])`);
+        }
+    }
+    // Stage A — verbatim body with setter lowering + inferred deps (or, for an
+    // augmented action, the behaviour prologue + all-state deps). The body is
+    // decomposed into pieces: verbatim source spans keep char-accurate origins,
+    // the lowered `set<X>(`/`)` are generated. Per-line marks bind breakpoints
+    // across a multi-line body and at each setter-rewrite site (#10-followup §8).
+    const pieces = aug.augmented
+        ? actionBodyPieces(preprocessed, a, stateNames, renamedStates, aug.prologue ?? undefined, aug.epilogue ?? undefined)
+        : actionBodyPieces(preprocessed, a, stateNames, renamedStates);
+    // Widened: ALL states (the snapshot closes over them) UNION the body's
+    // non-state reads — referenced actions (BUG-2), `param`/`query`/store reads —
+    // so the callback still tracks them. Otherwise: the inferred read-set as-is
+    // (already includes referenced actions after Pass 3's callback-set widening).
+    const deps = aug.widensDeps
+        ? [...stateNames, ...a.deps.filter((d) => !stateNames.has(d))].join(", ")
+        : a.deps.join(", ");
+    // Async (Component DSL §11) — wrap the body in a transition + expose isPending.
+    if (a.isAsync)
+        return emitAsyncAction(preprocessed, a, head, pieces, deps);
+    return emitMappedPieces(head, pieces, `, [${deps}])`);
+};
+/**
+ * Order a component's emitted actions so a callee is declared before any action
+ * that lists it as a dependency (BUG-2 Direction A) — otherwise the `[callee]`
+ * dep array would reference an uninitialised `const` (TDZ). Post-order DFS over
+ * the action→action edges (`a.deps` ∩ emitted-action-names, minus self); a back
+ * edge is a reference cycle, which has no valid order → **R021**. Suppressed
+ * identity setters (R016) are excluded — they emit as the stable `useState`
+ * setter, already in scope. Independent actions keep declaration order.
+ */
+const orderActionsForEmit = (c, suppressedActions) => {
+    const emitted = c.actions.filter((a) => !suppressedActions.has(a.name));
+    const names = new Set(emitted.map((a) => a.name));
+    const byName = new Map(emitted.map((a) => [a.name, a]));
+    const out = [];
+    const visitState = new Map();
+    const visit = (a, stack) => {
+        const st = visitState.get(a.name);
+        if (st === "done")
+            return;
+        if (st === "visiting") {
+            const cycle = [...stack.slice(stack.indexOf(a.name)), a.name].join(" → ");
+            throw new Error(`[reactra:compile] R021: reference cycle among actions in component "${c.name}": ${cycle}. ` +
+                `Mutually-recursive actions cannot be ordered so each lists the other as a dependency — ` +
+                `break the cycle by extracting the shared logic into a store action or a plain helper. ` +
+                `(Component DSL §14 R021.)`);
+        }
+        visitState.set(a.name, "visiting");
+        for (const dep of a.deps) {
+            if (dep !== a.name && names.has(dep))
+                visit(byName.get(dep), [...stack, a.name]);
+        }
+        visitState.set(a.name, "done");
+        out.push(a); // post-order — pushed after its callees, so callees emit first
+    };
+    for (const a of emitted)
+        visit(a, []);
+    return out;
+};
+/**
+ * True when an `inject store X` name is bound — either a same-file store
+ * declaration or a type-only import `import type { X }` / `import { type X }`
+ * (Store §2.5). The type-only import is what makes the name traceable and
+ * survives package boundaries; the sidecar is no longer consulted (backlog 1a,
+ * Compiler §6). An unbound cross-file reference is S014.
+ */
+const isStoreNameBound = (graph, name) => {
+    if (graph.containers.some((c) => isStoreContainer(c) && c.name === name))
+        return true;
+    return graph.userImports.some((imp) => importsTypeName(imp, name));
+};
+/**
+ * Does a user import statement bind `name` as a store/service reference?
+ * Accepts `import type { name }`, `import { type name }`, and `import { name }`
+ * (DSL v2 honest value imports — Phase 5 migration converts `import type` to
+ * `import { }`, so both forms must be accepted during the v1→v2 transition).
+ */
+const importsTypeName = (imp, name) => {
+    const typeOnlyImport = new RegExp(`\\bimport\\s+type\\b[^;]*\\{[^}]*\\b${name}\\b[^}]*\\}`);
+    const inlineTypeSpecifier = new RegExp(`\\bimport\\b[^;]*\\{[^}]*\\btype\\s+${name}\\b[^}]*\\}`);
+    // DSL v2: plain value import `import { storeX }` from "...".
+    // This is the honest-import form (reactra-dsl-v2-surface.md §FB-6.4).
+    const valueImport = new RegExp(`\\bimport\\b(?!\\s+type\\b)[^;]*\\{[^}]*\\b${name}\\b[^}]*\\}`);
+    return typeOnlyImport.test(imp) || inlineTypeSpecifier.test(imp) || valueImport.test(imp);
+};
+/**
+ * Emit the React-side subscription for an `inject store X` binding (bare or
+ * argumented — both subscribe to a live instance). Backlog 1a access model
+ * (Store §2.5):
+ *   - field selection `inject store X { a, b }` → per-field subscription:
+ *     `const { a, b } = useReactraStoreFields<X>("X", ["a", "b"])` (A2 / Store
+ *     §7.3 — re-renders only when a selected source field changes)
+ *   - no braces → namespace binding `const X = useReactraStore<X>("X")` (member access `X.a`)
+ *
+ * The `<X>` type param resolves to the store's emitted public-surface type
+ * (`export type X = StoreSurface<typeof X>`) — same-file (hoisted) or via the
+ * consumer's `import type { X }`. No sidecar lookup. A cross-file reference
+ * with neither a same-file decl nor an `import type` is **S014**.
+ *
+ * Argumented `inject store` ALSO emits `routeBindings` on the page component
+ * (see `emitRegisterRouteBindings`); the lifecycle hooks live there. Keyed
+ * `inject store X(key)({...})` subscribes by name like the bare/argumented forms.
+ */
+const emitStoreUse = (graph, u) => {
+    if (!isStoreNameBound(graph, u.storeName)) {
+        throw new Error(`[reactra:compile] S014: \`inject store ${u.storeName}\` — name not bound. ` +
+            `A cross-file consumer must \`import type { ${u.storeName} } from "..."\`; ` +
+            `no same-file store declaration was found either. (Store v4.2 §2.5 / §13.)`);
+    }
+    // The generic type param: the `:Type` override when present (Store §2.5 /
+    // Compiler v14 — TypeScript then surfaces an incompatible structural subset,
+    // standing in for the LSP-deferred S015), else the store's emitted surface type.
+    // The override types the value; the store *name* is still resolved/bound above.
+    const surface = u.typeOverride ?? u.storeName;
+    if (u.fields && u.fields.length > 0) {
+        // A2 (Store §7.3) — field-selected: per-field subscription via
+        // `useReactraStoreFields`, so the component re-renders ONLY when one of the
+        // selected SOURCE fields changes (not on every store write). The destructure
+        // is UNCHANGED from the whole-store form (C0-1): a renamed field emits the JS
+        // object-destructure rename `source: local` (Store v4.7 §2.5); a bare field
+        // stays as-is. C3 (CRITICAL): the field-list argument is the store's SOURCE
+        // keys — `f` for a bare field, `f.source` for a rename — NOT the renamed
+        // locals; subscribing to a local name would target a non-existent field.
+        const destructure = u.fields
+            .map((f) => (typeof f === "string" ? f : `${f.source}: ${f.local}`))
+            .join(", ");
+        const sourceKeys = u.fields
+            .map((f) => `"${typeof f === "string" ? f : f.source}"`)
+            .join(", ");
+        return `const { ${destructure} } = useReactraStoreFields<${surface}>("${u.storeName}", [${sourceKeys}])`;
+    }
+    // Namespace form — bind under the alias when `inject store X as Y` (Store v4.9 §2.5).
+    // C5: no fields present ⇒ whole-store `useReactraStore` (unchanged).
+    return `const ${u.alias ?? u.storeName} = useReactraStore<${surface}>("${u.storeName}")`;
+};
+const extractArgumentedInputs = (u) => {
+    const out = [];
+    if (!u.args || !t.isObjectExpression(u.args))
+        return out;
+    for (const prop of u.args.properties) {
+        if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key))
+            continue;
+        const alias = prop.key.name;
+        // Shorthand `{ returnTo }` and `{ alias: id }` both give an Identifier value.
+        const valueName = t.isIdentifier(prop.value) ? prop.value.name : "";
+        out.push({ alias, valueName });
+    }
+    return out;
+};
+/**
+ * Build the `inputs` object literal an argumented `inject store` lowers to
+ * inside `StoreRegistry.instantiate("storeX", { inputs: ... })`. Each value
+ * identifier is resolved against the page's `param`/`query` declarations →
+ * `params.X` / `query.X`. A value that is neither (a `state`/`derived` source,
+ * or unknown) is **RO018** — route stores re-instantiate on navigation, not on
+ * arbitrary reactive change (Router v4.10 §4).
+ */
+const emitInputsObj = (inputs, c, storeName) => {
+    const paramNames = new Set(c.params.map((p) => p.name));
+    const queryNames = new Set(c.queries.map((q) => q.name));
+    const props = inputs.map((i) => {
+        if (paramNames.has(i.valueName))
+            return `${i.alias}: params.${i.valueName}`;
+        if (queryNames.has(i.valueName))
+            return `${i.alias}: query.${i.valueName}`;
+        throw new Error(`[reactra:compile] RO018: \`inject store ${storeName}({ ${i.alias}: ${i.valueName || "<expr>"} })\` ` +
+            `— the input value must be a route \`param\`/\`query\` in scope; ` +
+            `"${i.valueName || "<expr>"}" is neither (state/derived inputs are disallowed — ` +
+            `route stores re-instantiate on navigation). (Router v4.10 §4 / RO018.)`);
+    });
+    return `{ ${props.join(", ")} }`;
+};
+/**
+ * Emit the module-level `RouterRegistry.registerRouteBindings("Foo", { … })`
+ * side-effect call that pairs with a page component holding ≥1 argumented
+ * `use storeX(...)`. The router calls `onEnter` on route enter (with the
+ * matched URL params and query) and `onExit` on leave. Each argumented
+ * use becomes one `StoreRegistry.instantiate` call (with mapped inputs)
+ * and one `StoreRegistry.dispose`. Multiple argumented uses on the same
+ * page are independent — Router §4.4.
+ *
+ * Day 16 / `#18b`: replaced the prior `Object.assign(component, { routeBindings })`
+ * wrap with this name-keyed side effect. The component now exports as a
+ * plain arrow function, which React Fast Refresh accepts; the name-keyed
+ * binding survives HMR because the new module's re-execution overwrites
+ * the entry under the same name.
+ */
+const emitRegisterRouteBindings = (c, argumentedUses) => {
+    // `preservedKey` (the route-entry coordinates) is passed to every instantiate
+    // and the matching savePreservedState; the registry no-ops it for stores with
+    // no `preserved state` (Store §6 / Router §8.4). The page can't know a
+    // cross-file store's preserved fields, so it always threads the key.
+    const enters = argumentedUses.map((u) => {
+        const inputs = extractArgumentedInputs(u);
+        return `    StoreRegistry.instantiate("${u.storeName}", { inputs: ${emitInputsObj(inputs, c, u.storeName)}, preservedKey })`;
+    });
+    // Save before dispose on exit (Store §6.4 — values captured for the route
+    // we're leaving). Wave 3 §2b — thread the destination route's pathname so
+    // subtree-aware stores can keep their instance alive across pages inside
+    // the same subtree. `toCtx` is the second positional arg the router passes
+    // to onExit (Router v4.19); non-subtree stores ignore the nextPathname opt.
+    const exits = argumentedUses.flatMap((u) => [
+        `    StoreRegistry.savePreservedState("${u.storeName}", preservedKey)`,
+        `    StoreRegistry.dispose("${u.storeName}", { nextPathname: toCtx?.pathname })`,
+    ]);
+    // Stage 2 compiler — emit a `warm({ params, query }, signal)` companion
+    // alongside onEnter/onExit. `PrefetchRuntime.warm(to, params, query)`
+    // (Router §8.5) calls this on hover/visible/mount; we fan out to
+    // `StoreRegistry.warm(name, inputs, signal)` for every argumented store
+    // use, which in turn invokes the route store's `warm(inputs, signal)`
+    // companion emitted by `emitStoreWarm` (above). Stores without resources
+    // omit `warm` on their binding; `StoreRegistry.warm` treats absence as
+    // a silent no-op so the fan-out stays correct even when only some of
+    // the argumented uses have warm-able resources.
+    const warmCalls = argumentedUses.map((u) => {
+        const inputs = extractArgumentedInputs(u);
+        return `      StoreRegistry.warm("${u.storeName}", ${emitInputsObj(inputs, c, u.storeName)}, signal),`;
+    });
+    return [
+        `RouterRegistry.registerRouteBindings("${c.name}", {`,
+        `  onEnter: ({ pathname, params, query }) => {`,
+        `    const preservedKey = { pathname, params, query }`,
+        ...enters,
+        `  },`,
+        `  onExit: ({ pathname, params, query }, toCtx) => {`,
+        `    const preservedKey = { pathname, params, query }`,
+        ...exits,
+        `  },`,
+        `  warm: async ({ params, query }, signal) => {`,
+        `    await Promise.all([`,
+        ...warmCalls,
+        `    ])`,
+        `  },`,
+        `})`,
+    ].join("\n");
+};
+// `setterActionTarget`, `isTrivialIdentitySetter`, `classifyStateSetters`, and
+// the `setterNameFor`/`cap` helpers moved to `conventions/index.ts` (framework
+// review §B1) so the shadow emitter shares the EXACT same gated derivation.
+// Imported at the top of this file.
+/** The prefix Pass 9 reserves for compiler-emitted identifiers (`__route`, `__meta`, `__set<X>`, …). */
+const RESERVED_EMISSION_PREFIX = "__";
+/**
+ * R017: a Reactra-declared component identifier — `state`/`derived`/`action`/
+ * `resource`/`ref` — must not begin with `__`. That prefix is reserved for the
+ * compiler's own emitted identifiers (Compiler §4 Pass 9: `__route`, `__meta`,
+ * `__AwaitInner`, the renamed setter `__set<Cap(X)>`), so a user identifier
+ * sharing it can collide with generated code. Hard error at compile time, since
+ * the alternative is a silent name clash (Component DSL §2.1 / §14 R017).
+ *
+ * Scope: component primitives (the R-prefix owns these). `param`/`query`
+ * (Router/RO) and store/service names (Store/Service) are a noted follow-up.
+ */
+const validateReservedPrefix = (c) => {
+    if (c.kind !== "component")
+        return;
+    const declared = [
+        ...c.states.map((s) => ({ kind: "state", name: s.name })),
+        ...c.deriveds.map((d) => ({ kind: "derived", name: d.name })),
+        ...c.actions.map((a) => ({ kind: "action", name: a.name })),
+        ...c.resources.map((r) => ({ kind: "resource", name: r.name })),
+        ...c.refs.map((r) => ({ kind: "ref", name: r.name })),
+    ];
+    for (const { kind, name } of declared) {
+        if (!name.startsWith(RESERVED_EMISSION_PREFIX))
+            continue;
+        throw new Error(`[reactra:compile] R017: ${kind} "${name}" in component "${c.name}" uses the reserved ` +
+            `"__" prefix. Double-underscore identifiers are reserved for compiler-emitted code ` +
+            `(\`__route\`, \`__meta\`, \`__set<X>\`, …) and may collide. Rename without the leading "__". ` +
+            `(Component DSL §2.1 / §14 R017.)`);
+    }
+};
+/**
+ * Props validations (Component DSL §1.1 / §14):
+ *  - R020: a component takes a single props object — more than one parameter is
+ *    an error (the `forwardRef` ref-parameter is deferred).
+ *  - R018: a prop name may not collide with another component binding.
+ *  - R019: a prop is a read-only input — assigning to it (`label = …`) is an
+ *    error; seed a `state` for a local mutable value. Detected by a scoped walk
+ *    so a local/action-param that *shadows* a prop name is not flagged.
+ */
+const validateProps = (c) => {
+    if (c.kind !== "component")
+        return;
+    // R020 — more than one parameter (the preprocessor emits the header param(s)
+    // verbatim, so `(a, b)` parses as two arrow params).
+    if (c.factory.params.length > 1) {
+        throw new Error(`[reactra:compile] R020: component "${c.name}" declares ${c.factory.params.length} parameters — ` +
+            `a component takes a single props object. The forwardRef ref-parameter is deferred. ` +
+            `(Component DSL §1.1 / §14 R020.)`);
+    }
+    const props = c.propNames ?? [];
+    if (props.length === 0)
+        return;
+    const propSet = new Set(props);
+    // R018 — collision with another component binding.
+    const others = [
+        ...c.states.map((s) => ["state", s.name]),
+        ...c.deriveds.map((d) => ["derived", d.name]),
+        ...c.actions.map((a) => ["action", a.name]),
+        ...c.resources.map((r) => ["resource", r.name]),
+        ...c.refs.map((r) => ["ref", r.name]),
+        ...c.params.map((p) => ["param", p.name]),
+        ...c.queries.map((q) => ["query", q.name]),
+        ...c.injects.map((inj) => ["inject", inj.alias ?? inj.name]),
+        ...c.storeUses.flatMap((su) => su.fields && su.fields.length > 0
+            ? su.fields.map((f) => ["inject store field", fieldLocal(f)])
+            : [["inject store", su.storeName]]),
+    ];
+    for (const [kind, name] of others) {
+        if (propSet.has(name)) {
+            throw new Error(`[reactra:compile] R018: prop "${name}" in component "${c.name}" collides with a ${kind} ` +
+                `of the same name. Rename the prop or the ${kind}. (Component DSL §1.1 / §14 R018.)`);
+        }
+    }
+    // R019 — assignment to a read-only prop. Precise: we flag only when the
+    // assigned binding resolves to the component's *own* prop-parameter identifier
+    // node (not a local or nested-arrow param that merely shadows the name).
+    const propIdents = new Set();
+    if (c.factory.params.length > 0)
+        collectPatternIdentifiers(c.factory.params[0], propIdents);
+    traverse(t.file(t.program([t.expressionStatement(c.factory)])), {
+        AssignmentExpression(path) {
+            const left = path.node.left;
+            if (!t.isIdentifier(left) || !propSet.has(left.name))
+                return;
+            const binding = path.scope.getBinding(left.name);
+            if (!binding || !propIdents.has(binding.identifier))
+                return; // shadowing local — fine
+            throw new Error(`[reactra:compile] R019: assignment to prop "${left.name}" in component "${c.name}" — ` +
+                `props are read-only inputs from the parent. Seed a \`state\` for a local mutable value. ` +
+                `(Component DSL §1.1 / §14 R019.)`);
+        },
+    });
+};
+/**
+ * `inject store` field-selection validations (Store v4.7 §2.5 / §13):
+ *  - S017: a field rename used the import-style `as` (`{ b as localB }`) — use
+ *    the React-style `{ b: localB }`.
+ *  - S016: a field-selection **local** name collides — duplicated across the
+ *    expanded local-name list (across injects, within one brace `{ a: b, b }`),
+ *    or clashing with a `state`/`derived`/`action`/`resource`/`ref`/`param`/
+ *    `query`/prop in the same component.
+ */
+const validateStoreFieldSelection = (c) => {
+    if (c.kind !== "component")
+        return;
+    // S017 — `as` rename is rejected.
+    for (const su of c.storeUses) {
+        for (const f of su.fields ?? []) {
+            if (typeof f !== "string" && f.as) {
+                throw new Error(`[reactra:compile] S017: \`inject store ${su.storeName} { ${f.source} as ${f.local} }\` ` +
+                    `uses \`as\` — use the React-style rename \`{ ${f.source}: ${f.local} }\`. ` +
+                    `(Store §2.5 / §13 S017.)`);
+            }
+        }
+    }
+    // S016 — local-name collision. Non-store bindings populate the origin map
+    // first (a duplicate among THEM is a different error, not S016), then each
+    // field-selection local must be unclaimed.
+    const origin = new Map();
+    const addBinding = (name, where) => {
+        if (!origin.has(name))
+            origin.set(name, where);
+    };
+    for (const s of c.states)
+        addBinding(s.name, `state ${s.name}`);
+    for (const d of c.deriveds)
+        addBinding(d.name, `derived ${d.name}`);
+    for (const a of c.actions)
+        addBinding(a.name, `action ${a.name}`);
+    for (const r of c.resources)
+        addBinding(r.name, `resource ${r.name}`);
+    for (const r of c.refs)
+        addBinding(r.name, `ref ${r.name}`);
+    for (const p of c.params)
+        addBinding(p.name, `param ${p.name}`);
+    for (const q of c.queries)
+        addBinding(q.name, `query ${q.name}`);
+    for (const n of c.propNames ?? [])
+        addBinding(n, `prop ${n}`);
+    const claim = (name, where, hint) => {
+        const prev = origin.get(name);
+        if (prev) {
+            throw new Error(`[reactra:compile] S016: \`${name}\` in component "${c.name}" is bound by both ${prev} ` +
+                `and ${where}. ${hint} (Store §2.5 / §13 S016.)`);
+        }
+        origin.set(name, where);
+    };
+    for (const su of c.storeUses) {
+        // S018 — a namespace alias cannot combine with field-selection braces.
+        if (su.alias && su.fields && su.fields.length > 0) {
+            throw new Error(`[reactra:compile] S018: \`inject store ${su.storeName} as ${su.alias} { … }\` combines a ` +
+                `namespace alias with field selection. The alias names the whole store; the braces ` +
+                `destructure — use one. (Store §2.5 / §13 S018.)`);
+        }
+        if (su.fields && su.fields.length > 0) {
+            for (const f of su.fields) {
+                const local = fieldLocal(f);
+                claim(local, `inject store ${su.storeName} { ${local} }`, `Rename one with \`{ field: newLocal }\` or use the namespace form ` +
+                    `(\`inject store ${su.storeName}\` → \`${su.storeName}.${typeof f === "string" ? f : f.source}\`).`);
+            }
+        }
+        else if (su.classification === "bare") {
+            // namespace form — the in-scope binding is the alias, else the store name.
+            const name = su.alias ?? su.storeName;
+            claim(name, su.alias ? `inject store ${su.storeName} as ${su.alias}` : `inject store ${su.storeName}`, `Alias the namespace with \`as ${name}2\` (or rename the other binding).`);
+        }
+    }
+    // `inject service X [as Y]` (Service v2.3 §4.2) — the binding (alias, else the
+    // service name) is subject to the same collision check → SVC016.
+    for (const inj of c.injects) {
+        if (inj.serviceKind !== "service")
+            continue;
+        const name = inj.alias ?? inj.name;
+        const where = inj.alias ? `inject service ${inj.name} as ${inj.alias}` : `inject service ${inj.name}`;
+        const prev = origin.get(name);
+        if (prev) {
+            throw new Error(`[reactra:compile] SVC016: \`${name}\` in component "${c.name}" is bound by both ${prev} ` +
+                `and ${where}. Alias the service (\`as ${name}2\`) or rename the other binding. ` +
+                `(Service §4.2 / §12 SVC016.)`);
+        }
+        origin.set(name, where);
+    }
+};
+/**
+ * G7 — Reactive-state mutation inside `mount`/`effect` body → R023.
+ *
+ * DSL v2 uniform rule (§8.3 locked / Component DSL §2.1/§3 / §14 R023): reactive
+ * state mutation is legal only at a *tracked boundary* — an `action` (declared)
+ * or a JSX event handler (auto-wrapped by G6). `mount` and `effect` blocks
+ * observe state; they must call an action to mutate it.
+ *
+ * The check is **lexical and recurses into every nested closure** within the
+ * body — a write inside a `.then`/timer/listener callback (`mount { p.then(d =>
+ * x = d) }`) is R023, because a deferred write that escapes the instrumented
+ * boundary breaks passive replay/undo determinism (this is the determinism hole
+ * the rule closes). A write is reactive iff its target identifier is a declared
+ * `state` name that does NOT resolve to a binding local to the body (an
+ * effect-local `let`, a nested-callback param — `scope.getBinding`). DOM writes
+ * (`document.title = …`) and `ref.current = …` carry a MemberExpression LHS and
+ * are excluded by the `isIdentifier` guard; a compound `count += 1` / `count++`
+ * on a `state` field IS R023.
+ */
+const validateEffectMutations = (c) => {
+    if (c.kind !== "component")
+        return;
+    const stateNames = new Set(c.states.map((s) => s.name));
+    if (stateNames.size === 0)
+        return;
+    const reportAt = (name, location) => {
+        throw new Error(`[reactra:compile] R023: reactive state "${name}" is mutated inside a ${location} ` +
+            `of component "${c.name}". DSL v2 uniform rule: only an \`action\` (declared) or a ` +
+            `JSX event handler (auto-wrapped) may mutate reactive state — \`effect\`/\`mount\` ` +
+            `observe and route mutation through an action. ` +
+            `Move "${name} = …" into a named \`action\` and call it from the ${location}. ` +
+            `(Component DSL §3 / §14 R023.)`);
+    };
+    // R023 is **lexical and recurses into nested closures** (Component DSL §2.1/§14):
+    // a reactive `state` write at ANY function-nesting depth inside a `mount`/`effect`
+    // body is the error — `mount { p.then(d => x = d) }`, a `setInterval`/listener
+    // callback, a helper declared in the body. This closes the determinism hole: a
+    // deferred write would otherwise mutate state outside any instrumented boundary,
+    // breaking passive replay/undo. A write is reactive iff the target identifier is a
+    // declared `state` name AND does NOT resolve to a binding local to the body
+    // (effect-local `let`, a nested-callback param). DOM writes (`document.title = …`)
+    // and `ref.current = …` have a MemberExpression LHS → excluded by the `isIdentifier`
+    // guard; a compound `count += 1` / `count++` on a `state` field IS R023.
+    const check = (bodyArrow, location) => {
+        traverse(t.file(t.program([t.expressionStatement(bodyArrow)])), {
+            AssignmentExpression(inner) {
+                const left = inner.node.left;
+                if (t.isIdentifier(left)) {
+                    // Simple assignment LHS: `x = expr`.
+                    if (!stateNames.has(left.name))
+                        return;
+                    if (inner.scope.getBinding(left.name))
+                        return; // local var/param — not the reactive state
+                    reportAt(left.name, location);
+                }
+                else if (t.isArrayPattern(left) || t.isObjectPattern(left)) {
+                    // F3: destructuring assignment `[x] = arr` or `({ x } = obj)`.
+                    // Collect all bound identifiers from the pattern (reuse existing helper).
+                    const idents = new Set();
+                    collectPatternIdentifiers(left, idents);
+                    for (const id of idents) {
+                        if (!stateNames.has(id.name))
+                            continue;
+                        if (inner.scope.getBinding(id.name))
+                            continue;
+                        reportAt(id.name, location);
+                    }
+                }
+            },
+            UpdateExpression(inner) {
+                const arg = inner.node.argument;
+                if (!t.isIdentifier(arg) || !stateNames.has(arg.name))
+                    return;
+                if (inner.scope.getBinding(arg.name))
+                    return;
+                reportAt(arg.name, location);
+            },
+        });
+    };
+    for (const m of c.mounts)
+        check(m.body, "mount");
+    for (const e of c.effects)
+        check(e.body, "effect");
+};
+/** Collect the binding Identifier NODES introduced by a props parameter pattern. */
+const collectPatternIdentifiers = (node, out) => {
+    if (t.isIdentifier(node))
+        out.add(node);
+    else if (t.isAssignmentPattern(node))
+        collectPatternIdentifiers(node.left, out);
+    else if (t.isRestElement(node))
+        collectPatternIdentifiers(node.argument, out);
+    else if (t.isObjectPattern(node)) {
+        for (const p of node.properties) {
+            if (t.isObjectProperty(p))
+                collectPatternIdentifiers(p.value, out);
+            else
+                collectPatternIdentifiers(p, out);
+        }
+    }
+    else if (t.isArrayPattern(node)) {
+        for (const el of node.elements)
+            if (el)
+                collectPatternIdentifiers(el, out);
+    }
+};
+/**
+ * Emit a paired `mount` + `cleanup` as one `useEffect` whose callback runs the
+ * mount body and **returns** the cleanup as its teardown (Component DSL §3.2):
+ *
+ *   useEffect(() => { <mount body>; return () => { <cleanup body> } }, [])
+ *
+ * The mount block's inner statements are spliced verbatim, then a generated
+ * `return () => <cleanup block>` is appended on its own line (so ASI separates
+ * it from the last mount statement). Without this the cleanup was extracted but
+ * never emitted — teardown silently never ran.
+ */
+const emitMountWithCleanup = (preprocessed, mount, cleanup) => {
+    const mb = mount.body.body; // mount BlockStatement
+    const cb = cleanup.body.body; // cleanup BlockStatement
+    if (mb.start == null || mb.end == null || cb.start == null || cb.end == null) {
+        // Defensive: positions missing → fall back to a solo mount (cleanup dropped,
+        // but this should never happen for parsed blocks).
+        return mappedSlice(preprocessed, `  useEffect(() => `, mb, `, [])`);
+    }
+    const pieces = [
+        { kind: "verbatim", srcStart: mb.start + 1, text: preprocessed.slice(mb.start + 1, mb.end - 1) },
+        { kind: "gen", text: `\n    return () => `, anchorSrc: cb.start },
+        { kind: "verbatim", srcStart: cb.start, text: preprocessed.slice(cb.start, cb.end) },
+    ];
+    return emitMappedPieces(`  useEffect(() => {`, pieces, ` }, [])`);
+};
+/** Emit a single component as a React 19 function component. */
+const emitComponent = (preprocessed, graph, c) => {
+    validateReservedPrefix(c);
+    validateProps(c);
+    validateStoreFieldSelection(c);
+    validateEffectMutations(c);
+    const { renamedStates, suppressedActions } = classifyStateSetters(c);
+    // R016 (warning, not a throw): the emitted code stays correct — the implicit
+    // setter stands in for the suppressed action. Advisory style matches #5.
+    for (const name of suppressedActions) {
+        const stateName = setterActionTarget(name);
+        console.warn(`[reactra:compile] R016: redundant identity setter action "${name}" in ` +
+            `component "${c.name}" duplicates the auto-emitted setter for state "${stateName}" ` +
+            `(\`const [${stateName}, ${name}] = useState(...)\`). The action is suppressed — ` +
+            `call the implicit ${name}(...) directly, or give it a non-trivial body to keep it. ` +
+            `(Component DSL §2.3 / §14 R016.)`);
+    }
+    // R028 (warning, not a throw): a resource dep that mints a fresh object/array
+    // each render never key-equals, so the resource refetches every render and the
+    // dep-id cache grows unbounded. Detected in Pass 3 (`unstableDeps`). The
+    // emitted code is unchanged — this is purely advisory. (Component DSL §2.4.)
+    for (const r of c.resources) {
+        for (const dep of r.unstableDeps ?? []) {
+            console.warn(`[reactra:compile] R028: resource "${r.name}" dep "${dep}" is a fresh object/array ` +
+                `each render (a derived returning an object literal, or an inline literal) — it never ` +
+                `key-equals, so the resource refetches every render and the dep-id cache grows ` +
+                `unbounded. Use a stable scalar/identifier dep, or derive the primitive fields you ` +
+                `actually key on. (Component DSL §2.4)`);
+        }
+    }
+    // R029 (warning, not a throw): a `.map()` in the view returning keyless JSX is
+    // the classic React reconciliation footgun. Detected in Pass 3
+    // (`view.keylessMaps` = offending count). Emission is unchanged. (Component DSL §7.)
+    for (let i = 0; i < (c.view?.keylessMaps ?? 0); i++) {
+        console.warn(`[reactra:compile] R029: a \`.map()\` in component "${c.name}"'s view returns JSX ` +
+            `with no \`key\` — React needs a stable \`key\` to reconcile list items correctly ` +
+            `(missing keys cause lost state, wrong-row updates, and remount churn). Add ` +
+            `\`key={…}\` to the element the callback returns. (Component DSL §7)`);
+    }
+    const stateNames = new Set(c.states.map((s) => s.name));
+    // States any `command`'s `optimistic {}` writes — these emit a useOptimistic shadow.
+    const optimisticStates = optimisticStatesOf(preprocessed, c, stateNames);
+    // Compiler-native behaviours this component `uses`, in source order (Pass 9.1).
+    // The ctx hands the seam methods the Pass-9 helpers they need (Compiler §4).
+    const behaviours = matchedNativeBehaviours(c);
+    const behaviourCtx = {
+        stateNames,
+        renamedStates,
+        setterNameFor: (s) => setterNameFor(s, renamedStates),
+        actionWritesState: (a) => actionWritesState(a.arrow, stateNames),
+        straightLineStateWrites: (a) => straightLineStateWrites(preprocessed, a, stateNames),
+        line: plain,
+    };
+    const argumentedUses = c.storeUses.filter((u) => u.classification === "argumented");
+    const hasRouteState = c.params.length > 0 || c.queries.length > 0;
+    // Plugin-class behaviours (Behaviour Plugin spec §3/§4): resolved up front so
+    // an unresolvable name throws R045 before any emission. Empty for the common
+    // no-plugin component — emission stays byte-identical then (§4 rule 5).
+    const plugins = resolvePluginBehaviours(c, graph);
+    // Each `entries` element is one emitted line (joined by "\n" at the end —
+    // byte-identical to the old `lines.join`). Slice-bearing lines carry their
+    // source marks; boilerplate lines are `plain(...)` (Compiler §8).
+    const entries = [];
+    const decl = c.exported ? "export const" : "const";
+    // Day 16 / `#18b`: page component exports as a plain arrow regardless
+    // of routeBindings — Fast Refresh accepts this shape. The bindings, if
+    // any, land in a sibling `RouterRegistry.registerRouteBindings(…)`
+    // side-effect call after the component definition (see emit below).
+    // §1.1 — re-emit the React-style props parameter verbatim (or `()` if none).
+    // With plugin behaviours the body lands on a private `X__impl` and the public
+    // name is the wrap — once, re-exported through both export forms (§4 rule 2);
+    // BLIM-01: this shape degrades Fast Refresh to a module reload.
+    const implName = plugins.length > 0 ? `${c.name}__impl` : c.name;
+    entries.push(plain(plugins.length > 0
+        ? `const ${implName} = (${c.propsParam ?? ""}) => {`
+        : `${decl} ${c.name} = (${c.propsParam ?? ""}) => {`));
+    // Param / query lookups go first — they introduce identifiers that store
+    // hooks, state initialisers, injects, and the view body may reference.
+    // One useRoute() call per render; both params and query come from the
+    // same snapshot so they're consistent within a single transition.
+    if (hasRouteState) {
+        entries.push(plain(`  const __route = useRoute()`));
+        for (const p of c.params)
+            entries.push(plain(`  const ${p.name} = __route.params.${p.name}`));
+        for (const q of c.queries)
+            entries.push(plain(emitQueryRead(q)));
+    }
+    // Inject lookups next — same precedence as Day 9c. Strategy A keeps
+    // the `ServiceRegistry.get` path for store/service bodies; Strategy B
+    // (Wave 3 §2b) flips component-side `inject service X` to
+    // `useService("X")` so ancestor `provide X with Y` is honoured.
+    for (const inj of c.injects)
+        entries.push(plain(`  ${emitInjectLookup(inj, c.kind)}`));
+    for (const u of c.storeUses)
+        entries.push(plain(`  ${emitStoreUse(graph, u)}`));
+    // Wave 3 §2b — `provide X with Y` setup. Read the parent overrides,
+    // compose the child additions on top, then wrap the view return in
+    // <ServiceContext.Provider>. The useMemo dep list includes the parent
+    // overrides identity so a re-render with the same parent + same
+    // declared replacements doesn't allocate a new map; descendants don't
+    // re-render solely because of the Provider value churn.
+    if (c.kind === "component" && c.provides.length > 0) {
+        entries.push(plain(`  const __reactraParentOverrides = use(ServiceContext)`));
+        const additions = c.provides
+            .map((p) => `${JSON.stringify(p.name)}: ServiceRegistry.get(${JSON.stringify(p.valueText)})`)
+            .join(", ");
+        entries.push(plain(`  const __reactraOverrides = useMemo(() => composeOverrides(__reactraParentOverrides, { ${additions} }), [__reactraParentOverrides])`));
+    }
+    for (const s of c.states)
+        entries.push(concatE([plain("  "), emitState(preprocessed, s, renamedStates, optimisticStates)]));
+    for (const d of c.deriveds)
+        entries.push(concatE([plain("  "), emitDerived(preprocessed, d)]));
+    for (const r of c.refs) {
+        entries.push(mappedSlice(preprocessed, `  const ${r.name} = useRef(`, r.initializer, `)`));
+    }
+    for (const r of c.resources)
+        entries.push(concatE([plain("  "), emitResource(preprocessed, r, c)]));
+    // BUG-3 is closed: plugin-class `uses` names are resolved (R045 if not) and
+    // wrapped (Behaviour Plugin spec §3/§4) — no inert drop remains. The one
+    // still-pending directive is BUG-4 (Router §5.6): `transition <name>` should
+    // compile to a `transition: { name, duration }` manifest field the runtime
+    // applies via `document.startViewTransition()`; the field + View Transitions
+    // runtime are deferred to Wave 3 (the flushSync+Suspense interaction). Until
+    // then, warn (non-fatal) instead of dropping the directive on the floor.
+    if (c.transition) {
+        console.warn(`[reactra:compile] RO: component "${c.name}" declares \`transition ${c.transition.name}\` but ` +
+            `route view-transitions are not yet emitted — the directive is currently inert (deferred to ` +
+            `Wave 3). (Router §5.6.)`);
+    }
+    // Compiler-native behaviour preambles (Pass 9.1): land after resources and
+    // before actions, so `__snapshot`/`__replay` close over every state and the
+    // augmented actions can reference the behaviour's bindings. Emitted in `uses`
+    // source order. State-writing actions are then augmented per behaviour below.
+    if (behaviours.some((b) => b.name === "undoable") && c.states.length === 0) {
+        // Harmless (the buffer is always empty) but almost certainly a mistake.
+        // Behaviour-specific use-site diagnostic, owned by Undo §10 (not a seam).
+        console.warn(`[reactra:compile] BHV004: component "${c.name}" declares \`uses undoable\` but has no ` +
+            `\`state\` — the undo history will always be empty. (Undo spec §10.)`);
+    }
+    for (const b of behaviours) {
+        for (const line of b.emitPreamble(c, behaviourCtx))
+            entries.push(line);
+    }
+    // Commands emit AFTER the behaviour preamble (like actions) so a recording
+    // command's reducer closes over an already-declared `__replay` (no TDZ-adjacent
+    // ordering surprise) and over every state.
+    for (const cmd of c.commands)
+        entries.push(concatE([plain("  "), emitCommand(preprocessed, cmd, c, stateNames, renamedStates)]));
+    // Emit actions in dependency order so a callee declared after its caller still
+    // precedes it (BUG-2 Direction A) — a reference cycle throws R021. Suppressed
+    // identity setters are already excluded by `orderActionsForEmit`.
+    for (const a of orderActionsForEmit(c, suppressedActions)) {
+        const aug = augmentationFor(a, c, behaviours, behaviourCtx);
+        entries.push(concatE([plain("  "), emitAction(preprocessed, a, stateNames, renamedStates, aug)]));
+    }
+    // Behaviour resource hooks (Pass 9.1): emitted after the actions and after the
+    // resource declarations they reference (e.g. replay's per-resource status
+    // useEffect — Replay §4.1). `undoable` contributes none.
+    for (const b of behaviours) {
+        for (const line of b.emitResourceHooks(c, behaviourCtx))
+            entries.push(line);
+    }
+    // Route metadata (Router §3.7). Phase-1 scope: the `meta {}` object is
+    // evaluated in component scope (so a `title` may reference param / query /
+    // state / derived / resource) and its `title` field is applied to
+    // `document.title` via an effect — the canonical CSR use. Static-field
+    // hoisting to the manifest (§3.7.1 resolveStatic), the static/dynamic
+    // classifier, and `useRoute().meta` cross-component reads are deferred to
+    // Wave 3 (SSR / route guards / layouts — no Phase-1 consumer).
+    if (c.meta) {
+        entries.push(mappedSlice(preprocessed, `  const __meta = `, c.meta.object, ``));
+        entries.push(plain(`  useEffect(() => { if (typeof document !== "undefined" && __meta.title != null) document.title = String(__meta.title) }, [__meta.title])`));
+    }
+    const lifecycle = [
+        ...c.mounts.map((n) => ({ kind: "mount", node: n })),
+        ...c.cleanups.map((n) => ({ kind: "cleanup", node: n })),
+    ].sort((a, b) => (a.node.call.start ?? 0) - (b.node.call.start ?? 0));
+    const emitSoloMount = (m) => entries.push(mappedSlice(preprocessed, `  useEffect(() => `, m.body.body, `, [])`));
+    let openMount = null;
+    for (const item of lifecycle) {
+        if (item.kind === "mount") {
+            if (openMount)
+                emitSoloMount(openMount); // a previous mount with no cleanup
+            openMount = item.node;
+        }
+        else if (openMount === null) {
+            throw new Error(`[reactra:compile] R012: orphan cleanup in component "${c.name}" — a \`cleanup\` block has ` +
+                `no preceding \`mount\` to pair with. A \`cleanup\` becomes the \`useEffect\` teardown return ` +
+                `of the closest preceding \`mount\`; add a \`mount\`, or move the teardown into one. ` +
+                `(Component DSL §3.2 / §14 R012.)`);
+        }
+        else {
+            entries.push(emitMountWithCleanup(preprocessed, openMount, item.node));
+            openMount = null;
+        }
+    }
+    if (openMount)
+        emitSoloMount(openMount); // trailing mount with no cleanup
+    for (const e of c.effects) {
+        if (e.watch) {
+            entries.push(concatE([
+                mappedSlice(preprocessed, `  useEffect(() => `, e.body.body, `, [`),
+                mappedSlice(preprocessed, ``, e.watch.body, `])`),
+            ]));
+        }
+        else {
+            entries.push(mappedSlice(preprocessed, `  useEffect(() => `, e.body.body, `, [])`));
+        }
+    }
+    // G6 — Inline-handler auto-wrap (DSL v2 / Compiler §4 Pass 9).
+    // Extract JSX event handlers containing reactive-state assignments from the
+    // view body. The hoisted `useCallback` declarations are emitted here (after
+    // all declared actions, before the test hook). The view substitutions are
+    // forwarded to `viewBodyPieces` so the JSX references the hoisted name.
+    // Invariant (S1 gate): synthesized names carry the `__` prefix and are NEVER
+    // placed in `hookBindings`.
+    const inlineHandlers = c.kind === "component" && c.view != null
+        ? extractInlineHandlers(preprocessed, c.view.body.body, stateNames, renamedStates)
+        : { handlers: [], substs: [] };
+    for (const h of inlineHandlers.handlers) {
+        entries.push(plain(h.decl));
+    }
+    // The test-hook line (Testing spec §2 / Compiler §4 Pass 9 v2.18): the LAST
+    // statement before the view return, on EVERY component, in every environment.
+    // useEffect form is mandatory (commit-accurate, StrictMode-clean); the
+    // bindings object follows the normative ordered assembly rule — props →
+    // state → derived → behaviour exposedBindings (uses-source order) → actions
+    // (emit order, suppressed setters excluded) → resources.
+    //
+    // A1 (allocation guard): the hook is read once into `h`, and the bindings
+    // object is built ONLY when a hook is present (`if (h) h.update(...)`). With
+    // `?.update`, the object-literal argument is evaluated BEFORE the optional
+    // call short-circuits, so production (no hook installed) paid a per-render
+    // allocation on the most-instantiated unit in the framework. The guard is a
+    // pure runtime presence check (no build-time constant) — presence IS the
+    // opt-in, so devtools/testing/replay still fire under bun/test the instant a
+    // hook is installed. NO dep array: every-commit firing is load-bearing (the
+    // devtools passive ring + testing `renderCount` depend on it).
+    const hookBindings = [
+        // propNames already carries the destructured names OR the bag identifier.
+        ...(c.propNames ?? []),
+        ...c.states.map((s) => s.name),
+        ...c.deriveds.map((d) => d.name),
+        ...behaviours.flatMap((b) => b.exposedBindings),
+        ...orderActionsForEmit(c, suppressedActions).map((a) => a.name),
+        ...c.resources.map((r) => r.name),
+    ];
+    const hookObj = hookBindings.length > 0 ? `{ ${hookBindings.join(", ")} }` : `{}`;
+    entries.push(plain(`  useEffect(() => { const h = globalThis.__REACTRA_TEST__; if (h) h.update("${c.name}", ${hookObj}) })`));
+    // View — return the JSX expression from inside the view's arrow body, with any
+    // __reactra_await__ calls rewritten to Suspense+ErrorBoundary. The body is a
+    // per-line `Piece` list, so each view line maps back to its own DSL line and
+    // each await wrapper to its `await(...)` line (#10-followup §8, Session 4).
+    //
+    // Wave 3 §2b — when the component has `provide X with Y` declarations,
+    // wrap the JSX return in <ServiceContext.Provider value={__reactraOverrides}>
+    // so descendants' useService("X") calls see the override.
+    const hasProvides = c.kind === "component" && c.provides.length > 0;
+    if (c.view) {
+        const viewPieces = trimViewPieces(viewBodyPieces(preprocessed, c.view.body.body, inlineHandlers.substs));
+        // Wrap the view (outer → inner): `errorBoundary` → `suspense` → `provide`
+        // Provider → view (Component DSL §7/§11). ErrorBoundary is outermost so it
+        // also catches errors surfaced by a suspended child; the Provider is
+        // innermost so the view + descendants see the service overrides. Without
+        // this wrap a component-level `errorBoundary`/`suspense` was extracted but
+        // never emitted (the boundary silently did nothing).
+        const open = [];
+        const close = [];
+        const eb = c.errorBoundary;
+        if (eb && eb.body.start != null) {
+            // `errorBoundary(e) { J }` → `(e) => (<>J</>)`; that arrow IS the fallback
+            // render-fn — ErrorBoundary renders `fallback(error)` (@reactra/resource).
+            open.push({ kind: "gen", text: `<ErrorBoundary fallback={`, anchorSrc: eb.body.start });
+            open.push({ kind: "verbatim", srcStart: eb.body.start, text: sliceNode(preprocessed, eb.body) });
+            open.push({ kind: "gen", text: `}>`, anchorSrc: eb.body.end ?? eb.body.start });
+            close.unshift({ kind: "gen", text: `</ErrorBoundary>`, anchorSrc: eb.call.start ?? eb.body.start });
+        }
+        const sus = c.suspense;
+        if (sus && sus.body.body.start != null) {
+            // `suspense { J }` → `() => (<>J</>)`; the Suspense fallback is the JSX
+            // element inside the arrow, not the arrow itself.
+            const sj = sus.body.body;
+            open.push({ kind: "gen", text: `<Suspense fallback={`, anchorSrc: sj.start });
+            open.push({ kind: "verbatim", srcStart: sj.start, text: sliceNode(preprocessed, sj) });
+            open.push({ kind: "gen", text: `}>`, anchorSrc: sj.end ?? sj.start });
+            close.unshift({ kind: "gen", text: `</Suspense>`, anchorSrc: sus.call.start ?? sj.start });
+        }
+        if (hasProvides) {
+            const a = c.view.body.start ?? 0;
+            open.push({ kind: "gen", text: `<ServiceContext.Provider value={__reactraOverrides}>`, anchorSrc: a });
+            close.unshift({ kind: "gen", text: `</ServiceContext.Provider>`, anchorSrc: a });
+        }
+        entries.push(emitMappedPieces(`  return (`, [...open, ...viewPieces, ...close], `)`));
+    }
+    else if (hasProvides) {
+        // No view but provides exist — still emit the Provider so a
+        // descendant rendered via children would see overrides. Phase 1
+        // doesn't model `children` for `export component` but the shape is
+        // future-proof.
+        entries.push(plain(`  return (<ServiceContext.Provider value={__reactraOverrides}>{null}</ServiceContext.Provider>)`));
+    }
+    else {
+        entries.push(plain(`  return null`));
+    }
+    entries.push(plain(`}`));
+    if (plugins.length > 0) {
+        // Wrap once, export twice (Behaviour Plugin §4): source order, outside-in —
+        // `uses A, B` → A(B(X__impl)). The default-export tail and the
+        // registerRouteBindings sibling both reference `X`, so every consumer gets
+        // the wrapped component.
+        const wrapped = plugins
+            .slice()
+            .reverse()
+            .reduce((acc, p) => `${p.name}(${acc})`, implName);
+        entries.push(plain(`${decl} ${c.name} = ${wrapped}`));
+    }
+    if (argumentedUses.length > 0) {
+        // Sibling module-level side effect that registers this page's
+        // onEnter/onExit under the component name. The router looks them up
+        // via `route.bindingsName` which the walker fills in from the same
+        // name (Day 16 / `#18b`).
+        entries.push(plain(""));
+        entries.push(plain(emitRegisterRouteBindings(c, argumentedUses)));
+    }
+    return joinE(entries, "\n");
+};
+/**
+ * Inside a store action, the user writes `count = count + 1` directly.
+ * The closure model preserves the bare assignment (closure vars are
+ * mutable), so we just embed the user's arrow text unchanged and append a
+ * `notify()` call before the closing brace.
+ *
+ * MVP limitation: a single `notify()` fires at the END of the body. Actions
+ * with early returns won't notify on intermediate mutations. Multi-mutation
+ * action bodies notify once total — which avoids over-rendering and matches
+ * the "single dispatch per action" intent of the spec's middleware pipeline
+ * (Store §8.1).
+ */
+const emitStoreAction = (preprocessed, a) => {
+    const arrowText = sliceNode(preprocessed, a.arrow);
+    const prefix = `const ${a.name} = `;
+    if (a.arrow.start == null || arrowText.length === 0)
+        return plain(`${prefix}${arrowText}`);
+    const start = a.arrow.start;
+    const lastBrace = arrowText.lastIndexOf("}");
+    // The body is verbatim (store closures keep bare assignments); the single
+    // `notify()` injected before the closing brace is a `gen` piece, so each source
+    // line of the body still maps to its DSL line (#10-followup §8, Session 3).
+    const pieces = lastBrace < 0
+        ? [{ kind: "verbatim", srcStart: start, text: arrowText }]
+        : [
+            { kind: "verbatim", srcStart: start, text: arrowText.slice(0, lastBrace) },
+            { kind: "gen", text: `; notify(); `, anchorSrc: start + lastBrace },
+            { kind: "verbatim", srcStart: start + lastBrace, text: arrowText.slice(lastBrace) },
+        ];
+    return emitMappedPieces(prefix, pieces, ``);
+};
+/**
+ * Emit the snapshot composer's body — produces the object that consumers
+ * destructure. Recomputes derived values on every call so they always
+ * reflect the latest state. Statement order matches DSL declaration order
+ * so later deriveds can read earlier ones.
+ */
+const emitStoreSnapshot = (preprocessed, c) => {
+    const stateNames = c.states.map((s) => s.name);
+    const actionNames = c.actions.map((a) => a.name);
+    const fieldOrder = [
+        ...stateNames,
+        ...c.deriveds.map((d) => d.name),
+        ...actionNames,
+    ];
+    const returnObj = `{ ${fieldOrder.join(", ")} }`;
+    if (c.deriveds.length === 0) {
+        return plain(`    return () => (${returnObj})`);
+    }
+    // Each derived expression is a user-code slice mapped back to its DSL `derived`
+    // line (#10-followup §8); the surrounding `return () => {…}` is boilerplate.
+    const derivedLines = c.deriveds.map((d) => mappedSlice(preprocessed, `      const ${d.name} = `, d.thunk.body, ``));
+    return joinE([
+        plain(`    return () => {`),
+        ...derivedLines,
+        plain(`      return ${returnObj}`),
+        plain(`    }`),
+    ], "\n");
+};
+/** Map the container kind to the StoreBinding.kind the runtime expects. */
+const storeBindingKind = (c) => {
+    if (c.kind === "export-store")
+        return "export";
+    if (c.kind === "session-store")
+        return "session";
+    return "route";
+};
+/**
+ * Emit a store container as a closure-based factory the user passes to
+ * `configureStores`. Force-exported regardless of `c.exported`: a Phase-1
+ * MVP simplification so single-file demos with `route store X` / `session
+ * store X` can still be registered manually.
+ *
+ * Route-store shape (Day 10a): the factory accepts an `inputs` parameter
+ * which the router's `StoreRegistry.instantiate` call supplies. The store's
+ * `input X` declarations destructure off it. Export and session stores
+ * ignore the parameter — their factories run eagerly at registration.
+ */
+/**
+ * Resource v1 §8.1 (Compiler stage 2) — emit the `warm: async (inputs, signal)`
+ * companion for a route store with one or more `resource` declarations. The
+ * companion destructures the same `inputs` the factory does, then
+ * `Promise.all`s a `warmResource(name, deps, fetcher, signal)` call per
+ * declared resource — invoking each fetcher DIRECTLY (no React tree —
+ * architect Q8), writing the result into `ResourceCache` under
+ * `(resourceName, depsKey)` so a consumer's
+ * `useResource(deps, fn, { resourceName: "X" })` (compiler stage 1) hits a
+ * fresh cache entry on mount.
+ *
+ * **Scope rule (intentional MVP):** the fetcher closure has only the
+ * destructured inputs in scope — not store state / derived / inject-acquired
+ * services (those live inside `factory`'s `createStoreInstance(...)` closure,
+ * which is a sibling field on the binding, not a parent of `warm`). A
+ * fetcher that references an out-of-scope identifier produces a TypeScript
+ * "Cannot find name" diagnostic at the user's call site, which is the right
+ * signal — store-resources should depend only on inputs (the navigation-
+ * derived data that uniquely keys the cache entry).
+ *
+ * Returns `[]` for stores with no resources OR for non-route stores
+ * (session/export stores don't have route-scoped prefetch lifecycles).
+ */
+const emitStoreWarm = (preprocessed, c) => {
+    if (c.resources.length === 0)
+        return [];
+    if (storeBindingKind(c) !== "route")
+        return [];
+    const destructureLine = c.inputs.length > 0
+        ? plain(`    const { ${c.inputs.map((i) => i.name).join(", ")} } = inputs ?? {}`)
+        : plain(`    // no inputs to destructure`);
+    // One call per resource — `warmResource(name, deps, fetcher, signal)`.
+    // Deps is the existing depsThunk body (compiler stage 1 already maps it
+    // for the consumer's useResource). Fetcher is emitted verbatim — its
+    // closure references only the destructured `inputs` (see scope rule).
+    const callLines = c.resources.map((r) => concatE([
+        plain(`      warmResource(${JSON.stringify(r.name)}, `),
+        mappedSlice(preprocessed, ``, r.depsThunk.body, ``),
+        plain(`, `),
+        mappedSlice(preprocessed, ``, r.fetcher, ``),
+        plain(`, signal),`),
+    ]));
+    return [
+        plain(`  warm: async (inputs, signal) => {`),
+        destructureLine,
+        plain(`    await Promise.all([`),
+        ...callLines,
+        plain(`    ])`),
+        plain(`  },`),
+    ];
+};
+const emitStore = (preprocessed, c) => {
+    const kind = storeBindingKind(c);
+    const isRoute = kind === "route";
+    // S019 (warning — Store v4.0 §2.5 / §13): the store name must end in `Store`
+    // so that `inject store fooStore` is self-describing in raw source (the suffix
+    // is the signal that identifies a name as a store binding vs. a plain value).
+    if (!c.name.endsWith("Store")) {
+        console.warn(`[reactra:compile] S019: store "${c.name}" should end in the \`Store\` suffix ` +
+            `(e.g. "${c.name}Store"). Because the binding is a plain value import, the suffix ` +
+            `keeps \`inject store ${c.name}Store\` self-describing in raw source. ` +
+            `Fixable by rename. (Store v4.0 §2.5 / §14 S019.)`);
+    }
+    // Behaviours are components-only in Stage 1. A compiler-native name on a
+    // store is BHV001 (error — Undo §10 ULIM-01 / Replay §11 RLIM-06); a plugin
+    // name is BHV003 (advisory — parsed, not wrapped; Behaviour Plugin §8/BLIM-03).
+    // Numbers assigned by Behaviour Plugin spec §8; semantics live with the owners.
+    for (const name of c.uses?.names ?? []) {
+        if (NATIVE_BEHAVIOURS.has(name)) {
+            const specRef = name === "undoable" ? "Undo spec §10 / ULIM-01" : "Replay spec §11 / RLIM-06";
+            throw new Error(`[reactra:compile] BHV001: store "${c.name}" declares \`uses ${name}\`, but \`${name}\` is ` +
+                `components-only in Stage 1 — store-level support is deferred (${specRef}). ` +
+                `Move \`uses ${name}\` onto the component(s) consuming this store.`);
+        }
+        console.warn(`[reactra:compile] BHV003: store "${c.name}" declares \`uses ${name}\` — store-level ` +
+            `plugin behaviours are not wrapped in Stage 1; the directive is currently inert. ` +
+            `(Behaviour Plugin spec §8 / BLIM-03.)`);
+    }
+    // `preserved state` validations (Store §6 / §13). S010 (non-serializable
+    // declared type) is a type-level/LSP concern — the Babel pass can't walk types
+    // (same boundary as S015); these are the AST-checkable ones.
+    if (c.preserved && c.preserved.fields.length > 0) {
+        if (!isRoute) {
+            throw new Error(`[reactra:compile] S011: \`preserved state\` is only valid in a \`route store\` ` +
+                `(store "${c.name}" is ${kind}). Back-button persistence is route-scoped (Store §6.2).`);
+        }
+        const stateNames = new Set(c.states.map((s) => s.name));
+        const derivedNames = new Set(c.deriveds.map((d) => d.name));
+        for (const f of c.preserved.fields) {
+            if (derivedNames.has(f)) {
+                throw new Error(`[reactra:compile] S013: \`preserved state ${f}\` names a \`derived\` in store "${c.name}". ` +
+                    `A derived is recomputed from state — preserve the underlying \`state\` instead (Store §6.2).`);
+            }
+            if (!stateNames.has(f)) {
+                throw new Error(`[reactra:compile] S012: \`preserved state ${f}\` names an unknown field in store "${c.name}". ` +
+                    `Each name must be a declared \`state\` field (Store §6.2).`);
+            }
+        }
+    }
+    // Route stores destructure inputs at the top of the factory closure so
+    // state initialisers, derived expressions, and actions all see the
+    // input identifiers by bare name (Router §4.2).
+    const inputDestructure = isRoute && c.inputs.length > 0
+        ? [plain(`    const { ${c.inputs.map((i) => i.name).join(", ")} } = inputs ?? {}`)]
+        : [];
+    // Inject lookups next so state initialisers / actions can reference them.
+    const injectLines = c.injects.map((inj) => plain(`    ${emitInjectLookup(inj, c.kind)}`));
+    // State initialiser + action body are user-code slices, mapped back to their
+    // DSL lines (#10-followup §8); the factory scaffolding around them is plain.
+    const initLines = c.states.map((s) => mappedSlice(preprocessed, `    let ${s.name} = `, s.initializer, ``));
+    // Preserved-state restore (Store §6): a route store's `preserved state X, Y`
+    // overwrites those `state` lets from the `restored` factory arg (read back from
+    // sessionStorage by StoreRegistry.instantiate). `as typeof X` keeps each write
+    // typed to the field — the only legal direct-state write outside an action.
+    const preservedFields = c.preserved?.fields ?? [];
+    const restoreLines = preservedFields.length > 0
+        ? [
+            plain(`    if (restored) {`),
+            ...preservedFields.map((f) => plain(`      if (${JSON.stringify(f)} in restored) ${f} = restored[${JSON.stringify(f)}] as typeof ${f}`)),
+            plain(`    }`),
+        ]
+        : [];
+    const actionLines = c.actions.map((a) => concatE([plain(`    `), emitStoreAction(preprocessed, a)]));
+    // Devtools time-travel restore closure (plan store-time-travel §3.1): register
+    // a name-keyed writer that drives this store's `state` lets back to a past
+    // snapshot. ONLY `state` fields are assignable (derived recompute on notify;
+    // actions/inputs aren't state). Mirrors the `preserved state` restore's
+    // `as typeof <field>` write — the same blessed outside-an-action direct write
+    // (architect C1). Always-emit (matches the unconditional __REACTRA_TEST__
+    // hook); a store with zero state fields emits no call at all. `notify` is the
+    // factory's existing wake.
+    const restoreRegistration = c.states.length > 0
+        ? [
+            plain(`    __registerStoreRestore(${JSON.stringify(c.name)}, (next) => {`),
+            plain(`      let __written = 0`),
+            ...c.states.map((s) => plain(`      if (${JSON.stringify(s.name)} in next) { ${s.name} = next[${JSON.stringify(s.name)}] as typeof ${s.name}; __written++ }`)),
+            plain(`      notify()`),
+            plain(`      return __written`),
+            plain(`    })`),
+        ]
+        : [];
+    const snapshot = emitStoreSnapshot(preprocessed, c);
+    const factorySig = isRoute ? (preservedFields.length > 0 ? "(inputs, restored)" : "(inputs)") : "()";
+    const preservedFieldsLine = preservedFields.length > 0
+        ? [plain(`  preservedFields: [${preservedFields.map((f) => JSON.stringify(f)).join(", ")}],`)]
+        : [];
+    // Wave 3 §2b — `route store ... for subtree "/path"`. When present on the
+    // ContainerNode (populated by Pass 2 from `__reactra_route_store_subtree__`),
+    // emit `subtreePath: "/path",` on the binding so the runtime can skip-
+    // dispose + skip-rebuild across pages inside the subtree.
+    const subtreePathLine = c.subtreePath !== undefined
+        ? [plain(`  subtreePath: ${JSON.stringify(c.subtreePath)},`)]
+        : [];
+    // Stage 2 compiler — emit the `warm(inputs, signal)` companion AFTER the
+    // factory's closing `}),` so the binding object literal stays valid even
+    // when the factory or warm has multi-line bodies. Empty array for non-
+    // route stores or stores with no resources (silent no-op at runtime —
+    // `StoreRegistry.warm` treats absence as a no-op).
+    const warmField = emitStoreWarm(preprocessed, c);
+    return joinE([
+        plain(`export const ${c.name} = {`),
+        plain(`  name: "${c.name}",`),
+        plain(`  kind: "${kind}",`),
+        ...preservedFieldsLine,
+        ...subtreePathLine,
+        plain(`  factory: ${factorySig} => createStoreInstance((notify) => {`),
+        ...inputDestructure,
+        ...injectLines,
+        ...initLines,
+        ...restoreLines,
+        ...actionLines,
+        ...restoreRegistration,
+        snapshot,
+        plain(`  }),`),
+        ...warmField,
+        plain(`}`),
+        // Store §2.5 — emit the public-surface type alias next to the binding so a
+        // cross-file consumer's `import type { <name> }` resolves the live surface
+        // (state + derived + actions; inputs are excluded — they're factory params,
+        // not in the snapshot). `StoreSurface` infers it from the factory above, so
+        // it stays in lockstep by construction. A type alias and a const may share
+        // a name in TypeScript (separate namespaces), so this does not clash with
+        // `export const ${c.name}`.
+        plain(`export type ${c.name} = StoreSurface<typeof ${c.name}>`),
+    ], "\n");
+};
+/**
+ * Inside a service action the user writes plain TypeScript — no reactive
+ * subscription, no notify call. The factory closure owns any state vars as
+ * mutable `let` bindings, so bare assignments are valid as-written. The
+ * user's arrow text is sliced unchanged.
+ *
+ * MVP simplification matching the Service spec's "stateless callable units"
+ * framing (§1): no per-action middleware, no transition wrapping (that lives
+ * in components — Service spec §9.2), no AbortSignal injection yet.
+ */
+const emitServiceAction = (preprocessed, a) => mappedSlice(preprocessed, `const ${a.name} = `, a.arrow, ``);
+/**
+ * Emit a service container as a Strategy A `{ name, factory }` binding the
+ * user passes to `configureServices`. The factory runs once at registration
+ * (eagerly, so service-to-service `inject` lookups resolve in declaration
+ * order); the returned surface exposes the action names — the service's
+ * public methods.
+ *
+ * Force-exported regardless of `c.exported`: a Phase-1 MVP simplification so
+ * single-file demos can register the binding manually. Same convention as
+ * Day 9b stores.
+ *
+ * MVP scope:
+ *   - `inject X`           → `const X = ServiceRegistry.get("X")` at top
+ *   - `state X = init`     → private closure `let X = init` (not exposed)
+ *   - `derived X = expr`   → private closure `const X = expr` evaluated once
+ *                            at factory time; not reactive (use a store if
+ *                            reactivity is needed)
+ *   - `action X(...) {}`   → `const X = (...) => {}` exposed in the surface
+ *   - `provide`, `scoped`, `server` modifiers → ignored, Wave 3
+ */
+const emitService = (preprocessed, c) => {
+    const injectLines = c.injects.map((inj) => plain(`    ${emitInjectLookup(inj, c.kind)}`));
+    // State init, derived expression, and action body are user-code slices mapped
+    // back to their DSL lines (#10-followup §8); the factory shell is plain.
+    const stateLines = c.states.map((s) => mappedSlice(preprocessed, `    let ${s.name} = `, s.initializer, ``));
+    const derivedLines = c.deriveds.map((d) => mappedSlice(preprocessed, `    const ${d.name} = `, d.thunk.body, ``));
+    const actionLines = c.actions.map((a) => concatE([plain(`    `), emitServiceAction(preprocessed, a)]));
+    const surface = c.actions.map((a) => a.name);
+    const returnObj = `{ ${surface.join(", ")} }`;
+    // Wave 3 §2b — scoped services emit `scoped: true` on the binding so
+    // the runtime knows NOT to instantiate at `configureServices` time
+    // (instantiate happens via `ServiceRegistry.activateScopedServices`
+    // wired into the router lifecycle).
+    const scopedField = c.serviceModifier === "scoped" ? [plain(`  scoped: true,`)] : [];
+    return joinE([
+        plain(`export const ${c.name} = {`),
+        plain(`  name: "${c.name}",`),
+        ...scopedField,
+        plain(`  factory: () => createServiceInstance(() => {`),
+        ...injectLines,
+        ...stateLines,
+        ...derivedLines,
+        ...actionLines,
+        plain(`    return ${returnObj}`),
+        plain(`  }),`),
+        plain(`}`),
+    ], "\n");
+};
+export const codegen = (graph) => {
+    const reactImports = collectReactImports(graph);
+    const resourceImports = collectResourceImports(graph);
+    const storeImports = collectStoreImports(graph);
+    const serviceImports = collectServiceImports(graph);
+    const routerImports = collectRouterImports(graph);
+    const importLines = [];
+    // User-written imports come first so their order matches the source.
+    // The compiler-injected imports below can never collide with these —
+    // they're scoped to react / @reactra/* package specifiers, none of
+    // which a user would re-import as a named import for their own use.
+    for (const imp of graph.userImports) {
+        importLines.push(imp);
+    }
+    if (reactImports.size > 0) {
+        importLines.push(`import { ${[...reactImports].sort().join(", ")} } from "react"`);
+    }
+    if (resourceImports.size > 0) {
+        importLines.push(`import { ${[...resourceImports].sort().join(", ")} } from "@reactra/resource"`);
+    }
+    if (storeImports.size > 0) {
+        importLines.push(`import { ${[...storeImports].sort().join(", ")} } from "@reactra/store"`);
+    }
+    if (serviceImports.size > 0) {
+        importLines.push(`import { ${[...serviceImports].sort().join(", ")} } from "@reactra/service"`);
+    }
+    if (routerImports.size > 0) {
+        importLines.push(`import { ${[...routerImports].sort().join(", ")} } from "@reactra/router"`);
+    }
+    // Compiler-native behaviour runtimes — one subpath import per behaviour used
+    // anywhere in the file (Pass 9.1 registry; Undo §4/§5, Replay §4/§5). Keyed by
+    // name so a behaviour used by several components imports once; first-occurrence
+    // order across containers is deterministic.
+    const usedBehaviours = new Map();
+    for (const c of graph.containers) {
+        for (const b of matchedNativeBehaviours(c))
+            usedBehaviours.set(b.name, b);
+    }
+    for (const b of usedBehaviours.values()) {
+        importLines.push(`import { ${b.runtime.hook} } from "${b.runtime.module}"`);
+    }
+    // First-party plugin behaviours auto-import from their compiler-constant path
+    // (Behaviour Plugin §3 row 2); third-party names ride the user's own import.
+    // Components only — a store's plugin name is the BHV003 advisory, never a wrap.
+    const usedFirstPartyPlugins = new Set();
+    for (const c of graph.containers) {
+        if (c.kind !== "component")
+            continue;
+        for (const p of resolvePluginBehaviours(c, graph)) {
+            if (p.firstParty)
+                usedFirstPartyPlugins.add(p.name);
+        }
+    }
+    for (const name of usedFirstPartyPlugins) {
+        importLines.push(`import { ${name} } from "@reactra/behaviours/${name}"`);
+    }
+    const importBlock = importLines.length > 0 ? `${importLines.join("\n")}\n\n` : "";
+    // §1.1 — preserve the file's own top-level `interface`/`type` declarations
+    // (e.g. a component's props type), emitted after the imports and before the
+    // container code. Type-level only — no runtime, order-independent.
+    const typeBlock = graph.userTypes.length > 0 ? `${graph.userTypes.join("\n\n")}\n\n` : "";
+    // Wave 3 §2b Stage 4 — `"use server"` directive prepended at the top of
+    // the emitted module when any service in this file carries the `server`
+    // modifier (`export service server X { ... }`). Per the spec / React 19,
+    // a file-level `"use server"` directive marks every exported function as
+    // a server action, so this file is intended to contain ONLY server
+    // services. Mixing a server service with a client component in one file
+    // is the user's call — the directive applies file-wide and would mark
+    // the component's exported function as a server action too, which is
+    // almost never what they want. Documented as a user-side constraint
+    // rather than a compiler error so the surface stays small for Phase 1.
+    const hasServerService = graph.containers.some((c) => c.kind === "service" && c.serviceModifier === "server");
+    const useServerDirective = hasServerService ? `"use server"\n\n` : "";
+    // Components, stores, and services all carry source marks for their user-code
+    // slices (#10-followup §8 — components S1, stores/services S2). The remaining
+    // unmapped slices are per-character setter-rewrite sub-spans (S3).
+    const blocks = [];
+    for (const c of graph.containers) {
+        if (c.kind === "component") {
+            blocks.push(emitComponent(graph.preprocessed, graph, c));
+        }
+        else if (isStoreContainer(c)) {
+            blocks.push(emitStore(graph.preprocessed, c));
+        }
+        else if (c.kind === "service") {
+            blocks.push(emitService(graph.preprocessed, c));
+        }
+    }
+    // Day 21 / `#18`: auto-default-export. When a file has exactly one
+    // `export component Foo`, emit `export default Foo` after the named
+    // export. Mirrors Router §3.1 (pages are default-exported) and lets
+    // the walker drop `pickPageComponent`'s function-finding heuristic
+    // in favour of clean `import PageX from "..."` lines.
+    // Files with zero or multiple exported components get no default —
+    // multiple defaults would be a parse error, and Phase 1's Compiler §1
+    // says at most one `export component` per file anyway.
+    const exportedComponents = graph.containers.filter((c) => c.kind === "component" && c.exported);
+    const defaultExport = exportedComponents.length === 1 ? `\nexport default ${exportedComponents[0].name}\n` : "";
+    const tail = hasHmrTargets(graph) ? "\n\n" + emitHmrBlock(graph) + "\n" : "\n";
+    // Assemble via concatE so the marks' offsets track into the final string;
+    // `.text` is byte-identical to the old `importBlock + blocks.join("\n\n") + …`.
+    const out = concatE([
+        plain(useServerDirective),
+        plain(importBlock),
+        plain(typeBlock),
+        joinE(blocks, "\n\n"),
+        plain(defaultExport),
+        plain(tail),
+    ]);
+    return { code: out.text, marks: out.marks };
+};
+//# sourceMappingURL=pass-9-codegen.js.map