agentic-mermaid 0.1.1 → 0.2.0

package/src/ascii/index.ts

@@ -1,196 +0,0 @@
-// ============================================================================
-// Agentic Mermaid — ASCII renderer public API (published as agentic-mermaid)
-//
-// Renders Mermaid diagrams to ASCII or Unicode box-drawing art.
-// No external dependencies — pure TypeScript.
-//
-// Supported diagram types:
-//   - Flowcharts (graph TD / flowchart LR) — grid-based layout with A* pathfinding
-//   - State diagrams (stateDiagram-v2) — same pipeline as flowcharts
-//   - Architecture diagrams (architecture-beta) — dedicated entrypoint built on graph layout
-//   - Sequence diagrams (sequenceDiagram) — column-based timeline layout
-//   - Class diagrams (classDiagram) — level-based UML layout
-//   - ER diagrams (erDiagram) — grid layout with crow's foot notation
-//   - Timeline diagrams (timeline) — chronological outline with grouped milestones
-//   - User Journey diagrams (journey) — scored task lists with actor annotations
-//   - XY charts (xychart / xychart-beta)
-//   - Pie charts (pie) — proportional slice list
-//   - Quadrant charts (quadrantChart) — coordinate plot with legend
-//   - Gantt charts (gantt) — sectioned schedule bars and milestones
-//
-// Usage:
-//   import { renderMermaidASCII } from 'agentic-mermaid'
-//   const ascii = renderMermaidASCII('graph LR\n  A --> B')
-// ============================================================================
-
-import { detectColorMode, DEFAULT_ASCII_THEME, diagramColorsToAsciiTheme } from './ansi.ts'
-import type { AsciiConfig, AsciiTheme, ColorMode } from './types.ts'
-import { normalizeMermaidSource, detectDiagramTypeFromFirstLine } from '../mermaid-source.ts'
-import type { MermaidRuntimeConfig } from '../mermaid-source.ts'
-import { getFamily } from '../render-family-hooks.ts'
-import type { DiagramKind } from '../agent/types.ts'
-
-// Re-export types for external use
-export type { AsciiTheme, ColorMode }
-export { DEFAULT_ASCII_THEME, detectColorMode, diagramColorsToAsciiTheme }
-
-export interface AsciiRenderOptions {
-  /** true = ASCII chars (+,-,|,>), false = Unicode box-drawing (┌,─,│,►). Default: false */
-  useAscii?: boolean
-  /** Horizontal spacing between nodes. Default: 5 */
-  paddingX?: number
-  /** Vertical spacing between nodes. Default: 5 */
-  paddingY?: number
-  /** Padding inside node boxes. Default: 1 */
-  boxBorderPadding?: number
-  /**
-   * Color mode for output.
-   * - 'none': No colors (plain text)
-   * - 'auto': Auto-detect (terminal ANSI capabilities, or HTML in browsers)
-   * - 'ansi16': 16-color ANSI
-   * - 'ansi256': 256-color xterm
-   * - 'truecolor': 24-bit RGB
-   * - 'html': HTML <span> tags with inline color styles (for browser rendering)
-   * Default: 'auto'
-   */
-  colorMode?: ColorMode | 'auto'
-  /** Theme colors for ASCII output. Uses default theme if not provided. */
-  theme?: Partial<AsciiTheme>
-  /** Optional Mermaid-style runtime config (analogous to initialize/frontmatter config). */
-  mermaidConfig?: MermaidRuntimeConfig
-  /**
-   * Loop 9 M13: cap output width in characters. When set, node labels wrap
-   * at word boundaries to fit within `maxWidth / 3` per node. Single words
-   * longer than `maxWidth / 2` render anyway (with a console.warn). The
-   * overall canvas may still exceed `maxWidth` if the diagram has many
-   * parallel columns; this is best-effort wrapping, not hard truncation.
-   */
-  maxWidth?: number
-  /**
-   * Explicit "today" for the Gantt todayMarker (date in the diagram's
-   * dateFormat or ISO YYYY-MM-DD). Gantt never reads the wall clock; without
-   * this the marker is not drawn.
-   */
-  ganttToday?: string
-}
-
-/**
- * Render Mermaid diagram text to an ASCII/Unicode string.
- *
- * Synchronous — no async layout engine needed (unlike the SVG renderer).
- * Auto-detects diagram type from the header line and dispatches to
- * the appropriate renderer.
- *
- * @param text - Mermaid source text (any supported diagram type)
- * @param options - Rendering options
- * @returns Multi-line ASCII/Unicode string
- *
- * @example
- * ```ts
- * const result = renderMermaidAscii(`
- *   graph LR
- *     A --> B --> C
- * `, { useAscii: true })
- *
- * // Output:
- * // +---+     +---+     +---+
- * // |   |     |   |     |   |
- * // | A |---->| B |---->| C |
- * // |   |     |   |     |   |
- * // +---+     +---+     +---+
- * ```
- */
-export function renderMermaidASCII(
-  text: string,
-  options: AsciiRenderOptions = {},
-): string {
-  const config: AsciiConfig = {
-    useAscii: options.useAscii ?? false,
-    paddingX: options.paddingX ?? 5,
-    paddingY: options.paddingY ?? 5,
-    boxBorderPadding: options.boxBorderPadding ?? 1,
-    graphDirection: 'TD', // default, overridden for flowcharts below
-  }
-
-  // Resolve color mode ('auto' or unset → detect environment, otherwise use specified mode)
-  const colorMode: ColorMode = options.colorMode === 'auto' || options.colorMode === undefined
-    ? detectColorMode()
-    : options.colorMode
-
-  // Merge user theme with defaults
-  const theme: AsciiTheme = { ...DEFAULT_ASCII_THEME, ...options.theme }
-  // Loop 9 M13: apply pre-render label wrapping if maxWidth is set. Walks
-  // the source and rewrites bracket-quoted labels to insert <br/> at word
-  // boundaries when the label exceeds (maxWidth / 3). Family-agnostic
-  // because every renderer respects <br/> as a hard line break.
-  const sourceText = options.maxWidth ? wrapLabelsInSource(text, options.maxWidth) : text
-  const normalizedSource = normalizeMermaidSource(sourceText, options.mermaidConfig ?? {})
-
-  const diagramType = detectDiagramTypeFromFirstLine(normalizedSource.firstLine) ?? 'flowchart'
-
-  const family = getFamily(diagramType as DiagramKind)
-  if (!family?.renderAscii) {
-    throw new Error(`No ASCII renderer registered for Mermaid family ${diagramType}`)
-  }
-  return family.renderAscii({
-    source: normalizedSource,
-    config,
-    colorMode,
-    theme,
-    options: {
-      maxWidth: options.maxWidth,
-      ganttToday: options.ganttToday,
-    },
-  })
-}
-
-/** @deprecated Use `renderMermaidASCII` */
-export const renderMermaidAscii = renderMermaidASCII
-
-/**
- * Loop 9 M13: wrap a single label string at word boundaries to fit a column
- * width. Words longer than `maxLineWidth` emit a warn and render as-is.
- * Returns the label with `<br/>` separators between wrapped lines.
- */
-export function wrapLabel(text: string, maxLineWidth: number): string {
-  if (text.length <= maxLineWidth) return text
-  const words = text.split(/\s+/).filter(Boolean)
-  const lines: string[] = []
-  let current = ''
-  for (const word of words) {
-    if (word.length > maxLineWidth) {
-      // Word can't fit on its own line — emit warning, render anyway.
-      // eslint-disable-next-line no-console
-      console.warn(`wrapLabel: word "${word.slice(0, 20)}..." exceeds maxLineWidth=${maxLineWidth}`)
-      if (current) lines.push(current)
-      lines.push(word)
-      current = ''
-      continue
-    }
-    if (current.length === 0) current = word
-    else if (current.length + 1 + word.length <= maxLineWidth) current += ' ' + word
-    else { lines.push(current); current = word }
-  }
-  if (current) lines.push(current)
-  return lines.join('<br/>')
-}
-
-/**
- * Walk Mermaid source and wrap bracket-quoted labels (`["..."]`, `[...]`,
- * `(...)`, `{...}`, `((...))`) whose contents exceed `maxWidth / 3` columns.
- * Family-agnostic — works on flowchart node labels, sequence message text,
- * class members, etc.
- */
-function wrapLabelsInSource(source: string, maxWidth: number): string {
-  const perLabel = Math.max(8, Math.floor(maxWidth / 3))
-  // Match bracket-quoted labels: ["text"], [text], (text), {text}, ((text))
-  // Skip already-wrapped labels (those containing <br/>) and identifier-only labels.
-  return source.replace(/(\[\[|\(\(|\[|\(|\{)("?)([^\[\]\(\)\{\}\n]+)\2(\]\]|\)\)|\]|\)|\})/g,
-    (full, open: string, quote: string, inner: string, close: string) => {
-      if (inner.length <= perLabel || inner.includes('<br/>')) return full
-      // Don't wrap identifier-like content (no spaces, looks like a variable)
-      if (!inner.includes(' ')) return full
-      const wrapped = wrapLabel(inner, perLabel)
-      return open + quote + wrapped + quote + close
-    })
-}

package/src/ascii/journey.ts

@@ -1,169 +0,0 @@
-// ============================================================================
-// ASCII renderer — journey diagrams
-//
-// Renders Mermaid user journeys as compact scored task lists with optional
-// section headings and actor annotations.
-// ============================================================================
-
-import { parseJourneyDiagram } from '../journey/parser.ts'
-import type { JourneyDiagram } from '../journey/types.ts'
-import { preprocessMermaidLines } from '../mermaid-source.ts'
-import { colorizeLine, DEFAULT_ASCII_THEME } from './ansi.ts'
-import type { AsciiConfig, AsciiTheme, CharRole, ColorMode } from './types.ts'
-import { visualWidth } from './width.ts'
-import { wrapText } from './wrap.ts'
-
-interface StyledSegment {
-  text: string
-  role: CharRole | null
-}
-
-function renderStyledLine(
-  segments: StyledSegment[],
-  colorMode: ColorMode,
-  theme: AsciiTheme,
-): string {
-  const chars: string[] = []
-  const roles: (CharRole | null)[] = []
-
-  for (const segment of segments) {
-    for (const char of segment.text) {
-      chars.push(char)
-      roles.push(segment.role)
-    }
-  }
-
-  return colorizeLine(chars, roles, theme, colorMode)
-}
-
-function renderScoreSegments(score: number, useAscii: boolean): StyledSegment[] {
-  const filled = useAscii ? '#' : '●'
-  const empty = useAscii ? '.' : '○'
-
-  const segments: StyledSegment[] = [
-    { text: filled.repeat(score), role: 'arrow' },
-    { text: empty.repeat(5 - score), role: 'border' },
-  ]
-  return segments.filter(segment => segment.text.length > 0)
-}
-
-/** Block glyphs for scores 1..5 — five distinct heights, lowest to full. */
-const SCORE_BLOCKS = ['▁', '▂', '▄', '▆', '█'] as const
-
-/**
- * Score trajectory strip — one glyph per task in source order, a single
- * space between sections. Mirrors the SVG renderer's experience curve so
- * terminal output conveys the trajectory too. ASCII mode uses the score
- * digits themselves. Scores are parser-validated to the 1..5 range.
- */
-function renderScoreStrip(diagram: JourneyDiagram, useAscii: boolean): string {
-  return diagram.sections
-    .map(section => section.tasks
-      .map(task => useAscii ? String(task.score) : SCORE_BLOCKS[task.score - 1]!)
-      .join(''))
-    .filter(group => group.length > 0)
-    .join(' ')
-}
-
-/**
- * Render a Mermaid journey diagram to ASCII/Unicode text.
- */
-export function renderJourneyAscii(
-  text: string,
-  config: AsciiConfig,
-  colorMode: ColorMode = 'none',
-  theme: AsciiTheme = DEFAULT_ASCII_THEME,
-  maxWidth?: number,
-): string {
-  const lines = preprocessMermaidLines(text)
-  const diagram = parseJourneyDiagram(lines)
-  const useAscii = config.useAscii
-  const out: string[] = []
-  const pushLine = (segments: StyledSegment[] = []): void => {
-    out.push(segments.length === 0 ? '' : renderStyledLine(segments, colorMode, theme))
-  }
-
-  if (diagram.title) {
-    for (const line of wrapText(diagram.title, maxWidth)) {
-      pushLine([{ text: line, role: 'text' }])
-    }
-    pushLine()
-  }
-
-  const scoreStrip = renderScoreStrip(diagram, useAscii)
-  if (scoreStrip) {
-    const stripPrefix = 'scores: '
-    const stripLines = wrapText(scoreStrip, maxWidth ? Math.max(1, maxWidth - stripPrefix.length) : undefined, { hyphenate: false })
-    stripLines.forEach((line, index) => {
-      pushLine([
-        index === 0
-          ? { text: stripPrefix, role: 'border' }
-          : { text: ' '.repeat(stripPrefix.length), role: null },
-        { text: line, role: 'arrow' },
-      ])
-    })
-    pushLine()
-  }
-
-  for (let sectionIndex = 0; sectionIndex < diagram.sections.length; sectionIndex++) {
-    const section = diagram.sections[sectionIndex]!
-
-    if (section.label) {
-      // Bracket only the first line of a wrapped label — bracketing every
-      // line would read as one section per line. Continuations indent by
-      // one cell to align inside the opening bracket.
-      const labelLines = wrapText(section.label.replace(/\n/g, ' / '), maxWidth ? Math.max(1, maxWidth - 2) : undefined)
-      labelLines.forEach((line, index) => {
-        const segments: StyledSegment[] = [
-          index === 0
-            ? { text: '[', role: 'border' }
-            : { text: ' ', role: null },
-          { text: line, role: 'text' },
-        ]
-        if (index === labelLines.length - 1) segments.push({ text: ']', role: 'border' })
-        pushLine(segments)
-      })
-    }
-
-    for (let taskIndex = 0; taskIndex < section.tasks.length; taskIndex++) {
-      const task = section.tasks[taskIndex]!
-      const scoreSegments = renderScoreSegments(task.score, useAscii)
-      const scoreWidth = 5
-      const taskPrefixWidth = scoreWidth + 1
-      const taskLines = wrapText(task.text, maxWidth ? Math.max(1, maxWidth - taskPrefixWidth) : undefined)
-
-      pushLine([
-        ...scoreSegments,
-        { text: ' ', role: null },
-        { text: taskLines[0] ?? '', role: 'text' },
-      ])
-      for (const line of taskLines.slice(1)) {
-        pushLine([
-          { text: ' '.repeat(taskPrefixWidth), role: null },
-          { text: line, role: 'text' },
-        ])
-      }
-
-      if (task.actors.length > 0) {
-        const actorPrefix = '  by '
-        const actorLines = wrapText(task.actors.join(', '), maxWidth ? Math.max(1, maxWidth - visualWidth(actorPrefix)) : undefined)
-        actorLines.forEach((line, index) => {
-          pushLine([
-            { text: index === 0 ? '  ' : ' '.repeat(visualWidth(actorPrefix)), role: null },
-            ...(index === 0 ? [
-              { text: 'by', role: 'border' as const },
-              { text: ' ', role: null },
-            ] : []),
-            { text: line, role: 'text' },
-          ])
-        })
-      }
-
-      const moreTasks = taskIndex < section.tasks.length - 1
-      const moreSections = sectionIndex < diagram.sections.length - 1
-      if (moreTasks || moreSections) pushLine()
-    }
-  }
-
-  return out.join('\n').trimEnd()
-}

package/src/ascii/meta.ts

@@ -1,244 +0,0 @@
-// ============================================================================
-// renderMermaidASCIIWithMeta — render ASCII art and return per-region metadata.
-//
-// Loop 9 M11. The intended use case is TUI integration: callers (e.g. a TUI
-// debugger) need to know which characters in the rendered grid correspond to
-// which node id so they can highlight, click-target, or scroll-anchor a
-// region.
-//
-// Implementation choice: rather than instrument every renderer to capture
-// per-character roles (which would touch grid.ts, canvas.ts, draw.ts, and
-// every family-specific renderer), this module derives regions by scanning
-// the rendered string for known node labels. This is honest about what it
-// can prove:
-//   - Flowchart / state: regions for each node by label match. Flowchart
-//     subgraphs are exposed as best-effort label regions using the same stable
-//     ids as SVG/layout JSON; edge spans remain deferred until renderer
-//     instrumentation lands.
-//   - Sequence / class / ER / timeline / gantt / journey / xychart /
-//     architecture: regions for each participant / class / entity / section /
-//     task, derived by label scan. Best-effort; some renderers wrap labels
-//     and the scan misses them.
-//
-// Determinism: identical input → identical regions (no randomness, no
-// timestamps). Region order follows the scan order (top-down, left-to-right).
-// ============================================================================
-
-import { renderMermaidASCII, type AsciiRenderOptions } from './index.ts'
-import { parseMermaid } from '../agent/parse.ts'
-
-export type RegionKind = 'node' | 'edge' | 'label' | 'subgraph'
-
-export type AsciiWarningCode = 'ASCII_RENDER_FAILED' | 'ASCII_EDGE_REGION_UNMAPPED'
-export interface AsciiWarning { code: AsciiWarningCode; message: string; severity: 'degraded' }
-
-export const ASCII_ROUTE_PARITY_CONTRACT = {
-  version: 1,
-  routeIntent: 'shared-route-classes',
-  svgSource: 'route-contract classifyRoutes() + certificates',
-  asciiSource: 'grid router seeded with classifyRoutes() routeClass metadata, longest-path layering, and direct-lane-first routing',
-  degradationWarnings: ['ASCII_RENDER_FAILED', 'ASCII_EDGE_REGION_UNMAPPED'],
-} as const
-
-export interface AsciiRegion {
-  kind: RegionKind
-  /** Stable identifier for the diagram element (e.g. node id, participant id). */
-  id: string
-  /** Optional 1-based source line where the element was declared, when known. */
-  sourceLine?: number
-  /** 0-based row in the rendered canvas where the region starts. */
-  canvasRow: number
-  /** 0-based column where the region starts (inclusive). */
-  canvasColStart: number
-  /** 0-based column where the region ends (exclusive). */
-  canvasColEnd: number
-  /** Optional row count when the region spans multiple lines (boxed node). */
-  rowSpan?: number
-}
-
-export interface AsciiWithMeta {
-  ascii: string
-  regions: AsciiRegion[]
-  warnings: AsciiWarning[]
-  routeParity: typeof ASCII_ROUTE_PARITY_CONTRACT
-}
-
-export function renderMermaidASCIIWithMeta(input: string, opts: AsciiRenderOptions = {}): AsciiWithMeta {
-  // Mirror parseMermaid's structured-or-opaque rule: if the renderer rejects
-  // the source (parse failure), surface empty regions rather than throwing —
-  // the meta API is read-only and shouldn't propagate parser errors.
-  try {
-    const ascii = renderMermaidASCII(input, opts)
-    const regions = deriveRegions(ascii, input)
-    return { ascii, regions, warnings: deriveWarnings(input, regions), routeParity: ASCII_ROUTE_PARITY_CONTRACT }
-  } catch {
-    return { ascii: '', regions: [], warnings: [{ code: 'ASCII_RENDER_FAILED', severity: 'degraded', message: 'ASCII/Unicode renderer failed; no route parity evidence is available.' }], routeParity: ASCII_ROUTE_PARITY_CONTRACT }
-  }
-}
-
-function deriveWarnings(source: string, regions: AsciiRegion[]): AsciiWarning[] {
-  const parsed = parseMermaid(source)
-  if (!parsed.ok) return []
-  if (parsed.value.body.kind !== 'flowchart' && parsed.value.body.kind !== 'state') return []
-  const edgeRegions = regions.filter(r => r.kind === 'edge').length
-  const edgeCount = parsed.value.body.kind === 'flowchart' ? parsed.value.body.graph.edges.length : parsed.value.body.transitions.length
-  if (edgeCount > 0 && edgeRegions === 0) {
-    return [{
-      code: 'ASCII_EDGE_REGION_UNMAPPED',
-      severity: 'degraded',
-      message: 'ASCII route drawing follows the explicit route-intent parity mapping, but per-edge cell spans are not instrumented yet.',
-    }]
-  }
-  return []
-}
-
-interface Candidate { id: string; label: string; sourceLine?: number; kind?: RegionKind }
-
-function addCandidate(out: Candidate[], id: string, label: string | undefined, sourceLine?: number, kind: RegionKind = 'node'): void {
-  const normalized = label?.trim()
-  if (!normalized) return
-  out.push({ id, label: normalized, sourceLine, kind })
-}
-
-function addCandidateWithFallback(out: Candidate[], id: string, label: string | undefined, sourceLine?: number, kind: RegionKind = 'node'): void {
-  addCandidate(out, id, label, sourceLine, kind)
-  if (label !== id) addCandidate(out, id, id, sourceLine, kind)
-}
-
-function deriveRegions(ascii: string, source: string): AsciiRegion[] {
-  const candidates = candidatesForDiagram(source)
-  if (candidates.length === 0) return []
-  const lines = ascii.split('\n')
-  // Sort longest label first so 'Alpha' wins over 'A' on the same row.
-  const sorted = [...candidates].sort((a, b) => b.label.length - a.label.length)
-  // Track regions already assigned so a label scan doesn't double-match.
-  const used = new Set<string>()
-  const out: AsciiRegion[] = []
-  for (let row = 0; row < lines.length; row++) {
-    const line = lines[row]!
-    for (const c of sorted) {
-      if (used.has(c.id)) continue
-      const idx = line.indexOf(c.label)
-      if (idx < 0) continue
-      out.push({
-        kind: c.kind ?? 'node',
-        id: c.id,
-        sourceLine: c.sourceLine,
-        canvasRow: row,
-        canvasColStart: idx,
-        canvasColEnd: idx + c.label.length,
-      })
-      used.add(c.id)
-    }
-  }
-  // Stable order: by canvasRow then canvasColStart.
-  out.sort((a, b) => a.canvasRow - b.canvasRow || a.canvasColStart - b.canvasColStart)
-  return out
-}
-
-function candidatesForDiagram(source: string): Candidate[] {
-  const r = parseMermaid(source)
-  if (!r.ok) return []
-  const d = r.value
-  if (d.body.kind === 'flowchart') {
-    const out: Candidate[] = []
-    for (const n of d.body.graph.nodes.values()) addCandidateWithFallback(out, n.id, n.label && n.label.length > 0 ? n.label : n.id, d.source.nodes.get(n.id)?.line)
-    const visit = (groups: typeof d.body.graph.subgraphs): void => {
-      for (const g of groups) {
-        addCandidateWithFallback(out, g.id, g.label || g.id, d.source.groups.get(g.id)?.line, 'subgraph')
-        visit(g.children)
-      }
-    }
-    visit(d.body.graph.subgraphs)
-    return out
-  }
-  if (d.body.kind === 'state') {
-    const out: Candidate[] = []
-    const visit = (states: typeof d.body.states): void => {
-      for (const s of states) {
-        addCandidateWithFallback(out, s.id, s.label ?? s.id)
-        if (s.states) visit(s.states)
-      }
-    }
-    visit(d.body.states)
-    return out
-  }
-  if (d.body.kind === 'sequence') {
-    return d.body.participants.flatMap(p => {
-      const out: Candidate[] = []
-      addCandidateWithFallback(out, p.id, p.label || p.id)
-      return out
-    })
-  }
-  if (d.body.kind === 'class') {
-    return d.body.classes.flatMap(c => {
-      const out: Candidate[] = []
-      addCandidateWithFallback(out, c.id, c.label || c.id)
-      return out
-    })
-  }
-  if (d.body.kind === 'er') {
-    return d.body.entities.map(e => ({ id: e.id, label: e.id }))
-  }
-  if (d.body.kind === 'timeline') {
-    const out: Candidate[] = []
-    for (const s of d.body.sections) {
-      addCandidate(out, s.id, s.label)
-      for (const p of s.periods) addCandidate(out, p.id, p.label)
-    }
-    return out
-  }
-  if (d.body.kind === 'journey') {
-    const out: Candidate[] = []
-    addCandidate(out, 'title', d.body.title)
-    for (const s of d.body.sections) {
-      addCandidate(out, s.id, s.label)
-      for (const t of s.tasks) addCandidate(out, t.id, t.text)
-    }
-    return out
-  }
-  if (d.body.kind === 'architecture') {
-    const out: Candidate[] = []
-    for (const g of d.body.groups) addCandidateWithFallback(out, g.id, g.label || g.id)
-    for (const s of d.body.services) addCandidateWithFallback(out, s.id, s.label || s.id)
-    return out
-  }
-  if (d.body.kind === 'xychart') {
-    const out: Candidate[] = []
-    addCandidate(out, 'title', d.body.title)
-    addCandidate(out, 'x-axis', d.body.xAxis?.name)
-    addCandidate(out, 'y-axis', d.body.yAxis?.name)
-    d.body.xAxis?.categories?.forEach((label, index) => addCandidate(out, `x-category-${index}`, label))
-    for (const s of d.body.series) addCandidate(out, s.id, s.name)
-    return out
-  }
-  if (d.body.kind === 'pie') {
-    const out: Candidate[] = []
-    addCandidate(out, 'title', d.body.title)
-    for (const s of d.body.slices) addCandidate(out, s.id, s.label)
-    return out
-  }
-  if (d.body.kind === 'quadrant') {
-    const out: Candidate[] = []
-    addCandidate(out, 'title', d.body.title)
-    addCandidate(out, 'x-axis-near', d.body.xAxis?.near)
-    addCandidate(out, 'x-axis-far', d.body.xAxis?.far)
-    addCandidate(out, 'y-axis-near', d.body.yAxis?.near)
-    addCandidate(out, 'y-axis-far', d.body.yAxis?.far)
-    d.body.quadrants.forEach((label, index) => addCandidate(out, `quadrant-${index + 1}`, label))
-    d.body.points.forEach((p, index) => addCandidate(out, `point-${index}`, p.label))
-    return out
-  }
-  if (d.body.kind === 'gantt') {
-    // Issue #26 WS10: gantt tasks/sections as stable click-mappable regions.
-    // Region ids prefer the Mermaid task id (the durable handle agents use in
-    // after/until/click) over the parse-order internal id.
-    const out: Candidate[] = []
-    for (const s of d.body.sections) {
-      addCandidate(out, s.id, s.label)
-      for (const t of s.tasks) addCandidate(out, t.taskId ?? t.id, t.label)
-    }
-    return out
-  }
-  return []
-}

package/src/ascii/multiline-utils.ts

@@ -1,80 +0,0 @@
-// ============================================================================
-// ASCII renderer — multi-line text utilities
-//
-// Shared utilities for handling multi-line labels (containing \n from <br> tags)
-// in ASCII/Unicode rendering. Provides consistent text splitting, sizing, and
-// centered rendering across all diagram types.
-// ============================================================================
-
-import type { Canvas } from './types.ts'
-import { drawText } from './canvas.ts'
-import { charVisualWidth, visualWidth } from './width.ts'
-
-export { charVisualWidth, visualWidth }
-
-/**
- * Split a label into lines.
- * Labels are already normalized by parsers (br tags → \n).
- */
-export function splitLines(label: string): string[] {
-  return label.split('\n')
-}
-
-/**
- * Get the maximum line width for sizing calculations.
- * Used to determine column widths for multi-line labels.
- */
-export function maxLineWidth(label: string): number {
-  const lines = splitLines(label)
-  return Math.max(...lines.map(l => visualWidth(l)), 0)
-}
-
-/**
- * Get the number of lines for height calculations.
- * Used to determine row heights for multi-line labels.
- */
-export function lineCount(label: string): number {
-  return splitLines(label).length
-}
-
-/**
- * Draw multi-line text centered at (cx, cy).
- * Expands vertically from the center point.
- * Each line is horizontally centered independently.
- */
-export function drawMultilineTextCentered(
-  canvas: Canvas,
-  label: string,
-  cx: number,
-  cy: number
-): void {
-  const lines = splitLines(label)
-  const totalHeight = lines.length
-  // Center vertically: start y positions lines evenly around cy
-  const startY = cy - Math.floor((totalHeight - 1) / 2)
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!
-    // Center each line horizontally by terminal column width.
-    const startX = cx - Math.floor(visualWidth(line) / 2)
-    // Force overwrite for node labels (they take priority)
-    drawText(canvas, { x: startX, y: startY + i }, line, true)
-  }
-}
-
-/**
- * Draw multi-line text left-aligned starting at (x, y).
- * Each subsequent line is placed one row below.
- */
-export function drawMultilineTextLeft(
-  canvas: Canvas,
-  label: string,
-  x: number,
-  y: number
-): void {
-  const lines = splitLines(label)
-  for (let i = 0; i < lines.length; i++) {
-    // Force overwrite for node labels (they take priority)
-    drawText(canvas, { x, y: y + i }, lines[i]!, true)
-  }
-}