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

package/dist/lib/catalogue/builders/event-catalog-walker.js

@@ -0,0 +1,186 @@
+// Walker for `docs/domains/<domain>/contracts/events/event-catalog.yaml` —
+// the reverse-method canonical source for events per ADR 0156.
+//
+// One file per domain. Each `events[]` entry encodes the event's name,
+// publisher_service_id, transport, schema_path, version, and consumers[].
+// The walker emits rows for both `events.csv` and `service_event.csv`
+// (publisher → publishes role; consumers[] → consumes role).
+//
+// Merges with the avsc-sourced forward path in events.ts: YAML wins on
+// name/domain/publisher/transport/consumers; avsc augments schema_path/
+// version when the YAML row leaves them null. See ADR 0156 §4 and the
+// metamodel's §"Event sources" subsection for the precedence rules.
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+const RECOMMENDED_TRANSPORTS = new Set([
+    "kafka",
+    "sns",
+    "sqs",
+    "kinesis",
+    "eventbridge",
+    "mongodb-change-stream",
+    "nats",
+    "activemq",
+    "rabbitmq",
+    "jms",
+    "other",
+]);
+export async function walkEventCatalogs(inputs) {
+    const domainsDir = join(inputs.sddPath, "docs", "domains");
+    const byId = new Map();
+    let domainEntries;
+    try {
+        domainEntries = await readdir(domainsDir, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return { byId };
+        throw err;
+    }
+    for (const entry of domainEntries) {
+        if (!entry.isDirectory())
+            continue;
+        const domain = entry.name;
+        const manifestPath = join(domainsDir, domain, "contracts", "events", "event-catalog.yaml");
+        let text;
+        try {
+            text = await readFile(manifestPath, "utf-8");
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT")
+                continue;
+            throw err;
+        }
+        let raw;
+        try {
+            raw = parseYaml(text);
+        }
+        catch (err) {
+            inputs.findings.add("convention", `docs/domains/${domain}/contracts/events/event-catalog.yaml: failed to parse YAML — ${err.message}`);
+            continue;
+        }
+        if (!raw || typeof raw !== "object")
+            continue;
+        const rawObj = raw;
+        const events = rawObj["events"];
+        if (!Array.isArray(events))
+            continue;
+        // File-level evidence-class fallback for events that don't declare
+        // their own (ADR 0175). Both key spellings accepted.
+        const fileEvidenceClass = String(rawObj["evidence_class"] ?? rawObj["evidence-class"] ?? "").trim();
+        // Track slugs derived within this domain so we can flag duplicates.
+        const slugsInDomain = new Set();
+        for (const event of events) {
+            if (!event || typeof event !== "object")
+                continue;
+            const e = event;
+            const explicitId = String(e["id"] ?? "").trim();
+            const name = String(e["name"] ?? "").trim();
+            // Derive id: explicit id wins when present (allows future override);
+            // otherwise slug from name. Original ADR 0156 coordination doc spec:
+            // "derive `id` from `name` (slugged)". Some adopters' authoring uses
+            // `name:` only (no `id:` field).
+            let id;
+            if (explicitId !== "") {
+                id = explicitId;
+            }
+            else if (name !== "") {
+                id = slugify(name);
+                if (slugsInDomain.has(id)) {
+                    inputs.findings.add("divergence", `docs/domains/${domain}/contracts/events/event-catalog.yaml: duplicate slug-derived id "${id}" in domain ${domain} (from name "${name}") — first-seen kept`);
+                    continue;
+                }
+                slugsInDomain.add(id);
+            }
+            else {
+                inputs.findings.add("convention", `docs/domains/${domain}/contracts/events/event-catalog.yaml: event entry missing both 'id' and 'name' — skipped`);
+                continue;
+            }
+            // Display name: explicit name wins; fall back to id when name absent.
+            const displayName = name !== "" ? name : id;
+            const publisher = String(e["publisher_service_id"] ?? e["producer"] ?? "").trim();
+            const transport = String(e["transport"] ?? "").trim();
+            const schemaPath = String(e["schema_path"] ?? "").trim();
+            const version = String(e["version"] ?? "").trim();
+            const ownEvidenceClass = String(e["evidence_class"] ?? e["evidence-class"] ?? "").trim();
+            const evidenceClass = ownEvidenceClass !== "" ? ownEvidenceClass : fileEvidenceClass;
+            const consumersRaw = e["consumers"];
+            const consumers = [];
+            if (Array.isArray(consumersRaw)) {
+                for (const c of consumersRaw) {
+                    const cstr = String(c ?? "").trim();
+                    if (cstr !== "")
+                        consumers.push(cstr);
+                }
+            }
+            if (transport !== "" && !RECOMMENDED_TRANSPORTS.has(transport)) {
+                inputs.findings.add("convention", `docs/domains/${domain}/contracts/events/event-catalog.yaml: event ${id} transport "${transport}" outside recommended set (per ADR 0156)`);
+            }
+            if (byId.has(id)) {
+                inputs.findings.add("divergence", `event ${id} declared in multiple event-catalog.yaml files — first-seen kept`);
+                continue;
+            }
+            byId.set(id, {
+                id,
+                name: displayName,
+                domain,
+                publisher,
+                transport,
+                schemaPath,
+                version,
+                consumers,
+                evidenceClass,
+            });
+        }
+    }
+    return { byId };
+}
+/**
+ * Slugify an event name into an id.
+ *
+ * - Inserts a hyphen at camelCase boundaries (`AssetTwin` → `Asset-Twin`).
+ * - Lowercases.
+ * - Replaces any run of non-alphanumeric characters with a single hyphen.
+ * - Trims leading/trailing hyphens.
+ *
+ * Mirrors the slug derivation used elsewhere in the builder for consistency
+ * (capability ids, feature ids).
+ */
+function slugify(s) {
+    return s
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Merge a YAML-parsed event with the equivalent avsc-derived row. YAML wins
+ * on name/domain/publisher/transport per ADR 0156 §4.1; avsc augments
+ * schema_path/version only when the YAML row leaves them empty.
+ *
+ * Returns a fresh CatalogueRow ready to write into events.csv.
+ */
+export function mergeYamlAndAvsc(yaml, avsc) {
+    const schemaPath = yaml.schemaPath !== ""
+        ? yaml.schemaPath
+        : String(avsc?.["schema_path"] ?? "");
+    const version = yaml.version !== ""
+        ? yaml.version
+        : String(avsc?.["version"] ?? "");
+    return {
+        id: yaml.id,
+        name: yaml.name,
+        publisher_service_id: yaml.publisher,
+        domain_id: yaml.domain,
+        transport: yaml.transport,
+        schema_path: schemaPath,
+        version,
+        // YAML-only field — avsc has no evidence slot, so YAML wins outright.
+        evidence_class: yaml.evidenceClass,
+        source_sdd_id: "",
+    };
+}
+//# sourceMappingURL=event-catalog-walker.js.map

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

@@ -0,0 +1,327 @@
+// service_event + capability_event edge builders.
+//
+// service_event sources (per ADR 0156):
+//   - Forward-method canonical: repo-config `events.produces[].schema`
+//     (role=publishes) and `events.consumes[].schema` (role=consumes).
+//     Each schema is resolved against the contracts.avro index → event id.
+//   - Reverse-method canonical: event-catalog.yaml `publisher_service_id`
+//     (role=publishes) and `consumers[]` (role=consumes).
+//   - Both paths emit; rows merge by (service, event, role) deduplication.
+//
+// `contracts.avro` is NOT a fallback for publishes — it's a build-time list
+// (for code-gen / validation) that consumers commonly declare too. Only
+// the events block + event-catalog.yaml are authoritative for edges.
+//
+// capability_event sources (per ADR 0160, schema 2.14.0):
+//   - Forward shape A — `traceability.events[{id, role}]` (legacy
+//     aspirational shape; unauthored across observed adopters, kept for
+//     compatibility). Emits with source=authored.
+//   - Forward shape B — `traceability.contracts.published_events[]` /
+//     `consumed_events[]` with `{event, status, notes}`. Slug the `event`
+//     field via the same normaliser the events walker uses; check against
+//     `knownEventIds`. Pre-lock sketches (events not yet in events.csv)
+//     fire `[finding] orphan`. Emits with source=authored.
+//   - Derived — `capability_service ⋈ service_event` join on service_id.
+//     Zero-authoring associative path; emits role from service_event.
+//     Per ADR 0160, the over-attribution fan-out is intrinsic to services
+//     that own multiple primary capabilities, so a role filter has no
+//     useful effect (verified on a real corpus: 144 → 144 with primary
+//     filter). The `source=derived` column distinguishes these from
+//     authored edges for governance queries.
+//   - Merge by PK `{capability_id}__{event_id}__{role}`: authored wins;
+//     conflicting authored sources fire `[finding] divergence`.
+//
+// feature_event sources (per ADR 0161, schema 2.15.0):
+//   - Derived only — `feature_service ⋈ service_event` join on service_id.
+//     Completes the capability/feature/service trio of materialised event
+//     edges. There is no authored shape; the authored signal lives at the
+//     service level (`service_event`) and the feature inherits it through
+//     `feature_service`. Every row carries `source=derived` for symmetry
+//     with `capability_event.source`.
+//   - PK is `{feature_id}__{event_id}__{role}` so a feature can carry both
+//     publishes + consumes for the same event without collision.
+import { sep } from "node:path";
+export function buildServiceEvent(inputs) {
+    const rows = [];
+    const seen = new Set();
+    // Interim guard (M-ADR 0197 stopgap, ahead of the Phase B attribution
+    // mechanism): this check pre-dates M-ADR 0197 and always dropped a
+    // non-resolving serviceId silently, on the assumption that knownServiceIds
+    // was always a superset of every repo id — true until a repo could declare
+    // a `services:` block that drops its own default id. The drop stays (a
+    // dangling FK would fail the whole build for what is an authoring
+    // situation), but it must never be silent again: any serviceId absent from
+    // knownServiceIds now names the loss instead of swallowing it. `context`
+    // points at the authoring source so the finding is actionable.
+    const emit = (serviceId, eventId, role, context) => {
+        if (!inputs.knownServiceIds.has(serviceId)) {
+            inputs.findings.add("orphan", `${context}: service_event ${role} edge for service "${serviceId}" dropped — "${serviceId}" does not resolve in services.csv. Check the id matches a repository or a services: block entry (M-ADR 0197); this can also mean the authoring source names something other than a catalogued service.`);
+            return;
+        }
+        if (!inputs.knownEventIds.has(eventId)) {
+            // Same shape as the guard above, unrelated cause: a resolved schema
+            // path or YAML event id that doesn't land a row in events.csv. Not an
+            // M-ADR 0197 case — flagged separately in the same sweep that found
+            // the serviceId guard, fixed here rather than left as the one asymmetry
+            // inside a function just touched for the identical reason.
+            inputs.findings.add("orphan", `${context}: service_event ${role} edge for event "${eventId}" dropped — "${eventId}" does not resolve in events.csv`);
+            return;
+        }
+        const id = `${serviceId}__${eventId}__${role}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        rows.push({ id, service_id: serviceId, event_id: eventId, role });
+    };
+    // Forward-method path: repo-config events.produces/consumes blocks.
+    for (const cfg of inputs.configs) {
+        const events = cfg.data.events;
+        if (!events)
+            continue;
+        for (const entry of events.produces ?? []) {
+            if (!entry.schema)
+                continue;
+            const eid = resolveAvroPath(entry.schema, inputs.contractIdByPath);
+            if (eid !== undefined)
+                emit(cfg.repoId, eid, "publishes", cfg.relPath);
+        }
+        for (const entry of events.consumes ?? []) {
+            if (!entry.schema)
+                continue;
+            const eid = resolveAvroPath(entry.schema, inputs.contractIdByPath);
+            if (eid !== undefined)
+                emit(cfg.repoId, eid, "consumes", cfg.relPath);
+        }
+    }
+    // Reverse-method path: event-catalog.yaml publisher + consumers[].
+    // YAML rows already validated publisher/consumers against knownServiceIds
+    // during events.ts merge, but emit() re-checks defensively.
+    for (const yaml of (inputs.yamlEvents?.values() ?? [])) {
+        if (yaml.publisher !== "") {
+            emit(yaml.publisher, yaml.id, "publishes", `event ${yaml.id}`);
+        }
+        for (const consumer of yaml.consumers) {
+            if (!inputs.knownServiceIds.has(consumer)) {
+                inputs.findings.add("orphan", `event ${yaml.id}: consumer "${consumer}" does not resolve to a known service — service_event edge omitted`);
+                continue;
+            }
+            emit(consumer, yaml.id, "consumes", `event ${yaml.id}`);
+        }
+    }
+    return rows;
+}
+export function buildCapabilityEvent(inputs) {
+    // Authored rows from shapes A + B accumulate first; derived rows are
+    // appended only when no authored row owns the same PK.
+    const authored = new Map();
+    // ---- Shape A: traceability.events[{id, role}] (legacy) -------------
+    for (const m of inputs.manifests) {
+        const capId = m.capability.id;
+        if (!inputs.knownCapabilityIds.has(capId))
+            continue;
+        const events = m.data
+            ?.traceability?.events;
+        if (!Array.isArray(events))
+            continue;
+        for (const entry of events) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const o = entry;
+            const eid = String(o["id"] ?? "").trim();
+            const role = String(o["role"] ?? "").trim();
+            if (eid === "" || (role !== "publishes" && role !== "consumes"))
+                continue;
+            if (!inputs.knownEventIds.has(eid)) {
+                inputs.findings.add("orphan", `${m.relPath}: capability_event references "${eid}" but no such event exists`);
+                continue;
+            }
+            tryEmitAuthored(authored, capId, eid, role, m.relPath, inputs.findings);
+        }
+    }
+    // ---- Shape B: traceability.contracts.{published,consumed}_events[] -
+    // The observed forward-method shape. `event` is a name (often dotted);
+    // slug-normalise via the same convention the events walker uses before
+    // checking against knownEventIds. Pre-lock sketches that don't resolve
+    // are surfaced as `orphan` findings (not silent drops).
+    for (const m of inputs.manifests) {
+        const capId = m.capability.id;
+        if (!inputs.knownCapabilityIds.has(capId))
+            continue;
+        const contracts = m.data?.traceability?.contracts;
+        if (!contracts || typeof contracts !== "object")
+            continue;
+        const c = contracts;
+        for (const [key, role] of [
+            ["published_events", "publishes"],
+            ["consumed_events", "consumes"],
+        ]) {
+            const items = c[key];
+            if (!Array.isArray(items))
+                continue;
+            for (const entry of items) {
+                if (!entry || typeof entry !== "object")
+                    continue;
+                const o = entry;
+                const eventName = String(o["event"] ?? "").trim();
+                if (eventName === "")
+                    continue;
+                const eid = slugifyEventName(eventName);
+                if (eid === "")
+                    continue;
+                if (!inputs.knownEventIds.has(eid)) {
+                    inputs.findings.add("orphan", `${m.relPath}: ${key} entry "${eventName}" doesn't resolve to a known event id "${eid}" (likely a pre-lock sketch — events.csv has no matching row)`);
+                    continue;
+                }
+                tryEmitAuthored(authored, capId, eid, role, m.relPath, inputs.findings);
+            }
+        }
+    }
+    // ---- Derived: capability_service ⋈ service_event --------------------
+    // Pure associative coupling. Per ADR 0160, no role filter — Phase Pre
+    // verified that role=primary filtering gives no reduction in practice
+    // (services that emit events legitimately own multiple primary caps).
+    // Provenance distinguishes derived from authored for governance queries.
+    const derived = [];
+    const derivedSeen = new Set();
+    if (inputs.capabilityServiceRows &&
+        inputs.serviceEventRows &&
+        inputs.serviceEventRows.length > 0) {
+        const capsByService = new Map();
+        for (const cs of inputs.capabilityServiceRows) {
+            const sid = String(cs["service_id"] ?? "");
+            const cid = String(cs["capability_id"] ?? "");
+            if (sid === "" || cid === "")
+                continue;
+            if (!inputs.knownCapabilityIds.has(cid))
+                continue;
+            let bucket = capsByService.get(sid);
+            if (bucket === undefined) {
+                bucket = new Set();
+                capsByService.set(sid, bucket);
+            }
+            bucket.add(cid);
+        }
+        for (const se of inputs.serviceEventRows) {
+            const sid = String(se["service_id"] ?? "");
+            const eid = String(se["event_id"] ?? "");
+            const role = String(se["role"] ?? "");
+            if (sid === "" || eid === "" || (role !== "publishes" && role !== "consumes"))
+                continue;
+            const caps = capsByService.get(sid);
+            if (caps === undefined)
+                continue;
+            for (const cid of caps) {
+                const pk = `${cid}__${eid}__${role}`;
+                if (authored.has(pk))
+                    continue; // authored wins
+                if (derivedSeen.has(pk))
+                    continue;
+                derivedSeen.add(pk);
+                derived.push({
+                    id: pk,
+                    capability_id: cid,
+                    event_id: eid,
+                    role,
+                    source: "derived",
+                });
+            }
+        }
+    }
+    return [...authored.values(), ...derived];
+}
+export function buildFeatureEvent(inputs) {
+    // Derived-only edge per ADR 0161. Mirrors capability_event's derived path
+    // one rung lower in the hierarchy. PK uses three components so the same
+    // feature can hold both publishes + consumes rows for the same event.
+    const rows = [];
+    const seen = new Set();
+    if (inputs.serviceEventRows.length === 0)
+        return rows;
+    // Index: service_id -> features served by that service.
+    const featuresByService = new Map();
+    for (const fs of inputs.featureServiceRows) {
+        const sid = String(fs["service_id"] ?? "");
+        const fid = String(fs["feature_id"] ?? "");
+        if (sid === "" || fid === "")
+            continue;
+        if (!inputs.knownFeatureIds.has(fid))
+            continue;
+        let bucket = featuresByService.get(sid);
+        if (bucket === undefined) {
+            bucket = new Set();
+            featuresByService.set(sid, bucket);
+        }
+        bucket.add(fid);
+    }
+    for (const se of inputs.serviceEventRows) {
+        const sid = String(se["service_id"] ?? "");
+        const eid = String(se["event_id"] ?? "");
+        const role = String(se["role"] ?? "");
+        if (sid === "" || eid === "" || (role !== "publishes" && role !== "consumes"))
+            continue;
+        if (!inputs.knownEventIds.has(eid))
+            continue;
+        const features = featuresByService.get(sid);
+        if (features === undefined)
+            continue;
+        for (const fid of features) {
+            const pk = `${fid}__${eid}__${role}`;
+            if (seen.has(pk))
+                continue;
+            seen.add(pk);
+            rows.push({
+                id: pk,
+                feature_id: fid,
+                event_id: eid,
+                role,
+                source: "derived",
+            });
+        }
+    }
+    return rows;
+}
+function tryEmitAuthored(authored, capId, eid, role, relPath, findings) {
+    const pk = `${capId}__${eid}__${role}`;
+    if (authored.has(pk)) {
+        // Already authored from another source/shape. We don't compare
+        // attributes here (the only fields are PK components); silent dedup
+        // is the right behaviour. Cross-shape divergence at the field level
+        // would only matter if shapes carried attributes beyond the PK.
+        return;
+    }
+    authored.set(pk, {
+        id: pk,
+        capability_id: capId,
+        event_id: eid,
+        role,
+        source: "authored",
+    });
+}
+function slugifyEventName(s) {
+    return s
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function resolveAvroPath(schema, index) {
+    const cleaned = schema.replace(/^\/+/, "");
+    const full = `contracts/avro/${cleaned}`;
+    if (index.has(full))
+        return index.get(full);
+    if (index.has(cleaned))
+        return index.get(cleaned);
+    for (const [path, id] of index) {
+        const parts = path.split(sep);
+        if (parts.length >= 2 && parts.slice(-2).join("/") === cleaned)
+            return id;
+    }
+    const base = cleaned.split("/").slice(-1)[0] ?? cleaned;
+    for (const [path, id] of index) {
+        const parts = path.split(sep);
+        if ((parts[parts.length - 1] ?? "") === base)
+            return id;
+    }
+    return undefined;
+}
+//# sourceMappingURL=event-edges.js.map

package/dist/lib/catalogue/builders/events.js

@@ -0,0 +1,168 @@
+// Events discoverer — emits `events.csv` from two canonical sources per
+// ADR 0156 (multi-source ingestion):
+//
+//   Forward-method canonical: `contracts/avro/*.avsc` files (existing path).
+//     The avsc id becomes the event id; publisher_service_id reads from
+//     `repo-config.events.produces[].schema` resolved against the avsc index.
+//   Reverse-method canonical: `docs/domains/<domain>/contracts/events/
+//     event-catalog.yaml` (new path, walked by event-catalog-walker.ts).
+//     One file per domain; each entry carries name, publisher_service_id,
+//     transport, schema_path, version, consumers[].
+//
+// Merge precedence when both sources declare an event (matched by id slug):
+//   - name, domain_id, publisher_service_id, transport → YAML wins
+//   - schema_path, version → YAML wins when set; avsc augments when null
+//   - Events declared only in avsc → forward-only row (existing behaviour)
+//   - Events declared only in YAML → reverse-only row (new)
+//
+// Transport: open string per ADR 0156 (no hardcoded default). When the
+// source is avsc-only with no `repo-config.events` declaration, transport
+// may be empty.
+import { sep } from "node:path";
+import { mergeYamlAndAvsc, walkEventCatalogs, } from "./event-catalog-walker.js";
+export async function buildEvents(inputs) {
+    // 1. Walk the reverse-method canonical source (event-catalog.yaml files).
+    const yamlResult = await walkEventCatalogs({
+        sddPath: inputs.sddPath,
+        findings: inputs.findings,
+    });
+    // 2. Build the forward-method publisher index from repo-config events.produces.
+    // Earlier-encountered service wins on ties (deterministic per sorted
+    // config order from the repositories builder).
+    const publisherByContractId = new Map();
+    for (const cfg of inputs.configs) {
+        if (!inputs.knownServiceIds.has(cfg.repoId))
+            continue;
+        const events = cfg.data.events;
+        const produces = events?.produces ?? [];
+        for (const entry of produces) {
+            const schema = entry.schema;
+            if (!schema)
+                continue;
+            const id = resolveContractByPath(schema, "avro", inputs.contractIdByPath);
+            if (id === undefined)
+                continue;
+            if (!publisherByContractId.has(id)) {
+                publisherByContractId.set(id, cfg.repoId);
+            }
+        }
+    }
+    // 3. Build avsc-derived event rows (forward path), indexed by id for merge.
+    const avscRows = new Map();
+    for (const c of inputs.avroContracts) {
+        const id = String(c["id"]);
+        const specPath = String(c["spec_path"] ?? "");
+        const rawDomain = inferDomainFromAvroPath(specPath);
+        let domain = rawDomain;
+        if (rawDomain.startsWith("_")) {
+            // `_common`, `_shared`, etc. — cross-domain envelope schemas.
+            domain = "";
+        }
+        else if (rawDomain !== "" && !inputs.knownDomainIds.has(rawDomain)) {
+            inputs.findings.add("orphan", `event ${id}: schema is at ${specPath} but no docs/domains/${rawDomain}/ exists — emitting with empty domain_id`);
+            domain = "";
+        }
+        avscRows.set(id, {
+            id,
+            name: String(c["name"] ?? id),
+            publisher_service_id: publisherByContractId.get(id) ?? "",
+            domain_id: domain,
+            transport: "",
+            schema_path: specPath,
+            version: String(c["version"] ?? ""),
+            // avsc has no evidence slot — avsc-only events stay empty (ADR 0175).
+            evidence_class: "",
+            source_sdd_id: "",
+        });
+    }
+    // 4. Merge YAML + avsc. YAML rows win on overlapping fields.
+    const merged = new Map();
+    // An event declared in the catalogue YAML and present as an .avsc is ONE event, whatever
+    // the two sources call it. Matching by id alone missed every pair whose ids differ (the
+    // avsc-derived id carries the domain prefix and an `-event` suffix), so one schema
+    // yielded two event rows — inflating an estate's count by 12. The schema path is the
+    // stronger key: the YAML's id wins and the avsc row it describes is consumed.
+    const avscIdBySchema = new Map();
+    for (const [aid, row] of avscRows) {
+        const sp = normaliseSchemaPath(String(row["schema_path"] ?? ""));
+        if (sp !== "")
+            avscIdBySchema.set(sp, aid);
+    }
+    const consumedAvsc = new Set();
+    for (const [id, yaml] of yamlResult.byId) {
+        let avsc = avscRows.get(id);
+        if (avsc !== undefined) {
+            consumedAvsc.add(id);
+        }
+        else {
+            const aid = avscIdBySchema.get(normaliseSchemaPath(yaml.schemaPath));
+            if (aid !== undefined && !yamlResult.byId.has(aid)) {
+                avsc = avscRows.get(aid);
+                consumedAvsc.add(aid);
+            }
+        }
+        const baseRow = mergeYamlAndAvsc(yaml, avsc);
+        // Resolve domain_id against known domains; empty if unknown.
+        let domainId = String(baseRow["domain_id"] ?? "");
+        if (domainId !== "" && !inputs.knownDomainIds.has(domainId)) {
+            inputs.findings.add("orphan", `event ${id}: event-catalog.yaml declares domain "${domainId}" but no docs/domains/${domainId}/ exists — emitting with empty domain_id`);
+            domainId = "";
+        }
+        // Resolve publisher against known services.
+        let publisher = String(baseRow["publisher_service_id"] ?? "");
+        if (publisher !== "" && !inputs.knownServiceIds.has(publisher)) {
+            inputs.findings.add("orphan", `event ${id}: publisher_service_id "${publisher}" does not resolve to a known service — emitting with empty publisher_service_id`);
+            publisher = "";
+        }
+        merged.set(id, {
+            ...baseRow,
+            domain_id: domainId,
+            publisher_service_id: publisher,
+        });
+    }
+    // Avsc-only events (no YAML row): keep the existing avsc-derived row as-is.
+    for (const [id, row] of avscRows) {
+        if (!merged.has(id) && !consumedAvsc.has(id)) {
+            merged.set(id, row);
+        }
+    }
+    // 5. Deterministic order: sort by id.
+    const rows = [...merged.values()].sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+    return {
+        rows,
+        publisherIndex: { publisherByContractId },
+        yamlEvents: yamlResult.byId,
+    };
+}
+function normaliseSchemaPath(p) {
+    return p.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function inferDomainFromAvroPath(relPath) {
+    // Layout: contracts/avro/<domain>/<file>.avsc
+    const parts = relPath.split(sep);
+    if (parts.length < 4)
+        return "";
+    return parts[2] ?? "";
+}
+function resolveContractByPath(schema, kind, index) {
+    const cleaned = schema.replace(/^\/+/, "");
+    const fullCandidate = `contracts/${kind}/${cleaned}`;
+    if (index.has(fullCandidate))
+        return index.get(fullCandidate);
+    if (index.has(cleaned))
+        return index.get(cleaned);
+    for (const [path, id] of index) {
+        const parts = path.split(sep);
+        const last2 = parts.length >= 2 ? parts.slice(-2).join("/") : "";
+        if (last2 === cleaned)
+            return id;
+    }
+    const base = cleaned.split("/").slice(-1)[0] ?? cleaned;
+    for (const [path, id] of index) {
+        const parts = path.split(sep);
+        if ((parts[parts.length - 1] ?? "") === base)
+            return id;
+    }
+    return undefined;
+}
+//# sourceMappingURL=events.js.map