@sdd-method/verify-cli 0.1.0

package/dist/lib/catalogue/gate-checks.js

@@ -0,0 +1,338 @@
+/**
+ * Phase-0 gate checks as SQL — M-ADR 0205 §4.4 (engine-evolution Phase A3,
+ * final tranche). The nine small catalogue-integrity-gate steps
+ * re-expressed on the engine: emptiness-vs-populated-inputs signals
+ * (repo-edges 0157, data-model-entities 0159, capability-event 0160,
+ * feature-event 0161, platform-dependencies 0162, glossary-xref 0158),
+ * the per-domain event-catalogue count compare (0156), and the two
+ * features.csv Phase-0 checks (0177 F1 promotion, F2 near-duplicate
+ * surfaces — the classified borderline: engine for access, the token
+ * Jaccard stays host-language).
+ *
+ * The shell scripts remain the REFERENCE implementations until A4. Known,
+ * deliberate divergence class: several references read CSV columns
+ * POSITIONALLY with a naive comma split (`awk -F, $5`) and count PHYSICAL
+ * lines rather than CSV records — this port reads by column name over
+ * parsed records. Where real data makes those disagree, the dual-run
+ * driver surfaces it and the adjudication is a defect in the shell side
+ * (the exact matcher-error class M-ADR 0205 §1 exists to kill), never a
+ * smoothing of this side.
+ *
+ * File and YAML ingestion stay host-side, mirroring each reference's
+ * refusal semantics (a missing key, an unparseable document, an absent
+ * tool each behave exactly as the reference behaves).
+ */
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+async function scalar(session, sql) {
+    const reader = await session.conn.runAndReadAll(sql);
+    return Number(reader.getRows()[0][0]);
+}
+const count = (table, where = "") => `SELECT COUNT(*) FROM "${table}"${where ? ` WHERE ${where}` : ""};`;
+// @rule gate-event-catalogue
+export async function runEventCatalogueCheck(session, options) {
+    if (!options.eventsPresent)
+        return { skipped: true, gaps: [] };
+    const domainsDir = join(options.sddRoot, "docs", "domains");
+    if (!existsSync(domainsDir))
+        return { skipped: false, gaps: [] };
+    const gaps = [];
+    for (const domain of readdirSync(domainsDir).sort()) {
+        const catalogPath = join(domainsDir, domain, "contracts", "events", "event-catalog.yaml");
+        if (!existsSync(catalogPath))
+            continue;
+        // Mirror of `yq '.events | length' || echo 0`: missing key or null → 0,
+        // an array → its length, a mapping → its key count, unparseable → 0.
+        let declared = 0;
+        try {
+            const doc = parseYaml(readFileSync(catalogPath, "utf-8"));
+            const events = doc?.["events"];
+            if (Array.isArray(events))
+                declared = events.length;
+            else if (events !== null && events !== undefined && typeof events === "object")
+                declared = Object.keys(events).length;
+        }
+        catch {
+            declared = 0;
+        }
+        if (declared <= 0)
+            continue;
+        const emitted = await scalar(session, count("events", `COALESCE("domain_id", '') = '${domain.replace(/'/g, "''")}'`));
+        if (emitted < declared)
+            gaps.push({ domain, declared, emitted });
+    }
+    return { skipped: false, gaps };
+}
+// @rule gate-repo-edges
+export async function runRepoEdgesCheck(session, options) {
+    const repoCaps = await scalar(session, count("repo_capability"));
+    const capSvcs = await scalar(session, count("capability_service"));
+    const svcsWithRepo = await scalar(session, count("services", `COALESCE("primary_repo_id", '') <> ''`));
+    const repoContracts = await scalar(session, count("repo_contract"));
+    const contracts = await scalar(session, count("contracts"));
+    const svcContracts = await scalar(session, count("service_contract"));
+    // Mirror of the reference's two glob patterns (bash without globstar:
+    // `**` collapses to one level) — direct files AND one directory deep,
+    // schema.yaml deliberately NOT excluded because the reference scans it.
+    let repoConfigsWithContracts = 0;
+    const cfgDir = join(options.sddRoot, "orchestration", "repo-config");
+    if (existsSync(cfgDir)) {
+        const candidates = [];
+        for (const entry of readdirSync(cfgDir, { withFileTypes: true })) {
+            const p = join(cfgDir, entry.name);
+            if (entry.isFile() && entry.name.endsWith(".yaml"))
+                candidates.push(p);
+            else if (entry.isDirectory()) {
+                for (const f of readdirSync(p)) {
+                    if (f.endsWith(".yaml"))
+                        candidates.push(join(p, f));
+                }
+            }
+        }
+        for (const p of candidates) {
+            if (/^contracts:/m.test(readFileSync(p, "utf-8")))
+                repoConfigsWithContracts++;
+        }
+    }
+    return {
+        ...(repoCaps === 0 && capSvcs > 0 && svcsWithRepo > 0
+            ? { repoCapabilityGap: { capabilityService: capSvcs, servicesWithRepo: svcsWithRepo } }
+            : {}),
+        ...(repoContracts === 0 && contracts > 0 && repoConfigsWithContracts > 0
+            ? { repoContractForwardGap: { contracts, repoConfigsWithContracts } }
+            : {}),
+        ...(repoContracts === 0 && svcContracts > 0 && svcsWithRepo > 0
+            ? { repoContractPathXGap: { serviceContracts: svcContracts, servicesWithRepo: svcsWithRepo } }
+            : {}),
+        ...(repoContracts === 0 &&
+            contracts > 0 &&
+            repoConfigsWithContracts === 0 &&
+            svcContracts === 0
+            ? { repoContractReverseGap: { contracts } }
+            : {}),
+    };
+}
+// ─── 0158: glossary-xref ingestion gap ───────────────────────────────────
+// @rule gate-glossary-xref
+export async function runGlossaryXrefCheck(session, options) {
+    const manifest = join(options.sddRoot, "docs", "platform", "reference", "glossary-alignment-manifest.yaml");
+    if (!existsSync(manifest) || !options.xrefPresent)
+        return { finding: false };
+    const rows = await scalar(session, count("glossary_xref"));
+    return { finding: rows === 0 };
+}
+// @rule gate-data-model-entities
+export async function runDataModelEntitiesCheck(session) {
+    const domainModels = await scalar(session, count("domain_models"));
+    const entities = await scalar(session, count("entities"));
+    const services = await scalar(session, count("services"));
+    const serviceEntity = await scalar(session, count("service_entity"));
+    const containerEntity = await scalar(session, count("c4_container_entity"));
+    const containersWithService = await scalar(session, count("c4_containers", `COALESCE("service_id", '') <> ''`));
+    return {
+        ...(domainModels > 0 && entities === 0 ? { entitiesGap: { domainModels } } : {}),
+        ...(entities > 0 && services > 0 && serviceEntity === 0
+            ? { serviceEntityGap: { entities, services } }
+            : {}),
+        ...(serviceEntity > 0 && containersWithService > 0 && containerEntity === 0
+            ? { containerEntityGap: { containersWithService, serviceEntity } }
+            : {}),
+    };
+}
+// @rule gate-capability-event
+export async function runCapabilityEventCheck(session) {
+    const serviceEvent = await scalar(session, count("service_event"));
+    const capabilityService = await scalar(session, count("capability_service"));
+    const capabilityEvent = await scalar(session, count("capability_event"));
+    let authoredGap;
+    if (capabilityEvent > 0) {
+        const authored = await scalar(session, count("capability_event", `COALESCE("source", '') = 'authored'`));
+        const derived = await scalar(session, count("capability_event", `COALESCE("source", '') = 'derived'`));
+        if (authored === 0 && derived > 0)
+            authoredGap = { derived };
+    }
+    return {
+        ...(serviceEvent > 0 && capabilityService > 0 && capabilityEvent === 0
+            ? { derivableGap: { serviceEvent, capabilityService } }
+            : {}),
+        ...(authoredGap !== undefined ? { authoredGap } : {}),
+    };
+}
+// ─── 0161: feature_event derivation gap ──────────────────────────────────
+// @rule gate-feature-event
+export async function runFeatureEventCheck(session) {
+    const serviceEvent = await scalar(session, count("service_event"));
+    const featureService = await scalar(session, count("feature_service"));
+    const featureEvent = await scalar(session, count("feature_event"));
+    return serviceEvent > 0 && featureService > 0 && featureEvent === 0
+        ? { gap: { serviceEvent, featureService } }
+        : {};
+}
+// ─── 0162: forward platform-dependencies parity gap ──────────────────────
+// @rule gate-platform-dependencies
+export async function runPlatformDependenciesCheck(session, options) {
+    const forwardFile = join(options.sddRoot, "app-platform-dependencies.yaml");
+    const forwardAuthored = existsSync(forwardFile) &&
+        /^\s*platform_dependencies:/m.test(readFileSync(forwardFile, "utf-8"));
+    if (!forwardAuthored)
+        return { finding: false };
+    const ppd = await scalar(session, count("product_platform_dependencies"));
+    return { finding: ppd === 0 };
+}
+// ─── 0177 F1: feature-spec promotion ─────────────────────────────────────
+/** Python's round(): half to even — the reference computes pct with it. */
+function pythonRound(x) {
+    const floor = Math.floor(x);
+    const diff = x - floor;
+    if (diff > 0.5)
+        return floor + 1;
+    if (diff < 0.5)
+        return floor;
+    return floor % 2 === 0 ? floor : floor + 1;
+}
+// @rule gate-feature-spec-promotion
+export async function runFeatureSpecPromotionCheck(session) {
+    const reader = await session.conn.runAndReadAll(`SELECT COALESCE("source", '') FROM "features";`);
+    let total = 0;
+    let resolvable = 0;
+    let intermediate = 0;
+    for (const r of reader.getRows()) {
+        const src = String(r[0] ?? "").trim();
+        total++;
+        if (src === "feature-spec" || src === "feature-tree")
+            resolvable++;
+        else if (src === "capability-spec" || src === "feature-grounding")
+            intermediate++;
+    }
+    if (total === 0 || intermediate === 0)
+        return {};
+    return {
+        finding: {
+            intermediate,
+            total,
+            pctResolvable: pythonRound((100 * resolvable) / total),
+            note: intermediate >= resolvable ? "predominantly un-promoted" : "partially promoted",
+        },
+    };
+}
+// ─── 0177 F2: near-duplicate feature surfaces (the borderline: engine for
+//     access, the token Jaccard host-language) ───────────────────────────
+function tokens(slug) {
+    return new Set(slug.split("-").filter((t) => t !== ""));
+}
+function near(a, b) {
+    const ta = tokens(a);
+    const tb = tokens(b);
+    if (ta.size === 0 || tb.size === 0)
+        return false;
+    const inter = [...ta].filter((t) => tb.has(t)).length;
+    if (inter === ta.size || inter === tb.size)
+        return true; // subset either way
+    const union = ta.size + tb.size - inter;
+    return union > 0 && inter / union >= 0.5;
+}
+// @rule gate-feature-surface-duplication
+export async function runFeatureSurfaceDuplicationCheck(session) {
+    const reader = await session.conn.runAndReadAll(`SELECT COALESCE("capability_id", ''), COALESCE("name", ''), COALESCE("source", '') FROM "features";`);
+    const rollup = new Map();
+    const detailed = new Map();
+    for (const r of reader.getRows()) {
+        const cap = String(r[0] ?? "").trim();
+        const slug = String(r[1] ?? "").trim();
+        const src = String(r[2] ?? "").trim();
+        if (cap === "" || slug === "")
+            continue;
+        if (src === "capability-spec") {
+            rollup.set(cap, [...(rollup.get(cap) ?? []), slug]);
+        }
+        else if (src === "feature-grounding") {
+            detailed.set(cap, [...(detailed.get(cap) ?? []), slug]);
+        }
+    }
+    let pairs = 0;
+    const caps = new Set();
+    for (const [cap, rollupSlugs] of rollup) {
+        const detailedSlugs = detailed.get(cap);
+        if (!detailedSlugs)
+            continue;
+        for (const r of rollupSlugs) {
+            for (const d of detailedSlugs) {
+                if (r !== d && near(r, d)) {
+                    pairs++;
+                    caps.add(cap);
+                }
+            }
+        }
+    }
+    return pairs > 0 ? { finding: { pairs, capabilities: caps.size } } : {};
+}
+// @rule gate-relationship-coherence
+export async function runRelationshipCoherenceCheck(session) {
+    const ownedUntraced = [];
+    let reader = await session.conn.runAndReadAll(`SELECT f."id", f."capability_id" FROM "features" f
+     WHERE COALESCE(f."capability_id", '') <> ''
+       AND NOT EXISTS (SELECT 1 FROM "capability_feature" cf
+                       WHERE cf."capability_id" = f."capability_id"
+                         AND cf."feature_id" = f."id")
+     ORDER BY f."id";`);
+    for (const r of reader.getRows()) {
+        ownedUntraced.push({ featureId: String(r[0]), capabilityId: String(r[1]) });
+    }
+    const publisherDrift = [];
+    reader = await session.conn.runAndReadAll(`SELECT se."service_id", se."event_id" FROM "service_event" se
+     WHERE se."role" = 'publishes'
+       AND NOT EXISTS (SELECT 1 FROM "events" e
+                       WHERE e."id" = se."event_id"
+                         AND COALESCE(e."publisher_service_id", '') = se."service_id")
+     ORDER BY 1, 2;`);
+    for (const r of reader.getRows()) {
+        publisherDrift.push({
+            serviceId: String(r[0]),
+            eventId: String(r[1]),
+            missing: "publisher-fk",
+        });
+    }
+    reader = await session.conn.runAndReadAll(`SELECT e."publisher_service_id", e."id" FROM "events" e
+     WHERE COALESCE(e."publisher_service_id", '') <> ''
+       AND NOT EXISTS (SELECT 1 FROM "service_event" se
+                       WHERE se."role" = 'publishes'
+                         AND se."event_id" = e."id"
+                         AND se."service_id" = e."publisher_service_id")
+     ORDER BY 1, 2;`);
+    for (const r of reader.getRows()) {
+        publisherDrift.push({
+            serviceId: String(r[0]),
+            eventId: String(r[1]),
+            missing: "publishes-edge",
+        });
+    }
+    const supersessionDrift = [];
+    reader = await session.conn.runAndReadAll(`SELECT s."superseding_adr_id", s."superseded_adr_id" FROM "adr_supersedes" s
+     WHERE NOT EXISTS (SELECT 1 FROM "adrs" a
+                       WHERE a."id" = s."superseded_adr_id"
+                         AND COALESCE(a."superseded_by_id", '') = s."superseding_adr_id")
+     ORDER BY 1, 2;`);
+    for (const r of reader.getRows()) {
+        supersessionDrift.push({
+            supersedingId: String(r[0]),
+            supersededId: String(r[1]),
+            missing: "fk-backfill",
+        });
+    }
+    reader = await session.conn.runAndReadAll(`SELECT a."superseded_by_id", a."id" FROM "adrs" a
+     WHERE COALESCE(a."superseded_by_id", '') <> ''
+       AND NOT EXISTS (SELECT 1 FROM "adr_supersedes" s
+                       WHERE s."superseded_adr_id" = a."id"
+                         AND s."superseding_adr_id" = a."superseded_by_id")
+     ORDER BY 1, 2;`);
+    for (const r of reader.getRows()) {
+        supersessionDrift.push({
+            supersedingId: String(r[0]),
+            supersededId: String(r[1]),
+            missing: "edge-row",
+        });
+    }
+    return { ownedUntraced, publisherDrift, supersessionDrift };
+}
+//# sourceMappingURL=gate-checks.js.map

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

@@ -0,0 +1,329 @@
+/**
+ * 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"],
+};
+/**
+ * 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