@sdd-method/author-cli 0.10.0 → 0.12.0

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

package/dist/lib/structure/effects.js

@@ -0,0 +1,36 @@
+// A change's structural effect, and the effect record an archive leaves (M-ADR 0230 §4.6, §4.7, Proposed). Pure reads,
+// so the catalogue builder and the verify-only CLI can carry them; writing the record is apply.ts's.
+import { parseDocument } from "yaml";
+import { elementKey, revision } from "./model.js";
+export function effectsOf(s, current) {
+    const out = [];
+    const rev = (catalogue, id) => {
+        const e = current.get(catalogue)?.get(id);
+        return e ? revision(e.catalogue, e.id, e.columns) : undefined;
+    };
+    for (const d of s.deltas) {
+        for (const e of d.added)
+            out.push({ element: elementKey(e.catalogue, e.id), operation: "ADDED", target: revision(e.catalogue, e.id, e.columns) });
+        for (const e of d.modified) {
+            const base = rev(e.catalogue, e.id);
+            out.push({ element: elementKey(e.catalogue, e.id), operation: "MODIFIED", ...(base ? { base } : {}), target: revision(e.catalogue, e.id, e.columns) });
+        }
+        for (const r of d.removed) {
+            const base = rev(r.catalogue, r.id);
+            out.push({ element: elementKey(r.catalogue, r.id), operation: "REMOVED", ...(base ? { base } : {}) });
+        }
+    }
+    return out.sort((a, b) => a.element.localeCompare(b.element));
+}
+export function parseAppliedRecord(text) {
+    try {
+        const v = parseDocument(text).toJS();
+        if (!v || typeof v.change !== "string" || !Array.isArray(v.effects))
+            return null;
+        return { change: v.change, baseCommit: String(v.base_commit ?? ""), effects: v.effects };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=effects.js.map

package/dist/lib/structure/model.js

@@ -0,0 +1,212 @@
+// The structural model and a change's structural deltas (M-ADR 0230 §4.3, §4.4, Proposed). Pure reads, so the
+// verify-only CLI can carry them. The format is docs/method/methods/guides/structural-model-format.md:
+//   openspec/structure/<partition>.yaml                    the model, one file per partition
+//   openspec/changes/<change>/structure/<partition>.yaml   a change's delta for that partition
+//   openspec/changes/<change>/structure/none.yaml          a change's typed claim of no structural effect
+// An element is a catalogue row of a `structure` catalogue, keyed by its immutable id. Its revision is the
+// SHA-256 of its canonical JSON, so two readers agree on it without agreeing on anything else.
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseDocument } from "yaml";
+export const STRUCTURE_DIR = join("openspec", "structure");
+export const NO_OP_FILE = "none.yaml";
+/** An archived change's record of its structural effect, beside its deltas (M-ADR 0230 §4.6). */
+export const APPLIED_FILE = "applied.yaml";
+/** Partition names a file name would confuse with the no-op claim or the effect record. */
+export const RESERVED_PARTITIONS = new Set(["none", "applied"]);
+export const FORMAT_VERSION = "1.0.0";
+/** `sha256:<hex>` of the element's canonical JSON: {catalogue, columns (sorted), id}, no whitespace, UTF-8. */
+export function revision(catalogue, id, columns) {
+    const sorted = {};
+    for (const k of Object.keys(columns).sort())
+        sorted[k] = columns[k];
+    const canonical = JSON.stringify({ catalogue, columns: sorted, id });
+    return `sha256:${createHash("sha256").update(canonical, "utf8").digest("hex")}`;
+}
+export function elementKey(catalogue, id) {
+    return `${catalogue}/${id}`;
+}
+async function readText(p) {
+    try {
+        return await readFile(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+async function yamlFiles(dir) {
+    try {
+        return (await readdir(dir, { withFileTypes: true }))
+            .filter((e) => e.isFile() && e.name.endsWith(".yaml"))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return null;
+    }
+}
+function parseYamlMap(text, where, problems) {
+    const doc = parseDocument(text);
+    if (doc.errors.length > 0) {
+        problems.push(`${where}: not valid YAML (${doc.errors[0].message.split("\n")[0]})`);
+        return null;
+    }
+    const v = doc.toJS();
+    if (v === null || typeof v !== "object" || Array.isArray(v)) {
+        problems.push(`${where}: not a YAML mapping`);
+        return null;
+    }
+    return v;
+}
+function checkVersion(m, where, problems) {
+    if (m["schema_version"] === undefined) {
+        problems.push(`${where}: no schema_version`);
+        return false;
+    }
+    if (String(m["schema_version"]) !== FORMAT_VERSION) {
+        problems.push(`${where}: schema_version ${JSON.stringify(String(m["schema_version"]))} is not ${FORMAT_VERSION}, the format this CLI reads`);
+        return false;
+    }
+    return true;
+}
+/** Elements under a `<catalogue>: [ {id, ...} ]` map. */
+function readElements(block, where, partition, file, problems) {
+    const out = [];
+    if (block === undefined || block === null)
+        return out;
+    if (typeof block !== "object" || Array.isArray(block)) {
+        problems.push(`${where}: must map catalogue names to lists of elements`);
+        return out;
+    }
+    for (const [catalogue, list] of Object.entries(block)) {
+        if (!Array.isArray(list)) {
+            problems.push(`${where}.${catalogue}: must be a list of elements`);
+            continue;
+        }
+        list.forEach((raw, i) => {
+            const at = `${where}.${catalogue}[${i}]`;
+            if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+                problems.push(`${at}: an element must be a mapping`);
+                return;
+            }
+            const r = raw;
+            const id = r["id"];
+            if (typeof id !== "string" || id === "") {
+                problems.push(`${at}: no id`);
+                return;
+            }
+            const columns = {};
+            for (const [k, v] of Object.entries(r)) {
+                if (k === "id")
+                    continue;
+                if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+                    columns[k] = v;
+                else
+                    problems.push(`${at} (${id}).${k}: a value must be a string, number or boolean`);
+            }
+            out.push({ catalogue, id, columns, partition, file });
+        });
+    }
+    return out;
+}
+/** The model, or null when the SDD has no openspec/structure/ directory. */
+export async function loadModel(repo, problems) {
+    const names = await yamlFiles(join(repo, STRUCTURE_DIR));
+    if (names === null)
+        return null;
+    const files = [];
+    for (const name of names) {
+        const file = join(STRUCTURE_DIR, name);
+        const m = parseYamlMap((await readText(join(repo, file))) ?? "", file, problems);
+        if (m === null || !checkVersion(m, file, problems))
+            continue;
+        const partition = name.slice(0, -".yaml".length);
+        if (RESERVED_PARTITIONS.has(partition)) {
+            problems.push(`${file}: ${partition} is a reserved name, not a partition`);
+            continue;
+        }
+        if (m["partition"] !== partition) {
+            problems.push(`${file}: partition ${JSON.stringify(m["partition"] ?? null)} does not match the file name (${partition})`);
+            continue;
+        }
+        for (const k of Object.keys(m))
+            if (!["schema_version", "partition", "elements"].includes(k))
+                problems.push(`${file}: unknown key ${k}`);
+        files.push({ partition, file, elements: readElements(m["elements"], `${file}: elements`, partition, file, problems) });
+    }
+    return files;
+}
+/** A change's structural artifact. */
+export async function loadChangeStructure(repo, change, problems) {
+    const dir = join("openspec", "changes", change, "structure");
+    const names = await yamlFiles(join(repo, dir));
+    if (names === null)
+        return { change, deltas: [], noOp: null, present: false };
+    const deltas = [];
+    let noOp = null;
+    for (const name of names) {
+        if (name === APPLIED_FILE)
+            continue;
+        const file = join(dir, name);
+        const m = parseYamlMap((await readText(join(repo, file))) ?? "", file, problems);
+        if (m === null || !checkVersion(m, file, problems))
+            continue;
+        if (name === NO_OP_FILE) {
+            const reason = typeof m["reason"] === "string" ? m["reason"].trim() : "";
+            if (m["no_structural_effect"] !== true)
+                problems.push(`${file}: a no-op claim states no_structural_effect: true`);
+            else if (reason === "")
+                problems.push(`${file}: a no-op claim states its reason`);
+            else
+                noOp = { file, reason };
+            continue;
+        }
+        const partition = name.slice(0, -".yaml".length);
+        if (m["partition"] !== partition) {
+            problems.push(`${file}: partition ${JSON.stringify(m["partition"] ?? null)} does not match the file name (${partition})`);
+            continue;
+        }
+        const dependsOn = m["depends_on"] ?? [];
+        if (!Array.isArray(dependsOn) || dependsOn.some((d) => typeof d !== "string"))
+            problems.push(`${file}: depends_on must be a list of change names`);
+        const base = new Map();
+        const rawBase = m["base"] ?? {};
+        if (typeof rawBase !== "object" || rawBase === null || Array.isArray(rawBase))
+            problems.push(`${file}: base must map <catalogue>/<id> to a revision`);
+        else {
+            for (const [k, v] of Object.entries(rawBase)) {
+                if (typeof v !== "string" || !/^sha256:[0-9a-f]{64}$/.test(v))
+                    problems.push(`${file}: base ${k} is not a revision (sha256:<64 hex digits>)`);
+                else
+                    base.set(k, v);
+            }
+        }
+        const removed = [];
+        for (const r of readElements(m["REMOVED"], `${file}: REMOVED`, partition, file, problems)) {
+            const reason = r.columns["reason"];
+            if (typeof reason !== "string" || reason.trim() === "")
+                problems.push(`${file}: REMOVED ${elementKey(r.catalogue, r.id)} gives no reason`);
+            const extra = Object.keys(r.columns).filter((k) => k !== "reason");
+            if (extra.length > 0)
+                problems.push(`${file}: REMOVED ${elementKey(r.catalogue, r.id)} states ${extra.join(", ")}; a removal gives its id and a reason only`);
+            removed.push({ catalogue: r.catalogue, id: r.id, reason: typeof reason === "string" ? reason : "" });
+        }
+        for (const k of Object.keys(m)) {
+            if (!["schema_version", "partition", "depends_on", "ADDED", "MODIFIED", "REMOVED", "base"].includes(k))
+                problems.push(`${file}: unknown key ${k}`);
+        }
+        deltas.push({
+            change,
+            partition,
+            file,
+            dependsOn: Array.isArray(dependsOn) ? dependsOn.map(String) : [],
+            added: readElements(m["ADDED"], `${file}: ADDED`, partition, file, problems),
+            modified: readElements(m["MODIFIED"], `${file}: MODIFIED`, partition, file, problems),
+            removed,
+            base,
+        });
+    }
+    return { change, deltas, noOp, present: true };
+}
+//# sourceMappingURL=model.js.map