@component-compass/reference-graph 0.1.18 → 0.1.20

package/dist/engine/index.js

@@ -9,32 +9,38 @@ import { buildHelperCallers, findLocalDeclaration } from "./helper-callers.js";
 import { resolveOwnerChain } from "./owner-resolution.js";
 import { createCycleGuard } from "./cycle-detection.js";
 import { unparsedMemberDefinition, effectiveExportName, residualMemberChain, compoundExportName } from "./member-identity.js";
-import { buildComponentRegistry, excludeFoldedHolders, entryKey } from "./registry.js";
+import { buildComponentRegistry, excludeFoldedHolders, excludeHostElementNames, entryKey } from "./registry.js";
+import { hasOnlyHostElementNames, isHostElementName } from "./host-element.js";
+import { firstDynamicImport } from "./component-shape.js";
 /**
  * JSX treats a bare, lowercase-initial element name as a host element
  * (`div`, `svg`, `web-button`) — it never names a binding, so it is not an
  * unresolved reference. A member chain (`motion.div`) or a capitalised name
- * is a component reference and IS reported when unbound (#518 D7).
+ * is a component reference and IS reported when unbound.
  */
 function isHostElementRoot(ref) {
-    return ref.memberChain.length === 0 && /^[a-z]/.test(ref.symbol);
+    return ref.memberChain.length === 0 && isHostElementName(ref.symbol);
 }
 export function resolve(graph, opts) {
     const occurrences = [];
     const argMap = createArgumentMap();
-    const helperIndex = buildHelperCallers(graph);
+    // The registry is the one judge of component-ness: owner
+    // classification asks it (through the host-element narrowing, so a
+    // lowercase member is a helper for ownership while the base registry still
+    // gates the argument-site holder loop below).
     const registry = buildComponentRegistry(graph);
-    // THE admission rule (spec D1/D12, ruling 14: shape-only). A local
+    const helperIndex = buildHelperCallers(graph, excludeHostElementNames(registry, graph));
+    // THE admission rule (shape-only). A local
     // react-component identity must be component-shaped; consumption is the
     // usage itself (a JSX usage that resolves to a local declaration IS that
     // declaration's consumption — the engine's own alias/union/dynamic-map/
     // re-export/wrapper-fold resolution already did that work, so admission
     // never re-derives it). Everything the registry does not type (externals,
     // custom elements, vue-dialect declarations, workspace-member definitions
-    // outside the graph) is admitted as before — except a non-code file, which
-    // is never a component.
+    // outside the graph) is admitted — except a non-code file, which is never a
+    // component.
     //
-    // Ruling 17: a workspace-member path outside the graph (the bounded
+    // A workspace-member path outside the graph (the bounded
     // resolver pins it but never parses it — a lazy `import("./PhoneInput")`
     // whose target file wasn't walked) is rejected only when its path HAS an
     // extension that is provably not code (`hero.png`, `.SVG`). An
@@ -65,23 +71,23 @@ export function resolve(graph, opts) {
     // O(ownership) `.find()` — matters on large files (hundreds of usages).
     const composition = [];
     // Finalise the occurrences emitted by one usage (the slice since
-    // `lengthBefore`): collapse #248 duplicates, then stamp composition info +
+    // `lengthBefore`): collapse duplicates, then stamp composition info +
     // a `depth` sourced from the ownership entry. Called after each per-usage
     // emit so helper-call fanout (multiple occurrences per usage) carries
     // identical composition metadata across the fan.
     //
-    // #248 dedup: resolveType's `Function` case flatMaps every `return`, so a
+    // Dedup: resolveType's `Function` case flatMaps every `return`, so a
     // referenced component whose body has N `return <JSX>` branches yields N
     // folded terminals that all collapse to one identity — emitting N records
     // sharing an `occurrenceId` (componentId + file + line + column + owner).
     // Collapsing is scoped to THIS usage's slice, so genuinely-distinct
-    // cross-usage repeats that share an occurrenceId (e.g. a #151 prop-forward
+    // cross-usage repeats that share an occurrenceId (e.g. a prop-forward
     // of one `const x = <Y/>` literal into two sibling call sites) are separate
     // usages and never merged. Within one usage, a shared occurrenceId means
     // same identity AND same owner — always a spurious duplicate. The
     // `composition` sidecar isn't populated for this slice until the stamp loop
     // below, so the compaction only touches `occurrences`.
-    // THE per-slice compaction seam (admission + #248 dedup). Every emission
+    // THE per-slice compaction seam (admission + dedup). Every emission
     // path — a usage's slice via `stampComposition`, a holder's argument-site
     // slice below — routes through it; never re-derive admission or dedup at a
     // push site.
@@ -134,7 +140,7 @@ export function resolve(graph, opts) {
                 if (!decl) {
                     if (!isHostElementRoot(usage.ref)) {
                         // No import record and no declaration in scope: the engine cannot
-                        // attribute this usage. Surface it (#518 D7 / #111) instead of
+                        // attribute this usage. Surface it instead of
                         // dropping it silently — `info`, because the usual cause is a
                         // global or macro-provided binding the scan cannot see.
                         opts?.collector?.emit({
@@ -156,9 +162,9 @@ export function resolve(graph, opts) {
             const packageName = packageNameFromSpecifier(matchedImport.specifier);
             // Resolve namespace-import members to their export name once, up front —
             // every export-name / re-export lookup below keys on this, not the raw
-            // `imported` (#362). `via.import` keeps the raw `imported` (provenance).
+            // `imported`. `via.import` keeps the raw `imported` (provenance).
             const effectiveImported = effectiveExportName(matchedImport.imported, usage.ref.memberChain);
-            // #518 D4: lookups below key on `effectiveImported` (the ROOT); the
+            // Lookups below key on `effectiveImported` (the ROOT); the
             // identity stamped on a fallback is the root plus the residual chain.
             // A member the walker resolves to its own declaration never reaches a
             // fallback, so this only names members with no declaration of their own.
@@ -169,7 +175,7 @@ export function resolve(graph, opts) {
                 const resolvedAbsTarget = graph.moduleResolver(filePath, matchedImport.specifier);
                 if (!resolvedAbsTarget) {
                     // A JSX usage whose import failed to resolve is a dropped local
-                    // reference — surface it instead of vanishing (#369).
+                    // reference — surface it instead of vanishing.
                     opts?.collector?.emit({
                         code: "unresolved-import",
                         severity: "warning",
@@ -188,12 +194,14 @@ export function resolve(graph, opts) {
                 const refType = resolveReference(graph, fileGraph, usage.ref);
                 const folded = walkWithFolding(graph, fileGraph, refType, argMap);
                 const jsxTerminals = folded.filter((t) => t.type.kind === "JSX");
-                if (jsxTerminals.length === 0)
+                if (jsxTerminals.length === 0) {
+                    emitLazyImportUnsupported(opts, filePath, usage.loc, refType);
                     continue;
+                }
                 // Determine the canonical source file + local export name. When the
                 // target is a re-export barrel (`export { X } from './source'`),
                 // follow the chain to the actual definition file so JSX edges
-                // attribute to the source rather than the barrel (#101). Without
+                // attribute to the source rather than the barrel. Without
                 // this, two consumers importing the same component through different
                 // re-export paths fragment across phantom identities.
                 const chained = followReExportChain(graph, resolvedTarget, effectiveImported);
@@ -228,7 +236,7 @@ export function resolve(graph, opts) {
                     source: { type: "local", filePath: canonicalFile },
                 };
                 if (viaOverride !== undefined) {
-                    // #151 prop-forward: parser has pre-decided the owner — single-occurrence path.
+                    // Prop-forward: parser has pre-decided the owner — single-occurrence path.
                     const rawOwnerComponentId = ownerIdFromRef(graph, ownerRef, fileGraph.filePath);
                     for (const ft of jsxTerminals) {
                         const rawComponentId = componentIdFromIdentity(ft.identity, fallbackComponentId, fileGraph.dialect, {
@@ -297,7 +305,7 @@ export function resolve(graph, opts) {
                 : resolvedAbsTarget;
             const targetInGraph = resolvedNormTarget !== null && graph.files.has(resolvedNormTarget);
             if (targetInGraph) {
-                // Target file is in graph — workspace sibling (#94). Resolve to check
+                // Target file is in graph — workspace sibling. Resolve to check
                 // JSX type, fan out per terminal. The fallback identity is local so
                 // null-identity terminals still attribute to the sibling file rather
                 // than a phantom external stub. Terminal identities from deriveIdentity
@@ -305,8 +313,10 @@ export function resolve(graph, opts) {
                 const refType = resolveReference(graph, fileGraph, usage.ref);
                 const foldedTerminals = walkWithFolding(graph, fileGraph, refType, argMap);
                 const jsxTerminals = foldedTerminals.filter((t) => t.type.kind === "JSX");
-                if (jsxTerminals.length === 0)
+                if (jsxTerminals.length === 0) {
+                    emitLazyImportUnsupported(opts, filePath, usage.loc, refType);
                     continue;
+                }
                 const siblingFallback = workspaceSiblingFallback(graph, resolvedNormTarget, matchedImport, effectiveImported, fileGraph.dialect);
                 const localFallback = siblingFallback !== undefined && siblingFallback.kind !== "custom-element"
                     ? { ...siblingFallback, export: compoundExportName(siblingFallback.export, residual) }
@@ -316,7 +326,7 @@ export function resolve(graph, opts) {
                 }
             }
             else {
-                // Target not in graph. Workspace membership (spec Piece 2, #327): a
+                // Target not in graph. Workspace membership: a
                 // resolved target owned by a workspace member is first-party — emit
                 // LOCAL, pinned to the definition file (bounded re-export resolution)
                 // so identity is scope-invariant between whole-repo and single-app
@@ -394,22 +404,22 @@ export function resolve(graph, opts) {
             stampComposition(tagLengthBefore, "tag", i, tagDepth, tagParentUsageIdx);
         }
     }
-    // Argument-site seeding (spec §4, D4/D5; PR 2 rulings R1–R3). A module-
+    // Argument-site seeding. A module-
     // scope registry member whose value is a call — a wrapper product — is a
     // *holder*. Its own fold decides everything: when the fold reaches JSX and
     // every terminal carries neither an identity nor a `hoc-wrapper` hop, the
     // holder is its own identity
-    // (D9 arm 2: the callee was visible and built a new function) and credited
+    // (the callee was visible and built a new function) and credited
     // none of its arguments, so each identifier argument of the OUTERMOST call
     // that resolves to a component gets one occurrence at the argument's own
     // position, owned by the holder. A fold that carried an identity credited
-    // an argument already (arm 1 / arm 3) and seeds nothing — a site is never
+    // an argument already and seeds nothing — a site is never
     // counted twice. The registry gate keeps an unused, unexported holder from
     // owning anything (no phantom owner by construction). Runs after the usage
     // loops so a holder's slice never interleaves with a usage's; there is no
     // composition sidecar entry because an argument site has no lexical JSX
     // parent.
-    // #539 D1/D2: the SAME fold answers membership. A holder whose every JSX
+    // The SAME fold answers membership. A holder whose every JSX
     // terminal carries an identity has credited another identity for every
     // render — it is the route to that identity, not a member. Collected here,
     // applied once through `excludeFoldedHolders` at the return below.
@@ -431,6 +441,43 @@ export function resolve(graph, opts) {
             compactSlice(lengthBefore);
         }
     }
+    // Hook argument seeding. A component passed to a hook call inside a
+    // top-level function body (`const [modal] = useModalTwoStatic(Modal)`) is
+    // used at that site: a hook's product is a value the caller interpolates,
+    // never a tag, so no render site will ever pay for the argument and the
+    // "fold credited it already" reasoning does not apply. Same argument rules
+    // and the same push seam as the holder loop; the owner is
+    // the enclosing declaration through `resolveOwnerChain`, so a helper hook
+    // fans the seed out to each caller with a `helper-call` hop. A hook is
+    // named by `HOOK_NAME`, React's own `isHookName` predicate (rules-of-hooks
+    // and the compiler) — there is no structural signal for "hook".
+    for (const [filePath, fileGraph] of graph.files) {
+        if (fileGraph.dialect === "vue")
+            continue;
+        for (const bodyCall of fileGraph.bodyCalls) {
+            if (!HOOK_NAME.test(bodyCall.callee.symbol) || bodyCall.args.length === 0)
+                continue;
+            const call = {
+                kind: "ReturnTypeOf",
+                callee: { kind: "TypeOf", ref: bodyCall.callee },
+                args: bodyCall.args,
+            };
+            const ownerRef = {
+                symbol: bodyCall.ownerSymbol,
+                scope: MODULE_SCOPE,
+                memberChain: [],
+                loc: { line: 0, column: 0 },
+                originFile: filePath,
+            };
+            const owners = () => resolveOwnerChain(ownerRef, graph, helperIndex, createCycleGuard()).map((res) => ({
+                rawOwnerComponentId: ownerIdFromResolution(graph, res.ownerDecl),
+                viaPrefix: res.viaPrefix,
+            }));
+            const lengthBefore = occurrences.length;
+            pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph, fileGraph, argMap, opts);
+            compactSlice(lengthBefore);
+        }
+    }
     // Pass 2: resolve `parentRef` from per-file `parentUsageIdx` ownership data.
     // Pass 1 populated the `composition` sidecar with `(fileUsageIdx, kind)` per
     // emitted occurrence, which lets us build a `(filePath, kind, fileUsageIdx)
@@ -455,7 +502,7 @@ export function resolve(graph, opts) {
         if (parentIdx !== undefined)
             occ.parentRef = parentIdx;
     }
-    return { occurrences, registry: excludeFoldedHolders(registry, folded) };
+    return { occurrences, registry: excludeHostElementNames(excludeFoldedHolders(registry, folded), graph) };
 }
 /**
  * Build a local-scope ComponentId for a symbol declared in `filePath`.
@@ -482,7 +529,7 @@ function dialectForFile(graph, filePath) {
     return graph.files.get(filePath)?.dialect ?? "react";
 }
 /**
- * Owner ComponentId for a parser-pre-decided owner reference (#151
+ * Owner ComponentId for a parser-pre-decided owner reference (the
  * prop-forward path). `fallbackFile` is the consuming file, used when the ref
  * carries no originFile.
  *
@@ -513,17 +560,14 @@ function ownerIdFromResolution(graph, ownerDecl) {
  * (e.g. `@shoelace/dist/components/button` → `modulePath: "dist/components/button"`)
  * so per-subpath components stay distinct. Relative imports canonicalise to
  * `identity.resolvedFile` (repo-relative POSIX from the moduleResolver) so
- * `'./page'` and `'../page'` from different callers collapse to one identity
- * (#109).
+ * `'./page'` and `'../page'` from different callers collapse to one identity.
  *
  * The component kind is derived from `fileDialect` via `componentKindFor` —
  * `"vue"` dialect files emit `vue-component`, all others emit `react-component`.
- * A future `manifestKindHint` parameter will let callers override the
- * dialect-derived default when a manifest entry resolves to a concrete kind.
  * Tag-usage paths emit `custom-element` directly and don't call this helper.
  *
  * When `ctx` is supplied, this is also the single seam that applies the
- * external-leaf relabel (#242) — see `relabelExternalLeaf`. The specifier fed
+ * external-leaf relabel — see `relabelExternalLeaf`. The specifier fed
  * to the relabel hook is the folded terminal's OWN specifier when `identity`
  * is `"imported"` (it may diverge from the consuming file's own import
  * specifier, e.g. an in-graph barrel re-wrap), falling back to
@@ -572,7 +616,7 @@ function buildComponentId(identity, fallback, fileDialect) {
  * Build the external `ComponentSource` for an import specifier. Stamps
  * `modulePath` with the subpath after the package name when one is present,
  * so subpath imports like `@shoelace/dist/components/button` stay distinct
- * from `/icon` (#109). Bare package specs (`react`, `@org/pkg`) omit
+ * from `/icon`. Bare package specs (`react`, `@org/pkg`) omit
  * modulePath. Subpath derivation (including module-extension normalisation, so
  * `react/button` and `react/button.js` collapse to one identity) lives in the
  * `externalSubpath` seam.
@@ -585,7 +629,7 @@ function externalSource(pkg, specifier) {
 }
 /**
  * Relabel an external react-component identity to the leaf package its
- * re-export chain terminates in (#242). No-op unless the hook is supplied,
+ * re-export chain terminates in. No-op unless the hook is supplied,
  * the identity is an external react-component, and the walk crossed a
  * package boundary. The relabeled modulePath routes through the
  * `externalSource`/`externalSubpath` seam so extension normalisation stays
@@ -597,7 +641,7 @@ function relabelExternalLeaf(rawComponentId, filePath, specifier, resolveExterna
         rawComponentId.source.type !== "external") {
         return rawComponentId;
     }
-    // A compound export (#518) names a member of the package's ROOT export;
+    // A compound export names a member of the package's ROOT export;
     // the leaf walk resolves the root and the member chain is re-joined onto
     // whatever export the leaf calls it.
     const { root, path } = parseCompoundExport(rawComponentId.export);
@@ -611,7 +655,7 @@ function relabelExternalLeaf(rawComponentId, filePath, specifier, resolveExterna
     };
 }
 /**
- * Build the local fallback ComponentId for a workspace-sibling import (#94).
+ * Build the local fallback ComponentId for a workspace-sibling import.
  * When a bare-package import (`@org/foo`) resolves to a file in the parsed
  * graph, the package is a workspace sibling — JSX edges should land on the
  * sibling's actual file rather than a phantom external stub.
@@ -621,11 +665,11 @@ function relabelExternalLeaf(rawComponentId, filePath, specifier, resolveExterna
  * default external fallback.
  */
 function workspaceSiblingFallback(graph, resolvedTarget, matchedImport, 
-/** Namespace-member-resolved export name (#362); see `effectiveExportName`. */
+/** Namespace-member-resolved export name; see `effectiveExportName`. */
 effectiveImported, consumerDialect) {
     if (!resolvedTarget)
         return undefined;
-    // Follow re-exports (#101) — workspace siblings can also use barrels.
+    // Follow re-exports — workspace siblings can also use barrels.
     const chained = followReExportChain(graph, resolvedTarget, effectiveImported);
     const canonicalFile = chained?.file ?? resolvedTarget;
     let exportName = chained?.localExport ?? effectiveImported;
@@ -670,8 +714,8 @@ function computeWraps(rawComponentId, wrapCallback) {
 }
 function pushOccurrence(occurrences, filePath, usage, matchedImport, 
 /** Export name for the fallback identity — the root export resolved via
- *  `effectiveExportName` (#362) joined with the residual member chain via
- *  `compoundExportName` (#518). Distinct from `matchedImport.imported`,
+ *  `effectiveExportName` joined with the residual member chain via
+ *  `compoundExportName`. Distinct from `matchedImport.imported`,
  *  which stays raw for `via` provenance. */
 effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opts, fallbackOverride, viaOverride) {
     const fallback = fallbackOverride ?? {
@@ -694,7 +738,7 @@ effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opt
         import: matchedImport.imported,
     };
     if (viaOverride !== undefined) {
-        // #151 prop-forward: parser has pre-decided the owner — single-occurrence path.
+        // Prop-forward: parser has pre-decided the owner — single-occurrence path.
         const rawOwnerComponentId = ownerIdFromRef(graph, ownerRef, filePath);
         const viaChain = [viaOverride];
         const provisionalId = serialiseComponentId(rawComponentId);
@@ -740,6 +784,27 @@ effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opt
         });
     }
 }
+/**
+ * A fold that reached no JSX while an import() sits in the walked value is a
+ * lazy shape the pipeline could not resolve to a component: a `.then` callback
+ * that does more than pick a property, or a target whose component shape could
+ * not be confirmed. Report it at the render site so the miss is visible, and
+ * name the file the `import()` is declared in when that is not the render file.
+ */
+function emitLazyImportUnsupported(opts, filePath, loc, value) {
+    const di = opts?.collector ? firstDynamicImport(value) : null;
+    if (!di)
+        return;
+    opts?.collector?.emit({
+        code: "lazy-import-unsupported",
+        severity: "warning",
+        filePath,
+        line: loc.line,
+        column: loc.column,
+        specifier: di.specifier,
+        detail: `the import() target could not be resolved to a component${di.originFile === filePath ? "" : ` (declared in ${di.originFile})`}`,
+    });
+}
 /**
  * Push local-scope occurrences for a symbol declared in the same file (no import).
  * Walks the decl's value via walkWithFolding and fans out per JSX terminal.
@@ -747,21 +812,22 @@ effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opt
 function pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGraph, argMap, ownerRef, helperIndex, opts, viaOverride) {
     // A member access on a same-file binding (`<LocalNS.Leaf/>`) walks the
     // MEMBER, not the whole object — `resolveReference` applies the usage's
-    // member chain exactly as the import path already gets it (#520 shape 4,
-    // the same static-MemberOf arm as #512). A bare reference is unchanged:
+    // member chain exactly as the import path already gets it (the same
+    // static-MemberOf arm). A bare reference is unchanged:
     // `decl.value` is what `resolveReference` returns for an empty chain.
     const value = usage.ref.memberChain.length > 0 ? resolveReference(graph, fileGraph, usage.ref) : decl.value;
     const folded = walkWithFolding(graph, fileGraph, value, argMap);
     const jsxTerminals = folded.filter((t) => t.type.kind === "JSX");
     // A reference that resolves to no JSX terminal — a function parameter
     // (`<Component/>` inside a factory body), a hook-return destructure, or an
-    // unresolvable alias — emits nothing (spec D4/D7). The old dynamic-binding
-    // phantom (`{ packageName: null, exportName: "Component" }`) is gone.
-    if (jsxTerminals.length === 0)
+    // unresolvable alias — emits no occurrence.
+    if (jsxTerminals.length === 0) {
+        emitLazyImportUnsupported(opts, filePath, usage.loc, value);
         return;
+    }
     const outerVia = viaOverride ?? { kind: "local-component" };
     if (viaOverride !== undefined) {
-        // #151 prop-forward: parser has pre-decided the owner — single-occurrence path.
+        // Prop-forward: parser has pre-decided the owner — single-occurrence path.
         const rawOwnerComponentId = ownerIdFromRef(graph, ownerRef, fileGraph.filePath);
         for (const ft of jsxTerminals) {
             const fallback = {
@@ -828,11 +894,11 @@ function pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGrap
     }
 }
 /**
- * #539 D1: a holder is folded away iff its fold reaches JSX and EVERY JSX
+ * A holder is folded away iff its fold reaches JSX and EVERY JSX
  * terminal carries an identity — the fold credited someone else for every
  * render. Any identity-less terminal means the holder is its own identity
- * (spec D9 arm 2: `memo(createField(Base))`, `forwardRef((p, r) => <b/>)`).
- * D4: the target is reported only when all terminals name ONE local member of
+ * (`memo(createField(Base))`, `forwardRef((p, r) => <b/>)`).
+ * The target is reported only when all terminals name ONE local member of
  * the holder's own file; that member inherits `isDefault` in the seam.
  * Returns `null` when the holder is not folded.
  */
@@ -848,8 +914,8 @@ function foldedHolder(holderJsx, filePath) {
     return { target: sameFileSingle ? { filePath, export: first.export } : null };
 }
 /**
- * Argument-site seeding for one holder (spec §4; PR 2 rulings R1–R3) over the
- * fold the caller already ran (#539 D2) — the rule is stated at the call site
+ * Argument-site seeding for one holder over the fold the caller already ran
+ * — the rule is stated at the call site
  * in `resolve`. Identity goes through `componentIdFromIdentity` (the
  * external-leaf relabel seam) and the owner through `ownerIdFromRef`, exactly
  * as every other push path; the binding is named through `argumentProvenance`,
@@ -857,9 +923,9 @@ function foldedHolder(holderJsx, filePath) {
  * (admission + dedup).
  */
 function pushArgumentSiteOccurrences(occurrences, filePath, holder, call, holderJsx, graph, fileGraph, argMap, opts) {
-    // R1: the holder is its own identity iff its fold reaches JSX and no
+    // The holder is its own identity iff its fold reaches JSX and no
     // terminal carries an identity of its own OR a `hoc-wrapper` hop — the hop
-    // is the fold's own record that it credited an argument (arm 1 / arm 3),
+    // is the fold's own record that it credited an argument,
     // even when that argument was anonymous (`forwardRef((p, r) => <b/>, x)`),
     // so the holder is a wrapper of it and its other arguments are
     // configuration, not wrapped components.
@@ -874,15 +940,42 @@ function pushArgumentSiteOccurrences(occurrences, filePath, holder, call, holder
         loc: holder.loc,
         originFile: filePath,
     };
-    const rawOwnerComponentId = ownerIdFromRef(graph, holderRef, filePath);
-    const ownerKey = rawOwnerComponentId !== undefined ? serialiseComponentId(rawOwnerComponentId) : undefined;
-    // R2: the outermost call's arguments only — an inner call's arguments
-    // configure the wrapper, they are not wrapped. R3: identifier arguments
-    // only, each resolved through the walker so aliases, re-exports and
-    // import-backed leaves take the same path a render site does; a null
-    // identity is skipped, never invented.
+    // The holder still seeds (its argument is a real usage), but a
+    // declaration that can never be rendered under any of its names is not a
+    // component and cannot own — the phantom-owner rule the registry gate
+    // above encodes, applied to the one owner this loop builds directly.
+    const rawOwnerComponentId = hasOnlyHostElementNames(holder.symbol, fileGraph)
+        ? undefined
+        : ownerIdFromRef(graph, holderRef, filePath);
+    pushCallArgumentOccurrences(occurrences, filePath, call, () => [{ rawOwnerComponentId, viaPrefix: [] }], graph, fileGraph, argMap, opts);
+}
+/** React's own hook predicate (`isHookName` in rules-of-hooks and the compiler). */
+const HOOK_NAME = /^use[A-Z0-9]/;
+/**
+ * THE argument-site push seam: one `passed-as-argument` occurrence per
+ * (identifier argument that resolves to a component) × (owner). The
+ * module-scope holder loop and the hook loop in `resolve` both call it;
+ * neither re-derives the argument rules or the push.
+ *
+ * The outermost call's arguments only — an inner call's arguments configure
+ * the wrapper, they are not wrapped. Identifier arguments only, each
+ * resolved through the walker so aliases, re-exports and import-backed
+ * leaves take the same path a render site does; a null identity is skipped,
+ * never invented. An identifier that is a host-element name (`useSelector(pick, shallowEqual)`) can never be
+ * rendered as a component, whatever it resolves to — an external leaf has
+ * no shape to check and would otherwise synthesise a component out of any
+ * import; the same predicate the held-reference seam and the roster naming
+ * gate apply.
+ *
+ * `owners` is resolved on the first push and reused: most hook calls
+ * (`useState(x)`, `useEffect(fn, deps)`) never reach a push, and resolving
+ * the owner chain for each of them measured as roughly half of the hook
+ * loop's scan-time cost on a large consumer repo.
+ */
+function pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph, fileGraph, argMap, opts) {
+    let resolvedOwners;
     call.args.forEach((arg, index) => {
-        if (arg.kind !== "TypeOf")
+        if (arg.kind !== "TypeOf" || isHostElementName(arg.ref.symbol))
             return;
         const outerVia = { kind: "passed-as-argument", index, ...argumentProvenance(call, arg, fileGraph) };
         const argDecl = findLocalDeclaration(fileGraph, arg.ref);
@@ -898,22 +991,26 @@ function pushArgumentSiteOccurrences(occurrences, filePath, holder, call, holder
                 resolveExternalLeaf: opts?.resolveExternalLeaf,
             });
             const wraps = computeWraps(rawComponentId, opts?.wrapCallback);
-            const occurrenceId = computeOccurrenceId(serialiseComponentId(rawComponentId), filePath, arg.ref.loc.line, arg.ref.loc.column, ownerKey);
-            occurrences.push({
-                rawComponentId,
-                filePath,
-                line: arg.ref.loc.line,
-                column: arg.ref.loc.column,
-                via: outerVia,
-                viaChain: [outerVia, ...ft.viaTrail],
-                props: {},
-                events: [],
-                occurrenceId,
-                depth: 0,
-                ...(argDecl !== null ? { definition: { line: argDecl.loc.line, column: argDecl.loc.column } } : {}),
-                ...(rawOwnerComponentId !== undefined ? { rawOwnerComponentId } : {}),
-                ...(wraps !== undefined ? { wraps } : {}),
-            });
+            resolvedOwners ??= owners();
+            for (const { rawOwnerComponentId, viaPrefix } of resolvedOwners) {
+                const viaChain = [...viaPrefix, outerVia, ...ft.viaTrail];
+                const occurrenceId = computeOccurrenceId(serialiseComponentId(rawComponentId), filePath, arg.ref.loc.line, arg.ref.loc.column, rawOwnerComponentId !== undefined ? serialiseComponentId(rawOwnerComponentId) : undefined);
+                occurrences.push({
+                    rawComponentId,
+                    filePath,
+                    line: arg.ref.loc.line,
+                    column: arg.ref.loc.column,
+                    via: viaChain[0] ?? outerVia,
+                    viaChain,
+                    props: {},
+                    events: [],
+                    occurrenceId,
+                    depth: 0,
+                    ...(argDecl !== null ? { definition: { line: argDecl.loc.line, column: argDecl.loc.column } } : {}),
+                    ...(rawOwnerComponentId !== undefined ? { rawOwnerComponentId } : {}),
+                    ...(wraps !== undefined ? { wraps } : {}),
+                });
+            }
         }
     });
 }
@@ -963,18 +1060,11 @@ function pushTagOccurrence(occurrences, filePath, usage, rawComponentId, ownerRe
     }
 }
 /**
- * Decide the `kind` for a JSX-emitted ComponentId.
- *
- * Resolution order:
- *  1. If a manifest entry returned a concrete kind hint, use it verbatim
- *     (parser-vue's future CEM-hit path will thread this through; today no
- *     caller supplies it).
- *  2. Otherwise fall back to the file's dialect — `"vue"` files emit
- *     `"vue-component"`, all others emit `"react-component"`.
- *
- * `manifestKindHint` is wired through now so the future plumbing (parser-vue
- * + CEM lookups in A2) is a single-site change rather than another caller
- * sweep. Tag-usage paths (custom-element) don't call this helper.
+ * Decide the `kind` for a JSX-emitted ComponentId. A concrete
+ * `manifestKindHint` is used verbatim; otherwise the file's dialect decides —
+ * `"vue"` files emit `"vue-component"`, all others `"react-component"`. No
+ * caller supplies a hint today. Tag-usage paths (custom-element) don't call
+ * this helper.
  */
 function componentKindFor(fileDialect, manifestKindHint) {
     if (manifestKindHint !== undefined)