@zombie-mermaid/ascii-renderer 2.2.1

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@zombie-mermaid/ascii-renderer",
+  "version": "2.2.1",
+  "license": "MIT",
+  "description": "ASCII and Unicode box-drawing renderer for zombie-mermaid diagrams.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "files": [
+    "src/",
+    "dist/",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@zombie-mermaid/core": "workspace:*",
+    "@zombie-mermaid/mermaid-parser": "workspace:*"
+  }
+}

package/src/__tests__/ascii-arrowhead-direction-1083.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Regression tests for #1083: the last edge in a mixed-style fan-out got a
+ * bogus diagonal arrowhead (↘) instead of a straight one (▼), even though
+ * its line was perfectly vertical with zero horizontal drift.
+ *
+ * Root cause: that edge's route fell through to determinePath's Case-4
+ * direct fallback (see #418), producing a single non-axis-aligned grid
+ * segment. draw-lines.ts's drawLine draws that as an L (horizontal run,
+ * then vertical run) folded into one `linesDrawn` entry. drawArrowHead used
+ * to derive direction from that entry's *first* and *last* point, which
+ * spans both legs of the L and reads as diagonal — even when the actual
+ * final approach into the arrowhead is a plain vertical step. Fixed by
+ * deriving direction from the last two points (the final step) instead.
+ */
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+const ARROWHEAD_CHARS = '▼▲◄►↖↗↘↙'
+
+function arrowCharsInLastRowBeforeTargets(source: string): string[] {
+  const lines = renderMermaidASCII(source, { colorMode: 'none' }).split('\n')
+  const arrowRow = lines.find((l) =>
+    [...l].some((ch) => ARROWHEAD_CHARS.includes(ch)),
+  )!
+  return [...arrowRow].filter((ch) => ARROWHEAD_CHARS.includes(ch))
+}
+
+describe('arrowhead direction on a Case-4 direct-fallback (diagonal) path', () => {
+  it('renders every arrowhead as ▼ when thick is the last mixed-style edge', () => {
+    const source = `graph TD
+  A[Source] -->|solid| B[Target 1]
+  A -.->|dotted| C[Target 2]
+  A ==>|thick| D[Target 3]`
+
+    const arrows = arrowCharsInLastRowBeforeTargets(source)
+    expect(arrows).toEqual(['▼', '▼', '▼'])
+  })
+
+  it('renders every arrowhead as ▼ regardless of which style is last', () => {
+    // Same three styles, reordered so `solid` (not `thick`) is the one that
+    // falls through to the Case-4 fallback — the bug followed *position*,
+    // not the specific style.
+    const source = `graph TD
+  A[Source] ==>|thick| B[Target 1]
+  A -.->|dotted| C[Target 2]
+  A -->|solid| D[Target 3]`
+
+    const arrows = arrowCharsInLastRowBeforeTargets(source)
+    expect(arrows).toEqual(['▼', '▼', '▼'])
+  })
+})

package/src/__tests__/ascii-canvas-first-claim-wins-1093.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Direct unit tests for `firstClaimWins` (packages/ascii-renderer/src/canvas.ts),
+ * added in response to a CodeRabbit finding on PR #1093 (the #1067 fix):
+ * https://github.com/dfadler/zombie-mermaid/pull/1093#discussion_r… (canvas.ts:446).
+ *
+ * `firstClaimWins` runs before `mergeCanvases` on the line-canvas layer to
+ * fix #1067's "one edge's style bleeds into another's" bug — but its
+ * original implementation suppressed a later canvas's character at any
+ * already-claimed cell purely by coordinate, with no regard for what the
+ * two characters actually were. That silently broke a genuine perpendicular
+ * crossing between two plain box-drawing edges (one edge's own `─`, another
+ * unrelated edge's own `│`): `mergeCanvases`'s existing junction-merge logic
+ * (`isJunctionChar` + `mergeJunctions`) would normally combine them into
+ * `┼`, but firstClaimWins now deleted the second character before
+ * mergeCanvases ever saw it, so the crossing silently became whichever edge
+ * drew first instead. The fix: only suppress a later cell when the two
+ * characters *wouldn't* form a meaningful junction merge (i.e. when at
+ * least one of them isn't a junction char at all — the actual #1067
+ * scenario, dashed vs. heavy characters, neither of which is in
+ * `JUNCTION_CHARS`).
+ */
+import { describe, it, expect } from 'vitest'
+import { mkCanvas, firstClaimWins, mergeCanvases } from '../canvas.ts'
+import type { Canvas } from '../types.ts'
+
+function canvasWithChar(
+  width: number,
+  height: number,
+  x: number,
+  y: number,
+  c: string,
+): Canvas {
+  const canvas = mkCanvas(width, height)
+  canvas[x]![y] = c
+  return canvas
+}
+
+describe('firstClaimWins', () => {
+  it('preserves a genuine perpendicular crossing between two plain junction characters', () => {
+    // Edge A's own line draws '─' at (2,2); edge B's own (unrelated) line
+    // independently draws '│' at the very same cell — a real crossing, not
+    // a style conflict.
+    const horizontal = canvasWithChar(4, 4, 2, 2, '─')
+    const vertical = canvasWithChar(4, 4, 2, 2, '│')
+
+    const resolved = firstClaimWins([horizontal, vertical])
+    // Both canvases must still carry their own character at the shared
+    // cell — dropping either one would make it impossible for
+    // mergeCanvases's junction-merge logic below to ever see both.
+    expect(resolved[0]![2]![2]).toBe('─')
+    expect(resolved[1]![2]![2]).toBe('│')
+
+    const merged = mergeCanvases(
+      mkCanvas(4, 4),
+      { x: 0, y: 0 },
+      false,
+      ...resolved,
+    )
+    expect(merged[2]![2]).toBe('┼')
+  })
+
+  it('still suppresses a later same-orientation duplicate (collinear overlap)', () => {
+    const first = canvasWithChar(4, 4, 1, 1, '─')
+    const second = canvasWithChar(4, 4, 1, 1, '─')
+    const resolved = firstClaimWins([first, second])
+    expect(resolved[0]![1]![1]).toBe('─')
+    expect(resolved[1]![1]![1]).toBe(' ')
+  })
+
+  it('still suppresses a later non-junction character at an already-claimed cell (#1067)', () => {
+    // The original #1067 scenario: a dashed edge's own leg ('┄', not a
+    // junction char) sharing a cell with a heavy edge's own leg ('━', also
+    // not a junction char) — neither can form a meaningful merge, so first
+    // claim must still win.
+    const dashed = canvasWithChar(4, 4, 1, 1, '┄')
+    const heavy = canvasWithChar(4, 4, 1, 1, '━')
+    const resolved = firstClaimWins([dashed, heavy])
+    expect(resolved[0]![1]![1]).toBe('┄')
+    expect(resolved[1]![1]![1]).toBe(' ')
+  })
+
+  it('suppresses a later cell when only one side is a junction character', () => {
+    const junction = canvasWithChar(4, 4, 1, 1, '│')
+    const heavy = canvasWithChar(4, 4, 1, 1, '━')
+    const resolved = firstClaimWins([junction, heavy])
+    expect(resolved[0]![1]![1]).toBe('│')
+    expect(resolved[1]![1]![1]).toBe(' ')
+  })
+})

package/src/__tests__/ascii-canvas-size-offset-1093.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Regression for a bug found while investigating PR #1093 (the #1067 fix):
+ * `setCanvasSizeToGrid`/`setRoleCanvasSizeToGrid` sized the canvas from
+ * `columnWidth`/`rowHeight` alone, with no way to account for
+ * `graph.offsetX`/`offsetY` — the shift `offsetDrawingForSubgraphs` applies
+ * whenever a subgraph's own border padding would otherwise push its content
+ * negative. Every `gridToDrawingCoord` call (including edge line-drawing)
+ * adds that offset to its result, but `createMapping` sized the canvas
+ * *before* the offset was known, leaving it exactly `offsetX`/`offsetY` too
+ * small. Node boxes were retroactively shifted into the correct position,
+ * but nothing widened the canvas array to match — so any edge line whose
+ * drawing coordinate landed in that unreserved margin was silently dropped
+ * by `write()`'s out-of-bounds clip. This surfaced as a fully disconnected
+ * edge (a dangling corner glyph with no line connecting it to its node) in
+ * the "State: Composite States" sample's `Error --> Idle : retry` edge,
+ * once the #1067 chain-overlap fix rerouted that edge through a column
+ * further right than anything else in the diagram — see that sample's
+ * regenerated baseline in this same PR.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  mkCanvas,
+  mkRoleCanvas,
+  setCanvasSizeToGrid,
+  setRoleCanvasSizeToGrid,
+  getCanvasSize,
+} from '../canvas.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+describe('setCanvasSizeToGrid / setRoleCanvasSizeToGrid — offset', () => {
+  it('reserves extra width/height for a nonzero offset', () => {
+    const canvas = mkCanvas(0, 0)
+    const columnWidth = new Map([
+      [0, 3],
+      [1, 4],
+    ])
+    const rowHeight = new Map([
+      [0, 2],
+      [1, 5],
+    ])
+    setCanvasSizeToGrid(canvas, columnWidth, rowHeight, 6, 3)
+    const [maxX, maxY] = getCanvasSize(canvas)
+    // columnWidth sums to 7, plus an offset of 6 => max valid index 12.
+    expect(maxX).toBe(12)
+    // rowHeight sums to 7, plus an offset of 3 => max valid index 9.
+    expect(maxY).toBe(9)
+  })
+
+  it('matches the un-offset canvas size when offset is omitted (default 0)', () => {
+    const canvas = mkCanvas(0, 0)
+    const columnWidth = new Map([[0, 5]])
+    const rowHeight = new Map([[0, 4]])
+    setCanvasSizeToGrid(canvas, columnWidth, rowHeight)
+    const [maxX, maxY] = getCanvasSize(canvas)
+    expect(maxX).toBe(4)
+    expect(maxY).toBe(3)
+  })
+
+  it('role canvas sizing accepts the same offset', () => {
+    const roleCanvas = mkRoleCanvas(0, 0)
+    const columnWidth = new Map([[0, 3]])
+    const rowHeight = new Map([[0, 2]])
+    setRoleCanvasSizeToGrid(roleCanvas, columnWidth, rowHeight, 5, 1)
+    expect(roleCanvas.length - 1).toBe(7)
+    expect((roleCanvas[0]?.length ?? 1) - 1).toBe(2)
+  })
+})
+
+describe('subgraph-offset edges reach their node border (#1093 regression)', () => {
+  it("draws the retry edge's connector all the way into Error's box, with no gap", () => {
+    const src = `stateDiagram-v2
+  [*] --> Idle
+  Idle --> Processing : submit
+  state Processing {
+    parse --> validate
+    validate --> execute
+  }
+  Processing --> Complete : done
+  Processing --> Error : fail
+  Error --> Idle : retry
+  Complete --> [*]`
+
+    const lines = renderMermaidASCII(src, { colorMode: 'none' }).split('\n')
+    const errorRow = lines.find((l) => l.includes('Error'))
+    expect(errorRow).toBeDefined()
+
+    // Error's own right border ('├', where the outgoing retry edge exits)
+    // must be immediately followed by a drawn connector character, not a
+    // gap — a disconnected edge leaves that cell (and the next) blank.
+    const portIndex = errorRow!.indexOf('├')
+    expect(portIndex).toBeGreaterThan(-1)
+    const afterPort = errorRow!.slice(portIndex + 1)
+    expect(afterPort).toMatch(/^[─┘└┐┌│]/)
+  })
+})

package/src/__tests__/ascii-canvas-write.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Direct unit tests for `write()` (src/ascii/canvas.ts) — specifically its
+ * clip boundary in all four directions.
+ *
+ * These previously didn't exist: an adversarial review of PR #180
+ * instrumented the clip condition and ran the full suite (1318 passing
+ * tests at the time) and found the clip branch was never exercised — 0
+ * clip events fired. That gap is exactly how a real border-corruption
+ * regression in `drawSubgraphLabel` (src/ascii/draw-subgraphs.ts, see
+ * ascii-subgraph-label-border-clip.test.ts) got through green CI: no test
+ * distinguished `write()`'s clip semantics from the per-call-site guards it
+ * replaced.
+ */
+import { describe, it, expect } from 'vitest'
+import { mkCanvas, mkRoleCanvas, write, getCanvasSize } from '../canvas.ts'
+import type { CharRole } from '../types.ts'
+
+describe('canvas.ts write()', () => {
+  it('writes within bounds, including exactly on the inclusive max edge', () => {
+    const canvas = mkCanvas(2, 2) // valid indices 0..2 in both axes
+    const [maxX, maxY] = getCanvasSize(canvas)
+    expect([maxX, maxY]).toEqual([2, 2])
+
+    write(canvas, 0, 0, 'A')
+    write(canvas, maxX, maxY, 'B')
+    write(canvas, maxX, 0, 'C')
+    write(canvas, 0, maxY, 'D')
+
+    expect(canvas[0]![0]).toBe('A')
+    expect(canvas[maxX]![maxY]).toBe('B')
+    expect(canvas[maxX]![0]).toBe('C')
+    expect(canvas[0]![maxY]).toBe('D')
+  })
+
+  it('is a no-op at x = -1 (just past the low edge)', () => {
+    const canvas = mkCanvas(2, 2)
+    // No cell to inspect at x = -1; assert the call doesn't throw and
+    // leaves the rest of the canvas untouched.
+    expect(() => write(canvas, -1, 1, 'X')).not.toThrow()
+    for (const col of canvas) {
+      expect(col.every((c) => c === ' ')).toBe(true)
+    }
+  })
+
+  it('is a no-op at x = maxX + 1 (just past the high edge)', () => {
+    const canvas = mkCanvas(2, 2)
+    const [maxX] = getCanvasSize(canvas)
+    expect(() => write(canvas, maxX + 1, 1, 'X')).not.toThrow()
+    for (const col of canvas) {
+      expect(col.every((c) => c === ' ')).toBe(true)
+    }
+  })
+
+  it('writes at x = maxX (on the inclusive edge, not clipped)', () => {
+    const canvas = mkCanvas(2, 2)
+    const [maxX] = getCanvasSize(canvas)
+    write(canvas, maxX, 1, 'X')
+    expect(canvas[maxX]![1]).toBe('X')
+  })
+
+  it('is a no-op at y = -1 (just past the low edge)', () => {
+    const canvas = mkCanvas(2, 2)
+    expect(() => write(canvas, 1, -1, 'X')).not.toThrow()
+    for (const col of canvas) {
+      expect(col.every((c) => c === ' ')).toBe(true)
+    }
+  })
+
+  it('is a no-op at y = maxY + 1 (just past the high edge)', () => {
+    const canvas = mkCanvas(2, 2)
+    const [, maxY] = getCanvasSize(canvas)
+    expect(() => write(canvas, 1, maxY + 1, 'X')).not.toThrow()
+    for (const col of canvas) {
+      expect(col.every((c) => c === ' ')).toBe(true)
+    }
+  })
+
+  it('writes at y = maxY (on the inclusive edge, not clipped)', () => {
+    const canvas = mkCanvas(2, 2)
+    const [, maxY] = getCanvasSize(canvas)
+    write(canvas, 1, maxY, 'X')
+    expect(canvas[1]![maxY]).toBe('X')
+  })
+
+  it('never grows the canvas on an out-of-range write in any direction', () => {
+    const canvas = mkCanvas(2, 2)
+    const before = getCanvasSize(canvas)
+    write(canvas, -1, 1, 'X')
+    write(canvas, 5, 1, 'X')
+    write(canvas, 1, -1, 'X')
+    write(canvas, 1, 5, 'X')
+    expect(getCanvasSize(canvas)).toEqual(before)
+  })
+
+  it('out-of-range writes are a no-op on the role canvas too, when roleTracking is provided', () => {
+    const canvas = mkCanvas(2, 2)
+    const roleCanvas = mkRoleCanvas(2, 2)
+    const role: CharRole = 'border'
+
+    write(canvas, -1, 1, 'X', { role, roleCanvas })
+    write(canvas, 5, 1, 'X', { role, roleCanvas })
+    write(canvas, 1, -1, 'X', { role, roleCanvas })
+    write(canvas, 1, 5, 'X', { role, roleCanvas })
+
+    for (const col of roleCanvas) {
+      expect(col.every((r) => r === null)).toBe(true)
+    }
+  })
+
+  it('records the role on the role canvas for an in-range write', () => {
+    const canvas = mkCanvas(2, 2)
+    const roleCanvas = mkRoleCanvas(2, 2)
+    const role: CharRole = 'border'
+
+    write(canvas, 1, 1, 'X', { role, roleCanvas })
+
+    expect(canvas[1]![1]).toBe('X')
+    expect(roleCanvas[1]![1]).toBe('border')
+  })
+
+  it('does not touch the role canvas when roleTracking is omitted', () => {
+    const canvas = mkCanvas(2, 2)
+    const roleCanvas = mkRoleCanvas(2, 2)
+
+    write(canvas, 1, 1, 'X')
+
+    expect(canvas[1]![1]).toBe('X')
+    for (const col of roleCanvas) {
+      expect(col.every((r) => r === null)).toBe(true)
+    }
+  })
+})

package/src/__tests__/ascii-chain-edge-overlap-1067.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Regression test for #1067 ("System Architecture" form-judge finding): an
+ * edge chained through a shared intermediate node (`C(Mobile App) -->
+ * B(API Gateway)` then `B --> E(User Service)`) could render as one
+ * unbroken line straight from Mobile App to User Service, even though the
+ * source has no direct `Mobile App --> User Service` edge.
+ *
+ * Root cause: both edges are independently routed (LR direction, so
+ * `analyzeEdgeBundles` never groups anything — see its own "LR routing
+ * handles merging naturally at corners" comment), and their corners
+ * happened to land on the exact same grid cell: `Mobile App --> API
+ * Gateway`'s incoming leg travels up API Gateway's own column to the same
+ * row `API Gateway --> User Service`'s outgoing leg travels down, before
+ * turning right toward User Service. The two legs are collinear, so the
+ * drawn result reads as one continuous connector across a shared row.
+ *
+ * Fix: `edge-cell-styles.ts`'s `findUnrelatedOverlap` (scoped to true
+ * *chain* pairs — one edge's `to` equal to the other's `from`, not a
+ * fan-in/fan-out sibling pair, which legitimately shares trunk cells; see
+ * that module's doc for why the broader "shares neither endpoint" version
+ * broke the `ampersand_lhs_and_rhs` golden file) flags a chain pair that
+ * shares 2+ open cells beyond their common node's own border, and
+ * `rerouteAroundStyleConflicts` (grid.ts) reroutes one of them around the
+ * conflicting cell — the same mechanism already used for cross-style
+ * conflicts, extended to this same-style chain case.
+ */
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+const SYSTEM_ARCHITECTURE = `graph LR
+  subgraph clients [Client Layer]
+    A([Web App]) --> B[API Gateway]
+    C([Mobile App]) --> B
+  end
+  subgraph services [Service Layer]
+    B --> D[Auth Service]
+    B --> E[User Service]
+    B --> F[Order Service]
+  end
+  subgraph data [Data Layer]
+    D --> G[(Auth DB)]
+    E --> H[(User DB)]
+    F --> I[(Order DB)]
+    F --> J([Message Queue])
+  end`
+
+describe('chained edges through a shared intermediate node stay visually distinct (#1067)', () => {
+  const lines = renderMermaidASCII(SYSTEM_ARCHITECTURE, { colorMode: 'none' })
+    .split('\n')
+    .map((l) => l.replace(/\s+$/, ''))
+
+  it('renders every label and does not throw', () => {
+    const out = lines.join('\n')
+    for (const label of [
+      'Web App',
+      'Mobile App',
+      'API Gateway',
+      'Auth Service',
+      'User Service',
+      'Order Service',
+    ]) {
+      expect(out).toContain(label)
+    }
+  })
+
+  it("leaves a visual break between Mobile App's own row and User Service — they must not read as one connected line", () => {
+    const mobileRow = lines.find((l) => l.includes('Mobile App'))
+    expect(mobileRow).toBeDefined()
+    // Start just past Mobile App's own right border connector ('├' or
+    // '┤'), and end at User Service's own left border ('│  User Service').
+    // Both boxes' own padding ("Mobile App │" / "│  User Service")
+    // contributes a harmless blank cell or two right next to the label
+    // text itself — excluding both box borders from the scanned range
+    // means only the *connector* in between is checked, not incidental box
+    // padding (see the sabotage check on this test, which caught exactly
+    // this false pass on an earlier, looser version of this assertion).
+    const afterLabel = mobileRow!.indexOf('Mobile App') + 'Mobile App'.length
+    const start = mobileRow!.slice(afterLabel).search(/[├┤]/) + afterLabel + 1
+    const end = mobileRow!.indexOf('│  User Service')
+    expect(end).toBeGreaterThan(start)
+    const between = mobileRow!.slice(start, end)
+
+    // The bug produced a fully packed run of box-drawing characters (no
+    // blank cell at all) all the way from Mobile App's own border to User
+    // Service's — i.e. one unbroken connector. A genuine visual break
+    // requires at least one blank cell somewhere in between.
+    expect(between).toMatch(/ /)
+  })
+
+  it("does not draw an arrowhead into User Service on Mobile App's own row", () => {
+    // User Service's real incoming edge (from API Gateway) is routed on a
+    // different row; if Mobile App's row also shows an arrowhead landing
+    // directly on User Service's border, the two are still effectively
+    // fused into what reads as one edge.
+    const mobileRow = lines.find((l) => l.includes('Mobile App'))!
+    const userServiceBoxStart = mobileRow.indexOf('│  User Service')
+    expect(userServiceBoxStart).toBeGreaterThan(-1)
+    expect(mobileRow[userServiceBoxStart - 1]).not.toBe('►')
+  })
+})

package/src/__tests__/ascii-charset-border-junctions.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Regression test: ASCII-charset rendering (`{ useAscii: true }`) never drew
+ * a junction character where an edge exits a node's border — the border
+ * stayed a plain run of dashes even at the column where a connector
+ * dropped/branched from it, while Unicode mode correctly drew a T-junction
+ * ('┬'/'┴'/'├'/'┤') there. Root cause: `drawBoxStart` (draw-arrows.ts) and
+ * the fan-in box-start connector (draw-bundles.ts) early-returned/guarded
+ * on `useAscii`, skipping junction placement entirely instead of writing
+ * the ASCII equivalent ('+').
+ */
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+describe('ASCII vs Unicode charset: box-start border junctions', () => {
+  it('draws a "+" junction on a plain top-down edge, matching the Unicode T-junction', () => {
+    const src = `flowchart TD
+  A[Hello World] --> B[Done]`
+
+    const unicode = renderMermaidASCII(src, { useAscii: false })
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+
+    expect(unicode).toContain('└──────┬──────┘')
+    // Before the fix this rendered as a plain, uninterrupted
+    // '+-------------+' with no junction at all.
+    expect(ascii).toContain('+------+------+')
+  })
+
+  it('draws a "+" junction on a left-right (LR) edge exit, matching Unicode', () => {
+    const src = `flowchart LR
+  A[Hello] --> B[World]`
+
+    const unicode = renderMermaidASCII(src, { useAscii: false })
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+
+    expect(unicode).toContain('├')
+
+    // The row with the arrow must have a '+' where Unicode has '├', not a
+    // plain '|' vertical border with no junction.
+    const unicodeRow = unicode.split('\n').find((l) => l.includes('├'))!
+    const asciiRow = ascii.split('\n').find((l) => l.includes('+---->'))
+    expect(asciiRow).toBeDefined()
+    const junctionCol = unicodeRow.indexOf('├')
+    expect(asciiRow![junctionCol]).toBe('+')
+  })
+
+  it('draws "+" junctions on a fan-in bundle box-start connector in ASCII mode', () => {
+    const src = `flowchart TD
+  A[One] --> C[Target]
+  B[Two] --> C`
+
+    const unicode = renderMermaidASCII(src, { useAscii: false })
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+
+    // Unicode shows T-junctions where each source box's bottom border
+    // meets the fan-in connector line.
+    expect(unicode).toMatch(/[┬┴├┤]/)
+
+    // Each source box's bottom border must show an interior '+' junction
+    // where the fan-in connector drops from it, not a plain dash run.
+    expect(ascii).toContain('+----+---+')
+    expect(ascii).toContain('+--+--+')
+  })
+})