@descryy/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Descry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/capabilities/index.d.ts

@@ -0,0 +1,3 @@
+export { auditRequirements, checkPreconditions } from "./preconditions.ts";
+export type { CapabilityRequirement, PreconditionVerdict, ProducerCapabilities, } from "./preconditions.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/capabilities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/capabilities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,YAAY,EACV,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}

package/dist/capabilities/index.js

@@ -0,0 +1,2 @@
+export { auditRequirements, checkPreconditions } from "./preconditions.js";
+//# sourceMappingURL=index.js.map

package/dist/capabilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/capabilities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/capabilities/preconditions.d.ts

@@ -0,0 +1,99 @@
+/**
+ * A check declares what it needs; the engine refuses to run it if no loaded
+ * producer can supply that. DEC-112's implementation.
+ *
+ * ## The defect this makes impossible
+ *
+ * Three static checks read their graph side with `nodesOfType("FILE")`. **No
+ * shipped adapter emits a `FILE` node** — all nine use `MODULE`. So the graph
+ * half of every one of them was dead on every real repository, and 48 tests and
+ * three precision gates stayed green throughout, because all four instruments
+ * minted the node type the check wanted.
+ *
+ * The fact was *already known*. `packages/core/src/tiers/ladder.ts` records it in
+ * a comment, written after the tier ladder required `FILE` and failed every
+ * adapter at Tier C. A comment is not reachable from the place the next person
+ * writes a check.
+ *
+ * **`capabilities()` has declared `nodeTypes` since the adapter contract was
+ * written** (`packages/ir/src/contracts.ts`). Nobody asked it. This module is
+ * the asking.
+ *
+ * ## Declared, not emitted — and the distinction is the whole design
+ *
+ * The precondition is checked against what loaded producers **declare**, never
+ * against what a particular run emitted. Those are different failures and only
+ * one of them is a bug:
+ *
+ * | situation | verdict | why |
+ * | --- | --- | --- |
+ * | no loaded producer *declares* the type | **refuse** | the check can never work here; running it produces an empty result indistinguishable from a clean repository |
+ * | a producer declares it, this run emitted none | **run** | a legitimately empty answer, disclosed by the check in the ordinary way |
+ *
+ * Conflating them would make every quiet repository look like a wiring bug, and
+ * DEC-070 already machine-checks that a declaration matches what the adapter
+ * emitted, so a declaration is evidence rather than a promise.
+ *
+ * ## Refusal is `not_analysable`, not a crash
+ *
+ * §20.2's four categories are the point: *"we found nothing"* and *"we cannot
+ * look"* are different sentences. A refusal names the missing type and the
+ * producers that were loaded, so the answer a user sees is the second sentence
+ * rather than an empty list. It does not throw, because a repository analysed
+ * with only a Ruby adapter legitimately lacks most types — that is degradation,
+ * which is disclosed, not a defect.
+ */
+import type { CapabilityMatrix, EdgeType, NodeType } from "@descryy/ir";
+export interface CapabilityRequirement {
+    /** The check's name, used in the refusal so a reader knows what did not run. */
+    readonly check: string;
+    readonly nodeTypes?: readonly NodeType[];
+    readonly edgeTypes?: readonly EdgeType[];
+    /**
+     * `attrs` keys the check reads, such as `envReads`.
+     *
+     * **Declared for the reader, never enforced**, and that asymmetry is
+     * deliberate: `capabilities()` describes node and edge types and says nothing
+     * about `attrs`, because nothing above the IR may read `attrs` (rule 9). So
+     * this cannot be machine-checked without extending the contract, and claiming
+     * to check it would be worse than not checking it. It is carried so a refusal
+     * can say *which attribute* is missing when the type is present and the data
+     * is not.
+     */
+    readonly attrKeys?: readonly string[];
+}
+export interface ProducerCapabilities {
+    readonly id: string;
+    readonly capabilities: CapabilityMatrix;
+}
+export type PreconditionVerdict = {
+    readonly satisfied: true;
+} | {
+    readonly satisfied: false;
+    readonly missingNodeTypes: readonly NodeType[];
+    readonly missingEdgeTypes: readonly EdgeType[];
+    /** One sentence, in §20.2's *not analysable* voice. */
+    readonly reason: string;
+};
+/**
+ * Can this check run against the producers that are loaded?
+ *
+ * **An empty producer list refuses everything**, which is correct rather than
+ * pedantic: a check run with no producers loaded returns an empty result, and an
+ * empty result from no data reads exactly like an empty result from clean code.
+ */
+export declare function checkPreconditions(requirement: CapabilityRequirement, producers: readonly ProducerCapabilities[]): PreconditionVerdict;
+/**
+ * The same question asked the other way, for an audit rather than for a run:
+ * **which declared requirements can no loaded producer satisfy?**
+ *
+ * DEC-112's rule is that at least one gate per capability must consume what a
+ * shipped producer actually emits. This is how you find the ones that do not,
+ * on purpose rather than by accident — five instances were found by accident,
+ * and that is only the count so far.
+ */
+export declare function auditRequirements(requirements: readonly CapabilityRequirement[], producers: readonly ProducerCapabilities[]): readonly {
+    readonly requirement: CapabilityRequirement;
+    readonly verdict: PreconditionVerdict;
+}[];
+//# sourceMappingURL=preconditions.d.ts.map

package/dist/capabilities/preconditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preconditions.d.ts","sourceRoot":"","sources":["../../src/capabilities/preconditions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAExE,MAAM,WAAW,qBAAqB;IACpC,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACzC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;CACzC;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CAAE,GAC5B;IACE,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,gBAAgB,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC/C,QAAQ,CAAC,gBAAgB,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC/C,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEN;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,qBAAqB,EAClC,SAAS,EAAE,SAAS,oBAAoB,EAAE,GACzC,mBAAmB,CA2BrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,SAAS,qBAAqB,EAAE,EAC9C,SAAS,EAAE,SAAS,oBAAoB,EAAE,GACzC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,EAAE,CAKnG"}

package/dist/capabilities/preconditions.js

@@ -0,0 +1,94 @@
+/**
+ * A check declares what it needs; the engine refuses to run it if no loaded
+ * producer can supply that. DEC-112's implementation.
+ *
+ * ## The defect this makes impossible
+ *
+ * Three static checks read their graph side with `nodesOfType("FILE")`. **No
+ * shipped adapter emits a `FILE` node** — all nine use `MODULE`. So the graph
+ * half of every one of them was dead on every real repository, and 48 tests and
+ * three precision gates stayed green throughout, because all four instruments
+ * minted the node type the check wanted.
+ *
+ * The fact was *already known*. `packages/core/src/tiers/ladder.ts` records it in
+ * a comment, written after the tier ladder required `FILE` and failed every
+ * adapter at Tier C. A comment is not reachable from the place the next person
+ * writes a check.
+ *
+ * **`capabilities()` has declared `nodeTypes` since the adapter contract was
+ * written** (`packages/ir/src/contracts.ts`). Nobody asked it. This module is
+ * the asking.
+ *
+ * ## Declared, not emitted — and the distinction is the whole design
+ *
+ * The precondition is checked against what loaded producers **declare**, never
+ * against what a particular run emitted. Those are different failures and only
+ * one of them is a bug:
+ *
+ * | situation | verdict | why |
+ * | --- | --- | --- |
+ * | no loaded producer *declares* the type | **refuse** | the check can never work here; running it produces an empty result indistinguishable from a clean repository |
+ * | a producer declares it, this run emitted none | **run** | a legitimately empty answer, disclosed by the check in the ordinary way |
+ *
+ * Conflating them would make every quiet repository look like a wiring bug, and
+ * DEC-070 already machine-checks that a declaration matches what the adapter
+ * emitted, so a declaration is evidence rather than a promise.
+ *
+ * ## Refusal is `not_analysable`, not a crash
+ *
+ * §20.2's four categories are the point: *"we found nothing"* and *"we cannot
+ * look"* are different sentences. A refusal names the missing type and the
+ * producers that were loaded, so the answer a user sees is the second sentence
+ * rather than an empty list. It does not throw, because a repository analysed
+ * with only a Ruby adapter legitimately lacks most types — that is degradation,
+ * which is disclosed, not a defect.
+ */
+/**
+ * Can this check run against the producers that are loaded?
+ *
+ * **An empty producer list refuses everything**, which is correct rather than
+ * pedantic: a check run with no producers loaded returns an empty result, and an
+ * empty result from no data reads exactly like an empty result from clean code.
+ */
+export function checkPreconditions(requirement, producers) {
+    const declaredNodes = new Set();
+    const declaredEdges = new Set();
+    for (const producer of producers) {
+        for (const type of producer.capabilities.nodeTypes)
+            declaredNodes.add(type);
+        for (const type of producer.capabilities.edgeTypes)
+            declaredEdges.add(type);
+    }
+    const missingNodeTypes = (requirement.nodeTypes ?? []).filter((t) => !declaredNodes.has(t));
+    const missingEdgeTypes = (requirement.edgeTypes ?? []).filter((t) => !declaredEdges.has(t));
+    if (missingNodeTypes.length === 0 && missingEdgeTypes.length === 0)
+        return { satisfied: true };
+    const missing = [...missingNodeTypes, ...missingEdgeTypes].join(", ");
+    const who = producers.length === 0
+        ? "no producer is loaded"
+        : `the loaded producers (${producers.map((p) => p.id).join(", ")}) declare none of them`;
+    return {
+        satisfied: false,
+        missingNodeTypes,
+        missingEdgeTypes,
+        reason: `${requirement.check} needs ${missing}, and ${who}. ` +
+            `This is reported as not analysable rather than as an empty result: nothing looked, ` +
+            `so "no findings" would be a claim about the code that was never checked.`,
+    };
+}
+/**
+ * The same question asked the other way, for an audit rather than for a run:
+ * **which declared requirements can no loaded producer satisfy?**
+ *
+ * DEC-112's rule is that at least one gate per capability must consume what a
+ * shipped producer actually emits. This is how you find the ones that do not,
+ * on purpose rather than by accident — five instances were found by accident,
+ * and that is only the count so far.
+ */
+export function auditRequirements(requirements, producers) {
+    return requirements.map((requirement) => ({
+        requirement,
+        verdict: checkPreconditions(requirement, producers),
+    }));
+}
+//# sourceMappingURL=preconditions.js.map

package/dist/capabilities/preconditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preconditions.js","sourceRoot":"","sources":["../../src/capabilities/preconditions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAsCH;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,WAAkC,EAClC,SAA0C;IAE1C,MAAM,aAAa,GAAG,IAAI,GAAG,EAAY,CAAC;IAC1C,MAAM,aAAa,GAAG,IAAI,GAAG,EAAY,CAAC;IAC1C,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,YAAY,CAAC,SAAS;YAAE,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5E,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,YAAY,CAAC,SAAS;YAAE,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9E,CAAC;IAED,MAAM,gBAAgB,GAAG,CAAC,WAAW,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5F,MAAM,gBAAgB,GAAG,CAAC,WAAW,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5F,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IAE/F,MAAM,OAAO,GAAG,CAAC,GAAG,gBAAgB,EAAE,GAAG,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtE,MAAM,GAAG,GACP,SAAS,CAAC,MAAM,KAAK,CAAC;QACpB,CAAC,CAAC,uBAAuB;QACzB,CAAC,CAAC,yBAAyB,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC;IAE7F,OAAO;QACL,SAAS,EAAE,KAAK;QAChB,gBAAgB;QAChB,gBAAgB;QAChB,MAAM,EACJ,GAAG,WAAW,CAAC,KAAK,UAAU,OAAO,SAAS,GAAG,IAAI;YACrD,qFAAqF;YACrF,0EAA0E;KAC7E,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,YAA8C,EAC9C,SAA0C;IAE1C,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QACxC,WAAW;QACX,OAAO,EAAE,kBAAkB,CAAC,WAAW,EAAE,SAAS,CAAC;KACpD,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/contracts/engine.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The contract engine — §13, both halves, each honest about its own reach.
+ *
+ * ```
+ *   API_ROUTE ──SERVES_API──▶ API_ENDPOINT ◀──USES_API── caller
+ *       │                                                   │
+ *   USES_TYPE (attrs.roles)                       attrs.requestType / responseType
+ *       ▼                                                   ▼
+ *      DTO ◀───────────── shapes compared at R3 ─────────▶ DTO
+ * ```
+ *
+ * The **path half** works at R2 and runs today; see `orphans.ts`. The **shape
+ * half** needs per-field detail on both sides, and this file is where the two
+ * meet.
+ *
+ * ## Which side is the reader — it flips between request and response
+ *
+ * A shape mismatch is only a defect in one direction: the side that *reads* a
+ * field the other side does not *send*. For a **response** the caller reads and
+ * the route sends. For a **request body the route reads and the caller sends**.
+ * So the two comparisons are run with their arguments in opposite order, and
+ * getting that backwards would report every optional request field in every
+ * codebase as a defect.
+ *
+ * ## What the producers must attach, stated here because the engine is what needs it
+ *
+ * | side | carrier | key |
+ * | --- | --- | --- |
+ * | consumer | the `USES_API` edge | `attrs.requestType` / `attrs.responseType` — a node id — or `attrs.requestFields` / `attrs.responseFields`, a list of names |
+ * | provider | the route's `USES_TYPE` edge | `attrs.roles`: a list containing `"request"`, `"response"`, or both |
+ *
+ * **The consumer half does not exist in any adapter yet**, and the report says so
+ * by name rather than reporting "no mismatches" — the attribute and the edge, so
+ * it reads as a task rather than a shrug:
+ *
+ * 1. `USES_API` currently carries `attrs.client` and nothing about shape.
+ * 2. A route's `USES_TYPE` edges carry no direction, so a request DTO and a
+ *    response DTO are indistinguishable. Comparing a caller's response
+ *    expectation against a request schema would produce confident nonsense, so
+ *    an unroled DTO is refused rather than assumed — even when a route names
+ *    exactly one, because "one schema" does not say which direction it travels.
+ *    **`adapter-openapi` now supplies `attrs.roles`**, so the provider half of
+ *    this is closed; the consumer half is not.
+ */
+import type { IRNode, ResolutionLevel } from "@descryy/ir";
+import type { AdjacencyProvider, QueryResult } from "../query/provider.ts";
+import { type ContractReport, type OrphanOptions } from "./orphans.ts";
+import { type ShapeDifference } from "./shapes.ts";
+export type ShapeDirection = "request" | "response";
+export interface ShapeMismatch {
+    readonly endpoint: IRNode;
+    readonly direction: ShapeDirection;
+    /** The node that reads the shape — the side a missing field breaks. */
+    readonly reader: IRNode;
+    /** The node that declares it. */
+    readonly writer: IRNode;
+    readonly differences: readonly ShapeDifference[];
+    readonly resolution: ResolutionLevel;
+}
+export interface ShapeCheck {
+    /** True when at least one endpoint had a comparable shape on both sides. */
+    readonly ran: boolean;
+    readonly comparable: number;
+    readonly mismatches: readonly ShapeMismatch[];
+    /**
+     * Endpoints where a shape existed on one side only, by side. The two counts
+     * are the size of the gap and point at which producer has to change.
+     */
+    readonly consumerOnly: number;
+    readonly providerOnly: number;
+    /** Routes naming a DTO with no request/response role, so direction is unknown. */
+    readonly unroledDtos: number;
+    /**
+     * Directions where one route named **two different schemas**, so which body a
+     * caller reads is unknown. Refused rather than resolved by ranking.
+     */
+    readonly ambiguousDirections: number;
+    /** Exactly what is missing, in plain words. Never empty when `ran` is false. */
+    readonly blockers: readonly string[];
+}
+export interface ContractCheck {
+    readonly paths: ContractReport;
+    readonly shapes: ShapeCheck;
+}
+export interface ContractOptions extends OrphanOptions {
+    /** Skip the shape half entirely — for a fast pre-push run. */
+    readonly pathsOnly?: boolean;
+}
+export declare function checkContracts(provider: AdjacencyProvider, options?: ContractOptions): QueryResult<ContractCheck>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/contracts/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/contracts/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAc,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,EAAuB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAC5F,OAAO,EAAwC,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAEzF,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,UAAU,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iCAAiC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACjD,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;CACtC;AAED,MAAM,WAAW,UAAU;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED,MAAM,WAAW,eAAgB,SAAQ,aAAa;IACpD,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAqGD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,eAAoB,GAC5B,WAAW,CAAC,aAAa,CAAC,CAuK5B"}

package/dist/contracts/engine.js

@@ -0,0 +1,291 @@
+/**
+ * The contract engine — §13, both halves, each honest about its own reach.
+ *
+ * ```
+ *   API_ROUTE ──SERVES_API──▶ API_ENDPOINT ◀──USES_API── caller
+ *       │                                                   │
+ *   USES_TYPE (attrs.roles)                       attrs.requestType / responseType
+ *       ▼                                                   ▼
+ *      DTO ◀───────────── shapes compared at R3 ─────────▶ DTO
+ * ```
+ *
+ * The **path half** works at R2 and runs today; see `orphans.ts`. The **shape
+ * half** needs per-field detail on both sides, and this file is where the two
+ * meet.
+ *
+ * ## Which side is the reader — it flips between request and response
+ *
+ * A shape mismatch is only a defect in one direction: the side that *reads* a
+ * field the other side does not *send*. For a **response** the caller reads and
+ * the route sends. For a **request body the route reads and the caller sends**.
+ * So the two comparisons are run with their arguments in opposite order, and
+ * getting that backwards would report every optional request field in every
+ * codebase as a defect.
+ *
+ * ## What the producers must attach, stated here because the engine is what needs it
+ *
+ * | side | carrier | key |
+ * | --- | --- | --- |
+ * | consumer | the `USES_API` edge | `attrs.requestType` / `attrs.responseType` — a node id — or `attrs.requestFields` / `attrs.responseFields`, a list of names |
+ * | provider | the route's `USES_TYPE` edge | `attrs.roles`: a list containing `"request"`, `"response"`, or both |
+ *
+ * **The consumer half does not exist in any adapter yet**, and the report says so
+ * by name rather than reporting "no mismatches" — the attribute and the edge, so
+ * it reads as a task rather than a shrug:
+ *
+ * 1. `USES_API` currently carries `attrs.client` and nothing about shape.
+ * 2. A route's `USES_TYPE` edges carry no direction, so a request DTO and a
+ *    response DTO are indistinguishable. Comparing a caller's response
+ *    expectation against a request schema would produce confident nonsense, so
+ *    an unroled DTO is refused rather than assumed — even when a route names
+ *    exactly one, because "one schema" does not say which direction it travels.
+ *    **`adapter-openapi` now supplies `attrs.roles`**, so the provider half of
+ *    this is closed; the consumer half is not.
+ */
+import { findContractOrphans } from "./orphans.js";
+import { compareShapes, readShape } from "./shapes.js";
+/** Shapes a caller declared on its `USES_API` edge, by direction. */
+function consumerShapes(provider, caller, edgeAttrs) {
+    const out = {};
+    for (const direction of ["request", "response"]) {
+        const idKey = `${direction}Type`;
+        const fieldsKey = `${direction}Fields`;
+        const id = edgeAttrs[idKey];
+        if (typeof id === "string") {
+            const node = provider.node(id);
+            const shape = node === undefined ? null : readShape(node);
+            if (shape !== null) {
+                out[direction] = shape;
+                continue;
+            }
+        }
+        // Inline names, for a producer that has field names but no node to hang them
+        // on. Name-level only — `readShape` will mark it undetailed and the
+        // comparator will refuse to compare types against it.
+        const names = edgeAttrs[fieldsKey];
+        if (Array.isArray(names)) {
+            const fields = names.filter((n) => typeof n === "string").map((name) => ({ name }));
+            if (fields.length > 0)
+                out[direction] = { source: caller, fields, detailed: false };
+        }
+    }
+    return out;
+}
+/** Shapes the routes serving an endpoint declare, by direction. */
+function providerShapes(provider, routes) {
+    const shapes = {};
+    const ambiguous = new Set();
+    let unroled = 0;
+    for (const route of routes) {
+        for (const edge of provider.outgoing(route.id, { types: ["USES_TYPE"] })) {
+            const target = provider.node(edge.to);
+            if (target === undefined)
+                continue;
+            const shape = readShape(target);
+            if (shape === null)
+                continue;
+            // `roles` is a **list**, and that is not over-engineering. Edge identity is
+            // hash(from, to, type) with attrs excluded (DEC-012), so a route naming one
+            // schema is exactly one edge — and `PUT /orders/{id}` that takes an `Order`
+            // and returns an `Order` is the ordinary REST shape. A singular label would
+            // force a guess or drop that pair entirely.
+            const raw = edge.attrs?.["roles"];
+            const declared = Array.isArray(raw) ? raw.filter((r) => typeof r === "string") : [];
+            const roles = declared.filter((r) => r === "request" || r === "response");
+            if (roles.length === 0) {
+                // Two different things, and conflating them misleads a producer. A
+                // schema labelled `errorResponse` has a **known** direction this check
+                // does not compare — a 4xx body is a different contract, not an unknown
+                // one — while a schema with no usable label really is direction-unknown
+                // and is the case a producer has to fix.
+                if (declared.length === 0)
+                    unroled += 1;
+                continue;
+            }
+            for (const role of roles) {
+                const existing = shapes[role];
+                if (existing === undefined) {
+                    shapes[role] = shape;
+                    continue;
+                }
+                if (existing.source.id === shape.source.id)
+                    continue;
+                // **Two different schemas claiming one direction on one route.**
+                // First-wins is a guess wearing a `??=`: whichever schema the adjacency
+                // ranking returned first becomes "the response", and that ranking is by
+                // resolution then confidence then id — none of which knows which body a
+                // caller reads. Measured cost: four of seven findings on a real contract
+                // compared a success type against FastAPI's validation error and
+                // reported every field of the real response as missing.
+                ambiguous.add(`${route.id} ${role}`);
+                delete shapes[role];
+            }
+        }
+    }
+    // A direction that ended up ambiguous is cleared, so nothing downstream can
+    // read a shape two schemas disagreed about.
+    return { shapes, unroled, ambiguous: ambiguous.size };
+}
+export function checkContracts(provider, options = {}) {
+    const paths = findContractOrphans(provider, options);
+    const notes = [...paths.notes];
+    if (options.pathsOnly === true) {
+        return assemble(provider, paths.data, skipped("the shape half was not requested"), paths, [
+            ...notes,
+            "Only the path half ran. Request and response shapes were not compared.",
+        ]);
+    }
+    // Endpoints with both sides present are the only ones a shape comparison can
+    // say anything about: with one side missing, the path half has already
+    // reported it and a shape check would report the same gap a second time.
+    const set = provider.nodesOfType("API_ENDPOINT", ...(options.limit === undefined ? [] : [options.limit]));
+    const mismatches = [];
+    let comparable = 0;
+    let consumerOnly = 0;
+    let providerOnly = 0;
+    let unroledDtos = 0;
+    let ambiguousDirections = 0;
+    let floor = 4;
+    for (const endpoint of set.nodes) {
+        const callers = [];
+        const routes = [];
+        let edgeFloor = 4;
+        for (const edge of provider.incoming(endpoint.id, { types: ["USES_API", "SERVES_API"] })) {
+            const other = provider.node(edge.from);
+            if (other === undefined)
+                continue;
+            if (edge.resolution < edgeFloor)
+                edgeFloor = edge.resolution;
+            if (edge.type === "USES_API") {
+                callers.push({ node: other, attrs: edge.attrs ?? {}, resolution: edge.resolution });
+            }
+            else
+                routes.push(other);
+        }
+        if (callers.length === 0 || routes.length === 0)
+            continue;
+        const supplied = providerShapes(provider, routes);
+        unroledDtos += supplied.unroled;
+        ambiguousDirections += supplied.ambiguous;
+        for (const caller of callers) {
+            const wanted = consumerShapes(provider, caller.node, caller.attrs);
+            for (const direction of ["request", "response"]) {
+                const consumer = wanted[direction];
+                const producer = supplied.shapes[direction];
+                if (consumer === undefined && producer === undefined)
+                    continue;
+                if (consumer === undefined) {
+                    providerOnly += 1;
+                    continue;
+                }
+                if (producer === undefined) {
+                    consumerOnly += 1;
+                    continue;
+                }
+                comparable += 1;
+                // The reader is whoever consumes the payload, and it flips: the caller
+                // reads a response, the route reads a request body.
+                const [reader, writer] = direction === "response" ? [consumer, producer] : [producer, consumer];
+                const comparison = compareShapes(reader, writer);
+                if (comparison.differences.length === 0)
+                    continue;
+                // Principle 3, at the point the claim is made rather than in the report.
+                // A shape claim is not name-level, so R2 evidence caps it at class B
+                // however confident the diff looks.
+                // `attrs.shapeResolution` when a producer supplies it — DEC-058 one
+                // level up. A `USES_API` edge carries two kinds of evidence: the path
+                // was matched at R2, the shape may have been read from a type checker at
+                // R3. Taking the edge's own resolution for both caps every shape claim
+                // at the weaker of the two facts it carries.
+                const declaredRes = caller.attrs["shapeResolution"];
+                const shapeEvidence = typeof declaredRes === "number" && declaredRes >= 0 && declaredRes <= 4
+                    ? declaredRes
+                    : caller.resolution;
+                const resolution = Math.min(shapeEvidence, reader.detailed && writer.detailed ? 3 : 2);
+                if (resolution < floor)
+                    floor = resolution;
+                mismatches.push({
+                    endpoint,
+                    direction,
+                    reader: reader.source,
+                    writer: writer.source,
+                    differences: comparison.differences,
+                    resolution,
+                });
+            }
+        }
+    }
+    const blockers = [];
+    if (comparable === 0) {
+        if (consumerOnly === 0) {
+            blockers.push("No producer attaches a request or response shape to a USES_API edge. The engine reads " +
+                "attrs.requestType / attrs.responseType (a node id) or attrs.requestFields / " +
+                "attrs.responseFields (a list of names); a frontend extractor emits the edge today with " +
+                "only the client name on it.");
+        }
+        if (unroledDtos > 0) {
+            blockers.push(`${unroledDtos} route-to-DTO link(s) carry no direction. A route's USES_TYPE edge needs ` +
+                'attrs.roles listing "request", "response" or both — without it a request schema and a ' +
+                "response schema are indistinguishable, and the engine refuses to guess rather than " +
+                "compare a caller's response expectation against a request body.");
+        }
+        if (providerOnly > 0 && consumerOnly === 0 && blockers.length === 0) {
+            blockers.push(`${providerOnly} endpoint(s) have a shape on the provider side and none on the consumer ` +
+                "side, so there was nothing to compare it against.");
+        }
+        if (blockers.length === 0) {
+            blockers.push("No endpoint had a declared shape on both sides, so no comparison ran. This is not a " +
+                "result of zero mismatches.");
+        }
+    }
+    const shapes = {
+        ran: comparable > 0,
+        comparable,
+        mismatches: mismatches.sort((a, b) => b.resolution - a.resolution ||
+            a.endpoint.name.localeCompare(b.endpoint.name) ||
+            a.direction.localeCompare(b.direction)),
+        consumerOnly,
+        providerOnly,
+        unroledDtos,
+        ambiguousDirections,
+        blockers,
+    };
+    for (const blocker of blockers)
+        notes.push(blocker);
+    if (ambiguousDirections > 0) {
+        notes.push(`${ambiguousDirections} route direction(s) had two different schemas claiming them, so ` +
+            "which body a caller reads is unknown and no comparison was made for those. Picking one " +
+            "by rank would decide it by whichever row the index reached first.");
+    }
+    if (shapes.ran) {
+        notes.push(`${comparable} shape pair(s) were compared and ${mismatches.length} disagreed. A field the ` +
+            "reading side ignores is not reported — only one the reading side needs and the writing " +
+            "side does not supply.");
+    }
+    return assemble(provider, paths.data, shapes, paths, notes, floor);
+}
+function skipped(reason) {
+    return {
+        ran: false,
+        comparable: 0,
+        mismatches: [],
+        consumerOnly: 0,
+        providerOnly: 0,
+        unroledDtos: 0,
+        ambiguousDirections: 0,
+        blockers: [reason],
+    };
+}
+function assemble(provider, paths, shapes, pathResult, notes, shapeFloor = 4) {
+    // The floor is the weaker of the two halves, because the answer is both of
+    // them. A path check at R2 does not become R3 because a shape check reached it.
+    const resolutionFloor = Math.min(pathResult.stamp.resolutionFloor, shapes.ran ? shapeFloor : 4);
+    const stamp = { ...provider.baseStamp(), resolutionFloor };
+    return {
+        data: { paths, shapes },
+        stamp,
+        truncated: pathResult.truncated,
+        notes: [...notes],
+    };
+}
+//# sourceMappingURL=engine.js.map

package/dist/contracts/engine.js.map

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