@diagrammo/dgmo 0.64.1 → 0.66.0

package/dist/{chunk-KPX2OWZR.js → chunk-YKWHUPBP.js}

@@ -1,28 +1,28 @@
 import {
   renderCollapseBar,
   renderNodeCard
-} from "./chunk-H3HFC3SQ.js";
+} from "./chunk-5GM6BZO7.js";
 import {
   CARD_RADIUS,
   CONTAINER_RADIUS
-} from "./chunk-3CIOJ5YJ.js";
+} from "./chunk-FJ57274M.js";
 import {
   layoutInlineHeader
-} from "./chunk-6VJCURWU.js";
+} from "./chunk-J2EXBAPZ.js";
 import {
   renderIntegratedLegend
-} from "./chunk-RBAW7VUG.js";
+} from "./chunk-2EPV7CLY.js";
 import {
   getLegendExtent,
   getMaxLegendReservedHeight
-} from "./chunk-ES66QH6J.js";
+} from "./chunk-FG24NXKN.js";
 import {
   FONT_FAMILY
-} from "./chunk-Z5ID35YP.js";
+} from "./chunk-UTCPNJND.js";
 import {
   measureText,
   wrapTextToWidth
-} from "./chunk-4ASYQ347.js";
+} from "./chunk-MTGGOCND.js";
 import {
   resolveActiveTagGroup,
   resolveTagColor,
@@ -39,14 +39,12 @@ import {
 import * as d3 from "d3-selection";
 
 // src/sketch/markdown-card.ts
-var BOLD_WIDTH_FACTOR = 1.06;
 var INDENT_PX = 12;
 var BULLET_HANG_PX = 12;
 var ELLIPSIS = "\u2026";
 var BULLET = "\u2022";
 function segWidth(seg, fontSize) {
-  const w = measureText(seg.text, fontSize);
-  return seg.bold ? w * BOLD_WIDTH_FACTOR : w;
+  return measureText(seg.text, fontSize, { bold: seg.bold });
 }
 function parseInline(text) {
   const segments = [];
@@ -287,15 +285,16 @@ var CARD_LABEL_MIN = 11;
 var CARD_META_FONT = 12;
 var CARD_TITLE_MAX = 30;
 function fitWrapped(label, maxWidth, maxFont = CARD_LABEL_MAX, minFont = CARD_LABEL_MIN, maxLines = 2) {
+  const BOLD = { hardBreak: true, bold: true };
   for (let fs = maxFont; fs >= minFont; fs--) {
-    const lines2 = wrapTextToWidth(label, fs, maxWidth, { hardBreak: true });
+    const lines2 = wrapTextToWidth(label, fs, maxWidth, BOLD);
     if (lines2.length <= maxLines) return { lines: lines2, fontSize: fs };
   }
-  const lines = wrapTextToWidth(label, minFont, maxWidth, { hardBreak: true });
+  const lines = wrapTextToWidth(label, minFont, maxWidth, BOLD);
   if (lines.length <= maxLines) return { lines, fontSize: minFont };
   const kept = lines.slice(0, maxLines);
   let last = kept[maxLines - 1];
-  while (last.length > 1 && measureText(`${last}\u2026`, minFont) > maxWidth)
+  while (last.length > 1 && measureText(`${last}\u2026`, minFont, { bold: true }) > maxWidth)
     last = last.slice(0, -1);
   kept[maxLines - 1] = `${last}\u2026`;
   return { lines: kept, fontSize: minFont };
@@ -1128,4 +1127,4 @@ export {
   sketchEdgeGeometry,
   renderSketchForExport
 };
-//# sourceMappingURL=chunk-KPX2OWZR.js.map
+//# sourceMappingURL=chunk-YKWHUPBP.js.map

package/dist/{chunk-FRC4LDTQ.js → chunk-YMYPFX4O.js}

@@ -3,10 +3,10 @@ import {
   layoutJourneyMap,
   scoreToColor,
   scoreToCurveY
-} from "./chunk-KRTO7NRK.js";
+} from "./chunk-D2WHS23S.js";
 import {
   wrapNoteBody
-} from "./chunk-VJARCVMH.js";
+} from "./chunk-MU3CJPJF.js";
 import {
   NOTE_BULLET_INDENT
 } from "./chunk-5DH3KYFH.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-WGC42WJU.js";
 import {
   CARD_RADIUS
-} from "./chunk-3CIOJ5YJ.js";
+} from "./chunk-FJ57274M.js";
 import {
   ScaleContext
 } from "./chunk-YYVTBZZC.js";
@@ -24,15 +24,15 @@ import {
 } from "./chunk-RU2HHHYA.js";
 import {
   renderIntegratedLegend
-} from "./chunk-RBAW7VUG.js";
+} from "./chunk-2EPV7CLY.js";
 import {
   FONT_FAMILY
-} from "./chunk-Z5ID35YP.js";
+} from "./chunk-UTCPNJND.js";
 import {
   measureText,
   truncateText,
   wrapTextToWidth
-} from "./chunk-4ASYQ347.js";
+} from "./chunk-MTGGOCND.js";
 import {
   parseJourneyMap
 } from "./chunk-NSJK7F2V.js";
@@ -65,6 +65,7 @@ var COLUMN_RADIUS = 8;
 var COLUMN_HEADER_HEIGHT = 36;
 var COLUMN_PADDING = 12;
 var FONT_SIZE_TITLE = 18;
+var PERSONA_PANEL_WIDTH = 280;
 var FONT_SIZE_PHASE = 13;
 var FONT_SIZE_STEP = 12;
 var FONT_SIZE_META = 10;
@@ -115,7 +116,16 @@ function renderJourneyMap(container, parsed, palette, isDark, options) {
     if (parsed.titleLineNumber) {
       titleG.attr("data-line-number", parsed.titleLineNumber);
     }
-    titleG.append("text").attr("x", PADDING).attr("y", PADDING + FONT_SIZE_TITLE).attr("font-size", FONT_SIZE_TITLE).attr("font-weight", "bold").attr("fill", palette.text).text(parsed.title);
+    const personaPanelX = parsed.persona ? layout.totalWidth - PADDING - PERSONA_PANEL_WIDTH : layout.totalWidth;
+    const titleMaxW = Math.max(
+      0,
+      Math.min(personaPanelX - PADDING, layout.totalWidth - PADDING) - PADDING
+    );
+    titleG.append("text").attr("x", PADDING).attr("y", PADDING + FONT_SIZE_TITLE).attr("font-size", FONT_SIZE_TITLE).attr("font-weight", "bold").attr("fill", palette.text).text(
+      truncateText(parsed.title, FONT_SIZE_TITLE, titleMaxW, {
+        bold: true
+      })
+    );
     if (onNavigateToLine && parsed.titleLineNumber) {
       titleG.style("cursor", "pointer").on("click", () => {
         onNavigateToLine(parsed.titleLineNumber);
@@ -127,7 +137,7 @@ function renderJourneyMap(container, parsed, palette, isDark, options) {
     const personaG = svg.append("g").attr("class", "journey-persona").attr("data-line-number", parsed.persona.lineNumber);
     const titleRowH = CARD_HEADER_HEIGHT;
     const silhouetteZone = 60;
-    const panelWidth = 280;
+    const panelWidth = PERSONA_PANEL_WIDTH;
     const textAreaWidth = panelWidth - silhouetteZone - CARD_PADDING_X;
     const descLineH = 14;
     const descLines = parsed.persona.description ? wrapNoteBody(parsed.persona.description, textAreaWidth, FONT_SIZE_META) : [];
@@ -164,7 +174,9 @@ function renderJourneyMap(container, parsed, palette, isDark, options) {
       fillMode
     );
     personaG.append("rect").attr("x", panelX).attr("y", panelY).attr("width", panelWidth).attr("height", panelHeight).attr("rx", CARD_RADIUS).attr("fill", "none").attr("stroke", personaColor).attr("stroke-width", CARD_STROKE_WIDTH);
-    personaG.append("text").attr("x", textX).attr("y", panelY + CARD_PADDING_Y + FONT_SIZE_STEP).attr("font-size", FONT_SIZE_STEP).attr("font-weight", "500").attr("fill", onPersonaText).text(parsed.persona.name);
+    personaG.append("text").attr("x", textX).attr("y", panelY + CARD_PADDING_Y + FONT_SIZE_STEP).attr("font-size", FONT_SIZE_STEP).attr("font-weight", "500").attr("fill", onPersonaText).text(
+      truncateText(parsed.persona.name, FONT_SIZE_STEP, textAreaWidth)
+    );
     for (let li = 0; li < descLines.length; li++) {
       const line2 = descLines[li];
       const indent = line2.kind === "plain" ? 0 : NOTE_BULLET_INDENT;
@@ -372,11 +384,11 @@ function renderJourneyMap(container, parsed, palette, isDark, options) {
         palette.textOnFillLight,
         palette.textOnFillDark
       );
-      phaseG.append("text").attr("x", pl.x + COLUMN_PADDING).attr("y", pl.y + COLUMN_HEADER_HEIGHT / 2 + FONT_SIZE_PHASE / 2 - 2).attr("font-size", FONT_SIZE_PHASE).attr("font-weight", "bold").attr("fill", onHeaderText).text(
-        isCollapsed ? truncateText2(
+      phaseG.append("text").attr("x", pl.x + COLUMN_PADDING).attr("y", pl.y + COLUMN_HEADER_HEIGHT / 2).attr("dominant-baseline", "central").attr("font-size", FONT_SIZE_PHASE).attr("font-weight", "bold").attr("fill", onHeaderText).text(
+        isCollapsed ? truncateText(
           pl.phase.name,
-          pl.width - COLUMN_PADDING * 2,
-          FONT_SIZE_PHASE
+          FONT_SIZE_PHASE,
+          pl.width - COLUMN_PADDING * 2
         ) : pl.phase.name
       );
       if (onPhaseToggle) {
@@ -445,7 +457,7 @@ function renderJourneyMap(container, parsed, palette, isDark, options) {
           }
           const textX = listX + CARD_PADDING_X + COLLAPSED_FACE_R * 2 + 6;
           const maxTextW = cardW - CARD_PADDING_X * 2 - COLLAPSED_FACE_R * 2 - 6;
-          itemG.append("text").attr("x", textX).attr("y", itemY + COLLAPSED_CARD_H / 2 + FONT_SIZE_META / 2 - 1).attr("font-size", FONT_SIZE_META).attr("fill", palette.text).text(truncateText2(step.title, maxTextW, FONT_SIZE_META));
+          itemG.append("text").attr("x", textX).attr("y", itemY + COLLAPSED_CARD_H / 2).attr("dominant-baseline", "central").attr("font-size", FONT_SIZE_META).attr("fill", palette.text).text(truncateText(step.title, FONT_SIZE_META, maxTextW));
           if (onNavigateToLine) {
             itemG.style("cursor", "pointer").on("click", (event) => {
               event.stopPropagation();
@@ -540,7 +552,7 @@ function renderJourneyMap(container, parsed, palette, isDark, options) {
       const fcx = parseFloat(faceEl.attr("data-cx") ?? "0");
       const fcy = parseFloat(faceEl.attr("data-cy") ?? "0");
       const score = parseInt(faceEl.attr("data-score") ?? "3", 10);
-      const lines = wrapText(thoughtText, THOUGHT_MAX_W, THOUGHT_FONT);
+      const lines = wrapTextToWidth(thoughtText, THOUGHT_FONT, THOUGHT_MAX_W);
       const textW = Math.min(
         THOUGHT_MAX_W,
         Math.max(...lines.map((l) => measureText(l, THOUGHT_FONT)))
@@ -690,10 +702,10 @@ function renderStepCard(parent, sl, palette, isDark, activeGroup, tagGroups, onN
   }
   let metaY = cy + titleBlockH + CARD_META_LINE_HEIGHT;
   if (sl.step.description) {
-    const descLines = wrapText(
+    const descLines = wrapTextToWidth(
       sl.step.description,
-      sl.width - CARD_PADDING_X * 2,
-      FONT_SIZE_META
+      FONT_SIZE_META,
+      sl.width - CARD_PADDING_X * 2
     );
     for (const line2 of descLines) {
       stepG.append("text").attr("x", cx + CARD_PADDING_X).attr("y", metaY).attr("font-size", FONT_SIZE_META).attr("fill", onCardText).text(line2);
@@ -707,7 +719,7 @@ function renderStepCard(parent, sl, palette, isDark, activeGroup, tagGroups, onN
   for (const anno of cardAnnotations) {
     const annoColor = annotationColor(anno.type, palette);
     const iconPaths = annotationIconPaths(anno.type);
-    const annoLines = wrapText(anno.text, annoTextW, FONT_SIZE_META);
+    const annoLines = wrapTextToWidth(anno.text, FONT_SIZE_META, annoTextW);
     const iconColor = fillMode === "solid" ? onCardText : annoColor;
     renderAnnotationIcon(
       stepG,
@@ -741,7 +753,7 @@ function renderStepCard(parent, sl, palette, isDark, activeGroup, tagGroups, onN
       palette.textOnFillLight,
       palette.textOnFillDark
     );
-    stepG.append("text").attr("x", cx + sl.width / 2).attr("y", stripY + TAG_STRIP_HEIGHT / 2 + FONT_SIZE_META / 2 - 1).attr("text-anchor", "middle").attr("font-size", FONT_SIZE_META).attr("fill", stripTextColor).text(value);
+    stepG.append("text").attr("x", cx + sl.width / 2).attr("y", stripY + TAG_STRIP_HEIGHT / 2).attr("dominant-baseline", "central").attr("text-anchor", "middle").attr("font-size", FONT_SIZE_META).attr("fill", stripTextColor).text(value);
   }
   if (onNavigateToLine) {
     stepG.style("cursor", "pointer").on("click", (event) => {
@@ -791,20 +803,14 @@ var EMOTION_LABEL_MAX_WIDTH = 180;
 var EMOTION_LABEL_FONT_SIZE = FONT_SIZE_META;
 function addEmotionLabel(faceG, pt, palette) {
   if (!pt.emotionLabel) return;
-  const text = truncateText2(
+  const text = truncateText(
     pt.emotionLabel,
-    EMOTION_LABEL_MAX_WIDTH,
-    EMOTION_LABEL_FONT_SIZE
+    EMOTION_LABEL_FONT_SIZE,
+    EMOTION_LABEL_MAX_WIDTH
   );
   const y = pt.y + FACE_RADIUS + 5 + EMOTION_LABEL_FONT_SIZE;
   faceG.append("text").attr("class", "journey-emotion-label").attr("x", pt.x).attr("y", y).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", EMOTION_LABEL_FONT_SIZE).attr("font-weight", 500).attr("fill", palette.text).attr("stroke", palette.bg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.8).attr("paint-order", "stroke").attr("pointer-events", "none").text(text);
 }
-function wrapText(text, maxWidth, fontSize) {
-  return wrapTextToWidth(text, fontSize, maxWidth);
-}
-function truncateText2(text, maxWidth, fontSize) {
-  return truncateText(text, fontSize, maxWidth);
-}
 function annotationColor(type, palette) {
   switch (type) {
     case "pain":
@@ -871,4 +877,4 @@ export {
   renderJourneyMap,
   renderJourneyMapForExport
 };
-//# sourceMappingURL=chunk-FRC4LDTQ.js.map
+//# sourceMappingURL=chunk-YMYPFX4O.js.map

package/dist/cloud-reference.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Live links — the shared resolver (Diagrammo Cloud story 10.6).
+ *
+ * A live link points at a diagram living in Diagrammo Cloud instead of at bytes
+ * pasted into a document. The point of it is CURRENCY: a linked diagram is
+ * never stale, which is true for a team of one and needs no distribution to be
+ * worth having.
+ *
+ * There are three SPELLINGS and exactly ONE parser, because each spelling is
+ * native to where it gets typed:
+ *
+ *   | Surface                | Form                        |
+ *   |------------------------|-----------------------------|
+ *   | docs frameworks        | `live-link abc123` in a fence|
+ *   | Obsidian, desktop app  | `![[live-link:abc123]]`     |
+ *   | anywhere taking a URL  | the plain URL               |
+ *
+ * The keyword was `cloud` until 2026-08-01 (decision #53). `cloud` named where
+ * the thing lives; `live-link` names what it is, and it is the publish dialog's
+ * own phrase, so one word now spans both sides of the exchange. Pre-1.0 there
+ * is no dual-accept window — `cloud abc123` simply stops resolving. The module
+ * and its package subpath keep the old name deliberately: renaming a subpath
+ * export breaks the app's `pnpm dev` while the production build stays green.
+ *
+ * 🔴 EVERY future modifier must land in all three (A9), and
+ * `cloud-reference.test.ts` asserts parity across the forms from ONE table so a
+ * modifier cannot ship into a single spelling. If you are adding a modifier and
+ * only touching one branch below, the tests are about to tell you so.
+ *
+ * A reference ALWAYS FLOATS — it resolves to the current revision, which is the
+ * whole point (a referenced diagram is never stale). A date pin (`@2026-03-12`)
+ * was designed and then dropped on 2026-07-30: the server retains a bounded
+ * number of versions and prunes on every push, so a pin would fail on exactly
+ * the diagrams that are edited most. Anything carrying a modifier therefore
+ * parses to NULL rather than silently floating — a document that asked to be
+ * frozen must not quietly get the latest instead.
+ *
+ * This module is deliberately dependency-free and does no I/O: it is imported by
+ * every wrapper and by the CLI, and a parser that reached the network would make
+ * each of them harder to test than the thing they are testing.
+ */
+/** Default origin of the Cloud API. Overridable for self-host / staging / tests. */
+declare const CLOUD_API_BASE = "https://api.diagrammo.app";
+/** Where human-facing share links live — the URLs people actually copy. */
+declare const CLOUD_APP_BASE = "https://online.diagrammo.app";
+/** A parsed reference. An id, and — for now — deliberately nothing else. */
+interface CloudReference {
+    id: string;
+}
+/**
+ * Parse any of the three spellings, wherever it appears.
+ *
+ * 🔴 **A `dgmo` fence must NOT use this — use `parseCloudReferenceFence`.** The
+ * embed spelling is host markdown, and inside a fence the content is DGMO, so
+ * accepting `![[live-link:<id>]]` there is a category error: markdown nested in
+ * a code fence that is itself in markdown. It was accepted until 2026-08-05 and
+ * the showcase content taught it. Removed rather than deprecated — pre-1.0.
+ *
+ * This union survives for a host scanning raw note text, where any of the three
+ * may legitimately turn up. Returns null for anything that is not a reference,
+ * so it must not throw and must not guess.
+ */
+declare function parseCloudReference(text: string): CloudReference | null;
+/**
+ * What may appear as the whole body of a `dgmo` fence: the keyword form, or a
+ * plain link somebody pasted. **Not** the embed spelling — see above.
+ */
+declare function parseCloudReferenceFence(text: string): CloudReference | null;
+/**
+ * The note spelling — `![[live-link:<id>]]` — which extends the
+ * `![[foo.dgmo]]` transclusion Obsidian and the desktop app already understand.
+ * Takes the text as TYPED, brackets included, because that is the thing being
+ * recognised; a host holding only the inside of the brackets puts them back.
+ */
+declare function parseCloudReferenceEmbed(text: string): CloudReference | null;
+/** The URL spelling, split out because hosts that only take URLs need just this. */
+declare function parseCloudReferenceUrl(text: string): CloudReference | null;
+interface ResolveUrlOptions {
+    /** Origin of the Cloud API. */
+    base?: string;
+}
+/** The URL to fetch a reference's source from. Always the current revision. */
+declare function referenceSourceUrl(ref: CloudReference, options?: ResolveUrlOptions): string;
+/** The human share link for a reference — what a "view this in Diagrammo" link points at. */
+declare function referenceShareUrl(ref: CloudReference, options?: {
+    base?: string;
+}): string;
+/** The shape of a source response, so consumers don't re-declare it per wrapper. */
+interface CloudReferenceSource {
+    id: string;
+    source: string;
+    dgmoVersion: string;
+    updatedAt: number;
+}
+
+export { CLOUD_API_BASE, CLOUD_APP_BASE, type CloudReference, type CloudReferenceSource, type ResolveUrlOptions, parseCloudReference, parseCloudReferenceEmbed, parseCloudReferenceFence, parseCloudReferenceUrl, referenceShareUrl, referenceSourceUrl };

package/dist/completion-registry.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Static completion registries — the LIGHT completion surface
+ * (`@diagrammo/dgmo/completion`).
+ *
+ * Pure data: chart-type directive registries, structural keywords, entity-type
+ * vocabularies, the reference-grammar descriptor, closed value enums, pipe /
+ * same-line metadata keys, and the derived metadata key set.
+ *
+ * Split out of `./completion` (which additionally owns the symbol *extractors*)
+ * so editor front-ends can import the registries without dragging the chart
+ * parsers — notably `body/parser`, whose figure-asset catalog is ~290 KB — onto
+ * their startup path. Same rationale and rule as `./chart-meta`: only symbols
+ * whose transitive imports are parser-constant-only live here.
+ *
+ * Closed enum sets (`ALL_MARKERS`, wireframe `STATE_KEYWORDS` /
+ * `GROUP_ONLY_METADATA`) are imported from their owning parsers — never
+ * hand-copied — so completion can't drift from the grammar (one-oracle rule).
+ */
+/** Specification for a single directive: description + optional enumerated values. */
+interface DirectiveValueSpec {
+    description: string;
+    values?: string[];
+}
+/** Specification for a chart type's directives. */
+interface DirectiveSpec {
+    directives: Record<string, DirectiveValueSpec>;
+}
+/** Chart-type → directive specifications. Every chart type has at least palette + theme. */
+declare const COMPLETION_REGISTRY: Map<string, DirectiveSpec>;
+declare const CHART_TYPES: ReadonlyArray<{
+    name: string;
+    description: string;
+}>;
+/**
+ * Entity types for `Name is a <type>` declarations, keyed by chart type.
+ * Values are sourced from parser constants (VALID_PARTICIPANT_TYPES,
+ * C4_IS_A_RE).
+ */
+declare const ENTITY_TYPES: Map<string, string[]>;
+/**
+ * Chart-type-specific structural keywords offered on an empty/start-of-line in
+ * the data zone (block openers like `loop`, section headers like `containers`,
+ * the `tag` block declaration, etc.). This is the single source of truth for
+ * the editor's structural-keyword popup — every entry MUST be a token the
+ * corresponding parser actually recognizes (validated by the
+ * completion-conformance suite). Do NOT add removed/diagnostic-only tokens
+ * (e.g. cycle's `no-descriptions`) or tokens the parser ignores.
+ *
+ * Chart types not listed here have no structural keywords (most data charts).
+ */
+declare const STRUCTURAL_KEYWORDS: Map<string, string[]>;
+/**
+ * Chart types that support `tag` block declarations (and thus the
+ * `alias`/`default` sub-keywords inside a tag block). Derived from
+ * STRUCTURAL_KEYWORDS so the two can never drift — a chart supports tag blocks
+ * iff it offers the `tag` keyword.
+ */
+declare const TAG_SUPPORTING_TYPES: ReadonlySet<string>;
+/** Whether a chart type has a reference position (arrow/operator → a prior
+ *  declaration) and which operators open it. The single oracle that drives
+ *  the library extractor audit, the app's entity-trigger map, and the
+ *  conformance drift-guard — so the three can never disagree. v1 models
+ *  reference-after-operator only (NOT metadata-target references). */
+interface ReferenceGrammar {
+    hasReferenceGrammar: boolean;
+    /** Literal operator tokens that introduce a reference (e.g. `->`, `<->`,
+     *  `~>`, `+`). The app derives its trigger regex from these (allowing the
+     *  labeled `-label->` / `~label~>` variants where applicable). */
+    referenceOperators: string[];
+}
+/**
+ * Per-type reference grammar. Grounded in each parser's arrow/operator
+ * grammar — NOT hand-typed blind. Types with no reference position (org,
+ * kanban, mindmap, all data charts, the radial/visualization types) declare
+ * `hasReferenceGrammar: false`. `map` references (`route A ~> B`) are owned by
+ * the app's bespoke geo-completion path, so it stays `false` here to avoid
+ * double-handling.
+ */
+declare const REFERENCE_GRAMMAR: Map<string, ReferenceGrammar>;
+/**
+ * RACI marker alphabet (slot-7 enum in the role-assignment value position).
+ * Consumed by editor completion. The chart type is always `raci`; the variant
+ * (RACI / RASCI / DACI) is inferred from the markers used, so completion offers
+ * the full union (R / A / S / C / I / D) sourced from `raci/variants.ts`'s
+ * `ALL_MARKERS` — the marker set can never drift from the parser.
+ */
+declare const RACI_MARKER_ALPHABETS: ReadonlyMap<string, readonly string[]>;
+/**
+ * Closed set of wireframe element state flags (slot-7 trailing enum, e.g.
+ * `(Submit) primary destructive`). Sourced from the wireframe parser's
+ * `STATE_KEYWORDS` — exported there and consumed here, never re-typed.
+ */
+declare const WIREFRAME_FLAGS: readonly string[];
+/**
+ * The subset of `WIREFRAME_FLAGS` that only make sense on group elements
+ * (`[...]`). Editor completion drops these for non-group elements (buttons
+ * `(...)`, dropdowns `{...}`). Sourced from the wireframe parser's
+ * `GROUP_ONLY_METADATA` — exported there and consumed here, never re-typed.
+ */
+declare const WIREFRAME_GROUP_ONLY_FLAGS: readonly string[];
+/** Specification for a single pipe metadata key. */
+interface PipeKeySpec {
+    description: string;
+    values?: string[];
+}
+/**
+ * Pipe metadata keys for inline `| key value` on data lines.
+ * Keyed by chart type → { context-name: keys }.
+ *
+ * Contexts are open-ended. The two universal ones are:
+ *   - `node` — the default for any non-arrow line
+ *   - `edge` — lines containing an arrow (`->`, `--`)
+ *
+ * Charts with richer line types declare additional contexts:
+ *   - raci: `role`, `phase`, `assignment`
+ *   - ring / pyramid: `layer`
+ *   - tech-radar: `quadrant`, `blip`
+ *   - journey-map: `step`
+ *
+ * IMPORTANT: NEVER add 'sequence' here. The `|` character in sequence
+ * diagrams separates display names from identifiers and tag metadata.
+ * Adding sequence would trigger false pipe-metadata completions on every `|`.
+ */
+type PipeContextMap = Record<string, Record<string, PipeKeySpec>>;
+declare const PIPE_METADATA: Map<string, PipeContextMap>;
+/** All known directive keys, derived from COMPLETION_REGISTRY. Includes implicit keys. */
+declare const METADATA_KEY_SET: ReadonlySet<string>;
+
+export { CHART_TYPES, COMPLETION_REGISTRY, type DirectiveSpec, type DirectiveValueSpec, ENTITY_TYPES, METADATA_KEY_SET, PIPE_METADATA, type PipeContextMap, type PipeKeySpec, RACI_MARKER_ALPHABETS, REFERENCE_GRAMMAR, type ReferenceGrammar, STRUCTURAL_KEYWORDS, TAG_SUPPORTING_TYPES, WIREFRAME_FLAGS, WIREFRAME_GROUP_ONLY_FLAGS };