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

package/dist/lib/catalogue/traceability-loader.js

@@ -0,0 +1,350 @@
+// Traceability manifest loader — walks `docs/domains/**​/*.traceability.yaml`
+// and returns parsed declarations.
+//
+// The traceability manifest is per-capability declarative metadata that
+// the canonical builder reads to populate `capabilities.csv` and the
+// five capability_* edge catalogues (services, adrs, features,
+// contracts, events). One YAML per capability; the canonical layout is
+// `docs/domains/{domain}/product/{capability}.traceability.yaml`.
+//
+// Schema reference: docs/method/methods/capability-traceability-manifest-template.yaml
+// in sdd-method (per ADR 0047 / capability-spec-template.md).
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+const DOMAINS_DIR_REL = join("docs", "domains");
+/**
+ * Normalise an authored `feature_directory` value (string, list of strings,
+ * or absent) to a clean `string[]`. Non-string entries and empties are
+ * dropped. Lets a capability declare one or several feature dirs.
+ */
+export function normalizeFeatureDirs(value) {
+    if (typeof value === "string") {
+        return value.trim() === "" ? [] : [value];
+    }
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === "string" && v.trim() !== "");
+    }
+    return [];
+}
+/**
+ * THE contract-kind list. Every consumer of `traceability.contracts` iterates
+ * THIS — never a hand-written array — because hand-copies are what let `graphql`
+ * be discoverable, mappable and loadable while the capability_contract EDGE
+ * builder silently ignored it. Measured cost: an estate authored 9 correct
+ * declarations, rebuilt, and got zero edges and 7 standing orphans.
+ *
+ * The list was hand-written at THREE consumer sites and `graphql` was missed at
+ * all three. A kind added here now reaches every consumer at once.
+ *
+ * Not in scope: repo-config's own `contracts` block (a different schema with its
+ * own three kinds) — that is not a stale copy of this list and must not be
+ * "fixed" with this helper.
+ */
+export const CONTRACT_LIST_KEYS = [
+    "openapi",
+    "proto",
+    "avro",
+    "spicedb",
+    "graphql",
+];
+/**
+ * Every contract path a contracts block declares, across all kinds and both
+ * entry forms (bare string, or `{path, external}` per D13).
+ */
+export function declaredContractPaths(block) {
+    if (block === undefined)
+        return [];
+    const out = [];
+    for (const key of CONTRACT_LIST_KEYS) {
+        const list = block[key];
+        if (!Array.isArray(list))
+            continue;
+        for (const entry of list) {
+            if (typeof entry === "string")
+                out.push(entry);
+            else if (entry && typeof entry.path === "string")
+                out.push(entry.path);
+        }
+    }
+    return out;
+}
+export async function loadTraceabilityManifests(opts) {
+    const root = join(opts.sddPath, DOMAINS_DIR_REL);
+    let yamlPaths;
+    try {
+        yamlPaths = await collectYamlPaths(root, /\.traceability\.yaml$/);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            // No domains dir → no traceability data; return empty.
+            return [];
+        }
+        throw err;
+    }
+    const manifests = [];
+    for (const path of yamlPaths.sort()) {
+        const text = await readFile(path, "utf-8");
+        let raw;
+        try {
+            raw = parseYaml(text);
+        }
+        catch (err) {
+            opts.findings.add("convention", `failed to parse YAML at ${relative(opts.sddPath, path)}: ${err.message}`);
+            continue;
+        }
+        if (!raw || typeof raw !== "object") {
+            opts.findings.add("convention", `${relative(opts.sddPath, path)}: not an object — skipped`);
+            continue;
+        }
+        const obj = raw;
+        const cap = obj["capability"] ?? {};
+        const capId = String(cap["id"] ?? "").trim();
+        if (capId === "") {
+            opts.findings.add("convention", `${relative(opts.sddPath, path)}: missing capability.id`);
+            continue;
+        }
+        const relPath = relative(opts.sddPath, path);
+        const domainFromPath = inferDomainFromPath(relPath);
+        const declaredDomain = String(cap["domain"] ?? "").trim();
+        if (declaredDomain && domainFromPath && declaredDomain !== domainFromPath) {
+            opts.findings.add("divergence", `${relPath}: capability.domain="${declaredDomain}" disagrees with path domain "${domainFromPath}"`);
+        }
+        const capability = {
+            id: capId,
+            domain: declaredDomain || domainFromPath,
+            ...(typeof cap["capability_spec"] === "string"
+                ? { capability_spec: cap["capability_spec"] }
+                : {}),
+            ...(normalizeFeatureDirs(cap["feature_directory"]).length > 0
+                ? { feature_directory: normalizeFeatureDirs(cap["feature_directory"]) }
+                : {}),
+            ...(typeof cap["status"] === "string" ? { status: cap["status"] } : {}),
+            ...(typeof cap["data_subset"] === "string"
+                ? { data_subset: cap["data_subset"] }
+                : {}),
+            ...(typeof cap["slice_scope"] === "string"
+                ? { slice_scope: cap["slice_scope"] }
+                : {}),
+            ...(typeof cap["evidence_class"] === "string"
+                ? { evidence_class: cap["evidence_class"] }
+                : {}),
+            ...(typeof cap["context"] === "string"
+                ? { context: cap["context"] }
+                : {}),
+        };
+        manifests.push({
+            path,
+            relPath,
+            domainFromPath,
+            capability,
+            traceability: extractTraceabilityBlock(obj["traceability"]),
+            data: raw,
+        });
+    }
+    return manifests;
+}
+function extractTraceabilityBlock(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const t = raw;
+    const runway = t["runway"];
+    const adrs = t["adrs"];
+    const services = t["services"];
+    const contracts = t["contracts"];
+    const domainModel = t["domain_model"];
+    return {
+        ...(runway && typeof runway === "object" ? { runway: extractRunway(runway) } : {}),
+        ...(Array.isArray(adrs) ? { adrs: extractAdrs(adrs) } : {}),
+        ...(Array.isArray(services) ? { services: extractServices(services) } : {}),
+        ...(contracts && typeof contracts === "object"
+            ? { contracts: extractContracts(contracts) }
+            : {}),
+        ...(domainModel && typeof domainModel === "object"
+            ? extractDomainModel(domainModel)
+            : {}),
+    };
+}
+function extractDomainModel(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const dm = raw;
+    const path = String(dm["path"] ?? "").trim();
+    if (path === "")
+        return {};
+    const version = dm["version"];
+    return {
+        domain_model: {
+            path,
+            ...(typeof version === "string" && version.trim() !== ""
+                ? { version }
+                : {}),
+        },
+    };
+}
+function extractRunway(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const r = raw;
+    const enables = Array.isArray(r["enables"])
+        ? r["enables"].filter((e) => typeof e === "string")
+        : undefined;
+    return {
+        ...(typeof r["classification"] === "string"
+            ? { classification: r["classification"] }
+            : {}),
+        ...(enables ? { enables } : {}),
+    };
+}
+function extractAdrs(raw) {
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const o = item;
+        const id = String(o["id"] ?? "").trim();
+        if (!id)
+            continue;
+        out.push({
+            id,
+            ...(typeof o["path"] === "string" ? { path: o["path"] } : {}),
+            ...(typeof o["relationship"] === "string"
+                ? { relationship: o["relationship"] }
+                : {}),
+            ...(typeof o["notes"] === "string" ? { notes: o["notes"] } : {}),
+        });
+    }
+    return out;
+}
+function extractServices(raw) {
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const o = item;
+        const id = String(o["id"] ?? "").trim();
+        if (!id)
+            continue;
+        out.push({
+            id,
+            ...(typeof o["owner_domain"] === "string"
+                ? { owner_domain: o["owner_domain"] }
+                : {}),
+            ...(typeof o["owner_sdd"] === "string" && o["owner_sdd"].trim() !== ""
+                ? { owner_sdd: o["owner_sdd"].trim() }
+                : {}),
+            ...(typeof o["role"] === "string" ? { role: o["role"] } : {}),
+            ...(typeof o["status"] === "string" ? { status: o["status"] } : {}),
+            ...(typeof o["notes"] === "string" ? { notes: o["notes"] } : {}),
+            ...(typeof o["contract"] === "string" && o["contract"].trim() !== ""
+                ? { contract: o["contract"].trim() }
+                : {}),
+            ...(typeof o["interaction_pattern"] === "string" && o["interaction_pattern"].trim() !== ""
+                ? { interaction_pattern: o["interaction_pattern"].trim() }
+                : {}),
+            ...(typeof o["qualifier"] === "string" && o["qualifier"].trim() !== ""
+                ? { qualifier: o["qualifier"].trim() }
+                : {}),
+            ...(typeof o["evidence"] === "string" && o["evidence"].trim() !== ""
+                ? { evidence: o["evidence"].trim() }
+                : {}),
+        });
+    }
+    return out;
+}
+function extractContracts(raw) {
+    const o = raw;
+    // Keeps BOTH legal entry forms. The original version filtered to strings
+    // only — which silently discarded every object entry before any builder
+    // ran. Measured cost when an adopter marked 58 entries `external: true`
+    // for the D13 canary: 0 rows emitted AND the 56 orphan findings those
+    // entries used to raise disappeared — the declarations became invisible
+    // to row emission and to finding emission at once. The builder had been
+    // taught the object form (contracts.ts) while its only feeder had not:
+    // the F36 shape again, one surface ahead of the pipeline that supplies
+    // it. `spicedb` was likewise never extracted, so `.zed` declarations
+    // never reached any builder even as bare strings.
+    const arr = (key) => {
+        const v = o[key];
+        if (!Array.isArray(v))
+            return undefined;
+        return v.filter((e) => typeof e === "string" ||
+            (e !== null &&
+                typeof e === "object" &&
+                !Array.isArray(e) &&
+                typeof e["path"] === "string"));
+    };
+    const openapi = arr("openapi");
+    const proto = arr("proto");
+    const avro = arr("avro");
+    const spicedb = arr("spicedb");
+    const graphql = arr("graphql");
+    // `provenance` (3.5.0) MUST be extracted here or the builder that reads it
+    // sees nothing — this function reconstructs the block key-by-key rather than
+    // passing the parsed object through, which is precisely the F36 shape the
+    // comment above records. It was re-committed once during 3.5.0's own
+    // implementation: the builder was taught to read provenance while this feeder
+    // still dropped it, and only an end-to-end catalogue build caught it, because
+    // the builder's unit tests construct the manifest object directly and never
+    // traverse this function. Any future key added to this block needs a line here
+    // AND a loader-level test.
+    const provenance = typeof o["provenance"] === "string" ? o["provenance"].trim() : undefined;
+    return {
+        ...(openapi ? { openapi } : {}),
+        ...(proto ? { proto } : {}),
+        ...(avro ? { avro } : {}),
+        ...(spicedb ? { spicedb } : {}),
+        ...(graphql ? { graphql } : {}),
+        ...(provenance ? { provenance } : {}),
+    };
+}
+function inferDomainFromPath(relPath) {
+    const parts = relPath.split(sep);
+    const idx = parts.indexOf("domains");
+    if (idx === -1 || idx + 1 >= parts.length)
+        return "";
+    return parts[idx + 1] ?? "";
+}
+async function collectYamlPaths(dir, pattern) {
+    const out = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return [];
+        throw err;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...(await collectYamlPaths(full, pattern)));
+        }
+        else if (entry.isFile() && pattern.test(entry.name)) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+/** Convenience: read a file's first non-empty line, returning the trimmed value. */
+export async function readFirstNonEmptyLine(path) {
+    try {
+        const s = await stat(path);
+        if (!s.isFile())
+            return "";
+    }
+    catch {
+        return "";
+    }
+    const text = await readFile(path, "utf-8");
+    for (const line of text.split(/\r?\n/)) {
+        const t = line.trim();
+        if (t !== "")
+            return t;
+    }
+    return "";
+}
+//# sourceMappingURL=traceability-loader.js.map

package/dist/lib/catalogue/validate.js

@@ -0,0 +1,200 @@
+// `sdd-cli catalogue validate` — re-validate an existing catalogues/
+// directory without rebuilding. Two checks per the canonical CLI spec:
+//
+//   1. Column-shape check: every CSV's header row must match the
+//      canonical schema's declared columns (exact set + order).
+//   2. FK validation: full pass over the loaded rows, internal mode
+//      (external FKs treated per their declared flag — same semantics
+//      as `catalogue build`). Adopters who want post-merge validation
+//      run `catalogue aggregate` instead.
+//
+// Outputs the same shape of findings as `build` so consumers can pipe
+// either through the same parser. Exit 0 on PASS; non-zero on shape
+// drift OR internal-FK FAIL.
+import { readFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { CLI_VERSION } from "./cli-version.js";
+import { readCatalogueCsv } from "./csv-reader.js";
+import { writeCatalogue } from "./csv-writer.js";
+import { validatedPopulation, validateWithEngineToLog } from "./engine-validator.js";
+import { FindingsLog } from "./findings.js";
+import { PLATFORM_SCOPED_AT_ORGANISATION } from "./platform-scope.js";
+import { loadCanonicalSchema } from "./schema-loader.js";
+export async function runCatalogueValidate(inputs, write) {
+    const sddPath = resolve(inputs.sddPath ?? process.cwd());
+    // An organisation root is aggregate-only by construction (M-ADR 0208): its own
+    // catalogues/ is deliberately empty and catalogues-aggregated/ is all it produces.
+    // Validating the empty member directory reported every file missing — a check
+    // that could only fail on such a root. Validate what it actually publishes.
+    const orgRoot = await isOrganisationRoot(sddPath);
+    const dirName = orgRoot ? "catalogues-aggregated" : "catalogues";
+    const cataloguesDir = join(sddPath, dirName);
+    const schema = await loadCanonicalSchema();
+    write(`sdd-cli catalogue validate (canonical schema ${schema.schemaVersion}, cli ${CLI_VERSION})\n`);
+    if (orgRoot)
+        write(`organisation root: validating ${dirName}/ (an organisation root publishes only its aggregate)\n`);
+    // Existence check on catalogues/ — fail fast with a clear message.
+    try {
+        const s = await stat(cataloguesDir);
+        if (!s.isDirectory()) {
+            throw new Error(`catalogues/ at ${cataloguesDir} exists but is not a directory`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new Error(`catalogues/ not found at ${cataloguesDir}\n` +
+                `  Run \`sdd-cli catalogue build\` before \`validate\`.`);
+        }
+        throw err;
+    }
+    const findings = new FindingsLog();
+    const rowsByCatalogue = new Map();
+    let columnShapeOk = true;
+    for (const cat of schema.catalogues) {
+        const filePath = join(cataloguesDir, `${cat.name}.csv`);
+        let parsed;
+        try {
+            parsed = await readCatalogueCsv(filePath);
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                // Missing file is a shape failure — every catalogue declared in
+                // the schema MUST have a CSV (headers-only acceptable).
+                findings.add("convention", `${dirName}/${cat.name}.csv missing — every schema catalogue must have a file (headers-only acceptable)`);
+                columnShapeOk = false;
+                rowsByCatalogue.set(cat.name, []);
+                continue;
+            }
+            throw err;
+        }
+        const expected = cat.columns.map((c) => c.name);
+        const drift = compareColumns(expected, parsed.columns);
+        if (drift !== null) {
+            findings.add("convention", `${dirName}/${cat.name}.csv: column shape drift — ${drift}`);
+            columnShapeOk = false;
+        }
+        rowsByCatalogue.set(cat.name, parsed.rows);
+    }
+    // Derive the SDD profile from products.csv so profile-external FKs (schema
+    // 2.23.0) resolve consistently with `catalogue build`. A per-SDD catalogue
+    // has one distinct profile → pass it (an app catalogue's capabilities.domain_id
+    // is then treated external, matching the build). An aggregated catalogue mixes
+    // profiles → leave undefined, so those FKs validate as internal and MUST
+    // resolve (the merged platform domains are present to satisfy them).
+    const profile = singleProfile(rowsByCatalogue.get("products") ?? []);
+    // FK + bound-enum validation on the embedded engine (M-ADR 0205 §4.4
+    // cutover; same semantics, findings text unchanged — the A2/A3 dual-run
+    // record is the evidence). Enum hard-fail behaviour per M-ADR 0203 §4.1
+    // is unchanged: an out-of-set value is an error-severity finding.
+    const { fk, enums } = await validateWithEngineToLog(schema, rowsByCatalogue, findings, {
+        ...(profile !== undefined ? { profile } : {}),
+        // At organisation tier `domains` is keyed (platform_sdd_id, id): two platforms may
+        // each own a domain of one name, exactly as the aggregator validates it.
+        ...(orgRoot ? { platformScopedTargets: PLATFORM_SCOPED_AT_ORGANISATION } : {}),
+    });
+    // Report.
+    const findingsText = findings.render();
+    if (findingsText)
+        write(`\n${findingsText}\n`);
+    if (columnShapeOk) {
+        write(`\nColumn-shape check: PASS (${validatedPopulation(rowsByCatalogue)})\n`);
+    }
+    else {
+        write(`\nColumn-shape check: FAIL\n`);
+    }
+    if (fk.internalPass) {
+        write(`FK validation (internal): PASS (${validatedPopulation(rowsByCatalogue)})\n`);
+    }
+    else {
+        write(`FK validation (internal): FAIL (${fk.internalFailures.length} dangling)\n`);
+        for (const f of fk.internalFailures) {
+            write(`  ${f.catalogue}.${f.column}: row pk=${f.referencingRow} → ${f.target}=${f.value || "<empty>"}\n`);
+        }
+    }
+    if (enums.pass) {
+        write(`Enum validation (column_enums): PASS (${validatedPopulation(rowsByCatalogue)})\n`);
+    }
+    else {
+        write(`Enum validation (column_enums): FAIL (${enums.violations.length} out-of-set)\n`);
+        for (const v of enums.violations) {
+            write(`  ${v.catalogue}.${v.column}: row pk=${v.rowPk} value "${v.value}" (allowed: ${v.allowed})\n`);
+        }
+    }
+    if (fk.externalFindings > 0) {
+        write(`External findings: ${fk.externalFindings} (validated by aggregator)\n`);
+    }
+    // Force-touch writeCatalogue to keep imports honest if a future
+    // refactor wants to re-emit a cleaned-up file from validate. Today
+    // validate is read-only.
+    void writeCatalogue;
+    const strictFail = inputs.strict === true && findings.count() > 0;
+    // Error-severity findings (the bound-enum FAIL path) fail validate by
+    // default, matching `catalogue build`'s exit-code contract.
+    const exitCode = !columnShapeOk || !fk.internalPass || !enums.pass || findings.errorCount() > 0 || strictFail
+        ? 1
+        : 0;
+    return {
+        exitCode,
+        schemaVersion: schema.schemaVersion,
+        internalFkPass: fk.internalPass,
+        columnShapeOk,
+        enumPass: enums.pass,
+        findingsCount: findings.count(),
+    };
+}
+/**
+ * Compare a CSV's actual column header against the schema's declared
+ * column order. Returns null if exactly equal (order included), or a
+ * one-line description of the drift otherwise.
+ */
+/**
+ * The single distinct non-empty `profile` across products rows, or undefined
+ * when there are zero or multiple (an aggregated catalogue). Drives
+ * profile-external FK handling (schema 2.23.0) — see the call site.
+ */
+function singleProfile(products) {
+    const profiles = new Set();
+    for (const p of products) {
+        const v = String(p["profile"] ?? "");
+        if (v !== "")
+            profiles.add(v);
+    }
+    return profiles.size === 1 ? [...profiles][0] : undefined;
+}
+function compareColumns(expected, actual) {
+    if (expected.length === actual.length) {
+        let equal = true;
+        for (let i = 0; i < expected.length; i++) {
+            if (expected[i] !== actual[i]) {
+                equal = false;
+                break;
+            }
+        }
+        if (equal)
+            return null;
+    }
+    const expectedSet = new Set(expected);
+    const actualSet = new Set(actual);
+    const missing = expected.filter((c) => !actualSet.has(c));
+    const extra = actual.filter((c) => !expectedSet.has(c));
+    if (missing.length === 0 && extra.length === 0) {
+        return `column order differs (expected: ${expected.join(",")} | got: ${actual.join(",")})`;
+    }
+    const parts = [];
+    if (missing.length > 0)
+        parts.push(`missing: ${missing.join(",")}`);
+    if (extra.length > 0)
+        parts.push(`unexpected: ${extra.join(",")}`);
+    return parts.join("; ");
+}
+/** True when the SDD's manifest declares it an organisation root (aggregate-only). */
+async function isOrganisationRoot(sddPath) {
+    try {
+        const raw = await readFile(join(sddPath, ".sdd", "sdd-manifest.yaml"), "utf8");
+        return /^category:\s*"?organisation-root"?\s*$/m.test(raw);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/lib/catalogue/version.js

@@ -0,0 +1,18 @@
+// `sdd-cli catalogue version` — prints the canonical schema version
+// and the sdd-cli version pin so adopters can verify their tooling
+// matches the schema they expect.
+import { CLI_VERSION } from "./cli-version.js";
+import { SCHEMA_COMPAT } from "./schema-compat.js";
+import { loadCanonicalSchema } from "./schema-loader.js";
+export async function runCatalogueVersion(write) {
+    const schema = await loadCanonicalSchema();
+    write([
+        `sdd-cli                    ${CLI_VERSION}`,
+        `catalogue schema           ${schema.schemaVersion}`,
+        `accepted catalogue range   ${SCHEMA_COMPAT.catalogue_schema}`,
+        `accepted sdd_manifest      ${SCHEMA_COMPAT.sdd_manifest}`,
+        `accepted aggregation       ${SCHEMA_COMPAT.aggregation_manifest}`,
+        "",
+    ].join("\n"));
+}
+//# sourceMappingURL=version.js.map

package/dist/lib/conformance/binding.js

@@ -0,0 +1,70 @@
+import { readFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+export const BINDING_FILENAME = ".sdd/implementation-binding.yaml";
+/** One binding per implementation, for an SDD that specifies several (M-ADR 0214 §4.9). */
+export const BINDINGS_DIRNAME = ".sdd/implementation-bindings";
+export function bindingPath(targetRepo) {
+    return resolve(targetRepo, BINDING_FILENAME);
+}
+/**
+ * Every binding file of the SDD, relative to its root: the single-implementation file
+ * when present, then each `<implementation>.yaml` in the bindings directory, sorted.
+ */
+export function bindingFiles(targetRepo) {
+    const out = [];
+    if (existsSync(bindingPath(targetRepo)))
+        out.push(BINDING_FILENAME);
+    const dir = resolve(targetRepo, BINDINGS_DIRNAME);
+    if (existsSync(dir)) {
+        for (const f of readdirSync(dir).sort()) {
+            if (f.endsWith(".yaml") || f.endsWith(".yml"))
+                out.push(`${BINDINGS_DIRNAME}/${f}`);
+        }
+    }
+    return out;
+}
+export function hasBinding(targetRepo) {
+    return bindingFiles(targetRepo).length > 0;
+}
+/**
+ * Flatten the binding's implementation members into derived checks. Each member's `checks[]` become
+ * Check objects (run as-is by the extractor core); the member's repo/role/lifecycle ride alongside so
+ * the emitted finding records *which implementation* drifted. A member with no checks contributes none
+ * (e.g. a decommissioned as-is member you no longer validate).
+ */
+export async function deriveChecksFromBinding(targetRepo) {
+    const derived = [];
+    // A check id is the conformance_finding primary key within the SDD, so one declared by two
+    // bindings would collide there: refused here, where both files can be named.
+    const declaredIn = new Map();
+    for (const file of bindingFiles(targetRepo)) {
+        for (const d of await deriveFromFile(resolve(targetRepo, file))) {
+            const prior = declaredIn.get(d.check.id);
+            if (prior !== undefined) {
+                throw new Error(`conformance check id '${d.check.id}' is declared by both ${prior} and ${file} — check ids are unique within the SDD (M-ADR 0214 §4.9)`);
+            }
+            declaredIn.set(d.check.id, file);
+            derived.push(d);
+        }
+    }
+    return derived;
+}
+async function deriveFromFile(path) {
+    const raw = parseYaml(await readFile(path, "utf-8"));
+    const derived = [];
+    for (const impl of raw?.implementations ?? []) {
+        const member = {
+            repo: impl.repo,
+            ...(impl.role ? { role: impl.role } : {}),
+            ...(impl.lifecycle ? { lifecycle: impl.lifecycle } : {}),
+            ...(impl.stack ? { stack: impl.stack } : {}),
+        };
+        for (const check of impl.checks ?? []) {
+            derived.push({ check, member });
+        }
+    }
+    return derived;
+}
+//# sourceMappingURL=binding.js.map