@descryy/adapter-python 0.4.1 → 0.5.1

package/dist/extract.js

@@ -30,7 +30,7 @@
  * because `a/__init__.py` importing from `b/__init__.py` importing back is legal
  * Python and must not hang the run.
  */
-import { databaseTableNodesFromModel, edgeId, endpointQsp, isCallableNodeType, isTypeLikeNodeType, nodeId, normaliseEndpointPath, symbolQsp, testCaseQsp, } from "@descryy/ir";
+import { databaseTableNodesFromModel, edgeId, endpointQsp, externalQsp, isCallableNodeType, isTypeLikeNodeType, nodeId, normaliseEndpointPath, routeQsp, symbolQsp, testCaseQsp, } from "@descryy/ir";
 import { importRoots, modulePathOf, moduleNameOf, resolveImport, } from "./module.js";
 import { attributeExternal, externalImportTable, ownNamespaces, STDLIB_BASIS, } from "./external.js";
 import { DECLARATIVE_BASE_FACTORIES, ORM_BASE_MODULES, isFrameworkBaseName, ormShapeOf, } from "./orm.js";
@@ -39,7 +39,16 @@ import { drfShapeOf, dtoShapeOf, isDrfSerializerRoot, isPydanticRoot, isValidato
 import { DRF_ACTIONS, drfRegisterCallsIn, drfRouterLocalsIn, djangoUrlEntriesIn, HTTP_METHODS, isApplicationRouter, joinPath, mountsIn, odooRouteFromDecorator, routeFromDecorator, routersIn, } from "./routes.js";
 import { GRAPHQL_METHOD, fieldFromMethod, fieldsFromAttributes, operationPath, schemaDeclsIn, } from "./graphql.js";
 import { clientCallsIn, clientLocalsIn } from "./client.js";
+import { modelParsing, validateCalls } from "./response-shape.js";
 export const LANGUAGE = "python";
+/** Which packaging world an external module name belongs to. The name is the
+ *  ecosystem's, not an installed path's: `pyyaml` installs `yaml`, and `yaml`
+ *  is what the source writes and what this node is identified by. */
+const EXTERNAL_ECOSYSTEM = "pypi";
+/** An external node is attributed from the file's own `import`/`from`
+ *  statements, 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;
 /**
  * Confidence by the level an edge's evidence earned — never by the level the
  * run reached. DEC-058: those were two different notions in the first adapter,
@@ -79,10 +88,6 @@ const REASONS = {
     callBaseUnresolved: "an HTTP call written as f\"{BASE}/path\" whose base this file does not bind to a string " +
         "literal. The path half is readable and the base half is not, so the served template cannot " +
         "be assembled — the named base is the piece of work that would close it.",
-    callBaseIsExternalHost: "an HTTP call written as f\"{BASE}/path\" whose base resolves to an absolute URL on another " +
-        "host. Read correctly and out of scope for the join: an endpoint is identified by method and " +
-        "path with no host (DEC-014), so claiming one here would let this caller join a local route " +
-        "of the same path that it never reaches.",
     callPathFromLocal: "an HTTP call whose path is a local assembled earlier in the function. Distinguished from an " +
         "opaque path because it is reachable by further work, and filing the two together would " +
         "report one number for two populations.",
@@ -354,6 +359,24 @@ export function extract(input) {
     const edges = [];
     const unresolved = [];
     const seenEdge = new Set();
+    /**
+     * DEC-164's `attrs.clientBase`, per caller node id. First writer wins, so a
+     * function making two calls is described by the first one read rather than
+     * by whichever happened to be walked last.
+     *
+     * **Declared HERE, beside `nodes`, and the reason is a bug this already
+     * caused.** It sat next to the R2 guard, which reads as the right place —
+     * the client half is R2 work. But the client half runs inside `emitRoutes`,
+     * and `emitRoutes` is *called* above that line, so every run threw
+     * `ReferenceError: Cannot access 'clientBases' before initialization`,
+     * `extractOrDegrade` turned the throw into a degraded one-node-per-file
+     * graph, and the corpus reported all nineteen patterns as role-unbound
+     * failures rather than as a crash. A temporal-dead-zone error inside a
+     * catch-all degrade path looks exactly like an adapter that read nothing.
+     * The map stays empty below R2 because nothing writes to it there, which is
+     * the honest version of what the old placement was trying to say.
+     */
+    const clientBases = new Map();
     /** file -> declaration name (first segment) -> Declared */
     const declaredIn = new Map();
     /** node id -> the entry owning it, where it sits in `nodes`, and how many
@@ -430,19 +453,26 @@ export function extract(input) {
         }));
         assignedOf.set(file, new Set(parsed.assignedNames ?? []));
     }
+    /** Node ids already minted for a dependency symbol — one node per symbol, not
+     *  per call site. Measured node growth is +3.1% (plane) to +4.5% (dispatch). */
+    const externalIds = new Map();
     /**
-     * The module and symbol behind a call that left the repository, as ledger
-     * `attrs`, or `undefined` when no binding the developer wrote settles it.
+     * The id of the `FUNCTION` node standing for the symbol behind a call that
+     * left the repository, or `undefined` when no binding the developer wrote
+     * settles it — or when this run did not reach the resolution such a node
+     * requires.
      *
-     * **This does not mint a node or an edge.** `@descryy/ir` gained the
-     * discriminator that lets a `FUNCTION` stand for a symbol in a dependency
-     * only at 0.7.0; this package is pinned to the release before it, and a node
-     * emitted against that release is rejected with every edge to it — losing the
-     * ledger row as well, which is strictly worse than the boundary being
-     * unnamed. The attribution is computed at the site that files the row so that
-     * minting is the only step left.
+     * 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, and it owns no outgoing edge, because nothing read its
+     * body. `thirdParty` rides in `attrs`, never in the hash: a module that moved
+     * between the standard library and an installed package would otherwise
+     * change identity with no line of source changing.
      */
-    const externalAttrs = (file, receiver, name) => {
+    const mintExternal = (file, receiver, name) => {
+        if (input.reached < EXTERNAL_RESOLUTION)
+            return undefined;
         const attribution = attributeExternal({
             receiver,
             name,
@@ -451,18 +481,49 @@ export function extract(input) {
         });
         if (attribution === null)
             return undefined;
-        return {
-            external: {
-                // Identity, and it is the module path the source imported — never a
-                // site-packages directory, never a distribution name, never a version.
-                moduleOrNamespace: attribution.moduleOrNamespace,
-                symbol: attribution.symbolPath.join("."),
+        // Identity, and it is the module path the source imported — never a
+        // site-packages directory, never a distribution name, never a version.
+        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,
                 // Honest degradation: `thirdParty` is decided against a static list,
-                // not against anything installed, and the row says which list.
+                // not against anything installed, and the node says which list.
                 thirdPartyBasis: STDLIB_BASIS,
             },
-        };
+            external: {
+                ecosystem: EXTERNAL_ECOSYSTEM,
+                moduleOrNamespace: attribution.moduleOrNamespace,
+            },
+        });
+        return id;
+    };
+    /**
+     * The edge into a dependency is **always `CALLS`, never `TESTS`**, even when
+     * the container is a `TEST_CASE` and every in-repo edge it owns is a `TESTS`.
+     * `TESTS` asserts coverage — that this case exercises that node — and this
+     * run read nothing of the dependency's body, so it cannot assert it (rule 4,
+     * rule 7). A test that reaches `yaml.safe_load` calls it; it does not test
+     * it. Filed as `DEC-NEXT-external-edge-is-calls-not-tests`.
+     */
+    const callExternal = (from, to) => {
+        push({ from, to, type: "CALLS" }, EXTERNAL_RESOLUTION);
     };
     // --- which classes are test suites, decided from evidence not from names ---
     /** file -> top-level class name -> the bases it was written with. */
@@ -934,6 +995,7 @@ export function extract(input) {
                 file,
                 range: { startLine: declaration.range.startLine, endLine: declaration.range.endLine },
                 declaration,
+                qualifiedSymbolPath: qsp,
             };
             // **One name in one scope is one symbol, however many `def`s write it.**
             //
@@ -1109,6 +1171,7 @@ export function extract(input) {
                     fields: [],
                     decorators: [],
                 },
+                qualifiedSymbolPath: qsp,
             };
             byName.set(alias.name, entry);
             byFull.set(alias.name, entry);
@@ -1477,7 +1540,12 @@ export function extract(input) {
                     // left into is readable. This is the half `adapter-go` has no
                     // analogue for (Go has no from-import), and on measurement it is the
                     // larger half: 2,790 of 4,836 attributions on dispatch.
-                    disclose(source, edgeType, reference.name, file, reference.line, "outside", externalAttrs(file, undefined, reference.name));
+                    const external = mintExternal(file, undefined, reference.name);
+                    if (external !== undefined) {
+                        callExternal(source.id, external);
+                        continue;
+                    }
+                    disclose(source, edgeType, reference.name, file, reference.line, "outside");
                     continue;
                 }
                 if ((target.type === "FUNCTION" || target.type === "TEST_CASE") && target.id !== source.id) {
@@ -1560,8 +1628,16 @@ export function extract(input) {
                     // about this row — there is one, and it leaves the repository. So the
                     // reason becomes `outside`, which is what the row actually is. An
                     // unattributed row is untouched and stays `unknown`.
-                    const external = externalAttrs(file, reference.receiver, reference.name);
-                    disclose(source, edgeType, `${reference.receiver}.${reference.name}`, file, reference.line, external === undefined ? "unknown" : "outside", external);
+                    const external = mintExternal(file, reference.receiver, reference.name);
+                    if (external !== undefined) {
+                        // `import yaml` ... `yaml.safe_load(raw)`. When an import statement
+                        // binds the receiver, "no resolvable binding" is a FALSE sentence
+                        // about this row — there is one, and it leaves the repository. It
+                        // is now a node and an edge rather than a better-worded refusal.
+                        callExternal(source.id, external);
+                        continue;
+                    }
+                    disclose(source, edgeType, `${reference.receiver}.${reference.name}`, file, reference.line, "unknown");
                     continue;
                 }
                 const method = byFullName
@@ -1781,6 +1857,11 @@ export function extract(input) {
         const mounts = [];
         const routeDecls = [];
         const clientCalls = [];
+        /**
+         * Every file's client half, read but not yet judged — see the push site
+         * for why deciding is deferred to after the loop.
+         */
+        const pendingClients = [];
         const djangoRouteEntries = [];
         const djangoIncludeEntries = [];
         const drfRegisterEntries = [];
@@ -1849,27 +1930,22 @@ export function extract(input) {
                 const moduleId = moduleNodeId.get(file);
                 return moduleId === undefined ? undefined : { id: moduleId };
             };
-            for (const refusal of read.refusals) {
-                const container = containerFor([]);
-                if (container === undefined)
-                    continue;
-                disclose(container, "USES_API", refusal.rawTarget, refusal.file, 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 }),
-                    });
-            }
-            for (const call of read.calls) {
-                const container = containerFor(call.scope);
-                if (container === undefined)
-                    continue;
-                clientCalls.push({ call, containerId: container.id });
-            }
+            // EMITTED AFTER THE LOOP, NOT HERE — DEC-164's origin rule needs every
+            // file's bases before any one call site can be judged, and a base three
+            // files away is still evidence about this call. Reading is per file;
+            // deciding is per program. File order is preserved, so the ledger reads
+            // the same as it did.
+            pendingClients.push({
+                file,
+                calls,
+                moduleOfImport: moduleOfImportIn(file),
+                clientLocals,
+                constants,
+                localStrings,
+                functionParams,
+                containerFor,
+                read,
+            });
             for (const declaration of parsed.declarations) {
                 for (const call of declaration.decoratorCalls ?? []) {
                     const route = routeFromDecorator(file, call, declaration.path);
@@ -1893,6 +1969,81 @@ export function extract(input) {
                     drfRegisterEntries.push(reg);
             }
         }
+        // --- the client half, decided now that every file has been read --------
+        //
+        // DEC-164's own-origin rule admits an absolute call path only at an origin
+        // some base in this same program already resolves to. The first read
+        // produced those origins; the second re-reads only the files that could
+        // change, and with no absolute base anywhere `origins` is empty and no
+        // file is re-read at all.
+        const origins = new Set();
+        for (const pending of pendingClients) {
+            for (const call of pending.read.calls) {
+                if (call.baseOrigin !== undefined)
+                    origins.add(call.baseOrigin);
+            }
+        }
+        for (const pending of pendingClients) {
+            const couldChange = origins.size > 0 && pending.read.refusals.some((refusal) => refusal.reason === "callPathNotRelative");
+            const read = couldChange
+                ? clientCallsIn(pending.file, pending.calls, pending.moduleOfImport, pending.clientLocals, pending.constants, pending.localStrings, pending.functionParams, origins)
+                : pending.read;
+            for (const refusal of read.refusals) {
+                // DEC-164 is attributed to the caller that wrote the call; the ledger
+                // row's own container is unchanged and still the module.
+                const owner = pending.containerFor(refusal.scope);
+                if (owner !== undefined && refusal.clientBase !== undefined && !clientBases.has(owner.id)) {
+                    clientBases.set(owner.id, refusal.clientBase);
+                }
+                const container = pending.containerFor([]);
+                if (container === undefined)
+                    continue;
+                disclose(container, "USES_API", refusal.rawTarget, refusal.file, 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 }),
+                    });
+            }
+            // Pydantic parses written in this file, read once rather than per call
+            // — golden 18's consumer half. Read HERE and not at the first pass
+            // because `read` may be the SECOND read of this file (DEC-164's origin
+            // rule re-reads a file whose refusals could change), and a model
+            // resolved against the first read's calls would describe calls that no
+            // longer exist.
+            const parses = validateCalls(pending.calls);
+            for (const call of read.calls) {
+                const container = pending.containerFor(call.scope);
+                if (container === undefined)
+                    continue;
+                if (!clientBases.has(container.id))
+                    clientBases.set(container.id, call.clientBase);
+                clientCalls.push({
+                    call,
+                    containerId: container.id,
+                    responseModel: modelParsing(parses, call.scope, call.client, call.rawPath),
+                    responseModelFile: pending.file,
+                });
+            }
+        }
+        // DEC-164, patched onto the caller now rather than at the end of the
+        // function. `adapter-csharp` patches its own at the end and can, because
+        // it has one exit; this function returns early at `reached < 3`, and a
+        // patch after that line was **absent at R2 while the golden requires it
+        // there** — the conformance sweep caught it as three `node-attr-mismatch`
+        // findings at R2 only, which a single-level run would never have shown.
+        // Here is the earliest point where every caller node exists and every
+        // base has been decided.
+        for (let i = 0; i < nodes.length; i += 1) {
+            const base = clientBases.get(nodes[i].id);
+            if (base === undefined)
+                continue;
+            nodes[i] = { ...nodes[i], attrs: { ...nodes[i].attrs, clientBase: base } };
+        }
         /** child -> its parent and the prefix mounting it there. */
         const parentOf = new Map();
         for (const mount of mounts) {
@@ -2042,11 +2193,22 @@ export function extract(input) {
             // honest rather than implied.
             const served = joinPath(prefix, route.path);
             for (const method of route.methods) {
+                // Handler resolution now runs BEFORE the route id is computed. The
+                // resolved handler's own qualified symbol path is folded in as a
+                // third hash input alongside method+template — product ruling,
+                // `DEC-NEXT-duplicate-route-handlers-tracked-separately.md`: two
+                // different handlers serving one method+template must become two
+                // distinct `API_ROUTE` nodes (both still joined to the one shared
+                // `API_ENDPOINT` below), not the second one silently losing its node.
+                // Falls back to the declaring module's own qsp — never a raw file
+                // path (DEC-004) — when the handler can't be resolved.
+                const handler = route.handler === null ? undefined : resolveSameFileHandler(route.file, route.handler.join("."));
+                const handlerQsp = handler?.qualifiedSymbolPath ?? symbolQsp(pkg, modulePathOf(route.file));
                 // The route keeps the template AS WRITTEN in its identity and the
                 // normalised form in `attrs.pathTemplate` — `adapter-openapi` does
                 // exactly this, and two producers of one route must mint the same
                 // endpoint id or the join this whole lane exists for does not happen.
-                const routeId = nodeId(scope, "API_ROUTE", `${method} ${served}`, LANGUAGE);
+                const routeId = nodeId(scope, "API_ROUTE", routeQsp(method, served, handlerQsp), LANGUAGE);
                 let isNewRoute = false;
                 if (!routeSeen.has(routeId)) {
                     routeSeen.add(routeId);
@@ -2076,21 +2238,20 @@ export function extract(input) {
                     });
                 }
                 else {
-                    // This declaration's own SERVES_API edge and source location did not
-                    // enter the graph — a second router already claimed this exact
-                    // method+path. Real (two apps mounted at overlapping prefixes, a
-                    // duplicate registration) rather than a bug in this reader, but
-                    // silent until now: nothing distinguished it from "checked, only
-                    // one declaration exists".
+                    // The narrow residual this identity change still allows: two
+                    // declarations at the same method+template that ALSO resolved to
+                    // the exact same handler (or, unresolved, the exact same fallback
+                    // module qsp) — a genuine duplicate, correctly merged into one
+                    // node. A route with a *different* handler no longer reaches this
+                    // branch at all; it gets its own node above instead.
                     disclose(from, "SERVES_API", `${method} ${served}`, route.file, route.line, "routeIdCollision");
                 }
                 // Route -> handler, golden pattern 19. Only for the declaration that
-                // actually won the node above — the second of two declarations
-                // colliding on one method+path already lost its SERVES_API edge and
-                // location just above, and letting its handler through here would
-                // attach an unrelated function to a route it does not own.
+                // actually won the node above — the residual duplicate case just
+                // above already lost its SERVES_API edge and location, and letting
+                // its handler through here would attach it to a route it does not
+                // own.
                 if (isNewRoute) {
-                    const handler = route.handler === null ? undefined : resolveSameFileHandler(route.file, route.handler.join("."));
                     emitHandlerCalls(routeId, handler, route.handler === null ? `${method} ${served}` : route.handler.join("."), route.file, route.line, "routeHandlerUnresolved", 0);
                 }
                 else {
@@ -2378,7 +2539,19 @@ export function extract(input) {
         };
         const emitDjangoRoute = (file, line, served, method, methodDeclared, level, framework, handler) => {
             const from = { id: moduleNodeId.get(file) };
-            const routeId = nodeId(scope, "API_ROUTE", `${method} ${served}`, LANGUAGE);
+            // Every caller (`djangoRouteHandler`, DRF's own action lookup, the
+            // strawberry field lookup) has already resolved `handler` before this
+            // function runs, so its declaration's own qualified symbol path can be
+            // folded straight into the route id as a third hash input alongside
+            // method+template — product ruling,
+            // `DEC-NEXT-duplicate-route-handlers-tracked-separately.md`: two
+            // different handlers serving one method+template must become two
+            // distinct `API_ROUTE` nodes, not the second one silently losing its
+            // node. Falls back to the declaring module's own qsp — never a raw
+            // file path (DEC-004) — when there is no handler or it could not be
+            // resolved.
+            const handlerQsp = handler?.declared?.qualifiedSymbolPath ?? symbolQsp(pkg, modulePathOf(file));
+            const routeId = nodeId(scope, "API_ROUTE", routeQsp(method, served, handlerQsp), LANGUAGE);
             let isNewRoute = false;
             if (!routeSeen.has(routeId)) {
                 routeSeen.add(routeId);
@@ -2405,6 +2578,10 @@ export function extract(input) {
                 }
             }
             else {
+                // The narrow residual this identity change still allows: two
+                // declarations at the same method+template that ALSO resolved to the
+                // same handler (or the same fallback module qsp) — a genuine
+                // duplicate, correctly merged into one node.
                 disclose(from, "SERVES_API", `${method} ${served}`, file, line, "routeIdCollision");
             }
             if (handler !== undefined) {
@@ -2412,9 +2589,8 @@ export function extract(input) {
                     emitHandlerCalls(routeId, handler.declared, handler.rawTarget, file, line, handler.reason, 0);
                 }
                 else {
-                    // Consistent with the SERVES_API drop just above: the second of two
-                    // declarations colliding on one method+path does not get to claim a
-                    // handler either.
+                    // Consistent with the SERVES_API drop just above: the residual
+                    // duplicate case does not get to claim a handler either.
                     disclose({ id: routeId }, "CALLS", `${method} ${served}`, file, line, "routeIdCollision");
                 }
             }
@@ -2507,7 +2683,15 @@ export function extract(input) {
             }
             const served = normaliseEndpointPath(route.path).startsWith("/") ? route.path : `/${route.path}`;
             for (const method of route.methods) {
-                const routeId = nodeId(scope, "API_ROUTE", `${method} ${served}`, LANGUAGE);
+                // Same restructuring as the FastAPI/Flask site above: resolve the
+                // handler before minting the route id and fold its qualified symbol
+                // path into the hash as a third input (product ruling,
+                // `DEC-NEXT-duplicate-route-handlers-tracked-separately.md`).
+                // Fallback: the declaring module's own qsp, never a raw file path
+                // (DEC-004).
+                const handler = route.handler === null ? undefined : resolveSameFileHandler(route.file, route.handler.join("."));
+                const handlerQsp = handler?.qualifiedSymbolPath ?? symbolQsp(pkg, modulePathOf(route.file));
+                const routeId = nodeId(scope, "API_ROUTE", routeQsp(method, served, handlerQsp), LANGUAGE);
                 let isNewRoute = false;
                 if (!routeSeen.has(routeId)) {
                     routeSeen.add(routeId);
@@ -2525,10 +2709,12 @@ export function extract(input) {
                     });
                 }
                 else {
+                    // Narrow residual: two declarations at the same method+template
+                    // that also resolved to the same handler (or fallback qsp) — a
+                    // genuine duplicate, correctly merged into one node.
                     disclose(from, "SERVES_API", `${method} ${served}`, route.file, route.line, "routeIdCollision");
                 }
                 if (isNewRoute) {
-                    const handler = route.handler === null ? undefined : resolveSameFileHandler(route.file, route.handler.join("."));
                     emitHandlerCalls(routeId, handler, route.handler === null ? `${method} ${served}` : route.handler.join("."), route.file, route.line, "routeHandlerUnresolved", 0);
                 }
                 else {
@@ -2608,6 +2794,10 @@ export function extract(input) {
                 walk(local, schema.file, 0);
                 for (const { declared } of collected) {
                     const moduleOf = moduleOfImportIn(declared.file);
+                    // Populated below only for the decorated-method form, where a real
+                    // function declaration was found and resolved. The attribute/field
+                    // form's fields never get an entry — there is nothing to resolve to.
+                    const fieldHandlers = new Map();
                     const fields = [
                         ...fieldsFromAttributes(declared.declaration.attributes ?? [], declared.file, schema.naming, moduleOf),
                     ];
@@ -2627,8 +2817,21 @@ export function extract(input) {
                         // the last segment, and using the whole of it would mint
                         // `/Query/Query.circuit_by_id`.
                         candidate.path[candidate.path.length - 1], candidate.decorators ?? [], candidate.decoratorCalls ?? [], declared.file, candidate.range.startLine, schema.naming, moduleOf);
-                        if (field !== null)
+                        if (field !== null) {
                             fields.push(field);
+                            // The loop above already resolved this exact declaration to
+                            // decide it was a field at all — reusing the same same-file
+                            // lookup every other handler resolution in this file goes
+                            // through (`resolveSameFileHandler`, the Odoo case's own
+                            // precedent just above) rather than re-deriving a node
+                            // reference from `candidate` by hand. Attribute-form fields
+                            // never reach this branch, so they never gain an entry here —
+                            // `emitDjangoRoute` below sees `undefined` for those, same as
+                            // before this fix.
+                            const handlerDeclared = resolveSameFileHandler(declared.file, candidate.path.join("."));
+                            if (handlerDeclared !== undefined)
+                                fieldHandlers.set(field, handlerDeclared);
+                        }
                     }
                     for (const field of fields) {
                         if (field.name === null) {
@@ -2645,7 +2848,10 @@ export function extract(input) {
                         const level = (field.file === schema.file ? 0 : 1);
                         if (level > input.reached)
                             continue;
-                        emitDjangoRoute(field.file, field.line, operationPath(slot, field.name), GRAPHQL_METHOD, true, level, "strawberry");
+                        const handlerDeclared = fieldHandlers.get(field);
+                        emitDjangoRoute(field.file, field.line, operationPath(slot, field.name), GRAPHQL_METHOD, true, level, "strawberry", handlerDeclared === undefined
+                            ? undefined
+                            : { declared: handlerDeclared, rawTarget: field.name, reason: "routeHandlerCrossFile" });
                     }
                 }
             }
@@ -2664,7 +2870,9 @@ export function extract(input) {
         // rejected at the boundary as RESOLUTION_EXCEEDS_BATCH — the batch
         // contract catching a claim stronger than the run that produced it, which
         // is exactly what it is for.
-        for (const { call, containerId } of input.reached >= 2 ? clientCalls : []) {
+        for (const { call, containerId, responseModel, responseModelFile } of input.reached >= 2
+            ? clientCalls
+            : []) {
             const endpointId = nodeId(scope, "API_ENDPOINT", endpointQsp(call.method, call.path), null);
             if (!routeSeen.has(endpointId)) {
                 routeSeen.add(endpointId);
@@ -2680,6 +2888,26 @@ export function extract(input) {
                     attrs: { method: call.method, pathTemplate: normaliseEndpointPath(call.path) },
                 });
             }
+            /**
+             * Golden 18's consumer half. Gated on `input.reached >= 3` INSIDE the
+             * attrs rather than by an early return above: this loop runs from R2, so
+             * a guard placed one level up would be green at R3 and silently wrong at
+             * R2 — the monotonic sweep's own failure mode. At R2 the key is simply
+             * absent, which is the honest answer.
+             *
+             * R3 because the shape is a Pydantic DECLARATION — types stated, not
+             * inferred — which is DEC-202's rule and the same ground `adapter-java`'s
+             * JPA shapes and `adapter-sql`'s schema stand on. The edge itself stays
+             * at 2 (path resolution); `shapeResolution` carries the shape's own
+             * evidence so the contract engine does not cap it at the weaker of the
+             * two facts this edge holds (DEC-058).
+             */
+            const declaredShape = input.reached >= 3 && responseModel !== null
+                ? followName(responseModelFile, responseModel)
+                : undefined;
+            const shapeAttrs = declaredShape !== undefined && declaredShape.type === "DTO"
+                ? { responseType: declaredShape.id, shapeResolution: 3 }
+                : {};
             push({
                 from: containerId,
                 to: endpointId,
@@ -2689,6 +2917,7 @@ export function extract(input) {
                     file: call.file,
                     line: call.line,
                     written: call.rawPath,
+                    ...shapeAttrs,
                 },
             }, 2);
         }