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

package/dist/core/repo/authored/paths.js

@@ -0,0 +1,210 @@
+/**
+ * WHERE THE TWO AUTHORED VOCABULARY TREES LIVE — `capabilities/<id>/` and
+ * `glossary/<term>.md`.
+ *
+ * Split out of `../paths.ts` when that file passed 400 lines, and along the seam
+ * that was already there rather than at the line the count happened to land on:
+ * everything left in the parent spells the layout loam MAINTAINS — a service's
+ * artifacts, a feature's deltas, the generated views — while these two spell the
+ * trees a human AUTHORS and loam only reads. They share a rule the parent's
+ * paths do not have: the directory IS the list, its existence is the axis's
+ * opt-in, and `loam init` scaffolds neither.
+ *
+ * `ARTIFACT_FILES` is imported back from the parent rather than restated. The
+ * capability document is `spec.md` because it is the same grammar read by the
+ * same parser as a service's, and a second spelling of that name is exactly the
+ * drift the parent's one-table rule exists to prevent.
+ */
+import { join } from "node:path";
+import { ARTIFACT_FILES } from "../paths.js";
+/**
+ * The AUTHORED business tree — `capabilities/<id>/`, one directory per
+ * capability, each holding the document that describes it.
+ *
+ * Top-level and not under `architecture/`, because the two altitudes have
+ * different authors and different reasons to change: `architecture/` is the
+ * architect's — the map, the vocabularies, the use cases — while a capability
+ * document is the analyst's, and it must survive every redesign of the fleet
+ * that realizes it. A business tree filed inside the architecture tree would
+ * say the opposite of what the axis is for.
+ *
+ * NESTING IS SPELLED BY THE TREE, not inside a name. A capability id keeps its
+ * slashes wherever it is written (`core/capabilities/capabilities.ts` preserves
+ * the YAML key exactly as a `Capability:` line spells it), so `payments/refunds`
+ * lives at `capabilities/payments/refunds/spec.md` and `payments` may be a
+ * capability in its own right at `capabilities/payments/spec.md`. A directory is
+ * a capability if and only if it holds the document — the same
+ * presence-classifies rule `isServiceArtifactName` applies one tree over, and
+ * the reason it is safe here too: a group directory that acquires a document
+ * becomes a capability visibly, in a diff, rather than by a marker file nobody
+ * updated.
+ *
+ * NOT SCAFFOLDED BY `loam init`, exactly as `architecture/adrs/` is not. git
+ * does not carry an empty directory, so a scaffolded one vanishes on the first
+ * clone and returns as a diff on the next `init`; and an empty `capabilities/`
+ * in a fresh repo reads as an obligation nobody has met, when a fleet that has
+ * not adopted the axis owes nothing. The directory's EXISTENCE is the opt-in.
+ */
+export function capabilityDocsDir(docsDir) {
+    return join(docsDir, "capabilities");
+}
+/**
+ * The document paths of a capability whose directory is already KNOWN — the
+ * enumeration's `dir`, at whatever depth the walk found it. Same discipline as
+ * `servicePathsAt`: joining `capabilities/<id>/` at the root is only true for a
+ * flat id, and a nested capability would silently grade as absent through it.
+ */
+export function capabilityDocPathsAt(dir) {
+    return { dir, spec: join(dir, ARTIFACT_FILES.spec) };
+}
+/**
+ * The LIVING document a capability id addresses — `capabilities/` with the id's
+ * own nesting spelled back out as directories, so `payments/refunds` resolves to
+ * `capabilities/payments/refunds/spec.md`.
+ *
+ * Spelled here because FIVE readers need it — the delta grade, the archive
+ * merge, the conflict-marker scan, the archive gate's strayed-requirement scan
+ * and `loam rebase` — and a reader that resolved it differently would disagree
+ * about which document a feature is changing. The delta grade is where that costs most: a living path that finds
+ * nothing reads as an empty document, so every ADDED looks new and no
+ * `Based-On:` is ever compared, and the merge then lands over text nobody
+ * re-read.
+ *
+ * `...id.split("/")` rather than passing the id whole is explicitness, not a
+ * fix: `node:path.join` already normalizes an embedded separator, so both
+ * spellings resolve identically on every platform. The split is what makes the
+ * nesting visible at the one place the rule is written down. The mistake this
+ * function actually prevents is the OTHER one — resolving a nested id by its
+ * leaf, which silently addresses a different capability.
+ *
+ * `id` IS caller-controlled path input and carries no brand, for the reason
+ * `capabilityDocPathsAt` above takes a bare `dir`: a capability id has no
+ * grammar — it is a YAML key and a directory name, constrained nowhere — so
+ * there is nothing for a smart constructor to validate. What holds the join is
+ * PROVENANCE, and every caller owes it: the id must have come from a
+ * `readCapabilityTree` walk, where each component is a `readdir` entry name.
+ * An id read out of `architecture/capabilities.yaml` has not, and must not
+ * reach here.
+ */
+export function livingCapabilityPaths(docsDir, id) {
+    return capabilityDocPathsAt(join(capabilityDocsDir(docsDir), ...id.split("/")));
+}
+/**
+ * A feature's own capability deltas — `features/<FEAT>/capabilities/<id>/`,
+ * the delta tree that merges into `capabilityDocsDir` above.
+ *
+ * The layout MIRRORS the living one exactly, nesting included: a delta for
+ * `payments/refunds` sits at `features/<FEAT>/capabilities/payments/refunds/`,
+ * so `readCapabilityTree` walks both sides with one implementation and the
+ * merge target is the same id split the same way. The alternative — a flat
+ * escaped spelling like `payments%2Frefunds/` — would be a second grammar with
+ * its own escaping defects, and a diff nobody could read by eye against
+ * `specs/<svc>/spec.md` ↔ `services/<svc>/spec.md` one directory over.
+ *
+ * The DIRECTORY'S EXISTENCE is this axis's per-feature opt-in, exactly as
+ * `capabilityDocsDir`'s is the fleet's: a feature without one pays a single
+ * `existsSync` and produces no finding, so a fleet that has not adopted the
+ * business axis sees nothing.
+ */
+export function featureCapabilityDeltasDir(featureDir) {
+    return join(featureDir, "capabilities");
+}
+/**
+ * The domain's own vocabulary — `glossary/<term>.md`, one FILE per term.
+ *
+ * A FILE, where a capability gets a directory, and the difference is what sits
+ * beside the document. A capability's directory is the seam its feature-local
+ * deltas and anything later join through; a term has nothing beside it but its
+ * definition, and a directory holding one file is ceremony. The general rule
+ * both follow is the one `core/capabilities/tree.ts` states: an entry with prose
+ * gets a file, an entry without prose stays a line in YAML — and a domain term
+ * is prose or it is nothing.
+ *
+ * NO `glossary.yaml`, for the reason the capability tree gives at length: a
+ * single vocabulary file at fleet scale is unworkable, and a second list is the
+ * drift `loam init`'s removed `loam.docs.json` was removed for. The DIRECTORY is
+ * the list. Unlike the capability axis there is no YAML half to union with —
+ * that file predates the tree and carries `description`/`owner` fields prose
+ * cannot overwrite, and nothing here has ever had a second side.
+ *
+ * NESTING IS ALLOWED and spelled by the tree: `glossary/payments/order.md` is
+ * the term `payments/order`. A fleet with three hundred terms in one flat
+ * directory is the state this prevents, and it costs nothing — the walk is
+ * recursive and the id is the path.
+ *
+ * TOP-LEVEL, not under `architecture/`, and for `capabilityDocsDir`'s reason:
+ * the vocabulary is the domain's, and it must survive every redesign of the
+ * fleet that speaks it.
+ *
+ * NOT SCAFFOLDED BY `loam init`, exactly as `architecture/adrs/` and
+ * `capabilities/` are not. The directory's existence is the opt-in.
+ */
+export function glossaryDir(docsDir) {
+    return join(docsDir, "glossary");
+}
+/**
+ * A feature's own glossary deltas — `features/<FEAT>/glossary/<term>.md`, the
+ * vocabulary axis's answer to `specs/<svc>/spec.md`.
+ *
+ * A term a feature INTRODUCES ships and unships with it: the archive copies the
+ * definition into `glossary/`, and unarchive takes it back out with everything
+ * else the feature landed. That is the whole reason this route exists, and it is
+ * why it is CREATE-ONLY (`core/glossary/delta.ts` states the rule and the
+ * refusal): a definition is prose with no delta algebra to protect, so rewriting
+ * a living one belongs in a pull request where git itself produces the conflict.
+ *
+ * The DIRECTORY'S EXISTENCE is this axis's per-feature opt-in, exactly as
+ * `featureCapabilityDeltasDir`'s is the business axis's: a feature without one
+ * pays a single `existsSync` and produces nothing.
+ */
+export function featureGlossaryDir(featureDir) {
+    return join(featureDir, "glossary");
+}
+/**
+ * A feature's own flows — `features/<FEAT>/usecases/<name>.likec4`, the use-case
+ * axis's answer to `specs/<svc>/spec.md`.
+ *
+ * A `dynamic view` is the only realizer a promise that CROSSES services has, and
+ * it was the one realizer no feature could carry: every other axis had a delta
+ * slot and this one had none, so the business axis's headline case — an analyst
+ * adds a cross-service requirement, the architect answers it with a flow — could
+ * not ship as one change. The promise had to land first, kept by nothing, and
+ * the flow followed in a second pull request.
+ *
+ * The name mirrors the LIVING layout rather than inventing a second one:
+ * `architecture/usecases/` is where a flow already lives, `usecases/` is where a
+ * feature writes the one it brings, and the merge is the same path one directory
+ * over. Nesting is spelled by the tree, as it is for every other authored tree
+ * here.
+ *
+ * CREATE-ONLY (`core/usecases/delta/flows.ts` states the rule and the refusal),
+ * for `featureGlossaryDir`'s reason: a flow is one ordered hop sequence with no
+ * delta algebra to protect, so rewriting a living one belongs in a pull request
+ * where git itself produces the conflict.
+ *
+ * The DIRECTORY'S EXISTENCE is this axis's per-feature opt-in, exactly as the
+ * two above: a feature without one pays a single walk over a directory that is
+ * not there and produces nothing.
+ */
+export function featureUseCasesDir(featureDir) {
+    return join(featureDir, "usecases");
+}
+/**
+ * `features/<FEAT>/deployment/` — the TOPOLOGY a feature brings.
+ *
+ * The third document a feature carries whole rather than as a delta, and for
+ * the same reason as the two above: a `deployment { }` block is a topology, the
+ * merge is a whole-file copy, and there is nothing to merge partially. What
+ * makes the slot work at all is that LikeC4 `extend` resolves ACROSS documents
+ * of one project — measured before the axis was written — so a feature adds a
+ * standby datacenter inside a living region without touching the living file.
+ *
+ * `delta.likec4` still refuses a `deployment { }` block, and the refusal now
+ * names this directory: the C4 delta re-declares the landscape's identifiers
+ * and carries its own `specification`, so it cannot be staged beside the map in
+ * one project, and a document that declares neither can.
+ */
+export function featureDeploymentDir(featureDir) {
+    return join(featureDir, "deployment");
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/repo/authored/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../../src/core/repo/authored/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAgB;IAChD,OAAO,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;AACvC,CAAC;AAaD;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAgB,EAAE,EAAU;IAChE,OAAO,oBAAoB,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAClF,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,0BAA0B,CAAC,UAAsB;IAC/D,OAAO,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,WAAW,CAAC,OAAgB;IAC1C,OAAO,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAAsB;IACvD,OAAO,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAAsB;IACvD,OAAO,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAAsB;IACzD,OAAO,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;AACxC,CAAC","sourcesContent":["/**\n * WHERE THE TWO AUTHORED VOCABULARY TREES LIVE — `capabilities/<id>/` and\n * `glossary/<term>.md`.\n *\n * Split out of `../paths.ts` when that file passed 400 lines, and along the seam\n * that was already there rather than at the line the count happened to land on:\n * everything left in the parent spells the layout loam MAINTAINS — a service's\n * artifacts, a feature's deltas, the generated views — while these two spell the\n * trees a human AUTHORS and loam only reads. They share a rule the parent's\n * paths do not have: the directory IS the list, its existence is the axis's\n * opt-in, and `loam init` scaffolds neither.\n *\n * `ARTIFACT_FILES` is imported back from the parent rather than restated. The\n * capability document is `spec.md` because it is the same grammar read by the\n * same parser as a service's, and a second spelling of that name is exactly the\n * drift the parent's one-table rule exists to prevent.\n */\nimport { join } from \"node:path\";\nimport { ARTIFACT_FILES } from \"../paths.js\";\nimport type { DocsDir, FeatureDir } from \"../../kernel/ids/dirs.js\";\n\n/**\n * The AUTHORED business tree — `capabilities/<id>/`, one directory per\n * capability, each holding the document that describes it.\n *\n * Top-level and not under `architecture/`, because the two altitudes have\n * different authors and different reasons to change: `architecture/` is the\n * architect's — the map, the vocabularies, the use cases — while a capability\n * document is the analyst's, and it must survive every redesign of the fleet\n * that realizes it. A business tree filed inside the architecture tree would\n * say the opposite of what the axis is for.\n *\n * NESTING IS SPELLED BY THE TREE, not inside a name. A capability id keeps its\n * slashes wherever it is written (`core/capabilities/capabilities.ts` preserves\n * the YAML key exactly as a `Capability:` line spells it), so `payments/refunds`\n * lives at `capabilities/payments/refunds/spec.md` and `payments` may be a\n * capability in its own right at `capabilities/payments/spec.md`. A directory is\n * a capability if and only if it holds the document — the same\n * presence-classifies rule `isServiceArtifactName` applies one tree over, and\n * the reason it is safe here too: a group directory that acquires a document\n * becomes a capability visibly, in a diff, rather than by a marker file nobody\n * updated.\n *\n * NOT SCAFFOLDED BY `loam init`, exactly as `architecture/adrs/` is not. git\n * does not carry an empty directory, so a scaffolded one vanishes on the first\n * clone and returns as a diff on the next `init`; and an empty `capabilities/`\n * in a fresh repo reads as an obligation nobody has met, when a fleet that has\n * not adopted the axis owes nothing. The directory's EXISTENCE is the opt-in.\n */\nexport function capabilityDocsDir(docsDir: DocsDir): string {\n  return join(docsDir, \"capabilities\");\n}\n\nexport interface CapabilityDocPaths {\n  dir: string;\n  /**\n   * The capability's own document: narrative and requirements in one file.\n   * `spec.md`, the same name a service's requirements live under, because it is\n   * the same grammar read by the same parser — a second spelling would be a\n   * second thing to keep in step for no reader's benefit.\n   */\n  spec: string;\n}\n\n/**\n * The document paths of a capability whose directory is already KNOWN — the\n * enumeration's `dir`, at whatever depth the walk found it. Same discipline as\n * `servicePathsAt`: joining `capabilities/<id>/` at the root is only true for a\n * flat id, and a nested capability would silently grade as absent through it.\n */\nexport function capabilityDocPathsAt(dir: string): CapabilityDocPaths {\n  return { dir, spec: join(dir, ARTIFACT_FILES.spec) };\n}\n\n/**\n * The LIVING document a capability id addresses — `capabilities/` with the id's\n * own nesting spelled back out as directories, so `payments/refunds` resolves to\n * `capabilities/payments/refunds/spec.md`.\n *\n * Spelled here because FIVE readers need it — the delta grade, the archive\n * merge, the conflict-marker scan, the archive gate's strayed-requirement scan\n * and `loam rebase` — and a reader that resolved it differently would disagree\n * about which document a feature is changing. The delta grade is where that costs most: a living path that finds\n * nothing reads as an empty document, so every ADDED looks new and no\n * `Based-On:` is ever compared, and the merge then lands over text nobody\n * re-read.\n *\n * `...id.split(\"/\")` rather than passing the id whole is explicitness, not a\n * fix: `node:path.join` already normalizes an embedded separator, so both\n * spellings resolve identically on every platform. The split is what makes the\n * nesting visible at the one place the rule is written down. The mistake this\n * function actually prevents is the OTHER one — resolving a nested id by its\n * leaf, which silently addresses a different capability.\n *\n * `id` IS caller-controlled path input and carries no brand, for the reason\n * `capabilityDocPathsAt` above takes a bare `dir`: a capability id has no\n * grammar — it is a YAML key and a directory name, constrained nowhere — so\n * there is nothing for a smart constructor to validate. What holds the join is\n * PROVENANCE, and every caller owes it: the id must have come from a\n * `readCapabilityTree` walk, where each component is a `readdir` entry name.\n * An id read out of `architecture/capabilities.yaml` has not, and must not\n * reach here.\n */\nexport function livingCapabilityPaths(docsDir: DocsDir, id: string): CapabilityDocPaths {\n  return capabilityDocPathsAt(join(capabilityDocsDir(docsDir), ...id.split(\"/\")));\n}\n\n/**\n * A feature's own capability deltas — `features/<FEAT>/capabilities/<id>/`,\n * the delta tree that merges into `capabilityDocsDir` above.\n *\n * The layout MIRRORS the living one exactly, nesting included: a delta for\n * `payments/refunds` sits at `features/<FEAT>/capabilities/payments/refunds/`,\n * so `readCapabilityTree` walks both sides with one implementation and the\n * merge target is the same id split the same way. The alternative — a flat\n * escaped spelling like `payments%2Frefunds/` — would be a second grammar with\n * its own escaping defects, and a diff nobody could read by eye against\n * `specs/<svc>/spec.md` ↔ `services/<svc>/spec.md` one directory over.\n *\n * The DIRECTORY'S EXISTENCE is this axis's per-feature opt-in, exactly as\n * `capabilityDocsDir`'s is the fleet's: a feature without one pays a single\n * `existsSync` and produces no finding, so a fleet that has not adopted the\n * business axis sees nothing.\n */\nexport function featureCapabilityDeltasDir(featureDir: FeatureDir): string {\n  return join(featureDir, \"capabilities\");\n}\n\n/**\n * The domain's own vocabulary — `glossary/<term>.md`, one FILE per term.\n *\n * A FILE, where a capability gets a directory, and the difference is what sits\n * beside the document. A capability's directory is the seam its feature-local\n * deltas and anything later join through; a term has nothing beside it but its\n * definition, and a directory holding one file is ceremony. The general rule\n * both follow is the one `core/capabilities/tree.ts` states: an entry with prose\n * gets a file, an entry without prose stays a line in YAML — and a domain term\n * is prose or it is nothing.\n *\n * NO `glossary.yaml`, for the reason the capability tree gives at length: a\n * single vocabulary file at fleet scale is unworkable, and a second list is the\n * drift `loam init`'s removed `loam.docs.json` was removed for. The DIRECTORY is\n * the list. Unlike the capability axis there is no YAML half to union with —\n * that file predates the tree and carries `description`/`owner` fields prose\n * cannot overwrite, and nothing here has ever had a second side.\n *\n * NESTING IS ALLOWED and spelled by the tree: `glossary/payments/order.md` is\n * the term `payments/order`. A fleet with three hundred terms in one flat\n * directory is the state this prevents, and it costs nothing — the walk is\n * recursive and the id is the path.\n *\n * TOP-LEVEL, not under `architecture/`, and for `capabilityDocsDir`'s reason:\n * the vocabulary is the domain's, and it must survive every redesign of the\n * fleet that speaks it.\n *\n * NOT SCAFFOLDED BY `loam init`, exactly as `architecture/adrs/` and\n * `capabilities/` are not. The directory's existence is the opt-in.\n */\nexport function glossaryDir(docsDir: DocsDir): string {\n  return join(docsDir, \"glossary\");\n}\n\n/**\n * A feature's own glossary deltas — `features/<FEAT>/glossary/<term>.md`, the\n * vocabulary axis's answer to `specs/<svc>/spec.md`.\n *\n * A term a feature INTRODUCES ships and unships with it: the archive copies the\n * definition into `glossary/`, and unarchive takes it back out with everything\n * else the feature landed. That is the whole reason this route exists, and it is\n * why it is CREATE-ONLY (`core/glossary/delta.ts` states the rule and the\n * refusal): a definition is prose with no delta algebra to protect, so rewriting\n * a living one belongs in a pull request where git itself produces the conflict.\n *\n * The DIRECTORY'S EXISTENCE is this axis's per-feature opt-in, exactly as\n * `featureCapabilityDeltasDir`'s is the business axis's: a feature without one\n * pays a single `existsSync` and produces nothing.\n */\nexport function featureGlossaryDir(featureDir: FeatureDir): string {\n  return join(featureDir, \"glossary\");\n}\n\n/**\n * A feature's own flows — `features/<FEAT>/usecases/<name>.likec4`, the use-case\n * axis's answer to `specs/<svc>/spec.md`.\n *\n * A `dynamic view` is the only realizer a promise that CROSSES services has, and\n * it was the one realizer no feature could carry: every other axis had a delta\n * slot and this one had none, so the business axis's headline case — an analyst\n * adds a cross-service requirement, the architect answers it with a flow — could\n * not ship as one change. The promise had to land first, kept by nothing, and\n * the flow followed in a second pull request.\n *\n * The name mirrors the LIVING layout rather than inventing a second one:\n * `architecture/usecases/` is where a flow already lives, `usecases/` is where a\n * feature writes the one it brings, and the merge is the same path one directory\n * over. Nesting is spelled by the tree, as it is for every other authored tree\n * here.\n *\n * CREATE-ONLY (`core/usecases/delta/flows.ts` states the rule and the refusal),\n * for `featureGlossaryDir`'s reason: a flow is one ordered hop sequence with no\n * delta algebra to protect, so rewriting a living one belongs in a pull request\n * where git itself produces the conflict.\n *\n * The DIRECTORY'S EXISTENCE is this axis's per-feature opt-in, exactly as the\n * two above: a feature without one pays a single walk over a directory that is\n * not there and produces nothing.\n */\nexport function featureUseCasesDir(featureDir: FeatureDir): string {\n  return join(featureDir, \"usecases\");\n}\n\n/**\n * `features/<FEAT>/deployment/` — the TOPOLOGY a feature brings.\n *\n * The third document a feature carries whole rather than as a delta, and for\n * the same reason as the two above: a `deployment { }` block is a topology, the\n * merge is a whole-file copy, and there is nothing to merge partially. What\n * makes the slot work at all is that LikeC4 `extend` resolves ACROSS documents\n * of one project — measured before the axis was written — so a feature adds a\n * standby datacenter inside a living region without touching the living file.\n *\n * `delta.likec4` still refuses a `deployment { }` block, and the refusal now\n * names this directory: the C4 delta re-declares the landscape's identifiers\n * and carries its own `specification`, so it cannot be staged beside the map in\n * one project, and a document that declares neither can.\n */\nexport function featureDeploymentDir(featureDir: FeatureDir): string {\n  return join(featureDir, \"deployment\");\n}\n"]}

package/dist/core/repo/entries.js

@@ -0,0 +1,126 @@
+/**
+ * What the docs repo's two enumerations hand back, and how their ids compare.
+ *
+ * Split from the read model because these are the shapes every OTHER module
+ * names — `ServiceEntry` is the type a dozen call sites annotate against — and
+ * a shape should not drag the `readdir` that produces it into every importer.
+ * `compareIds` lives here for the same reason: sorting ids is what a renderer
+ * does, and no renderer wants the enumeration.
+ */
+import { serviceTreePath } from "../kernel/ids/dirs.js";
+import { rawFeatureId } from "../kernel/ids/feature.js";
+/**
+ * The directories in the `services/` tree that no loam command can address.
+ *
+ * A finding rather than a silent skip, and an ERROR rather than a warning,
+ * because the state is not survivable in either direction: `loam adopt`,
+ * `loam delta`, `loam rebase` and `loam new --touches` all refuse the id with
+ * `invalid-option`, so the documents in there can never be updated by loam
+ * again, while `validate --all` used to grade the directory as an ordinary
+ * service and demand `model.likec4`, a spec and a landscape binding for it. The
+ * fix is a rename, and it is a rename loam cannot do for you — the id is
+ * spelled in the landscape binding, in the frontmatter and in every feature
+ * that touched the service — so the message names all three.
+ *
+ * Emitted from the fleet target (`validate --all`), where the SET of service
+ * directories is the thing being checked; a per-service run is already refused
+ * by its own `--service` guard before it gets here. Lives beside the entry
+ * shape rather than the enumeration because it is a projection of `idProblem`,
+ * not a read — the entry docblock already points here.
+ */
+export function serviceIdFindings(services) {
+    return services
+        .filter((s) => s.idProblem !== undefined)
+        .map((s) => ({
+        severity: "error",
+        code: "service.id-invalid",
+        subject: s.id,
+        message: 
+        // The path is spelled from the entry's own placement chain, not a
+        // `services/<id>/` join: a FILED service with an illegal name lives at
+        // services/<subsystem>/…/<id>/, and a finding naming a root directory
+        // that does not exist sends the fix to the wrong place.
+        `${serviceTreePath(s)}/ — ${s.idProblem} ` +
+            `Every authoring command refuses this id (\`loam adopt\`, \`loam delta\`, \`loam new --touches\`), so nothing in that directory can be changed through loam. ` +
+            `Rename the directory to a legal id, then update its \`service:\` frontmatter, its \`metadata { service '${s.id}' }\` binding in architecture/landscape.likec4, and any features/<FEAT>/specs/${s.id}/ that names it.`,
+    }));
+}
+/**
+ * Compare ids so digit runs sort numerically: FEAT-2 before FEAT-10.
+ * Deterministic and locale-independent — ordering is part of the output
+ * contract for `list`, and `--json` consumers diff it.
+ */
+export function compareIds(a, b) {
+    const ta = tokenize(a);
+    const tb = tokenize(b);
+    for (let i = 0; i < Math.max(ta.length, tb.length); i += 1) {
+        const x = ta[i];
+        const y = tb[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        if (typeof x === "number" && typeof y === "number") {
+            if (x !== y)
+                return x - y;
+        }
+        else if (String(x) !== String(y)) {
+            return String(x) < String(y) ? -1 : 1;
+        }
+    }
+    return 0;
+}
+function tokenize(s) {
+    return (s.match(/\d+|\D+/g) ?? []).map((t) => (/^\d/.test(t) ? Number(t) : t));
+}
+/**
+ * Known ids within a small edit distance of `id`, closest first, at most three.
+ *
+ * The did-you-mean hint for a name somebody typed: `loam new --touches` and
+ * `loam delta <svc>` answer the same mistake, and each carried its own copy of
+ * these twenty-four lines. It belongs here because the ids being scored are
+ * this module's ids — service directory names, feature ids — and because
+ * `compareIds` right above is the tiebreak that keeps the list deterministic
+ * when two candidates score equally. Not in `core/kernel/ids/`: `compareIds` lives
+ * here and repo.ts imports ids.js, so putting it there would close a cycle.
+ *
+ * `arch.ts`'s `closeIds` looks similar and is not: substring and prefix, capped
+ * at five, answering "which element could this be" rather than "did you
+ * misspell a directory". Two rules, two homes.
+ */
+export function nearestIds(id, known) {
+    const budget = Math.max(1, Math.floor(id.length / 4));
+    return known
+        .map((candidate) => ({ candidate, distance: editDistance(id.toLowerCase(), candidate.toLowerCase()) }))
+        .filter((scored) => scored.distance <= budget)
+        .sort((a, b) => a.distance - b.distance || compareIds(a.candidate, b.candidate))
+        .slice(0, 3)
+        .map((scored) => scored.candidate);
+}
+/** Plain Levenshtein — ids are short, and the row-at-a-time form keeps it obvious. */
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j += 1) {
+            const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+            current.push(Math.min(previous[j] + 1, current[j - 1] + 1, substitution));
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+/**
+ * Feature id from a directory name: everything up to and including the first
+ * number run (`FEAT-101-payment-splitting` -> `FEAT-101`). A name with no
+ * `<word>-<number>` head is its own id. Quirk: a dated slug keeps only its first
+ * segment (`release-2024-01-x` -> `release-2024`) — ids are not meant to be dates.
+ */
+export function featureIdFromDirName(dirName) {
+    const m = /^(.*?-\d+)(?:-|$)/.exec(dirName);
+    // Constructed through the kernel helper, so this module holds no cast: the
+    // derived id's provenance is the repository — a directory the enumeration
+    // listed — which is exactly what `RawFeatureId` records.
+    return rawFeatureId(m ? m[1] : dirName);
+}
+//# sourceMappingURL=entries.js.map

package/dist/core/repo/entries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.js","sourceRoot":"","sources":["../../../src/core/repo/entries.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,eAAe,EAAoC,MAAM,uBAAuB,CAAC;AAC1F,OAAO,EAAE,YAAY,EAAqB,MAAM,0BAA0B,CAAC;AA0F3E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAwB;IACxD,OAAO,QAAQ;SACZ,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC;SACxC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,QAAQ,EAAE,OAAgB;QAC1B,IAAI,EAAE,oBAAoB;QAC1B,OAAO,EAAE,CAAC,CAAC,EAAE;QACb,OAAO;QACL,kEAAkE;QAClE,uEAAuE;QACvE,sEAAsE;QACtE,wDAAwD;QACxD,GAAG,eAAe,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,GAAG;YAC1C,8JAA8J;YAC9J,2GAA2G,CAAC,CAAC,EAAE,iFAAiF,CAAC,CAAC,EAAE,kBAAkB;KACzN,CAAC,CAAC,CAAC;AACR,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,CAAS,EAAE,CAAS;IAC7C,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3D,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,CAAC,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,CAAC,CAAC;QAC9B,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;YACnD,IAAI,CAAC,KAAK,CAAC;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QAC5B,CAAC;aAAM,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACnC,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,SAAS,QAAQ,CAAC,CAAS;IACzB,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjF,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,UAAU,CAAC,EAAU,EAAE,KAAe;IACpD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IACtD,OAAO,KAAK;SACT,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,EAAE,SAAS,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;SACtG,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC;SAC7C,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,IAAI,UAAU,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC;SAC/E,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;SACX,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AACvC,CAAC;AAED,sFAAsF;AACtF,SAAS,YAAY,CAAC,CAAS,EAAE,CAAS;IACxC,IAAI,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IACjE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACtC,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACxE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAE,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,CAAE,GAAG,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;QAC9E,CAAC;QACD,QAAQ,GAAG,OAAO,CAAC;IACrB,CAAC;IACD,OAAO,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAE,CAAC;AAC7B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAe;IAClD,MAAM,CAAC,GAAG,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5C,2EAA2E;IAC3E,0EAA0E;IAC1E,yDAAyD;IACzD,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAC3C,CAAC","sourcesContent":["/**\n * What the docs repo's two enumerations hand back, and how their ids compare.\n *\n * Split from the read model because these are the shapes every OTHER module\n * names — `ServiceEntry` is the type a dozen call sites annotate against — and\n * a shape should not drag the `readdir` that produces it into every importer.\n * `compareIds` lives here for the same reason: sorting ids is what a renderer\n * does, and no renderer wants the enumeration.\n */\nimport { serviceTreePath, type FeatureDir, type ServiceDir } from \"../kernel/ids/dirs.js\";\nimport { rawFeatureId, type RawFeatureId } from \"../kernel/ids/feature.js\";\nimport type { RawServiceId } from \"../kernel/ids/service.js\";\nimport type { Finding } from \"../vocabulary/report.js\";\n\n\nexport interface ServiceArtifacts {\n  model: boolean;\n  spec: boolean;\n  openapi: boolean;\n  /**\n   * The async contract (AsyncAPI 3). Presence-tracked only, like `runbook` and\n   * `health` — deliberately NOT part of the maturity ladder (core/vocabulary/maturity.ts),\n   * whose `documented` rung is the model/spec/openapi triple. Adding a fourth\n   * required artifact would demote every already-`documented` service in the\n   * fleet on upgrade, without one byte of their files changing.\n   */\n  asyncapi: boolean;\n  runbook: boolean;\n  health: boolean;\n}\n\nexport interface ServiceEntry {\n  /** Canonical service id — the LEAF directory name, at whatever depth the tree walk found it. */\n  id: RawServiceId;\n  /** Absolute path to the service's directory, as enumerated — the value every artifact path is resolved from. */\n  dir: ServiceDir;\n  /**\n   * Names of the subsystem directories between `services/` and the service,\n   * outermost first. Empty = unfiled — directly under `services/`, which is\n   * permanent, normal and never a finding. Placement only: no identity, no\n   * check and no join may branch on it.\n   */\n  subsystem: string[];\n  has: ServiceArtifacts;\n  /** Number of ADR files under adrs/. */\n  adrs: number;\n  /** `status` from the living spec's frontmatter; null when nobody has said. */\n  status: string | null;\n  /**\n   * Provenance signals from the living spec's frontmatter: whether it declares\n   * any `sources`, and whether a `sources_digest` stamp exists. Presence only —\n   * whether the digest still matches the code is `validate`'s question, and it\n   * can only be answered from inside the service's own repo.\n   */\n  sources: { declared: boolean; stamped: boolean };\n  /**\n   * \"sampled\" when EITHER spec axis carries a `vouch_scope` — a vouch a person\n   * gave after reading a recorded sample of the document rather than all of\n   * it — and null when neither does. Either axis, because the sample is per\n   * file: a service whose arch.spec.md alone was sampled is a service part of\n   * whose documentation nobody read.\n   *\n   * PRESENCE decides it, not decodability: a scope nobody can parse still\n   * means somebody stamped a partial read, so it grades as sampled. Fail\n   * closed, because the alternative is that mangling one field turns a partial\n   * vouch into a full one on every dashboard reading this table.\n   *\n   * The RUNG never changes: `vouched` is a published contract and this is a\n   * qualification of it, so the maturity ladder, the rollup and `--needs-work`\n   * are all untouched. Only the renderings say \"vouched (sampled)\".\n   */\n  vouchScope: \"sampled\" | null;\n  /**\n   * Why no loam command can author this directory, or absent when the name is a\n   * legal service id — `serviceIdProblem`'s own sentence, so the read model and\n   * the refusal say the same thing.\n   *\n   * The enumeration still LISTS it: the directory is there, it holds somebody's\n   * documents, and hiding it would repeat the symlink mistake one field up. But\n   * every authoring command (`adopt`, `delta`, `rebase`, `new --touches`,\n   * `init`) refuses this id with `invalid-option`, so grading it as an ordinary\n   * service left the fleet gate demanding fixes no loam command can make. The\n   * NAME is the finding — see `serviceIdFindings`.\n   */\n  idProblem?: string;\n}\n\nexport interface FeatureEntry {\n  /** Feature id, derived from the directory name (FEAT-1-split -> FEAT-1). */\n  id: RawFeatureId;\n  /** The directory name as it is on disk, slug and all. */\n  dirName: string;\n  /** Absolute path to the feature directory. */\n  dir: FeatureDir;\n  archived: boolean;\n  /** Services this feature carries a delta for, from specs/<svc>/. */\n  services: RawServiceId[];\n  has: { intent: boolean; delta: boolean };\n}\n\n/**\n * The directories in the `services/` tree that no loam command can address.\n *\n * A finding rather than a silent skip, and an ERROR rather than a warning,\n * because the state is not survivable in either direction: `loam adopt`,\n * `loam delta`, `loam rebase` and `loam new --touches` all refuse the id with\n * `invalid-option`, so the documents in there can never be updated by loam\n * again, while `validate --all` used to grade the directory as an ordinary\n * service and demand `model.likec4`, a spec and a landscape binding for it. The\n * fix is a rename, and it is a rename loam cannot do for you — the id is\n * spelled in the landscape binding, in the frontmatter and in every feature\n * that touched the service — so the message names all three.\n *\n * Emitted from the fleet target (`validate --all`), where the SET of service\n * directories is the thing being checked; a per-service run is already refused\n * by its own `--service` guard before it gets here. Lives beside the entry\n * shape rather than the enumeration because it is a projection of `idProblem`,\n * not a read — the entry docblock already points here.\n */\nexport function serviceIdFindings(services: ServiceEntry[]): Finding[] {\n  return services\n    .filter((s) => s.idProblem !== undefined)\n    .map((s) => ({\n      severity: \"error\" as const,\n      code: \"service.id-invalid\",\n      subject: s.id,\n      message:\n        // The path is spelled from the entry's own placement chain, not a\n        // `services/<id>/` join: a FILED service with an illegal name lives at\n        // services/<subsystem>/…/<id>/, and a finding naming a root directory\n        // that does not exist sends the fix to the wrong place.\n        `${serviceTreePath(s)}/ — ${s.idProblem} ` +\n        `Every authoring command refuses this id (\\`loam adopt\\`, \\`loam delta\\`, \\`loam new --touches\\`), so nothing in that directory can be changed through loam. ` +\n        `Rename the directory to a legal id, then update its \\`service:\\` frontmatter, its \\`metadata { service '${s.id}' }\\` binding in architecture/landscape.likec4, and any features/<FEAT>/specs/${s.id}/ that names it.`,\n    }));\n}\n\n/**\n * Compare ids so digit runs sort numerically: FEAT-2 before FEAT-10.\n * Deterministic and locale-independent — ordering is part of the output\n * contract for `list`, and `--json` consumers diff it.\n */\nexport function compareIds(a: string, b: string): number {\n  const ta = tokenize(a);\n  const tb = tokenize(b);\n  for (let i = 0; i < Math.max(ta.length, tb.length); i += 1) {\n    const x = ta[i];\n    const y = tb[i];\n    if (x === undefined) return -1;\n    if (y === undefined) return 1;\n    if (typeof x === \"number\" && typeof y === \"number\") {\n      if (x !== y) return x - y;\n    } else if (String(x) !== String(y)) {\n      return String(x) < String(y) ? -1 : 1;\n    }\n  }\n  return 0;\n}\n\nfunction tokenize(s: string): (string | number)[] {\n  return (s.match(/\\d+|\\D+/g) ?? []).map((t) => (/^\\d/.test(t) ? Number(t) : t));\n}\n\n/**\n * Known ids within a small edit distance of `id`, closest first, at most three.\n *\n * The did-you-mean hint for a name somebody typed: `loam new --touches` and\n * `loam delta <svc>` answer the same mistake, and each carried its own copy of\n * these twenty-four lines. It belongs here because the ids being scored are\n * this module's ids — service directory names, feature ids — and because\n * `compareIds` right above is the tiebreak that keeps the list deterministic\n * when two candidates score equally. Not in `core/kernel/ids/`: `compareIds` lives\n * here and repo.ts imports ids.js, so putting it there would close a cycle.\n *\n * `arch.ts`'s `closeIds` looks similar and is not: substring and prefix, capped\n * at five, answering \"which element could this be\" rather than \"did you\n * misspell a directory\". Two rules, two homes.\n */\nexport function nearestIds(id: string, known: string[]): string[] {\n  const budget = Math.max(1, Math.floor(id.length / 4));\n  return known\n    .map((candidate) => ({ candidate, distance: editDistance(id.toLowerCase(), candidate.toLowerCase()) }))\n    .filter((scored) => scored.distance <= budget)\n    .sort((a, b) => a.distance - b.distance || compareIds(a.candidate, b.candidate))\n    .slice(0, 3)\n    .map((scored) => scored.candidate);\n}\n\n/** Plain Levenshtein — ids are short, and the row-at-a-time form keeps it obvious. */\nfunction editDistance(a: string, b: string): number {\n  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);\n  for (let i = 1; i <= a.length; i += 1) {\n    const current = [i];\n    for (let j = 1; j <= b.length; j += 1) {\n      const substitution = previous[j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1);\n      current.push(Math.min(previous[j]! + 1, current[j - 1]! + 1, substitution));\n    }\n    previous = current;\n  }\n  return previous[b.length]!;\n}\n\n/**\n * Feature id from a directory name: everything up to and including the first\n * number run (`FEAT-101-payment-splitting` -> `FEAT-101`). A name with no\n * `<word>-<number>` head is its own id. Quirk: a dated slug keeps only its first\n * segment (`release-2024-01-x` -> `release-2024`) — ids are not meant to be dates.\n */\nexport function featureIdFromDirName(dirName: string): RawFeatureId {\n  const m = /^(.*?-\\d+)(?:-|$)/.exec(dirName);\n  // Constructed through the kernel helper, so this module holds no cast: the\n  // derived id's provenance is the repository — a directory the enumeration\n  // listed — which is exactly what `RawFeatureId` records.\n  return rawFeatureId(m ? m[1]! : dirName);\n}\n"]}