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

package/dist/lib/catalogue/builders/data-items.js

@@ -0,0 +1,344 @@
+// Data items, supply and demand (M-ADR 0216).
+//
+//   data_items               ← docs/platform/reference/data-items.yaml (platform-owned, like events)
+//   integration_data_item    ← the integration's feature-grounding.md:
+//                                every table with a "Data Item" column anywhere in the
+//                                "Provider-to-Canonical Field Mapping" section (sub-headings
+//                                included, up to the next `##`) → supported, or partial when
+//                                its Notes begin with `partial`; and the "Data Items Not
+//                                Supplied" section → the verdict it states.
+//   feature_data_requirement ← a "Data Requirements" table in a feature spec (the spec's own
+//                                feature) or in the feature tree (a Feature column, by id or
+//                                bullet slug — tree features have no spec file).
+//
+// `unknown` is never written: it is the reading of no row. A placeholder or an empty cell
+// declares nothing — a row is evidence only when it names an item.
+import { readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { findIntegrationGroundingFile } from "./feature-grounding-walker.js";
+import { findFeatureTreeFile } from "./feature-tree-walker.js";
+export const DATA_ITEMS_FILE_REL = join("docs", "platform", "reference", "data-items.yaml");
+const SUPPLY_VERDICTS = new Set(["supported", "partial", "source-absent", "gateway-gap", "not-applicable"]);
+const NOT_SUPPLIED_VERDICTS = new Set(["partial", "source-absent", "gateway-gap", "not-applicable"]);
+const POSITIVE = new Set(["supported", "partial"]);
+const BASES = new Set(["code", "grounded", "declared", "inferred"]);
+const NECESSITIES = new Set(["required", "enhances"]);
+// ------------------------------------------------------------------ entity
+export async function buildDataItems(sddPath, findings) {
+    let raw;
+    try {
+        raw = await readFile(join(sddPath, DATA_ITEMS_FILE_REL), "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let doc;
+    try {
+        doc = parseYaml(raw);
+    }
+    catch (err) {
+        findings.add("convention", `${DATA_ITEMS_FILE_REL}: failed to parse YAML — ${err.message}`, "error");
+        return [];
+    }
+    const items = doc?.data_items;
+    if (!Array.isArray(items)) {
+        findings.add("convention", `${DATA_ITEMS_FILE_REL}: expected a top-level \`data_items:\` list — no data items read`);
+        return [];
+    }
+    const rows = [];
+    const seen = new Set();
+    for (const it of items) {
+        const o = (it ?? {});
+        const id = String(o["id"] ?? "").trim();
+        const name = String(o["name"] ?? "").trim();
+        const category = String(o["category"] ?? "").trim();
+        if (id === "" || name === "" || category === "") {
+            findings.add("convention", `${DATA_ITEMS_FILE_REL}: a data item lacks id, name or category — skipped`);
+            continue;
+        }
+        if (seen.has(id)) {
+            findings.add("divergence", `${DATA_ITEMS_FILE_REL}: data item ${id} declared twice — first kept`);
+            continue;
+        }
+        seen.add(id);
+        rows.push({
+            id,
+            name,
+            category,
+            canonical_field: String(o["canonical_field"] ?? "").trim(),
+            description: String(o["description"] ?? "").trim(),
+            source_sdd_id: "",
+        });
+    }
+    return rows;
+}
+/**
+ * The tables in the `##` section whose heading matches `section`, sub-headings included, up
+ * to the next heading of level ≤ 2. Each table carries the governing `Checked:` line: the
+ * nearest one set at its own heading level or above, cleared by the next heading of the same
+ * or higher level.
+ */
+export function tablesInSection(text, section) {
+    const lines = text.split(/\r?\n/);
+    const out = [];
+    let inSection = false;
+    let inFence = false;
+    let level = 0; // level of the most recent heading inside the section
+    const checkedAtLevel = new Map();
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const t = line.trim();
+        if (t.startsWith("```")) {
+            inFence = !inFence;
+            i++;
+            continue;
+        }
+        if (inFence) {
+            i++;
+            continue;
+        }
+        const h = /^(#{1,6})\s+(.*)$/.exec(t);
+        if (h) {
+            const lv = h[1].length;
+            if (lv <= 2) {
+                inSection = lv === 2 && section.test(h[2].trim());
+                checkedAtLevel.clear();
+            }
+            for (const k of [...checkedAtLevel.keys()])
+                if (k >= lv)
+                    checkedAtLevel.delete(k);
+            level = lv;
+            i++;
+            continue;
+        }
+        if (!inSection) {
+            i++;
+            continue;
+        }
+        if (/^Checked:/i.test(t)) {
+            checkedAtLevel.set(level, t.replace(/^Checked:\s*/i, "").trim());
+            i++;
+            continue;
+        }
+        if (t.startsWith("|") && i + 1 < lines.length && /^\|?\s*:?-{2,}/.test(lines[i + 1].trim())) {
+            const headers = splitRow(t).map((c) => c.toLowerCase());
+            const rows = [];
+            let j = i + 2;
+            while (j < lines.length && lines[j].trim().startsWith("|")) {
+                rows.push({ cells: splitRow(lines[j].trim()), line: j + 1 });
+                j++;
+            }
+            let checkedAt = "";
+            for (let lv = level; lv >= 1; lv--) {
+                const c = checkedAtLevel.get(lv);
+                if (c !== undefined) {
+                    checkedAt = c;
+                    break;
+                }
+            }
+            out.push({ headers, rows, checkedAt });
+            i = j;
+            continue;
+        }
+        i++;
+    }
+    return out;
+}
+/** Split a table row on UNESCAPED pipes (GFM): `\|` is a literal pipe inside a cell. */
+function splitRow(row) {
+    const inner = row.replace(/^\|/, "").replace(/(?<!\\)\|\s*$/, "");
+    return inner.split(/(?<!\\)\|/).map((c) => c.replace(/\\\|/g, "|").trim());
+}
+/**
+ * A row whose cell count differs from its header's was split wrongly, almost always by an unescaped
+ * `|` inside a cell. Reading it would shift every later column (an evidence cell would land in the
+ * verdict), so it is reported and skipped rather than read.
+ */
+function malformed(r, headers, rel, findings) {
+    if (r.cells.length === headers.length)
+        return false;
+    findings.add("convention", `${rel}:${r.line}: table row has ${r.cells.length} cells, its header ${headers.length} — an unescaped | inside a cell? write it as \\| — row skipped`);
+    return true;
+}
+/** A cell that names something: not empty, not a dash, not a `{placeholder}`. Backticks dropped. */
+function named(cell) {
+    const v = (cell ?? "").replace(/`/g, "").trim();
+    if (v === "" || /^[-—–]+$/.test(v) || v.includes("{"))
+        return "";
+    return v;
+}
+function col(headers, name) {
+    return headers.indexOf(name);
+}
+export async function buildIntegrationSupply(inputs) {
+    if (inputs.integrationId === "")
+        return [];
+    const path = await findIntegrationGroundingFile(inputs.sddPath);
+    if (!path)
+        return [];
+    const rel = relative(inputs.sddPath, path);
+    const text = await readFile(path, "utf-8");
+    const rows = [];
+    const add = (item, verdict, basis, evidence, checkedAt) => {
+        rows.push({
+            id: `${inputs.integrationId}::${item}::${evidence}`,
+            integration_id: inputs.integrationId,
+            data_item_id: item,
+            verdict,
+            basis,
+            evidence_ref: evidence,
+            checked_at: checkedAt,
+            source_sdd_id: "",
+        });
+    };
+    for (const tbl of tablesInSection(text, /^Provider-to-Canonical Field Mapping\b/i)) {
+        const di = col(tbl.headers, "data item");
+        if (di < 0)
+            continue;
+        const notes = col(tbl.headers, "notes");
+        const basisCol = col(tbl.headers, "basis");
+        for (const r of tbl.rows) {
+            if (malformed(r, tbl.headers, rel, inputs.findings))
+                continue;
+            const item = named(r.cells[di]);
+            if (item === "")
+                continue;
+            const verdict = notes >= 0 && /^partial\b/i.test(r.cells[notes] ?? "") ? "partial" : "supported";
+            add(item, verdict, basisOf(r.cells[basisCol], rel, r.line, inputs.findings), `${rel}:${r.line}`, tbl.checkedAt);
+        }
+    }
+    for (const tbl of tablesInSection(text, /^Data Items Not Supplied\b/i)) {
+        const di = col(tbl.headers, "data item");
+        const vc = col(tbl.headers, "verdict");
+        if (di < 0 || vc < 0) {
+            inputs.findings.add("convention", `${rel}: a "Data Items Not Supplied" table needs Data Item and Verdict columns — table skipped`);
+            continue;
+        }
+        const basisCol = col(tbl.headers, "basis");
+        const evCol = col(tbl.headers, "evidence");
+        for (const r of tbl.rows) {
+            if (malformed(r, tbl.headers, rel, inputs.findings))
+                continue;
+            const item = named(r.cells[di]);
+            if (item === "")
+                continue;
+            const verdict = named(r.cells[vc]).toLowerCase();
+            if (!NOT_SUPPLIED_VERDICTS.has(verdict)) {
+                inputs.findings.add("convention", `${rel}:${r.line}: data item ${item} — verdict "${verdict}" is not one of ${[...NOT_SUPPLIED_VERDICTS].join(", ")} (a supplied item belongs in the mapping table; unknown is never written) — row skipped`);
+                continue;
+            }
+            const ev = named(r.cells[evCol]) || `${rel}:${r.line}`;
+            add(item, verdict, basisOf(r.cells[basisCol], rel, r.line, inputs.findings), ev, tbl.checkedAt);
+        }
+    }
+    // @rule gate-supply-contradiction
+    // Several rows per item are normal; a positive and a negative row for one item contradict.
+    const byItem = new Map();
+    for (const r of rows)
+        byItem.set(String(r["data_item_id"]), [...(byItem.get(String(r["data_item_id"])) ?? []), r]);
+    for (const [item, rs] of byItem) {
+        const pos = rs.filter((r) => POSITIVE.has(String(r["verdict"])));
+        const neg = rs.filter((r) => !POSITIVE.has(String(r["verdict"])));
+        if (pos.length && neg.length) {
+            inputs.findings.add("divergence", `${rel}: data item ${item} is stated both supplied (${pos.map((r) => `${r["verdict"]} @ ${r["evidence_ref"]}`).join("; ")}) and not supplied (${neg.map((r) => `${r["verdict"]} @ ${r["evidence_ref"]}`).join("; ")}) — resolve one; coverage never picks a winner between them (M-ADR 0216 §4.2)`, "error", `data_item:${item}`);
+        }
+    }
+    return dedupe(rows);
+}
+function basisOf(cell, rel, line, findings) {
+    const b = named(cell).toLowerCase();
+    if (b === "")
+        return "";
+    if (!BASES.has(b)) {
+        findings.add("convention", `${rel}:${line}: basis "${b}" is not one of ${[...BASES].join(", ")} — left empty`);
+        return "";
+    }
+    return b;
+}
+function dedupe(rows) {
+    const seen = new Set();
+    return rows.filter((r) => {
+        const k = String(r["id"]);
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+export async function buildFeatureDemand(inputs) {
+    const rows = [];
+    const section = /^Data Requirements\b/i;
+    const read = async (rel, ownFeature) => {
+        let text;
+        try {
+            text = await readFile(join(inputs.sddPath, rel), "utf-8");
+        }
+        catch {
+            return;
+        }
+        for (const tbl of tablesInSection(text, section)) {
+            const di = col(tbl.headers, "data item");
+            const nc = col(tbl.headers, "necessity");
+            const fc = col(tbl.headers, "feature");
+            if (di < 0 || nc < 0) {
+                inputs.findings.add("convention", `${rel}: a "Data Requirements" table needs Data Item and Necessity columns — table skipped`);
+                continue;
+            }
+            const gc = col(tbl.headers, "alternative group");
+            const bc = col(tbl.headers, "basis");
+            for (const r of tbl.rows) {
+                if (malformed(r, tbl.headers, rel, inputs.findings))
+                    continue;
+                const item = named(r.cells[di]);
+                if (item === "")
+                    continue;
+                let feature = ownFeature;
+                if (fc >= 0) {
+                    const f = named(r.cells[fc]);
+                    if (f !== "")
+                        feature = inputs.knownFeatureIds.has(f) ? f : (inputs.idBySlug.get(f) ?? "");
+                    if (feature === "") {
+                        inputs.findings.add("orphan", `${rel}:${r.line}: Data Requirements feature "${f}" is neither a feature id nor a feature slug of this SDD — row skipped`);
+                        continue;
+                    }
+                }
+                if (feature === "") {
+                    inputs.findings.add("convention", `${rel}:${r.line}: a Data Requirements row outside a feature spec needs a Feature column — row skipped`);
+                    continue;
+                }
+                const necessity = named(r.cells[nc]).toLowerCase();
+                if (!NECESSITIES.has(necessity)) {
+                    inputs.findings.add("convention", `${rel}:${r.line}: necessity "${necessity}" is not required or enhances — row skipped`);
+                    continue;
+                }
+                rows.push({
+                    id: `${feature}::${item}`,
+                    feature_id: feature,
+                    data_item_id: item,
+                    necessity,
+                    alternative_group: named(r.cells[gc]),
+                    basis_ref: named(r.cells[bc]) || `${rel}:${r.line}`,
+                    source_sdd_id: "",
+                });
+            }
+        }
+    };
+    for (const [rel, id] of [...inputs.idByPath].sort(([a], [b]) => a.localeCompare(b)))
+        await read(rel, id);
+    const tree = await findFeatureTreeFile(inputs.sddPath);
+    if (tree)
+        await read(relative(inputs.sddPath, tree), "");
+    const seen = new Map();
+    for (const r of rows) {
+        const k = String(r["id"]);
+        if (seen.has(k)) {
+            inputs.findings.add("divergence", `feature ${r["feature_id"]} states its need for ${r["data_item_id"]} twice (${seen.get(k)["basis_ref"]}, ${r["basis_ref"]}) — first kept`);
+            continue;
+        }
+        seen.set(k, r);
+    }
+    return [...seen.values()];
+}
+//# sourceMappingURL=data-items.js.map

package/dist/lib/catalogue/builders/data-store-mapping.js

@@ -0,0 +1,113 @@
+// Shared parsing primitives for the `## Data Store Mapping` markdown table
+// that reverse-method adopters author in
+// `docs/domains/<domain>/architecture/data-model.mermaid.md`.
+//
+// Extracted so two consumers share one parser (ADR 0164):
+//   - service-entity-tables.ts — emits service_entity edges from the
+//     Entity + Owning Service columns (relation=owns).
+//   - entity-persistence.ts — backfills entities.persistence_kind from the
+//     Store column.
+//
+// The Store column is reverse-only: forward-method adopters author a
+// store-less table (Entity | Owning Service | Notes), so detectColumn returns
+// -1 for `store` there and persistence_kind stays empty (correctly).
+import { entitySlug } from "./entity-slug.js";
+export const RE_DATA_STORE_HEADING = /^##\s+Data Store\s+(Mapping|Inventory)\s*$/i;
+/**
+ * Locate the first `## Data Store Mapping`/`Inventory` table in the file and
+ * return its split headers + data rows. Returns null when the heading is
+ * absent or no markdown table follows it (callers decide whether that's a
+ * finding).
+ */
+export function findDataStoreTable(text) {
+    const lines = text.split(/\r?\n/);
+    const headingIdx = lines.findIndex((l) => RE_DATA_STORE_HEADING.test(l));
+    if (headingIdx === -1)
+        return null;
+    const tableLines = collectTableLines(lines, headingIdx + 1);
+    if (tableLines === null || tableLines.length < 2)
+        return null;
+    const headers = splitRow(tableLines[0]);
+    const dataRows = [];
+    // tableLines[1] is the |---|---| separator; data rows start at index 2.
+    for (let i = 2; i < tableLines.length; i++)
+        dataRows.push(splitRow(tableLines[i]));
+    return { headers, dataRows };
+}
+/** Index of the first header (lowercased) satisfying `match`, or -1. */
+export function detectColumn(headers, match) {
+    for (let i = 0; i < headers.length; i++) {
+        if (match(headers[i].toLowerCase()))
+            return i;
+    }
+    return -1;
+}
+/** Strip a trailing parenthetical annotation: "Role (fleet)" → "Role". */
+export function normaliseEntity(entityText) {
+    return entityText.replace(/\s*\([^)]+\)\s*$/, "").trim();
+}
+export function splitRow(line) {
+    // Strip leading/trailing `|`, split on `|`, trim cells.
+    const trimmed = line.trim();
+    const parts = trimmed.split("|");
+    return parts.slice(1, parts.length - 1).map((c) => c.trim());
+}
+export function collectTableLines(lines, startIdx) {
+    let i = startIdx;
+    while (i < lines.length) {
+        const l = lines[i] ?? "";
+        if (l.startsWith("## "))
+            return null;
+        if (l.trimStart().startsWith("|")) {
+            const out = [];
+            while (i < lines.length && lines[i].trimStart().startsWith("|")) {
+                out.push(lines[i]);
+                i++;
+            }
+            return out;
+        }
+        i++;
+    }
+    return null;
+}
+// ADR 0164: map a Data Store Mapping `Store` cell (a physical engine such as
+// "MySQL (fleet-db)", "MongoDB", "DynamoDB", "Kinesis") to the canonical
+// `entities.persistence_kind` classification. This mirrors the services
+// builder's deriveLanguage (a normalised token derived from a raw cell) —
+// faithful classification, not a verbatim engine. The raw engine string is
+// preserved by the caller in `notes`.
+const PERSISTENCE_KIND_RULES = [
+    [
+        /\b(mysql|mariadb|postgres|postgresql|aurora|oracle|mssql|sqlserver|sql server|rds|relational)\b/,
+        "relational-table",
+    ],
+    [
+        /\b(mongodb|mongo|dynamodb|dynamo|documentdb|cosmos|couchbase|couchdb|firestore)\b/,
+        "document-collection",
+    ],
+    [
+        /\b(kinesis|kafka|activemq|rabbitmq|sqs|sns|eventbridge|nats|pubsub|stream|queue|topic)\b/,
+        "event-payload",
+    ],
+    // Transient / in-memory state (not a system of record) — the schema's
+    // `dto` classification. Real-world values: "In-memory (Vuex)",
+    // "Transient (API response)", "Runtime (Vue plugin)".
+    [/\b(in-memory|transient|ephemeral|runtime)\b/, "dto"],
+];
+/** Cells that mean "no store", treated as empty. */
+const NULL_STORE = new Set(["", "n/a", "na", "-", "—", "none", "tbd"]);
+export function derivePersistenceKind(store) {
+    const s = store.trim().toLowerCase();
+    if (NULL_STORE.has(s))
+        return { kind: "", recognised: true };
+    for (const [re, kind] of PERSISTENCE_KIND_RULES) {
+        if (re.test(s))
+            return { kind, recognised: true };
+    }
+    // Present but unmapped (e.g. Elasticsearch, in-memory/Vuex) → a valid
+    // recommended value, but flagged so the rule set can grow.
+    return { kind: "other", recognised: false };
+}
+// Re-export so callers needing the entity-aware slug import from one place.
+export { entitySlug };
+//# sourceMappingURL=data-store-mapping.js.map

package/dist/lib/catalogue/builders/domain-models.js

@@ -0,0 +1,175 @@
+// Node builder for domain_models — emits `domain_models.csv` rows.
+//
+// Platform-profile only. Non-platform SDDs return an empty list.
+//
+// Sources (combined; deduplicated by domain_id):
+//   - Forward: scan loaded traceability manifests for
+//     `traceability.domain_model.path`. The capability's domain (from the
+//     manifest's `capability.domain` or path) determines `domain_id`.
+//   - Reverse: scan `docs/domains/<domain>/architecture/data-model.mermaid.md`
+//     and, since schema 3.11.0, `data-model.tql` beside it (M-ADR 0210 §4.6
+//     Decision 2). Presence-only — content is not parsed in this phase.
+//
+// `notation` (3.11.0) is DERIVED from the artefact's filename — mermaid-erd or
+// typeql — never authored. It is Decision 2's compliance instrument: every
+// build reports `[metric] domain_models: rows=N typeql=T mermaid-erd=M`, and a
+// mermaid-erd row is a `convention` finding, advisory before the sunset
+// (2027-03-31) and an error at the first build after it.
+//
+// One row per unique domain_id. If forward declares a path AND reverse
+// finds a file for the same domain, the forward entry wins (the manifest
+// is the declarative source) and the reverse check is silent unless the
+// paths disagree, in which case a `[finding] divergence` is emitted.
+//
+// Added in schema 2.4.0 per ADR 0142.
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { extractFileEvidenceClass } from "./evidence-class.js";
+const DOMAINS_DIR_REL = join("docs", "domains");
+const DATA_MODEL_FILENAME = "data-model.mermaid.md";
+const DATA_MODEL_TQL_FILENAME = "data-model.tql";
+/** M-ADR 0210 §4.6 Decision 2 (as amended 2026-09-18): the first build after this date fails on a mermaid-erd model. */
+export const DECISION_2_SUNSET = "2027-03-31";
+/** Derived from the artefact, never authored (M-ADR 0210 §4.6). */
+export function notationOf(docPath) {
+    return /\.tql$/i.test(docPath) ? "typeql" : "mermaid-erd";
+}
+export async function buildDomainModels(inputs) {
+    if (inputs.manifest.profile !== "platform-profile") {
+        return [];
+    }
+    // Step 1: Forward — collect declared paths from traceability manifests.
+    // Multiple capabilities in the same domain may declare the same path;
+    // deduplicate by domain_id.
+    const declaredByDomain = new Map();
+    for (const m of inputs.manifests) {
+        const dm = m.traceability.domain_model;
+        if (!dm)
+            continue;
+        const domainId = m.capability.domain;
+        if (!domainId || !inputs.knownDomainIds.has(domainId))
+            continue;
+        const existing = declaredByDomain.get(domainId);
+        if (existing && existing.path !== dm.path) {
+            inputs.findings.add("divergence", `domain_model.path for domain "${domainId}": "${existing.path}" vs "${dm.path}" — using first declaration`);
+            continue;
+        }
+        declaredByDomain.set(domainId, {
+            path: dm.path,
+            ...(dm.version ? { version: dm.version } : {}),
+        });
+    }
+    // Step 2: Reverse — scan filesystem for data-model.mermaid.md per domain.
+    // Domains without a forward declaration that have a file get a row;
+    // domains with both get a divergence finding if paths disagree.
+    const fsByDomain = await scanFilesystemModels(inputs.sddPath, inputs.findings);
+    for (const [domainId, fsPath] of fsByDomain) {
+        if (!inputs.knownDomainIds.has(domainId))
+            continue;
+        const declared = declaredByDomain.get(domainId);
+        if (!declared) {
+            declaredByDomain.set(domainId, { path: fsPath });
+            continue;
+        }
+        if (normalisePath(declared.path) !== normalisePath(fsPath)) {
+            inputs.findings.add("divergence", `domain_model for "${domainId}": traceability declares "${declared.path}" but file found at "${fsPath}"`);
+        }
+    }
+    // Step 3: Coverage finding for domains with no model at all.
+    for (const domainId of inputs.knownDomainIds) {
+        if (!declaredByDomain.has(domainId)) {
+            inputs.findings.add("coverage", `no domain_model for domain "${domainId}" — neither traceability declares nor file exists`);
+        }
+    }
+    // Step 4: Emit rows sorted by id for determinism. `evidence_class` reads
+    // from the model file's leading ```yaml fence (`evidence-class:`) per the
+    // documentation-reverse anchor convention (ADR 0175); absent file or
+    // declaration → "".
+    const rows = [];
+    for (const [domainId, model] of declaredByDomain) {
+        rows.push({
+            id: `${domainId}-data-model`,
+            name: `${titleCase(domainId)} Domain Model`,
+            domain_id: domainId,
+            doc_path: model.path,
+            version: model.version ?? "",
+            evidence_class: await readEvidenceClass(inputs.sddPath, model.path),
+            source_sdd_id: "",
+            notation: notationOf(model.path),
+        });
+    }
+    const sorted = rows.sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+    // Decision 2's instrument (M-ADR 0210 §4.6 as amended): a number that moves, and one finding.
+    const typeql = sorted.filter((r) => r["notation"] === "typeql").length;
+    const mermaid = sorted.length - typeql;
+    inputs.findings.add("metric", `domain_models: rows=${sorted.length} typeql=${typeql} mermaid-erd=${mermaid}`);
+    const today = inputs.today ?? new Date().toISOString().slice(0, 10);
+    const pastSunset = today > DECISION_2_SUNSET;
+    for (const r of sorted) {
+        if (r["notation"] !== "mermaid-erd")
+            continue;
+        inputs.findings.add("convention", `domain_models: "${String(r["id"])}" is in mermaid-erd ${pastSunset ? "after" : "before"} the Decision-2 sunset (${DECISION_2_SUNSET}) — migrate at the next requirements pass (M-ADR 0210 §4.6)`, pastSunset ? "error" : "warn");
+    }
+    return sorted;
+}
+async function scanFilesystemModels(sddPath, findings) {
+    const result = new Map();
+    const domainsDir = join(sddPath, DOMAINS_DIR_REL);
+    let entries;
+    try {
+        entries = await readdir(domainsDir, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return result;
+        throw err;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        // Both notations are looked for; the TypeQL artefact wins when both exist,
+        // because after migration the diagram is a generated projection of it
+        // (M-ADR 0210 §4.1) and the model's notation is the authored one.
+        for (const filename of [DATA_MODEL_TQL_FILENAME, DATA_MODEL_FILENAME]) {
+            if (result.has(entry.name))
+                break;
+            const candidate = join(domainsDir, entry.name, "architecture", filename);
+            try {
+                const s = await stat(candidate);
+                if (s.isFile()) {
+                    result.set(entry.name, join(DOMAINS_DIR_REL, entry.name, "architecture", filename));
+                }
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== "ENOENT") {
+                    findings.add("convention", `failed to stat ${candidate}: ${err.message}`);
+                }
+            }
+        }
+    }
+    return result;
+}
+async function readEvidenceClass(sddPath, docPath) {
+    const abs = docPath.startsWith("/") ? docPath : join(sddPath, docPath);
+    let text;
+    try {
+        text = await readFile(abs, "utf-8");
+    }
+    catch {
+        // Forward-declared paths may not exist on disk; absence → empty.
+        return "";
+    }
+    return extractFileEvidenceClass(text);
+}
+function normalisePath(p) {
+    return p.replace(/^\.\//, "").replace(/\\/g, "/");
+}
+function titleCase(slug) {
+    return slug
+        .split(/[-_]/)
+        .map((s) => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s))
+        .join(" ");
+}
+//# sourceMappingURL=domain-models.js.map