@sdd-method/maintain-cli 0.11.0 → 0.13.0

package/dist/lib/behaviour-store/archive.js

@@ -204,4 +204,17 @@ export function surfaceMatches(entry, contractId, specPath) {
     const re = new RegExp(`(^|/)${e.split("*").map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")}$`);
     return re.test(specPath.split("\\").join("/"));
 }
+/**
+ * The delta entries a work order's `implements` entry names (schema 5.0.0). `<feature>::<name>` names exactly one
+ * requirement. A bare name resolves only when one feature in the change has a requirement of that name; across
+ * two features it is ambiguous, and names none.
+ */
+export function resolveImplements(delta, entry) {
+    const q = /^(.+?)::(.+)$/.exec(entry);
+    if (q)
+        return { matches: delta.filter((d) => d.feature === q[1] && d.name === q[2]), ambiguous: [] };
+    const matches = delta.filter((d) => d.name === entry);
+    const features = [...new Set(matches.map((d) => d.feature))];
+    return features.length > 1 ? { matches: [], ambiguous: features } : { matches, ambiguous: [] };
+}
 //# sourceMappingURL=archive.js.map

package/dist/lib/catalogue/aggregate.js

@@ -27,6 +27,7 @@ import { SCHEMA_COMPAT } from "./schema-compat.js";
 import { loadCanonicalSchema } from "./schema-loader.js";
 import { readCatalogueCsv, parseCatalogueCsv } from "./csv-reader.js";
 import { writeCatalogue } from "./csv-writer.js";
+import { removeRetiredCatalogues } from "./retired-catalogues.js";
 import { buildLegacyContractIdMap } from "./contract-id.js";
 import { validatedPopulation, validateWithEngineToLog } from "./engine-validator.js";
 import { PLATFORM_STAMP_COLUMN, isPlatformScopedFk } from "./fk-validator.js";
@@ -40,6 +41,7 @@ import { buildCapabilitySpec } from "./builders/capability-spec.js";
 import { buildFeatureGrounding } from "./builders/feature-grounding.js";
 import { loadFeatureGroundingAliases } from "./feature-grounding-aliases-loader.js";
 import { buildFeatureContract } from "./builders/feature-contract.js";
+import { buildJourneyRequirement } from "./builders/journey-requirement.js";
 import { buildCapabilityEvent } from "./builders/event-edges.js";
 import { discoverVocabulary } from "./application-archetype/vocabulary.js";
 import { checkDataPlaneOverlayAtAggregation } from "./application-archetype/expectations.js";
@@ -342,6 +344,67 @@ export async function runCatalogueAggregate(inputs, write) {
             findings.add("coverage", `feature_repo: ${added} row(s) re-derived at aggregate tier for features that had NO anchor at member tier — evidence tokens naming a repo registered by another contributor resolve only against the merged repositories; already-anchored features are not widened (M-ADR 0198 §4.1 as amended; ${contributors.length} contributor doc trees scanned)`);
         }
     }
+    // M-ADR 0229 §4.4 (Proposed): journey_requirement re-derived over the merged rows. A journey is often catalogued
+    // in an application SDD and the requirements its steps cite in the platform's behaviour store, so neither member
+    // holds both join inputs; each reports the tag as external. Each contributor's tagged end-to-end files (its own
+    // manifest's journeys.test_paths) and its journey features' living specs are read again here against the MERGED
+    // features, requirements and journeys. Fills absences only (rederiveAppend). A tag naming another contributor's
+    // feature that the merged rows still do not resolve is reported here; everything the member build already reported
+    // (its own features' tags, its test paths, its files' journey tags and journey specs) is not repeated.
+    {
+        const contributors = [{ sddPath, sddId: rootManifest.sddId }];
+        for (const sib of aggManifest.siblings) {
+            if (sib.level === "organisation")
+                continue;
+            if (crossCheck.siblingProfiles.get(sib.sddId) === undefined)
+                continue;
+            contributors.push({ sddPath: sib.sddRoot, sddId: sib.sddId });
+        }
+        const merged = {
+            features: rowsByCatalogue.get("features") ?? [],
+            requirements: rowsByCatalogue.get("requirements") ?? [],
+            knownJourneyIds: new Set((rowsByCatalogue.get("user_journeys") ?? []).map((r) => String(r["id"]))),
+        };
+        const rederived = [];
+        const seen = new Set();
+        const unresolved = [];
+        for (const c of contributors) {
+            let testPaths = [];
+            try {
+                testPaths = (await loadSddManifest(c.sddPath, { cliVersion: CLI_VERSION })).journeys?.testPaths ?? [];
+            }
+            catch {
+                // the member's own build reports an unreadable manifest
+            }
+            const scratch = new FindingsLog();
+            // The contributor's own features: its member build already reported on tags naming them.
+            const reportedFeatureIds = new Set(merged.features.filter((f) => String(f["source_sdd_id"] ?? "") === c.sddId).map((f) => String(f["id"])));
+            for (const row of await buildJourneyRequirement({ sddPath: c.sddPath, findings: scratch, testPaths, reportedFeatureIds, ...merged })) {
+                const id = String(row["id"]);
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                rederived.push({ ...row, source_sdd_id: c.sddId });
+            }
+            // Still external against the merged rows: unresolved. An orphan or divergence about another contributor's feature
+            // (a tag naming a platform requirement that does not exist, or that two of its requirements share) was invisible
+            // to the member build, so it is reported here.
+            for (const f of scratch.all()) {
+                if (f.category === "external")
+                    unresolved.push(`${c.sddId}: ${f.summary.replace(/; resolves at aggregation.*$/, "")}`);
+                else if (f.category === "orphan" || f.category === "divergence")
+                    unresolved.push(`${c.sddId}: ${f.summary}`);
+            }
+        }
+        const before = (rowsByCatalogue.get("journey_requirement") ?? []).length;
+        rederiveAppend(rowsByCatalogue, "journey_requirement", rederived);
+        const added = (rowsByCatalogue.get("journey_requirement") ?? []).length - before;
+        if (added > 0) {
+            findings.add("coverage", `journey_requirement: ${added} row(s) derived at aggregate tier, where a journey and the requirements it cites are catalogued in different SDDs (M-ADR 0229 §4.4, Proposed; ${contributors.length} contributor(s) read)`);
+        }
+        for (const u of unresolved)
+            findings.add("orphan", `journey_requirement: unresolved against the merged catalogue: ${u}`);
+    }
     const repoEdges = buildRepoEdges({
         findings,
         configs: [],
@@ -553,6 +616,7 @@ export async function runCatalogueAggregate(inputs, write) {
                 `resolving; neither is worth deleting the rows over.`);
         }
     }
+    await removeRetiredCatalogues(outDir, findings, "catalogues-aggregated");
     await writeAggregationManifestJson({
         outDir,
         schemaVersion: schema.schemaVersion,

package/dist/lib/catalogue/build.js

@@ -16,6 +16,11 @@
  * still produces a valid but empty `catalogues/` directory — useful as a
  * smoke test that the infrastructure works end-to-end on any SDD repo.
  */
+import { overlayModel } from "../structure/catalogue.js";
+import { buildDataModelElements, readDataModelSources } from "./builders/data-model.js";
+import { removeRetiredCatalogues } from "./retired-catalogues.js";
+import { loadModel } from "../structure/model.js";
+import { viewOf } from "../structure/view.js";
 import { checkCapabilityServicePopulation } from "./population-checks.js";
 import { basename, join, relative, resolve } from "node:path";
 import { copyFile, mkdir, readFile, stat } from "node:fs/promises";
@@ -35,6 +40,9 @@ import { buildDataItems, buildFeatureDemand, buildIntegrationSupply } from "./bu
 import { buildEvidenceTargetRepos } from "./builders/evidence-target-repo.js";
 import { buildRepoDependencies } from "./builders/repo-dependency.js";
 import { buildRequirements } from "./builders/requirements.js";
+import { deriveAdrGoverns } from "./builders/adr-governs.js";
+import { buildContractRevisions } from "./builders/contract-revisions.js";
+import { buildJourneyRequirement } from "./builders/journey-requirement.js";
 import { buildDomains, buildProducts, buildApplicationDataPlaneBindings, buildApplicationDataPlaneDeviations, buildApplicationConformanceCoverage, buildImplementations, buildRepositories, buildServices, buildCapabilities, buildCapabilityService, buildCapabilityAdr, buildCapabilityFeature, buildCapabilityContract, buildAdrs, buildAdrSupersedes, buildFeatures, buildFeatureGroups, buildFeatureGrounding, buildCapabilitySpec, buildContracts, buildDeclaredExternalContracts, buildRepoEdges, deriveFeatureRepoFromServices, buildRepoCapabilityExemption, buildServiceCapabilityExemption, buildEvents, buildServiceEvent, buildCapabilityEvent, buildFeatureEvent, buildServiceContract, buildServiceContractConsumes, buildFeatureContract, buildDomainModels, buildCapabilityDomainModel, buildFeatureDomainModel, buildFeatureSubscriptionChannels, buildProductPlatformDependencies, buildGlossaryItems, backfillGlossaryRelations, buildGlossaryXref, buildC4Systems, buildC4Containers, buildC4Components, buildC4ExternalSystems, buildExternalSystemExemption, buildContainerDependency, reportEntryIdReferentCollisions, buildSystemExternalDependency, buildPersonaC4System, buildPersonaContainer, buildPersonas, buildQualityScores, buildScaffolds, buildScreens, buildUserJourneys, buildPersonaJourney, buildPersonaFeature, buildJourneyFeature, buildProductEdges, buildIntegrations, entitySlug, buildEntitiesFromManifest, buildEntitiesFromMermaid, buildServiceEntityFromTables, enrichEntityPersistenceKind, buildC4ContainerEntity, buildC4SystemEntity, } from "./builders/index.js";
 import { buildIntegrationComponents } from "./builders/integration-components.js";
 import { loadReverseProductQuality } from "./reverse-product-quality.js";
@@ -67,7 +75,14 @@ export async function runCatalogueBuild(inputs, write) {
             `If the manifest follows a newer sdd-manifest-schema than this build, upgrade ` +
             `sdd-cli; otherwise remove or correct the key.`);
     }
-    const rowsByCatalogue = await collectRows(schema, manifest, findings, sddPath, inputs.snapshotStore);
+    const collected = await collectRows(schema, manifest, findings, sddPath, inputs.snapshotStore);
+    // 3 (then). Where the SDD has a structural model, it is the record of structure: every structure catalogue is built from
+    // its current view, and what the sources say otherwise is reported (M-ADR 0230 §4.3, Proposed).
+    const modelProblems = [];
+    const modelFiles = await loadModel(sddPath, modelProblems);
+    const rowsByCatalogue = modelFiles === null ? collected : overlayModel(schema, viewOf(modelFiles, modelProblems), collected, findings);
+    for (const p of modelProblems)
+        findings.add("convention", `${p} (M-ADR 0230, Proposed)`);
     // 3a. Normalise every keyed catalogue to PK-unique rows. Multi-source edge
     // tables (feature_service, feature_repo) can have the same fact asserted by
     // more than one walker; each walker's own seen-set only dedupes intra-walker.
@@ -117,6 +132,9 @@ export async function runCatalogueBuild(inputs, write) {
                 `resolving; neither is worth deleting the rows over.`);
         }
     }
+    // 4a. A catalogue the schema has retired leaves the SDD's own catalogues/ with its replacement's first build.
+    if (outDir === ownCatalogues)
+        await removeRetiredCatalogues(outDir, findings, "catalogues");
     // 5. Internal FK validation (external FKs logged as findings). Pass the
     // SDD profile so profile-external FKs (schema 2.23.0, e.g. an app/integration
     // capability's platform-resident domain_id per M-ADR 0136) resolve at
@@ -190,6 +208,7 @@ export async function runCatalogueBuild(inputs, write) {
         pkConflicts: dedupe.conflicts.length,
         unionedRows: dedupe.unionedRows,
         outDir,
+        findings: findings.all(),
     };
 }
 /**
@@ -1163,13 +1182,30 @@ async function collectRows(schema, manifest, findings, sddPath, snapshotStore) {
             findings,
             knownFeatureIds: new Set((out.get("features") ?? []).map((row) => String(row["id"]))),
             knownRepoIds: knownRepoIdsFinal,
+            sddId: manifest.sddId,
         });
         out.set("requirements", r.requirements);
         out.set("requirement_lineage", r.lineage);
-        out.set("requirement_status", r.status);
+        out.set("requirement_revisions", r.revisions);
+        out.set("requirement_assertions", r.assertions);
+        out.set("change_effects", r.effects);
         out.set("changes", r.changes);
         out.set("change_work_order", r.workOrders);
         out.set("change_work_item", r.workItems);
+        // M-ADR 0230 §4.2 (Proposed): which view each decision governs, now the store's changes are known.
+        out.set("adrs", deriveAdrGoverns(out.get("adrs") ?? [], out.get("adr_supersedes") ?? [], r.changes, findings));
+        // M-ADR 0230 §4.2 (Proposed): each contract's revisions by digest, active beside agreed.
+        out.set("contract_revisions", await buildContractRevisions({ sddPath, findings, contracts: out.get("contracts") ?? [], changes: r.changes }));
+        // M-ADR 0229 §4.4 (Proposed): the requirements each journey cites, from its tagged end-to-end files or its
+        // journey feature's living spec.
+        out.set("journey_requirement", await buildJourneyRequirement({
+            sddPath,
+            findings,
+            testPaths: manifest.journeys?.testPaths ?? [],
+            features: out.get("features") ?? [],
+            requirements: r.requirements,
+            knownJourneyIds: new Set((out.get("user_journeys") ?? []).map((row) => String(row["id"]))),
+        }));
     }
     // 15. C4 systems + containers + components (L1 + L2 + L3). The L3 walker
     // is the forward-method authoring path reading
@@ -1388,6 +1424,13 @@ async function collectRows(schema, manifest, findings, sddPath, snapshotStore) {
         entityRows,
     });
     out.set("entities", enrichedEntityRows);
+    // 17a. The domain models' own content (M-ADR 0230 §4.3, §4.11 proof 7, Proposed; schema 6.0.0): each entity's
+    // attributes, the relationships with both ends' cardinality and roles, and the keys as invariants, from the same
+    // parse the entities came from.
+    const dataModel = buildDataModelElements(await readDataModelSources(sddPath, domainModels.map((r) => ({ id: String(r["id"]), domainId: String(r["domain_id"]), docPath: String(r["doc_path"]) }))), enrichedEntityRows, findings);
+    out.set("entity_attributes", dataModel.entityAttributes);
+    out.set("entity_relationships", dataModel.entityRelationships);
+    out.set("domain_invariants", dataModel.domainInvariants);
     const serviceEntityRows = await buildServiceEntityFromTables({
         sddPath,
         findings,

package/dist/lib/catalogue/builders/adr-governs.js

@@ -0,0 +1,39 @@
+export function deriveAdrGoverns(adrs, supersedes, changes, findings) {
+    const changeState = (name) => {
+        const rows = changes.filter((c) => c["name"] === name);
+        if (rows.some((c) => c["status"] === "archived"))
+            return "archived";
+        if (rows.some((c) => c["status"] === "withdrawn" || c["status"] === "superseded"))
+            return "closed";
+        return rows.length > 0 ? "open" : "absent";
+    };
+    const accepted = new Map();
+    for (const a of adrs) {
+        if (!/^accepted\b/i.test(String(a["status"] ?? "")))
+            continue;
+        const change = String(a["effective_change"] ?? "");
+        if (change === "") {
+            accepted.set(String(a["id"]), "current");
+            continue;
+        }
+        const state = changeState(change);
+        if (state === "absent")
+            findings.add("convention", `${String(a["doc_path"])}: effective on archive of ${change}, which is no change in this store; the decision governs nothing until it is (M-ADR 0230 §4.2, Proposed)`);
+        accepted.set(String(a["id"]), state === "archived" ? "current" : state === "open" ? "intended" : "none");
+    }
+    const successors = new Map();
+    for (const s of supersedes) {
+        const old = String(s["superseded_adr_id"]);
+        successors.set(old, [...(successors.get(old) ?? []), String(s["superseding_adr_id"])]);
+    }
+    return adrs.map((a) => {
+        const id = String(a["id"]);
+        let governs = accepted.get(id) ?? "none";
+        if (/^superseded\b/i.test(String(a["status"] ?? ""))) {
+            const next = (successors.get(id) ?? []).map((s) => accepted.get(s) ?? "none");
+            governs = next.length > 0 && !next.includes("current") ? "current" : "none";
+        }
+        return { ...a, governs };
+    });
+}
+//# sourceMappingURL=adr-governs.js.map

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

@@ -19,6 +19,8 @@
 //   - **Date:** YYYY-MM-DD
 //   - **Supersedes:** raw text (captured into supersedes_raw for the
 //     adr_supersedes builder to parse)
+//   - **Effective:** `on acceptance` (the default) or `on archive of <change>` (M-ADR 0230 §4.2, Proposed):
+//     effective_change holds the change; governs is derived once the store's changes are known (adr-governs.ts)
 //
 // ID canonicalisation: filename stem `ADR XXXX[: Title]` → `ADR-{0-padded}`.
 // Title = the portion after the colon when present, else the file stem
@@ -80,6 +82,12 @@ export async function buildAdrs(inputs) {
         const decisionDate = extractField(text, "Date") || "";
         const supersedesRaw = extractField(text, "Supersedes") || "";
         const supersededByRaw = extractField(text, "Superseded By") || "";
+        const effectiveRaw = (extractField(text, "Effective") || "").trim();
+        const onArchive = /^on archive of\s+`?([A-Za-z0-9][A-Za-z0-9._-]*)`?\s*\.?$/i.exec(effectiveRaw);
+        if (effectiveRaw !== "" && !onArchive && !/^on acceptance\.?$/i.test(effectiveRaw)) {
+            inputs.findings.add("convention", `${relPath}: **Effective:** is "${effectiveRaw}", neither "on acceptance" nor "on archive of <change>"; read as on acceptance (M-ADR 0230 §4.2, Proposed)`);
+        }
+        const effectiveChange = onArchive?.[1] ?? "";
         if (scope === "domain" && !inputs.knownDomainIds.has(domainId)) {
             inputs.findings.add("orphan", `${relPath}: ADR is in domain "${domainId}" but no docs/domains/${domainId}/ exists`);
         }
@@ -97,6 +105,7 @@ export async function buildAdrs(inputs) {
             docPath: relPath,
             supersedesRaw,
             supersededByRaw,
+            effectiveChange,
         });
     }
     if (methodScopeSkipCount > 0) {
@@ -112,6 +121,8 @@ export async function buildAdrs(inputs) {
         superseded_by_id: "", // populated in a backfill pass after adr_supersedes builds
         inference_confidence: "",
         supersedes_raw: a.supersedesRaw,
+        effective_change: a.effectiveChange,
+        governs: "", // derived once the store's changes are known (adr-governs.ts)
         source_sdd_id: "",
     }));
     return { rows, parsed };

package/dist/lib/catalogue/builders/capability-spec.js

@@ -133,6 +133,7 @@ export async function buildCapabilitySpec(inputs) {
                     status: "active",
                     source: "capability-spec",
                     runway: "",
+                    kind: "feature",
                     source_sdd_id: "",
                 });
             }

package/dist/lib/catalogue/builders/contract-revisions.js

@@ -0,0 +1,126 @@
+// contract_revisions: a contract version's content revisions, by digest (M-ADR 0230 §4.2, Proposed; schema 6.0.0).
+//   active      the contract file's current content (deprecated where the contract is)
+//   agreed      a revision an agreed open change agrees (agreement record 1.2.0, contracts[].agrees)
+//   retired     a revision an archived change agreed that the file no longer holds
+// An archived change that agreed the current content is the active revision's change. A compatible amendment is a
+// new revision at the same path, so an agreed revision and the active one coexist.
+//
+// A record names a contract by the file in its own repository (`file:`, or a `files:` list), which the catalogue holds
+// under the SDD's mount of that repository; so a record's file matches the contract whose spec_path ends with it, and
+// a file matching no contract, or several, is a finding and produces no row. `relies_on` and `agrees` are a digest
+// beside `file:`, or a map from each file to its digest beside `files:`. A `relies_on` that no longer matches the
+// file's content is reported: the change relies on a revision that has moved, and is re-agreed.
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+const AGREEMENTS = join("docs", "agreements");
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+export function contentDigest(bytes) {
+    return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+const revisionId = (contract, digest) => `${contract}@${digest.slice("sha256:".length, "sha256:".length + 12)}`;
+/** Each (file, relies_on, agrees) a record's contracts list pins. */
+function pins(record, where, findings) {
+    const r = record?.agreement_record;
+    if (!Array.isArray(r?.contracts))
+        return [];
+    const out = [];
+    for (const [i, raw] of r.contracts.entries()) {
+        const c = raw;
+        if (!c)
+            continue;
+        const files = typeof c["file"] === "string" ? [c["file"]] : Array.isArray(c["files"]) ? c["files"].map(String) : [];
+        const digestFor = (key, file) => {
+            const v = c[key];
+            if (v === undefined)
+                return undefined;
+            const d = typeof v === "string" && typeof c["file"] === "string" ? v : typeof v === "object" && v !== null ? v[file] : undefined;
+            if (d === undefined)
+                return undefined;
+            if (typeof d !== "string" || !DIGEST.test(d)) {
+                findings.add("convention", `${where}: contracts[${i}].${key} for ${file} is not a sha256:<64 hex> digest`);
+                return undefined;
+            }
+            return d;
+        };
+        for (const file of files) {
+            const reliesOn = digestFor("relies_on", file);
+            const agrees = digestFor("agrees", file);
+            if (reliesOn || agrees)
+                out.push({ file, ...(reliesOn ? { reliesOn } : {}), ...(agrees ? { agrees } : {}) });
+        }
+    }
+    return out;
+}
+export async function buildContractRevisions(inputs) {
+    const { sddPath, findings } = inputs;
+    const rows = new Map();
+    const current = new Map(); // contract id -> current digest
+    for (const c of inputs.contracts) {
+        const path = String(c["spec_path"] ?? "");
+        if (path === "")
+            continue;
+        const bytes = await readFile(join(sddPath, path)).catch(() => null);
+        if (bytes === null)
+            continue;
+        const id = String(c["id"]);
+        const digest = contentDigest(bytes);
+        current.set(id, digest);
+        const rid = revisionId(id, digest);
+        rows.set(rid, { id: rid, contract_id: id, digest, state: c["status"] === "deprecated" ? "deprecated" : "active", sunset_date: "", change_id: "", source_sdd_id: "", platform_sdd_id: "" });
+    }
+    const byFile = (file) => inputs.contracts.filter((c) => String(c["spec_path"] ?? "").endsWith(`/${file}`) || c["spec_path"] === file).map((c) => String(c["id"]));
+    let names = [];
+    try {
+        names = (await readdir(join(sddPath, AGREEMENTS))).filter((n) => n.endsWith(".yaml")).sort();
+    }
+    catch {
+        names = [];
+    }
+    for (const name of names) {
+        const change = name.slice(0, -".yaml".length);
+        const where = join(AGREEMENTS, name);
+        let doc;
+        try {
+            doc = parseYaml(await readFile(join(sddPath, where), "utf8"));
+        }
+        catch {
+            continue; // the behaviour-store check reports an unparseable record
+        }
+        const changeRows = inputs.changes.filter((c) => c["name"] === change);
+        const archived = changeRows.find((c) => c["status"] === "archived");
+        const open = changeRows.find((c) => c["status"] !== "archived");
+        const state = archived ? "archived" : open?.["status"] === "agreed" ? "agreed" : "other";
+        if (state === "other")
+            continue;
+        const changeId = String((archived ?? open)["id"]);
+        for (const p of pins(doc, where, findings)) {
+            const matches = byFile(p.file);
+            if (matches.length !== 1) {
+                findings.add("convention", `${where}: contract file ${p.file} matches ${matches.length === 0 ? "no catalogued contract" : `${matches.length} catalogued contracts (${matches.join(", ")})`}; no revision row`);
+                continue;
+            }
+            const contract = matches[0];
+            const now = current.get(contract);
+            if (state === "agreed" && p.reliesOn && now && p.reliesOn !== now) {
+                findings.add("divergence", `${where}: relies on revision ${p.reliesOn.slice(0, 19)}… of ${contract}, which has moved to ${now.slice(0, 19)}…; the change relies on a revision no longer published, so it is re-agreed (M-ADR 0230 §4.2, Proposed)`);
+            }
+            if (!p.agrees)
+                continue;
+            const rid = revisionId(contract, p.agrees);
+            const existing = rows.get(rid);
+            if (p.agrees === now) {
+                if (existing && state === "archived")
+                    rows.set(rid, { ...existing, change_id: changeId });
+                continue;
+            }
+            if (state === "agreed")
+                rows.set(rid, { id: rid, contract_id: contract, digest: p.agrees, state: "agreed", sunset_date: "", change_id: changeId, source_sdd_id: "", platform_sdd_id: "" });
+            else if (!existing)
+                rows.set(rid, { id: rid, contract_id: contract, digest: p.agrees, state: "retired", sunset_date: "", change_id: changeId, source_sdd_id: "", platform_sdd_id: "" });
+        }
+    }
+    return [...rows.values()].sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+}
+//# sourceMappingURL=contract-revisions.js.map