@component-compass/reference-graph 0.1.23 → 0.1.24

package/dist/engine/wrapper-folding.d.ts

@@ -2,6 +2,7 @@ import type { Graph, FileGraph, InferredType } from "../index.js";
 import type { OccurrenceVia } from "@component-compass/plugin-core";
 import type { ArgumentMap } from "./argument-map.js";
 import { type CycleGuard } from "./cycle-detection.js";
+import { type Evaluation, type Terminal } from "./denotation.js";
 /**
  * Identity hint for a folded terminal. Tells the engine which binding produced
  * this terminal so componentId derives from the folded-to-inner identity.
@@ -25,17 +26,6 @@ export type TerminalIdentity = {
     filePath: string;
     export: string;
 } | null;
-/**
- * Terminal returned by `walkWithFolding`. Each terminal carries an inner viaTrail
- * accumulated through any folding rules that fired along the walk, plus an identity
- * hint for componentId derivation. The engine's outer occurrence-builder prepends
- * the outer via (direct-import/local-component/etc.) to form the full viaChain.
- */
-export type FoldedTerminal = {
-    type: InferredType;
-    viaTrail: OccurrenceVia[];
-    identity: TerminalIdentity;
-};
 /**
  * Provenance of ONE argument of a wrapper call: the wrapper's `callee` name
  * and the `{ specifier, import }` pair naming the argument's own binding —
@@ -64,7 +54,7 @@ export declare function argumentProvenance(type: Extract<InferredType, {
  */
 export declare function foldedArgument(graph: Graph, fileGraph: FileGraph, call: Extract<InferredType, {
     kind: "ReturnTypeOf";
-}>, jsx: FoldedTerminal[], argMap: ArgumentMap): {
+}>, jsx: readonly Terminal[], argMap: ArgumentMap): {
     arg: InferredType;
     via: OccurrenceVia;
 } | null;
@@ -78,7 +68,7 @@ export declare function foldedArgument(graph: Graph, fileGraph: FileGraph, call:
  * (pure algebra) and computes identity from the input type's leaf TypeOf
  * when one can be confidently identified.
  */
-export declare function walkWithFolding(graph: Graph, fileGraph: FileGraph, type: InferredType, argMap: ArgumentMap, guard?: CycleGuard, identityFallback?: InferredType): FoldedTerminal[];
+export declare function walkWithFolding(graph: Graph, fileGraph: FileGraph, type: InferredType, argMap: ArgumentMap, guard?: CycleGuard, identityFallback?: InferredType): Evaluation;
 /**
  * The file a DynamicImport's specifier resolves against: the file that
  * contains the `import()`, whichever file the walk is standing in.

package/dist/engine/wrapper-folding.js

@@ -1,12 +1,15 @@
 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 { HOOK_NAME } from "./host-element.js";
 import { assertNever } from "./assert-never.js";
+import { creditedTerminals, matchDenotation } from "./denotation.js";
+import { libraryExportFor } from "./library-stubs.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,146 @@ import { assertNever } from "./assert-never.js";
 function isDataMethodRenderCall(type, graph, fileGraph, guard) {
     return type.callee.kind === "MemberOf" && !isImportBackedLeaf(type.callee, graph, fileGraph, guard);
 }
+/** 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,
+};
+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,
+};
+/**
+ * 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,
+};
+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 +172,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 +182,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 +194,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 +288,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 +304,16 @@ 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) {
+    return atLeastOne(walkInner(graph, fileGraph, type, argMap, guard, identityFallback).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.
+ */
+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
@@ -200,7 +347,9 @@ identityFallback) {
             // 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));
+            return type.returns
+                .flatMap((r) => walkInner(graph, fileGraph, r, argMap, guard, type))
+                .map(returnedValue);
         case "TypeOf":
             return walkTypeOf(graph, fileGraph, type, argMap, guard, fallback);
         case "Union":
@@ -208,8 +357,9 @@ identityFallback) {
             // 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));
         case "ParameterOf":
+            return walkParameter(graph, fileGraph, type, argMap, guard, fallback);
         case "DynamicImport":
         case "Object":
         case "Array":
@@ -221,12 +371,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 +445,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
@@ -309,7 +472,7 @@ export function dynamicImportIdentity(graph, fileGraph, di) {
  */
 function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
     if (guard.pushNode(type) === "cycle") {
-        return [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return [indeterminateTerminal()];
     }
     try {
         const resolved = resolveReference(graph, fileGraph, type.ref, guard);
@@ -323,14 +486,15 @@ 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);
         if (inner.every((t) => t.identity !== null))
             return inner;
         const self = resolved.kind !== "ParameterOf" && evalKind(resolved, graph, innerGraph, argMap) === "component"
             ? deriveIdentity(type, fileGraph, graph)
             : null;
         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);
@@ -339,7 +503,7 @@ function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
 /**
  * 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)
@@ -352,7 +516,7 @@ function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
  */
 function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
     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 +529,87 @@ 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);
+            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));
         }
-        return out.length > 0 ? out : [{ type: { kind: "Unknown" }, viaTrail: [], identity: null }];
+        return out.length > 0 ? out : [indeterminateTerminal()];
     }
     finally {
         guard.popNode(type);
     }
 }
+/**
+ * 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
+ * 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));
+    }
+    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) {
     // (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 +624,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)
+                : walkInner(graph, fileGraph, syntheticDI, argMap, guard);
         }
         finally {
             guard.pop(syntheticDI.originFile, guardKey);
@@ -418,12 +647,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,13 +660,13 @@ 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.
@@ -457,7 +686,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);
             return foldToWrappedArg(inner, buildHocVia(type, wrapped, fileGraph));
         }
     }
@@ -466,10 +695,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 +711,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);
             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 +724,9 @@ 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);
+    const inner = walkInner(graph, fileGraph, lastArg, argMap, guard);
     // 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
@@ -506,11 +735,11 @@ function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
     // 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");
+        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,7 +788,7 @@ 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.
  */
@@ -577,7 +806,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));
             }
         }
         finally {
@@ -585,10 +814,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;
@@ -659,7 +888,7 @@ function findFirstDynamicImport(t, fileGraph, depthBudget) {
  */
 function walkDynamicMember(graph, fileGraph, type, argMap, guard) {
     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 +904,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);
                 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
                     });