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

package/dist/core/vocabulary/maturity.js

@@ -0,0 +1,145 @@
+/** The ladder, in order. Each rung stands on every rung below it. */
+export const MATURITY_LADDER = ["empty", "partial", "documented", "sourced", "vouched"];
+/**
+ * How far a service's documentation has got. Derived from artifact PRESENCE and
+ * provenance state only — the data an enumeration already holds — never from
+ * what the artifacts say. COMPLETENESS of adopted docs is explicitly on the
+ * unchecked list (brief/unchecked.ts): a service with one endpoint documented out of
+ * thirty climbs this ladder exactly as fast as a thorough one, which is why no
+ * rung is called "adopted".
+ *
+ *   empty       services/<id>/ exists, no artifact is in it
+ *   partial     some artifacts, but not the required set
+ *   documented  the artifacts the adopt brief marks required are present
+ *   sourced     the living spec declares `sources` — something ties it to code
+ *   vouched     status: verified with a sources_digest behind it — a person
+ *               stamped it. `verified` with no digest is a claim with nothing
+ *               behind it and stays below this rung.
+ *
+ * `openapi.yaml` is required ONLY where an API is expected. The rung used to
+ * demand it of everything, which permanently pinned every worker, cron and
+ * consumer in the fleet at `partial` — services that are fully documented and
+ * vouched for, reported as unfinished forever, leaving the rollup permanently
+ * below its true documentation state. The evidence is the same one
+ * `validate` uses to keep `service.no-openapi` quiet, so a service cannot be
+ * green in one command and unfinished in the other.
+ */
+export function serviceMaturity(v) {
+    const s = v.entry;
+    if (!Object.values(s.has).some(Boolean) && !v.archSpec && s.adrs === 0)
+        return "empty";
+    if (!(s.has.model && s.has.spec && (!v.apiExpected || s.has.openapi)))
+        return "partial";
+    if (!s.sources.declared)
+        return "documented";
+    if (!(s.status === "verified" && s.sources.stamped))
+        return "sourced";
+    return "vouched";
+}
+/**
+ * What stands between this service and `vouched`, named as the thing to go and
+ * do. One rung's worth at a time: telling somebody at `empty` that they also
+ * need a vouch is noise, and the vouch is not even possible yet.
+ */
+export function maturityGaps(v) {
+    const s = v.entry;
+    const files = [
+        ...(s.has.model ? [] : ["model.likec4"]),
+        ...(s.has.spec ? [] : ["spec.md"]),
+        ...(v.apiExpected && !s.has.openapi ? ["openapi.yaml"] : []),
+    ];
+    if (files.length > 0)
+        return files;
+    if (!s.sources.declared)
+        return ["sources: in the spec.md frontmatter"];
+    if (!(s.status === "verified" && s.sources.stamped))
+        return [`\`loam vouch --service ${s.id}\``];
+    return [];
+}
+/** Counts per rung, every rung present — a stable shape a fleet dashboard can diff. */
+export function maturityRollup(graded) {
+    const out = Object.fromEntries(MATURITY_LADDER.map((m) => [m, 0]));
+    for (const v of graded)
+        out[v.maturity] += 1;
+    return out;
+}
+/* ------------------------------------------------------------------ */
+/* What the fleet map proves about one service                         */
+/* ------------------------------------------------------------------ */
+/**
+ * C4 kinds that model people, and the tag marking an element as somebody
+ * else's system. A person is never a service directory, and `#external` is
+ * undocumented on purpose — every census and exemption over the fleet map
+ * asks both questions.
+ *
+ * Extracted on the third strike: `commands/validate/checks/vocabulary.ts`,
+ * `core/gate/partners.ts` and `core/verify/checklist.ts` each carried a copy.
+ * Their real home is `core/c4/likec4.ts` beside the model they describe, but
+ * that file sits against the 300-line limit and its package holds five files
+ * — so the trio lives here, beside `landscapeEvidence`, which reads the same
+ * map for the same per-service questions.
+ *
+ * `PLATFORM_TAG` joined them from `commands/validate/checks/fleet-shape.ts`,
+ * where it was declared beside its one reader. It moved for the rule above the
+ * others came for: `fleet/kind-tags.ts` needs to know which tag names loam
+ * grades on, and reaching into fleet-shape.ts for a five-character constant
+ * would import a module that reads permissions, capabilities and every
+ * service's requirements to get it. The two tags loam gives meaning to belong
+ * in one place anyway — that list IS what the kind-tag check is about.
+ */
+export const ACTOR_KINDS = new Set(["person", "actor", "user"]);
+export const EXTERNAL_TAG = "external";
+/** Tag marking ubiquitous infrastructure; the scaffolded fleet view excludes it. */
+export const PLATFORM_TAG = "platform";
+/**
+ * The tags loam GRADES on, as opposed to the ones it merely carries.
+ *
+ * A tag in this list changes what loam concludes about a fleet: `#external`
+ * exempts an element from the landscape↔services reconciliation entirely, and
+ * `#platform` silences the hub warning. Every other tag on an element is the
+ * author's own vocabulary and loam does not read it.
+ *
+ * The list exists because since LikeC4 1.59.0 a tag can be declared on a KIND
+ * — `specification { element softwareSystem { #external } }` — and LikeC4
+ * applies it to every element of that kind. A kind-wide declaration of a tag on
+ * this list switches loam's grading off for the whole fleet at once, which is
+ * what `kindTagFindings` refuses. A tag NOT on this list is safe to declare
+ * kind-wide, so the check must ask exactly this question and no broader one.
+ */
+export const GRADED_TAGS = [EXTERNAL_TAG, PLATFORM_TAG];
+/**
+ * The fleet map's evidence about one service: the edges into and out of it,
+ * whether the map draws it at all, and whether an API is expected of it.
+ *
+ * One spelling, because it had grown three. `explore`'s describe and the
+ * context pack's living slice partitioned the same relationships with the
+ * same positive-evidence rule line for line — an inbound edge carrying an
+ * operation proves somebody calls the service; a landscape that is absent or
+ * does not parse proves NOTHING about who calls it, so the contract is still
+ * owed — and a rule spelled twice is how the same service grades `partial` in
+ * one command and `documented` in another. `list`'s serviceViews
+ * (`commands/list/views.ts`) derives the same rule fleet-wide in ONE pass —
+ * a single `called` set for every service, not a partition per service —
+ * so that spelling deliberately stays there, cross-referenced from both
+ * sides: calling this per service inside a fleet loop would re-walk the
+ * whole relationship list once per service.
+ */
+export function landscapeEvidence(req) {
+    const { id, parses, relationships, svcOf } = req;
+    const inbound = [];
+    const outbound = [];
+    for (const r of relationships) {
+        const edge = { op: r.op ?? null, title: r.title ?? null };
+        if (svcOf(r.target) === id)
+            inbound.push({ service: svcOf(r.source), ...edge });
+        else if (svcOf(r.source) === id)
+            outbound.push({ service: svcOf(r.target), ...edge });
+    }
+    return {
+        inbound,
+        outbound,
+        modelled: req.elementIds.some((e) => svcOf(e) === id),
+        apiExpected: !parses || inbound.some((e) => e.op !== null),
+    };
+}
+//# sourceMappingURL=maturity.js.map

package/dist/core/vocabulary/maturity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maturity.js","sourceRoot":"","sources":["../../../src/core/vocabulary/maturity.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The adoption-maturity ladder: one monotone word for how far a service's\n * documentation has got, and what stands between it and the next rung.\n *\n * This lived inside `commands/list.ts` while `list` was the only caller. It\n * moved here when `explore` needed the same answer, because the alternative is\n * the failure `core/kernel/ids/service.ts` already records for the service-id grammar: a\n * second, subtly different copy, so two commands grade the same directory\n * differently and nobody can tell which one is lying. The rung is a fleet dial\n * — `list` prints it per service and in a rollup, `explore` prints it for a\n * service somebody is about to build against — and a dial with two readings is\n * not a dial.\n */\nimport type { ServiceEntry } from \"../repo/entries.js\";\n\n/** The ladder, in order. Each rung stands on every rung below it. */\nexport const MATURITY_LADDER = [\"empty\", \"partial\", \"documented\", \"sourced\", \"vouched\"] as const;\nexport type Maturity = (typeof MATURITY_LADDER)[number];\n\n/**\n * A service entry plus the two facts the directory enumeration cannot know on\n * its own. Both change what a rung MEANS, and both are fleet-level: they need\n * the landscape, not `services/<id>/`.\n */\nexport interface MaturityInput {\n  entry: ServiceEntry;\n  /** `arch.spec.md` — the architecture-obligations axis, absent from ServiceEntry.has. */\n  archSpec: boolean;\n  /**\n   * Does anything in the fleet call an operation on this service? True unless\n   * the landscape PROVES otherwise, exactly as `validate`'s no-openapi grace\n   * reads it: a missing or unparseable landscape proves nothing.\n   */\n  apiExpected: boolean;\n}\n\n/**\n * How far a service's documentation has got. Derived from artifact PRESENCE and\n * provenance state only — the data an enumeration already holds — never from\n * what the artifacts say. COMPLETENESS of adopted docs is explicitly on the\n * unchecked list (brief/unchecked.ts): a service with one endpoint documented out of\n * thirty climbs this ladder exactly as fast as a thorough one, which is why no\n * rung is called \"adopted\".\n *\n *   empty       services/<id>/ exists, no artifact is in it\n *   partial     some artifacts, but not the required set\n *   documented  the artifacts the adopt brief marks required are present\n *   sourced     the living spec declares `sources` — something ties it to code\n *   vouched     status: verified with a sources_digest behind it — a person\n *               stamped it. `verified` with no digest is a claim with nothing\n *               behind it and stays below this rung.\n *\n * `openapi.yaml` is required ONLY where an API is expected. The rung used to\n * demand it of everything, which permanently pinned every worker, cron and\n * consumer in the fleet at `partial` — services that are fully documented and\n * vouched for, reported as unfinished forever, leaving the rollup permanently\n * below its true documentation state. The evidence is the same one\n * `validate` uses to keep `service.no-openapi` quiet, so a service cannot be\n * green in one command and unfinished in the other.\n */\nexport function serviceMaturity(v: MaturityInput): Maturity {\n  const s = v.entry;\n  if (!Object.values(s.has).some(Boolean) && !v.archSpec && s.adrs === 0) return \"empty\";\n  if (!(s.has.model && s.has.spec && (!v.apiExpected || s.has.openapi))) return \"partial\";\n  if (!s.sources.declared) return \"documented\";\n  if (!(s.status === \"verified\" && s.sources.stamped)) return \"sourced\";\n  return \"vouched\";\n}\n\n/**\n * What stands between this service and `vouched`, named as the thing to go and\n * do. One rung's worth at a time: telling somebody at `empty` that they also\n * need a vouch is noise, and the vouch is not even possible yet.\n */\nexport function maturityGaps(v: MaturityInput): string[] {\n  const s = v.entry;\n  const files = [\n    ...(s.has.model ? [] : [\"model.likec4\"]),\n    ...(s.has.spec ? [] : [\"spec.md\"]),\n    ...(v.apiExpected && !s.has.openapi ? [\"openapi.yaml\"] : []),\n  ];\n  if (files.length > 0) return files;\n  if (!s.sources.declared) return [\"sources: in the spec.md frontmatter\"];\n  if (!(s.status === \"verified\" && s.sources.stamped)) return [`\\`loam vouch --service ${s.id}\\``];\n  return [];\n}\n\n/** Counts per rung, every rung present — a stable shape a fleet dashboard can diff. */\nexport function maturityRollup(graded: readonly { maturity: Maturity }[]): Record<Maturity, number> {\n  const out = Object.fromEntries(MATURITY_LADDER.map((m) => [m, 0])) as Record<Maturity, number>;\n  for (const v of graded) out[v.maturity] += 1;\n  return out;\n}\n\n/* ------------------------------------------------------------------ */\n/* What the fleet map proves about one service                         */\n/* ------------------------------------------------------------------ */\n\n/**\n * C4 kinds that model people, and the tag marking an element as somebody\n * else's system. A person is never a service directory, and `#external` is\n * undocumented on purpose — every census and exemption over the fleet map\n * asks both questions.\n *\n * Extracted on the third strike: `commands/validate/checks/vocabulary.ts`,\n * `core/gate/partners.ts` and `core/verify/checklist.ts` each carried a copy.\n * Their real home is `core/c4/likec4.ts` beside the model they describe, but\n * that file sits against the 300-line limit and its package holds five files\n * — so the trio lives here, beside `landscapeEvidence`, which reads the same\n * map for the same per-service questions.\n *\n * `PLATFORM_TAG` joined them from `commands/validate/checks/fleet-shape.ts`,\n * where it was declared beside its one reader. It moved for the rule above the\n * others came for: `fleet/kind-tags.ts` needs to know which tag names loam\n * grades on, and reaching into fleet-shape.ts for a five-character constant\n * would import a module that reads permissions, capabilities and every\n * service's requirements to get it. The two tags loam gives meaning to belong\n * in one place anyway — that list IS what the kind-tag check is about.\n */\nexport const ACTOR_KINDS = new Set([\"person\", \"actor\", \"user\"]);\nexport const EXTERNAL_TAG = \"external\";\n/** Tag marking ubiquitous infrastructure; the scaffolded fleet view excludes it. */\nexport const PLATFORM_TAG = \"platform\";\n\n/**\n * The tags loam GRADES on, as opposed to the ones it merely carries.\n *\n * A tag in this list changes what loam concludes about a fleet: `#external`\n * exempts an element from the landscape↔services reconciliation entirely, and\n * `#platform` silences the hub warning. Every other tag on an element is the\n * author's own vocabulary and loam does not read it.\n *\n * The list exists because since LikeC4 1.59.0 a tag can be declared on a KIND\n * — `specification { element softwareSystem { #external } }` — and LikeC4\n * applies it to every element of that kind. A kind-wide declaration of a tag on\n * this list switches loam's grading off for the whole fleet at once, which is\n * what `kindTagFindings` refuses. A tag NOT on this list is safe to declare\n * kind-wide, so the check must ask exactly this question and no broader one.\n */\nexport const GRADED_TAGS: readonly string[] = [EXTERNAL_TAG, PLATFORM_TAG];\n\n/** One end of a call the fleet map draws, as every per-service view spells it. */\nexport interface LandscapeEdge {\n  service: string;\n  op: string | null;\n  title: string | null;\n}\n\n/**\n * The slice of a parsed relationship the partition reads. Structural on\n * purpose — the smallest parameter type the derivation needs — so this module\n * stays a leaf: `core/c4/likec4.ts`'s `Rel` satisfies it without an import\n * edge from the vocabulary package into the parser.\n */\nexport interface EdgeSource {\n  source: string;\n  target: string;\n  op?: string;\n  title?: string;\n}\n\nexport interface LandscapeEvidenceRequest {\n  /** The service being asked about. */\n  id: string;\n  /** Whether the landscape parsed — what makes its silence evidence rather than absence. */\n  parses: boolean;\n  /** The parsed relationships; empty when the landscape is absent or unparseable. */\n  relationships: readonly EdgeSource[];\n  /** Every element id in the map, for the `modelled` probe. */\n  elementIds: readonly string[];\n  /** The shared resolver (`core/c4/resolve/service.ts` `serviceResolver`), widened to plain strings. */\n  svcOf: (id: string) => string;\n}\n\nexport interface LandscapeEvidence {\n  inbound: LandscapeEdge[];\n  outbound: LandscapeEdge[];\n  /** Whether anything in the fleet map resolves to this service. */\n  modelled: boolean;\n  /** The `apiExpected` input the ladder above consumes. */\n  apiExpected: boolean;\n}\n\n/**\n * The fleet map's evidence about one service: the edges into and out of it,\n * whether the map draws it at all, and whether an API is expected of it.\n *\n * One spelling, because it had grown three. `explore`'s describe and the\n * context pack's living slice partitioned the same relationships with the\n * same positive-evidence rule line for line — an inbound edge carrying an\n * operation proves somebody calls the service; a landscape that is absent or\n * does not parse proves NOTHING about who calls it, so the contract is still\n * owed — and a rule spelled twice is how the same service grades `partial` in\n * one command and `documented` in another. `list`'s serviceViews\n * (`commands/list/views.ts`) derives the same rule fleet-wide in ONE pass —\n * a single `called` set for every service, not a partition per service —\n * so that spelling deliberately stays there, cross-referenced from both\n * sides: calling this per service inside a fleet loop would re-walk the\n * whole relationship list once per service.\n */\nexport function landscapeEvidence(req: LandscapeEvidenceRequest): LandscapeEvidence {\n  const { id, parses, relationships, svcOf } = req;\n  const inbound: LandscapeEdge[] = [];\n  const outbound: LandscapeEdge[] = [];\n  for (const r of relationships) {\n    const edge = { op: r.op ?? null, title: r.title ?? null };\n    if (svcOf(r.target) === id) inbound.push({ service: svcOf(r.source), ...edge });\n    else if (svcOf(r.source) === id) outbound.push({ service: svcOf(r.target), ...edge });\n  }\n  return {\n    inbound,\n    outbound,\n    modelled: req.elementIds.some((e) => svcOf(e) === id),\n    apiExpected: !parses || inbound.some((e) => e.op !== null),\n  };\n}\n"]}

package/dist/core/{report.js → vocabulary/report.js}

@@ -26,7 +26,20 @@ export function reportValid(targets) {
 export function countSeverity(targets, severity) {
     return targets.reduce((n, t) => n + t.findings.filter((f) => f.severity === severity).length, 0);
 }
-export function findingJson(f) {
+/**
+ * DISTINCT subjects carrying a finding with `code`, across the whole report.
+ *
+ * By SUBJECT, not by finding, and that is the rule every rollup derived from
+ * findings must share: one service can raise the same code from two documents
+ * — each document has its own list and its own answer — but it is one service,
+ * and a count of findings sends the reader looking for services that do not
+ * exist. A finding that names no subject is about its target, so the target id
+ * is the fallback key.
+ */
+export function subjectsWith(targets, code) {
+    return new Set(targets.flatMap((t) => t.findings.filter((f) => f.code === code).map((f) => f.subject ?? t.id))).size;
+}
+export function findingJson(f, fallback) {
     return {
         severity: f.severity,
         code: f.code,
@@ -34,14 +47,29 @@ export function findingJson(f) {
         ...(f.gates === undefined ? {} : { gates: f.gates }),
         message: f.message,
         details: f.details ?? [],
+        locations: f.locations ?? (fallback === undefined ? [] : [fallback]),
+    };
+}
+function targetScope(t) {
+    const path = t.path ??
+        (t.kind === "service"
+            ? `services/${t.id}`
+            : t.kind === "feature"
+                ? "features"
+                : "architecture/landscape.likec4");
+    return {
+        path,
+        role: t.kind === "landscape" ? "primary" : "scope",
+        ...(t.kind === "feature" && t.path === undefined ? { pointer: t.id } : {}),
     };
 }
 export function targetJson(t) {
     return {
         kind: t.kind,
         id: t.id,
+        ...(t.path === undefined ? {} : { path: t.path }),
         valid: targetValid(t),
-        findings: t.findings.map(findingJson),
+        findings: t.findings.map((finding) => findingJson(finding, targetScope(t))),
     };
 }
 //# sourceMappingURL=report.js.map

package/dist/core/vocabulary/report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../../../src/core/vocabulary/report.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The validation report — what `loam validate` produces before anything is\n * printed.\n *\n * Checks build findings; renderers turn them into a human view or into the JSON\n * contract. Keeping the two apart is what makes `--all` and `--json` possible\n * without a second implementation of every check, and it is why a finding\n * carries a stable `code`: prose is for people, codes are for callers.\n */\n\nexport type Severity = \"ok\" | \"warn\" | \"error\";\n\n/**\n * The glyph each severity is printed with. Five sites had written it out\n * themselves — four as a two-armed ternary that spelled `error` and let\n * everything else fall to ⚠ — and a reader who learns the marks from one\n * command's output has to be able to read them in the next. It lives beside\n * `Severity` because it is a fact about the union, not about any one renderer;\n * `TextHint.marker` above already describes it as \"the ✓/⚠/✗ marker\".\n */\nexport const SEVERITY_MARK: Record<Severity, string> = { ok: \"✓\", warn: \"⚠\", error: \"✗\" };\n\n/** How the text renderer should lay a finding out. The JSON contract ignores this. */\nexport interface TextHint {\n  /** Leading spaces. Default 0. */\n  indent?: number;\n  /** Print the ✓/⚠/✗ marker. Default true. */\n  marker?: boolean;\n  /** Block header printed once, before the first finding that carries it. */\n  header?: string;\n  /** Prefix for each detail line (e.g. \"- \" for a list of names). */\n  detailPrefix?: string;\n}\n\nexport interface FindingLocation {\n  /** Portable path relative to the docs repo whenever the finding is about one. */\n  path: string;\n  /** `primary` is exact; `scope` is the smallest directory the check can prove. */\n  role: \"primary\" | \"related\" | \"scope\";\n  line?: number;\n  column?: number;\n  /** A stable structural address when a line is not available. */\n  pointer?: string;\n}\n\nexport interface Finding {\n  severity: Severity;\n  /** Stable machine identifier — prose may change, this may not. */\n  code: string;\n  message: string;\n  /**\n   * What the finding is about, when that is narrower than the target: the\n   * service a feature's per-service check ran on, say. Without it a caller\n   * would have to read the service name back out of the message.\n   */\n  subject?: string;\n  details?: string[];\n  locations?: FindingLocation[];\n  /**\n   * Coherence findings only: whether `loam archive` refuses on this issue\n   * without `--approve` (issue.ts explains why severity alone cannot say).\n   * Absent on findings that never face the archive gate.\n   */\n  gates?: boolean;\n  text?: TextHint;\n}\n\nexport interface TargetReport {\n  /**\n   * What was validated. `landscape` is the fleet itself — the checks that need\n   * every service and every element in view at once, so they belong to no single\n   * service and only run under `--all`.\n   */\n  kind: \"service\" | \"feature\" | \"landscape\";\n  id: string;\n  /** The exact repo-relative scope this target was read from. */\n  path?: string;\n  findings: Finding[];\n}\n\n/** A target is valid when nothing in it is an error. Warnings never gate. */\nexport function targetValid(target: TargetReport): boolean {\n  return !target.findings.some((f) => f.severity === \"error\");\n}\n\nexport function reportValid(targets: TargetReport[]): boolean {\n  return targets.every(targetValid);\n}\n\nexport function countSeverity(targets: TargetReport[], severity: Severity): number {\n  return targets.reduce((n, t) => n + t.findings.filter((f) => f.severity === severity).length, 0);\n}\n\n/**\n * DISTINCT subjects carrying a finding with `code`, across the whole report.\n *\n * By SUBJECT, not by finding, and that is the rule every rollup derived from\n * findings must share: one service can raise the same code from two documents\n * — each document has its own list and its own answer — but it is one service,\n * and a count of findings sends the reader looking for services that do not\n * exist. A finding that names no subject is about its target, so the target id\n * is the fallback key.\n */\nexport function subjectsWith(targets: TargetReport[], code: string): number {\n  return new Set(\n    targets.flatMap((t) =>\n      t.findings.filter((f) => f.code === code).map((f) => f.subject ?? t.id),\n    ),\n  ).size;\n}\n\nexport function findingJson(f: Finding, fallback?: FindingLocation): Record<string, unknown> {\n  return {\n    severity: f.severity,\n    code: f.code,\n    ...(f.subject === undefined ? {} : { subject: f.subject }),\n    ...(f.gates === undefined ? {} : { gates: f.gates }),\n    message: f.message,\n    details: f.details ?? [],\n    locations: f.locations ?? (fallback === undefined ? [] : [fallback]),\n  };\n}\n\nfunction targetScope(t: TargetReport): FindingLocation {\n  const path =\n    t.path ??\n    (t.kind === \"service\"\n      ? `services/${t.id}`\n      : t.kind === \"feature\"\n        ? \"features\"\n        : \"architecture/landscape.likec4\");\n  return {\n    path,\n    role: t.kind === \"landscape\" ? \"primary\" : \"scope\",\n    ...(t.kind === \"feature\" && t.path === undefined ? { pointer: t.id } : {}),\n  };\n}\n\nexport function targetJson(t: TargetReport): Record<string, unknown> {\n  return {\n    kind: t.kind,\n    id: t.id,\n    ...(t.path === undefined ? {} : { path: t.path }),\n    valid: targetValid(t),\n    findings: t.findings.map((finding) => findingJson(finding, targetScope(t))),\n  };\n}\n"]}

package/dist/core/vocabulary/steps.js

@@ -0,0 +1,266 @@
+/**
+ * What counts as a Gherkin step in a scenario body, and what counts as that
+ * step's ARGUMENT — the one rule `loam gherkin` emits by and `loam validate`
+ * grades by.
+ *
+ * It lives in a leaf of its own because both of those readers need it and they
+ * sit on opposite sides of an import: `spec.ts` parses the markdown a scenario
+ * is written in, `gherkin/emit.ts` renders that scenario into a `.feature` file and
+ * parses requirements back out of `spec.ts` to do it. With the detector inside
+ * `gherkin/emit.ts`, asking "does this scenario have any steps?" from the parser made
+ * the two modules import each other, and a module-evaluation cycle is decided by
+ * whichever entry point happens to be loaded first.
+ *
+ * Nothing here reads a file or knows what a requirement is: it is text in, shape
+ * out, so both sides can depend on it and neither has to depend on the other.
+ * `fenceTracker` comes from `core/kernel/`, the one package below everything, for
+ * the same reason — `core/document/` already depends on this file, so borrowing
+ * the fence rule from `core/document/parse.ts` would close a package cycle.
+ */
+import { fenceTracker } from "../kernel/fences.js";
+const STEP_KEYWORD_RE = /^(given|when|then|and|but)$/i;
+/**
+ * Is this scenario body line a step? A step is a LIST BULLET (`-`, `*`, `+`)
+ * whose text opens with Given/When/Then/And/But — case-insensitive, so the
+ * OpenSpec `- **WHEN** ...` convention counts — where the keyword may be
+ * wrapped in `**bold**` and may carry a trailing colon. The keyword must stand
+ * alone before the step text (`- Givenx` is prose). Everything that is not a
+ * step stays scenario description: prose is never dropped, only steps are
+ * promoted.
+ */
+export function stepFromLine(line) {
+    const bullet = /^\s*[-*+]\s+(.*)$/.exec(line);
+    if (!bullet)
+        return null;
+    const rest = bullet[1];
+    const bold = /^\*\*([^*]+?)\*\*\s*(.*)$/.exec(rest);
+    let lead;
+    let tail;
+    if (bold) {
+        lead = bold[1].trim();
+        tail = bold[2];
+    }
+    else {
+        const sp = /^(\S+)\s*(.*)$/.exec(rest);
+        if (!sp)
+            return null;
+        lead = sp[1];
+        tail = sp[2];
+    }
+    const kw = STEP_KEYWORD_RE.exec(lead.replace(/:$/, ""));
+    if (!kw)
+        return null;
+    const word = kw[1].toLowerCase();
+    return { keyword: word[0].toUpperCase() + word.slice(1), text: tail.trim() };
+}
+/**
+ * `| a | b |` -> `["a", "b"]`; null when the line is not a pipe row at all.
+ *
+ * The split honours markdown's `\|` escape, and that is not a nicety: a cell
+ * holding a literal pipe — a regex alternation, a Kafka key template, a shell
+ * snippet — otherwise splits into two, the row's width stops matching the
+ * header's, and the WHOLE table is reported unreadable. The failure lands on the
+ * one row that needed the escape and reads as if the author miscounted columns.
+ * `\\` unescapes too, so a cell can end in a backslash without eating the
+ * delimiter after it.
+ */
+function cellsOf(line) {
+    const t = line.trim();
+    if (!/^\|.*\|$/.test(t))
+        return null;
+    const cells = [];
+    let cur = "";
+    for (let i = 1; i < t.length - 1; i += 1) {
+        const c = t[i];
+        if (c === "\\" && (t[i + 1] === "|" || t[i + 1] === "\\")) {
+            cur += t[i + 1];
+            i += 1;
+            continue;
+        }
+        if (c === "|") {
+            cells.push(cur.trim());
+            cur = "";
+            continue;
+        }
+        cur += c;
+    }
+    cells.push(cur.trim());
+    return cells;
+}
+/** `|---|:--:|` — the row markdown puts under a table header. */
+function isSeparator(cells) {
+    return cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c));
+}
+/**
+ * The scenario body split into fenced blocks, markdown tables and plain lines,
+ * in source order.
+ *
+ * Fences are recognised FIRST and win outright, which is what stops a pipe row
+ * inside a JSON payload from being hoisted out of it. That ordering is not a
+ * nicety: before it existed, a scenario carrying a fenced payload that happened
+ * to contain a table emitted the payload as trimmed prose and the payload's own
+ * table as the scenario's `Examples`, turning one data pass into an outline
+ * parameterized by the contents of its own request body — and `loam validate`
+ * graded it green, because steps existed and no table was malformed.
+ */
+function blocksOf(lines) {
+    const out = [];
+    const fenced = fenceTracker();
+    let open = null;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        const inFence = fenced(line);
+        const marker = /^(\s*)(```|~~~)(.*)$/.exec(line);
+        if (inFence && marker && open === null) {
+            const info = marker[3].trim();
+            open = { indent: marker[1].length, lines: [], ...(info.length > 0 ? { contentType: info } : {}) };
+            continue;
+        }
+        if (open !== null) {
+            // The tracker still reports the CLOSING marker as fenced content, so the
+            // marker line is what ends the block rather than the first unfenced line
+            // after it — reading it the other way swallows the line following the
+            // fence into the payload.
+            if (marker) {
+                out.push({ kind: "fence", ...open });
+                open = null;
+                continue;
+            }
+            open.lines.push(line);
+            continue;
+        }
+        const table = tableAt(lines, i);
+        if (table !== null) {
+            out.push({ kind: "table", indent: table.indent, rows: table.rows, lines: lines.slice(i, table.end + 1) });
+            i = table.end;
+            continue;
+        }
+        out.push({ kind: "line", text: line });
+    }
+    // An unterminated fence is the author's typo, not a reason to lose the text:
+    // its lines go back as plain lines and land in the description.
+    if (open !== null)
+        for (const l of open.lines)
+            out.push({ kind: "line", text: l });
+    return out;
+}
+/**
+ * The markdown table starting at `lines[i]`, or null when none does.
+ * `rows` is null when a table was clearly intended and its shape cannot be read.
+ */
+function tableAt(lines, i) {
+    const header = cellsOf(lines[i] ?? "");
+    // An unnamed column cannot be referenced by a `<placeholder>`, so a header
+    // with an empty cell is not a header — it is prose that contains pipes.
+    if (header === null || header.length === 0 || header.some((c) => c.length === 0))
+        return null;
+    const sep = cellsOf(lines[i + 1] ?? "");
+    if (sep === null || !isSeparator(sep))
+        return null;
+    const indent = /^\s*/.exec(lines[i])[0].length;
+    if (sep.length !== header.length)
+        return { indent, end: i + 1, rows: null };
+    const rows = [];
+    let end = i + 1;
+    for (let j = i + 2; j < lines.length; j += 1) {
+        const row = cellsOf(lines[j]);
+        if (row === null)
+            break;
+        end = j;
+        if (row.length !== header.length)
+            return { indent, end, rows: null };
+        rows.push(row);
+    }
+    // A header and a separator with nothing under them is a table that carries
+    // zero cases — worse than no table, because it reads as coverage.
+    if (rows.length === 0)
+        return { indent, end, rows: null };
+    return { indent, end, rows: [header, ...rows] };
+}
+/**
+ * A scenario body split for rendering: bullet lines that read as steps become
+ * steps, a fenced block or an INDENTED table under a step becomes that step's
+ * argument, a table at the body's own left margin becomes the `Examples` of a
+ * `Scenario Outline`, and every other non-blank line is kept (edge-trimmed) as
+ * the scenario's description. Description renders BEFORE the steps whatever the
+ * source order — Gherkin's grammar ends a description at the first step keyword
+ * — so prose survives verbatim but interleaving does not.
+ *
+ * INDENTATION IS THE WHOLE DISAMBIGUATION, and it is one rule an author can
+ * hold in their head: a table written under a step, indented the way markdown
+ * already asks you to indent anything belonging to a list item, is that step's
+ * data table; a table at the margin is the scenario's case matrix. Before this
+ * rule existed there was only the second reading, so `Then the ledger holds:`
+ * followed by its expected rows silently became a two-case outline and the step
+ * reached the runner with no argument at all.
+ *
+ * The table matters more than it looks in both roles. A permission matrix, a
+ * validation matrix, a status-code table — the shape most of a service's
+ * decision layer actually has — is one parameterized test in the code it came
+ * from and one outline here. And an expected-state table is how a component
+ * test says what a row, a topic or an outbox must hold after one data pass;
+ * without it that assertion is prose, and prose asserts nothing.
+ *
+ * ONLY THE FIRST top-level table is `Examples`. Gherkin permits several
+ * `Examples` blocks per outline, and supporting them would make "which table is
+ * the outline's" a question with no answer in markdown; a second one keeps its
+ * prose exactly as it reads today.
+ */
+export function scenarioGherkin(lines) {
+    const description = [];
+    const steps = [];
+    let examples = null;
+    let malformedExamples = false;
+    let strandedBlocks = false;
+    const keep = (raw) => {
+        for (const l of raw)
+            if (l.trim().length > 0)
+                description.push(l.trim());
+    };
+    for (const block of blocksOf(lines)) {
+        if (block.kind === "line") {
+            if (block.text.trim().length === 0)
+                continue;
+            const step = stepFromLine(block.text);
+            if (step)
+                steps.push({ text: step.text.length > 0 ? `${step.keyword} ${step.text}` : step.keyword });
+            else
+                description.push(block.text.trim());
+            continue;
+        }
+        const last = steps[steps.length - 1];
+        if (block.kind === "fence") {
+            if (last === undefined) {
+                strandedBlocks = true;
+                keep(block.lines);
+                continue;
+            }
+            last.docstring = {
+                ...(block.contentType === undefined ? {} : { contentType: block.contentType }),
+                lines: block.lines.map((l) => l.slice(0, block.indent).trim().length === 0 ? l.slice(block.indent) : l.trimStart()),
+            };
+            continue;
+        }
+        // A table at the margin answers to the scenario; an indented one answers to
+        // the step above it. Either can be unreadable, and an unreadable one keeps
+        // its prose rather than being guessed at.
+        if (block.indent === 0 && examples === null && !malformedExamples) {
+            if (block.rows === null) {
+                malformedExamples = true;
+                keep(block.lines);
+            }
+            else
+                examples = { header: block.rows[0], rows: block.rows.slice(1) };
+            continue;
+        }
+        if (block.indent > 0 && block.rows !== null && last !== undefined) {
+            last.table = block.rows;
+            continue;
+        }
+        if (block.indent > 0)
+            strandedBlocks = true;
+        keep(block.lines);
+    }
+    return { description, steps, examples, malformedExamples, strandedBlocks };
+}
+//# sourceMappingURL=steps.js.map

package/dist/core/vocabulary/steps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.js","sourceRoot":"","sources":["../../../src/core/vocabulary/steps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,eAAe,GAAG,8BAA8B,CAAC;AASvD;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,MAAM,GAAG,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9C,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;IACxB,MAAM,IAAI,GAAG,2BAA2B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,IAAY,CAAC;IACjB,IAAI,IAAY,CAAC;IACjB,IAAI,IAAI,EAAE,CAAC;QACT,IAAI,GAAG,IAAI,CAAC,CAAC,CAAE,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,GAAG,IAAI,CAAC,CAAC,CAAE,CAAC;IAClB,CAAC;SAAM,CAAC;QACN,MAAM,EAAE,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,EAAE;YAAE,OAAO,IAAI,CAAC;QACrB,IAAI,GAAG,EAAE,CAAC,CAAC,CAAE,CAAC;QACd,IAAI,GAAG,EAAE,CAAC,CAAC,CAAE,CAAC;IAChB,CAAC;IACD,MAAM,EAAE,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;IACxD,IAAI,CAAC,EAAE;QAAE,OAAO,IAAI,CAAC;IACrB,MAAM,IAAI,GAAG,EAAE,CAAC,CAAC,CAAE,CAAC,WAAW,EAAE,CAAC;IAClC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAE,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;AAChF,CAAC;AAqED;;;;;;;;;;GAUG;AACH,SAAS,OAAO,CAAC,IAAY;IAC3B,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACzC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;QAChB,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;YAC1D,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAE,CAAC;YACjB,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACX,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YACd,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;YACvB,GAAG,GAAG,EAAE,CAAC;YACT,SAAS;QACX,CAAC;QACD,GAAG,IAAI,CAAC,CAAC;IACX,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IACvB,OAAO,KAAK,CAAC;AACf,CAAC;AAED,iEAAiE;AACjE,SAAS,WAAW,CAAC,KAAe;IAClC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACpE,CAAC;AAQD;;;;;;;;;;;GAWG;AACH,SAAS,QAAQ,CAAC,KAAe;IAC/B,MAAM,GAAG,GAAY,EAAE,CAAC;IACxB,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,IAAI,IAAI,GAAqE,IAAI,CAAC;IAClF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;QACvB,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QAC7B,MAAM,MAAM,GAAG,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,OAAO,IAAI,MAAM,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YACvC,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC,IAAI,EAAE,CAAC;YAC/B,IAAI,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAE,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;YACnG,SAAS;QACX,CAAC;QACD,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,yEAAyE;YACzE,yEAAyE;YACzE,sEAAsE;YACtE,0BAA0B;YAC1B,IAAI,MAAM,EAAE,CAAC;gBACX,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;gBACrC,IAAI,GAAG,IAAI,CAAC;gBACZ,SAAS;YACX,CAAC;YACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtB,SAAS;QACX,CAAC;QACD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAChC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;YAC1G,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;YACd,SAAS;QACX,CAAC;QACD,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IACD,6EAA6E;IAC7E,gEAAgE;IAChE,IAAI,IAAI,KAAK,IAAI;QAAE,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK;YAAE,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IACnF,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,SAAS,OAAO,CAAC,KAAe,EAAE,CAAS;IACzC,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IACvC,2EAA2E;IAC3E,wEAAwE;IACxE,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9F,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IACxC,IAAI,GAAG,KAAK,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE,CAAE,CAAC,CAAC,CAAE,CAAC,MAAM,CAAC;IAClD,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM;QAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC5E,MAAM,IAAI,GAAe,EAAE,CAAC;IAC5B,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7C,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC;QAC/B,IAAI,GAAG,KAAK,IAAI;YAAE,MAAM;QACxB,GAAG,GAAG,CAAC,CAAC;QACR,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM;YAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACrE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjB,CAAC;IACD,2EAA2E;IAC3E,kEAAkE;IAClE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC1D,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,eAAe,CAAC,KAAe;IAC7C,MAAM,WAAW,GAAa,EAAE,CAAC;IACjC,MAAM,KAAK,GAAkB,EAAE,CAAC;IAChC,IAAI,QAAQ,GAAoB,IAAI,CAAC;IACrC,IAAI,iBAAiB,GAAG,KAAK,CAAC;IAC9B,IAAI,cAAc,GAAG,KAAK,CAAC;IAC3B,MAAM,IAAI,GAAG,CAAC,GAAa,EAAQ,EAAE;QACnC,KAAK,MAAM,CAAC,IAAI,GAAG;YAAE,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;gBAAE,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3E,CAAC,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC1B,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC;gBAAE,SAAS;YAC7C,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,IAAI;gBAAE,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;;gBAChG,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YACzC,SAAS;QACX,CAAC;QACD,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACrC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC3B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,cAAc,GAAG,IAAI,CAAC;gBACtB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAClB,SAAS;YACX,CAAC;YACD,IAAI,CAAC,SAAS,GAAG;gBACf,GAAG,CAAC,KAAK,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC9E,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;aACpH,CAAC;YACF,SAAS;QACX,CAAC;QACD,4EAA4E;QAC5E,2EAA2E;QAC3E,0CAA0C;QAC1C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAClE,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACxB,iBAAiB,GAAG,IAAI,CAAC;gBACzB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACpB,CAAC;;gBAAM,QAAQ,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACxE,SAAS;QACX,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YAClE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC;YACxB,SAAS;QACX,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,cAAc,GAAG,IAAI,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,cAAc,EAAE,CAAC;AAC7E,CAAC","sourcesContent":["/**\n * What counts as a Gherkin step in a scenario body, and what counts as that\n * step's ARGUMENT — the one rule `loam gherkin` emits by and `loam validate`\n * grades by.\n *\n * It lives in a leaf of its own because both of those readers need it and they\n * sit on opposite sides of an import: `spec.ts` parses the markdown a scenario\n * is written in, `gherkin/emit.ts` renders that scenario into a `.feature` file and\n * parses requirements back out of `spec.ts` to do it. With the detector inside\n * `gherkin/emit.ts`, asking \"does this scenario have any steps?\" from the parser made\n * the two modules import each other, and a module-evaluation cycle is decided by\n * whichever entry point happens to be loaded first.\n *\n * Nothing here reads a file or knows what a requirement is: it is text in, shape\n * out, so both sides can depend on it and neither has to depend on the other.\n * `fenceTracker` comes from `core/kernel/`, the one package below everything, for\n * the same reason — `core/document/` already depends on this file, so borrowing\n * the fence rule from `core/document/parse.ts` would close a package cycle.\n */\n\nimport { fenceTracker } from \"../kernel/fences.js\";\n\nconst STEP_KEYWORD_RE = /^(given|when|then|and|but)$/i;\n\nexport interface Step {\n  /** Canonical Gherkin keyword: Given / When / Then / And / But. */\n  keyword: string;\n  /** The rest of the line, trimmed. May be empty. */\n  text: string;\n}\n\n/**\n * Is this scenario body line a step? A step is a LIST BULLET (`-`, `*`, `+`)\n * whose text opens with Given/When/Then/And/But — case-insensitive, so the\n * OpenSpec `- **WHEN** ...` convention counts — where the keyword may be\n * wrapped in `**bold**` and may carry a trailing colon. The keyword must stand\n * alone before the step text (`- Givenx` is prose). Everything that is not a\n * step stays scenario description: prose is never dropped, only steps are\n * promoted.\n */\nexport function stepFromLine(line: string): Step | null {\n  const bullet = /^\\s*[-*+]\\s+(.*)$/.exec(line);\n  if (!bullet) return null;\n  const rest = bullet[1]!;\n  const bold = /^\\*\\*([^*]+?)\\*\\*\\s*(.*)$/.exec(rest);\n  let lead: string;\n  let tail: string;\n  if (bold) {\n    lead = bold[1]!.trim();\n    tail = bold[2]!;\n  } else {\n    const sp = /^(\\S+)\\s*(.*)$/.exec(rest);\n    if (!sp) return null;\n    lead = sp[1]!;\n    tail = sp[2]!;\n  }\n  const kw = STEP_KEYWORD_RE.exec(lead.replace(/:$/, \"\"));\n  if (!kw) return null;\n  const word = kw[1]!.toLowerCase();\n  return { keyword: word[0]!.toUpperCase() + word.slice(1), text: tail.trim() };\n}\n\n/** A Gherkin `Examples` table: the column names, then one row of values per case. */\nexport interface Examples {\n  header: string[];\n  rows: string[][];\n}\n\n/**\n * A fenced block written under a step — Gherkin's docstring argument, and the\n * only way to put a request body, an expected JSON document or any other\n * multi-line literal into a scenario.\n *\n * `lines` are NOT trimmed beyond removing the fence's own indentation, and that\n * asymmetry with every other line in this module is the whole point: a payload\n * whose leading whitespace has been eaten is a payload no step definition can\n * compare against, and the loss is invisible because the file still parses.\n */\nexport interface DocString {\n  /** The fence's info string (` ```json ` -> \"json\"), absent when it carried none. */\n  contentType?: string;\n  lines: string[];\n}\n\n/** One step as it will be emitted, with the argument written under it, if any. */\nexport interface EmittedStep {\n  /** The rendered step line: keyword then text — `Given a payment of 100.00`. */\n  text: string;\n  docstring?: DocString;\n  /**\n   * An INDENTED markdown table written under this step, as Gherkin's data-table\n   * argument: every row including the header, with the markdown separator row\n   * dropped. Markdown needs the separator to render at all, Gherkin has no such\n   * row, and the source stays legible in a pull request either way.\n   */\n  table?: string[][];\n}\n\nexport interface ScenarioGherkin {\n  description: string[];\n  steps: EmittedStep[];\n  /** The cases a `Scenario Outline` runs, or null for a plain `Scenario`. */\n  examples: Examples | null;\n  /**\n   * A top-level table was clearly intended as `Examples` and could not be read —\n   * a row whose width disagrees with the header, or a header with no rows under\n   * it.\n   *\n   * Reported rather than guessed at. The rule this whole module holds is that\n   * prose is never dropped, so a table loam cannot read stays in the scenario\n   * DESCRIPTION and the emission is still valid Gherkin — which is exactly why\n   * silence would be wrong: the author wrote twenty cases, cucumber runs one\n   * scenario, and both the file and the report look healthy.\n   */\n  malformedExamples: boolean;\n  /**\n   * A fenced block or an indented table was written where it cannot become a\n   * step argument — before the scenario's first step, or (for a table) in a\n   * shape this module cannot read. It stays in the description, so nothing is\n   * lost from the DOCUMENT, and everything is lost from the TEST: the payload\n   * reaches no step definition and the runner sees a step with no argument.\n   *\n   * A separate flag from `malformedExamples` because the fixes are different —\n   * one is \"move it under a step\", the other is \"give the table equal columns\" —\n   * and a machine must not have to guess which was meant.\n   */\n  strandedBlocks: boolean;\n}\n\n/**\n * `| a | b |` -> `[\"a\", \"b\"]`; null when the line is not a pipe row at all.\n *\n * The split honours markdown's `\\|` escape, and that is not a nicety: a cell\n * holding a literal pipe — a regex alternation, a Kafka key template, a shell\n * snippet — otherwise splits into two, the row's width stops matching the\n * header's, and the WHOLE table is reported unreadable. The failure lands on the\n * one row that needed the escape and reads as if the author miscounted columns.\n * `\\\\` unescapes too, so a cell can end in a backslash without eating the\n * delimiter after it.\n */\nfunction cellsOf(line: string): string[] | null {\n  const t = line.trim();\n  if (!/^\\|.*\\|$/.test(t)) return null;\n  const cells: string[] = [];\n  let cur = \"\";\n  for (let i = 1; i < t.length - 1; i += 1) {\n    const c = t[i]!;\n    if (c === \"\\\\\" && (t[i + 1] === \"|\" || t[i + 1] === \"\\\\\")) {\n      cur += t[i + 1]!;\n      i += 1;\n      continue;\n    }\n    if (c === \"|\") {\n      cells.push(cur.trim());\n      cur = \"\";\n      continue;\n    }\n    cur += c;\n  }\n  cells.push(cur.trim());\n  return cells;\n}\n\n/** `|---|:--:|` — the row markdown puts under a table header. */\nfunction isSeparator(cells: string[]): boolean {\n  return cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c));\n}\n\n/** One run of source lines, already classified by {@link blocksOf}. */\ntype Block =\n  | { kind: \"line\"; text: string }\n  | { kind: \"fence\"; indent: number; contentType?: string; lines: string[] }\n  | { kind: \"table\"; indent: number; rows: string[][] | null; lines: string[] };\n\n/**\n * The scenario body split into fenced blocks, markdown tables and plain lines,\n * in source order.\n *\n * Fences are recognised FIRST and win outright, which is what stops a pipe row\n * inside a JSON payload from being hoisted out of it. That ordering is not a\n * nicety: before it existed, a scenario carrying a fenced payload that happened\n * to contain a table emitted the payload as trimmed prose and the payload's own\n * table as the scenario's `Examples`, turning one data pass into an outline\n * parameterized by the contents of its own request body — and `loam validate`\n * graded it green, because steps existed and no table was malformed.\n */\nfunction blocksOf(lines: string[]): Block[] {\n  const out: Block[] = [];\n  const fenced = fenceTracker();\n  let open: { indent: number; contentType?: string; lines: string[] } | null = null;\n  for (let i = 0; i < lines.length; i += 1) {\n    const line = lines[i]!;\n    const inFence = fenced(line);\n    const marker = /^(\\s*)(```|~~~)(.*)$/.exec(line);\n    if (inFence && marker && open === null) {\n      const info = marker[3]!.trim();\n      open = { indent: marker[1]!.length, lines: [], ...(info.length > 0 ? { contentType: info } : {}) };\n      continue;\n    }\n    if (open !== null) {\n      // The tracker still reports the CLOSING marker as fenced content, so the\n      // marker line is what ends the block rather than the first unfenced line\n      // after it — reading it the other way swallows the line following the\n      // fence into the payload.\n      if (marker) {\n        out.push({ kind: \"fence\", ...open });\n        open = null;\n        continue;\n      }\n      open.lines.push(line);\n      continue;\n    }\n    const table = tableAt(lines, i);\n    if (table !== null) {\n      out.push({ kind: \"table\", indent: table.indent, rows: table.rows, lines: lines.slice(i, table.end + 1) });\n      i = table.end;\n      continue;\n    }\n    out.push({ kind: \"line\", text: line });\n  }\n  // An unterminated fence is the author's typo, not a reason to lose the text:\n  // its lines go back as plain lines and land in the description.\n  if (open !== null) for (const l of open.lines) out.push({ kind: \"line\", text: l });\n  return out;\n}\n\n/**\n * The markdown table starting at `lines[i]`, or null when none does.\n * `rows` is null when a table was clearly intended and its shape cannot be read.\n */\nfunction tableAt(lines: string[], i: number): { indent: number; end: number; rows: string[][] | null } | null {\n  const header = cellsOf(lines[i] ?? \"\");\n  // An unnamed column cannot be referenced by a `<placeholder>`, so a header\n  // with an empty cell is not a header — it is prose that contains pipes.\n  if (header === null || header.length === 0 || header.some((c) => c.length === 0)) return null;\n  const sep = cellsOf(lines[i + 1] ?? \"\");\n  if (sep === null || !isSeparator(sep)) return null;\n  const indent = /^\\s*/.exec(lines[i]!)![0]!.length;\n  if (sep.length !== header.length) return { indent, end: i + 1, rows: null };\n  const rows: string[][] = [];\n  let end = i + 1;\n  for (let j = i + 2; j < lines.length; j += 1) {\n    const row = cellsOf(lines[j]!);\n    if (row === null) break;\n    end = j;\n    if (row.length !== header.length) return { indent, end, rows: null };\n    rows.push(row);\n  }\n  // A header and a separator with nothing under them is a table that carries\n  // zero cases — worse than no table, because it reads as coverage.\n  if (rows.length === 0) return { indent, end, rows: null };\n  return { indent, end, rows: [header, ...rows] };\n}\n\n/**\n * A scenario body split for rendering: bullet lines that read as steps become\n * steps, a fenced block or an INDENTED table under a step becomes that step's\n * argument, a table at the body's own left margin becomes the `Examples` of a\n * `Scenario Outline`, and every other non-blank line is kept (edge-trimmed) as\n * the scenario's description. Description renders BEFORE the steps whatever the\n * source order — Gherkin's grammar ends a description at the first step keyword\n * — so prose survives verbatim but interleaving does not.\n *\n * INDENTATION IS THE WHOLE DISAMBIGUATION, and it is one rule an author can\n * hold in their head: a table written under a step, indented the way markdown\n * already asks you to indent anything belonging to a list item, is that step's\n * data table; a table at the margin is the scenario's case matrix. Before this\n * rule existed there was only the second reading, so `Then the ledger holds:`\n * followed by its expected rows silently became a two-case outline and the step\n * reached the runner with no argument at all.\n *\n * The table matters more than it looks in both roles. A permission matrix, a\n * validation matrix, a status-code table — the shape most of a service's\n * decision layer actually has — is one parameterized test in the code it came\n * from and one outline here. And an expected-state table is how a component\n * test says what a row, a topic or an outbox must hold after one data pass;\n * without it that assertion is prose, and prose asserts nothing.\n *\n * ONLY THE FIRST top-level table is `Examples`. Gherkin permits several\n * `Examples` blocks per outline, and supporting them would make \"which table is\n * the outline's\" a question with no answer in markdown; a second one keeps its\n * prose exactly as it reads today.\n */\nexport function scenarioGherkin(lines: string[]): ScenarioGherkin {\n  const description: string[] = [];\n  const steps: EmittedStep[] = [];\n  let examples: Examples | null = null;\n  let malformedExamples = false;\n  let strandedBlocks = false;\n  const keep = (raw: string[]): void => {\n    for (const l of raw) if (l.trim().length > 0) description.push(l.trim());\n  };\n  for (const block of blocksOf(lines)) {\n    if (block.kind === \"line\") {\n      if (block.text.trim().length === 0) continue;\n      const step = stepFromLine(block.text);\n      if (step) steps.push({ text: step.text.length > 0 ? `${step.keyword} ${step.text}` : step.keyword });\n      else description.push(block.text.trim());\n      continue;\n    }\n    const last = steps[steps.length - 1];\n    if (block.kind === \"fence\") {\n      if (last === undefined) {\n        strandedBlocks = true;\n        keep(block.lines);\n        continue;\n      }\n      last.docstring = {\n        ...(block.contentType === undefined ? {} : { contentType: block.contentType }),\n        lines: block.lines.map((l) => l.slice(0, block.indent).trim().length === 0 ? l.slice(block.indent) : l.trimStart()),\n      };\n      continue;\n    }\n    // A table at the margin answers to the scenario; an indented one answers to\n    // the step above it. Either can be unreadable, and an unreadable one keeps\n    // its prose rather than being guessed at.\n    if (block.indent === 0 && examples === null && !malformedExamples) {\n      if (block.rows === null) {\n        malformedExamples = true;\n        keep(block.lines);\n      } else examples = { header: block.rows[0]!, rows: block.rows.slice(1) };\n      continue;\n    }\n    if (block.indent > 0 && block.rows !== null && last !== undefined) {\n      last.table = block.rows;\n      continue;\n    }\n    if (block.indent > 0) strandedBlocks = true;\n    keep(block.lines);\n  }\n  return { description, steps, examples, malformedExamples, strandedBlocks };\n}\n"]}