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

package/dist/lib/catalogue/builders/repo-capability-exemption.js

@@ -0,0 +1,61 @@
+// repo_capability_exemption builder — M-ADR 0188 §4.3.
+//
+// Emits one row per repo-config declaring a `capability_exemption:` block:
+//
+//   capability_exemption:
+//     reason: infrastructure   # closed vocabulary, see canonical-schema.yaml
+//     note: "Terraform modules; provisions the estate, realises no capability."
+//
+// The table exists so that "this repository deliberately bears no capability"
+// is a fact in the model rather than an absence in it. Under M-ADR 0188 §4.1
+// every `repositories` row must resolve — by a `repo_capability` edge, or by a
+// row here. FK integrity cannot express that: a missing edge is not a dangling
+// reference, it is nothing, and nothing is what a referential check is blind
+// to. Coverage is a participation constraint, checked, not declared.
+//
+// VALIDATION ORDER IS LOad-BEARING. Every rejection below drops the exemption
+// row and leaves the repository unresolved — reported as an orphan by
+// `check-repo-capability-coverage.sh`. It never drops the repository. An
+// exemption that fails validation must not quietly succeed at the one thing an
+// exemption does, which is remove a repository from the invariant's attention.
+// Fail open on the row; fail closed on the repository.
+export function buildRepoCapabilityExemption(inputs) {
+    const rows = [];
+    const seen = new Set();
+    for (const cfg of inputs.configs) {
+        const block = cfg.data.capability_exemption;
+        if (block === undefined || block === null)
+            continue;
+        const reason = typeof block.reason === "string" ? block.reason.trim() : "";
+        const note = typeof block.note === "string" ? block.note.trim() : "";
+        if (reason === "") {
+            inputs.findings.add("convention", `${cfg.relPath}: capability_exemption declares no reason — exemption dropped, repo stays unresolved (per M-ADR 0188 §4.2)`);
+            continue;
+        }
+        if (!inputs.allowedReasons.has(reason)) {
+            const allowed = [...inputs.allowedReasons].sort().join(", ");
+            inputs.findings.add("convention", `${cfg.relPath}: capability_exemption reason "${reason}" is outside the closed vocabulary (${allowed}) — exemption dropped, repo stays unresolved (per M-ADR 0188 §4.2)`);
+            continue;
+        }
+        // The note is what makes an exemption reviewable rather than merely
+        // countable. An unexplained suppression is a defect; an explained one is
+        // a decision. The method takes the lint-suppression position here.
+        if (note === "") {
+            inputs.findings.add("convention", `${cfg.relPath}: capability_exemption (${reason}) has an empty note — exemption dropped, repo stays unresolved (per M-ADR 0188 §4.2)`);
+            continue;
+        }
+        if (inputs.knownRepoIds !== undefined &&
+            !inputs.knownRepoIds.has(cfg.repoId)) {
+            continue;
+        }
+        const id = cfg.repoId;
+        if (seen.has(id)) {
+            inputs.findings.add("divergence", `${cfg.relPath}: duplicate capability_exemption for repo ${cfg.repoId} — first declaration wins`);
+            continue;
+        }
+        seen.add(id);
+        rows.push({ id, repo_id: cfg.repoId, reason, note });
+    }
+    return rows;
+}
+//# sourceMappingURL=repo-capability-exemption.js.map

package/dist/lib/catalogue/builders/repo-dependency.js

@@ -0,0 +1,127 @@
+// repo_dependency — a repository depends on another repository's code without either
+// being a running service: a library linked at build time, or a template family it was
+// generated from (M-ADR 0217, schema 3.20.0).
+//
+// Two sources, merged by id (M-ADR 0157 parity):
+//   DECLARED  repo-config `depends_on: [{repo, kind, version?}]`; from_repo_id is the
+//             repository the repo-config describes. `kind` is required, so a provenance
+//             dependency is never recorded as a library by default.
+//   DERIVED   a per-component integration manifest's `dependencies.sharedLibraries`
+//             (`repos/<member>/integration-manifest.yaml`), each entry kind `library`,
+//             from_repo_id the member directory. `none` is a declared absence.
+// The declared row wins `version` and `declared_in` when both name one dependency.
+//
+// to_repo_id is EXTERNAL: it may belong to another SDD, so build reports what it cannot
+// resolve and the aggregator fails what still resolves to nothing. An entry is never
+// renamed or guessed to make it resolve.
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+export const REPO_DEPENDENCY_KINDS = ["library", "generated-from"];
+const rowId = (d) => `${d.from}__${d.to}__${d.kind}`;
+function declared(inputs) {
+    const out = [];
+    for (const cfg of inputs.configs) {
+        const entries = cfg.data.depends_on ?? [];
+        entries.forEach((raw, i) => {
+            const where = `${cfg.relPath}: depends_on[${i}]`;
+            if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+                inputs.findings.add("convention", `${where}: expected a mapping {repo, kind, version?} — entry skipped (M-ADR 0217 §4.2)`);
+                return;
+            }
+            const e = raw;
+            const repo = typeof e["repo"] === "string" ? e["repo"].trim() : "";
+            const kind = typeof e["kind"] === "string" ? e["kind"].trim() : "";
+            if (repo === "") {
+                inputs.findings.add("convention", `${where}: no repo — entry skipped (M-ADR 0217 §4.2)`);
+                return;
+            }
+            if (!REPO_DEPENDENCY_KINDS.includes(kind)) {
+                inputs.findings.add("convention", `${where}: kind "${kind}" is not one of ${REPO_DEPENDENCY_KINDS.join(" | ")} — entry skipped. ` +
+                    `kind is required: a provenance dependency is never recorded as a library by default (M-ADR 0217 §4.2)`);
+                return;
+            }
+            const version = e["version"] === undefined || e["version"] === null ? "" : String(e["version"]).trim();
+            out.push({ from: cfg.repoId, to: repo, kind: kind, version, declaredIn: cfg.relPath });
+        });
+    }
+    return out;
+}
+async function derived(inputs) {
+    let dirs;
+    try {
+        dirs = (await readdir(join(inputs.sddPath, "repos"), { withFileTypes: true }))
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .sort();
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const out = [];
+    for (const dir of dirs) {
+        const rel = `repos/${dir}/integration-manifest.yaml`;
+        let text;
+        try {
+            text = await readFile(join(inputs.sddPath, rel), "utf-8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        let doc;
+        try {
+            doc = parseYaml(text);
+        }
+        catch {
+            continue; // integration_component already reports an unparsable manifest
+        }
+        const deps = doc?.dependencies;
+        const libs = deps?.sharedLibraries;
+        if (libs === undefined || libs === null)
+            continue; // the field is optional; absence is no finding
+        if (!Array.isArray(libs)) {
+            inputs.findings.add("convention", `${rel}: dependencies.sharedLibraries is not a list — ignored (M-ADR 0217 §4.2)`);
+            continue;
+        }
+        const names = libs.map((l) => String(l).trim()).filter((l) => l !== "" && l !== "none");
+        if (names.length === 0)
+            continue; // `none` is a declared absence
+        // from_repo_id is an INTERNAL key: the member directory must be one of this SDD's
+        // repositories, or the row would fail the build's own FK check.
+        if (!inputs.knownRepoIds.has(dir)) {
+            inputs.findings.add("coverage", `repo_dependency: ${rel} declares ${names.length} shared librar${names.length === 1 ? "y" : "ies"} but its directory "${dir}" is no repositories.id in this SDD — not emitted. Catalogue the repository or correct the directory name.`);
+            continue;
+        }
+        for (const to of names)
+            out.push({ from: dir, to, kind: "library", version: "", declaredIn: rel });
+    }
+    return out;
+}
+export async function buildRepoDependencies(inputs) {
+    const byId = new Map();
+    for (const d of await derived(inputs))
+        if (!byId.has(rowId(d)))
+            byId.set(rowId(d), d);
+    // Declared second, so it overrides version and declared_in.
+    for (const d of declared(inputs)) {
+        const prior = byId.get(rowId(d));
+        byId.set(rowId(d), prior === undefined ? d : { ...d, version: d.version !== "" ? d.version : prior.version });
+    }
+    return [...byId.values()]
+        .sort((a, b) => rowId(a).localeCompare(rowId(b)))
+        .map((d) => ({
+        id: rowId(d),
+        from_repo_id: d.from,
+        to_repo_id: d.to,
+        kind: d.kind,
+        version: d.version,
+        declared_in: d.declaredIn,
+        source_sdd_id: "",
+        platform_sdd_id: "",
+    }));
+}
+//# sourceMappingURL=repo-dependency.js.map

package/dist/lib/catalogue/builders/repo-edges.js

@@ -0,0 +1,340 @@
+// Repo-edge builders — repo_capability, repo_contract, feature_repo.
+//
+// Per ADR 0157 (Forward-Declared / Reverse-Derived Parity for Edge Catalogues):
+// both edges ingest from forward-method declared sources AND reverse-method
+// derived sources, merged by primary-key deduplication. The two paths are
+// equal-status per the parity principle; neither displaces the other.
+//
+// Forward-method declared sources (typically authored by forward-method
+// adopters in `orchestration/repo-config/<domain>/<repo>.yaml`):
+//
+//   capabilities:                                    # M-ADR 0188 §6.1
+//     - <capability spec_path, exactly as emitted in capabilities.csv>
+//
+// The spec_path layout is profile-dependent, NOT fixed — a reverse platform SDD emits
+// `docs/domains/<domain>/product/<capability>.md`, a forward application-product may emit
+// `docs/<capability>.md`. Match against capabilities.csv, never against a path convention.
+//
+//   additional_context:                              # legacy, multi-purpose
+//     - docs/domains/<domain>/product/<capability>.md
+//     - docs/domains/<domain>/architecture/adr/ADR XXXX: ....md
+//
+//   contracts:
+//     openapi: [<path-relative-to-contracts/openapi/>]
+//     proto:   [<path-relative-to-contracts/proto/>]
+//     avro:    [<path-relative-to-contracts/avro/>]
+//
+// Reverse-method derived sources (universal — work for any SDD with the
+// underlying catalogue rows populated):
+//
+//   repo_contract Path X (universal) — `service_contract ⋈
+//     services.primary_repo_id`. A service exposing a contract is implemented
+//     by a repo (its primary_repo_id) — the repo "owns" the contract by
+//     transitive inference. Works universally because primary_repo_id and
+//     service_contract are core-schema populated. Added per ADR 0157 §4.2
+//     amendment after an early-adopter 0/30 source_repo_id outcome.
+//   repo_contract Path Y — `contracts.source_repo_id` denormalisation
+//     (from OpenAPI `x-source-repo` hints per ADR 0110, or whatever
+//     populates the column). Augments Path X when adopters carry the hint.
+//   repo_capability Path X (universal) — `capability_service ⋈
+//     services.primary_repo_id`. Works in both forward and reverse method
+//     shapes because primary_repo_id is core-schema and capability_service
+//     is heavily authored.
+//   repo_capability Path Y (augments via ADR 0143 feature-grounding) —
+//     `capability_feature ⋈ feature_repo`. Adopters who have adopted the
+//     feature-grounding extractor get many additional rows.
+//
+// feature_repo: ADR 0143's feature-grounding extractor populates this in
+// build.ts (10a). The forward declared `contributes_to.artifact_type:
+// feature-set` path is documented in the metamodel but unused by any
+// observed adopter — left empty here pending first-adopter authoring.
+import { basename, sep } from "node:path";
+import { normaliseAdditionalContextEntry, } from "./repositories.js";
+/**
+ * feature_repo derivation — `feature_service ⋈ services.primary_repo_id`.
+ *
+ * The same shape as repo_capability's Path X one rung down the hierarchy: a
+ * feature implemented by a service is implemented in the repo that builds that
+ * service. Added per D8 of the catalogue-coverage-invariants work, and only
+ * become POSSIBLE once the app-product Feature Services table was wired into
+ * feature_service (0.115.0) — before that the join's left side was empty in the
+ * profile where feature_repo had no source at all.
+ *
+ * ⚠ IT KEYS ON `primary_repo_id`, A DECLARED FK — NOT ON THE `service.id ==
+ * repo.id` IDENTITY. That distinction is why M-ADR 0197 does not endanger it:
+ * 0197 breaks the identity, and Phase A explicitly preserves primary_repo_id on
+ * every declared entry. Path X is identity-VALUED today, not
+ * identity-DEPENDENT, and so is this. A first review of D8 flagged the opposite
+ * and was wrong.
+ *
+ * Caller supplies `existingIds` so this only ever ADDS: the ADR 0143
+ * feature-grounding extractor and the capability-spec walker own their rows and
+ * are authoritative where they overlap.
+ */
+export function deriveFeatureRepoFromServices(inputs) {
+    const repoBySvc = new Map();
+    for (const s of inputs.serviceRows) {
+        const sid = String(s["id"] ?? "");
+        const rid = String(s["primary_repo_id"] ?? "");
+        if (sid !== "" && rid !== "")
+            repoBySvc.set(sid, rid);
+    }
+    const rows = [];
+    const seen = new Set(inputs.existingIds);
+    for (const fs of inputs.featureServiceRows) {
+        const featureId = String(fs["feature_id"] ?? "");
+        const svcId = String(fs["service_id"] ?? "");
+        if (featureId === "" || svcId === "")
+            continue;
+        const repoId = repoBySvc.get(svcId);
+        // A service with no primary_repo_id contributes nothing — silently, because
+        // repo_contract's Path X already reports that condition once per build and
+        // a second identical finding per feature would be noise, not signal.
+        if (repoId === undefined)
+            continue;
+        // Never emit a dangling repo reference. Measured across two estates at the
+        // time of writing: 0 of 1,221 derived rows referenced an unresolvable
+        // primary_repo_id, so this guard is a safety net rather than a filter.
+        if (!inputs.knownRepoIds.has(repoId))
+            continue;
+        const id = `${featureId}__${repoId}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        rows.push({ id, feature_id: featureId, repo_id: repoId });
+    }
+    return rows;
+}
+export function buildRepoEdges(inputs) {
+    const repoCapability = collectRepoCapability(inputs);
+    const repoContract = collectRepoContract(inputs);
+    // feature_repo is populated later in build.ts by the ADR 0143
+    // feature-grounding extractor; this builder doesn't contribute.
+    const featureRepo = [];
+    return { repoCapability, repoContract, featureRepo };
+}
+function collectRepoCapability(inputs) {
+    const rows = [];
+    const seen = new Set();
+    const serviceRows = inputs.serviceRows ?? [];
+    const capabilityServiceRows = inputs.capabilityServiceRows ?? [];
+    const capabilityFeatureRows = inputs.capabilityFeatureRows ?? [];
+    const featureRepoRows = inputs.featureRepoRows ?? [];
+    const knownRepoIds = inputs.knownRepoIds;
+    const emit = (repoId, capId) => {
+        if (knownRepoIds !== undefined && !knownRepoIds.has(repoId))
+            return;
+        const id = `${repoId}__${capId}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        rows.push({ id, repo_id: repoId, capability_id: capId });
+    };
+    // Forward path A — declared in repo-config `capabilities[]` (M-ADR 0188 §6.1).
+    //
+    // This block exists because the older `additional_context[]` path below,
+    // though it works, cannot be validated: the field is multi-purpose, so an
+    // entry that resolves to no capability is indistinguishable from an ADR
+    // reference and must be skipped in silence. A typo'd capability path is
+    // therefore undetectable there — which is why, on the reference estate,
+    // 0 of 377 repo-configs used it to declare a capability and 264 repos
+    // resolved to nothing.
+    //
+    // `capabilities[]` is single-purpose. Every entry is an assertion that this
+    // repository realises that capability, so a non-match is an authoring error
+    // and is reported as one. Same edge, same table; the difference is that this
+    // surface can tell you when you got it wrong.
+    for (const cfg of inputs.configs) {
+        for (const rawEntry of cfg.data.capabilities ?? []) {
+            const cleaned = rawEntry.replace(/^\/+/, "").trim();
+            if (cleaned === "")
+                continue;
+            const capId = inputs.capabilityIdByPath.get(cleaned);
+            if (capId === undefined) {
+                inputs.findings.add("orphan", `${cfg.relPath}: capabilities entry "${cleaned}" did not match any capability spec_path (per M-ADR 0188 §6.1)`);
+                continue;
+            }
+            emit(cfg.repoId, capId);
+        }
+    }
+    // Forward path B (legacy) — declared in repo-config additional_context[].
+    for (const cfg of inputs.configs) {
+        const extras = cfg.data.additional_context ?? [];
+        for (const raw of extras) {
+            const reconstructed = normaliseAdditionalContextEntry(raw);
+            if (reconstructed === null)
+                continue;
+            const cleaned = reconstructed.replace(/^\/+/, "");
+            const capId = inputs.capabilityIdByPath.get(cleaned);
+            if (capId === undefined) {
+                // Not a capability spec path (likely an ADR file or freeform doc).
+                // additional_context is intentionally multi-purpose; only matches
+                // that resolve to capabilities count. Cannot warn here — see above.
+                continue;
+            }
+            emit(cfg.repoId, capId);
+        }
+    }
+    // Reverse path X (universal) — capability_service ⋈ services.primary_repo_id.
+    const repoBySvcId = new Map();
+    for (const s of serviceRows) {
+        const sid = String(s["id"]);
+        const repoId = String(s["primary_repo_id"] ?? "");
+        if (sid !== "" && repoId !== "")
+            repoBySvcId.set(sid, repoId);
+    }
+    // M-ADR 0157 §4.3 (amended): `repo_capability` means "repo CONTRIBUTES to
+    // capability". A capability_service row with role `dependency` says the
+    // capability DEPENDS ON the service — the inverse direction — so its repo
+    // does not contribute and Path X skips it. `primary`, `related` and
+    // `backend-gateway` all participate in delivering the capability and stay.
+    // Measured before the filter: 62% of one estate's repo_capability rows and
+    // one row of another's rested on non-primary roles; `related` was realising
+    // in every measured use, so only `dependency` is excluded.
+    let dependencyRowsSkipped = 0;
+    for (const cs of capabilityServiceRows) {
+        const svcId = String(cs["service_id"] ?? "");
+        const capId = String(cs["capability_id"] ?? "");
+        if (svcId === "" || capId === "")
+            continue;
+        if (String(cs["role"] ?? "").trim() === "dependency") {
+            dependencyRowsSkipped++;
+            continue;
+        }
+        const repoId = repoBySvcId.get(svcId);
+        if (repoId === undefined)
+            continue;
+        emit(repoId, capId);
+    }
+    if (dependencyRowsSkipped > 0) {
+        inputs.findings.add("coverage", `repo_capability: ${dependencyRowsSkipped} capability_service rows with role "dependency" excluded from Path X — a dependency is the inverse direction of "repo contributes to capability" (M-ADR 0157 §4.3 as amended); the relationship itself is unchanged in capability_service`);
+    }
+    // Surface a single summary finding when capability_service rows exist with
+    // services lacking primary_repo_id. The walker quietly skips those edges;
+    // this finding tells the reader why the universal path missed some.
+    let missingPrimaryRepoSvcs = 0;
+    for (const cs of capabilityServiceRows) {
+        const svcId = String(cs["service_id"] ?? "");
+        if (svcId === "")
+            continue;
+        if (!repoBySvcId.has(svcId))
+            missingPrimaryRepoSvcs++;
+    }
+    if (missingPrimaryRepoSvcs > 0) {
+        inputs.findings.add("orphan", `repo_capability: ${missingPrimaryRepoSvcs} capability_service rows reference services with empty primary_repo_id — reverse-method Path X (capability_service ⋈ services.primary_repo_id) skipped those edges (per ADR 0157 §4.3)`);
+    }
+    // Reverse path Y — capability_feature ⋈ feature_repo (transitive via ADR 0143).
+    const featuresToRepos = new Map();
+    for (const fr of featureRepoRows) {
+        const fid = String(fr["feature_id"] ?? "");
+        const rid = String(fr["repo_id"] ?? "");
+        if (fid === "" || rid === "")
+            continue;
+        if (!featuresToRepos.has(fid))
+            featuresToRepos.set(fid, new Set());
+        featuresToRepos.get(fid).add(rid);
+    }
+    for (const cf of capabilityFeatureRows) {
+        const fid = String(cf["feature_id"] ?? "");
+        const cid = String(cf["capability_id"] ?? "");
+        if (fid === "" || cid === "")
+            continue;
+        const repos = featuresToRepos.get(fid);
+        if (!repos)
+            continue;
+        for (const repoId of repos)
+            emit(repoId, cid);
+    }
+    return rows;
+}
+function collectRepoContract(inputs) {
+    const rows = [];
+    const seen = new Set();
+    const contractRows = inputs.contractRows ?? [];
+    const serviceRows = inputs.serviceRows ?? [];
+    const serviceContractRows = inputs.serviceContractRows ?? [];
+    const knownRepoIds = inputs.knownRepoIds;
+    const emit = (repoId, contractId) => {
+        if (knownRepoIds !== undefined && !knownRepoIds.has(repoId))
+            return;
+        const id = `${repoId}__${contractId}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        rows.push({ id, repo_id: repoId, contract_id: contractId });
+    };
+    // Forward path — declared in repo-config contracts.{openapi,proto,avro}[].
+    // Pre-compute suffix and basename indexes for fuzzy matching.
+    const suffixIndex = new Map();
+    const basenameIndex = new Map();
+    for (const [path, id] of inputs.contractIdByPath) {
+        const parts = path.split(sep);
+        if (parts.length >= 2) {
+            suffixIndex.set(parts.slice(-2).join("/"), id);
+        }
+        basenameIndex.set(basename(path), id);
+    }
+    for (const cfg of inputs.configs) {
+        const block = cfg.data.contracts;
+        if (!block)
+            continue;
+        for (const kind of ["openapi", "proto", "avro"]) {
+            const list = block[kind] ?? [];
+            for (const rawEntry of list) {
+                const entry = rawEntry.replace(/^\/+/, "");
+                const fullCandidate = `contracts/${kind}/${entry}`;
+                const id = inputs.contractIdByPath.get(fullCandidate)
+                    ?? inputs.contractIdByPath.get(entry)
+                    ?? suffixIndex.get(fullCandidate)
+                    ?? suffixIndex.get(entry)
+                    ?? basenameIndex.get(basename(entry));
+                if (id === undefined) {
+                    inputs.findings.add("orphan", `${cfg.relPath}: contracts.${kind} entry "${entry}" did not match any contract`);
+                    continue;
+                }
+                emit(cfg.repoId, id);
+            }
+        }
+    }
+    // Reverse path X (universal) — service_contract ⋈ services.primary_repo_id.
+    // A service exposing a contract is implemented by a repo; the repo "owns"
+    // the contract by transitive inference. Added per ADR 0157 §4.2 amendment
+    // (an early adopter's source_repo_id was 0/30 populated, so
+    // a derivation that depends only on it leaves them empty).
+    const repoBySvcId = new Map();
+    for (const s of serviceRows) {
+        const sid = String(s["id"]);
+        const repoId = String(s["primary_repo_id"] ?? "");
+        if (sid !== "" && repoId !== "")
+            repoBySvcId.set(sid, repoId);
+    }
+    let missingPrimaryRepoSvcs = 0;
+    for (const sc of serviceContractRows) {
+        const svcId = String(sc["service_id"] ?? "");
+        const ctrId = String(sc["contract_id"] ?? "");
+        if (svcId === "" || ctrId === "")
+            continue;
+        const repoId = repoBySvcId.get(svcId);
+        if (repoId === undefined) {
+            missingPrimaryRepoSvcs++;
+            continue;
+        }
+        emit(repoId, ctrId);
+    }
+    if (missingPrimaryRepoSvcs > 0) {
+        inputs.findings.add("orphan", `repo_contract: ${missingPrimaryRepoSvcs} service_contract rows reference services with empty primary_repo_id — reverse-method Path X (service_contract ⋈ services.primary_repo_id) skipped those edges (per ADR 0157 §4.2)`);
+    }
+    // Reverse path Y — contracts.source_repo_id denormalisation.
+    // Adopters who carry OpenAPI x-source-repo hints (per ADR 0110) or whose
+    // contracts builder otherwise populates source_repo_id get one row per
+    // (source_repo_id, contract.id) for free.
+    for (const c of contractRows) {
+        const cid = String(c["id"]);
+        const srcRepo = String(c["source_repo_id"] ?? "");
+        if (cid === "" || srcRepo === "")
+            continue;
+        emit(srcRepo, cid);
+    }
+    return rows;
+}
+//# sourceMappingURL=repo-edges.js.map