@descryy/adapter-csharp 0.1.0

package/dist/extract.js

@@ -0,0 +1,1120 @@
+/**
+ * C# files to Canonical IR.
+ *
+ * ## Identity is the project plus the declared namespace
+ *
+ * Not the namespace alone. C# namespaces do not follow directories and the same
+ * namespace legitimately spans projects, so two `.csproj` files in one
+ * repository may both declare `Shop.Orders.OrderService`. That is DEC-077's
+ * collision — the Java case where one fully-qualified name existed under two
+ * source sets and stopped identifying anything — and the project is C#'s
+ * equivalent separator.
+ *
+ * ## Two decisions land here, both taken before this file was written
+ *
+ * **DEC-083, a declaration that spans files.** `partial class` is the first
+ * construct in this project whose declaration is legitimately multi-file. The
+ * merge is free — a node id never contains a file path — so the parts collapse
+ * to one node with no new machinery. `file` is the lexicographically first
+ * declaring path and every part is listed in `attrs.declaredIn`, which is what
+ * a precision adjudicator has to search instead of `file`.
+ *
+ * **DEC-084, the base list.** `class A : B, IC` does not say which entry is the
+ * class, but the language does: at most one base class, and it must be first.
+ * So entries after the first are `IMPLEMENTS` unconditionally, a struct's and an
+ * interface's entries are all `IMPLEMENTS`, and exactly one entry per class ever
+ * needs resolving. The `IFoo` prefix is never read — it is a convention,
+ * `System.Exception` disproves it in the other direction, and inferring an edge
+ * from a naming habit is what golden pattern 12 exists to punish.
+ *
+ * ## Ambiguity is disclosed, never broken
+ *
+ * A `using` imports a whole namespace, so a bare name can be found under two of
+ * them at once. Real C# resolves that with the full type environment; this
+ * adapter has names only, so two candidates produce a ledger entry and no edge.
+ * Extension methods are the same answer for the same reason: `x.Foo()` where
+ * `Foo` is a static method on an unrelated class, selected by the receiver's
+ * type, is not decidable from names.
+ */
+import { edgeId, endpointQsp, nodeId, normaliseEndpointPath, symbolQsp, testCaseQsp, } from "@descryy/ir";
+import { efModels, isGenerated } from "./efcore.js";
+import { aspNetRoutes } from "./aspnetcore.js";
+import { resolveNullable, nullableDirectives } from "./nullability.js";
+import { clientCalls, endpointFor } from "./client.js";
+import { typedClientBases } from "./client-base.js";
+export const LANGUAGE = "csharp";
+const CONFIDENCE = { 0: 0.5, 1: 0.7, 2: 0.9, 3: 0.95 };
+const REASONS = {
+    outside: 
+    // Same correction as the Java adapter's, for the same reason, on weaker
+    // evidence. There the final sentence "A scope boundary, not an analysis
+    // gap." was measured false for 238 of 458 entries on `okhttp`, which is
+    // Kotlin-and-Java. No C# corpus here holds another CLR language — `.fs` and
+    // `.vb` counts are 0 across all six — so the claim is not *known* wrong on
+    // C#. It is unverifiable either way from inside one adapter, and a
+    // disclosure must not assert what its author cannot check.
+    "names a type or member this run did not analyse. Either a scope boundary — a NuGet " +
+        "package, the .NET base class library, a project outside the analysed set — or a " +
+        "declaration this run could not read, in another language in this same repository. " +
+        "This adapter sees only C# sources and cannot tell the two apart.",
+    unmodelled: "the type is in the analysed set but declares no such member — most often inherited from a " +
+        "base type or interface this run did not read, or reached through an extension method.",
+    ambiguousName: "the name is found under more than one imported namespace. C# resolves this with the full " +
+        "type environment; names alone cannot, so no edge is emitted rather than one of two guessed.",
+    untypedReceiver: "the receiver's type is not written down at this reference: a `var` bound to something " +
+        "unwritten, an untyped lambda parameter, or a member declared in an unread type.",
+    valueTarget: "the invocation target is a value, not a name — a delegate field, an element of a map of " +
+        "delegates, a `Func<>` local. Which method it holds is a runtime fact.",
+    noProject: "no .csproj covers this file, so it belongs to no assembly and nothing else can name its " +
+        "types. Disclosed rather than given an invented identity.",
+    noBaseContext: "`base` in a type whose base class is not in the analysed set.",
+};
+const INHERITANCE_HOPS = 12;
+const PENDING_PASSES = 3;
+/**
+ * Test attributes, by framework. All three are declared in source.
+ *
+ * xUnit `[Fact]`/`[Theory]`, NUnit `[Test]`/`[TestCase]`, MSTest `[TestMethod]`.
+ * This is the same shape Java's `@Test` already handles and it is reading an
+ * annotation, not guessing from a method name — C# has no naming convention for
+ * tests the way XCTest does.
+ */
+const TEST_ATTRIBUTES = new Set(["Fact", "Theory", "Test", "TestCase", "TestMethod", "DataTestMethod"]);
+function qualify(namespace, path) {
+    const joined = path.join(".");
+    return namespace === "" ? joined : `${namespace}.${joined}`;
+}
+export function extract(input) {
+    const nodes = [];
+    const edges = [];
+    const unresolved = [];
+    const seenEdge = new Set();
+    const scope = input.scope;
+    // The caller's half of the HTTP boundary — collected per-method below,
+    // where the enclosing FUNCTION node and receiver scopes are both in hand,
+    // and emitted with the routes below so both halves mint one `API_ENDPOINT`.
+    const clientCallSites = [];
+    /**
+     * `FUNCTION`/`TEST_CASE` node id -> its index in `nodes`, so D-FIX-3's
+     * client-base extractor (DEC-164) can patch `attrs.clientBase` onto the
+     * caller node once `clientCallSites` is fully known — golden patterns
+     * 08a/08b/08c bind their `caller_*` role to the `FUNCTION`, not the edge,
+     * per `capabilities.ts`'s own "on every caller" phrasing.
+     */
+    const functionNodeIndex = new Map();
+    /** `FUNCTION`/`TEST_CASE` node id -> the `clientBase` this row attaches to it. First writer wins. */
+    const functionClientBase = new Map();
+    // -------------------------------------------------------------------------
+    // Framework extractors, resolved for the whole batch before any id is minted
+    // -------------------------------------------------------------------------
+    //
+    // A MODEL is a MODEL rather than a CLASS, and the node id hashes the kind
+    // (DEC-004), so the kind has to be settled BEFORE the id exists. Both
+    // extractors also read across files — a `DbSet<Order>` names a type declared
+    // elsewhere, and the evidence making a class a controller is usually on a base
+    // in another file — so neither can run per-unit.
+    const sources = input.sources ?? new Map();
+    const frameworkFiles = input.files
+        .map((parsed) => ({ parsed, source: sources.get(parsed.file) ?? "" }))
+        .filter((each) => each.source !== "" && !isGenerated(each.parsed.file, each.source));
+    /**
+     * The NRT context governing a file, resolved from its directives alone here.
+     *
+     * The project and the imported props are the adapter's to supply and are not
+     * reachable from a `CsFile`, so a file with no directive resolves to `absent`
+     * and its reference-typed columns come out `unresolved` and counted. That is
+     * the honest degradation: unknown is not false, and DEC-180 §2 is the whole
+     * reason this is not allowed to guess.
+     */
+    const contextOf = (file) => {
+        if (input.nullableContextOf !== undefined)
+            return input.nullableContextOf(file);
+        const source = sources.get(file);
+        if (source === undefined)
+            return "absent";
+        return resolveNullable({ directives: nullableDirectives(source), project: "absent", directoryProps: "absent" }, source.split("\n").length).context;
+    };
+    const orm = efModels({ files: frameworkFiles, contextOf });
+    /** D-FIX-3's client-base extractor (DEC-164), the `AddHttpClient<T>(...)` half — `client-base.ts`'s own header has the account. */
+    const typedClientBaseMap = typedClientBases(frameworkFiles);
+    /**
+     * **Qualified** type name -> its mapping, for the CLASS/MODEL decision below.
+     *
+     * Keyed on the simple name until a resolved collision showed what that costs:
+     * two types named `Basket` in one repository both became `MODEL`, and the
+     * Razor `ViewComponent` carried the entity's columns.
+     */
+    const modelsByName = new Map(orm.models.map((model) => [model.fqn, model]));
+    const push = (edge, level) => {
+        if (level > input.reached)
+            return false;
+        if (edge.from === edge.to)
+            return true;
+        const key = edgeId(edge.from, edge.to, edge.type);
+        if (seenEdge.has(key))
+            return true;
+        seenEdge.add(key);
+        edges.push({ ...edge, producedBy: input.producedBy, resolution: level, confidence: CONFIDENCE[level] ?? 0.5 });
+        return true;
+    };
+    const ledger = (from, edgeType, rawTarget, unit, line, reason, attrs) => {
+        unresolved.push({
+            fromNodeId: from,
+            edgeType,
+            rawTarget: rawTarget.slice(0, 120),
+            file: unit.file,
+            line,
+            producedBy: input.producedBy,
+            reason,
+            ...(attrs === undefined ? {} : { attrs }),
+        });
+    };
+    // -------------------------------------------------------------------------
+    // Nodes — types first, so partial parts merge before any member is placed
+    // -------------------------------------------------------------------------
+    /** Keyed by `assembly::FullyQualifiedName`, which is what makes it identity. */
+    const types = new Map();
+    /**
+     * The same names, keyed by fully-qualified name alone.
+     *
+     * Identity and resolution want different indexes and conflating them is a
+     * defect in both directions. The assembly separates two declarations of one
+     * name, so it belongs in the id. But a `using` reaches *across* projects — a
+     * test project referencing the app project is the ordinary case — so keying
+     * resolution by assembly too would silently drop every cross-project edge.
+     *
+     * `<ProjectReference>` is not read, so which projects may see each other is
+     * unknown here. The rule that follows is the precision rule: prefer a match in
+     * the referencing file's own assembly, and otherwise accept a match only when
+     * exactly one assembly declares the name. Two claimants is an ambiguity to
+     * disclose, not a tie to break.
+     */
+    const byFqn = new Map();
+    const moduleIdOf = new Map();
+    const moduleKeys = new Map();
+    // Sorted, so the primary declaration of a partial type is a property of the
+    // repository and not of filesystem enumeration order. DEC-083 requires this:
+    // "lexicographically first" is only reproducible if the input is ordered.
+    const units = [...input.files].sort((a, b) => a.file.localeCompare(b.file));
+    const keyOf = (unit, fqn) => `${unit.assembly}::${fqn}`;
+    for (const unit of units) {
+        const stem = unit.file.slice(unit.file.lastIndexOf("/") + 1).replace(/\.cs$/i, "");
+        const holder = unit.assembly === "" ? "(no project)" : unit.assembly;
+        const namespaceKey = unit.namespace === "" ? "(global)" : unit.namespace;
+        const key = `${holder}::${namespaceKey}::${stem}`;
+        const owner = moduleKeys.get(key);
+        const disambiguated = owner !== undefined && owner !== unit.file;
+        if (owner === undefined)
+            moduleKeys.set(key, unit.file);
+        const directory = unit.file.slice(0, Math.max(0, unit.file.lastIndexOf("/")));
+        const segment = disambiguated ? (directory === "" ? unit.file : `${directory}/${stem}`) : stem;
+        const moduleId = nodeId(scope, "MODULE", symbolQsp(`${holder}::${namespaceKey}`, [segment]), LANGUAGE);
+        moduleIdOf.set(unit.file, moduleId);
+        nodes.push({
+            id: moduleId,
+            type: "MODULE",
+            name: `${stem}.cs`,
+            file: unit.file,
+            range: { startLine: 1, endLine: 1 },
+            language: LANGUAGE,
+            producedBy: input.producedBy,
+            resolution: 0,
+            attrs: {
+                ...(unit.hasError ? { parsedWithErrors: true } : {}),
+                ...(disambiguated ? { disambiguatedBy: "directory" } : {}),
+                ...(unit.namespace === "" ? {} : { namespace: unit.namespace }),
+                ...(unit.assembly === "" ? { noProject: true } : { assembly: unit.assembly }),
+            },
+        });
+        for (const part of unit.types) {
+            const fqn = qualify(unit.namespace, part.path);
+            const key_ = keyOf(unit, fqn);
+            const existing = types.get(key_);
+            if (existing !== undefined) {
+                existing.parts.push(part);
+                if (!existing.files.includes(unit.file))
+                    existing.files.push(unit.file);
+                continue;
+            }
+            // The kind is decided here and the id is minted from it. DEC-004 hashes
+            // the kind, so a MODEL cannot be patched onto a CLASS afterwards.
+            const kind = modelsByName.has(fqn) ? "MODEL" : "CLASS";
+            const declared = {
+                kind,
+                id: nodeId(scope, kind, symbolQsp(holder, [fqn]), LANGUAGE),
+                fqn,
+                parts: [part],
+                files: [unit.file],
+                unit,
+                members: new Map(),
+                methods: new Map(),
+            };
+            types.set(key_, declared);
+            byFqn.set(fqn, [...(byFqn.get(fqn) ?? []), declared]);
+        }
+    }
+    // DEC-083: one node per type, `file` the lexicographically first declaring
+    // path, every part in `attrs.declaredIn`.
+    for (const declared of types.values()) {
+        const primary = declared.parts[0];
+        if (primary === undefined)
+            continue;
+        const files = [...declared.files].sort();
+        const partial = declared.parts.some((part) => part.isPartial);
+        for (const part of declared.parts) {
+            for (const [member, written] of part.members)
+                declared.members.set(member, { type: written });
+        }
+        const model = declared.kind === "MODEL" ? modelsByName.get(declared.fqn) : undefined;
+        nodes.push({
+            id: declared.id,
+            type: declared.kind,
+            name: primary.name,
+            file: files[0] ?? declared.unit.file,
+            range: { startLine: primary.startLine, endLine: primary.endLine },
+            language: LANGUAGE,
+            producedBy: input.producedBy,
+            resolution: 0,
+            attrs: {
+                declarationForm: primary.form,
+                ...(primary.isAbstract ? { abstract: true } : {}),
+                ...(primary.attributes.length > 0 ? { attributes: primary.attributes } : {}),
+                // Written whenever the type has more than one part, so an adjudicator
+                // that searches only `file` has something to search instead.
+                ...(files.length > 1 || partial ? { partial: true, declaredIn: files } : {}),
+                ...(model === undefined
+                    ? {}
+                    : {
+                        orm: "efcore",
+                        ...(model.table === null ? {} : { table: model.table }),
+                        // **Not gated on `input.reached`.** A mapped column is a
+                        // declaration the framework itself enforces, not an inference, so
+                        // its resolution is the evidence's rather than the run's (DEC-058)
+                        // — the same exception `adapter-java` records for JPA.
+                        ...(model.columns.length > 0
+                            ? {
+                                fields: model.columns.map((column) => ({
+                                    name: column.name,
+                                    // `undefined` is dropped by JSON, so an unresolved column
+                                    // must say so rather than vanish into a missing key.
+                                    ...(column.nullable === undefined
+                                        ? { nullable: null }
+                                        : { nullable: column.nullable }),
+                                    nullableFrom: column.nullableFrom,
+                                })),
+                            }
+                            : {}),
+                        admittedBy: model.admittedBy,
+                    }),
+            },
+        });
+    }
+    /** A type is a test suite when any of its methods carries a test attribute. */
+    const suites = new Set();
+    for (const unit of units) {
+        for (const fn of unit.funcs) {
+            if (fn.ownerPath.length === 0)
+                continue;
+            if (!fn.attributes.some((attribute) => TEST_ATTRIBUTES.has(attribute)))
+                continue;
+            suites.add(keyOf(unit, qualify(unit.namespace, fn.ownerPath)));
+        }
+    }
+    for (const unit of units) {
+        const holder = unit.assembly === "" ? "(no project)" : unit.assembly;
+        for (const fn of unit.funcs) {
+            if (fn.ownerPath.length === 0)
+                continue;
+            const ownerFqn = qualify(unit.namespace, fn.ownerPath);
+            const owner = types.get(keyOf(unit, ownerFqn));
+            if (owner === undefined)
+                continue;
+            const isCase = suites.has(keyOf(unit, ownerFqn)) && fn.attributes.some((attribute) => TEST_ATTRIBUTES.has(attribute));
+            const id = isCase
+                ? nodeId(scope, "TEST_CASE", testCaseQsp(holder, [unit.namespace, ...fn.ownerPath].filter((s) => s !== ""), fn.name), LANGUAGE)
+                : nodeId(scope, "FUNCTION", symbolQsp(holder, [ownerFqn, fn.name]), LANGUAGE);
+            // An overload set is one node. C# picks between overloads by argument
+            // types, which is R3 evidence this adapter does not have — so an edge to
+            // "the method called Format" is the honest claim, and pretending to have
+            // chosen an overload would be a claim it cannot support.
+            if (owner.methods.has(fn.name))
+                continue;
+            owner.methods.set(fn.name, { id, fn, unit, ownerFqn, isTest: isCase });
+            functionNodeIndex.set(id, nodes.length);
+            nodes.push({
+                id,
+                type: isCase ? "TEST_CASE" : "FUNCTION",
+                name: fn.name,
+                file: unit.file,
+                range: { startLine: fn.startLine, endLine: fn.endLine },
+                language: LANGUAGE,
+                producedBy: input.producedBy,
+                resolution: 0,
+                attrs: {
+                    ...(fn.isStatic ? { static: true } : {}),
+                    ...(fn.isAbstract ? { abstract: true } : {}),
+                    ...(fn.attributes.length > 0 ? { attributes: fn.attributes } : {}),
+                },
+            });
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Resolution
+    // -------------------------------------------------------------------------
+    /**
+     * Every fully-qualified name a written name could denote, in this file.
+     *
+     * C# searches the enclosing namespaces outward and then the imports, and a
+     * name found under two imports is genuinely ambiguous without the full type
+     * environment. Candidates are collected rather than short-circuited so that
+     * ambiguity can be *seen* instead of silently resolved to whichever rule ran
+     * first.
+     */
+    /**
+     * `global using` declarations, by assembly.
+     *
+     * They are in force for every file in their project, so they are gathered once
+     * and consulted for every unit — the alternative is that a name introduced by
+     * one resolves nowhere else, which is the whole point of the construct.
+     */
+    const globalUsings = new Map();
+    for (const unit of units) {
+        for (const using of unit.usings) {
+            if (!using.isGlobal)
+                continue;
+            globalUsings.set(unit.assembly, [...(globalUsings.get(unit.assembly) ?? []), using]);
+        }
+    }
+    const usingsFor = (unit) => {
+        const global = globalUsings.get(unit.assembly);
+        return global === undefined ? unit.usings : [...unit.usings, ...global];
+    };
+    function candidatesFor(raw, unit, host) {
+        const name = raw.trim().replace(/^global::/, "");
+        if (name === "")
+            return [];
+        const found = new Set();
+        const visible = usingsFor(unit);
+        // **Enclosing TYPES are searched before enclosing namespaces.** A nested
+        // type written by its simple name from inside the type that declares it —
+        // `DbLock.EnterWrite(...)` inside `PessimisticLockBehavior`, which declares
+        // `private sealed class DbLock` — resolved nowhere, because only the
+        // namespace chain was walked. Innermost wins outright, as in C#: returning
+        // here rather than adding to `found` keeps a nested `Foo` from colliding
+        // with a namespace-level `Foo` and being reported ambiguous.
+        if (host !== undefined) {
+            let scope_ = host.fqn;
+            while (scope_ !== "") {
+                if (byFqn.has(scope_)) {
+                    const nested = `${scope_}.${name}`;
+                    if (byFqn.has(nested))
+                        return [nested];
+                }
+                const cut = scope_.lastIndexOf(".");
+                scope_ = cut === -1 ? "" : scope_.slice(0, cut);
+            }
+        }
+        const consider = (candidate) => {
+            if (byFqn.has(candidate))
+                found.add(candidate);
+        };
+        // An alias binds one name outright and wins over everything else.
+        const head = name.includes(".") ? name.slice(0, name.indexOf(".")) : name;
+        const tail = name.includes(".") ? name.slice(name.indexOf(".")) : "";
+        for (const using of visible) {
+            if (using.alias !== undefined && using.alias === head) {
+                const aliased = `${using.target}${tail}`;
+                if (byFqn.has(aliased))
+                    return [aliased];
+            }
+        }
+        // Written as given — already fully qualified, or a nested type reached by
+        // its outer type's name.
+        consider(name);
+        // Enclosing namespaces, innermost outward. C#'s own rule.
+        const segments = unit.namespace === "" ? [] : unit.namespace.split(".");
+        for (let depth = segments.length; depth >= 0; depth -= 1) {
+            const prefix = segments.slice(0, depth).join(".");
+            consider(prefix === "" ? name : `${prefix}.${name}`);
+        }
+        // Imported namespaces. `using static` imports members, not types, and is
+        // handled where members are resolved.
+        for (const using of visible) {
+            if (using.alias !== undefined || using.isStatic)
+                continue;
+            consider(`${using.target}.${name}`);
+        }
+        return [...found];
+    }
+    function resolveType(raw, unit, host) {
+        const candidates = candidatesFor(raw, unit, host);
+        if (candidates.length === 0)
+            return { reason: REASONS.outside };
+        if (candidates.length > 1)
+            return { reason: REASONS.ambiguousName };
+        const claimants = byFqn.get(candidates[0]) ?? [];
+        if (claimants.length === 0)
+            return { reason: REASONS.outside };
+        // Own assembly first — that is where C# would look and where a `partial`
+        // sibling lives. Across assemblies, one claimant resolves and two do not.
+        const own = claimants.filter((candidate) => candidate.unit.assembly === unit.assembly);
+        if (own.length === 1)
+            return { declared: own[0] };
+        if (own.length > 1)
+            return { reason: REASONS.ambiguousName };
+        if (claimants.length === 1)
+            return { declared: claimants[0] };
+        return { reason: REASONS.ambiguousName };
+    }
+    /** Every type in a declaration's supertype chain, across all its parts. */
+    function* ancestry(start) {
+        const queue = [start];
+        const seen = new Set([start.fqn]);
+        let hops = 0;
+        while (queue.length > 0 && hops < INHERITANCE_HOPS) {
+            const current = queue.shift();
+            if (current === undefined)
+                break;
+            hops += 1;
+            yield current;
+            for (const part of current.parts) {
+                for (const raw of part.baseList) {
+                    const parent = resolveType(raw, current.unit, current);
+                    if ("declared" in parent && !seen.has(parent.declared.fqn)) {
+                        seen.add(parent.declared.fqn);
+                        queue.push(parent.declared);
+                    }
+                }
+            }
+        }
+    }
+    function findMethod(start, name) {
+        for (const current of ancestry(start)) {
+            const found = current.methods.get(name);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    function findMember(start, name) {
+        for (const current of ancestry(start)) {
+            const found = current.members.get(name);
+            if (found !== undefined)
+                return found.type;
+        }
+        return undefined;
+    }
+    // ---------------------------------------------------------------------------
+    // D-FIX-3's client-base extractor (DEC-164) — see `client-base.ts`'s own
+    // header for the shape and why it is scoped exactly here.
+    // ---------------------------------------------------------------------------
+    /**
+     * Does `rawName`'s own declaration — resolved in `unit`/`host`'s context,
+     * the same resolution every other type reference in this file goes
+     * through — carry `WebApplicationFactory<` in its written base list,
+     * directly or through one further in-repo indirection?
+     *
+     * `WebApplicationFactory<TEntryPoint>` is itself external (`Microsoft.
+     * AspNetCore.Mvc.Testing`), so `resolveType` never resolves it as a
+     * `DeclaredType` and `ancestry` never yields it — this reads the *written*
+     * text of each yielded type's own base list instead of trying to resolve
+     * that final hop, the same reason `baseListWritten` exists rather than
+     * `baseList` alone (see `CsType.baseListWritten`'s own doc).
+     */
+    function derivesFromWebApplicationFactory(rawName, unit, host) {
+        const resolved = resolveType(rawName, unit, host);
+        if (!("declared" in resolved))
+            return false;
+        for (const current of ancestry(resolved.declared)) {
+            for (const part of current.parts) {
+                if (part.baseListWritten.some((entry) => /^WebApplicationFactory\s*(<|$)/.test(entry.trim())))
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * The one traceable base-setting mechanism this row builds. `receiverType`
+     * is the *written* type name of whatever received a `.CreateClient()` call
+     * — see `client-base.ts`'s own header for why `IHttpClientFactory`'s named-
+     * client form and every other DI shape are deliberately left untouched.
+     */
+    function creatorBaseOf(receiverType, unit, host) {
+        if (receiverType === undefined)
+            return undefined;
+        if (!derivesFromWebApplicationFactory(receiverType, unit, host))
+            return undefined;
+        // `WebApplicationFactory<T>.CreateClient()`'s documented default
+        // `BaseAddress` is `http://localhost/` — origin only, no path. No
+        // corpus witness in this row overrides it (`WebApplicationFactoryClientOptions`
+        // is never constructed with its own `BaseAddress` in any of the six), so
+        // that override is not read here — disclosed, not silently assumed.
+        return { state: "resolved", path: "" };
+    }
+    /**
+     * `var client = _factory.CreateClient();` — resolved from `scope_.pending`
+     * *before* `settle()` runs, because `settle()`'s own fallback (`locals.set(name,
+     * null)`) is exactly the silence this row exists to fix: `CreateClient` is
+     * never declared in-repo (it is inherited from an external base), so
+     * `findMethod` never finds it and every such local stayed permanently
+     * unresolved before this function existed — invisible to `clientCalls`,
+     * not even ledgered. Mutates `scope_` in place (same contract `settle`
+     * already has) and returns the per-local bases this pass resolved.
+     */
+    function resolveClientBaseLocals(scope_, unit, host) {
+        const bases = new Map();
+        for (const [name, pending] of scope_.pending) {
+            if (pending.name !== "CreateClient")
+                continue;
+            const receiverType = pending.receiver === undefined
+                ? undefined
+                : definite(scope_.locals.get(pending.receiver) ?? findMemberOn(host, pending.receiver));
+            const base = creatorBaseOf(receiverType, unit, host);
+            if (base === undefined)
+                continue;
+            scope_.locals.set(name, "HttpClient");
+            scope_.pending.delete(name);
+            bases.set(name, base);
+        }
+        return bases;
+    }
+    /** `findMember`, tolerant of an absent `host` — every call site here already needs that. */
+    function findMemberOn(host, name) {
+        return host === undefined ? undefined : findMember(host, name);
+    }
+    /** `null` (ambiguous) collapses to `undefined` (unknown) — the same reader stance `writtenReceiverType` already takes. */
+    function definite(value) {
+        return value === null ? undefined : value;
+    }
+    /**
+     * A property or field's own base, traced once per `DeclaredType` and
+     * cached — a field's inline initialiser (`memberProvenance`, read at the
+     * declaration) or a `.ctor`'s own assignment (`propertyAssignments`, read
+     * from the constructor's body) are the two shapes measured; the first
+     * writer for a given name wins, matching `findMember`'s own "nearest
+     * declaration" precedence.
+     */
+    const memberClientBaseCache = new Map();
+    function memberClientBase(declared) {
+        const cached = memberClientBaseCache.get(declared.id);
+        if (cached !== undefined)
+            return cached;
+        const bases = new Map();
+        const consider = (name, call, scope_) => {
+            if (bases.has(name) || call.name !== "CreateClient")
+                return;
+            const receiverType = call.receiver === undefined
+                ? undefined
+                : definite((scope_ === undefined ? undefined : scope_.locals.get(call.receiver)) ?? findMemberOn(declared, call.receiver));
+            const base = creatorBaseOf(receiverType, declared.unit, declared);
+            if (base !== undefined)
+                bases.set(name, base);
+        };
+        for (const part of declared.parts) {
+            for (const [field, call] of part.memberProvenance)
+                consider(field, call, undefined);
+        }
+        const ctor = declared.methods.get(".ctor");
+        if (ctor !== undefined) {
+            for (const [prop, call] of ctor.fn.scope.propertyAssignments)
+                consider(prop, call, ctor.fn.scope);
+        }
+        memberClientBaseCache.set(declared.id, bases);
+        return bases;
+    }
+    function ownerOfType(raw, unit, host) {
+        if (raw === null || raw === undefined)
+            return { reason: REASONS.untypedReceiver };
+        if (raw === "this")
+            return host === undefined ? { reason: REASONS.noBaseContext } : { declared: host };
+        if (raw === "base") {
+            if (host === undefined)
+                return { reason: REASONS.noBaseContext };
+            // DEC-084: the base class, if there is one, is the *first* base-list entry.
+            for (const part of host.parts) {
+                const first = part.baseList[0];
+                if (first === undefined)
+                    continue;
+                const parent = resolveType(first, host.unit, host);
+                if ("declared" in parent && parent.declared.parts[0]?.form !== "interface")
+                    return parent;
+            }
+            return { reason: REASONS.noBaseContext };
+        }
+        return resolveType(raw, unit, host);
+    }
+    function ownerOfReceiver(written, scope_, unit, host) {
+        if (written === "this" || written === "base")
+            return ownerOfType(written, unit, host);
+        const local = scope_.locals.get(written);
+        if (local !== undefined)
+            return ownerOfType(local, unit, host);
+        if (host !== undefined) {
+            const member = findMember(host, written);
+            if (member !== undefined)
+                return ownerOfType(member, unit, host);
+        }
+        return resolveType(written, unit, host);
+    }
+    /**
+     * The receiver's type **as written**, without resolving it to a declaration —
+     * `HttpClient` has none in this repository, and `ownerOfReceiver` above would
+     * refuse it for exactly that reason. D-FIX-3 needs the name, not the node, so
+     * this stops one step earlier: same lookup order (`locals`, then the host
+     * type's own members), same `null`-is-poisoned handling, no `resolveType` call.
+     *
+     * `ref.receiverProperty` is resolved only through `this` — `this._client.Get()`
+     * — not through an arbitrary chain (`_service.Client.Get()`), which is a
+     * disclosed limit rather than an attempt to walk a chain this reader does not
+     * track elsewhere. `ref.receiverCall` (`Factory.CreateClient().Get()`) is left
+     * unresolved for the same reason Java's chained builder is: no receiver here
+     * has a written type, so nothing is silently guessed.
+     */
+    function writtenReceiverType(ref, scope_, host) {
+        if (ref.receiverType !== undefined)
+            return ref.receiverType;
+        if (ref.receiverProperty !== undefined) {
+            if (ref.receiverProperty.of !== "this" || host === undefined)
+                return undefined;
+            const member = findMember(host, ref.receiverProperty.name);
+            return member === null || member === undefined ? undefined : member;
+        }
+        if (ref.receiverCall !== undefined)
+            return undefined;
+        if (ref.receiver === "this" || ref.receiver === "base")
+            return undefined;
+        const local = scope_.locals.get(ref.receiver);
+        if (local !== undefined)
+            return local === null ? undefined : local;
+        if (host !== undefined) {
+            const member = findMember(host, ref.receiver);
+            if (member !== undefined)
+                return member === null ? undefined : member;
+        }
+        return undefined;
+    }
+    function settle(scope_, unit, host) {
+        for (let pass = 0; pass < PENDING_PASSES && scope_.pending.size > 0; pass += 1) {
+            let changed = false;
+            for (const [name, pending] of [...scope_.pending]) {
+                let returns;
+                if (pending.receiver === undefined) {
+                    if (host !== undefined)
+                        returns = findMethod(host, pending.name)?.fn.returns;
+                }
+                else {
+                    const owner = ownerOfReceiver(pending.receiver, scope_, unit, host);
+                    if ("declared" in owner)
+                        returns = findMethod(owner.declared, pending.name)?.fn.returns;
+                }
+                if (returns === undefined)
+                    continue;
+                scope_.pending.delete(name);
+                scope_.locals.set(name, returns);
+                changed = true;
+            }
+            if (!changed)
+                break;
+        }
+        for (const name of scope_.pending.keys())
+            scope_.locals.set(name, null);
+        scope_.pending.clear();
+    }
+    // -------------------------------------------------------------------------
+    // Edges
+    // -------------------------------------------------------------------------
+    for (const unit of units) {
+        const moduleId = moduleIdOf.get(unit.file);
+        if (moduleId === undefined)
+            continue;
+        // IMPORTS. A C# `using` names a *namespace*, so like Go's package import it
+        // fans out — to every file declaring a type in that namespace. That is not
+        // an approximation: importing a namespace makes every type in it visible.
+        for (const using of unit.usings) {
+            const targets = new Set();
+            for (const declared of types.values()) {
+                const owner = declared.fqn.slice(0, Math.max(0, declared.fqn.lastIndexOf(".")));
+                if (using.alias !== undefined || using.isStatic) {
+                    if (declared.fqn === using.target)
+                        for (const file of declared.files)
+                            targets.add(file);
+                }
+                else if (owner === using.target) {
+                    for (const file of declared.files)
+                        targets.add(file);
+                }
+            }
+            if (targets.size === 0) {
+                ledger(moduleId, "IMPORTS", using.target, unit, using.line, REASONS.outside);
+                continue;
+            }
+            for (const file of targets) {
+                const id = moduleIdOf.get(file);
+                if (id !== undefined)
+                    push({ from: moduleId, to: id, type: "IMPORTS" }, 1);
+            }
+        }
+        for (const part of unit.types) {
+            const declared = types.get(keyOf(unit, qualify(unit.namespace, part.path)));
+            if (declared === undefined)
+                continue;
+            emitBaseList(declared, part, unit);
+            for (const ref of part.typeRefs)
+                emitType(declared.id, ref, unit, declared, undefined);
+        }
+        for (const fn of unit.funcs) {
+            if (fn.ownerPath.length === 0)
+                continue;
+            const host = types.get(keyOf(unit, qualify(unit.namespace, fn.ownerPath)));
+            const declared = host?.methods.get(fn.name);
+            if (declared === undefined || declared.unit.file !== unit.file || declared.fn !== fn)
+                continue;
+            // D-FIX-3's client-base extractor (DEC-164): `var client =
+            // _factory.CreateClient();` must be read out of `fn.scope.pending`
+            // *before* `settle()` runs — `settle()`'s own fallback nulls out
+            // anything it cannot resolve, and `CreateClient` is never declared
+            // in-repo (inherited from an external base), so every such local
+            // stayed permanently, silently unresolved before this pass existed.
+            const localClientBase = resolveClientBaseLocals(fn.scope, unit, host);
+            settle(fn.scope, unit, host);
+            // The caller's half of the HTTP boundary (DEC-241 §4). Read alongside
+            // the general ref loop below rather than inside it — `clientCalls` owns
+            // its own candidate predicate (`candidateClientRefs`), the same
+            // separation Java's `client.ts` keeps from `extract.ts`'s general
+            // `CALLS` handling.
+            {
+                const clientBaseOf = (ref) => {
+                    // A local traced through `resolveClientBaseLocals` above.
+                    const local = localClientBase.get(ref.receiver);
+                    if (local !== undefined)
+                        return local;
+                    // `this.Client` / a bare `Client` reaching a member on the host type.
+                    // A bare receiver only ever names a member here when it is not
+                    // *also* a local or parameter — same precedence `writtenReceiverType`
+                    // already applies, so a local that happens to shadow a same-named
+                    // member is never misattributed to the member's own base.
+                    const propertyName = ref.receiverProperty !== undefined
+                        ? ref.receiverProperty.of === "this"
+                            ? ref.receiverProperty.name
+                            : undefined
+                        : ref.receiverType === undefined && ref.receiverCall === undefined && !fn.scope.locals.has(ref.receiver)
+                            ? ref.receiver
+                            : undefined;
+                    if (propertyName !== undefined && host !== undefined) {
+                        const member = memberClientBase(host).get(propertyName);
+                        if (member !== undefined)
+                            return member;
+                    }
+                    // `AddHttpClient<TClient>(...)` — DI hands the configured client
+                    // straight to `TClient`'s own constructor, so a call inside
+                    // `TClient` whose receiver reached here untraced is exactly that
+                    // typed client. Matched against the host's own simple name — see
+                    // `typedClientBases`'s own doc for why this is textual rather than
+                    // a full type resolution.
+                    if (host !== undefined) {
+                        const simple = host.fqn.slice(host.fqn.lastIndexOf(".") + 1);
+                        const typed = typedClientBaseMap.get(simple);
+                        if (typed !== undefined)
+                            return typed;
+                    }
+                    return { state: "none" };
+                };
+                const read = clientCalls(fn.scope.refs, declared.id, (ref) => writtenReceiverType(ref, fn.scope, host), declared.isTest, fn.scope.parameterNames, clientBaseOf);
+                clientCallSites.push(...read.calls);
+                for (const call of read.calls) {
+                    if (!functionClientBase.has(call.fromId))
+                        functionClientBase.set(call.fromId, call.clientBase);
+                }
+                for (const refusal of read.refusals) {
+                    // A refusal still carries `clientBase` when DEC-164's own
+                    // `unresolved` state is *why* it refused — golden pattern 08b binds
+                    // its `caller_unresolved_base` role to the `FUNCTION` even though
+                    // no `USES_API` edge exists to look at, so the node is the only
+                    // place that fact can live.
+                    if (refusal.clientBase !== undefined && !functionClientBase.has(refusal.fromId)) {
+                        functionClientBase.set(refusal.fromId, refusal.clientBase);
+                    }
+                    ledger(refusal.fromId, "USES_API", refusal.raw, unit, refusal.line, refusal.reason, 
+                    // Unset `refusalClass` stays legal and means unclassified — DEC-242 — so
+                    // `attrs` is omitted entirely rather than sent with an `undefined` field.
+                    refusal.refusalClass === undefined
+                        ? undefined
+                        : {
+                            blockedBy: refusal.blockedBy,
+                            refusalClass: refusal.refusalClass,
+                            ...(refusal.argumentKind === undefined ? {} : { argumentKind: refusal.argumentKind }),
+                            ...(refusal.clientBase === undefined ? {} : { clientBase: refusal.clientBase }),
+                        });
+                }
+            }
+            for (const ref of fn.scope.refs) {
+                switch (ref.kind) {
+                    case "dynamic":
+                        ledger(declared.id, "CALLS", ref.raw, unit, ref.line, REASONS.valueTarget);
+                        break;
+                    case "type":
+                        emitType(declared.id, ref, unit, host, fn.scope);
+                        break;
+                    case "new":
+                        emitType(declared.id, ref, unit, host, fn.scope);
+                        emitConstructor(declared.id, ref, unit, host, declared.isTest);
+                        break;
+                    case "call":
+                        emitCall(declared.id, fn, ref, unit, host, declared.isTest);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+    /**
+     * DEC-084 in one function.
+     *
+     * Position is a specification guarantee, not a convention: a class has at most
+     * one base class and it must come first. So only the first entry of a class
+     * base list is ever ambiguous, and everything else is decided by the language.
+     */
+    function emitBaseList(declared, part, unit) {
+        part.baseList.forEach((raw, index) => {
+            const target = resolveType(raw, unit, declared);
+            const first = index === 0;
+            const canInherit = first && (part.form === "class" || part.form === "record");
+            if (!("declared" in target)) {
+                ledger(declared.id, canInherit ? "INHERITS" : "IMPLEMENTS", raw, unit, part.startLine, target.reason);
+                return;
+            }
+            const targetForm = target.declared.parts[0]?.form;
+            const type = canInherit && targetForm !== "interface" ? "INHERITS" : "IMPLEMENTS";
+            push({ from: declared.id, to: target.declared.id, type }, 2);
+        });
+    }
+    function emitType(from, ref, unit, host, scope_) {
+        if (ref.speculative === true) {
+            // `order.Total` and `Status.Pending` are the same shape. If the holder is
+            // a local, a parameter or a member, it is a value and not a type — which
+            // is not an unresolved reference, so nothing is written to the ledger.
+            if (scope_?.locals.has(ref.name) === true)
+                return;
+            if (host !== undefined && findMember(host, ref.name) !== undefined)
+                return;
+            const target = resolveType(ref.name, unit, host);
+            if ("declared" in target)
+                push({ from, to: target.declared.id, type: "USES_TYPE" }, 2);
+            return;
+        }
+        if (ref.name === "this" || ref.name === "base")
+            return;
+        const target = resolveType(ref.name, unit, host);
+        if (!("declared" in target)) {
+            ledger(from, "USES_TYPE", ref.name, unit, ref.line, target.reason);
+            return;
+        }
+        push({ from, to: target.declared.id, type: "USES_TYPE" }, 2);
+    }
+    function emitConstructor(from, ref, unit, host, isTest) {
+        const owner = ownerOfType(ref.name, unit, host);
+        if (!("declared" in owner))
+            return;
+        const constructor = owner.declared.methods.get(".ctor");
+        if (constructor !== undefined)
+            push({ from, to: constructor.id, type: isTest ? "TESTS" : "CALLS" }, 2);
+    }
+    function emitCall(from, fn, ref, unit, host, isTest) {
+        const edgeType = isTest ? "TESTS" : "CALLS";
+        // An unqualified call is a member of the enclosing type or something it
+        // inherits. It may also be a `using static` import, which is a member the
+        // name alone cannot separate from an inherited one — so a miss is disclosed.
+        if (ref.receiver === undefined &&
+            ref.receiverType === undefined &&
+            ref.receiverProperty === undefined &&
+            ref.receiverCall === undefined) {
+            // `handler(payload)` where `handler` is a local holding a delegate. The
+            // name is a *value*, not a method, and a type that happens to declare a
+            // method of the same name would otherwise collect a wrong edge — which is
+            // golden pattern 12's failure mode arriving through an unqualified call.
+            if (fn.scope.locals.has(ref.name)) {
+                ledger(from, edgeType, ref.raw, unit, ref.line, REASONS.valueTarget);
+                return;
+            }
+            const target = host === undefined ? undefined : findMethod(host, ref.name);
+            if (target === undefined) {
+                ledger(from, edgeType, ref.raw, unit, ref.line, host === undefined ? REASONS.outside : REASONS.unmodelled);
+                return;
+            }
+            push({ from, to: target.id, type: edgeType }, 2);
+            return;
+        }
+        const owner = ownerOf(ref, fn.scope, unit, host);
+        if (!("declared" in owner)) {
+            ledger(from, edgeType, ref.raw, unit, ref.line, owner.reason);
+            return;
+        }
+        const target = findMethod(owner.declared, ref.name);
+        if (target === undefined) {
+            ledger(from, edgeType, ref.raw, unit, ref.line, REASONS.unmodelled);
+            return;
+        }
+        push({ from, to: target.id, type: edgeType }, 2);
+    }
+    function ownerOf(ref, scope_, unit, host) {
+        if (ref.receiverType !== undefined)
+            return ownerOfType(ref.receiverType, unit, host);
+        if (ref.receiverCall !== undefined) {
+            const { receiver, name } = ref.receiverCall;
+            const holder = receiver === undefined
+                ? host === undefined
+                    ? undefined
+                    : { declared: host }
+                : ownerOfReceiver(receiver, scope_, unit, host);
+            if (holder === undefined || !("declared" in holder))
+                return { reason: REASONS.untypedReceiver };
+            const method = findMethod(holder.declared, name);
+            if (method === undefined)
+                return { reason: REASONS.unmodelled };
+            return ownerOfType(method.fn.returns, method.unit, holder.declared);
+        }
+        if (ref.receiver === undefined)
+            return { reason: REASONS.untypedReceiver };
+        // The written receiver may be a whole dotted path — `Shop.Orders.Money` is a
+        // namespace-qualified type, `this._repository` is a member chain. Trying the
+        // path as a type first is what separates them, and it costs nothing when it
+        // fails because the property route is tried immediately after.
+        const asType = resolveType(ref.receiver, unit, host);
+        if ("declared" in asType)
+            return asType;
+        if (ref.receiverProperty !== undefined) {
+            const holder = ownerOfReceiver(ref.receiverProperty.of, scope_, unit, host);
+            if (!("declared" in holder))
+                return holder;
+            const declaredType = findMember(holder.declared, ref.receiverProperty.name);
+            if (declaredType === undefined)
+                return { reason: REASONS.unmodelled };
+            return ownerOfType(declaredType, unit, holder.declared);
+        }
+        return ownerOfReceiver(ref.receiver, scope_, unit, host);
+    }
+    // -------------------------------------------------------------------------
+    // Routes
+    // -------------------------------------------------------------------------
+    //
+    // R2 and no lower, for the reason `adapter-go` records and `adapter-java`
+    // repeats: telling a controller from an ordinary class is provenance, and a
+    // route emitted from the R0 or R1 rung is a claim stronger than the run that
+    // produced it — which the Normaliser rejects as RESOLUTION_EXCEEDS_BATCH.
+    //
+    // Gated on `reached >= 2` alone, not on `frameworkFiles.length > 0` — a
+    // repository can make outbound `HttpClient` calls without being an ASP.NET
+    // server itself (a pure API-consuming client, an integration test project),
+    // so the caller's half below must not depend on route files existing. Only
+    // the route loop itself stays gated on ASP.NET files being present.
+    if (input.reached >= 2) {
+        const routeNodes = new Map();
+        const endpointNodes = new Map();
+        if (frameworkFiles.length > 0) {
+            const census = aspNetRoutes({ files: frameworkFiles });
+            // D-FIX-3's own finding: `census.unresolvedBaseSites` was computed
+            // correctly and never reached this ledger before this row — a real,
+            // disclosed-by-the-adapter-internally refusal that was nonetheless a
+            // true silence from `emit()`'s own caller's point of view. `SERVES_API`
+            // is the edge type this class's controller status would have produced
+            // evidence for, had the base resolved.
+            const unitByFile = new Map(units.map((each) => [each.file, each]));
+            for (const site of census.unresolvedBaseSites) {
+                const unit = unitByFile.get(site.file);
+                if (unit === undefined)
+                    continue;
+                const declared = types.get(keyOf(unit, qualify(unit.namespace, site.path)));
+                if (declared === undefined)
+                    continue;
+                ledger(declared.id, "SERVES_API", site.base, unit, site.line, `this class's controller status could not be determined: its base chain reaches \`${site.base}\`, ` +
+                    `which is not a declaration this run analysed — an external NuGet package (most often ` +
+                    `Ardalis.ApiEndpoints), or a declaration in another language in this same repository. Neither an ` +
+                    `API_ROUTE nor its absence is claimed for this class: this run genuinely does not know.`);
+            }
+            for (const route of census.routes) {
+                const template = normaliseEndpointPath(route.template);
+                const name = `${route.method} ${route.written}`;
+                const routeId = nodeId(scope, "API_ROUTE", name, LANGUAGE);
+                if (!routeNodes.has(routeId)) {
+                    routeNodes.set(routeId, {
+                        id: routeId,
+                        type: "API_ROUTE",
+                        name,
+                        file: route.file,
+                        range: { startLine: route.line, endLine: route.line },
+                        language: LANGUAGE,
+                        producedBy: input.producedBy,
+                        resolution: 2,
+                        attrs: {
+                            method: route.method,
+                            pathTemplate: template,
+                            rawTemplate: route.written,
+                            mechanism: route.mechanism,
+                            framework: route.framework,
+                        },
+                    });
+                }
+                // Workspace-scoped, fileless, language-less, and minted with the SAME
+                // `endpointQsp` every other producer uses — DEC-115's one hard
+                // constraint. Two producers that mint different ids do not conflict,
+                // they silently fail to join.
+                const endpointId = nodeId(scope, "API_ENDPOINT", endpointQsp(route.method, route.written), null);
+                if (!endpointNodes.has(endpointId)) {
+                    endpointNodes.set(endpointId, {
+                        id: endpointId,
+                        type: "API_ENDPOINT",
+                        name: `${route.method} ${template}`,
+                        file: null,
+                        range: null,
+                        language: null,
+                        producedBy: input.producedBy,
+                        resolution: 2,
+                        attrs: { method: route.method, pathTemplate: template },
+                    });
+                }
+                push({ from: routeId, to: endpointId, type: "SERVES_API" }, 2);
+            }
+        }
+        // --- The caller's half ---------------------------------------------------
+        //
+        // Mints into the SAME `endpointNodes` map, so a call to a route this run
+        // also read produces one node with two edges rather than two nodes with
+        // one each. A call to a route this run did *not* read still mints its
+        // endpoint — either side can exist without the other (golden 08's note).
+        for (const call of clientCallSites) {
+            const endpoint = endpointFor(scope, call, input.producedBy, normaliseEndpointPath);
+            if (!endpointNodes.has(endpoint.id))
+                endpointNodes.set(endpoint.id, endpoint);
+            push({
+                from: call.fromId,
+                to: endpoint.id,
+                type: "USES_API",
+                // DEC-164's contract: every `USES_API` edge this adapter mints now
+                // carries `clientBase` — `resolved` (a traced base composed per
+                // DEC-097) or `none` (no traced mechanism; the call's own literal
+                // path stood alone, unchanged from before this row). See
+                // `client-base.ts`'s own header for why `unresolved` is never
+                // produced by this build.
+                attrs: { callerKind: call.callerKind, via: call.method, clientBase: call.clientBase },
+            }, 2);
+        }
+        nodes.push(...routeNodes.values(), ...endpointNodes.values());
+    }
+    // D-FIX-3's client-base extractor (DEC-164): patch `attrs.clientBase` onto
+    // the caller `FUNCTION`/`TEST_CASE` node itself, not just the `USES_API`
+    // edge — golden patterns 08a/08b/08c bind their `caller_*` role to the
+    // node, and 08b's refused call has no edge for the fact to live on at all.
+    // Done here, after every unit's calls and refusals are known, because
+    // `functionNodeIndex` and `functionClientBase` are both built incrementally
+    // across the whole loop above.
+    for (const [fnId, base] of functionClientBase) {
+        const index = functionNodeIndex.get(fnId);
+        const node = index === undefined ? undefined : nodes[index];
+        if (node === undefined)
+            continue;
+        nodes[index] = { ...node, attrs: { ...node.attrs, clientBase: base } };
+    }
+    return { nodes, edges, unresolved };
+}
+//# sourceMappingURL=extract.js.map