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

package/dist/lib/catalogue/builders/evidence-class.js

@@ -0,0 +1,43 @@
+// File-level evidence-class extraction for data-model markdown, per the
+// documentation-reverse anchor convention (ADR 0175 / sdd-method
+// `docs/method/methods/reverse/documentation-reverse-anchor-schema.md`).
+//
+// Documentation-reversed data models open with a fenced ```yaml block near
+// the top of the file carrying the anchor metadata:
+//
+//   ```yaml
+//   evidence-class: vendor-doc
+//   vendor: workos
+//   vendor-version: workos-docs@2026-06-10
+//   anchors: [...]
+//   ```
+//
+// The extractor finds the FIRST ```yaml fence in the markdown, YAML-parses
+// the fence body, and reads `evidence-class` (alias `evidence_class`).
+// Everything is best-effort: no fence, a non-mapping body, an unparseable
+// body, or a missing key all yield "" — code-reversed data models carry no
+// fence and stay empty.
+import { parse as parseYaml } from "yaml";
+const RE_YAML_FENCE = /^[ \t]*```[ \t]*ya?ml[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```[ \t]*$/im;
+/**
+ * Extract the file-level `evidence-class:` declaration from a markdown
+ * document's leading ```yaml fence. Returns "" when absent or malformed.
+ */
+export function extractFileEvidenceClass(markdown) {
+    const m = RE_YAML_FENCE.exec(markdown);
+    if (!m)
+        return "";
+    let parsed;
+    try {
+        parsed = parseYaml(m[1] ?? "");
+    }
+    catch {
+        return "";
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return "";
+    const obj = parsed;
+    const value = obj["evidence-class"] ?? obj["evidence_class"];
+    return typeof value === "string" ? value.trim() : "";
+}
+//# sourceMappingURL=evidence-class.js.map

package/dist/lib/catalogue/builders/evidence-target-repo.js

@@ -0,0 +1,67 @@
+// evidence_target_repo (M-ADR 0214 §4.10): a reverse evidence YAML names, through a top-level
+// `target_repo` (one id or a list), repositories ANOTHER SDD owns. A reference, never a claim — the
+// repository is described by exactly one SDD, elsewhere — so the FK is external at build and must
+// resolve at aggregation. Naming a repository this SDD itself describes is reported: that is the
+// SDD's own, and its reverse-metadata already says so.
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+const SKIP = new Set(["node_modules", ".git", "source", "catalogues", "catalogues-aggregated", "dist", "bundle-cache"]);
+async function evidenceFiles(root, current, inEvidence, out) {
+    let entries;
+    try {
+        entries = await readdir(current, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (SKIP.has(e.name))
+            continue;
+        const abs = join(current, e.name);
+        if (e.isDirectory()) {
+            if (relative(root, abs).split(sep).length > 10)
+                continue;
+            await evidenceFiles(root, abs, inEvidence || e.name === "reverse-evidence", out);
+        }
+        else if (inEvidence && e.isFile() && /\.ya?ml$/.test(e.name)) {
+            out.push(abs);
+        }
+    }
+}
+export async function buildEvidenceTargetRepos(sddPath, ownRepoIds, findings) {
+    const files = [];
+    await evidenceFiles(sddPath, sddPath, false, files);
+    const rows = new Map();
+    for (const abs of files) {
+        const rel = relative(sddPath, abs);
+        let doc;
+        try {
+            doc = parseYaml(await readFile(abs, "utf-8"));
+        }
+        catch {
+            continue; // an unparseable file is the yaml-parse validator's finding, not this one's
+        }
+        if (!doc || typeof doc !== "object" || Array.isArray(doc))
+            continue;
+        const raw = doc["target_repo"];
+        if (raw === undefined)
+            continue;
+        const ids = Array.isArray(raw) ? raw : [raw];
+        for (const v of ids) {
+            if (typeof v !== "string" || v.trim() === "") {
+                findings.add("convention", `${rel}: target_repo must be a repository id or a list of them — ${JSON.stringify(v)} skipped`);
+                continue;
+            }
+            const repoId = v.trim();
+            if (ownRepoIds.has(repoId)) {
+                findings.add("convention", `${rel}: target_repo ${repoId} is a repository this SDD describes — it is yours, not a reference to another SDD's (M-ADR 0214 §4.10); drop it`);
+                continue;
+            }
+            const id = `${rel}::${repoId}`;
+            rows.set(id, { id, evidence_path: rel, repo_id: repoId, source_sdd_id: "" });
+        }
+    }
+    return [...rows.values()];
+}
+//# sourceMappingURL=evidence-target-repo.js.map

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

@@ -0,0 +1,120 @@
+// external_system_exemption builder — M-ADR 0189 §4.6 (gov WS15).
+//
+// Emits one row per entry in `orchestration/external-system-exemptions.yaml`:
+//
+//   exemptions:
+//     - external_system_id: "ext-acme-email"
+//       reason: "third-party-saas"     # closed vocabulary, canonical-schema.yaml
+//       note: "Transactional email vendor; SMTP relay only."
+//
+// An adjudicator can prove a candidate INTERNAL; it cannot prove one
+// EXTERNAL — externality is an assertion the author is accountable for
+// (the adopter owns assertions; the method owns inferences). Each row
+// retires exactly one "kept external, unverified" coverage finding at
+// aggregation, and nothing else.
+//
+// VALIDATION ORDER IS LOAD-BEARING, per the M-ADR 0188 §4.3 precedent:
+// every rejection below drops the exemption row and leaves the candidate
+// unverified — reported by the aggregator's coverage predicate. It never
+// drops the candidate. An exemption that fails validation must not quietly
+// succeed at the one thing an exemption does, which is remove a candidate
+// from the invariant's attention.
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+export const EXTERNAL_EXEMPTIONS_REL_PATH = "orchestration/external-system-exemptions.yaml";
+export async function buildExternalSystemExemption(inputs) {
+    const abs = join(inputs.sddPath, EXTERNAL_EXEMPTIONS_REL_PATH);
+    let raw;
+    try {
+        raw = await readFile(abs, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const doc = parseYaml(raw);
+    const entries = Array.isArray(doc?.exemptions) ? doc.exemptions : [];
+    const rows = [];
+    // Resolved id → the id it was AUTHORED as. A Map rather than a Set because a
+    // collision has to name both sources, and after cut-window re-keying the two
+    // colliding entries may have been authored under different ids — reporting
+    // only the survivor would name neither of the things the author wrote.
+    const seen = new Map();
+    for (const item of entries) {
+        if (!item || typeof item !== "object")
+            continue;
+        const o = item;
+        let extId = typeof o["external_system_id"] === "string" ? o["external_system_id"].trim() : "";
+        // Captured before cut-window re-keying rewrites `extId`, so a collision can
+        // report what the author actually wrote rather than what it resolved to.
+        const authoredId = extId;
+        const reason = typeof o["reason"] === "string" ? o["reason"].trim() : "";
+        const note = typeof o["note"] === "string" ? o["note"].trim() : "";
+        if (extId === "")
+            continue;
+        if (!inputs.knownExternalIds.has(extId)) {
+            // M-ADR 0203 §4.2 cut window: an id the 2.x builder minted from the
+            // display name is provably tool-authored — regenerable, not drift.
+            const mapped = inputs.legacyIdMap?.get(extId);
+            if (mapped !== undefined && mapped.length === 1) {
+                inputs.findings.add("inferred", `${EXTERNAL_EXEMPTIONS_REL_PATH}: exemption for "${extId}" re-keyed to "${mapped[0]}" — ` +
+                    `2.x name-slug id migrated per the 3.0.0 ext-id map (regenerable, not drift); update the yaml to retire this finding`);
+                extId = mapped[0];
+            }
+            else if (mapped !== undefined && mapped.length > 1) {
+                inputs.findings.add("convention", `${EXTERNAL_EXEMPTIONS_REL_PATH}: exemption for "${extId}" — this 2.x name-slug id maps to ` +
+                    `${mapped.length} declared identities at 3.0.0 [${mapped.join(", ")}]; the author must choose one; exemption dropped`);
+                continue;
+            }
+            else {
+                inputs.findings.add("convention", `${EXTERNAL_EXEMPTIONS_REL_PATH}: exemption for "${extId}" — this SDD declares no such external-system candidate ` +
+                    `(3.0.0 ids derive from diagram entry ids; \`sdd-cli catalogue migration-map\` lists the 2.x→3.0.0 id map); exemption dropped`);
+                continue;
+            }
+        }
+        if (reason === "") {
+            inputs.findings.add("convention", `${EXTERNAL_EXEMPTIONS_REL_PATH}: exemption for "${extId}" declares no reason — dropped, candidate stays unverified (M-ADR 0189 §4.6)`);
+            continue;
+        }
+        if (!inputs.allowedReasons.has(reason)) {
+            const allowed = [...inputs.allowedReasons].sort().join(", ");
+            inputs.findings.add("convention", `${EXTERNAL_EXEMPTIONS_REL_PATH}: exemption for "${extId}" reason "${reason}" is outside the closed vocabulary [${allowed}] — dropped, candidate stays unverified (M-ADR 0189 §4.6)`);
+            continue;
+        }
+        if (note === "") {
+            inputs.findings.add("convention", `${EXTERNAL_EXEMPTIONS_REL_PATH}: exemption for "${extId}" has no note — the reason makes exemptions countable, the note makes them reviewable; dropped (M-ADR 0189 §4.6)`);
+            continue;
+        }
+        // A collapse is a FINDING, not a silent drop. Two authored exemptions
+        // resolving to one candidate means one author's reason and note are
+        // discarded, and an exemption's whole job is to carry a reviewable
+        // justification — so dropping one silently retires a candidate from the
+        // invariant's attention under a justification nobody chose. Both sibling
+        // builders (repo-capability-exemption, service-capability-exemption) already
+        // report their duplicates as `divergence`; this one was the outlier.
+        //
+        // Names BOTH SOURCES, which is more than "duplicate id" would say: after
+        // cut-window re-keying the two entries can have been authored under
+        // DIFFERENT ids, so the collision is invisible in the yaml — the author sees
+        // two unlike entries, and only the resolved form collides. Reporting the
+        // resolved id alone would name something they never wrote.
+        const firstAuthoredAs = seen.get(extId);
+        if (firstAuthoredAs !== undefined) {
+            const bothAuthoredSame = firstAuthoredAs === authoredId;
+            inputs.findings.add("divergence", bothAuthoredSame
+                ? `${EXTERNAL_EXEMPTIONS_REL_PATH}: duplicate external_system_exemption for "${extId}" — first declaration wins; ` +
+                    `the later entry's reason "${reason}" and note are discarded. One candidate takes one exemption; merge them.`
+                : `${EXTERNAL_EXEMPTIONS_REL_PATH}: exemptions authored as "${firstAuthoredAs}" and "${authoredId}" both resolve to ` +
+                    `"${extId}" — first declaration wins; the later entry's reason "${reason}" and note are discarded. ` +
+                    `Two authored entries cannot both exempt one candidate: merge them, or correct whichever id is wrong.`);
+            continue;
+        }
+        seen.set(extId, authoredId);
+        rows.push({ id: extId, external_system_id: extId, reason, note });
+    }
+    rows.sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+    return rows;
+}
+//# sourceMappingURL=external-system-exemption.js.map

package/dist/lib/catalogue/builders/feature-contract.js

@@ -0,0 +1,77 @@
+// Edge builder for feature_contract — derived from two join paths.
+//
+// Forward:  capability_feature ⋈ capability_contract  (on capability_id)
+// Reverse:  feature_service    ⋈ service_contract     (on service_id)
+//
+// Both paths are run and results are merged; duplicate (feature_id, contract_id)
+// pairs are deduplicated with a `[finding] inferred` log line recording that
+// both paths produced the same edge.
+//
+// Added in schema 2.3.0 — see catalogue-metamodel.md §"Edge catalogue status"
+// and the companion plan
+// `content/plans/document-non-catalogued-artefacts-and-add-feature-contract.md`.
+export function buildFeatureContract(inputs) {
+    const seen = new Map();
+    // Path 1 (forward): capability_feature ⋈ capability_contract on capability_id.
+    const contractsByCap = new Map();
+    for (const row of inputs.capabilityContractRows) {
+        const capId = String(row["capability_id"] ?? "");
+        if (capId === "")
+            continue;
+        const contractId = String(row["contract_id"] ?? "");
+        if (contractId === "")
+            continue;
+        const arr = contractsByCap.get(capId) ?? [];
+        arr.push(contractId);
+        contractsByCap.set(capId, arr);
+    }
+    for (const row of inputs.capabilityFeatureRows) {
+        const featureId = String(row["feature_id"] ?? "");
+        const capId = String(row["capability_id"] ?? "");
+        if (featureId === "" || capId === "")
+            continue;
+        for (const contractId of contractsByCap.get(capId) ?? []) {
+            emit(seen, featureId, contractId, "cap-feature-cap-contract", inputs.findings);
+        }
+    }
+    // Path 2 (reverse): feature_service ⋈ service_contract on service_id.
+    // service_contract may carry rows with role=exposes|consumes; both
+    // count as the service being wired to the contract for traceability.
+    const contractsByService = new Map();
+    for (const row of inputs.serviceContractRows) {
+        const svcId = String(row["service_id"] ?? "");
+        if (svcId === "")
+            continue;
+        const contractId = String(row["contract_id"] ?? "");
+        if (contractId === "")
+            continue;
+        const arr = contractsByService.get(svcId) ?? [];
+        arr.push(contractId);
+        contractsByService.set(svcId, arr);
+    }
+    for (const row of inputs.featureServiceRows) {
+        const featureId = String(row["feature_id"] ?? "");
+        const svcId = String(row["service_id"] ?? "");
+        if (featureId === "" || svcId === "")
+            continue;
+        for (const contractId of contractsByService.get(svcId) ?? []) {
+            emit(seen, featureId, contractId, "feature-service-service-contract", inputs.findings);
+        }
+    }
+    // Sort by id for deterministic output (same convention as capability-edges.ts).
+    return Array.from(seen.values()).sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+}
+function emit(seen, featureId, contractId, derivationPath, findings) {
+    const id = `${featureId}__${contractId}`;
+    if (seen.has(id)) {
+        findings.add("inferred", `feature_contract derived by both join paths: ${id} (kept first; would also derive via ${derivationPath})`);
+        return;
+    }
+    seen.set(id, {
+        id,
+        feature_id: featureId,
+        contract_id: contractId,
+        derivation_path: derivationPath,
+    });
+}
+//# sourceMappingURL=feature-contract.js.map

package/dist/lib/catalogue/builders/feature-domain-model.js

@@ -0,0 +1,50 @@
+// Edge builder for feature_domain_model — emits `feature_domain_model.csv`.
+//
+// Platform-profile only. Non-platform SDDs return an empty list.
+//
+// Derived from capability_feature ⋈ capability_domain_model on
+// capability_id. Orphan features (no capability link) get no row;
+// the join produces nothing for them.
+//
+// Output is deduplicated on (feature_id, domain_model_id). If a feature
+// links to multiple capabilities that each link to a different domain
+// model, both pairs are emitted. If multiple capabilities link to the
+// SAME domain model, the duplicate is silently dropped.
+//
+// Added in schema 2.4.0 per ADR 0142.
+export function buildFeatureDomainModel(inputs) {
+    if (inputs.manifest.profile !== "platform-profile") {
+        return [];
+    }
+    // Index capability_domain_model rows by capability_id for join.
+    const modelsByCap = new Map();
+    for (const row of inputs.capabilityDomainModelRows) {
+        const capId = String(row["capability_id"] ?? "");
+        const modelId = String(row["domain_model_id"] ?? "");
+        if (capId === "" || modelId === "")
+            continue;
+        const arr = modelsByCap.get(capId) ?? [];
+        arr.push(modelId);
+        modelsByCap.set(capId, arr);
+    }
+    const seen = new Map();
+    for (const row of inputs.capabilityFeatureRows) {
+        const featureId = String(row["feature_id"] ?? "");
+        const capId = String(row["capability_id"] ?? "");
+        if (featureId === "" || capId === "")
+            continue;
+        for (const modelId of modelsByCap.get(capId) ?? []) {
+            const id = `${featureId}__${modelId}`;
+            if (seen.has(id))
+                continue;
+            seen.set(id, {
+                id,
+                feature_id: featureId,
+                domain_model_id: modelId,
+                derivation_path: "cap-feature-cap-domain-model",
+            });
+        }
+    }
+    return Array.from(seen.values()).sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+}
+//# sourceMappingURL=feature-domain-model.js.map

package/dist/lib/catalogue/builders/feature-grounding-walker.js

@@ -0,0 +1,254 @@
+/**
+ * Walker for `feature-grounding.md` files per ADR 0143 (schema 2.5.0).
+ *
+ * Reads markdown tables of the canonical shape:
+ *
+ *     | Feature | UI Components | API Routes | Backend Handlers | Data Entities | Evidence |
+ *     |---|---|---|---|---|---|
+ *     | `oauth2-login` | ... | BFF `GET /login` | `AuthHandler.handle...()` | Token | `auth-handler.ts` |
+ *
+ * Path conventions (per ADR 0143 §4.3):
+ *   - platform-profile: `docs/domains/<dom>/design/<capability>/feature-grounding.md`
+ *   - integration-product: `docs/design/integration/feature-grounding.md`
+ *
+ * Tolerant of column re-ordering and missing optional columns. The only
+ * required column is `Feature`. Lines inside ```fenced``` code blocks
+ * are skipped. Recovery is row-local — a malformed row emits a finding
+ * and the walker continues with the next row.
+ */
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+const DOMAINS_DIR_REL = join("docs", "domains");
+const PLATFORM_LEAF = "feature-grounding.md";
+/**
+ * Find all `docs/domains/<dom>/design/<capability>/feature-grounding.md`
+ * files under the SDD root. Sorted for deterministic output.
+ */
+export async function findPlatformGroundingFiles(sddPath) {
+    const out = [];
+    const domainsDir = join(sddPath, DOMAINS_DIR_REL);
+    let domains;
+    try {
+        domains = await readdir(domainsDir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const d of domains) {
+        if (!d.isDirectory())
+            continue;
+        const designDir = join(domainsDir, d.name, "design");
+        let caps;
+        try {
+            caps = await readdir(designDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const c of caps) {
+            if (!c.isDirectory())
+                continue;
+            const candidate = join(designDir, c.name, PLATFORM_LEAF);
+            try {
+                await readFile(candidate, "utf-8");
+                out.push(candidate);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === "ENOENT")
+                    continue;
+                throw err;
+            }
+        }
+    }
+    return out.sort();
+}
+/**
+ * Find the single integration-product feature-grounding.md, if any.
+ * Path: `docs/design/integration/feature-grounding.md`.
+ */
+export async function findIntegrationGroundingFile(sddPath) {
+    const candidate = join(sddPath, "docs", "design", "integration", PLATFORM_LEAF);
+    try {
+        await readFile(candidate, "utf-8");
+        return candidate;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+/**
+ * Resolve the capability id from a platform-profile grounding file's
+ * absolute path. Returns the parent folder name. Callers verify the
+ * id resolves against `capabilities.csv` and emit findings on miss.
+ */
+export function capabilityIdFromPath(absPath, sddPath) {
+    const rel = relative(sddPath, absPath);
+    const parts = rel.split(sep);
+    // Expected: ["docs", "domains", "<dom>", "design", "<capability>", "feature-grounding.md"]
+    if (parts.length < 6)
+        return "";
+    return parts[parts.length - 2] ?? "";
+}
+/**
+ * Parse the markdown content of a feature-grounding.md file and return
+ * the rows from its first valid feature table. A "valid table" has a
+ * header row whose first non-empty cell normalises to `feature`.
+ * Returns an empty array if no such table is found (caller logs a
+ * coverage finding).
+ */
+export function parseGroundingTable(text) {
+    const lines = text.split(/\r?\n/);
+    let inFence = false;
+    let i = 0;
+    while (i < lines.length) {
+        const raw = lines[i] ?? "";
+        if (isFenceToggle(raw)) {
+            inFence = !inFence;
+            i++;
+            continue;
+        }
+        if (inFence) {
+            i++;
+            continue;
+        }
+        if (!isTableRowLine(raw)) {
+            i++;
+            continue;
+        }
+        // Candidate header row. Need a separator row right after.
+        const next = lines[i + 1] ?? "";
+        if (!isSeparatorRowLine(next)) {
+            i++;
+            continue;
+        }
+        const headers = splitTableRow(raw).map(normaliseHeader);
+        if (headers.length === 0 || headers[0] !== "feature") {
+            i++;
+            continue;
+        }
+        // Found the table. Walk body rows until non-table line.
+        return parseBodyRows(lines, i + 2, headers);
+    }
+    return [];
+}
+function parseBodyRows(lines, startIdx, headers) {
+    const rows = [];
+    let inFence = false;
+    for (let i = startIdx; i < lines.length; i++) {
+        const raw = lines[i] ?? "";
+        if (isFenceToggle(raw)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        if (!isTableRowLine(raw)) {
+            // Allow a single blank line inside the table; anything else ends it.
+            if (raw.trim() === "")
+                continue;
+            break;
+        }
+        const cells = splitTableRow(raw);
+        const featureCell = cells[0] ?? "";
+        const slug = extractSlug(featureCell);
+        if (slug === "") {
+            // Skip rows whose first cell isn't a recognisable slug — caller logs.
+            continue;
+        }
+        const cellMap = new Map();
+        for (let c = 1; c < headers.length; c++) {
+            const header = headers[c] ?? "";
+            if (header === "")
+                continue;
+            cellMap.set(header, (cells[c] ?? "").trim());
+        }
+        rows.push({ slug, cells: cellMap, lineNumber: i + 1 });
+    }
+    return rows;
+}
+/** A line is a table row if it has at least one unescaped `|`. */
+function isTableRowLine(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("|") && !trimmed.includes("|"))
+        return false;
+    // Heuristic: a row must contain at least two | characters.
+    return (trimmed.match(/\|/g)?.length ?? 0) >= 2;
+}
+/** Separator row: `|---|---|...|`, possibly with `:` alignment markers. */
+function isSeparatorRowLine(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("|"))
+        return false;
+    return /^\|(\s*:?-+:?\s*\|)+\s*$/.test(trimmed);
+}
+function isFenceToggle(raw) {
+    const trimmed = raw.trimStart();
+    return trimmed.startsWith("```") || trimmed.startsWith("~~~");
+}
+/**
+ * Split a `| a | b | c |` row into cells. Strips leading/trailing
+ * empty cells caused by the bookend pipes. Does NOT split inside
+ * backtick spans — `` `foo|bar` `` stays as one cell.
+ */
+function splitTableRow(raw) {
+    const cells = [];
+    let current = "";
+    let inTick = false;
+    // Skip the opening pipe if present.
+    let trimmed = raw.trim();
+    if (trimmed.startsWith("|"))
+        trimmed = trimmed.slice(1);
+    if (trimmed.endsWith("|"))
+        trimmed = trimmed.slice(0, -1);
+    for (const ch of trimmed) {
+        if (ch === "`") {
+            inTick = !inTick;
+            current += ch;
+            continue;
+        }
+        if (ch === "|" && !inTick) {
+            cells.push(current);
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    cells.push(current);
+    return cells;
+}
+/**
+ * Normalise a header cell to a key form: lowercase, trimmed, spaces
+ * and `/` collapsed to `_`. Backticks stripped. e.g. "API Routes" →
+ * "api_routes", "UI / UX" → "ui_ux".
+ */
+function normaliseHeader(cell) {
+    return cell
+        .replace(/`/g, "")
+        .trim()
+        .toLowerCase()
+        .replace(/[\s/]+/g, "_");
+}
+/**
+ * Extract the slug from the first cell. Recognises:
+ *   - `` `slug` ``                     → "slug"
+ *   - `` `slug` (description) ``       → "slug"
+ *   - plain `slug-name`                → "slug-name"
+ * Returns "" if no valid slug pattern matches.
+ */
+function extractSlug(cell) {
+    const trimmed = cell.trim();
+    // Backticked form first — the canonical shape.
+    const tickMatch = trimmed.match(/^`([a-z0-9][a-z0-9-]*)`/i);
+    if (tickMatch)
+        return tickMatch[1] ?? "";
+    // Plain kebab-case fallback.
+    const plainMatch = trimmed.match(/^([a-z][a-z0-9-]*)$/i);
+    if (plainMatch)
+        return plainMatch[1] ?? "";
+    return "";
+}
+//# sourceMappingURL=feature-grounding-walker.js.map