@component-compass/parser-react 0.0.4 → 0.1.0

package/dist/emit.js

@@ -0,0 +1,1009 @@
+import { findEnclosingComponentBinding, positionAt } from "@component-compass/ast-utils";
+import { MODULE_SCOPE } from "@component-compass/reference-graph";
+import { walk } from "oxc-walker";
+import { inferValue, extractFunctionReturns, extractClassRenderReturns } from "./infer-value.js";
+import { readJsxAttrs } from "./jsx-attrs.js";
+export function emitReact(opts) {
+    const captureValues = opts.captureValues ?? false;
+    const emitState = {
+        fileBuilder: opts.fileBuilder,
+        pendingPropForwardBindings: [],
+        ast: opts.ast,
+        source: opts.source,
+    };
+    for (const node of opts.ast.body) {
+        if (node.type === "ImportDeclaration") {
+            emitImport(node, opts.fileBuilder, opts.source);
+        }
+        else if (node.type === "VariableDeclaration") {
+            emitVariableDeclaration(node, opts.fileBuilder, opts.source, captureValues, emitState);
+        }
+        else if (node.type === "FunctionDeclaration" ||
+            node.type === "TSDeclareFunction") {
+            emitFunctionDeclaration(node, opts.fileBuilder, opts.source, captureValues);
+        }
+        else if (node.type === "ClassDeclaration" ||
+            node.type === "ClassExpression") {
+            emitClassDeclaration(node, opts.fileBuilder, opts.source, captureValues);
+        }
+        else if (node.type === "ExportNamedDeclaration") {
+            emitExportNamed(node, opts.fileBuilder, opts.source, captureValues, emitState);
+        }
+        else if (node.type === "ExportDefaultDeclaration") {
+            emitExportDefault(node, opts.fileBuilder, opts.source, captureValues);
+        }
+        else if (node.type === "ExportAllDeclaration") {
+            emitExportAll(node, opts.fileBuilder);
+        }
+    }
+    // Second pass: prop-forward finalize (#151).
+    finalizePropForwardBindings(emitState);
+}
+// ---------------------------------------------------------------------------
+// Import emission
+// ---------------------------------------------------------------------------
+function emitImport(node, fb, source) {
+    const specifier = node.source.value;
+    const pos = positionAt(source, node.start);
+    const loc = { line: pos.line, column: pos.column + 1 };
+    if (!node.specifiers || node.specifiers.length === 0) {
+        // Side-effect import — skip (no binding emitted).
+        return;
+    }
+    for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+            // `imported` is ModuleExportName: IdentifierName | IdentifierReference | StringLiteral
+            // IdentifierName / IdentifierReference have `.name`; StringLiteral has `.value`
+            const imported = spec.imported.type === "Identifier"
+                ? spec.imported.name
+                : String(spec.imported.value);
+            fb.addImport({ specifier, imported, local: spec.local.name, loc });
+        }
+        else if (spec.type === "ImportDefaultSpecifier") {
+            fb.addImport({ specifier, imported: "default", local: spec.local.name, loc });
+        }
+        else if (spec.type === "ImportNamespaceSpecifier") {
+            fb.addImport({ specifier, imported: "*", local: spec.local.name, loc });
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// JSX walking helpers
+// ---------------------------------------------------------------------------
+/**
+ * Decompose a JSX element name into symbol + memberChain.
+ * `<Foo />` → { symbol: "Foo", memberChain: [] }
+ * `<Foo.Bar.Baz />` → { symbol: "Foo", memberChain: ["Bar", "Baz"] }
+ * Returns null for JSXNamespacedName (skip those).
+ */
+function decomposeJsxName(node) {
+    if (node.type === "JSXIdentifier") {
+        return { symbol: node.name, memberChain: [] };
+    }
+    if (node.type === "JSXMemberExpression") {
+        const parts = [];
+        let current = node;
+        while (current.type === "JSXMemberExpression") {
+            const mem = current;
+            parts.unshift(mem.property.name);
+            current = mem.object;
+        }
+        if (current.type !== "JSXIdentifier")
+            return null;
+        return { symbol: current.name, memberChain: parts };
+    }
+    // JSXNamespacedName — skip
+    return null;
+}
+/**
+ * Walk an arbitrary AST subtree looking for JSXOpeningElement nodes.
+ * For each found, emit a JsxUsage via fb.addJsxUsage and, if currentOwner is
+ * non-null, wire it via fb.setOwner.
+ */
+function walkJsxIn(node, fb, source, currentOwner, captureValues) {
+    if (node == null)
+        return;
+    if (node.type === "JSXOpeningElement") {
+        const opening = node;
+        const decomposed = decomposeJsxName(opening.name);
+        if (decomposed) {
+            const pos = positionAt(source, opening.start);
+            const loc = { line: pos.line, column: pos.column };
+            fb.addJsxUsage({
+                ref: {
+                    symbol: decomposed.symbol,
+                    memberChain: decomposed.memberChain,
+                    scope: fb.currentScope(),
+                    loc,
+                    originFile: fb.filePath,
+                },
+                loc,
+                props: readJsxAttrs(opening, captureValues),
+            });
+            if (currentOwner !== null) {
+                fb.setOwner(currentOwner);
+            }
+        }
+    }
+    if (node.type === "VariableDeclaration") {
+        const varDecl = node;
+        for (const declr of varDecl.declarations) {
+            if (declr.id.type !== "Identifier") {
+                tryEmitDestructureFromCall(declr, fb, source);
+                continue;
+            }
+            const id = declr.id;
+            emitDeclarationFromDeclarator(declr, fb, source, { symbol: id.name, file: fb.filePath });
+        }
+        // Fall through to the generic recursion below so we still walk into initializers
+        // for JSX usages, nested function bodies, and further VariableDeclarations.
+    }
+    // Nested function / arrow / fn-expr — push scope + emit params, then walk body.
+    // Without this:
+    //   - render-prop arrows like `<DL>{(Item) => <Item.X />}</DL>` never register Item as a binding;
+    //   - nested function decls inside another function body leak params (or drop them).
+    // Top-level FunctionDeclarations are handled by `emitFunctionDeclaration` directly (which
+    // already pushes a scope + calls emitParameterBindings); this branch only fires for nested
+    // instances reached via this generic walker.
+    if (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionExpression" ||
+        node.type === "FunctionDeclaration") {
+        const fnNode = node;
+        const refSymbol = fnNode.id?.name ?? `<arrow@${fnNode.start}>`;
+        const fnRef = {
+            symbol: refSymbol,
+            scope: fb.currentScope(),
+            memberChain: [],
+            loc: positionAt(source, fnNode.start),
+            originFile: fb.filePath,
+        };
+        fb.pushScope();
+        try {
+            emitParameterBindings(fnNode.params, fnRef, fb, source);
+            walkJsxIn(fnNode.body, fb, source, currentOwner, captureValues);
+        }
+        finally {
+            fb.popScope();
+        }
+        return; // do NOT fall through to generic recursion — we walked the body already.
+    }
+    // Recurse into all child nodes
+    for (const val of Object.values(node)) {
+        if (Array.isArray(val)) {
+            for (const child of val) {
+                if (child !== null && typeof child === "object" && typeof child.type === "string") {
+                    walkJsxIn(child, fb, source, currentOwner, captureValues);
+                }
+            }
+        }
+        else if (val !== null && typeof val === "object" && typeof val.type === "string") {
+            walkJsxIn(val, fb, source, currentOwner, captureValues);
+        }
+    }
+}
+/**
+ * Walk the body of a top-level function looking for identifier-callee
+ * CallExpressions and emit one `fb.addBodyCall` entry per call found.
+ * Does NOT descend into nested ArrowFunctionExpression / FunctionExpression /
+ * FunctionDeclaration bodies — only the lexical body of the owning top-level
+ * function is walked.
+ *
+ * Only Identifier callees are recorded (member-expression calls like
+ * `this.foo()` or `a.b()` are skipped). This matches the design intent:
+ * we only need direct identifier calls for the helper-caller index.
+ */
+function walkBodyCalls(node, fb, source, ownerSymbol) {
+    if (node == null)
+        return;
+    // Stop descent at nested function boundaries — only the top-level body is in scope.
+    if (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionExpression" ||
+        node.type === "FunctionDeclaration") {
+        return;
+    }
+    // Emit a body-call record for every CallExpression with an Identifier callee.
+    if (node.type === "CallExpression") {
+        const call = node;
+        if (call.callee.type === "Identifier") {
+            const id = call.callee;
+            const pos = positionAt(source, id.start);
+            // `scope: MODULE_SCOPE` is intentionally hardcoded even though the call
+            // site is lexically inside a function body, not at module scope. The
+            // sole consumer (`buildHelperCallers` → `resolveRefToDecl`) ignores
+            // scope and resolves by symbol + originFile only. Setting a literal
+            // value here keeps the code mechanical without threading the file
+            // builder's scope stack through `walkBodyCalls`.
+            fb.addBodyCall({
+                ownerSymbol,
+                callee: {
+                    symbol: id.name,
+                    memberChain: [],
+                    loc: { line: pos.line, column: pos.column },
+                    originFile: fb.filePath,
+                    scope: MODULE_SCOPE,
+                },
+            });
+        }
+        // Still recurse into arguments and callee (e.g. IIFE or chained calls)
+        // but the boundary check above prevents descent into nested function bodies.
+    }
+    // Generic recursion into all child nodes.
+    for (const val of Object.values(node)) {
+        if (Array.isArray(val)) {
+            for (const child of val) {
+                if (child !== null && typeof child === "object" && typeof child.type === "string") {
+                    walkBodyCalls(child, fb, source, ownerSymbol);
+                }
+            }
+        }
+        else if (val !== null && typeof val === "object" && typeof val.type === "string") {
+            walkBodyCalls(val, fb, source, ownerSymbol);
+        }
+    }
+}
+/**
+ * Walk a function-parameter or destructure pattern AST node, yielding one
+ * PatternLeaf per leaf Identifier. The `source` InferredType describes the
+ * value being destructured (e.g. `ParameterOf(fnRef, i)` or the call-return
+ * type for `const { X } = useFoo()`). Leaves carry MemberOf chains over
+ * `source` keyed by destructure path. Mirrors Omlet's
+ * extract_symbols_from_pattern.
+ *
+ * `sourceText` is needed to compute `positionAt` for each leaf identifier.
+ */
+export function extractBindingsFromPattern(pattern, source, sourceText) {
+    const out = [];
+    const recurse = (node, src) => {
+        switch (node.type) {
+            case "Identifier": {
+                const id = node;
+                const pos = positionAt(sourceText, id.start);
+                out.push({ symbol: id.name, value: src, loc: { line: pos.line, column: pos.column } });
+                return;
+            }
+            case "ObjectPattern": {
+                const op = node;
+                for (const prop of op.properties) {
+                    // OXC emits "Property" for binding patterns (BindingProperty), never "ObjectProperty"
+                    // which only appears in expression-context object literals.
+                    if (prop.type === "Property") {
+                        const p = prop;
+                        if (p.computed)
+                            continue; // computed keys carry no static member name
+                        const keyName = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
+                        recurse(p.value, { kind: "MemberOf", obj: src, member: keyName });
+                    }
+                    else if (prop.type === "RestElement") {
+                        const r = prop;
+                        recurse(r.argument, src);
+                    }
+                }
+                return;
+            }
+            case "ArrayPattern": {
+                const ap = node;
+                for (let i = 0; i < ap.elements.length; i++) {
+                    const el = ap.elements[i];
+                    if (el == null)
+                        continue; // sparse holes
+                    if (el.type === "RestElement") {
+                        const r = el;
+                        recurse(r.argument, src);
+                    }
+                    else {
+                        // Index labels are decorative — MemberOf-over-Array in resolve-type.ts
+                        // fans out to all elements at resolve time regardless of `member`.
+                        recurse(el, { kind: "MemberOf", obj: src, member: String(i) });
+                    }
+                }
+                return;
+            }
+            case "AssignmentPattern": {
+                const ap = node;
+                recurse(ap.left, src);
+                return;
+            }
+            case "RestElement": {
+                const r = node;
+                recurse(r.argument, src);
+                return;
+            }
+            // Other pattern shapes (TSParameterProperty, etc) are not in scope for #31.
+        }
+    };
+    recurse(pattern, source);
+    return out;
+}
+/**
+ * Emit one BindingDecl per leaf in each function parameter, valued as a
+ * MemberOf chain over `ParameterOf(fnRef, paramIndex)`. Bindings are stamped
+ * `dynamicSource: "parameter"` so the engine emits a dynamic-binding
+ * occurrence when the resolution chain bottoms out at Unknown.
+ *
+ * Call this AFTER `fb.pushScope()` so the bindings land in the function's
+ * body scope (not the caller's scope).
+ */
+function emitParameterBindings(params, fnRef, fb, sourceText) {
+    for (let i = 0; i < params.length; i++) {
+        const param = params[i];
+        if (!param)
+            continue;
+        const paramSource = { kind: "ParameterOf", fn: fnRef, index: i };
+        const leaves = extractBindingsFromPattern(param, paramSource, sourceText);
+        for (const leaf of leaves) {
+            fb.addDeclaration({
+                symbol: leaf.symbol,
+                value: leaf.value,
+                loc: leaf.loc,
+                isExported: false,
+                dynamicSource: "parameter",
+            });
+        }
+    }
+}
+/**
+ * If a VariableDeclarator has a destructure pattern id AND a CallExpression
+ * initializer, emit one BindingDecl per leaf with `dynamicSource: "hook-return"`
+ * and a `MemberOf(initType, key)` value over the call's InferredType.
+ *
+ * Returns true if any leaf was emitted; false if the shape didn't match
+ * (caller can fall through to other handling).
+ *
+ * The `"hook-return"` label fires for ANY CallExpression-init destructure,
+ * not just identifiers matching /^use[A-Z]/. Keeps detection cheap and avoids
+ * a brittle name heuristic.
+ */
+function tryEmitDestructureFromCall(declr, fb, source) {
+    if (declr.id.type === "Identifier")
+        return false;
+    if (declr.id.type !== "ObjectPattern" && declr.id.type !== "ArrayPattern")
+        return false;
+    if (declr.init == null)
+        return false;
+    const init = declr.init;
+    if (init.type !== "CallExpression")
+        return false;
+    const initType = inferValue(declr.init, fb.currentScope(), fb.filePath, undefined);
+    const leaves = extractBindingsFromPattern(declr.id, initType, source);
+    for (const leaf of leaves) {
+        fb.addDeclaration({
+            symbol: leaf.symbol,
+            value: leaf.value,
+            loc: leaf.loc,
+            isExported: false,
+            dynamicSource: "hook-return",
+        });
+    }
+    return leaves.length > 0;
+}
+// ---------------------------------------------------------------------------
+// Prop-forward helpers (#151)
+// ---------------------------------------------------------------------------
+/**
+ * True if the given node type is a JSX expression that produces a React
+ * element value. Used to detect module-scope `const X = <JSX/>` bindings
+ * whose JSX construction site needs prop-forward owner attribution.
+ */
+export function isJsxTypeInit(nodeType) {
+    return nodeType === "JSXElement" || nodeType === "JSXFragment";
+}
+/**
+ * Extract the root identifier from a JSX init expression.
+ * Returns the root binding name (`<Foo.Bar />` → `"Foo"`) or null for
+ * JSXFragment / namespaced names (no static root identifier).
+ */
+export function rootSymbolOfJsxInit(init) {
+    if (init.type !== "JSXElement")
+        return null;
+    const opening = init.openingElement;
+    const decomposed = decomposeJsxName(opening.name);
+    return decomposed?.symbol ?? null;
+}
+/**
+ * Scan the file AST for Identifier reads that resolve to a pending prop-forward
+ * binding. Returns one ReadSite per matching read, recording the enclosing
+ * component as the owner attribution target.
+ */
+function findPropForwardReadSites(emitState) {
+    const sites = [];
+    const pending = emitState.pendingPropForwardBindings;
+    if (pending.length === 0)
+        return sites;
+    const pendingNames = new Set(pending.map((p) => p.symbol));
+    walk(emitState.ast, {
+        enter(node, parent) {
+            if (node.type !== "Identifier")
+                return;
+            const idName = node.name;
+            if (!pendingNames.has(idName))
+                return;
+            // Skip non-read positions.
+            if (isWritePosition(node, parent))
+                return;
+            // Use ast-utils helper to find the enclosing component.
+            const enclosing = findEnclosingComponentBinding(node, emitState.ast);
+            if (!enclosing)
+                return;
+            // Shadowing check: skip if a closer-enclosing scope re-binds the name.
+            if (isShadowedByInnerScope(emitState.ast, node, idName))
+                return;
+            const pendingIdx = pending.findIndex((p) => p.symbol === idName);
+            if (pendingIdx === -1)
+                return;
+            const ownerRef = {
+                symbol: enclosing.name,
+                scope: MODULE_SCOPE,
+                memberChain: [],
+                loc: enclosing.loc ?? { line: 0, column: 0 },
+                originFile: emitState.fileBuilder.filePath,
+            };
+            sites.push({ pendingIdx, ownerRef });
+        },
+    });
+    return sites;
+}
+/**
+ * Returns true if `outerName` is shadowed by a closer-enclosing declaration
+ * between the read site (`identifierNode`) and module scope. Used by the
+ * prop-forward second-pass to skip reads that bind to an inner declaration
+ * rather than the outer module-scope binding.
+ *
+ * v1 conservative implementation: scan only the immediately enclosing
+ * function's parameters + top-level VariableDeclarations within the function
+ * body. Misses block-scoped `let` shadowing inside if/for/etc. Acceptable
+ * for the consumer-web patterns we're targeting; tighten if real-world data
+ * shows misses.
+ */
+function isShadowedByInnerScope(ast, identifierNode, outerName) {
+    let stopped = false;
+    let shadowed = false;
+    const fnStack = [];
+    walk(ast, {
+        enter(node) {
+            if (stopped)
+                return;
+            if (node.type === "FunctionDeclaration" ||
+                node.type === "FunctionExpression" ||
+                node.type === "ArrowFunctionExpression") {
+                fnStack.push(node);
+            }
+            if (node === identifierNode) {
+                stopped = true;
+                const innermostFn = fnStack[fnStack.length - 1];
+                if (!innermostFn)
+                    return;
+                // Check params for a binding named outerName.
+                const params = innermostFn.params ?? [];
+                for (const param of params) {
+                    if (containsBindingName(param, outerName)) {
+                        shadowed = true;
+                        return;
+                    }
+                }
+                // Check top-level VariableDeclarations within the function body.
+                const body = innermostFn.body;
+                if (body && body.type === "BlockStatement" && Array.isArray(body.body)) {
+                    for (const stmt of body.body) {
+                        if (stmt.type === "VariableDeclaration") {
+                            const decls = stmt.declarations;
+                            for (const d of decls) {
+                                if (containsBindingName(d.id, outerName)) {
+                                    shadowed = true;
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        leave(node) {
+            if (stopped)
+                return;
+            if (node.type === "FunctionDeclaration" ||
+                node.type === "FunctionExpression" ||
+                node.type === "ArrowFunctionExpression") {
+                fnStack.pop();
+            }
+        },
+    });
+    return shadowed;
+}
+/** True if the given pattern binds `name` at its top level (simple identifier
+ *  patterns + destructure leaves; no nested-destructure recursion since v1
+ *  doesn't need that depth). */
+function containsBindingName(pattern, name) {
+    if (pattern.type === "Identifier") {
+        return pattern.name === name;
+    }
+    if (pattern.type === "ObjectPattern") {
+        const props = pattern.properties;
+        for (const p of props) {
+            if (p.value && containsBindingName(p.value, name))
+                return true;
+            if (p.argument && containsBindingName(p.argument, name))
+                return true;
+        }
+    }
+    if (pattern.type === "ArrayPattern") {
+        const elements = pattern.elements;
+        for (const el of elements) {
+            if (el && containsBindingName(el, name))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * True when the Identifier is in a "write" position (declaration, assignment
+ * target, static property key, static member access property, import name)
+ * rather than a "read" position. Used to filter out non-read appearances of
+ * the binding name during the prop-forward second-pass scan.
+ */
+function isWritePosition(node, parent) {
+    if (!parent)
+        return false;
+    switch (parent.type) {
+        case "VariableDeclarator":
+            return parent.id === node;
+        case "FunctionDeclaration":
+        case "FunctionExpression":
+        case "ArrowFunctionExpression":
+        case "ClassDeclaration":
+        case "ClassExpression":
+            return parent.id === node;
+        case "ImportSpecifier":
+        case "ImportDefaultSpecifier":
+        case "ImportNamespaceSpecifier":
+            return true;
+        case "Property": {
+            const p = parent;
+            return p.key === node && p.computed !== true;
+        }
+        case "MemberExpression": {
+            const p = parent;
+            return p.property === node && p.computed !== true;
+        }
+        case "AssignmentExpression":
+            return parent.left === node;
+        default:
+            return false;
+    }
+}
+/**
+ * Finalize prop-forward attribution. For each pending binding that has at
+ * least one read site, re-attribute every JsxUsage in the binding's
+ * construction range `[usageIdxStart, usageIdxEnd)` to the read site's
+ * enclosing component.
+ *
+ * Range-clone semantics: when a binding is read in N components, every usage
+ * in the range is cloned (N − 1) additional times so nested children
+ * (e.g. `<Provider><Notification/></Provider>` emits two usages — both get
+ * fanned out per read site). The engine emits one occurrence per
+ * (jsxUsage, ownership) pair, so cloning produces accurate per-component
+ * occurrence counts even when the binding wraps the subject in a tracked
+ * structural component.
+ *
+ * Pending bindings with no read sites are left alone (orphan signal
+ * preserved).
+ */
+function finalizePropForwardBindings(emitState) {
+    const sites = findPropForwardReadSites(emitState);
+    if (sites.length === 0)
+        return;
+    const byBinding = new Map();
+    for (const site of sites) {
+        const list = byBinding.get(site.pendingIdx) ?? [];
+        list.push(site);
+        byBinding.set(site.pendingIdx, list);
+    }
+    const fb = emitState.fileBuilder;
+    for (const [pendingIdx, readSites] of byBinding) {
+        const pending = emitState.pendingPropForwardBindings[pendingIdx];
+        if (!pending)
+            continue;
+        const via = {
+            kind: "prop-forward",
+            bindingName: pending.symbol,
+            constructionSite: {
+                file: fb.filePath,
+                line: pending.constructionLoc.line,
+                column: pending.constructionLoc.column,
+            },
+        };
+        // First read site: re-attribute every ownership entry in the range
+        // [usageIdxStart, usageIdxEnd) in place via setOwnerAt. Covers both the
+        // root JSX and any nested children.
+        const firstSite = readSites[0];
+        if (!firstSite)
+            continue;
+        for (let i = pending.usageIdxStart; i < pending.usageIdxEnd; i++) {
+            fb.setOwnerAt(i, firstSite.ownerRef, via);
+        }
+        // Additional read sites: clone the entire range. Each clone gets its
+        // own ownership entry attributed to the additional read site's enclosing
+        // component, so nested usages fan out correctly across multiple consumers.
+        for (let s = 1; s < readSites.length; s++) {
+            const site = readSites[s];
+            if (!site)
+                continue;
+            for (let i = pending.usageIdxStart; i < pending.usageIdxEnd; i++) {
+                const snapshot = fb.getJsxUsage(i);
+                if (!snapshot)
+                    continue;
+                fb.addJsxUsage(snapshot);
+                fb.setOwner(site.ownerRef, via);
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Declaration emission
+// ---------------------------------------------------------------------------
+function emitDeclarationFromDeclarator(declr, fb, source, enclosingBinding, isExported = false) {
+    if (declr.id.type !== "Identifier")
+        return;
+    const id = declr.id;
+    const loc = positionAt(source, declr.start);
+    fb.addDeclaration({
+        symbol: id.name,
+        value: inferValue(declr.init ?? null, fb.currentScope(), fb.filePath, enclosingBinding),
+        loc,
+        isExported,
+    });
+}
+function emitVariableDeclaration(node, fb, source, captureValues, emitState) {
+    for (const declr of node.declarations) {
+        if (declr.id.type !== "Identifier") {
+            // Non-Identifier id: try destructure-from-call (#31). Falls through silently
+            // if the init isn't a CallExpression — other destructure shapes are out of
+            // scope for this issue.
+            tryEmitDestructureFromCall(declr, fb, source);
+            continue;
+        }
+        const id = declr.id;
+        const loc = positionAt(source, declr.start);
+        emitDeclarationFromDeclarator(declr, fb, source, { symbol: id.name, file: fb.filePath });
+        if (declr.init != null) {
+            // Unwrap `(...)`-wrapped expressions — oxc preserves ParenthesizedExpression
+            // (Babel strips it). Multi-line JSX inits in real codebases are typically
+            // parens-wrapped; without this, `const X = (<Y/>)` falls through to the
+            // catch-all walk path and bypasses the prop-forward / function-component /
+            // HOC detection below. Loop in case of multiple wraps (`((<Y/>))`).
+            let init = declr.init;
+            while (init.type === "ParenthesizedExpression") {
+                init = init.expression;
+            }
+            const initType = init.type;
+            const ownerRef = { symbol: id.name, scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+            if (initType === "ArrowFunctionExpression" || initType === "FunctionExpression") {
+                // Variable holding a function component — walk its body with this symbol as owner
+                const fnLike = init;
+                const body = fnLike.body;
+                const fnRef = { symbol: id.name, scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+                fb.pushScope();
+                try {
+                    emitParameterBindings(fnLike.params, fnRef, fb, source);
+                    walkJsxIn(body, fb, source, ownerRef, captureValues);
+                    walkBodyCalls(body, fb, source, id.name);
+                }
+                finally {
+                    fb.popScope();
+                }
+            }
+            else if (initType === "CallExpression") {
+                // HOC pattern: const Foo = memo(() => ...) / forwardRef((ref, props) => ...) etc.
+                // Walk the first argument (inner function) body with this symbol as owner,
+                // so JSX inside the HOC wrapper is attributed to the variable name.
+                const call = init;
+                const firstArg = call.arguments[0];
+                if (firstArg && (firstArg.type === "ArrowFunctionExpression" || firstArg.type === "FunctionExpression")) {
+                    const fnLike = firstArg;
+                    const body = fnLike.body;
+                    const fnRef = { symbol: id.name, scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+                    fb.pushScope();
+                    try {
+                        emitParameterBindings(fnLike.params, fnRef, fb, source);
+                        walkJsxIn(body, fb, source, ownerRef, captureValues);
+                        walkBodyCalls(body, fb, source, id.name);
+                    }
+                    finally {
+                        fb.popScope();
+                    }
+                }
+                else {
+                    // Non-HOC call expression — walk with null owner
+                    walkJsxIn(init, fb, source, null, captureValues);
+                }
+            }
+            else if (isJsxTypeInit(initType) && fb.currentScope() === MODULE_SCOPE) {
+                // Module-scope `const X = <JSX/>` — register pending prop-forward
+                // binding before walking so we can re-attribute the owner at file
+                // finalize (#151). Capture clone data at emit time to keep
+                // FileBuilder write-only (apart from the one jsxUsageCount accessor —
+                // documented spec §11 deviation).
+                const rootSymbol = rootSymbolOfJsxInit(init);
+                if (rootSymbol !== null) {
+                    const opening = init.openingElement;
+                    const decomposed = decomposeJsxName(opening.name);
+                    if (decomposed) {
+                        const openingPos = positionAt(source, opening.start);
+                        // Capture the JsxUsage range emitted by walking the init.
+                        // walkJsxIn descends depth-first; the FIRST emitted usage is the
+                        // root JSX. Subsequent usages are nested children (e.g.
+                        // `<Provider><Notification/></Provider>` emits Provider then
+                        // Notification). The full range is re-attributed at finalize.
+                        const usageIdxStart = fb.jsxUsageCount();
+                        walkJsxIn(init, fb, source, null, captureValues);
+                        const usageIdxEnd = fb.jsxUsageCount();
+                        if (usageIdxEnd > usageIdxStart) {
+                            emitState.pendingPropForwardBindings.push({
+                                symbol: id.name,
+                                scope: MODULE_SCOPE,
+                                constructionLoc: loc,
+                                jsxRootLoc: { line: openingPos.line, column: openingPos.column },
+                                usageIdxStart,
+                                usageIdxEnd,
+                            });
+                        }
+                    }
+                    else {
+                        // Couldn't decompose JSX name (namespaced name etc.) — fall back to
+                        // ordinary walk without registration.
+                        walkJsxIn(init, fb, source, null, captureValues);
+                    }
+                }
+                else {
+                    // JSXFragment or other non-JSXElement init — no root symbol to track.
+                    walkJsxIn(init, fb, source, null, captureValues);
+                }
+            }
+            else {
+                // Top-level non-JSX init or non-module-scope — walk with null owner (existing behavior).
+                walkJsxIn(init, fb, source, null, captureValues);
+            }
+        }
+    }
+}
+function emitFunctionDeclaration(node, fb, source, captureValues) {
+    if (!node.id)
+        return;
+    const loc = positionAt(source, node.start);
+    const enclosingBinding = { symbol: node.id.name, file: fb.filePath };
+    fb.addDeclaration({
+        symbol: node.id.name,
+        value: {
+            kind: "Function",
+            returns: extractFunctionReturns(node.body, fb.currentScope(), fb.filePath, enclosingBinding),
+            enclosingBinding,
+        },
+        loc,
+        isExported: false,
+    });
+    if (node.body) {
+        const ownerRef = { symbol: node.id.name, scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+        const fnRef = { symbol: node.id.name, scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+        fb.pushScope();
+        try {
+            emitParameterBindings(node.params, fnRef, fb, source);
+            walkJsxIn(node.body, fb, source, ownerRef, captureValues);
+            walkBodyCalls(node.body, fb, source, node.id.name);
+        }
+        finally {
+            fb.popScope();
+        }
+    }
+}
+function emitClassDeclaration(node, fb, source, captureValues) {
+    if (!node.id)
+        return;
+    const loc = positionAt(source, node.start);
+    const renderReturns = extractClassRenderReturns(node, fb.currentScope(), fb.filePath);
+    fb.addDeclaration({
+        symbol: node.id.name,
+        value: {
+            kind: "Function",
+            returns: renderReturns ?? [{ kind: "JSX" }],
+        },
+        loc,
+        isExported: false,
+    });
+    const ownerRef = { symbol: node.id.name, scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+    fb.pushScope();
+    try {
+        walkJsxIn(node, fb, source, ownerRef, captureValues);
+    }
+    finally {
+        fb.popScope();
+    }
+}
+// ---------------------------------------------------------------------------
+// Export emission
+// ---------------------------------------------------------------------------
+function emitExportNamed(node, fb, source, captureValues, emitState) {
+    const decl = node.declaration;
+    if (decl) {
+        // `export const Foo = ...` / `export function Foo() {}` / `export class Foo {}`
+        let symbolName = null;
+        if (decl.type === "VariableDeclaration") {
+            emitVariableDeclaration(decl, fb, source, captureValues, emitState);
+            // Collect symbol names from declarators to mark as exported
+            for (const d of decl.declarations) {
+                if (d.id.type === "Identifier") {
+                    const name = d.id.name;
+                    // Re-emit with isExported: true (addDeclaration is upsert by key)
+                    emitDeclarationFromDeclarator(d, fb, source, { symbol: name, file: fb.filePath }, true);
+                    fb.addExport({ kind: "named", exportedAs: name, local: name });
+                }
+            }
+            return;
+        }
+        if (decl.type === "FunctionDeclaration" ||
+            decl.type === "TSDeclareFunction") {
+            const fnNode = decl;
+            emitFunctionDeclaration(fnNode, fb, source, captureValues);
+            symbolName = fnNode.id?.name ?? null;
+        }
+        else if (decl.type === "ClassDeclaration" ||
+            decl.type === "ClassExpression") {
+            const classNode = decl;
+            emitClassDeclaration(classNode, fb, source, captureValues);
+            symbolName = classNode.id?.name ?? null;
+        }
+        if (symbolName) {
+            // Re-emit declaration with isExported: true
+            const loc = positionAt(source, decl.start);
+            if (decl.type === "FunctionDeclaration" || decl.type === "TSDeclareFunction") {
+                const fnNode = decl;
+                const enclosingBinding = { symbol: symbolName, file: fb.filePath };
+                fb.addDeclaration({
+                    symbol: symbolName,
+                    value: {
+                        kind: "Function",
+                        returns: extractFunctionReturns(fnNode.body, fb.currentScope(), fb.filePath, enclosingBinding),
+                        enclosingBinding,
+                    },
+                    loc,
+                    isExported: true,
+                });
+            }
+            else if (decl.type === "ClassDeclaration" || decl.type === "ClassExpression") {
+                const classNode = decl;
+                const renderReturns = extractClassRenderReturns(classNode, fb.currentScope(), fb.filePath);
+                fb.addDeclaration({
+                    symbol: symbolName,
+                    value: {
+                        kind: "Function",
+                        returns: renderReturns ?? [{ kind: "JSX" }],
+                    },
+                    loc,
+                    isExported: true,
+                });
+            }
+            fb.addExport({ kind: "named", exportedAs: symbolName, local: symbolName });
+        }
+        return;
+    }
+    // `export { Foo }` or `export { Foo as Bar }` or `export { Foo as Bar } from "./x"`
+    const from = node.source?.value ?? null;
+    for (const spec of node.specifiers) {
+        const localName = spec.local.type === "Identifier"
+            ? spec.local.name
+            : String(spec.local.value);
+        const exportedName = spec.exported.type === "Identifier"
+            ? spec.exported.name
+            : String(spec.exported.value);
+        if (from) {
+            fb.addExport({ kind: "named", exportedAs: exportedName, from, fromImported: localName });
+        }
+        else {
+            fb.addExport({ kind: "named", exportedAs: exportedName, local: localName });
+        }
+    }
+}
+function emitExportDefault(node, fb, source, captureValues) {
+    const decl = node.declaration;
+    if (decl.type === "Identifier") {
+        // `export default Foo` — re-export of a local binding.
+        const local = decl.name;
+        fb.addExport({ kind: "default", local });
+    }
+    else if (decl.type === "FunctionDeclaration" ||
+        decl.type === "TSDeclareFunction") {
+        // `export default function App() { ... }` — named or anonymous.
+        const fnNode = decl;
+        if (fnNode.id) {
+            // Named: treat as a regular function declaration and record the default export.
+            emitFunctionDeclaration(fnNode, fb, source, captureValues);
+            fb.addExport({ kind: "default", local: fnNode.id.name });
+        }
+        else {
+            // Anonymous default export function — attribute JSX to the synthetic "default" symbol.
+            const loc = positionAt(source, node.start);
+            const enclosingBinding = { symbol: "default", file: fb.filePath };
+            fb.addDeclaration({
+                symbol: "default",
+                value: {
+                    kind: "Function",
+                    returns: extractFunctionReturns(fnNode.body, fb.currentScope(), fb.filePath, enclosingBinding),
+                    enclosingBinding,
+                },
+                loc,
+                isExported: true,
+            });
+            fb.addExport({ kind: "default", local: "default" });
+            const ownerRef = { symbol: "default", scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+            if (fnNode.body) {
+                const fnRef = { symbol: "default", scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+                fb.pushScope();
+                try {
+                    emitParameterBindings(fnNode.params, fnRef, fb, source);
+                    walkJsxIn(fnNode.body, fb, source, ownerRef, captureValues);
+                    walkBodyCalls(fnNode.body, fb, source, "default");
+                }
+                finally {
+                    fb.popScope();
+                }
+            }
+        }
+    }
+    else if (decl.type === "ClassDeclaration" ||
+        decl.type === "ClassExpression") {
+        // `export default class App { ... }` — named or anonymous.
+        const classNode = decl;
+        if (classNode.id) {
+            emitClassDeclaration(classNode, fb, source, captureValues);
+            fb.addExport({ kind: "default", local: classNode.id.name });
+        }
+        else {
+            fb.pushScope();
+            try {
+                walkJsxIn(classNode, fb, source, null, captureValues);
+            }
+            finally {
+                fb.popScope();
+            }
+        }
+    }
+    else if (decl.type === "CallExpression") {
+        // `export default withFallback(InnerComponent)` — HOC applied at the
+        // default export site. Mirror the inline form (`const X = withFallback(Y)`
+        // in emitVariableDeclaration above): synthesise a "default" declaration
+        // whose value carries the ReturnTypeOf shape so the engine's wrapper-
+        // folding collapses to the inner-arg identity.
+        const loc = positionAt(source, decl.start);
+        fb.addDeclaration({
+            symbol: "default",
+            value: inferValue(decl, fb.currentScope(), fb.filePath, { symbol: "default", file: fb.filePath }),
+            loc,
+            isExported: true,
+        });
+        fb.addExport({ kind: "default", local: "default" });
+        // Walk JSX inside an anonymous inner arg (e.g. `withFallback(() => <Foo />)`)
+        // with "default" as the owner so nested JSX is attributed correctly.
+        const call = decl;
+        const firstArg = call.arguments[0];
+        if (firstArg &&
+            (firstArg.type === "ArrowFunctionExpression" || firstArg.type === "FunctionExpression")) {
+            const fnLike = firstArg;
+            const body = fnLike.body;
+            const ownerRef = { symbol: "default", scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+            const fnRef = { symbol: "default", scope: MODULE_SCOPE, memberChain: [], loc, originFile: fb.filePath };
+            fb.pushScope();
+            try {
+                emitParameterBindings(fnLike.params, fnRef, fb, source);
+                walkJsxIn(body, fb, source, ownerRef, captureValues);
+                walkBodyCalls(body, fb, source, "default");
+            }
+            finally {
+                fb.popScope();
+            }
+        }
+    }
+    // Other default export shapes (object literals, arrow functions at top level,
+    // etc.) are skipped — no stable name to key ownership on.
+}
+function emitExportAll(node, fb) {
+    fb.addExport({ kind: "star", from: node.source.value });
+}
+//# sourceMappingURL=emit.js.map