@sdd-method/author-cli 0.10.0 → 0.12.0

package/dist/lib/structure/render.js

@@ -0,0 +1,242 @@
+// The generated views of the structural model (M-ADR 0230 §4.3, Proposed): projections, never edited. Each file is
+// rendered from the current view alone, in id order, so the same model renders the same bytes. Its first line names
+// the generator and the digest of the body below it, which tells three states apart:
+//   missing      the file is absent
+//   stale        the body matches its header but not a render of the model: the model moved; render again
+//   hand-edited  the body no longer matches its header: someone edited a generated view
+// Pure: the verb reads and writes the files.
+import { createHash } from "node:crypto";
+import { VIEW_PATHS } from "./catalogue.js";
+export { VIEW_PATHS };
+const HEADER = /^<!-- Generated by sdd-cli structure render from openspec\/structure\/ \(M-ADR 0230\)\. Do not edit: change the model through a change's structural deltas\. body (sha256:[0-9a-f]{64}) -->\n/;
+const digest = (s) => `sha256:${createHash("sha256").update(s, "utf8").digest("hex")}`;
+function withHeader(body) {
+    return `<!-- Generated by sdd-cli structure render from openspec/structure/ (M-ADR 0230). Do not edit: change the model through a change's structural deltas. body ${digest(body)} -->\n${body}`;
+}
+const elements = (view, catalogue) => [...(view.get(catalogue)?.values() ?? [])].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+const col = (e, c) => (e.columns[c] === undefined ? "" : String(e.columns[c]));
+const nameOf = (e) => col(e, "name") || e.id;
+/** A string inside a Mermaid quoted argument: one line, no double quote. */
+const q = (s) => s.replace(/\s+/g, " ").replace(/"/g, "'").trim();
+/** A cell of a Markdown table. */
+const td = (s) => s.replace(/\s+/g, " ").replace(/\|/g, "\\|").trim();
+/** Mermaid aliases for ids, which may hold characters an alias cannot; a clash after cleaning takes a suffix. */
+function aliases() {
+    const taken = new Map();
+    const used = new Set();
+    return (id) => {
+        const known = taken.get(id);
+        if (known)
+            return known;
+        const base = id.replace(/[^A-Za-z0-9_]/g, "_").replace(/^(?=[0-9])/, "_") || "_";
+        let alias = base;
+        for (let n = 2; used.has(alias); n++)
+            alias = `${base}_${n}`;
+        used.add(alias);
+        taken.set(id, alias);
+        return alias;
+    };
+}
+function c4Context(view) {
+    const a = aliases();
+    const links = elements(view, "persona_c4system");
+    const personas = new Set(links.map((l) => col(l, "persona_id")));
+    const lines = ["# System context", "", "```mermaid", "C4Context", "  title System context"];
+    for (const p of elements(view, "personas"))
+        if (personas.has(p.id))
+            lines.push(`  Person(${a(p.id)}, "${q(nameOf(p))}", "${q(col(p, "role"))}")`);
+    for (const s of elements(view, "c4_systems"))
+        lines.push(`  System(${a(s.id)}, "${q(nameOf(s))}", "${q(col(s, "description"))}")`);
+    for (const x of elements(view, "c4_external_systems"))
+        lines.push(`  System_Ext(${a(x.id)}, "${q(nameOf(x))}", "${q(col(x, "description"))}")`);
+    for (const l of links)
+        lines.push(`  Rel(${a(col(l, "persona_id"))}, ${a(col(l, "c4_system_id"))}, "${q(col(l, "interaction"))}")`);
+    for (const l of elements(view, "system_external_dependency"))
+        lines.push(`  Rel(${a(col(l, "c4_system_id"))}, ${a(col(l, "external_system_id"))}, "${q(col(l, "interaction"))}")`);
+    lines.push("```", "");
+    return lines.join("\n");
+}
+function c4Containers(view) {
+    const containers = elements(view, "c4_containers");
+    const systemOf = new Map(containers.map((c) => [c.id, col(c, "system_id")]));
+    const deps = elements(view, "container_dependency");
+    const lines = ["# Containers", ""];
+    for (const s of elements(view, "c4_systems")) {
+        const a = aliases();
+        const inside = containers.filter((c) => col(c, "system_id") === s.id);
+        lines.push(`## ${nameOf(s)} (\`${s.id}\`)`, "", "```mermaid", "C4Container", `  title Containers of ${q(nameOf(s))}`, `  System_Boundary(${a(s.id)}, "${q(nameOf(s))}") {`);
+        for (const c of inside)
+            lines.push(`    Container(${a(c.id)}, "${q(nameOf(c))}", "${q(col(c, "technology"))}", "${q(col(c, "description"))}")`);
+        lines.push("  }");
+        const outbound = deps.filter((d) => systemOf.get(col(d, "from_container_id")) === s.id);
+        const outside = [...new Set(outbound.map((d) => col(d, "to_container_id")).filter((t) => systemOf.get(t) !== s.id))].sort();
+        for (const t of outside) {
+            const c = view.get("c4_containers")?.get(t);
+            lines.push(`  Container_Ext(${a(t)}, "${q(c ? nameOf(c) : t)}", "${q(c ? col(c, "technology") : "")}", "")`);
+        }
+        for (const d of outbound)
+            lines.push(`  Rel(${a(col(d, "from_container_id"))}, ${a(col(d, "to_container_id"))}, "${q(col(d, "interaction"))}")`);
+        lines.push("```", "");
+    }
+    return lines.join("\n");
+}
+function services(view) {
+    const lines = [
+        "# Services",
+        "",
+        "| Service | Name | Domain | Primary repository | Runtime | Language | Component type | Status |",
+        "| --- | --- | --- | --- | --- | --- | --- | --- |",
+    ];
+    for (const s of elements(view, "services")) {
+        const cells = [`\`${s.id}\``, nameOf(s), col(s, "domain_id"), col(s, "primary_repo_id"), col(s, "runtime_type"), col(s, "language"), col(s, "component_type"), col(s, "status")];
+        lines.push(`| ${cells.map(td).join(" | ")} |`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function featureTree(view) {
+    const caps = elements(view, "capabilities");
+    const groups = elements(view, "feature_groups");
+    const features = elements(view, "features");
+    const linked = new Map();
+    for (const l of elements(view, "capability_feature")) {
+        const set = linked.get(col(l, "capability_id")) ?? new Set();
+        set.add(col(l, "feature_id"));
+        linked.set(col(l, "capability_id"), set);
+    }
+    const placed = new Set();
+    const lines = ["# Feature tree", ""];
+    const feature = (f, depth) => {
+        placed.add(f.id);
+        const facts = [col(f, "kind"), col(f, "status")].filter((x) => x !== "").join(", ");
+        lines.push(`${"  ".repeat(depth)}- ${td(nameOf(f))} (\`${f.id}\`)${facts ? `: ${facts}` : ""}`);
+        for (const c of features)
+            if (col(c, "parent_feature_id") === f.id && !placed.has(c.id))
+                feature(c, depth + 1);
+    };
+    const group = (g, depth) => {
+        lines.push(`${"  ".repeat(depth)}- **${td(nameOf(g))}** (\`${g.id}\`)`);
+        for (const c of groups)
+            if (col(c, "parent_group_id") === g.id)
+                group(c, depth + 1);
+        for (const f of features)
+            if (col(f, "parent_group_id") === g.id && col(f, "parent_feature_id") === "" && !placed.has(f.id))
+                feature(f, depth + 1);
+    };
+    const isRoot = (f) => col(f, "parent_group_id") === "" && col(f, "parent_feature_id") === "";
+    const capability = (c, depth) => {
+        lines.push(`${"#".repeat(Math.min(depth + 2, 6))} ${nameOf(c)} (\`${c.id}\`)`, "");
+        const before = lines.length;
+        for (const g of groups)
+            if (col(g, "capability_id") === c.id && col(g, "parent_group_id") === "")
+                group(g, 0);
+        for (const f of features)
+            if (isRoot(f) && !placed.has(f.id) && (col(f, "capability_id") === c.id || linked.get(c.id)?.has(f.id)))
+                feature(f, 0);
+        if (lines.length > before)
+            lines.push("");
+        for (const child of caps)
+            if (col(child, "parent_capability_id") === c.id)
+                capability(child, depth + 1);
+    };
+    for (const c of caps)
+        if (col(c, "parent_capability_id") === "" || !view.get("capabilities")?.has(col(c, "parent_capability_id")))
+            capability(c, 0);
+    const rest = features.filter((f) => !placed.has(f.id));
+    const loose = groups.filter((g) => col(g, "capability_id") === "" && col(g, "parent_group_id") === "");
+    if (loose.length > 0 || rest.length > 0) {
+        lines.push("## Not under a capability", "");
+        for (const g of loose)
+            group(g, 0);
+        for (const f of features)
+            if (!placed.has(f.id) && isRoot(f))
+                feature(f, 0);
+        for (const f of features)
+            if (!placed.has(f.id))
+                feature(f, 0);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/** Mermaid's end markers for relationship_end_cardinality, written at the from end and at the to end. */
+const FROM_END = { "exactly-one": "||", "zero-or-one": "|o", "one-or-more": "}|", "zero-or-more": "}o" };
+const TO_END = { "exactly-one": "||", "zero-or-one": "o|", "one-or-more": "|{", "zero-or-more": "o{" };
+function dataModel(view) {
+    const entities = elements(view, "entities");
+    const attributes = elements(view, "entity_attributes");
+    const relationships = elements(view, "entity_relationships");
+    const invariants = elements(view, "domain_invariants");
+    const word = (s) => s.replace(/[^A-Za-z0-9_]/g, "_") || "_";
+    const sections = elements(view, "domains").map((d) => [`${nameOf(d)} (\`${d.id}\`)`, entities.filter((e) => col(e, "domain_id") === d.id)]);
+    const domains = new Set(view.get("domains")?.keys() ?? []);
+    sections.push(["Entities without a domain", entities.filter((e) => !domains.has(col(e, "domain_id")))]);
+    const lines = ["# Data model", ""];
+    for (const [title, members] of sections) {
+        if (members.length === 0)
+            continue;
+        const a = aliases();
+        const ids = new Set(members.map((e) => e.id));
+        lines.push(`## ${title}`, "", "```mermaid", "erDiagram");
+        for (const e of members) {
+            const attrs = attributes.filter((x) => col(x, "entity_id") === e.id);
+            if (attrs.length === 0) {
+                lines.push(`  ${a(e.id)}["${q(nameOf(e))}"]`);
+                continue;
+            }
+            lines.push(`  ${a(e.id)}["${q(nameOf(e))}"] {`);
+            for (const x of attrs)
+                lines.push(`    ${word(col(x, "type"))} ${word(col(x, "name"))}`);
+            lines.push("  }");
+        }
+        for (const r of relationships) {
+            if (!ids.has(col(r, "from_entity_id")))
+                continue;
+            const ends = `${FROM_END[col(r, "from_cardinality")] ?? "}o"}--${TO_END[col(r, "to_cardinality")] ?? "o{"}`;
+            lines.push(`  ${a(col(r, "from_entity_id"))} ${ends} ${a(col(r, "to_entity_id"))} : "${q(nameOf(r))}"`);
+        }
+        lines.push("```", "");
+        const rules = invariants.filter((i) => ids.has(col(i, "entity_id")));
+        if (rules.length > 0) {
+            lines.push("Invariants:", "");
+            for (const i of rules)
+                lines.push(`- \`${i.id}\` (${col(i, "kind")}) on \`${col(i, "entity_id")}\`: ${td(col(i, "statement"))}`);
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+/** Every generated view of the current view, by path relative to the SDD. */
+export function renderViews(view) {
+    return new Map([
+        [VIEW_PATHS.c4Context, withHeader(c4Context(view))],
+        [VIEW_PATHS.c4Containers, withHeader(c4Containers(view))],
+        [VIEW_PATHS.services, withHeader(services(view))],
+        [VIEW_PATHS.featureTree, withHeader(featureTree(view))],
+        [VIEW_PATHS.dataModel, withHeader(dataModel(view))],
+    ]);
+}
+/** A view file's state against its render. `text` is the file's content, or null when it is absent. */
+export function viewState(rendered, text) {
+    if (text === null)
+        return "missing";
+    if (text === rendered)
+        return "current";
+    const m = HEADER.exec(text);
+    if (m === null || digest(text.slice(m[0].length)) !== m[1])
+        return "hand-edited";
+    return "stale";
+}
+/** One line per view that is not current. */
+export function describeState(path, state) {
+    switch (state) {
+        case "missing":
+            return `${path}: missing; run \`sdd-cli structure render\``;
+        case "stale":
+            return `${path}: stale, rendered from an earlier model; run \`sdd-cli structure render\``;
+        case "hand-edited":
+            return `${path}: edited by hand since it was generated; a generated view is never edited. Make the change in the model, through a change's structural deltas, and render again`;
+        default:
+            return `${path}: current`;
+    }
+}
+//# sourceMappingURL=render.js.map

package/dist/lib/structure/view.js

@@ -0,0 +1,301 @@
+import { elementKey, revision } from "./model.js";
+export const STRUCTURE = "structure";
+export function catalogueOf(schema, name) {
+    return schema.catalogues.find((c) => c.name === name);
+}
+/** The model's elements as one view, reporting an id held twice. */
+export function viewOf(files, problems) {
+    const view = new Map();
+    for (const f of files) {
+        for (const e of f.elements) {
+            const byId = view.get(e.catalogue) ?? new Map();
+            const prior = byId.get(e.id);
+            if (prior) {
+                problems.push(`${e.file}: ${elementKey(e.catalogue, e.id)} is also in ${prior.file}; an element is owned by one partition, and an id is held once`);
+                continue;
+            }
+            byId.set(e.id, e);
+            view.set(e.catalogue, byId);
+        }
+    }
+    return view;
+}
+export function revisionOf(e) {
+    return revision(e.catalogue, e.id, e.columns);
+}
+function typeOk(type, v) {
+    switch (type) {
+        case "int":
+        case "integer":
+            return typeof v === "number" && Number.isInteger(v);
+        case "number":
+            return typeof v === "number";
+        case "boolean":
+            return typeof v === "boolean";
+        case "date":
+            return typeof v === "string" && /^\d{4}-\d{2}-\d{2}$/.test(v);
+        default:
+            return typeof v === "string";
+    }
+}
+/** The element's own shape against its catalogue: class, columns, required columns, types, vocabularies. */
+export function checkElementShape(schema, e, where, problems) {
+    const key = elementKey(e.catalogue, e.id);
+    const cat = catalogueOf(schema, e.catalogue);
+    if (!cat) {
+        problems.push(`${where}: ${key}: the metamodel declares no catalogue ${e.catalogue}`);
+        return;
+    }
+    if (cat.sourceOfTruth !== STRUCTURE) {
+        problems.push(`${where}: ${key}: ${e.catalogue} is of class ${cat.sourceOfTruth ?? "(none)"}, not structure; it is authored elsewhere`);
+        return;
+    }
+    for (const [col, v] of Object.entries(e.columns)) {
+        const def = cat.columns.find((c) => c.name === col);
+        if (!def) {
+            problems.push(`${where}: ${key}: ${e.catalogue} has no column ${col}`);
+            continue;
+        }
+        if (def.sourceOfTruth !== STRUCTURE) {
+            problems.push(`${where}: ${key}: ${e.catalogue}.${col} is of class ${def.sourceOfTruth ?? "(none)"}, not structure; it is never written in the model`);
+            continue;
+        }
+        if (v === "")
+            problems.push(`${where}: ${key}: ${col} is empty; omit an empty value`);
+        else if (!typeOk(def.type, v))
+            problems.push(`${where}: ${key}: ${col} must be of type ${def.type}`);
+        const en = cat.columnEnums[col];
+        if (en !== undefined && typeof v === "string" && v !== "") {
+            const values = schema.enums[en.replace(/^enums\./, "")]?.values.map((x) => x.value) ?? [];
+            if (!values.includes(v))
+                problems.push(`${where}: ${key}: ${col} ${JSON.stringify(v)} is not a value of ${en}`);
+        }
+    }
+    for (const def of cat.columns) {
+        if (def.name === cat.primaryKey || def.nullable || def.sourceOfTruth !== STRUCTURE)
+            continue;
+        if (e.columns[def.name] === undefined)
+            problems.push(`${where}: ${key}: required column ${def.name} is missing`);
+    }
+}
+function find(view, catalogue, column, value) {
+    const byId = view.get(catalogue);
+    if (!byId)
+        return undefined;
+    if (column === "id")
+        return byId.get(value);
+    for (const e of byId.values())
+        if (String(e.columns[column] ?? "") === value)
+            return e;
+    return undefined;
+}
+/** The element's references: each non-external foreign key with a value. */
+export function referencesOf(schema, e) {
+    const cat = catalogueOf(schema, e.catalogue);
+    if (!cat)
+        return [];
+    const out = [];
+    for (const fk of cat.foreignKeys) {
+        if (fk.external)
+            continue;
+        const v = e.columns[fk.column];
+        if (v === undefined || v === "")
+            continue;
+        const [target, targetColumn] = fk.references.split(".");
+        out.push({ column: fk.column, catalogue: target, targetColumn: targetColumn ?? "id", value: String(v), structural: catalogueOf(schema, target)?.sourceOfTruth === STRUCTURE });
+    }
+    return out;
+}
+/** The natural key's value for an element, or null when the catalogue declares none or the element lacks a part. */
+function naturalKey(cat, e) {
+    const nk = cat.naturalKey;
+    if (!nk || nk.length === 0)
+        return null;
+    const parts = nk.map((c) => (c === "id" ? e.id : e.columns[c]));
+    if (parts.some((p) => p === undefined || p === ""))
+        return null;
+    return parts.map(String).join("\u0000");
+}
+/**
+ * The checks a view must satisfy on its own: every element's shape, references resolved within the view (or, into a
+ * catalogue of another class, against its built rows), no cycle through a self-reference, natural keys unique, and
+ * domain invariants naming their entity's own attributes and relationships.
+ */
+export function validateView(schema, view, built, problems, unresolved) {
+    for (const [catalogue, byId] of view) {
+        const cat = catalogueOf(schema, catalogue);
+        for (const e of byId.values()) {
+            const shape = [];
+            checkElementShape(schema, e, e.file, shape);
+            problems.push(...shape);
+            if (!cat || cat.sourceOfTruth !== STRUCTURE)
+                continue;
+            for (const r of referencesOf(schema, e)) {
+                if (r.structural) {
+                    if (!find(view, r.catalogue, r.targetColumn, r.value))
+                        problems.push(`${e.file}: ${elementKey(catalogue, e.id)}: ${r.column} ${JSON.stringify(r.value)} names no ${r.catalogue} element in this view (${elementKey(r.catalogue, r.value)})`);
+                }
+                else {
+                    const rows = built(r.catalogue, r.targetColumn);
+                    if (rows === null)
+                        unresolved.add(r.catalogue);
+                    else if (!rows.has(r.value))
+                        problems.push(`${e.file}: ${elementKey(catalogue, e.id)}: ${r.column} ${JSON.stringify(r.value)} names no row of ${r.catalogue} as built`);
+                }
+            }
+        }
+        if (!cat || cat.sourceOfTruth !== STRUCTURE)
+            continue;
+        // Hierarchies through a self-reference stay acyclic.
+        for (const fk of cat.foreignKeys.filter((f) => f.references.split(".")[0] === catalogue && !f.external)) {
+            const reported = new Set();
+            for (const start of byId.values()) {
+                const path = [];
+                const onPath = new Set();
+                let cur = start;
+                while (cur && !onPath.has(cur.id)) {
+                    onPath.add(cur.id);
+                    path.push(cur.id);
+                    const next = cur.columns[fk.column];
+                    cur = next === undefined || next === "" ? undefined : byId.get(String(next));
+                }
+                if (cur && onPath.has(cur.id)) {
+                    const cycle = path.slice(path.indexOf(cur.id));
+                    const sig = [...cycle].sort().join(",");
+                    if (!reported.has(sig)) {
+                        reported.add(sig);
+                        problems.push(`${start.file}: ${catalogue}.${fk.column} forms a cycle: ${[...cycle, cur.id].map((id) => elementKey(catalogue, id)).join(" -> ")}`);
+                    }
+                }
+            }
+        }
+        // Natural keys are unique.
+        const seen = new Map();
+        for (const e of byId.values()) {
+            const k = naturalKey(cat, e);
+            if (k === null)
+                continue;
+            const prior = seen.get(k);
+            if (prior)
+                problems.push(`${e.file}: ${elementKey(catalogue, e.id)} and ${elementKey(catalogue, prior.id)} share the natural key (${cat.naturalKey.join(", ")}) ${JSON.stringify(k.split("\u0000").join(", "))}`);
+            else
+                seen.set(k, e);
+        }
+    }
+    // Domain invariants name their own entity's attributes and relationships.
+    for (const inv of view.get("domain_invariants")?.values() ?? []) {
+        const key = elementKey("domain_invariants", inv.id);
+        const entity = String(inv.columns["entity_id"] ?? "");
+        const kind = String(inv.columns["kind"] ?? "");
+        const attrs = String(inv.columns["attribute_ids"] ?? "").split(";").map((s) => s.trim()).filter(Boolean);
+        const rel = String(inv.columns["relationship_id"] ?? "");
+        if ((kind === "unique" || kind === "required") && attrs.length === 0)
+            problems.push(`${inv.file}: ${key}: a ${kind} invariant names its attributes (attribute_ids)`);
+        if (kind === "cardinality" && rel === "")
+            problems.push(`${inv.file}: ${key}: a cardinality invariant names its relationship (relationship_id)`);
+        for (const a of attrs) {
+            const at = view.get("entity_attributes")?.get(a);
+            if (!at)
+                problems.push(`${inv.file}: ${key}: attribute ${elementKey("entity_attributes", a)} is not in this view`);
+            else if (String(at.columns["entity_id"] ?? "") !== entity)
+                problems.push(`${inv.file}: ${key}: attribute ${elementKey("entity_attributes", a)} belongs to ${String(at.columns["entity_id"] ?? "")}, not ${entity}`);
+        }
+        if (rel !== "") {
+            const r = view.get("entity_relationships")?.get(rel);
+            if (r && String(r.columns["from_entity_id"] ?? "") !== entity)
+                problems.push(`${inv.file}: ${key}: relationship ${elementKey("entity_relationships", rel)} is ${String(r.columns["from_entity_id"] ?? "")}'s, not ${entity}'s`);
+        }
+    }
+}
+/**
+ * One change's deltas against the current view (M-ADR 0230 §4.4): each element's shape, ADDED ids new, MODIFIED and
+ * REMOVED ids held by the delta's partition, and a base revision for every element it modifies, removes or reads.
+ * A base revision that no longer matches the current element is reported as moved: the change is revalidated.
+ * `addedElsewhere` holds the elements other open changes add, for a reference into one of them.
+ */
+export function validateDeltas(schema, current, deltas, addedElsewhere, problems) {
+    const ownAdded = new Set();
+    const dependsOn = new Set();
+    for (const d of deltas) {
+        for (const e of d.added)
+            ownAdded.add(elementKey(e.catalogue, e.id));
+        for (const c of d.dependsOn)
+            dependsOn.add(c);
+    }
+    const seenWrite = new Map();
+    for (const d of deltas) {
+        const write = (key, op) => {
+            const prior = seenWrite.get(key);
+            if (prior)
+                problems.push(`${d.file}: ${op} ${key}, which this change also writes in ${prior}`);
+            else
+                seenWrite.set(key, `${d.file} (${op})`);
+        };
+        const needBase = (key, why) => {
+            const b = d.base.get(key);
+            if (b === undefined) {
+                problems.push(`${d.file}: no base revision for ${key}, which it ${why}`);
+                return;
+            }
+            const [catalogue, ...rest] = key.split("/");
+            const cur = current.get(catalogue)?.get(rest.join("/"));
+            if (cur && revisionOf(cur) !== b)
+                problems.push(`${d.file}: base revision of ${key} has moved since the change was written (${b.slice(0, 19)}… now ${revisionOf(cur).slice(0, 19)}…): revalidate the change`);
+        };
+        for (const e of d.added) {
+            const key = elementKey(e.catalogue, e.id);
+            checkElementShape(schema, e, `${d.file}: ADDED`, problems);
+            if (current.get(e.catalogue)?.has(e.id))
+                problems.push(`${d.file}: ADDED ${key}, which the model already holds; an added id is new`);
+            write(key, "ADDED");
+        }
+        for (const e of d.modified) {
+            const key = elementKey(e.catalogue, e.id);
+            checkElementShape(schema, e, `${d.file}: MODIFIED`, problems);
+            const cur = current.get(e.catalogue)?.get(e.id);
+            if (!cur)
+                problems.push(`${d.file}: MODIFIED ${key}, which the model does not hold`);
+            else {
+                if (cur.partition !== d.partition)
+                    problems.push(`${d.file}: MODIFIED ${key}, which partition ${cur.partition} owns, not ${d.partition}`);
+                needBase(key, "modifies");
+            }
+            write(key, "MODIFIED");
+        }
+        for (const r of d.removed) {
+            const key = elementKey(r.catalogue, r.id);
+            const cur = current.get(r.catalogue)?.get(r.id);
+            if (!cur)
+                problems.push(`${d.file}: REMOVED ${key}, which the model does not hold`);
+            else {
+                if (cur.partition !== d.partition)
+                    problems.push(`${d.file}: REMOVED ${key}, which partition ${cur.partition} owns, not ${d.partition}`);
+                needBase(key, "removes");
+            }
+            write(key, "REMOVED");
+        }
+        // Reads: every element an added or modified element references.
+        for (const e of [...d.added, ...d.modified]) {
+            for (const r of referencesOf(schema, e)) {
+                if (!r.structural)
+                    continue;
+                const target = r.targetColumn === "id" ? r.value : find(current, r.catalogue, r.targetColumn, r.value)?.id;
+                const key = elementKey(r.catalogue, target ?? r.value);
+                if (target !== undefined && current.get(r.catalogue)?.has(target)) {
+                    needBase(key, `reads (${elementKey(e.catalogue, e.id)}.${r.column})`);
+                    continue;
+                }
+                if (ownAdded.has(key))
+                    continue;
+                const by = addedElsewhere.get(key);
+                if (by !== undefined && dependsOn.has(by))
+                    continue;
+                if (by !== undefined)
+                    problems.push(`${d.file}: ${elementKey(e.catalogue, e.id)}.${r.column} names ${key}, which open change ${by} adds; declare it in depends_on`);
+                else
+                    problems.push(`${d.file}: ${elementKey(e.catalogue, e.id)}.${r.column} names ${key}, which is in neither the model nor an open change`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=view.js.map