@diagrammo/dgmo 0.31.0 → 0.32.1

package/src/er/parser.ts

@@ -377,7 +377,12 @@ export function parseERDiagram(
     // Tag group entries (indented under tag heading)
     if (currentTagGroup && !contentStarted && 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; finalized below.
       if (isDefault) {
         currentTagGroup.defaultValue = label;

package/src/gantt/parser.ts

@@ -200,6 +200,8 @@ export function parseGantt(
     syntaxMode: 'new', // always new-mode at 1.0
   };
 
+  // Bespoke (not the shared makeFail, Story 111.4): gantt accumulates into a
+  // local `diagnostics` array, not `result.diagnostics`.
   const fail = (line: number, message: string): ParsedGantt => {
     const diag = makeDgmoError(line, message);
     diagnostics.push(diag);
@@ -396,7 +398,12 @@ export function parseGantt(
         if (eraEntryMatch) {
           // Capture groups 1-3 guaranteed by successful regex match.
           const eraLabelRaw = eraEntryMatch[3]!.trim();
-          const eraExtracted = extractColor(eraLabelRaw, palette);
+          const eraExtracted = extractColor(
+            eraLabelRaw,
+            palette,
+            diagnostics,
+            lineNumber
+          );
           result.eras.push({
             startDate: eraEntryMatch[1]!,
             endDate: eraEntryMatch[2]!,
@@ -423,7 +430,12 @@ export function parseGantt(
         if (markerEntryMatch) {
           // Capture groups 1-2 guaranteed by successful regex match.
           const markerLabelRaw = markerEntryMatch[2]!.trim();
-          const markerExtracted = extractColor(markerLabelRaw, palette);
+          const markerExtracted = extractColor(
+            markerLabelRaw,
+            palette,
+            diagnostics,
+            lineNumber
+          );
           result.markers.push({
             date: markerEntryMatch[1]!,
             label: markerExtracted.label,
@@ -451,7 +463,12 @@ export function parseGantt(
         // First entry is the default unless another is marked `default`
         if (COMMENT_RE.test(line)) continue;
         const { text: cleanEntry, isDefault } = stripDefaultModifier(line);
-        const extracted = extractColor(cleanEntry, palette);
+        const extracted = extractColor(
+          cleanEntry,
+          palette,
+          diagnostics,
+          lineNumber
+        );
         const color =
           extracted.color ||
           seriesColors[currentTagGroup.entries.length % seriesColors.length] ||
@@ -710,7 +727,12 @@ export function parseGantt(
         const startOff = parseOffsetPrefix('+' + eraOffsetMatch[1]!);
         const endOff = parseOffsetPrefix('+' + eraOffsetMatch[2]!);
         const eraLabelRaw = eraOffsetMatch[3]!.trim();
-        const eraExtracted = extractColor(eraLabelRaw, palette);
+        const eraExtracted = extractColor(
+          eraLabelRaw,
+          palette,
+          diagnostics,
+          lineNumber
+        );
         result.eras.push({
           startDate: '',
           endDate: '',
@@ -728,7 +750,12 @@ export function parseGantt(
       if (markerOffsetMatch) {
         const dateOff = parseOffsetPrefix('+' + markerOffsetMatch[1]!);
         const markerLabelRaw = markerOffsetMatch[2]!.trim();
-        const markerExtracted = extractColor(markerLabelRaw, palette);
+        const markerExtracted = extractColor(
+          markerLabelRaw,
+          palette,
+          diagnostics,
+          lineNumber
+        );
         result.markers.push({
           date: '',
           label: markerExtracted.label,
@@ -825,7 +852,12 @@ export function parseGantt(
     if (eraMatch) {
       // Capture groups 1-3 guaranteed by successful regex match.
       const eraLabelRaw = eraMatch[3]!.trim();
-      const eraExtracted = extractColor(eraLabelRaw, palette);
+      const eraExtracted = extractColor(
+        eraLabelRaw,
+        palette,
+        diagnostics,
+        lineNumber
+      );
       result.eras.push({
         startDate: eraMatch[1]!,
         endDate: eraMatch[2]!,
@@ -848,7 +880,12 @@ export function parseGantt(
     if (markerMatch) {
       // Capture groups 1-2 guaranteed by successful regex match.
       const markerLabelRaw = markerMatch[2]!.trim();
-      const markerExtracted = extractColor(markerLabelRaw, palette);
+      const markerExtracted = extractColor(
+        markerLabelRaw,
+        palette,
+        diagnostics,
+        lineNumber
+      );
       result.markers.push({
         date: markerMatch[1]!,
         label: markerExtracted.label,

package/src/graph/flowchart-parser.ts

@@ -100,6 +100,29 @@ function parseNodeRef(text: string): NodeRef | null {
   return null;
 }
 
+/**
+ * Match a leading shape token plus any trailing text. Used to SALVAGE a node
+ * that `parseNodeRef` rejects because of trailing junk — most commonly an
+ * unsupported tag/metadata suffix the AI emits (`(Denied) s: Denied`).
+ * Flowcharts have no metadata/tag-group system (color a node inline instead:
+ * `(Denied red)`), so rather than silently drop the node AND its edge we keep
+ * the node, strip the suffix, and let the caller warn. The shape regexes are
+ * non-greedy so the FIRST balanced delimiter wins.
+ */
+function parseNodeRefLoose(
+  text: string
+): { ref: NodeRef; trailing: string } | null {
+  const t = text.trim();
+  // Order mirrors parseNodeRef: subroutine/document before process.
+  const shapeRe =
+    /^(\[\[.+?\]\]|\[.+?~\]|\[.+?\]|\(.+?\)|<.+?>|\/.+?\/)\s+(\S.*)$/;
+  const m = t.match(shapeRe);
+  if (!m) return null;
+  const ref = parseNodeRef(m[1]!);
+  if (!ref) return null;
+  return { ref, trailing: m[2]!.trim() };
+}
+
 /**
  * Split a line into segments around arrow tokens.
  * Arrows: `->`, `-label->`, and long-dash variants like `-->`, `--->`,
@@ -270,6 +293,11 @@ export function parseFlowchart(
   const notes: GraphNote[] = [];
   let contentStarted = false;
   let firstLineParsed = false;
+  // The last node id seen on the PREVIOUS content line — the implicit source
+  // for a line that begins with a bare arrow (`(Start)` then `-> Next` on its
+  // own line). Without this, the same-indent pop empties the indent stack and
+  // the leading-arrow line is dropped, orphaning the prior node.
+  let prevLineLastNodeId: string | null = null;
 
   // Per-parse alias literal → canonical node id (TD-18). Per C8:
   // never persisted, fresh each parse.
@@ -287,6 +315,22 @@ export function parseFlowchart(
     return { seg: m[1]!.trim(), alias: m[2]! };
   }
 
+  // Lines we've already warned about an unsupported node suffix on, so a chain
+  // with several salvaged nodes doesn't emit duplicate warnings per line.
+  const suffixWarnedLines = new Set<number>();
+  function warnUnsupportedSuffix(lineNumber: number, trailing: string): void {
+    if (suffixWarnedLines.has(lineNumber)) return;
+    suffixWarnedLines.add(lineNumber);
+    result.diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Ignored unsupported text after a node shape: "${trailing}". Flowcharts have no tag groups or node metadata; node colors are assigned automatically by shape (e.g. terminals green/red, decisions yellow). Remove the suffix.`,
+        'warning',
+        'W_FLOWCHART_NODE_SUFFIX'
+      )
+    );
+  }
+
   function getOrCreateNode(ref: NodeRef, lineNumber: number): GraphNode {
     const key = ref.id;
     const existing = nodeMap.get(key);
@@ -371,6 +415,13 @@ export function parseFlowchart(
     // Split line into segments around arrows
     const segments = splitArrows(trimmed);
 
+    // A line that begins with a bare arrow (first segment empty) is a
+    // continuation of the previous line's chain — its source is the last node
+    // on the previous content line when the indent stack offers nothing.
+    const startsWithArrow = segments.length >= 2 && segments[0]!.trim() === '';
+    const effectiveSource =
+      implicitSourceId ?? (startsWithArrow ? prevLineLastNodeId : null);
+
     if (segments.length === 1) {
       // Single node reference, no arrows. May carry an `as <alias>`
       // postfix per TD-18.
@@ -383,6 +434,15 @@ export function parseFlowchart(
         indentStack.push({ nodeId: node.id, indent });
         return node.id;
       }
+      // Salvage a shape with an unsupported trailing suffix (e.g. a tag/
+      // metadata assignment `(Denied) s: Denied`) — keep the node, warn.
+      const loose = parseNodeRefLoose(peeled.seg);
+      if (loose) {
+        warnUnsupportedSuffix(lineNumber, loose.trailing);
+        const node = getOrCreateNode(loose.ref, lineNumber);
+        indentStack.push({ nodeId: node.id, indent });
+        return node.id;
+      }
       // Bare-token alias reference: `os` (no brackets) on its own line
       // resolves to the canonical id and pushes onto the indent stack.
       const aliasResolved = nameAliasMap.get(peeled.seg.trim());
@@ -431,18 +491,28 @@ export function parseFlowchart(
           }
         }
       }
+      if (!ref) {
+        // Salvage a shape with an unsupported trailing suffix (most often a
+        // tag/metadata assignment like `(Denied) s: Denied`) so the node AND
+        // its edge survive instead of being silently dropped.
+        const loose = parseNodeRefLoose(peeled.seg);
+        if (loose) {
+          warnUnsupportedSuffix(lineNumber, loose.trailing);
+          ref = loose.ref;
+        }
+      }
       if (!ref) continue;
 
       const node = getOrCreateNode(ref, lineNumber);
       if (peeled.alias) nameAliasMap.set(peeled.alias, node.id);
 
       if (pendingArrow !== null) {
-        const sourceId = lastNodeId ?? implicitSourceId;
+        const sourceId = lastNodeId ?? effectiveSource;
         if (sourceId) {
           addEdge(sourceId, node.id, lineNumber, pendingArrow.label);
         }
         pendingArrow = null;
-      } else if (lastNodeId === null && implicitSourceId === null) {
+      } else if (lastNodeId === null && effectiveSource === null) {
         // First node in chain, no arrow yet — just register
       }
 
@@ -571,7 +641,11 @@ export function parseFlowchart(
     }
 
     // Content line (nodes and edges)
-    processContentLine(trimmed, lineNumber, indent);
+    const lastId = processContentLine(trimmed, lineNumber, indent);
+    // Remember this line's tail so a following bare-arrow line can attach to
+    // it (leading-arrow continuation). Keep the prior value when a line
+    // produces no node so blank/unparseable lines don't break the chain.
+    if (lastId) prevLineLastNodeId = lastId;
   }
 
   // Validation: no nodes found

package/src/graph/state-renderer.ts

@@ -7,7 +7,7 @@ import { appendArrowheadMarkers } from '../utils/arrow-markers';
 import { fitDiagramToCanvas } from '../utils/fit-canvas';
 import { FONT_FAMILY } from '../fonts';
 import type { PaletteColors } from '../palettes';
-import { contrastText, mix, shapeFill } from '../palettes/color-utils';
+import { contrastText, mix, shapeFill, themeBaseBg } from '../palettes/color-utils';
 import type { ParsedGraph } from './types';
 import type { LayoutResult, LayoutNode } from './layout';
 import { parseState } from './state-parser';
@@ -211,7 +211,7 @@ export function renderState(
     const gh = group.height + sGroupExtraPadding * 2 + sGroupLabelFontSize + 4;
 
     const fillColor = group.color
-      ? mix(group.color, isDark ? palette.surface : palette.bg, 10)
+      ? mix(group.color, themeBaseBg(palette, isDark), 10)
       : isDark
         ? palette.surface
         : mix(palette.border, palette.bg, 30);

package/src/infra/parser.ts

@@ -1066,9 +1066,89 @@ export function parseInfra(content: string): ParsedInfra {
 
   validateTagGroupNames(result.tagGroups, warn, setError);
 
+  checkReachability(result);
+
   return result;
 }
 
+/**
+ * Reachability lint: an infra diagram traces request traffic flowing inward
+ * from an `internet`/`edge` entry, so every node must have a directed path
+ * back to an entry. A node nothing routes to carries no traffic — it's dead
+ * and doesn't belong. Emits `warning`-severity diagnostics (never blocks
+ * rendering). Mirrors the compute model: an edge targeting a `[Group]`
+ * delivers to all of that group's children.
+ */
+function checkReachability(result: Writable<ParsedInfra>): void {
+  if (result.nodes.length === 0) return;
+
+  const entries = result.nodes.filter((n) => n.isEdge);
+
+  // No entry at all: the rule can't be satisfied. One diagnostic, not N.
+  if (entries.length === 0) {
+    const line = result.titleLineNumber ?? result.nodes[0]?.lineNumber ?? 1;
+    result.diagnostics.push(
+      makeDgmoError(
+        line,
+        `Infra diagram has no 'internet' or 'edge' entry point — an infra diagram traces request traffic from an entry inward, so without one nothing carries traffic. Add an 'internet' or 'edge' node and route from it.`,
+        'warning',
+        'W_INFRA_NO_ENTRY'
+      )
+    );
+    return;
+  }
+
+  // groupId -> child node ids (for expanding edges that target a [Group]).
+  const groupChildMap = new Map<string, string[]>();
+  for (const node of result.nodes) {
+    if (node.groupId) {
+      const list = groupChildMap.get(node.groupId) ?? [];
+      list.push(node.id);
+      // node.groupId is already a normalized id from parse time.
+      // eslint-disable-next-line name-normalize/required-at-insertion
+      groupChildMap.set(node.groupId, list);
+    }
+  }
+
+  // Outbound adjacency: an edge to a group reaches every child of that group.
+  const outbound = new Map<string, string[]>();
+  for (const edge of result.edges) {
+    const targets = groupChildMap.get(edge.targetId) ?? [edge.targetId];
+    const list = outbound.get(edge.sourceId) ?? [];
+    list.push(...targets);
+    outbound.set(edge.sourceId, list);
+  }
+
+  // BFS from every entry node.
+  const reachable = new Set<string>();
+  const queue: string[] = [];
+  for (const entry of entries) {
+    reachable.add(entry.id);
+    queue.push(entry.id);
+  }
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    for (const next of outbound.get(current) ?? []) {
+      if (!reachable.has(next)) {
+        reachable.add(next);
+        queue.push(next);
+      }
+    }
+  }
+
+  for (const node of result.nodes) {
+    if (node.isEdge || reachable.has(node.id)) continue;
+    result.diagnostics.push(
+      makeDgmoError(
+        node.lineNumber,
+        `'${node.label}' is unreachable from an 'internet'/'edge' entry — no request traffic flows to it, so it's dead on an infra diagram. Connect it downstream of an entry, or remove it.`,
+        'warning',
+        'W_INFRA_UNREACHABLE'
+      )
+    );
+  }
+}
+
 // ============================================================
 // Symbol extraction (for completion API)
 // ============================================================

package/src/journey-map/parser.ts

@@ -5,6 +5,7 @@ import {
   formatDgmoError,
   journeyBareScoreRemovedMessage,
   makeDgmoError,
+  makeFail,
   METADATA_DIAGNOSTIC_CODES,
   pipeOperatorRemovedMessage,
   suggest,
@@ -75,12 +76,7 @@ export function parseJourneyMap(
     error: null,
   };
 
-  const fail = (line: number, message: string): ParsedJourneyMap => {
-    const diag = makeDgmoError(line, message);
-    result.diagnostics.push(diag);
-    result.error = formatDgmoError(diag);
-    return result;
-  };
+  const fail = makeFail(result);
 
   const warn = (line: number, message: string): void => {
     result.diagnostics.push(makeDgmoError(line, message, 'warning'));
@@ -266,7 +262,12 @@ export function parseJourneyMap(
     if (currentTagGroup && !contentStarted) {
       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; finalized below.
         if (isDefault) {
           currentTagGroup.defaultValue = label;

package/src/kanban/parser.ts

@@ -2,6 +2,7 @@ import type { PaletteColors } from '../palettes';
 import {
   formatDgmoError,
   makeDgmoError,
+  makeFail,
   METADATA_DIAGNOSTIC_CODES,
   pipeOperatorRemovedMessage,
   suggest,
@@ -77,12 +78,7 @@ export function parseKanban(
     error: null,
   };
 
-  const fail = (line: number, message: string): ParsedKanban => {
-    const diag = makeDgmoError(line, message);
-    result.diagnostics.push(diag);
-    result.error = formatDgmoError(diag);
-    return result;
-  };
+  const fail = makeFail(result);
 
   const warn = (line: number, message: string): void => {
     result.diagnostics.push(makeDgmoError(line, message, 'warning'));
@@ -218,7 +214,12 @@ export function parseKanban(
       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; finalized below.
         if (isDefault) {
           currentTagGroup.defaultValue = label;