@ybotok/loam 0.1.0-beta.3 → 0.2.0-alpha.13

package/dist/core/c4/parsed/specification.js

@@ -0,0 +1,78 @@
+/**
+ * The `specification { ... }` block, read off LikeC4's parsed model.
+ *
+ * loam reads a model for what it MEANS, and until LikeC4 1.59.0 the
+ * specification carried nothing loam had to mean anything by: it declared which
+ * kinds and tags exist, and LikeC4 itself enforced that every use was declared.
+ * 1.59.0 added **tags on kinds** — `specification { element softwareSystem {
+ * #external } }` — and LikeC4 applies those tags to every element of the kind
+ * before loam ever sees it. So `Elem.tags` stopped answering the question loam
+ * was actually asking of it.
+ *
+ * That distinction is what this module exists for. loam does not need the
+ * specification to SEE an inherited tag — the tag is already on the element, and
+ * `flattenModel` has always copied it faithfully. It needs the specification to
+ * tell an inherited tag from one somebody wrote on the element, because loam
+ * gives two tags grading meaning (`#external` exempts an element from the
+ * landscape↔services reconciliation, `#platform` silences a hub warning) and a
+ * kind-wide declaration of either switches that grading off for every element of
+ * the kind at once. Six words in the specification block turned a fleet gate
+ * green over a fleet it had stopped checking; `kindTagFindings`
+ * (commands/validate/fleet/kind-tags.ts) is the check that refuses that, and this
+ * is the reader it is built on.
+ *
+ * Everything here is defensive. The specification is not part of the model API
+ * loam's `ReadableModel` slice pins, and 1.59.2 already spells the two kind
+ * tables differently — element kinds carry `tags` at the top of the kind record,
+ * relationship kinds carry theirs under `style` — which is exactly the kind of
+ * internal detail that moves between releases. Both positions are read for both
+ * tables, so a shape that swaps degrades to "no kind tags" (the pre-1.59.0
+ * answer) rather than throwing inside a validate run.
+ */
+/** Every string in `v`, or `[]` — `v` is `unknown` off an untyped parse. */
+function stringList(v) {
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+}
+/**
+ * The tags one kind record declares. 1.59.2 puts an element kind's under `tags`
+ * and a relationship kind's under `style.tags`; both are read for both, because
+ * which one a given kind table uses is LikeC4's internal business and a check
+ * that silently stopped seeing tags would fail OPEN — the exact failure this
+ * module was added to close.
+ */
+function kindTags(kind) {
+    if (!kind || typeof kind !== "object")
+        return [];
+    const rec = kind;
+    const style = rec["style"];
+    const nested = style && typeof style === "object" ? style["tags"] : undefined;
+    return [...new Set([...stringList(rec["tags"]), ...stringList(nested)])];
+}
+/** `{ kind: [tag, ...] }` for every kind in one of the specification's kind tables. */
+function tagTable(table) {
+    if (!table || typeof table !== "object")
+        return {};
+    const out = {};
+    for (const [name, kind] of Object.entries(table)) {
+        const tags = kindTags(kind);
+        if (tags.length > 0)
+            out[name] = tags;
+    }
+    return out;
+}
+/**
+ * Normalize the `specification` LikeC4 hangs off its parsed model. Takes the
+ * whole untyped value so every shape assumption lives in this file: callers get
+ * `DocSpecification` or nothing, and never touch `unknown`.
+ */
+export function readSpecification(spec) {
+    if (!spec || typeof spec !== "object")
+        return undefined;
+    const rec = spec;
+    return {
+        elementKindTags: tagTable(rec["elements"]),
+        relationshipKindTags: tagTable(rec["relationships"]),
+        metadataKeys: stringList(rec["metadataKeys"]),
+    };
+}
+//# sourceMappingURL=specification.js.map

package/dist/core/c4/parsed/specification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"specification.js","sourceRoot":"","sources":["../../../../src/core/c4/parsed/specification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAwBH,4EAA4E;AAC5E,SAAS,UAAU,CAAC,CAAU;IAC5B,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACrF,CAAC;AAED;;;;;;GAMG;AACH,SAAS,QAAQ,CAAC,IAAa;IAC7B,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACjD,MAAM,GAAG,GAAG,IAA+B,CAAC;IAC5C,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC;IAC3B,MAAM,MAAM,GAAG,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAE,KAAiC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3G,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3E,CAAC;AAED,uFAAuF;AACvF,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACnD,MAAM,GAAG,GAA6B,EAAE,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC,EAAE,CAAC;QAC5E,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACxC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAa;IAC7C,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IACxD,MAAM,GAAG,GAAG,IAA+B,CAAC;IAC5C,OAAO;QACL,eAAe,EAAE,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC1C,oBAAoB,EAAE,QAAQ,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QACpD,YAAY,EAAE,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;KAC9C,CAAC;AACJ,CAAC","sourcesContent":["/**\n * The `specification { ... }` block, read off LikeC4's parsed model.\n *\n * loam reads a model for what it MEANS, and until LikeC4 1.59.0 the\n * specification carried nothing loam had to mean anything by: it declared which\n * kinds and tags exist, and LikeC4 itself enforced that every use was declared.\n * 1.59.0 added **tags on kinds** — `specification { element softwareSystem {\n * #external } }` — and LikeC4 applies those tags to every element of the kind\n * before loam ever sees it. So `Elem.tags` stopped answering the question loam\n * was actually asking of it.\n *\n * That distinction is what this module exists for. loam does not need the\n * specification to SEE an inherited tag — the tag is already on the element, and\n * `flattenModel` has always copied it faithfully. It needs the specification to\n * tell an inherited tag from one somebody wrote on the element, because loam\n * gives two tags grading meaning (`#external` exempts an element from the\n * landscape↔services reconciliation, `#platform` silences a hub warning) and a\n * kind-wide declaration of either switches that grading off for every element of\n * the kind at once. Six words in the specification block turned a fleet gate\n * green over a fleet it had stopped checking; `kindTagFindings`\n * (commands/validate/fleet/kind-tags.ts) is the check that refuses that, and this\n * is the reader it is built on.\n *\n * Everything here is defensive. The specification is not part of the model API\n * loam's `ReadableModel` slice pins, and 1.59.2 already spells the two kind\n * tables differently — element kinds carry `tags` at the top of the kind record,\n * relationship kinds carry theirs under `style` — which is exactly the kind of\n * internal detail that moves between releases. Both positions are read for both\n * tables, so a shape that swaps degrades to \"no kind tags\" (the pre-1.59.0\n * answer) rather than throwing inside a validate run.\n */\n\n/** The slice of a LikeC4 `specification { ... }` block loam reads, normalized. */\nexport interface DocSpecification {\n  /** Tag names each ELEMENT kind declares, by kind name. Kinds declaring none are absent. */\n  elementKindTags: Record<string, string[]>;\n  /**\n   * Tag names each RELATIONSHIP kind declares, by kind name.\n   *\n   * Read and carried even though no check grades relationship tags today: the\n   * feature tag on an edge is what `loam archive` splices on, and a kind-wide\n   * declaration of one is the same defect on the write path. Dropping the table\n   * here would make that a second reader's problem to rediscover.\n   */\n  relationshipKindTags: Record<string, string[]>;\n  /**\n   * The sorted union of every `metadata { }` key used anywhere in the document,\n   * computed by LikeC4 for free. loam's own binding vocabulary is four keys —\n   * `service`, `op`, `publishes`, `consumes` — and a near miss (`ops`,\n   * `serviceId`) parses clean, binds nothing, and reports nothing.\n   */\n  metadataKeys: string[];\n}\n\n/** Every string in `v`, or `[]` — `v` is `unknown` off an untyped parse. */\nfunction stringList(v: unknown): string[] {\n  return Array.isArray(v) ? v.filter((x): x is string => typeof x === \"string\") : [];\n}\n\n/**\n * The tags one kind record declares. 1.59.2 puts an element kind's under `tags`\n * and a relationship kind's under `style.tags`; both are read for both, because\n * which one a given kind table uses is LikeC4's internal business and a check\n * that silently stopped seeing tags would fail OPEN — the exact failure this\n * module was added to close.\n */\nfunction kindTags(kind: unknown): string[] {\n  if (!kind || typeof kind !== \"object\") return [];\n  const rec = kind as Record<string, unknown>;\n  const style = rec[\"style\"];\n  const nested = style && typeof style === \"object\" ? (style as Record<string, unknown>)[\"tags\"] : undefined;\n  return [...new Set([...stringList(rec[\"tags\"]), ...stringList(nested)])];\n}\n\n/** `{ kind: [tag, ...] }` for every kind in one of the specification's kind tables. */\nfunction tagTable(table: unknown): Record<string, string[]> {\n  if (!table || typeof table !== \"object\") return {};\n  const out: Record<string, string[]> = {};\n  for (const [name, kind] of Object.entries(table as Record<string, unknown>)) {\n    const tags = kindTags(kind);\n    if (tags.length > 0) out[name] = tags;\n  }\n  return out;\n}\n\n/**\n * Normalize the `specification` LikeC4 hangs off its parsed model. Takes the\n * whole untyped value so every shape assumption lives in this file: callers get\n * `DocSpecification` or nothing, and never touch `unknown`.\n */\nexport function readSpecification(spec: unknown): DocSpecification | undefined {\n  if (!spec || typeof spec !== \"object\") return undefined;\n  const rec = spec as Record<string, unknown>;\n  return {\n    elementKindTags: tagTable(rec[\"elements\"]),\n    relationshipKindTags: tagTable(rec[\"relationships\"]),\n    metadataKeys: stringList(rec[\"metadataKeys\"]),\n  };\n}\n"]}

package/dist/core/c4/parsed/values.js

@@ -0,0 +1,110 @@
+/**
+ * The corners of LikeC4's parse output that are typed `unknown`, decoded.
+ *
+ * LikeC4 models `metadata { ... }` values and a `description` as open shapes —
+ * a value may be a string, an array, or a rich-text object, and the declared
+ * type says none of that. Every one of those crossings needs a defensive read
+ * that answers "not present" rather than throwing, and each read encodes a
+ * defect somebody hit. They live together here, one module below the adapter
+ * (`../likec4.ts`) that calls them, because the adapter is at its line limit and
+ * because "decode a value LikeC4 left untyped" is a subject of its own: the
+ * specification reader beside this file is the same subject on a different
+ * corner of the same object. The ORDER relationships come back in is one more
+ * such corner — LikeC4 promises none, and the one it happens to give changes
+ * between runs — so `compareRels` lives here too.
+ */
+/**
+ * Read one string key out of a LikeC4 `metadata { ... }` block. Four keys carry
+ * loam's spines: `op` on a relationship (the OpenAPI operationId it calls),
+ * `publishes`/`consumes` on a relationship (the AsyncAPI message it produces or
+ * receives), and `service` on an element (the services/<id> directory it stands
+ * for). Every one of them is read by BOTH model readers — the parsed one
+ * (`flattenModel` in `../likec4.ts`, which calls this) and the text scanner
+ * `scanModel` uses for archive's splice map — because a key only one of them
+ * sees is a key the merge silently drops. Elements with no metadata come back as
+ * `{}`, so a missing key is indistinguishable from a missing block — both mean
+ * "not bound".
+ */
+export function metaKey(m, key) {
+    if (m && typeof m === "object") {
+        const v = m[key];
+        if (typeof v === "string")
+            return v;
+        // A key written TWICE in one block comes back as an array, accepted with no
+        // error, and reading only the string form dropped every value — so an edge
+        // naming two operations reported as naming none, `c4.op-link-missing` telling
+        // the author the opposite of what they wrote. First wins, matching the text
+        // scanner's `keyedLiteral`: the two readers disagreeing about a binding is
+        // exactly what the paragraph above exists to prevent. Later values stay
+        // dropped — one id per key per edge is the model.
+        if (Array.isArray(v) && typeof v[0] === "string")
+            return v[0];
+    }
+    return undefined;
+}
+/** LikeC4 descriptions can be a string or a rich-text object ({ txt } / { text } / { md }). */
+export function descText(d) {
+    if (typeof d === "string")
+        return d;
+    if (d && typeof d === "object") {
+        const o = d;
+        for (const key of ["txt", "text", "md", "value"]) {
+            const v = o[key];
+            if (typeof v === "string")
+                return v;
+        }
+    }
+    return undefined;
+}
+/**
+ * The ONE order every loader hands relationships back in: by source, then
+ * target, title, `op`, `publishes`, `consumes` and tags — plain code-unit
+ * compares, so the order is a function of the documents' text alone and never
+ * of the locale, the machine or the run. Two edges equal on every key are equal
+ * in every field `Rel` (`../likec4.ts`) carries, so which of them comes first
+ * cannot be seen. `flattenModel` there sorts with it; it lives here, beside the
+ * other reads of LikeC4's parse output that cannot be taken at face value,
+ * because the adapter is at its line limit.
+ *
+ * LikeC4 does not give one, for two measured reasons (1.59.2). Its parsed
+ * model indexes relations in a plain object keyed by an id HASHED FROM THE
+ * DOCUMENT'S URI — and every loader stages documents under a fresh
+ * crypto-random folder per invocation (`../workspace.ts` says why), so the ids
+ * change on every run. A JavaScript object enumerates integer-like keys
+ * numerically ahead of every other key, so whenever a hash comes out all
+ * digits (about one hash in 2,200) that edge jumps to the front of the list,
+ * on that run only. And inside a project of several documents the base order
+ * is whichever file Langium's concurrent folder walk finished reading first.
+ * The first reason is what failed a scheduled CI run on 2026-09-28:
+ * `loadProjectBatch` and `loadProject` returned one service's two edges in
+ * opposite orders on an unchanged commit — and on a fleet map of a few hundred
+ * edges it would reorder some run's findings far more often than that.
+ *
+ * Declaration order is therefore NOT what a reader gets, and nothing may read
+ * meaning into the position of an edge: what the `Rel` list promises is the
+ * same order for the same documents, which is what the text report and the
+ * `--json` envelope being diffed between runs and machines needs.
+ */
+export function compareRels(a, b) {
+    // An absent field sorts ahead of every present one, the empty string
+    // included, so "no title" and "an empty title" cannot tie. Tags are LikeC4
+    // identifiers, which cannot contain the comma that joins them.
+    const opt = (value) => (value === undefined ? "" : `=${value}`);
+    const keys = (r) => [
+        r.source,
+        r.target,
+        opt(r.title),
+        opt(r.op),
+        opt(r.publishes),
+        opt(r.consumes),
+        r.tags.join(","),
+    ];
+    const ka = keys(a);
+    const kb = keys(b);
+    for (let i = 0; i < ka.length; i++) {
+        if (ka[i] !== kb[i])
+            return ka[i] < kb[i] ? -1 : 1;
+    }
+    return 0;
+}
+//# sourceMappingURL=values.js.map

package/dist/core/c4/parsed/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","sourceRoot":"","sources":["../../../../src/core/c4/parsed/values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,OAAO,CAAC,CAAU,EAAE,GAAW;IAC7C,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC/B,MAAM,CAAC,GAAI,CAA6B,CAAC,GAAG,CAAC,CAAC;QAC9C,IAAI,OAAO,CAAC,KAAK,QAAQ;YAAE,OAAO,CAAC,CAAC;QACpC,4EAA4E;QAC5E,2EAA2E;QAC3E,8EAA8E;QAC9E,4EAA4E;QAC5E,2EAA2E;QAC3E,wEAAwE;QACxE,kDAAkD;QAClD,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ;YAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,QAAQ,CAAC,CAAU;IACjC,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC/B,MAAM,CAAC,GAAG,CAA4B,CAAC;QACvC,KAAK,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;YACjD,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YACjB,IAAI,OAAO,CAAC,KAAK,QAAQ;gBAAE,OAAO,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,WAAW,CAAC,CAAU,EAAE,CAAU;IAChD,qEAAqE;IACrE,2EAA2E;IAC3E,+DAA+D;IAC/D,MAAM,GAAG,GAAG,CAAC,KAAyB,EAAU,EAAE,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC;IAC5F,MAAM,IAAI,GAAG,CAAC,CAAU,EAAY,EAAE,CAAC;QACrC,CAAC,CAAC,MAAM;QACR,CAAC,CAAC,MAAM;QACR,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QACZ,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QACT,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC;QACf,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;KACjB,CAAC;IACF,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACnB,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAAE,OAAO,EAAE,CAAC,CAAC,CAAE,GAAG,EAAE,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC","sourcesContent":["/**\n * The corners of LikeC4's parse output that are typed `unknown`, decoded.\n *\n * LikeC4 models `metadata { ... }` values and a `description` as open shapes —\n * a value may be a string, an array, or a rich-text object, and the declared\n * type says none of that. Every one of those crossings needs a defensive read\n * that answers \"not present\" rather than throwing, and each read encodes a\n * defect somebody hit. They live together here, one module below the adapter\n * (`../likec4.ts`) that calls them, because the adapter is at its line limit and\n * because \"decode a value LikeC4 left untyped\" is a subject of its own: the\n * specification reader beside this file is the same subject on a different\n * corner of the same object. The ORDER relationships come back in is one more\n * such corner — LikeC4 promises none, and the one it happens to give changes\n * between runs — so `compareRels` lives here too.\n */\n\n/**\n * Read one string key out of a LikeC4 `metadata { ... }` block. Four keys carry\n * loam's spines: `op` on a relationship (the OpenAPI operationId it calls),\n * `publishes`/`consumes` on a relationship (the AsyncAPI message it produces or\n * receives), and `service` on an element (the services/<id> directory it stands\n * for). Every one of them is read by BOTH model readers — the parsed one\n * (`flattenModel` in `../likec4.ts`, which calls this) and the text scanner\n * `scanModel` uses for archive's splice map — because a key only one of them\n * sees is a key the merge silently drops. Elements with no metadata come back as\n * `{}`, so a missing key is indistinguishable from a missing block — both mean\n * \"not bound\".\n */\nexport function metaKey(m: unknown, key: string): string | undefined {\n  if (m && typeof m === \"object\") {\n    const v = (m as Record<string, unknown>)[key];\n    if (typeof v === \"string\") return v;\n    // A key written TWICE in one block comes back as an array, accepted with no\n    // error, and reading only the string form dropped every value — so an edge\n    // naming two operations reported as naming none, `c4.op-link-missing` telling\n    // the author the opposite of what they wrote. First wins, matching the text\n    // scanner's `keyedLiteral`: the two readers disagreeing about a binding is\n    // exactly what the paragraph above exists to prevent. Later values stay\n    // dropped — one id per key per edge is the model.\n    if (Array.isArray(v) && typeof v[0] === \"string\") return v[0];\n  }\n  return undefined;\n}\n\n/** LikeC4 descriptions can be a string or a rich-text object ({ txt } / { text } / { md }). */\nexport function descText(d: unknown): string | undefined {\n  if (typeof d === \"string\") return d;\n  if (d && typeof d === \"object\") {\n    const o = d as Record<string, unknown>;\n    for (const key of [\"txt\", \"text\", \"md\", \"value\"]) {\n      const v = o[key];\n      if (typeof v === \"string\") return v;\n    }\n  }\n  return undefined;\n}\n\n/**\n * The fields of a relationship its order is decided on — `Rel` in\n * `../likec4.ts`, stated structurally because that module imports this one and\n * a type imported back would close a cycle.\n */\nexport interface RelKeys {\n  readonly source: string;\n  readonly target: string;\n  readonly title?: string;\n  readonly op?: string;\n  readonly publishes?: string;\n  readonly consumes?: string;\n  readonly tags: readonly string[];\n}\n\n/**\n * The ONE order every loader hands relationships back in: by source, then\n * target, title, `op`, `publishes`, `consumes` and tags — plain code-unit\n * compares, so the order is a function of the documents' text alone and never\n * of the locale, the machine or the run. Two edges equal on every key are equal\n * in every field `Rel` (`../likec4.ts`) carries, so which of them comes first\n * cannot be seen. `flattenModel` there sorts with it; it lives here, beside the\n * other reads of LikeC4's parse output that cannot be taken at face value,\n * because the adapter is at its line limit.\n *\n * LikeC4 does not give one, for two measured reasons (1.59.2). Its parsed\n * model indexes relations in a plain object keyed by an id HASHED FROM THE\n * DOCUMENT'S URI — and every loader stages documents under a fresh\n * crypto-random folder per invocation (`../workspace.ts` says why), so the ids\n * change on every run. A JavaScript object enumerates integer-like keys\n * numerically ahead of every other key, so whenever a hash comes out all\n * digits (about one hash in 2,200) that edge jumps to the front of the list,\n * on that run only. And inside a project of several documents the base order\n * is whichever file Langium's concurrent folder walk finished reading first.\n * The first reason is what failed a scheduled CI run on 2026-09-28:\n * `loadProjectBatch` and `loadProject` returned one service's two edges in\n * opposite orders on an unchanged commit — and on a fleet map of a few hundred\n * edges it would reorder some run's findings far more often than that.\n *\n * Declaration order is therefore NOT what a reader gets, and nothing may read\n * meaning into the position of an edge: what the `Rel` list promises is the\n * same order for the same documents, which is what the text report and the\n * `--json` envelope being diffed between runs and machines needs.\n */\nexport function compareRels(a: RelKeys, b: RelKeys): number {\n  // An absent field sorts ahead of every present one, the empty string\n  // included, so \"no title\" and \"an empty title\" cannot tie. Tags are LikeC4\n  // identifiers, which cannot contain the comma that joins them.\n  const opt = (value: string | undefined): string => (value === undefined ? \"\" : `=${value}`);\n  const keys = (r: RelKeys): string[] => [\n    r.source,\n    r.target,\n    opt(r.title),\n    opt(r.op),\n    opt(r.publishes),\n    opt(r.consumes),\n    r.tags.join(\",\"),\n  ];\n  const ka = keys(a);\n  const kb = keys(b);\n  for (let i = 0; i < ka.length; i++) {\n    if (ka[i] !== kb[i]) return ka[i]! < kb[i]! ? -1 : 1;\n  }\n  return 0;\n}\n"]}

package/dist/core/c4/parsed/view-ids.js

@@ -0,0 +1,113 @@
+/**
+ * The ids of every view a document AUTHORS — the census read, as distinct from
+ * `./dynamic-views.ts`'s use-case read.
+ *
+ * Two readers over one record, because docs/DESIGN.md rule 26 states two
+ * filters and they are not interchangeable. A use-case reader wants dynamic
+ * views and filters on `_type === "dynamic"`. A census must see authored
+ * ELEMENT views too — a `view fleet { include * }` claims an id exactly as
+ * firmly as a dynamic one does — so it filters on `sourcePath !== undefined`
+ * instead. Measured: the `index` view LikeC4 synthesizes into every document is
+ * `_type: "element"` AND carries no `sourcePath`, so each filter drops it, and a
+ * reader that learned only the other one would report a fiction.
+ *
+ * Kept as its own module rather than a second export beside the use-case reader:
+ * the two share nothing but the reach into `$data`, and a defensive adapter is
+ * safer when each one owns its shape assumptions outright — the same reason
+ * `./specification.ts` states.
+ *
+ * Two censuses over one record now: view ids off `$data.views`, and since
+ * 2026-09-03 the global style ids off `$data.globals.styles` — the same
+ * question (which authored ids exist, for a collision or a reference) asked of
+ * a second corner, so the generated subsystem views can reference a style
+ * group only when the project actually declares it. The second rode into this
+ * module rather than a file of its own because `parsed/` sits AT its five-file
+ * cap and the census IS this module's subject; `./deployment.ts`'s banner
+ * records the seam the next non-census reader still needs.
+ *
+ * Ids only, each with the file that claims it. What the view SHOWS stays
+ * unread, in any document, forever — and so does what a style group SAYS.
+ */
+/**
+ * The shape LikeC4 mints for a view its author never named — `view of svc { }`
+ * becomes `view_1yu7e9n`.
+ *
+ * Excluded from the census, and this is a correctness rule rather than
+ * tidiness: such an id is not a claim anybody wrote, and MEASURED at the
+ * 1.59.2 pin it is not even stable across loam's own two loaders — the same
+ * document yields `view_1yu7e9n` through `loadFile` and `view_zmkx82` through
+ * `loadBatch`, because the mint hashes the document URI and the batch stages
+ * into a temp workspace. Reporting it would put a value in `LoadedDoc` that
+ * depends on which loader ran, which is the one thing
+ * test/fleet-context-parity.test.ts exists to forbid; it also cannot collide
+ * with anything loam generates, since every generated id loam mints carries a
+ * prefix of its own.
+ *
+ * The cost is exact and small: an author who literally writes
+ * `view view_abc { }` loses that id from the census. It is a name nobody
+ * chooses, and no check reads the census for anything but collisions against
+ * loam's own generated prefixes, which this shape can never match.
+ */
+const MINTED_ID = /^view_[0-9a-z]+$/;
+/** A record, or nothing — `v` is `unknown` off an untyped parse. */
+function record(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : undefined;
+}
+/**
+ * Every view id the document declares, in the record's own order.
+ *
+ * `model` is the AWAITED `parsedModel()` result; `$data` is undefined on the
+ * unresolved promise, so a caller that forgets the await gets an empty census
+ * rather than a throw. Empty is also what a malformed record yields — this runs
+ * inside `validate --all` over every C4 document a fleet has, and the one
+ * behaviour it may never have is failing the run it was added to.
+ */
+export function readViewIds(model) {
+    const views = record(record(record(model)?.["$data"])?.["views"]);
+    if (!views)
+        return [];
+    const out = [];
+    for (const raw of Object.values(views)) {
+        const rec = record(raw);
+        // Authored, which is what `sourcePath` means here. The synthesized entry
+        // has none, and reporting a collision against a view nobody wrote would be
+        // a false error on every fleet in existence.
+        const sourcePath = rec?.["sourcePath"];
+        if (!rec || typeof sourcePath !== "string")
+            continue;
+        const id = rec["id"];
+        if (typeof id === "string" && id.length > 0 && !MINTED_ID.test(id))
+            out.push({ id, sourcePath });
+    }
+    return out;
+}
+/**
+ * Every global style id the document declares, sorted.
+ *
+ * `$data.globals.styles` is keyed by id and holds one entry per `styleGroup`
+ * OR single-rule `style` declared under `global { }` — both forms land in the
+ * one table, measured at the 1.59.2 pin and pinned in
+ * test/likec4-view-shape.test.ts. Keys only: what a group SAYS — its targets
+ * and colours — is a rendering instruction, and docs/DESIGN.md rule 26 keeps
+ * loam out of those on purpose; the one consumer (the generated subsystem
+ * views) asks whether an id is declared, nothing more. Sorted so a document
+ * declaring two groups yields one order under every loader — the parity rule
+ * `readViewIds` states for the minted-id case, applied here to `Object.keys`
+ * order, which is the record's and not the author's.
+ *
+ * Defensive like everything here: a shape this cannot read is ZERO ids, so the
+ * generated views then reference nothing — the same file they rendered before
+ * the read existed, never a reference to a name loam guessed. That direction
+ * is the safe one: a missed declaration costs a palette, while an invented
+ * reference is a parse error that blanks the whole `architecture/` project in
+ * the renderer.
+ */
+export function readGlobalStyleIds(model) {
+    const styles = record(record(record(record(model)?.["$data"])?.["globals"])?.["styles"]);
+    if (!styles)
+        return [];
+    return Object.keys(styles)
+        .filter((id) => id.length > 0)
+        .sort();
+}
+//# sourceMappingURL=view-ids.js.map

package/dist/core/c4/parsed/view-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-ids.js","sourceRoot":"","sources":["../../../../src/core/c4/parsed/view-ids.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AASH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,SAAS,GAAG,kBAAkB,CAAC;AAErC,oEAAoE;AACpE,SAAS,MAAM,CAAC,CAAU;IACxB,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAE,CAA6B,CAAC,CAAC,CAAC,SAAS,CAAC;AACtG,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAClE,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IACtB,MAAM,GAAG,GAAkB,EAAE,CAAC;IAC9B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QACxB,yEAAyE;QACzE,2EAA2E;QAC3E,6CAA6C;QAC7C,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,CAAC,GAAG,IAAI,OAAO,UAAU,KAAK,QAAQ;YAAE,SAAS;QACrD,MAAM,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACrB,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;IACnG,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzF,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;SACvB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;SAC7B,IAAI,EAAE,CAAC;AACZ,CAAC","sourcesContent":["/**\n * The ids of every view a document AUTHORS — the census read, as distinct from\n * `./dynamic-views.ts`'s use-case read.\n *\n * Two readers over one record, because docs/DESIGN.md rule 26 states two\n * filters and they are not interchangeable. A use-case reader wants dynamic\n * views and filters on `_type === \"dynamic\"`. A census must see authored\n * ELEMENT views too — a `view fleet { include * }` claims an id exactly as\n * firmly as a dynamic one does — so it filters on `sourcePath !== undefined`\n * instead. Measured: the `index` view LikeC4 synthesizes into every document is\n * `_type: \"element\"` AND carries no `sourcePath`, so each filter drops it, and a\n * reader that learned only the other one would report a fiction.\n *\n * Kept as its own module rather than a second export beside the use-case reader:\n * the two share nothing but the reach into `$data`, and a defensive adapter is\n * safer when each one owns its shape assumptions outright — the same reason\n * `./specification.ts` states.\n *\n * Two censuses over one record now: view ids off `$data.views`, and since\n * 2026-09-03 the global style ids off `$data.globals.styles` — the same\n * question (which authored ids exist, for a collision or a reference) asked of\n * a second corner, so the generated subsystem views can reference a style\n * group only when the project actually declares it. The second rode into this\n * module rather than a file of its own because `parsed/` sits AT its five-file\n * cap and the census IS this module's subject; `./deployment.ts`'s banner\n * records the seam the next non-census reader still needs.\n *\n * Ids only, each with the file that claims it. What the view SHOWS stays\n * unread, in any document, forever — and so does what a style group SAYS.\n */\n\n/** One authored view id, and the document that claims it. */\nexport interface ViewIdClaim {\n  id: string;\n  /** As LikeC4 spells it: relative to the project root. */\n  sourcePath: string;\n}\n\n/**\n * The shape LikeC4 mints for a view its author never named — `view of svc { }`\n * becomes `view_1yu7e9n`.\n *\n * Excluded from the census, and this is a correctness rule rather than\n * tidiness: such an id is not a claim anybody wrote, and MEASURED at the\n * 1.59.2 pin it is not even stable across loam's own two loaders — the same\n * document yields `view_1yu7e9n` through `loadFile` and `view_zmkx82` through\n * `loadBatch`, because the mint hashes the document URI and the batch stages\n * into a temp workspace. Reporting it would put a value in `LoadedDoc` that\n * depends on which loader ran, which is the one thing\n * test/fleet-context-parity.test.ts exists to forbid; it also cannot collide\n * with anything loam generates, since every generated id loam mints carries a\n * prefix of its own.\n *\n * The cost is exact and small: an author who literally writes\n * `view view_abc { }` loses that id from the census. It is a name nobody\n * chooses, and no check reads the census for anything but collisions against\n * loam's own generated prefixes, which this shape can never match.\n */\nconst MINTED_ID = /^view_[0-9a-z]+$/;\n\n/** A record, or nothing — `v` is `unknown` off an untyped parse. */\nfunction record(v: unknown): Record<string, unknown> | undefined {\n  return v && typeof v === \"object\" && !Array.isArray(v) ? (v as Record<string, unknown>) : undefined;\n}\n\n/**\n * Every view id the document declares, in the record's own order.\n *\n * `model` is the AWAITED `parsedModel()` result; `$data` is undefined on the\n * unresolved promise, so a caller that forgets the await gets an empty census\n * rather than a throw. Empty is also what a malformed record yields — this runs\n * inside `validate --all` over every C4 document a fleet has, and the one\n * behaviour it may never have is failing the run it was added to.\n */\nexport function readViewIds(model: unknown): ViewIdClaim[] {\n  const views = record(record(record(model)?.[\"$data\"])?.[\"views\"]);\n  if (!views) return [];\n  const out: ViewIdClaim[] = [];\n  for (const raw of Object.values(views)) {\n    const rec = record(raw);\n    // Authored, which is what `sourcePath` means here. The synthesized entry\n    // has none, and reporting a collision against a view nobody wrote would be\n    // a false error on every fleet in existence.\n    const sourcePath = rec?.[\"sourcePath\"];\n    if (!rec || typeof sourcePath !== \"string\") continue;\n    const id = rec[\"id\"];\n    if (typeof id === \"string\" && id.length > 0 && !MINTED_ID.test(id)) out.push({ id, sourcePath });\n  }\n  return out;\n}\n\n/**\n * Every global style id the document declares, sorted.\n *\n * `$data.globals.styles` is keyed by id and holds one entry per `styleGroup`\n * OR single-rule `style` declared under `global { }` — both forms land in the\n * one table, measured at the 1.59.2 pin and pinned in\n * test/likec4-view-shape.test.ts. Keys only: what a group SAYS — its targets\n * and colours — is a rendering instruction, and docs/DESIGN.md rule 26 keeps\n * loam out of those on purpose; the one consumer (the generated subsystem\n * views) asks whether an id is declared, nothing more. Sorted so a document\n * declaring two groups yields one order under every loader — the parity rule\n * `readViewIds` states for the minted-id case, applied here to `Object.keys`\n * order, which is the record's and not the author's.\n *\n * Defensive like everything here: a shape this cannot read is ZERO ids, so the\n * generated views then reference nothing — the same file they rendered before\n * the read existed, never a reference to a name loam guessed. That direction\n * is the safe one: a missed declaration costs a palette, while an invented\n * reference is a parse error that blanks the whole `architecture/` project in\n * the renderer.\n */\nexport function readGlobalStyleIds(model: unknown): string[] {\n  const styles = record(record(record(record(model)?.[\"$data\"])?.[\"globals\"])?.[\"styles\"]);\n  if (!styles) return [];\n  return Object.keys(styles)\n    .filter((id) => id.length > 0)\n    .sort();\n}\n"]}

package/dist/core/c4/prefetch/fleet.js

@@ -0,0 +1,134 @@
+/**
+ * Every service model ONE command invocation has read, memoised — the fleet
+ * map, each model's shape, each per-service project, and each assembled
+ * `ServiceModel`.
+ *
+ * A package of its own rather than four more maps on `core/fleet-context.ts`,
+ * and the seam is the one that module's banner already states for its leaves:
+ * the rules being memoised here are `../service-model/`'s (which shape a file
+ * has, which documents its project holds, how a failed batch degrades), and a
+ * memo whose rules live an import away is a memo somebody fills under the wrong
+ * key. The read index keeps what it owns — the document parses, the
+ * enumerations — and hands them in. It also keeps that file under its line
+ * limit, which is the honest second reason: this axis is four memos and a batch
+ * plan, and it arrived at a module that was already 336 lines of other axes.
+ *
+ * The direction is one-way and load-bearing: `fleet-context.ts` imports this,
+ * never the reverse. Everything this class needs from the read index arrives as
+ * a function on the request (`ModelRead`), so nothing here knows that a
+ * FleetContext exists — which is what keeps `core/` → `core/c4/` acyclic.
+ *
+ * REQUEST-SCOPED exactly as `FleetContext` is: one instance per invocation,
+ * dropped when the command finishes. No module-level state, so a later run
+ * cannot observe an earlier one's answer, and a `chdir` between two tests
+ * cannot leak one docs repo into the next.
+ */
+import { resolve } from "node:path";
+import { memo } from "../../kernel/concurrency.js";
+import { loadArchitecture } from "../project/architecture.js";
+import { asLoadedDoc, loadProject } from "../project/load.js";
+import { modelProjectDocuments } from "../service-model/documents.js";
+import { batchServiceProjects, serviceModelAt, } from "../service-model/load.js";
+import { readModelShape, readModelShapes } from "../service-model/shape.js";
+export class ServiceModels {
+    deps;
+    architectures = new Map();
+    shapeOf = new Map();
+    projects = new Map();
+    models = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * The fleet map as the PROJECT it is (`../project/architecture.ts`). Read
+     * twice over for every service now rather than once for the run — it is the
+     * gate on whether an extending model can be read at all, and the other half
+     * of the diff that decides what such a model actually declares — so the memo
+     * is what keeps a fleet run to one parse of it.
+     *
+     * Filled ONLY when somebody asks. `model` below hands `loadServiceModel` a
+     * thunk rather than an awaited value, so a fleet whose models all stand alone
+     * never parses this project at all — a standalone model is read as one file,
+     * and paying for the map (and inheriting its failures) for `loam show` or the
+     * adopt brief was cost and risk for an answer nobody used.
+     */
+    architecture(docsDir) {
+        return memo(this.architectures, resolve(docsDir), () => loadArchitecture(docsDir));
+    }
+    /**
+     * Which shape each model has, keyed by resolved path — ONE read of each
+     * file's bytes per invocation, however many questions are asked of it.
+     *
+     * The bulk form is the primary one because every caller asks in bulk: the
+     * fleet target needs the shapes of the WHOLE enumeration before it can grade
+     * a single renderer-file finding, and the prefetch needs them before it can
+     * decide which workspace each model belongs in.
+     */
+    async shapes(paths) {
+        const keys = [...new Set(paths.map((path) => resolve(path)))];
+        const missing = keys.filter((k) => !this.shapeOf.has(k));
+        for (const [k, shape] of await readModelShapes(missing)) {
+            // A concurrent read's promise stays authoritative — it is the one another
+            // caller is already holding — so a second scan of the same bytes can
+            // never replace it with a duplicate.
+            if (!this.shapeOf.has(k))
+                this.shapeOf.set(k, Promise.resolve(shape));
+        }
+        const answered = await Promise.all(keys.map(async (k) => [k, await this.shape(k)]));
+        return new Map(answered);
+    }
+    /** One model's shape, out of the same memo the bulk form fills. */
+    shape(modelPath) {
+        return memo(this.shapeOf, resolve(modelPath), () => readModelShape(modelPath));
+    }
+    /** A service's model, read the way its own shape demands. Memoised per model PATH, which is what identifies the file. */
+    model(docsDir, paths) {
+        return memo(this.models, resolve(paths.model), async () => serviceModelAt({
+            docsDir,
+            paths,
+            shape: await this.shape(paths.model),
+            known: await this.deps.known(docsDir),
+            // A thunk, so a standalone model never spins the map's workspace: the
+            // memo makes the extending case one parse for the run either way.
+            architecture: () => this.architecture(docsDir),
+            standalone: () => this.deps.standalone(paths.model),
+            project: () => this.project(docsDir, paths.model),
+        }));
+    }
+    /**
+     * Prepare every EXTENDING model's project in one workspace, and answer with
+     * the STANDALONE models' paths for the caller to prefetch through its own
+     * document batch — the two shapes need different workspaces, and only the
+     * caller has the memo the second one seeds.
+     *
+     * Purely an accelerator: a batch that could not be created seeds nothing and
+     * every reader falls back to its own load, so findings can never change
+     * because of a tmpdir — only the speed can.
+     */
+    async prefetch(docsDir, paths) {
+        const shapes = await this.shapes(paths.map((p) => p.model));
+        const models = (shape) => [...shapes].filter(([, found]) => found === shape).map(([model]) => model);
+        const extending = models("extending").filter((model) => !this.projects.has(model));
+        for (const [k, doc] of await batchServiceProjects(docsDir, extending)) {
+            // A concurrent load's promise stays authoritative: it is the one every
+            // reader is already holding, and replacing it would count the parse twice.
+            if (this.projects.has(k))
+                continue;
+            this.deps.onProjectLoad();
+            this.projects.set(k, Promise.resolve(doc));
+        }
+        return models("standalone");
+    }
+    /**
+     * One service's project — the architecture documents and its model, parsed
+     * together. Keyed on the model, which is what `prefetch` seeds above, so a
+     * batched fleet run and a single-service run answer out of the same memo.
+     */
+    project(docsDir, modelPath) {
+        return memo(this.projects, resolve(modelPath), async () => {
+            this.deps.onProjectLoad();
+            return asLoadedDoc(await loadProject(docsDir, await modelProjectDocuments(docsDir, modelPath)));
+        });
+    }
+}
+//# sourceMappingURL=fleet.js.map

package/dist/core/c4/prefetch/fleet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet.js","sourceRoot":"","sources":["../../../../src/core/c4/prefetch/fleet.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Every service model ONE command invocation has read, memoised — the fleet\n * map, each model's shape, each per-service project, and each assembled\n * `ServiceModel`.\n *\n * A package of its own rather than four more maps on `core/fleet-context.ts`,\n * and the seam is the one that module's banner already states for its leaves:\n * the rules being memoised here are `../service-model/`'s (which shape a file\n * has, which documents its project holds, how a failed batch degrades), and a\n * memo whose rules live an import away is a memo somebody fills under the wrong\n * key. The read index keeps what it owns — the document parses, the\n * enumerations — and hands them in. It also keeps that file under its line\n * limit, which is the honest second reason: this axis is four memos and a batch\n * plan, and it arrived at a module that was already 336 lines of other axes.\n *\n * The direction is one-way and load-bearing: `fleet-context.ts` imports this,\n * never the reverse. Everything this class needs from the read index arrives as\n * a function on the request (`ModelRead`), so nothing here knows that a\n * FleetContext exists — which is what keeps `core/` → `core/c4/` acyclic.\n *\n * REQUEST-SCOPED exactly as `FleetContext` is: one instance per invocation,\n * dropped when the command finishes. No module-level state, so a later run\n * cannot observe an earlier one's answer, and a `chdir` between two tests\n * cannot leak one docs repo into the next.\n */\nimport { resolve } from \"node:path\";\nimport { memo } from \"../../kernel/concurrency.js\";\nimport type { DocsDir } from \"../../kernel/ids/dirs.js\";\nimport type { ServicePaths } from \"../../repo/paths.js\";\nimport type { LoadedDoc } from \"../likec4.js\";\nimport { loadArchitecture } from \"../project/architecture.js\";\nimport { asLoadedDoc, loadProject } from \"../project/load.js\";\nimport { modelProjectDocuments } from \"../service-model/documents.js\";\nimport {\n  batchServiceProjects,\n  serviceModelAt,\n  type ServiceModel,\n} from \"../service-model/load.js\";\nimport { readModelShape, readModelShapes, type ModelShape } from \"../service-model/shape.js\";\n\n/**\n * The three things this memo cannot know for itself, supplied once by whoever\n * owns it. Functions rather than values because each is itself memoised on the\n * caller's side: asking again is what makes an answer shared rather than\n * copied.\n */\nexport interface ModelDeps {\n  /** Fires once per per-service project actually parsed, batched or not — the caller owns its counters. */\n  onProjectLoad: () => void;\n  /** The service directories that exist — the caller has enumerated them; this package must not enumerate them again. */\n  known: (docsDir: DocsDir) => Promise<ReadonlySet<string>>;\n  /** Parse one `.likec4` document ALONE, through the caller's own document memo, so a prefetched parse is a hit. */\n  standalone: (path: string) => Promise<LoadedDoc>;\n}\n\nexport class ServiceModels {\n  private readonly architectures = new Map<string, Promise<LoadedDoc>>();\n  private readonly shapeOf = new Map<string, Promise<ModelShape>>();\n  private readonly projects = new Map<string, Promise<LoadedDoc>>();\n  private readonly models = new Map<string, Promise<ServiceModel>>();\n\n  constructor(private readonly deps: ModelDeps) {}\n\n  /**\n   * The fleet map as the PROJECT it is (`../project/architecture.ts`). Read\n   * twice over for every service now rather than once for the run — it is the\n   * gate on whether an extending model can be read at all, and the other half\n   * of the diff that decides what such a model actually declares — so the memo\n   * is what keeps a fleet run to one parse of it.\n   *\n   * Filled ONLY when somebody asks. `model` below hands `loadServiceModel` a\n   * thunk rather than an awaited value, so a fleet whose models all stand alone\n   * never parses this project at all — a standalone model is read as one file,\n   * and paying for the map (and inheriting its failures) for `loam show` or the\n   * adopt brief was cost and risk for an answer nobody used.\n   */\n  architecture(docsDir: DocsDir): Promise<LoadedDoc> {\n    return memo(this.architectures, resolve(docsDir), () => loadArchitecture(docsDir));\n  }\n\n  /**\n   * Which shape each model has, keyed by resolved path — ONE read of each\n   * file's bytes per invocation, however many questions are asked of it.\n   *\n   * The bulk form is the primary one because every caller asks in bulk: the\n   * fleet target needs the shapes of the WHOLE enumeration before it can grade\n   * a single renderer-file finding, and the prefetch needs them before it can\n   * decide which workspace each model belongs in.\n   */\n  async shapes(paths: readonly string[]): Promise<Map<string, ModelShape>> {\n    const keys = [...new Set(paths.map((path) => resolve(path)))];\n    const missing = keys.filter((k) => !this.shapeOf.has(k));\n    for (const [k, shape] of await readModelShapes(missing)) {\n      // A concurrent read's promise stays authoritative — it is the one another\n      // caller is already holding — so a second scan of the same bytes can\n      // never replace it with a duplicate.\n      if (!this.shapeOf.has(k)) this.shapeOf.set(k, Promise.resolve(shape));\n    }\n    const answered = await Promise.all(keys.map(async (k) => [k, await this.shape(k)] as const));\n    return new Map(answered);\n  }\n\n  /** One model's shape, out of the same memo the bulk form fills. */\n  shape(modelPath: string): Promise<ModelShape> {\n    return memo(this.shapeOf, resolve(modelPath), () => readModelShape(modelPath));\n  }\n\n  /** A service's model, read the way its own shape demands. Memoised per model PATH, which is what identifies the file. */\n  model(docsDir: DocsDir, paths: ServicePaths): Promise<ServiceModel> {\n    return memo(this.models, resolve(paths.model), async () =>\n      serviceModelAt({\n        docsDir,\n        paths,\n        shape: await this.shape(paths.model),\n        known: await this.deps.known(docsDir),\n        // A thunk, so a standalone model never spins the map's workspace: the\n        // memo makes the extending case one parse for the run either way.\n        architecture: () => this.architecture(docsDir),\n        standalone: () => this.deps.standalone(paths.model),\n        project: () => this.project(docsDir, paths.model),\n      }),\n    );\n  }\n\n  /**\n   * Prepare every EXTENDING model's project in one workspace, and answer with\n   * the STANDALONE models' paths for the caller to prefetch through its own\n   * document batch — the two shapes need different workspaces, and only the\n   * caller has the memo the second one seeds.\n   *\n   * Purely an accelerator: a batch that could not be created seeds nothing and\n   * every reader falls back to its own load, so findings can never change\n   * because of a tmpdir — only the speed can.\n   */\n  async prefetch(docsDir: DocsDir, paths: readonly ServicePaths[]): Promise<string[]> {\n    const shapes = await this.shapes(paths.map((p) => p.model));\n    const models = (shape: ModelShape): string[] =>\n      [...shapes].filter(([, found]) => found === shape).map(([model]) => model);\n    const extending = models(\"extending\").filter((model) => !this.projects.has(model));\n    for (const [k, doc] of await batchServiceProjects(docsDir, extending)) {\n      // A concurrent load's promise stays authoritative: it is the one every\n      // reader is already holding, and replacing it would count the parse twice.\n      if (this.projects.has(k)) continue;\n      this.deps.onProjectLoad();\n      this.projects.set(k, Promise.resolve(doc));\n    }\n    return models(\"standalone\");\n  }\n\n  /**\n   * One service's project — the architecture documents and its model, parsed\n   * together. Keyed on the model, which is what `prefetch` seeds above, so a\n   * batched fleet run and a single-service run answer out of the same memo.\n   */\n  private project(docsDir: DocsDir, modelPath: string): Promise<LoadedDoc> {\n    return memo(this.projects, resolve(modelPath), async () => {\n      this.deps.onProjectLoad();\n      return asLoadedDoc(await loadProject(docsDir, await modelProjectDocuments(docsDir, modelPath)));\n    });\n  }\n}\n"]}