@sdd-method/author-cli 0.0.0-stage → 0.1.0

package/dist/lib/catalogue/graph-projection.js

@@ -0,0 +1,346 @@
+/**
+ * Graph projection — `sdd-cli catalogue graph` (M-ADR 0205 §4.6, Phase C0b).
+ *
+ * Derives a typed node/edge list (JSON Lines) from built catalogues. The
+ * projection is DERIVED, never authored, never a second source of truth:
+ * regenerated on every run, digest-stamped, not committed. The derivation
+ * rule is the C0a rule table (catalogue-engine-evolution plan), keyed on
+ * the rubric-coverage-map's `kind` × the schema's FK arity:
+ *
+ *   entity (less `applications`)  → nodes, id = "<catalogue>/<pk>"
+ *   entity FK columns             → edges typed "<catalogue>.<column>"
+ *   edge, 2 FKs                   → edges, declaration order = source→target;
+ *                                   a row with an empty nullable endpoint
+ *                                   degrades to a property record, never an edge
+ *   edge, 3 FKs                   → edges with declared endpoint pairs
+ *                                   (THREE_FK_ENDPOINTS below)
+ *   edge, 1 FK                    → property records on the FK owner
+ *   `applications`                → excluded (C0a ruling 2026-08-06: filtered
+ *                                   view of products — its rows ARE product
+ *                                   rows; emitting it creates edge-less
+ *                                   shadow nodes beside the products nodes)
+ *   finding / enum kinds          → excluded (diagnostics / vocabularies)
+ *
+ * Emission reads the PARSED CSV ROWS, deliberately not an engine readback:
+ * the engine's load TRY_CASTs typed columns and silently nulls unparseable
+ * cells (a real, measured case: prose in a date-typed column). A projection
+ * that inherits cast smoothing is no longer a faithful derivation of the
+ * CSV canon. C1's impact queries run on the engine; this emission does not.
+ *
+ * Every edge endpoint and property owner MUST resolve to a node record in
+ * the same export — a dangling reference here is a defect in the projection,
+ * not a finding about the estate (the FK layer already reports those). A
+ * candidate whose endpoint does not resolve is OMITTED and COUNTED, loudly,
+ * in the header and summary: `omitted_external` for external /
+ * external-for-profiles FKs (expected at member tier, resolving at
+ * aggregate), `omitted_unresolved` for the rest (mirrors an FK-layer
+ * finding). Stub nodes are never emitted — inventing nodes is the failure
+ * mode the C0a rule exists to prevent.
+ */
+import { createHash } from "node:crypto";
+/** Node-kind catalogues excluded from projection by C0a ruling. */
+const EXCLUDED_NODE_CATALOGUES = new Set(["applications"]);
+/**
+ * Declared endpoint pairs for the three 3-FK edge catalogues (C0a).
+ * `product_platform_dependencies` is SERVICE-FIRST — the aggregator already
+ * derives product→capability (cross_sdd_platform_capability) by joining
+ * target_service_id, so a capability-first rule would emit the same
+ * relationship twice; its resolution is per-row in projectRow below.
+ */
+const THREE_FK_ENDPOINTS = {
+    system_external_dependency: ["c4_system_id", "external_system_id"],
+    cross_sdd_platform_capability: [
+        "consuming_product_id",
+        "platform_capability_id",
+    ],
+    product_platform_dependencies: null, // per-row: target_service_id, else target_capability_id
+    // schema 3.9.0 (M-ADR 0211 §4.1): the third FK, contract_id, is a PROPERTY of the
+    // capability→service dependency — the contract it is against — not an endpoint. The
+    // edge stays capability→service; the contract rides as a property.
+    capability_service: ["capability_id", "service_id"],
+    // schema 3.9.0 (M-ADR 0211) added entity_id as a third FK. M-ADR 0158 decides the
+    // edge: "entity_glossary is entity-to-term". domain_id is the row's scope, a
+    // property; a row with no entity_id degrades to a property of its glossary term.
+    entity_glossary: ["entity_id", "glossary_item_id"],
+    // schema 3.18.0 (M-ADR 0216): coverage is feature→integration; limiting_item_id is the
+    // PROPERTY that says why an unsupported pair is unsupported, not an endpoint.
+    feature_integration_support: ["feature_id", "integration_id"],
+};
+/**
+ * The catalogues a tier reads when no directory is named. The aggregate tier's
+ * data is the aggregator's output, `catalogues-aggregated/`: defaulting it to the
+ * member `catalogues/` made `--tier aggregate` run the aggregate rules over MEMBER
+ * rows — measured at a platform root, 1 reachable node instead of 2,316, a clean-
+ * looking miss of every cross-SDD consumer.
+ */
+export function defaultCataloguesDir(tier) {
+    return tier === "aggregate" ? "catalogues-aggregated" : "catalogues";
+}
+/**
+ * Kinds must cover every schema catalogue — a catalogue without a kind
+ * cannot be classified and the projection must not guess (the map is
+ * guarded method-side by the entity-scoring-coverage correspondence
+ * instance; this is the consumer-side half of that guarantee).
+ */
+export function assertKindCoverage(schema, kinds) {
+    const missing = schema.catalogues
+        .map((c) => c.name)
+        .filter((n) => !kinds.has(n));
+    if (missing.length > 0) {
+        throw new Error(`rubric-coverage-map has no kind for: ${missing.join(", ")} — ` +
+            `sync the vendored map (it must cover every schema catalogue).`);
+    }
+}
+export function projectGraph(schema, kinds, rowsByCatalogue, tier, 
+/**
+ * When provided (M-ADR 0206 §4.6), every edge record is stamped with its
+ * declared `class` and RESOLVED `impact_flow` (role-conditional flows
+ * resolve per row), so consumers need no map lookup. Additive fields; the
+ * export regenerates per run, so the format change costs one restated
+ * determinism proof.
+ */
+semantics) {
+    assertKindCoverage(schema, kinds);
+    const stampFor = (type, props) => {
+        if (semantics === undefined)
+            return {};
+        const decl = type.includes(".")
+            ? semantics.entityFks.get(type)
+            : semantics.edges.get(type);
+        if (decl === undefined) {
+            throw new Error(`graph: relationship ${type} has no declaration in the ` +
+                `rubric-coverage-map (M-ADR 0206) — sync the vendored map.`);
+        }
+        const flow = decl.impactFlow ??
+            decl.impactFlowBy.values[(props[decl.impactFlowBy.column] ?? "").trim()];
+        if (flow === undefined) {
+            throw new Error(`graph: ${type} resolves flow by column '${decl.impactFlowBy.column}' ` +
+                `but the row value is not in the declared map.`);
+        }
+        return { class: decl.class, impact_flow: flow };
+    };
+    const nodeCats = schema.catalogues.filter((c) => kinds.get(c.name) === "entity" && !EXCLUDED_NODE_CATALOGUES.has(c.name));
+    // `annotation` (M-ADR 0133 §4.2b; kinds corrected at schema 3.9.0): a single-FK assertion
+    // ABOUT one entity. It takes the same path as a 1-FK edge — a property record on the FK
+    // owner — so it joins the edge set here rather than vanishing from the projection.
+    const edgeCats = schema.catalogues.filter((c) => kinds.get(c.name) === "edge" || kinds.get(c.name) === "annotation");
+    // Pass 1 — the node set. Endpoint resolution below is against THIS
+    // export's nodes, which is exactly the per-export invariant.
+    const nodeIds = new Set();
+    const nodeLines = [];
+    for (const cat of nodeCats) {
+        for (const row of rowsByCatalogue.get(cat.name) ?? []) {
+            const key = cell(row, cat.primaryKey);
+            const id = `${cat.name}/${key}`;
+            nodeIds.add(id);
+            nodeLines.push(jsonLine({
+                t: "node",
+                id,
+                catalogue: cat.name,
+                key,
+                properties: propsOf(cat, row, new Set([cat.primaryKey])),
+            }));
+        }
+    }
+    const resolveTarget = (fk, value) => {
+        const [refCat, refCol] = fk.references.split(".");
+        // The rule resolves FK values against node PKs; a reference to a
+        // non-PK column would resolve against the wrong namespace. All 127
+        // parsed FKs reference `.id` today — guard it rather than assume it.
+        const refDef = schema.catalogues.find((c) => c.name === refCat);
+        if (refDef && refDef.primaryKey !== refCol) {
+            throw new Error(`FK ${fk.column} references non-PK column ${fk.references} — ` +
+                `the projection cannot resolve non-PK references.`);
+        }
+        const target = `${refCat}/${value}`;
+        return nodeIds.has(target) ? target : null;
+    };
+    const isExternal = (fk) => fk.external || (fk.externalForProfiles ?? []).length > 0;
+    const edgeLines = [];
+    const propertyLines = [];
+    const omissions = { external: 0, unresolved: 0 };
+    const emitEdge = (cat, row, type, sourceFk, targetFk) => {
+        const sv = cell(row, sourceFk.column);
+        const tv = cell(row, targetFk.column);
+        const source = resolveTarget(sourceFk, sv);
+        const target = resolveTarget(targetFk, tv);
+        if (source === null || target === null) {
+            const failedFk = source === null ? sourceFk : targetFk;
+            if (isExternal(failedFk))
+                omissions.external += 1;
+            else
+                omissions.unresolved += 1;
+            return;
+        }
+        const props = propsOf(cat, row, new Set([sourceFk.column, targetFk.column]));
+        edgeLines.push(jsonLine({
+            t: "edge",
+            type,
+            ...stampFor(type, props),
+            source,
+            target,
+            properties: props,
+        }));
+    };
+    const emitProperty = (cat, row, ownerFk) => {
+        const ov = cell(row, ownerFk.column);
+        const owner = ov === "" ? null : resolveTarget(ownerFk, ov);
+        if (owner === null) {
+            if (ov !== "" && isExternal(ownerFk))
+                omissions.external += 1;
+            else
+                omissions.unresolved += 1;
+            return;
+        }
+        propertyLines.push(jsonLine({
+            t: "property",
+            owner,
+            catalogue: cat.name,
+            via: ownerFk.column,
+            properties: propsOf(cat, row, new Set([ownerFk.column])),
+        }));
+    };
+    // Pass 2a — edges from edge catalogues, schema declaration order.
+    for (const cat of edgeCats) {
+        const fks = cat.foreignKeys;
+        for (const row of rowsByCatalogue.get(cat.name) ?? []) {
+            if (fks.length === 1) {
+                // Attribute table the metamodel calls an edge: the other "end" is
+                // an enum/key/name — a property record, never an edge.
+                emitProperty(cat, row, fks[0]);
+                continue;
+            }
+            let sourceFk;
+            let targetFk;
+            if (fks.length === 2) {
+                [sourceFk, targetFk] = fks;
+            }
+            else if (cat.name === "product_platform_dependencies") {
+                sourceFk = fks.find((f) => f.column === "product_id");
+                const svc = cell(row, "target_service_id");
+                const cap = cell(row, "target_capability_id");
+                const targetCol = svc !== ""
+                    ? "target_service_id"
+                    : cap !== ""
+                        ? "target_capability_id"
+                        : null;
+                if (targetCol === null) {
+                    // Neither target declared: property-only row on the product.
+                    emitProperty(cat, row, sourceFk);
+                    continue;
+                }
+                targetFk = fks.find((f) => f.column === targetCol);
+            }
+            else {
+                const pair = THREE_FK_ENDPOINTS[cat.name];
+                if (pair === undefined || pair === null) {
+                    throw new Error(`edge catalogue ${cat.name} has ${fks.length} FKs and no declared ` +
+                        `endpoint pair — extend THREE_FK_ENDPOINTS (a C0a-level decision, ` +
+                        `not a default).`);
+                }
+                sourceFk = fks.find((f) => f.column === pair[0]);
+                targetFk = fks.find((f) => f.column === pair[1]);
+            }
+            if (sourceFk === undefined || targetFk === undefined) {
+                throw new Error(`edge catalogue ${cat.name}: declared endpoint column missing from ` +
+                    `schema foreign_keys — schema and rule table disagree.`);
+            }
+            const sv = cell(row, sourceFk.column);
+            const tv = cell(row, targetFk.column);
+            if (sv === "" || tv === "") {
+                // Empty nullable endpoint: degrade to a property record on the
+                // present endpoint (screen_action is the live case — measured
+                // 2026-08-06: all 85+1,652 rows on both estates have no event_id).
+                const present = sv !== "" ? sourceFk : tv !== "" ? targetFk : null;
+                if (present === null) {
+                    omissions.unresolved += 1; // no endpoint at all — counted, never guessed
+                    continue;
+                }
+                emitProperty(cat, row, present);
+                continue;
+            }
+            emitEdge(cat, row, cat.name, sourceFk, targetFk);
+        }
+    }
+    // Pass 2b — edges carried on node rows (41 FK columns on 22 catalogues;
+    // 34–40% of all edges on the measured estates — the third of the graph
+    // the naive "edge catalogues = edges" rule drops).
+    for (const cat of nodeCats) {
+        for (const fk of cat.foreignKeys) {
+            for (const row of rowsByCatalogue.get(cat.name) ?? []) {
+                const value = cell(row, fk.column);
+                if (value === "")
+                    continue;
+                const source = `${cat.name}/${cell(row, cat.primaryKey)}`;
+                const target = resolveTarget(fk, value);
+                if (target === null) {
+                    if (isExternal(fk))
+                        omissions.external += 1;
+                    else
+                        omissions.unresolved += 1;
+                    continue;
+                }
+                edgeLines.push(jsonLine({
+                    t: "edge",
+                    type: `${cat.name}.${fk.column}`,
+                    ...stampFor(`${cat.name}.${fk.column}`, {}),
+                    source,
+                    target,
+                    properties: {},
+                }));
+            }
+        }
+    }
+    const body = [...nodeLines, ...edgeLines, ...propertyLines];
+    const bodyText = body.map((l) => `${l}\n`).join("");
+    const digest = createHash("sha256").update(bodyText, "utf8").digest("hex");
+    const counts = {
+        nodes: nodeLines.length,
+        edges: edgeLines.length,
+        properties: propertyLines.length,
+        omittedExternal: omissions.external,
+        omittedUnresolved: omissions.unresolved,
+    };
+    const header = jsonLine({
+        t: "header",
+        format: "sdd-graph/1",
+        schema_version: schema.schemaVersion,
+        tier,
+        nodes: counts.nodes,
+        edges: counts.edges,
+        properties: counts.properties,
+        omitted_external: counts.omittedExternal,
+        omitted_unresolved: counts.omittedUnresolved,
+        digest: `sha256:${digest}`,
+    });
+    return { text: `${header}\n${bodyText}`, counts, digest };
+}
+/**
+ * Row columns as a properties object: schema column order (deterministic),
+ * empty string omitted (the schema's own convention — empty means absent),
+ * excluded columns (PK / endpoint / owner) carried structurally instead.
+ * Values stay the strings the CSV canon holds — no cast, no smoothing.
+ */
+function propsOf(cat, row, exclude) {
+    const out = {};
+    for (const col of cat.columns) {
+        if (exclude.has(col.name))
+            continue;
+        const v = row[col.name];
+        const s = v === null || v === undefined ? "" : String(v);
+        if (s === "")
+            continue;
+        out[col.name] = s;
+    }
+    return out;
+}
+/** JSON.stringify with stable insertion-order keys — the whole line contract. */
+function jsonLine(obj) {
+    return JSON.stringify(obj);
+}
+/** One cell as the trimmed string the CSV canon holds ('' = absent). */
+function cell(row, column) {
+    const v = row[column];
+    return v === null || v === undefined ? "" : String(v).trim();
+}
+//# sourceMappingURL=graph-projection.js.map

package/dist/lib/catalogue/impact-run.js

@@ -0,0 +1,228 @@
+/**
+ * Transitive impact analysis — `sdd-cli catalogue impact` (M-ADR 0206 §4.6).
+ *
+ * Impact traverses the graph-projection edge set BY DECLARED SEMANTICS: every
+ * relationship carries an impact-flow token in the rubric-coverage-map
+ * (M-ADR 0206 §4.1) naming which endpoint RECEIVES impact — `toward-source`
+ * (dependency shape: a change at the target propagates to the source),
+ * `toward-target` (membership shape: a part's change reaches its whole),
+ * `both` (realisation), `none` (xref, lineage records, attributes). One
+ * relationship (`service_event`) resolves its flow per row from a named
+ * column (§4.2). The closure is the set of nodes impact can reach from the
+ * seed along declared propagation directions, computed by recursive SQL
+ * (`WITH RECURSIVE`) on the Phase A engine.
+ *
+ * THE CO-DIRECTIONALITY INVARIANT (§4.4, a condition of 0206's acceptance):
+ * the Phase C mirror-dedup heuristic is retired because under the declared
+ * tokens every true-mirror pair propagates the SAME direction. That premise
+ * is exercised, not assumed: buildImpactPropagation asserts that no node
+ * pair receives propagation in BOTH directions from two DIFFERENT
+ * single-direction relationship types, and fails loudly naming the pair and
+ * types. A single relationship declaring `both` is deliberate bidirectional
+ * coupling and is exempt; a self-referential type contributing both
+ * directions from different rows (a hierarchy cycle) is likewise exempt.
+ * A future token edit that would silently bring the undirected flood back
+ * trips this assertion instead.
+ *
+ * Cycle discipline: the recursion carries NO depth column — recursive UNION
+ * deduplicates whole rows, and a depth column makes every lap of a cycle a
+ * "new" row: the query that looks more informative is the query that never
+ * terminates. As a bare id-set the closure saturates and stops.
+ */
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readCatalogueCsv } from "./csv-reader.js";
+import { loadCanonicalSchema } from "./schema-loader.js";
+import { loadCatalogueKinds, loadRelationshipSemantics, } from "./relationship-semantics.js";
+import { defaultCataloguesDir, projectGraph, } from "./graph-projection.js";
+function resolveFlow(edge, semantics) {
+    const decl = edge.type.includes(".")
+        ? semantics.entityFks.get(edge.type)
+        : semantics.edges.get(edge.type);
+    if (decl === undefined) {
+        throw new Error(`impact: relationship ${edge.type} has no declaration in the ` +
+            `rubric-coverage-map (M-ADR 0206) — sync the vendored map.`);
+    }
+    if (decl.impactFlow !== undefined)
+        return decl.impactFlow;
+    const by = decl.impactFlowBy;
+    const value = (edge.properties?.[by.column] ?? "").trim();
+    const flow = by.values[value];
+    if (flow === undefined) {
+        throw new Error(`impact: ${edge.type} resolves flow by column '${by.column}' but row ` +
+            `value '${value}' is not in the declared map — extend the ` +
+            `declaration or fix the row.`);
+    }
+    return flow;
+}
+/**
+ * Resolve every declared edge into propagation steps per its flow, and
+ * exercise the §4.4 co-directionality invariant.
+ */
+export function buildImpactPropagation(edges, semantics) {
+    const out = [];
+    const byFlow = new Map();
+    let flowNone = 0;
+    const pairs = new Map();
+    const notePair = (from, to, type) => {
+        const [a, b] = from < to ? [from, to] : [to, from];
+        const key = `${a}␟${b}`;
+        let rec = pairs.get(key);
+        if (rec === undefined) {
+            rec = { ab: new Set(), ba: new Set() };
+            pairs.set(key, rec);
+        }
+        (from === a ? rec.ab : rec.ba).add(type);
+    };
+    for (const e of edges) {
+        const flow = resolveFlow(e, semantics);
+        byFlow.set(flow, (byFlow.get(flow) ?? 0) + 1);
+        if (flow === "none") {
+            flowNone += 1;
+            continue;
+        }
+        if (flow === "toward-source" || flow === "both") {
+            out.push({ from: e.target, to: e.source, type: e.type });
+            notePair(e.target, e.source, e.type);
+        }
+        if (flow === "toward-target" || flow === "both") {
+            out.push({ from: e.source, to: e.target, type: e.type });
+            notePair(e.source, e.target, e.type);
+        }
+    }
+    // §4.4 invariant, refined on measured data (2026-08-06): a pair fails only
+    // when one type contributes EXCLUSIVELY a→b against another contributing
+    // EXCLUSIVELY b→a. A type that itself spans both directions on the pair —
+    // opposing role-rows of a role-conditional relationship (a service that
+    // publishes AND consumes the same event: five real pairs on the reverse
+    // estate, one service, all session-broadcast shaped), a self-referential
+    // hierarchy cycle, or a declared `both` flow — has DECLARED that pair
+    // bidirectional, so other types aligning with either direction are
+    // consistent with declarations, not drift. The flipped-token flood shape
+    // (two single-direction declarations opposing) still fails, loudly.
+    for (const [key, rec] of pairs) {
+        const abOnly = [...rec.ab].filter((t) => !rec.ba.has(t));
+        const baOnly = [...rec.ba].filter((t) => !rec.ab.has(t));
+        if (abOnly.length > 0 && baOnly.length > 0) {
+            const [a, b] = key.split("␟");
+            throw new Error(`impact: counter-directional reciprocal pair (M-ADR 0206 §4.4): ` +
+                `${abOnly[0]} propagates ${a} -> ${b} while ${baOnly[0]} propagates ` +
+                `${b} -> ${a}, and neither declares the pair bidirectional. The ` +
+                `declared tokens have re-created an undirected pair; fix the ` +
+                `classification before trusting any closure.`);
+        }
+    }
+    return { edges: out, flowNone, byFlow };
+}
+function sqlStringLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+ * Closure of `seed` over resolved propagation edges, on the engine.
+ * Exported for the fixture controls; the verb goes through runCatalogueImpact.
+ */
+export async function computeImpactClosure(propagation, seed) {
+    const { DuckDBInstance } = await import("@duckdb/node-api");
+    const instance = await DuckDBInstance.create(":memory:");
+    const conn = await instance.connect();
+    try {
+        await conn.run(`CREATE TABLE prop (f VARCHAR, t VARCHAR);`);
+        const CHUNK = 500;
+        for (let i = 0; i < propagation.length; i += CHUNK) {
+            const tuples = propagation
+                .slice(i, i + CHUNK)
+                .map((e) => `(${sqlStringLiteral(e.from)}, ${sqlStringLiteral(e.to)})`)
+                .join(",\n");
+            await conn.run(`INSERT INTO prop VALUES\n${tuples};`);
+        }
+        const seedLit = sqlStringLiteral(seed);
+        // CYCLE GUARD: the recursion carries NO depth column, deliberately.
+        // Recursive UNION deduplicates whole rows; a depth column makes every
+        // lap around a cycle a "new" row (same id, bigger depth), so the query
+        // that looks more informative is the query that never terminates — the
+        // catalogue graph is not a DAG. As a bare id-set the closure saturates
+        // and stops.
+        const reader = await conn.runAndReadAll(`WITH RECURSIVE reach(id) AS (\n` +
+            `  SELECT t FROM prop WHERE f = ${seedLit}\n` +
+            `  UNION\n` +
+            `  SELECT p.t FROM prop p JOIN reach r ON p.f = r.id\n` +
+            `)\n` +
+            `SELECT DISTINCT id FROM reach WHERE id <> ${seedLit} ORDER BY id;`);
+        return reader.getRows().map((row) => String(row[0]));
+    }
+    finally {
+        conn.disconnectSync();
+    }
+}
+export async function runCatalogueImpact(inputs, write) {
+    const sddRoot = resolve(inputs.sddPath ?? process.cwd());
+    const tier = inputs.tier ?? "member";
+    const dir = resolve(sddRoot, inputs.cataloguesDir ?? defaultCataloguesDir(tier));
+    if (!existsSync(dir)) {
+        write(`catalogues directory not found at ${dir}\n` +
+            `  Run \`sdd-cli catalogue build\` (or aggregate) first.\n`);
+        return { exitCode: 2 };
+    }
+    const schema = await loadCanonicalSchema();
+    const kinds = await loadCatalogueKinds();
+    const semantics = await loadRelationshipSemantics();
+    const rowsByCatalogue = new Map();
+    for (const cat of schema.catalogues) {
+        const filePath = join(dir, `${cat.name}.csv`);
+        if (!existsSync(filePath))
+            continue;
+        rowsByCatalogue.set(cat.name, (await readCatalogueCsv(filePath)).rows);
+    }
+    const projection = projectGraph(schema, kinds, rowsByCatalogue, tier);
+    const lines = projection.text.trimEnd().split("\n");
+    const nodeIds = new Set();
+    const edges = [];
+    for (const line of lines) {
+        const o = JSON.parse(line);
+        if (o.t === "node")
+            nodeIds.add(o.id);
+        else if (o.t === "edge")
+            edges.push({
+                source: o.source,
+                target: o.target,
+                type: o.type,
+                ...(o.properties !== undefined ? { properties: o.properties } : {}),
+            });
+    }
+    if (!nodeIds.has(inputs.of)) {
+        write(`node not found in the projection: ${inputs.of}\n` +
+            `  Node ids have the form "<catalogue>/<id>", e.g. contracts/orders-api.\n`);
+        return { exitCode: 2 };
+    }
+    const prop = buildImpactPropagation(edges, semantics);
+    const closure = await computeImpactClosure(prop.edges, inputs.of);
+    const byCatalogue = new Map();
+    for (const id of closure) {
+        const cat = id.slice(0, id.indexOf("/"));
+        byCatalogue.set(cat, (byCatalogue.get(cat) ?? 0) + 1);
+    }
+    write(`impact closure of ${inputs.of} (${tier} tier, schema ${schema.schemaVersion})\n`);
+    // Required stated lines (M-ADR 0206 §4.6): what the number means, and what
+    // was traversed under each declared flow — visible per run, not
+    // discoverable from the code.
+    write(`  semantics: change impact over classified relationships (M-ADR 0206) —\n` +
+        `    each relationship traversed per its declared impact-flow; the\n` +
+        `    co-directionality invariant is asserted on every run\n`);
+    const flowCounts = [...prop.byFlow.entries()]
+        .sort()
+        .map(([f, n]) => `${f}=${n}`)
+        .join("  ");
+    write(`  declared edges by resolved flow: ${flowCounts}\n`);
+    write(`  reachable nodes: ${closure.length}\n`);
+    for (const [cat, n] of [...byCatalogue.entries()].sort()) {
+        write(`    ${cat}: ${n}\n`);
+    }
+    for (const id of closure) {
+        write(`  ${id}\n`);
+    }
+    return {
+        exitCode: 0,
+        result: { seed: inputs.of, closure, byCatalogue },
+    };
+}
+//# sourceMappingURL=impact-run.js.map