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

package/dist/core/usecases/delta/modified.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modified.js","sourceRoot":"","sources":["../../../../src/core/usecases/delta/modified.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The LIVING flows whose `#req-` tag claims a requirement this feature changes:\n * `usecase.requirement-modified` for one it rewrites, and\n * `usecase.requirement-unresolved` for one it takes away.\n *\n * THE HOLE. A `#req-` tag joins a flow to one named promise, and the join is by\n * id. A MODIFIED requirement keeps its id and replaces its whole text, so after\n * the archive the tag still resolves, every grade of the flow stays green — and\n * the flow can be drawing exactly the behaviour the new wording forbids: an\n * event path the requirement now says is gone, a hop through a service it no\n * longer names. Nothing in loam reads a flow's MEANING, so nothing can say\n * whether the drawing still keeps the promise. What loam can say is that the\n * promise moved under it, and it said nothing.\n *\n * A WARNING, AND IT NEVER GATES. Rewording a promise a flow keeps is ordinary;\n * the flow may well still keep it. This names each flow and the requirement, so\n * the author reads one against the other while the feature is still open — and\n * redraws the flow in the same change where it no longer holds.\n *\n * A REMOVAL IS THE FLEET'S OWN ERROR, ONE ARCHIVE EARLY. The merge deletes the\n * promise and leaves the tag, so the very next `validate --all` reports the flow\n * `usecase.requirement-unresolved` — while the feature gate had said nothing and\n * the archive had exited 0 (the real-fleet review, 2026-10-21). That grade holds\n * no judgement about the drawing: the tag resolves to nothing, whatever the flow\n * shows. So it is raised here under the SAME code, at the same severity, with\n * the VIEW as its subject as at fleet altitude — the fleet's grade predicted,\n * not a second opinion beside it — and as an error it gates the archive.\n * `--approve` may walk past it, for `capability.remove-requirement-realized`'s\n * reason one carrier over: retiring a promise something still claims is the\n * author's call about the feature, loam reads the flow perfectly well (this is\n * no `usecase.flow-invalid` blindness), and the living docs then carry exactly\n * the error this named.\n *\n * GRADED AGAINST WHAT THE MERGE LEAVES, not against the REMOVED list. Each\n * document's after-side is the merge's own fold (`applyRequirementDelta`), so a\n * removal the same delta re-spells under an id that flattens to the same tag\n * leaves the tag resolving and earns nothing, exactly as the fleet will grade\n * it. The same verdict is asked of a MODIFIED: it keeps its id, but\n * an id this feature adds beside it may flatten to the same tag, and then the\n * merge breaks the tag too — the error, not the warning, whose \"the tag will\n * still resolve\" would be false. And only a claim that resolves TODAY is asked\n * about: one that is already broken is `validate --all`'s finding now, and\n * reporting it again here would be one mistake counted twice.\n *\n * TWO ALTITUDES, TWO SCOPES — the ones `validate --all` resolves the tag with.\n * A flow in `architecture/` keeps a BUSINESS promise: its `#req-` tag is scoped\n * by its `#cap-` tag to a capability document (`core/capabilities/usecase-join.ts`),\n * so it is asked about the capability requirements this feature changes. A\n * flow beside a service's model keeps that SERVICE's promise: its `#req-` tag is\n * scoped by the directory to the ids of that service's spec.md and arch.spec.md\n * (`commands/validate/service/usecases/tags.ts`), so it is asked about the\n * service requirements this feature changes there — and only the services the\n * feature's `specs/` touch can hold one. BOTH documents are that scope, so the\n * one a touched service carries no delta for is read as it stands: without it\n * an id the other document also declares would read as gone after the merge,\n * and gate an archive the fleet then grades green. The feature's own\n * `usecases/` are not living and are graded against the new text already\n * (`../grade/feature.ts`).\n *\n * WHAT IT COSTS. Nothing, for a feature that modifies and removes no\n * requirement — which is nearly every feature, and the caller does not call\n * this then. For one that does, a byte scan for the tag's own spelling\n * (`req-<slug>`) over the documents that could declare it, the living document\n * of a touched service's other axis, and a LikeC4 load only for a project one\n * of them is in: a tag name is one token, so a document without its characters\n * cannot carry it. A project that does not parse is skipped, not reported —\n * `validate --all` owns that answer (`usecase.flow-invalid`, `landscape.invalid`),\n * and a finding about one requirement must not become a second report of a\n * broken map.\n */\nimport { existsSync } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { join, relative } from \"node:path\";\nimport {\n  REQ_TAG_PREFIX,\n  resolveCapabilityTags,\n  resolveRequirementTags,\n  tagSlug,\n  type RequirementClaim,\n} from \"../../capabilities/usecase-join.js\";\nimport { gradableCapabilityIds } from \"../../capabilities/findings.js\";\nimport type { CapabilityVocabulary } from \"../../capabilities/capabilities.js\";\nimport type { CapabilityDeltaDoc } from \"../../capabilities/delta/uncovered.js\";\nimport { architectureDocuments } from \"../../c4/project/documents.js\";\nimport { architectureProjectDocuments } from \"../../c4/project/architecture.js\";\nimport type { ParsedView } from \"../../c4/parsed/dynamic-views.js\";\nimport type { LoadedDoc } from \"../../c4/likec4.js\";\nimport type { ServiceModel } from \"../../c4/service-model/load.js\";\nimport { applyRequirementDelta, replacementsOf, type Replacement } from \"../../document/apply.js\";\nimport type { Requirement } from \"../../document/spec.js\";\nimport type { DocsDir } from \"../../kernel/ids/dirs.js\";\nimport { SPEC_AXES, type ServicePaths, type SpecAxis } from \"../../repo/paths.js\";\nimport { compareIds } from \"../../repo/entries.js\";\nimport type { Issue } from \"../../vocabulary/issue.js\";\nimport { useCasesIn } from \"../fleet.js\";\nimport { viewFile } from \"../place.js\";\nimport { readServiceFlows } from \"../service/flows.js\";\n\n/** One delta document beside the living one it merges into — a capability's, or one spec axis of a service. */\nexport interface DeltaPair {\n  /** The capability id, or the service id. */\n  id: string;\n  reqs: readonly Requirement[];\n  living: readonly Requirement[];\n}\n\n/** One spec axis of a service the feature touches, and where that service lives — asked only for one whose delta changes something. */\nexport interface ServiceDeltaPair extends DeltaPair {\n  /** Which of the service's two documents this is: the other is read as it stands when the feature carries no delta for it. */\n  axis: SpecAxis[\"key\"];\n  paths: () => Promise<ServicePaths>;\n}\n\nexport interface ChangedPromiseRequest {\n  docsDir: DocsDir;\n  /** The feature's capability deltas — what an `architecture/` flow's tag is asked about. */\n  capabilities: readonly CapabilityDeltaDoc[];\n  /** The feature's service deltas, one entry per spec axis — what a service's own flow is asked about. */\n  services: readonly ServiceDeltaPair[];\n  /** The capability vocabulary a `#cap-` tag resolves against. */\n  vocabulary: CapabilityVocabulary;\n  /** The enumerated fleet, for the element→service resolver's reason (`../fleet.ts`). */\n  known: ReadonlySet<string>;\n  /**\n   * A service's model, read the way its shape demands. Injected for\n   * `./overlay.ts`'s reason: a memoised read does not justify an edge from\n   * `core/usecases/` to `fleet-context`.\n   */\n  serviceModel: (paths: ServicePaths) => Promise<ServiceModel>;\n  /**\n   * The `architecture/` project, as the invocation already holds it — the\n   * same injection, for the same reason: `validate --all` and `status` run this\n   * walk once per active feature, and a fresh load per feature is a LikeC4\n   * workspace each.\n   */\n  architecture: () => Promise<LoadedDoc>;\n  /** A living requirements document, parsed — a touched service's axis the feature carries no delta for. Injected for the same reason again. */\n  readRequirements: (path: string) => Promise<Requirement[]>;\n}\n\n/** One living flow, located, and the scope its `#req-` tag resolves in. */\ninterface LivingFlow {\n  view: ParsedView;\n  /** The repo-relative file a reader opens. */\n  file: string;\n  /** The capability ids its own `#cap-` tags resolve to, or — beside a model — its service alone. */\n  scope: string[];\n  /** Which of the two scopes `scope` is in: a capability id and a service id may be spelled alike. */\n  altitude: Altitude;\n}\n\ntype Altitude = \"capability\" | \"service\";\n\ntype Resolved = Extract<RequirementClaim, { kind: \"resolved\" }>;\n\n/**\n * Per document id — a capability, or a service's two axes together, the one\n * set its directory-scoped tag is read against — the ids a tag resolves\n * against today and after the merge, and which living ids this feature\n * rewrites or retires.\n */\ninterface Table {\n  living: Map<string, Set<string>>;\n  merged: Map<string, Set<string>>;\n  modified: Map<string, Set<string>>;\n  removed: Map<string, Set<string>>;\n}\n\nexport async function changedPromiseFlowIssues(req: ChangedPromiseRequest): Promise<Issue[]> {\n  const tables: Record<Altitude, Table> = {\n    capability: tableOf(req.capabilities),\n    service: tableOf(await withUntouchedAxes(req)),\n  };\n  const flows = [\n    ...(await fleetFlows(req, changedIds(tables.capability))),\n    ...(await serviceFlows(req, changedIds(tables.service))),\n  ];\n  const issues: Issue[] = [];\n  for (const flow of flows.sort((a, b) => compareIds(a.file, b.file) || compareIds(a.view.id, b.view.id))) {\n    const table = tables[flow.altitude];\n    const after = new Map(resolveRequirementTags(flow.view.tags, flow.scope, (id) => table.merged.get(id)).map((c) => [c.tag, c]));\n    for (const claim of resolveRequirementTags(flow.view.tags, flow.scope, (id) => table.living.get(id))) {\n      if (claim.kind !== \"resolved\") continue;\n      const change = changeOf(table, claim);\n      if (change === null) continue;\n      // The merge's verdict first, for either change: a MODIFIED keeps its id,\n      // but an id this feature adds beside it can flatten to the same tag, and\n      // then the warning's \"the tag will still resolve\" would be false.\n      const later = after.get(claim.tag);\n      if (later !== undefined && later.kind !== \"resolved\") issues.push(brokenIssue(flow, claim, { change, later }));\n      else if (change === \"MODIFIES\") issues.push(modifiedIssue(flow, claim));\n    }\n  }\n  return issues;\n}\n\nfunction changeOf(table: Table, claim: Resolved): \"MODIFIES\" | \"REMOVES\" | null {\n  if (table.modified.get(claim.capability)?.has(claim.id) === true) return \"MODIFIES\";\n  return table.removed.get(claim.capability)?.has(claim.id) === true ? \"REMOVES\" : null;\n}\n\nfunction whose(flow: LivingFlow, claim: Resolved): string {\n  return flow.altitude === \"capability\" ? `${claim.capability}#${claim.id}` : `${claim.capability}'s requirement ${claim.id}`;\n}\n\nfunction modifiedIssue(flow: LivingFlow, claim: Resolved): Issue {\n  return {\n    severity: \"warn\",\n    code: \"usecase.requirement-modified\",\n    subject: claim.capability,\n    message:\n      `${flow.file}: flow '${flow.view.id}' is tagged #${claim.tag} — it claims ${whose(flow, claim)}, which this feature MODIFIES. ` +\n      `The tag will still resolve after the archive and nothing grades what the flow draws against the new ` +\n      `wording: read the flow against the replacement, and redraw it in this change if it no longer keeps the promise.`,\n    locations: [{ path: flow.file, role: \"primary\" }],\n  };\n}\n\n/**\n * The tag the merge breaks. Two ways, and each has its own fix: a removal\n * leaves nothing the tag names, and an id this feature adds can flatten to the\n * same tag as the one it claims — the only way a MODIFIED, which keeps its id,\n * can break it at all.\n */\nfunction brokenIssue(\n  flow: LivingFlow,\n  claim: Resolved,\n  broken: { change: \"MODIFIES\" | \"REMOVES\"; later: Exclude<RequirementClaim, { kind: \"resolved\" }> },\n): Issue {\n  const { change, later } = broken;\n  const [why, fix] =\n    later.kind === \"many\"\n      ? [\n          `${later.ids.length} requirements will flatten to '${later.slug}' (${later.ids.join(\", \")}), so nothing in the tag can say which promise the flow keeps`,\n          \"rename one of the colliding ids in this change\",\n        ]\n      : [\n          \"nothing it names is left\",\n          \"drop the tag (or point it at the promise that replaces this one) in this change, or MODIFY the requirement instead of removing it\",\n        ];\n  return {\n    severity: \"error\",\n    code: \"usecase.requirement-unresolved\",\n    // The VIEW, as `validate --all` names it once the archive lands — so the\n    // prediction and the outcome are about one thing a reader opens.\n    subject: flow.view.id,\n    message:\n      `${flow.file}: flow '${flow.view.id}' is tagged #${claim.tag} — it claims ${whose(flow, claim)}, which this feature ${change}. ` +\n      `After the archive the tag no longer resolves — ${why} — and \\`loam validate --all\\` reports this flow with this ` +\n      `same error: ${fix}.`,\n    locations: [{ path: flow.file, role: \"primary\" }],\n  };\n}\n\n/**\n * Each document's table rows. The modified and removed ids are named by the id\n * the LIVING document gives them — selected by `replacementsOf`, the merge's own\n * walk, so a MODIFIED or REMOVED written by heading alone still names the id a\n * tag carries — and the after-side is that same merge's result. A document the\n * merge would refuse keeps its living ids on both sides and changes nothing:\n * the delta gate reports it, and nothing here has a true thing to say about a\n * merge that cannot happen.\n *\n * TODAY'S side leaves out a living requirement sitting under a REMOVED heading,\n * as both fleet indexes do (`capabilityRequirementIndex`, `requirementIdsOf`):\n * a tag resolving only through one is already the fleet's error. The fold\n * still runs on the whole living list, because that is the archive's input.\n */\nfunction tableOf(docs: readonly DeltaPair[]): Table {\n  const table: Table = { living: new Map(), merged: new Map(), modified: new Map(), removed: new Map() };\n  for (const doc of docs) {\n    const living = doc.living.filter((r) => r.kind !== \"REMOVED\");\n    let fold: { replaced: Replacement[]; merged: readonly Requirement[] };\n    try {\n      fold = { replaced: replacementsOf([...doc.living], [...doc.reqs]), merged: applyRequirementDelta([...doc.living], [...doc.reqs]) };\n    } catch {\n      fold = { replaced: [], merged: living };\n    }\n    idsInto(table.living, doc.id, living);\n    idsInto(table.merged, doc.id, fold.merged);\n    for (const r of fold.replaced) {\n      if (r.living.id === undefined || (r.kind !== \"MODIFIED\" && r.kind !== \"REMOVED\")) continue;\n      const into = r.kind === \"MODIFIED\" ? table.modified : table.removed;\n      into.set(doc.id, (into.get(doc.id) ?? new Set()).add(r.living.id));\n    }\n  }\n  return table;\n}\n\n/** A document's ids, unioned into its row — created even when empty, which is the `empty` arm's answer rather than `undocumented`'s. */\nfunction idsInto(rows: Map<string, Set<string>>, id: string, reqs: readonly Requirement[]): void {\n  const ids = rows.get(id) ?? new Set<string>();\n  for (const r of reqs) if (r.id !== undefined) ids.add(r.id);\n  rows.set(id, ids);\n}\n\n/** The ids each document's delta modifies or removes — what a flow has to mention to be asked about at all. */\nfunction changedIds(table: Table): Map<string, Set<string>> {\n  const out = new Map<string, Set<string>>();\n  for (const rows of [table.modified, table.removed]) {\n    for (const [id, ids] of rows) out.set(id, new Set([...(out.get(id) ?? []), ...ids]));\n  }\n  return out;\n}\n\n/**\n * The service pairs, plus — for each service whose delta modifies or removes\n * something — every document of it the feature carries no delta for, as it\n * stands (`reqs: []`, so it changes nothing and only widens both sides).\n * `requirementIdsOf` (`commands/validate/service/usecases/usecases.ts`) reads\n * both documents for a service-local tag, skipping a requirement under a\n * REMOVED heading; so must this, or a tag the untouched document keeps\n * resolving reads as broken — and one only a REMOVED entry there answers reads\n * as kept, though the archive leaves that document as it is.\n */\nasync function withUntouchedAxes(req: ChangedPromiseRequest): Promise<DeltaPair[]> {\n  const out: DeltaPair[] = [...req.services];\n  const asked = new Set<string>();\n  // Sequential, and it costs nothing worth racing: a feature names a handful of\n  // services, each read is one memoised document, and most services here\n  // already have both axes in the feature or no second document at all.\n  for (const pair of req.services) {\n    const own = req.services.filter((p) => p.id === pair.id);\n    if (asked.has(pair.id) || !own.some((p) => p.reqs.some((r) => r.kind === \"MODIFIED\" || r.kind === \"REMOVED\"))) continue;\n    asked.add(pair.id);\n    const paths = await pair.paths();\n    for (const axis of SPEC_AXES) {\n      if (own.some((p) => p.axis === axis.key) || !existsSync(paths[axis.key])) continue;\n      const living = (await req.readRequirements(paths[axis.key])).filter((r) => r.kind !== \"REMOVED\");\n      out.push({ id: pair.id, reqs: [], living });\n    }\n  }\n  return out;\n}\n\n/** The tag spellings that could claim one of these ids. */\nfunction needlesFor(changed: ReadonlyMap<string, ReadonlySet<string>>): string[] {\n  return [...new Set([...changed.values()].flatMap((ids) => [...ids].map((id) => `${REQ_TAG_PREFIX}${tagSlug(id)}`)))];\n}\n\n/** Does any of these documents contain one of the tag spellings at all? Unreadable fails closed, as `../fleet.ts`'s gate does. */\nasync function mentions(paths: readonly string[], needles: readonly string[]): Promise<boolean> {\n  for (const path of paths) {\n    try {\n      const text = (await readFile(path)).toString(\"latin1\");\n      if (needles.some((needle) => text.includes(needle))) return true;\n    } catch {\n      return true;\n    }\n  }\n  return false;\n}\n\nasync function fleetFlows(req: ChangedPromiseRequest, changed: ReadonlyMap<string, ReadonlySet<string>>): Promise<LivingFlow[]> {\n  // The vocabulary ladder (`core/capabilities/findings.ts`): with nothing\n  // declared no `#cap-` tag resolves, so no fleet flow can be said to claim anything.\n  const declared = gradableCapabilityIds(req.vocabulary);\n  if (changed.size === 0 || declared === null) return [];\n  if (!(await mentions(await architectureProjectDocuments(req.docsDir), needlesFor(changed)))) return [];\n  const read = useCasesIn(await req.architecture(), req.known);\n  if (read.kind !== \"read\") return [];\n  return read.views.map((view) => ({\n    view,\n    file: viewFile(view),\n    scope: resolveCapabilityTags(view.tags, declared).flatMap((c) => (c.kind === \"resolved\" ? [c.id] : [])),\n    altitude: \"capability\" as const,\n  }));\n}\n\nasync function serviceFlows(req: ChangedPromiseRequest, changed: ReadonlyMap<string, ReadonlySet<string>>): Promise<LivingFlow[]> {\n  const out: LivingFlow[] = [];\n  for (const [service, ids] of changed) {\n    // Sequential on purpose, for `../fleet.ts`'s gate's reason: nearly every\n    // service answers from one readdir and a byte scan, and the rare one that\n    // opens a workspace should not be raced by the ones that do not need one.\n    const pair = req.services.find((doc) => doc.id === service);\n    if (pair === undefined) continue;\n    const paths = await pair.paths();\n    if (!(await mentions(await architectureDocuments(paths.dir), needlesFor(new Map([[service, ids]]))))) continue;\n    const model = await req.serviceModel(paths);\n    if (model.mapUnreadable || model.doc.errors.length > 0) continue;\n    const flows = await readServiceFlows({\n      paths,\n      model: model.doc,\n      known: req.known,\n      ...(model.shape === \"extending\" && model.project !== null\n        ? { extending: { docsDir: req.docsDir, project: model.project } }\n        : {}),\n    });\n    if (flows.kind !== \"read\") continue;\n    for (const view of flows.views) {\n      const file = relative(req.docsDir, join(paths.dir, view.sourcePath ?? \"model.likec4\")).split(/[\\\\/]/).join(\"/\");\n      out.push({ view, file, scope: [service], altitude: \"service\" });\n    }\n  }\n  return out;\n}\n"]}

package/dist/core/usecases/delta/overlay.js

@@ -0,0 +1,76 @@
+/**
+ * A feature's flows, read against the fleet map AS THIS FEATURE'S MERGE WOULD
+ * LEAVE IT.
+ *
+ * The staging and the merge preview that make that possible are no longer here:
+ * they moved to `core/c4/project/staged.ts` when the deployment slot became the
+ * second feature-local `.likec4` document, because a second copy of that
+ * machinery is the copy that drifts, and the two would disagree first about the
+ * merge preview — the one thing both axes' refusals rest on. That module's
+ * header carries the WHY of the post-merge corpus; this one keeps what is
+ * particular to use cases, which is the interpretation: which of the staged
+ * views are this feature's, and what they resolve against.
+ *
+ * FAIL CLOSED, and not silently. Every failure is the `unreadable` arm carrying
+ * LikeC4's own messages: a flow this cannot read is never a flow that grades
+ * clean, which is the asymmetry `../fleet.ts` states for the fleet-scope scan.
+ */
+import {} from "../../c4/likec4.js";
+import { stageMergedProject } from "../../c4/project/staged.js";
+import { serviceResolver } from "../../c4/resolve/service.js";
+import { isUseCase } from "../fleet.js";
+import { featureFlows, USECASE_SUBDIR } from "./flows.js";
+/**
+ * The flows this feature carries, parsed over the post-merge map — or the
+ * honest refusal to say.
+ *
+ * A feature with no `usecases/` directory is `read` with no views, at the cost
+ * of one walk over a directory that is not there. That is the axis's
+ * per-feature opt-in and the whole price a fleet that has not adopted it pays.
+ */
+export async function readFeatureFlows(req) {
+    const flows = await featureFlows(req.featureDir);
+    if (flows.length === 0) {
+        return { kind: "read", views: [], model: { elements: [], relationships: [], known: req.known }, resolve: (id) => id };
+    }
+    // AFTER the early return, which is what makes the thunk worth its shape: the
+    // fleet read is paid only by a feature that actually brings a flow.
+    const models = req.models === undefined ? undefined : await req.models();
+    const staged = await stageMergedProject({
+        docsDir: req.docsDir,
+        featureDir: req.featureDir,
+        featureId: req.featureId,
+        documents: flows.map((flow) => ({ rel: `${USECASE_SUBDIR}/${flow.rel}`, path: flow.path })),
+        ...(req.load === undefined ? {} : { load: req.load }),
+        ...(models === undefined ? {} : { models }),
+    });
+    return interpret(staged, req.known);
+}
+/**
+ * The staged parse as the use-case axis reads it.
+ *
+ * THE FEATURE'S OWN FLOWS ONLY. A living use case is the fleet scan's to report,
+ * and repeating it here would file somebody else's finding against this
+ * feature's gate — the same scoping every other feature-side check keeps.
+ */
+function interpret(staged, known) {
+    if (staged.kind === "unreadable")
+        return { kind: "unreadable", errors: staged.errors };
+    const { doc, real, mine } = staged;
+    // Through `isUseCase`, because `UseCaseScan.views` is documented as the
+    // reserved-tag views ONLY and this is the type's second producer. The
+    // resolvers below filter on the prefix anyway, so no answer changes today —
+    // but `flowsClaiming` and `servicesInFlowsClaiming` take a `UseCaseScan` and
+    // read `scan.views` straight, and the whole point of exporting one predicate
+    // was that a second spelling of the opt-in drifts.
+    const views = (doc.views ?? [])
+        .filter((view) => view.sourcePath !== undefined && mine.has(view.sourcePath))
+        .filter(isUseCase);
+    return {
+        kind: "read",
+        views: views.map((view) => ({ ...view, sourcePath: view.sourcePath === undefined ? view.sourcePath : real(view.sourcePath) })),
+        model: { elements: doc.elements, relationships: doc.relationships, known },
+        resolve: serviceResolver(doc.elements, known),
+    };
+}
+//# sourceMappingURL=overlay.js.map

package/dist/core/usecases/delta/overlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.js","sourceRoot":"","sources":["../../../../src/core/usecases/delta/overlay.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A feature's flows, read against the fleet map AS THIS FEATURE'S MERGE WOULD\n * LEAVE IT.\n *\n * The staging and the merge preview that make that possible are no longer here:\n * they moved to `core/c4/project/staged.ts` when the deployment slot became the\n * second feature-local `.likec4` document, because a second copy of that\n * machinery is the copy that drifts, and the two would disagree first about the\n * merge preview — the one thing both axes' refusals rest on. That module's\n * header carries the WHY of the post-merge corpus; this one keeps what is\n * particular to use cases, which is the interpretation: which of the staged\n * views are this feature's, and what they resolve against.\n *\n * FAIL CLOSED, and not silently. Every failure is the `unreadable` arm carrying\n * LikeC4's own messages: a flow this cannot read is never a flow that grades\n * clean, which is the asymmetry `../fleet.ts` states for the fleet-scope scan.\n */\nimport { type LoadedDoc } from \"../../c4/likec4.js\";\nimport { stageMergedProject, type StagedProject } from \"../../c4/project/staged.js\";\nimport type { ExtendingModel } from \"../../c4/splice/contract.js\";\nimport { serviceResolver } from \"../../c4/resolve/service.js\";\nimport type { DocsDir, FeatureDir } from \"../../kernel/ids/dirs.js\";\nimport { isUseCase, type UseCaseScan } from \"../fleet.js\";\nimport { featureFlows, USECASE_SUBDIR } from \"./flows.js\";\n\n/** Everything the overlay needs, and nothing it would have to read twice. */\nexport interface FlowOverlayRequest {\n  docsDir: DocsDir;\n  featureDir: FeatureDir;\n  /** The feature's id — the tag that selects the delta's own additions. */\n  featureId: string;\n  /**\n   * The enumerated fleet, for the element→service resolver. It rides in for the\n   * reason every other edge join carries it: without it a hop drawn into a\n   * modelled container `payment.api` resolves to a service called \"api\" that\n   * has never existed.\n   */\n  known: ReadonlySet<string>;\n  /**\n   * The caller's memoised LikeC4 read, when it has one. Only `delta.likec4` goes\n   * through it, and only to compute the merge preview — but the caller\n   * (`featureCoherence`) has already loaded that exact document, and loading one\n   * spins a fresh Langium workspace, which `core/coherence/coherence.ts` calls\n   * the dominant per-feature cost.\n   *\n   * A FUNCTION rather than the `FleetContext` itself, deliberately: this package\n   * has no edge to `core/fleet-context.ts`, one memoised read does not justify\n   * adding one, and the edge would push `core/usecases/` up a DAG level for\n   * nothing. Absent, the load happens directly, which is right for a caller\n   * running outside an invocation index.\n   */\n  load?: (path: string) => Promise<LoadedDoc>;\n  /**\n   * The fleet's extending models, for the merge preview — the SAME list\n   * `loam archive` routes with. Without it the preview holds interior the\n   * archive will put in `services/<…>/model.likec4`, so a hop naming\n   * `<service-fqn>.<container>` resolves here and against nothing once the flow\n   * is living: `usecase.flow-invalid` fails open, and it is the gate\n   * `--approve` cannot override (verification 2026-09-04, review F8).\n   *\n   * A THUNK, and both halves of that matter. A function for the reason `load`\n   * is one: the reader takes a `FleetContext` and this package has no edge to\n   * it, so the caller that owns the fleet read supplies the answer. LAZY\n   * because the early return above is the axis's per-feature opt-in — a feature\n   * with no `usecases/` directory must not pay for a fleet enumeration and one\n   * read per extending model to be told there is nothing to grade.\n   */\n  models?: () => Promise<readonly ExtendingModel[]>;\n}\n\n/**\n * The flows this feature carries, parsed over the post-merge map — or the\n * honest refusal to say.\n *\n * A feature with no `usecases/` directory is `read` with no views, at the cost\n * of one walk over a directory that is not there. That is the axis's\n * per-feature opt-in and the whole price a fleet that has not adopted it pays.\n */\nexport async function readFeatureFlows(req: FlowOverlayRequest): Promise<UseCaseScan> {\n  const flows = await featureFlows(req.featureDir);\n  if (flows.length === 0) {\n    return { kind: \"read\", views: [], model: { elements: [], relationships: [], known: req.known }, resolve: (id) => id };\n  }\n  // AFTER the early return, which is what makes the thunk worth its shape: the\n  // fleet read is paid only by a feature that actually brings a flow.\n  const models = req.models === undefined ? undefined : await req.models();\n  const staged = await stageMergedProject({\n    docsDir: req.docsDir,\n    featureDir: req.featureDir,\n    featureId: req.featureId,\n    documents: flows.map((flow) => ({ rel: `${USECASE_SUBDIR}/${flow.rel}`, path: flow.path })),\n    ...(req.load === undefined ? {} : { load: req.load }),\n    ...(models === undefined ? {} : { models }),\n  });\n  return interpret(staged, req.known);\n}\n\n/**\n * The staged parse as the use-case axis reads it.\n *\n * THE FEATURE'S OWN FLOWS ONLY. A living use case is the fleet scan's to report,\n * and repeating it here would file somebody else's finding against this\n * feature's gate — the same scoping every other feature-side check keeps.\n */\nfunction interpret(staged: StagedProject, known: ReadonlySet<string>): UseCaseScan {\n  if (staged.kind === \"unreadable\") return { kind: \"unreadable\", errors: staged.errors };\n  const { doc, real, mine } = staged;\n  // Through `isUseCase`, because `UseCaseScan.views` is documented as the\n  // reserved-tag views ONLY and this is the type's second producer. The\n  // resolvers below filter on the prefix anyway, so no answer changes today —\n  // but `flowsClaiming` and `servicesInFlowsClaiming` take a `UseCaseScan` and\n  // read `scan.views` straight, and the whole point of exporting one predicate\n  // was that a second spelling of the opt-in drifts.\n  const views = (doc.views ?? [])\n    .filter((view) => view.sourcePath !== undefined && mine.has(view.sourcePath))\n    .filter(isUseCase);\n  return {\n    kind: \"read\",\n    views: views.map((view) => ({ ...view, sourcePath: view.sourcePath === undefined ? view.sourcePath : real(view.sourcePath) })),\n    model: { elements: doc.elements, relationships: doc.relationships, known },\n    resolve: serviceResolver(doc.elements, known),\n  };\n}\n"]}

package/dist/core/usecases/fleet.js

@@ -0,0 +1,296 @@
+/**
+ * The fleet's use cases, read once for whoever asks — and NOT read at all when
+ * the fleet demonstrably has none.
+ *
+ * `validate --all` grades use cases as part of a run that was already loading
+ * `architecture/` as a LikeC4 project, so it pays nothing extra. Every reader
+ * added in phase 4 is in a different position: `loam diff`, `loam delta`,
+ * `loam context` and `loam explore` did not load the fleet map as a project
+ * before, and `loam delta` in particular sits in `/loam-implement`'s inner loop
+ * — a Langium workspace spin-up there is felt on every iteration of somebody's
+ * day. So this module's whole job is to answer "which use cases does the fleet
+ * declare?" and, in the common case where the answer is none, to answer it
+ * without starting LikeC4 at all.
+ *
+ * THE CHEAP GATE IS A BYTE SCAN, and it is sound rather than heuristic. A view
+ * is a use case only if it carries a reserved tag — `#cap-<slug>`,
+ * `#req-<slug>` or `#suite-<name>`, `isUseCase` below is the whole test — and
+ * a view carries a tag only through a REFERENCE written in the document that
+ * declares the view. LikeC4's grammar spells every tag reference `HashId`: the
+ * `#` terminal, then the name. Measured at the 1.59.2 pin, the `#` is
+ * mandatory — a bare `suite-smoke` in a view body fails to resolve, and
+ * `tags #suite-smoke` fails to parse — but LikeC4's four hidden tokens may sit
+ * between the `#` and the name: `# suite-smoke`, a `#` ending one line with
+ * the name on the next, and a block comment in between all parse to the tag
+ * `suite-smoke`. So the scan finds each `#`, skips exactly those tokens
+ * (`referencesReservedTag`), and asks whether a reserved prefix starts there.
+ * A document set in which no file does declares no use case, however badly it
+ * parses, and `{ views: [] }` is the correct answer, not an evasion. A
+ * `tag cap-…` line in a `specification` block is a declaration, not a
+ * reference, and does not open the gate: a tag no view carries opts nothing
+ * in.
+ *
+ * THE `#` IS WHAT KEEPS PROSE OUT. The scan used to look for the bare
+ * substrings, so a view titled 'What the e2e-suite-a job exercises', or a
+ * comment naming `req-` in passing, opened it. At fleet scope that cost one
+ * project load, because a map that does not parse is `landscape.invalid`
+ * whether or not the gate opens; at service scope (`./service/flows.ts`) it
+ * turned an untagged hand-drawn sibling that did not parse into
+ * `usecase.flow-invalid` — an error, exit 1 — over a diagram that opted
+ * nothing in. A `#` followed by a reserved prefix still opens it wherever it
+ * is written, a comment or a description included: that over-scan is
+ * accepted, because it is spelled as the tag syntax, and the scan must never
+ * be narrower than the parser.
+ *
+ * The scan reads bytes rather than decoded text on purpose: it looks for
+ * ASCII, and `readFile(path, "utf8")` on a document that is not UTF-8 would
+ * substitute U+FFFD and could hide it. Decoded as latin1 instead, every byte is
+ * one character, and the bytes of a multi-byte sequence never read as ASCII.
+ *
+ * EVERY PREFIX, because the gate and the predicate answer one question and a
+ * gate narrower than the predicate is silence rather than a smaller answer. A
+ * fleet whose only flow is tagged `#req-` alone writes `cap-` nowhere, so a
+ * `cap-`-only scan returned `false` and none of the five readers ever loaded
+ * the project — the widening below would have fixed nothing without this one.
+ * The suite prefix joined for the same reason the day a `#suite-`-only view
+ * became a use case: both now read one list, `USE_CASE_TAG_PREFIXES`, so a
+ * fourth prefix cannot be added to one and not the other.
+ *
+ * The gate FAILS CLOSED. A document this module cannot open is treated as one
+ * that might mention the prefix, so the project load happens and reports the
+ * failure as a hole. The alternative — reading an EACCES as "no tag here" — is
+ * the fail-open shape docs/CODE-STYLE.md forbids at a validator, arriving in an
+ * optimisation.
+ */
+import { readFile } from "node:fs/promises";
+import { CAP_TAG_PREFIX, REQ_TAG_PREFIX } from "../capabilities/usecase-join.js";
+import { architectureProjectDocuments, loadArchitecture } from "../c4/project/architecture.js";
+import { errorText } from "../c4/likec4.js";
+import { serviceResolver } from "../c4/resolve/service.js";
+import { SUITE_TAG_PREFIX } from "./suites/suites.js";
+/**
+ * Every reserved prefix that opts a view in — the one list both the byte gate
+ * and `isUseCase` read, so the two cannot disagree about which tags make a use
+ * case. `cap-` and `req-` are spelled by the capability join that resolves
+ * them; `suite-` by `./suites/suites.ts`, which groups by it and resolves
+ * nothing, because a suite name is checked by LikeC4's own undeclared-tag
+ * refusal rather than by a vocabulary.
+ */
+const USE_CASE_TAG_PREFIXES = [CAP_TAG_PREFIX, REQ_TAG_PREFIX, SUITE_TAG_PREFIX];
+/**
+ * Does any document in the set reference a reserved tag — a `#`, then only
+ * LikeC4's hidden tokens, then `cap-`, `req-` or `suite-`?
+ *
+ * Sequential and short-circuiting ON PURPOSE — the usual "no await in a loop"
+ * rule is about independent work that all has to finish, and this loop exists
+ * precisely so that a fleet whose first file declares a use case stops reading
+ * the other ninety-nine.
+ *
+ * What the scan lets through costs differently at its two callers, and the
+ * header above names both. A `#req-…` written in a comment opens it: at fleet
+ * scope that is one project load loam could have skipped, a slower right
+ * answer; at service scope it loads a sibling set that may not parse, and a
+ * broken one is then `usecase.flow-invalid` — an error, but over a document
+ * that spelled the tag syntax. Prose without the `#` opens neither. Missing a
+ * reference would cost a wrong answer at both: a use case nobody graded.
+ *
+ * Exported for the service-scope reader (`./service/flows.ts`), which asks the
+ * same question of the `.likec4` files beside one `model.likec4`: a sibling set
+ * that references no reserved tag declares no use case, so a hand-drawn
+ * `views.likec4` costs that service no LikeC4 workspace. One gate, two callers,
+ * because a second byte scan spelled in the service package would be free to
+ * disagree with this one about which prefixes opt a view in.
+ */
+export async function mentionsTagPrefix(paths) {
+    for (const path of paths) {
+        try {
+            const bytes = await readFile(path);
+            if (referencesReservedTag(bytes.toString("latin1")))
+                return true;
+        }
+        catch {
+            // Unreadable is not "no tag": the project load below owns that failure and
+            // will report it as a hole naming the document. Answering `false` here
+            // would let an unopenable file grade the fleet as having no use cases.
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Is a reserved prefix written as a tag reference anywhere in this text? Every
+ * `#` is tried, wherever it stands — in a view body, a comment, a string —
+ * because the scan may over-approximate the parser and never under-approximate
+ * it.
+ *
+ * A text with no `#`, or with no reserved prefix anywhere in it, cannot answer
+ * yes, so it is answered before the table below is built: that is nearly every
+ * document, and it costs those two native searches and no allocation.
+ *
+ * Exported for its own test (test/usecase-byte-gate.test.ts), which holds it to
+ * the walk the first version made from each `#` over crafted inputs, and holds
+ * its cost to one pass over inputs that walk took minutes on.
+ */
+export function referencesReservedTag(text) {
+    const first = text.indexOf("#");
+    if (first === -1 || !USE_CASE_TAG_PREFIXES.some((prefix) => text.includes(prefix)))
+        return false;
+    const nameAt = hiddenRunEnds(text);
+    for (let hash = first; hash !== -1; hash = text.indexOf("#", hash + 1)) {
+        const name = nameAt[hash + 1];
+        if (USE_CASE_TAG_PREFIXES.some((prefix) => text.startsWith(prefix, name)))
+            return true;
+    }
+    return false;
+}
+/**
+ * For every position in `text`, where the next token LikeC4 would read starts
+ * from there: past whitespace, line breaks, `//` line comments and block
+ * comments — the four terminals the 1.59.2 grammar marks hidden (`WS`, `NL`,
+ * `LINE_COMMENT`, `BLOCK_COMMENT`), which its lexer drops between the `#` of a
+ * tag reference and the name. Index `text.length` is the end itself.
+ *
+ * ONE PASS, FROM THE END, so every answer is built from answers already known
+ * and the whole table costs one visit per character, however the `#`s and the
+ * comments interleave. The first version walked forward from each `#` instead,
+ * and a run of hidden tokens with `#`s inside it was re-walked once per `#`:
+ * `#/*` repeated took 17.6 s on 100 KB (each unclosed opener searched the rest
+ * of the file for a closer), and `#//` repeated on one line, or the same `#/*`
+ * run closed once at its end, were quadratic the same way. Remembering only
+ * where the closer search last failed would have fixed the first of those
+ * three and left the other two; nothing short of reusing every answer fixes
+ * the shape, and this scan runs over every document on every reader's path.
+ *
+ * A hand loop rather than one regular expression: a repeated group of
+ * alternatives that can each consume a comment backtracks exponentially on a
+ * long run of slashes. An UNTERMINATED block comment is not one LikeC4 can lex
+ * as a comment, so only the `/*` itself is stepped over and a name written
+ * after it still counts: that can open the gate more often, never less, and
+ * the document cannot parse anyway — the load the gate opens is what reports
+ * it. The closer is searched from two past the opener, so the `*` of an opener
+ * never doubles as the `*` of its closer, exactly as the lexer reads it.
+ */
+function hiddenRunEnds(text) {
+    const end = new Int32Array(text.length + 1);
+    end[text.length] = text.length;
+    // The nearest line break at or after the position being read, and the
+    // nearest `*/` at or after the NEXT position and the one after that — an
+    // opener at `at` searches from `at + 2`, and the pass meets that position
+    // before it meets `at`. -1 is "none".
+    let lineBreak = text.length;
+    let closeFromNext = -1;
+    let closeFromAfterNext = -1;
+    for (let at = text.length - 1; at >= 0; at -= 1) {
+        const char = text[at];
+        const closeFromHere = char === "*" && text[at + 1] === "/" ? at : closeFromNext;
+        if (char === "\r" || char === "\n")
+            lineBreak = at;
+        if (char === " " || char === "\t" || char === "\r" || char === "\n") {
+            end[at] = end[at + 1];
+        }
+        else if (char === "/" && text[at + 1] === "/") {
+            // The comment runs to the line break and leaves it unread; the break is
+            // whitespace, so the run goes on from there. No break: the text ends.
+            end[at] = end[lineBreak];
+        }
+        else if (char === "/" && text[at + 1] === "*") {
+            end[at] = closeFromAfterNext === -1 ? end[at + 2] : end[closeFromAfterNext + 2];
+        }
+        else {
+            end[at] = at;
+        }
+        closeFromAfterNext = closeFromNext;
+        closeFromNext = closeFromHere;
+    }
+    return end;
+}
+/**
+ * Is this a use case at all? — the ONE answer, for `validate` and every reader
+ * alike.
+ *
+ * ANY RESERVED PREFIX OPTS A VIEW IN. A view carrying `#req-CHK-ONCE` and no
+ * `#cap-` tag is an author who asked to be graded and forgot half the claim; it
+ * earns `usecase.requirement-unresolved`'s `unscoped` arm rather than silence,
+ * and SCHEMA.md has said so since the tag shipped. A view carrying only
+ * `#suite-<name>` claims no capability and no requirement and is still a use
+ * case — the owner's call, recorded in SCHEMA.md: putting a journey in a suite
+ * is asking for it to be run, and a journey a test stand is provisioned from
+ * must be held to the model hop by hop like any other.
+ *
+ * It is exported because it was the asymmetry, not the rule, that was the
+ * defect. `validate --all` widened here and the readers did not, so a
+ * `#req-`-only flow was graded hop by hop by the gate and invisible to `loam
+ * diff`, `delta`, `status`, the packs and `list capabilities` — a fleet where
+ * the gate and the report disagree about what exists, which is worse than
+ * either answer alone. One predicate is what stops that recurring: a caller
+ * that spells `startsWith` itself is a second answer waiting to drift.
+ *
+ * The parameter is the smallest shape the test needs rather than `ParsedView`,
+ * so a caller holding a view-like row does not have to build one to ask. Every
+ * prefix test matches its reader's exactly, case included, so a view can never
+ * be opted in here and read as untagged in `resolveCapabilityTags` or
+ * `suiteNames`.
+ *
+ * NOT the same question as `flowsClaiming`'s. That one asks which flows claim
+ * capability X and matches the whole `cap-<slug>` tag; a `#req-`-only view
+ * claims none, and it is correct for it to stay out of that answer while
+ * counting as a use case here.
+ */
+export function isUseCase(view) {
+    return view.tags.some((tag) => USE_CASE_TAG_PREFIXES.some((prefix) => tag.startsWith(prefix)));
+}
+/**
+ * The fleet's declared use cases, with the model they are drawn over.
+ *
+ * Reads only, throws nothing, and refuses nothing: every failure is the
+ * `unreadable` arm. Callers memoise this per invocation — nothing is cached
+ * here, because a module-level cache keyed on a docsDir would leak across the
+ * `chdir`-per-test processes AGENTS.md warns about and, in a long-running host,
+ * across invocations.
+ */
+export async function readUseCases(req) {
+    const none = {
+        kind: "read",
+        views: [],
+        model: { elements: [], relationships: [], known: req.known },
+        resolve: (id) => id,
+    };
+    // EXACTLY the documents `loadArchitecture` will load two lines down, root
+    // `exclude` and all — `architectureProjectDocuments` is that one answer
+    // (`c4/project/architecture.ts`). The gate used to walk `architecture/` for
+    // itself and skip the exclude, which could only over-scan: the byte gate
+    // reading a document the loader then drops decides "there might be a use
+    // case here" and pays for a project load that finds none. Never a wrong
+    // answer, but two lists that disagree about what the project is, and the
+    // next reader to take the wider one for the project's would be wrong.
+    const documents = await architectureProjectDocuments(req.docsDir);
+    if (!(await mentionsTagPrefix(documents)))
+        return none;
+    return useCasesIn(await loadArchitecture(req.docsDir), req.known);
+}
+/**
+ * The use cases of an `architecture/` project somebody has ALREADY loaded —
+ * `readUseCases` minus its byte gate and its load.
+ *
+ * For a reader that needs the project anyway: the consumer index
+ * (`core/consumers/`) reads the project's edges and its hops off one load, and
+ * going through `readUseCases` there would parse the same documents a second
+ * time behind a gate whose whole purpose is to skip a load that has already
+ * happened. The answer is the same one: a project with no reserved-tag view
+ * yields `read` with no views, exactly what the gate returns without loading.
+ */
+export function useCasesIn(doc, known) {
+    // loam's standing rule, at project altitude: errors mean no model. A use-case
+    // file with one unresolved element leaves the whole project unusable, and
+    // grading a flow against half a map is the wrong answer this refuses to give.
+    if (doc.errors.length > 0) {
+        return { kind: "unreadable", errors: doc.errors.map(errorText) };
+    }
+    return {
+        kind: "read",
+        views: (doc.views ?? []).filter(isUseCase),
+        model: { elements: doc.elements, relationships: doc.relationships, known },
+        resolve: serviceResolver(doc.elements, known),
+    };
+}
+//# sourceMappingURL=fleet.js.map

package/dist/core/usecases/fleet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet.js","sourceRoot":"","sources":["../../../src/core/usecases/fleet.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The fleet's use cases, read once for whoever asks — and NOT read at all when\n * the fleet demonstrably has none.\n *\n * `validate --all` grades use cases as part of a run that was already loading\n * `architecture/` as a LikeC4 project, so it pays nothing extra. Every reader\n * added in phase 4 is in a different position: `loam diff`, `loam delta`,\n * `loam context` and `loam explore` did not load the fleet map as a project\n * before, and `loam delta` in particular sits in `/loam-implement`'s inner loop\n * — a Langium workspace spin-up there is felt on every iteration of somebody's\n * day. So this module's whole job is to answer \"which use cases does the fleet\n * declare?\" and, in the common case where the answer is none, to answer it\n * without starting LikeC4 at all.\n *\n * THE CHEAP GATE IS A BYTE SCAN, and it is sound rather than heuristic. A view\n * is a use case only if it carries a reserved tag — `#cap-<slug>`,\n * `#req-<slug>` or `#suite-<name>`, `isUseCase` below is the whole test — and\n * a view carries a tag only through a REFERENCE written in the document that\n * declares the view. LikeC4's grammar spells every tag reference `HashId`: the\n * `#` terminal, then the name. Measured at the 1.59.2 pin, the `#` is\n * mandatory — a bare `suite-smoke` in a view body fails to resolve, and\n * `tags #suite-smoke` fails to parse — but LikeC4's four hidden tokens may sit\n * between the `#` and the name: `# suite-smoke`, a `#` ending one line with\n * the name on the next, and a block comment in between all parse to the tag\n * `suite-smoke`. So the scan finds each `#`, skips exactly those tokens\n * (`referencesReservedTag`), and asks whether a reserved prefix starts there.\n * A document set in which no file does declares no use case, however badly it\n * parses, and `{ views: [] }` is the correct answer, not an evasion. A\n * `tag cap-…` line in a `specification` block is a declaration, not a\n * reference, and does not open the gate: a tag no view carries opts nothing\n * in.\n *\n * THE `#` IS WHAT KEEPS PROSE OUT. The scan used to look for the bare\n * substrings, so a view titled 'What the e2e-suite-a job exercises', or a\n * comment naming `req-` in passing, opened it. At fleet scope that cost one\n * project load, because a map that does not parse is `landscape.invalid`\n * whether or not the gate opens; at service scope (`./service/flows.ts`) it\n * turned an untagged hand-drawn sibling that did not parse into\n * `usecase.flow-invalid` — an error, exit 1 — over a diagram that opted\n * nothing in. A `#` followed by a reserved prefix still opens it wherever it\n * is written, a comment or a description included: that over-scan is\n * accepted, because it is spelled as the tag syntax, and the scan must never\n * be narrower than the parser.\n *\n * The scan reads bytes rather than decoded text on purpose: it looks for\n * ASCII, and `readFile(path, \"utf8\")` on a document that is not UTF-8 would\n * substitute U+FFFD and could hide it. Decoded as latin1 instead, every byte is\n * one character, and the bytes of a multi-byte sequence never read as ASCII.\n *\n * EVERY PREFIX, because the gate and the predicate answer one question and a\n * gate narrower than the predicate is silence rather than a smaller answer. A\n * fleet whose only flow is tagged `#req-` alone writes `cap-` nowhere, so a\n * `cap-`-only scan returned `false` and none of the five readers ever loaded\n * the project — the widening below would have fixed nothing without this one.\n * The suite prefix joined for the same reason the day a `#suite-`-only view\n * became a use case: both now read one list, `USE_CASE_TAG_PREFIXES`, so a\n * fourth prefix cannot be added to one and not the other.\n *\n * The gate FAILS CLOSED. A document this module cannot open is treated as one\n * that might mention the prefix, so the project load happens and reports the\n * failure as a hole. The alternative — reading an EACCES as \"no tag here\" — is\n * the fail-open shape docs/CODE-STYLE.md forbids at a validator, arriving in an\n * optimisation.\n */\nimport { readFile } from \"node:fs/promises\";\nimport type { StepScope } from \"../c4/resolve/steps.js\";\nimport { CAP_TAG_PREFIX, REQ_TAG_PREFIX } from \"../capabilities/usecase-join.js\";\nimport type { ParsedView } from \"../c4/parsed/dynamic-views.js\";\nimport { architectureProjectDocuments, loadArchitecture } from \"../c4/project/architecture.js\";\nimport { errorText, type LoadedDoc } from \"../c4/likec4.js\";\nimport { serviceResolver } from \"../c4/resolve/service.js\";\nimport type { DocsDir } from \"../kernel/ids/dirs.js\";\nimport { SUITE_TAG_PREFIX } from \"./suites/suites.js\";\n\n/**\n * Every reserved prefix that opts a view in — the one list both the byte gate\n * and `isUseCase` read, so the two cannot disagree about which tags make a use\n * case. `cap-` and `req-` are spelled by the capability join that resolves\n * them; `suite-` by `./suites/suites.ts`, which groups by it and resolves\n * nothing, because a suite name is checked by LikeC4's own undeclared-tag\n * refusal rather than by a vocabulary.\n */\nconst USE_CASE_TAG_PREFIXES: readonly string[] = [CAP_TAG_PREFIX, REQ_TAG_PREFIX, SUITE_TAG_PREFIX];\n\n/**\n * What the fleet's use cases are, or the honest refusal to say.\n *\n * Two variants rather than a record with an `unreadable` flag, because the\n * fields are not independent: a project that did not parse has no elements to\n * resolve against and no views to grade, and a caller handed\n * `{ views: [], unreadable: true }` is one `.length` check away from printing\n * \"no use cases touch this service\" about a fleet nobody could read. Tagged,\n * that state stops being constructible — every caller has to name the\n * `unreadable` arm to get at the views.\n *\n * `read` with an empty `views` is the ordinary answer for a fleet that draws no\n * use cases, and it is exactly what the cheap gate returns without loading\n * anything: the gate is an optimisation over a question with a known answer,\n * never a third verdict.\n */\nexport type UseCaseScan =\n  | {\n      kind: \"read\";\n      /** The reserved-tag views ONLY — `isUseCase` below is the opt-in, and the only one. */\n      views: readonly ParsedView[];\n      /**\n       * What a hop is attributed against, built ONCE per scan. It carries the\n       * fleet set that `resolve` below was built from, which is what stops\n       * \"which service is this element\" being answered one way by\n       * `attributeStep`'s fallback tier and another by a caller's own join —\n       * the same reason `validate`'s `StepGrading` holds both together.\n       *\n       * `known` is REQUIRED here while `StepScope` leaves it optional, and the\n       * narrowing is load-bearing rather than tidy: every scan is built from a\n       * `UseCaseRequest` that has one, so a consumer reading `model.known` was\n       * writing an `undefined` branch that could not be reached and could not be\n       * tested. A `StepScope` is still what `attributeStep` receives.\n       */\n      model: StepScope & { known: ReadonlySet<string> };\n      /** One element→service resolver for the whole scan, built with the enumerated fleet. */\n      resolve: (id: string) => string;\n    }\n  | {\n      kind: \"unreadable\";\n      /**\n       * LikeC4's own messages, so a caller can say WHICH document broke —\n       * spelled through `errorText` like every other diagnostic loam prints.\n       * They used to travel raw, so the 1-based line was missing and one\n       * dropped quote in the map put a 143 KB parser message into the\n       * `useCaseScan.error` of every service's `loam context --json`.\n       */\n      errors: string[];\n    };\n\nexport interface UseCaseRequest {\n  docsDir: DocsDir;\n  /**\n   * The enumerated fleet. It rides into the resolver for the reason every other\n   * edge join carries it: without it, a step drawn into a modelled container\n   * `payment.api` resolves to a service called \"api\" that has never existed\n   * (docs/DESIGN.md's serviceResolver-known row).\n   */\n  known: ReadonlySet<string>;\n}\n\n/**\n * Does any document in the set reference a reserved tag — a `#`, then only\n * LikeC4's hidden tokens, then `cap-`, `req-` or `suite-`?\n *\n * Sequential and short-circuiting ON PURPOSE — the usual \"no await in a loop\"\n * rule is about independent work that all has to finish, and this loop exists\n * precisely so that a fleet whose first file declares a use case stops reading\n * the other ninety-nine.\n *\n * What the scan lets through costs differently at its two callers, and the\n * header above names both. A `#req-…` written in a comment opens it: at fleet\n * scope that is one project load loam could have skipped, a slower right\n * answer; at service scope it loads a sibling set that may not parse, and a\n * broken one is then `usecase.flow-invalid` — an error, but over a document\n * that spelled the tag syntax. Prose without the `#` opens neither. Missing a\n * reference would cost a wrong answer at both: a use case nobody graded.\n *\n * Exported for the service-scope reader (`./service/flows.ts`), which asks the\n * same question of the `.likec4` files beside one `model.likec4`: a sibling set\n * that references no reserved tag declares no use case, so a hand-drawn\n * `views.likec4` costs that service no LikeC4 workspace. One gate, two callers,\n * because a second byte scan spelled in the service package would be free to\n * disagree with this one about which prefixes opt a view in.\n */\nexport async function mentionsTagPrefix(paths: readonly string[]): Promise<boolean> {\n  for (const path of paths) {\n    try {\n      const bytes = await readFile(path);\n      if (referencesReservedTag(bytes.toString(\"latin1\"))) return true;\n    } catch {\n      // Unreadable is not \"no tag\": the project load below owns that failure and\n      // will report it as a hole naming the document. Answering `false` here\n      // would let an unopenable file grade the fleet as having no use cases.\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Is a reserved prefix written as a tag reference anywhere in this text? Every\n * `#` is tried, wherever it stands — in a view body, a comment, a string —\n * because the scan may over-approximate the parser and never under-approximate\n * it.\n *\n * A text with no `#`, or with no reserved prefix anywhere in it, cannot answer\n * yes, so it is answered before the table below is built: that is nearly every\n * document, and it costs those two native searches and no allocation.\n *\n * Exported for its own test (test/usecase-byte-gate.test.ts), which holds it to\n * the walk the first version made from each `#` over crafted inputs, and holds\n * its cost to one pass over inputs that walk took minutes on.\n */\nexport function referencesReservedTag(text: string): boolean {\n  const first = text.indexOf(\"#\");\n  if (first === -1 || !USE_CASE_TAG_PREFIXES.some((prefix) => text.includes(prefix))) return false;\n  const nameAt = hiddenRunEnds(text);\n  for (let hash = first; hash !== -1; hash = text.indexOf(\"#\", hash + 1)) {\n    const name = nameAt[hash + 1]!;\n    if (USE_CASE_TAG_PREFIXES.some((prefix) => text.startsWith(prefix, name))) return true;\n  }\n  return false;\n}\n\n/**\n * For every position in `text`, where the next token LikeC4 would read starts\n * from there: past whitespace, line breaks, `//` line comments and block\n * comments — the four terminals the 1.59.2 grammar marks hidden (`WS`, `NL`,\n * `LINE_COMMENT`, `BLOCK_COMMENT`), which its lexer drops between the `#` of a\n * tag reference and the name. Index `text.length` is the end itself.\n *\n * ONE PASS, FROM THE END, so every answer is built from answers already known\n * and the whole table costs one visit per character, however the `#`s and the\n * comments interleave. The first version walked forward from each `#` instead,\n * and a run of hidden tokens with `#`s inside it was re-walked once per `#`:\n * `#/*` repeated took 17.6 s on 100 KB (each unclosed opener searched the rest\n * of the file for a closer), and `#//` repeated on one line, or the same `#/*`\n * run closed once at its end, were quadratic the same way. Remembering only\n * where the closer search last failed would have fixed the first of those\n * three and left the other two; nothing short of reusing every answer fixes\n * the shape, and this scan runs over every document on every reader's path.\n *\n * A hand loop rather than one regular expression: a repeated group of\n * alternatives that can each consume a comment backtracks exponentially on a\n * long run of slashes. An UNTERMINATED block comment is not one LikeC4 can lex\n * as a comment, so only the `/*` itself is stepped over and a name written\n * after it still counts: that can open the gate more often, never less, and\n * the document cannot parse anyway — the load the gate opens is what reports\n * it. The closer is searched from two past the opener, so the `*` of an opener\n * never doubles as the `*` of its closer, exactly as the lexer reads it.\n */\nfunction hiddenRunEnds(text: string): Int32Array {\n  const end = new Int32Array(text.length + 1);\n  end[text.length] = text.length;\n  // The nearest line break at or after the position being read, and the\n  // nearest `*/` at or after the NEXT position and the one after that — an\n  // opener at `at` searches from `at + 2`, and the pass meets that position\n  // before it meets `at`. -1 is \"none\".\n  let lineBreak = text.length;\n  let closeFromNext = -1;\n  let closeFromAfterNext = -1;\n  for (let at = text.length - 1; at >= 0; at -= 1) {\n    const char = text[at];\n    const closeFromHere = char === \"*\" && text[at + 1] === \"/\" ? at : closeFromNext;\n    if (char === \"\\r\" || char === \"\\n\") lineBreak = at;\n    if (char === \" \" || char === \"\\t\" || char === \"\\r\" || char === \"\\n\") {\n      end[at] = end[at + 1]!;\n    } else if (char === \"/\" && text[at + 1] === \"/\") {\n      // The comment runs to the line break and leaves it unread; the break is\n      // whitespace, so the run goes on from there. No break: the text ends.\n      end[at] = end[lineBreak]!;\n    } else if (char === \"/\" && text[at + 1] === \"*\") {\n      end[at] = closeFromAfterNext === -1 ? end[at + 2]! : end[closeFromAfterNext + 2]!;\n    } else {\n      end[at] = at;\n    }\n    closeFromAfterNext = closeFromNext;\n    closeFromNext = closeFromHere;\n  }\n  return end;\n}\n\n/**\n * Is this a use case at all? — the ONE answer, for `validate` and every reader\n * alike.\n *\n * ANY RESERVED PREFIX OPTS A VIEW IN. A view carrying `#req-CHK-ONCE` and no\n * `#cap-` tag is an author who asked to be graded and forgot half the claim; it\n * earns `usecase.requirement-unresolved`'s `unscoped` arm rather than silence,\n * and SCHEMA.md has said so since the tag shipped. A view carrying only\n * `#suite-<name>` claims no capability and no requirement and is still a use\n * case — the owner's call, recorded in SCHEMA.md: putting a journey in a suite\n * is asking for it to be run, and a journey a test stand is provisioned from\n * must be held to the model hop by hop like any other.\n *\n * It is exported because it was the asymmetry, not the rule, that was the\n * defect. `validate --all` widened here and the readers did not, so a\n * `#req-`-only flow was graded hop by hop by the gate and invisible to `loam\n * diff`, `delta`, `status`, the packs and `list capabilities` — a fleet where\n * the gate and the report disagree about what exists, which is worse than\n * either answer alone. One predicate is what stops that recurring: a caller\n * that spells `startsWith` itself is a second answer waiting to drift.\n *\n * The parameter is the smallest shape the test needs rather than `ParsedView`,\n * so a caller holding a view-like row does not have to build one to ask. Every\n * prefix test matches its reader's exactly, case included, so a view can never\n * be opted in here and read as untagged in `resolveCapabilityTags` or\n * `suiteNames`.\n *\n * NOT the same question as `flowsClaiming`'s. That one asks which flows claim\n * capability X and matches the whole `cap-<slug>` tag; a `#req-`-only view\n * claims none, and it is correct for it to stay out of that answer while\n * counting as a use case here.\n */\nexport function isUseCase(view: { tags: readonly string[] }): boolean {\n  return view.tags.some((tag) => USE_CASE_TAG_PREFIXES.some((prefix) => tag.startsWith(prefix)));\n}\n\n/**\n * The fleet's declared use cases, with the model they are drawn over.\n *\n * Reads only, throws nothing, and refuses nothing: every failure is the\n * `unreadable` arm. Callers memoise this per invocation — nothing is cached\n * here, because a module-level cache keyed on a docsDir would leak across the\n * `chdir`-per-test processes AGENTS.md warns about and, in a long-running host,\n * across invocations.\n */\nexport async function readUseCases(req: UseCaseRequest): Promise<UseCaseScan> {\n  const none: UseCaseScan = {\n    kind: \"read\",\n    views: [],\n    model: { elements: [], relationships: [], known: req.known },\n    resolve: (id) => id,\n  };\n  // EXACTLY the documents `loadArchitecture` will load two lines down, root\n  // `exclude` and all — `architectureProjectDocuments` is that one answer\n  // (`c4/project/architecture.ts`). The gate used to walk `architecture/` for\n  // itself and skip the exclude, which could only over-scan: the byte gate\n  // reading a document the loader then drops decides \"there might be a use\n  // case here\" and pays for a project load that finds none. Never a wrong\n  // answer, but two lists that disagree about what the project is, and the\n  // next reader to take the wider one for the project's would be wrong.\n  const documents = await architectureProjectDocuments(req.docsDir);\n  if (!(await mentionsTagPrefix(documents))) return none;\n\n  return useCasesIn(await loadArchitecture(req.docsDir), req.known);\n}\n\n/**\n * The use cases of an `architecture/` project somebody has ALREADY loaded —\n * `readUseCases` minus its byte gate and its load.\n *\n * For a reader that needs the project anyway: the consumer index\n * (`core/consumers/`) reads the project's edges and its hops off one load, and\n * going through `readUseCases` there would parse the same documents a second\n * time behind a gate whose whole purpose is to skip a load that has already\n * happened. The answer is the same one: a project with no reserved-tag view\n * yields `read` with no views, exactly what the gate returns without loading.\n */\nexport function useCasesIn(doc: LoadedDoc, known: ReadonlySet<string>): UseCaseScan {\n  // loam's standing rule, at project altitude: errors mean no model. A use-case\n  // file with one unresolved element leaves the whole project unusable, and\n  // grading a flow against half a map is the wrong answer this refuses to give.\n  if (doc.errors.length > 0) {\n    return { kind: \"unreadable\", errors: doc.errors.map(errorText) };\n  }\n  return {\n    kind: \"read\",\n    views: (doc.views ?? []).filter(isUseCase),\n    model: { elements: doc.elements, relationships: doc.relationships, known },\n    resolve: serviceResolver(doc.elements, known),\n  };\n}\n"]}

package/dist/core/usecases/grade/capability-tag.js

@@ -0,0 +1,93 @@
+/**
+ * `usecase.capability-unresolved` — the `#cap-` tag that names no declared
+ * capability, or more than one.
+ *
+ * The join itself lives in `core/capabilities/usecase-join.ts` and none of it is
+ * repeated here: this module owns the grade and the sentence, nothing else. That
+ * split is why the tag can answer "many" at all — the slug is not injective, so
+ * `payments/refunds` and `payments-refunds` both flatten to
+ * `payments-refunds` — and why the close candidates a message offers are real
+ * declared ids rather than loam's flattened spelling of them.
+ *
+ * ERROR, the same grade `capability.unknown` carries on a `Capability:` line and
+ * for its reason: an invented capability reads exactly like a real one. Here it
+ * reads that way at flow altitude — the tag is what files a whole business
+ * sequence under an owner, so a claim that resolves to nothing produces a use
+ * case nobody can find and a capability nobody can see is realized.
+ *
+ * SUPPRESSED ENTIRELY when the vocabulary is absent or unreadable: the caller
+ * resolves no claims at all in that case, so this answers with nothing. The
+ * claims are RESOLVED BY THE CALLER rather than here because the `#req-` grade
+ * beside this one is scoped by the very same verdicts, and two resolutions of
+ * one view's tags are two chances to disagree about which capability a flow is
+ * about. The ladder that produces the suppressing `null` is
+ * `gradableCapabilityIds` in `core/capabilities/findings.ts` — one function, called by every site that needs the graded id list, this module's
+ * callers in `commands/validate/fleet/map/usecases.ts` and `./feature.ts` included. The FILE is this axis's opt-in, so a
+ * fleet with no `architecture/capabilities.yaml` produces no capability finding
+ * at all, and an unreadable one is `capability.invalid` alone rather than one
+ * unresolved tag per use case in the fleet, which is a cascade and not a
+ * diagnosis. That rule is not re-decided here: a second reading of
+ * `CapabilityVocabulary` anywhere in this package is the copy that goes stale
+ * the day a fourth un-gradable state is added, so call the function.
+ */
+import { CAP_TAG_PREFIX, tagSlug, } from "../../capabilities/usecase-join.js";
+/** A capability id as an author must write it in a tag: `identity/tokens (#cap-identity-tokens)`. */
+function idAndTag(id) {
+    return `${id} (#${CAP_TAG_PREFIX}${tagSlug(id)})`;
+}
+/**
+ * A tag nothing declares, with the close names spelled as TAGS as well as ids.
+ *
+ * Both spellings, because either alone sends the author somewhere wrong: the id
+ * is what `capabilities.yaml` holds and the tag is what the view must carry, and
+ * an author handed only `identity/tokens` writes `#cap-identity/tokens`, which
+ * LikeC4 refuses to parse. The flattening rule is stated in the same breath so
+ * the reader can derive the next one without being told again.
+ */
+function noneMessage(where, claim) {
+    const hint = claim.close.length > 0
+        ? `Did you mean: ${claim.close.map(idAndTag).join(", ")}?`
+        : "Declare it there (`capabilities: {<id>: {description, owner}}`), or fix the tag.";
+    return (`${where} is tagged #${claim.tag}, and no capability declared in ` +
+        `architecture/capabilities.yaml flattens to '${claim.slug}'. ${hint} ` +
+        "A tag spells the id with every character outside `[A-Za-z0-9_-]` flattened to `-`, because that is all a LikeC4 tag name accepts.");
+}
+/**
+ * A tag two or more declared ids answer to. Every colliding id is named — a
+ * message that stopped at the first would be reporting the ambiguity while
+ * hiding half of what makes it one.
+ */
+function manyMessage(where, claim) {
+    return (`${where} is tagged #${claim.tag}, and ${claim.ids.length} declared capabilities flatten to ` +
+        `'${claim.slug}' (${claim.ids.join(", ")}) — nothing in the tag can say which one this use case realizes. ` +
+        "Rename one of them in architecture/capabilities.yaml: a guessed capability files every hop of the flow, " +
+        "and every rollup built over it, under an owner who never claimed it — and the wrong answer looks exactly " +
+        "like the right one.");
+}
+/**
+ * One finding per `#cap-` tag that does not resolve — never one per view.
+ *
+ * A view may legitimately carry two capability tags (a checkout flow that also
+ * issues the identity token realizes both), and `resolveCapabilityTags` answers
+ * each on its own terms for that reason. Collapsing them here would either
+ * swallow a broken tag beside a working one or lose the capability the view
+ * genuinely does realize; one tag, one verdict, one finding keeps both facts.
+ */
+export function capabilityTagFindings(view, claims, place) {
+    const findings = [];
+    for (const claim of claims) {
+        if (claim.kind === "resolved")
+            continue;
+        findings.push({
+            severity: "error",
+            code: "usecase.capability-unresolved",
+            // The VIEW, not the tag: a subject is what a reader goes and opens, and
+            // `subjectsWith` counts one broken use case once however many of its tags
+            // are wrong.
+            subject: view.id,
+            message: claim.kind === "none" ? noneMessage(place(view), claim) : manyMessage(place(view), claim),
+        });
+    }
+    return findings;
+}
+//# sourceMappingURL=capability-tag.js.map