@ybotok/loam 0.2.0-alpha.1 → 0.2.0-alpha.13

package/dist/core/c4/service-model/shape.js

@@ -0,0 +1,106 @@
+/**
+ * Which of the two shapes a `model.likec4` has, decided by a byte scan of the
+ * file itself.
+ *
+ * A STANDALONE model declares at least one `element <kind>` inside a top-level
+ * `specification { }` block. It is parsed ALONE, exactly as every model was
+ * before this axis: it may re-declare the partners it talks to, and it renders
+ * only as a project of its own. An EXTENDING model declares no element kind —
+ * it takes the map's — and says what is inside the service with
+ * `extend <fqn> { … }`; it is parsed INSIDE the fleet's `architecture/`
+ * project, beside the map that declares those kinds.
+ *
+ * THE FILE'S OWN GRAMMAR DECIDES, never a config key, and that is the whole
+ * design of this module. A flag in `loam.json` would be a second authority on a
+ * fact the document already states, free to disagree with it — and the
+ * disagreement is not a warning but a parse: a model read the wrong way is
+ * either eleven `c4.invalid` errors (an extending model parsed alone: measured,
+ * deleting a model's `specification` under the old loader) or a pile of
+ * duplicate-declaration errors blamed on BOTH files (a standalone model staged
+ * beside the landscape). Nothing about a model has to be migrated for loam to
+ * read it correctly; the bytes say which it is.
+ *
+ * Every other answer is `extending`, and each of those is legal on purpose: a
+ * tags-only `specification { tag req-X }` (measured legal inside one project,
+ * and it lands the tag in the project's specification), a bare `model {}`, an
+ * empty file, a file that is only `views { }`. The conservative direction is
+ * therefore towards `extending` — which is why an unreadable file is NOT
+ * classified here at all (see `FleetContext.serviceModel`): absence is a
+ * question for the reader that establishes the file exists, not for a scanner
+ * looking at bytes it does not have.
+ */
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { inOrder } from "../../kernel/concurrency.js";
+import { maskSource, topLevelBlocks } from "../source-mask.js";
+/**
+ * A kind declaration inside a specification block — `element service`,
+ * `element softwareSystem`. Deliberately only `element`: `tag`,
+ * `relationship`, `deploymentNode` and `color` declare no ELEMENT kind, and a
+ * model whose specification holds only those still takes every element kind it
+ * uses from the map, which is exactly what makes it extending.
+ */
+const ELEMENT_KIND = /\belement\s+[A-Za-z_][\w-]*/;
+/**
+ * The shape of a model, from its source text.
+ *
+ * The scan runs over MASKED source (`../source-mask.ts`), so a comment or a
+ * string containing `specification { element x }` counts for nothing — and that
+ * is not a hypothetical: the brief loam writes for an adopted service explains
+ * the other shape in a comment, so an authored model can easily carry those
+ * exact words in prose. Reading them as a declaration would flip a whole
+ * service to the wrong loader.
+ *
+ * Only TOP-LEVEL blocks are considered — depth zero in the masked source — for
+ * the same reason: `specification` nested inside another block is not a
+ * declaration LikeC4 would honour, so loam must not honour it either.
+ *
+ * An unbalanced block (no closing brace) is read to end of file and still
+ * answers `standalone` when it declares a kind. That file does not parse at
+ * all, and both loaders will say so; answering `standalone` sends the reader to
+ * the one whose errors name only this file, which is the honest half of a
+ * broken document.
+ */
+export function modelShape(text) {
+    const { code } = maskSource(text);
+    // Built per call rather than hoisted to module scope: a `/g` regex carries
+    // `lastIndex`, which is mutable state a second caller would inherit — the
+    // module-level-state hazard AGENTS.md names, arriving through a constant that
+    // looks immutable.
+    const specification = /\bspecification\s*\{/g;
+    for (const { body } of topLevelBlocks(code, specification)) {
+        if (ELEMENT_KIND.test(body))
+            return "standalone";
+    }
+    return "extending";
+}
+/**
+ * One model's shape, from its bytes — the shape of a file that cannot be read
+ * is `standalone`.
+ *
+ * That is the conservative arm rather than a guess. The standalone path hands
+ * the model to the per-file loader, so a caller asking about a file that is not
+ * there (or is not readable) gets today's exact error — `c4.invalid`, naming
+ * that file — instead of a slice of the fleet map, which is what the extending
+ * path would answer about a document nobody could open.
+ */
+export async function readModelShape(path) {
+    return readFile(path, "utf8").then(modelShape, () => "standalone");
+}
+/**
+ * Many models' shapes at once, keyed by RESOLVED path.
+ *
+ * The fleet needs this list before it can do anything else: which models are
+ * batched as projects and which as documents, which directories are owed a
+ * per-service `likec4.config.json` and which must not have one. Every one of
+ * those questions is asked over the FULL service enumeration rather than over
+ * whatever subset a run is grading, so the read is a bulk one through the
+ * shared pool — a fleet of 56 models is 56 small reads, and the pool is what
+ * keeps them from being 56 sequential round-trips on a network-mounted docs
+ * repo.
+ */
+export async function readModelShapes(paths) {
+    const entries = await inOrder(paths, async (path) => [resolve(path), await readModelShape(path)]);
+    return new Map(entries);
+}
+//# sourceMappingURL=shape.js.map

package/dist/core/c4/service-model/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","sourceRoot":"","sources":["../../../../src/core/c4/service-model/shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAI/D;;;;;;GAMG;AACH,MAAM,YAAY,GAAG,6BAA6B,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAClC,2EAA2E;IAC3E,0EAA0E;IAC1E,8EAA8E;IAC9E,mBAAmB;IACnB,MAAM,aAAa,GAAG,uBAAuB,CAAC;IAC9C,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,cAAc,CAAC,IAAI,EAAE,aAAa,CAAC,EAAE,CAAC;QAC3D,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,OAAO,YAAY,CAAC;IACnD,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,IAAY;IAC/C,OAAO,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,GAAe,EAAE,CAAC,YAAY,CAAC,CAAC;AACjF,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,KAAwB;IAC5D,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,cAAc,CAAC,IAAI,CAAC,CAAU,CAAC,CAAC;IAC3G,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;AAC1B,CAAC","sourcesContent":["/**\n * Which of the two shapes a `model.likec4` has, decided by a byte scan of the\n * file itself.\n *\n * A STANDALONE model declares at least one `element <kind>` inside a top-level\n * `specification { }` block. It is parsed ALONE, exactly as every model was\n * before this axis: it may re-declare the partners it talks to, and it renders\n * only as a project of its own. An EXTENDING model declares no element kind —\n * it takes the map's — and says what is inside the service with\n * `extend <fqn> { … }`; it is parsed INSIDE the fleet's `architecture/`\n * project, beside the map that declares those kinds.\n *\n * THE FILE'S OWN GRAMMAR DECIDES, never a config key, and that is the whole\n * design of this module. A flag in `loam.json` would be a second authority on a\n * fact the document already states, free to disagree with it — and the\n * disagreement is not a warning but a parse: a model read the wrong way is\n * either eleven `c4.invalid` errors (an extending model parsed alone: measured,\n * deleting a model's `specification` under the old loader) or a pile of\n * duplicate-declaration errors blamed on BOTH files (a standalone model staged\n * beside the landscape). Nothing about a model has to be migrated for loam to\n * read it correctly; the bytes say which it is.\n *\n * Every other answer is `extending`, and each of those is legal on purpose: a\n * tags-only `specification { tag req-X }` (measured legal inside one project,\n * and it lands the tag in the project's specification), a bare `model {}`, an\n * empty file, a file that is only `views { }`. The conservative direction is\n * therefore towards `extending` — which is why an unreadable file is NOT\n * classified here at all (see `FleetContext.serviceModel`): absence is a\n * question for the reader that establishes the file exists, not for a scanner\n * looking at bytes it does not have.\n */\nimport { readFile } from \"node:fs/promises\";\nimport { resolve } from \"node:path\";\nimport { inOrder } from \"../../kernel/concurrency.js\";\nimport { maskSource, topLevelBlocks } from \"../source-mask.js\";\n\nexport type ModelShape = \"standalone\" | \"extending\";\n\n/**\n * A kind declaration inside a specification block — `element service`,\n * `element softwareSystem`. Deliberately only `element`: `tag`,\n * `relationship`, `deploymentNode` and `color` declare no ELEMENT kind, and a\n * model whose specification holds only those still takes every element kind it\n * uses from the map, which is exactly what makes it extending.\n */\nconst ELEMENT_KIND = /\\belement\\s+[A-Za-z_][\\w-]*/;\n\n/**\n * The shape of a model, from its source text.\n *\n * The scan runs over MASKED source (`../source-mask.ts`), so a comment or a\n * string containing `specification { element x }` counts for nothing — and that\n * is not a hypothetical: the brief loam writes for an adopted service explains\n * the other shape in a comment, so an authored model can easily carry those\n * exact words in prose. Reading them as a declaration would flip a whole\n * service to the wrong loader.\n *\n * Only TOP-LEVEL blocks are considered — depth zero in the masked source — for\n * the same reason: `specification` nested inside another block is not a\n * declaration LikeC4 would honour, so loam must not honour it either.\n *\n * An unbalanced block (no closing brace) is read to end of file and still\n * answers `standalone` when it declares a kind. That file does not parse at\n * all, and both loaders will say so; answering `standalone` sends the reader to\n * the one whose errors name only this file, which is the honest half of a\n * broken document.\n */\nexport function modelShape(text: string): ModelShape {\n  const { code } = maskSource(text);\n  // Built per call rather than hoisted to module scope: a `/g` regex carries\n  // `lastIndex`, which is mutable state a second caller would inherit — the\n  // module-level-state hazard AGENTS.md names, arriving through a constant that\n  // looks immutable.\n  const specification = /\\bspecification\\s*\\{/g;\n  for (const { body } of topLevelBlocks(code, specification)) {\n    if (ELEMENT_KIND.test(body)) return \"standalone\";\n  }\n  return \"extending\";\n}\n\n/**\n * One model's shape, from its bytes — the shape of a file that cannot be read\n * is `standalone`.\n *\n * That is the conservative arm rather than a guess. The standalone path hands\n * the model to the per-file loader, so a caller asking about a file that is not\n * there (or is not readable) gets today's exact error — `c4.invalid`, naming\n * that file — instead of a slice of the fleet map, which is what the extending\n * path would answer about a document nobody could open.\n */\nexport async function readModelShape(path: string): Promise<ModelShape> {\n  return readFile(path, \"utf8\").then(modelShape, (): ModelShape => \"standalone\");\n}\n\n/**\n * Many models' shapes at once, keyed by RESOLVED path.\n *\n * The fleet needs this list before it can do anything else: which models are\n * batched as projects and which as documents, which directories are owed a\n * per-service `likec4.config.json` and which must not have one. Every one of\n * those questions is asked over the FULL service enumeration rather than over\n * whatever subset a run is grading, so the read is a bulk one through the\n * shared pool — a fleet of 56 models is 56 small reads, and the pool is what\n * keeps them from being 56 sequential round-trips on a network-mounted docs\n * repo.\n */\nexport async function readModelShapes(paths: readonly string[]): Promise<Map<string, ModelShape>> {\n  const entries = await inOrder(paths, async (path) => [resolve(path), await readModelShape(path)] as const);\n  return new Map(entries);\n}\n"]}

package/dist/core/c4/service-model/slice.js

@@ -0,0 +1,188 @@
+/**
+ * The service's OWN part of a per-service project — derived, because LikeC4
+ * does not record it.
+ *
+ * Measured at the 1.59.2 pin: `$data.views[id]` carries a `sourcePath` and
+ * `$data.elements[fqn]` carries NO source-document field at all. So after the
+ * map and one extending model have been parsed together there is nothing in the
+ * parse output that says which of the two files declared a given element. The
+ * answer has to be reconstructed, and this module is the reconstruction: DIFF
+ * the project against the architecture-alone load, and resolve what is left
+ * through the same element→service resolver every fleet check already joins on.
+ *
+ * Why it matters that this is exact rather than approximate: every model-
+ * dependent check reads the slice as if it were the standalone file it used to
+ * read — `c4.no-relationships`, `health.dependency-unmodelled`, `Covers:`
+ * resolution, the attested-call scan. Too WIDE and a service is graded against
+ * the whole fleet map (every service would suddenly have relationships, and
+ * every dependency would resolve). Too NARROW and a service that models its
+ * partners correctly is told it models nothing.
+ */
+import { properAncestorIds } from "../../kernel/ids/fqn/ancestors.js";
+import { serviceResolver } from "../resolve/service.js";
+/**
+ * A relationship's identity for the DIFF, and every field of it is one loam
+ * already reads somewhere.
+ *
+ * There is no id to join on: LikeC4 mints relationship ids per parse, so the
+ * same edge in two loads of overlapping document sets is two different ids.
+ * Endpoints alone are not enough either — a fleet may draw two edges between
+ * the same pair (`api -> kafka 'publishes'` and `api -> kafka 'consumes'`), and
+ * collapsing them would let a model silently inherit one of the map's. So the
+ * key is everything a check can branch on: the endpoints, the label, and the
+ * three metadata keys plus the tag set, sorted because tag order is authoring
+ * order and means nothing.
+ */
+function relKey(rel) {
+    return JSON.stringify([
+        rel.source,
+        rel.target,
+        rel.title ?? "",
+        rel.op ?? "",
+        rel.publishes ?? "",
+        rel.consumes ?? "",
+        [...rel.tags].sort(),
+    ]);
+}
+/**
+ * The service's own slice of a per-service project.
+ *
+ * OWN is resolution PLUS NESTING, and the second half is not a widening for
+ * convenience — it is the only thing that keeps a model's own file from being
+ * filtered against it.
+ *
+ * Resolution first: every project element whose id resolves to this service,
+ * whether the model added it or the map already declared it. The bound element
+ * itself has to be in — a standalone model declared it, and every check that
+ * reads "the service's elements" expects it.
+ *
+ * Then nesting, because resolution alone ejects a child the author wrote INSIDE
+ * their own `extend` block. `serviceResolver`'s second rung answers with the
+ * nearest ancestor whose TITLE names a real `services/<id>/` directory, and that
+ * rung sees the child before it sees the parent: a container written as
+ * `store = database 'db'` under `extend svcA { … }` resolves to a service called
+ * `db` the moment some other team has adopted one, and svcA's own element is
+ * bound by title only. The model then reported one element fewer than it
+ * declares, a `Covers: svcA.store` line was convicted as a typo, and
+ * `c4.element-unowned` told the author their own container belonged in somebody
+ * else's model. A standalone model was never filtered against its own file at
+ * all, so every one of those is a regression the second shape introduced.
+ *
+ * So: an OWN ROOT is an own element none of whose proper ancestors is own — the
+ * element the author actually extended — and everything nested under one is own
+ * too. Id nesting under the extended element is evidence nobody had to guess at,
+ * and it outranks a title guess. It does NOT outrank an explicit
+ * `metadata { service '…' }` binding, which is a claim somebody wrote down: a
+ * map that nests one service's element inside another's keeps both on the right
+ * side of the line.
+ *
+ * OWN RELATIONSHIPS are the diff: the project's edges minus the ones the
+ * architecture documents already have. Resolution cannot decide this one, and
+ * the reason is the whole point of the fleet map: the map is where cross-service
+ * edges live, so `checkoutWeb -> paymentService` resolves to this service at one
+ * end and must NOT become part of the model's own relationships — otherwise
+ * every service would be graded as declaring calls it never wrote, and
+ * `landscape.service-isolated` (which asks whether the map's edges and the
+ * model's agree) would be answering about itself.
+ *
+ * The diff is a MULTISET difference, not a set one, and that distinction is the
+ * whole grade for a model that agrees with the map. A model may legitimately
+ * draw an edge the map also draws, spelled identically —
+ * `marketplace.paymentService -> stripe 'Authorizes cards'` — and under a set
+ * difference every such edge would vanish from the model's own list. Then
+ * `attestedCalls` finds no attested call, `landscape.service-isolated` reports a
+ * service that talks to nobody, the adopt brief's `landscape.attested` list
+ * comes back empty and `c4.no-relationships` fires on a model full of edges. So
+ * each structural key drops `min(architecture, project)` occurrences and the
+ * rest are the model's: one copy in the map cancels exactly one copy here.
+ *
+ * PARTNERS are the endpoints of the model's own edges that lie outside the
+ * service, AND every ancestor of such an endpoint that the project holds. The
+ * ancestors are not tidiness: a standalone model had to declare `kafka` in order
+ * to draw an edge at `kafka.orderEvents`, and health.yaml names the dependency
+ * `kafka`. Dropping the ancestor would turn a fleet's dependency declarations
+ * into `health.dependency-unmodelled` findings the day it migrated its models,
+ * with nothing in the docs having changed.
+ *
+ * UNOWNED is what the model added outside its own element — present in the
+ * project, absent from the architecture load, and resolving to somebody else. A
+ * new top-level element (`ledger` beside the map's systems) and a child added
+ * under another service's element both land here, and both are things the map
+ * or the other service should be declaring instead.
+ */
+export function sliceForService(input) {
+    const resolve = serviceResolver(input.project.elements, input.known);
+    const byId = new Map(input.project.elements.map((e) => [e.id, e]));
+    const ownIds = new Set(input.project.elements.filter((e) => resolve(e.id) === input.service).map((e) => e.id));
+    // The elements the author extended: own, with nothing own above them. Frozen
+    // before the loop below adds anything, so a child pulled in by nesting cannot
+    // itself become a root and widen the set a second time.
+    const roots = [...ownIds].filter((id) => !properAncestorIds(id).some((up) => ownIds.has(up)));
+    for (const element of input.project.elements) {
+        if (ownIds.has(element.id))
+            continue;
+        if (!roots.some((root) => element.id.startsWith(`${root}.`)))
+            continue;
+        // The one thing nesting does not outrank. An explicit binding anywhere at or
+        // above this element names its service outright, and a map that files one
+        // service's element under another's would otherwise hand the outer service
+        // every element of the inner one.
+        if (boundServiceOf(element.id, byId) !== undefined)
+            continue;
+        ownIds.add(element.id);
+    }
+    // One budget per structural key: the map's copies cancel the project's, one
+    // for one, and what the budget does not cover is the model's own.
+    const budget = new Map();
+    for (const rel of input.architecture.relationships) {
+        const k = relKey(rel);
+        budget.set(k, (budget.get(k) ?? 0) + 1);
+    }
+    const relationships = input.project.relationships.filter((rel) => {
+        const k = relKey(rel);
+        const left = budget.get(k) ?? 0;
+        if (left === 0)
+            return true;
+        budget.set(k, left - 1);
+        return false;
+    });
+    const partnerIds = new Set();
+    for (const rel of relationships) {
+        for (const endpoint of [rel.source, rel.target]) {
+            if (ownIds.has(endpoint))
+                continue;
+            for (const id of [endpoint, ...properAncestorIds(endpoint)]) {
+                if (byId.has(id) && !ownIds.has(id))
+                    partnerIds.add(id);
+            }
+        }
+    }
+    // Project order for both lists, never the order ids happened to be
+    // discovered in: the elements of a service are printed, counted and diffed,
+    // and a set that reorders itself between two runs of the same command is a
+    // diff nobody can read.
+    const archElementIds = new Set(input.architecture.elements.map((e) => e.id));
+    return {
+        elements: input.project.elements.filter((e) => ownIds.has(e.id) || partnerIds.has(e.id)),
+        relationships,
+        unowned: input.project.elements.filter((e) => !archElementIds.has(e.id) && !ownIds.has(e.id)),
+    };
+}
+/**
+ * The nearest explicit `metadata { service '…' }` binding at or above an id, or
+ * undefined when nothing on the chain declares one.
+ *
+ * `serviceResolver`'s first rung, asked on its own — because the caller above
+ * needs to tell that rung's answer apart from the two guesses below it, and the
+ * resolver returns one `DeclaredService` for all three. A binding is a claim
+ * somebody wrote down; a title match is evidence, and a bare title is a guess.
+ */
+function boundServiceOf(id, byId) {
+    for (const candidate of [id, ...properAncestorIds(id)]) {
+        const bound = byId.get(candidate)?.service;
+        if (bound !== undefined)
+            return bound;
+    }
+    return undefined;
+}
+//# sourceMappingURL=slice.js.map

package/dist/core/c4/service-model/slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.js","sourceRoot":"","sources":["../../../../src/core/c4/service-model/slice.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The service's OWN part of a per-service project — derived, because LikeC4\n * does not record it.\n *\n * Measured at the 1.59.2 pin: `$data.views[id]` carries a `sourcePath` and\n * `$data.elements[fqn]` carries NO source-document field at all. So after the\n * map and one extending model have been parsed together there is nothing in the\n * parse output that says which of the two files declared a given element. The\n * answer has to be reconstructed, and this module is the reconstruction: DIFF\n * the project against the architecture-alone load, and resolve what is left\n * through the same element→service resolver every fleet check already joins on.\n *\n * Why it matters that this is exact rather than approximate: every model-\n * dependent check reads the slice as if it were the standalone file it used to\n * read — `c4.no-relationships`, `health.dependency-unmodelled`, `Covers:`\n * resolution, the attested-call scan. Too WIDE and a service is graded against\n * the whole fleet map (every service would suddenly have relationships, and\n * every dependency would resolve). Too NARROW and a service that models its\n * partners correctly is told it models nothing.\n */\nimport { properAncestorIds } from \"../../kernel/ids/fqn/ancestors.js\";\nimport type { Elem, LoadedDoc, Rel } from \"../likec4.js\";\nimport { serviceResolver } from \"../resolve/service.js\";\n\n/** What one service owns inside a project that also holds the fleet map. */\nexport interface OwnSlice {\n  /** The service's own elements, plus the partner elements its own edges point at. */\n  elements: Elem[];\n  /** Only the relationships this model added — the project's, minus the map's. */\n  relationships: Rel[];\n  /** Elements this model added OUTSIDE its own element: the `c4.element-unowned` set. */\n  unowned: Elem[];\n}\n\nexport interface SliceRequest {\n  /** The per-service project: the architecture documents and this model, parsed together. */\n  project: LoadedDoc;\n  /** The same architecture documents parsed WITHOUT the model — the diff's other half. */\n  architecture: LoadedDoc;\n  /** The `services/<…>/<id>` directory name this model belongs to. */\n  service: string;\n  /** Every service directory that exists, so an edge into a modelled container resolves to its owner. */\n  known: ReadonlySet<string>;\n}\n\n/**\n * A relationship's identity for the DIFF, and every field of it is one loam\n * already reads somewhere.\n *\n * There is no id to join on: LikeC4 mints relationship ids per parse, so the\n * same edge in two loads of overlapping document sets is two different ids.\n * Endpoints alone are not enough either — a fleet may draw two edges between\n * the same pair (`api -> kafka 'publishes'` and `api -> kafka 'consumes'`), and\n * collapsing them would let a model silently inherit one of the map's. So the\n * key is everything a check can branch on: the endpoints, the label, and the\n * three metadata keys plus the tag set, sorted because tag order is authoring\n * order and means nothing.\n */\nfunction relKey(rel: Rel): string {\n  return JSON.stringify([\n    rel.source,\n    rel.target,\n    rel.title ?? \"\",\n    rel.op ?? \"\",\n    rel.publishes ?? \"\",\n    rel.consumes ?? \"\",\n    [...rel.tags].sort(),\n  ]);\n}\n\n/**\n * The service's own slice of a per-service project.\n *\n * OWN is resolution PLUS NESTING, and the second half is not a widening for\n * convenience — it is the only thing that keeps a model's own file from being\n * filtered against it.\n *\n * Resolution first: every project element whose id resolves to this service,\n * whether the model added it or the map already declared it. The bound element\n * itself has to be in — a standalone model declared it, and every check that\n * reads \"the service's elements\" expects it.\n *\n * Then nesting, because resolution alone ejects a child the author wrote INSIDE\n * their own `extend` block. `serviceResolver`'s second rung answers with the\n * nearest ancestor whose TITLE names a real `services/<id>/` directory, and that\n * rung sees the child before it sees the parent: a container written as\n * `store = database 'db'` under `extend svcA { … }` resolves to a service called\n * `db` the moment some other team has adopted one, and svcA's own element is\n * bound by title only. The model then reported one element fewer than it\n * declares, a `Covers: svcA.store` line was convicted as a typo, and\n * `c4.element-unowned` told the author their own container belonged in somebody\n * else's model. A standalone model was never filtered against its own file at\n * all, so every one of those is a regression the second shape introduced.\n *\n * So: an OWN ROOT is an own element none of whose proper ancestors is own — the\n * element the author actually extended — and everything nested under one is own\n * too. Id nesting under the extended element is evidence nobody had to guess at,\n * and it outranks a title guess. It does NOT outrank an explicit\n * `metadata { service '…' }` binding, which is a claim somebody wrote down: a\n * map that nests one service's element inside another's keeps both on the right\n * side of the line.\n *\n * OWN RELATIONSHIPS are the diff: the project's edges minus the ones the\n * architecture documents already have. Resolution cannot decide this one, and\n * the reason is the whole point of the fleet map: the map is where cross-service\n * edges live, so `checkoutWeb -> paymentService` resolves to this service at one\n * end and must NOT become part of the model's own relationships — otherwise\n * every service would be graded as declaring calls it never wrote, and\n * `landscape.service-isolated` (which asks whether the map's edges and the\n * model's agree) would be answering about itself.\n *\n * The diff is a MULTISET difference, not a set one, and that distinction is the\n * whole grade for a model that agrees with the map. A model may legitimately\n * draw an edge the map also draws, spelled identically —\n * `marketplace.paymentService -> stripe 'Authorizes cards'` — and under a set\n * difference every such edge would vanish from the model's own list. Then\n * `attestedCalls` finds no attested call, `landscape.service-isolated` reports a\n * service that talks to nobody, the adopt brief's `landscape.attested` list\n * comes back empty and `c4.no-relationships` fires on a model full of edges. So\n * each structural key drops `min(architecture, project)` occurrences and the\n * rest are the model's: one copy in the map cancels exactly one copy here.\n *\n * PARTNERS are the endpoints of the model's own edges that lie outside the\n * service, AND every ancestor of such an endpoint that the project holds. The\n * ancestors are not tidiness: a standalone model had to declare `kafka` in order\n * to draw an edge at `kafka.orderEvents`, and health.yaml names the dependency\n * `kafka`. Dropping the ancestor would turn a fleet's dependency declarations\n * into `health.dependency-unmodelled` findings the day it migrated its models,\n * with nothing in the docs having changed.\n *\n * UNOWNED is what the model added outside its own element — present in the\n * project, absent from the architecture load, and resolving to somebody else. A\n * new top-level element (`ledger` beside the map's systems) and a child added\n * under another service's element both land here, and both are things the map\n * or the other service should be declaring instead.\n */\nexport function sliceForService(input: SliceRequest): OwnSlice {\n  const resolve = serviceResolver(input.project.elements, input.known);\n  const byId = new Map(input.project.elements.map((e) => [e.id, e]));\n  const ownIds = new Set(\n    input.project.elements.filter((e) => resolve(e.id) === input.service).map((e) => e.id),\n  );\n  // The elements the author extended: own, with nothing own above them. Frozen\n  // before the loop below adds anything, so a child pulled in by nesting cannot\n  // itself become a root and widen the set a second time.\n  const roots = [...ownIds].filter((id) => !properAncestorIds(id).some((up) => ownIds.has(up)));\n  for (const element of input.project.elements) {\n    if (ownIds.has(element.id)) continue;\n    if (!roots.some((root) => element.id.startsWith(`${root}.`))) continue;\n    // The one thing nesting does not outrank. An explicit binding anywhere at or\n    // above this element names its service outright, and a map that files one\n    // service's element under another's would otherwise hand the outer service\n    // every element of the inner one.\n    if (boundServiceOf(element.id, byId) !== undefined) continue;\n    ownIds.add(element.id);\n  }\n\n  // One budget per structural key: the map's copies cancel the project's, one\n  // for one, and what the budget does not cover is the model's own.\n  const budget = new Map<string, number>();\n  for (const rel of input.architecture.relationships) {\n    const k = relKey(rel);\n    budget.set(k, (budget.get(k) ?? 0) + 1);\n  }\n  const relationships = input.project.relationships.filter((rel) => {\n    const k = relKey(rel);\n    const left = budget.get(k) ?? 0;\n    if (left === 0) return true;\n    budget.set(k, left - 1);\n    return false;\n  });\n\n  const partnerIds = new Set<string>();\n  for (const rel of relationships) {\n    for (const endpoint of [rel.source, rel.target]) {\n      if (ownIds.has(endpoint)) continue;\n      for (const id of [endpoint, ...properAncestorIds(endpoint)]) {\n        if (byId.has(id) && !ownIds.has(id)) partnerIds.add(id);\n      }\n    }\n  }\n\n  // Project order for both lists, never the order ids happened to be\n  // discovered in: the elements of a service are printed, counted and diffed,\n  // and a set that reorders itself between two runs of the same command is a\n  // diff nobody can read.\n  const archElementIds = new Set(input.architecture.elements.map((e) => e.id));\n  return {\n    elements: input.project.elements.filter((e) => ownIds.has(e.id) || partnerIds.has(e.id)),\n    relationships,\n    unowned: input.project.elements.filter((e) => !archElementIds.has(e.id) && !ownIds.has(e.id)),\n  };\n}\n\n/**\n * The nearest explicit `metadata { service '…' }` binding at or above an id, or\n * undefined when nothing on the chain declares one.\n *\n * `serviceResolver`'s first rung, asked on its own — because the caller above\n * needs to tell that rung's answer apart from the two guesses below it, and the\n * resolver returns one `DeclaredService` for all three. A binding is a claim\n * somebody wrote down; a title match is evidence, and a bare title is a guess.\n */\nfunction boundServiceOf(id: string, byId: ReadonlyMap<string, Elem>): string | undefined {\n  for (const candidate of [id, ...properAncestorIds(id)]) {\n    const bound = byId.get(candidate)?.service;\n    if (bound !== undefined) return bound;\n  }\n  return undefined;\n}\n"]}