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

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

@@ -0,0 +1,115 @@
+/**
+ * Coverage mode — `sdd-cli catalogue validate --coverage` (A4 CS-2).
+ *
+ * Runs the thirteen engine coverage predicates against a catalogues
+ * directory and prints EXACTLY the lines the reference shell scripts
+ * printed (coverage-render.ts holds the text contract), in a fixed block
+ * order: the four catalogue-classics (repo-capability, service-capability,
+ * event, contract), then the nine Phase-0 gate checks in the
+ * catalogue-integrity-gate's step order. Nothing else is written to
+ * stdout — the gate swaps N script invocations for one CLI call and the
+ * stream stays parseable by the same baseline machinery.
+ *
+ * Exit code is 0 in normal operation, exactly as the reference scripts:
+ * gating is the findings baseline's job, never this mode's. A classifier
+ * probe failure throws (the references exit 2).
+ *
+ * The one deliberately-unported check is check-repo-config-coverage.sh:
+ * it reads the AUTHORING surface, is text-shaped by design (A0's
+ * classification), and stays shell.
+ */
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readCatalogueCsv } from "./csv-reader.js";
+import { createEngineSession } from "./engine-validator.js";
+import { loadCanonicalSchema } from "./schema-loader.js";
+import { runContractCoverage, runEventCoverage, runRepoCapabilityCoverage, runServiceCapabilityCoverage, } from "./coverage-predicates.js";
+import { runCapabilityEventCheck, runDataModelEntitiesCheck, runEventCatalogueCheck, runFeatureEventCheck, runFeatureSpecPromotionCheck, runFeatureSurfaceDuplicationCheck, runGlossaryXrefCheck, runPlatformDependenciesCheck, runRelationshipCoherenceCheck, runRepoEdgesCheck, } from "./gate-checks.js";
+import { runScoresCoverage } from "./scores-coverage.js";
+import { renderScaffoldDelta, runScaffoldDelta } from "./scaffold-delta.js";
+import { renderStalenessVerdicts, runStalenessVerdicts } from "./staleness-verdicts.js";
+import { renderCapabilityEventCheck, renderContractCoverage, renderDataModelEntitiesCheck, renderEventCatalogueCheck, renderEventCoverage, renderFeatureEventCheck, renderFeatureSpecPromotionCheck, renderFeatureSurfaceDuplicationCheck, renderGlossaryXrefCheck, renderPlatformDependenciesCheck, renderRelationshipCoherenceCheck, renderRepoCapability, renderRepoEdgesCheck, renderScoresCoverage, renderServiceCapability, } from "./coverage-render.js";
+export async function runCatalogueCoverage(inputs, write) {
+    const sddRoot = resolve(inputs.sddPath ?? process.cwd());
+    const dir = resolve(sddRoot, inputs.cataloguesDir ?? "catalogues");
+    const tier = inputs.tier ?? "member";
+    const schema = await loadCanonicalSchema();
+    const present = (name) => existsSync(join(dir, `${name}.csv`));
+    const rowsByCatalogue = new Map();
+    for (const cat of schema.catalogues) {
+        if (!present(cat.name))
+            continue;
+        const parsed = await readCatalogueCsv(join(dir, `${cat.name}.csv`));
+        rowsByCatalogue.set(cat.name, parsed.rows);
+    }
+    const session = await createEngineSession(schema, rowsByCatalogue);
+    const lines = [];
+    try {
+        // The four catalogue-classics, each anchored on its population file
+        // exactly as the reference scripts anchor (absent file → silent).
+        if (present("repositories")) {
+            const r = await runRepoCapabilityCoverage(session);
+            lines.push(...renderRepoCapability(r.findings, r.metrics));
+        }
+        if (present("services")) {
+            const r = await runServiceCapabilityCoverage(session, {
+                tier,
+                repoCapabilityAvailable: present("repo_capability"),
+            });
+            lines.push(...renderServiceCapability(r.findings, r.metrics, tier));
+        }
+        if (present("events")) {
+            const r = await runEventCoverage(session, { tier });
+            lines.push(...renderEventCoverage(r, tier));
+        }
+        if (present("contracts")) {
+            const r = await runContractCoverage(session, { tier, sddRoot });
+            lines.push(...renderContractCoverage(r, tier));
+        }
+        // The nine Phase-0 gate checks, in the gate's step order.
+        const eventCatalogue = await runEventCatalogueCheck(session, {
+            sddRoot,
+            eventsPresent: present("events"),
+        });
+        lines.push(...renderEventCatalogueCheck(eventCatalogue.gaps));
+        lines.push(...renderRepoEdgesCheck(await runRepoEdgesCheck(session, { sddRoot })));
+        lines.push(...renderGlossaryXrefCheck((await runGlossaryXrefCheck(session, {
+            sddRoot,
+            xrefPresent: present("glossary_xref"),
+        })).finding));
+        lines.push(...renderDataModelEntitiesCheck(await runDataModelEntitiesCheck(session)));
+        lines.push(...renderCapabilityEventCheck(await runCapabilityEventCheck(session)));
+        lines.push(...renderFeatureEventCheck(await runFeatureEventCheck(session)));
+        lines.push(...renderPlatformDependenciesCheck((await runPlatformDependenciesCheck(session, { sddRoot })).finding));
+        lines.push(...renderFeatureSpecPromotionCheck(await runFeatureSpecPromotionCheck(session)));
+        lines.push(...renderFeatureSurfaceDuplicationCheck(await runFeatureSurfaceDuplicationCheck(session)));
+        // The fourteenth check (M-ADR 0205 §4.5, Phase B): every eligible artefact
+        // carries a current score. Last in the block order because it is the newest
+        // and the baselines hold the stream positionally-agnostic but ordered.
+        const available = new Set(schema.catalogues.map((c) => c.name).filter((n) => present(n)));
+        lines.push(...renderScoresCoverage(await runScoresCoverage(session, { tier, available, sddRoot }), tier));
+        // Staleness VERDICTS — the second half of the fourteenth check's §4.5
+        // scope (ledger §3o), member-tier only with the aggregate skip stated.
+        // Same coverage class, same reporting-only staging as the rest of the
+        // scores family.
+        lines.push(...renderStalenessVerdicts(await runStalenessVerdicts(session, { tier, available, sddRoot }), tier));
+        // The fifteenth check (M-ADR 0206 §4.5): relationship coherence for the
+        // three families where drift or gaps mean something — owned-but-untraced
+        // features, publisher-projection drift, supersession drift. Reporting-only
+        // at both tiers; newest last in the block order, same as scores was.
+        lines.push(...renderRelationshipCoherenceCheck(await runRelationshipCoherenceCheck(session)));
+        // The sixteenth check (M-ADR 0207 §4.8): the scaffold declared-vs-derived
+        // delta, its resolution self-check, and the §4.6 staleness verdict.
+        // Reporting-only at both tiers per §4.9 — nothing here gates until the
+        // pilot's stated-in-advance figures land. Newest last in the block order,
+        // same as scores and coherence were.
+        lines.push(...renderScaffoldDelta(await runScaffoldDelta(session, { tier, available, schema, sddRoot }), tier));
+    }
+    finally {
+        session.dispose();
+    }
+    for (const line of lines)
+        write(`${line}\n`);
+    return { exitCode: 0 };
+}
+//# sourceMappingURL=coverage-run.js.map

package/dist/lib/catalogue/csv-reader.js

@@ -0,0 +1,97 @@
+// CSV reader for catalogue files.
+//
+// RFC-4180-aware: handles `"` quoting (including doubled `""` for literal
+// quotes), commas inside quoted cells, and CR/LF/CRLF line breaks. We
+// don't try to be a general CSV library — the canonical writer's output
+// is the input shape we support, plus tolerance for byte-identical
+// catalogues authored by other conforming aggregator implementations.
+//
+// Headers come from the file's first line; column order is preserved
+// for traceability but row access is by column name.
+import { readFile } from "node:fs/promises";
+export async function readCatalogueCsv(path) {
+    const text = await readFile(path, "utf-8");
+    return parseCatalogueCsv(text);
+}
+export function parseCatalogueCsv(text) {
+    const records = parseRecords(text);
+    if (records.length === 0)
+        return { columns: [], rows: [] };
+    const columns = records[0] ?? [];
+    const rows = [];
+    for (let r = 1; r < records.length; r++) {
+        const record = records[r] ?? [];
+        if (record.length === 1 && record[0] === "")
+            continue; // empty trailing line
+        const row = {};
+        for (let c = 0; c < columns.length; c++) {
+            row[columns[c] ?? ""] = record[c] ?? "";
+        }
+        rows.push(row);
+    }
+    return { columns, rows };
+}
+function parseRecords(text) {
+    const records = [];
+    let current = [];
+    let cell = "";
+    let i = 0;
+    let inQuotes = false;
+    while (i < text.length) {
+        const ch = text[i] ?? "";
+        if (inQuotes) {
+            if (ch === '"') {
+                if (text[i + 1] === '"') {
+                    // Escaped double-quote inside a quoted cell.
+                    cell += '"';
+                    i += 2;
+                    continue;
+                }
+                inQuotes = false;
+                i++;
+                continue;
+            }
+            cell += ch;
+            i++;
+            continue;
+        }
+        if (ch === '"') {
+            inQuotes = true;
+            i++;
+            continue;
+        }
+        if (ch === ",") {
+            current.push(cell);
+            cell = "";
+            i++;
+            continue;
+        }
+        if (ch === "\r") {
+            if (text[i + 1] === "\n")
+                i++;
+            current.push(cell);
+            records.push(current);
+            current = [];
+            cell = "";
+            i++;
+            continue;
+        }
+        if (ch === "\n") {
+            current.push(cell);
+            records.push(current);
+            current = [];
+            cell = "";
+            i++;
+            continue;
+        }
+        cell += ch;
+        i++;
+    }
+    // Trailing cell + record.
+    if (cell !== "" || current.length > 0) {
+        current.push(cell);
+        records.push(current);
+    }
+    return records;
+}
+//# sourceMappingURL=csv-reader.js.map

package/dist/lib/catalogue/csv-writer.js

@@ -0,0 +1,96 @@
+/**
+ * Deterministic CSV writer for catalogues.
+ *
+ * Emits headers + sorted rows per ADR 0134 builder contract:
+ *   - column order matches the canonical schema exactly,
+ *   - rows sorted by primary-key value,
+ *   - cells with embedded comma/quote/newline are RFC-4180 quoted,
+ *   - empty trailing newline (POSIX convention).
+ *
+ * Headers-only emission is supported — pass an empty rows array to write
+ * a CSV that downstream consumers can rely on the file existence of.
+ *
+ * ⚠ BUT A HEADERS-ONLY WRITE NEVER TRUNCATES A CATALOGUE THAT HAS ROWS.
+ * `conformance_finding` is written by a DIFFERENT VERB — `sdd-cli conformance
+ * --emit-finding` calls writeFindings() into the same `catalogues/` directory —
+ * and nothing in the `catalogue build` row-collection path ever sets it. So
+ * build emitted a bare header over it, unconditionally, and one verb destroyed
+ * another verb's output. Measured across one estate: every SDD that had
+ * authored a conformance finding lost it, while the gate registries went on
+ * citing those rows as CURRENT evidence for a hard-gated score.
+ *
+ * ⚠ The first cut of this comment said `c4_system_entity` was a second
+ * producerless catalogue. It is not — `build.ts` sets it directly rather than
+ * via `builders/`, and the sweep that "found" it only searched `builders/`.
+ * An adopter disproved it by counterfactual, installing the defective version
+ * and measuring that its rows survived. Stated here because the wrong version
+ * shipped in 1.29.0 and a reader deserves the correction beside the claim.
+ *
+ * The guard is keyed on the CONDITION, not on those two names, so it also
+ * catches the case nobody has hit yet: a builder that regresses to zero rows
+ * silently deleting a populated catalogue.
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+/** Data-row count of an existing catalogue file, or 0 when absent/unreadable/header-only. */
+async function existingDataRows(filePath) {
+    let text;
+    try {
+        text = await readFile(filePath, "utf-8");
+    }
+    catch {
+        return 0;
+    }
+    const lines = text.split("\n").filter((l) => l.trim() !== "");
+    return lines.length > 1 ? lines.length - 1 : 0;
+}
+export async function writeCatalogue(opts) {
+    await mkdir(opts.outDir, { recursive: true });
+    const filePath = join(opts.outDir, `${opts.catalogue.name}.csv`);
+    // Refuse to replace rows with a bare header. Emitting one is correct when the
+    // file is absent or already empty — that is the "consumers can rely on the
+    // file existing" case — and is data loss when it is not.
+    if (opts.rows.length === 0) {
+        const onDisk = await existingDataRows(filePath);
+        if (onDisk > 0) {
+            return { rowCount: onDisk, path: filePath, preserved: true, preservedRows: onDisk };
+        }
+    }
+    const text = renderCatalogueCsv(opts.catalogue, opts.rows);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, text, "utf-8");
+    return { rowCount: opts.rows.length, path: filePath };
+}
+export function renderCatalogueCsv(catalogue, rows) {
+    const columns = catalogue.columns.map((c) => c.name);
+    const lines = [];
+    lines.push(columns.map(escapeCell).join(","));
+    const sorted = [...rows].sort((a, b) => compareCell(a[catalogue.primaryKey], b[catalogue.primaryKey]));
+    for (const row of sorted) {
+        const cells = columns.map((col) => escapeCell(formatCell(row[col])));
+        lines.push(cells.join(","));
+    }
+    // Trailing newline per POSIX convention.
+    return `${lines.join("\n")}\n`;
+}
+function formatCell(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    return String(value);
+}
+function escapeCell(value) {
+    if (value === "")
+        return "";
+    if (/[",\n\r]/.test(value)) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+function compareCell(a, b) {
+    const sa = a === undefined || a === null ? "" : String(a);
+    const sb = b === undefined || b === null ? "" : String(b);
+    return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+//# sourceMappingURL=csv-writer.js.map

package/dist/lib/catalogue/data-item-coverage.js

@@ -0,0 +1,142 @@
+// feature_integration_support — coverage derived at aggregation (M-ADR 0216 §4.4).
+//
+// For each feature with at least one `required` requirement and each integration of the same
+// platform: decide every requirement (an ungrouped item alone; an alternative_group across its
+// members), then the feature takes the worst. `supported` means the items reach the canonical
+// boundary, NOT that the feature works end to end. `enhances` never decides coverage. A feature
+// with no requirement gets no row: nothing was declared, so nothing is decided.
+//
+// Two readings the ADR leaves to the builder, chosen conservatively:
+//   - a `not-applicable` item inside a feature that is not wholly not-applicable is unmet with
+//     reason source-absent (the integration does not have it);
+//   - when the members of an unmet requirement fail for different reasons, the reason reported
+//     is the most actionable: gateway-gap, then no-canonical-home, then source-absent.
+const SUPPLY_ORDER = ["supported", "partial", "gateway-gap", "source-absent", "not-applicable"];
+const REASON_ORDER = ["gateway-gap", "no-canonical-home", "source-absent"];
+export function deriveFeatureIntegrationSupport(rows) {
+    const plat = (r) => String(r["platform_sdd_id"] ?? "");
+    const items = new Map();
+    for (const r of rows.get("data_items") ?? [])
+        items.set(`${plat(r)}\u0000${r["id"]}`, r);
+    const canonical = (p, item) => String(items.get(`${p}\u0000${item}`)?.["canonical_field"] ?? "") !== "";
+    const best = new Map(); // integration\0item → best verdict
+    const supplied = new Set();
+    for (const r of rows.get("integration_data_item") ?? []) {
+        const k = `${r["integration_id"]}\u0000${r["data_item_id"]}`;
+        const v = String(r["verdict"]);
+        supplied.add(String(r["integration_id"]));
+        const cur = best.get(k);
+        if (cur === undefined || SUPPLY_ORDER.indexOf(v) < SUPPLY_ORDER.indexOf(cur))
+            best.set(k, v);
+    }
+    // feature → requirement key → items
+    const reqs = new Map();
+    for (const r of rows.get("feature_data_requirement") ?? []) {
+        if (String(r["necessity"]) !== "required")
+            continue;
+        const f = String(r["feature_id"]);
+        const item = String(r["data_item_id"]);
+        const g = String(r["alternative_group"] ?? "");
+        const key = g !== "" ? `group:${g}` : `item:${item}`;
+        const m = reqs.get(f) ?? new Map();
+        m.set(key, [...(m.get(key) ?? []), item]);
+        reqs.set(f, m);
+    }
+    const features = rows.get("features") ?? [];
+    const integrations = rows.get("integrations") ?? [];
+    const out = [];
+    const byVerdict = {};
+    for (const f of features) {
+        const fid = String(f["id"]);
+        const fr = reqs.get(fid);
+        if (!fr)
+            continue;
+        const p = plat(f);
+        for (const integ of integrations) {
+            if (plat(integ) !== p)
+                continue;
+            const iid = String(integ["id"]);
+            const itemState = (item) => {
+                if (!canonical(p, item))
+                    return { kind: "unmet", reason: "no-canonical-home" };
+                const v = best.get(`${iid}\u0000${item}`);
+                if (v === undefined)
+                    return { kind: "unknown" };
+                if (v === "supported")
+                    return { kind: "met" };
+                if (v === "partial")
+                    return { kind: "partly" };
+                if (v === "not-applicable")
+                    return { kind: "na" };
+                return { kind: "unmet", reason: v };
+            };
+            const decided = [...fr.entries()]
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([, members]) => {
+                const states = members.sort().map((m) => ({ m, s: itemState(m) }));
+                if (states.some((x) => x.s.kind === "met"))
+                    return { kind: "met" };
+                if (states.some((x) => x.s.kind === "partly"))
+                    return { kind: "partly" };
+                if (states.some((x) => x.s.kind === "unknown"))
+                    return { kind: "unknown" };
+                if (states.every((x) => x.s.kind === "na"))
+                    return { kind: "na", item: states[0].m };
+                const unmet = states
+                    .map((x) => ({ m: x.m, reason: x.s.kind === "unmet" ? x.s.reason : "source-absent" }))
+                    .sort((a, b) => REASON_ORDER.indexOf(a.reason) - REASON_ORDER.indexOf(b.reason));
+                return { kind: "unmet", item: unmet[0].m, reason: unmet[0].reason };
+            });
+            let verdict;
+            let limitingItem = "";
+            let limitingReason = "";
+            const firstUnmet = decided.find((d) => d.kind === "unmet");
+            if (firstUnmet && firstUnmet.kind === "unmet") {
+                verdict = "unsupported";
+                limitingItem = firstUnmet.item;
+                limitingReason = firstUnmet.reason;
+            }
+            else if (decided.every((d) => d.kind === "na")) {
+                verdict = "not-applicable";
+            }
+            else if (decided.some((d) => d.kind === "na")) {
+                // n/a mixed with anything else: the integration does not have the item.
+                const na = decided.find((d) => d.kind === "na");
+                verdict = "unsupported";
+                limitingItem = na.item;
+                limitingReason = "source-absent";
+            }
+            else if (decided.some((d) => d.kind === "unknown")) {
+                verdict = "unknown";
+            }
+            else if (decided.some((d) => d.kind === "partly")) {
+                verdict = "partial";
+            }
+            else {
+                verdict = "supported";
+            }
+            byVerdict[verdict] = (byVerdict[verdict] ?? 0) + 1;
+            out.push({
+                id: `${fid}::${iid}`,
+                feature_id: fid,
+                integration_id: iid,
+                verdict,
+                limiting_item_id: limitingItem,
+                limiting_reason: limitingReason,
+                source_sdd_id: String(f["source_sdd_id"] ?? ""),
+                platform_sdd_id: p,
+            });
+        }
+    }
+    return {
+        rows: out.sort((a, b) => String(a["id"]).localeCompare(String(b["id"]))),
+        stats: {
+            featuresWithRequirements: reqs.size,
+            features: features.length,
+            integrations: integrations.length,
+            integrationsWithSupply: supplied.size,
+            byVerdict,
+        },
+    };
+}
+//# sourceMappingURL=data-item-coverage.js.map

package/dist/lib/catalogue/data-plane-coherence.js

@@ -0,0 +1,77 @@
+// data_plane ↔ product_platform_dependencies coherence cross-check
+// (M-ADR 0193 §4.2, as amended 2026-07-19).
+//
+// The two surfaces are complementary views, not mutually derived: a data_plane
+// binding carries pattern / fine locality / runtime that platform-dependencies
+// lack, and a platform-dependency carries capability / contract / stability that
+// a binding lacks. The method CROSS-CHECKS them for coherence rather than
+// deriving one from the other.
+//
+// The check is deliberately COARSE, and per-target correspondence is NOT
+// asserted. Under the gateway convention (M-ADR 0189: consumers reach a
+// capability through a BFF/gateway), a `retrieve@internal-domain` binding names
+// the DOMAIN service it logically reads (its finer-grained `target`), while the
+// matching `product_platform_dependencies` row names the GATEWAY through which
+// access physically flows. The two targets legitimately differ — that
+// difference is the locality/granularity signal the axis exists to capture, not
+// drift. Matching binding.target against platform-dep.target_service_id would
+// flag every such binding falsely, and adopters would "fix" the false finding by
+// coarsening `target` to the gateway id — destroying the axis's value. So the
+// coherence check asserts only the coarse invariant: a product that declares
+// platform-targeting data-plane bindings should also declare *some* platform
+// dependency. A product with internal bindings and zero platform-deps has one
+// surface without the other — a genuine coherence gap worth surfacing.
+import { isOutputSidePattern } from "./manifest-loader.js";
+const INTERNAL_LOCALITIES = new Set([
+    "internal-platform",
+    "internal-domain",
+]);
+/**
+ * Coarse coherence check: if a product declares platform-targeting INBOUND
+ * data-plane bindings (internal locality) but no `product_platform_dependencies`
+ * rows at all, the two complementary surfaces are out of step. Returns 1 if
+ * flagged, else 0. Per-target correspondence is intentionally NOT checked, and
+ * output-side bindings are excluded entirely (see header).
+ */
+// @rule data-plane-platform-dep-coherence
+export function checkDataPlanePlatformDepCoherence(inputs) {
+    const { productId, bindings, platformDeps, findings } = inputs;
+    const platformTargeting = bindings.filter((b) => INTERNAL_LOCALITIES.has(String(b["locality"] ?? "")) &&
+        !isOutputSidePattern(String(b["pattern"] ?? "")));
+    if (platformTargeting.length === 0)
+        return 0; // no platform-targeting bindings
+    if (platformDeps.length > 0)
+        return 0; // both surfaces present — coherent
+    findings.add("convention", `data_plane coherence: ${productId} declares ${platformTargeting.length} platform-targeting ` +
+        `inbound data_plane binding(s) (internal locality) but no product_platform_dependencies rows — the two ` +
+        `complementary surfaces are out of step; declare the platform dependencies in ` +
+        `app-platform-dependencies.yaml (M-ADR 0193 §4.2). Per-target correspondence is not asserted ` +
+        `(gateway indirection, M-ADR 0189).`);
+    return 1;
+}
+/**
+ * Coherence cross-check between the `surface: api` trait and a `publish`
+ * data_plane binding. Returns 1 if a drift finding was raised, else 0.
+ *
+ * One-directional: only a headless (`surface: api`) product missing its
+ * `publish` binding is flagged. A `publish` binding on a `ui` surface is
+ * legitimate and never flagged (see header). Runs only over a DECLARED
+ * data-plane (bindings present) — same gating as the platform-dep check; a
+ * product that has not authored a data_plane is not nagged.
+ */
+// @rule publish-surface-coherence
+export function checkPublishSurfaceCoherence(inputs) {
+    const { productId, surface, bindings, findings } = inputs;
+    const effectiveSurface = surface ?? "ui";
+    if (effectiveSurface !== "api")
+        return 0; // publish is orthogonal to a ui surface
+    const hasPublish = bindings.some((b) => String(b["pattern"] ?? "") === "publish");
+    if (hasPublish)
+        return 0; // both views present — coherent
+    findings.add("convention", `data_plane/surface coherence: ${productId} declares surface: api (headless, M-ADR 0167) but its ` +
+        `data_plane has no publish binding — a headless product's entire surface is programmatic, so the ` +
+        `contract that constitutes it is missing from the declared composition. Add a publish binding, or ` +
+        `reconsider the surface classification (M-ADR 0193 §4.7). Complementary views, not a derivation.`);
+    return 1;
+}
+//# sourceMappingURL=data-plane-coherence.js.map