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

package/dist/lib/catalogue/builders/glossary-xref.js

@@ -0,0 +1,378 @@
+// glossary_xref + entity_glossary edge builders — emit cross-domain glossary
+// relationships from `docs/platform/reference/glossary-alignment-manifest.yaml`.
+//
+// Per ADR 0158 (Glossary Cross-Reference Multi-Source Ingestion, schema 2.12.0),
+// the builder ingests from FIVE walkers:
+//
+//   1. Forward declared pair-form (existing).
+//        aliases: [{source, target}]
+//        conflicts: [{source, target}]
+//      Emits glossary_xref rows with relation ∈ {alias-of, conflicts-with}.
+//
+//   2. Reverse-method cross_domain_terms (new).
+//        cross_domain_terms:
+//          - term: <name>
+//            owner: <domain>
+//            referenced_by: [<domain>, ...]
+//      One row per (referencer, owner) pair with relation=references.
+//
+//   3. Reverse-method multi-domain conflicts (new).
+//        conflicts:
+//          - term: <name>
+//            domains: [{domain, meaning}, ...]
+//            resolution: <text>
+//      Pair-wise expansion across domains[] with relation=conflicts-with.
+//      Disambiguated from #1 by per-entry field inspection.
+//
+//   4. Forward-method supersedes (new).
+//        models[].entities[] with status: superseded + superseded_by
+//      One row per supersedes mapping after resolving both endpoints'
+//      glossary_term against glossary_items.csv. Orphan finding when an
+//      endpoint doesn't resolve.
+//
+//   5. Forward-method entity-mapping (new, writes to entity_glossary).
+//        models[].entities[] with status ∈ {aligned, matched_direct} and
+//        non-empty glossary_term.
+//      One row per (domain, entity_name, glossary_term) tuple after dedup.
+//      Same-domain multi-diagram entries collapse to one row; cross-domain
+//      entries (e.g. platform-wide conceptual + party-domain detailed)
+//      emit one row per domain — legitimate cross-level cataloguing.
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+const MANIFEST_REL_PATH = join("docs", "platform", "reference", "glossary-alignment-manifest.yaml");
+export async function buildGlossaryXref(inputs) {
+    // Profile gate per ADR 0158 §amendment: the manifest is platform-owned;
+    // sibling SDDs that syndicate it for documentation accessibility should
+    // not re-emit rows. Mirrors the entities-manifest profile gate.
+    if (inputs.profile !== "platform-profile") {
+        return { glossaryXref: [], entityGlossary: [] };
+    }
+    const path = join(inputs.sddPath, MANIFEST_REL_PATH);
+    let text;
+    try {
+        text = await readFile(path, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return { glossaryXref: [], entityGlossary: [] };
+        throw err;
+    }
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        inputs.findings.add("convention", `${MANIFEST_REL_PATH}: failed to parse YAML — ${err.message}`);
+        return { glossaryXref: [], entityGlossary: [] };
+    }
+    if (!raw || typeof raw !== "object")
+        return { glossaryXref: [], entityGlossary: [] };
+    const obj = raw;
+    const xrefRows = [];
+    const xrefSeen = new Set();
+    const entityRows = [];
+    const entitySeen = new Map();
+    const emitXref = (sourceId, targetId, relation) => {
+        if (sourceId === targetId)
+            return;
+        const id = `${sourceId}__${relation}__${targetId}`;
+        if (xrefSeen.has(id))
+            return;
+        xrefSeen.add(id);
+        xrefRows.push({ id, source_id: sourceId, target_id: targetId, relation });
+    };
+    // Walker 1 — forward declared pair-form aliases.
+    const aliasesRaw = obj["aliases"];
+    for (const pair of collectPairs(aliasesRaw)) {
+        const sourceId = resolveTerm(pair.source, inputs);
+        const targetId = resolveTerm(pair.target, inputs);
+        if (sourceId === undefined) {
+            inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: alias-of source "${pair.source}" doesn't resolve to a known glossary item`);
+            continue;
+        }
+        if (targetId === undefined) {
+            inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: alias-of target "${pair.target}" doesn't resolve to a known glossary item`);
+            continue;
+        }
+        emitXref(sourceId, targetId, "alias-of");
+    }
+    // Walkers 1+3 — `conflicts` key: disambiguated per-entry.
+    // Pair-form {source, target} → forward (alias-style conflicts-with).
+    // Multi-domain {term, domains[]} → reverse-method walker.
+    const conflictsRaw = obj["conflicts_with"] ?? obj["conflicts"];
+    if (Array.isArray(conflictsRaw)) {
+        for (const item of conflictsRaw) {
+            if (!item || typeof item !== "object")
+                continue;
+            const o = item;
+            const hasPairFields = "source" in o || "source_id" in o || "target" in o || "target_id" in o;
+            const hasReverseFields = "term" in o && "domains" in o && Array.isArray(o["domains"]);
+            if (hasPairFields && hasReverseFields) {
+                inputs.findings.add("divergence", `${MANIFEST_REL_PATH}: glossary-xref conflicts entry has mixed forward/reverse fields — skipped`);
+                continue;
+            }
+            if (hasPairFields) {
+                const source = String(o["source"] ?? o["source_id"] ?? "").trim();
+                const target = String(o["target"] ?? o["target_id"] ?? "").trim();
+                if (source === "" || target === "")
+                    continue;
+                const sourceId = resolveTerm(source, inputs);
+                const targetId = resolveTerm(target, inputs);
+                if (sourceId === undefined) {
+                    inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: conflicts-with source "${source}" doesn't resolve to a known glossary item`);
+                    continue;
+                }
+                if (targetId === undefined) {
+                    inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: conflicts-with target "${target}" doesn't resolve to a known glossary item`);
+                    continue;
+                }
+                emitXref(sourceId, targetId, "conflicts-with");
+            }
+            else if (hasReverseFields) {
+                const term = String(o["term"] ?? "").trim();
+                const domains = o["domains"].map((d) => {
+                    if (!d || typeof d !== "object")
+                        return null;
+                    return String(d["domain"] ?? "").trim();
+                }).filter((d) => d !== null && d !== "");
+                // Resolve each domain to its term-specific glossary id.
+                const resolvedIds = [];
+                for (const domain of domains) {
+                    const id = inputs.idByDomainTerm.get(`${domain}:${term.toLowerCase()}`);
+                    if (id === undefined) {
+                        inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: conflicts entry "${term}" domain "${domain}" — no domain-local glossary item`);
+                        continue;
+                    }
+                    resolvedIds.push({ domain, id });
+                }
+                // Pair-wise emit across domains[i] × domains[j] for i<j.
+                for (let i = 0; i < resolvedIds.length; i++) {
+                    for (let j = i + 1; j < resolvedIds.length; j++) {
+                        emitXref(resolvedIds[i].id, resolvedIds[j].id, "conflicts-with");
+                    }
+                }
+            }
+        }
+    }
+    // Walker 2 — reverse-method cross_domain_terms.
+    const crossDomainTermsRaw = obj["cross_domain_terms"];
+    if (Array.isArray(crossDomainTermsRaw)) {
+        for (const item of crossDomainTermsRaw) {
+            if (!item || typeof item !== "object")
+                continue;
+            const o = item;
+            const term = String(o["term"] ?? "").trim();
+            const owner = String(o["owner"] ?? "").trim();
+            if (term === "" || owner === "")
+                continue;
+            const ownerTermId = inputs.idByDomainTerm.get(`${owner}:${term.toLowerCase()}`);
+            if (ownerTermId === undefined) {
+                inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: cross_domain_terms entry "${term}" owner "${owner}" doesn't resolve to a glossary item`);
+                continue;
+            }
+            const referencedByRaw = o["referenced_by"];
+            if (!Array.isArray(referencedByRaw))
+                continue;
+            for (const refDomain of referencedByRaw) {
+                const domain = String(refDomain ?? "").trim();
+                if (domain === "")
+                    continue;
+                const referencerId = inputs.idByDomainTerm.get(`${domain}:${term.toLowerCase()}`);
+                if (referencerId === undefined) {
+                    // Domain doesn't have its own glossary entry for the term — note
+                    // this and skip (no edge can resolve when source is unknown).
+                    inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: cross_domain_terms entry "${term}" referencer "${domain}" has no domain-local glossary item — edge skipped`);
+                    continue;
+                }
+                emitXref(referencerId, ownerTermId, "references");
+            }
+        }
+    }
+    // Walkers 4 + 5 — models[].entities[] (forward-method supersedes + entity-mapping).
+    const modelsRaw = obj["models"];
+    if (Array.isArray(modelsRaw)) {
+        // First pass: index all entities by name for supersedes resolution.
+        const entityByName = new Map();
+        for (const m of modelsRaw) {
+            if (!m || typeof m !== "object")
+                continue;
+            const mObj = m;
+            const domain = String(mObj["domain"] ?? "").trim();
+            const entitiesRaw = mObj["entities"];
+            if (!Array.isArray(entitiesRaw))
+                continue;
+            for (const e of entitiesRaw) {
+                if (!e || typeof e !== "object")
+                    continue;
+                const eObj = e;
+                const name = String(eObj["name"] ?? "").trim();
+                const glossaryTerm = String(eObj["glossary_term"] ?? "").trim();
+                if (name === "" || glossaryTerm === "")
+                    continue;
+                // First-seen wins; cross-domain entries don't overwrite. Used only
+                // by supersedes walker for back-link resolution.
+                if (!entityByName.has(name)) {
+                    entityByName.set(name, { domain, glossaryTerm });
+                }
+            }
+        }
+        // Second pass: emit entity_glossary + supersedes edges.
+        for (const m of modelsRaw) {
+            if (!m || typeof m !== "object")
+                continue;
+            const mObj = m;
+            const domain = String(mObj["domain"] ?? "").trim();
+            const entitiesRaw = mObj["entities"];
+            if (!Array.isArray(entitiesRaw))
+                continue;
+            for (const e of entitiesRaw) {
+                if (!e || typeof e !== "object")
+                    continue;
+                const eObj = e;
+                const name = String(eObj["name"] ?? "").trim();
+                const status = String(eObj["status"] ?? "").trim();
+                const glossaryTerm = String(eObj["glossary_term"] ?? "").trim();
+                if (status === "superseded") {
+                    const supersededBy = String(eObj["superseded_by"] ?? "").trim();
+                    if (supersededBy === "") {
+                        inputs.findings.add("coverage", `${MANIFEST_REL_PATH}: superseded marker on ${name} has no superseded_by field`);
+                        continue;
+                    }
+                    if (glossaryTerm === "") {
+                        inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: supersedes edge can't emit — ${name} has no glossary_term`);
+                        continue;
+                    }
+                    const sourceId = inputs.idByDomainTerm.get(`${domain}:${glossaryTerm.toLowerCase()}`)
+                        ?? resolveTermByName(glossaryTerm, inputs);
+                    const targetEntity = entityByName.get(supersededBy);
+                    const targetId = targetEntity === undefined
+                        ? undefined
+                        : inputs.idByDomainTerm.get(`${targetEntity.domain}:${targetEntity.glossaryTerm.toLowerCase()}`)
+                            ?? resolveTermByName(targetEntity.glossaryTerm, inputs);
+                    if (sourceId === undefined) {
+                        inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: supersedes edge can't emit — source "${glossaryTerm}" doesn't resolve to a glossary item`);
+                        continue;
+                    }
+                    if (targetId === undefined) {
+                        inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: supersedes edge can't emit — target "${supersededBy}" (→ glossary "${targetEntity?.glossaryTerm ?? "?"}") doesn't resolve to a glossary item`);
+                        continue;
+                    }
+                    emitXref(sourceId, targetId, "supersedes");
+                    continue;
+                }
+                if ((status === "aligned" || status === "matched_direct") && glossaryTerm !== "") {
+                    // Entity-mapping walker writes to entity_glossary.csv.
+                    if (domain === "" || !inputs.knownDomainIds.has(domain)) {
+                        // Domain not in this SDD's domains.csv — likely "platform-wide"
+                        // or another scope identifier. Skip with a coverage finding.
+                        inputs.findings.add("coverage", `${MANIFEST_REL_PATH}: entity ${name} domain "${domain}" not in known domains — entity_glossary row skipped`);
+                        continue;
+                    }
+                    const glossaryItemId = inputs.idByDomainTerm.get(`${domain}:${glossaryTerm.toLowerCase()}`)
+                        ?? resolveTermByName(glossaryTerm, inputs);
+                    if (glossaryItemId === undefined) {
+                        inputs.findings.add("orphan", `${MANIFEST_REL_PATH}: entity ${name} glossary_term "${glossaryTerm}" doesn't resolve to a glossary item — entity_glossary row skipped`);
+                        continue;
+                    }
+                    const entityNameSlug = slugify(name);
+                    const id = `${domain}__${entityNameSlug}__${glossaryItemId}`;
+                    const existing = entitySeen.get(id);
+                    if (existing !== undefined) {
+                        // Dedup: matched_direct wins over aligned; same status = no-op;
+                        // conflicting statuses fire divergence finding.
+                        const existingStatus = String(existing["status"]);
+                        if (existingStatus === status)
+                            continue;
+                        const winner = status === "matched_direct" ? status : existingStatus;
+                        if (existingStatus !== winner) {
+                            entitySeen.set(id, {
+                                ...existing,
+                                status: winner,
+                            });
+                        }
+                        inputs.findings.add("divergence", `${MANIFEST_REL_PATH}: entity ${name} in domain ${domain} has conflicting statuses across models (${existingStatus} vs ${status}) — keeping ${winner} (per ADR 0158)`);
+                        continue;
+                    }
+                    const row = {
+                        id,
+                        domain_id: domain,
+                        entity_name: name,
+                        glossary_item_id: glossaryItemId,
+                        status,
+                        source_sdd_id: "",
+                    };
+                    entitySeen.set(id, row);
+                }
+                // status: missing or other → no edge emitted.
+            }
+        }
+        // Realise the deduplicated entity_glossary rows.
+        entityRows.push(...entitySeen.values());
+    }
+    // Surface a single convention finding when the manifest is present but
+    // zero walkers produced output. Older builders emitted this; preserved
+    // for adopters whose manifest sits in an entirely-unsupported shape.
+    if (xrefRows.length === 0 && entityRows.length === 0) {
+        const hasAnyKnownKey = "aliases" in obj
+            || "conflicts" in obj
+            || "conflicts_with" in obj
+            || "cross_domain_terms" in obj
+            || "models" in obj;
+        if (!hasAnyKnownKey) {
+            inputs.findings.add("convention", `${MANIFEST_REL_PATH}: present but no recognised top-level keys (aliases/conflicts/cross_domain_terms/models) — emitting 0 xref rows (per ADR 0158)`);
+        }
+    }
+    return { glossaryXref: xrefRows, entityGlossary: entityRows };
+}
+function collectPairs(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const o = item;
+        const source = String(o["source"] ?? o["source_id"] ?? "").trim();
+        const target = String(o["target"] ?? o["target_id"] ?? "").trim();
+        if (source !== "" && target !== "")
+            out.push({ source, target });
+    }
+    return out;
+}
+function resolveTerm(raw, inputs) {
+    // Direct id (e.g. "asset-vehicle")
+    if (inputs.knownGlossaryIds.has(raw))
+        return raw;
+    // domain:term lookup
+    const colonIdx = raw.indexOf(":");
+    if (colonIdx > 0) {
+        const domain = raw.slice(0, colonIdx).trim().toLowerCase();
+        const term = raw.slice(colonIdx + 1).trim().toLowerCase();
+        return inputs.idByDomainTerm.get(`${domain}:${term}`);
+    }
+    return undefined;
+}
+function resolveTermByName(term, inputs) {
+    // Match term names case-insensitively against the (domain, term) index.
+    const needle = term.toLowerCase();
+    for (const [key, id] of inputs.idByDomainTerm) {
+        const colonIdx = key.indexOf(":");
+        if (colonIdx <= 0)
+            continue;
+        const keyTerm = key.slice(colonIdx + 1);
+        if (keyTerm === needle)
+            return id;
+    }
+    return undefined;
+}
+function slugify(s) {
+    return s
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+//# sourceMappingURL=glossary-xref.js.map

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

@@ -0,0 +1,204 @@
+// Glossary discoverer — emits `glossary_items.csv` rows from
+// `docs/domains/<domain>/architecture/glossary.md` "## Owned Terms"
+// tables.
+//
+// Convention (per the catalogue-metamodel.md + an adopter platform's
+// existing layout):
+//   ## Owned Terms
+//
+//   | Term | Definition | Notes |
+//   |------|------------|-------|
+//   | <term> | <definition> | <optional notes> |
+//
+// Borrowed terms and deprecated-terms tables are intentionally NOT
+// emitted — borrowed terms reference a canonical entry in another
+// domain (which is already captured by that domain's Owned Terms),
+// and deprecated terms are migration noise.
+//
+// Item id: `<domain>-<slug>` so terms in different domains can reuse
+// the same word without collision.
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+const DOMAINS_DIR_REL = join("docs", "domains");
+const SECTION_HEADING_RE = /^##\s+(Owned|Borrowed|Deprecated)\s+Terms?\s*$/i;
+export async function buildGlossaryItems(inputs) {
+    const rows = [];
+    const idByDomainTerm = new Map();
+    const seen = new Set();
+    const glossaryFiles = await collectGlossaryFiles(inputs.sddPath);
+    for (const path of glossaryFiles) {
+        const relPath = relative(inputs.sddPath, path);
+        const domain = inferDomainFromPath(relPath);
+        if (domain === "")
+            continue;
+        if (!inputs.knownDomainIds.has(domain)) {
+            inputs.findings.add("orphan", `${relPath}: glossary path implies domain "${domain}" but no docs/domains/${domain}/ exists`);
+            continue;
+        }
+        const text = await readFile(path, "utf-8");
+        const ownedTerms = extractOwnedTerms(text);
+        for (const { term, definition, notes } of ownedTerms) {
+            const slug = slugify(term);
+            if (slug === "")
+                continue;
+            const id = `${domain}-${slug}`;
+            if (seen.has(id)) {
+                inputs.findings.add("divergence", `${relPath}: glossary item "${id}" already emitted (term="${term}")`);
+                continue;
+            }
+            seen.add(id);
+            rows.push({
+                id,
+                term,
+                definition,
+                owning_domain_id: domain,
+                canonical_term_id: "",
+                aliases: "",
+                evidence: "",
+                notes,
+                source_sdd_id: "",
+            });
+            idByDomainTerm.set(`${domain}:${term.toLowerCase()}`, id);
+        }
+    }
+    return { rows, idByDomainTerm };
+}
+/**
+ * Backfill `canonical_term_id` + `aliases` on glossary_items rows from the
+ * glossary_xref edges (computed downstream from the same alignment manifest).
+ *
+ * An `alias-of` / `references` edge means source_id is an alias/borrowing of
+ * the canonical target_id, so:
+ *   - the alias/referencing row gets `canonical_term_id = target_id`;
+ *   - the canonical row collects the alias term names into `aliases`
+ *     (';'-separated, per schema).
+ *
+ * Most cross_domain_terms `referenced_by` entries don't resolve (the
+ * referencing domain has no own glossary row for the borrowed term — that's
+ * conceptual borrowing, not a duplicated entry), so only the genuinely-
+ * duplicated terms populate. That small count is the real data floor, not a
+ * gap (see source-gaps-backlog G-02).
+ */
+export function backfillGlossaryRelations(rows, xrefRows) {
+    const termById = new Map(rows.map((r) => [String(r["id"]), String(r["term"])]));
+    const canonicalByAlias = new Map();
+    const aliasTermsByCanonical = new Map();
+    for (const x of xrefRows) {
+        const relation = String(x["relation"]);
+        if (relation !== "alias-of" && relation !== "references")
+            continue;
+        const aliasId = String(x["source_id"]);
+        const canonicalId = String(x["target_id"]);
+        if (aliasId === "" || canonicalId === "" || aliasId === canonicalId)
+            continue;
+        if (!canonicalByAlias.has(aliasId))
+            canonicalByAlias.set(aliasId, canonicalId);
+        const aliasTerm = termById.get(aliasId);
+        if (aliasTerm) {
+            const list = aliasTermsByCanonical.get(canonicalId) ?? [];
+            if (!list.includes(aliasTerm))
+                list.push(aliasTerm);
+            aliasTermsByCanonical.set(canonicalId, list);
+        }
+    }
+    if (canonicalByAlias.size === 0 && aliasTermsByCanonical.size === 0) {
+        return [...rows];
+    }
+    return rows.map((r) => {
+        const id = String(r["id"]);
+        const canonical = canonicalByAlias.get(id);
+        const aliasTerms = aliasTermsByCanonical.get(id);
+        if (canonical === undefined && aliasTerms === undefined)
+            return r;
+        return {
+            ...r,
+            ...(canonical !== undefined ? { canonical_term_id: canonical } : {}),
+            ...(aliasTerms !== undefined ? { aliases: aliasTerms.join(";") } : {}),
+        };
+    });
+}
+function extractOwnedTerms(text) {
+    const out = [];
+    let inOwnedSection = false;
+    let sawHeader = false;
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trimEnd();
+        const heading = SECTION_HEADING_RE.exec(line.trim());
+        if (heading) {
+            inOwnedSection = (heading[1] ?? "").toLowerCase() === "owned";
+            sawHeader = false;
+            continue;
+        }
+        if (!inOwnedSection)
+            continue;
+        // Header row: `| Term | Definition | ... |`
+        if (/^\s*\|\s*Term\b/i.test(line)) {
+            sawHeader = true;
+            continue;
+        }
+        // Separator row: `|---|---|...`
+        if (/^\s*\|[\s-:|]+\|\s*$/.test(line))
+            continue;
+        if (!sawHeader)
+            continue;
+        if (!line.trim().startsWith("|"))
+            continue;
+        const cells = splitTableRow(line);
+        if (cells.length < 2 || cells[0] === "")
+            continue;
+        out.push({
+            term: cells[0] ?? "",
+            definition: cells[1] ?? "",
+            notes: cells[2] ?? "",
+        });
+    }
+    return out;
+}
+function splitTableRow(line) {
+    // Trim outer pipes, split on |, strip cells. Doesn't try to handle
+    // escaped pipes — adopter convention says: avoid raw | in cells, use
+    // "or" instead. We honour that.
+    const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+    return trimmed.split("|").map((c) => c.trim());
+}
+async function collectGlossaryFiles(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 path = join(domainsDir, d.name, "architecture", "glossary.md");
+        try {
+            await readFile(path, "utf-8");
+            out.push(path);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "ENOENT")
+                throw err;
+        }
+    }
+    return out.sort();
+}
+function inferDomainFromPath(relPath) {
+    const parts = relPath.split(sep);
+    const idx = parts.indexOf("domains");
+    if (idx === -1 || idx + 1 >= parts.length)
+        return "";
+    return parts[idx + 1] ?? "";
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/&/g, " and ")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+//# sourceMappingURL=glossary.js.map