@descryy/adapter-csharp 0.5.0 → 0.5.2

package/dist/external.d.ts

@@ -0,0 +1,167 @@
+/**
+ * The dependency boundary, C# side — and the narrowest of the ten by a wide
+ * margin, which is the finding rather than a shortfall against it.
+ *
+ * ## The measurement this module does not contest
+ *
+ * `lane-extmint6` filed
+ * `DEC-NEXT-csharp-cannot-attribute-a-dependency-boundary-from-source` after
+ * measuring two facts that are structural and remain true:
+ *
+ * **1. A `using` binds a namespace, not a name.** `using System.IO;` does not
+ * say `Path` is `System.IO.Path`; it says `System.IO` is one of eleven places a
+ * bare name may be found. That is `adapter-java`'s wildcard import and
+ * `adapter-python`'s `from x import *`, and in C# it is not a minority idiom —
+ * it is the only idiom. Counted: `jellyfin` 13,435 plain usings, `eShopOnWeb`
+ * 884. Every one of them is refused here, and that refusal is the module's
+ * largest single behaviour.
+ *
+ * **2. A dotted C# name cannot be split into namespace and symbol by
+ * convention.** Go splits on the import path, Java and Kotlin at the first
+ * capitalised segment, PHP at the last `\`. C# namespaces and type names are
+ * both PascalCase, so `System.Text.Json.JsonSerializer` offers nothing that says
+ * where the namespace stops.
+ *
+ * ## What is attributable anyway, and the one thing the prior measurement did
+ * not use
+ *
+ * Two written forms name a symbol rather than a namespace, and both are read:
+ *
+ *   - **`using Alias = N.T;`** binds one name outright. The developer wrote the
+ *     name, the target, and (by using the alias in type or static-call position)
+ *     that the target is a type.
+ *   - **a name written out in full at the reference** — `System.Text.Json.
+ *     JsonSerializer.Serialize(x)`. Every segment is written by the developer at
+ *     the site.
+ *
+ * Fact 2 blocks both, and the way past it is not a convention but **another
+ * written binding**: a plain `using N;` is the language's own guarantee that `N`
+ * is a namespace. So the repository's plain usings — the very population this
+ * module refuses to resolve *names* with — are read instead as a **dictionary of
+ * strings the source states are namespaces**, and a dotted target is split at
+ * the longest prefix that appears in it. `System.Text.Json` is a namespace
+ * because some file in this repository wrote `using System.Text.Json;`, not
+ * because three segments looked like enough. A target whose prefix no file
+ * writes down is refused, not guessed.
+ *
+ * This reads no `.csproj` `<PackageReference>`, no `packages.lock.json`, no
+ * `~/.nuget`, no assembly. Two reasons, Go's two: most checkouts have nothing
+ * restored, and an identity taken from a restored graph would move the first
+ * time somebody ran `dotnet restore`.
+ *
+ * ## `using static` is read as a namespace fact and never as a name binding
+ *
+ * `using static N.T;` is the other form the task named, and it is **refused for
+ * edges on purpose.** Unlike Java's `import static a.b.C.m`, C#'s form names no
+ * member: it imports *every* static member of `T`, so an unqualified `m()` under
+ * it is a member of the enclosing type, or of an unread base type, or one of
+ * `T`'s — and the file writes down nothing that chooses. That is fact 1 again in
+ * a smaller population. What the directive does write down is that `N` is a
+ * namespace-or-type and `T` a type, so its prefix joins the namespace dictionary
+ * and nothing else.
+ *
+ * ## What this is worth, measured
+ *
+ * Counted over the C# reference subjects, and the honest headline is that the
+ * attributable population is tiny **and mostly in-repo**:
+ *
+ * | subject       | plain `using` | `using static` | alias `using` | of those, target OUTSIDE the repo |
+ * | ---           | ---           | ---            | ---           | --- |
+ * | `jellyfin`    | 13,435        | 9              | 125           | **11** |
+ * | `eShopOnWeb`  | 884           | 0              | 0             | **0** |
+ *
+ * `jellyfin`'s 125 aliases are overwhelmingly `Episode = MediaBrowser.
+ * Controller.Entities.TV.Episode` — a shortening of its own name, not a
+ * dependency. Eleven name something outside, over six distinct targets. So this
+ * module's yield on `jellyfin` is a two-digit number of edges against a graded
+ * population of 74,383 calls, and on `eShopOnWeb` it is zero. **That is the
+ * result, reported rather than improved by lowering the bar**, and it is what
+ * the prior lane predicted.
+ */
+/** What written form bound the name. */
+export type CsBinding = "alias-using" | "written-fully-qualified";
+export interface ExternalContext {
+    /**
+     * Alias -> target, for one file: its own `using X = N.T;` plus the assembly's
+     * `global using X = N.T;`. The one C# directive that binds a name.
+     */
+    readonly aliases: ReadonlyMap<string, string>;
+    /**
+     * Every string this repository's own source states is a namespace: the target
+     * of every plain `using N;`, and every prefix of one, plus the prefixes of
+     * `using static` targets. Repository-wide on purpose — a namespace is a
+     * property of the string, not of the file that wrote it down.
+     */
+    readonly writtenNamespaces: ReadonlySet<string>;
+    /** Namespaces this repository declares. A type under one is OURS whether or
+     *  not this run read it — calling unanalysed code of ours a dependency is the
+     *  error that never surfaces. */
+    readonly ownNamespaces: ReadonlySet<string>;
+    /** Fully-qualified names this run actually read. One of ours is not a
+     *  boundary. */
+    readonly analysed: (fqn: string) => boolean;
+}
+export interface ExternalAttribution {
+    /** The namespace **as the repository's own source writes it down** — this is
+     *  the identity. Never a NuGet package id, never an assembly, never a version:
+     *  a package-to-namespace mapping lives inside the assembly, and
+     *  `<PackageReference>` binds an id to no namespace at all. */
+    readonly moduleOrNamespace: string;
+    /** The type chain, then any member named on it. */
+    readonly symbolPath: readonly string[];
+    readonly binding: CsBinding;
+    /** Outside the .NET base class library, decided from the namespace alone
+     *  against `PLATFORM_BASIS`. Disclosure only, and outside the hash: a
+     *  namespace that moved between the two would otherwise change identity with
+     *  no line of source changing. */
+    readonly thirdParty: boolean;
+}
+/**
+ * Provenance of the platform-namespace list, carried on every attributed node.
+ * A property of the framework, frozen into this source — never read from
+ * whatever SDK a developer happens to have installed, which would make the
+ * answer depend on the machine.
+ *
+ * `Microsoft` is **not** taken whole, and that is the whole reason this constant
+ * is a list rather than two prefixes: `Microsoft.Extensions.*` and
+ * `Microsoft.AspNetCore.*` ship as NuGet packages, `Microsoft.Win32` and
+ * `Microsoft.CSharp` ship with the runtime. Taking the prefix either way would
+ * be a wrong disclosure on every node under it.
+ */
+export declare const PLATFORM_BASIS = "dotnet base class library: System.* roots, plus the runtime's own Microsoft.* namespaces";
+/** Is `name` the namespace `prefix`, or inside it? Whole segments only — a raw
+ *  `startsWith` would put `Acme.ServiceBus` inside `Acme.Service`, which is the
+ *  vendor-namespace hazard rule 2 prices above a missing edge. */
+export declare function isUnder(name: string, prefix: string): boolean;
+/** Generic arguments, nullable marks, array brackets and `global::` are not part
+ *  of a name's identity, and the type arguments inside them are separate
+ *  references the extractor already files on their own. */
+export declare function bareTypeName(written: string): string;
+/**
+ * A dotted name split into the namespace the repository states it is in and the
+ * symbol chain inside it, or `null` when no plain `using` in this repository
+ * writes a namespace that prefixes it.
+ *
+ * The **longest** written prefix wins, and it must be a proper prefix: a name
+ * that is itself a written namespace names no symbol and is refused.
+ */
+export declare function splitAtWrittenNamespace(fqn: string, writtenNamespaces: ReadonlySet<string>): {
+    namespace: string;
+    symbols: string[];
+} | null;
+/**
+ * The namespace and type behind a **type reference** that left the repository,
+ * or `null` when no binding the developer wrote settles it.
+ */
+export declare function attributeExternalType(written: string, context: ExternalContext): ExternalAttribution | null;
+/**
+ * The namespace, type and member behind a **call** that left the repository, or
+ * `null` when no binding the developer wrote settles it.
+ *
+ * `receiverWritten` is the receiver exactly as the source wrote it — an alias, or
+ * a dotted path written out in full. A local, a field, a property or a `var` is
+ * not a written type and `extract.ts` never reaches here with one, because it
+ * consults this module only where its own resolution already declined.
+ */
+export declare function attributeExternalCall(receiverWritten: string | undefined, method: string, context: ExternalContext): ExternalAttribution | null;
+//# sourceMappingURL=external.d.ts.map

package/dist/external.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../src/external.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AAEH,wCAAwC;AACxC,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,yBAAyB,CAAC;AAElE,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChD;;qCAEiC;IACjC,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C;oBACgB;IAChB,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CAC7C;AAED,MAAM,WAAW,mBAAmB;IAClC;;;mEAG+D;IAC/D,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,mDAAmD;IACnD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;sCAGkC;IAClC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,6FAA6F,CAAC;AA0BzH;;kEAEkE;AAClE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D;AAYD;;2DAE2D;AAC3D,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKpD;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,GACrC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAUjD;AA+ED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,GACvB,mBAAmB,GAAG,IAAI,CAI5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,GACvB,mBAAmB,GAAG,IAAI,CAK5B"}

package/dist/external.js

@@ -0,0 +1,262 @@
+/**
+ * The dependency boundary, C# side — and the narrowest of the ten by a wide
+ * margin, which is the finding rather than a shortfall against it.
+ *
+ * ## The measurement this module does not contest
+ *
+ * `lane-extmint6` filed
+ * `DEC-NEXT-csharp-cannot-attribute-a-dependency-boundary-from-source` after
+ * measuring two facts that are structural and remain true:
+ *
+ * **1. A `using` binds a namespace, not a name.** `using System.IO;` does not
+ * say `Path` is `System.IO.Path`; it says `System.IO` is one of eleven places a
+ * bare name may be found. That is `adapter-java`'s wildcard import and
+ * `adapter-python`'s `from x import *`, and in C# it is not a minority idiom —
+ * it is the only idiom. Counted: `jellyfin` 13,435 plain usings, `eShopOnWeb`
+ * 884. Every one of them is refused here, and that refusal is the module's
+ * largest single behaviour.
+ *
+ * **2. A dotted C# name cannot be split into namespace and symbol by
+ * convention.** Go splits on the import path, Java and Kotlin at the first
+ * capitalised segment, PHP at the last `\`. C# namespaces and type names are
+ * both PascalCase, so `System.Text.Json.JsonSerializer` offers nothing that says
+ * where the namespace stops.
+ *
+ * ## What is attributable anyway, and the one thing the prior measurement did
+ * not use
+ *
+ * Two written forms name a symbol rather than a namespace, and both are read:
+ *
+ *   - **`using Alias = N.T;`** binds one name outright. The developer wrote the
+ *     name, the target, and (by using the alias in type or static-call position)
+ *     that the target is a type.
+ *   - **a name written out in full at the reference** — `System.Text.Json.
+ *     JsonSerializer.Serialize(x)`. Every segment is written by the developer at
+ *     the site.
+ *
+ * Fact 2 blocks both, and the way past it is not a convention but **another
+ * written binding**: a plain `using N;` is the language's own guarantee that `N`
+ * is a namespace. So the repository's plain usings — the very population this
+ * module refuses to resolve *names* with — are read instead as a **dictionary of
+ * strings the source states are namespaces**, and a dotted target is split at
+ * the longest prefix that appears in it. `System.Text.Json` is a namespace
+ * because some file in this repository wrote `using System.Text.Json;`, not
+ * because three segments looked like enough. A target whose prefix no file
+ * writes down is refused, not guessed.
+ *
+ * This reads no `.csproj` `<PackageReference>`, no `packages.lock.json`, no
+ * `~/.nuget`, no assembly. Two reasons, Go's two: most checkouts have nothing
+ * restored, and an identity taken from a restored graph would move the first
+ * time somebody ran `dotnet restore`.
+ *
+ * ## `using static` is read as a namespace fact and never as a name binding
+ *
+ * `using static N.T;` is the other form the task named, and it is **refused for
+ * edges on purpose.** Unlike Java's `import static a.b.C.m`, C#'s form names no
+ * member: it imports *every* static member of `T`, so an unqualified `m()` under
+ * it is a member of the enclosing type, or of an unread base type, or one of
+ * `T`'s — and the file writes down nothing that chooses. That is fact 1 again in
+ * a smaller population. What the directive does write down is that `N` is a
+ * namespace-or-type and `T` a type, so its prefix joins the namespace dictionary
+ * and nothing else.
+ *
+ * ## What this is worth, measured
+ *
+ * Counted over the C# reference subjects, and the honest headline is that the
+ * attributable population is tiny **and mostly in-repo**:
+ *
+ * | subject       | plain `using` | `using static` | alias `using` | of those, target OUTSIDE the repo |
+ * | ---           | ---           | ---            | ---           | --- |
+ * | `jellyfin`    | 13,435        | 9              | 125           | **11** |
+ * | `eShopOnWeb`  | 884           | 0              | 0             | **0** |
+ *
+ * `jellyfin`'s 125 aliases are overwhelmingly `Episode = MediaBrowser.
+ * Controller.Entities.TV.Episode` — a shortening of its own name, not a
+ * dependency. Eleven name something outside, over six distinct targets. So this
+ * module's yield on `jellyfin` is a two-digit number of edges against a graded
+ * population of 74,383 calls, and on `eShopOnWeb` it is zero. **That is the
+ * result, reported rather than improved by lowering the bar**, and it is what
+ * the prior lane predicted.
+ */
+/**
+ * Provenance of the platform-namespace list, carried on every attributed node.
+ * A property of the framework, frozen into this source — never read from
+ * whatever SDK a developer happens to have installed, which would make the
+ * answer depend on the machine.
+ *
+ * `Microsoft` is **not** taken whole, and that is the whole reason this constant
+ * is a list rather than two prefixes: `Microsoft.Extensions.*` and
+ * `Microsoft.AspNetCore.*` ship as NuGet packages, `Microsoft.Win32` and
+ * `Microsoft.CSharp` ship with the runtime. Taking the prefix either way would
+ * be a wrong disclosure on every node under it.
+ */
+export const PLATFORM_BASIS = "dotnet base class library: System.* roots, plus the runtime's own Microsoft.* namespaces";
+/** Namespace roots the runtime owns outright. */
+const PLATFORM_ROOTS = ["System"];
+/** The `Microsoft` subnamespaces the runtime ships. Everything else under
+ *  `Microsoft` is a package. */
+const PLATFORM_MICROSOFT = new Set([
+    "Microsoft.Win32", "Microsoft.CSharp", "Microsoft.VisualBasic", "Microsoft.SafeHandles",
+]);
+/**
+ * Namespaces whose whole purpose is to make a call target dynamic.
+ *
+ * `System.Reflection`'s `MethodInfo.Invoke` and `System.Linq.Expressions`'
+ * compiled delegates are where a C# call graph deliberately stops being
+ * readable, and golden pattern 12 — the corpus's most important fixture —
+ * forbids a `CALLS` edge out of a method that dispatches through them *to any
+ * target at any resolution*. The edge would be true and it is still the one
+ * edge that pattern exists to forbid: it makes a traversal look as though it
+ * continued through a site where the graph cannot see the next hop. Java's
+ * `external.ts` declines `java.lang.reflect` and `java.lang.invoke` for exactly
+ * this reason (`DEC-NEXT-external-nodes-through-the-reflection-packages`).
+ */
+const DYNAMIC_DISPATCH_NAMESPACES = ["System.Reflection", "System.Linq.Expressions"];
+/** Is `name` the namespace `prefix`, or inside it? Whole segments only — a raw
+ *  `startsWith` would put `Acme.ServiceBus` inside `Acme.Service`, which is the
+ *  vendor-namespace hazard rule 2 prices above a missing edge. */
+export function isUnder(name, prefix) {
+    return name === prefix || name.startsWith(`${prefix}.`);
+}
+function isPlatform(namespace) {
+    for (const root of PLATFORM_ROOTS) {
+        if (isUnder(namespace, root))
+            return true;
+    }
+    for (const known of PLATFORM_MICROSOFT) {
+        if (isUnder(namespace, known))
+            return true;
+    }
+    return false;
+}
+/** Generic arguments, nullable marks, array brackets and `global::` are not part
+ *  of a name's identity, and the type arguments inside them are separate
+ *  references the extractor already files on their own. */
+export function bareTypeName(written) {
+    const stripped = written.trim().replace(/^global::/, "");
+    const cut = stripped.indexOf("<");
+    const head = (cut === -1 ? stripped : stripped.slice(0, cut)).trim();
+    return head.replace(/(\[[\s,]*\])+$/, "").replace(/\?+$/, "").trim();
+}
+/**
+ * A dotted name split into the namespace the repository states it is in and the
+ * symbol chain inside it, or `null` when no plain `using` in this repository
+ * writes a namespace that prefixes it.
+ *
+ * The **longest** written prefix wins, and it must be a proper prefix: a name
+ * that is itself a written namespace names no symbol and is refused.
+ */
+export function splitAtWrittenNamespace(fqn, writtenNamespaces) {
+    const parts = fqn.split(".");
+    if (parts.length < 2 || parts.some((part) => part === ""))
+        return null;
+    for (let cut = parts.length - 1; cut >= 1; cut -= 1) {
+        const prefix = parts.slice(0, cut).join(".");
+        if (writtenNamespaces.has(prefix)) {
+            return { namespace: prefix, symbols: parts.slice(cut) };
+        }
+    }
+    return null;
+}
+/** Ours, whether or not this run read it. */
+function isOurs(fqn, context) {
+    if (context.analysed(fqn))
+        return true;
+    for (const own of context.ownNamespaces) {
+        if (own !== "" && isUnder(fqn, own))
+            return true;
+    }
+    return false;
+}
+function attribute(fqn, binding, extra, context) {
+    if (isOurs(fqn, context))
+        return null;
+    // The whole written name is itself a namespace some file states is one. A
+    // namespace declares no members, so there is nothing here to point at.
+    if (context.writtenNamespaces.has(fqn))
+        return null;
+    const split = splitAtWrittenNamespace(fqn, context.writtenNamespaces);
+    if (split === null)
+        return null;
+    if (isOurs(split.namespace, context))
+        return null;
+    // The written namespace must be the type's IMMEDIATE parent, and this is an
+    // identity rule rather than a taste one. `Microsoft.AspNetCore.WebUtilities.
+    // QueryHelpers.AddQueryString` splits at `Microsoft.AspNetCore` when no file
+    // happens to write `using Microsoft.AspNetCore.WebUtilities;` and at the
+    // deeper namespace when one does — so the same symbol would carry two
+    // different node ids depending on a `using` in an unrelated file, and adding
+    // that line would silently move the node. Capping the split at one segment
+    // turns that churn into presence or absence, which is what rule 2 asks for: a
+    // missing edge is a disclosed gap, a moving identity destroys every link that
+    // ever pointed at it. The cost is real and disclosed — a nested type
+    // (`System.Text.Encoding.UTF8`, `Map.Entry`'s C# analogue) is refused.
+    if (split.symbols.length !== 1)
+        return null;
+    for (const dynamic of DYNAMIC_DISPATCH_NAMESPACES) {
+        if (isUnder(split.namespace, dynamic))
+            return null;
+    }
+    const symbolPath = [...split.symbols, ...extra];
+    if (symbolPath.some((part) => part === ""))
+        return null;
+    return {
+        moduleOrNamespace: split.namespace,
+        symbolPath,
+        binding,
+        thirdParty: !isPlatform(split.namespace),
+    };
+}
+/** The fully-qualified name a written type resolves to through the bindings this
+ *  file wrote, and which binding did it. `null` when none did. */
+function qualify(written, context) {
+    const name = bareTypeName(written);
+    if (name === "")
+        return null;
+    const separator = name.indexOf(".");
+    const head = separator === -1 ? name : name.slice(0, separator);
+    const aliased = context.aliases.get(head);
+    if (aliased !== undefined && aliased !== "") {
+        const rest = separator === -1 ? "" : name.slice(separator + 1);
+        const target = bareTypeName(aliased);
+        return { fqn: rest === "" ? target : `${target}.${rest}`, binding: "alias-using" };
+    }
+    // Written out in full at the reference. Every segment is the developer's, so
+    // it is as much a written binding as an alias is — and the namespace boundary
+    // inside it is decided by `splitAtWrittenNamespace`, from plain usings, never
+    // by how the segments are capitalised.
+    if (separator !== -1)
+        return { fqn: name, binding: "written-fully-qualified" };
+    // A bare name under a plain `using`. The largest population and the refusal
+    // this module exists to make: eleven candidate namespaces and nothing written
+    // that chooses between them.
+    return null;
+}
+/**
+ * The namespace and type behind a **type reference** that left the repository,
+ * or `null` when no binding the developer wrote settles it.
+ */
+export function attributeExternalType(written, context) {
+    const qualified = qualify(written, context);
+    if (qualified === null)
+        return null;
+    return attribute(qualified.fqn, qualified.binding, [], context);
+}
+/**
+ * The namespace, type and member behind a **call** that left the repository, or
+ * `null` when no binding the developer wrote settles it.
+ *
+ * `receiverWritten` is the receiver exactly as the source wrote it — an alias, or
+ * a dotted path written out in full. A local, a field, a property or a `var` is
+ * not a written type and `extract.ts` never reaches here with one, because it
+ * consults this module only where its own resolution already declined.
+ */
+export function attributeExternalCall(receiverWritten, method, context) {
+    if (receiverWritten === undefined || method === "")
+        return null;
+    const qualified = qualify(receiverWritten, context);
+    if (qualified === null)
+        return null;
+    return attribute(qualified.fqn, qualified.binding, [method], context);
+}
+//# sourceMappingURL=external.js.map

package/dist/external.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"external.js","sourceRoot":"","sources":["../src/external.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AA2CH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,0FAA0F,CAAC;AAEzH,iDAAiD;AACjD,MAAM,cAAc,GAAsB,CAAC,QAAQ,CAAC,CAAC;AAErD;gCACgC;AAChC,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAC;IACtD,iBAAiB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,uBAAuB;CACxF,CAAC,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,2BAA2B,GAAsB,CAAC,mBAAmB,EAAE,yBAAyB,CAAC,CAAC;AAExG;;kEAEkE;AAClE,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,MAAc;IAClD,OAAO,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,UAAU,CAAC,SAAiB;IACnC,KAAK,MAAM,IAAI,IAAI,cAAc,EAAE,CAAC;QAClC,IAAI,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;IAC5C,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,kBAAkB,EAAE,CAAC;QACvC,IAAI,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;IAC7C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;2DAE2D;AAC3D,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IACzD,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACrE,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AACvE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CACrC,GAAW,EACX,iBAAsC;IAEtC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;QAAE,OAAO,IAAI,CAAC;IACvE,KAAK,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QACpD,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7C,IAAI,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YAClC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1D,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,6CAA6C;AAC7C,SAAS,MAAM,CAAC,GAAW,EAAE,OAAwB;IACnD,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACvC,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;QACxC,IAAI,GAAG,KAAK,EAAE,IAAI,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC;IACnD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,SAAS,CAChB,GAAW,EACX,OAAkB,EAClB,KAAwB,EACxB,OAAwB;IAExB,IAAI,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IACtC,0EAA0E;IAC1E,uEAAuE;IACvE,IAAI,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACpD,MAAM,KAAK,GAAG,uBAAuB,CAAC,GAAG,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACtE,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAChC,IAAI,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IAClD,4EAA4E;IAC5E,6EAA6E;IAC7E,6EAA6E;IAC7E,yEAAyE;IACzE,sEAAsE;IACtE,6EAA6E;IAC7E,2EAA2E;IAC3E,8EAA8E;IAC9E,8EAA8E;IAC9E,qEAAqE;IACrE,uEAAuE;IACvE,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,KAAK,MAAM,OAAO,IAAI,2BAA2B,EAAE,CAAC;QAClD,IAAI,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC;YAAE,OAAO,IAAI,CAAC;IACrD,CAAC;IACD,MAAM,UAAU,GAAG,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,CAAC;IAChD,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;QAAE,OAAO,IAAI,CAAC;IACxD,OAAO;QACL,iBAAiB,EAAE,KAAK,CAAC,SAAS;QAClC,UAAU;QACV,OAAO;QACP,UAAU,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;KACzC,CAAC;AACJ,CAAC;AAED;kEACkE;AAClE,SAAS,OAAO,CACd,OAAe,EACf,OAAwB;IAExB,MAAM,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,IAAI,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAE7B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACpC,MAAM,IAAI,GAAG,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;IAChE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC1C,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;QAC5C,MAAM,IAAI,GAAG,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;QAC/D,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACrC,OAAO,EAAE,GAAG,EAAE,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;IACrF,CAAC;IAED,6EAA6E;IAC7E,8EAA8E;IAC9E,8EAA8E;IAC9E,uCAAuC;IACvC,IAAI,SAAS,KAAK,CAAC,CAAC;QAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,yBAAyB,EAAE,CAAC;IAE/E,4EAA4E;IAC5E,8EAA8E;IAC9E,6BAA6B;IAC7B,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAAe,EACf,OAAwB;IAExB,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC5C,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACpC,OAAO,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CACnC,eAAmC,EACnC,MAAc,EACd,OAAwB;IAExB,IAAI,eAAe,KAAK,SAAS,IAAI,MAAM,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAChE,MAAM,SAAS,GAAG,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;IACpD,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACpC,OAAO,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;AACxE,CAAC"}

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;AAIjF,OAAO,EAAuC,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAI7F,eAAO,MAAM,QAAQ,WAAW,CAAC;AAkDjC,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;AAiCD,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAupCvD"}
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../src/extract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAQL,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;AAW7F,eAAO,MAAM,QAAQ,WAAW,CAAC;AA+DjC,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,CA22CvD"}