@descryy/adapter-csharp 0.4.1 → 0.5.1

package/dist/dto.d.ts

@@ -0,0 +1,73 @@
+/**
+ * `DTO` for C# — the transport shapes a ROUTE declares, never a type that
+ * looks like one.
+ *
+ * ## The rule this keeps
+ *
+ * DEC-043 refused `DTO` because the corpus supplies structurally identical
+ * types separable only by name, and `*Request`/`*Response` -> `DTO` is a
+ * heuristic. **Nothing in this file reads the candidate type to decide whether
+ * it is one.** A type becomes a `DTO` because an ASP.NET Core controller names
+ * it, under two rules the framework states itself:
+ *
+ *   - a controller action's **return type is the response body** — a
+ *     `[ApiController]` (or `ControllerBase`-derived) action is serialized
+ *     straight to the response, with no view resolution in the path;
+ *   - **`[FromBody]` on a parameter** says the parameter's type is bound from
+ *     the request body.
+ *
+ * Both markers are on the action. The entity beside them keeps its fields and
+ * its name and stays a `CLASS`, which is the discrimination golden pattern 07
+ * exists to test.
+ *
+ * ## Refusals
+ *
+ * - **`[FromRoute]`/`[FromQuery]`/`[FromHeader]`/`[FromServices]` are
+ *   parameter attributes and are not bodies**, and an unattributed parameter
+ *   declares nothing either. `[ApiController]`'s binding *inference* would
+ *   treat a complex-typed parameter as a body with no attribute at all; that
+ *   is real ASP.NET and deliberately NOT read here — it is an inference rule
+ *   layered on top of the written one, and admitting it would mint a `DTO` for
+ *   every service and options object an action happens to take.
+ * - **A framework or built-in return type names no shape**: `IActionResult`,
+ *   `ActionResult<T>`, `Task<T>`, `string`, `void`, a collection. `T` is a
+ *   generic argument and resolving it is a read this file does not do, so it
+ *   refuses rather than minting the wrapper.
+ * - **A type resolving to no declaration here, or to two, is refused** — a
+ *   `DTO` with no shape joins nothing, and the wrong one carries the wrong
+ *   shape into a comparison.
+ * - **An EF Core entity stays a `MODEL`** (applied by the caller, which holds
+ *   both maps): a wrong `MODEL` is a claim about a database, a wrong `DTO` a
+ *   claim about a wire format.
+ *
+ * ## Field NAMES, and deliberately not field detail
+ *
+ * `attrs.fields` carries declared member names — a name-level fact, which rule
+ * 3 permits at R2. No `fieldDetail`, no `shapeResolution`, no resolution
+ * raise, and `shape-reach.ts` untouched: whether a plain class body's member
+ * list is R3-grade evidence is a filed, unanswered question with fleet-wide
+ * blast radius. Golden 05's note asks for exactly this shape.
+ */
+import type { CsFile } from "./parse.ts";
+/** The fully-qualified name, spelled exactly as `extract.ts`'s `qualify` does —
+ *  the key `modelsByName` and the type table both use, so one lookup answers both.
+ *  Exported for `shape-reach.ts`/`json.ts`, which need the identical key at
+ *  `prepare()` time, before `extract.ts`'s own copy has run. */
+export declare function qualify(namespace: string, path: readonly string[]): string;
+/** The declaration marker every `DTO` this file mints names in `attrs.schema`. */
+export declare const SCHEMA = "aspnetcore";
+export interface TransportShape {
+    /** Declared member names, sorted. Names only — see the header. */
+    readonly fields: readonly string[];
+    readonly roles: readonly ("request" | "response")[];
+}
+/**
+ * Every type an ASP.NET action declares as a request or response body, across
+ * the whole batch. Keyed by the same `path.join(".")` identity the caller's
+ * own type map uses.
+ *
+ * Resolution is by simple name against the declared types — the reach this
+ * adapter has. A name declared twice is refused rather than ranked.
+ */
+export declare function readTransportShapes(files: readonly CsFile[]): ReadonlyMap<string, TransportShape>;
+//# sourceMappingURL=dto.d.ts.map

package/dist/dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto.d.ts","sourceRoot":"","sources":["../src/dto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAU,MAAM,YAAY,CAAC;AAEjD;;;gEAGgE;AAChE,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAG1E;AAED,kFAAkF;AAClF,eAAO,MAAM,MAAM,eAAe,CAAC;AAoEnC,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,GAAG,UAAU,CAAC,EAAE,CAAC;CACrD;AAwBD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAgDrC"}

package/dist/dto.js

@@ -0,0 +1,205 @@
+/**
+ * `DTO` for C# — the transport shapes a ROUTE declares, never a type that
+ * looks like one.
+ *
+ * ## The rule this keeps
+ *
+ * DEC-043 refused `DTO` because the corpus supplies structurally identical
+ * types separable only by name, and `*Request`/`*Response` -> `DTO` is a
+ * heuristic. **Nothing in this file reads the candidate type to decide whether
+ * it is one.** A type becomes a `DTO` because an ASP.NET Core controller names
+ * it, under two rules the framework states itself:
+ *
+ *   - a controller action's **return type is the response body** — a
+ *     `[ApiController]` (or `ControllerBase`-derived) action is serialized
+ *     straight to the response, with no view resolution in the path;
+ *   - **`[FromBody]` on a parameter** says the parameter's type is bound from
+ *     the request body.
+ *
+ * Both markers are on the action. The entity beside them keeps its fields and
+ * its name and stays a `CLASS`, which is the discrimination golden pattern 07
+ * exists to test.
+ *
+ * ## Refusals
+ *
+ * - **`[FromRoute]`/`[FromQuery]`/`[FromHeader]`/`[FromServices]` are
+ *   parameter attributes and are not bodies**, and an unattributed parameter
+ *   declares nothing either. `[ApiController]`'s binding *inference* would
+ *   treat a complex-typed parameter as a body with no attribute at all; that
+ *   is real ASP.NET and deliberately NOT read here — it is an inference rule
+ *   layered on top of the written one, and admitting it would mint a `DTO` for
+ *   every service and options object an action happens to take.
+ * - **A framework or built-in return type names no shape**: `IActionResult`,
+ *   `ActionResult<T>`, `Task<T>`, `string`, `void`, a collection. `T` is a
+ *   generic argument and resolving it is a read this file does not do, so it
+ *   refuses rather than minting the wrapper.
+ * - **A type resolving to no declaration here, or to two, is refused** — a
+ *   `DTO` with no shape joins nothing, and the wrong one carries the wrong
+ *   shape into a comparison.
+ * - **An EF Core entity stays a `MODEL`** (applied by the caller, which holds
+ *   both maps): a wrong `MODEL` is a claim about a database, a wrong `DTO` a
+ *   claim about a wire format.
+ *
+ * ## Field NAMES, and deliberately not field detail
+ *
+ * `attrs.fields` carries declared member names — a name-level fact, which rule
+ * 3 permits at R2. No `fieldDetail`, no `shapeResolution`, no resolution
+ * raise, and `shape-reach.ts` untouched: whether a plain class body's member
+ * list is R3-grade evidence is a filed, unanswered question with fleet-wide
+ * blast radius. Golden 05's note asks for exactly this shape.
+ */
+/** The fully-qualified name, spelled exactly as `extract.ts`'s `qualify` does —
+ *  the key `modelsByName` and the type table both use, so one lookup answers both.
+ *  Exported for `shape-reach.ts`/`json.ts`, which need the identical key at
+ *  `prepare()` time, before `extract.ts`'s own copy has run. */
+export function qualify(namespace, path) {
+    const joined = path.join(".");
+    return namespace === "" ? joined : `${namespace}.${joined}`;
+}
+/** The declaration marker every `DTO` this file mints names in `attrs.schema`. */
+export const SCHEMA = "aspnetcore";
+/** ASP.NET's own statement that a parameter is bound from the request body. */
+const BODY_PARAMETER = "FromBody";
+/** Action attributes that make a method a route handler at all. */
+const VERB_ATTRIBUTES = new Set([
+    "HttpGet",
+    "HttpPost",
+    "HttpPut",
+    "HttpPatch",
+    "HttpDelete",
+    "HttpHead",
+    "HttpOptions",
+    "Route",
+]);
+/**
+ * Framework plumbing and built-ins. A return type here is refused: the real
+ * payload of `ActionResult<T>`/`Task<T>` is its type argument, and this reader
+ * does not resolve generics.
+ */
+const NOT_A_SHAPE = new Set([
+    "IActionResult",
+    "ActionResult",
+    "Task",
+    "ValueTask",
+    "IResult",
+    "JsonResult",
+    "ObjectResult",
+    "ContentResult",
+    "FileResult",
+    "IEnumerable",
+    "ICollection",
+    "IList",
+    "List",
+    "IQueryable",
+    "Dictionary",
+    "IDictionary",
+    "string",
+    "object",
+    "void",
+    "String",
+    "Object",
+    "bool",
+    "byte",
+    "sbyte",
+    "char",
+    "decimal",
+    "double",
+    "float",
+    "int",
+    "uint",
+    "long",
+    "ulong",
+    "short",
+    "ushort",
+    "Boolean",
+    "Int32",
+    "Int64",
+    "Decimal",
+    "Double",
+    "Guid",
+    "DateTime",
+    "DateTimeOffset",
+    "Stream",
+]);
+/**
+ * Is this type an ASP.NET controller whose actions return bodies? Read from
+ * its own declaration only — `[ApiController]`, or a `Controller`/
+ * `ControllerBase` base. `aspnetcore.ts` additionally walks the base chain to
+ * admit a controller whose evidence is on an in-repo base class; this reader
+ * deliberately does not, because an unresolved base there produces a disclosed
+ * refusal while here it would produce a node type, and rule 2 prefers the
+ * narrower claim. Measured consequence: a jellyfin-style
+ * `XController : BaseJellyfinApiController` yields no DTO, a disclosed gap.
+ */
+function declaresBodies(type) {
+    if (type.attributes.includes("ApiController"))
+        return true;
+    return type.baseList.some((base) => base === "Controller" || base === "ControllerBase");
+}
+/** A simple type name this reader is willing to carry, or `undefined`. */
+function shapeName(name) {
+    if (name === undefined || name === null || name === "")
+        return undefined;
+    const bare = name.replace(/\?$/, "");
+    return NOT_A_SHAPE.has(bare) ? undefined : bare;
+}
+/**
+ * Every type an ASP.NET action declares as a request or response body, across
+ * the whole batch. Keyed by the same `path.join(".")` identity the caller's
+ * own type map uses.
+ *
+ * Resolution is by simple name against the declared types — the reach this
+ * adapter has. A name declared twice is refused rather than ranked.
+ */
+export function readTransportShapes(files) {
+    /** Simple name -> key, or `null` once ambiguous. */
+    const declared = new Map();
+    const fieldsOf = new Map();
+    for (const file of files) {
+        for (const type of file.types) {
+            const key = qualify(file.namespace, type.path);
+            fieldsOf.set(key, [...type.members.keys()].sort());
+            declared.set(type.name, declared.has(type.name) ? null : key);
+        }
+    }
+    const roles = new Map();
+    const record = (simple, role) => {
+        if (simple === undefined)
+            return;
+        const key = declared.get(simple);
+        if (key === undefined || key === null)
+            return;
+        const existing = roles.get(key);
+        if (existing === undefined)
+            roles.set(key, new Set([role]));
+        else
+            existing.add(role);
+    };
+    for (const file of files) {
+        for (const type of file.types) {
+            if (!declaresBodies(type))
+                continue;
+            for (const action of file.funcs) {
+                // Actions of THIS type only: `ownerPath` is the declaring type's
+                // nesting path, so comparing it to the type's own path keeps a second
+                // controller in the same file from lending its actions to this one.
+                if (action.ownerPath.join(".") !== type.path.join("."))
+                    continue;
+                if (!action.attributes.some((each) => VERB_ATTRIBUTES.has(each)))
+                    continue;
+                record(shapeName(action.returns), "response");
+                for (const [name, attributes] of action.scope.parameterAttributes) {
+                    if (!attributes.includes(BODY_PARAMETER))
+                        continue;
+                    record(shapeName(action.scope.locals.get(name)), "request");
+                }
+            }
+        }
+    }
+    const shapes = new Map();
+    for (const [key, directions] of roles) {
+        shapes.set(key, { fields: fieldsOf.get(key) ?? [], roles: [...directions].sort() });
+    }
+    return shapes;
+}
+//# sourceMappingURL=dto.js.map

package/dist/dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto.js","sourceRoot":"","sources":["../src/dto.ts"],"names":[],"mappings":"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"}

package/dist/extract.d.ts

@@ -64,5 +64,32 @@ export interface Extraction {
     readonly edges: readonly IREdge[];
     readonly unresolved: readonly UnresolvedRef[];
 }
+/**
+ * The fallback graph when `extract()` throws mid-run, per
+ * `DEC-NEXT-degraded-graph-shape-for-adapters-without-one.md`.
+ *
+ * `FILE`, not `MODULE`: a C# module's identity here is
+ * `assembly::namespace::stem`, and both the assembly (`.csproj` resolution,
+ * `projects.ts`) and the namespace (`namespace Foo.Bar;`, a declaration
+ * *inside* the file) are exactly the machinery a mid-extraction throw means
+ * just failed or cannot be trusted to have finished. Unlike Go's import path
+ * or Rust's crate/module path — both resolved from the file's own location
+ * plus a manifest, never from the file's parsed content — nothing about a C#
+ * file's identity is recoverable without a successful parse. `FILE` (via the
+ * shared `@descryy/adapter-common#fileNode` helper) is the fact that
+ * survives: the file exists, on disk, at this path, and that is all this
+ * function claims.
+ *
+ * One disclosure row, not one per file — the fact is about the run. Anchored
+ * to the first file's `FILE` node because the ledger requires a `fromNodeId`
+ * and `FILE` is the only node type this path emits.
+ */
+export declare function degradedGraph(input: {
+    readonly repo: string;
+    readonly workspace: string | undefined;
+    readonly producedBy: string;
+    readonly files: readonly string[];
+    readonly cause: string;
+}): Extraction;
 export declare function extract(input: ExtractInput): Extraction;
 //# sourceMappingURL=extract.d.ts.map

package/dist/extract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../src/extract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,MAAM,EAAwD,MAAM,YAAY,CAAC;AAC/F,OAAO,EAAyB,KAAK,QAAQ,EAAgB,MAAM,aAAa,CAAC;AAGjF,OAAO,EAAuC,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAI7F,eAAO,MAAM,QAAQ,WAAW,CAAC;AA+CjC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;;;;;OAQG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IAC/D;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;CAC/C;AAgCD,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CA6jCvD"}
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../src/extract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAIrB,OAAO,KAAK,EAAE,MAAM,EAAwD,MAAM,YAAY,CAAC;AAC/F,OAAO,EAAyB,KAAK,QAAQ,EAAgB,MAAM,aAAa,CAAC;AAKjF,OAAO,EAAuC,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAI7F,eAAO,MAAM,QAAQ,WAAW,CAAC;AAmDjC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;;;;;OAQG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IAC/D;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,GAAG,UAAU,CA0Bb;AAiCD,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAwtCvD"}

package/dist/extract.js

@@ -22,7 +22,10 @@
  * no edge. Extension methods are the same call for the same reason.
  */
 import { edgeId, endpointQsp, nodeId, normaliseEndpointPath, symbolQsp, testCaseQsp, } from "@descryy/ir";
+import { fileNode } from "@descryy/adapter-common";
 import { efModels, isGenerated } from "./efcore.js";
+import { readTransportShapes, SCHEMA as DTO_SCHEMA } from "./dto.js";
+import { hasJsonShapeEvidence } from "./json.js";
 import { decidedShape, SHAPE_LEVEL } from "./shape-reach.js";
 import { aspNetRoutes } from "./aspnetcore.js";
 import { resolveNullable, nullableDirectives } from "./nullability.js";
@@ -52,9 +55,12 @@ const REASONS = {
     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.",
-    handlerUnresolved: "this route's handler could not be resolved to a FUNCTION node: a minimal-API registration " +
-        "reads only its path argument textually and does not capture the handler expression, or an " +
-        "attribute-routed handler's declaring type left the analysed set.",
+    belowLevel: "resolved to a declaration, but this run was capped below the level that evidence earns. " +
+        "Not an analysis gap and not a scope boundary — a limit the caller asked for.",
+    handlerUnresolved: "this route's handler could not be resolved to a FUNCTION node: a minimal-API registration's " +
+        "second argument is an inline lambda (no name to resolve), names a delegate this run could " +
+        "not join to a declared method, or an attribute-routed handler's declaring type left the " +
+        "analysed set.",
 };
 const INHERITANCE_HOPS = 12;
 const PENDING_PASSES = 3;
@@ -64,6 +70,49 @@ const PENDING_PASSES = 3;
  * as an annotation — C# has no naming convention for tests the way XCTest does.
  */
 const TEST_ATTRIBUTES = new Set(["Fact", "Theory", "Test", "TestCase", "TestMethod", "DataTestMethod"]);
+/**
+ * The fallback graph when `extract()` throws mid-run, per
+ * `DEC-NEXT-degraded-graph-shape-for-adapters-without-one.md`.
+ *
+ * `FILE`, not `MODULE`: a C# module's identity here is
+ * `assembly::namespace::stem`, and both the assembly (`.csproj` resolution,
+ * `projects.ts`) and the namespace (`namespace Foo.Bar;`, a declaration
+ * *inside* the file) are exactly the machinery a mid-extraction throw means
+ * just failed or cannot be trusted to have finished. Unlike Go's import path
+ * or Rust's crate/module path — both resolved from the file's own location
+ * plus a manifest, never from the file's parsed content — nothing about a C#
+ * file's identity is recoverable without a successful parse. `FILE` (via the
+ * shared `@descryy/adapter-common#fileNode` helper) is the fact that
+ * survives: the file exists, on disk, at this path, and that is all this
+ * function claims.
+ *
+ * One disclosure row, not one per file — the fact is about the run. Anchored
+ * to the first file's `FILE` node because the ledger requires a `fromNodeId`
+ * and `FILE` is the only node type this path emits.
+ */
+export function degradedGraph(input) {
+    const scope = { repo: input.repo, workspace: input.workspace };
+    const nodes = input.files.map((file) => fileNode(scope, 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)} C# file(s). ${input.cause}. ` +
+                    "Files are listed because their existence and path are facts about the filesystem; 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 };
+}
 function qualify(namespace, path) {
     const joined = path.join(".");
     return namespace === "" ? joined : `${namespace}.${joined}`;
@@ -117,6 +166,9 @@ export function extract(input) {
      * `ViewComponent` carried the entity's columns.
      */
     const modelsByName = new Map(orm.models.map((model) => [model.fqn, model]));
+    // Transport shapes an ASP.NET ROUTE declares — never a type this reader
+    // guessed at from its name (DEC-043). Own file, `dto.ts`.
+    const shapesByType = readTransportShapes(input.files);
     const push = (edge, level) => {
         if (level > input.reached)
             return false;
@@ -162,6 +214,8 @@ export function extract(input) {
     // Sorted: DEC-083's "lexicographically first" is only reproducible if the
     // input is ordered, not left to filesystem enumeration order.
     const units = [...input.files].sort((a, b) => a.file.localeCompare(b.file));
+    /** Path -> the `CsFile` declared there, for `responseShapeEvidence`'s per-part provenance lookup. */
+    const fileByPath = new Map(units.map((unit) => [unit.file, unit]));
     const keyOf = (unit, fqn) => `${unit.assembly}::${fqn}`;
     for (const unit of units) {
         const stem = unit.file.slice(unit.file.lastIndexOf("/") + 1).replace(/\.cs$/i, "");
@@ -204,7 +258,16 @@ export function extract(input) {
             }
             // 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";
+            // An EF Core entity outranks a declared transport shape where both
+            // somehow apply: a wrong `MODEL` is a claim about a database and a wrong
+            // `DTO` a claim about a wire format, so the narrower evidence wins — the
+            // same tie-break, for the same reason, as adapter-python's and
+            // adapter-java's.
+            const kind = modelsByName.has(fqn)
+                ? "MODEL"
+                : shapesByType.has(fqn)
+                    ? "DTO"
+                    : "CLASS";
             const declared = {
                 kind,
                 id: nodeId(scope, kind, symbolQsp(holder, [fqn]), LANGUAGE),
@@ -232,13 +295,26 @@ export function extract(input) {
                 declared.members.set(member, { type: written });
         }
         const model = declared.kind === "MODEL" ? modelsByName.get(declared.fqn) : undefined;
+        const shape = declared.kind === "DTO" ? shapesByType.get(declared.fqn) : undefined;
         /**
          * The level this node's strongest fact carries. A `MODEL` bundles two
          * different claims — *this type is persisted* (a `DbSet<T>` or an
          * `IEntityTypeConfiguration<T>`, read at R0/R1) and *this is its mapped
          * shape* — and only the second is R3-grade, so the shape's own level is
-         * also stated in `attrs.shapeResolution` (DEC-058's carrier, which
-         * `descry-core`'s contract engine already reads).
+         * also stated in `attrs.shapeResolution` (DEC-058's carrier).
+         *
+         * **Node-scoped, and deliberately unrelated to the `USES_API`-edge
+         * `shapeResolution` this file also now writes** (see
+         * `responseShapeEvidence` above,
+         * `DEC-NEXT-dto-shape-evidence-for-api-contracts`). This one is the EF
+         * Core-mapped, PERSISTED database shape — `descry-core`'s contract engine
+         * (`engine.ts:286`) reads only the edge-level attribute for API
+         * wire-shape comparison and never reads a node-level `shapeResolution` at
+         * all, on a `MODEL` or otherwise. A type can be both — an entity that is
+         * also serialized straight to the wire — but the two facts rest on
+         * different attributes (EF Core's vs. JSON serialization's) and are
+         * asserted independently; this one is not the mechanism the API-shape
+         * ruling built.
          *
          * `decidedShape` and not `columns.length > 0`: a model whose every column
          * came back `unresolved` has had no shape read (DEC-180 §2 — unknown is
@@ -264,6 +340,18 @@ export function extract(input) {
                 // 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 } : {}),
+                ...(shape === undefined
+                    ? {}
+                    : {
+                        // The declaration this node rests on, named the way a `MODEL`
+                        // names its ORM. NAMES only — no `fieldDetail`, no
+                        // `shapeResolution`, no level raise: whether a plain class
+                        // body's member list is R3-grade evidence is a filed,
+                        // unanswered question and `shape-reach.ts` is untouched.
+                        schema: DTO_SCHEMA,
+                        declaredDirections: shape.roles,
+                        ...(shape.fields.length > 0 ? { fields: shape.fields } : {}),
+                    }),
                 ...(model === undefined
                     ? {}
                     : {
@@ -438,6 +526,48 @@ export function extract(input) {
             return { declared: claimants[0] };
         return { reason: REASONS.ambiguousName };
     }
+    /**
+     * `DEC-NEXT-dto-shape-evidence-for-api-contracts`'s ruling, applied at the
+     * one place a C# `USES_API` edge states a response type: a call's sole
+     * generic type argument (`GetFromJsonAsync<OrderResponse>(url)`, read by
+     * `genericArgumentOf` in `parse.ts`). Mirrors `adapter-java`'s
+     * `responseShapeEvidence` and `adapter-python`'s Pydantic gate — resolve
+     * the written name through the SAME scope rules every other name in this
+     * adapter goes through, then require real `System.Text.Json`/
+     * `Newtonsoft.Json` evidence before claiming R3, never the type argument
+     * alone.
+     *
+     * Gated on `input.reached >= 3` INSIDE the returned attrs, not by an early
+     * return one level up — a guard placed above this function would be green
+     * at R3 and silently wrong at R2, the monotonic sweep's own failure mode.
+     *
+     * A `MODEL` is excluded even when JSON-annotated: that is an EF Core
+     * persistence claim (see the comment beside `attrs.shapeResolution` at the
+     * `MODEL` node above), and DEC-NEXT scopes this ruling to *wire* shape
+     * evidence, a different fact resting on different attributes.
+     */
+    function responseShapeEvidence(unit, written) {
+        if (input.reached < 3 || written === undefined)
+            return {};
+        const resolved = resolveType(written, unit);
+        if (!("declared" in resolved))
+            return {};
+        const { declared } = resolved;
+        if (declared.kind !== "DTO")
+            return {}; // a MODEL: persisted shape, not wire shape, or a plain CLASS
+        // `parts[i]` was declared in `files[i]` — each file contributes at most
+        // one part for a given type (one `unit.types` entry per declaration), so
+        // the two arrays grow in lockstep. A part's OWN file gates its OWN
+        // provenance: a `using` in one file of a `partial` type does not make an
+        // attribute in a different file of it verified.
+        const evidenced = declared.parts.some((part, index) => {
+            const partFile = fileByPath.get(declared.files[index] ?? declared.unit.file) ?? declared.unit;
+            return hasJsonShapeEvidence(partFile, part);
+        });
+        if (!evidenced)
+            return {};
+        return { responseType: declared.id, shapeResolution: 3 };
+    }
     /** Every type in a declaration's supertype chain, across all its parts. */
     function* ancestry(start) {
         const queue = [start];
@@ -766,7 +896,9 @@ export function extract(input) {
                     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) {
+                    clientCallSites.push({ ...call, ...responseShapeEvidence(unit, call.responseTypeWritten) });
+                }
                 for (const call of read.calls) {
                     if (!functionClientBase.has(call.fromId))
                         functionClientBase.set(call.fromId, call.clientBase);
@@ -791,14 +923,32 @@ export function extract(input) {
                         });
                 }
             }
+            /**
+             * Mapped-column reads, grouped by the entity they land on. Edge
+             * identity is `(from, to, type)`, so a method reading three columns of
+             * one entity is **one** edge naming three columns, not three edges — a
+             * singular `field` attribute would make the second unrepresentable
+             * (DEC-046). Sorted on the way out so the attribute is a property of
+             * the source and not of statement order.
+             */
+            const columnReads = new Map();
             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":
+                    case "type": {
+                        const read = mappedColumnRead(ref, fn.scope, unit, host);
+                        if (read !== undefined) {
+                            const columns = columnReads.get(read.to);
+                            if (columns === undefined)
+                                columnReads.set(read.to, new Set([read.column]));
+                            else
+                                columns.add(read.column);
+                        }
                         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);
@@ -810,8 +960,54 @@ export function extract(input) {
                         break;
                 }
             }
+            for (const [to, columns] of columnReads) {
+                if (push({ from: declared.id, to, type: "READS", attrs: { fields: [...columns].sort() } }, 2))
+                    continue;
+                ledger(declared.id, "READS", [...columns].sort().join(", "), unit, fn.startLine, REASONS.belowLevel);
+            }
         }
     }
+    /**
+     * `FUNCTION --READS--> MODEL` for `order.TotalAmount` — golden 07.
+     *
+     * C# needs no accessor convention the way Java does: an EF Core entity's
+     * columns **are** its properties, so the read is written directly and the
+     * only question is whether the receiver and the member are both known.
+     * Three written things have to agree, and no name decides any of them:
+     *
+     *   1. the access is a **read** — `parse.ts` withholds `ref.member` for an
+     *      invocation's callee and for an assignment's left-hand side, which
+     *      are the same tree shape and are, respectively, a method and a write;
+     *   2. the receiver's type is written down and resolves, through the same
+     *      `ownerOfReceiver` every `CALLS` edge here goes through; and
+     *   3. the resolved type was admitted as a `MODEL` by `efcore.ts`, and the
+     *      member is one of the **columns that mapping declares** — not merely
+     *      a property, so `[NotMapped]` and a computed property are refused.
+     *
+     * Level 2: the edge names a member. It compares no shape and proves none,
+     * and the cap makes a name-level fact R2 — the column's shape is already on
+     * the `MODEL` node at R3, carrying its own `shapeResolution`.
+     */
+    function mappedColumnRead(ref, scope_, unit, host) {
+        if (ref.speculative !== true || ref.member === undefined)
+            return undefined;
+        // `this.X` / `base.X` reach the enclosing type, not a receiver whose type
+        // the site wrote down; an entity reading its own column is not the fact
+        // golden 07 is about and `push` would drop the self-edge anyway.
+        if (ref.name === "this" || ref.name === "base")
+            return undefined;
+        const owner = ownerOfReceiver(ref.name, scope_, unit, host);
+        if (!("declared" in owner))
+            return undefined;
+        if (owner.declared.kind !== "MODEL")
+            return undefined;
+        const model = modelsByName.get(owner.declared.fqn);
+        if (model === undefined)
+            return undefined;
+        if (!model.columns.some((column) => column.name === ref.member))
+            return undefined;
+        return { to: owner.declared.id, column: ref.member };
+    }
     /**
      * DEC-084 in one function: base-list position is a language guarantee, not
      * a convention, so only the first entry of a class base list is ever
@@ -1047,7 +1243,14 @@ export function extract(input) {
                 // (traced base, DEC-097) or `none` (no traced mechanism, literal
                 // path stands alone). See `client-base.ts` for why `unresolved` is
                 // never produced by this build.
-                attrs: { callerKind: call.callerKind, via: call.method, clientBase: call.clientBase },
+                attrs: {
+                    callerKind: call.callerKind,
+                    via: call.method,
+                    clientBase: call.clientBase,
+                    ...(call.responseType === undefined
+                        ? {}
+                        : { responseType: call.responseType, shapeResolution: call.shapeResolution }),
+                },
             }, 2);
         }
         nodes.push(...routeNodes.values(), ...endpointNodes.values());