@component-compass/reference-graph 0.1.23 → 0.1.25

package/dist/engine/wrapper-folding.js

@@ -1,12 +1,15 @@
+import { findLocalDeclaration } from "./helper-callers.js";
 import { resolveType, resolveToFunctions, resolveDynamicImportTarget, DYNAMIC_MEMBER_KEY } from "./resolve-type.js";
-import { argumentRefKey } from "./argument-map.js";
+import { argumentRefKey, boundArgument } from "./argument-map.js";
 import { createCycleGuard } from "./cycle-detection.js";
 import { fileGraphForRef, resolveReference } from "./resolve-reference.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, 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)
@@ -16,13 +19,192 @@ import { assertNever } from "./assert-never.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) {
+    return { denotation: t.denotation, viaTrail: t.viaTrail, identity: t.identity, semantics };
+}
+/** The product every branch of an evaluation is marked with; null when any
+ *  branch is unmarked or marked differently. */
+function markedProduct(terminals) {
+    const first = terminals[0]?.semantics;
+    if (first === undefined)
+        return null;
+    return terminals.every((t) => t.semantics === first) ? first : null;
+}
+/** THE in-walker replacement for `t.type.kind === "Unknown"`, stated once and
+ *  read only through `matchDenotation`: "this branch came to nothing".
+ *
+ *  `late-bound` answers `true`: the values it classifies reduce to `Unknown` in
+ *  the algebra. `opaque` is in the record for exhaustiveness only — the walk
+ *  mints it at the public boundary and never reads it back, so no internal
+ *  path can observe that handler. */
+const CAME_TO_NOTHING = {
+    element: () => false,
+    foreign: () => false,
+    "host-string": () => false,
+    opaque: () => true,
+    "late-bound": () => true,
+    data: () => false,
+    indeterminate: () => true,
+    callable: () => false,
+};
+function cameToNothing(t) {
+    return matchDenotation(t, CAME_TO_NOTHING);
+}
+const IS_LATE_BOUND = {
+    element: () => false,
+    foreign: () => false,
+    "host-string": () => false,
+    opaque: () => false,
+    "late-bound": () => true,
+    data: () => false,
+    indeterminate: () => false,
+    callable: () => false,
+};
+/**
+ * Rename a branch that came to nothing, keeping its identity and viaTrail
+ * exactly as the fold produced them, and dropping any product mark: the new
+ * denotation is what the branch is now. A branch that reduced to something the
+ * walk does know keeps its own denotation and its mark.
+ */
+function relabel(denotation) {
+    return (t) => (cameToNothing(t) ? { denotation, viaTrail: t.viaTrail, identity: t.identity } : t);
+}
+function asLateBound(source) {
+    return relabel({ kind: "late-bound", source });
+}
+/** True when every branch of an evaluation is a value supplied elsewhere. */
+function evaluatesLateBound(terminals) {
+    return terminals.length > 0 && terminals.every((t) => matchDenotation(t, IS_LATE_BOUND));
+}
+/**
+ * THE boundary between "what this value IS" and "what this function returns".
+ *
+ * A string becomes the data the function returns; a late-bound value becomes
+ * "nothing known"; a product mark is dropped, so a function that returns a
+ * context is not itself a context. `opaque` is in the record for
+ * exhaustiveness only — no internal path produces that denotation.
+ *
+ * Stated once and applied at exactly two places: the `Function` arm of
+ * `walkInner` and the exit of `walkReturnTypeOf`.
+ */
+const AS_RETURNED_VALUE = {
+    element: (d) => d,
+    foreign: (d) => d,
+    "host-string": () => ({ kind: "data", shape: "string" }),
+    opaque: () => INDETERMINATE,
+    "late-bound": () => INDETERMINATE,
+    data: (d) => d,
+    indeterminate: (d) => d,
+    callable: (d) => d,
+};
+function returnedValue(t) {
+    const denotation = matchDenotation(t, AS_RETURNED_VALUE);
+    return denotation === t.denotation && t.semantics === undefined
+        ? t
+        : { denotation, viaTrail: t.viaTrail, identity: t.identity };
+}
+function indeterminateTerminal() {
+    return { denotation: INDETERMINATE, viaTrail: [], identity: null };
+}
+/** THE one place a product mark becomes a denotation. A marked branch the tag
+ *  would credit keeps the denotation it earned; any other marked branch IS the
+ *  product. */
+function published(t) {
+    if (t.semantics === undefined)
+        return t;
+    const denotation = creditedTerminals([t]).length > 0 ? t.denotation : { kind: "opaque", semantics: t.semantics };
+    return { denotation, viaTrail: t.viaTrail, identity: t.identity };
+}
+/** The public boundary's guarantee, and only the public boundary's: an
+ *  `Evaluation` handed to a caller is never empty, because a caller has
+ *  nothing to read otherwise. Inside the walk `[]` stays `[]`. */
+function atLeastOne(terminals) {
+    return terminals.length > 0 ? terminals : [indeterminateTerminal()];
+}
+/**
+ * What one `resolveType` terminal denotes. `synthesised` marks the unreducible
+ * import-backed leaf `foldTerminals` mints an identity for: the reference is
+ * real and its target unparseable, so the value is `foreign`. `indeterminate`
+ * is reserved for the terminal the algebra bottomed out at knowing nothing —
+ * a value the algebra did reduce, to a string or to data, is not that.
+ */
+function denote(type, synthesised) {
+    if (synthesised)
+        return { kind: "foreign" };
+    switch (type.kind) {
+        case "JSX":
+            return { kind: "element" };
+        case "Str":
+            return { kind: "host-string", value: type.value };
+        case "Object":
+            return { kind: "data", shape: "object" };
+        case "Array":
+            return { kind: "data", shape: "array" };
+        case "TypeOf":
+        case "Function":
+        case "ReturnTypeOf":
+        case "ParameterOf":
+        case "MemberOf":
+        case "Union":
+        case "Unknown":
+        case "DynamicImport":
+            return INDETERMINATE;
+        default:
+            return assertNever(type);
+    }
+}
 /**
  * THE single seam for unreducible-leaf identity synthesis.
  *
- * Maps `resolveType` results into FoldedTerminals. When the algebra preserved
+ * Maps `resolveType` results into Terminals. When the algebra preserved
  * an identity-bearing leaf — an import-backed TypeOf or a DynamicImport that
  * couldn't be reduced (see resolve-type.ts's TypeOf/DynamicImport cases) —
- * synthesize a JSX terminal carrying the identity derived FROM THE TERMINAL
+ * synthesize a `foreign` terminal carrying the identity derived FROM THE TERMINAL
  * ITSELF: the reference is real even though its target can't be parsed
  * (external package, CJS, unresolvable specifier). Every other terminal
  * derives identity from `source`, falling back to `fallback` only when the
@@ -36,7 +218,7 @@ function foldTerminals(graph, fileGraph, results, fallback) {
         if (t.kind === "TypeOf" || t.kind === "DynamicImport") {
             const identity = deriveIdentity(t, fileGraph, graph);
             if (identity !== null) {
-                return { type: { kind: "JSX" }, viaTrail: [], identity };
+                return { denotation: denote(t, true), viaTrail: [], identity };
             }
         }
         // A fan-out branch (Union / dynamic-map) is stamped as `source`. Derive
@@ -46,7 +228,7 @@ function foldTerminals(graph, fileGraph, results, fallback) {
         // ternary/logical render body).
         const identity = (source && deriveIdentity(source, fileGraph, graph)) ?? deriveIdentity(fallback, fileGraph, graph);
         return {
-            type: t,
+            denotation: denote(t, false),
             viaTrail: [],
             identity,
         };
@@ -58,22 +240,24 @@ 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 through the re-export chain), synthesise a JSX terminal
+ * local-promoted through the re-export chain), synthesise a `foreign` terminal
  * from it — without this
  * rescue, HOC-wrapped occurrences drop silently (~128 in example-web's
  * connect/flow/withTranslators patterns). Truly
  * nothing → a single Unknown terminal.
  */
 function foldToWrappedArg(inner, via) {
-    const innerHasNonUnknown = inner.some((t) => t.type.kind !== "Unknown");
+    // Drops the product mark: what a wrapper call returns is not the wrapped
+    // value, so `memo(Ctx)` is not a context.
+    const innerHasNonUnknown = inner.some((t) => !cameToNothing(t));
     if (innerHasNonUnknown) {
-        return inner.map((t) => ({ type: t.type, viaTrail: [via, ...t.viaTrail], identity: t.identity }));
+        return inner.map((t) => ({ denotation: t.denotation, viaTrail: [via, ...t.viaTrail], identity: t.identity }));
     }
     const synthesisIdentity = inner.find((t) => t.identity !== null)?.identity ?? null;
     if (synthesisIdentity) {
-        return [{ type: { kind: "JSX" }, viaTrail: [via], identity: synthesisIdentity }];
+        return [{ denotation: { kind: "foreign" }, viaTrail: [via], identity: synthesisIdentity }];
     }
-    return [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+    return [indeterminateTerminal()];
 }
 /**
  * Provenance of ONE argument of a wrapper call: the wrapper's `callee` name
@@ -150,8 +334,8 @@ function identityKey(id) {
  * returns a DIFFERENT component fails this and keeps its richer algebra result.
  */
 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");
+    const innerKeys = new Set(inner.filter((t) => !cameToNothing(t) && t.identity !== null).map((t) => identityKey(t.identity)));
+    const algKeys = algResult.filter((t) => !cameToNothing(t));
     // 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)));
@@ -166,7 +350,23 @@ 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(), 
+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
 // carries no identity of its own (no `source`, no unreducible TypeOf/
 // DynamicImport leaf). Defaults to `type` (the walked node itself). The
@@ -178,38 +378,46 @@ export function walkWithFolding(graph, fileGraph, type, argMap, guard = createCy
 // 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.
-            return type.returns.flatMap((r) => walkWithFolding(graph, fileGraph, r, argMap, guard, type));
+            if (position === "tag")
+                return [{ denotation: { kind: "callable" }, identity: null, viaTrail: [] }];
+            return type.returns
+                .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) => walkWithFolding(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":
         case "Object":
         case "Array":
@@ -221,12 +429,25 @@ identityFallback) {
             return assertNever(type);
     }
 }
+/**
+ * A parameter. Bound by the call the walk is inside — `resolveType`
+ * substitutes the argument and the walk continues into it, exactly as before.
+ * Unbound, the value is supplied by whoever calls this function later, which
+ * is a different fact from "nothing is known": the algebra flattens both to
+ * `Unknown`, and only the render site acts on the difference.
+ */
+function walkParameter(graph, fileGraph, type, argMap, guard, fallback) {
+    const leaf = foldLeaf(graph, fileGraph, type, argMap, guard, fallback);
+    if (boundArgument(argMap, type) !== undefined)
+        return leaf;
+    return leaf.map(asLateBound("parameter"));
+}
 /**
  * The leaf fold: pure algebra, then identity synthesis through the ONE
  * unreducible-leaf seam (`foldTerminals`). This is the only place the walker
  * hands a subtree to `resolveType`; every structural kind (TypeOf, Union,
  * MemberOf, Function, ReturnTypeOf) has its own arm above and re-enters
- * `walkWithFolding` instead.
+ * `walkInner` instead.
  */
 function foldLeaf(graph, fileGraph, type, argMap, guard, fallback) {
     return foldTerminals(graph, fileGraph, resolveType(graph, fileGraph, type, argMap, guard), fallback);
@@ -282,7 +503,7 @@ export function dynamicImportIdentity(graph, fileGraph, di) {
 }
 /**
  * Structural re-entry for a reference. Resolves ONE
- * hop and walks the resolved value through `walkWithFolding`, so every walker
+ * hop and walks the resolved value through `walkInner`, so every walker
  * 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
@@ -291,9 +512,14 @@ 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. At a tag, a self-stamp of a same-file reference
+ * also carries the declaration that reference resolves to
+ * (`withOwnDeclaration`).
  *
  * An import the graph cannot see (`resolved` is Unknown) is NOT re-entered:
  * it is the identity-bearing leaf `foldLeaf` synthesises from, and
@@ -307,9 +533,9 @@ 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 [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return [indeterminateTerminal()];
     }
     try {
         const resolved = resolveReference(graph, fileGraph, type.ref, guard);
@@ -323,23 +549,40 @@ 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 = walkWithFolding(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 self = position === "tag" ? withOwnDeclaration(derived, graph, fileGraph, type.ref) : derived;
         const stamp = self ?? deriveIdentity(fallback, fileGraph, graph);
-        return inner.map((t) => (t.identity === null ? { type: t.type, viaTrail: t.viaTrail, identity: stamp } : t));
+        // 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);
     }
     finally {
         guard.popNode(type);
     }
 }
+/**
+ * A local identity stamped from a same-file reference with no member chain,
+ * given the declaration that reference resolves to in its own scope
+ * (`findLocalDeclaration`). Any other identity is returned unchanged.
+ */
+function withOwnDeclaration(identity, graph, fileGraph, ref) {
+    if (identity === null || identity.kind !== "local" || ref.memberChain.length > 0)
+        return identity;
+    const lookup = fileGraphForRef(graph, ref, fileGraph);
+    if (identity.filePath !== lookup.filePath || lookup.importsByLocal.has(ref.symbol))
+        return identity;
+    const declaration = findLocalDeclaration(lookup, ref);
+    return declaration === null ? identity : { ...identity, declaration };
+}
 /**
  * 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
+ * member, walk the member's VALUE through `walkInner` — 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)
@@ -350,9 +593,9 @@ 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 [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return [indeterminateTerminal()];
     }
     try {
         const objects = resolveType(graph, fileGraph, type.obj, argMap, guard)
@@ -365,22 +608,61 @@ function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
             // identity), not just on real cycles. The `finally` below still runs
             // (a no-op double pop) once this returns.
             guard.popNode(type);
-            return foldLeaf(graph, fileGraph, type, argMap, guard, fallback);
+            const leaf = foldLeaf(graph, fileGraph, type, argMap, guard, fallback);
+            if (!(leaf.length > 0 && leaf.every(cameToNothing)))
+                return leaf;
+            // The object answers for the member: a prop read off a value supplied
+            // elsewhere (`props.Icon`, `useThing()[0]`) is supplied elsewhere too,
+            // 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, undefined, "value");
+            const semantics = markedProduct(object);
+            if (semantics !== null)
+                return leaf.map((t) => withSemantics(t, semantics));
+            return evaluatesLateBound(object) ? leaf.map(asLateBound("parameter-member")) : leaf;
         }
         const out = [];
         for (const obj of objects) {
             const value = obj.props[type.member];
             if (value === undefined)
                 continue;
-            out.push(...walkWithFolding(graph, fileGraph, value, argMap, guard, fallback));
+            out.push(...walkInner(graph, fileGraph, value, argMap, guard, fallback, position));
         }
-        return out.length > 0 ? out : [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return out.length > 0 ? out : [indeterminateTerminal()];
     }
     finally {
         guard.popNode(type);
     }
 }
-function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
+/**
+ * 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.
+ *
+ * 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, 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;
+}
+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);
@@ -395,14 +677,14 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
         };
         const guardKey = `import()::${syntheticDI.specifier}::${syntheticDI.projection.join(".")}`;
         if (guard.push(syntheticDI.originFile, guardKey) !== "ok") {
-            return [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+            return [indeterminateTerminal()];
         }
         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);
+                ? walkInner(graph, target.targetFileGraph, target.value, argMap, guard, undefined, position)
+                : walkInner(graph, fileGraph, syntheticDI, argMap, guard, undefined, position);
         }
         finally {
             guard.pop(syntheticDI.originFile, guardKey);
@@ -418,12 +700,12 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
         // 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");
+        const innerHasNonUnknown = inner.some((t) => !cameToNothing(t));
         if (innerHasNonUnknown) {
             return inner
-                .filter((t) => t.type.kind !== "Unknown")
+                .filter((t) => !cameToNothing(t))
                 .map((t) => ({
-                type: t.type,
+                denotation: t.denotation,
                 viaTrail: [via, ...t.viaTrail],
                 identity: t.identity ?? identity,
             }));
@@ -431,17 +713,17 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
         // 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
+        // specifier+projection from lazyShape — synthesize a `foreign` terminal rather
         // than falling through to Unknown.
-        return [{ type: { kind: "JSX" }, viaTrail: [via], identity }];
+        return [{ denotation: { kind: "foreign" }, viaTrail: [via], identity }];
     }
     // (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
+    // via walkInner in the function's authoring fileGraph. This lets the
     // 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
@@ -457,7 +739,7 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
     if (passThroughIndex !== null) {
         const wrapped = type.args[passThroughIndex];
         if (wrapped !== undefined) {
-            const inner = walkWithFolding(graph, fileGraph, wrapped, argMap, guard);
+            const inner = walkInner(graph, fileGraph, wrapped, argMap, guard, undefined, position);
             return foldToWrappedArg(inner, buildHocVia(type, wrapped, fileGraph));
         }
     }
@@ -466,10 +748,10 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
     // Union / Array fanouts attribute each branch to its own binding instead
     // 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
+    // synthesized `foreign` terminals, so a resolvable and an unresolvable imported
     // 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");
+    const algHasNonUnknown = algResult.some((r) => !cameToNothing(r));
     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
@@ -482,12 +764,12 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
         // stands with no via.
         const lastArg = type.args.at(-1);
         if (lastArg !== undefined) {
-            const inner = walkWithFolding(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);
                 return inner
-                    .filter((t) => t.type.kind !== "Unknown")
-                    .map((t) => ({ type: t.type, viaTrail: [via, ...t.viaTrail], identity: t.identity }));
+                    .filter((t) => !cameToNothing(t))
+                    .map((t) => ({ denotation: t.denotation, viaTrail: [via, ...t.viaTrail], identity: t.identity }));
             }
         }
         return algResult;
@@ -495,9 +777,13 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
     // (4) HOC fallback: algebra failed, last arg is the wrapper target.
     const lastArg = type.args.at(-1);
     if (lastArg === undefined) {
-        return [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return [indeterminateTerminal()];
     }
-    const inner = walkWithFolding(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
@@ -505,12 +791,12 @@ function walkReturnTypeOf(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)) {
-        const nonUnknown = inner.filter((t) => t.type.kind !== "Unknown");
+    if (dataMethod) {
+        const nonUnknown = inner.filter((t) => !cameToNothing(t));
         if (nonUnknown.length > 0) {
-            return nonUnknown.map((t) => ({ type: t.type, viaTrail: t.viaTrail, identity: null }));
+            return nonUnknown.map((t) => ({ denotation: t.denotation, viaTrail: t.viaTrail, identity: null }));
         }
-        return [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return [indeterminateTerminal()];
     }
     return foldToWrappedArg(inner, buildHocVia(type, lastArg, fileGraph));
 }
@@ -559,11 +845,11 @@ function passThroughParameterIndex(graph, fileGraph, type, argMap, guard) {
  * so no `dynamic-map` via would land in the chain.
  *
  * This helper detects the shape and walks each function's returns through
- * `walkWithFolding` in the function's authoring fileGraph (via
+ * `walkInner` in the function's authoring fileGraph (via
  * `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)
@@ -577,7 +863,7 @@ function walkDispatcherReturns(graph, fileGraph, type, argMap, guard) {
             argMap.bind(bindingRef, type.args);
         try {
             for (const ret of fn.returns) {
-                folded.push(...walkWithFolding(graph, fnFileGraph, ret, argMap, guard));
+                folded.push(...walkInner(graph, fnFileGraph, ret, argMap, guard, undefined, position));
             }
         }
         finally {
@@ -585,10 +871,10 @@ function walkDispatcherReturns(graph, fileGraph, type, argMap, guard) {
                 argMap.unbind(bindingRef);
         }
     }
-    const hasNonUnknown = folded.some((t) => t.type.kind !== "Unknown");
+    const hasNonUnknown = folded.some((t) => !cameToNothing(t));
     if (!hasNonUnknown)
         return null;
-    return folded.filter((t) => t.type.kind !== "Unknown");
+    return folded.filter((t) => !cameToNothing(t));
 }
 function isDynamicMemberReturn(t) {
     return t.kind === "MemberOf" && t.member === DYNAMIC_MEMBER_KEY;
@@ -657,9 +943,9 @@ 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 [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return [indeterminateTerminal()];
     }
     try {
         const objResults = resolveType(graph, fileGraph, type.obj, argMap, guard);
@@ -675,15 +961,15 @@ function walkDynamicMember(graph, fileGraph, type, argMap, guard) {
                 column: mapBinding?.loc.column ?? 0,
             };
             for (const propValue of Object.values(obj.props)) {
-                // Recurse via walkWithFolding so identity is derived from each branch's
+                // Recurse via walkInner so identity is derived from each branch's
                 // leaf TypeOf (Foo/Bar resolve to their respective bindings).
-                const inner = walkWithFolding(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 (t.type.kind === "Unknown")
+                    if (cameToNothing(t))
                         continue;
                     out.push({
-                        type: t.type,
+                        denotation: t.denotation,
                         viaTrail: [via, ...t.viaTrail],
                         identity: t.identity, // per-branch identity, distinct per map value
                     });
@@ -969,7 +1255,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) — an empty chain is a no-op.
+        // `evaluateJsxUsage`'s same-file fallback) — an empty chain is a no-op.
         for (const [, decl] of lookup.declarations) {
             if (decl && decl.symbol === symbol) {
                 return withResidual({