@component-compass/reference-graph 0.1.18 → 0.1.20

package/dist/engine/wrapper-folding.js

@@ -1,4 +1,4 @@
-import { resolveType, resolveToFunctions, DYNAMIC_MEMBER_KEY } from "./resolve-type.js";
+import { resolveType, resolveToFunctions, resolveDynamicImportTarget, DYNAMIC_MEMBER_KEY } from "./resolve-type.js";
 import { argumentRefKey } from "./argument-map.js";
 import { createCycleGuard } from "./cycle-detection.js";
 import { fileGraphForRef, resolveReference } from "./resolve-reference.js";
@@ -7,7 +7,7 @@ import { followReExportChain } from "./re-export-chain.js";
 import { unparsedMemberDefinition, effectiveExportName, residualMemberChain, compoundExportName } from "./member-identity.js";
 import { evalKind, isImportBackedLeaf } from "./component-shape.js";
 import { assertNever } from "./assert-never.js";
-/** Ruling 19: true when a `ReturnTypeOf`'s callee is a data-method render
+/** 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)
  *  uses to answer `"jsx"` instead of `"component"`. Shared, not re-derived:
@@ -17,7 +17,7 @@ function isDataMethodRenderCall(type, graph, fileGraph, guard) {
     return type.callee.kind === "MemberOf" && !isImportBackedLeaf(type.callee, graph, fileGraph, guard);
 }
 /**
- * THE single seam for unreducible-leaf identity synthesis (#135 / #274).
+ * THE single seam for unreducible-leaf identity synthesis.
  *
  * Maps `resolveType` results into FoldedTerminals. When the algebra preserved
  * an identity-bearing leaf — an import-backed TypeOf or a DynamicImport that
@@ -40,12 +40,10 @@ function foldTerminals(graph, fileGraph, results, fallback) {
             }
         }
         // A fan-out branch (Union / dynamic-map) is stamped as `source`. Derive
-        // from it FIRST — a branch that has its own binding must win (#131) —
+        // from it FIRST — a branch that has its own binding must win —
         // and only fall back to the resolved binding when the branch carries no
         // identity of its own (e.g. a bare `{kind:"JSX"}` branch from a lowered
-        // ternary/logical render body). Committing to `source ?? fallback` before
-        // deriving discarded the fallback entirely once any fanout occurred, even
-        // when the branch itself resolved to nothing.
+        // ternary/logical render body).
         const identity = (source && deriveIdentity(source, fileGraph, graph)) ?? deriveIdentity(fallback, fileGraph, graph);
         return {
             type: t,
@@ -60,10 +58,11 @@ function foldTerminals(graph, fileGraph, results, fallback) {
  * a seen-through wrapper and an opaque one attribute identically. Inner
  * terminals pass through with the wrapper hop prepended. When the inner walk
  * bottomed out at Unknown but carried an identity hint (imported, or
- * local-promoted via #101), synthesise a JSX terminal from it — without this
+ * local-promoted through the re-export chain), synthesise a JSX terminal
+ * from it — without this
  * rescue, HOC-wrapped occurrences drop silently (~128 in example-web's
- * connect/flow/withTranslators patterns, diagnosed on PR #141). Truly
- * nothing → a single Unknown terminal, as before.
+ * connect/flow/withTranslators patterns). Truly
+ * nothing → a single Unknown terminal.
  */
 function foldToWrappedArg(inner, via) {
     const innerHasNonUnknown = inner.some((t) => t.type.kind !== "Unknown");
@@ -83,7 +82,7 @@ function foldToWrappedArg(inner, via) {
  * resolution. THE single helper for both via kinds that describe a wrapped
  * argument (`hoc-wrapper` when the wrapper folds to the argument,
  * `passed-as-argument` when the holder is its own identity and the argument
- * is seeded at its site — spec §4), so the two name a binding identically.
+ * 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) {
@@ -128,10 +127,8 @@ function identityKey(id) {
 function isPassThroughWrapper(algResult, inner) {
     const innerKeys = new Set(inner.filter((t) => t.type.kind !== "Unknown" && t.identity !== null).map((t) => identityKey(t.identity)));
     const algKeys = algResult.filter((t) => t.type.kind !== "Unknown");
-    // A null identity on either side is "no information", never a match — the
-    // old null-equals-null comparison folded factory calls onto their
-    // rehydrate/config argument once the callee unwrap stopped inventing an
-    // identity for the algebra side.
+    // A null identity on either side is "no information", never a match:
+    // null-equals-null folds a factory call onto its rehydrate/config argument.
     return algKeys.length > 0 && algKeys.every((t) => t.identity !== null && innerKeys.has(identityKey(t.identity)));
 }
 /**
@@ -143,21 +140,18 @@ function isPassThroughWrapper(algResult, inner) {
  * For nodes where no folding rule applies, delegates to `resolveType`
  * (pure algebra) and computes identity from the input type's leaf TypeOf
  * when one can be confidently identified.
- *
- * See spec: docs/superpowers/specs/2026-05-19-wrapper-folding-engine-extension-design.md §4.3
  */
 export function walkWithFolding(graph, fileGraph, type, argMap, guard = createCycleGuard(), 
-// Ruling 20: the identity `foldTerminals` falls back to when a terminal
+// The identity `foldTerminals` falls back to when a terminal
 // carries no identity of its own (no `source`, no unreducible TypeOf/
-// DynamicImport leaf). Defaults to `type` (the walked node itself) —
-// unchanged behaviour for every caller that doesn't pass this. The
+// DynamicImport leaf). Defaults to `type` (the walked node itself). The
 // `Function` arm below is the ONE place that overrides it: a component's
 // own return (`return priceElement;`, `return contactModals;` — a bare
 // JSX-value alias or a hook-return leaf) must keep deriving identity as
 // "nothing", so the engine's own fallback (the rendered declaration, e.g.
 // `OfferPrice`) wins — never a same-file local alias like `priceElement`
 // that happens to sit in `foldTerminals`' fallback slot. Per-branch
-// identity from a fanout `source` (#131 — Union([TypeOf A, TypeOf B])) is
+// identity from a fanout `source` (Union([TypeOf A, TypeOf B])) is
 // untouched: `source` is checked BEFORE this fallback in `foldTerminals`.
 identityFallback) {
     const fallback = identityFallback ?? type;
@@ -170,26 +164,25 @@ identityFallback) {
             }
             return walkStaticMember(graph, fileGraph, type, argMap, guard, fallback);
         case "Function":
-            // Ruling 19: a component's own returns can contain a nested
+            // 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/>`) silently produced zero occurrences before this.
-            // Mirrors `resolveType`'s "Function" case, one level up. Ruling 20:
-            // pass THIS Function as the identity fallback for every return — a
+            // (e.g. `<List/>`) would silently produce zero occurrences.
+            // 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, matching the pre-ruling-19 semantics this restores.
+            // is always null.
             return type.returns.flatMap((r) => walkWithFolding(graph, fileGraph, r, argMap, guard, type));
         case "TypeOf":
             return walkTypeOf(graph, fileGraph, type, argMap, guard, fallback);
         case "Union":
-            // Structural re-entry (D1/D3): each branch walks through the walker so
+            // Structural re-entry: each branch walks through the walker so
             // a TypeOf branch reaches `walkTypeOf` and decides its own identity
-            // (per-branch attribution, #131) while a bare JSX branch — a lowered
-            // ternary/logical render body — derives from the outer fallback exactly
-            // as the algebra's `source ?? fallback` did.
+            // (per-branch attribution) while a bare JSX branch — a lowered
+            // ternary/logical render body — derives from the outer fallback.
             return type.types.flatMap((branch) => walkWithFolding(graph, fileGraph, branch, argMap, guard, fallback));
         case "ParameterOf":
         case "DynamicImport":
@@ -214,14 +207,14 @@ function foldLeaf(graph, fileGraph, type, argMap, guard, fallback) {
     return foldTerminals(graph, fileGraph, resolveType(graph, fileGraph, type, argMap, guard), fallback);
 }
 /**
- * THE seam for "walk a Function in its authoring file" (spec D4). A Function
+ * THE seam for "walk a Function in its authoring file". A Function
  * declared in another module must walk in THAT module's graph, because the
  * walker's file-scoped lookups inside it — a dynamic map's binding
  * (`findMapBinding`), an import table — only resolve where the code was
- * written. Originally `walkDispatcherReturns`' rationale (#136): a
- * cross-module `function getMapped(k) { return MAP[k]; }` walked in the
- * caller's fileGraph misses `MAP` entirely and loses the `dynamic-map` hop.
- * `walkTypeOf` needs the identical switch, so it is one function, not two.
+ * written: a cross-module `function getMapped(k) { return MAP[k]; }`
+ * walked in the caller's fileGraph misses `MAP` entirely and loses the
+ * `dynamic-map` hop. `walkDispatcherReturns` and `walkTypeOf` need the
+ * identical switch, so it is one function, not two.
  * Falls back to the caller's graph when the file is absent or unindexed.
  */
 function fileGraphForFunction(graph, fileGraph, fn) {
@@ -230,25 +223,58 @@ function fileGraphForFunction(graph, fileGraph, fn) {
         : fileGraph;
 }
 /**
- * Structural re-entry for a reference (spec D1–D4, D6; #521). Resolves ONE
+ * The file a DynamicImport's specifier resolves against: the file that
+ * contains the `import()`, whichever file the walk is standing in.
+ */
+export function fileGraphForDynamicImport(graph, di, fallback) {
+    if (!graph || di.originFile === fallback.filePath)
+        return 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`.
+ */
+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, di.specifier, importedName, resolvedFile) ??
+        relativeChainLocalIdentity(graph, origin, di.specifier, importedName) ??
+        memberLocalIdentity(graph, origin, di.specifier, importedName) ?? {
+        kind: "imported",
+        specifier: di.specifier,
+        imported: importedName,
+        resolvedFile,
+    });
+}
+/**
+ * Structural re-entry for a reference. Resolves ONE
  * hop and walks the resolved value through `walkWithFolding`, so every walker
- * rule — wrapper hops, dynamic maps, Ruling 19's `.map()` bodies — applies
- * through an alias exactly as at a direct render site. Before this arm the
- * default fold handed the whole subtree to `resolveType`, which never comes
- * back, so a map-bodied `List` reached via `MAP[k]` died as Unknown.
+ * rule — wrapper hops, dynamic maps, `.map()` bodies — applies
+ * through an alias exactly as at a direct render site. Without this arm the
+ * default fold hands the whole subtree to `resolveType`, which never comes
+ * back, so a map-bodied `List` reached via `MAP[k]` dies as Unknown.
  *
- * Identity (D2): a terminal that comes back with no identity of its own is
+ * 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: Ruling 20 by construction rather than by special case.
+ * fallback wins, by construction rather than by special case.
  *
- * An import the graph cannot see (`resolved` is Unknown) is NOT re-entered
- * (D6): it is the identity-bearing leaf `foldLeaf` synthesises from
- * (#135/#274), and `foldToWrappedArg`'s rescue relies on that shape.
+ * An import the graph cannot see (`resolved` is Unknown) is NOT re-entered:
+ * it is the identity-bearing leaf `foldLeaf` synthesises from, and
+ * `foldToWrappedArg`'s rescue relies on that shape.
  *
- * Cross-file (D4): a Function authored elsewhere walks in ITS file graph
+ * Cross-file: a Function authored elsewhere walks in ITS file graph
  * through the `fileGraphForFunction` seam — the same switch
  * `walkDispatcherReturns` makes — so file-scoped lookups inside it (a dynamic
  * map's binding) resolve where they were written.
@@ -286,13 +312,13 @@ function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
     }
 }
 /**
- * Static member access (spec D5; #512). Mirrors `walkDynamicMember` for one
+ * Static member access. Mirrors `walkDynamicMember` for one
  * named prop and without the `dynamic-map` hop: resolve the object, take the
  * member, walk the member's VALUE through `walkWithFolding` — so a wrapper
  * product stored in a map (`MAP.memo` → `memo(Button)`) reaches
  * `walkReturnTypeOf` and keeps its `hoc-wrapper` hop. Anything that is not an
  * in-graph Object (an Array, an import-backed namespace the graph cannot see)
- * takes the leaf fold exactly as before.
+ * takes the leaf fold.
  *
  * Cycle guard: mirrors `walkTypeOf`. `const A = { Item: () => B.Item };
  * const B = { Item: () => A.Item }` is legal, loadable JS and the walk
@@ -340,8 +366,22 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
             kind: "DynamicImport",
             specifier: lazyShape.specifier,
             projection: lazyShape.projection,
+            originFile: lazyShape.originFile,
         };
-        const inner = walkWithFolding(graph, fileGraph, syntheticDI, argMap, guard);
+        const guardKey = `import()::${syntheticDI.specifier}::${syntheticDI.projection.join(".")}`;
+        if (guard.push(syntheticDI.originFile, guardKey) !== "ok") {
+            return [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        }
+        let inner;
+        try {
+            const target = resolveDynamicImportTarget(graph, fileGraph, syntheticDI, guard);
+            inner = target
+                ? walkWithFolding(graph, target.targetFileGraph, target.value, argMap, guard)
+                : walkWithFolding(graph, fileGraph, syntheticDI, argMap, guard);
+        }
+        finally {
+            guard.pop(syntheticDI.originFile, guardKey);
+        }
         const wrapperCallee = deriveHocCallee(type.callee);
         const importedName = lazyShape.projection[0] ?? "default";
         const via = {
@@ -350,30 +390,9 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
             specifier: lazyShape.specifier,
             import: importedName,
         };
-        // OVERRIDE identity with the DynamicImport-derived identity. The inner
-        // walk resolved algebraically through the DynamicImport but its
-        // identity field defaults to null (resolveType doesn't track which
-        // module the JSX came from); we know the source from lazyShape.
-        // Canonicalise via moduleResolver so `lazy(() => import('./x'))` and
-        // `lazy(() => import('../x'))` from different callers collapse (#109);
-        // promote to local when the chain resolves into the graph (#101).
-        // Workspace-sibling bare-package lazy targets promote to local too (#94
-        // parity with deriveIdentity's DynamicImport branch, #327 — validated
-        // against a real monorepo where `next/dynamic` member imports split
-        // identity: a bare-package specifier that resolves to an in-graph file
-        // via the workspace-exports resolver was falling through to `imported`
-        // because this chain never called `workspaceSiblingIdentity`).
-        const resolvedFile = resolveImportedFile(graph, fileGraph, lazyShape.specifier, importedName);
-        const workspaceLocal = workspaceSiblingIdentity(graph, lazyShape.specifier, importedName, resolvedFile);
-        const relativeLocal = relativeChainLocalIdentity(graph, fileGraph, lazyShape.specifier, importedName);
-        const identity = workspaceLocal ??
-            relativeLocal ??
-            memberLocalIdentity(graph, fileGraph, lazyShape.specifier, importedName) ?? {
-            kind: "imported",
-            specifier: lazyShape.specifier,
-            imported: importedName,
-            resolvedFile,
-        };
+        // A terminal keeps the identity its own fold produced; the import-derived
+        // identity covers terminals that carry none.
+        const identity = dynamicImportIdentity(graph, fileGraph, syntheticDI);
         const innerHasNonUnknown = inner.some((t) => t.type.kind !== "Unknown");
         if (innerHasNonUnknown) {
             return inner
@@ -381,14 +400,17 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
                 .map((t) => ({
                 type: t.type,
                 viaTrail: [via, ...t.viaTrail],
-                identity,
+                identity: t.identity ?? identity,
             }));
         }
-        // External package: target not in graph. We still have a valid specifier+projection
-        // from lazyShape — synthesize a JSX terminal rather than falling through to Unknown.
+        // External package: target not in graph. Also reached when the inner walk
+        // was cut by the import cycle key above or by the depth budget, in which
+        // case the import-derived identity is the answer. We still have a valid
+        // specifier+projection from lazyShape — synthesize a JSX terminal rather
+        // than falling through to Unknown.
         return [{ type: { kind: "JSX" }, viaTrail: [via], identity }];
     }
-    // (2) Dispatcher detection (#136): if the callee resolves to a Function
+    // (2) Dispatcher detection: if the callee resolves to a Function
     // whose body returns a dynamic-map access (`return MAP[k]`), walk that body
     // via walkWithFolding in the function's authoring fileGraph. This lets the
     // walkDynamicMember rule fire and surfaces the dynamic-map via in the chain
@@ -397,7 +419,7 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
     const dispatcherResult = walkDispatcherReturns(graph, fileGraph, type, argMap, guard);
     if (dispatcherResult)
         return dispatcherResult;
-    // (2b) Structural pass-through (spec D9 arm 1; #328). When every Function
+    // (2b) Structural pass-through. When every Function
     // the callee resolves to returns its own parameter (a bare `ParameterOf`, or a `TypeOf` that resolves to one) bound by THIS call,
     // the wrapper is identity-preserving by construction — `c => c`; React's
     // memo/forwardRef reach this arm through a library stub table, regardless
@@ -417,17 +439,17 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
     // (3) Pure algebra walk. Per-leaf identity uses each terminal's source
     // (the leaf at the innermost fanout fork that produced it) so dynamic-map /
     // Union / Array fanouts attribute each branch to its own binding instead
-    // of collapsing every leaf to the outer wrapper's identity (#131).
+    // of collapsing every leaf to the outer wrapper's identity.
     // foldTerminals also converts unreducible identity-bearing leaves into
     // synthesized JSX terminals, so a resolvable and an unresolvable imported
-    // leaf take the same emission path (#274).
+    // leaf take the same emission path.
     const algResult = foldTerminals(graph, fileGraph, resolveType(graph, fileGraph, type, argMap, guard), type);
     const algHasNonUnknown = algResult.some((r) => r.type.kind !== "Unknown");
     if (algHasNonUnknown) {
         // (3b) Pass-through HOC recovery. When the algebra reduces this call to the
         // identity of its wrapped last arg (an identity-preserving `c => c` wrapper
-        // — withRouter/connect stubs, and now direct external-import calls the leaf
-        // synthesis at #274 lets the algebra see through), the reduction flattened
+        // — withRouter/connect stubs, plus direct external-import calls the leaf
+        // synthesis lets the algebra see through), the reduction flattened
         // the wrapper breadcrumb away. Recover it so a seen-through wrapper and an
         // opaque one (step 4) attribute composition identically: via presence
         // tracks the wrapper, not the algebra's reach. A wrapper whose body returns
@@ -451,14 +473,13 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
         return [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
     }
     const inner = walkWithFolding(graph, fileGraph, lastArg, argMap, guard);
-    // Ruling 19: a data-method render call (`items.map(render)`) is not a
+    // 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
     // `hoc-wrapper` hop, and identity stays null so the engine's own fallback
     // (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 existing fold+hop
-    // below — arm 3 (D9) stands for those.
+    // callees (`Sentry.withProfiler`) fall through to the fold+hop below.
     if (isDataMethodRenderCall(type, graph, fileGraph, guard)) {
         const nonUnknown = inner.filter((t) => t.type.kind !== "Unknown");
         if (nonUnknown.length > 0) {
@@ -475,7 +496,7 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
  * a `TypeOf` resolved one hop) to a `ParameterOf` whose `fn` is the ref this
  * call binds args to (`bindingRef`), and every return names the same index.
  * Unions, JSX, nested Functions or an unresolvable callee all yield null so the
- * existing algebra / opaque-HOC paths handle them exactly as before.
+ * algebra / opaque-HOC paths handle them instead.
  */
 function passThroughParameterIndex(graph, fileGraph, type, argMap, guard) {
     const calleeFns = resolveToFunctions(graph, fileGraph, type.callee, argMap, guard);
@@ -504,7 +525,7 @@ function passThroughParameterIndex(graph, fileGraph, type, argMap, guard) {
     return index;
 }
 /**
- * Cross-module dispatcher walk (#136). When the callee of a ReturnTypeOf
+ * Cross-module dispatcher walk. When the callee of a ReturnTypeOf
  * resolves to a Function whose body returns a `MemberOf-DYNAMIC` access
  * (the canonical `function getMapped(k) { return MAP[k]; }` shape), the
  * dynamic-map fanout lives across a module boundary from the call site.
@@ -556,13 +577,19 @@ function findLazyImportArg(args, fileGraph) {
     for (const arg of args) {
         const di = findFirstDynamicImport(arg, fileGraph, /*depthBudget=*/ 1);
         if (di)
-            return { arg, specifier: di.specifier, projection: di.projection };
+            return di;
     }
     return null;
 }
+const PROMISE_METHODS = new Set(["then", "catch", "finally"]);
+/** The crediting finder: narrow by design, and the only one that may claim a
+ *  projection. `firstDynamicImport` (`engine/component-shape.ts`) is the
+ *  reporting inverse — it descends everything and names a specifier only for
+ *  the diagnostic. */
 function findFirstDynamicImport(t, fileGraph, depthBudget) {
-    if (t.kind === "DynamicImport")
-        return { specifier: t.specifier, projection: t.projection };
+    if (t.kind === "DynamicImport") {
+        return { specifier: t.specifier, projection: t.projection, originFile: t.originFile };
+    }
     if (t.kind === "Function") {
         for (const r of t.returns) {
             const hit = findFirstDynamicImport(r, fileGraph, depthBudget);
@@ -571,14 +598,21 @@ function findFirstDynamicImport(t, fileGraph, depthBudget) {
         }
         return null;
     }
+    if (t.kind === "ReturnTypeOf" && t.callee.kind === "MemberOf" && PROMISE_METHODS.has(t.callee.member)) {
+        // `catch`/`finally` keep the import's value; a `then` the parser did not
+        // collapse cannot name an export, so the import stays unclaimed.
+        return t.callee.member === "then" ? null : findFirstDynamicImport(t.callee.obj, fileGraph, depthBudget);
+    }
     if (t.kind === "MemberOf") {
+        if (PROMISE_METHODS.has(t.member))
+            return null;
         // Descend into obj; if the inner result is a bare namespace DynamicImport
         // (projection=[]), append this member as the named-export projection so
         // that the async-await form `m.X` where `m = DynamicImport("./foo", [])`
         // produces projection:["X"] instead of projection:[].
         const inner = findFirstDynamicImport(t.obj, fileGraph, depthBudget);
         if (inner && t.member !== "" && inner.projection.length === 0) {
-            return { specifier: inner.specifier, projection: [t.member] };
+            return { specifier: inner.specifier, projection: [t.member], originFile: inner.originFile };
         }
         return inner;
     }
@@ -690,19 +724,19 @@ function resolveAnonymousLastArg(lastArg, fileGraph) {
     let cur = lastArg;
     while (cur.kind === "ReturnTypeOf")
         cur = cur.callee;
-    // (1) Leaf TypeOf — surface the bound symbol directly (preserves the
-    // historical hocCallee-adjacent behaviour for chains like `withA(withB(X))`,
-    // where the inner-call's callee name is the most descriptive via.import).
+    // (1) Leaf TypeOf — surface the bound symbol directly: for chains like
+    // `withA(withB(X))` the inner call's callee name is the most descriptive
+    // via.import.
     if (cur.kind === "TypeOf") {
         return { specifier: fileGraph.filePath, import: cur.ref.symbol };
     }
     // (2) Function tagged at parser-emit time — works across file boundaries
-    // because the annotation travels with the value (#130).
+    // because the annotation travels with the value.
     if (cur.kind === "Function" && cur.enclosingBinding) {
         return { specifier: cur.enclosingBinding.file, import: cur.enclosingBinding.symbol };
     }
     // (3) Same-file reference-equality scan — find the declaration whose
-    // value tree contains lastArg (#122 same-file fallback).
+    // value tree contains lastArg (same-file fallback).
     for (const decl of fileGraph.declarations.values()) {
         if (decl && typeContainsRef(decl.value, lastArg)) {
             return { specifier: fileGraph.filePath, import: decl.symbol };
@@ -749,9 +783,9 @@ function typeContainsRef(haystack, needle) {
  *
  * When `imported` is provided, follows re-export chains (both
  * `{kind: "named", from, fromImported}` and `{kind: "star", from}`) to the
- * canonical source file via `followReExportChain` — which gained star support
- * in #158 with first-wins priority. Mirrors what
- * `resolveExport` in resolve-reference.ts does for value-flow purposes,
+ * 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`.
@@ -759,7 +793,7 @@ function typeContainsRef(haystack, needle) {
  * 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 (#109 — Omlet's ModuleResolver shape).
+ * collapse to the same identity.
  */
 function resolveImportedFile(graph, fileGraph, specifier, imported) {
     const abs = graph.moduleResolver(fileGraph.filePath, specifier);
@@ -776,9 +810,9 @@ function resolveImportedFile(graph, fileGraph, specifier, imported) {
  * 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 (#101).
+ * preventing the barrel-vs-source phantom split.
  *
- * Symmetric with `workspaceSiblingIdentity` (#94) but for relative imports.
+ * Symmetric with `workspaceSiblingIdentity` but for relative imports.
  */
 function relativeChainLocalIdentity(graph, fileGraph, specifier, imported) {
     if (!graph)
@@ -797,7 +831,7 @@ function relativeChainLocalIdentity(graph, fileGraph, specifier, imported) {
     return { kind: "local", filePath: chained.file, export: chained.localExport };
 }
 /**
- * Workspace-sibling detection (#94). A bare-package import (`@org/foo`) that
+ * 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
@@ -832,7 +866,7 @@ function workspaceSiblingIdentity(graph, specifier, imported, resolvedFile) {
     return { kind: "local", filePath: resolvedFile, export: exportName };
 }
 /**
- * Membership fallback for composition-path identity (#327). When a specifier
+ * 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
@@ -857,7 +891,7 @@ function memberLocalIdentity(graph, fileGraph, specifier, imported) {
         return null;
     return { kind: "local", filePath: member.absFile, export: member.exportName };
 }
-/** Append a residual member chain (#518) to a derived identity's export name. */
+/** Append a residual member chain to a derived identity's export name. */
 function withResidual(identity, residual) {
     if (identity === null || residual.length === 0)
         return identity;
@@ -876,42 +910,22 @@ function withResidual(identity, residual) {
  * that match the ref actually live.
  */
 export function deriveIdentity(type, fileGraph, graph) {
-    // A ReturnTypeOf never derives identity from its callee (spec D9 arm 2):
+    // 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. (#271, #328)
+    // null here is what makes that fallback win.
     const cur = type;
     if (cur.kind === "DynamicImport") {
-        const importedName = cur.projection[0] ?? "default";
-        const resolvedFile = graph ? resolveImportedFile(graph, fileGraph, cur.specifier, importedName) : null;
-        const workspaceLocal = workspaceSiblingIdentity(graph, cur.specifier, importedName, resolvedFile);
-        if (workspaceLocal)
-            return workspaceLocal;
-        // Re-export-chain-followed relative imports promote to local (#101).
-        const relativeLocal = relativeChainLocalIdentity(graph, fileGraph, cur.specifier, importedName);
-        if (relativeLocal)
-            return relativeLocal;
-        const memberLocal = memberLocalIdentity(graph, fileGraph, cur.specifier, importedName);
-        if (memberLocal)
-            return memberLocal;
-        return {
-            kind: "imported",
-            specifier: cur.specifier,
-            imported: importedName,
-            // Canonicalise via moduleResolver — `lazy(() => import('./x'))` and
-            // `lazy(() => import('../x'))` from different callers collapse to one
-            // identity (#109).
-            resolvedFile,
-        };
+        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 (#394),
-            // matching the direct-import path's `effectiveImported` (engine/index.ts,
-            // #362) so both paths mint the same identity. The residual chain (#518)
+            // 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.
@@ -936,7 +950,7 @@ export function deriveIdentity(type, fileGraph, graph) {
         }
         // Check local declarations. A same-file symbol is never a namespace
         // import, so the whole member chain is residual (mirror of
-        // `pushLocalOccurrence`'s fallback, #518) — an empty chain is a no-op.
+        // `pushLocalOccurrence`'s fallback) — an empty chain is a no-op.
         for (const [, decl] of lookup.declarations) {
             if (decl && decl.symbol === symbol) {
                 return withResidual({