@diagrammo/dgmo 0.47.0 → 0.48.1

package/src/graph/flowchart-parser.ts

@@ -1,759 +0,0 @@
-import type { DgmoError } from '../diagnostics';
-import type { PaletteColors } from '../palettes';
-import {
-  emit,
-  makeDgmoError,
-  formatDgmoError,
-  suggest,
-  NAME_DIAGNOSTIC_CODES,
-  nameMergedMessage,
-} from '../diagnostics';
-import { GRAPH_DX } from './diagnostics';
-import { parseInArrowLabel } from '../utils/arrows';
-import {
-  measureIndent,
-  parseFirstLine,
-  OPTION_NOCOLON_RE,
-  ALL_CHART_TYPES,
-  tryParseSharedOption,
-} from '../utils/parsing';
-import { normalizeName, displayName } from '../utils/name-normalize';
-import type { Writable } from '../utils/brand';
-import type {
-  ParsedGraph,
-  GraphNode,
-  GraphEdge,
-  GraphShape,
-  GraphNote,
-} from './types';
-import { tryCollectNote, resolveNotes } from './notes';
-
-// ============================================================
-// Helpers
-// ============================================================
-
-function nodeId(shape: GraphShape, label: string): string {
-  return `${shape}:${normalizeName(label)}`;
-}
-
-interface NodeRef {
-  id: string;
-  label: string;
-  shape: GraphShape;
-  color?: string;
-}
-
-/**
- * Try to parse a node reference from a text fragment.
- * Order matters: subroutine & document before process.
- */
-function parseNodeRef(text: string): NodeRef | null {
-  const t = text.trim();
-  if (!t) return null;
-
-  // Subroutine: [[Label]]
-  let m = t.match(/^\[\[([^\]]+)\]\]$/);
-  if (m) {
-    // Capture group 1 guaranteed present by successful regex match.
-    const label = m[1]!.trim();
-    return { id: nodeId('subroutine', label), label, shape: 'subroutine' };
-  }
-
-  // Document: [Label~]
-  m = t.match(/^\[([^\]]+)~\]$/);
-  if (m) {
-    // Capture group 1 guaranteed present by successful regex match.
-    const label = m[1]!.trim();
-    return { id: nodeId('document', label), label, shape: 'document' };
-  }
-
-  // Process: [Label]
-  m = t.match(/^\[([^\]]+)\]$/);
-  if (m) {
-    // Capture group 1 guaranteed present by successful regex match.
-    const label = m[1]!.trim();
-    return { id: nodeId('process', label), label, shape: 'process' };
-  }
-
-  // Terminal: (Label) — use .+ (greedy) so (Label(color)) matches outermost parens
-  m = t.match(/^\((.+)\)$/);
-  if (m) {
-    // Capture group 1 guaranteed present by successful regex match.
-    const label = m[1]!.trim();
-    return { id: nodeId('terminal', label), label, shape: 'terminal' };
-  }
-
-  // Decision: <Label>
-  m = t.match(/^<([^>]+)>$/);
-  if (m) {
-    // Capture group 1 guaranteed present by successful regex match.
-    const label = m[1]!.trim();
-    return { id: nodeId('decision', label), label, shape: 'decision' };
-  }
-
-  // I/O: /Label/
-  m = t.match(/^\/([^/]+)\/$/);
-  if (m) {
-    // Capture group 1 guaranteed present by successful regex match.
-    const label = m[1]!.trim();
-    return { id: nodeId('io', label), label, shape: 'io' };
-  }
-
-  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 `-->`, `--->`,
- * `--foo--->` (TD-9 longest-match: the arrow token is the maximal run of `-+>`).
- *
- * Returns alternating: [nodeText, arrowText, nodeText, arrowText, nodeText, ...]
- * Where arrowText is the synthesized full arrow token like `-yes->` or `->`
- * (with visual dash-run length collapsed to the minimal `-...->` form —
- * edge styling is not yet differentiated by arrow length).
- */
-function splitArrows(line: string): string[] {
-  const segments: string[] = [];
-  const arrowPositions: {
-    start: number;
-    end: number;
-    label?: string;
-  }[] = [];
-
-  // Find all arrow tokens. A token is a maximal run of `-+>` (one-or-more
-  // dashes followed by `>`). We scan for `->` and then expand leftward across
-  // adjacent dashes to absorb longer forms. `scanFloor` marks the lower
-  // bound for the next opening-dash search so an arrow's opening cannot
-  // reach back into the territory of a previously consumed arrow.
-  let searchFrom = 0;
-  let scanFloor = 0;
-  while (searchFrom < line.length) {
-    const idx = line.indexOf('->', searchFrom);
-    if (idx === -1) break;
-
-    // TD-9: absorb the full arrow run leftward from idx, but not past the
-    // scanFloor (which is right after the previous arrow).
-    let runStart = idx;
-    while (runStart > scanFloor && line[runStart - 1] === '-') runStart--;
-    const arrowEnd = idx + 2; // position after `>`
-
-    // Look for an opening dash run before the arrow. The opening is the
-    // LEFTMOST `-` in the region `[scanFloor, runStart)` that is preceded by
-    // whitespace or start-of-line. Any dashes to its right up to the first
-    // non-dash character are part of the opening run; content after that is
-    // the label; the full arrow token runs from opening through `>`.
-    let arrowStart: number;
-    let label: string | undefined;
-
-    let openingStart = -1;
-    for (let i = scanFloor; i < runStart; i++) {
-      if (line[i] !== '-') continue;
-      const prevIsWsOrFloor =
-        i === 0 || i === scanFloor || /\s/.test(line.charAt(i - 1));
-      if (prevIsWsOrFloor) {
-        openingStart = i;
-        break;
-      }
-    }
-
-    if (openingStart !== -1) {
-      // End of opening run: consume consecutive dashes after openingStart.
-      let openingEnd = openingStart;
-      while (openingEnd < runStart && line[openingEnd] === '-') openingEnd++;
-
-      // Label content = everything between opening run and the arrow run.
-      // Edges have no color slot (§1.7); parens stay literal.
-      const labelPart = line.substring(openingEnd, runStart).trim();
-      if (labelPart) label = labelPart;
-      arrowStart = openingStart;
-    } else {
-      // No opening dash run found. All absorbed leftward dashes belong to
-      // the arrow token itself (e.g. `A --> B` → arrow is `-->`, no label).
-      arrowStart = runStart;
-    }
-
-    arrowPositions.push({
-      start: arrowStart,
-      end: arrowEnd,
-      ...(label !== undefined && { label }),
-    });
-    searchFrom = arrowEnd;
-    scanFloor = arrowEnd;
-  }
-
-  if (arrowPositions.length === 0) {
-    return [line];
-  }
-
-  // Build segments.
-  //
-  // NOTE: the synthesized arrow token is always the short form (`->` or
-  // `-label->`). The actual dash run-length (`-->`, `--->`, `---->`) seen
-  // in the source is collapsed here.
-  let lastIndex = 0;
-  for (let i = 0; i < arrowPositions.length; i++) {
-    // In-bounds by loop guard.
-    const arrow = arrowPositions[i]!;
-    const beforeText = line.substring(lastIndex, arrow.start).trim();
-    if (beforeText || i === 0) {
-      segments.push(beforeText);
-    }
-    const arrowToken = arrow.label ? `-${arrow.label}->` : '->';
-    segments.push(arrowToken);
-    lastIndex = arrow.end;
-  }
-  // Remaining text after last arrow
-  const remaining = line.substring(lastIndex).trim();
-  if (remaining) {
-    segments.push(remaining);
-  }
-
-  return segments;
-}
-
-interface ArrowInfo {
-  label?: string;
-}
-
-function parseArrowToken(
-  token: string,
-  _palette: PaletteColors | undefined,
-  lineNumber: number,
-  diagnostics: DgmoError[]
-): ArrowInfo {
-  if (token === '->') return {};
-  // Edges have no color slot (spec §1.7 "Edge color is not a feature"). The
-  // whole content between `-` and `->` is the label, including parens.
-  const m = token.match(/^-(.+?)->$/);
-  if (m) {
-    const rawLabel = m[1] ?? '';
-    const labelResult = parseInArrowLabel(rawLabel, lineNumber);
-    diagnostics.push(...labelResult.diagnostics);
-    return {
-      ...(labelResult.label !== undefined && { label: labelResult.label }),
-    };
-  }
-  return {};
-}
-
-// ============================================================
-// Group heading support
-// ============================================================
-
-// ============================================================
-// Main parser
-// ============================================================
-
-export function parseFlowchart(
-  content: string,
-  palette?: PaletteColors
-): ParsedGraph {
-  const lines = content.split('\n');
-  const options: Record<string, string> = {};
-  const result: Writable<ParsedGraph> = {
-    type: 'flowchart',
-    direction: 'TB',
-    nodes: [],
-    edges: [],
-    options,
-    diagnostics: [],
-    error: null,
-  };
-
-  const fail = (line: number, message: string): ParsedGraph => {
-    const diag = makeDgmoError(line, message);
-    result.diagnostics.push(diag);
-    result.error = formatDgmoError(diag);
-    return result;
-  };
-
-  const nodeMap = new Map<string, GraphNode>();
-  const indentStack: { nodeId: string; indent: number }[] = [];
-  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.
-  const nameAliasMap = new Map<string, string>();
-  /**
-   * Peel any trailing `as <alias>` off a segment. Returns the cleaned
-   * segment plus the alias literal if one was found. The caller is
-   * expected to register the alias once it knows the canonical node id.
-   */
-  function peelAlias(seg: string): { seg: string; alias?: string } {
-    const trimmed = seg.trim();
-    const m = trimmed.match(/^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/);
-    if (!m) return { seg: trimmed };
-    // Capture groups 1 and 2 guaranteed present by successful regex match.
-    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(
-      emit(GRAPH_DX.FLOWCHART_NODE_SUFFIX, lineNumber, { trailing })
-    );
-  }
-
-  function getOrCreateNode(ref: NodeRef, lineNumber: number): GraphNode {
-    const key = ref.id;
-    const existing = nodeMap.get(key);
-    if (existing) {
-      const incomingDisplay = displayName(ref.label);
-      const existingDisplay = displayName(existing.label);
-      if (incomingDisplay !== existingDisplay) {
-        result.diagnostics.push(
-          makeDgmoError(
-            lineNumber,
-            nameMergedMessage({
-              incomingDisplay,
-              incomingLine: lineNumber,
-              existingDisplay,
-              existingLine: existing.lineNumber,
-            }),
-            'warning',
-            NAME_DIAGNOSTIC_CODES.NAME_MERGED
-          )
-        );
-      }
-      return existing;
-    }
-
-    const node: GraphNode = {
-      id: key,
-      label: ref.label,
-      shape: ref.shape,
-      lineNumber,
-      ...(ref.color && { color: ref.color }),
-    };
-    nodeMap.set(key, node);
-    result.nodes.push(node);
-
-    return node;
-  }
-
-  function addEdge(
-    sourceId: string,
-    targetId: string,
-    lineNumber: number,
-    label?: string
-  ): void {
-    const edge: GraphEdge = {
-      source: sourceId,
-      target: targetId,
-      lineNumber,
-      ...(label && { label }),
-    };
-    result.edges.push(edge);
-  }
-
-  /**
-   * Process a content line that may contain nodes and arrows.
-   * Returns the last node ID encountered (for indent stack tracking).
-   */
-  function processContentLine(
-    trimmed: string,
-    lineNumber: number,
-    indent: number
-  ): string | null {
-    contentStarted = true;
-
-    // Determine implicit source from indent stack
-    // Pop stack entries that are at same or deeper indent level
-    while (indentStack.length > 0) {
-      // In-bounds: length > 0 guarded by while.
-      const top = indentStack[indentStack.length - 1]!;
-      if (top.indent >= indent) {
-        indentStack.pop();
-      } else {
-        break;
-      }
-    }
-
-    const implicitSourceId =
-      indentStack.length > 0
-        ? // In-bounds: length > 0 guarded by ternary.
-          indentStack[indentStack.length - 1]!.nodeId
-        : null;
-
-    // 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.
-      // In-bounds: length === 1 guarded above.
-      const peeled = peelAlias(segments[0]!);
-      const ref = parseNodeRef(peeled.seg);
-      if (ref) {
-        const node = getOrCreateNode(ref, lineNumber);
-        if (peeled.alias) nameAliasMap.set(peeled.alias, node.id);
-        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());
-      if (aliasResolved !== undefined) {
-        indentStack.push({ nodeId: aliasResolved, indent });
-        return aliasResolved;
-      }
-      return null;
-    }
-
-    // Process chain: alternating nodeText / arrowToken / nodeText / ...
-    let lastNodeId: string | null = null;
-    let pendingArrow: ArrowInfo | null = null;
-
-    for (let i = 0; i < segments.length; i++) {
-      // In-bounds by loop guard.
-      const seg = segments[i]!;
-
-      // Check if this is an arrow token
-      if (seg === '->' || /^-.+->$/.test(seg)) {
-        pendingArrow = parseArrowToken(
-          seg,
-          palette,
-          lineNumber,
-          result.diagnostics
-        );
-        continue;
-      }
-
-      // This is a node text segment. May carry an `as <alias>` postfix.
-      const peeled = peelAlias(seg);
-      let ref = parseNodeRef(peeled.seg);
-      if (!ref) {
-        // Bare alias reference inside a chain: `os -> ps`.
-        const aliasResolved = nameAliasMap.get(peeled.seg.trim());
-        if (aliasResolved !== undefined) {
-          // Synthesize a NodeRef shape that exactly matches the bound
-          // canonical entry — fed to getOrCreateNode (which dedups by id).
-          const existing = nodeMap.get(aliasResolved);
-          if (existing) {
-            ref = {
-              id: aliasResolved,
-              label: existing.label,
-              shape: existing.shape,
-            };
-          }
-        }
-      }
-      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 ?? effectiveSource;
-        if (sourceId) {
-          addEdge(sourceId, node.id, lineNumber, pendingArrow.label);
-        }
-        pendingArrow = null;
-      } else if (lastNodeId === null && effectiveSource === null) {
-        // First node in chain, no arrow yet — just register
-      }
-
-      lastNodeId = node.id;
-    }
-
-    // If we ended with a pending arrow but no target node, that's an edge-only line
-    // handled by: the arrow was at the start with implicit source
-    if (pendingArrow !== null && lastNodeId === null && implicitSourceId) {
-      // Edge-only line like `  -> ` with no target — ignore
-    }
-
-    // If line started with an arrow and we have an implicit source
-    // but no explicit first node, the first segment was empty
-    if (
-      segments.length >= 2 &&
-      segments[0] === '' &&
-      implicitSourceId &&
-      lastNodeId
-    ) {
-      // Already handled above — the implicit source was used
-    }
-
-    if (lastNodeId) {
-      indentStack.push({ nodeId: lastNodeId, indent });
-    }
-
-    return lastNodeId;
-  }
-
-  // === Main loop ===
-  for (let i = 0; i < lines.length; i++) {
-    // In-bounds by loop guard.
-    const raw = lines[i]!;
-    const trimmed = raw.trim();
-    const lineNumber = i + 1;
-    const indent = measureIndent(raw);
-
-    // Skip empty lines
-    if (!trimmed) continue;
-
-    // Skip comments
-    if (trimmed.startsWith('//')) continue;
-
-    // First line: try parseFirstLine for `flowchart [Title]`
-    if (!firstLineParsed && !contentStarted) {
-      const firstLineResult = parseFirstLine(trimmed);
-      if (firstLineResult) {
-        firstLineParsed = true;
-        if (firstLineResult.chartType !== 'flowchart') {
-          const allTypes = Array.from(ALL_CHART_TYPES);
-          let msg = `Expected chart type "flowchart", got "${firstLineResult.chartType}"`;
-          const hint = suggest(firstLineResult.chartType, allTypes);
-          if (hint) msg += `. ${hint}`;
-          return fail(lineNumber, msg);
-        }
-        if (firstLineResult.title) {
-          result.title = firstLineResult.title;
-          result.titleLineNumber = lineNumber;
-        }
-        continue;
-      }
-    }
-
-    // Note annotation: `note <ref> [inline body]` + optional indented
-    // body. Handled before options so `note foo bar` is never mistaken
-    // for an option. Only `note -> X` (arrow immediately after `note`) is
-    // excluded so it can edge; arrows are allowed inside a note body.
-    const noteResult = tryCollectNote(
-      lines,
-      i,
-      indent,
-      palette,
-      result.diagnostics
-    );
-    if (noteResult) {
-      if (noteResult.note) notes.push(noteResult.note);
-      i = noteResult.lastIndex;
-      continue;
-    }
-
-    // Options (space-separated, before content)
-    if (!contentStarted) {
-      // Bare boolean: direction-lr
-      if (/^direction-lr$/i.test(trimmed)) {
-        result.direction = 'LR';
-        continue;
-      }
-
-      // Bare boolean: solid-fill
-      if (/^solid-fill$/i.test(trimmed)) {
-        options['solid-fill'] = 'on';
-        continue;
-      }
-
-      // Removed: no-color
-      if (/^no-color$/i.test(trimmed)) {
-        result.diagnostics.push(
-          makeDgmoError(lineNumber, '"no-color" has been removed.', 'warning')
-        );
-        continue;
-      }
-
-      // Cross-chart-type bare booleans (no-title, etc.)
-      if (tryParseSharedOption(trimmed, options)) {
-        continue;
-      }
-
-      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
-      if (optMatch && !trimmed.includes('->')) {
-        // Capture groups 1 and 2 guaranteed present by successful regex match.
-        const key = optMatch[1]!.toLowerCase();
-        const value = optMatch[2]!.trim();
-
-        if (key === 'no-color') {
-          result.diagnostics.push(
-            makeDgmoError(
-              lineNumber,
-              '"no-color" was removed — node colors are assigned automatically by shape; delete this line.',
-              'warning'
-            )
-          );
-          continue;
-        }
-
-        // Store other options (e.g., color off)
-        options[key] = value;
-        continue;
-      }
-    }
-
-    // Content line (nodes and edges)
-    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
-  if (result.nodes.length === 0 && !result.error) {
-    const diag = makeDgmoError(
-      1,
-      'No nodes found. Add flowchart content with shape syntax like [Process] or (Start).'
-    );
-    result.diagnostics.push(diag);
-    result.error = formatDgmoError(diag);
-  }
-
-  // Resolve note refs (forward refs OK — runs after all nodes parsed).
-  // Emits diagnostics for unknown/ambiguous/duplicate refs; the resolved
-  // binding is recomputed in layout from `result.notes`.
-  if (notes.length > 0) {
-    result.notes = notes;
-    resolveNotes(notes, result.nodes, result.diagnostics);
-  }
-
-  // Warn about orphaned nodes (not referenced in any edge)
-  if (result.nodes.length >= 2 && result.edges.length >= 1 && !result.error) {
-    const connectedIds = new Set<string>();
-    for (const edge of result.edges) {
-      // edge endpoints are already-normalized node IDs (set via getOrCreateNode)
-      // eslint-disable-next-line name-normalize/required-at-insertion
-      connectedIds.add(edge.source);
-      // eslint-disable-next-line name-normalize/required-at-insertion
-      connectedIds.add(edge.target);
-    }
-    for (const node of result.nodes) {
-      if (!connectedIds.has(node.id)) {
-        result.diagnostics.push(
-          makeDgmoError(
-            node.lineNumber,
-            `Node "${node.label}" is not connected to any other node`,
-            'warning'
-          )
-        );
-      }
-    }
-  }
-
-  return result;
-}
-
-// ============================================================
-// Detection helper
-// ============================================================
-
-/**
- * Detect if content looks like a flowchart (without explicit `chart: flowchart` header).
- * Checks for shape delimiters combined with `->` arrows.
- * Avoids false-positives on sequence diagrams (which use bare names with `->`)
- */
-export function looksLikeFlowchart(content: string): boolean {
-  // Must have -> arrows
-  if (!content.includes('->')) return false;
-
-  // Must have at least one shape delimiter pattern
-  // Shape delimiters: [...], (...), <...>, /.../, [[...]], [...~]
-  // Sequence diagrams use bare names like "Alice -> Bob: msg" — no delimiters around names
-  const hasShapeDelimiter =
-    /\[[^\]]+\]/.test(content) ||
-    /\([^)]+\)/.test(content) ||
-    /<[^>]+>/.test(content) ||
-    /\/[^/]+\//.test(content);
-
-  if (!hasShapeDelimiter) return false;
-
-  // Check that shape delimiters appear near arrows (not just random brackets)
-  // Look for patterns like `[X] ->` or `-> [X]` or `(X) ->` etc.
-  const shapeNearArrow =
-    /[\])][ \t]*-.*->/.test(content) || // shape ] or ) followed by arrow
-    /->[ \t]*[[(</]/.test(content); // arrow followed by shape opener
-
-  return shapeNearArrow;
-}
-
-// ============================================================
-// Symbol extraction (for completion API)
-// ============================================================
-
-import type { DiagramSymbols } from '../completion-types';
-
-// Node ID: identifier at line start followed by a shape delimiter or space (arrow line)
-const NODE_ID_RE = /^([a-zA-Z_][\w-]*)[\s([</{]/;
-
-/**
- * Extract node IDs (entities) from flowchart document text.
- * Used by the dgmo completion API for ghost hints and popup completions.
- */
-export function extractSymbols(docText: string): DiagramSymbols {
-  const entities: string[] = [];
-  let inMetadata = true;
-  for (const rawLine of docText.split('\n')) {
-    const line = rawLine.trim();
-    // Skip old-style colon metadata and new-style space-separated options
-    if (
-      inMetadata &&
-      (/^[a-z-]+\s*:/i.test(line) || /^[a-z-]+\s+\S/i.test(line))
-    )
-      continue;
-    inMetadata = false;
-    if (line.length === 0 || /^\s/.test(rawLine)) continue;
-    const m = NODE_ID_RE.exec(line);
-    if (m && !entities.includes(m[1]!)) entities.push(m[1]!);
-  }
-  return { kind: 'flowchart', entities };
-}