@diagrammo/dgmo 0.30.0 → 0.32.0

package/src/boxes-and-lines/parser.ts

@@ -42,6 +42,11 @@ import type { PaletteColors } from '../palettes';
 
 const MAX_GROUP_DEPTH = 2;
 
+// §1.4/§1.10 legacy-pipe detection — module-scope so they aren't re-created per
+// line. `|` inside a directed (`->`) or undirected (`~>`) arrow label is valid.
+const ARROW_LABEL_PIPE_DIRECTED_RE = /-\S*\|\S*->/;
+const ARROW_LABEL_PIPE_UNDIRECTED_RE = /~\S*\|\S*~>/;
+
 /** Boxes-and-lines requires explicit first line — no heuristic detection. */
 export function looksLikeBoxesAndLines(_content: string): boolean {
   return false;
@@ -127,6 +132,8 @@ export function parseBoxesAndLines(
   const nodes: MutBLNode[] = [];
   const edges: MutBLEdge[] = [];
   const groups: MutBLGroup[] = [];
+  // Trailing `layout` block (Canvas Editor spike): node-id → absolute {x,y}.
+  const nodePositions = new Map<string, { x: number; y: number }>();
   const result: Writable<ParsedBoxesAndLines> = {
     type: 'boxes-and-lines',
     title: null,
@@ -178,6 +185,11 @@ export function parseBoxesAndLines(
 
   // Tag block state
   let contentStarted = false;
+  // `layout` coordinate-block state (Canvas Editor spike). Unlike tag blocks,
+  // this is a TRAILING appendix — it may appear after diagram content.
+  let inLayoutBlock = false;
+  const LAYOUT_ENTRY_RE =
+    /^(.+?):\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*$/;
   let currentTagGroup: Writable<TagGroup> | null = null;
   // metaAliasMap: tag-group metadata-key aliases (per A1).
   const metaAliasMap = new Map<string, string>();
@@ -240,8 +252,8 @@ export function parseBoxesAndLines(
     // regions.
     if (
       trimmed.includes('|') &&
-      !/-\S*\|\S*->/.test(trimmed) &&
-      !/~\S*\|\S*~>/.test(trimmed)
+      !ARROW_LABEL_PIPE_DIRECTED_RE.test(trimmed) &&
+      !ARROW_LABEL_PIPE_UNDIRECTED_RE.test(trimmed)
     ) {
       result.diagnostics.push(
         makeDgmoError(
@@ -397,7 +409,12 @@ export function parseBoxesAndLines(
       if (tagBlockMatch.inlineValues) {
         for (const rawVal of tagBlockMatch.inlineValues) {
           const { text: cleanVal, isDefault } = stripDefaultModifier(rawVal);
-          const { label, color } = extractColor(cleanVal);
+          const { label, color } = extractColor(
+            cleanVal,
+            palette,
+            result.diagnostics,
+            lineNum
+          );
           newTagGroup.entries.push({
             value: label,
             color: color ?? AUTO_TAG_COLOR_SENTINEL,
@@ -417,7 +434,12 @@ export function parseBoxesAndLines(
     // Tag group entries (indented under tag heading)
     if (currentTagGroup && !contentStarted && indent > 0) {
       const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
-      const { label, color } = extractColor(cleanEntry);
+      const { label, color } = extractColor(
+        cleanEntry,
+        palette,
+        result.diagnostics,
+        lineNum
+      );
       currentTagGroup.entries.push({
         value: label,
         color: color ?? AUTO_TAG_COLOR_SENTINEL,
@@ -436,6 +458,52 @@ export function parseBoxesAndLines(
       currentTagGroup = null;
     }
 
+    // `layout` coordinate block (Canvas Editor spike). A bare `layout` heading
+    // at indent 0 opens the block; indented `<node-id>: <x>, <y>` entries map a
+    // node to an absolute position. Any non-indented line closes it. Quarantined
+    // before group/node/edge matching so the entries don't parse as nodes.
+    if (!inLayoutBlock && indent === 0 && trimmed === 'layout') {
+      // Disambiguate from a node legitimately NAMED `layout`: only treat this as
+      // the coordinate appendix when the next non-blank line is an indented
+      // `<id>: <x>, <y>` entry. Otherwise fall through and parse `layout` as a
+      // normal node (no silent data loss).
+      let isBlock = false;
+      for (let j = i + 1; j < lines.length; j++) {
+        const peek = lines[j]!;
+        if (!peek.trim()) continue;
+        isBlock = measureIndent(peek) > 0 && LAYOUT_ENTRY_RE.test(peek.trim());
+        break;
+      }
+      if (isBlock) {
+        flushDescription();
+        closeGroupsToIndent(0);
+        inLayoutBlock = true;
+        continue;
+      }
+    }
+    if (inLayoutBlock) {
+      if (indent > 0) {
+        const lm = trimmed.match(LAYOUT_ENTRY_RE);
+        if (lm) {
+          nodePositions.set(lm[1]!.trim(), {
+            x: Number(lm[2]),
+            y: Number(lm[3]),
+          });
+        } else {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNum,
+              `Invalid layout entry "${trimmed}" — expected "<node-id>: <x>, <y>"`,
+              'warning'
+            )
+          );
+        }
+        continue;
+      }
+      // indent 0 → block ends; fall through to process this line normally.
+      inLayoutBlock = false;
+    }
+
     // Description collection: indented non-edge lines under a node
     if (descState !== null) {
       if (indent > descState.indent) {
@@ -762,6 +830,31 @@ export function parseBoxesAndLines(
   // passed to extractColor above), so auto colors match for consistency.
   finalizeAutoTagColors(result.tagGroups as Writable<TagGroup>[]);
 
+  // Attach parsed `layout` positions. Validate coverage: unknown ids warn; a
+  // PARTIAL block (some nodes unpositioned) is honored by neither pin nor seed —
+  // the layout engine ignores it and auto-lays-out (Decision 3, AC12), so emit a
+  // single diagnostic naming the gap.
+  if (nodePositions.size > 0) {
+    const nodeLabelSet = new Set(result.nodes.map((n) => n.label));
+    for (const id of nodePositions.keys()) {
+      if (!nodeLabelSet.has(id)) {
+        pushWarning(0, `layout entry for unknown node "${id}" (ignored)`);
+      }
+    }
+    const unpositioned = result.nodes
+      .filter((n) => !nodePositions.has(n.label))
+      .map((n) => n.label);
+    if (unpositioned.length > 0) {
+      pushWarning(
+        0,
+        `layout block is partial — ${unpositioned.length} node(s) without coordinates ` +
+          `(${unpositioned.slice(0, 5).join(', ')}${unpositioned.length > 5 ? '…' : ''}); ` +
+          `ignoring the block and auto-laying-out`
+      );
+    }
+    result.nodePositions = nodePositions;
+  }
+
   // Post-parse: inject default tag metadata and validate tag values
   if (result.tagGroups.length > 0) {
     injectDefaultTagMetadata(result.nodes, result.tagGroups);

package/src/boxes-and-lines/renderer.ts

@@ -30,6 +30,7 @@ import {
   relativeLuminance,
   shapeFill,
   valueRampColor,
+  themeBaseBg,
 } from '../palettes/color-utils';
 import { resolveColor } from '../colors';
 import { resolveTagColor } from '../utils/tag-groups';
@@ -56,9 +57,13 @@ const DIAGRAM_PADDING = 20;
 const NODE_FONT_SIZE = 11;
 const MIN_NODE_FONT_SIZE = 9;
 const EDGE_LABEL_FONT_SIZE = 11;
-const EDGE_STROKE_WIDTH = 1.5;
-const NODE_STROKE_WIDTH = 1.5;
+import {
+  EDGE_STROKE_WIDTH,
+  NODE_STROKE_WIDTH,
+} from '../utils/visual-conventions'; // shared (Story 111.1)
 const NODE_RX = 8;
+// Intentional deviation (conventions §3): boxes-and-lines uses a 4px collapse
+// bar (and 4px separator gap in layout.ts) — denser than the 6px default.
 const COLLAPSE_BAR_HEIGHT = 4;
 const ARROWHEAD_W = 5;
 const ARROWHEAD_H = 4;
@@ -89,6 +94,15 @@ const lineGeneratorTB = d3Shape
   .y((d) => d.y)
   .curve(d3Shape.curveBasis);
 
+// Straight (linear) generator for pinned-layout connectors (Canvas Editor
+// spike). curveBasis collapses a 2-point polyline, so border-clipped straight
+// edges must draw linearly.
+const lineGeneratorStraight = d3Shape
+  .line<{ x: number; y: number }>()
+  .x((d) => d.x)
+  .y((d) => d.y)
+  .curve(d3Shape.curveLinear);
+
 // ── Text fitting ───────────────────────────────────────────
 
 function splitCamelCase(word: string): string[] {
@@ -425,6 +439,11 @@ interface BLRenderOptions {
   /** When 'app', the description toggle is hosted by the app overlay strip
    *  (inline gear suppressed, controls row + anchor reserved). */
   controlsHost?: 'app' | 'inline';
+  /** Explicit value-ramp domain override. When provided, the choropleth ramp
+   *  uses these endpoints instead of computing min/max from `parsed.nodes`.
+   *  Focus mode passes the GLOBAL (pre-filter) domain so neighbor colours stay
+   *  stable when only a subset is rendered (Decision 20 / FM1). */
+  rampDomain?: { min: number; max: number };
 }
 
 export function renderBoxesAndLines(
@@ -446,6 +465,7 @@ export function renderBoxesAndLines(
     onToggleControlsExpand,
     exportMode = false,
     controlsHost,
+    rampDomain,
   } = options ?? {};
   d3Selection.select(container).selectAll(':not([data-d3-tooltip])').remove();
 
@@ -479,8 +499,10 @@ export function renderBoxesAndLines(
   // Anchor the low end at the lowest value (not 0) to maximise within-diagram
   // dynamic range; mirrors the map's region-metric ramp. Equal-value data
   // (rampMin === rampMax) falls back to t = 1 in fillForValue below.
-  const rampMin = hasRamp ? Math.min(...nodeValues) : 0;
-  const rampMax = Math.max(...nodeValues);
+  // A caller-supplied domain (focus mode) wins so colours don't shift when a
+  // subset is rendered; otherwise derive from the nodes on screen.
+  const rampMin = rampDomain?.min ?? (hasRamp ? Math.min(...nodeValues) : 0);
+  const rampMax = rampDomain?.max ?? Math.max(...nodeValues);
   // Default hue = palette.primary (NOT red like the map — boxes have no water to
   // stand out against, and red reads as alarm on a neutral metric). A trailing
   // color on `box-metric` overrides.
@@ -614,8 +636,43 @@ export function renderBoxesAndLines(
   const scaleY = height / (contentH + sDiagramPadding * 2);
   const scale = Math.min(scaleX, scaleY, 3);
 
-  const offsetX = (width - contentW * scale) / 2;
-  const offsetY = sDiagramPadding + titleOffset + legendH;
+  // Pinned (`layout`-block) coordinates can leave the content's real extent
+  // sitting off-centre inside layout.width/height — e.g. nodes pinned far from
+  // the origin bake a wide gap on one side. Re-centre the content within its
+  // own box by equalizing opposite margins. Gated to pinned diagrams so the
+  // auto-layout path (and its snapshots) stays byte-identical: that path
+  // already produces symmetric margins.
+  let centerShiftX = 0;
+  let centerShiftY = 0;
+  if (parsed.nodePositions && parsed.nodePositions.size > 0) {
+    let bMinX = Infinity,
+      bMinY = Infinity,
+      bMaxX = -Infinity,
+      bMaxY = -Infinity;
+    const accB = (x: number, y: number) => {
+      if (x < bMinX) bMinX = x;
+      if (x > bMaxX) bMaxX = x;
+      if (y < bMinY) bMinY = y;
+      if (y > bMaxY) bMaxY = y;
+    };
+    for (const n of layout.nodes) {
+      accB(n.x - n.width / 2, n.y - n.height / 2);
+      accB(n.x + n.width / 2, n.y + n.height / 2);
+    }
+    for (const g of layout.groups) {
+      accB(g.x - g.width / 2, g.y - g.height / 2);
+      accB(g.x + g.width / 2, g.y + g.height / 2);
+    }
+    for (const e of layout.edges) for (const p of e.points) accB(p.x, p.y);
+    if (Number.isFinite(bMinX)) {
+      centerShiftX = (layout.width - bMaxX - bMinX) / 2;
+      centerShiftY = (layout.height - bMaxY - bMinY) / 2;
+    }
+  }
+
+  const offsetX = (width - contentW * scale) / 2 + centerShiftX * scale;
+  const offsetY =
+    sDiagramPadding + titleOffset + legendH + centerShiftY * scale;
 
   const svg: D3Svg = d3Selection
     .select(container)
@@ -703,7 +760,7 @@ export function renderBoxesAndLines(
 
     if (group.collapsed) {
       // Collapsed: solid rounded rect matching node style + 6px collapse bar
-      const fillColor = isDark ? palette.surface : palette.bg;
+      const fillColor = themeBaseBg(palette, isDark);
       const strokeColor = palette.border;
 
       groupG
@@ -896,7 +953,11 @@ export function renderBoxesAndLines(
     edgeGroups.set(i, edgeG as unknown as D3G);
 
     const markerId = `bl-arrow-${color.replace('#', '')}`;
-    const gen = parsed.direction === 'TB' ? lineGeneratorTB : lineGeneratorLR;
+    const gen = le.straight
+      ? lineGeneratorStraight
+      : parsed.direction === 'TB'
+        ? lineGeneratorTB
+        : lineGeneratorLR;
     const path = edgeG
       .append('path')
       .attr('class', 'bl-edge')
@@ -1394,6 +1455,48 @@ export function renderBoxesAndLines(
     });
     legendG.selectAll('[data-legend-group]').classed('bl-legend-group', true);
   }
+
+  // ── Focus mode: one reusable hover-reveal icon (interactive only) ──
+  // A single hidden icon the app repositions over the hovered box/group and
+  // stamps `data-focus-id`/`data-focus-kind` on (Decision 22 / ADR-4) — NOT one
+  // per node (~4k elements on a large graph). Appended to the SVG root so the
+  // app positions it in root (screen-mapped) coordinates, counter-scaled to a
+  // constant size regardless of fit. Excluded from export like org's icon.
+  if (!exportDims && !exportMode) {
+    const iconSize = 14;
+    const focusG = svg
+      .append('g')
+      .attr('class', 'bl-focus-icon')
+      .attr('data-export-ignore', 'true')
+      .style('display', 'none')
+      .style('pointer-events', 'auto')
+      .style('cursor', 'pointer');
+    // Hit area
+    focusG
+      .append('rect')
+      .attr('x', -3)
+      .attr('y', -3)
+      .attr('width', iconSize + 6)
+      .attr('height', iconSize + 6)
+      .attr('fill', 'transparent');
+    // Scope/target icon: outer circle + inner dot (mirrors org-focus-icon)
+    const cx = iconSize / 2;
+    const cy = iconSize / 2;
+    focusG
+      .append('circle')
+      .attr('cx', cx)
+      .attr('cy', cy)
+      .attr('r', iconSize / 2 - 1)
+      .attr('fill', palette.bg)
+      .attr('stroke', palette.textMuted)
+      .attr('stroke-width', 1.5);
+    focusG
+      .append('circle')
+      .attr('cx', cx)
+      .attr('cy', cy)
+      .attr('r', 2)
+      .attr('fill', palette.textMuted);
+  }
 }
 
 // ── Export helper ──────────────────────────────────────────

package/src/boxes-and-lines/types.ts

@@ -42,6 +42,15 @@ export interface ParsedBoxesAndLines {
   readonly notes?: readonly DiagramNote[];
   readonly initialHiddenTagValues: ReadonlyMap<string, ReadonlySet<string>>;
   readonly direction: 'LR' | 'TB';
+  /** Optional per-node absolute positions, parsed from a trailing `layout`
+   *  block (`<node-id>: <x>, <y>`). Diagram-space coordinates. When present and
+   *  covering EVERY node, the layout engine bypasses auto-placement and pins
+   *  nodes here (see Decision 3 — two clean modes). A partial block is ignored
+   *  with a diagnostic (AC12). Experimental — Canvas Editor spike. */
+  readonly nodePositions?: ReadonlyMap<
+    string,
+    { readonly x: number; readonly y: number }
+  >;
   /** `box-metric <label> [low] [high]` — names the value-ramp dimension and
    *  optionally sets its endpoint colours. One color = high hue over a neutral
    *  low; two = explicit `low high`. Mirror of map's `region-metric`. */

package/src/c4/parser.ts

@@ -8,6 +8,7 @@ import {
   descriptionBareRemovedMessage,
   formatDgmoError,
   makeDgmoError,
+  makeFail,
   METADATA_DIAGNOSTIC_CODES,
   pipeOperatorRemovedMessage,
   suggest,
@@ -296,12 +297,7 @@ export function parseC4(content: string, palette?: PaletteColors): ParsedC4 {
       result.error = formatDgmoError(diag);
   };
 
-  const fail = (line: number, message: string): ParsedC4 => {
-    const diag = makeDgmoError(line, message);
-    result.diagnostics.push(diag);
-    result.error = formatDgmoError(diag);
-    return result;
-  };
+  const fail = makeFail(result);
 
   if (!content?.trim()) {
     return fail(0, 'No content provided');
@@ -455,7 +451,12 @@ export function parseC4(content: string, palette?: PaletteColors): ParsedC4 {
       const indent = measureIndent(line);
       if (indent > 0) {
         const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
-        const { label, color } = extractColor(cleanEntry, palette);
+        const { label, color } = extractColor(
+          cleanEntry,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
         // Bare value (no explicit color) → keep it; the post-parse
         // finalize pass assigns a deterministic palette color.
         if (isDefault) {

package/src/c4/renderer.ts

@@ -37,16 +37,18 @@ const DESC_FONT_SIZE = 11;
 const DESC_LINE_HEIGHT = 16;
 const EDGE_LABEL_FONT_SIZE = 11;
 const TECH_FONT_SIZE = 10;
-const EDGE_STROKE_WIDTH = 1.5;
-const NODE_STROKE_WIDTH = 1.5;
-const CARD_RADIUS = 6;
+import {
+  EDGE_STROKE_WIDTH,
+  NODE_STROKE_WIDTH,
+  CARD_RADIUS,
+  META_FONT_SIZE,
+  META_LINE_HEIGHT,
+} from '../utils/visual-conventions'; // shared (Story 111.1)
 const CARD_H_PAD = 20;
 const CARD_V_PAD = 14;
 const TYPE_LABEL_HEIGHT = 18;
 const DIVIDER_GAP = 6;
 const NAME_HEIGHT = 20;
-const META_FONT_SIZE = 11;
-const META_LINE_HEIGHT = 16;
 const BOUNDARY_LABEL_FONT_SIZE = 12;
 const BOUNDARY_STROKE_WIDTH = 1.5;
 const BOUNDARY_RADIUS = 8;

package/src/chart-type-registry.ts

@@ -87,6 +87,10 @@ export interface ChartTypeDescriptor {
   readonly category: RenderCategory;
   readonly parse: ParseFn;
   readonly measure?: (content: string) => ContentCounts;
+  readonly minDims?: (counts: ContentCounts) => {
+    width: number;
+    height: number;
+  };
 }
 
 // ============================================================
@@ -210,6 +214,92 @@ function measureInfra(content: string): ContentCounts {
   return { nodes: parsed.nodes.length };
 }
 
+// ============================================================
+// minDims() implementations — relocated verbatim from computeMinDimensions() in
+// utils/scaling.ts so the registry owns per-type minimum-dimension formulas
+// alongside measure(). Each maps ContentCounts → {width,height}. Types without a
+// minDims fall back to {300,200} (the old switch `default`) via the
+// REGISTRY_BY_ID lookup in dimensions.ts.
+// ============================================================
+
+function minDimsSequence(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.participants ?? 2) * 80, 320),
+    height: Math.max((c.messages ?? 1) * 20 + 120, 200),
+  };
+}
+function minDimsRaci(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.roles ?? 2) * 50 + 180, 300),
+    height: Math.max((c.tasks ?? 1) * 28 + 80, 200),
+  };
+}
+function minDimsMindmap(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.nodes ?? 3) * 30, 300),
+    height: Math.max((c.depth ?? 2) * 60, 200),
+  };
+}
+function minDimsTechRadar(): { width: number; height: number } {
+  return { width: 360, height: 400 };
+}
+function minDimsHeatmap(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.columns ?? 3) * 40, 300),
+    height: Math.max((c.rows ?? 3) * 30 + 60, 200),
+  };
+}
+function minDimsArc(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: 300,
+    height: Math.max((c.nodes ?? 3) * 20 + 120, 200),
+  };
+}
+function minDimsOrg(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.nodes ?? 3) * 60, 300),
+    height: Math.max((c.depth ?? 2) * 80, 200),
+  };
+}
+function minDimsGantt(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: 400,
+    height: Math.max((c.tasks ?? 3) * 24 + 80, 200),
+  };
+}
+function minDimsKanban(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.columns ?? 3) * 120, 360),
+    height: 300,
+  };
+}
+// er + class share this formula.
+function minDimsEntities(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.nodes ?? 2) * 140, 300),
+    height: Math.max((c.nodes ?? 2) * 80, 200),
+  };
+}
+// flowchart + state share this formula.
+function minDimsGraph(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.nodes ?? 3) * 60, 300),
+    height: Math.max((c.nodes ?? 3) * 50, 200),
+  };
+}
+function minDimsPert(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.tasks ?? 3) * 80, 340),
+    height: Math.max((c.tasks ?? 3) * 40 + 80, 200),
+  };
+}
+function minDimsInfra(c: ContentCounts): { width: number; height: number } {
+  return {
+    width: Math.max((c.nodes ?? 3) * 80, 300),
+    height: Math.max((c.nodes ?? 3) * 60, 200),
+  };
+}
+
 // ============================================================
 // THE REGISTRY — ordered to match the previous chartTypeParsers grouping
 // (structured diagrams, standard ECharts, extended ECharts, D3 visualizations,
@@ -224,32 +314,49 @@ export const CHART_TYPE_REGISTRY: readonly ChartTypeDescriptor[] = [
     category: 'diagram',
     parse: parseSequenceDgmo,
     measure: measureSequence,
+    minDims: minDimsSequence,
   },
   {
     id: 'flowchart',
     category: 'diagram',
     parse: parseFlowchart,
     measure: measureFlowchart,
+    minDims: minDimsGraph,
   },
   {
     id: 'class',
     category: 'diagram',
     parse: parseClassDiagram,
     measure: measureClass,
+    minDims: minDimsEntities,
+  },
+  {
+    id: 'er',
+    category: 'diagram',
+    parse: parseERDiagram,
+    measure: measureER,
+    minDims: minDimsEntities,
   },
-  { id: 'er', category: 'diagram', parse: parseERDiagram, measure: measureER },
   {
     id: 'state',
     category: 'diagram',
     parse: parseState,
     measure: measureStateGraph,
+    minDims: minDimsGraph,
+  },
+  {
+    id: 'org',
+    category: 'diagram',
+    parse: parseOrg,
+    measure: measureOrg,
+    minDims: minDimsOrg,
   },
-  { id: 'org', category: 'diagram', parse: parseOrg, measure: measureOrg },
   {
     id: 'kanban',
     category: 'diagram',
     parse: parseKanban,
     measure: measureKanban,
+    minDims: minDimsKanban,
   },
   { id: 'c4', category: 'diagram', parse: parseC4 },
   { id: 'sitemap', category: 'diagram', parse: parseSitemap },
@@ -258,24 +365,39 @@ export const CHART_TYPE_REGISTRY: readonly ChartTypeDescriptor[] = [
     category: 'diagram',
     parse: parseInfra,
     measure: measureInfra,
+    minDims: minDimsInfra,
   },
   {
     id: 'gantt',
     category: 'diagram',
     parse: parseGantt,
     measure: measureGantt,
+    minDims: minDimsGantt,
+  },
+  {
+    id: 'pert',
+    category: 'diagram',
+    parse: parsePert,
+    measure: measurePert,
+    minDims: minDimsPert,
   },
-  { id: 'pert', category: 'diagram', parse: parsePert, measure: measurePert },
   { id: 'boxes-and-lines', category: 'diagram', parse: parseBoxesAndLines },
   {
     id: 'mindmap',
     category: 'diagram',
     parse: parseMindmap,
     measure: measureMindmap,
+    minDims: minDimsMindmap,
   },
   { id: 'wireframe', category: 'diagram', parse: parseWireframe },
   { id: 'journey-map', category: 'diagram', parse: parseJourneyMap },
-  { id: 'raci', category: 'diagram', parse: parseRaci, measure: measureRaci },
+  {
+    id: 'raci',
+    category: 'diagram',
+    parse: parseRaci,
+    measure: measureRaci,
+    minDims: minDimsRaci,
+  },
   { id: 'rasci', category: 'diagram', parse: parseRaci, measure: measureRaci },
   { id: 'daci', category: 'diagram', parse: parseRaci, measure: measureRaci },
 
@@ -300,6 +422,7 @@ export const CHART_TYPE_REGISTRY: readonly ChartTypeDescriptor[] = [
     category: 'data-chart',
     parse: parseHeatmap,
     measure: measureHeatmap,
+    minDims: minDimsHeatmap,
   },
   { id: 'funnel', category: 'data-chart', parse: parseFunnel },
 
@@ -311,6 +434,7 @@ export const CHART_TYPE_REGISTRY: readonly ChartTypeDescriptor[] = [
     category: 'visualization',
     parse: parseArc,
     measure: measureArc,
+    minDims: minDimsArc,
   },
   { id: 'timeline', category: 'visualization', parse: parseTimeline },
   { id: 'venn', category: 'visualization', parse: parseVenn },
@@ -322,6 +446,7 @@ export const CHART_TYPE_REGISTRY: readonly ChartTypeDescriptor[] = [
     category: 'visualization',
     parse: parseTechRadar,
     measure: measureTechRadar,
+    minDims: minDimsTechRadar,
   },
   { id: 'cycle', category: 'visualization', parse: parseCycle },
   { id: 'pyramid', category: 'visualization', parse: parsePyramid },

package/src/chart-types.ts

@@ -46,7 +46,7 @@ export const chartTypes: readonly ChartTypeMeta[] = [
   },
   {
     id: 'sequence',
-    description: 'Message / interaction flows',
+    description: 'Message request and response interaction flows',
     fallback: true,
   },
   {
@@ -143,7 +143,7 @@ export const chartTypes: readonly ChartTypeMeta[] = [
   },
   {
     id: 'slope',
-    description: 'Change between two periods',
+    description: 'Change between 2 time periods',
   },
   {
     id: 'sankey',
@@ -173,7 +173,7 @@ export const chartTypes: readonly ChartTypeMeta[] = [
   // ── Tier 4 — General-purpose data charts ──────────────────
   {
     id: 'bar',
-    description: 'Categorical comparisons',
+    description: 'Categorical comparisons for 3 - 5 figures',
     fallback: true,
   },
   {