@reactra/babel-plugin 0.1.0-alpha.0

package/dist/passes/pass-2-extract.js

@@ -0,0 +1,762 @@
+// Pass 2 — extract Reactra metadata from the parsed Babel AST.
+//
+// Walks the AST, finds the top-level `__reactra_{component|service|store}__`
+// wrappers, then walks each one's factory body finding the per-marker calls
+// (state, derived, action, view, ...). Produces a FileGraph that later
+// passes consume.
+//
+// Owner spec: reactra-compiler-spec.md §4 Pass 2, Pass 2a.
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+// §B1: marker vocabulary + await arg order come from the shared conventions home
+// (CONTAINER_MARKERS is re-exported there from ast/nodes.ts — one home).
+import { AWAIT_ARG_ORDER, CONTAINER_MARKERS } from "../conventions/index.js";
+// @babel/traverse is a CJS module that exports its default via .default
+// when imported from ESM. The dual cast keeps both interop paths happy.
+// CJS/ESM interop: @babel/traverse exports `module.exports = traverse` (CJS).
+// Under moduleResolution:NodeNext the default import resolves to the module
+// namespace (not callable). The runtime `.default` unwrap + any-cast recovers it.
+// The dev typecheck (moduleResolution:Bundler) validates call-site types.
+const traverse = (_traverse.default ?? _traverse);
+/** Slice the original source between two AST positions. */
+const sliceSource = (source, node) => {
+    if (node.start == null || node.end == null)
+        return "";
+    return source.slice(node.start, node.end);
+};
+/** Returns the string literal value of the first argument, or undefined. */
+const firstStringArg = (call) => {
+    const a = call.arguments[0];
+    if (a && t.isStringLiteral(a))
+        return a.value;
+    return undefined;
+};
+/** Returns the arrow function at the given argument index, or undefined. */
+const arrowArg = (call, idx) => {
+    const a = call.arguments[idx];
+    if (a && t.isArrowFunctionExpression(a))
+        return a;
+    return undefined;
+};
+/** Extract the expression body of a thunk arrow `() => (expr)`. */
+const thunkBody = (arrow) => {
+    const body = arrow.body;
+    if (!t.isBlockStatement(body))
+        return body;
+    // Single-return form `() => { return expr }`
+    if (body.body.length === 1) {
+        const stmt = body.body[0];
+        if (t.isReturnStatement(stmt) && stmt.argument)
+            return stmt.argument;
+    }
+    return undefined;
+};
+export const extractGraph = (source, preprocessed, ast) => {
+    // AST positions are relative to `preprocessed` (what Babel parsed).
+    // Use that for source-slicing; `source` is kept for source-map work later.
+    const sliceFrom = preprocessed;
+    const containers = [];
+    // Top-level `import …` statements — emitted verbatim by Pass 9 above
+    // its own auto-injected imports so user modules (api, utils, peer
+    // components imported into a JSX view) stay in scope. Looking at
+    // `ast.program.body` directly avoids walking the whole tree.
+    const userImports = [];
+    // §1.1 — top-level `interface`/`type` declarations are pure type-level, so we
+    // preserve them verbatim (Pass 9 re-emits after imports) and a DSL file can
+    // declare its own props types in-file. `export`ed variants included.
+    const userTypes = [];
+    const isTypeDecl = (n) => t.isTSInterfaceDeclaration(n) || t.isTSTypeAliasDeclaration(n);
+    for (const stmt of ast.program.body) {
+        if (t.isImportDeclaration(stmt)) {
+            userImports.push(sliceSource(sliceFrom, stmt));
+        }
+        else if (isTypeDecl(stmt)) {
+            userTypes.push(sliceSource(sliceFrom, stmt));
+        }
+        else if (t.isExportNamedDeclaration(stmt) && stmt.declaration && isTypeDecl(stmt.declaration)) {
+            userTypes.push(sliceSource(sliceFrom, stmt));
+        }
+    }
+    traverse(ast, {
+        VariableDeclaration(path) {
+            // Top-level declarations only — direct children of Program.
+            if (!t.isProgram(path.parent) && !t.isExportNamedDeclaration(path.parent))
+                return;
+            for (const declarator of path.node.declarations) {
+                const init = declarator.init;
+                if (!t.isCallExpression(init))
+                    continue;
+                const callee = init.callee;
+                if (!t.isIdentifier(callee))
+                    continue;
+                const kind = CONTAINER_MARKERS[callee.name];
+                if (!kind)
+                    continue;
+                const name = firstStringArg(init);
+                if (!name)
+                    continue;
+                // The factory arrow is the LAST argument (subtree stores have
+                // `(name, "/path", factory)`; keyed have `(name, (key) => {})`).
+                const factory = init.arguments[init.arguments.length - 1];
+                if (!t.isArrowFunctionExpression(factory))
+                    continue;
+                // subtree path: 2nd arg is a string for `__reactra_route_store_subtree__`
+                let subtreePath;
+                if (callee.name === "__reactra_route_store_subtree__") {
+                    const second = init.arguments[1];
+                    if (t.isStringLiteral(second))
+                        subtreePath = second.value;
+                }
+                // keyed sig — emitted by the preprocessor as the factory's first param
+                let keySig;
+                if (callee.name === "__reactra_route_store_keyed__" && factory.params.length === 1) {
+                    keySig = sliceSource(sliceFrom, factory.params[0]);
+                }
+                // Wave 3 §2b — service modifier (`scoped` / `server`). The
+                // preprocessor differentiates by emitting separate marker
+                // function names; here we map them back to the field on
+                // ContainerNode for Pass 9 to consume.
+                let serviceModifier;
+                if (callee.name === "__reactra_service_scoped__")
+                    serviceModifier = "scoped";
+                else if (callee.name === "__reactra_service_server__")
+                    serviceModifier = "server";
+                const exported = t.isExportNamedDeclaration(path.parent);
+                const container = {
+                    kind,
+                    name,
+                    exported,
+                    call: init,
+                    factory,
+                    states: [],
+                    deriveds: [],
+                    actions: [],
+                    commands: [],
+                    resources: [],
+                    refs: [],
+                    effects: [],
+                    mounts: [],
+                    cleanups: [],
+                    injects: [],
+                    provides: [],
+                    params: [],
+                    queries: [],
+                    storeUses: [],
+                    inputs: [],
+                    awaitBlocks: [],
+                    subtreePath,
+                    keySig,
+                    serviceModifier,
+                };
+                // §1.1 — component props parameter. The preprocessor emitted it as the
+                // factory arrow's first param; record the verbatim text (Pass 9 re-emits
+                // it) and the binding names (Pass 3 adds them to the reactive read-set).
+                if (kind === "component" && factory.params.length > 0) {
+                    const p = factory.params[0];
+                    container.propsParam = sliceSource(sliceFrom, p);
+                    const names = [];
+                    collectPatternNames(p, names);
+                    container.propNames = names;
+                }
+                extractContainerBody(sliceFrom, factory, container);
+                // Day 23 / `#7b`: walk the captured view (if any) and surface
+                // every `await(r) { ... } pending { ... } error(e) { ... }`
+                // block into `container.awaitBlocks`. Runtime path is still
+                // pass-9-codegen's inline Suspense+ErrorBoundary rewrite; this
+                // list exists so sidecar consumers (devtools / LSP / future
+                // passes) can enumerate await sites without re-parsing the
+                // view AST.
+                extractAwaitBlocks(sliceFrom, container);
+                containers.push(container);
+            }
+        },
+    });
+    return { source, preprocessed, containers, userImports, userTypes };
+};
+/**
+ * Collect every binding name introduced by a component's props parameter
+ * (Component DSL §1.1) into `out`. A bag identifier `(props)` contributes
+ * `props`; a destructuring pattern `({ a, b = d, ...rest })` contributes each
+ * leaf binding (`a`, `b`, `rest`). These are the names Pass 3 treats as reactive
+ * reads — for the bag form, `props` then absorbs `props.x` member reads.
+ */
+const collectPatternNames = (node, out) => {
+    if (t.isIdentifier(node))
+        out.push(node.name);
+    else if (t.isAssignmentPattern(node))
+        collectPatternNames(node.left, out);
+    else if (t.isRestElement(node))
+        collectPatternNames(node.argument, out);
+    else if (t.isObjectPattern(node)) {
+        for (const prop of node.properties) {
+            if (t.isObjectProperty(prop))
+                collectPatternNames(prop.value, out);
+            else
+                collectPatternNames(prop, out); // RestElement
+        }
+    }
+    else if (t.isArrayPattern(node)) {
+        for (const el of node.elements)
+            if (el)
+                collectPatternNames(el, out);
+    }
+};
+/** Walk the factory body of a container, classifying each top-level marker call. */
+const extractContainerBody = (source, factory, container) => {
+    const body = factory.body;
+    if (!t.isBlockStatement(body))
+        return;
+    for (const stmt of body.body) {
+        if (!t.isExpressionStatement(stmt))
+            continue;
+        const expr = stmt.expression;
+        if (!t.isCallExpression(expr))
+            continue;
+        classifyBodyMarker(source, expr, container);
+    }
+};
+/** Dispatch a body-level call to the right node-builder. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const classifyBodyMarker = (source, call, c) => {
+    const callee = call.callee;
+    if (!t.isIdentifier(callee))
+        return;
+    switch (callee.name) {
+        case "__reactra_state__":
+            c.states.push(buildState(source, call));
+            return;
+        case "__reactra_derived__":
+            c.deriveds.push(buildDerived(source, call));
+            return;
+        case "__reactra_action__":
+            c.actions.push(buildAction(call, false));
+            return;
+        case "__reactra_action_async__":
+            c.actions.push(buildAction(call, true));
+            return;
+        case "__reactra_command__":
+            c.commands.push(buildCommand(call, "block"));
+            return;
+        case "__reactra_command_arrow__":
+            c.commands.push(buildCommand(call, "arrow"));
+            return;
+        case "__reactra_resource__":
+            c.resources.push(buildResource(source, call));
+            return;
+        case "__reactra_ref__":
+            c.refs.push(buildRef(source, call));
+            return;
+        case "__reactra_mount__":
+            c.mounts.push(buildMount(call));
+            return;
+        case "__reactra_cleanup__":
+            c.cleanups.push(buildCleanup(call));
+            return;
+        case "__reactra_effect__":
+        case "__reactra_effect_on__":
+            c.effects.push(buildEffect(call, callee.name === "__reactra_effect_on__"));
+            return;
+        case "__reactra_view__":
+            c.view = buildView(call);
+            return;
+        case "__reactra_uses__":
+            // One `uses` clause per container (Component DSL §9). A second marker
+            // means the source carried BOTH a header clause (lowered first by
+            // Pass 1.1) and a body line — error rather than silently overwrite.
+            // Code-less: no `R` code is minted for this structural band.
+            if (c.uses) {
+                throw new Error(`[reactra:compile] BHV002: ${c.kind} "${c.name}" declares more than one \`uses\` clause ` +
+                    `(header form + body line). Declare ONE — either in the header ` +
+                    `(\`component ${c.name} uses ${c.uses.names.join(", ")} {\`) or as a body line. ` +
+                    `(Component DSL §9; Behaviour Plugin spec §8.)`);
+            }
+            c.uses = buildUses(call);
+            return;
+        case "__reactra_inject__":
+            c.injects.push(buildInject(call));
+            return;
+        case "__reactra_provide__":
+            c.provides.push(buildProvide(source, call));
+            return;
+        case "__reactra_param__":
+            c.params.push(buildParam(call));
+            return;
+        case "__reactra_query__":
+            c.queries.push(buildQuery(source, call));
+            return;
+        case "__reactra_meta__":
+            c.meta = buildMeta(call);
+            return;
+        case "__reactra_prefetch__":
+            c.prefetch = buildPrefetch(call);
+            return;
+        case "__reactra_transition__":
+            c.transition = buildTransition(call);
+            return;
+        case "__reactra_inject_store__":
+            c.storeUses.push(buildStoreUseBare(call));
+            return;
+        case "__reactra_inject_store_args__":
+            c.storeUses.push(buildStoreUseArgs(call));
+            return;
+        case "__reactra_inject_store_keyed__":
+            c.storeUses.push(buildStoreUseKeyed(call));
+            return;
+        case "__reactra_error_boundary__":
+            c.errorBoundary = buildErrorBoundary(call);
+            return;
+        case "__reactra_suspense__":
+            c.suspense = buildSuspense(call);
+            return;
+        case "__reactra_input__":
+            c.inputs.push(buildInput(source, call));
+            return;
+        case "__reactra_preserved__":
+            // v2: each `preserved state X = init` emits one __reactra_preserved__("X") call
+            // with a single field; multiple calls accumulate on the same node. v1 emitted
+            // a single call with all fields as string args — both forms are handled by
+            // merging into the existing `preserved` node's field list.
+            if (c.preserved) {
+                const extra = buildPreserved(call);
+                for (const f of extra.fields) {
+                    if (!c.preserved.fields.includes(f))
+                        c.preserved.fields.push(f);
+                }
+            }
+            else {
+                c.preserved = buildPreserved(call);
+            }
+            return;
+        default:
+            return;
+    }
+};
+// ---------- per-marker builders ----------
+const buildState = (source, call) => {
+    const name = firstStringArg(call) ?? "";
+    const init = (call.arguments[1] ?? t.identifier("undefined"));
+    return {
+        kind: "state",
+        name,
+        initializer: init,
+        initializerText: sliceSource(source, init),
+        call,
+    };
+};
+const buildDerived = (source, call) => {
+    const name = firstStringArg(call) ?? "";
+    const thunk = arrowArg(call, 1);
+    const expr = thunkBody(thunk);
+    return {
+        kind: "derived",
+        name,
+        thunk,
+        exprText: expr ? sliceSource(source, expr) : "",
+        deps: [], // populated by Pass 3 (read-set analysis)
+        call,
+    };
+};
+const buildAction = (call, isAsync) => ({
+    kind: "action",
+    name: firstStringArg(call) ?? "",
+    isAsync,
+    arrow: arrowArg(call, 1),
+    deps: [], // populated by Pass 3 (read-set analysis)
+    call,
+});
+/** The value of an object-literal property by key, or undefined. */
+const objProp = (obj, key) => {
+    for (const p of obj.properties) {
+        if (t.isObjectProperty(p) && t.isIdentifier(p.key, { name: key }))
+            return p.value;
+    }
+    return undefined;
+};
+/**
+ * Resource names from an `invalidate [a, b]` array. Each entry names a resource —
+ * a bare identifier (`posts`) or a string literal (`"posts"`, the useMutation
+ * muscle-memory form); both mean the same cache key. Any OTHER element kind
+ * (member expression, call, spread) is NOT a resource name — warn loudly rather
+ * than silently dropping it, so a malformed `invalidate` can't quietly skip a
+ * refetch (a cache-coherence footgun). Holes (`[a, ,]`) are ignored silently.
+ */
+const invalidateNames = (commandName, arr) => {
+    const names = [];
+    for (const e of arr.elements) {
+        if (e == null)
+            continue; // an array hole (trailing/extra comma) — harmless
+        if (t.isIdentifier(e))
+            names.push(e.name);
+        else if (t.isStringLiteral(e))
+            names.push(e.value);
+        else {
+            console.warn(`[reactra:compile] command "${commandName}" — \`invalidate\` accepts bare resource ` +
+                `names (e.g. \`invalidate [posts]\` or \`invalidate ["posts"]\`); ignoring an ` +
+                `unsupported entry of kind "${e.type}".`);
+        }
+    }
+    return names;
+};
+const buildCommand = (call, form) => {
+    // Arrow form may carry a 3rd arg — the clause options object
+    // `{ optimistic: () => {…}, invalidate: [a, b], rollback: (e) => {…} }`.
+    const opts = form === "arrow" && t.isObjectExpression(call.arguments[2]) ? call.arguments[2] : undefined;
+    const name = firstStringArg(call) ?? "";
+    const optimistic = opts && objProp(opts, "optimistic");
+    const invalidate = opts && objProp(opts, "invalidate");
+    const rollback = opts && objProp(opts, "rollback");
+    return {
+        kind: "command",
+        name,
+        form,
+        arrow: arrowArg(call, 1),
+        ...(optimistic && t.isArrowFunctionExpression(optimistic) ? { optimistic } : {}),
+        ...(invalidate && t.isArrayExpression(invalidate) ? { invalidate: invalidateNames(name, invalidate) } : {}),
+        ...(rollback && t.isArrowFunctionExpression(rollback) ? { rollback } : {}),
+        call,
+    };
+};
+const buildResource = (source, call) => {
+    // Stage 3 — the 4th arg, when present, is an ObjectExpression literal the
+    // preprocessor emits for modifier opt-ins (`cache`, `swr`, `retry`). We read
+    // both the flags AND the parameterized values: `cache: { ttlMs }` (hard-expiry)
+    // vs `cache: { staleWhileRevalidate, ttlMs }` (swr) vs `cache: true` (bare); and
+    // the `retry` count. Values are sliced as source so an expression (`retry: MAX`)
+    // survives. Absent → all default (Pass 9 fills `ttlMs: 60_000` / `retry: 3`).
+    const optsArg = call.arguments[3];
+    let optCache;
+    let optSwr;
+    let optRetry;
+    let cacheTtl;
+    let retryCount;
+    let select;
+    if (optsArg && t.isObjectExpression(optsArg)) {
+        const cacheVal = objProp(optsArg, "cache");
+        const retryVal = objProp(optsArg, "retry");
+        if (cacheVal && t.isObjectExpression(cacheVal)) {
+            const isSwr = objProp(cacheVal, "staleWhileRevalidate") !== undefined;
+            if (isSwr)
+                optSwr = true;
+            else
+                optCache = true;
+            const ttl = objProp(cacheVal, "ttlMs");
+            if (ttl)
+                cacheTtl = sliceSource(source, ttl);
+        }
+        else if (cacheVal) {
+            optCache = true; // `cache: true` (bare, no TTL)
+        }
+        if (retryVal) {
+            optRetry = true;
+            retryCount = sliceSource(source, retryVal);
+        }
+        const selectVal = objProp(optsArg, "select");
+        if (selectVal && t.isArrowFunctionExpression(selectVal)) {
+            select = sliceSource(source, selectVal);
+        }
+    }
+    return {
+        kind: "resource",
+        name: firstStringArg(call) ?? "",
+        depsThunk: arrowArg(call, 1),
+        fetcher: arrowArg(call, 2),
+        optCache,
+        optSwr,
+        optRetry,
+        ...(cacheTtl !== undefined ? { cacheTtl } : {}),
+        ...(retryCount !== undefined ? { retryCount } : {}),
+        ...(select !== undefined ? { select } : {}),
+        call,
+    };
+};
+const buildRef = (source, call) => {
+    const name = firstStringArg(call) ?? "";
+    const init = (call.arguments[1] ?? t.nullLiteral());
+    return {
+        kind: "ref",
+        name,
+        initializer: init,
+        initializerText: sliceSource(source, init),
+        call,
+    };
+};
+const buildMount = (call) => ({
+    kind: "mount",
+    body: arrowArg(call, 0),
+    call,
+});
+const buildCleanup = (call) => ({
+    kind: "cleanup",
+    body: arrowArg(call, 0),
+    call,
+});
+const buildEffect = (call, hasWatch) => ({
+    kind: "effect",
+    watch: hasWatch ? arrowArg(call, 0) : undefined,
+    body: hasWatch ? arrowArg(call, 1) : arrowArg(call, 0),
+    call,
+});
+const buildView = (call) => ({
+    kind: "view",
+    body: arrowArg(call, 0),
+    call,
+});
+const buildUses = (call) => {
+    const names = [];
+    for (const arg of call.arguments) {
+        if (t.isStringLiteral(arg))
+            names.push(arg.value);
+    }
+    return { kind: "uses", names, call };
+};
+/** Read a string-valued property `key` off an ObjectExpression argument. */
+const objStringProp = (arg, key) => {
+    if (!arg || !t.isObjectExpression(arg))
+        return undefined;
+    for (const prop of arg.properties) {
+        if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key) || prop.key.name !== key)
+            continue;
+        if (t.isStringLiteral(prop.value))
+            return prop.value.value;
+    }
+    return undefined;
+};
+/**
+ * Read a `{ fields: ["a", { source: "b", local: "localB" }] }` argument into a
+ * `StoreField[]` (undefined if absent). A string element is a bare field; an
+ * object element is a `{ source, local, as? }` rename (Store v4.7 §2.5).
+ */
+const readFieldsArg = (arg) => {
+    if (!arg || !t.isObjectExpression(arg))
+        return undefined;
+    for (const prop of arg.properties) {
+        if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key) || prop.key.name !== "fields")
+            continue;
+        if (!t.isArrayExpression(prop.value))
+            return undefined;
+        const out = [];
+        for (const e of prop.value.elements) {
+            if (e == null)
+                continue;
+            if (t.isStringLiteral(e)) {
+                out.push(e.value);
+            }
+            else if (t.isObjectExpression(e)) {
+                const source = objStringProp(e, "source");
+                const local = objStringProp(e, "local");
+                if (source && local)
+                    out.push({ source, local, as: objBoolProp(e, "as") });
+            }
+        }
+        return out.length > 0 ? out : undefined;
+    }
+    return undefined;
+};
+/** Read a boolean object property (`{ as: true }`) — true only when literally `true`. */
+const objBoolProp = (obj, key) => {
+    if (!obj || !t.isObjectExpression(obj))
+        return false;
+    for (const prop of obj.properties) {
+        if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === key) {
+            return t.isBooleanLiteral(prop.value) && prop.value.value === true;
+        }
+    }
+    return false;
+};
+const buildInject = (call) => {
+    const opts = call.arguments[1];
+    const serviceKind = objStringProp(opts, "kind") === "service" ? "service" : undefined;
+    return {
+        kind: "inject",
+        name: firstStringArg(call) ?? "",
+        serviceKind,
+        source: objStringProp(opts, "source"),
+        alias: objStringProp(opts, "alias"),
+        call,
+    };
+};
+const buildProvide = (source, call) => {
+    const name = firstStringArg(call) ?? "";
+    const value = (call.arguments[1] ?? t.nullLiteral());
+    return {
+        kind: "provide",
+        name,
+        value,
+        valueText: sliceSource(source, value),
+        call,
+    };
+};
+const buildParam = (call) => ({
+    kind: "param",
+    name: firstStringArg(call) ?? "",
+    call,
+});
+const buildQuery = (source, call) => {
+    const name = firstStringArg(call) ?? "";
+    // `__reactra_query__("name", "<type>"[, default[, parser]])` — arg[1] is the
+    // declared type string (preprocessor always emits it; "string" when unannotated),
+    // arg[2] the optional default, arg[3] the optional custom-from parser identifier.
+    // When `from parseFoo` is present without a default, arg[2] is the literal
+    // `undefined` (a placeholder so the parser stays at arg[3]).
+    const typeArg = call.arguments[1];
+    const tsType = t.isStringLiteral(typeArg) ? typeArg.value : "string";
+    const def = call.arguments[2];
+    const isUndefinedPlaceholder = def != null && t.isIdentifier(def) && def.name === "undefined";
+    const parserArg = call.arguments[3];
+    const fromParser = parserArg != null && t.isIdentifier(parserArg) ? parserArg.name : undefined;
+    return {
+        kind: "query",
+        name,
+        tsType,
+        defaultExpr: isUndefinedPlaceholder ? undefined : def,
+        defaultText: def && !isUndefinedPlaceholder ? sliceSource(source, def) : undefined,
+        fromParser,
+        call,
+    };
+};
+const buildMeta = (call) => ({
+    kind: "meta",
+    object: call.arguments[0],
+    call,
+});
+const buildPrefetch = (call) => {
+    const trigger = firstStringArg(call) ?? "none";
+    return {
+        kind: "prefetch",
+        trigger: trigger,
+        call,
+    };
+};
+const buildTransition = (call) => {
+    const name = firstStringArg(call) ?? "";
+    const second = call.arguments[1];
+    const durationMs = second && t.isNumericLiteral(second) ? second.value : undefined;
+    return { kind: "transition", name, durationMs, call };
+};
+const buildStoreUseBare = (call) => ({
+    kind: "store-use",
+    storeName: firstStringArg(call) ?? "",
+    classification: "bare",
+    // __reactra_inject_store__("X" [, { fields: [...], typeOverride: "T", alias: "Y" }])
+    fields: readFieldsArg(call.arguments[1]),
+    typeOverride: objStringProp(call.arguments[1], "typeOverride"),
+    alias: objStringProp(call.arguments[1], "alias"),
+    call,
+});
+const buildStoreUseArgs = (call) => ({
+    kind: "store-use",
+    storeName: firstStringArg(call) ?? "",
+    classification: "argumented",
+    // __reactra_inject_store_args__("X", { inputs } [, { fields: [...], typeOverride: "T" }])
+    args: call.arguments[1],
+    fields: readFieldsArg(call.arguments[2]),
+    typeOverride: objStringProp(call.arguments[2], "typeOverride"),
+    call,
+});
+const buildStoreUseKeyed = (call) => ({
+    kind: "store-use",
+    storeName: firstStringArg(call) ?? "",
+    classification: "keyed",
+    // __reactra_inject_store_keyed__("X", key, { inputs } [, { fields: [...], typeOverride: "T" }])
+    key: call.arguments[1],
+    args: call.arguments[2],
+    fields: readFieldsArg(call.arguments[3]),
+    typeOverride: objStringProp(call.arguments[3], "typeOverride"),
+    call,
+});
+const buildErrorBoundary = (call) => {
+    const body = arrowArg(call, 0);
+    const paramNode = body.params[0];
+    const errorParam = paramNode && t.isIdentifier(paramNode) ? paramNode.name : "e";
+    return { kind: "error-boundary", errorParam, body, call };
+};
+const buildSuspense = (call) => ({
+    kind: "suspense",
+    body: arrowArg(call, 0),
+    call,
+});
+const buildInput = (source, call) => {
+    const name = firstStringArg(call) ?? "";
+    let requirement = "required";
+    let defaultExpr;
+    let defaultText;
+    const opts = call.arguments[1];
+    if (opts && t.isObjectExpression(opts)) {
+        for (const prop of opts.properties) {
+            if (!t.isObjectProperty(prop) || !t.isIdentifier(prop.key))
+                continue;
+            if (prop.key.name === "optional" && t.isBooleanLiteral(prop.value) && prop.value.value) {
+                requirement = "optional";
+            }
+            else if (prop.key.name === "default") {
+                requirement = "default";
+                defaultExpr = prop.value;
+                defaultText = sliceSource(source, prop.value);
+            }
+        }
+    }
+    // arg[1].tsType — the declared type string (Run 2 / D3), present only when the
+    // source annotated the input. Shadow-emitter only; Pass-9 ignores it.
+    const tsType = objStringProp(opts, "tsType");
+    return { kind: "input", name, requirement, defaultExpr, defaultText, tsType, call };
+};
+const buildPreserved = (call) => {
+    const fields = [];
+    for (const arg of call.arguments) {
+        if (t.isStringLiteral(arg))
+            fields.push(arg.value);
+    }
+    return { kind: "preserved", fields, call };
+};
+/**
+ * Day 23 / `#7b`: walk the component's view body for `__reactra_await__(...)`
+ * CallExpressions and append one `AwaitBlockNode` per match to
+ * `container.awaitBlocks`. Mirrors `scanAwaits` in pass-9-codegen but
+ * keeps the extracted data on the FileGraph so the sidecar builder
+ * (and future devtools/LSP consumers) can read it without
+ * re-traversing the view AST.
+ *
+ * `resourceName` is the text of the first arrow's body — typically a
+ * bare identifier (e.g. `"customer"`) but tolerates richer expressions
+ * (e.g. `"customer.data"`). `hasPending` / `hasError` mirror whether
+ * the optional 3rd / 4th arrow arguments are present (the preprocessor
+ * emits arrows for both unconditionally if the source declares them).
+ */
+const extractAwaitBlocks = (source, container) => {
+    if (!container.view)
+        return;
+    const viewBody = container.view.body.body;
+    // Wrap the view body's expression in a synthetic file so we can
+    // traverse it the same way pass-9-codegen does. (Direct traversal
+    // of a bare Expression isn't supported by @babel/traverse.)
+    traverse(t.file(t.program([t.expressionStatement(viewBody)])), {
+        CallExpression(path) {
+            const callee = path.node.callee;
+            if (!t.isIdentifier(callee) || callee.name !== "__reactra_await__")
+                return;
+            // §B1 MAJOR-2: index via the shared AWAIT_ARG_ORDER (this extract-side
+            // reader feeds `awaitBlocks` to devtools/LSP/sidecar — it must agree with
+            // the Pass-9 + shadow await wiring, not carry its own magic positions).
+            const args = path.node.arguments;
+            const resourceArrow = args[AWAIT_ARG_ORDER.resource];
+            const pendingArrow = args[AWAIT_ARG_ORDER.pending];
+            const errorArrow = args[AWAIT_ARG_ORDER.error];
+            if (!t.isArrowFunctionExpression(resourceArrow))
+                return;
+            // Resource expression text — the body of the first arrow.
+            // Slice from the original source via the node's start/end
+            // (sliceSource tolerates missing positions by returning "").
+            const resourceName = sliceSource(source, resourceArrow.body).trim();
+            if (resourceName.length === 0)
+                return;
+            const block = {
+                kind: "await-block",
+                resourceName,
+                hasPending: t.isArrowFunctionExpression(pendingArrow),
+                hasError: t.isArrowFunctionExpression(errorArrow),
+            };
+            container.awaitBlocks.push(block);
+        },
+    });
+};
+//# sourceMappingURL=pass-2-extract.js.map