@descryy/ir 0.1.0

package/dist/conformance/compare.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The comparison primitives: attribute matching and edge-type equivalence.
+ *
+ * Pure functions over plain values. Nothing here reads a batch, constructs a
+ * finding or knows what a pattern is — which is what makes the two rules below
+ * arguable on their own terms rather than buried inside the runner.
+ */
+import type { EdgeType, NodeType } from "../vocabulary.ts";
+/**
+ * Node types whose attributes are **not** passed through `fieldNameMap`.
+ *
+ * The map translates one identifier in source code into another corpus's
+ * spelling of the same idea — `total_amount` and `totalAmount` are the same
+ * field written the way each language writes fields. A database column is not
+ * that: `discount_code` is the same string in every language, because it is the
+ * name in the schema and not the name in the code. Mapping it would make golden
+ * pattern 10 demand `discountCode` from one adapter and `discount_code` from
+ * another for the identical migration, and pattern 10 exists precisely because
+ * that migration is language-independent (§14.6).
+ *
+ * Found by writing the map, not by reasoning about it: the corpus binds
+ * `discount_code -> discountCode` for one language and also asserts a column
+ * literally named `discount_code`. See DEC-040.
+ */
+export declare const UNMAPPED_ATTR_NODE_TYPES: ReadonlySet<NodeType>;
+/**
+ * Rewrite every string leaf of an expected value through the manifest's map.
+ *
+ * Applied to the *expectation*, never to what the adapter emitted. An adapter
+ * reports what the source says (`fixtures/languages/<name>/manifest.json`,
+ * `fieldNameMapNote`); rewriting its output would let the harness invent
+ * agreement that is not there.
+ */
+export declare function mapFieldNames(value: unknown, map: Readonly<Record<string, string>>): unknown;
+export interface AttrMismatch {
+    /** Dotted path into the attrs, for a message the adapter author can act on. */
+    readonly path: string;
+    readonly detail: string;
+}
+/**
+ * Does `actual` contain everything `expected` asserts?
+ *
+ * **Containment, not equality**, in three places, and each is deliberate:
+ *
+ * - extra keys in an actual object are fine — `attrs` is the pressure valve that
+ *   keeps the vocabulary at 15 types, so a framework-specific key is expected;
+ * - extra elements in an actual array are fine, for the same reason;
+ * - array order is not compared, because declaration order of fields carries no
+ *   meaning and forcing one would make the golden a style guide.
+ *
+ * Precision violations are not expressed by "the adapter emitted more than
+ * this"; they are expressed by `forbiddenEdges` and `mustNotResolveTo`, which
+ * say exactly what must be absent. Two mechanisms, not three.
+ */
+export declare function attrsSubset(actual: unknown, expected: unknown, path?: string): AttrMismatch | null;
+/**
+ * Edge types a golden expectation will also accept, and from whom.
+ *
+ * Only one pair, and it comes from the corpus rather than from convenience:
+ * golden pattern 11's note says a language that does not distinguish an
+ * interface from a base class may emit `INHERITS` where the golden says
+ * `IMPLEMENTS`, "and the adapter declares which via `capabilities()`".
+ *
+ * The declaration requirement is what keeps this from being a hole. Without it,
+ * any adapter could satisfy `IMPLEMENTS` by emitting `INHERITS` at random and
+ * the pattern would stop asserting anything.
+ */
+export declare const EDGE_TYPE_ALTERNATIVES: Readonly<Partial<Record<EdgeType, readonly EdgeType[]>>>;
+/**
+ * Which edge types satisfy an expectation for `expected`, given what the adapter
+ * declared it can produce. An adapter that declares nothing gets no substitutes.
+ */
+export declare function acceptedEdgeTypes(expected: EdgeType, declared: readonly EdgeType[] | undefined): readonly EdgeType[];
+//# sourceMappingURL=compare.d.ts.map

package/dist/conformance/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../src/conformance/compare.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAM3D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,QAAQ,CAGzD,CAAC;AAEH;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,OAAO,CAS5F;AAMD,MAAM,WAAW,YAAY;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,OAAO,EACjB,IAAI,SAAU,GACb,YAAY,GAAG,IAAI,CAwCrB;AAMD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,QAAQ,EAAE,CAAC,CAAC,CAE3F,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,SAAS,QAAQ,EAAE,GAAG,SAAS,GACxC,SAAS,QAAQ,EAAE,CAIrB"}

package/dist/conformance/compare.js

@@ -0,0 +1,140 @@
+/**
+ * The comparison primitives: attribute matching and edge-type equivalence.
+ *
+ * Pure functions over plain values. Nothing here reads a batch, constructs a
+ * finding or knows what a pattern is — which is what makes the two rules below
+ * arguable on their own terms rather than buried inside the runner.
+ */
+// ---------------------------------------------------------------------------
+// Field-name mapping
+// ---------------------------------------------------------------------------
+/**
+ * Node types whose attributes are **not** passed through `fieldNameMap`.
+ *
+ * The map translates one identifier in source code into another corpus's
+ * spelling of the same idea — `total_amount` and `totalAmount` are the same
+ * field written the way each language writes fields. A database column is not
+ * that: `discount_code` is the same string in every language, because it is the
+ * name in the schema and not the name in the code. Mapping it would make golden
+ * pattern 10 demand `discountCode` from one adapter and `discount_code` from
+ * another for the identical migration, and pattern 10 exists precisely because
+ * that migration is language-independent (§14.6).
+ *
+ * Found by writing the map, not by reasoning about it: the corpus binds
+ * `discount_code -> discountCode` for one language and also asserts a column
+ * literally named `discount_code`. See DEC-040.
+ */
+export const UNMAPPED_ATTR_NODE_TYPES = new Set([
+    "DATABASE_TABLE",
+    "DATABASE_COLUMN",
+]);
+/**
+ * Rewrite every string leaf of an expected value through the manifest's map.
+ *
+ * Applied to the *expectation*, never to what the adapter emitted. An adapter
+ * reports what the source says (`fixtures/languages/<name>/manifest.json`,
+ * `fieldNameMapNote`); rewriting its output would let the harness invent
+ * agreement that is not there.
+ */
+export function mapFieldNames(value, map) {
+    if (typeof value === "string")
+        return map[value] ?? value;
+    if (Array.isArray(value))
+        return value.map((item) => mapFieldNames(item, map));
+    if (typeof value === "object" && value !== null) {
+        const out = {};
+        for (const [key, entry] of Object.entries(value))
+            out[key] = mapFieldNames(entry, map);
+        return out;
+    }
+    return value;
+}
+function describe(value) {
+    return JSON.stringify(value) ?? String(value);
+}
+/**
+ * Does `actual` contain everything `expected` asserts?
+ *
+ * **Containment, not equality**, in three places, and each is deliberate:
+ *
+ * - extra keys in an actual object are fine — `attrs` is the pressure valve that
+ *   keeps the vocabulary at 15 types, so a framework-specific key is expected;
+ * - extra elements in an actual array are fine, for the same reason;
+ * - array order is not compared, because declaration order of fields carries no
+ *   meaning and forcing one would make the golden a style guide.
+ *
+ * Precision violations are not expressed by "the adapter emitted more than
+ * this"; they are expressed by `forbiddenEdges` and `mustNotResolveTo`, which
+ * say exactly what must be absent. Two mechanisms, not three.
+ */
+export function attrsSubset(actual, expected, path = "attrs") {
+    if (Array.isArray(expected)) {
+        if (!Array.isArray(actual)) {
+            return { path, detail: `expected an array, got ${describe(actual)}` };
+        }
+        const taken = new Set();
+        for (const want of expected) {
+            let found = false;
+            for (let i = 0; i < actual.length; i += 1) {
+                if (taken.has(i))
+                    continue;
+                if (attrsSubset(actual[i], want, `${path}[]`) === null) {
+                    taken.add(i);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                return { path, detail: `no entry matching ${describe(want)}` };
+        }
+        return null;
+    }
+    if (typeof expected === "object" && expected !== null) {
+        if (typeof actual !== "object" || actual === null || Array.isArray(actual)) {
+            return { path, detail: `expected an object, got ${describe(actual)}` };
+        }
+        const actualRecord = actual;
+        for (const [key, want] of Object.entries(expected)) {
+            if (!(key in actualRecord)) {
+                return { path: `${path}.${key}`, detail: `absent; expected ${describe(want)}` };
+            }
+            const mismatch = attrsSubset(actualRecord[key], want, `${path}.${key}`);
+            if (mismatch !== null)
+                return mismatch;
+        }
+        return null;
+    }
+    if (actual !== expected) {
+        return { path, detail: `expected ${describe(expected)}, got ${describe(actual)}` };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Edge-type equivalence
+// ---------------------------------------------------------------------------
+/**
+ * Edge types a golden expectation will also accept, and from whom.
+ *
+ * Only one pair, and it comes from the corpus rather than from convenience:
+ * golden pattern 11's note says a language that does not distinguish an
+ * interface from a base class may emit `INHERITS` where the golden says
+ * `IMPLEMENTS`, "and the adapter declares which via `capabilities()`".
+ *
+ * The declaration requirement is what keeps this from being a hole. Without it,
+ * any adapter could satisfy `IMPLEMENTS` by emitting `INHERITS` at random and
+ * the pattern would stop asserting anything.
+ */
+export const EDGE_TYPE_ALTERNATIVES = {
+    IMPLEMENTS: ["INHERITS"],
+};
+/**
+ * Which edge types satisfy an expectation for `expected`, given what the adapter
+ * declared it can produce. An adapter that declares nothing gets no substitutes.
+ */
+export function acceptedEdgeTypes(expected, declared) {
+    const alternatives = EDGE_TYPE_ALTERNATIVES[expected] ?? [];
+    if (declared === undefined)
+        return [expected];
+    return [expected, ...alternatives.filter((type) => declared.includes(type))];
+}
+//# sourceMappingURL=compare.js.map

package/dist/conformance/compare.js.map

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

package/dist/conformance/compose.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Several producers, graded as the graph will actually see them.
+ *
+ * ## Why a per-adapter gate is not enough on its own
+ *
+ * `runConformance` grades **one** adapter, and that is right: a release gate
+ * certifies a thing that can be released. But four of the fourteen golden
+ * patterns assert nodes from **two different producers at once**, and no
+ * single-adapter run can ever satisfy one of those. Pattern 04 is the clearest
+ * case:
+ *
+ *     API_ROUTE ──SERVES_API──▶ API_ENDPOINT      and a FUNCTION handler
+ *     (a contract, or a framework extractor)      (the language adapter)
+ *
+ * `adapter-openapi` produces the route and the endpoint and genuinely cannot
+ * produce the handler; the language adapter produces the handler and genuinely
+ * cannot produce the route. Run apart, each correctly reports a skip for a type
+ * it does not declare — and the pattern is then **permanently unmeasured**,
+ * which reads exactly like a gap in the product when it is a gap in the harness.
+ *
+ * Composing them is not a loosening. It is the arrangement the product ships in:
+ * the Graph Builder merges every `IRSource` over one repository, and a question
+ * like *which handler serves this endpoint* is only ever answerable in the
+ * merged graph. What the composed run certifies is a **pair**, and it is
+ * reported separately from each adapter's own gate so neither number is diluted.
+ *
+ * ## What this is not
+ *
+ * It is not the Graph Builder. It concatenates batches and drops a node whose id
+ * a previous batch already emitted, which is the merge rule stated at its
+ * simplest (DEC-012); the builder additionally reconciles attributes, resolution
+ * and confidence across producers, and that reconciliation has its own tests.
+ * Using the real builder here would make a conformance failure ambiguous between
+ * the adapters and the merge — so this stays deliberately thin, and a
+ * disagreement between two producers over one id is **reported** rather than
+ * silently resolved.
+ *
+ * ## The one thing it gives up, and why that is allowed here
+ *
+ * The Normaliser requires every node in a batch to carry the batch own
+ * `producedBy`, because the writer invalidates by `(producedBy, sourceFiles)`
+ * and a node stamped differently would be inserted by a batch and then never
+ * deleted by it. That rule is load-bearing for storage and is not weakened: the
+ * composed batch **restamps** every node and edge with the composition id, which
+ * costs per-node provenance *inside this run*.
+ *
+ * That is acceptable only because a composed run stores nothing and certifies
+ * nothing shippable. The per-adapter gates above it keep full provenance and are
+ * what release depends on; this run answers one question — can the pair satisfy
+ * a pattern neither can satisfy alone — and is reported separately so no
+ * adapter number is diluted. The product itself never does this: the Graph
+ * Builder normalises each batch on its own and merges the results, which is why
+ * it keeps the provenance this does not.
+ */
+import type { CapabilityMatrix, IRSource } from "../contracts.ts";
+import type { NodeType } from "../vocabulary.ts";
+/** A node two producers both claimed, kept for reporting rather than hidden. */
+export interface CompositionConflict {
+    readonly nodeId: string;
+    readonly keptFrom: string;
+    readonly alsoFrom: string;
+    readonly type: NodeType;
+    readonly name: string;
+}
+export interface ComposedSource extends IRSource {
+    capabilities(): CapabilityMatrix;
+    /** Populated by `emit`. Empty when no two producers claimed the same id. */
+    readonly conflicts: readonly CompositionConflict[];
+}
+/**
+ * Compose several sources into one, in the given order.
+ *
+ * Order is significant and deliberate: the first producer to claim a node id
+ * keeps it. Passing the language adapter first therefore means a route it
+ * extracted from source outranks the same route read from a contract, which is
+ * the precedence a framework extractor should have — it saw the code.
+ */
+export declare function composeSources(sources: readonly IRSource[], composedId?: string): ComposedSource;
+//# sourceMappingURL=compose.d.ts.map

package/dist/conformance/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/conformance/compose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAIH,OAAO,KAAK,EAEV,gBAAgB,EAChB,QAAQ,EAET,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE3D,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAe,SAAQ,QAAQ;IAC9C,YAAY,IAAI,gBAAgB,CAAC;IACjC,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACpD;AAKD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,cAAc,CAyGhG"}

package/dist/conformance/compose.js

@@ -0,0 +1,167 @@
+/**
+ * Several producers, graded as the graph will actually see them.
+ *
+ * ## Why a per-adapter gate is not enough on its own
+ *
+ * `runConformance` grades **one** adapter, and that is right: a release gate
+ * certifies a thing that can be released. But four of the fourteen golden
+ * patterns assert nodes from **two different producers at once**, and no
+ * single-adapter run can ever satisfy one of those. Pattern 04 is the clearest
+ * case:
+ *
+ *     API_ROUTE ──SERVES_API──▶ API_ENDPOINT      and a FUNCTION handler
+ *     (a contract, or a framework extractor)      (the language adapter)
+ *
+ * `adapter-openapi` produces the route and the endpoint and genuinely cannot
+ * produce the handler; the language adapter produces the handler and genuinely
+ * cannot produce the route. Run apart, each correctly reports a skip for a type
+ * it does not declare — and the pattern is then **permanently unmeasured**,
+ * which reads exactly like a gap in the product when it is a gap in the harness.
+ *
+ * Composing them is not a loosening. It is the arrangement the product ships in:
+ * the Graph Builder merges every `IRSource` over one repository, and a question
+ * like *which handler serves this endpoint* is only ever answerable in the
+ * merged graph. What the composed run certifies is a **pair**, and it is
+ * reported separately from each adapter's own gate so neither number is diluted.
+ *
+ * ## What this is not
+ *
+ * It is not the Graph Builder. It concatenates batches and drops a node whose id
+ * a previous batch already emitted, which is the merge rule stated at its
+ * simplest (DEC-012); the builder additionally reconciles attributes, resolution
+ * and confidence across producers, and that reconciliation has its own tests.
+ * Using the real builder here would make a conformance failure ambiguous between
+ * the adapters and the merge — so this stays deliberately thin, and a
+ * disagreement between two producers over one id is **reported** rather than
+ * silently resolved.
+ *
+ * ## The one thing it gives up, and why that is allowed here
+ *
+ * The Normaliser requires every node in a batch to carry the batch own
+ * `producedBy`, because the writer invalidates by `(producedBy, sourceFiles)`
+ * and a node stamped differently would be inserted by a batch and then never
+ * deleted by it. That rule is load-bearing for storage and is not weakened: the
+ * composed batch **restamps** every node and edge with the composition id, which
+ * costs per-node provenance *inside this run*.
+ *
+ * That is acceptable only because a composed run stores nothing and certifies
+ * nothing shippable. The per-adapter gates above it keep full provenance and are
+ * what release depends on; this run answers one question — can the pair satisfy
+ * a pattern neither can satisfy alone — and is reported separately so no
+ * adapter number is diluted. The product itself never does this: the Graph
+ * Builder normalises each batch on its own and merges the results, which is why
+ * it keeps the provenance this does not.
+ */
+const hasCapabilities = (source) => typeof source.capabilities === "function";
+/**
+ * Compose several sources into one, in the given order.
+ *
+ * Order is significant and deliberate: the first producer to claim a node id
+ * keeps it. Passing the language adapter first therefore means a route it
+ * extracted from source outranks the same route read from a contract, which is
+ * the precedence a framework extractor should have — it saw the code.
+ */
+export function composeSources(sources, composedId) {
+    const conflicts = [];
+    // The id half of `producedBy` admits no `+`; the version half does. Both
+    // halves are checked by the Normaliser and a malformed one fails the whole
+    // batch, which is the boundary working rather than an obstacle.
+    const id = (composedId ?? sources.map((source) => source.id).join("-")).replace(/[^A-Za-z0-9._-]/g, "-");
+    const version = sources.map((source) => source.version).join("+");
+    const stamp = `${id}@${version}`;
+    return {
+        id,
+        version,
+        conflicts,
+        capabilities() {
+            const matrices = sources.filter(hasCapabilities).map((source) => source.capabilities());
+            const nodeTypes = new Set();
+            const edgeTypes = new Set();
+            const extractors = new Set();
+            const supplied = new Set();
+            let maxResolution = 0;
+            for (const matrix of matrices) {
+                for (const type of matrix.nodeTypes)
+                    nodeTypes.add(type);
+                for (const type of matrix.edgeTypes)
+                    edgeTypes.add(type);
+                for (const extractor of matrix.frameworkExtractors)
+                    extractors.add(extractor);
+                for (const capability of matrix.frameworkCapabilities ?? [])
+                    supplied.add(capability);
+                // The union's ceiling is the best any member reaches. A pattern is then
+                // graded against the producer that can actually satisfy it rather than
+                // against the weakest member of the pair.
+                if (matrix.maxResolution > maxResolution)
+                    maxResolution = matrix.maxResolution;
+            }
+            return {
+                maxResolution,
+                nodeTypes: [...nodeTypes],
+                edgeTypes: [...edgeTypes],
+                hasCallHierarchy: matrices.some((matrix) => matrix.hasCallHierarchy),
+                hasTypeHierarchy: matrices.some((matrix) => matrix.hasTypeHierarchy),
+                frameworkExtractors: [...extractors],
+                // The union of what the members supply, and only declared when
+                // something is bound. A composed source binding extractors and
+                // declaring no capability is the same adapter failure as a single one:
+                // the check lives in manifest-check.ts and applies here unchanged.
+                ...(extractors.size === 0 ? {} : { frameworkCapabilities: [...supplied] }),
+            };
+        },
+        async emit(ctx) {
+            conflicts.length = 0;
+            const nodes = new Map();
+            const owner = new Map();
+            const edges = new Map();
+            const unresolved = [];
+            const sourceFiles = [];
+            const skippedFiles = [];
+            let reached = 0;
+            let first;
+            for (const source of sources) {
+                const batch = await source.emit(ctx);
+                first ??= batch;
+                sourceFiles.push(...batch.sourceFiles);
+                skippedFiles.push(...batch.skippedFiles);
+                if (batch.reachedResolution > reached)
+                    reached = batch.reachedResolution;
+                for (const node of batch.nodes) {
+                    const held = nodes.get(node.id);
+                    if (held !== undefined) {
+                        conflicts.push({
+                            nodeId: node.id,
+                            keptFrom: owner.get(node.id) ?? "?",
+                            alsoFrom: batch.producedBy,
+                            type: held.type,
+                            name: held.name,
+                        });
+                        continue;
+                    }
+                    nodes.set(node.id, { ...node, producedBy: stamp });
+                    owner.set(node.id, batch.producedBy);
+                }
+                for (const edge of batch.edges) {
+                    edges.set(`${edge.from} ${edge.to} ${edge.type}`, { ...edge, producedBy: stamp });
+                }
+                unresolved.push(...batch.unresolved.map((ref) => ({ ...ref, producedBy: stamp })));
+            }
+            if (first === undefined) {
+                throw new TypeError("composeSources: at least one source is required");
+            }
+            return {
+                repo: first.repo,
+                ...(first.workspace === undefined ? {} : { workspace: first.workspace }),
+                commitSha: first.commitSha,
+                producedBy: stamp,
+                sourceFiles: [...new Set(sourceFiles)].sort(),
+                skippedFiles,
+                reachedResolution: reached,
+                nodes: [...nodes.values()],
+                edges: [...edges.values()],
+                unresolved,
+            };
+        },
+    };
+}
+//# sourceMappingURL=compose.js.map

package/dist/conformance/compose.js.map

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

package/dist/conformance/golden.d.ts

@@ -0,0 +1,110 @@
+/**
+ * The golden corpus, parsed and validated — `fixtures/golden/patterns.json`.
+ *
+ * The golden is hand-written JSON that outlives every adapter, so it is parsed
+ * **strictly**: an unknown key is an error, not something to ignore. A typo in
+ * `requiredAtResolution` that silently parsed as "no requirement" would turn a
+ * recall gate into a no-op, and nothing downstream would ever notice — the suite
+ * would go green and stay green.
+ *
+ * One golden, N language bindings (`fixtures/README.md`). Nothing here is
+ * per-language, and nothing here may become per-language: the moment a pattern
+ * needs a different expectation per adapter it has stopped being a conformance
+ * pattern and become a language quirk, which belongs in `attrs`.
+ */
+import { type FrameworkCapability } from "../capabilities.ts";
+import type { ResolutionLevel } from "../ir.ts";
+import { type EdgeType, type NodeType } from "../vocabulary.ts";
+/** The wildcard target in a `forbiddenEdges` entry. See `compare.ts` for why it matters. */
+export declare const ANY_TARGET = "*";
+export interface GoldenNode {
+    readonly role: string;
+    readonly type: NodeType;
+    /** Asserts two roles resolve to nodes in the same file. Compares `node.file`. */
+    readonly sameFileAs?: string;
+    readonly attrs?: Readonly<Record<string, unknown>>;
+}
+export interface GoldenEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly type: EdgeType;
+    /** Lowest level at which the edge MUST be present. Absence below it is correct. */
+    readonly requiredAtResolution?: ResolutionLevel;
+    readonly attrs?: Readonly<Record<string, unknown>>;
+}
+export interface GoldenForbiddenEdge {
+    readonly from: string;
+    /** A role, or `ANY_TARGET` — the licence to look outside the role-bound set. */
+    readonly to: string;
+    readonly type: EdgeType;
+    readonly atAnyResolution?: boolean;
+}
+/**
+ * A role the corpus declares and the adapter must NOT produce a node for.
+ *
+ * The mirror of every other role: a binding is normally an assertion that
+ * something exists, and this one asserts that nothing does. It is how the corpus
+ * states an OVER-ADMISSION trap — a call site spelled exactly like a
+ * registration whose receiver is not a router, which a name-based rule admits
+ * and a provenance-based rule refuses.
+ *
+ * Why a role rather than a literal in the golden: the trap's spelling is
+ * per-language (`mux.HandleFunc("/health", ...)`, `Preferences::get(...)`,
+ * `@mock.patch(...)`) and per-language detail belongs in the manifest. The
+ * golden names the rule; the manifest names the trap. `alternates` on the
+ * binding are every spelling a wrong adapter might give it, and any of them
+ * binding is the failure.
+ *
+ * **A corpus that declares no such role is SKIPPED, never passed.** A negative
+ * nothing can violate is decorative, and reporting it green is exactly the
+ * "green means covered" failure this corpus exists to prevent.
+ */
+export interface GoldenMustNotBind {
+    readonly role: string;
+    readonly why: string;
+}
+export interface GoldenMustNotResolveTo {
+    /** `"from_role->to_role"`, naming one of the pattern's expected edges. */
+    readonly edge: string;
+    /** The role the edge must NOT terminate at. */
+    readonly target: string;
+    readonly why: string;
+}
+export interface GoldenPattern {
+    readonly description: string;
+    readonly nodes: readonly GoldenNode[];
+    readonly edges: readonly GoldenEdge[];
+    /** Applies to this pattern's node assertions, and to edges that state no level. */
+    readonly requiredAtResolution?: ResolutionLevel;
+    /**
+     * The framework capability a language adapter alone cannot supply (§11A.8).
+     *
+     * Named rather than boolean, so an adapter that reads routes and no ORM is
+     * held to the route pattern and excused the ORM ones. See `capabilities.ts`.
+     */
+    readonly requires?: FrameworkCapability;
+    readonly forbiddenEdges?: readonly GoldenForbiddenEdge[];
+    readonly mustNotResolveTo?: GoldenMustNotResolveTo;
+    /** Roles that must bind to nothing. See `GoldenMustNotBind`. */
+    readonly mustNotBind?: readonly GoldenMustNotBind[];
+    readonly note?: string;
+}
+export interface Golden {
+    readonly version: number;
+    readonly patterns: Readonly<Record<string, GoldenPattern>>;
+}
+export declare class GoldenError extends Error {
+    readonly name = "GoldenError";
+}
+export declare function parseGolden(raw: unknown): Golden;
+export declare function loadGolden(path: string): Golden;
+/** Every role any pattern names. Used to check a manifest binds the whole corpus. */
+export declare function goldenRoles(golden: Golden): readonly string[];
+/**
+ * The roles a single pattern needs bound before it can be checked.
+ *
+ * `forbiddenEdges[].to === ANY_TARGET` contributes nothing here, which is the
+ * point of the wildcard: it names no role, so it needs none bound.
+ */
+export declare function patternRoles(pattern: GoldenPattern): readonly string[];
+//# sourceMappingURL=golden.d.ts.map

package/dist/conformance/golden.d.ts.map

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