@sdd-method/maintain-cli 0.11.0 → 0.13.0

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

@@ -218,6 +218,16 @@ const ManifestSchema = z.object({
     // Shared-library trait (sdd-manifest-schema 1.12.0, M-ADR 0217 §4.4). Profile-agnostic,
     // like `exemplar`; absent is the unmarked norm, no finding.
     shared_library: z.boolean().optional(),
+    // Where this estate's journey behaviour is mastered (sdd-manifest-schema 1.13.0, M-ADR 0229 §4.2, Proposed).
+    // `master` is declared at the root, and journey-impact treats a member naming its platform as inheriting it.
+    // `test_paths` is never inherited: it is relative to this SDD, so an SDD that holds end-to-end files declares
+    // its own block, with the master and its paths. Unknown values fail at load.
+    journeys: z
+        .object({
+        master: z.enum(["test-file", "store"]),
+        test_paths: z.array(z.string()).optional(),
+    })
+        .optional(),
     // Application-product archetype trait (M-ADR 0191, sdd-manifest-schema
     // 1.2.0). RESOLVED enum, not fixed: the loader validates only the slug
     // shape here. Whether the value resolves against the active vocabulary
@@ -378,6 +388,9 @@ export async function loadSddManifest(sddPath, options) {
         ...(parsed.data.packaging !== undefined ? { packaging: parsed.data.packaging } : {}),
         ...(parsed.data.exemplar !== undefined ? { exemplar: parsed.data.exemplar } : {}),
         ...(parsed.data.shared_library !== undefined ? { sharedLibrary: parsed.data.shared_library } : {}),
+        ...(parsed.data.journeys !== undefined
+            ? { journeys: { master: parsed.data.journeys.master, testPaths: parsed.data.journeys.test_paths ?? [] } }
+            : {}),
         ...(parsed.data.application_archetype !== undefined
             ? { applicationArchetype: parsed.data.application_archetype }
             : {}),

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
@@ -933,3 +933,109 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
+  feature_status:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  journey_requirement:
+    kind: edge
+    scoring: derived-edge
+    class: dependency
+    impact_flow: toward-source
+    reason: derived from end-to-end test tags or journey features' living specs
+  feature_kind:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  journey_requirement_basis:
+    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: "^4.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/metamodel/tql-subset-parser.js

@@ -174,7 +174,13 @@ export function parseTypes(text, fileLabel = "catalogue-schema.tql", options = {
                     throw new ParseError(`${where}: plays needs <relation>:<role>`);
                 if (decl.plays.has(w[1]))
                     throw new ParseError(`${where}: ${lab} plays ${w[1]} twice`);
-                decl.plays.set(w[1], parseAnnotations(w.slice(2), where));
+                const ann = parseAnnotations(w.slice(2), where);
+                // A plays clause's cardinality constrains participation, which the relational projection has no place for:
+                // refused, so a constraint the model gained can never be dropped by the projection with the gate green.
+                if (ann.key || ann.required || ann.multi || ann.optional) {
+                    throw new ParseError(`${where}: ${lab} plays ${w[1]} with a cardinality annotation; participation cardinality cannot be projected onto the catalogue schema, so it is not admitted`);
+                }
+                decl.plays.set(w[1], ann);
             }
             else if (head === "relates") {
                 if (kind !== "relation")
@@ -225,6 +231,16 @@ export function parseTypes(text, fileLabel = "catalogue-schema.tql", options = {
 }
 const ROW_RE = /^insert \$m isa ([a-z][a-z0-9-]*), (.*);$/;
 const TOK_RE = /has ([a-z][a-z0-9-]*) ("(?:[^"\\]|\\.)*"|-?\d+|true|false)/y;
+function valueFamily(v) {
+    return typeof v === "boolean" ? "boolean" : typeof v === "number" ? "integer" : "string";
+}
+function attrFamily(valueType) {
+    if (valueType === undefined)
+        return undefined;
+    if (valueType === "long" || valueType === "integer")
+        return "integer";
+    return valueType;
+}
 export function parseMeta(text, fileLabel = "catalogue-schema-meta.tql", options = {}) {
     const metaTypes = options.metaTypes ?? META_TYPES;
     const rows = new Map();
@@ -268,9 +284,26 @@ export function parseMeta(text, fileLabel = "catalogue-schema-meta.tql", options
             else
                 throw new ParseError(`${where}: expected ', has ...' at offset ${i}: ${JSON.stringify(body.slice(i, i + 40))}`);
         }
+        const decl = options.types?.entities.get(typ);
+        if (options.types && !decl)
+            throw new ParseError(`${where}: meta type ${typ} is not declared in the type file`);
+        if (decl) {
+            for (const [k, vs] of acc) {
+                const own = decl.owns.get(k);
+                if (!own)
+                    throw new ParseError(`${where}: ${typ} does not own ${k}; an undeclared meta property is refused, not ignored`);
+                if (!own.multi && vs.length > 1)
+                    throw new ParseError(`${where}: ${typ}.${k} is a single value and appears ${vs.length} times; a repeated scalar is refused, not reduced to its first value`);
+                const fam = attrFamily(options.types.attrs.get(k));
+                for (const v of vs) {
+                    if (fam !== undefined && valueFamily(v) !== fam)
+                        throw new ParseError(`${where}: ${typ}.${k} holds ${JSON.stringify(v)}, but ${k} is of value type ${options.types.attrs.get(k)}`);
+                }
+            }
+        }
         const row = {};
         for (const [k, vs] of acc)
-            row[k] = LIST_KEYS.has(k) ? vs : vs[0];
+            row[k] = (decl ? decl.owns.get(k).multi : LIST_KEYS.has(k)) ? vs : vs[0];
         const list = rows.get(typ) ?? [];
         list.push(row);
         rows.set(typ, list);

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