@component-compass/parser-react 0.0.2 → 0.0.4

package/dist/walk-jsx.js

@@ -1,111 +1,346 @@
-import { parse } from "@babel/parser";
+import { relative, isAbsolute } from "node:path";
+import { walk } from "oxc-walker";
 import { serialiseComponentId, externalPackageOf } from "@component-compass/plugin-core";
 import { asTagName, asWrapperId } from "@component-compass/plugin-core";
-import { traverse, posixPath, classifyImportOrigin } from "@component-compass/ast-utils";
-// `errorRecovery: true` only handles a narrow band of recoverable parse errors;
-// unrecoverable syntax errors still throw synchronously. Callers must wrap
-// invocations in try/catch and convert thrown errors into PARSE_FAILURE warnings.
-export function walkJsx(opts) {
-    const ast = parse(opts.source, {
-        sourceType: "module",
-        plugins: ["typescript", "jsx", "decorators-legacy", "classProperties"],
-        errorRecovery: true,
+import { posixPath, classifyImportOrigin, positionAt } from "@component-compass/ast-utils";
+// React-API factories whose return value is conventionally a component.
+// Detected by callee identifier name OR `React.<name>` member-expression.
+// Detection is callee-name only — we don't try to verify the factory's
+// return shape.
+const LOCAL_COMPONENT_FACTORIES = new Set(["forwardRef", "memo", "lazy"]);
+// HOC names recognised for owner-binding unwrap (mirrors find-owner.ts).
+const HOC_NAMES = new Set(["memo", "forwardRef", "observer"]);
+/**
+ * Walk a JSXMemberExpression chain to its root identifier, returning the
+ * flat dotted name (e.g. "Tabs.Trigger.Inner") and the root identifier name.
+ * Returns null if the chain bottoms out at anything other than a JSXIdentifier.
+ */
+function readMemberChain(node) {
+    const parts = [];
+    let current = node;
+    while (current.type === "JSXMemberExpression") {
+        parts.unshift(current.property.name);
+        current = current.object;
+    }
+    if (current.type !== "JSXIdentifier")
+        return null;
+    parts.unshift(current.name);
+    return { compoundName: parts.join("."), rootName: current.name };
+}
+/**
+ * Build an opportunistic Occurrence for an unmapped import — used when
+ * `resolveOpening` returns undefined but the root identifier matches an
+ * unmappedImports entry. `tail` is the compound-name suffix after the root
+ * (null for bare `<Foo/>`, "Bar" for `<Foo.Bar/>`, "Bar.Baz" for deeper).
+ *
+ * `unmapped.modulePath` is the package-relative resolved module path when the
+ * lazy resolver landed on a leaf (paired with non-null `leafPackage`); null
+ * otherwise (unresolvable specifier or bare-package fallback through
+ * classifyImportOrigin). The emission threads it onto the external identity
+ * so downstream consumers can disambiguate same-export entries served from
+ * different package subpaths (#63).
+ *
+ * Two terminal paths:
+ *   - `unmapped.leafPackage` set → opaque external occurrence rooted at the
+ *     leaf package; compound usages prefix the tail with the importedName
+ *     (with the `default.` prefix stripped for default-import roots).
+ *   - else → classifyImportOrigin → local-source match against the
+ *     local-index by-path map.
+ */
+function emitOpportunistic(unmapped, tail, opening, opts, source) {
+    const compoundExport = tail === null
+        ? unmapped.importedName
+        : unmapped.importedName === "default"
+            ? tail
+            : `${unmapped.importedName}.${tail}`;
+    const via = { kind: "direct-import", specifier: unmapped.specifier, import: unmapped.importedName };
+    const loc = locOf(opening, opts.file, source);
+    if (unmapped.leafPackage) {
+        const { props, events } = readJsxAttrs(opening, opts.captureValues);
+        return {
+            componentId: {
+                kind: "react-component",
+                export: compoundExport,
+                source: {
+                    type: "external",
+                    package: unmapped.leafPackage,
+                    ...(unmapped.modulePath !== null ? { modulePath: unmapped.modulePath } : {}),
+                },
+            },
+            loc,
+            via,
+            props,
+            events,
+        };
+    }
+    // Fallback: classifyImportOrigin to determine whether the specifier is
+    // external or local. The lazy resolver returns null only for genuinely
+    // unresolvable specifiers or workspace siblings now (identity resolution
+    // always runs for external imports). Distinguish the two cases here:
+    //   - external → emit an opaque occurrence keyed by package name; manifest
+    //     stays null (manifest enrichment and identity resolution are separate)
+    //   - local    → match against the local index (original path below)
+    //   - unresolved → nothing to emit
+    const origin = classifyImportOrigin(unmapped.specifier, {
+        repoRoot: opts.repoRoot,
+        fromFile: opts.file,
     });
+    if (origin.type === "external") {
+        const { props, events } = readJsxAttrs(opening, opts.captureValues);
+        return {
+            componentId: {
+                kind: "react-component",
+                export: compoundExport,
+                source: {
+                    type: "external",
+                    package: origin.package,
+                    ...(unmapped.modulePath !== null ? { modulePath: unmapped.modulePath } : {}),
+                },
+            },
+            loc,
+            via,
+            props,
+            events,
+        };
+    }
+    // Bare-specifier fallback: classifyImportOrigin returns "unresolved" for
+    // workspace-symlinked packages (no node_modules/ segment in the resolved
+    // path, yet outside the fixture root). If the specifier looks like a bare
+    // npm package name, use it directly as the package name — identity is
+    // preserved; manifest stays null.
+    if (origin.type === "unresolved" && isBarePackageSpecifier(unmapped.specifier)) {
+        const pkgName = unmapped.specifier.startsWith("@")
+            ? unmapped.specifier.split("/").slice(0, 2).join("/")
+            : (unmapped.specifier.split("/")[0] ?? unmapped.specifier);
+        const { props, events } = readJsxAttrs(opening, opts.captureValues);
+        return {
+            componentId: {
+                kind: "react-component",
+                export: compoundExport,
+                source: {
+                    type: "external",
+                    package: pkgName,
+                    ...(unmapped.modulePath !== null ? { modulePath: unmapped.modulePath } : {}),
+                },
+            },
+            loc,
+            via,
+            props,
+            events,
+        };
+    }
+    if (origin.type !== "local")
+        return undefined;
+    const localDefs = opts.localIndex.byPath.get(origin.filePath);
+    const matched = localDefs?.find((d) => unmapped.importedName === "default"
+        ? d.isDefault
+        : d.exportName === unmapped.importedName && !d.isDefault);
+    if (!matched || matched.componentId.kind !== "react-component")
+        return undefined;
+    if (tail !== null && matched.componentId.source.type !== "local")
+        return undefined;
+    const { props, events } = readJsxAttrs(opening, opts.captureValues);
+    // For bare usage (tail null): identity is the local def's componentId.
+    // For compound: rebuild with `matched.exportName.tail` (stripping
+    // `default.` for default-exported locals — mirrors the leafPackage path).
+    if (tail === null) {
+        return { componentId: matched.componentId, loc, via, props, events };
+    }
+    const localCompoundExport = matched.exportName === "default" ? tail : `${matched.exportName}.${tail}`;
+    return {
+        componentId: {
+            kind: "react-component",
+            export: localCompoundExport,
+            source: matched.componentId.source,
+        },
+        loc,
+        via,
+        props,
+        events,
+    };
+}
+// Pre-parsed oxc Program is supplied by scan.ts (single source of truth for
+// parsing). Tasks 1-7 of Phase C swapped parsing to oxc-parser; this walker
+// drives off the resulting Program node. Recovered parse errors land on the
+// raw ParseResult.errors field upstream — oxc-parser carries them on the
+// result, not the Program, so they are warned at parse time and not
+// re-emitted here.
+export function walkJsx(opts) {
+    const program = opts.ast;
+    const source = opts.source;
     const occurrences = [];
     const wrappers = [];
     const imports = [];
     const warnings = [];
-    const recovered = ast.errors ?? [];
-    for (const err of recovered) {
-        warnings.push({
-            code: "PARSE_FAILURE",
-            message: `Recovered parse error: ${err.message}`,
-            file: opts.file,
-            // line: 0 means "unknown" when Babel didn't supply a location.
-            line: typeof err.loc?.line === "number" ? err.loc.line : 0,
-        });
-    }
     const localBindings = new Map();
-    // Tracks imports that did NOT match a manifest entry: local → { importedName, specifier, leafPackage }.
-    // `leafPackage` is non-null when the lazy resolver landed on a leaf package
-    // but had no manifest entry for `importedName` — in that case the third pass
-    // attributes the opaque external occurrence to the leaf rather than re-running
-    // origin classification on the user-written aggregator specifier.
+    // Tracks imports that did NOT match a manifest entry: local → { importedName,
+    // specifier, leafPackage, modulePath }. `leafPackage` is non-null when the
+    // lazy resolver landed on a leaf package but had no manifest entry for
+    // `importedName` — in that case the third pass attributes the opaque external
+    // occurrence to the leaf rather than re-running origin classification on the
+    // user-written aggregator specifier. `modulePath` is the package-relative
+    // resolved path (paired with `leafPackage`); null when the resolver returned
+    // no hit, threaded onto the external identity by the JSX-emission pass.
     const unmappedImports = new Map();
-    // First pass: collect imports and resolve via the lazy manifest resolver.
-    traverse(ast, {
-        ImportDeclaration(path) {
-            const source = path.node.source.value;
-            if (path.node.specifiers.length === 0) {
-                // Side-effect import: `import "pkg"`. Prime the resolver's leaf cache
-                // so later HTML / Lit-template tag references find the leaf's CEM
-                // even though no JS-side identifier was ever bound. The empty
-                // exportName won't match anything in matchInLeaf, but the call still
-                // walks into the leaf and populates byTag for tag-only consumers.
-                opts.resolveLazyManifest(opts.file, source, "");
+    // ── Pass 1: collect imports + local Context / factory bindings ──────────
+    // Single pre-pass over the program populates `localBindings` and
+    // `unmappedImports` so the wrapper-detection (pass 2) and JSX-emission
+    // (pass 3) passes have a complete view of what's bound.
+    walk(program, {
+        enter(node) {
+            if (node.type === "VariableDeclarator") {
+                collectLocalVarBinding(node, localBindings);
                 return;
             }
-            for (const spec of path.node.specifiers) {
-                if (spec.type !== "ImportSpecifier" && spec.type !== "ImportDefaultSpecifier")
-                    continue;
-                const imported = spec.type === "ImportSpecifier" ? identName(spec.imported) : "default";
-                const local = spec.local.name;
-                const hit = opts.resolveLazyManifest(opts.file, source, imported);
-                if (hit?.matched?.kind === "custom-element") {
-                    localBindings.set(local, {
-                        kind: "wc-wrapper",
-                        tagName: asTagName(hit.matched.tagName),
-                        package: hit.leafPackage,
-                        specifier: source,
-                        importName: imported,
-                    });
-                }
-                else if (hit?.matched?.kind === "react-component") {
-                    localBindings.set(local, {
-                        kind: "react-direct",
-                        package: hit.leafPackage,
-                        export: hit.matched.export,
-                        specifier: source,
-                        importName: imported,
-                    });
-                }
-                else if (hit) {
-                    // Resolver landed on a leaf but no manifest match → opaque external bound to leaf.
-                    unmappedImports.set(local, {
-                        importedName: imported,
-                        specifier: source,
-                        leafPackage: hit.leafPackage,
-                    });
-                }
-                else {
-                    // Specifier did not resolve (could be local relative or unresolvable).
-                    unmappedImports.set(local, {
-                        importedName: imported,
-                        specifier: source,
-                        leafPackage: null,
-                    });
-                }
-                imports.push({ file: posixPath(opts.file), imported: local, source, loc: locOf(spec, opts.file) });
+            if (node.type === "ImportDeclaration") {
+                collectImportBindings(node, opts, localBindings, unmappedImports, imports, source);
             }
         },
     });
-    // Second pass: detect wrapper definitions.
-    traverse(ast, {
-        Function(path) {
-            detectWrapper(path, opts.file, localBindings, opts.lookupByTag, wrappers);
+    const wrapperStack = [];
+    const ancestorMap = new WeakMap();
+    const parentOf = (n) => ancestorMap.get(n) ?? null;
+    walk(program, {
+        enter(node, parent) {
+            if (parent)
+                ancestorMap.set(node, parent);
+            const candidate = wrapperCandidate(node, parent ?? null, program, parentOf);
+            if (candidate)
+                wrapperStack.push(candidate);
+            if (node.type === "JSXOpeningElement") {
+                const frame = wrapperStack[wrapperStack.length - 1];
+                if (frame)
+                    collectWrapperDep(node, localBindings, opts.lookupByTag, frame);
+            }
         },
-        ClassDeclaration(path) {
-            detectWrapper(path, opts.file, localBindings, opts.lookupByTag, wrappers);
+        leave(node) {
+            const top = wrapperStack[wrapperStack.length - 1];
+            if (top && top.node === node) {
+                wrapperStack.pop();
+                if (top.deps.length > 0) {
+                    wrappers.push({
+                        id: wrapperId(top.name),
+                        name: top.name,
+                        file: posixPath(opts.file),
+                        exportName: top.exportName,
+                        componentDeps: top.deps,
+                    });
+                }
+            }
         },
     });
     /** Topmost element is the current tracked parent. node is kept for matched
      *  pop on exit (depth-first traversal guarantees the topmost stack entry is
      *  the current node when its exit handler fires). */
     const parentStack = [];
+    const renderPropStack = [];
+    const ownerStack = [];
     function resolveOpening(opening) {
         const nameNode = opening.name;
-        if (nameNode.type !== "JSXIdentifier")
+        const start = opening.start;
+        const loc = typeof start === "number" ? positionAt(source, start) : { line: 1, column: 0 };
+        if (nameNode.type === "JSXMemberExpression") {
+            const chain = readMemberChain(nameNode);
+            if (!chain) {
+                opts.collector?.emit({
+                    code: "jsx-shape-unsupported",
+                    severity: "warning",
+                    filePath: opts.file,
+                    line: loc.line,
+                    column: loc.column,
+                    nameType: "JSXMemberExpression-malformed",
+                    detail: "member chain did not bottom out at JSXIdentifier",
+                });
+                return undefined;
+            }
+            if (/^[a-z]/.test(chain.rootName)) {
+                opts.collector?.emit({
+                    code: "jsx-shape-unsupported",
+                    severity: "warning",
+                    filePath: opts.file,
+                    line: loc.line,
+                    column: loc.column,
+                    nameType: "JSXMemberExpression-lowercase-root",
+                    detail: `lowercase root identifier "${chain.rootName}" cannot be a React component`,
+                });
+                return undefined;
+            }
+            const bound = localBindings.get(chain.rootName);
+            if (bound) {
+                // Compound subcomponents always emit as react-component, regardless of
+                // whether the root binding is react-direct or wc-wrapper. The WC-wrapper
+                // folding rule applies only to bare root usage (<Tabs />), never to
+                // compound subcomponents (<Tabs.Trigger />).
+                if (bound.kind === "local-context") {
+                    // `<MyContext.Provider>` / `<MyContext.Consumer>` is access to a
+                    // member of a React Context object, not a separate component
+                    // definition. Skip emission so the artifact doesn't gain a spurious
+                    // `MyContext.Provider` component identity without a real binding site.
+                    return undefined;
+                }
+                if (bound.kind === "local-component") {
+                    // Compound usage of a local var-bound component (e.g. forwardRef'd
+                    // root with static subcomponents attached: `<Button.Header />`).
+                    // Full compound name preserves the access pattern so subcomponents
+                    // surface as distinct identities under the same local-source root.
+                    return { kind: "local-component", export: chain.compoundName };
+                }
+                if (bound.kind === "react-namespace") {
+                    // `import * as Foo from "pkg"` — strip the namespace alias and emit
+                    // the tail as the package's actual export. `via.import` (set in the
+                    // emission step) preserves the local namespace alias so consumers
+                    // can still distinguish namespace-style access from named imports.
+                    // Namespace imports don't trigger per-export resolver hits, so
+                    // modulePath is unknown at this access point.
+                    const tail = chain.compoundName.slice(chain.rootName.length + 1);
+                    return {
+                        kind: "react-direct",
+                        package: bound.package,
+                        export: tail,
+                        specifier: bound.specifier,
+                        importName: bound.importName,
+                        modulePath: null,
+                    };
+                }
+                return {
+                    kind: "react-direct",
+                    package: bound.package,
+                    export: chain.compoundName,
+                    specifier: bound.specifier,
+                    importName: bound.importName,
+                    modulePath: bound.modulePath,
+                };
+            }
+            // Root unbound. If the root matches an unmapped import, skip the
+            // diagnostic — the JSX-element opportunistic block will attempt to emit
+            // an opaque external (or local-source) occurrence using the unmapped
+            // binding. Symmetric with the single-identifier branch which is silent
+            // on unmapped misses.
+            if (!unmappedImports.has(chain.rootName)) {
+                opts.collector?.emit({
+                    code: "jsx-shape-unsupported",
+                    severity: "warning",
+                    filePath: opts.file,
+                    line: loc.line,
+                    column: loc.column,
+                    nameType: "JSXMemberExpression-unbound-root",
+                    detail: `compound JSX with unbound root "${chain.rootName}"`,
+                });
+            }
+            return undefined;
+        }
+        if (nameNode.type !== "JSXIdentifier") {
+            opts.collector?.emit({
+                code: "jsx-shape-unsupported",
+                severity: "warning",
+                filePath: opts.file,
+                line: loc.line,
+                column: loc.column,
+                nameType: nameNode.type,
+                detail: `unhandled JSX element name type: ${nameNode.type}`,
+            });
             return undefined;
+        }
         const id = nameNode.name;
         if (/^[a-z]/.test(id) && id.includes("-")) {
             const indexed = opts.lookupByTag(asTagName(id));
@@ -131,128 +366,573 @@ export function walkJsx(opts) {
                 export: bound.export,
                 specifier: bound.specifier,
                 importName: bound.importName,
+                modulePath: bound.modulePath,
             };
         }
+        if (bound?.kind === "local-component") {
+            return { kind: "local-component", export: id };
+        }
         return undefined;
     }
-    traverse(ast, {
-        JSXElement: {
-            enter(path) {
-                const opening = path.node.openingElement;
-                const resolved = resolveOpening(opening);
-                let occurrence;
-                if (!resolved) {
-                    // Opportunistic emission for unmapped imports (preserves Phase 1 behaviour).
-                    const nameNode = opening.name;
-                    if (nameNode.type === "JSXIdentifier") {
-                        const id = nameNode.name;
-                        if (!/^[a-z]/.test(id) || !id.includes("-")) {
-                            const unmapped = unmappedImports.get(id);
-                            if (unmapped) {
-                                if (unmapped.leafPackage) {
-                                    const { props, events } = readJsxAttrs(opening, opts.captureValues);
-                                    occurrence = {
-                                        componentId: {
-                                            kind: "react-component",
-                                            export: unmapped.importedName,
-                                            source: { type: "external", package: unmapped.leafPackage },
-                                        },
-                                        loc: locOf(opening, opts.file),
-                                        via: { kind: "direct-import", specifier: unmapped.specifier, import: unmapped.importedName },
-                                        props,
-                                        events,
-                                    };
-                                }
-                                else {
-                                    const origin = classifyImportOrigin(unmapped.specifier, {
-                                        repoRoot: opts.repoRoot,
-                                        fromFile: opts.file,
-                                    });
-                                    if (origin.type === "local") {
-                                        const localDefs = opts.localIndex.byPath.get(origin.filePath);
-                                        const matched = localDefs?.find((d) => unmapped.importedName === "default"
-                                            ? d.isDefault
-                                            : d.exportName === unmapped.importedName && !d.isDefault);
-                                        if (matched && matched.componentId.kind === "react-component") {
-                                            const { props, events } = readJsxAttrs(opening, opts.captureValues);
-                                            occurrence = {
-                                                componentId: matched.componentId,
-                                                loc: locOf(opening, opts.file),
-                                                via: { kind: "direct-import", specifier: unmapped.specifier, import: unmapped.importedName },
-                                                props,
-                                                events,
-                                            };
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
+    // Render-prop guard: true iff the topmost render-prop frame was pushed
+    // AFTER its lexical parent JSX was entered. The parent JSX adds 1 to
+    // parentStack.length on enter; if the render-prop frame was pushed when
+    // parentStack.length was >= the current value, no JSX was emitted since
+    // — meaning the render-prop scope opened inside the parent's subtree.
+    // (When called, `parentNode` is the topmost parentStack entry.)
+    const isInRenderPropScopeOxc = (parentNode) => {
+        if (!parentNode)
+            return false;
+        const top = renderPropStack[renderPropStack.length - 1];
+        return top !== undefined && top.depthAtPush >= parentStack.length;
+    };
+    walk(program, {
+        enter(node, parent) {
+            // ── Owner-attribution frame push ──────────────────────────────────
+            if (isOwnerCandidateNode(node)) {
+                const grand = parent ? parentOf(parent) : null;
+                ownerStack.push({ node, parent: parent ?? null, grand });
+            }
+            // ── Render-prop scope push ─────────────────────────────────────────
+            // Function bodies and JSXAttribute values open a render-prop boundary.
+            // Tracked at enter so parent-stack maintenance can read them at JSX time.
+            if (node.type === "ArrowFunctionExpression" ||
+                node.type === "FunctionExpression" ||
+                node.type === "FunctionDeclaration" ||
+                node.type === "JSXAttribute") {
+                renderPropStack.push({ node, depthAtPush: parentStack.length });
+            }
+            if (node.type !== "JSXElement")
+                return;
+            const jsxNode = node;
+            const opening = jsxNode.openingElement;
+            const resolved = resolveOpening(opening);
+            let occurrence;
+            if (!resolved) {
+                // Opportunistic emission for unmapped imports (preserves Phase 1
+                // behaviour). Determine the unmapped root + compound tail (if any),
+                // then delegate to emitOpportunistic — single-id and compound paths
+                // share leafPackage → opaque-external and classifyImportOrigin →
+                // local-source resolution.
+                const nameNode = opening.name;
+                let rootId = null;
+                let tail = null;
+                if (nameNode.type === "JSXIdentifier") {
+                    const id = nameNode.name;
+                    if (!/^[a-z]/.test(id) || !id.includes("-"))
+                        rootId = id;
                 }
-                else {
-                    const { props, events } = readJsxAttrs(opening, opts.captureValues);
-                    const loc = locOf(opening, opts.file);
-                    if (resolved.kind === "wc-tag") {
-                        occurrence = {
-                            componentId: { kind: "custom-element", tagName: resolved.tagName, source: { type: "external", package: resolved.package } },
-                            loc,
-                            via: { kind: "html-tag" },
-                            props,
-                            events,
-                        };
+                else if (nameNode.type === "JSXMemberExpression") {
+                    const chain = readMemberChain(nameNode);
+                    if (chain && !/^[a-z]/.test(chain.rootName)) {
+                        rootId = chain.rootName;
+                        tail = chain.compoundName.slice(chain.rootName.length + 1);
                     }
-                    else if (resolved.kind === "wc-wrapper") {
-                        occurrence = {
-                            componentId: { kind: "custom-element", tagName: resolved.tagName, source: { type: "external", package: resolved.package } },
-                            loc,
-                            via: { kind: "react-wrapper", specifier: resolved.specifier, import: resolved.importName },
-                            props,
-                            events,
-                        };
-                    }
-                    else {
-                        occurrence = {
-                            componentId: { kind: "react-component", export: resolved.export, source: { type: "external", package: resolved.package } },
-                            loc,
-                            via: { kind: "direct-import", specifier: resolved.specifier, import: resolved.importName },
-                            props,
-                            events,
-                        };
+                }
+                if (rootId !== null) {
+                    const unmapped = unmappedImports.get(rootId);
+                    if (unmapped) {
+                        occurrence = emitOpportunistic(unmapped, tail, opening, opts, source);
                     }
                 }
-                if (!occurrence)
-                    return;
-                const parentEntry = parentStack[parentStack.length - 1];
-                if (parentEntry && !isInRenderPropScope(path, parentEntry.node)) {
-                    occurrence.parentRef = parentEntry.idx;
-                    occurrence.depth = parentStack.length;
+            }
+            else {
+                const { props, events } = readJsxAttrs(opening, opts.captureValues);
+                const loc = locOf(opening, opts.file, source);
+                if (resolved.kind === "wc-tag") {
+                    occurrence = {
+                        componentId: { kind: "custom-element", tagName: resolved.tagName, source: { type: "external", package: resolved.package } },
+                        loc,
+                        via: { kind: "html-tag" },
+                        props,
+                        events,
+                    };
+                }
+                else if (resolved.kind === "wc-wrapper") {
+                    occurrence = {
+                        componentId: { kind: "custom-element", tagName: resolved.tagName, source: { type: "external", package: resolved.package } },
+                        loc,
+                        via: { kind: "react-wrapper", specifier: resolved.specifier, import: resolved.importName },
+                        props,
+                        events,
+                    };
+                }
+                else if (resolved.kind === "local-context") {
+                    occurrence = {
+                        componentId: {
+                            kind: "react-component",
+                            export: resolved.export,
+                            source: { type: "local", filePath: posixPath(opts.file) },
+                        },
+                        loc,
+                        via: { kind: "context-provider" },
+                        props,
+                        events,
+                    };
+                }
+                else if (resolved.kind === "local-component") {
+                    occurrence = {
+                        componentId: {
+                            kind: "react-component",
+                            export: resolved.export,
+                            source: { type: "local", filePath: posixPath(opts.file) },
+                        },
+                        loc,
+                        via: { kind: "local-component" },
+                        props,
+                        events,
+                    };
                 }
                 else {
-                    // Render-prop scope OR no parent: treated as fresh root in this lexical scope.
-                    occurrence.depth = 0;
+                    occurrence = {
+                        componentId: {
+                            kind: "react-component",
+                            export: resolved.export,
+                            source: {
+                                type: "external",
+                                package: resolved.package,
+                                ...(resolved.modulePath !== null ? { modulePath: resolved.modulePath } : {}),
+                            },
+                        },
+                        loc,
+                        via: { kind: "direct-import", specifier: resolved.specifier, import: resolved.importName },
+                        props,
+                        events,
+                    };
                 }
-                const idx = occurrences.length;
-                occurrences.push(occurrence);
-                parentStack.push({ idx, node: path.node });
-            },
-            exit(path) {
-                const top = parentStack[parentStack.length - 1];
-                if (top && top.node === path.node)
-                    parentStack.pop();
-            },
+            }
+            if (!occurrence)
+                return;
+            const parentEntry = parentStack[parentStack.length - 1];
+            if (parentEntry && !isInRenderPropScopeOxc(parentEntry.node)) {
+                occurrence.parentRef = parentEntry.idx;
+                occurrence.depth = parentStack.length;
+            }
+            else {
+                // Render-prop scope OR no parent: treated as fresh root in this lexical scope.
+                occurrence.depth = 0;
+            }
+            const owner = resolveOwnerFromStack(ownerStack, opts.localIndex, opts.file, opts.repoRoot);
+            if (owner !== undefined) {
+                occurrence.ownerComponentId = owner;
+            }
+            const idx = occurrences.length;
+            occurrences.push(occurrence);
+            parentStack.push({ idx, node: jsxNode });
+        },
+        leave(node) {
+            // Pop owner frame first (it's a subset of structural frames).
+            const topOwner = ownerStack[ownerStack.length - 1];
+            if (topOwner && topOwner.node === node)
+                ownerStack.pop();
+            // Pop render-prop frame for function/attribute boundaries we entered.
+            if (node.type === "ArrowFunctionExpression" ||
+                node.type === "FunctionExpression" ||
+                node.type === "FunctionDeclaration" ||
+                node.type === "JSXAttribute") {
+                const topRp = renderPropStack[renderPropStack.length - 1];
+                if (topRp && topRp.node === node)
+                    renderPropStack.pop();
+            }
+            if (node.type !== "JSXElement")
+                return;
+            const top = parentStack[parentStack.length - 1];
+            if (top && top.node === node)
+                parentStack.pop();
         },
     });
     return { occurrences, wrappers, imports, warnings };
 }
-function locOf(node, file) {
+// ── Helpers ──────────────────────────────────────────────────────────────
+function isOwnerCandidateNode(node) {
+    return (node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression" ||
+        node.type === "ArrowFunctionExpression" ||
+        node.type === "ClassDeclaration" ||
+        node.type === "ClassExpression");
+}
+/**
+ * Resolve the nearest enclosing component-binding from the owner frame
+ * stack. Walks innermost-to-outermost; first match wins. Filters via the
+ * local-index so non-exported component-shaped functions don't receive
+ * owner attribution (matches the babel walker's predicate behaviour, where
+ * `resolveOwnerComponentId` consults the local index's by-path entries).
+ */
+function resolveOwnerFromStack(ownerStack, localIndex, filePath, repoRoot) {
+    // localIndex.byPath uses repo-root-relative POSIX keys; filePath is absolute.
+    const relPath = isAbsolute(filePath) ? posixPath(relative(repoRoot, filePath)) : filePath;
+    const defs = localIndex.byPath.get(relPath) ?? [];
+    const knownExportNames = new Set(defs.map((d) => d.exportName));
+    const isKnown = (name) => knownExportNames.has(name);
+    for (let i = ownerStack.length - 1; i >= 0; i--) {
+        const frame = ownerStack[i];
+        if (!frame)
+            continue;
+        const binding = bindingForOwnerFrame(frame.node, frame.parent, frame.grand, isKnown);
+        if (binding) {
+            return {
+                kind: "react-component",
+                export: binding.name,
+                source: { type: "local", filePath: posixPath(filePath) },
+            };
+        }
+    }
+    return undefined;
+}
+function bindingForOwnerFrame(node, parent, grand, isKnown) {
+    // class Name { … }
+    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+        const cls = node;
+        const id = cls.id;
+        if (id && isPascalCase(id.name)) {
+            if (isKnown(id.name)) {
+                return { name: id.name, isDefault: false };
+            }
+        }
+        if (parent?.type === "ExportDefaultDeclaration") {
+            if (isKnown("default")) {
+                return { name: "default", isDefault: true };
+            }
+        }
+        return null;
+    }
+    // function Name() { … }
+    if (node.type === "FunctionDeclaration") {
+        const fn = node;
+        const id = fn.id;
+        if (parent?.type === "ExportDefaultDeclaration") {
+            const name = id && isPascalCase(id.name) ? id.name : "default";
+            if (isKnown(name)) {
+                return { name, isDefault: true };
+            }
+        }
+        if (id && isPascalCase(id.name)) {
+            if (isKnown(id.name)) {
+                return { name: id.name, isDefault: false };
+            }
+        }
+        return null;
+    }
+    // (...) => …  /  function () { … }  (anonymous), examined by its context.
+    if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+        return bindingFromAnonymousFunctionParent(parent, grand, isKnown);
+    }
+    return null;
+}
+function bindingFromAnonymousFunctionParent(parent, grand, isKnown) {
+    if (!parent)
+        return null;
+    if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+        return bindingFromVariableId(parent.id.name, isKnown);
+    }
+    if (parent.type === "CallExpression" && isHocCallOxc(parent)) {
+        if (!grand)
+            return null;
+        if (grand.type === "VariableDeclarator" && grand.id.type === "Identifier") {
+            return bindingFromVariableId(grand.id.name, isKnown);
+        }
+        if (grand.type === "ExportDefaultDeclaration") {
+            if (isKnown("default")) {
+                return { name: "default", isDefault: true };
+            }
+        }
+        return null;
+    }
+    if (parent.type === "ExportDefaultDeclaration") {
+        if (isKnown("default")) {
+            return { name: "default", isDefault: true };
+        }
+    }
+    return null;
+}
+function bindingFromVariableId(name, isKnown) {
+    if (!isPascalCase(name))
+        return null;
+    if (!isKnown(name))
+        return null;
+    return { name, isDefault: false };
+}
+function isHocCallOxc(call) {
+    if (call.type !== "CallExpression")
+        return false;
+    const callee = call.callee;
+    if (callee.type === "Identifier")
+        return HOC_NAMES.has(callee.name);
+    if (callee.type === "MemberExpression" &&
+        callee.object.type === "Identifier" &&
+        callee.object.name === "React" &&
+        callee.property.type === "Identifier") {
+        return HOC_NAMES.has(callee.property.name);
+    }
+    return false;
+}
+function isPascalCase(name) {
+    return /^[A-Z]/.test(name);
+}
+function collectLocalVarBinding(node, localBindings) {
+    // Detect var bindings whose initializer is a known React-API call:
+    //   - `const X = createContext(...)` / `React.createContext(...)`
+    //   - `const X = forwardRef(...)` / `memo(...)` / `lazy(...)` (and React.* variants)
+    // Scope-agnostic — any binding to a recognised callee gets tracked. The
+    // identity downstream uses `source: { type: "local", filePath }`, so two
+    // identically-named bindings in different files do not collide.
+    if (!node.init || node.init.type !== "CallExpression")
+        return;
+    if (node.id.type !== "Identifier")
+        return;
+    const call = node.init;
+    const callee = call.callee;
+    const localName = node.id.name;
+    const isCreateContext = (callee.type === "Identifier" && callee.name === "createContext") ||
+        (callee.type === "MemberExpression" &&
+            !callee.computed &&
+            callee.property.type === "Identifier" &&
+            callee.property.name === "createContext");
+    if (isCreateContext) {
+        localBindings.set(localName, { kind: "local-context", localName });
+        return;
+    }
+    const factoryName = callee.type === "Identifier"
+        ? callee.name
+        : callee.type === "MemberExpression" &&
+            !callee.computed &&
+            callee.property.type === "Identifier"
+            ? callee.property.name
+            : null;
+    if (factoryName && LOCAL_COMPONENT_FACTORIES.has(factoryName)) {
+        localBindings.set(localName, { kind: "local-component", localName });
+    }
+}
+function collectImportBindings(decl, opts, localBindings, unmappedImports, imports, source) {
+    const specifier = decl.source.value;
+    if (decl.specifiers.length === 0) {
+        // Side-effect import: `import "pkg"`. Prime the resolver's leaf cache
+        // so later HTML / Lit-template tag references find the leaf's CEM
+        // even though no JS-side identifier was ever bound. The empty
+        // exportName won't match anything in matchInLeaf, but the call still
+        // walks into the leaf and populates byTag for tag-only consumers.
+        opts.resolveLazyManifest(opts.file, specifier, "");
+        return;
+    }
+    for (const spec of decl.specifiers) {
+        if (spec.type === "ImportNamespaceSpecifier") {
+            // Namespace imports skip the lazy resolver — there's no specific
+            // exportName to resolve until a compound JSX usage picks one out.
+            // Record the binding so the compound branch in `resolveOpening` can
+            // emit the tail as the export name. `package` is the user-written
+            // specifier; aggregator-following for namespace imports would
+            // require a separate resolver pass and is deferred.
+            const nsSpec = spec;
+            const local = nsSpec.local.name;
+            localBindings.set(local, {
+                kind: "react-namespace",
+                package: specifier,
+                specifier,
+                importName: local,
+            });
+            imports.push({ file: posixPath(opts.file), imported: local, source: specifier, loc: locOf(spec, opts.file, source) });
+            continue;
+        }
+        if (spec.type !== "ImportSpecifier" && spec.type !== "ImportDefaultSpecifier")
+            continue;
+        const importSpec = spec;
+        const imported = spec.type === "ImportSpecifier" ? importedName(spec.imported) : "default";
+        const local = importSpec.local.name;
+        const hit = opts.resolveLazyManifest(opts.file, specifier, imported);
+        if (hit?.matched?.kind === "custom-element") {
+            localBindings.set(local, {
+                kind: "wc-wrapper",
+                tagName: asTagName(hit.matched.tagName),
+                package: hit.leafPackage,
+                specifier,
+                importName: imported,
+                modulePath: hit.modulePath,
+            });
+        }
+        else if (hit?.matched?.kind === "react-component") {
+            localBindings.set(local, {
+                kind: "react-direct",
+                package: hit.leafPackage,
+                export: hit.matched.export,
+                specifier,
+                importName: imported,
+                modulePath: hit.modulePath,
+            });
+        }
+        else if (hit) {
+            // Resolver landed on a leaf but no manifest match → opaque external bound to leaf.
+            unmappedImports.set(local, {
+                importedName: imported,
+                specifier,
+                leafPackage: hit.leafPackage,
+                modulePath: hit.modulePath,
+            });
+        }
+        else {
+            // Specifier did not resolve (could be local relative or unresolvable).
+            unmappedImports.set(local, {
+                importedName: imported,
+                specifier,
+                leafPackage: null,
+                modulePath: null,
+            });
+        }
+        imports.push({ file: posixPath(opts.file), imported: local, source: specifier, loc: locOf(spec, opts.file, source) });
+    }
+}
+function wrapperCandidate(node, parent, program, parentOf) {
+    // Function / class declarations with a PascalCase id, or an
+    // arrow/function-expr assigned to a PascalCase var. Anonymous bindings
+    // outside those patterns aren't tracked — they can't have an exportable
+    // wrapper name.
+    let name = null;
+    if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+        const id = node.id;
+        if (id && isPascalCase(id.name))
+            name = id.name;
+    }
+    else if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") &&
+        parent?.type === "VariableDeclarator" &&
+        parent.id.type === "Identifier" &&
+        isPascalCase(parent.id.name)) {
+        name = parent.id.name;
+    }
+    if (name === null)
+        return null;
+    return {
+        node,
+        name,
+        exportName: detectExportName(parent, program, parentOf, name),
+        deps: [],
+        seen: new Set(),
+    };
+}
+function detectExportName(parent, program, parentOf, declName) {
+    // Direct containment: walk up via the pre-built ancestor map. oxc does
+    // not auto-populate node.parent, so we thread parentOf through here.
+    for (let p = parent; p; p = parentOf(p)) {
+        if (p.type === "ExportDefaultDeclaration")
+            return "default";
+        if (p.type === "ExportNamedDeclaration")
+            return declName;
+    }
+    // Indirect: a separate `export default Foo;` or `export { Foo as Bar };`
+    // references this declaration by name. Scan the top-level program body.
+    for (const stmt of program.body) {
+        if (stmt.type === "ExportDefaultDeclaration" &&
+            stmt.declaration.type === "Identifier" &&
+            stmt.declaration.name === declName) {
+            return "default";
+        }
+        if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) {
+            for (const spec of stmt.specifiers) {
+                if (spec.type !== "ExportSpecifier")
+                    continue;
+                if (spec.local.type !== "Identifier" || spec.local.name !== declName)
+                    continue;
+                if (spec.exported.type === "Identifier" && spec.exported.name === "default") {
+                    return "default";
+                }
+                if (spec.exported.type === "Identifier")
+                    return spec.exported.name;
+                return declName;
+            }
+        }
+    }
+    return declName;
+}
+function collectWrapperDep(opening, localBindings, lookupByTag, frame) {
+    const n = opening.name;
+    function addDep(cid) {
+        const key = serialiseComponentId(cid);
+        if (!frame.seen.has(key)) {
+            frame.seen.add(key);
+            frame.deps.push(cid);
+        }
+    }
+    if (n.type === "JSXMemberExpression") {
+        const chain = readMemberChain(n);
+        if (!chain)
+            return;
+        if (/^[a-z]/.test(chain.rootName))
+            return;
+        const bound = localBindings.get(chain.rootName);
+        if (!bound)
+            return;
+        // Locally-declared bindings (Context, var-bound components) are not
+        // external component deps the wrapper "wraps". Skip.
+        if (bound.kind === "local-context" || bound.kind === "local-component")
+            return;
+        // Namespace imports: tail is the package's actual export — strip the
+        // local namespace alias so the wrapper dep records the same export
+        // identity downstream consumers see for non-namespace access patterns.
+        // Namespace bindings have no per-export resolver hit, so modulePath stays
+        // unset on the wrapper-dep identity.
+        const exportName = bound.kind === "react-namespace"
+            ? chain.compoundName.slice(chain.rootName.length + 1)
+            : chain.compoundName;
+        const modulePath = bound.kind === "react-namespace" ? null : bound.modulePath;
+        addDep({
+            kind: "react-component",
+            export: exportName,
+            source: {
+                type: "external",
+                package: bound.package,
+                ...(modulePath !== null ? { modulePath } : {}),
+            },
+        });
+        return;
+    }
+    if (n.type !== "JSXIdentifier")
+        return;
+    const id = n.name;
+    if (/^[a-z]/.test(id) && id.includes("-")) {
+        const indexed = lookupByTag(asTagName(id));
+        if (indexed) {
+            addDep({
+                kind: "custom-element",
+                tagName: asTagName(id),
+                source: { type: "external", package: externalPackageOf(indexed.source) },
+            });
+        }
+        return;
+    }
+    const bound = localBindings.get(id);
+    // Only WC-wrapper bindings count as wrapper component-deps; React-direct
+    // bindings refer to other React components, which are not WC-wrappers.
+    if (bound && bound.kind === "wc-wrapper") {
+        addDep({
+            kind: "custom-element",
+            tagName: bound.tagName,
+            source: { type: "external", package: bound.package },
+        });
+    }
+}
+function wrapperId(name) {
+    const kebab = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    return asWrapperId(`wrap-${kebab}`);
+}
+// ── Position / attribute helpers ────────────────────────────────────────
+function locOf(node, file, source) {
+    const start = node.start;
+    if (typeof start !== "number") {
+        return { file: posixPath(file), line: 1, column: 1 };
+    }
+    const pos = positionAt(source, start);
     return {
         file: posixPath(file),
-        line: node.loc?.start?.line ?? 1,
-        column: (node.loc?.start?.column ?? 0) + 1,
+        line: pos.line,
+        // babel emits 1-indexed columns at the call sites that read `loc.column`,
+        // matching the visible offset. positionAt returns 0-indexed columns; +1
+        // aligns with the historical babel output the artifact expects.
+        column: pos.column + 1,
     };
 }
-function identName(node) {
-    return node.type === "Identifier" ? node.name : node.value;
+function importedName(node) {
+    if (node.type === "Identifier")
+        return node.name ?? "";
+    // StringLiteral path for `import { "weird name" as X }`.
+    return node.value ?? "";
 }
 function readJsxAttrs(node, captureValues) {
     const props = [];
@@ -269,7 +949,9 @@ function readJsxAttrs(node, captureValues) {
         }
         if (attr.type !== "JSXAttribute")
             continue;
-        const name = attr.name.type === "JSXIdentifier" ? attr.name.name : "";
+        const jsxAttr = attr;
+        const nameNode = jsxAttr.name;
+        const name = nameNode.type === "JSXIdentifier" ? nameNode.name : "";
         if (!name)
             continue;
         // React event handlers are conventionally `on<Event>` props on the JSX side.
@@ -277,7 +959,7 @@ function readJsxAttrs(node, captureValues) {
             events.push(name.slice(2).toLowerCase());
             continue;
         }
-        if (!attr.value) {
+        if (!jsxAttr.value) {
             // Boolean shorthand `<Foo bar />` → literal `true`.
             const usage = { name, isDynamic: false };
             if (captureValues)
@@ -285,177 +967,75 @@ function readJsxAttrs(node, captureValues) {
             props.push(usage);
             continue;
         }
-        if (attr.value.type === "StringLiteral") {
+        // oxc emits `Literal` for string/number/boolean (ESTree shape); babel
+        // emitted distinct `StringLiteral` etc. Discriminate by `value` typeof.
+        if (jsxAttr.value.type === "Literal" && typeof jsxAttr.value.value === "string") {
             const usage = { name, isDynamic: false };
             if (captureValues)
-                usage.literalValue = attr.value.value;
+                usage.literalValue = jsxAttr.value.value;
             props.push(usage);
             continue;
         }
-        if (attr.value.type === "JSXExpressionContainer") {
-            const expr = attr.value.expression;
-            if (expr.type === "StringLiteral") {
-                const usage = { name, isDynamic: false };
-                if (captureValues)
-                    usage.literalValue = expr.value;
-                props.push(usage);
-            }
-            else if (expr.type === "NumericLiteral") {
-                const usage = { name, isDynamic: false };
-                if (captureValues)
-                    usage.literalValue = expr.value;
-                props.push(usage);
-            }
-            else if (expr.type === "BooleanLiteral") {
-                const usage = { name, isDynamic: false };
-                if (captureValues)
-                    usage.literalValue = expr.value;
-                props.push(usage);
+        if (jsxAttr.value.type === "JSXExpressionContainer") {
+            // JSXExpressionContainer.expression is JSXExpression = JSXEmptyExpression | Expression
+            // — widen to Node for the unwrap step so the JSXEmptyExpression branch
+            // below is reachable (oxc's Expression union excludes JSXEmptyExpression).
+            const expr = unwrapParens(jsxAttr.value.expression);
+            // Empty expression containers (`{}`) are ignored.
+            if (expr.type === "JSXEmptyExpression")
+                continue;
+            if (expr.type === "Literal") {
+                const litVal = expr.value;
+                const kind = typeof litVal;
+                if (kind === "string" || kind === "number" || kind === "boolean") {
+                    const usage = { name, isDynamic: false };
+                    if (captureValues)
+                        usage.literalValue = litVal;
+                    props.push(usage);
+                    continue;
+                }
+                // null / bigint / regex literals: treat as dynamic-expr.
+                props.push({ name, isDynamic: true, dynamicKind: "expr" });
+                continue;
             }
-            else if (expr.type === "Identifier") {
+            if (expr.type === "Identifier") {
                 props.push({ name, isDynamic: true, dynamicKind: "identifier" });
+                continue;
             }
-            else {
-                props.push({ name, isDynamic: true, dynamicKind: "expr" });
-            }
+            props.push({ name, isDynamic: true, dynamicKind: "expr" });
         }
     }
     return { props, events };
 }
-function detectWrapper(path, file, localBindings, lookupByTag, wrappers) {
-    const name = wrapperName(path);
-    if (!name)
-        return;
-    if (!/^[A-Z]/.test(name))
-        return;
-    const seen = new Set();
-    const deps = [];
-    function addDep(cid) {
-        const key = serialiseComponentId(cid);
-        if (!seen.has(key)) {
-            seen.add(key);
-            deps.push(cid);
-        }
-    }
-    path.traverse({
-        JSXOpeningElement(inner) {
-            const n = inner.node.name;
-            if (n.type !== "JSXIdentifier")
-                return;
-            const id = n.name;
-            if (/^[a-z]/.test(id) && id.includes("-")) {
-                const indexed = lookupByTag(asTagName(id));
-                if (indexed) {
-                    addDep({
-                        kind: "custom-element",
-                        tagName: asTagName(id),
-                        source: { type: "external", package: externalPackageOf(indexed.source) },
-                    });
-                }
-                return;
-            }
-            const bound = localBindings.get(id);
-            // Only WC-wrapper bindings count as wrapper component-deps; React-direct
-            // bindings refer to other React components, which are not WC-wrappers.
-            if (bound && bound.kind === "wc-wrapper") {
-                addDep({
-                    kind: "custom-element",
-                    tagName: bound.tagName,
-                    source: { type: "external", package: bound.package },
-                });
-            }
-        },
-    });
-    if (deps.length === 0)
-        return;
-    const id = wrapperId(name);
-    wrappers.push({
-        id,
-        name,
-        file: posixPath(file),
-        exportName: detectExportName(path, name),
-        componentDeps: deps,
-    });
-}
-function wrapperName(path) {
-    const node = path.node;
-    if (node.type === "FunctionDeclaration" && node.id)
-        return node.id.name;
-    if (node.type === "ClassDeclaration" && node.id)
-        return node.id.name;
-    if (path.parent.type === "VariableDeclarator" && path.parent.id.type === "Identifier") {
-        return path.parent.id.name;
-    }
-    return undefined;
-}
-function detectExportName(path, declName) {
-    // Direct containment: declaration is itself part of an export statement.
-    let p = path;
-    while (p) {
-        if (p.parent && p.parent.type === "ExportDefaultDeclaration")
-            return "default";
-        if (p.parent && p.parent.type === "ExportNamedDeclaration")
-            return declName;
-        p = p.parentPath;
-    }
-    // Indirect: a separate `export default Foo;` or `export { Foo as Bar };` references
-    // this declaration by name. Scan the top-level program body.
-    const program = path.findParent((parent) => parent.isProgram());
-    if (program?.isProgram()) {
-        for (const stmt of program.node.body) {
-            if (stmt.type === "ExportDefaultDeclaration" &&
-                stmt.declaration.type === "Identifier" &&
-                stmt.declaration.name === declName) {
-                return "default";
-            }
-            if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) {
-                for (const spec of stmt.specifiers) {
-                    if (spec.type !== "ExportSpecifier")
-                        continue;
-                    if (spec.local.name !== declName)
-                        continue;
-                    if (spec.exported.type === "Identifier" && spec.exported.name === "default") {
-                        return "default";
-                    }
-                    return declName;
-                }
-            }
-        }
+/**
+ * Returns true for specifiers that look like bare npm package names — neither
+ * relative paths (`.`, `..`) nor absolute paths (`/`). Scoped packages
+ * (`@scope/name`) are accepted only when the scope part is non-empty, to
+ * exclude alias conventions like `@/foo` where `@` is not an npm scope.
+ */
+function isBarePackageSpecifier(specifier) {
+    if (specifier.startsWith(".") || specifier.startsWith("/"))
+        return false;
+    if (specifier.startsWith("@")) {
+        // Scoped package: require a non-empty scope name before the first "/".
+        const slashIdx = specifier.indexOf("/");
+        // No "/" at all (bare "@foo") or scope part is empty ("@/foo") → not a
+        // valid npm scoped package specifier.
+        return slashIdx > 1; // slashIdx 1 means "@/" — scope is empty
     }
-    return declName;
-}
-function wrapperId(name) {
-    const kebab = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-    return asWrapperId(`wrap-${kebab}`);
+    return true;
 }
 /**
- * Render-prop guard: returns true when `path` (a JSXElement) is lexically
- * nested inside a function body or JSXAttribute that lives between it and
- * the topmost tracked parent (`parentNode`). React render-props pass children
- * opaquely through a function (`<DataLoader>{(d) => <Card />}</DataLoader>`,
- * `{items.map(i => <Card />)}`) or through a prop value (`<Modal title={<H/>}>`),
- * so descendants in that scope must NOT inherit the host as their parent.
- *
- * JSXExpressionContainer alone is transparent — `{cond && <Card />}` and
- * `{a ? <X /> : <Y />}` should keep lexical-parent attribution per
- * §Failure modes' "conditional rendering visible" rule. The function/attribute
- * boundary is what differentiates render-prop from a bare expression escape.
- *
- * (Vue scoped slots are lexical and handled differently in parser-vue.)
+ * oxc preserves `ParenthesizedExpression` as a real AST node where babel
+ * transparently strips them. Anywhere we inspect an expression's shape
+ * (JSX-attribute values, return arguments, etc.) we must recurse through
+ * these wrappers first.
  */
-function isInRenderPropScope(path, parentNode) {
-    if (!parentNode)
-        return false;
-    let p = path.parentPath;
-    while (p && p.node !== parentNode) {
-        if (p.isArrowFunctionExpression() ||
-            p.isFunctionExpression() ||
-            p.isFunctionDeclaration() ||
-            p.isJSXAttribute()) {
-            return true;
-        }
-        p = p.parentPath;
+function unwrapParens(node) {
+    let cur = node;
+    while (cur.type === "ParenthesizedExpression") {
+        cur = cur.expression;
     }
-    return false;
+    return cur;
 }
 //# sourceMappingURL=walk-jsx.js.map