agentic-mermaid 0.1.1 → 0.2.0

package/src/ascii/sequence.ts

@@ -1,499 +0,0 @@
-// ============================================================================
-// ASCII renderer — sequence diagrams
-//
-// Renders sequenceDiagram text to ASCII/Unicode art using a column-based layout.
-// Each actor occupies a column with a vertical lifeline; messages are horizontal
-// arrows between lifelines. Blocks (loop/alt/opt/par) wrap around message groups.
-//
-// Layout is fundamentally different from flowcharts — no grid or A* pathfinding.
-// Instead: actors → columns, messages → rows, all positioned linearly.
-// ============================================================================
-
-import { parseSequenceDiagram } from '../sequence/parser.ts'
-import type { SequenceDiagram, Block } from '../sequence/types.ts'
-import type { Canvas, AsciiConfig, RoleCanvas, CharRole, AsciiTheme, ColorMode } from './types.ts'
-import { mkCanvas, mkRoleCanvas, canvasToString, increaseSize, increaseRoleCanvasSize, setRole } from './canvas.ts'
-import { splitLines, maxLineWidth, lineCount } from './multiline-utils.ts'
-import { visualWidth, charVisualWidth } from './width.ts'
-
-/** Classify a box-drawing character as 'border' or 'text'. */
-function classifyBoxChar(ch: string): CharRole {
-  if (/^[┌┐└┘├┤┬┴┼│─╭╮╰╯+\-|]$/.test(ch)) return 'border'
-  return 'text'
-}
-
-/**
- * Render a Mermaid sequence diagram to ASCII/Unicode text.
- *
- * Pipeline: parse → layout (columns + rows) → draw onto canvas → string.
- */
-export function renderSequenceAscii(text: string, config: AsciiConfig, colorMode?: ColorMode, theme?: AsciiTheme): string {
-  const lines = text.split('\n').map(l => l.trim()).filter(l => l.length > 0 && !l.startsWith('%%'))
-  const diagram = parseSequenceDiagram(lines)
-
-  if (diagram.actors.length === 0) return ''
-
-  const useAscii = config.useAscii
-
-  // Box-drawing characters
-  const H = useAscii ? '-' : '─'
-  const V = useAscii ? '|' : '│'
-  const TL = useAscii ? '+' : '┌'
-  const TR = useAscii ? '+' : '┐'
-  const BL = useAscii ? '+' : '└'
-  const BR = useAscii ? '+' : '┘'
-  const JT = useAscii ? '+' : '┬' // top junction on lifeline
-  const JB = useAscii ? '+' : '┴' // bottom junction on lifeline
-  const JL = useAscii ? '+' : '├' // left junction
-  const JR = useAscii ? '+' : '┤' // right junction
-
-  // ---- LAYOUT: compute lifeline X positions ----
-
-  const actorIdx = new Map<string, number>()
-  diagram.actors.forEach((a, i) => actorIdx.set(a.id, i))
-
-  const boxPad = 1
-  // Use max line width for multi-line actor labels
-  const actorBoxWidths = diagram.actors.map(a => maxLineWidth(a.label) + 2 * boxPad + 2)
-  const halfBox = actorBoxWidths.map(w => Math.ceil(w / 2))
-  // Calculate actor box heights based on number of lines in label
-  const actorBoxHeights = diagram.actors.map(a => lineCount(a.label) + 2) // lines + top/bottom border
-  const actorBoxH = Math.max(...actorBoxHeights, 3) // Use max height for consistent lifeline positioning
-
-  // Compute minimum gap between adjacent lifelines based on message labels.
-  // For messages spanning multiple actors, distribute the required width across gaps.
-  const adjMaxWidth: number[] = new Array(Math.max(diagram.actors.length - 1, 0)).fill(0)
-
-  for (const msg of diagram.messages) {
-    const fi = actorIdx.get(msg.from)!
-    const ti = actorIdx.get(msg.to)!
-    if (fi === ti) continue // self-messages don't affect spacing
-    const lo = Math.min(fi, ti)
-    const hi = Math.max(fi, ti)
-    // Required gap per span = (max line width + arrow decorations) / number of gaps
-    const needed = maxLineWidth(msg.label) + 4
-    const numGaps = hi - lo
-    const perGap = Math.ceil(needed / numGaps)
-    for (let g = lo; g < hi; g++) {
-      adjMaxWidth[g] = Math.max(adjMaxWidth[g]!, perGap)
-    }
-  }
-
-  // Compute lifeline x-positions (greedy left-to-right)
-  const llX: number[] = [halfBox[0]!]
-  for (let i = 1; i < diagram.actors.length; i++) {
-    const gap = Math.max(
-      halfBox[i - 1]! + halfBox[i]! + 2,
-      adjMaxWidth[i - 1]! + 2,
-      10,
-    )
-    llX[i] = llX[i - 1]! + gap
-  }
-
-  // ---- LAYOUT: compute vertical positions for messages ----
-
-  // For each message index, track the y where its arrow is drawn.
-  // Also track block start/end y positions and divider y positions.
-  const msgArrowY: number[] = []
-  const msgLabelY: number[] = []
-  const blockStartY = new Map<number, number>()
-  const blockEndY = new Map<number, number>()
-  const divYMap = new Map<string, number>() // "blockIdx:divIdx" → y
-  const notePositions: Array<{ x: number; y: number; width: number; height: number; lines: string[] }> = []
-
-  let curY = actorBoxH // start right below header boxes
-
-  const positionNote = (note: SequenceDiagram['notes'][number], y: number) => {
-    const nLines = splitLines(note.text)
-    const nWidth = Math.max(...nLines.map(line => maxLineWidth(line)), 0) + 4
-    const nHeight = nLines.length + 2
-    const aIdx = actorIdx.get(note.actorIds[0]!) ?? 0
-    let nx: number
-    if (note.position === 'left') {
-      nx = llX[aIdx]! - nWidth - 1
-    } else if (note.position === 'right') {
-      nx = llX[aIdx]! + 2
-    } else if (note.actorIds.length >= 2) {
-      const aIdx2 = actorIdx.get(note.actorIds[note.actorIds.length - 1]!) ?? aIdx
-      nx = Math.floor((llX[aIdx]! + llX[aIdx2]!) / 2) - Math.floor(nWidth / 2)
-    } else {
-      nx = llX[aIdx]! - Math.floor(nWidth / 2)
-    }
-    return { x: Math.max(0, nx), y, width: nWidth, height: nHeight, lines: nLines }
-  }
-
-  for (const note of diagram.notes) {
-    if (note.afterIndex !== -1) continue
-    curY += 1
-    const positioned = positionNote(note, curY)
-    notePositions.push(positioned)
-    curY += positioned.height
-  }
-
-  for (let m = 0; m < diagram.messages.length; m++) {
-    // Block openings at this message
-    for (let b = 0; b < diagram.blocks.length; b++) {
-      if (diagram.blocks[b]!.startIndex === m) {
-        curY += 2 // 1 blank + 1 header row
-        blockStartY.set(b, curY - 1)
-      }
-    }
-
-    // Dividers at this message index
-    for (let b = 0; b < diagram.blocks.length; b++) {
-      for (let d = 0; d < diagram.blocks[b]!.dividers.length; d++) {
-        if (diagram.blocks[b]!.dividers[d]!.index === m) {
-          curY += 1
-          divYMap.set(`${b}:${d}`, curY)
-          curY += 1
-        }
-      }
-    }
-
-    curY += 1 // blank row before message
-
-    const msg = diagram.messages[m]!
-    const isSelf = msg.from === msg.to
-
-    // Calculate height needed for multi-line message labels
-    const msgLineCount = lineCount(msg.label)
-
-    if (isSelf) {
-      // Self-message occupies 3+ rows: top-arm, label-col(s), bottom-arm
-      msgLabelY[m] = curY + 1
-      msgArrowY[m] = curY
-      curY += 2 + msgLineCount // top-arm + label lines + bottom-arm
-    } else {
-      // Normal message: label row(s) then arrow row
-      msgLabelY[m] = curY
-      msgArrowY[m] = curY + msgLineCount  // arrow goes after all label lines
-      curY += msgLineCount + 1  // label lines + arrow row
-    }
-
-    // Notes after this message
-    for (let n = 0; n < diagram.notes.length; n++) {
-      if (diagram.notes[n]!.afterIndex === m) {
-        curY += 1
-        const note = diagram.notes[n]!
-        const positioned = positionNote(note, curY)
-        notePositions.push(positioned)
-        curY += positioned.height
-      }
-    }
-
-    // Block closings after this message
-    for (let b = 0; b < diagram.blocks.length; b++) {
-      if (diagram.blocks[b]!.endIndex === m) {
-        curY += 1
-        blockEndY.set(b, curY)
-        curY += 1
-      }
-    }
-  }
-
-  curY += 1 // gap before footer
-  const footerY = curY
-  const totalH = footerY + actorBoxH
-
-  // Total canvas width
-  const lastLL = llX[llX.length - 1] ?? 0
-  const lastHalf = halfBox[halfBox.length - 1] ?? 0
-  let totalW = lastLL + lastHalf + 2
-
-  // Ensure canvas is wide enough for self-message labels and notes.
-  // Use maxLineWidth so multi-line self labels (e.g. "hello<br/>world") get
-  // sized by the longest line rather than the raw concatenated string length.
-  for (let m = 0; m < diagram.messages.length; m++) {
-    const msg = diagram.messages[m]!
-    if (msg.from === msg.to) {
-      const fi = actorIdx.get(msg.from)!
-      const selfRight = llX[fi]! + 6 + 2 + maxLineWidth(msg.label)
-      totalW = Math.max(totalW, selfRight + 1)
-    }
-  }
-  for (const np of notePositions) {
-    totalW = Math.max(totalW, np.x + np.width + 1)
-  }
-
-  const canvas = mkCanvas(totalW, totalH - 1)
-  const rc = mkRoleCanvas(totalW, totalH - 1)
-
-  /** Set a character on the canvas and track its role. */
-  function setC(x: number, y: number, ch: string, role: CharRole): void {
-    if (x >= 0 && x < canvas.length && y >= 0 && y < (canvas[0]?.length ?? 0)) {
-      canvas[x]![y] = ch
-      setRole(rc, x, y, role)
-    }
-  }
-
-  // ---- DRAW: helper to place a bordered actor box (supports multi-line labels) ----
-
-  function drawActorBox(cx: number, topY: number, label: string): void {
-    const lines = splitLines(label)
-    const maxW = maxLineWidth(label)
-    const w = maxW + 2 * boxPad + 2
-    const h = lines.length + 2  // lines + top/bottom border
-    const left = cx - Math.floor(w / 2)
-
-    // Top border
-    setC(left, topY, TL, 'border')
-    for (let x = 1; x < w - 1; x++) setC(left + x, topY, H, 'border')
-    setC(left + w - 1, topY, TR, 'border')
-
-    // Content lines (centered horizontally within the box).
-    // Use terminal-column width so CJK / emoji labels sit symmetric in the
-    // box, and iterate codepoints (not UTF-16 units) so a single emoji
-    // surrogate pair counts as one glyph.
-    for (let i = 0; i < lines.length; i++) {
-      const row = topY + 1 + i
-      setC(left, row, V, 'border')
-      setC(left + w - 1, row, V, 'border')
-      const line = lines[i]!
-      const lineW = visualWidth(line)
-      const ls = left + 1 + boxPad + Math.floor((maxW - lineW) / 2)
-      let cursor = ls
-      for (const ch of line) {
-        setC(cursor, row, ch, 'text')
-        cursor += charVisualWidth(ch)
-      }
-    }
-
-    // Bottom border
-    const bottomY = topY + h - 1
-    setC(left, bottomY, BL, 'border')
-    for (let x = 1; x < w - 1; x++) setC(left + x, bottomY, H, 'border')
-    setC(left + w - 1, bottomY, BR, 'border')
-  }
-
-  // ---- DRAW: lifelines ----
-
-  for (let i = 0; i < diagram.actors.length; i++) {
-    const x = llX[i]!
-    for (let y = actorBoxH; y <= footerY; y++) {
-      setC(x, y, V, 'line')
-    }
-  }
-
-  // ---- DRAW: actor header + footer boxes (drawn over lifelines) ----
-
-  for (let i = 0; i < diagram.actors.length; i++) {
-    const actor = diagram.actors[i]!
-    drawActorBox(llX[i]!, 0, actor.label)
-    drawActorBox(llX[i]!, footerY, actor.label)
-
-    // Lifeline junctions on box borders (Unicode only)
-    if (!useAscii) {
-      setC(llX[i]!, actorBoxH - 1, JT, 'junction')
-      setC(llX[i]!, footerY, JB, 'junction')
-    }
-  }
-
-  // ---- DRAW: messages ----
-
-  for (let m = 0; m < diagram.messages.length; m++) {
-    const msg = diagram.messages[m]!
-    const fi = actorIdx.get(msg.from)!
-    const ti = actorIdx.get(msg.to)!
-    const fromX = llX[fi]!
-    const toX = llX[ti]!
-    const isSelf = fi === ti
-    const isDashed = msg.lineStyle === 'dashed'
-    const isFilled = msg.arrowHead === 'filled'
-
-    // Arrow line character (solid vs dashed)
-    const lineChar = isDashed ? (useAscii ? '.' : '╌') : H
-
-    if (isSelf) {
-      // Self-message: an N+2 row loop to the right of the lifeline. For a
-      // single-line label that's the classic 3-row form:
-      //   ├──┐           (row 0 = msgArrowY)
-      //   │  │ Label     (row 1)
-      //   │◄─┘           (row 2)
-      // For an N-line label the middle row repeats N times so each line gets
-      // its own row with a continuing right-side wall.
-      const y0 = msgArrowY[m]!
-      const loopW = 4
-      const selfLines = splitLines(msg.label)
-
-      // Row 0: start junction + horizontal + top-right corner
-      setC(fromX, y0, JL, 'junction')
-      for (let x = fromX + 1; x < fromX + loopW; x++) setC(x, y0, lineChar, 'line')
-      setC(fromX + loopW, y0, useAscii ? '+' : '┐', 'corner')
-
-      // Middle rows: vertical wall on the right + the label line for each row.
-      const labelX = fromX + loopW + 2
-      for (let lineIdx = 0; lineIdx < selfLines.length; lineIdx++) {
-        const row = y0 + 1 + lineIdx
-        // Lifeline wall on the source side (kept by lifeline pass, but make
-        // sure the right-hand wall is continuous so multi-line labels look
-        // contained).
-        setC(fromX + loopW, row, V, 'line')
-        const line = selfLines[lineIdx]!
-        // Use codepoint+stride pattern (same as actor box at lines 256-257) so
-        // CJK / emoji / surrogate-pair labels render with correct column width.
-        let cursor = labelX
-        for (const ch of line) {
-          if (cursor < totalW) setC(cursor, row, ch, 'text')
-          cursor += charVisualWidth(ch)
-        }
-      }
-
-      // Row N+1: arrow-back + horizontal + bottom-right corner.
-      const arrowChar = isFilled ? (useAscii ? '<' : '◀') : (useAscii ? '<' : '◁')
-      const bottomRow = y0 + 1 + selfLines.length
-      setC(fromX, bottomRow, arrowChar, 'arrow')
-      for (let x = fromX + 1; x < fromX + loopW; x++) setC(x, bottomRow, lineChar, 'line')
-      setC(fromX + loopW, bottomRow, useAscii ? '+' : '┘', 'corner')
-    } else {
-      // Normal message: label on row above, arrow on row below
-      const labelY = msgLabelY[m]!
-      const arrowY = msgArrowY[m]!
-      const leftToRight = fromX < toX
-
-      // Draw label centered between the two lifelines (supports multi-line).
-      // Center by terminal column width so CJK / emoji labels sit symmetric
-      // on the arrow and so left-pad rounding follows box parity, not line
-      // parity. Iterate codepoints (not UTF-16 code units) so emoji surrogate
-      // pairs render as one glyph.
-      const boxWidth = Math.abs(toX - fromX)
-      const msgLines = splitLines(msg.label)
-
-      for (let lineIdx = 0; lineIdx < msgLines.length; lineIdx++) {
-        const line = msgLines[lineIdx]!
-        const lineCells = visualWidth(line)
-        const labelStart = Math.min(fromX, toX) + Math.floor((boxWidth - lineCells) / 2)
-        const y = labelY + lineIdx
-        let cursor = labelStart
-        for (const ch of line) {
-          if (cursor >= 0 && cursor < totalW) setC(cursor, y, ch, 'text')
-          cursor += charVisualWidth(ch)
-        }
-      }
-
-      // Draw arrow line
-      if (leftToRight) {
-        for (let x = fromX + 1; x < toX; x++) setC(x, arrowY, lineChar, 'line')
-        // Arrowhead at destination
-        const ah = isFilled ? (useAscii ? '>' : '▶') : (useAscii ? '>' : '▷')
-        setC(toX, arrowY, ah, 'arrow')
-      } else {
-        for (let x = toX + 1; x < fromX; x++) setC(x, arrowY, lineChar, 'line')
-        const ah = isFilled ? (useAscii ? '<' : '◀') : (useAscii ? '<' : '◁')
-        setC(toX, arrowY, ah, 'arrow')
-      }
-    }
-  }
-
-  // ---- DRAW: blocks (loop, alt, opt, par, etc.) ----
-
-  for (let b = 0; b < diagram.blocks.length; b++) {
-    const block = diagram.blocks[b]!
-    const topY = blockStartY.get(b)
-    const botY = blockEndY.get(b)
-    if (topY === undefined || botY === undefined) continue
-
-    // Find the leftmost/rightmost lifelines involved in this block's messages.
-    // For self-messages the visible extent runs PAST the lifeline column —
-    // it's `llX[f] + loopW + 2 + max-label-line-width`. Treat that as the
-    // right edge for self-arrows so the block frame doesn't clip the label.
-    let minLX = totalW
-    let maxLX = 0
-    for (let m = block.startIndex; m <= block.endIndex; m++) {
-      if (m >= diagram.messages.length) break
-      const msg = diagram.messages[m]!
-      const f = actorIdx.get(msg.from) ?? 0
-      const t = actorIdx.get(msg.to) ?? 0
-      minLX = Math.min(minLX, llX[Math.min(f, t)]!)
-      if (f === t) {
-        // Self-arrow: the label sits at llX[f] + 4 + 2 = llX[f] + 6 with the
-        // longest line determining the extra width. Match the totalW math
-        // (llX[f] + 6 + maxLineWidth(label)) and add a 2-cell breathing room
-        // so the right border doesn't sit immediately on the last glyph.
-        const selfRight = llX[f]! + 6 + maxLineWidth(msg.label) + 2
-        maxLX = Math.max(maxLX, selfRight)
-      } else {
-        maxLX = Math.max(maxLX, llX[Math.max(f, t)]!)
-      }
-    }
-
-    const bLeft = Math.max(0, minLX - 4)
-    const bRight = Math.min(totalW - 1, maxLX + 4)
-
-    // Top border with block type label
-    setC(bLeft, topY, TL, 'border')
-    for (let x = bLeft + 1; x < bRight; x++) setC(x, topY, H, 'border')
-    setC(bRight, topY, TR, 'border')
-    // Write block header label over the top border (supports multi-line)
-    const hdrLabel = block.label ? `${block.type} [${block.label}]` : block.type
-    const hdrLines = splitLines(hdrLabel)
-
-    for (let lineIdx = 0; lineIdx < hdrLines.length && topY + lineIdx < botY; lineIdx++) {
-      const line = hdrLines[lineIdx]!
-      for (let i = 0; i < line.length && bLeft + 1 + i < bRight; i++) {
-        setC(bLeft + 1 + i, topY + lineIdx, line[i]!, 'text')
-      }
-    }
-
-    // Bottom border
-    setC(bLeft, botY, BL, 'border')
-    for (let x = bLeft + 1; x < bRight; x++) setC(x, botY, H, 'border')
-    setC(bRight, botY, BR, 'border')
-
-    // Side borders
-    for (let y = topY + 1; y < botY; y++) {
-      setC(bLeft, y, V, 'border')
-      setC(bRight, y, V, 'border')
-    }
-
-    // Dividers
-    for (let d = 0; d < block.dividers.length; d++) {
-      const dY = divYMap.get(`${b}:${d}`)
-      if (dY === undefined) continue
-      const dashChar = isDashedH()
-      setC(bLeft, dY, JL, 'junction')
-      for (let x = bLeft + 1; x < bRight; x++) setC(x, dY, dashChar, 'line')
-      setC(bRight, dY, JR, 'junction')
-      // Divider label
-      const dLabel = block.dividers[d]!.label
-      if (dLabel) {
-        const dStr = `[${dLabel}]`
-        for (let i = 0; i < dStr.length && bLeft + 1 + i < bRight; i++) {
-          setC(bLeft + 1 + i, dY, dStr[i]!, 'text')
-        }
-      }
-    }
-  }
-
-  // ---- DRAW: notes ----
-
-  for (const np of notePositions) {
-    // Ensure canvas is big enough
-    increaseSize(canvas, np.x + np.width, np.y + np.height)
-    increaseRoleCanvasSize(rc, np.x + np.width, np.y + np.height)
-    // Top border
-    setC(np.x, np.y, TL, 'border')
-    for (let x = 1; x < np.width - 1; x++) setC(np.x + x, np.y, H, 'border')
-    setC(np.x + np.width - 1, np.y, TR, 'border')
-    // Content rows
-    for (let l = 0; l < np.lines.length; l++) {
-      const ly = np.y + 1 + l
-      setC(np.x, ly, V, 'border')
-      setC(np.x + np.width - 1, ly, V, 'border')
-      for (let i = 0; i < np.lines[l]!.length; i++) {
-        setC(np.x + 2 + i, ly, np.lines[l]![i]!, 'text')
-      }
-    }
-    // Bottom border
-    const by = np.y + np.height - 1
-    setC(np.x, by, BL, 'border')
-    for (let x = 1; x < np.width - 1; x++) setC(np.x + x, by, H, 'border')
-    setC(np.x + np.width - 1, by, BR, 'border')
-  }
-
-  return canvasToString(canvas, { roleCanvas: rc, colorMode, theme })
-
-  // ---- Helper: dashed horizontal character ----
-  function isDashedH(): string {
-    return useAscii ? '-' : '╌'
-  }
-}

package/src/ascii/shapes/circle.ts

@@ -1,27 +0,0 @@
-// ============================================================================
-// Circle shape renderer — uses corner decorators instead of curves
-// ============================================================================
-
-import type { ShapeRenderer } from './types.ts'
-import { getBoxDimensions, renderBox, getBoxAttachmentPoint } from './rectangle.ts'
-import { getCorners } from './corners.ts'
-
-/**
- * Circle shape renderer.
- * Uses circle markers (◯) at corners to indicate circular shape semantics.
- *
- * Renders as:
- *   ◯─────────◯
- *   │  Label  │
- *   ◯─────────◯
- */
-export const circleRenderer: ShapeRenderer = {
-  getDimensions: getBoxDimensions,
-
-  render(label, dimensions, options) {
-    const corners = getCorners('circle', options.useAscii)
-    return renderBox(label, dimensions, corners, options.useAscii)
-  },
-
-  getAttachmentPoint: getBoxAttachmentPoint,
-}

package/src/ascii/shapes/corners.ts

@@ -1,143 +0,0 @@
-// ============================================================================
-// Corner character lookup table for shape rendering
-// ============================================================================
-//
-// All shapes are rendered as rectangles with distinctive corner characters
-// to indicate shape type. This eliminates diagonal characters while keeping
-// shapes visually distinguishable.
-
-import type { AsciiNodeShape } from '../types.ts'
-
-/**
- * Corner characters for a shape in both Unicode and ASCII modes.
- */
-export interface CornerChars {
-  /** Top-left corner */
-  tl: string
-  /** Top-right corner */
-  tr: string
-  /** Bottom-left corner */
-  bl: string
-  /** Bottom-right corner */
-  br: string
-}
-
-/**
- * Shape corner configuration with both Unicode and ASCII variants.
- */
-export interface ShapeCorners {
-  unicode: CornerChars
-  ascii: CornerChars
-}
-
-/**
- * Corner character lookup table for all shape types.
- *
- * Design principles:
- * - All shapes use orthogonal box structure (no diagonals)
- * - Corner characters indicate shape semantics
- * - ASCII fallbacks use available punctuation
- */
-export const SHAPE_CORNERS: Record<AsciiNodeShape, ShapeCorners> = {
-  // Standard rectangular shapes
-  rectangle: {
-    unicode: { tl: '┌', tr: '┐', bl: '└', br: '┘' },
-    ascii: { tl: '+', tr: '+', bl: '+', br: '+' },
-  },
-  service: {
-    unicode: { tl: '┌', tr: '┐', bl: '└', br: '┘' },
-    ascii: { tl: '+', tr: '+', bl: '+', br: '+' },
-  },
-  rounded: {
-    unicode: { tl: '╭', tr: '╮', bl: '╰', br: '╯' },
-    ascii: { tl: '.', tr: '.', bl: "'", br: "'" },
-  },
-
-  // Circular shapes - use circle markers at corners
-  circle: {
-    unicode: { tl: '◯', tr: '◯', bl: '◯', br: '◯' },
-    ascii: { tl: 'o', tr: 'o', bl: 'o', br: 'o' },
-  },
-  doublecircle: {
-    unicode: { tl: '◎', tr: '◎', bl: '◎', br: '◎' },
-    ascii: { tl: '@', tr: '@', bl: '@', br: '@' },
-  },
-
-  // Diamond - decision nodes
-  diamond: {
-    unicode: { tl: '◇', tr: '◇', bl: '◇', br: '◇' },
-    ascii: { tl: '<', tr: '>', bl: '<', br: '>' },
-  },
-
-  // Hexagon - process nodes (crop corners — monospace-safe, distinct from rectangle)
-  hexagon: {
-    unicode: { tl: '⌜', tr: '⌝', bl: '⌞', br: '⌟' },
-    ascii: { tl: '*', tr: '*', bl: '*', br: '*' },
-  },
-
-  // Stadium/pill shape
-  stadium: {
-    unicode: { tl: '(', tr: ')', bl: '(', br: ')' },
-    ascii: { tl: '(', tr: ')', bl: '(', br: ')' },
-  },
-
-  // Subroutine - double vertical bars
-  subroutine: {
-    unicode: { tl: '╟', tr: '╢', bl: '╟', br: '╢' },
-    ascii: { tl: '|', tr: '|', bl: '|', br: '|' },
-  },
-
-  // Cylinder/database
-  cylinder: {
-    unicode: { tl: '╭', tr: '╮', bl: '╰', br: '╯' },
-    ascii: { tl: '.', tr: '.', bl: "'", br: "'" },
-  },
-
-  // Asymmetric/flag - pointer on left side
-  asymmetric: {
-    unicode: { tl: '▷', tr: '┐', bl: '▷', br: '┘' },
-    ascii: { tl: '>', tr: '+', bl: '>', br: '+' },
-  },
-
-  // Trapezoid - wider at bottom (top corners slope inward)
-  trapezoid: {
-    unicode: { tl: '/', tr: '\\', bl: '└', br: '┘' },
-    ascii: { tl: '/', tr: '\\', bl: '+', br: '+' },
-  },
-
-  // Trapezoid-alt - wider at top (bottom corners slope inward)
-  'trapezoid-alt': {
-    unicode: { tl: '┌', tr: '┐', bl: '\\', br: '/' },
-    ascii: { tl: '+', tr: '+', bl: '\\', br: '/' },
-  },
-
-  // Parallelogram leaning right - all four corners sit on '/' slants
-  'lean-r': {
-    unicode: { tl: '/', tr: '/', bl: '/', br: '/' },
-    ascii: { tl: '/', tr: '/', bl: '/', br: '/' },
-  },
-
-  // Parallelogram leaning left - all four corners sit on '\' slants
-  'lean-l': {
-    unicode: { tl: '\\', tr: '\\', bl: '\\', br: '\\' },
-    ascii: { tl: '\\', tr: '\\', bl: '\\', br: '\\' },
-  },
-
-  // State diagram pseudostates (special handling, not corner-based)
-  'state-start': {
-    unicode: { tl: '●', tr: '●', bl: '●', br: '●' },
-    ascii: { tl: '*', tr: '*', bl: '*', br: '*' },
-  },
-  'state-end': {
-    unicode: { tl: '◉', tr: '◉', bl: '◉', br: '◉' },
-    ascii: { tl: '@', tr: '@', bl: '@', br: '@' },
-  },
-}
-
-/**
- * Get corner characters for a shape type.
- */
-export function getCorners(shape: AsciiNodeShape, useAscii: boolean): CornerChars {
-  const corners = SHAPE_CORNERS[shape] ?? SHAPE_CORNERS.rectangle
-  return useAscii ? corners.ascii : corners.unicode
-}