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

package/dist/lib/catalogue/fk-validator.js

@@ -0,0 +1,136 @@
+/**
+ * FK validator per ADR 0134 builder-spec §"Run internal FK validation
+ * before exiting" + §"External FK handling".
+ *
+ * For each catalogue's foreign keys:
+ *   - Internal FKs (external=false): every non-empty value MUST resolve
+ *     to a primary-key in the referenced catalogue's emitted rows. Missing
+ *     resolution is a hard failure.
+ *   - External FKs (external=true, or external for the build's profile via
+ *     `externalForProfiles` — schema 2.23.0): every non-empty value is logged
+ *     as a `[finding] external` line and skipped from validation. The
+ *     aggregator resolves these post-merge per ADR 0134 §4.5. A required
+ *     (non-nullable) external FK still fails when EMPTY — the value must be
+ *     named even if it resolves cross-SDD.
+ *
+ * Returns a structured result; the caller decides exit code + reporting.
+ *
+ * POST-CUTOVER ROLE (M-ADR 0205 §4.4, A4): no production path calls this
+ * module — validate/build/aggregate run the engine path. It remains as the
+ * reference side of the standing differential (parity-harness.ts and the
+ * estate sweep driver), so implementation drift between the two gets
+ * caught by the suite instead of lurking.
+ */
+/** The stamp column M-ADR 0208 §4.4 keys on. */
+export const PLATFORM_STAMP_COLUMN = "platform_sdd_id";
+/**
+ * Whether the FK `cat.fk → targetCat` resolves under the platform-scoped
+ * key (see FkValidationOptions.platformScopedTargets). One definition,
+ * shared with the query generator so the two paths cannot drift.
+ */
+export function isPlatformScopedFk(cat, targetCat, options) {
+    if (!(options.platformScopedTargets ?? []).includes(targetCat.name))
+        return false;
+    const has = (c) => c.columns.some((col) => col.name === PLATFORM_STAMP_COLUMN);
+    return has(cat) && has(targetCat);
+}
+/**
+ * Build an in-memory map of every catalogue's primary-key set, then walk
+ * every row's FK columns and check resolution.
+ */
+export function validateForeignKeys(schema, rowsByCatalogue, findings, options = {}) {
+    // Index primary keys per catalogue, and — for platform-scoped targets —
+    // the set of stamps each pk is present under ('' for an unstamped row).
+    const pkIndex = new Map();
+    const stampIndex = new Map();
+    const catByName = new Map(schema.catalogues.map((c) => [c.name, c]));
+    for (const cat of schema.catalogues) {
+        const rows = rowsByCatalogue.get(cat.name) ?? [];
+        const pks = new Set();
+        const stamps = new Map();
+        for (const row of rows) {
+            const pk = row[cat.primaryKey];
+            if (pk !== undefined && pk !== null && pk !== "") {
+                pks.add(String(pk));
+                const stamp = String(row[PLATFORM_STAMP_COLUMN] ?? "");
+                const set = stamps.get(String(pk)) ?? new Set();
+                set.add(stamp);
+                stamps.set(String(pk), set);
+            }
+        }
+        pkIndex.set(cat.name, pks);
+        stampIndex.set(cat.name, stamps);
+    }
+    const failures = [];
+    let externalCount = 0;
+    for (const cat of schema.catalogues) {
+        const rows = rowsByCatalogue.get(cat.name) ?? [];
+        for (const fk of cat.foreignKeys) {
+            // Effective-external (2.23.0): declared external OR external for the
+            // profile under build. Governs the resolution skip only — the
+            // required-empty check below stays keyed on the DECLARED `external` so
+            // a profile-external FK still requires a (cross-SDD) value to be named.
+            const effectiveExternal = fk.external ||
+                (options.profile !== undefined &&
+                    (fk.externalForProfiles ?? []).includes(options.profile));
+            const [targetCat, targetCol] = fk.references.split(".");
+            if (!targetCat || !targetCol) {
+                throw new Error(`malformed FK reference "${fk.references}" on ${cat.name}.${fk.column}`);
+            }
+            const targetPks = pkIndex.get(targetCat);
+            const targetDef = catByName.get(targetCat);
+            if (!targetPks || !targetDef) {
+                throw new Error(`FK ${cat.name}.${fk.column} references unknown catalogue "${targetCat}"`);
+            }
+            const scoped = isPlatformScopedFk(cat, targetDef, options);
+            const targetStamps = stampIndex.get(targetCat);
+            for (const row of rows) {
+                const raw = row[fk.column];
+                if (raw === undefined || raw === null || raw === "") {
+                    if (!fk.nullable && !fk.external) {
+                        // Required FK with no value — internal violation regardless of external flag.
+                        failures.push({
+                            catalogue: cat.name,
+                            column: fk.column,
+                            referencingRow: String(row[cat.primaryKey] ?? ""),
+                            value: "",
+                            target: fk.references,
+                        });
+                    }
+                    continue;
+                }
+                const value = String(raw);
+                let resolved = targetPks.has(value);
+                if (resolved && scoped) {
+                    const mine = String(row[PLATFORM_STAMP_COLUMN] ?? "");
+                    const theirs = targetStamps.get(value) ?? new Set();
+                    resolved = mine === "" || theirs.has("") || theirs.has(mine);
+                }
+                if (effectiveExternal && !options.treatExternalAsInternal) {
+                    if (!resolved) {
+                        // Per spec: optimistically resolve against own rows; only log when unresolved.
+                        externalCount++;
+                        findings.add("external", `${cat.name}.${fk.column} → ${fk.references}=${value} ` +
+                            `(referencing row pk=${row[cat.primaryKey] ?? "?"}; resolves at aggregation)`);
+                    }
+                    continue;
+                }
+                if (!resolved) {
+                    failures.push({
+                        catalogue: cat.name,
+                        column: fk.column,
+                        referencingRow: String(row[cat.primaryKey] ?? ""),
+                        value,
+                        target: fk.references,
+                    });
+                }
+            }
+        }
+    }
+    return {
+        internalPass: failures.length === 0,
+        internalFailures: failures,
+        externalFindings: externalCount,
+    };
+}
+//# sourceMappingURL=fk-validator.js.map

package/dist/lib/catalogue/freshness.js

@@ -0,0 +1,70 @@
+/**
+ * `catalogue build --check`: are the committed catalogues what the committed specs build to?
+ * (M-ADR 0218 §5, bead sdm-jts.6.)
+ *
+ * Builds into a temporary directory and compares, so it writes nothing into the SDD. Only what
+ * the build PRODUCES is compared: a hand-written file that happens to sit in catalogues/ (a
+ * README, say) is not a build output and is ignored. Stale means either a produced file whose
+ * bytes differ from the committed one, or a produced file the SDD has not committed, or a
+ * committed catalogue the build no longer produces.
+ *
+ * Measured before building it: an isolated clone (no siblings) of an application, an
+ * integration, a platform root and a packaged SDD rebuilt byte-identically to what each had
+ * committed, so a fresh SDD passes and the check flags only real drift. Catalogue content is a
+ * function of committed content, not of the commit: nothing stamps HEAD's sha.
+ */
+import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runCatalogueBuild } from "./build.js";
+/** Stale files: produced but differing or uncommitted, and committed .csv the build no longer produces. Pure over two directories. */
+export async function compareCatalogueDirs(producedDir, committedDir) {
+    const produced = (await readdir(producedDir)).sort();
+    const committed = existsSync(committedDir) ? (await readdir(committedDir)).sort() : [];
+    const stale = [];
+    for (const f of produced) {
+        if (!committed.includes(f)) {
+            stale.push(`${f} (produced, not committed)`);
+            continue;
+        }
+        const [a, b] = await Promise.all([readFile(join(producedDir, f)), readFile(join(committedDir, f))]);
+        if (!a.equals(b))
+            stale.push(`${f} (differs)`);
+    }
+    for (const f of committed) {
+        if (f.endsWith(".csv") && !produced.includes(f))
+            stale.push(`${f} (committed, no longer produced)`);
+    }
+    return stale;
+}
+export async function checkCataloguesFresh(sddPath, opts, out) {
+    const label = opts.label ?? "catalogue build --check";
+    const tmp = await mkdtemp(join(tmpdir(), "sdd-catalogue-check-"));
+    try {
+        const built = await runCatalogueBuild({
+            sddPath,
+            outDir: tmp,
+            ...(opts.strict !== undefined ? { strict: opts.strict } : {}),
+            ...(opts.snapshotStore !== undefined ? { snapshotStore: opts.snapshotStore } : {}),
+        }, () => { });
+        if (built.exitCode !== 0) {
+            out(`[FAIL] ${label}: the build itself failed (exit ${built.exitCode}); run catalogue build to see why.\n`);
+            return { exitCode: built.exitCode, stale: [] };
+        }
+        const produced = (await readdir(tmp)).sort();
+        const stale = await compareCatalogueDirs(tmp, join(sddPath, "catalogues"));
+        if (stale.length === 0) {
+            out(`[PASS] ${label}: ${produced.length} catalogue file(s) reproduce byte-identically from the committed specs.\n`);
+            return { exitCode: 0, stale };
+        }
+        out(`[FAIL] ${label}: ${stale.length} catalogue file(s) are stale against the committed specs — catalogue build (sdd-maintain or sdd-cli) rebuilds them:\n`);
+        for (const s of stale)
+            out(`  ${s}\n`);
+        return { exitCode: 1, stale };
+    }
+    finally {
+        await rm(tmp, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=freshness.js.map

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