@component-compass/reference-graph 0.1.24 → 0.1.26

package/dist/engine/wrapper-folding.js

@@ -1,15 +1,13 @@
 import { resolveType, resolveToFunctions, resolveDynamicImportTarget, DYNAMIC_MEMBER_KEY } from "./resolve-type.js";
 import { argumentRefKey, boundArgument } from "./argument-map.js";
 import { createCycleGuard } from "./cycle-detection.js";
-import { fileGraphForRef, resolveReference } from "./resolve-reference.js";
+import { resolveReference } from "./resolve-reference.js";
+import { bindingIdentity, pinUnparsed, resolveBinding, resolveModuleExport } from "./binding.js";
 import { packageNameFromSpecifier } from "./specifier.js";
-import { followReExportChain } from "./re-export-chain.js";
-import { unparsedMemberDefinition, effectiveExportName, residualMemberChain, compoundExportName } from "./member-identity.js";
-import { evalKind, isImportBackedLeaf } from "./component-shape.js";
+import { containsDynamicImport, evalKind, isImportBackedLeaf, nonComponentProduct } from "./component-shape.js";
 import { HOOK_NAME } from "./host-element.js";
 import { assertNever } from "./assert-never.js";
-import { creditedTerminals, matchDenotation } from "./denotation.js";
-import { libraryExportFor } from "./library-stubs.js";
+import { creditedTerminals, isCallable, matchDenotation } from "./denotation.js";
 /** True when a `ReturnTypeOf`'s callee is a data-method render
  *  call (`items.map(render)`) rather than a wrapper taking a component as a
  *  prop — the exact structural condition `component-shape.ts`'s rule (ii)
@@ -19,6 +17,49 @@ import { libraryExportFor } from "./library-stubs.js";
 function isDataMethodRenderCall(type, graph, fileGraph, guard) {
     return type.callee.kind === "MemberOf" && !isImportBackedLeaf(type.callee, graph, fileGraph, guard);
 }
+/** True when a value is a loader: a function whose body holds an `import()`,
+ *  inline, or reached from a reference through a chain of aliases, or held by
+ *  a static member of an object literal (by every member, for a dynamic one)
+ *  that the value names directly or through such a chain. Each reference
+ *  resolves in its own file. Anything else, a `lazy()` holder or a wrapper
+ *  product included, is not. */
+function isLoader(value, graph, fileGraph, guard) {
+    if (value.kind === "Function")
+        return containsDynamicImport(value, { graph, fileGraph });
+    if (value.kind !== "TypeOf" && value.kind !== "MemberOf")
+        return false;
+    if (guard.pushNode(value) === "cycle")
+        return false;
+    try {
+        if (value.kind === "TypeOf")
+            return isLoader(resolveReference(graph, fileGraph, value.ref, guard), graph, fileGraph, guard);
+        const holder = objectLiteralOf(value.obj, graph, fileGraph, guard);
+        if (holder === null)
+            return false;
+        if (value.member !== DYNAMIC_MEMBER_KEY) {
+            const held = holder.props[value.member];
+            return held !== undefined && isLoader(held, graph, fileGraph, guard);
+        }
+        const all = Object.values(holder.props);
+        return all.length > 0 && all.every((v) => isLoader(v, graph, fileGraph, guard));
+    }
+    finally {
+        guard.popNode(value);
+    }
+}
+/** The object literal a value is, directly or through a chain of aliases. */
+function objectLiteralOf(value, graph, fileGraph, guard) {
+    if (value.kind === "Object")
+        return value;
+    if (value.kind !== "TypeOf" || guard.pushNode(value) === "cycle")
+        return null;
+    try {
+        return objectLiteralOf(resolveReference(graph, fileGraph, value.ref, guard), graph, fileGraph, guard);
+    }
+    finally {
+        guard.popNode(value);
+    }
+}
 /** The denotation of a branch the walk learned nothing about. */
 const INDETERMINATE = { kind: "indeterminate" };
 function withSemantics(t, semantics) {
@@ -47,6 +88,7 @@ const CAME_TO_NOTHING = {
     "late-bound": () => true,
     data: () => false,
     indeterminate: () => true,
+    callable: () => false,
 };
 function cameToNothing(t) {
     return matchDenotation(t, CAME_TO_NOTHING);
@@ -59,6 +101,7 @@ const IS_LATE_BOUND = {
     "late-bound": () => true,
     data: () => false,
     indeterminate: () => false,
+    callable: () => false,
 };
 /**
  * Rename a branch that came to nothing, keeping its identity and viaTrail
@@ -95,6 +138,7 @@ const AS_RETURNED_VALUE = {
     "late-bound": () => INDETERMINATE,
     data: (d) => d,
     indeterminate: (d) => d,
+    callable: (d) => d,
 };
 function returnedValue(t) {
     const denotation = matchDenotation(t, AS_RETURNED_VALUE);
@@ -223,8 +267,8 @@ function foldToWrappedArg(inner, via) {
  * is seeded at its site), so the two name a binding identically.
  * Never re-derive `{ specifier, import }` for an argument elsewhere.
  */
-export function argumentProvenance(type, arg, fileGraph) {
-    const importRecord = findImportForLastArg(arg, fileGraph);
+export function argumentProvenance(graph, type, arg, fileGraph) {
+    const importRecord = findImportForLastArg(graph, arg, fileGraph);
     const resolved = importRecord
         ? { specifier: importRecord.specifier, import: importRecord.imported }
         : resolveAnonymousLastArg(arg, fileGraph);
@@ -236,8 +280,8 @@ export function argumentProvenance(type, arg, fileGraph) {
  * the opaque HOC fallback (step 4) so all three paths attribute composition
  * identically; the binding is named through `argumentProvenance`.
  */
-function buildHocVia(type, lastArg, fileGraph) {
-    const { callee, specifier, import: imported } = argumentProvenance(type, lastArg, fileGraph);
+function buildHocVia(graph, type, lastArg, fileGraph) {
+    const { callee, specifier, import: imported } = argumentProvenance(graph, type, lastArg, fileGraph);
     return { kind: "hoc-wrapper", hocCallee: callee, specifier, import: imported };
 }
 /**
@@ -254,7 +298,7 @@ export function foldedArgument(graph, fileGraph, call, jsx, argMap) {
     const arg = call.args[index];
     if (arg === undefined || jsx.length === 0)
         return null;
-    const via = buildHocVia(call, arg, fileGraph);
+    const via = buildHocVia(graph, call, arg, fileGraph);
     return jsx.every((t) => t.viaTrail[0] !== undefined && sameHocVia(t.viaTrail[0], via)) ? { arg, via } : null;
 }
 /** Two `hoc-wrapper` vias naming the same wrapper call and the same binding. */
@@ -304,14 +348,21 @@ function isPassThroughWrapper(algResult, inner) {
  * (pure algebra) and computes identity from the input type's leaf TypeOf
  * when one can be confidently identified.
  */
-export function walkWithFolding(graph, fileGraph, type, argMap, guard = createCycleGuard(), identityFallback) {
-    return atLeastOne(walkInner(graph, fileGraph, type, argMap, guard, identityFallback).map(published));
+export function walkWithFolding(graph, fileGraph, type, argMap, guard = createCycleGuard(), identityFallback, position = "value") {
+    return atLeastOne(walkInner(graph, fileGraph, type, argMap, guard, identityFallback, position).map(published));
 }
 /**
  * The walk itself. Returns exactly what each arm produced, empty included:
  * inside the walk an empty result means "this branch contributed nothing",
  * which `walkTypeOf`'s vacuous `every` and `foldToWrappedArg`'s rescue both
  * read. Only the exported boundary above may substitute a terminal for it.
+ *
+ * `position` says whether `type` is what a tag renders. At a `tag`, a
+ * function is one `callable` terminal and its body is not walked; the
+ * position carries through the value hops (a reference, a union branch, a
+ * static or dynamic member, a call's folded argument, a lazy target, a
+ * dispatcher's returns) and nowhere else. In `value` position a function is
+ * walked into its returns.
  */
 function walkInner(graph, fileGraph, type, argMap, guard, 
 // The identity `foldTerminals` falls back to when a terminal
@@ -325,39 +376,44 @@ function walkInner(graph, fileGraph, type, argMap, guard,
 // that happens to sit in `foldTerminals`' fallback slot. Per-branch
 // identity from a fanout `source` (Union([TypeOf A, TypeOf B])) is
 // untouched: `source` is checked BEFORE this fallback in `foldTerminals`.
-identityFallback) {
+identityFallback, position) {
     const fallback = identityFallback ?? type;
     switch (type.kind) {
         case "ReturnTypeOf":
-            return walkReturnTypeOf(graph, fileGraph, type, argMap, guard);
+            return walkReturnTypeOf(graph, fileGraph, type, argMap, guard, position);
         case "MemberOf":
             if (type.member === DYNAMIC_MEMBER_KEY) {
-                return walkDynamicMember(graph, fileGraph, type, argMap, guard);
+                return walkDynamicMember(graph, fileGraph, type, argMap, guard, position);
             }
-            return walkStaticMember(graph, fileGraph, type, argMap, guard, fallback);
+            return walkStaticMember(graph, fileGraph, type, argMap, guard, fallback, position);
         case "Function":
-            // A component's own returns can contain a nested
+            // At a tag the function is what JSX renders: one `callable` terminal
+            // with no identity of its own, and the body is not walked.
+            //
+            // In value position a component's own returns can contain a nested
             // ReturnTypeOf/MemberOf (`List = ({items}) => items.map(render)`) that
             // needs wrapper-folding's steps (the opaque-callee / dynamic-map
             // handling below), not `resolveType`'s plain algebra — `resolveType`'s
             // own "Function" case recurses via plain `resolveType`, which never
-            // re-enters this walk, so a JSX usage resolving to such a Function
-            // (e.g. `<List/>`) would silently produce zero occurrences.
+            // re-enters this walk, so a value resolving to such a Function would
+            // silently produce zero terminals.
             // Mirrors `resolveType`'s "Function" case, one level up. Pass THIS
             // Function as the identity fallback for every return — a
             // Function is never TypeOf/DynamicImport, so `deriveIdentity` on it
             // is always null.
+            if (position === "tag")
+                return [{ denotation: { kind: "callable" }, identity: null, viaTrail: [] }];
             return type.returns
-                .flatMap((r) => walkInner(graph, fileGraph, r, argMap, guard, type))
+                .flatMap((r) => walkInner(graph, fileGraph, r, argMap, guard, type, "value"))
                 .map(returnedValue);
         case "TypeOf":
-            return walkTypeOf(graph, fileGraph, type, argMap, guard, fallback);
+            return walkTypeOf(graph, fileGraph, type, argMap, guard, fallback, position);
         case "Union":
             // Structural re-entry: each branch walks through the walker so
             // a TypeOf branch reaches `walkTypeOf` and decides its own identity
             // (per-branch attribution) while a bare JSX branch — a lowered
             // ternary/logical render body — derives from the outer fallback.
-            return type.types.flatMap((branch) => walkInner(graph, fileGraph, branch, argMap, guard, fallback));
+            return type.types.flatMap((branch) => walkInner(graph, fileGraph, branch, argMap, guard, fallback, position));
         case "ParameterOf":
             return walkParameter(graph, fileGraph, type, argMap, guard, fallback);
         case "DynamicImport":
@@ -420,28 +476,13 @@ export function fileGraphForDynamicImport(graph, di, fallback) {
     return graph.files.get(di.originFile) ?? fallback;
 }
 /**
- * The identity cascade for a lazy target.
- *
- * `resolvedFile` is the specifier canonicalised through the module resolver, so
- * two spellings of one target — `./x` from one file, `../x` from another —
- * carry the same `resolvedFile` and collapse to a single componentId
- * downstream instead of minting a phantom each. A chain that resolves into the
- * graph (workspace sibling, relative import, or unparsed workspace member)
- * promotes to `local`, hashing to the same id as the local-index seed;
- * everything else stays `imported`.
+ * The identity of a lazy target: the binding its specifier's projected export
+ * names from the file that contains the `import()`.
  */
 export function dynamicImportIdentity(graph, fileGraph, di) {
     const origin = fileGraphForDynamicImport(graph, di, fileGraph);
-    const importedName = di.projection[0] ?? "default";
-    const resolvedFile = graph ? resolveImportedFile(graph, origin, di.specifier, importedName) : null;
-    return (workspaceSiblingIdentity(graph, origin, di.specifier, importedName) ??
-        relativeChainLocalIdentity(graph, origin, di.specifier, importedName) ??
-        memberLocalIdentity(graph, origin, di.specifier, importedName) ?? {
-        kind: "imported",
-        specifier: di.specifier,
-        imported: importedName,
-        resolvedFile,
-    });
+    const binding = resolveModuleExport(graph, origin.filePath, di.specifier, di.projection[0] ?? "default", []);
+    return bindingIdentity(pinUnparsed(graph, binding));
 }
 /**
  * Structural re-entry for a reference. Resolves ONE
@@ -454,9 +495,13 @@ export function dynamicImportIdentity(graph, fileGraph, di) {
  * Identity: a terminal that comes back with no identity of its own is
  * stamped with THIS reference's identity only when the reference names a
  * component-shaped value — `evalKind === "component"`, the one component-
- * shape seam, called not re-derived. A reference to a JSX value
- * (`return priceElement`) or to a parameter binding stays null so the outer
- * fallback wins, by construction rather than by special case.
+ * shape seam, called not re-derived — or, at a tag, when the walk came back
+ * with an identity-less `callable`: a reference to a function, or to a
+ * wrapper call over an anonymous one, names what the tag renders, whatever
+ * it returns. A reference to a JSX value (`return priceElement`) or to a
+ * parameter binding stays null so the outer fallback wins, by construction
+ * rather than by special case. A stamp naming a declaration with no member
+ * chain carries that declaration (`bindingIdentity`).
  *
  * An import the graph cannot see (`resolved` is Unknown) is NOT re-entered:
  * it is the identity-bearing leaf `foldLeaf` synthesises from, and
@@ -470,7 +515,7 @@ export function dynamicImportIdentity(graph, fileGraph, di) {
  * Cycle guard: mirrors `resolveType`'s node guard. `const A = B; const B = A`
  * is legal JS and would otherwise re-enter forever.
  */
-function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
+function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback, position) {
     if (guard.pushNode(type) === "cycle") {
         return [indeterminateTerminal()];
     }
@@ -486,13 +531,14 @@ function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
             return foldLeaf(graph, fileGraph, type, argMap, guard, fallback);
         }
         const innerGraph = resolved.kind === "Function" ? fileGraphForFunction(graph, fileGraph, resolved) : fileGraph;
-        const inner = walkInner(graph, innerGraph, resolved, argMap, guard, fallback);
+        const inner = walkInner(graph, innerGraph, resolved, argMap, guard, fallback, position);
         if (inner.every((t) => t.identity !== null))
             return inner;
-        const self = resolved.kind !== "ParameterOf" && evalKind(resolved, graph, innerGraph, argMap) === "component"
+        const derived = (position === "tag" && inner.some((t) => t.identity === null && isCallable(t))) ||
+            (resolved.kind !== "ParameterOf" && evalKind(resolved, graph, innerGraph, argMap) === "component")
             ? deriveIdentity(type, fileGraph, graph)
             : null;
-        const stamp = self ?? deriveIdentity(fallback, fileGraph, graph);
+        const stamp = derived ?? deriveIdentity(fallback, fileGraph, graph);
         // Carries the product mark: a reference to a context IS that context.
         return inner.map((t) => t.identity === null ? { denotation: t.denotation, viaTrail: t.viaTrail, identity: stamp, semantics: t.semantics } : t);
     }
@@ -514,7 +560,7 @@ function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
  * re-enters this arm forever without it — `resolveType` pops every node it
  * pushes, so nothing on such a cycle stays on the guard's path otherwise.
  */
-function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
+function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback, position) {
     if (guard.pushNode(type) === "cycle") {
         return [indeterminateTerminal()];
     }
@@ -537,7 +583,7 @@ function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
             // and any member of a non-component product is that product. ONE walk
             // answers both, and only once the member came to nothing, so a member
             // that resolved is never re-walked.
-            const object = walkInner(graph, fileGraph, type.obj, argMap, guard);
+            const object = walkInner(graph, fileGraph, type.obj, argMap, guard, undefined, "value");
             const semantics = markedProduct(object);
             if (semantics !== null)
                 return leaf.map((t) => withSemantics(t, semantics));
@@ -548,7 +594,7 @@ function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
             const value = obj.props[type.member];
             if (value === undefined)
                 continue;
-            out.push(...walkInner(graph, fileGraph, value, argMap, guard, fallback));
+            out.push(...walkInner(graph, fileGraph, value, argMap, guard, fallback, position));
         }
         return out.length > 0 ? out : [indeterminateTerminal()];
     }
@@ -557,59 +603,33 @@ function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
     }
 }
 /**
- * A call. Every folding rule runs first (`foldCall`); only when all of them
- * declined — no argument credited, no algebra result — does the call's own
- * shape get a name. A call of a hook the graph cannot see returns a value
+ * A call. A call of an export the stub table names a non-component product
+ * IS that product, before any fold runs: its arguments are values the product
+ * holds (a context's default), never a wrapped component, so none of them is
+ * walked or credited.
+ *
+ * Every other call runs the folding rules first (`foldCall`). The call's own
+ * shape gets a name only when all of them declined: no argument credited and no
+ * algebra result. A call of a hook the graph cannot see returns a value
  * bound at render time by the hook's own implementation, so it is late-bound
  * rather than unknown. The predicate is React's `HOOK_NAME` over a callee
  * `isImportBackedLeaf` says the graph cannot resolve; it runs after the folds,
  * so `const X = useStyled(Base)` keeps the credit its fold gave it.
  *
- * A call of an export the stub table names a non-component product carries
- * that product's mark on the terminals the folds produced, and only when the
- * folds credited nothing.
- *
  * ORDER IS LOAD-BEARING: `returnedValue` runs on the fold's results before
  * `late-bound{hook-result}` is minted for the call itself.
  */
-function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
-    const returns = foldCall(graph, fileGraph, type, argMap, guard).map(returnedValue);
-    if (creditedTerminals(returns).length === 0) {
-        const semantics = nonComponentProduct(graph, fileGraph, type.callee, guard);
-        if (semantics !== null)
-            return returns.map((t) => withSemantics(t, semantics));
-    }
+function walkReturnTypeOf(graph, fileGraph, type, argMap, guard, position) {
+    const semantics = nonComponentProduct(graph, fileGraph, type.callee, guard);
+    if (semantics !== null)
+        return [withSemantics(indeterminateTerminal(), semantics)];
+    const returns = foldCall(graph, fileGraph, type, argMap, guard, position).map(returnedValue);
     if (!(returns.length > 0 && returns.every(cameToNothing)))
         return returns;
     const unseenHook = HOOK_NAME.test(deriveHocCallee(type.callee)) && isImportBackedLeaf(type.callee, graph, fileGraph, guard);
     return unseenHook ? returns.map(asLateBound("hook-result")) : returns;
 }
-/**
- * The semantics of the non-component value a call produces: the stub table's
- * entry for the callee's export, when the callee is an import the graph cannot
- * see (`isImportBackedLeaf`, the same predicate the unseen-hook rule uses).
- * Null for every other call.
- *
- * The callee's spelling is read through `libraryExportFor`, the one table
- * `libraryStubFor` reads: a reference (a named import, or a default /
- * namespace import carrying the member on the ref) or a member access on one
- * (`React.createContext`).
- */
-function nonComponentProduct(graph, fileGraph, callee, guard) {
-    const ref = callee.kind === "TypeOf"
-        ? callee.ref
-        : callee.kind === "MemberOf" && callee.obj.kind === "TypeOf"
-            ? { ...callee.obj.ref, memberChain: [callee.member] }
-            : null;
-    if (ref === null)
-        return null;
-    const imp = fileGraphForRef(graph, ref, fileGraph).importsByLocal.get(ref.symbol);
-    const entry = imp === undefined ? null : libraryExportFor(imp, ref);
-    if (entry === null || entry.kind !== "non-component-product")
-        return null;
-    return isImportBackedLeaf(callee, graph, fileGraph, guard) ? entry.semantics : null;
-}
-function foldCall(graph, fileGraph, type, argMap, guard) {
+function foldCall(graph, fileGraph, type, argMap, guard, position) {
     // (1) lazy-import shape: any arg's subtree contains a DynamicImport
     //     (with one-ref-deep peek into local-file bindings to catch the async-await form).
     const lazyShape = findLazyImportArg(type.args, fileGraph);
@@ -628,10 +648,10 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
         }
         let inner;
         try {
-            const target = resolveDynamicImportTarget(graph, fileGraph, syntheticDI, guard);
+            const target = resolveDynamicImportTarget(graph, fileGraph, syntheticDI);
             inner = target
-                ? walkInner(graph, target.targetFileGraph, target.value, argMap, guard)
-                : walkInner(graph, fileGraph, syntheticDI, argMap, guard);
+                ? walkInner(graph, target.targetFileGraph, target.value, argMap, guard, undefined, position)
+                : walkInner(graph, fileGraph, syntheticDI, argMap, guard, undefined, position);
         }
         finally {
             guard.pop(syntheticDI.originFile, guardKey);
@@ -670,7 +690,7 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
     // walkDynamicMember rule fire and surfaces the dynamic-map via in the chain
     // — without it, cross-module dispatcher patterns would lose the via even
     // though identity attribution worked.
-    const dispatcherResult = walkDispatcherReturns(graph, fileGraph, type, argMap, guard);
+    const dispatcherResult = walkDispatcherReturns(graph, fileGraph, type, argMap, guard, position);
     if (dispatcherResult)
         return dispatcherResult;
     // (2b) Structural pass-through. When every Function
@@ -686,8 +706,8 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
     if (passThroughIndex !== null) {
         const wrapped = type.args[passThroughIndex];
         if (wrapped !== undefined) {
-            const inner = walkInner(graph, fileGraph, wrapped, argMap, guard);
-            return foldToWrappedArg(inner, buildHocVia(type, wrapped, fileGraph));
+            const inner = walkInner(graph, fileGraph, wrapped, argMap, guard, undefined, position);
+            return foldToWrappedArg(inner, buildHocVia(graph, type, wrapped, fileGraph));
         }
     }
     // (3) Pure algebra walk. Per-leaf identity uses each terminal's source
@@ -711,9 +731,9 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
         // stands with no via.
         const lastArg = type.args.at(-1);
         if (lastArg !== undefined) {
-            const inner = walkInner(graph, fileGraph, lastArg, argMap, guard);
+            const inner = walkInner(graph, fileGraph, lastArg, argMap, guard, undefined, position);
             if (isPassThroughWrapper(algResult, inner)) {
-                const via = buildHocVia(type, lastArg, fileGraph);
+                const via = buildHocVia(graph, type, lastArg, fileGraph);
                 return inner
                     .filter((t) => !cameToNothing(t))
                     .map((t) => ({ denotation: t.denotation, viaTrail: [via, ...t.viaTrail], identity: t.identity }));
@@ -726,7 +746,11 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
     if (lastArg === undefined) {
         return [indeterminateTerminal()];
     }
-    const inner = walkInner(graph, fileGraph, lastArg, argMap, guard);
+    // A data-method callback and a loader holding an `import()` the lazy arm
+    // declined are called, not rendered, so they walk in value position.
+    const dataMethod = isDataMethodRenderCall(type, graph, fileGraph, guard);
+    const called = dataMethod || isLoader(lastArg, graph, fileGraph, guard);
+    const inner = walkInner(graph, fileGraph, lastArg, argMap, guard, undefined, called ? "value" : position);
     // A data-method render call (`items.map(render)`) is not a
     // wrapper — its result IS the callback's rendered JSX, not a component
     // received as a prop. Return the callback's terminals AS-IS: no
@@ -734,14 +758,14 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
     // (the declaration being walked, e.g. `List`) wins rather than whatever
     // the callback itself happened to resolve to. Import-backed MemberOf
     // callees (`Sentry.withProfiler`) fall through to the fold+hop below.
-    if (isDataMethodRenderCall(type, graph, fileGraph, guard)) {
+    if (dataMethod) {
         const nonUnknown = inner.filter((t) => !cameToNothing(t));
         if (nonUnknown.length > 0) {
             return nonUnknown.map((t) => ({ denotation: t.denotation, viaTrail: t.viaTrail, identity: null }));
         }
         return [indeterminateTerminal()];
     }
-    return foldToWrappedArg(inner, buildHocVia(type, lastArg, fileGraph));
+    return foldToWrappedArg(inner, buildHocVia(graph, type, lastArg, fileGraph));
 }
 /**
  * Index of the argument an identity-preserving wrapper returns, or null when
@@ -792,7 +816,7 @@ function passThroughParameterIndex(graph, fileGraph, type, argMap, guard) {
  * `enclosingBinding.file`). Returns null when no callee matches the shape so
  * the caller falls through to the pure algebra path.
  */
-function walkDispatcherReturns(graph, fileGraph, type, argMap, guard) {
+function walkDispatcherReturns(graph, fileGraph, type, argMap, guard, position) {
     const calleeFns = resolveToFunctions(graph, fileGraph, type.callee, argMap, guard);
     const hasDispatcher = calleeFns.some(({ fn }) => fn.kind === "Function" && fn.returns.some(isDynamicMemberReturn));
     if (!hasDispatcher)
@@ -806,7 +830,7 @@ function walkDispatcherReturns(graph, fileGraph, type, argMap, guard) {
             argMap.bind(bindingRef, type.args);
         try {
             for (const ret of fn.returns) {
-                folded.push(...walkInner(graph, fnFileGraph, ret, argMap, guard));
+                folded.push(...walkInner(graph, fnFileGraph, ret, argMap, guard, undefined, position));
             }
         }
         finally {
@@ -886,7 +910,7 @@ function findFirstDynamicImport(t, fileGraph, depthBudget) {
  * reached through `MAP[k]` re-enters this arm forever without it. No
  * `foldLeaf` path here, so no early pop is needed.
  */
-function walkDynamicMember(graph, fileGraph, type, argMap, guard) {
+function walkDynamicMember(graph, fileGraph, type, argMap, guard, position) {
     if (guard.pushNode(type) === "cycle") {
         return [indeterminateTerminal()];
     }
@@ -906,7 +930,7 @@ function walkDynamicMember(graph, fileGraph, type, argMap, guard) {
             for (const propValue of Object.values(obj.props)) {
                 // Recurse via walkInner so identity is derived from each branch's
                 // leaf TypeOf (Foo/Bar resolve to their respective bindings).
-                const inner = walkInner(graph, fileGraph, propValue, argMap, guard);
+                const inner = walkInner(graph, fileGraph, propValue, argMap, guard, undefined, position);
                 const via = { kind: "dynamic-map", mapName, mapLoc };
                 for (const t of inner) {
                     if (cameToNothing(t))
@@ -954,16 +978,22 @@ function deriveHocCallee(callee) {
 }
 /**
  * Find an import record that the last arg's outermost TypeOf points at.
- * Returns null when the last arg isn't a TypeOf or isn't an imported binding.
+ * Returns null when the last arg isn't a TypeOf, isn't an imported binding,
+ * or binds to a declaration in this file's scope that shadows the import.
  */
-function findImportForLastArg(lastArg, fileGraph) {
+function findImportForLastArg(graph, lastArg, fileGraph) {
     let cur = lastArg;
     while (cur.kind === "ReturnTypeOf")
         cur = cur.callee;
     if (cur.kind !== "TypeOf")
         return null;
     const imp = fileGraph.importsByLocal.get(cur.ref.symbol);
-    return imp ? { specifier: imp.specifier, imported: imp.imported } : null;
+    if (!imp)
+        return null;
+    const binding = resolveBinding(graph, fileGraph, cur.ref);
+    if (binding.kind === "declaration" && binding.inScope && binding.file === fileGraph.filePath)
+        return null;
+    return { specifier: imp.specifier, imported: imp.imported };
 }
 /**
  * Resolve an anonymous lastArg (no leaf TypeOf, no import record) to a
@@ -1030,185 +1060,20 @@ function typeContainsRef(haystack, needle) {
     }
 }
 /**
- * Resolve an import specifier to its repo-relative POSIX target file via the
- * graph's moduleResolver + resolveToGraphKey. Returns null for unresolvable
- * specifiers or paths outside the repo root (e.g. node_modules siblings) —
- * callers fall back to the raw specifier in those cases.
- *
- * When `imported` is provided, follows re-export chains (both
- * `{kind: "named", from, fromImported}` and `{kind: "star", from}`) to the
- * canonical source file via `followReExportChain` (star re-exports are
- * first-wins). Mirrors what `resolveExport` in resolve-reference.ts
- * does for value-flow purposes,
- * applied here at identity-stamping time. So `import { X } from './barrel'`
- * where `./barrel` re-exports X from `./source` attributes the component's
- * identity to `./source.tsx`, not `./barrel.tsx`.
- *
- * Used by `deriveIdentity` so `TerminalIdentity.resolvedFile` carries the
- * canonical repo-relative path. Downstream `componentIdFromIdentity` uses
- * that canonical path so `'./page'` and `'../page'` from different callers
- * collapse to the same identity.
- */
-function resolveImportedFile(graph, fileGraph, specifier, imported) {
-    const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-    if (!abs)
-        return null;
-    const key = graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs;
-    if (!key || !imported)
-        return key;
-    return followReExportChain(graph, key, imported)?.file ?? key;
-}
-/**
- * When a relative-spec import resolves into the parsed graph (possibly via a
- * re-export chain) AND the canonical source file has a local declaration for
- * the exported name, promote the identity to `kind: "local"` directly. This
- * matches what the local-index seeds emit (keyed on `{filePath, exportName}`)
- * so the engine occurrence hashes to the same componentId as the seed —
- * preventing the barrel-vs-source phantom split.
- *
- * Symmetric with `workspaceSiblingIdentity` but for relative imports.
- */
-function relativeChainLocalIdentity(graph, fileGraph, specifier, imported) {
-    if (!graph)
-        return null;
-    if (packageNameFromSpecifier(specifier))
-        return null; // bare package — workspace-sibling path handles it
-    const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-    if (!abs)
-        return null;
-    const key = graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs;
-    if (!key || !graph.files.has(key))
-        return null;
-    const chained = followReExportChain(graph, key, imported);
-    if (!chained)
-        return null;
-    return { kind: "local", filePath: chained.file, export: chained.localExport };
-}
-/**
- * Workspace-sibling detection. A bare-package import (`@org/foo`) that
- * resolves to a file inside the parsed graph is a workspace sibling — the
- * package lives in this repo as a sibling workspace, not as a node_modules
- * dependency. Treat it as a local identity so JSX edges land on the actual
- * sibling file rather than a phantom external stub.
- *
- * Node_modules entries aren't in `graph.files` (excluded by default scan
- * globs), so they stay external naturally — no extra check needed.
- *
- * The file and export name are the ones `followReExportChain` lands on, so a
- * barrel that renames (`export { FooImpl as Foo } from "./foo"`) names the
- * binding `FooImpl` in `./foo`, the same identity the local-index seed hashes.
- */
-function workspaceSiblingIdentity(graph, fileGraph, specifier, imported) {
-    if (!graph)
-        return null;
-    if (!packageNameFromSpecifier(specifier))
-        return null;
-    const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-    const key = abs && (graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs);
-    if (!key)
-        return null;
-    const chained = followReExportChain(graph, key, imported);
-    const file = chained?.file ?? key;
-    if (!graph.files.has(file))
-        return null;
-    return { kind: "local", filePath: file, export: chained?.localExport ?? imported };
-}
-/**
- * Membership fallback for composition-path identity. When a specifier
- * resolves to an absolute target that is NOT in the parsed graph (outside
- * the scan globs, or reached through an unrealpathed node_modules symlink)
- * but IS owned by a workspace member, promote to a LOCAL identity pinned via
- * the shared unparsed-member seam — mirroring the direct-import branch in
- * engine/index.ts so both paths mint the SAME identity. The absolute
- * filePath is normalised downstream (CLI `normaliseEngineLocalId`). Runs
- * after the in-graph promotions (workspaceSiblingIdentity /
- * relativeChainLocalIdentity), so parsed targets never reach it with a
- * different answer.
- */
-function memberLocalIdentity(graph, fileGraph, specifier, imported) {
-    if (graph?.workspaceMembership === undefined)
-        return null;
-    const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-    if (!abs)
-        return null;
-    const key = graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs;
-    if (key !== null && graph.files.has(key))
-        return null;
-    const member = unparsedMemberDefinition(graph, abs, imported);
-    if (member === null)
-        return null;
-    return { kind: "local", filePath: member.absFile, export: member.exportName };
-}
-/** Append a residual member chain to a derived identity's export name. */
-function withResidual(identity, residual) {
-    if (identity === null || residual.length === 0)
-        return identity;
-    return identity.kind === "local"
-        ? { ...identity, export: compoundExportName(identity.export, residual) }
-        : { ...identity, imported: compoundExportName(identity.imported, residual) };
-}
-/**
- * Resolve the input type's leaf TypeOf ref (or DynamicImport) to either an
- * imported or a local identity. Any other shape — a `ReturnTypeOf` included —
+ * The identity of the binding a `TypeOf` reference or a `DynamicImport` names
+ * (`bindingIdentity`), with a directly reached workspace member pinned to its
+ * definition (`pinUnparsed`). Any other shape — a `ReturnTypeOf` included —
  * has no identity of its own and yields null.
- *
- * Switches FileGraph context via `ref.originFile` when set, so refs that have
- * travelled across module boundaries (e.g. cross-module function returns) are
- * derived in their authoring file — where the import / declaration tables
- * that match the ref actually live.
  */
 export function deriveIdentity(type, fileGraph, graph) {
     // A ReturnTypeOf never derives identity from its callee:
     // a resolvable factory call's identity is the declaration holding the call,
     // which every engine push site already supplies as its fallback. Returning
     // null here is what makes that fallback win.
-    const cur = type;
-    if (cur.kind === "DynamicImport") {
-        return dynamicImportIdentity(graph, fileGraph, cur);
-    }
-    if (cur.kind === "TypeOf") {
-        const symbol = cur.ref.symbol;
-        const lookup = graph ? fileGraphForRef(graph, cur.ref, fileGraph) : fileGraph;
-        const imp = lookup.importsByLocal.get(symbol);
-        if (imp) {
-            // Namespace-import members canonicalise to the member name,
-            // matching the direct-import path's `effectiveImported`
-            // (engine/index.ts) so both paths mint the same identity. The residual chain
-            // is appended AFTER every root lookup, so `Dialog.Popup` on an unparsed
-            // package and `NS.Inline` on a workspace member both mirror the direct
-            // path.
-            const imported = effectiveExportName(imp.imported, cur.ref.memberChain);
-            const residual = residualMemberChain(imp.imported, cur.ref.memberChain);
-            const resolvedFile = graph ? resolveImportedFile(graph, lookup, imp.specifier, imported) : null;
-            const workspaceLocal = workspaceSiblingIdentity(graph, lookup, imp.specifier, imported);
-            if (workspaceLocal)
-                return withResidual(workspaceLocal, residual);
-            const relativeLocal = relativeChainLocalIdentity(graph, lookup, imp.specifier, imported);
-            if (relativeLocal)
-                return withResidual(relativeLocal, residual);
-            const memberLocal = memberLocalIdentity(graph, lookup, imp.specifier, imported);
-            if (memberLocal)
-                return withResidual(memberLocal, residual);
-            return withResidual({
-                kind: "imported",
-                specifier: imp.specifier,
-                imported,
-                resolvedFile,
-            }, residual);
-        }
-        // Check local declarations. A same-file symbol is never a namespace
-        // import, so the whole member chain is residual (mirror of
-        // `pushLocalOccurrence`'s fallback) — an empty chain is a no-op.
-        for (const [, decl] of lookup.declarations) {
-            if (decl && decl.symbol === symbol) {
-                return withResidual({
-                    kind: "local",
-                    filePath: lookup.filePath,
-                    export: decl.exportedAs ?? symbol,
-                }, cur.ref.memberChain);
-            }
-        }
-    }
+    if (type.kind === "DynamicImport")
+        return dynamicImportIdentity(graph, fileGraph, type);
+    if (type.kind === "TypeOf")
+        return bindingIdentity(pinUnparsed(graph, resolveBinding(graph, fileGraph, type.ref)));
     return null;
 }
 //# sourceMappingURL=wrapper-folding.js.map