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

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

@@ -0,0 +1,181 @@
+// Integrations discoverer — emits `integrations.csv` rows from an
+// integration-product SDD's `integration-manifest.yaml`.
+//
+// Per ADR 0134 federation: each integration-provider SDD owns one row
+// in the granular integrations.csv. The aggregator merges siblings.
+//
+// Per ADR 0144 (schema 2.6.0): if the manifest declares an optional
+// `sub_integrations:` array (multi-provider monolith pattern), emit
+// one additional row per entry with parent_product_id set to the
+// SDD's integrationId. The umbrella SDD row stays unchanged.
+//
+// Profile gating: only integration-product profile SDDs emit. Other
+// profiles are no-ops.
+//
+// Umbrella row:
+//   id    = integrationId from the manifest (or sdd_id as fallback).
+//   name  = providerName (or title-cased id).
+//   category = profileType (open enum per schema description; ecosystems
+//          extend with values like saas-platform, oem, device, ...).
+//   parent_product_id = parentIntegrationProductId (typically empty).
+//   doc_path = "." (SDD root).
+//   repo_count = supplied by the orchestrator from discovered repos.
+//
+// Sub-integration rows (one per entry in sub_integrations:):
+//   id    = entry.id (required; unique within SDD)
+//   name  = entry.providerName (required)
+//   category = entry.category (required)
+//   parent_product_id = the SDD's integrationId (internal FK)
+//   doc_path = SDD's doc_path
+//   repo_count = 0 (repo ownership stays with the umbrella)
+//
+// domain_id is always empty per ADR 0136.
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+const REL_PATH = "integration-manifest.yaml";
+const SubIntegrationSchema = z.object({
+    id: z.string().optional(),
+    providerName: z.string().optional(),
+    category: z.string().optional(),
+});
+const ManifestSchema = z.object({
+    integrationId: z.string().optional(),
+    providerName: z.string().optional(),
+    profileType: z.string().optional(),
+    ingestionPattern: z.string().optional(),
+    invocationPattern: z.string().optional(),
+    patternQualifier: z.string().optional(),
+    parentIntegrationProductId: z.string().optional(),
+    sub_integrations: z.array(SubIntegrationSchema).optional(),
+});
+export async function buildIntegrations(inputs) {
+    if (inputs.profile !== "integration-product")
+        return [];
+    const path = join(inputs.sddPath, REL_PATH);
+    let text;
+    try {
+        text = await readFile(path, "utf-8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+        inputs.findings.add("coverage", `${REL_PATH} not found — emitting empty integrations.csv (integration-product SDD without a manifest)`);
+        return [];
+    }
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        inputs.findings.add("convention", `${REL_PATH}: failed to parse YAML — ${err.message}`);
+        return [];
+    }
+    const parsed = ManifestSchema.safeParse(raw);
+    if (!parsed.success) {
+        inputs.findings.add("convention", `${REL_PATH}: shape violation — ${parsed.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; ")}`);
+        return [];
+    }
+    const id = (parsed.data.integrationId ?? "").trim() || inputs.sddId;
+    const name = (parsed.data.providerName ?? "").trim() || titleCase(id);
+    const category = (parsed.data.profileType ?? "").trim();
+    const parentProductId = (parsed.data.parentIntegrationProductId ?? "").trim();
+    if (category === "") {
+        inputs.findings.add("convention", `${REL_PATH}: missing required \`profileType\` (used as integrations.category)`);
+    }
+    // Reference-exemplar trait (catalogue 2.46.0), derived from the SDD manifest —
+    // see the note on `IntegrationsBuildInputs.exemplar`. Empty is the unmarked
+    // norm; no finding on absence.
+    const exemplar = inputs.exemplar === true ? "true" : "";
+    const sharedLibrary = inputs.sharedLibrary === true ? "true" : "";
+    const rows = [
+        {
+            id,
+            name,
+            domain_id: "",
+            parent_product_id: parentProductId,
+            category,
+            doc_path: ".",
+            repo_count: inputs.repoCount,
+            // Interaction-pattern axis (M-ADR 0171 §4.2/§4.3), catalogued from 2.45.0.
+            // Authorable and gate-validated since the axis landed, but catalogued
+            // nowhere until now — so a declared pattern was invisible to rollups.
+            // SCALAR: §10.5 withdrew §9.3's multi-valued allowance, which is what lets
+            // these be plain columns rather than a join table.
+            ingestion_pattern: (parsed.data.ingestionPattern ?? "").trim(),
+            invocation_pattern: (parsed.data.invocationPattern ?? "").trim(),
+            pattern_qualifier: (parsed.data.patternQualifier ?? "").trim(),
+            exemplar,
+            shared_library: sharedLibrary,
+            source_sdd_id: "",
+        },
+    ];
+    // Per ADR 0144 (schema 2.6.0): emit one row per sub_integration with
+    // parent_product_id = the umbrella SDD's id.
+    const subs = parsed.data.sub_integrations ?? [];
+    const seenSubIds = new Set([id]); // umbrella id is reserved
+    for (let i = 0; i < subs.length; i++) {
+        const sub = subs[i];
+        const subId = (sub.id ?? "").trim();
+        const subName = (sub.providerName ?? "").trim();
+        const subCategory = (sub.category ?? "").trim();
+        const missing = [];
+        if (subId === "")
+            missing.push("id");
+        if (subName === "")
+            missing.push("providerName");
+        if (subCategory === "")
+            missing.push("category");
+        if (missing.length > 0) {
+            inputs.findings.add("convention", `${REL_PATH}: sub_integrations[${i}] missing required field(s): ${missing.join(", ")} — entry skipped`);
+            continue;
+        }
+        if (seenSubIds.has(subId)) {
+            inputs.findings.add("convention", `${REL_PATH}: sub_integrations[${i}] id "${subId}" duplicates an existing id within the SDD — entry skipped (first occurrence wins)`);
+            continue;
+        }
+        seenSubIds.add(subId);
+        rows.push({
+            id: subId,
+            name: subName,
+            domain_id: "",
+            parent_product_id: id,
+            category: subCategory,
+            doc_path: ".",
+            repo_count: 0,
+            // Deliberately empty on a sub_integrations row: the patterns are declared
+            // once at SDD level, and copying the umbrella's onto each sub-row would
+            // assert a per-provider mechanism the manifest never stated. Per-component
+            // patterns live in `integration_component`.
+            ingestion_pattern: "",
+            invocation_pattern: "",
+            pattern_qualifier: "",
+            // INHERITED, and deliberately the opposite treatment to the three pattern
+            // columns directly above. Do not "fix" this to match them. A pattern is a
+            // MECHANISM — how this integration acquires data — which is genuinely one
+            // per SDD. `exemplar` is a REALITY STATUS, and it propagates: if the SDD is
+            // a demonstration then every provider relationship it declares is a
+            // demonstration. For a multi-provider monolith the sub rows ARE the
+            // integrations a consumer counts (the umbrella row is the SDD container), so
+            // leaving them empty would flag the container while counting its
+            // demonstration providers as real — the exact rollup overcount this column
+            // exists to fix, reproduced one level down.
+            // Accepted trade: a real SDD with one demonstration sub-provider cannot be
+            // expressed. That state should not exist — it is a modelling error, not a
+            // legitimate shape — so per-entry declaration would buy expressiveness
+            // nobody needs.
+            exemplar,
+            shared_library: sharedLibrary,
+            source_sdd_id: "",
+        });
+    }
+    return rows;
+}
+function titleCase(slug) {
+    return slug
+        .split("-")
+        .map((p) => (p.length === 0 ? p : p[0].toUpperCase() + p.slice(1)))
+        .join(" ");
+}
+//# sourceMappingURL=integrations.js.map

package/dist/lib/catalogue/builders/persona-c4system.js

@@ -0,0 +1,149 @@
+// persona_c4system edge builder — emits one row per `Person(...)` actor on
+// the L1 context diagram that maps to a known persona (per ADR 0155). This
+// captures the C4 "Person uses System" relationship; the C4 Person
+// abstraction reuses the existing Persona entity rather than a parallel one.
+//
+// Resolution: `Person(id, "name", "desc")` actors are matched to personas
+// rows by name (case-insensitive) then by name-slug, using the maps the
+// personas builder produces. Unmatched actors log a `coverage` finding and
+// are skipped (no dangling FK). The optional interaction label comes from a
+// `Rel(person, system, "label")` line.
+//
+// `Person_Ext(...)` is discriminated by EVIDENCE, not notation (F10; F9's
+// first fix keyed on notation and broke the external-human case): the
+// notation is idiomatic both for a non-human external actor (a device) and
+// for a human legitimately outside the boundary. Whether a persona row
+// resolves is the declaration of humanity — a Person_Ext that resolves
+// emits its edge; one that doesn't is silent (a device is not an authoring
+// gap, and a typo'd human still surfaces through F8's reverse finding on
+// the edgeless persona row).
+//
+// `Person(...)` asserts a human, so an unresolved one stays a forward
+// coverage finding.
+//
+// Both directions report (F8, M-ADR 0157 parity + M-ADR 0133 §4.2c
+// no-silent-drop): a Person with no persona row is a coverage finding
+// (forward), and a persona with no edge is a coverage finding stating WHY —
+// no system row, no identity-sourcing L1, no Person actors, or no actor
+// naming it (reverse). Every persona ends the build with an edge or a
+// finding.
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveIdentityL1 } from "./c4-l1-candidates.js";
+// `Person(id, "name", "desc")` / `Person_Ext(id, "name", "desc")` — the
+// _Ext capture drives the evidence discriminator (F10; see header).
+const PERSON_RE = /Person(_Ext)?\s*\(\s*(\w+)\s*,\s*"([^"]+)"\s*(?:,\s*"([^"]*)")?\s*\)/;
+const REL_RE = /^(?:Bi)?Rel(?:_[A-Za-z]+)?\s*\(\s*(\w+)\s*,\s*(\w+)\s*(?:,\s*"([^"]*)")?/;
+export async function buildPersonaC4System(inputs) {
+    const allPersonaIds = new Set([
+        ...inputs.personaIdByName.values(),
+        ...inputs.personaIdBySlug.values(),
+    ]);
+    const none = new Set();
+    const systemId = inputs.manifest.c4SystemId ?? `${inputs.manifest.sddId}-system`;
+    if (!inputs.knownSystemIds.has(systemId)) {
+        reportEdgeless(allPersonaIds, none, "the SDD emits no c4_systems row", inputs.findings);
+        return [];
+    }
+    const content = await readL1(inputs.sddPath, inputs.manifest.category === "platform-root");
+    if (content === "") {
+        reportEdgeless(allPersonaIds, none, "no identity-sourcing L1 diagram (M-ADR 0189 §4.5)", inputs.findings);
+        return [];
+    }
+    const persons = parsePersons(content);
+    if (persons.length === 0) {
+        reportEdgeless(allPersonaIds, none, "the L1 declares no Person actors", inputs.findings);
+        return [];
+    }
+    const interactionByEntryId = relInteractionsTo(content, systemId);
+    const rows = [];
+    const seen = new Set();
+    const linked = new Set();
+    for (const person of persons) {
+        const personaId = inputs.personaIdByName.get(person.name.toLowerCase()) ??
+            inputs.personaIdBySlug.get(slugify(person.name));
+        if (personaId === undefined) {
+            // Person_Ext with no persona row: a device or other non-human external
+            // actor — silence is correct, and a typo'd human surfaces through the
+            // reverse finding on its edgeless persona row (F10).
+            if (person.external)
+                continue;
+            inputs.findings.add("coverage", `persona_c4system: Person "${person.name}" on the L1 diagram has no matching persona row — edge skipped`);
+            continue;
+        }
+        const id = `${personaId}__${systemId}`;
+        linked.add(personaId);
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        rows.push({
+            id,
+            persona_id: personaId,
+            c4_system_id: systemId,
+            interaction: interactionByEntryId.get(person.entryId) ?? "",
+        });
+    }
+    reportEdgeless(allPersonaIds, linked, "no Person actor on the L1 names it", inputs.findings);
+    rows.sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+    return rows;
+}
+// F8 — the reverse direction (M-ADR 0157 parity): every persona that ends
+// the build without an edge is reported, with the reason. A persona with
+// neither an edge nor a finding is indistinguishable from one that was
+// never considered.
+function reportEdgeless(allPersonaIds, linked, reason, findings) {
+    const edgeless = [...allPersonaIds]
+        .filter((id) => !linked.has(id))
+        .sort((a, b) => a.localeCompare(b));
+    for (const id of edgeless) {
+        findings.add("coverage", `persona_c4system: persona "${id}" has no c4system edge — ${reason}`);
+    }
+}
+function parsePersons(content) {
+    const out = [];
+    for (const raw of content.split(/\r?\n/)) {
+        const m = PERSON_RE.exec(raw.trim());
+        if (m) {
+            out.push({
+                entryId: m[2] ?? "",
+                name: m[3] ?? "",
+                external: m[1] === "_Ext",
+            });
+        }
+    }
+    return out;
+}
+// Map a person entry-id → the label of a Rel connecting it to the system.
+function relInteractionsTo(content, systemId) {
+    const out = new Map();
+    // The system's diagram entry-id is unknown here, so we accept any Rel
+    // whose `from` is a person and keep its label; the common L1 shape is
+    // `Rel(personEntryId, appSystem, "Uses", ...)`.
+    void systemId;
+    for (const raw of content.split(/\r?\n/)) {
+        const m = REL_RE.exec(raw.trim());
+        if (m && m[3]) {
+            const from = m[1] ?? "";
+            if (!out.has(from))
+                out.set(from, m[3]);
+        }
+    }
+    return out;
+}
+// Identity-sourcing L1 only (M-ADR 0189 §4.5): a sibling with no own L1
+// contributes no persona edges rather than matching the platform's personas
+// off the syndicated copy.
+async function readL1(sddPath, isPlatformRoot) {
+    const resolved = await resolveIdentityL1(sddPath, isPlatformRoot);
+    if (resolved.path === "")
+        return "";
+    return await readFile(join(sddPath, resolved.path), "utf-8");
+}
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .replace(/\s*\([^)]+\)/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+//# sourceMappingURL=persona-c4system.js.map

package/dist/lib/catalogue/builders/persona-container.js

@@ -0,0 +1,133 @@
+// persona_container edge builder — M-ADR 0189 F26 §3 (schema 2.34.0).
+//
+// The L2-granularity companion to persona_c4system: a Rel(...) between a
+// Person and a container had no catalogue and, until F26, no finding —
+// eleven of one estate's L2s and the bulk of another's 81 unroutable Rels
+// were exactly this class. F26 made the silence loud; this gives the
+// loudness a destination.
+//
+// Person entries are file-local (a Person declared in the same diagram as
+// the Rel); containers resolve SDD-wide (F20's rule). Either Rel direction
+// normalises to persona→container. A Person that matches no persona row is
+// a coverage finding, never a silent skip (the persona_c4system precedent).
+// The syndicated platform L1 is skipped for non-root SDDs (F14); parallel
+// labels concatenate loudly (F25).
+import { readFile } from "node:fs/promises";
+import { collectC4DiagramFiles } from "./c4-external-systems.js";
+import { mergeEdgeLabel } from "./edge-label-merge.js";
+const REL_RE = /^(?:Bi)?Rel(?:_[A-Za-z]+)?\s*\(\s*(\w+)\s*,\s*(\w+)\s*(?:,\s*"([^"]*)")?/;
+const PERSON_DECL_RE = /Person(?:_Ext)?\s*\(\s*(\w+)\s*,\s*"([^"]+)"/;
+export async function buildPersonaContainer(inputs) {
+    if (inputs.containerIdByEntryId.size === 0)
+        return [];
+    const isRoot = inputs.manifest.category === "platform-root";
+    const files = await collectC4DiagramFiles(inputs.sddPath);
+    const rows = [];
+    const rowsById = new Map();
+    for (const { abs, syndicated } of files) {
+        if (syndicated && !isRoot)
+            continue;
+        const content = await readFile(abs, "utf-8");
+        const personNameByEntry = new Map();
+        for (const raw of content.split(/\r?\n/)) {
+            const pm = PERSON_DECL_RE.exec(raw.trim());
+            if (pm && !personNameByEntry.has(pm[1] ?? "")) {
+                personNameByEntry.set(pm[1] ?? "", pm[2] ?? "");
+            }
+        }
+        if (personNameByEntry.size === 0)
+            continue;
+        // F31: only the SDD's OWN system entry is persona_c4system's domain —
+        // that catalogue emits one edge per persona to THE system, nothing
+        // else. The 0.89.0 skip silenced person Rels to ANY System(...) entry,
+        // a silence delegated to a catalogue that never held those edges
+        // (F5's shape, one tier over): four of an estate's best-authored
+        // persona edges vanished, while the same file's person→external edge
+        // was announced. Own entry = the first System(...) line, mirroring
+        // c4-systems' parseSystemLine; every other target takes exits 1/3/4.
+        let ownSystemEntry = "";
+        for (const raw of content.split(/\r?\n/)) {
+            const sm = /^System\s*\(\s*(\w+)\s*,/.exec(raw.trim());
+            if (sm) {
+                ownSystemEntry = sm[1] ?? "";
+                break;
+            }
+        }
+        for (const raw of content.split(/\r?\n/)) {
+            const m = REL_RE.exec(raw.trim());
+            if (!m)
+                continue;
+            const [, fromEntry, toEntry, label] = m;
+            // F29/F30 — the person tier's exits, designed once. Identify the
+            // person endpoint (file-local; container resolution wins on a
+            // dual-use id per F20), then route by the OTHER endpoint's kind:
+            //   local container      → persona_container row
+            //   own System(...)      → persona_c4system's domain; silent here
+            //   external             → announced skip (F30): a human using an
+            //                          external system has no persona-tier
+            //                          catalogue YET — it must never transmute
+            //                          into sed/ssd, whose semantics are runtime
+            //                          calls between software
+            //   anything else        → announced skip (F29): claimed by no
+            //                          catalogue is said, never silent
+            const fromIsContainer = inputs.containerIdByEntryId.has(fromEntry ?? "");
+            const toIsContainer = inputs.containerIdByEntryId.has(toEntry ?? "");
+            let personEntry;
+            let targetEntry;
+            let targetContainer;
+            if (!fromIsContainer && personNameByEntry.has(fromEntry ?? "")) {
+                personEntry = fromEntry;
+                targetEntry = toEntry;
+                targetContainer = toIsContainer ? inputs.containerIdByEntryId.get(toEntry ?? "") : undefined;
+            }
+            else if (!toIsContainer && personNameByEntry.has(toEntry ?? "")) {
+                personEntry = toEntry;
+                targetEntry = fromEntry;
+                targetContainer = fromIsContainer ? inputs.containerIdByEntryId.get(fromEntry ?? "") : undefined;
+            }
+            else {
+                continue;
+            }
+            if (ownSystemEntry !== "" && targetEntry === ownSystemEntry)
+                continue;
+            const personName = personNameByEntry.get(personEntry ?? "") ?? "";
+            const personaId = inputs.personaIdByName.get(personName.toLowerCase()) ??
+                inputs.personaIdBySlug.get(slugify(personName));
+            if (personaId === undefined) {
+                inputs.findings.add("coverage", `persona_container: Person "${personName}" on an L2 diagram has no matching persona row — edge skipped`);
+                continue;
+            }
+            if (targetContainer === undefined) {
+                const isExternal = inputs.externalIdByEntryId?.has(targetEntry ?? "") ?? false;
+                inputs.findings.add("coverage", isExternal
+                    ? `persona_container: persona "${personaId}" → external "${inputs.externalIdByEntryId.get(targetEntry ?? "")}"${label ? ` ("${label}")` : ""} — a human using an external system has no persona-tier catalogue; skipped, never transmuted into a system edge (F30)`
+                    : `persona_container: persona "${personaId}" → "${targetEntry}"${label ? ` ("${label}")` : ""} resolves to no container — claimed by no catalogue; skipped (F29)`);
+                continue;
+            }
+            const id = `${personaId}__${targetContainer}`;
+            const existing = rowsById.get(id);
+            if (existing !== undefined) {
+                mergeEdgeLabel(existing, label ?? "", "persona_container", inputs.findings);
+                continue;
+            }
+            const row = {
+                id,
+                persona_id: personaId,
+                container_id: targetContainer,
+                interaction: label ?? "",
+            };
+            rowsById.set(id, row);
+            rows.push(row);
+        }
+    }
+    rows.sort((a, b) => String(a["id"]).localeCompare(String(b["id"])));
+    return rows;
+}
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .replace(/\s*\([^)]+\)/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+//# sourceMappingURL=persona-container.js.map

package/dist/lib/catalogue/builders/persona-journey-edges.js

@@ -0,0 +1,133 @@
+// Persona/journey edge builders — emit:
+//   - persona_journey  (persona ↔ journey, role: primary | handoff | supporting)
+//   - persona_feature  (persona ↔ feature, from `## Related Features` in persona files)
+//   - journey_feature  (journey ↔ feature, from `**Feature:**` link or
+//                       `## Related Features` in journey files)
+//
+// Resolution rules:
+//   - Persona references in journeys are free-text (e.g. "Fleet Manager")
+//     because the persona convention doesn't enforce slug references. We
+//     resolve by name match (case-insensitive) against the personas index;
+//     unresolved entries log `[finding] orphan` and are skipped.
+//   - Feature references resolve via the path index from the features
+//     builder when the journey/persona uses a markdown link, OR via slug
+//     match against the feature id namespace ({capability_id}-{slug}).
+//   - "X → Y (handoff)" in primary_persona triggers a handoff role for Y
+//     against the same journey. The "primary" role goes to X.
+export function buildPersonaJourney(inputs) {
+    const rows = [];
+    const seen = new Set();
+    for (const [journeyId, primaryRaw] of inputs.journeyPrimaryPersonaById) {
+        const { primary, handoff } = splitHandoff(primaryRaw);
+        if (primary !== "") {
+            addEdge(inputs, rows, seen, journeyId, primary, "primary");
+        }
+        if (handoff !== "") {
+            addEdge(inputs, rows, seen, journeyId, handoff, "handoff");
+        }
+        const supporting = inputs.journeySupportingPersonasById.get(journeyId) ?? [];
+        for (const name of supporting) {
+            addEdge(inputs, rows, seen, journeyId, name, "supporting");
+        }
+    }
+    return rows;
+}
+function addEdge(inputs, rows, seen, journeyId, personaName, role) {
+    const personaId = resolvePersona(inputs.personaIdByName, inputs.personaIdBySlug, personaName);
+    if (personaId === undefined) {
+        inputs.findings.add("orphan", `persona_journey: journey ${journeyId} references persona "${personaName}" — no matching personas/<slug>.md`);
+        return;
+    }
+    const id = `${personaId}__${journeyId}__${role}`;
+    if (seen.has(id))
+        return;
+    seen.add(id);
+    rows.push({
+        id,
+        persona_id: personaId,
+        journey_id: journeyId,
+        role,
+    });
+}
+function resolvePersona(byName, bySlug, raw) {
+    const trimmed = raw.trim();
+    if (trimmed === "")
+        return undefined;
+    const byNameHit = byName.get(trimmed.toLowerCase());
+    if (byNameHit !== undefined)
+        return byNameHit;
+    // Try slugified form: "Fleet Manager" → "fleet-manager".
+    const slug = trimmed
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return bySlug.get(slug);
+}
+function splitHandoff(raw) {
+    // Pattern: `X → Y (handoff)` or `X -> Y (handoff)`.
+    const m = /^(.+?)\s*(?:→|->)\s*(.+?)\s*\(handoff\)\s*$/i.exec(raw.trim());
+    if (m)
+        return { primary: (m[1] ?? "").trim(), handoff: (m[2] ?? "").trim() };
+    return { primary: raw.trim(), handoff: "" };
+}
+export function buildPersonaFeature(inputs) {
+    return buildEdgesByFeatureRef({
+        findings: inputs.findings,
+        leftKey: "persona_id",
+        leftIdToRefs: inputs.relatedFeaturesById,
+        leftIdToPaths: new Map(),
+        featureIdByPath: inputs.featureIdByPath,
+        featureIdBySlug: inputs.featureIdBySlug,
+        edgeName: "persona_feature",
+    });
+}
+export function buildJourneyFeature(inputs) {
+    return buildEdgesByFeatureRef({
+        findings: inputs.findings,
+        leftKey: "journey_id",
+        leftIdToRefs: inputs.journeyRelatedFeatureSlugsById,
+        leftIdToPaths: inputs.journeyFeaturePathsById,
+        featureIdByPath: inputs.featureIdByPath,
+        featureIdBySlug: inputs.featureIdBySlug,
+        edgeName: "journey_feature",
+    });
+}
+function buildEdgesByFeatureRef(inputs) {
+    const rows = [];
+    const seen = new Set();
+    const addRow = (leftId, featureId) => {
+        const id = `${leftId}__${featureId}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        rows.push({
+            id,
+            [inputs.leftKey]: leftId,
+            feature_id: featureId,
+        });
+    };
+    // Path-based references (markdown links to feature spec files).
+    for (const [leftId, paths] of inputs.leftIdToPaths) {
+        for (const path of paths) {
+            const featureId = inputs.featureIdByPath.get(path);
+            if (featureId === undefined) {
+                inputs.findings.add("orphan", `${inputs.edgeName}: ${leftId} links to "${path}" — no matching features.csv row`);
+                continue;
+            }
+            addRow(leftId, featureId);
+        }
+    }
+    // Slug-based references (bare bullets in `## Related Features`).
+    for (const [leftId, slugs] of inputs.leftIdToRefs) {
+        for (const slug of slugs) {
+            const featureId = inputs.featureIdBySlug.get(slug);
+            if (featureId === undefined) {
+                inputs.findings.add("orphan", `${inputs.edgeName}: ${leftId} references feature slug "${slug}" — no feature with this slug in features.csv`);
+                continue;
+            }
+            addRow(leftId, featureId);
+        }
+    }
+    return rows;
+}
+//# sourceMappingURL=persona-journey-edges.js.map