@descryy/adapter-csharp 0.1.0

package/dist/client.js

@@ -0,0 +1,387 @@
+/**
+ * D-FIX-3's C# half: a call through a known HTTP client is disclosed, never
+ * silent — even though this adapter extracts no `USES_API` edges in C# at
+ * all yet.
+ *
+ * ## Why disclosure without extraction is the right first producer here
+ *
+ * Java's `client.ts` extracts real edges for Spring's clients and files a
+ * ledger row for the shapes it cannot read. C# has no extraction path at
+ * all — `capabilities()` already declares no `USES_API` for this adapter
+ * (PROGRESS.md), so *every* call through a known client is unclaimed today.
+ * Building the extractor itself (reading `GetAsync("/orders/{id}")`'s literal
+ * path, the way `bench/client-call-census.mjs`'s C# census shows is
+ * structurally the same shape as Spring's `RestTemplate` — the URL is the
+ * call's own first argument, not a separately built request object) is a
+ * **separate, larger row**: it needs the DEC-129 counting-first admission
+ * this project requires before an extractor ships, a golden fixture change,
+ * and a capability declaration tested against pattern 08 the way DEC-195
+ * records for Java. That is not built here.
+ *
+ * What *is* in scope, and small: recognise the receiver's declared type and
+ * turn "nothing" into a disclosed refusal, so `0 USES_API edges` stops being
+ * indistinguishable from "no HTTP calls in this codebase" — the exact
+ * distinction DEC-113's ledger exists to carry, and the reason a `cf-worker`
+ * zero and a `sherpa-frontend` zero are different facts.
+ *
+ * ## The bounded population, measured before it was picked
+ *
+ * `bench/client-call-census.mjs csharp` names `HttpClient`, `IHttpClientFactory`,
+ * `HttpRequestMessage` and `RestClient` as candidates. Measured directly against
+ * this row: `RestClient` (RestSharp's type) has **zero** occurrences across all
+ * six C# reference corpora (`jellyfin`, `eShop`, `eShopOnWeb`, `Ocelot`,
+ * `CleanArchitecture`, `Dapper`) — counted, not assumed, the same way DEC-129
+ * counted before admitting a corpus. `IHttpClientFactory` produces an
+ * `HttpClient` from `CreateClient()`; the client census's 61 relative-path call
+ * sites are all through `HttpClient` variables and fields once the factory call
+ * has already returned. So the known-type set here is **just `HttpClient`** —
+ * narrower than the census's candidate list, on a measurement rather than a
+ * guess, and it can widen the day a corpus exercises `RestClient` for real.
+ *
+ * `HttpRequestMessage` is not a receiver in any of the census's call sites — it
+ * is the *argument* to `SendAsync`, never the thing a verb method is called on
+ * — so it does not belong in a receiver-type set at all; including it would
+ * have been the coarser-than-node-key mistake DEC-165/187 already paid for once.
+ *
+ * ## Origin check, added after DEC-260
+ *
+ * The first pass of this file filed every candidate as "no extractor," with no
+ * distinction between a call whose literal path stays inside this repository
+ * and one that names a different origin outright — a divergence from Java's
+ * `client.ts`, which has always told the two apart. DEC-260 §3 names the
+ * consequence directly: two adapters disagreeing on the same refusal shape
+ * corrupts `refusalClass` (DEC-242) the moment a consumer trusts it, because
+ * C# would systematically over-report `capability-gap` against Java's
+ * classifier on the same underlying population.
+ *
+ * **Not Java's exact predicate, on purpose — measured, not assumed.** A first
+ * attempt reused Java's "does not start with `/`" rule verbatim and ran it
+ * against the real admitted corpora before calling the row done, per this
+ * project's own discipline. It misfired: `jellyfin` and `eShopOnWeb` both pass
+ * a **bare relative path with no leading slash** (`"Users/New"`) to `HttpClient`
+ * calls resolved against `HttpClient.BaseAddress` at run time — a shape Java's
+ * own population never contains, so Java's rule was never tested against it.
+ * Every such call site found is an integration test through
+ * `_factory.CreateClient()`, ASP.NET's in-process test client pointed at the
+ * application under test — a same-repository call this reader was about to
+ * mislabel as "another origin." See {@link namesAnotherOrigin}'s own comment
+ * for the corrected, narrower rule. This origin check was later carried back
+ * into `adapter-java`'s own `relativePath` rule, which carried the identical
+ * latent defect (`adapter-java` `1bfd2ae`) — the two adapters now agree on
+ * this shape by construction, not by two independently-tuned rules.
+ *
+ * ## Extraction, built on the shape the origin check already separated out
+ *
+ * `DEC-241` §4 named this row: `HttpClient`'s verb methods take the path as
+ * their **own first argument** — `GetAsync("/orders/{id}")`, never a
+ * separately built request object the way `OkHttpClient`/`java.net.http.HttpClient`
+ * require — the same structurally-straightforward shape Java's `RestTemplate`
+ * already extracts from. `clientCalls` below mints a real `USES_API` edge for
+ * every call whose receiver is a known client type, whose method names a
+ * literal verb, and whose path is a repository-relative literal
+ * (`relativePath`, unchanged from the origin check's own reasoning) — and
+ * files a ledger row, never silently drops the call, for every other shape:
+ * an unrecognised verb (`SendAsync`, which takes a pre-built
+ * `HttpRequestMessage` — verb and path both live inside an object this reader
+ * does not open), a non-literal path, an origin outside this repository, or a
+ * bare relative path this reader genuinely cannot place (the same
+ * `BaseAddress`-resolved shape the origin check exists to disclose rather
+ * than guess).
+ */
+import { endpointQsp, nodeId } from "@descryy/ir";
+const CAPABILITY_GAP = { blockedBy: null, refusalClass: "capability-gap" };
+const VARIES_PER_CALL = { blockedBy: null, refusalClass: "varies-per-call" };
+/** `Environment.GetEnvironmentVariable("X")` and an `IConfiguration` indexer named `configuration`/`Configuration`. */
+const ENV_READ_PATTERNS = [
+    /^Environment\.GetEnvironmentVariable\(\s*"[^"]*"\s*\)$/,
+    /^\w*[Cc]onfiguration\w*\[\s*"[^"]*"\s*\]$/,
+];
+/** Same heuristic as every other adapter's — see `adapter-rust/src/client.ts`'s doc. */
+function argumentKindOf(text) {
+    if (text.endsWith(")") && text.includes("("))
+        return "call";
+    if (text.includes("+"))
+        return "concatenation";
+    if (/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(text))
+        return "field";
+    return "other";
+}
+/**
+ * Why the first argument of a client call could not be read as a literal
+ * path — mirrors `firstArgumentTextOf`'s own reach: a bare identifier, a
+ * known environment/configuration-read expression, or something this reader
+ * does not trace.
+ */
+function diagnoseArgument(text, parameterNames) {
+    if (text === undefined)
+        return CAPABILITY_GAP;
+    const trimmed = text.trim();
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed) && parameterNames.has(trimmed))
+        return VARIES_PER_CALL;
+    if (ENV_READ_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+        return { blockedBy: trimmed, refusalClass: "value-unknown" };
+    }
+    return { ...CAPABILITY_GAP, argumentKind: argumentKindOf(trimmed) };
+}
+/** Verb methods on `HttpClient`. Taken from `bench/client-call-census.mjs`'s `METHODS.csharp`. */
+const CLIENT_METHODS = new Set([
+    "GetAsync",
+    "PostAsync",
+    "PutAsync",
+    "DeleteAsync",
+    "PatchAsync",
+    "SendAsync",
+    "GetStringAsync",
+    "GetByteArrayAsync",
+    "GetStreamAsync",
+    "GetFromJsonAsync",
+    "PostAsJsonAsync",
+    "PutAsJsonAsync",
+    "DeleteFromJsonAsync",
+]);
+const KNOWN_CLIENT_TYPES = new Set(["HttpClient"]);
+/**
+ * The HTTP verb a method name implies.
+ *
+ * `SendAsync` takes a pre-built `HttpRequestMessage` — the verb (and the
+ * path) live inside that object, not in this call's own arguments — so it is
+ * absent here and refused rather than defaulted, the identical reasoning
+ * Java's `exchange`/`execute`/`uri` carry: a wrong verb mints an endpoint
+ * that joins the wrong route, or none, and root-cause traversal would follow
+ * it.
+ */
+const VERB = {
+    GetAsync: "GET",
+    GetStringAsync: "GET",
+    GetByteArrayAsync: "GET",
+    GetStreamAsync: "GET",
+    GetFromJsonAsync: "GET",
+    PostAsync: "POST",
+    PostAsJsonAsync: "POST",
+    PutAsync: "PUT",
+    PutAsJsonAsync: "PUT",
+    DeleteAsync: "DELETE",
+    DeleteFromJsonAsync: "DELETE",
+    PatchAsync: "PATCH",
+};
+/**
+ * A path this reader will claim: repository-relative, no scheme, no assembly.
+ * Unchanged from the origin check's own reasoning — a leading `/` and nothing
+ * ambiguous about it, query string dropped because `SERVES_API` never mints
+ * one and keeping it would guarantee the join fails.
+ */
+function relativePath(value) {
+    if (!value.startsWith("/"))
+        return undefined;
+    if (value.startsWith("//"))
+        return undefined;
+    const cut = value.indexOf("?");
+    return cut === -1 ? value : value.slice(0, cut);
+}
+/**
+ * A literal argument this reader can say, with no ambiguity, names a
+ * *different* origin — an explicit scheme (`http://...`) or a protocol-relative
+ * URL (`//host/...`). Not Java's `relativePath` predicate, and deliberately
+ * not the same rule even though the two must agree on `refusalClass` (DEC-242)
+ * for the shapes they both actually see.
+ *
+ * Java's population (measured, DEC-260 §1) is `RestTemplate`/`TestRestTemplate`
+ * calls, which are either a leading-`/` repository-relative path or a fully
+ * qualified URL — nothing in between, so "does not start with `/`" was a safe
+ * proxy for "names another origin" *there*. C#'s real corpora are not the same
+ * population: `HttpClient` calls routinely pass a **bare relative path with no
+ * leading slash** (`"Users/New"`, `"SyncPlay/List"`) resolved against
+ * `HttpClient.BaseAddress` at run time — measured directly against jellyfin and
+ * eShopOnWeb, where every bare-relative call site found is an integration test
+ * driving `_factory.CreateClient()`, ASP.NET's own in-process test client
+ * whose `BaseAddress` is the application under test. Porting Java's predicate
+ * verbatim filed those as "another origin," which is not a fact this reader
+ * has — `BaseAddress` is a runtime value this reader does not see, so a bare
+ * relative path is genuinely undetermined, not a confirmed scope boundary.
+ * Rule 2 (precision over recall): when in doubt, the row stays in the
+ * capability-gap bucket rather than asserting a boundary this reader cannot
+ * back up. Only an unambiguous absolute form earns `out-of-scope`.
+ */
+function namesAnotherOrigin(value) {
+    return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value) || value.startsWith("//");
+}
+/**
+ * Every reference {@link clientCalls} will act on — an unbounded receiver
+ * type still makes it a true silence past this point, exactly as in Java. See
+ * `client.test.ts` for the reconciliation this makes checkable: every
+ * candidate whose type resolves lands in either `calls` or `refusals`, with
+ * nothing else.
+ */
+export function candidateClientRefs(refs) {
+    return refs.filter((ref) => ref.kind === "call" &&
+        CLIENT_METHODS.has(ref.name) &&
+        ref.receiver !== undefined &&
+        ref.receiver !== "this" &&
+        ref.receiver !== "base");
+}
+/** The literal path's own query string dropped — `SERVES_API` never mints one either. */
+function stripQuery(value) {
+    const cut = value.indexOf("?");
+    return cut === -1 ? value : value.slice(0, cut);
+}
+/**
+ * DEC-097's composition, with the separator neither half is guaranteed to
+ * supply. `path` (a resolved base's own prefix) never ends in `/`
+ * (`pathPrefixOf` in `client-base.ts` strips it) and a call's own literal
+ * may or may not start with one (`"orders/{id}"` vs `"/order/my-orders"`),
+ * so joining with a bare `+` silently drops the boundary exactly once: `"/api/v1"
+ * + "orders/{id}"` is `"/api/v1orders/{id}"`, one wrong path, not a missing
+ * slash `normaliseEndpointPath` can recover — it repairs a *doubled* slash,
+ * never a *missing* one. Always inserting `/` and letting `normaliseEndpointPath`'s
+ * own `/+` collapse handle the doubled case when the suffix already had one
+ * is the one join that is correct for both shapes.
+ */
+function joinBase(path, suffix) {
+    return `${path}/${suffix}`;
+}
+/**
+ * Read one method's calls for outbound HTTP.
+ *
+ * `typeOfReceiver` is supplied by `extract.ts`, which already has the scope
+ * tables (`fn.scope.locals`, the enclosing type's members) a second copy of
+ * here would drift from — the same division of labour as Java's `client.ts`.
+ *
+ * `clientBaseOfReceiver` is DEC-164's contract (`client-base.ts`'s own
+ * header): a per-call determination of what base, if any, this reader traced
+ * for the receiver. Called only for refs that already passed the known-client-
+ * type gate below, matching `typeOfReceiver`'s own division of labour.
+ */
+export function clientCalls(refs, fromId, typeOfReceiver, isTest, parameterNames, clientBaseOfReceiver) {
+    const calls = [];
+    const refusals = [];
+    for (const ref of candidateClientRefs(refs)) {
+        const receiverType = typeOfReceiver(ref);
+        if (receiverType === undefined || !KNOWN_CLIENT_TYPES.has(receiverType))
+            continue;
+        const refuse = (reason, diagnosis) => {
+            refusals.push({ fromId, raw: ref.raw, line: ref.line, reason, ...diagnosis });
+        };
+        const verb = VERB[ref.name];
+        if (verb === undefined) {
+            refuse(`an HTTP call through ${receiverType}, but \`${ref.name}\` takes a pre-built ` +
+                `HttpRequestMessage — the verb and the path both live inside that object, not in this ` +
+                `call's own arguments. Refused rather than defaulted to GET: a wrong verb mints an ` +
+                `endpoint that joins the wrong route, or none, and root-cause traversal would follow it.`, CAPABILITY_GAP);
+            continue;
+        }
+        if (ref.firstStringArgument === undefined) {
+            refuse(`an HTTP call through ${receiverType}, but its path is not a bare string literal — a ` +
+                `variable, a concatenation, or an interpolated string. A path assembled at run time is ` +
+                `not one this adapter can read, and an endpoint template invented here would join this ` +
+                `caller to a route it never calls.`, diagnoseArgument(ref.firstArgumentText, parameterNames));
+            continue;
+        }
+        // A literal argument unambiguously naming a different origin is a
+        // resolved fact, not a gap — DEC-113's out-of-scope population, the same
+        // one Java's client.ts already separates out for the shapes the two
+        // adapters' real corpora actually share (an absolute URL to another
+        // host). Checked before `clientBase` — an absolute request URI overrides
+        // `HttpClient.BaseAddress` regardless of what this reader traced for it.
+        if (namesAnotherOrigin(ref.firstStringArgument)) {
+            refuse(`an HTTP call through ${receiverType} to \`${ref.firstStringArgument}\`, which names ` +
+                `another origin rather than a path in this repository. A scope boundary, not a gap.`, { blockedBy: null, refusalClass: "out-of-scope" });
+            continue;
+        }
+        const base = clientBaseOfReceiver(ref);
+        if (base.state === "unresolved") {
+            // DEC-164: never guess. A base-setting mechanism was found and its
+            // value could not be read — zero witnesses for this branch in the six
+            // corpora this row measured (see `client-base.ts`'s own header), kept
+            // rather than deleted for the day one exists.
+            refusals.push({
+                fromId,
+                raw: ref.raw,
+                line: ref.line,
+                reason: `an HTTP call through ${receiverType}, whose base this reader traced to a DI ` +
+                    `registration but could not read as a literal: ${base.why}. DEC-164 refuses rather ` +
+                    `than guesses what an unreadable base composes to.`,
+                blockedBy: base.why,
+                refusalClass: "capability-gap",
+                clientBase: base,
+            });
+            continue;
+        }
+        if (base.state === "resolved") {
+            // DEC-097: only the origin was ever stripped from a resolved base: the
+            // call's own literal path — leading slash or not, the base is real and
+            // traced — composes directly against `path`.
+            calls.push({
+                fromId,
+                method: ref.name,
+                template: joinBase(base.path, stripQuery(ref.firstStringArgument)),
+                verb,
+                line: ref.line,
+                callerKind: isTest ? "test" : "production",
+                clientBase: base,
+            });
+            continue;
+        }
+        // `base.state === "none"` — no traced mechanism. Unchanged from every C#
+        // `USES_API` edge minted before this row: a leading-slash literal is
+        // trusted as complete on its own; a bare relative path is not, because
+        // this reader cannot tell whether an untraced `BaseAddress` elsewhere
+        // would give it a different meaning.
+        const template = relativePath(ref.firstStringArgument);
+        if (template === undefined) {
+            // A bare relative path with no leading slash and no traced base —
+            // structurally identical to Java's own `restTemplate.getForObject("orders/5",
+            // ...)` shape once `adapter-java` `1bfd2ae` closed the same latent
+            // defect there. It may resolve inside this repository, against a
+            // `BaseAddress` configured elsewhere this reader does not trace, or it
+            // may not; neither an edge nor an out-of-scope claim is honest here —
+            // rule 2, applied to a classification rather than an edge. Not a
+            // per-call value and not a named blocking expression either, so
+            // `capability-gap` rather than `varies-per-call`.
+            refusals.push({
+                fromId,
+                raw: ref.raw,
+                line: ref.line,
+                reason: `an HTTP call through ${receiverType} to \`${ref.firstStringArgument}\`, a relative path ` +
+                    `with no leading slash and no base this reader traced (DEC-164: \`clientBase.state === ` +
+                    `"none"\`). This reader cannot tell whether it resolves inside this repository — against ` +
+                    `a configured BaseAddress this call site does not state — or elsewhere, so neither an ` +
+                    `endpoint nor a scope boundary is claimed.`,
+                ...CAPABILITY_GAP,
+                clientBase: base,
+            });
+            continue;
+        }
+        calls.push({
+            fromId,
+            method: ref.name,
+            template,
+            verb,
+            line: ref.line,
+            callerKind: isTest ? "test" : "production",
+            clientBase: base,
+        });
+    }
+    return { calls, refusals };
+}
+/**
+ * The `API_ENDPOINT` a call joins to — minted identically to the route side.
+ *
+ * Shares `endpointQsp` with `extract.ts`'s `SERVES_API` block rather than
+ * recomputing the id, because the two must agree exactly and the failure when
+ * they do not is silent.
+ */
+export function endpointFor(scope, call, producedBy, normalise) {
+    const template = normalise(call.template);
+    return {
+        id: nodeId(scope, "API_ENDPOINT", endpointQsp(call.verb, call.template), null),
+        type: "API_ENDPOINT",
+        name: `${call.verb} ${template}`,
+        file: null,
+        range: null,
+        language: null,
+        producedBy,
+        resolution: 2,
+        attrs: { method: call.verb, pathTemplate: template },
+    };
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

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

package/dist/efcore.d.ts

@@ -0,0 +1,198 @@
+/**
+ * The ORM framework extractor for C# — Entity Framework Core.
+ *
+ * **A `MODEL` is a framework claim, and this file is where it is earned.**
+ * DEC-128 fixed the rules before extraction and **DEC-180 amended them after
+ * counting the corpus**, which is the part worth reading first: four of
+ * DEC-128's ORM rules were wrong, and every one of them was wrong in the same
+ * way — written from how EF Core is documented rather than from how the corpus
+ * is spelled. That is how a rule acquires zero witnesses.
+ *
+ * ## Admission — what the corpus actually contains
+ *
+ * | evidence | jellyfin | Ocelot | eShopOnWeb | CleanArchitecture |
+ * | --- | --- | --- | --- | --- |
+ * | `DbSet<` | 71 | 0 | 7 | 4 |
+ * | `IEntityTypeConfiguration<` | 26 | 0 | 7 | 2 |
+ * | `modelBuilder.Entity<` | **0** | **0** | **0** | **0** |
+ * | `[Table(` | **0** | **0** | **0** | **0** |
+ *
+ * So the admission grounds are:
+ *
+ * 1. **`DbSet<T>` on a `DbContext`.** Primary, and the only rule with witnesses
+ *    in three of four corpora.
+ * 2. **`IEntityTypeConfiguration<T>`.** This *replaces* DEC-128's
+ *    `modelBuilder.Entity<T>()` rule, which is the same fact written in a form
+ *    the corpus does not contain.
+ * 3. `[Table]` and `modelBuilder.Entity<T>()` are still **read** where they
+ *    appear, and are reported as **unwitnessed** — `0 of 0`, undefined, never as
+ *    passing. A rule with zero witnesses cannot be shown to work or to fail, and
+ *    its green is the green of a branch never taken.
+ *
+ * **Refused:** a type in a `Models` or `Entities` namespace with no mapping
+ * evidence — the `IFoo` guess this project forbids — and an owned type reached
+ * through `OwnsOne`, which shares its owner's table and has none of its own.
+ *
+ * ## Generated migrations are excluded, and the exclusion is counted
+ *
+ * DEC-128 read the table name from `ToTable(…)`. Measured: **1,338 of
+ * `jellyfin`'s 1,339 `ToTable` calls are inside `Migrations/`**, under a
+ * `// <auto-generated />` header, and 50 of `eShopOnWeb`'s 51. Those files are
+ * EF Core's serialised model from whenever someone last scaffolded a migration —
+ * an artefact of an operation, read as evidence about the world.
+ *
+ * An extractor reading them without excluding them is, to three significant
+ * figures, reading **only** generated code. So they are excluded — and the count
+ * is **reported**, because a silent exclusion of 1,338 of 1,339 is a correct
+ * decision that looks identical to a reader that never found them.
+ *
+ * ## No corpus can exercise the provenance rule
+ *
+ * `Dapper`, `NHibernate` and `linq2db` occur **zero** times across all four
+ * corpora. There is no C# repository here in which a rival ORM's types are
+ * present for these rules to correctly refuse — the identical hole the Java
+ * control set has. Stated before extraction rather than discovered after a green
+ * run, and every report carries the EF negative control as `0 of 0 — undefined`.
+ */
+import type { CsFile } from "./parse.ts";
+import { type NullableContext } from "./nullability.ts";
+/** Mirrors `JpaField` and `OrmField` so one shape crosses three languages. */
+export interface EfColumn {
+    readonly name: string;
+    /** `undefined` when nothing this reader can evaluate decides it. */
+    readonly nullable: boolean | undefined;
+    readonly nullableFrom: "fluent" | "annotation" | "value-type" | "nullable-value-type" | "reference-type" | "unresolved";
+}
+export interface EfModel {
+    readonly typeName: string;
+    /**
+     * Namespace-qualified, because the simple name is not what identifies a type.
+     *
+     * The consumer decides `MODEL` versus `CLASS` from this map, and it used to
+     * decide on `typeName`. While every simple-name collision was refused here
+     * that was invisible; the moment collisions began resolving, **every**
+     * declaration sharing a resolved name became a `MODEL` — `eShopOnWeb` emitted
+     * a second `Basket` for its Razor `ViewComponent` and a second `CatalogItem`
+     * for its Blazor DTO, each with the entity's columns attached to the wrong
+     * type.
+     *
+     * So a conservative refusal in this file was holding a defect in another one
+     * shut. Widening the refusal was correct and it was also the thing that fired
+     * the second bug — which is the argument for re-running precision after a
+     * widening rather than after a release.
+     */
+    readonly fqn: string;
+    readonly path: readonly string[];
+    /** `null` when only a convention this reader does not compute would give it. */
+    readonly table: string | null;
+    readonly admittedBy: "dbset" | "configuration" | "table-attribute" | "model-builder";
+    readonly columns: readonly EfColumn[];
+    readonly line: number;
+    readonly file: string;
+}
+/** What was read and what was refused, so a silent exclusion cannot pass for a finding. */
+export interface EfCensus {
+    readonly models: readonly EfModel[];
+    /** Files skipped as generated. See the file comment — reported, never silent. */
+    readonly generatedFilesSkipped: number;
+    /** `ToTable` calls inside those files, which is the 1,338-of-1,339 number. */
+    readonly generatedToTableSkipped: number;
+    /**
+     * Entities named by a mapping whose simple name is declared more than once.
+     *
+     * **Refused rather than guessed, and this is not hypothetical.** `eShopOnWeb`
+     * declares `Basket`, `CatalogBrand`, `CatalogItem` and `CatalogType` **twice**
+     * — once in `ApplicationCore/Entities` as the entity and once in
+     * `BlazorShared/Models` as the view DTO. A simple-name index with first-wins
+     * publishes the DTO's properties as the entity's columns: a wrong answer, and
+     * one that looks entirely healthy because a model *is* emitted with plausible
+     * columns.
+     *
+     * This is the mistake `adapter-java` records for `airbyte`, arriving in C#: a
+     * `Map<string, Declared>` keeps the last (or first) of several and resolves
+     * every reference to it. Two declarations is genuinely ambiguous and the
+     * `DbSet<T>` argument is rarely qualified, so there is nothing to break the tie
+     * with. Refused, and counted so the refusal is visible.
+     */
+    readonly ambiguousEntityNames: readonly string[];
+    /**
+     * Simple-name collisions, split by whether the namespace rule settled them.
+     *
+     * Reported because "eight refusals" and "eight refusals, all resolvable" are
+     * different disclosures and only the second is actionable.
+     */
+    readonly namespaceResolved: {
+        readonly resolved: number;
+        readonly unresolved: number;
+    };
+    /**
+     * Properties refused because their declared type is a class declared in this
+     * repository — a navigation, or an owned type. Not scalar columns.
+     *
+     * **The owned-type rule DEC-128 §2 states has no readable witness.**
+     * `eShopOnWeb`'s only `OwnsOne` calls are inside `Migrations/*.Designer.cs`,
+     * which are generated and correctly excluded, so `Address` and
+     * `CatalogItemOrdered` are never marked owned. Reading them anyway would have
+     * published `ShipToAddress` as one non-nullable column, when EF spreads an
+     * owned type across several columns of the owner's table under names this
+     * reader cannot compute.
+     *
+     * So the rule applied is broader and rests on the declaration rather than on
+     * the configuration: a property whose type is a repo-declared `class`,
+     * `record` or `interface` is not a scalar column. Enums and structs are, and
+     * stay.
+     */
+    readonly navigationsRefused: number;
+    /** Which rule *won* precedence for each admitted model. */
+    readonly admittedBy: Readonly<Record<EfModel["admittedBy"], number>>;
+    /**
+     * How many entities **each rule saw**, independent of which one won.
+     *
+     * Reported beside `admittedBy` because the two answer different questions and
+     * the first alone is misleading. `DbSet<T>` outranks `IEntityTypeConfiguration<T>`
+     * and names the same entities, so `admittedBy.configuration` is **0 on every
+     * corpus** — which reads as *the rule never fires* when it means *nothing
+     * needed it to*. A rule that fires and never wins is not an unwitnessed rule,
+     * and the distinction is exactly the one DEC-180 was written to protect.
+     */
+    readonly evidenceFor: Readonly<Record<EfModel["admittedBy"], number>>;
+}
+/**
+ * Does this file import EF Core at all? Provenance, not spelling.
+ *
+ * **A `global using` counts, and it is in force across the whole assembly.**
+ * That is not an edge case: `eShop`'s `OrderingContext` declares nine
+ * `DbSet<T>` and its only file-local `using` is `eShop.IntegrationEventLogEF` —
+ * `Microsoft.EntityFrameworkCore` arrives from `GlobalUsings.cs` three files
+ * away. Checking file-local usings alone read **zero** models from a corpus with
+ * nine, silently.
+ *
+ * `parse.ts` already says a `global using` is *"in force for every file in the
+ * project, not just this one"* and models the flag. This is the first consumer
+ * to act on it. Modern C# leans on it heavily — .NET 6 onward emits an implicit
+ * global-usings file per project — so a reader that ignores it fails on new
+ * codebases specifically.
+ *
+ * Scoped by **assembly**, because that is what a project is. A global using in
+ * one project does not reach another.
+ */
+export declare function importsEfCore(file: CsFile, globalsByAssembly?: ReadonlyMap<string, boolean>): boolean;
+/**
+ * Is this file generated?
+ *
+ * Two signals, and both are needed. The `// <auto-generated />` header is the
+ * language's own convention and is what EF Core's scaffolder emits. The
+ * `Migrations/` path catches the migration classes beside the snapshot, which
+ * carry no header of their own in every version.
+ */
+export declare function isGenerated(path: string, source: string): boolean;
+export interface EfInput {
+    readonly files: readonly {
+        readonly parsed: CsFile;
+        readonly source: string;
+    }[];
+    /** NRT context governing each file, resolved by the adapter. */
+    readonly contextOf: (file: string) => NullableContext;
+}
+export declare function efModels(input: EfInput): EfCensus;
+//# sourceMappingURL=efcore.d.ts.map

package/dist/efcore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"efcore.d.ts","sourceRoot":"","sources":["../src/efcore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAsB,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAE/E,8EAA8E;AAC9E,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,YAAY,EACjB,QAAQ,GACR,YAAY,GACZ,YAAY,GACZ,qBAAqB,GACrB,gBAAgB,GAChB,YAAY,CAAC;CAClB;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,GAAG,iBAAiB,GAAG,eAAe,CAAC;IACrF,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,2FAA2F;AAC3F,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;IACpC,iFAAiF;IACjF,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACvF;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,2DAA2D;IAC3D,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACrE;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;CACvE;AAgCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAGrG;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAKjE;AAoND,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAChF,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;CACvD;AAuDD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAqPjD"}