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

package/dist/core/coherence/coherence.js

@@ -0,0 +1,287 @@
+import { existsSync } from "node:fs";
+import { loadFile } from "../c4/likec4.js";
+import { elementService, serviceResolver } from "../c4/resolve/service.js";
+import { serviceIdProblem } from "../kernel/ids/service.js";
+import { deltaShapeIssues } from "../delta/delta.js";
+import { featurePaths } from "../repo/paths.js";
+import { featureSpecServices } from "../repo/repo.js";
+import { enumeratedServiceIds, enumeratedServiceIndex } from "../repo/service-target.js";
+import { serviceOperationIds } from "../openapi/doc.js";
+import { declaredByService } from "./declared.js";
+import { coherenceLookups } from "./lookups.js";
+import { eventCoherence } from "./events/events.js";
+import { authoringIssues } from "./authoring/scaffold.js";
+import { glossaryDeltaIssues } from "../glossary/delta.js";
+import { flowDeltaIssues } from "../usecases/delta/flows.js";
+import { deploymentDeltaIssues, readFeatureDeployments } from "../deployment/delta.js";
+export async function featureCoherence(request) {
+    const { docsDir, featureDir, featureId, preloadedDelta, context } = request;
+    const scope = { docsDir, featureDir, featureId };
+    // Delta shape first: a diff that does not apply to the living spec explains
+    // everything downstream, and it is the one breach that is silent without a check.
+    const issues = await deltaShapeIssues(docsDir, featureDir, featureId, context);
+    // The vocabulary axis, and it is asked first because it is cheap and
+    // independent: one `existsSync` for a feature with no glossary/, and nothing
+    // downstream reads its answer. A term this feature introduces that the living
+    // glossary already defines is the one thing that can go wrong on a create-only
+    // merge, and it must be caught before the copy, not after.
+    issues.push(...(await glossaryDeltaIssues(docsDir, featureDir)));
+    // The use-case axis, and it is asked here for the vocabulary axis's reasons
+    // exactly: one walk over a directory that is usually absent, nothing
+    // downstream reads its answer, and a create-only merge has one thing that can
+    // go wrong. A flow this feature introduces that the living `architecture/`
+    // already holds must be caught before the copy, not after it has replaced an
+    // authored hop sequence.
+    issues.push(...(await flowDeltaIssues(docsDir, featureDir)));
+    issues.push(...(await deploymentDeltaIssues(docsDir, featureDir)));
+    // And the topology's second question, which the collision check above cannot
+    // ask: does the document READ against the map this feature's own merge would
+    // leave behind. It matters more literally here than one axis over — a feature
+    // that stands a service up in a new cluster declares that service in its
+    // `delta.likec4` and instances it in the topology, so the element the document
+    // names exists only post-merge — and without it the archive copies an
+    // unreadable document into `architecture/` for the next reader's
+    // `loam validate --all` to fail on, against a file they did not write.
+    const topology = await readFeatureDeployments({
+        docsDir,
+        featureDir,
+        featureId,
+        // A function rather than the context itself, for the reason the use-case
+        // overlay states: one memoised read does not justify an edge from
+        // `core/deployment/` to `fleet-context`.
+        ...(context === undefined ? {} : { load: (path) => context.loadLikeC4(path) }),
+    });
+    if (topology.kind === "unreadable") {
+        issues.push({
+            severity: "error",
+            code: "deployment.doc-invalid",
+            subject: featureId,
+            // The opening sentence does not say whose file is at fault, on the
+            // `usecase.flow-invalid` message's reasoning: the corpus is the feature's
+            // `deployment/` PLUS the living `architecture/` documents it extends, so
+            // the failing path can be a living one — a landscape that no longer
+            // parses, a topology somebody else wrote. Every message carries its own
+            // path, so a reader can place it.
+            message: `this feature's deployment document(s) could not be read against the map its own merge would leave behind, ` +
+                `so the archive would land an architecture/ nothing has checked. The corpus is the feature's deployment/ AND ` +
+                `the living architecture/ documents it extends, so the fault may be in either — each message names its file. ` +
+                `${topology.errors.length} problem(s): ${topology.errors.join("; ")}`,
+        });
+    }
+    // --- C4 delta ---
+    let elements = [];
+    let taggedEls = [];
+    let taggedRels = [];
+    const deltaPath = featurePaths(featureDir).delta;
+    if (existsSync(deltaPath)) {
+        const res = preloadedDelta ?? (context === undefined ? await loadFile(deltaPath) : await context.loadLikeC4(deltaPath));
+        if (res.errors.length > 0) {
+            // An unreadable architecture axis can prove nothing — it must never count as coherent.
+            issues.push({
+                severity: "error",
+                code: "delta.invalid",
+                message: `delta.likec4 has ${res.errors.length} parse error(s) — architecture axis unreadable (run \`loam validate --feature ${featureId}\`)`,
+            });
+        }
+        else {
+            elements = res.elements;
+            taggedEls = res.elements.filter((e) => e.tags.includes(featureId));
+            taggedRels = res.relationships.filter((r) => r.tags.includes(featureId));
+            // Every rule below filters by the feature tag, so a delta whose author
+            // forgot the tags entirely passes every check and archives while merging
+            // nothing. Whole-file only: once ANYTHING is tagged, deciding that an
+            // untagged edge "looks intended" would be guessing.
+            if ((res.elements.length > 0 || res.relationships.length > 0) &&
+                taggedEls.length === 0 &&
+                taggedRels.length === 0) {
+                issues.push({
+                    severity: "error",
+                    code: "delta.nothing-tagged",
+                    message: `delta.likec4 declares elements/relationships but none are tagged #${featureId}; loam cannot see untagged changes`,
+                });
+            }
+        }
+    }
+    // --- per-service specs (requirement operations) + openapi deltas ---
+    const svcNames = await featureSpecServices(featureDir, context);
+    // Every axis below joins on the service id, so endpoints resolve through the
+    // element's `metadata { service }` binding — never through what the box is
+    // called. The enumerated fleet — `services/` plus this feature's own
+    // `specs/` directories, the same union `enumeratedTarget` probes below —
+    // rides into the resolver so a delta that models CONTAINERS joins correctly:
+    // without it, an edge into `payment.api` resolves to a service called "api"
+    // that has never existed, and every check below grades the edge against an
+    // absent service instead of the one that owns the container. An unenumerable
+    // services/ falls back to the feature's own names — every living probe would
+    // have found nothing there anyway.
+    const fleetIds = await enumeratedServiceIds(docsDir, context);
+    const svcOf = serviceResolver(elements, new Set([...fleetIds, ...svcNames]));
+    // Which elements the landscape merge would SPLICE: the tagged ones and
+    // everything nested inside their blocks. Defined here because two checks
+    // share it — the scaffold gate just below, and the binding-grammar check
+    // near the end of this function — and the merge carries a tagged element's
+    // authored block over byte for byte, children included, so a scope narrower
+    // than the splice lets a nested child's text ride through unread.
+    const taggedIds = taggedEls.map((el) => el.id);
+    const ridesWithTag = (el) => el.tags.includes(featureId) || taggedIds.some((id) => el.id.startsWith(`${id}.`));
+    // The scaffold gate: placeholder text and an unwritten intent are legal
+    // documents whose merge would publish content nobody authored — the exact
+    // template strings `loam new` wrote (authoring/scaffold.ts owns the list).
+    issues.push(...(await authoringIssues({ featureDir, featureId, splicedEls: elements.filter(ridesWithTag), svcNames, context })));
+    const { reqOps, removingOps, featureApiOps, unreadableApis, } = await declaredByService(scope, svcNames, issues, context);
+    const { governedByLivingSpec, edgeConsumers, requirementConsumers, definedElsewhere, deprecatedInLiving, undeprecatedByFeature, } = coherenceLookups(scope, context);
+    for (const [svc, retiring] of removingOps) {
+        for (const op of retiring) {
+            const consumers = [...(await edgeConsumers(svc, op)), ...(await requirementConsumers(svc, op))];
+            if (consumers.length === 0)
+                continue;
+            issues.push({
+                severity: "error",
+                code: "openapi.remove-op-consumed",
+                subject: svc,
+                message: `${svc}: this feature retires '${op}', but the living fleet still consumes it — ${consumers.join("; ")}. Retire the consumer in the same feature (drop the edge from architecture/landscape.likec4, or the requirement that names it), or archive with --approve to break it deliberately.`,
+            });
+        }
+    }
+    // E1: Spec -> API — every operation a requirement governs must exist in that service's OpenAPI.
+    for (const [svc, ops] of reqOps) {
+        // The union below reads the feature's own contract; unreadable means the
+        // op may well be defined in the file nobody could open, and `op-undefined`
+        // would point the author at the requirement when the truth is the YAML.
+        // `openapi.invalid` (declared.ts) already gates; one breach, one finding.
+        if (unreadableApis.has(svc))
+            continue;
+        const available = await serviceOperationIds(docsDir, svc, featureDir, context);
+        for (const op of ops) {
+            if (available.includes(op))
+                continue;
+            const other = await definedElsewhere(svc, op);
+            if (other !== undefined) {
+                issues.push({ severity: "warn", code: "spec-api.op-pending", message: `requirement in ${svc} governs '${op}', defined by in-flight ${other} — archive it first` });
+                continue;
+            }
+            issues.push({ severity: "error", code: "spec-api.op-undefined", message: `requirement in ${svc} governs '${op}', not defined in ${svc}'s OpenAPI` });
+        }
+    }
+    // The declared→enumerated bridge for edge TARGETS. `svcOf` answers with
+    // whatever the document wrote — `metadata { service '../../x' }` parses in
+    // LikeC4 without one error — and every living lookup below joins its answer
+    // into `services/<target>/` or `specs/<target>/`. So a target resolves
+    // through the enumerations first (the fleet's `services/` plus this
+    // feature's own `specs/`, where a service it introduces lives), and a name
+    // neither knows skips the lookups — no ops, not governed, not deprecated —
+    // grading exactly as an absent service, spelled with the declared name.
+    const enumeratedTarget = enumeratedServiceIndex(docsDir, svcNames, context);
+    // E2 / W1 / W4: C4 edges vs API + requirements.
+    for (const r of taggedRels) {
+        if (r.op === undefined) {
+            if ((r.title ?? "").toLowerCase().startsWith("call")) {
+                issues.push({ severity: "warn", code: "c4.op-link-missing", message: `edge ${svcOf(r.source)} → ${svcOf(r.target)} ("${r.title}") has no operation link (metadata { op })` });
+            }
+            continue;
+        }
+        const target = svcOf(r.target);
+        const pathable = await enumeratedTarget(target);
+        // Same suspension as E1, but only for the verdicts that READ a contract:
+        // does the op exist, is it being removed, is it deprecated (whose
+        // un-deprecation escape reads the feature contract too). Each of those
+        // would be an opinion about a file nobody could open. The governance
+        // question below is deliberately NOT suspended — it joins the edge against
+        // requirement documents alone, so the broken YAML could never change its
+        // answer, and silencing it deferred a real warning for no reason.
+        const contractUnreadable = pathable !== undefined && unreadableApis.has(pathable);
+        const available = pathable === undefined || contractUnreadable
+            ? []
+            : await serviceOperationIds(docsDir, pathable, featureDir, context);
+        if (contractUnreadable) {
+            // openapi.invalid (declared.ts) already gates; one breach, one finding.
+        }
+        else if (pathable !== undefined && removingOps.get(pathable)?.has(r.op) === true) {
+            issues.push({ severity: "error", code: "c4-api.op-removing", message: `${svcOf(r.source)} builds new consumption on '${r.op}', which this feature removes from ${target}` });
+        }
+        else if (!available.includes(r.op)) {
+            const other = await definedElsewhere(target, r.op);
+            if (other !== undefined) {
+                issues.push({ severity: "warn", code: "c4-api.op-pending", message: `${svcOf(r.source)} calls '${r.op}' on ${target}, defined by in-flight ${other} — archive it first` });
+            }
+            else {
+                issues.push({ severity: "error", code: "c4-api.op-undefined", message: `${svcOf(r.source)} calls '${r.op}' on ${target}, but ${target}'s OpenAPI does not define it (contract broken)` });
+            }
+        }
+        // Governed by THIS target's requirements, not by anybody's. An operationId
+        // is unique only inside one contract, so the fleet-wide set this used to
+        // ask meant a `getStatus` governed in service A silenced the question for
+        // service B's entirely unrelated `getStatus` — the warning went quiet for
+        // the edge that needed it, and only in repos where some other service
+        // happened to reuse the name. The living half on the same line has always
+        // joined per service (`governedByLivingSpec(target, …)`); this is the delta
+        // half asking it the same way.
+        if (pathable === undefined || (!(reqOps.get(pathable) ?? []).includes(r.op) && !(await governedByLivingSpec(pathable, r.op)))) {
+            issues.push({ severity: "warn", code: "c4.op-ungoverned", message: `'${r.op}' is called by ${svcOf(r.source)} but no requirement governs it` });
+        }
+        // Lifecycle: this NEW tagged edge builds consumption on an operation the
+        // living provider contract already marks deprecated. Advisory, never an
+        // archive gate — the edge is legal and the contract holds — but new
+        // consumption of a dying op deserves an eye before it ships. Quiet when
+        // the feature's own openapi delta drops the flag: that state is the fix
+        // in progress, not new consumption of a dying op.
+        if (!contractUnreadable && pathable !== undefined && (await deprecatedInLiving(pathable, r.op)) && !(await undeprecatedByFeature(pathable, r.op))) {
+            issues.push({ severity: "warn", code: "c4-api.op-deprecated", message: `${svcOf(r.source)} builds new consumption on '${r.op}', which ${target}'s living OpenAPI marks deprecated — prefer the replacement operation` });
+        }
+    }
+    // W2: API -> C4 — every operation the feature adds should be consumed by some edge.
+    const consumed = new Set(taggedRels.map((r) => r.op).filter((o) => o !== undefined));
+    for (const op of featureApiOps) {
+        if (!consumed.has(op)) {
+            issues.push({ severity: "warn", code: "api.op-unconsumed", message: `operation '${op}' is added but no architecture edge consumes it (provider-only or unmodeled)` });
+        }
+    }
+    // W3: a new service should carry a requirement delta.
+    for (const e of taggedEls) {
+        const svc = elementService(e);
+        if (e.kind === "softwareSystem" && !svcNames.some((n) => n === svc)) {
+            issues.push({ severity: "warn", code: "service.no-requirement-delta", message: `new service ${svc} has no requirement delta under specs/` });
+        }
+    }
+    // An explicit `metadata { service '<id>' }` binding, held to the same grammar
+    // every `--service` flag is — on the tagged elements AND everything nested
+    // inside their blocks. The scope is the splice's, not the tag's: the
+    // landscape merge carries a tagged element's authored block over byte for
+    // byte, children included (landscape-merge.ts's rides() exists exactly so a
+    // child travels inside its parent's text), so an untagged container's
+    // binding reaches the living map as surely as its tagged parent's — and
+    // checking only the tagged elements themselves let it ride through unread.
+    // The binding is the one name the archive TRUSTS: the merge splices it into
+    // the living map verbatim, and the new-service scan probes
+    // `services/<binding>/` with it — where `metadata { service '../outside-svc' }`,
+    // which LikeC4 parses without a murmur, collapses the probe right out of
+    // services/, and the spliced map fails the very next `validate --all`
+    // (`landscape.binding-unknown`). Explicit bindings only, on purpose: a prose
+    // title with no binding is legal C4, and a title becomes a path only through
+    // `specs/<svc>/`, whose own grammar check (`delta.service-id-invalid`)
+    // guards that route. `ridesWithTag` itself is defined up beside the scaffold
+    // gate, which shares the splice's scope for the same reason.
+    for (const e of elements.filter(ridesWithTag)) {
+        if (e.service === undefined)
+            continue;
+        const problem = serviceIdProblem(e.service, "metadata { service } binding");
+        if (problem === null)
+            continue;
+        issues.push({
+            severity: "error",
+            code: "c4.service-binding-invalid",
+            subject: e.service,
+            message: `'${e.title}' (${e.id}) — ${problem} ` +
+                `\`loam archive\` would splice '${e.service}' into the living landscape.likec4 exactly as written, ` +
+                `and probe services/${e.service}/ with it. Bind the element to the services/<id>/ directory it means.`,
+        });
+    }
+    // The event axis — the same three-way agreement the operation checks above
+    // grade, joined on the message name instead of the operationId: the
+    // feature's asyncapi deltas (pins, markers, justification), the tagged
+    // edges' publishes/consumes metadata, and the requirement deltas'
+    // Publishes:/Consumes: lines (./events/events.ts owns the walk).
+    issues.push(...(await eventCoherence({ scope, svcNames, taggedRels, svcOf, context })));
+    return issues;
+}
+//# sourceMappingURL=coherence.js.map

package/dist/core/coherence/coherence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coherence.js","sourceRoot":"","sources":["../../../src/core/coherence/coherence.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync } from \"node:fs\";\nimport { loadFile, type Elem, type LoadedDoc, type Rel } from \"../c4/likec4.js\";\nimport { elementService, serviceResolver } from \"../c4/resolve/service.js\";\nimport { serviceIdProblem } from \"../kernel/ids/service.js\";\nimport { deltaShapeIssues } from \"../delta/delta.js\";\nimport type { Issue } from \"../vocabulary/issue.js\";\nimport { featurePaths } from \"../repo/paths.js\";\nimport { featureSpecServices } from \"../repo/repo.js\";\nimport { enumeratedServiceIds, enumeratedServiceIndex } from \"../repo/service-target.js\";\nimport { serviceOperationIds } from \"../openapi/doc.js\";\nimport type { FleetContext } from \"../fleet-context.js\";\nimport { declaredByService, type DeltaScope } from \"./declared.js\";\nimport { coherenceLookups } from \"./lookups.js\";\nimport { eventCoherence } from \"./events/events.js\";\nimport { authoringIssues } from \"./authoring/scaffold.js\";\nimport { glossaryDeltaIssues } from \"../glossary/delta.js\";\nimport { flowDeltaIssues } from \"../usecases/delta/flows.js\";\nimport { deploymentDeltaIssues, readFeatureDeployments } from \"../deployment/delta.js\";\nimport type { DocsDir, FeatureDir } from \"../kernel/ids/dirs.js\";\n\n\n/**\n * Cross-axis consistency for a feature: do C4 (architecture), requirements (behaviour),\n * and OpenAPI (contract) agree? Errors are hard (would corrupt the living docs on archive);\n * warnings surface softer misalignments.\n *\n * `preloadedDelta` is the feature's already-parsed delta.likec4, when the caller\n * has it — loading a LikeC4 document spins up a fresh Langium workspace, the\n * dominant per-feature cost, and validate/archive have both parsed the same file\n * moments earlier. Standalone calls omit it and nothing changes: the file is\n * loaded here, exactly as before.\n */\n\n/** How a caller names the feature being graded, and what it already has in hand. */\nexport interface CoherenceRequest {\n  docsDir: DocsDir;\n  featureDir: FeatureDir;\n  featureId: string;\n  /** The delta LikeC4 document, when the caller already parsed it. */\n  preloadedDelta?: LoadedDoc;\n  context?: FleetContext;\n}\n\nexport async function featureCoherence(request: CoherenceRequest): Promise<Issue[]> {\n  const { docsDir, featureDir, featureId, preloadedDelta, context } = request;\n  const scope: DeltaScope = { docsDir, featureDir, featureId };\n  // Delta shape first: a diff that does not apply to the living spec explains\n  // everything downstream, and it is the one breach that is silent without a check.\n  const issues: Issue[] = await deltaShapeIssues(docsDir, featureDir, featureId, context);\n\n  // The vocabulary axis, and it is asked first because it is cheap and\n  // independent: one `existsSync` for a feature with no glossary/, and nothing\n  // downstream reads its answer. A term this feature introduces that the living\n  // glossary already defines is the one thing that can go wrong on a create-only\n  // merge, and it must be caught before the copy, not after.\n  issues.push(...(await glossaryDeltaIssues(docsDir, featureDir)));\n\n  // The use-case axis, and it is asked here for the vocabulary axis's reasons\n  // exactly: one walk over a directory that is usually absent, nothing\n  // downstream reads its answer, and a create-only merge has one thing that can\n  // go wrong. A flow this feature introduces that the living `architecture/`\n  // already holds must be caught before the copy, not after it has replaced an\n  // authored hop sequence.\n  issues.push(...(await flowDeltaIssues(docsDir, featureDir)));\n  issues.push(...(await deploymentDeltaIssues(docsDir, featureDir)));\n\n  // And the topology's second question, which the collision check above cannot\n  // ask: does the document READ against the map this feature's own merge would\n  // leave behind. It matters more literally here than one axis over — a feature\n  // that stands a service up in a new cluster declares that service in its\n  // `delta.likec4` and instances it in the topology, so the element the document\n  // names exists only post-merge — and without it the archive copies an\n  // unreadable document into `architecture/` for the next reader's\n  // `loam validate --all` to fail on, against a file they did not write.\n  const topology = await readFeatureDeployments({\n    docsDir,\n    featureDir,\n    featureId,\n    // A function rather than the context itself, for the reason the use-case\n    // overlay states: one memoised read does not justify an edge from\n    // `core/deployment/` to `fleet-context`.\n    ...(context === undefined ? {} : { load: (path: string) => context.loadLikeC4(path) }),\n  });\n  if (topology.kind === \"unreadable\") {\n    issues.push({\n      severity: \"error\",\n      code: \"deployment.doc-invalid\",\n      subject: featureId,\n      // The opening sentence does not say whose file is at fault, on the\n      // `usecase.flow-invalid` message's reasoning: the corpus is the feature's\n      // `deployment/` PLUS the living `architecture/` documents it extends, so\n      // the failing path can be a living one — a landscape that no longer\n      // parses, a topology somebody else wrote. Every message carries its own\n      // path, so a reader can place it.\n      message:\n        `this feature's deployment document(s) could not be read against the map its own merge would leave behind, ` +\n        `so the archive would land an architecture/ nothing has checked. The corpus is the feature's deployment/ AND ` +\n        `the living architecture/ documents it extends, so the fault may be in either — each message names its file. ` +\n        `${topology.errors.length} problem(s): ${topology.errors.join(\"; \")}`,\n    });\n  }\n\n  // --- C4 delta ---\n  let elements: Elem[] = [];\n  let taggedEls: Elem[] = [];\n  let taggedRels: Rel[] = [];\n  const deltaPath = featurePaths(featureDir).delta;\n  if (existsSync(deltaPath)) {\n    const res = preloadedDelta ?? (context === undefined ? await loadFile(deltaPath) : await context.loadLikeC4(deltaPath));\n    if (res.errors.length > 0) {\n      // An unreadable architecture axis can prove nothing — it must never count as coherent.\n      issues.push({\n        severity: \"error\",\n        code: \"delta.invalid\",\n        message: `delta.likec4 has ${res.errors.length} parse error(s) — architecture axis unreadable (run \\`loam validate --feature ${featureId}\\`)`,\n      });\n    } else {\n      elements = res.elements;\n      taggedEls = res.elements.filter((e) => e.tags.includes(featureId));\n      taggedRels = res.relationships.filter((r) => r.tags.includes(featureId));\n      // Every rule below filters by the feature tag, so a delta whose author\n      // forgot the tags entirely passes every check and archives while merging\n      // nothing. Whole-file only: once ANYTHING is tagged, deciding that an\n      // untagged edge \"looks intended\" would be guessing.\n      if (\n        (res.elements.length > 0 || res.relationships.length > 0) &&\n        taggedEls.length === 0 &&\n        taggedRels.length === 0\n      ) {\n        issues.push({\n          severity: \"error\",\n          code: \"delta.nothing-tagged\",\n          message: `delta.likec4 declares elements/relationships but none are tagged #${featureId}; loam cannot see untagged changes`,\n        });\n      }\n    }\n  }\n  // --- per-service specs (requirement operations) + openapi deltas ---\n  const svcNames = await featureSpecServices(featureDir, context);\n\n  // Every axis below joins on the service id, so endpoints resolve through the\n  // element's `metadata { service }` binding — never through what the box is\n  // called. The enumerated fleet — `services/` plus this feature's own\n  // `specs/` directories, the same union `enumeratedTarget` probes below —\n  // rides into the resolver so a delta that models CONTAINERS joins correctly:\n  // without it, an edge into `payment.api` resolves to a service called \"api\"\n  // that has never existed, and every check below grades the edge against an\n  // absent service instead of the one that owns the container. An unenumerable\n  // services/ falls back to the feature's own names — every living probe would\n  // have found nothing there anyway.\n  const fleetIds = await enumeratedServiceIds(docsDir, context);\n  const svcOf = serviceResolver(elements, new Set<string>([...fleetIds, ...svcNames]));\n\n  // Which elements the landscape merge would SPLICE: the tagged ones and\n  // everything nested inside their blocks. Defined here because two checks\n  // share it — the scaffold gate just below, and the binding-grammar check\n  // near the end of this function — and the merge carries a tagged element's\n  // authored block over byte for byte, children included, so a scope narrower\n  // than the splice lets a nested child's text ride through unread.\n  const taggedIds = taggedEls.map((el) => el.id);\n  const ridesWithTag = (el: Elem): boolean =>\n    el.tags.includes(featureId) || taggedIds.some((id) => el.id.startsWith(`${id}.`));\n\n  // The scaffold gate: placeholder text and an unwritten intent are legal\n  // documents whose merge would publish content nobody authored — the exact\n  // template strings `loam new` wrote (authoring/scaffold.ts owns the list).\n  issues.push(\n    ...(await authoringIssues({ featureDir, featureId, splicedEls: elements.filter(ridesWithTag), svcNames, context })),\n  );\n  const {\n    reqOps, removingOps, featureApiOps, unreadableApis,\n  } = await declaredByService(scope, svcNames, issues, context);\n  const {\n    governedByLivingSpec, edgeConsumers, requirementConsumers, definedElsewhere,\n    deprecatedInLiving, undeprecatedByFeature,\n  } = coherenceLookups(scope, context);\n\n  for (const [svc, retiring] of removingOps) {\n    for (const op of retiring) {\n      const consumers = [...(await edgeConsumers(svc, op)), ...(await requirementConsumers(svc, op))];\n      if (consumers.length === 0) continue;\n      issues.push({\n        severity: \"error\",\n        code: \"openapi.remove-op-consumed\",\n        subject: svc,\n        message: `${svc}: this feature retires '${op}', but the living fleet still consumes it — ${consumers.join(\"; \")}. Retire the consumer in the same feature (drop the edge from architecture/landscape.likec4, or the requirement that names it), or archive with --approve to break it deliberately.`,\n      });\n    }\n  }\n\n  // E1: Spec -> API — every operation a requirement governs must exist in that service's OpenAPI.\n  for (const [svc, ops] of reqOps) {\n    // The union below reads the feature's own contract; unreadable means the\n    // op may well be defined in the file nobody could open, and `op-undefined`\n    // would point the author at the requirement when the truth is the YAML.\n    // `openapi.invalid` (declared.ts) already gates; one breach, one finding.\n    if (unreadableApis.has(svc)) continue;\n    const available = await serviceOperationIds(docsDir, svc, featureDir, context);\n    for (const op of ops) {\n      if (available.includes(op)) continue;\n      const other = await definedElsewhere(svc, op);\n      if (other !== undefined) {\n        issues.push({ severity: \"warn\", code: \"spec-api.op-pending\", message: `requirement in ${svc} governs '${op}', defined by in-flight ${other} — archive it first` });\n        continue;\n      }\n      issues.push({ severity: \"error\", code: \"spec-api.op-undefined\", message: `requirement in ${svc} governs '${op}', not defined in ${svc}'s OpenAPI` });\n    }\n  }\n\n  // The declared→enumerated bridge for edge TARGETS. `svcOf` answers with\n  // whatever the document wrote — `metadata { service '../../x' }` parses in\n  // LikeC4 without one error — and every living lookup below joins its answer\n  // into `services/<target>/` or `specs/<target>/`. So a target resolves\n  // through the enumerations first (the fleet's `services/` plus this\n  // feature's own `specs/`, where a service it introduces lives), and a name\n  // neither knows skips the lookups — no ops, not governed, not deprecated —\n  // grading exactly as an absent service, spelled with the declared name.\n  const enumeratedTarget = enumeratedServiceIndex(docsDir, svcNames, context);\n\n  // E2 / W1 / W4: C4 edges vs API + requirements.\n  for (const r of taggedRels) {\n    if (r.op === undefined) {\n      if ((r.title ?? \"\").toLowerCase().startsWith(\"call\")) {\n        issues.push({ severity: \"warn\", code: \"c4.op-link-missing\", message: `edge ${svcOf(r.source)} → ${svcOf(r.target)} (\"${r.title}\") has no operation link (metadata { op })` });\n      }\n      continue;\n    }\n    const target = svcOf(r.target);\n    const pathable = await enumeratedTarget(target);\n    // Same suspension as E1, but only for the verdicts that READ a contract:\n    // does the op exist, is it being removed, is it deprecated (whose\n    // un-deprecation escape reads the feature contract too). Each of those\n    // would be an opinion about a file nobody could open. The governance\n    // question below is deliberately NOT suspended — it joins the edge against\n    // requirement documents alone, so the broken YAML could never change its\n    // answer, and silencing it deferred a real warning for no reason.\n    const contractUnreadable = pathable !== undefined && unreadableApis.has(pathable);\n    const available =\n      pathable === undefined || contractUnreadable\n        ? []\n        : await serviceOperationIds(docsDir, pathable, featureDir, context);\n    if (contractUnreadable) {\n      // openapi.invalid (declared.ts) already gates; one breach, one finding.\n    } else if (pathable !== undefined && removingOps.get(pathable)?.has(r.op) === true) {\n      issues.push({ severity: \"error\", code: \"c4-api.op-removing\", message: `${svcOf(r.source)} builds new consumption on '${r.op}', which this feature removes from ${target}` });\n    } else if (!available.includes(r.op)) {\n      const other = await definedElsewhere(target, r.op);\n      if (other !== undefined) {\n        issues.push({ severity: \"warn\", code: \"c4-api.op-pending\", message: `${svcOf(r.source)} calls '${r.op}' on ${target}, defined by in-flight ${other} — archive it first` });\n      } else {\n        issues.push({ severity: \"error\", code: \"c4-api.op-undefined\", message: `${svcOf(r.source)} calls '${r.op}' on ${target}, but ${target}'s OpenAPI does not define it (contract broken)` });\n      }\n    }\n    // Governed by THIS target's requirements, not by anybody's. An operationId\n    // is unique only inside one contract, so the fleet-wide set this used to\n    // ask meant a `getStatus` governed in service A silenced the question for\n    // service B's entirely unrelated `getStatus` — the warning went quiet for\n    // the edge that needed it, and only in repos where some other service\n    // happened to reuse the name. The living half on the same line has always\n    // joined per service (`governedByLivingSpec(target, …)`); this is the delta\n    // half asking it the same way.\n    if (pathable === undefined || (!(reqOps.get(pathable) ?? []).includes(r.op) && !(await governedByLivingSpec(pathable, r.op)))) {\n      issues.push({ severity: \"warn\", code: \"c4.op-ungoverned\", message: `'${r.op}' is called by ${svcOf(r.source)} but no requirement governs it` });\n    }\n    // Lifecycle: this NEW tagged edge builds consumption on an operation the\n    // living provider contract already marks deprecated. Advisory, never an\n    // archive gate — the edge is legal and the contract holds — but new\n    // consumption of a dying op deserves an eye before it ships. Quiet when\n    // the feature's own openapi delta drops the flag: that state is the fix\n    // in progress, not new consumption of a dying op.\n    if (!contractUnreadable && pathable !== undefined && (await deprecatedInLiving(pathable, r.op)) && !(await undeprecatedByFeature(pathable, r.op))) {\n      issues.push({ severity: \"warn\", code: \"c4-api.op-deprecated\", message: `${svcOf(r.source)} builds new consumption on '${r.op}', which ${target}'s living OpenAPI marks deprecated — prefer the replacement operation` });\n    }\n  }\n\n  // W2: API -> C4 — every operation the feature adds should be consumed by some edge.\n  const consumed = new Set(taggedRels.map((r) => r.op).filter((o): o is string => o !== undefined));\n  for (const op of featureApiOps) {\n    if (!consumed.has(op)) {\n      issues.push({ severity: \"warn\", code: \"api.op-unconsumed\", message: `operation '${op}' is added but no architecture edge consumes it (provider-only or unmodeled)` });\n    }\n  }\n\n  // W3: a new service should carry a requirement delta.\n  for (const e of taggedEls) {\n    const svc: string = elementService(e);\n    if (e.kind === \"softwareSystem\" && !svcNames.some((n) => n === svc)) {\n      issues.push({ severity: \"warn\", code: \"service.no-requirement-delta\", message: `new service ${svc} has no requirement delta under specs/` });\n    }\n  }\n\n  // An explicit `metadata { service '<id>' }` binding, held to the same grammar\n  // every `--service` flag is — on the tagged elements AND everything nested\n  // inside their blocks. The scope is the splice's, not the tag's: the\n  // landscape merge carries a tagged element's authored block over byte for\n  // byte, children included (landscape-merge.ts's rides() exists exactly so a\n  // child travels inside its parent's text), so an untagged container's\n  // binding reaches the living map as surely as its tagged parent's — and\n  // checking only the tagged elements themselves let it ride through unread.\n  // The binding is the one name the archive TRUSTS: the merge splices it into\n  // the living map verbatim, and the new-service scan probes\n  // `services/<binding>/` with it — where `metadata { service '../outside-svc' }`,\n  // which LikeC4 parses without a murmur, collapses the probe right out of\n  // services/, and the spliced map fails the very next `validate --all`\n  // (`landscape.binding-unknown`). Explicit bindings only, on purpose: a prose\n  // title with no binding is legal C4, and a title becomes a path only through\n  // `specs/<svc>/`, whose own grammar check (`delta.service-id-invalid`)\n  // guards that route. `ridesWithTag` itself is defined up beside the scaffold\n  // gate, which shares the splice's scope for the same reason.\n  for (const e of elements.filter(ridesWithTag)) {\n    if (e.service === undefined) continue;\n    const problem = serviceIdProblem(e.service, \"metadata { service } binding\");\n    if (problem === null) continue;\n    issues.push({\n      severity: \"error\",\n      code: \"c4.service-binding-invalid\",\n      subject: e.service,\n      message:\n        `'${e.title}' (${e.id}) — ${problem} ` +\n        `\\`loam archive\\` would splice '${e.service}' into the living landscape.likec4 exactly as written, ` +\n        `and probe services/${e.service}/ with it. Bind the element to the services/<id>/ directory it means.`,\n    });\n  }\n\n  // The event axis — the same three-way agreement the operation checks above\n  // grade, joined on the message name instead of the operationId: the\n  // feature's asyncapi deltas (pins, markers, justification), the tagged\n  // edges' publishes/consumes metadata, and the requirement deltas'\n  // Publishes:/Consumes: lines (./events/events.ts owns the walk).\n  issues.push(...(await eventCoherence({ scope, svcNames, taggedRels, svcOf, context })));\n\n  return issues;\n}\n"]}

package/dist/core/coherence/declared.js

@@ -0,0 +1,269 @@
+/**
+ * What a feature's own delta DECLARES, per service, indexed once.
+ *
+ * Seven indexes over the same four files (the delta spec.md, arch.spec.md,
+ * openapi.yaml, and the living contract they are graded against), built in one
+ * walk because every check downstream joins on the service id and would
+ * otherwise re-read the delta per question. The distinctions here are the ones
+ * the checks cannot make for themselves: an operation a REMOVED requirement
+ * governs is being retired, so it neither claims the contract nor governs
+ * anything after the merge; a removal marker that names an id also defined
+ * elsewhere in the delta is a RELOCATION, not a retirement; and a marker with
+ * no `operationId` at all is a shape only this walk can see. The capability
+ * gate rides the same loop: both delta spec documents are graded against the
+ * fleet vocabulary here, because coherence.ts and this package's file count
+ * are both at their limits and the walk already holds the parsed documents.
+ */
+import { existsSync } from "node:fs";
+import { NotUtf8DocumentError } from "../kernel/document-bytes.js";
+import { readFile } from "node:fs/promises";
+import {} from "../kernel/ids/service.js";
+import { featureSpecPaths } from "../repo/paths.js";
+import { locateServicePaths } from "../repo/service-target.js";
+import { parseRequirements } from "../document/parse.js";
+import { readCapabilityVocabulary } from "../capabilities/capabilities.js";
+import { capabilityRequirementIndex } from "../capabilities/findings.js";
+import { withFeatureCapabilities, withFeatureRequirements } from "../capabilities/delta/overlay.js";
+import { featureCapabilityDeltas } from "../capabilities/delta/tree.js";
+import { realizesUnknownIssues } from "../capabilities/realizes/findings.js";
+import { capabilityUnknownIssues } from "../capabilities/findings.js";
+import { openapiBaselineIssues } from "../openapi/baseline/gate.js";
+import { readOpenapi } from "../openapi/doc.js";
+export async function declaredByService(scope, svcNames, issues, context) {
+    const { docsDir, featureDir, featureId } = scope;
+    const reqOps = new Map();
+    const removedReqOps = new Map();
+    /** Per service: operations this feature genuinely retires (markers minus relocations). */
+    const removingOps = new Map();
+    /** Per service: every id a removal marker names, relocations included. */
+    const allMarkerIds = new Map();
+    /** Per service: does the feature contract carry a marker with no operationId? */
+    const anonymousMarkers = new Map();
+    const featureApiOps = new Set();
+    const unreadableApis = new Set();
+    // The capability gate's vocabulary, once per call. Absent or invalid stays
+    // SILENT here — capability.invalid is validate --all's one finding about a
+    // broken file, and an absent file means the fleet never opted in — so with
+    // either, nothing new gates archive (the roadmap's own trade; the
+    // /loam-check row tells agents to fix the YAML first). `grading` is that
+    // silence hoisted into a guard, so a silent axis also skips the reads that
+    // exist only to feed it.
+    //
+    // The vocabulary is the one this feature's MERGE would leave behind, not
+    // the one on disk: a feature that adds a capability requirement in its own
+    // capability delta and `Realizes:` it from its own service delta is the
+    // flow the whole axis exists for, and graded against the living tree alone
+    // it is refused with `capability.realizes-unknown` — an error, gating
+    // archive, for a target the same archive creates. `capabilities/delta/
+    // overlay.ts` states the whole judgement. One `existsSync` for a feature
+    // that carries no capability delta, which is every feature in a fleet that
+    // has not adopted the axis.
+    const capabilityDeltas = context === undefined ? await featureCapabilityDeltas(featureDir) : await context.featureCapabilityDeltas(featureDir);
+    const capabilityVocab = withFeatureCapabilities(context === undefined ? await readCapabilityVocabulary(docsDir) : await context.capabilities(docsDir), capabilityDeltas.docs.map((d) => d.id));
+    const grading = capabilityVocab.present && capabilityVocab.invalid === undefined;
+    // The `Realizes:` index, built at most ONCE per feature and only if some
+    // delta document actually reaches the grading branch. Lazy rather than
+    // eager because it reads every capability document in the fleet, and a
+    // feature whose deltas carry no requirement file at all must not pay for
+    // that — the same "a silent axis skips the reads that feed it" rule
+    // `grading` above states, one level deeper.
+    let pendingIndex = null;
+    const capabilityReqs = () => {
+        const read = context === undefined
+            ? async (p) => parseRequirements(await readFile(p, "utf8"))
+            : (p) => context.readRequirements(p);
+        // The living index first, then widened by what this feature's capability
+        // deltas ADD or MODIFY. Both halves are inside the lazy thunk, so a
+        // feature whose deltas carry no requirement file at all pays for neither.
+        pendingIndex ??= capabilityRequirementIndex(capabilityVocab, read).then(async (index) => withFeatureRequirements(index, await Promise.all(capabilityDeltas.docs.map(async (d) => ({ id: d.id, reqs: await read(d.spec) })))));
+        return pendingIndex;
+    };
+    for (const svc of svcNames) {
+        const paths = featureSpecPaths(featureDir, svc);
+        if (existsSync(paths.spec)) {
+            const reqs = context === undefined
+                ? parseRequirements(await readFile(paths.spec, "utf8"))
+                : await context.readRequirements(paths.spec);
+            // REMOVED requirements are being retired along with their operations — their
+            // ops neither claim the contract (E1) nor govern anything after the merge.
+            reqOps.set(svc, reqs.filter((r) => r.kind !== "REMOVED").flatMap((r) => r.operations));
+            removedReqOps.set(svc, new Set(reqs.filter((r) => r.kind === "REMOVED").flatMap((r) => r.operations)));
+            if (grading) {
+                const target = { where: `${svc}: spec.md`, subject: svc };
+                issues.push(...capabilityUnknownIssues(reqs, target, capabilityVocab));
+                issues.push(...realizesUnknownIssues(reqs, target, await capabilityReqs()));
+            }
+        }
+        // The delta arch.spec.md carries the same grammar and merges the same
+        // way, so an undeclared capability in it gates identically. Nothing else
+        // in this walk needs the arch delta, so the read itself sits behind
+        // `grading` — and it is NOT always cached: `validate --feature` passes a
+        // context, but archive's plan gate (commands/archive/plan/gate.ts) calls
+        // featureCoherence without one, so this parse is paid fresh there.
+        if (grading && existsSync(paths.archSpec)) {
+            const archReqs = context === undefined
+                ? parseRequirements(await readFile(paths.archSpec, "utf8"))
+                : await context.readRequirements(paths.archSpec);
+            const archTarget = { where: `${svc}: arch.spec.md`, subject: svc };
+            issues.push(...capabilityUnknownIssues(archReqs, archTarget, capabilityVocab));
+            issues.push(...realizesUnknownIssues(archReqs, archTarget, await capabilityReqs()));
+        }
+        // Only operations genuinely NEW to this service count as feature-added: authors
+        // restate the full living API in the delta file (it is a complete document, not a patch).
+        const featDoc = await readOpenapi(paths.openapi, context);
+        // A feature contract that EXISTS but does not read is a broken document,
+        // not an empty one — the living-side `openapi.invalid` discipline
+        // (validate/service/api.ts), applied to the delta. Before this check,
+        // `validate --feature` said nothing about the file at all: the empty
+        // parse silently skipped every baseline pin and removal marker in it,
+        // and E1 graded requirements against a contract that was never read.
+        // The rest of this service's contract-axis checks are suspended — every
+        // one of them would be an opinion about a document nobody could open.
+        if (featDoc.unreadable) {
+            unreadableApis.add(svc);
+            issues.push({
+                severity: "error",
+                code: "openapi.invalid",
+                subject: svc,
+                message: `${svc}: this feature's openapi.yaml does not parse${featDoc.error === undefined ? "" : ` (${featDoc.error})`} — the contract axis is unchecked and the merge would have nothing true to write. Fix the YAML first.`,
+            });
+            continue;
+        }
+        const featOps = featDoc.ops;
+        const removals = featOps.filter((op) => op.remove);
+        // A relocation — same operationId, removal marker on the old slot, upsert
+        // on the new one — retires nothing. Every rule that asks "is this operation
+        // going away" must therefore ask the NET set (markers this feature does not
+        // redefine), while "did the author write a marker at all" asks the raw one.
+        // Conflating them made moving an endpoint fail three checks at once for a
+        // change that removes nothing.
+        const redefined = new Set(featOps.filter((op) => !op.remove).map((op) => op.id));
+        const markerIds = new Set(removals.map((op) => op.id));
+        const netRemoved = new Set([...markerIds].filter((id) => !redefined.has(id)));
+        removingOps.set(svc, netRemoved);
+        allMarkerIds.set(svc, markerIds);
+        anonymousMarkers.set(svc, featDoc.anonymousRemovals.length > 0);
+        // A marker with no operationId names a slot but no operation. Every
+        // id-keyed check is blind to it, so it used to travel all the way into the
+        // living contract as a literal `x-loam-remove: true` — the one feature-only
+        // key that must never be published.
+        for (const marker of featDoc.anonymousRemovals) {
+            issues.push({
+                severity: "error",
+                code: "openapi.remove-marker-anonymous",
+                subject: svc,
+                message: `${svc}: ${marker.method} ${marker.path} carries x-loam-remove: true but declares no operationId — loam cannot tell which operation it retires; name the operation the living contract has at that slot`,
+            });
+        }
+        const livingDoc = await readOpenapi((await locateServicePaths(docsDir, svc, context)).openapi, context);
+        const livingOps = livingDoc.ops;
+        for (const id of livingDoc.duplicateIds) {
+            const slots = livingOps.filter((op) => op.id === id).map((op) => `${op.method} ${op.path}`);
+            issues.push({
+                severity: "warn",
+                code: "openapi.duplicate-operationid",
+                subject: svc,
+                message: `${svc}: the living OpenAPI defines operationId '${id}' at ${slots.join(" and ")} — every join on the id (a requirement's Operations: line, an edge's metadata { op }, a removal marker) picks one of those slots arbitrarily`,
+            });
+        }
+        // The baseline axis — operation pins, path-item keys and components —
+        // graded in its own package (openapi/baseline/gate.ts), slot-keyed
+        // exactly as the merge writes. Texts come through the context's memoized
+        // read when there is one, mirroring the readRequirements pattern above;
+        // the gate itself never touches the filesystem.
+        if (existsSync(paths.openapi)) {
+            const livingOpenapiPath = (await locateServicePaths(docsDir, svc, context)).openapi;
+            // `context.readText` DECODES and THROWS on non-UTF-8 bytes, where the
+            // no-context `readFile` substitutes U+FFFD and lets `readOpenapi`
+            // flag the document unreadable. Uncaught, one service's UTF-16 living
+            // contract took down the whole feature target under validate's
+            // context while archive's no-context path sailed past — the exact
+            // context/no-context divergence doc.ts documents as paid for once.
+            // Either text failing to decode gets the same answer the gate gives
+            // an unreadable parse: that side's surface checks are skipped.
+            const readOr = async (p) => {
+                try {
+                    return context === undefined ? await readFile(p, "utf8") : await context.readText(p);
+                }
+                catch (err) {
+                    if (err instanceof NotUtf8DocumentError)
+                        return undefined;
+                    throw err;
+                }
+            };
+            const featureText = await readOr(paths.openapi);
+            const livingText = !existsSync(livingOpenapiPath) ? undefined : await readOr(livingOpenapiPath);
+            if (featureText !== undefined) {
+                issues.push(...openapiBaselineIssues({ featDoc, livingDoc, featureText, livingText, service: svc, featureId }));
+            }
+        }
+        if (featOps.length > 0) {
+            const living = new Set(livingOps.filter((op) => !op.remove).map((op) => op.id));
+            for (const op of featOps) {
+                if (!op.remove && !living.has(op.id))
+                    featureApiOps.add(op.id);
+            }
+            // Removal is exact: the feature names both an operationId and the
+            // path+method slot it expects to delete. That catches stale deltas whose
+            // target moved or was already retired before the archive planner runs.
+            const justified = removedReqOps.get(svc) ?? new Set();
+            for (const marker of removals) {
+                const target = livingOps.find((op) => op.path === marker.path && op.method === marker.method);
+                if (target === undefined) {
+                    issues.push({
+                        severity: "error",
+                        code: "openapi.remove-target-missing",
+                        subject: svc,
+                        message: `${svc}: removal marker for '${marker.id}' addresses ${marker.method} ${marker.path}, but no living operation exists there`,
+                    });
+                }
+                else if (target.id !== marker.id) {
+                    issues.push({
+                        severity: "error",
+                        code: "openapi.remove-target-mismatch",
+                        subject: svc,
+                        message: `${svc}: removal marker names '${marker.id}' at ${marker.method} ${marker.path}, but the living operation there is '${target.id}'`,
+                    });
+                }
+                // A relocation needs no REMOVED requirement: the requirement governing
+                // the operation stays, the operation only changes address.
+                if (!netRemoved.has(marker.id))
+                    continue;
+                if (!justified.has(marker.id)) {
+                    issues.push({
+                        severity: "error",
+                        code: "openapi.remove-marker-unjustified",
+                        subject: svc,
+                        message: `${svc}: removal marker for '${marker.id}' is not governed by a REMOVED requirement's Operations: line`,
+                    });
+                }
+            }
+        }
+    }
+    for (const [svc, required] of removedReqOps) {
+        // The markers live in the unreadable file — "no matching marker" would
+        // be a claim about a document nobody could open.
+        if (unreadableApis.has(svc))
+            continue;
+        const marked = allMarkerIds.get(svc) ?? new Set();
+        for (const op of required) {
+            if (marked.has(op))
+                continue;
+            // Distinguish "no marker at all" from "a marker is there but loam cannot
+            // read which operation it names" — the first asks the author to write the
+            // marker, the second to write the operationId, and telling somebody who
+            // already wrote the marker that there is none sends them looking for a
+            // file they are staring at.
+            issues.push({
+                severity: "error",
+                code: "openapi.remove-marker-missing",
+                subject: svc,
+                message: anonymousMarkers.get(svc) === true
+                    ? `${svc}: REMOVED requirement governs '${op}', and its feature openapi.yaml carries an x-loam-remove: true marker with no operationId — name '${op}' on that marker`
+                    : `${svc}: REMOVED requirement governs '${op}', but its feature openapi.yaml has no matching x-loam-remove: true marker`,
+            });
+        }
+    }
+    return { reqOps, removedReqOps, removingOps, allMarkerIds, anonymousMarkers, featureApiOps, unreadableApis };
+}
+//# sourceMappingURL=declared.js.map