@component-compass/reference-graph 0.1.17 → 0.1.19

package/dist/engine/index.js

@@ -1,24 +1,71 @@
+import { asTagName, computeOccurrenceId, serialiseComponentId, projectPropUsages, parseCompoundExport } from "@component-compass/plugin-core";
 import { MODULE_SCOPE } from "../index.js";
-import { asTagName, computeOccurrenceId, serialiseComponentId, projectPropUsages } from "@component-compass/plugin-core";
 import { createArgumentMap } from "./argument-map.js";
 import { resolveReference } from "./resolve-reference.js";
-import { walkWithFolding } from "./wrapper-folding.js";
+import { walkWithFolding, argumentProvenance } from "./wrapper-folding.js";
 import { packageNameFromSpecifier, externalSubpath } from "./specifier.js";
 import { followReExportChain } from "./re-export-chain.js";
-import { buildHelperCallers } from "./helper-callers.js";
+import { buildHelperCallers, findLocalDeclaration } from "./helper-callers.js";
 import { resolveOwnerChain } from "./owner-resolution.js";
 import { createCycleGuard } from "./cycle-detection.js";
-import { unparsedMemberDefinition, effectiveExportName } from "./member-identity.js";
+import { unparsedMemberDefinition, effectiveExportName, residualMemberChain, compoundExportName } from "./member-identity.js";
+import { buildComponentRegistry, excludeFoldedHolders, excludeHostElementNames, entryKey } from "./registry.js";
+import { hasOnlyHostElementNames, isHostElementName } from "./host-element.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).
+ */
+function isHostElementRoot(ref) {
+    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 (#559): 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);
+    const helperIndex = buildHelperCallers(graph, excludeHostElementNames(registry, graph));
+    // THE admission rule (spec D1/D12, ruling 14: 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.
+    //
+    // Ruling 17: 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
+    // extensionless path (`./PhoneInput` resolved without a suffix — the
+    // resolver's own concern, not this rule's) is admitted: it's far more
+    // likely an unwalked source file than a non-code asset, and this rule has
+    // no way to tell without walking it.
+    const CODE_EXT = /\.(?:[cm]?[jt]sx?|vue)$/i;
+    const HAS_EXT = /\.[^./\\]+$/;
+    const admit = (id) => {
+        if (id.kind !== "react-component" || id.source.type !== "local")
+            return true;
+        const { filePath } = id.source;
+        const declaring = graph.files.get(filePath);
+        if (declaring === undefined)
+            return !HAS_EXT.test(filePath) || CODE_EXT.test(filePath);
+        if (declaring.dialect === "vue")
+            return true;
+        return registry.isComponentShaped(filePath, id.export);
+    };
     // Parallel sidecar holding the per-file usage index, kind, and (pre-resolved)
     // parent-usage index for each emitted occurrence. Used in pass 2 to resolve
     // `parentRef`. Held off-band (not on `EngineOccurrence`) so the public type
-    // stays clean and scratch state can't leak into output. `null` slots
-    // correspond to occurrences that have no composition source (defensive —
-    // every push path stamps a value today). Pre-capturing `parentUsageIdx` at
+    // stays clean and scratch state can't leak into output. `null` slots mean
+    // the occurrence has no lexical JSX parent — the argument-site seeding pass
+    // stamps nothing for its occurrences. Pre-capturing `parentUsageIdx` at
     // stamp time lets pass 2 do an O(1) lookup per occurrence instead of an
     // O(ownership) `.find()` — matters on large files (hundreds of usages).
     const composition = [];
@@ -39,19 +86,28 @@ export function resolve(graph, opts) {
     // 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`.
-    const stampComposition = (lengthBefore, kind, fileUsageIdx, depth, parentUsageIdx) => {
+    // THE per-slice compaction seam (admission + #248 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.
+    const compactSlice = (lengthBefore) => {
         const seenOccurrenceIds = new Set();
         let write = lengthBefore;
         for (let read = lengthBefore; read < occurrences.length; read++) {
             const occ = occurrences[read];
             if (occ === undefined)
                 continue;
+            if (!admit(occ.rawComponentId))
+                continue;
             if (seenOccurrenceIds.has(occ.occurrenceId))
                 continue;
             seenOccurrenceIds.add(occ.occurrenceId);
             occurrences[write++] = occ;
         }
         occurrences.length = write;
+    };
+    const stampComposition = (lengthBefore, kind, fileUsageIdx, depth, parentUsageIdx) => {
+        compactSlice(lengthBefore);
         for (let i = lengthBefore; i < occurrences.length; i++) {
             const occ = occurrences[i];
             if (!occ)
@@ -80,8 +136,24 @@ export function resolve(graph, opts) {
             if (!matchedImport) {
                 // Symbol is locally declared (no import) — emit local identity.
                 const decl = findLocalDeclaration(fileGraph, usage.ref);
-                if (!decl)
+                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
+                        // dropping it silently — `info`, because the usual cause is a
+                        // global or macro-provided binding the scan cannot see.
+                        opts?.collector?.emit({
+                            code: "unresolved-reference",
+                            severity: "info",
+                            filePath,
+                            line: usage.loc.line,
+                            column: usage.loc.column,
+                            symbol: usage.ref.symbol,
+                            memberChain: [...usage.ref.memberChain],
+                        });
+                    }
                     continue;
+                }
                 pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGraph, argMap, ownerRef, helperIndex, opts, viaOverride);
                 stampComposition(jsxLengthBefore, "jsx", usageIdx, jsxDepth, jsxParentUsageIdx);
                 continue;
@@ -91,6 +163,11 @@ export function resolve(graph, opts) {
             // every export-name / re-export lookup below keys on this, not the raw
             // `imported` (#362). `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
+            // 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.
+            const residual = residualMemberChain(matchedImport.imported, usage.ref.memberChain);
             if (!packageName) {
                 // Relative / absolute specifier — always a local file reference.
                 // Resolve the target path; normalize absolute → graph-relative if possible.
@@ -152,7 +229,7 @@ export function resolve(graph, opts) {
                 };
                 const fallbackComponentId = {
                     kind: componentKindFor(fileGraph.dialect),
-                    export: exportName,
+                    export: compoundExportName(exportName, residual),
                     source: { type: "local", filePath: canonicalFile },
                 };
                 if (viaOverride !== undefined) {
@@ -235,9 +312,12 @@ export function resolve(graph, opts) {
                 const jsxTerminals = foldedTerminals.filter((t) => t.type.kind === "JSX");
                 if (jsxTerminals.length === 0)
                     continue;
-                const localFallback = workspaceSiblingFallback(graph, resolvedNormTarget, matchedImport, effectiveImported, fileGraph.dialect);
+                const siblingFallback = workspaceSiblingFallback(graph, resolvedNormTarget, matchedImport, effectiveImported, fileGraph.dialect);
+                const localFallback = siblingFallback !== undefined && siblingFallback.kind !== "custom-element"
+                    ? { ...siblingFallback, export: compoundExportName(siblingFallback.export, residual) }
+                    : siblingFallback;
                 for (const ft of jsxTerminals) {
-                    pushOccurrence(occurrences, filePath, usage, matchedImport, effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opts, localFallback, viaOverride);
+                    pushOccurrence(occurrences, filePath, usage, matchedImport, compoundExportName(effectiveImported, residual), packageName, graph, fileGraph, ft, ownerRef, helperIndex, opts, localFallback, viaOverride);
                 }
             }
             else {
@@ -255,13 +335,13 @@ export function resolve(graph, opts) {
                 if (member !== null) {
                     const localFallback = {
                         kind: componentKindFor(fileGraph.dialect),
-                        export: member.exportName,
+                        export: compoundExportName(member.exportName, residual),
                         source: { type: "local", filePath: member.absFile },
                     };
-                    pushOccurrence(occurrences, filePath, usage, matchedImport, effectiveImported, packageName, graph, fileGraph, sentinelFt, ownerRef, helperIndex, opts, localFallback, viaOverride);
+                    pushOccurrence(occurrences, filePath, usage, matchedImport, compoundExportName(effectiveImported, residual), packageName, graph, fileGraph, sentinelFt, ownerRef, helperIndex, opts, localFallback, viaOverride);
                 }
                 else {
-                    pushOccurrence(occurrences, filePath, usage, matchedImport, effectiveImported, packageName, graph, fileGraph, sentinelFt, ownerRef, helperIndex, opts, undefined, viaOverride);
+                    pushOccurrence(occurrences, filePath, usage, matchedImport, compoundExportName(effectiveImported, residual), packageName, graph, fileGraph, sentinelFt, ownerRef, helperIndex, opts, undefined, viaOverride);
                 }
             }
             stampComposition(jsxLengthBefore, "jsx", usageIdx, jsxDepth, jsxParentUsageIdx);
@@ -319,6 +399,80 @@ 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-
+    // 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
+    // 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
+    // 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
+    // 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.
+    const folded = new Map();
+    for (const [filePath, fileGraph] of graph.files) {
+        if (fileGraph.dialect === "vue")
+            continue;
+        for (const decl of fileGraph.declarations.values()) {
+            if (decl.scope !== MODULE_SCOPE || decl.value.kind !== "ReturnTypeOf")
+                continue;
+            if (!registry.hasLocal(filePath, decl.symbol))
+                continue;
+            const holderJsx = walkWithFolding(graph, fileGraph, decl.value, argMap).filter((t) => t.type.kind === "JSX");
+            const foldedAway = foldedHolder(holderJsx, filePath);
+            if (foldedAway !== null)
+                folded.set(entryKey(filePath, decl.symbol), foldedAway);
+            const lengthBefore = occurrences.length;
+            pushArgumentSiteOccurrences(occurrences, filePath, decl, decl.value, holderJsx, graph, fileGraph, argMap, opts);
+            compactSlice(lengthBefore);
+        }
+    }
+    // Hook argument seeding (#561). 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 R1's
+    // "the fold credited it already" reasoning does not apply. Same R2/R3
+    // 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)
@@ -343,25 +497,7 @@ export function resolve(graph, opts) {
         if (parentIdx !== undefined)
             occ.parentRef = parentIdx;
     }
-    return { occurrences };
-}
-/**
- * Walk the scope chain for `ref.symbol` in `fileGraph.declarations` and
- * return the first matching BindingDecl, or null if not found.
- */
-function findLocalDeclaration(fileGraph, ref) {
-    let scope = ref.scope;
-    while (true) {
-        const decl = fileGraph.declarations.get(`${scope}::${ref.symbol}`);
-        if (decl)
-            return decl;
-        if (scope === MODULE_SCOPE)
-            return null;
-        const parent = fileGraph.scopes.get(scope)?.parent;
-        if (parent === null || parent === undefined)
-            return null;
-        scope = parent;
-    }
+    return { occurrences, registry: excludeHostElementNames(excludeFoldedHolders(registry, folded), graph) };
 }
 /**
  * Build a local-scope ComponentId for a symbol declared in `filePath`.
@@ -389,8 +525,8 @@ function dialectForFile(graph, filePath) {
 }
 /**
  * Owner ComponentId for a parser-pre-decided owner reference (#151
- * prop-forward and dynamic-binding paths). `fallbackFile` is the consuming
- * file, used when the ref carries no originFile.
+ * prop-forward path). `fallbackFile` is the consuming file, used when the ref
+ * carries no originFile.
  *
  * This and `ownerIdFromResolution` are the ONLY places an occurrence's
  * `rawOwnerComponentId` may be built — the dialect must come from the
@@ -503,12 +639,16 @@ function relabelExternalLeaf(rawComponentId, filePath, specifier, resolveExterna
         rawComponentId.source.type !== "external") {
         return rawComponentId;
     }
-    const hit = resolveExternalLeaf(filePath, specifier, rawComponentId.export);
+    // A compound export (#518) 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);
+    const hit = resolveExternalLeaf(filePath, specifier, root);
     if (!hit || hit.leafPackage === rawComponentId.source.package)
         return rawComponentId;
     return {
         kind: rawComponentId.kind,
-        export: hit.exportName,
+        export: compoundExportName(hit.exportName, path),
         source: externalSource(hit.leafPackage, `${hit.leafPackage}/${hit.modulePath}`),
     };
 }
@@ -571,9 +711,10 @@ function computeWraps(rawComponentId, wrapCallback) {
     return { kind: "custom-element", tagName: hit.tagName, packageName: hit.packageName };
 }
 function pushOccurrence(occurrences, filePath, usage, matchedImport, 
-/** Export name for the fallback identity — namespace members already
- *  resolved via `effectiveExportName` (#362). Distinct from
- *  `matchedImport.imported`, which stays raw for `via` provenance. */
+/** 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`,
+ *  which stays raw for `via` provenance. */
 effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opts, fallbackOverride, viaOverride) {
     const fallback = fallbackOverride ?? {
         kind: componentKindFor(fileGraph.dialect),
@@ -646,17 +787,20 @@ effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opt
  * Walks the decl's value via walkWithFolding and fans out per JSX terminal.
  */
 function pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGraph, argMap, ownerRef, helperIndex, opts, viaOverride) {
-    const folded = walkWithFolding(graph, fileGraph, decl.value, argMap);
+    // 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:
+    // `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");
-    if (jsxTerminals.length === 0) {
-        if (decl.dynamicSource) {
-            // For dynamic-binding occurrences, derive a single owner (no fanout needed —
-            // dynamic bindings are not the target of helper-call reclassification).
-            const rawOwnerComponentId = ownerIdFromRef(graph, ownerRef, fileGraph.filePath);
-            pushDynamicBindingOccurrence(occurrences, filePath, usage, decl.dynamicSource, fileGraph.dialect, rawOwnerComponentId);
-        }
+    // 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)
         return;
-    }
     const outerVia = viaOverride ?? { kind: "local-component" };
     if (viaOverride !== undefined) {
         // #151 prop-forward: parser has pre-decided the owner — single-occurrence path.
@@ -664,7 +808,7 @@ function pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGrap
         for (const ft of jsxTerminals) {
             const fallback = {
                 kind: componentKindFor(fileGraph.dialect),
-                export: usage.ref.symbol,
+                export: compoundExportName(usage.ref.symbol, usage.ref.memberChain),
                 source: { type: "local", filePath },
             };
             const rawComponentId = componentIdFromIdentity(ft.identity, fallback, fileGraph.dialect, {
@@ -696,7 +840,7 @@ function pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGrap
     for (const ft of jsxTerminals) {
         const fallback = {
             kind: componentKindFor(fileGraph.dialect),
-            export: usage.ref.symbol,
+            export: compoundExportName(usage.ref.symbol, usage.ref.memberChain),
             source: { type: "local", filePath },
         };
         const rawComponentId = componentIdFromIdentity(ft.identity, fallback, fileGraph.dialect, {
@@ -726,55 +870,124 @@ function pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGrap
     }
 }
 /**
- * Emit a single occurrence for a JSX root that resolves to a dynamic binding
- * (function parameter or destructure of a CallExpression return). The runtime
- * identity is genuinely indeterminate, so:
- *  - componentId.source = { type: "unknown" }
- *  - componentId.export = the binding's local name
- *  - via.kind = "dynamic-binding" with bindingName + bindingSource
+ * #539 D1: 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
+ * the holder's own file; that member inherits `isDefault` in the seam.
+ * Returns `null` when the holder is not folded.
+ */
+function foldedHolder(holderJsx, filePath) {
+    if (holderJsx.length === 0 || holderJsx.some((t) => t.identity === null))
+        return null;
+    const first = holderJsx[0]?.identity;
+    const sameFileSingle = first !== undefined &&
+        first !== null &&
+        first.kind === "local" &&
+        first.filePath === filePath &&
+        holderJsx.every((t) => t.identity !== null && t.identity.kind === "local" && t.identity.filePath === filePath && t.identity.export === first.export);
+    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
+ * 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`,
+ * the same helper `hoc-wrapper` uses. The caller compacts the slice
+ * (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
+    // 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),
+    // 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.
+    if (holderJsx.length === 0 ||
+        holderJsx.some((t) => t.identity !== null || t.viaTrail.some((v) => v.kind === "hoc-wrapper"))) {
+        return;
+    }
+    const holderRef = {
+        symbol: holder.symbol,
+        scope: MODULE_SCOPE,
+        memberChain: [],
+        loc: holder.loc,
+        originFile: filePath,
+    };
+    // #540: 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.
  *
- * memberChain on the usage is intentionally dropped — claiming `.Foo` of an
- * unknown adds noise without information.
+ * 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. R4 (#561): 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 #540 apply.
  *
- * `definition` is intentionally absent: the declaration site of a parameter
- * is the function signature, which doesn't represent a component definition
- * in the local-component aggregation sense.
+ * `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 cost on WebClients (#561 PR body, scan time).
  */
-function pushDynamicBindingOccurrence(occurrences, filePath, usage, bindingSource, fileDialect, rawOwnerComponentId) {
-    // Skip intrinsic HTML/SVG elements. React's convention: JSX whose root
-    // identifier starts with a lowercase letter is always an intrinsic
-    // (`<div>`, `<title>`, `<label>`, …), never a component. Without this
-    // guard, auto-generated icon components like `function Icon({ title }) {
-    // return <svg><title>{title}</title></svg>; }` produce a noisy
-    // dynamic-binding occurrence for the `<title>` intrinsic — a false
-    // positive that swamps the real signal.
-    const first = usage.ref.symbol.charCodeAt(0);
-    if (first >= 97 && first <= 122)
-        return; // ASCII 'a'–'z'
-    const rawComponentId = {
-        kind: componentKindFor(fileDialect),
-        export: usage.ref.symbol,
-        source: { type: "unknown" },
-    };
-    const via = {
-        kind: "dynamic-binding",
-        bindingName: usage.ref.symbol,
-        bindingSource,
-    };
-    const provisionalId = serialiseComponentId(rawComponentId);
-    const occurrenceId = computeOccurrenceId(provisionalId, filePath, usage.loc.line, usage.loc.column, rawOwnerComponentId !== undefined ? serialiseComponentId(rawOwnerComponentId) : undefined);
-    occurrences.push({
-        rawComponentId,
-        filePath,
-        line: usage.loc.line,
-        column: usage.loc.column,
-        via,
-        viaChain: [via],
-        props: projectPropUsages(usage.props),
-        events: usage.events ?? [],
-        occurrenceId,
-        depth: 0,
-        ...(rawOwnerComponentId !== undefined ? { rawOwnerComponentId } : {}),
+function pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph, fileGraph, argMap, opts) {
+    let resolvedOwners;
+    call.args.forEach((arg, index) => {
+        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);
+        // Never applied: every terminal used below carries a non-null identity,
+        // and `buildComponentId` returns the fallback only for a null one. The
+        // relabel seam's signature requires a fallback all the same.
+        const unusedFallback = makeLocalComponentId(filePath, arg.ref.symbol, fileGraph.dialect);
+        for (const ft of walkWithFolding(graph, fileGraph, arg, argMap)) {
+            if (ft.type.kind !== "JSX" || ft.identity === null)
+                continue;
+            const rawComponentId = componentIdFromIdentity(ft.identity, unusedFallback, fileGraph.dialect, {
+                filePath,
+                resolveExternalLeaf: opts?.resolveExternalLeaf,
+            });
+            const wraps = computeWraps(rawComponentId, opts?.wrapCallback);
+            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 } : {}),
+                });
+            }
+        }
     });
 }
 /**