@sdd-method/author-cli 0.11.0 → 0.12.0

package/dist/lib/catalogue/retired-catalogues.js

@@ -0,0 +1,25 @@
+// Catalogues a schema major has retired. A build writes the catalogues the schema declares, so the file of one
+// it no longer declares would otherwise stay on disk beside its replacement, and `catalogue build --check`
+// would report it committed and no longer produced in every estate after the wave. The build and the aggregate
+// remove it from the directory they write, and say so. Only a catalogue named here is removed: a CSV the method
+// never declared is left alone.
+import { rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+/** name -> why it went, and what replaced it. */
+export const RETIRED_CATALOGUES = new Map([
+    ["requirement_status", "retired in catalogue schema 6.0.0: evidence about one revision of a requirement is requirement_assertions (M-ADR 0230 §4.7, Proposed)"],
+]);
+/** Remove each retired catalogue's file from `dir`. Returns the file names removed. */
+export async function removeRetiredCatalogues(dir, findings, label) {
+    const removed = [];
+    for (const [name, why] of RETIRED_CATALOGUES) {
+        const file = join(dir, `${name}.csv`);
+        if (!(await stat(file).then((s) => s.isFile(), () => false)))
+            continue;
+        await rm(file);
+        removed.push(`${name}.csv`);
+        findings.add("convention", `${label}/${name}.csv: removed, ${why}; commit its removal with the rebuilt catalogues`, "warn", `${label}/${name}.csv`);
+    }
+    return removed;
+}
+//# sourceMappingURL=retired-catalogues.js.map

package/dist/lib/catalogue/rubric-coverage-map.yaml

@@ -883,7 +883,7 @@ coverage:
     class: lineage
     impact_flow: none
     reason: derived from the archived changes scored by their own judge
-  requirement_status:
+  requirement_assertions:
     kind: edge
     scoring: derived-edge
     class: realisation
@@ -901,7 +901,7 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
-  requirement_status_value:
+  requirement_assertion_kind:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
@@ -951,3 +951,91 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
+  entity_attributes:
+    kind: entity
+    scoring: scored-at-source
+    instrument: an element of the structural model (M-ADR 0230, Proposed); scored with its domain model by rubrics/domain-architecture-rubric.md
+    relationships:
+      entity_id:
+        class: membership
+        impact_flow: toward-target
+  entity_relationships:
+    kind: entity
+    scoring: scored-at-source
+    instrument: an element of the structural model (M-ADR 0230, Proposed); scored with its domain model by rubrics/domain-architecture-rubric.md
+    relationships:
+      from_entity_id:
+        class: membership
+        impact_flow: toward-target
+      to_entity_id:
+        class: dependency
+        impact_flow: toward-source
+  domain_invariants:
+    kind: entity
+    scoring: scored-at-source
+    instrument: an element of the structural model (M-ADR 0230, Proposed); scored with its domain model by rubrics/domain-architecture-rubric.md
+    relationships:
+      entity_id:
+        class: membership
+        impact_flow: toward-target
+      relationship_id:
+        class: dependency
+        impact_flow: toward-source
+  source_of_truth:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  relationship_end_cardinality:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  domain_invariant_kind:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  requirement_revisions:
+    kind: entity
+    scoring: scored-at-source
+    instrument: a revision of a requirement; scored with its living spec by the behaviour-store check
+    relationships:
+      requirement_id:
+        class: membership
+        impact_flow: toward-target
+      change_id:
+        class: lineage
+        impact_flow: toward-source
+  revision_state:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  change_effects:
+    kind: entity
+    scoring: scored-at-source
+    instrument: a change's effect; scored with the change by the behaviour-store and structural-model checks
+    relationships:
+      change_id:
+        class: membership
+        impact_flow: toward-target
+  change_effect_element_kind:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  adr_governs:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  contract_revisions:
+    kind: entity
+    scoring: scored-at-source
+    instrument: a revision of a contract; scored with its contract by the contract rubrics
+    relationships:
+      contract_id:
+        class: membership
+        impact_flow: toward-target
+      change_id:
+        class: lineage
+        impact_flow: toward-source
+  contract_revision_state:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact

package/dist/lib/catalogue/schema-compat.js

@@ -27,7 +27,7 @@
  * M-ADR 0134 §4.6 (canonical builder + aggregator).
  */
 export const SCHEMA_COMPAT = {
-    catalogue_schema: "^5.0.0",
+    catalogue_schema: "^6.0.0",
     sdd_manifest: "^1.0.0",
     aggregation_manifest: "^1.0.0",
 };

package/dist/lib/catalogue/schema-loader.js

@@ -36,6 +36,7 @@ function normalise(raw) {
             type: c.type,
             nullable: c.nullable ?? false,
             ...(c.description !== undefined ? { description: c.description } : {}),
+            ...((c.source_of_truth ?? def.source_of_truth) !== undefined ? { sourceOfTruth: c.source_of_truth ?? def.source_of_truth } : {}),
         })),
         foreignKeys: (def.foreign_keys ?? []).map((fk) => ({
             column: fk.column,
@@ -45,6 +46,8 @@ function normalise(raw) {
             externalForProfiles: fk.external_for_profiles ?? [],
         })),
         columnEnums: def.column_enums ?? {},
+        ...(def.source_of_truth !== undefined ? { sourceOfTruth: def.source_of_truth } : {}),
+        ...(def.natural_key !== undefined ? { naturalKey: def.natural_key } : {}),
     }));
     const enums = {};
     for (const [name, def] of Object.entries(raw.enums ?? {})) {

package/dist/lib/catalogue/staleness-verdicts.js

@@ -40,6 +40,14 @@
 //   none — already reported by scores-coverage as unknown currency; not
 //       re-reported here.
 //
+// ASSESSED INPUTS (M-ADR 0230 §4.9, Proposed): a review that names its other inputs (`input_paths`) is read with
+//   each of them, once its target is current. An input that moved stales the score, with the input named. So does an
+//   input gone from HEAD, and one the corpus did not hold at the anchor: unlike a missing target, the score can still
+//   be re-reviewed against its target, and a review cannot have read an input that was not there, so both prescribe a
+//   re-review rather than a withdrawal. An input present but uncommitted is UNKNOWN, as the target is, unless another
+//   input moved, which decides it whatever order the inputs are listed in. On the
+//   scored_at basis an input changed after the review stales it.
+//
 // MEMBER TIER ONLY, stated not silent: the aggregate tier reads sibling
 // catalogues whose target files and git histories are not local, so a verdict
 // there would be a guess. Reporting-only (`coverage` class) like the rest of
@@ -163,9 +171,12 @@ export async function runStalenessVerdicts(session, options) {
         };
     }
     const asStr = (v) => v === null || v === undefined ? "" : String(v).trim();
-    const reader = await session.conn.runAndReadAll(`SELECT rubric_id, target_ref, target_path, corpus_ref, scored_at, staleness_basis
+    // input_paths (schema 6.0.0, M-ADR 0230 §4.9, Proposed): a catalogue built before it has no such column, and its
+    // scores are read as naming no other input.
+    const query = (inputs) => `SELECT rubric_id, target_ref, target_path, corpus_ref, scored_at, staleness_basis, ${inputs}
      FROM "quality_scores"
-     WHERE staleness_basis IN ('corpus_ref', 'scored_at');`);
+     WHERE staleness_basis IN ('corpus_ref', 'scored_at');`;
+    const reader = await session.conn.runAndReadAll(query("input_paths")).catch(() => session.conn.runAndReadAll(query("NULL")));
     const rows = reader.getRows();
     const stale = [];
     let current = 0;
@@ -176,10 +187,13 @@ export async function runStalenessVerdicts(session, options) {
     const targetMissing = [];
     const anchorKnown = new Map();
     const renamesByAnchor = new Map();
-    for (const [rubricIdRaw, targetRefRaw, targetPathRaw, corpusRefRaw, scoredAtRaw, basisRaw] of rows) {
+    for (const [rubricIdRaw, targetRefRaw, targetPathRaw, corpusRefRaw, scoredAtRaw, basisRaw, inputPathsRaw] of rows) {
         const rubricId = asStr(rubricIdRaw);
         const targetRef = asStr(targetRefRaw);
         const basis = asStr(basisRaw);
+        // The review's other assessed inputs (M-ADR 0230 §4.9, Proposed): read with the target, so an edit to any of
+        // them makes the score stale as an edit to the target does.
+        const inputs = asStr(inputPathsRaw).split(";").map((x) => x.trim()).filter((x) => x !== "");
         // Counted for BOTH bases, before the branch. The first cut of this counter
         // sat inside the corpus_ref branch only, so it was blind to every
         // scored_at row — and the estate that ASKED for this count has all 18 of
@@ -242,7 +256,42 @@ export async function runStalenessVerdicts(session, options) {
             if (anchorBlob === headBlob) {
                 // Byte-identical to its assessed state — including across a rename,
                 // which is the whole point of testing content instead of touches.
-                current += 1;
+                let moved = null;
+                let unknown = false;
+                for (const input of inputs) {
+                    const now = await blobAt(options.sddRoot, "HEAD", input);
+                    if (now === null && (await existsOnDisk(options.sddRoot, input))) {
+                        unknown = true; // present but uncommitted: no blob to compare, as for the target
+                        continue;
+                    }
+                    let then = await blobAt(options.sddRoot, anchor, input);
+                    if (then === null) {
+                        let renames = renamesByAnchor.get(anchor);
+                        if (renames === undefined) {
+                            renames = await renameMap(options.sddRoot, anchor);
+                            renamesByAnchor.set(anchor, renames);
+                        }
+                        const oldPath = renames.get(input);
+                        if (oldPath !== undefined)
+                            then = await blobAt(options.sddRoot, anchor, oldPath);
+                    }
+                    if (now === null)
+                        moved = `assessed input ${input} no longer exists at HEAD`;
+                    else if (then === null)
+                        moved = `assessed input ${input} was not in the corpus at the anchor`;
+                    else if (then !== now)
+                        moved = `assessed input ${input} CONTENT differs from its state at the anchor`;
+                    if (moved !== null)
+                        break;
+                }
+                // An input that moved decides it, whatever the others are; with none moved, an uncommitted input leaves the
+                // score undecided.
+                if (moved !== null)
+                    stale.push({ rubricId, targetRef, basis: "corpus_ref", detail: moved });
+                else if (unknown)
+                    unknownAnchor += 1;
+                else
+                    current += 1;
             }
             else {
                 stale.push({
@@ -284,10 +333,30 @@ export async function runStalenessVerdicts(session, options) {
                     basis: "scored_at",
                     detail: `target last changed ${last.stdout.slice(0, 10)}, after the review of ${at.slice(0, 10)}`,
                 });
+                continue;
             }
-            else {
-                current += 1;
+            let moved = null;
+            let unknown = false;
+            for (const input of inputs) {
+                const changed = await git(options.sddRoot, ["log", "-1", "--format=%cI", "--", input]);
+                if ((await blobAt(options.sddRoot, "HEAD", input)) === null) {
+                    if (await existsOnDisk(options.sddRoot, input)) {
+                        unknown = true; // present but uncommitted: git has no history for it
+                        continue;
+                    }
+                    moved = `assessed input ${input} no longer exists at HEAD`;
+                }
+                else if (changed.ok && changed.stdout !== "" && Date.parse(changed.stdout) > reviewedMs)
+                    moved = `assessed input ${input} last changed ${changed.stdout.slice(0, 10)}, after the review of ${at.slice(0, 10)}`;
+                if (moved !== null)
+                    break;
             }
+            if (moved !== null)
+                stale.push({ rubricId, targetRef, basis: "scored_at", detail: moved });
+            else if (unknown)
+                unknownAnchor += 1;
+            else
+                current += 1;
         }
     }
     return {

package/dist/lib/structure/catalogue.js

@@ -0,0 +1,183 @@
+// The catalogue from the structural model, and the model a built catalogue implies (M-ADR 0230 §4.3, §5.3,
+// Proposed). Where an SDD has a model, it is the record of structure, so every structure catalogue is built from it whole:
+//   a row per element of the current view, with the model's structure columns;
+//   its other columns (every class but structure: derived, declaration, evidence, intent, execution) from the
+//   source-built row with the same id;
+//   for an element only the model holds, the derived columns the model itself settles (MODEL_DERIVED).
+// What the sources hold and the model does not, and a structure column where they disagree, is reported once per
+// catalogue. The model wins: either finding means the sources moved outside a change. Pure: no file is read or written.
+import { stringify } from "yaml";
+import { FORMAT_VERSION } from "./model.js";
+import { STRUCTURE } from "./view.js";
+/** The view each generated file renders, for a derived path column of an element only the model holds. */
+export const VIEW_PATHS = {
+    c4Context: "docs/structure/c4-context.md",
+    c4Containers: "docs/structure/c4-containers.md",
+    services: "docs/structure/services.md",
+    featureTree: "docs/structure/feature-tree.md",
+    dataModel: "docs/structure/data-model.md",
+};
+const EXAMPLES = 5;
+const cell = (v) => (v === null || v === undefined ? "" : typeof v === "boolean" ? (v ? "true" : "false") : String(v));
+/** The derived columns of a row built from an element the sources do not hold. */
+function modelDerived(catalogue, e, view) {
+    switch (catalogue) {
+        case "features":
+        case "capabilities":
+            return { source: "structural-model" };
+        case "domain_models":
+            return { doc_path: VIEW_PATHS.dataModel };
+        case "c4_systems":
+            return { diagram_path: VIEW_PATHS.c4Context };
+        case "domains":
+            return { repo_count: [...(view.get("repositories")?.values() ?? [])].filter((r) => r.columns["domain_id"] === e.id).length };
+        default:
+            return {};
+    }
+}
+function structureColumns(cat) {
+    return cat.columns.filter((c) => c.name !== cat.primaryKey && c.sourceOfTruth === STRUCTURE).map((c) => c.name);
+}
+function sample(ids) {
+    return ids.slice(0, EXAMPLES).join(", ") + (ids.length > EXAMPLES ? `, and ${ids.length - EXAMPLES} more` : "");
+}
+/**
+ * Replace every structure catalogue's rows with the view's. Rows of other catalogues are returned as they are. Source
+ * rows sharing an id are merged first, later values filling earlier gaps, as the keyed-table dedupe would.
+ */
+export function overlayModel(schema, view, rows, findings) {
+    const out = new Map(rows);
+    for (const cat of schema.catalogues) {
+        if (cat.sourceOfTruth !== STRUCTURE)
+            continue;
+        const pk = cat.primaryKey;
+        const structural = structureColumns(cat);
+        const source = new Map();
+        for (const r of rows.get(cat.name) ?? []) {
+            const id = cell(r[pk]);
+            const prior = source.get(id);
+            if (!prior)
+                source.set(id, { ...r });
+            else
+                for (const [k, v] of Object.entries(r))
+                    if (cell(prior[k]) === "" && cell(v) !== "")
+                        prior[k] = v;
+        }
+        const elements = view.get(cat.name) ?? new Map();
+        const built = [];
+        const differ = [];
+        for (const e of elements.values()) {
+            const from = source.get(e.id);
+            const row = {};
+            if (from) {
+                for (const [k, v] of Object.entries(from))
+                    if (!structural.includes(k))
+                        row[k] = v;
+                const cols = structural.filter((c) => cell(from[c]) !== "" && cell(from[c]) !== cell(e.columns[c]));
+                if (cols.length > 0)
+                    differ.push(`${e.id} (${cols.join(", ")})`);
+            }
+            else {
+                Object.assign(row, modelDerived(cat.name, e, view));
+            }
+            row[pk] = e.id;
+            for (const c of structural)
+                row[c] = e.columns[c];
+            built.push(row);
+        }
+        const missing = [...source.keys()].filter((id) => id !== "" && !elements.has(id)).sort();
+        if (missing.length > 0) {
+            findings.add("divergence", `${cat.name}: the sources hold ${missing.length} row(s) the structural model does not (${sample(missing)}); the model is the record of structure, so they are not catalogued. Add them through a change's structural deltas, or remove them from the sources (M-ADR 0230 §4.3, Proposed)`, "warn", `catalogue:${cat.name}`);
+        }
+        if (differ.length > 0) {
+            findings.add("divergence", `${cat.name}: ${differ.length} element(s) where the sources and the structural model disagree, catalogued as the model states them: ${sample(differ.sort())}. A source that is a generated view is rendered again; any other is brought into line through a change (M-ADR 0230 §4.3, Proposed)`, "warn", `catalogue:${cat.name}`);
+        }
+        out.set(cat.name, built);
+    }
+    return out;
+}
+function typed(type, v) {
+    switch (type) {
+        case "int":
+        case "integer":
+        case "number": {
+            const n = Number(v);
+            return Number.isFinite(n) ? n : null;
+        }
+        case "boolean":
+            return v === "true" ? true : v === "false" ? false : null;
+        default:
+            return v;
+    }
+}
+/**
+ * The model a built catalogue implies: each structure row as an element of its non-empty structure columns, typed by
+ * column. A platform's element goes to its domain's partition (its own `domain_id`, or the first element it references
+ * that has one; a domain is its own), else to `platform`; an application or integration SDD's to its sdd_id. A cell
+ * that does not parse as its column's type is reported and left out, which is the projection's only loss.
+ */
+export function modelFromRows(schema, rows, partitioning, loss) {
+    const byKey = new Map();
+    for (const cat of schema.catalogues) {
+        if (cat.sourceOfTruth !== STRUCTURE)
+            continue;
+        for (const r of rows.get(cat.name) ?? [])
+            byKey.set(`${cat.name}/${cell(r[cat.primaryKey])}`, r);
+    }
+    const memo = new Map();
+    const domainOf = (catName, row, seen) => {
+        const cat = schema.catalogues.find((c) => c.name === catName);
+        const key = `${catName}/${cell(row[cat.primaryKey])}`;
+        if (memo.has(key))
+            return memo.get(key);
+        if (seen.has(key))
+            return null;
+        seen.add(key);
+        let d = catName === "domains" ? cell(row[cat.primaryKey]) : cell(row["domain_id"]) || null;
+        for (const fk of d === null ? cat.foreignKeys : []) {
+            const [target, column] = fk.references.split(".");
+            if (fk.external || column !== "id" || cell(row[fk.column]) === "")
+                continue;
+            const next = byKey.get(`${target}/${cell(row[fk.column])}`);
+            if (next && (d = domainOf(target, next, seen)) !== null)
+                break;
+        }
+        memo.set(key, d);
+        return d;
+    };
+    const out = new Map();
+    for (const cat of schema.catalogues) {
+        if (cat.sourceOfTruth !== STRUCTURE)
+            continue;
+        const cols = cat.columns.filter((c) => c.name !== cat.primaryKey && c.sourceOfTruth === STRUCTURE);
+        const sorted = [...(rows.get(cat.name) ?? [])].sort((a, b) => cell(a[cat.primaryKey]).localeCompare(cell(b[cat.primaryKey])));
+        const seen = new Set();
+        for (const r of sorted) {
+            const id = cell(r[cat.primaryKey]);
+            if (id === "" || seen.has(id))
+                continue;
+            seen.add(id);
+            const element = { id };
+            for (const c of cols) {
+                const v = cell(r[c.name]);
+                if (v === "")
+                    continue;
+                const t = typed(c.type, v);
+                if (t === null)
+                    loss.push(`${cat.name}/${id}.${c.name}: ${JSON.stringify(v)} is not of type ${c.type}`);
+                else
+                    element[c.name] = t;
+            }
+            const partition = partitioning.platform ? (domainOf(cat.name, r, new Set()) ?? "platform") : partitioning.sddId;
+            const file = out.get(partition) ?? {};
+            (file[cat.name] ??= []).push(element);
+            out.set(partition, file);
+        }
+    }
+    return out;
+}
+/** One partition's model file, in the format loadModel reads. */
+export function modelFileText(partition, elements) {
+    return stringify({ schema_version: FORMAT_VERSION, partition, elements });
+}
+//# sourceMappingURL=catalogue.js.map

package/dist/lib/structure/compose.js

@@ -0,0 +1,174 @@
+// Views over the structural model, and how changes compose (M-ADR 0230 §4.5, §4.7, Proposed).
+//   current       the model as published
+//   at a change   current with that change's deltas and those of its dependency closure, dependencies first
+//   intended      current with every agreed change's deltas
+// Distinct ids do not prove independence, so three checks run:
+//   1 write overlap        two agreed changes never MODIFY or REMOVE one element, and never ADD one id; a change
+//                          not yet agreed that overlaps an agreed one cannot be agreed while that one is open
+//   2 composed validation  each view is validated on its own; what fails in a view and not in current is reported
+//                          against the changes that write the elements it names
+//   3 read dependencies    base revisions still current (validateDeltas); a dependency withdrawn invalidates its
+//                          dependants; an agreed change depending on one not yet agreed; a cycle of dependencies
+// Pure: reads nothing; the structural-model validator uses it.
+import { elementKey } from "./model.js";
+/** Element key -> the write a change makes to it. */
+export function writesOf(s) {
+    const out = new Map();
+    for (const d of s.deltas) {
+        for (const e of d.added)
+            out.set(elementKey(e.catalogue, e.id), "ADDED");
+        for (const e of d.modified)
+            out.set(elementKey(e.catalogue, e.id), "MODIFIED");
+        for (const r of d.removed)
+            out.set(elementKey(r.catalogue, r.id), "REMOVED");
+    }
+    return out;
+}
+function copy(view) {
+    const out = new Map();
+    for (const [c, m] of view)
+        out.set(c, new Map(m));
+    return out;
+}
+/** The view with one change's deltas applied: an addition or modification replaces whole, a removal deletes. */
+export function apply(view, s) {
+    const out = copy(view);
+    const put = (e) => {
+        const m = out.get(e.catalogue) ?? new Map();
+        m.set(e.id, e);
+        out.set(e.catalogue, m);
+    };
+    for (const d of s.deltas) {
+        for (const e of d.added)
+            put(e);
+        for (const e of d.modified)
+            put(e);
+        for (const r of d.removed)
+            out.get(r.catalogue)?.delete(r.id);
+    }
+    return out;
+}
+/**
+ * A change's dependency closure, dependencies first and the change last. A dependency that is not open is skipped
+ * here (archived: its additions are current; otherwise reported as withdrawn by checkDependencies). A cycle stops the
+ * walk and is reported there too.
+ */
+export function closure(change, open) {
+    const order = [];
+    const visiting = new Set();
+    const visit = (c) => {
+        if (order.includes(c) || visiting.has(c))
+            return;
+        const oc = open.get(c);
+        if (!oc)
+            return;
+        visiting.add(c);
+        for (const d of oc.structure.deltas)
+            for (const dep of d.dependsOn)
+                visit(dep);
+        visiting.delete(c);
+        order.push(c);
+    };
+    visit(change);
+    return order;
+}
+export function viewAt(current, change, open) {
+    let v = current;
+    for (const c of closure(change, open))
+        v = apply(v, open.get(c).structure);
+    return v;
+}
+/** Agreed changes in an order that applies each after its dependencies. */
+export function agreedOrder(open) {
+    const order = [];
+    for (const [name, oc] of [...open].sort(([a], [b]) => a.localeCompare(b))) {
+        if (oc.status !== "agreed")
+            continue;
+        for (const c of closure(name, open))
+            if (!order.includes(c) && open.get(c).status === "agreed")
+                order.push(c);
+    }
+    return order;
+}
+export function intended(current, open) {
+    let v = current;
+    for (const c of agreedOrder(open))
+        v = apply(v, open.get(c).structure);
+    return v;
+}
+/** Check 1: write overlap. */
+export function checkOverlap(open, problems) {
+    const names = [...open.keys()].sort();
+    const writes = new Map(names.map((n) => [n, writesOf(open.get(n).structure)]));
+    for (let i = 0; i < names.length; i++) {
+        for (let j = i + 1; j < names.length; j++) {
+            const a = names[i];
+            const b = names[j];
+            const sa = open.get(a).status;
+            const sb = open.get(b).status;
+            if (sa !== "agreed" && sb !== "agreed")
+                continue;
+            for (const [key, wa] of writes.get(a)) {
+                const wb = writes.get(b).get(key);
+                if (wb === undefined)
+                    continue;
+                // One adding what the other modifies or removes is reported by the other's own deltas, whose base cannot exist.
+                // Two additions of one id are one id claimed twice, whatever their content.
+                if ((wa === "ADDED") !== (wb === "ADDED"))
+                    continue;
+                const verb = wa === "ADDED" ? "both ADD" : wa === wb ? `both ${wa}` : `${wa} and ${wb}`;
+                if (sa === "agreed" && sb === "agreed")
+                    problems.push(`write overlap: agreed changes ${a} and ${b} ${verb} ${key}; reorder or merge them`);
+                else {
+                    const [held, waiting] = sa === "agreed" ? [a, b] : [b, a];
+                    problems.push(`write overlap: ${waiting} ${verb === "both ADD" ? "adds" : "writes"} ${key}, which agreed change ${held} also ${verb === "both ADD" ? "adds" : "writes"}; it cannot be agreed while ${held} is open`);
+                }
+            }
+        }
+    }
+}
+/** Check 3, beyond base revisions: withdrawn dependencies, agreement before a dependency, cycles. */
+export function checkDependencies(open, archived, problems) {
+    for (const [name, oc] of [...open].sort(([a], [b]) => a.localeCompare(b))) {
+        const deps = new Set(oc.structure.deltas.flatMap((d) => [...d.dependsOn]));
+        for (const dep of deps) {
+            const target = open.get(dep);
+            if (target === undefined) {
+                if (!archived.has(dep))
+                    problems.push(`read dependency: ${name} depends on ${dep}, which is neither open nor archived: withdrawn, so ${name} is invalidated until it no longer needs it`);
+                continue;
+            }
+            if (target.status === "withdrawn" || target.status === "superseded") {
+                problems.push(`read dependency: ${name} depends on ${dep}, whose agreement record is ${target.status}: ${name} is invalidated until it no longer needs it`);
+            }
+            else if (oc.status === "agreed" && target.status !== "agreed") {
+                problems.push(`read dependency: ${name} is agreed and depends on ${dep}, which is not: a change is agreed with its dependency closure`);
+            }
+        }
+        // A cycle through this change.
+        const seen = new Set();
+        const stack = [...deps];
+        while (stack.length > 0) {
+            const c = stack.pop();
+            if (c === name) {
+                problems.push(`read dependency: ${name} depends on itself through depends_on; a cycle can never archive`);
+                break;
+            }
+            if (seen.has(c))
+                continue;
+            seen.add(c);
+            for (const d of open.get(c)?.structure.deltas ?? [])
+                stack.push(...d.dependsOn);
+        }
+    }
+}
+const KEY_RE = /\b([a-z][a-z0-9_]*)\/([^\s,;:()"]+)/g;
+/** The changes that write any element a finding names. */
+export function attribute(problem, open, among) {
+    const keys = new Set([...problem.matchAll(KEY_RE)].map((m) => `${m[1]}/${m[2]}`));
+    return among.filter((c) => {
+        const w = writesOf(open.get(c).structure);
+        return [...keys].some((k) => w.has(k));
+    });
+}
+//# sourceMappingURL=compose.js.map