@sdd-method/author-cli 0.0.0-stage → 0.1.0

package/dist/lib/catalogue/builders/services.js

@@ -0,0 +1,232 @@
+// Services discoverer — emits `services.csv` rows derived 1:1 from
+// repository rows whose service_type is a runtime kind, UNLESS the
+// repository declares a `services:` block (M-ADR 0197), in which case the
+// declared list REPLACES the single-service default for that repository
+// only. Absent block: today's exact behaviour, unchanged. Present block
+// (including an empty list): authoritative — every declared entry's
+// `primary_repo_id` is set to the declaring repository's id, and the
+// repository's own default-by-silence id disappears unless an entry
+// re-declares it (continuity is the adopter's responsibility, per M-ADR
+// 0197 §4.1 — a dangling reference to it resolves to an orphan finding
+// elsewhere, not a crash here).
+//
+// Per ADR 0134 + Q7.1 resolution, runtime kinds are
+// {api_service, worker, gateway, frontend, mobile} — read from the
+// canonical schema's enums.service_type block where
+// `emits_service_row: true`. The runtime-kind gate applies only to the
+// DEFAULT projection; a declared entry is emitted regardless of the
+// declaring repository's own service_type, because declaring it is
+// itself the adopter's assertion that it is a service.
+//
+// This is a derived catalogue: services are 1:1 with their primary
+// repository for the contextual adoption pattern, unless declared
+// otherwise. Adopters whose services span multiple repos may extend this
+// builder later.
+//
+// Per-service metadata (runtime_type, language, status, confidence,
+// description) is read — faithfully, not inferred — from each service's
+// `repos/<id>/docs/service-architecture.md` via the shared
+// service-architecture-parser module.
+//
+// The `description` column has two authoring sources, honoured per the
+// forward/reverse parity principle (ADR 0157, extended to node columns by
+// ADR 0163):
+//   - forward: `orchestration/repo-config/<repo>.yaml` `description:` —
+//     the deliberate spec, authored by forward-method adopters.
+//   - reverse: the arch doc's `## Purpose` lead paragraph.
+// When both are present for the same service the forward repo-config
+// description wins (matching the ADR 0156 / 0162 merge convention) and a
+// `divergence` finding records the conflict. In practice an adopter has
+// only one of the two, so this is usually a plain coalesce.
+//
+// The four reverse-only columns (runtime_type, language, status,
+// confidence) have no forward authoring source; forward-method adopters
+// legitimately leave them empty (they declare service_type + dependencies
+// instead). See catalogue-metamodel.md §Service.
+import { runtimeServiceTypes, } from "../schema-loader.js";
+import { EMPTY_METADATA, indexServiceArchitectures, readServiceMetadata, } from "../service-architecture-parser.js";
+/**
+ * Validate one repo's raw `services:` value. Returns `null` when the block
+ * is absent, or present but not shaped like a list at all — both fall back
+ * to the default single-service projection, because a top-level shape
+ * violation reads as "not a valid declaration", not "declares zero
+ * services". Returns an array (possibly empty) when the block IS a list:
+ * that is a declaration, and it is authoritative even if every entry in it
+ * turned out invalid — a repository can legitimately declare it builds no
+ * cataloguable service.
+ *
+ * Per-entry problems (not an object, missing `id`, a duplicate `id` within
+ * this one block) drop only that entry, with an orphan/divergence finding
+ * naming the file and index — never the whole block, never the repository.
+ */
+function parseDeclaredServices(raw, relPath, findings) {
+    if (raw === undefined)
+        return null;
+    if (!Array.isArray(raw)) {
+        findings.add("convention", 
+        // Names the remedy, and specifically the `services: []` form: a BARE
+        // `services:` parses as null, which is not a list, so it lands here —
+        // and it is two characters away from the declaration an author meant.
+        `${relPath}: services: must be a list — block dropped, default single-service projection kept; write it as a list of entries (\`services:\` then \`  - id: ...\`), or as \`services: []\` to declare that this repo deliberately emits no service row (M-ADR 0197). A bare \`services:\` with nothing after it is neither.`);
+        return null;
+    }
+    const seen = new Set();
+    const out = [];
+    for (let i = 0; i < raw.length; i++) {
+        const entry = raw[i];
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+            findings.add("orphan", `${relPath}: services[${i}] is not an object — entry dropped`);
+            continue;
+        }
+        const o = entry;
+        const id = typeof o["id"] === "string" ? o["id"].trim() : "";
+        if (id === "") {
+            findings.add("orphan", `${relPath}: services[${i}] missing required "id" — entry dropped`);
+            continue;
+        }
+        if (seen.has(id)) {
+            findings.add("divergence", `${relPath}: services: declares "${id}" more than once — first occurrence kept`);
+            continue;
+        }
+        seen.add(id);
+        out.push({
+            id,
+            ...(typeof o["domain"] === "string" ? { domain: o["domain"] } : {}),
+            ...(typeof o["service_type"] === "string"
+                ? { service_type: o["service_type"] }
+                : {}),
+            ...(typeof o["description"] === "string"
+                ? { description: o["description"] }
+                : {}),
+        });
+    }
+    return out;
+}
+export async function buildServices(inputs) {
+    const runtime = runtimeServiceTypes(inputs.schema);
+    const validServiceTypes = canonicalServiceTypeValues(inputs.schema);
+    const declaredNonRepoIds = new Set();
+    // Index every service-architecture.md under repos/ by its repo slug (the
+    // directory above docs/). The layout is either repos/<repo>/docs/... or
+    // repos/<group>/<repo>/docs/..., so a recursive walk is required.
+    // Services whose architecture doc lives in a federated member SDD (rather
+    // than this SDD's own repos/) resolve to no entry here — their metadata is
+    // an aggregation-time concern (ADR 0163 P2), not a local build gap.
+    const archIndex = await indexServiceArchitectures(inputs.sddPath);
+    const repoDescriptions = inputs.repoDescriptions ?? new Map();
+    const declaredByRepo = inputs.declaredServicesByRepo ?? new Map();
+    const rows = [];
+    // Build-wide id set, so a declared entry colliding with an id already
+    // emitted (by any earlier repo, declared or default) is visible here
+    // rather than only surfacing later as a generic cross-catalogue PK
+    // conflict with no repo context. Genuinely differing payloads on the same
+    // id still hard-fail the build via dedupeKeyedTables (per M-ADR 0197's
+    // consumer sweep) — this is an earlier, better-attributed warning, not a
+    // replacement for that guard.
+    const emittedIds = new Map(); // id -> repoId that emitted it
+    for (const repo of inputs.repositories) {
+        const repoId = String(repo["id"] ?? "");
+        if (repoId === "")
+            continue;
+        const repoDocPath = String(repo["doc_path"] ?? "");
+        const repoDomainId = String(repo["domain_id"] ?? "");
+        const repoComponentType = String(repo["component_type"] ?? "");
+        const declared = parseDeclaredServices(declaredByRepo.get(repoId), repoDocPath || repoId, inputs.findings);
+        if (declared === null) {
+            // No declaration — the default single-service projection, unchanged.
+            if (!runtime.has(repoComponentType))
+                continue;
+            await emitOne(rows, emittedIds, archIndex, inputs, {
+                id: repoId,
+                name: repoId,
+                domainId: repoDomainId,
+                primaryRepoId: repoId,
+                componentType: repoComponentType,
+                forwardDescription: repoDescriptions.get(repoId) ?? "",
+                archKey: repoId,
+            });
+            continue;
+        }
+        // Declared — authoritative for this repository, regardless of the
+        // repository's own service_type. Zero valid entries is a legitimate
+        // outcome (a repository explicitly declaring it builds no service).
+        for (const entry of declared) {
+            const componentType = entry.service_type ?? repoComponentType;
+            if (componentType !== "" && !validServiceTypes.has(componentType)) {
+                inputs.findings.add("convention", `${repoDocPath || repoId}: services declares "${entry.id}" with service_type "${componentType}" not in canonical enum`);
+            }
+            await emitOne(rows, emittedIds, archIndex, inputs, {
+                id: entry.id,
+                name: entry.id,
+                domainId: entry.domain ?? repoDomainId,
+                primaryRepoId: repoId,
+                componentType,
+                forwardDescription: entry.description ?? "",
+                archKey: entry.id,
+            });
+            // M-ADR 0197 §4.6 is not implemented on the catalogue side yet — the
+            // forward event/contract builders still attribute only via the
+            // repository's own id (`cfg.repoId`), never via a declared entry.
+            // A declared entry whose id differs from the repository's own can
+            // therefore never receive event/contract rows today, by construction,
+            // regardless of any future primary-selection rule. This is the
+            // vacuous-signal candidate set (§4.7's fourth failure mode) — tracked
+            // here, where the declaration is parsed, rather than re-derived
+            // downstream.
+            if (entry.id !== repoId)
+                declaredNonRepoIds.add(entry.id);
+        }
+    }
+    return { rows, declaredNonRepoIds };
+}
+function canonicalServiceTypeValues(schema) {
+    const enumDef = schema.enums["service_type"];
+    if (!enumDef)
+        return new Set(runtimeServiceTypes(schema));
+    return new Set(enumDef.values.map((v) => v.value));
+}
+async function emitOne(rows, emittedIds, archIndex, inputs, args) {
+    const priorRepo = emittedIds.get(args.id);
+    if (priorRepo !== undefined && priorRepo !== args.primaryRepoId) {
+        inputs.findings.add("divergence", `services: id "${args.id}" declared by repo "${args.primaryRepoId}" collides with one already emitted by repo "${priorRepo}"`);
+    }
+    emittedIds.set(args.id, args.primaryRepoId);
+    const archPath = archIndex.get(args.archKey);
+    const meta = archPath ? await readServiceMetadata(archPath) : EMPTY_METADATA;
+    rows.push({
+        id: args.id,
+        name: args.name,
+        product_id: inputs.productId,
+        domain_id: args.domainId,
+        primary_repo_id: args.primaryRepoId,
+        runtime_type: meta.runtime_type,
+        language: meta.language,
+        component_type: args.componentType,
+        status: meta.status,
+        confidence: meta.confidence,
+        description: coalesceDescription(args.id, args.forwardDescription, meta.description, inputs.findings),
+        source_sdd_id: "",
+    });
+}
+/**
+ * Coalesce the forward (repo-config) and reverse (## Purpose) description
+ * sources. Forward wins when both are present; a `divergence` finding
+ * records the conflict so authors can reconcile. Whitespace-only values
+ * are treated as empty. Single-quotes/newlines normalised away for the
+ * comparison so cosmetic reformatting doesn't trip the finding.
+ */
+function coalesceDescription(serviceId, forward, reverse, findings) {
+    const f = forward.trim();
+    const r = reverse.trim();
+    if (f === "")
+        return r;
+    if (r !== "" && normalise(f) !== normalise(r)) {
+        findings.add("divergence", `services: "${serviceId}" description differs between repo-config (forward) ` +
+            `and service-architecture.md ## Purpose (reverse) — repo-config kept`);
+    }
+    return f;
+}
+function normalise(s) {
+    return s.replace(/\s+/g, " ").trim().toLowerCase();
+}
+//# sourceMappingURL=services.js.map

package/dist/lib/catalogue/builders/system-external-dependency.js

@@ -0,0 +1,115 @@
+// system_external_dependency edge builder — emits one row per
+// `Rel(...)` line on an L1/L2 diagram that connects the SDD's own system
+// (or one of its containers) to an external system (per ADR 0155).
+//
+// Resolution: the c4-external-systems builder supplies `externalIdByEntryId`
+// (diagram entry-id → ext-... row id). For each `Rel(a, b, "label")` where
+// exactly one endpoint is a known external entry-id, we emit an edge from
+// the SDD's c4_systems row to that external system. Container-level external
+// dependencies are intentionally collapsed to the system level — ADR 0155
+// §4.2 keeps the edge system-scoped.
+import { readFile } from "node:fs/promises";
+import { collectC4DiagramFiles } from "./c4-external-systems.js";
+import { mergeEdgeLabel } from "./edge-label-merge.js";
+// Any C4-PlantUML relationship macro: Rel, Rel_U/D/L/R, BiRel, Rel_Back, etc.
+// Capture the first two positional args (from, to) and an optional label.
+const REL_RE = /^(?:Bi)?Rel(?:_[A-Za-z]+)?\s*\(\s*(\w+)\s*,\s*(\w+)\s*(?:,\s*"([^"]*)")?/;
+// Diagram files come from the shared collector (F11c) — see
+// c4-external-systems.ts / c4-l1-candidates.ts. This builder previously
+// kept a private, pre-0.30.1-ordered copy missing the domain-scoped L1
+// path, so Rel(...) lines there were never harvested.
+export async function buildSystemExternalDependency(inputs) {
+    const systemId = inputs.manifest.c4SystemId ?? `${inputs.manifest.sddId}-system`;
+    if (!inputs.knownSystemIds.has(systemId)) {
+        // Non-architectural SDD — no c4_systems FK target. Skip silently.
+        return [];
+    }
+    if (inputs.externalIdByEntryId.size === 0)
+        return [];
+    const files = await collectC4DiagramFiles(inputs.sddPath);
+    const rows = [];
+    const seen = new Set();
+    const rowsById = new Map();
+    // F14: a Rel in the syndicated platform L1 is a statement about the
+    // PLATFORM. For any other SDD those lines minted the platform's
+    // dependencies (and even its persona interactions) as the sibling's own
+    // edges — measured at 28% of one estate's dependency graph and 35/35
+    // polluted interaction labels on another. §4.5's rule, applied to edges:
+    // the syndicated copy sources edges for the platform root only. The ROW
+    // harvest keeps it (endpoint resolution needs its declarations).
+    const isRoot = inputs.manifest.category === "platform-root";
+    const PERSON_DECL_RE = /Person(?:_Ext)?\s*\(\s*(\w+)\s*,/;
+    for (const { abs, syndicated } of files) {
+        if (syndicated && !isRoot)
+            continue;
+        // (F17) the non-external Rel endpoint may be a local container — carry
+        // its id so adjudication can rewrite this edge onto container_dependency
+        // instead of destroying it when the external endpoint proves internal.
+        const content = await readFile(abs, "utf-8");
+        // F30: a Person-sourced Rel must never enter this catalogue — its
+        // semantics are runtime calls between software, and attributing a
+        // human's Rel to the system erases the person-ness (which adjudication
+        // then launders into system_system_dependency). The persona-container
+        // builder owns the person tier's exits and announces every skip.
+        const personEntries = new Set();
+        for (const raw of content.split(/\r?\n/)) {
+            const pm = PERSON_DECL_RE.exec(raw.trim());
+            if (pm)
+                personEntries.add(pm[1] ?? "");
+        }
+        for (const rel of parseRels(content)) {
+            if (personEntries.has(rel.from) || personEntries.has(rel.to))
+                continue;
+            // F28: classification is CONTAINER-FIRST, uniformly with the
+            // container-dependency builder (F20 / ledger L6). An entry-id that
+            // resolves to a local container IS a container, whatever a sibling
+            // diagram called it — the old external-first read here meant a
+            // dual-use SOURCE made the pair look external↔external to this
+            // builder while looking container→external to its sibling, and the
+            // edge fell between them: claimed by neither, reported by nothing.
+            // L6's fix was applied to one builder and not swept into this one.
+            const fromIsContainer = inputs.containerIdByEntryId?.has(rel.from) ?? false;
+            const toIsContainer = inputs.containerIdByEntryId?.has(rel.to) ?? false;
+            const fromExt = fromIsContainer
+                ? undefined
+                : inputs.externalIdByEntryId.get(rel.from);
+            const toExt = toIsContainer
+                ? undefined
+                : inputs.externalIdByEntryId.get(rel.to);
+            // Exactly one endpoint external — otherwise it's internal↔internal or
+            // external↔external (neither is a system→external dependency).
+            if ((fromExt === undefined) === (toExt === undefined))
+                continue;
+            const externalSystemId = (fromExt ?? toExt);
+            const localEntry = fromExt === undefined ? rel.from : rel.to;
+            const fromContainerId = inputs.containerIdByEntryId?.get(localEntry) ?? "";
+            const id = `${systemId}__${externalSystemId}`;
+            const existing = rowsById.get(id);
+            if (existing !== undefined) {
+                mergeEdgeLabel(existing, rel.label, "system_external_dependency", inputs.findings);
+                continue;
+            }
+            seen.add(id);
+            rowsById.set(id, {
+                id,
+                c4_system_id: systemId,
+                external_system_id: externalSystemId,
+                interaction: rel.label,
+                from_container_id: fromContainerId,
+            });
+            rows.push(rowsById.get(id));
+        }
+    }
+    rows.sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+    return rows;
+}
+function parseRels(content) {
+    const out = [];
+    for (const raw of content.split(/\r?\n/)) {
+        const m = REL_RE.exec(raw.trim());
+        if (m)
+            out.push({ from: m[1] ?? "", to: m[2] ?? "", label: m[3] ?? "" });
+    }
+    return out;
+}
+//# sourceMappingURL=system-external-dependency.js.map

package/dist/lib/catalogue/builders/user-journeys.js

@@ -0,0 +1,253 @@
+// User journeys discoverer — emits `user_journeys.csv` rows from
+// `journeys/*.md` at the SDD root.
+//
+// Source convention (per docs/method/methods/user-journey-template.md):
+//   journeys/<slug>.md
+//   ---
+//   # User Journey: {Name}
+//   **App:** {app-name}
+//   **Feature:** [{feature-name}]({path/to/feature-spec.md})
+//   **Primary Persona:** {persona-name}
+//   **Supporting Personas:** {comma-separated names} (optional)
+//   ## Journey Goal
+//   ...
+//   ## Trigger
+//   ...
+//
+// Profile gating: journeys are an application-product profile concept.
+// id = `{product_id}-{slug}`, slug from filename stem.
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative } from "node:path";
+const JOURNEYS_DIR_REL = "journeys";
+export async function buildUserJourneys(inputs) {
+    const idByPath = new Map();
+    const idBySlug = new Map();
+    const featurePathsById = new Map();
+    const relatedFeatureSlugsById = new Map();
+    const primaryPersonaById = new Map();
+    const supportingPersonasById = new Map();
+    if (inputs.profile !== "application-product") {
+        return {
+            rows: [],
+            idByPath,
+            idBySlug,
+            featurePathsById,
+            relatedFeatureSlugsById,
+            primaryPersonaById,
+            supportingPersonasById,
+        };
+    }
+    const dir = join(inputs.sddPath, JOURNEYS_DIR_REL);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+        inputs.findings.add("coverage", `${JOURNEYS_DIR_REL}/ not found — emitting empty user_journeys.csv`);
+        return {
+            rows: [],
+            idByPath,
+            idBySlug,
+            featurePathsById,
+            relatedFeatureSlugsById,
+            primaryPersonaById,
+            supportingPersonasById,
+        };
+    }
+    const files = entries
+        .filter((e) => e.isFile() && e.name.endsWith(".md") && !isTemplate(e.name))
+        .map((e) => e.name)
+        .sort();
+    const rows = [];
+    for (const filename of files) {
+        const slug = basename(filename).replace(/\.md$/i, "");
+        const id = `${inputs.productId}-${slug}`;
+        const absPath = join(dir, filename);
+        const relPath = relative(inputs.sddPath, absPath);
+        const text = await readFile(absPath, "utf-8");
+        const name = extractName(text) || titleCase(slug);
+        const primaryPersona = extractField(text, "Primary Persona");
+        const supportingPersonas = extractList(text, "Supporting Personas");
+        const trigger = extractSectionParagraph(text, "Trigger");
+        const goal = extractSectionParagraph(text, "Journey Goal");
+        const featurePaths = extractFeaturePaths(text);
+        const relatedFeatureSlugs = extractRelatedFeatures(text);
+        rows.push({
+            id,
+            name,
+            product_id: inputs.productId,
+            primary_persona: primaryPersona,
+            supporting_personas: supportingPersonas.join(", "),
+            trigger,
+            goal,
+            source_sdd_id: "",
+        });
+        idByPath.set(relPath, id);
+        idBySlug.set(slug, id);
+        featurePathsById.set(id, featurePaths);
+        relatedFeatureSlugsById.set(id, relatedFeatureSlugs);
+        primaryPersonaById.set(id, primaryPersona);
+        supportingPersonasById.set(id, supportingPersonas);
+    }
+    return {
+        rows,
+        idByPath,
+        idBySlug,
+        featurePathsById,
+        relatedFeatureSlugsById,
+        primaryPersonaById,
+        supportingPersonasById,
+    };
+}
+function isTemplate(name) {
+    return /[{}]/.test(name) || name.toLowerCase().endsWith("-template.md");
+}
+function extractName(text) {
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line === "")
+            continue;
+        const m = /^#\s+(.+)$/.exec(line);
+        if (!m)
+            return "";
+        const stripped = (m[1] ?? "").trim();
+        const journeyPrefix = /^User Journey:\s*(.+)$/i.exec(stripped);
+        return journeyPrefix ? (journeyPrefix[1] ?? "").trim() : stripped;
+    }
+    return "";
+}
+function extractField(text, field) {
+    const re = new RegExp(`^\\s*[*\\-]?\\s*\\*\\*${escapeRegex(field)}:\\*\\*\\s*(.*?)\\s*$`, "im");
+    const m = re.exec(text);
+    if (!m || m[1] === undefined)
+        return "";
+    return m[1].trim();
+}
+function extractList(text, field) {
+    const value = extractField(text, field);
+    if (value === "")
+        return [];
+    return value
+        .split(/[,;]/)
+        .map((s) => s.trim())
+        .filter((s) => s !== "");
+}
+function extractSectionParagraph(text, heading) {
+    const lines = text.split(/\r?\n/);
+    const headingRe = new RegExp(`^##\\s+${escapeRegex(heading)}\\b`, "i");
+    let i = 0;
+    while (i < lines.length) {
+        if (headingRe.test(lines[i] ?? ""))
+            break;
+        i++;
+    }
+    if (i === lines.length)
+        return "";
+    i++;
+    while (i < lines.length && (lines[i] ?? "").trim() === "")
+        i++;
+    const para = [];
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        if (line.trim() === "")
+            break;
+        if (line.startsWith("#") || line.startsWith("---"))
+            break;
+        para.push(line.trim());
+        i++;
+    }
+    return para.join(" ").trim().slice(0, 500);
+}
+/**
+ * Pull out feature spec paths from the `**Feature:** [Name](path)` field
+ * and from any `[name](path)` link inside `## Related Features` bullets.
+ * Returns relative paths as written.
+ */
+function extractFeaturePaths(text) {
+    const out = [];
+    // Top-of-file `**Feature:** [Name](path)` link.
+    const featureLineRe = /\*\*Feature:\*\*\s*\[[^\]]+\]\(([^)]+)\)/i;
+    const m = featureLineRe.exec(text);
+    if (m && m[1])
+        out.push(m[1].trim());
+    // Bullets in `## Related Features` referencing files.
+    const lines = text.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        if (/^##\s+related\s+features\b/i.test(lines[i] ?? ""))
+            break;
+        i++;
+    }
+    if (i < lines.length) {
+        i++;
+        while (i < lines.length) {
+            const line = lines[i] ?? "";
+            if (line.startsWith("#") || line.startsWith("---"))
+                break;
+            const linkMatch = /^[-*]\s+\[[^\]]+\]\(([^)]+)\)/.exec(line.trim());
+            if (linkMatch && linkMatch[1])
+                out.push(linkMatch[1].trim());
+            i++;
+        }
+    }
+    return out;
+}
+function extractRelatedFeatures(text) {
+    const lines = text.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        if (/^##\s+related\s+features\b/i.test(lines[i] ?? ""))
+            break;
+        i++;
+    }
+    if (i === lines.length)
+        return [];
+    i++;
+    const out = [];
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        if (line.startsWith("#") || line.startsWith("---"))
+            break;
+        const trimmed = line.trim();
+        // Markdown link bullet: `- [Name](path/<slug>/spec.md)` → derive slug from path.
+        const linkMatch = /^[-*]\s+\[[^\]]+\]\(([^)]+)\)/.exec(trimmed);
+        if (linkMatch && linkMatch[1]) {
+            const slug = slugFromPath(linkMatch[1]);
+            if (slug !== "")
+                out.push(slug);
+        }
+        else {
+            // Bare-slug bullet: `- feature-name` or `- \`feature-name\``.
+            const slugMatch = /^[-*]\s+`?([a-z0-9][a-z0-9-]*)`?(?:\s|$)/i.exec(trimmed);
+            if (slugMatch && slugMatch[1])
+                out.push(slugMatch[1].toLowerCase());
+        }
+        i++;
+    }
+    return out;
+}
+function slugFromPath(path) {
+    // Take the last meaningful path segment that looks like a slug. Common
+    // shapes: `features/<slug>/spec.md`, `features/<slug>.md`.
+    const cleaned = path.replace(/^\/+/, "").replace(/\/+$/, "");
+    const parts = cleaned.split("/");
+    for (let j = parts.length - 1; j >= 0; j--) {
+        const part = (parts[j] ?? "").replace(/\.md$/i, "");
+        if (/^[a-z0-9][a-z0-9-]*$/.test(part) && part !== "spec") {
+            return part;
+        }
+    }
+    return "";
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function titleCase(slug) {
+    return slug
+        .split("-")
+        .map((p) => (p.length === 0 ? p : p[0].toUpperCase() + p.slice(1)))
+        .join(" ");
+}
+//# sourceMappingURL=user-journeys.js.map