@descryy/adapter-go 0.4.1 → 0.5.1

package/dist/extract.js

@@ -3,11 +3,21 @@
  * share a namespace completely). Import path is declared, so `qsp` needs no
  * anchor inference (DEC-047). `IMPLEMENTS` never emitted — structural in Go.
  */
-import { edgeId, endpointQsp, nodeId, normaliseEndpointPath, symbolQsp, testCaseQsp, } from "@descryy/ir";
+import { edgeId, endpointQsp, externalQsp, nodeId, normaliseEndpointPath, symbolQsp, testCaseQsp, } from "@descryy/ir";
+import { fileNode } from "@descryy/adapter-common";
 import { attributeExternal } from "./external.js";
 import { isUniverse } from "./parse.js";
+import { fieldReadsIn as gormFieldReadsIn, gormShapeOf, isGormModel } from "./gorm.js";
 import { endpointFor } from "./client.js";
 export const LANGUAGE = "go";
+/** Which packaging world an external module name belongs to. Go has one, and
+ *  the standard library is in it — `crypto/subtle` and a module path are both
+ *  named by the same `import` statement and resolved by the same toolchain. */
+const ECOSYSTEM = "go";
+/** An external node is attributed from the file's own `import` block, which is
+ *  module resolution and nothing more. R1 exactly: never R0 (the import *is*
+ *  the resolution), never R4 (nothing observed it run). */
+const EXTERNAL_RESOLUTION = 1;
 const CONFIDENCE = { 0: 0.5, 1: 0.7, 2: 0.9, 3: 0.95 };
 const REASONS = {
     outside: "names a package this run did not analyse — the standard library, a module in the build " +
@@ -24,7 +34,87 @@ const REASONS = {
     routeIdCollision: "this route's method and path are identical to one already emitted, so it collapsed onto " +
         "the same API_ROUTE node and this declaration's own SERVES_API edge and location were " +
         "dropped. The endpoint is real; this specific declaration is not the one the graph kept.",
+    grpcImplUnreadable: "the registration's implementation argument is not an inline `Type{}` (optionally `&Type{}`) value and " +
+        "not a plain name — a wrapper call, a selector expression, or a form this reader does not read. The " +
+        "route is real; the code implementing it is not established.",
+    grpcImplUntyped: "the registration's implementation argument names a value with no declared type this reader could " +
+        "trace to a composite literal — a function parameter, an interface-typed value with no concrete local " +
+        "binding, or a name declared outside the analysed set. The route is real; the code implementing it is " +
+        "not established.",
 };
+/**
+ * The fallback graph when `extract()` throws mid-run, per
+ * `DEC-NEXT-degraded-graph-shape-for-adapters-without-one.md`.
+ *
+ * `MODULE`, not `FILE` — unlike C#/Java (whose module identity is a
+ * declaration *inside* the file, exactly the machinery a mid-extraction
+ * throw means just failed), Go's import path is, in this adapter's own
+ * words, "declared, so `qsp` needs no anchor inference": it is resolved from
+ * `go.mod`'s `module` line plus the file's own directory (`modules.ts`'s
+ * `importPathOf`), never from parsing the file's content. `prepare()`
+ * already computed it, successfully, for every unit that reaches this
+ * function — `isolateFile` keeps a per-file parse/walk throw from ever
+ * populating `input.files` in the first place, so a throw here is
+ * necessarily further downstream (cross-file resolution, edge building), not
+ * a sign the identity below is unreliable. Minting `MODULE` with the exact
+ * id computation `extract()`'s own healthy path uses (`namespaceOf` +
+ * `symbolQsp`) means a degraded run's nodes merge with a later healthy run's
+ * for the same files, rather than forking against them the way a generic
+ * `FILE` node would.
+ *
+ * The per-file `try`/`catch` is defensive only: `namespaceOf` reads fields
+ * `prepare()` already resolved without error, so it should be unreachable in
+ * practice. If some future caller ever hands this function a unit whose
+ * fields are not what `prepare()` guarantees, falling back to the shared,
+ * language-blind `fileNode` (`@descryy/adapter-common`) for that one file
+ * keeps the fallback itself from becoming a second uncaught throw.
+ *
+ * One disclosure row, not one per file — the fact is about the run. Anchored
+ * to the first file's node because the ledger requires a `fromNodeId`.
+ */
+export function degradedGraph(input) {
+    const scope = { repo: input.repo, workspace: input.workspace };
+    const nodes = input.files.map((unit) => {
+        try {
+            const namespace = namespaceOf(unit);
+            const stem = unit.file.slice(unit.file.lastIndexOf("/") + 1).replace(/\.go$/, "");
+            return {
+                id: nodeId(scope, "MODULE", symbolQsp(namespace, [stem]), LANGUAGE),
+                type: "MODULE",
+                name: `${stem}.go`,
+                file: unit.file,
+                range: { startLine: 1, endLine: 1 },
+                language: LANGUAGE,
+                producedBy: input.producedBy,
+                resolution: 0,
+                attrs: { parsed: false },
+            };
+        }
+        catch {
+            return fileNode(scope, unit.file, input.producedBy);
+        }
+    });
+    const anchor = nodes[0];
+    const unresolved = anchor === undefined
+        ? []
+        : [
+            {
+                fromNodeId: anchor.id,
+                edgeType: "IMPORTS",
+                rawTarget: "(entire repository)",
+                file: anchor.file,
+                line: 1,
+                producedBy: input.producedBy,
+                reason: `NO GRAPH WAS PRODUCED for ${String(input.files.length)} Go file(s). ${input.cause}. ` +
+                    "Modules are listed because their import paths are a fact about the filesystem " +
+                    "(go.mod plus directory); their contents are absent. Every finding, coverage figure " +
+                    "and 'not affected' statement over this repository is UNSUPPORTED — this is a failed " +
+                    "analysis, not an empty repository.",
+                attrs: { refusalClass: "capability-gap" },
+            },
+        ];
+    return { nodes, edges: [], unresolved };
+}
 /** How many hops of `var A = B; var B = C` to follow before giving up. */
 const ALIAS_PASSES = 4;
 /** Usually the import path, except Go's external test package (`package storage_test`) is distinct — collapsing them lost `contextDone`/`makeInt64Pointer` on prometheus. */
@@ -91,26 +181,49 @@ export function extract(input) {
     const packages = new Map();
     const moduleIdOf = new Map();
     const ownModulePaths = input.ownModulePaths ?? [];
+    // --- Go/types shape evidence (R3) --------------------------------------
+    //
+    // `input.goShapes.structs` is already the "wanted" set — `goshapes/main.go`
+    // only ever records a struct a handler actually named as a request or
+    // response (`extractor.remember`, mirrored precision-over-recall stance to
+    // `adapter-python`'s DTO promotion never emitting an unreferenced class).
+    // Keyed by `${importPath}::${typeName}`, matching this file's own
+    // `${namespace}::${type.name}` key everywhere else a Go type is looked up.
+    const goStructsReady = input.reached >= 3 && input.goShapes !== undefined;
+    const goStructByKey = new Map();
+    if (goStructsReady) {
+        for (const s of input.goShapes.structs)
+            goStructByKey.set(`${s.importPath}::${s.name}`, s);
+    }
+    /** Populated only as each DTO node is actually minted below — the one
+     *  source of truth for "does this id exist in `nodes`", so the handler ->
+     *  DTO pass a bit further down can never point `USES_TYPE` at a node this
+     *  run did not emit (a dangling edge is exactly the wrong-edge corruption
+     *  rule 2 exists to prevent). */
+    const dtoIdByKey = new Map();
     /**
      * A boundary row, with the package behind it named when the file's own
      * `import` block settles which one it is.
      *
      * `REASONS.outside` says the callee is a scope boundary rather than an
      * analysis gap — correct, and this does not change it. What it adds is the
-     * fact the boundary *is*: `attrs.external` carries the import path the source
-     * wrote and the symbol chain, so the row states which dependency control left
-     * into instead of only that it left. A row with no `attrs.external` is one
-     * this adapter declined to attribute, and the reasons it declines are in
-     * `external.ts` — each is a recall cost paid for the 1-in-1,818 precision bar.
+     * fact the boundary *is*: which dependency control left into, and which
+     * symbol in it. When `external.ts` settles that from a binding the developer
+     * wrote, the site **mints a `FUNCTION` node standing for the dependency's
+     * symbol and a `CALLS` edge into it**, and files no ledger row — a site that
+     * resolves to a node is not an `UnresolvedRef`, and filing both would count
+     * it twice. When `external.ts` declines, the row is filed unchanged and says
+     * only that control left; the reasons it declines are in that module, each a
+     * recall cost paid for the 1-in-1,818 precision bar.
      *
-     * **This does not yet mint a node.** The IR gained the `external`
-     * discriminator that lets a `FUNCTION` stand for a symbol in a dependency;
-     * this package is pinned to the release before it, and emitting such a node
-     * against that release would have it rejected `MISSING_FILE` and every edge
-     * to it rejected `EDGE_ENDPOINT_DROPPED` — losing the ledger row too. The
-     * attribution is computed at the right site so that turning it into a node
-     * and a `CALLS` edge is the only step left. See
-     * `DEC-NEXT-external-symbol-nodes-at-the-dependency-boundary`.
+     * Three settled rules govern the node
+     * (`DEC-NEXT-external-symbol-nodes-at-the-dependency-boundary`): the qsp
+     * carries an `ext:` marker (`externalQsp`), the node may claim R1–R3 but
+     * never R0 or R4 — attribution *is* module resolution, so R1 is its floor —
+     * and it owns no outgoing edge, because nothing read its body. `thirdParty`
+     * rides in `attrs`, never in the hash: a package that moves between the
+     * standard library and a module would otherwise change identity with no line
+     * of source changing.
      */
     const boundary = (from, unit, scope, ref) => {
         const attribution = attributeExternal({
@@ -126,16 +239,53 @@ export function extract(input) {
             ledger(from, "CALLS", ref.raw, unit, ref.line, REASONS.outside);
             return;
         }
-        ledger(from, "CALLS", ref.raw, unit, ref.line, REASONS.outside, {
-            refusalClass: "out-of-scope",
+        const to = mintExternal(attribution);
+        if (to === null) {
+            // R0: nothing resolved a module, so there is no binding to have read and
+            // the node would claim more than the run earned. The boundary is still a
+            // fact and stays a row.
+            ledger(from, "CALLS", ref.raw, unit, ref.line, REASONS.outside);
+            return;
+        }
+        push({ from, to, type: "CALLS" }, EXTERNAL_RESOLUTION);
+    };
+    /** Node ids already minted for a dependency symbol — one node per symbol, not
+     *  per call site. Measured node growth is +6.9% (prometheus) to +13.0% (gin). */
+    const externalIds = new Map();
+    /**
+     * The `FUNCTION` node standing for one symbol in a dependency, or `null` when
+     * this run did not reach the resolution such a node requires.
+     */
+    const mintExternal = (attribution) => {
+        if (input.reached < EXTERNAL_RESOLUTION)
+            return null;
+        const qsp = externalQsp(attribution.moduleOrNamespace, attribution.symbolPath);
+        const existing = externalIds.get(qsp);
+        if (existing !== undefined)
+            return existing;
+        const id = nodeId(scope, "FUNCTION", qsp, LANGUAGE);
+        externalIds.set(qsp, id);
+        nodes.push({
+            id,
+            type: "FUNCTION",
+            name: attribution.symbolPath[attribution.symbolPath.length - 1] ?? "",
+            // No file and no range: the symbol lives in a dependency, and a node that
+            // named a file here would be invalidated by a source file it has nothing
+            // to do with.
+            file: null,
+            range: null,
+            language: LANGUAGE,
+            producedBy: input.producedBy,
+            resolution: EXTERNAL_RESOLUTION,
+            attrs: { thirdParty: attribution.thirdParty },
             external: {
+                ecosystem: ECOSYSTEM,
                 // Identity, and it is the import path the source wrote — never a
                 // module-cache path, never a `require` line's version.
                 moduleOrNamespace: attribution.moduleOrNamespace,
-                symbol: attribution.symbolPath.join("."),
-                thirdParty: attribution.thirdParty,
             },
         });
+        return id;
     };
     /** Node id -> other files declaring it under a different build constraint, disclosed on the node. */
     const alternates = new Map();
@@ -144,6 +294,29 @@ export function extract(input) {
     /** Two `t.Run` calls sharing a literal name are two subtests; `occurrence` keeps both. */
     const testOccurrence = new Map();
     const describe = (unit) => unit.buildConstraint === undefined ? unit.file : `${unit.file} (//go:build ${unit.buildConstraint})`;
+    /**
+     * Methods by `package::Type`, collected before anything is minted.
+     *
+     * A Go method lives wherever its author put it, routinely in a different
+     * file from its type — `TableName()` in `table.go` next to `Order` in
+     * `order.go` is ordinary. Deciding the ORM shape inside the per-file loop
+     * below would read whichever half happened to come first.
+     */
+    const methodsByType = new Map();
+    for (const unit of input.files) {
+        if (unit.importPath === "")
+            continue;
+        for (const fn of unit.funcs) {
+            if (fn.receiver === undefined)
+                continue;
+            const key = `${namespaceOf(unit)}::${fn.receiver}`;
+            const found = methodsByType.get(key);
+            if (found === undefined)
+                methodsByType.set(key, [fn]);
+            else
+                found.push(fn);
+        }
+    }
     for (const unit of input.files) {
         if (unit.importPath === "")
             continue;
@@ -170,24 +343,83 @@ export function extract(input) {
             attrs: unit.hasError ? { parsedWithErrors: true } : {},
         });
         for (const type of unit.types) {
-            const id = nodeId(scope, "CLASS", symbolQsp(namespace, [type.name]), LANGUAGE);
+            // MODEL is a framework claim and the only evidence for it is a `gorm`
+            // struct tag — see `gorm.ts`. DTO is the same kind of promotion, on
+            // go/types evidence instead: a struct is a DTO here iff the Go helper
+            // itself named it as some handler's decoded/encoded shape — never
+            // guessed from the struct's own name or fields. MODEL wins where both
+            // somehow apply (a type that is both persisted and decoded at a
+            // boundary is primarily the table, mirroring `adapter-python`'s own
+            // tie-break — a wrong `MODEL` claims a database, a wrong `DTO` claims a
+            // wire format). The node type is part of the hash (DEC-004), so it has
+            // to be decided before the id is minted.
+            const isModel = isGormModel(type);
+            const goShape = !isModel ? goStructByKey.get(`${namespace}::${type.name}`) : undefined;
+            const isDto = goShape !== undefined;
+            const id = nodeId(scope, isModel ? "MODEL" : isDto ? "DTO" : "CLASS", symbolQsp(namespace, [type.name]), LANGUAGE);
             // Legal when behind mutually exclusive build constraints (`gin`'s `Binding`) — one node, alternatives disclosed.
             const existing = pkg.types.get(type.name);
             if (existing !== undefined) {
                 alternates.set(id, [...(alternates.get(id) ?? []), describe(unit)]);
                 continue;
             }
-            pkg.types.set(type.name, { id, type, unit });
+            pkg.types.set(type.name, { id, type, unit, isModel });
+            if (isDto)
+                dtoIdByKey.set(`${namespace}::${type.name}`, id);
+            const ormAttrs = {};
+            const dtoAttrs = {};
+            if (isDto && goShape !== undefined) {
+                // **R3, unconditionally** — `goStructsReady` already gated whether
+                // `goShape` could exist at all (`input.reached >= 3`), so every DTO
+                // this branch reaches is real go/types evidence, never a hint the
+                // run has to wait on the way `adapter-python`'s annotation-derived
+                // DTO does (DEC-062's tradeoff does not apply here: this shape was
+                // CHECKED, not merely written down).
+                //
+                // `fields` is names and `fieldDetail` is shapes — `adapter-openapi`'s
+                // convention, matched rather than reinvented (golden 05 compares a
+                // list of names; two producers describing the same construct two
+                // ways is the defect DEC-115 exists to prevent for endpoints).
+                dtoAttrs["schema"] = "go-types";
+                dtoAttrs["fields"] = goShape.fields.filter((f) => f.skip !== true).map((f) => f.name);
+                dtoAttrs["fieldDetail"] = goShape.fields.map((f) => ({
+                    name: f.name,
+                    type: f.type,
+                    ...(f.jsonName === undefined ? {} : { jsonName: f.jsonName }),
+                    ...(f.embedded === true ? { embedded: true } : {}),
+                    ...(f.skip === true ? { skip: true } : {}),
+                }));
+            }
+            if (isModel) {
+                const shape = gormShapeOf(type, methodsByType.get(`${namespace}::${type.name}`) ?? []);
+                ormAttrs["orm"] = "gorm";
+                if (shape.table !== null)
+                    ormAttrs["table"] = shape.table;
+                else {
+                    ormAttrs["tableUnresolved"] = true;
+                    ormAttrs["tableUnresolvedReason"] =
+                        "the type declares no `TableName()` returning a literal, so only GORM's NamingStrategy " +
+                            "would say — configuration set in application code this adapter never reads, refused " +
+                            "rather than guessed";
+                }
+                if (shape.fields.length > 0)
+                    ormAttrs["fields"] = shape.fields;
+                // No DATABASE_TABLE/DATABASE_COLUMN. A `column:` tag does declare a
+                // physical name, but it is optional and usually omitted, so minting on
+                // the tagged subset yields a node that reads as a complete table and is
+                // not one. `gorm.ts`'s header has the full argument.
+                ormAttrs["databaseTableRefused"] = "column-tags-are-optional-so-the-set-is-incomplete";
+            }
             nodes.push({
                 id,
-                type: "CLASS",
+                type: isModel ? "MODEL" : isDto ? "DTO" : "CLASS",
                 name: type.name,
                 file: unit.file,
                 range: { startLine: type.startLine, endLine: type.endLine },
                 language: LANGUAGE,
                 producedBy: input.producedBy,
                 resolution: 0,
-                attrs: { declarationForm: type.form },
+                attrs: { declarationForm: type.form, ...ormAttrs, ...dtoAttrs },
             });
         }
         for (const fn of unit.funcs) {
@@ -234,6 +466,53 @@ export function extract(input) {
             }
         }
     }
+    // --- USES_TYPE, handler -> its go/types-confirmed request/response DTO ---
+    //
+    // **R3, and the reason it can be:** unlike a route's own written contract
+    // (a Python `response_model=`, a Java annotation), nothing at a Go
+    // registration site names which struct a handler decodes or encodes —
+    // that fact lives inside the function body, in a `Decode`/`Bind`/`JSON`
+    // call, and finding it needs data flow through a type checker, not a name
+    // to resolve. That is a stronger claim than R2's reference resolution, and
+    // it is exactly what `goShapes` supplies.
+    //
+    // Correlated by `${importPath}::${receiver}.${funcName}` against `packages`'
+    // own `funcs` map — the SAME map `route.handlerRaw` resolution already
+    // trusts a few hundred lines up — and by `dtoIdByKey` for the DTO side, so
+    // an edge is only ever pushed at an id this run actually minted a node
+    // for. Anything that fails to correlate (the go/types pass named a
+    // package or struct this run's own tree-sitter pass never read, or the
+    // struct lived under a namespace the two readers computed differently)
+    // is silently not an edge — a disclosed recall gap between two readers of
+    // the same repository, never a guess at which node was meant.
+    if (goStructsReady) {
+        for (const found of input.goShapes.handlers) {
+            const pkg = packages.get(found.importPath);
+            if (pkg === undefined)
+                continue;
+            const key = found.receiver === undefined ? found.funcName : `${found.receiver}.${found.funcName}`;
+            const fn = pkg.funcs.get(key);
+            if (fn === undefined)
+                continue;
+            const rolesByDto = new Map();
+            const addRole = (ref, role) => {
+                if (ref === undefined)
+                    return;
+                const dtoId = dtoIdByKey.get(`${ref.importPath}::${ref.name}`);
+                if (dtoId === undefined)
+                    return;
+                const roles = rolesByDto.get(dtoId) ?? [];
+                if (!roles.includes(role))
+                    roles.push(role);
+                rolesByDto.set(dtoId, roles);
+            };
+            addRole(found.request, "request");
+            addRole(found.response, "response");
+            for (const [dtoId, roles] of rolesByDto) {
+                push({ from: fn.id, to: dtoId, type: "USES_TYPE", attrs: { roles } }, 3);
+            }
+        }
+    }
     /** A written type name, split into its package qualifier and its own name. */
     const split = (written) => {
         const cut = written.indexOf(".");
@@ -442,6 +721,14 @@ export function extract(input) {
     }
     /** The caller's half of the HTTP boundary, minted with the routes below. */
     const clientCallSites = [];
+    /**
+     * DEC-164: caller node id -> the base this reader traced for it. First
+     * writer wins, so a function making two calls is described by the first one
+     * read rather than by whichever was walked last. Patched onto the node
+     * after the walk, the way `adapter-csharp` does it — the node is already in
+     * `disclosed` by the time its calls are read.
+     */
+    const functionClientBase = new Map();
     for (const unit of input.files) {
         const moduleId = moduleIdOf.get(unit.file);
         if (moduleId === undefined) {
@@ -490,11 +777,39 @@ export function extract(input) {
                 if (subtestId !== undefined)
                     emitRefs(subtestId, subtest, true, unit);
             }
+            // `order.TotalAmount` where `var order orders.Order` — golden 07. Go's
+            // parser already records `X.Y` as a `member` ref, so the only thing
+            // added here is the receiver's DECLARED type. `order := fetch(id)`
+            // states nothing at the binding site and produces nothing.
+            for (const read of gormFieldReadsIn(fn, (written) => {
+                const resolved = resolveType(unit, written);
+                return "declared" in resolved && resolved.declared.isModel === true
+                    ? resolved.declared.id
+                    : undefined;
+            })) {
+                if (read.model === declared.id)
+                    continue;
+                push({ from: declared.id, to: read.model, type: "READS", attrs: { fields: read.fields } }, 
+                // Both halves are written names resolved to a declaration — R2, the
+                // rung every other edge here rests on. The SHAPE lives on the MODEL
+                // node; the edge claims no more than it saw.
+                2);
+            }
             // The caller's half of the HTTP boundary — DEC-262's fork, Go's half.
             // Collected here, where the enclosing FUNCTION's own id is finally known,
             // and emitted with the routes below so both halves mint one API_ENDPOINT.
-            for (const call of fn.clientCalls)
+            for (const call of fn.clientCalls) {
                 clientCallSites.push({ ...call, fromId: declared.id });
+                if (!functionClientBase.has(declared.id))
+                    functionClientBase.set(declared.id, call.clientBase);
+            }
+            for (const refusal of fn.clientRefusals) {
+                // A refusal still states a base when DEC-164 reached one — 08b's whole
+                // point is that `unresolved` is a reading, not a silence.
+                if (refusal.clientBase !== undefined && !functionClientBase.has(declared.id)) {
+                    functionClientBase.set(declared.id, refusal.clientBase);
+                }
+            }
             for (const refusal of fn.clientRefusals) {
                 ledger(declared.id, "USES_API", refusal.raw, unit, refusal.line, refusal.reason, 
                 // Unset `refusalClass` stays legal and means unclassified — DEC-242 — so
@@ -505,6 +820,8 @@ export function extract(input) {
                         blockedBy: refusal.blockedBy,
                         refusalClass: refusal.refusalClass,
                         ...(refusal.argumentKind === undefined ? {} : { argumentKind: refusal.argumentKind }),
+                        ...(refusal.clientBase === undefined ? {} : { clientBase: refusal.clientBase }),
+                        ...(refusal.callPath === undefined ? {} : { callPath: refusal.callPath }),
                     });
             }
         }
@@ -688,9 +1005,24 @@ export function extract(input) {
     // one node, and the node says which files it stood in for.
     const disclosed = nodes.map((node) => {
         const others = alternates.get(node.id);
-        if (others === undefined)
+        // DEC-164's client base. NOT behind the R2 gate the `USES_API` edge sits
+        // behind: the golden asserts `attrs.clientBase` at R2 and the field is a
+        // reading of the source, not of a rung. `adapter-python` shipped this
+        // patch after an `input.reached` guard and it was green at R3 and absent
+        // at R2 — only the monotonic sweep saw it.
+        const base = functionClientBase.get(node.id);
+        // The field's ABSENCE is DEC-164's fourth state: a function no HTTP call
+        // was read from says nothing about a base, rather than saying `none`.
+        if (others === undefined && base === undefined)
             return node;
-        return { ...node, attrs: { ...node.attrs, buildConstrainedAlternates: others } };
+        return {
+            ...node,
+            attrs: {
+                ...node.attrs,
+                ...(others === undefined ? {} : { buildConstrainedAlternates: others }),
+                ...(base === undefined ? {} : { clientBase: base }),
+            },
+        };
     });
     // Routes (DEC-117), last: every ledger row attributes to a MODULE the pass above already minted.
     const routeNodes = new Map();
@@ -822,6 +1154,52 @@ export function extract(input) {
             }
         }
     }
+    /** The Go function whose body contains this line, innermost first — a registration inside a closure resolves against the closure's own locals, not its enclosing function's. */
+    const enclosingFunc = (unit, line) => {
+        let found;
+        for (const fn of unit.funcs) {
+            if (fn.startLine <= line && line <= fn.endLine) {
+                if (found === undefined || fn.endLine - fn.startLine < found.endLine - found.startLine)
+                    found = fn;
+            }
+        }
+        return found;
+    };
+    /**
+     * `Register<Service>Server(server, impl)`'s `impl` argument, resolved to a
+     * declared type the same way every other receiver in this file is: an
+     * inline composite literal (`&orderServer{}`) names its type directly;
+     * a bare name is looked up against its enclosing function's locals, a
+     * pending call-result binding, then the package's own vars — the same
+     * single-segment case `typeOfPath` already handles, read out here because
+     * the registration site (`grpc.ts`) has no function scope of its own to
+     * hand back.
+     *
+     * Never fails silently: every branch that cannot resolve returns a reason,
+     * and the gRPC loop below discloses it once per route rather than dropping
+     * the registration the way it silently did before (`DEC-NEXT-grpc-handler-
+     * edge-silent-gap`).
+     */
+    const resolveGrpcImplType = (unit, registration) => {
+        const impl = registration.impl;
+        if (impl === undefined)
+            return { reason: REASONS.grpcImplUnreadable };
+        if (impl.kind === "literal")
+            return resolveType(unit, impl.typeWritten);
+        const fn = enclosingFunc(unit, registration.line);
+        const local = fn?.locals.get(impl.name);
+        if (local !== undefined && local !== null)
+            return resolveType(unit, local);
+        if (fn !== undefined && fn.pending.has(impl.name)) {
+            const fromCall = resultTypeOf(unit, fn, impl.name, 0);
+            if (fromCall !== undefined)
+                return fromCall;
+        }
+        const packageLevel = packageVarType(unit, impl.name);
+        if (packageLevel !== undefined)
+            return resolveType(unit, packageLevel);
+        return { reason: REASONS.grpcImplUntyped };
+    };
     // --- gRPC routes — see `grpc.ts`'s own header for the wire-path-is-read, not-
     // invented rationale and the `method: "RPC"` sentinel. Cross-file by nature:
     // a `_FullMethodName` const and the `Register<Service>Server(...)` call site
@@ -858,6 +1236,9 @@ export function extract(input) {
                 const methods = targetNamespace === undefined ? undefined : grpcMethodsByNamespace.get(targetNamespace)?.get(registration.service);
                 if (methods === undefined || methods.length === 0)
                     continue;
+                // Computed once per registration, not per method: every RPC this
+                // registration serves is implemented by the SAME `impl` value.
+                const implResolution = resolveGrpcImplType(unit, registration);
                 for (const method of methods) {
                     const template = normaliseEndpointPath(method.path);
                     const name = `RPC ${method.path}`;
@@ -901,6 +1282,25 @@ export function extract(input) {
                         });
                     }
                     push({ from: routeId, to: endpointId, type: "SERVES_API" }, 2);
+                    // --- Which method implements it ------------------------------------
+                    //
+                    // Unlike an HTTP handler, a gRPC method is always named — the const
+                    // this route was minted from already names it. What was missing is
+                    // resolving `impl`'s type and finding that name on it. `SERVES_API`
+                    // stopping here and nothing else being said was the bug: every route
+                    // below gets either a CALLS edge or a disclosed reason, never neither.
+                    if ("declared" in implResolution) {
+                        const target = findMethod(implResolution.declared, method.method);
+                        if (target !== undefined) {
+                            push({ from: routeId, to: target.id, type: "CALLS" }, 2);
+                        }
+                        else {
+                            ledger(routeId, "CALLS", `${registration.service}.${method.method}`, unit, registration.line, REASONS.unmodelled);
+                        }
+                    }
+                    else {
+                        ledger(routeId, "CALLS", `${registration.service}.${method.method}`, unit, registration.line, implResolution.reason);
+                    }
                 }
             }
         }
@@ -925,6 +1325,24 @@ export function extract(input) {
         }
     }
     const withRoutes = [...disclosed, ...routeNodes.values(), ...endpointNodes.values()];
+    // A caller that asked for R3 and did not get it hears why, the same way a
+    // whole-run degradation does (`degradedGraph`, above) — just scoped to the
+    // one capability that fell back, not the whole graph.
+    if (input.goShapesUnavailableReason !== undefined) {
+        const anchor = withRoutes[0];
+        if (anchor !== undefined) {
+            unresolved.push({
+                fromNodeId: anchor.id,
+                edgeType: "USES_TYPE",
+                rawTarget: "(go/types shape extraction)",
+                file: anchor.file,
+                line: 1,
+                producedBy: input.producedBy,
+                reason: input.goShapesUnavailableReason,
+                attrs: { refusalClass: "capability-gap" },
+            });
+        }
+    }
     return { nodes: withRoutes, edges, unresolved };
 }
 export { REASONS };