@zombie-mermaid/ascii-renderer 2.2.1

package/src/__tests__/ascii-multibox-cjk-width.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Regression tests for issue #182 — `drawMultiBox` (the multi-compartment
+ * boxes used by class and ER diagrams) measured and wrote text by UTF-16 code
+ * unit rather than display width, the same bug class #66 fixed for the
+ * single-box path.
+ *
+ * The fix has to cover three sites at once, which is why these tests exercise
+ * whole rendered diagrams rather than `drawMultiBox` alone:
+ *
+ *   1. `drawMultiBox`'s own sizing and per-character write loop, and
+ *   2/3. the box dimensions `class-diagram.ts` and `er-diagram.ts` each
+ *        precompute to reserve grid space *before* drawing.
+ *
+ * Fixing only (1) would desync the drawn box from the space layout reserved
+ * for it, so the multi-box grid cases below (wide-character and ASCII
+ * siblings placed side by side) are the ones that would catch a partial fix.
+ *
+ * Width is measured with an oracle independent of `src/ascii/display-width.ts`
+ * — see the shared helper.
+ */
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+import {
+  terminalDisplayWidth,
+  assertUniformDisplayWidth,
+} from './helpers/terminal-display-width.ts'
+
+/**
+ * Assert that every border row and content row of a multi-compartment box
+ * puts its right-hand vertical border in the same terminal column — the
+ * direct symptom from the issue, content overflowing its own border.
+ *
+ * Only valid for single-box output: relationship connector lines also contain
+ * the vertical border character without being a box edge.
+ */
+function assertBordersAligned(ascii: string, useAscii: boolean): void {
+  const vChar = useAscii ? '|' : '│'
+  const rows = ascii.split('\n').filter((l) => l.includes(vChar))
+  expect(rows.length).toBeGreaterThan(0)
+
+  const columns = rows.map((row) =>
+    terminalDisplayWidth(row.slice(0, row.lastIndexOf(vChar))),
+  )
+  const expected = columns[0]
+  for (let i = 0; i < rows.length; i++) {
+    expect(
+      columns[i],
+      `row ${i} (${JSON.stringify(rows[i])}) has its right border at column ${columns[i]}, expected ${expected}`,
+    ).toBe(expected)
+  }
+}
+
+/**
+ * Terminal-column gap between two boxes drawn side by side on the same row.
+ *
+ * This is the assertion that catches a *partial* fix. If `drawMultiBox` is
+ * corrected but a caller still reserves grid space using code-unit widths,
+ * the box drawn for wide-character content is wider than the space reserved
+ * for it, and the surplus eats into the gap separating it from its neighbour
+ * (and, for a wide enough box, into the neighbour itself). The rendered box
+ * still looks well-formed, so only the spacing reveals the desync.
+ */
+function siblingGap(ascii: string, useAscii: boolean): number {
+  // Matched on the top-border row rather than by corner character: in the
+  // ASCII charset all four corners are '+', so there is no distinct
+  // right-corner glyph to search for. Two runs of border characters
+  // separated by spaces is unambiguous in both charsets.
+  const border = useAscii ? '[+\\-]' : '[┌┐─]'
+  const twoBoxes = new RegExp(`^\\s*(${border}+)(\\s+)(${border}+)`)
+
+  for (const line of ascii.split('\n')) {
+    const match = twoBoxes.exec(line)
+    if (match) return terminalDisplayWidth(match[2]!)
+  }
+
+  expect.fail('expected a row containing two side-by-side box borders')
+}
+
+describe('ASCII renderer — wide characters in multi-compartment boxes (issue #182)', () => {
+  for (const useAscii of [false, true]) {
+    const charset = useAscii ? 'ASCII charset' : 'Unicode charset'
+
+    describe(`class diagrams — ${charset}`, () => {
+      it('keeps a CJK class box within its own border', () => {
+        const ascii = renderMermaidASCII(
+          'classDiagram\n  class Aクラス {\n    +名前 name\n    +取得する() void\n  }',
+          { useAscii, colorMode: 'none' },
+        )
+        assertUniformDisplayWidth(ascii)
+        assertBordersAligned(ascii, useAscii)
+        expect(ascii).toContain('名前')
+      })
+
+      it('does not desync layout from drawing for wide/ASCII sibling boxes', () => {
+        // Two boxes side by side on the same level: one wide-character, one
+        // ASCII. A fix applied to drawMultiBox but not to class-diagram.ts's
+        // own sizing pass would overlap or misalign these.
+        const ascii = renderMermaidASCII(
+          'classDiagram\n  class Base\n  class 子クラスA {\n    +属性値 v\n  }\n  class ChildB {\n    +value v\n  }\n  Base <|-- 子クラスA\n  Base <|-- ChildB',
+          { useAscii, colorMode: 'none' },
+        )
+        assertUniformDisplayWidth(ascii)
+        expect(ascii).toContain('子クラスA')
+        expect(ascii).toContain('ChildB')
+
+        // The wide-character box must be separated from its ASCII sibling by
+        // the class renderer's full horizontal gap (hGap = 4). A caller still
+        // reserving code-unit width narrows this instead.
+        expect(siblingGap(ascii, useAscii)).toBe(4)
+      })
+
+      it('centers a CJK relationship label without overrunning', () => {
+        const ascii = renderMermaidASCII(
+          'classDiagram\n  class 動物 {\n    +名前 name\n  }\n  class 犬 {\n    +吠える() void\n  }\n  動物 <|-- 犬 : 継承する',
+          { useAscii, colorMode: 'none' },
+        )
+        assertUniformDisplayWidth(ascii)
+        expect(ascii).toContain('継承する')
+      })
+
+      it('handles a non-BMP (surrogate-pair) member without splitting it', () => {
+        const ascii = renderMermaidASCII(
+          'classDiagram\n  class Party {\n    +🎉🎉 confetti\n  }',
+          { useAscii, colorMode: 'none' },
+        )
+        assertUniformDisplayWidth(ascii)
+        // A code-unit write loop would emit lone surrogate halves into
+        // adjacent cells; the pair must survive intact.
+        expect(ascii).toContain('🎉🎉')
+        expect(ascii).not.toMatch(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])/)
+        expect(ascii).not.toMatch(/(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/)
+      })
+    })
+
+    describe(`ER diagrams — ${charset}`, () => {
+      it('keeps a CJK entity box within its own border', () => {
+        const ascii = renderMermaidASCII(
+          'erDiagram\n  顧客 {\n    string 名前\n    int 年齢\n  }',
+          { useAscii, colorMode: 'none' },
+        )
+        assertUniformDisplayWidth(ascii)
+        assertBordersAligned(ascii, useAscii)
+        expect(ascii).toContain('顧客')
+      })
+
+      it('does not desync layout from drawing for wide/ASCII sibling entities', () => {
+        const ascii = renderMermaidASCII(
+          'erDiagram\n  顧客 ||--o{ ORDER : places\n  顧客 {\n    string 名前\n  }\n  ORDER {\n    int number\n  }',
+          { useAscii, colorMode: 'none' },
+        )
+        assertUniformDisplayWidth(ascii)
+        expect(ascii).toContain('顧客')
+        expect(ascii).toContain('ORDER')
+      })
+
+      it('places a CJK relationship label without breaking alignment', () => {
+        const ascii = renderMermaidASCII(
+          'erDiagram\n  顧客 ||--o{ 注文 : "発注する"\n  顧客 {\n    string 名前\n  }\n  注文 {\n    int 番号\n  }',
+          { useAscii, colorMode: 'none' },
+        )
+        assertUniformDisplayWidth(ascii)
+        expect(ascii).toContain('発注する')
+      })
+    })
+  }
+
+  it('leaves the common all-ASCII case intact', () => {
+    // Guard against the fix perturbing diagrams with no wide characters.
+    const single = renderMermaidASCII(
+      'classDiagram\n  class Animal {\n    +String name\n    +eat() void\n  }',
+      { colorMode: 'none' },
+    )
+    assertUniformDisplayWidth(single)
+    assertBordersAligned(single, false)
+    expect(single).toContain('+ name: String')
+
+    const related = renderMermaidASCII(
+      'classDiagram\n  class Animal {\n    +String name\n  }\n  class Dog\n  Animal <|-- Dog',
+      { colorMode: 'none' },
+    )
+    assertUniformDisplayWidth(related)
+    expect(related).toContain('Dog')
+  })
+})

package/src/__tests__/ascii-multiline.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+import { mkCanvas, canvasToString } from '../canvas.ts'
+import {
+  drawMultilineTextCentered,
+  drawMultilineTextLeft,
+} from '../multiline-utils.ts'
+
+describe('ASCII multi-line labels', () => {
+  describe('flowchart nodes', () => {
+    it('renders multi-line node labels', () => {
+      const ascii = renderMermaidASCII('graph TD\n  A[Line1<br>Line2]', {
+        useAscii: false,
+      })
+      expect(ascii).toContain('Line1')
+      expect(ascii).toContain('Line2')
+      // Lines should be on different rows
+      const lines = ascii.split('\n')
+      const line1Row = lines.findIndex((l) => l.includes('Line1'))
+      const line2Row = lines.findIndex((l) => l.includes('Line2'))
+      expect(line2Row).toBeGreaterThan(line1Row)
+    })
+
+    it('handles 3+ line labels', () => {
+      const ascii = renderMermaidASCII('graph TD\n  A[A<br>B<br>C]', {
+        useAscii: false,
+      })
+      expect(ascii).toContain('A')
+      expect(ascii).toContain('B')
+      expect(ascii).toContain('C')
+      // Verify vertical ordering
+      const lines = ascii.split('\n')
+      const aRow = lines.findIndex(
+        (l) => l.includes('A') && !l.includes('─') && !l.includes('-'),
+      )
+      const bRow = lines.findIndex((l) => l.includes('B'))
+      const cRow = lines.findIndex((l) => l.includes('C'))
+      expect(bRow).toBeGreaterThan(aRow)
+      expect(cRow).toBeGreaterThan(bRow)
+    })
+
+    it('renders in ASCII mode (not Unicode)', () => {
+      const ascii = renderMermaidASCII('graph TD\n  A[Line1<br>Line2]', {
+        useAscii: true,
+      })
+      expect(ascii).toContain('Line1')
+      expect(ascii).toContain('Line2')
+      // Should use ASCII box characters
+      expect(ascii).toContain('+')
+      expect(ascii).toContain('-')
+    })
+  })
+
+  describe('flowchart edge labels', () => {
+    it('renders multi-line edge labels', () => {
+      const ascii = renderMermaidASCII(
+        'graph TD\n  A --> B\n  A -->|Line1<br>Line2| C',
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Line1')
+      expect(ascii).toContain('Line2')
+    })
+  })
+
+  describe('flowchart subgraph labels', () => {
+    it('renders multi-line subgraph labels', () => {
+      const ascii = renderMermaidASCII(
+        `graph TD
+        subgraph sg [Group<br>Header]
+          A[Node]
+        end
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Group')
+      expect(ascii).toContain('Header')
+    })
+  })
+
+  describe('sequence diagram', () => {
+    it('renders multi-line actor labels', () => {
+      const ascii = renderMermaidASCII(
+        `sequenceDiagram
+        participant A as Actor<br>One
+        A->>A: msg
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Actor')
+      expect(ascii).toContain('One')
+    })
+
+    it('renders multi-line message labels', () => {
+      const ascii = renderMermaidASCII(
+        `sequenceDiagram
+        participant A
+        participant B
+        A->>B: Line1<br>Line2
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Line1')
+      expect(ascii).toContain('Line2')
+    })
+
+    it('preserves existing note multi-line support', () => {
+      const ascii = renderMermaidASCII(
+        `sequenceDiagram
+        participant A
+        A->>A: self
+        Note over A: Note line 1<br>Note line 2
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Note line 1')
+      expect(ascii).toContain('Note line 2')
+    })
+  })
+
+  describe('class diagram', () => {
+    it('renders multi-line class names', () => {
+      const ascii = renderMermaidASCII(
+        `classDiagram
+        class MyClass["Long<br>Name"]
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Long')
+      expect(ascii).toContain('Name')
+    })
+
+    it('renders multi-line relationship labels', () => {
+      const ascii = renderMermaidASCII(
+        `classDiagram
+        A --> B : uses<br>implements
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('uses')
+      expect(ascii).toContain('implements')
+    })
+  })
+
+  describe('ER diagram', () => {
+    it('renders multi-line entity names', () => {
+      const ascii = renderMermaidASCII(
+        `erDiagram
+        "Entity<br>Name" {
+          string id
+        }
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Entity')
+      expect(ascii).toContain('Name')
+    })
+
+    it('renders multi-line relationship labels', () => {
+      const ascii = renderMermaidASCII(
+        `erDiagram
+        A ||--o{ B : "has<br>many"
+      `,
+        { useAscii: false },
+      )
+      expect(ascii).toContain('has')
+      expect(ascii).toContain('many')
+    })
+  })
+
+  describe('edge cases', () => {
+    it('handles empty lines from consecutive <br>', () => {
+      const ascii = renderMermaidASCII('graph TD\n  A[Line1<br><br>Line3]', {
+        useAscii: false,
+      })
+      expect(ascii).toContain('Line1')
+      expect(ascii).toContain('Line3')
+    })
+
+    it('handles single-line labels (no <br>)', () => {
+      const ascii = renderMermaidASCII('graph TD\n  A[SingleLine]', {
+        useAscii: false,
+      })
+      expect(ascii).toContain('SingleLine')
+    })
+
+    it('handles very long lines', () => {
+      const long = 'A'.repeat(30)
+      const ascii = renderMermaidASCII(`graph TD\n  A[${long}<br>Short]`, {
+        useAscii: false,
+      })
+      expect(ascii).toContain(long)
+      expect(ascii).toContain('Short')
+    })
+
+    it('handles mixed short and long lines', () => {
+      const ascii = renderMermaidASCII(
+        'graph TD\n  A[Short<br>VeryLongSecondLine<br>Med]',
+        { useAscii: false },
+      )
+      expect(ascii).toContain('Short')
+      expect(ascii).toContain('VeryLongSecondLine')
+      expect(ascii).toContain('Med')
+    })
+  })
+
+  describe('multiline-utils functions', () => {
+    it('splitLines splits on newlines', () => {
+      // Test through the rendering pipeline
+      const ascii = renderMermaidASCII('graph TD\n  A[One<br>Two<br>Three]', {
+        useAscii: false,
+      })
+      const lines = ascii.split('\n')
+      // All three words should appear on separate lines
+      expect(lines.some((l) => l.includes('One'))).toBe(true)
+      expect(lines.some((l) => l.includes('Two'))).toBe(true)
+      expect(lines.some((l) => l.includes('Three'))).toBe(true)
+    })
+
+    it('maxLineWidth uses longest line for box sizing', () => {
+      // Box should be wide enough for the longest line
+      const ascii = renderMermaidASCII('graph TD\n  A[X<br>LongLine<br>Y]', {
+        useAscii: false,
+      })
+      // The box should contain LongLine without truncation
+      expect(ascii).toContain('LongLine')
+    })
+  })
+
+  describe('drawMultilineTextCentered', () => {
+    it('draws a single line centered at the given point', () => {
+      const canvas = mkCanvas(10, 4)
+      drawMultilineTextCentered(canvas, 'Hi', 5, 2)
+      const lines = canvasToString(canvas).split('\n')
+      expect(lines[2]).toContain('Hi')
+    })
+
+    it('centers multiple lines vertically around the point', () => {
+      const canvas = mkCanvas(12, 6)
+      drawMultilineTextCentered(canvas, 'One\nTwo\nThree', 6, 3)
+      const lines = canvasToString(canvas).split('\n')
+      const oneRow = lines.findIndex((l) => l.includes('One'))
+      const twoRow = lines.findIndex((l) => l.includes('Two'))
+      const threeRow = lines.findIndex((l) => l.includes('Three'))
+      expect(oneRow).toBeGreaterThanOrEqual(0)
+      expect(twoRow).toBe(oneRow + 1)
+      expect(threeRow).toBe(twoRow + 1)
+    })
+
+    it('centers each line horizontally around the given x', () => {
+      const canvas = mkCanvas(20, 2)
+      drawMultilineTextCentered(canvas, 'Wide\nX', 10, 1)
+      const lines = canvasToString(canvas).split('\n')
+      const wideRow = lines.findIndex((l) => l.includes('Wide'))
+      const xRow = lines.findIndex((l) => l.includes('X'))
+      // 'Wide' (4 chars) centered on x=10 starts 2 columns left of center
+      expect(lines[wideRow]!.indexOf('Wide')).toBe(8)
+      // 'X' (1 char) centered on x=10 starts exactly at center
+      expect(lines[xRow]!.indexOf('X')).toBe(10)
+    })
+
+    it('handles an empty label without throwing', () => {
+      const canvas = mkCanvas(6, 3)
+      expect(() => drawMultilineTextCentered(canvas, '', 3, 1)).not.toThrow()
+    })
+  })
+
+  describe('drawMultilineTextLeft', () => {
+    it('draws a single line starting at the given coordinate', () => {
+      const canvas = mkCanvas(10, 4)
+      drawMultilineTextLeft(canvas, 'Hello', 1, 1)
+      const lines = canvasToString(canvas).split('\n')
+      expect(lines[1]!.indexOf('Hello')).toBe(1)
+    })
+
+    it('places each subsequent line one row below the previous', () => {
+      const canvas = mkCanvas(10, 5)
+      drawMultilineTextLeft(canvas, 'Alpha\nBeta', 0, 0)
+      const lines = canvasToString(canvas).split('\n')
+      expect(lines[0]!.indexOf('Alpha')).toBe(0)
+      expect(lines[1]!.indexOf('Beta')).toBe(0)
+    })
+
+    it('handles an empty label without throwing', () => {
+      const canvas = mkCanvas(6, 3)
+      expect(() => drawMultilineTextLeft(canvas, '', 0, 0)).not.toThrow()
+    })
+  })
+})

package/src/__tests__/ascii-padding-edge-cases.test.ts

@@ -0,0 +1,154 @@
+// ============================================================================
+// ASCII padding edge-case tests (issue #343 — CodeRabbit follow-up)
+//
+// #343 made paddingX/paddingY/boxBorderPadding functional for sequence,
+// class, and ER diagrams. CodeRabbit's review of that PR found three ways
+// an out-of-range padding value could corrupt output rather than just
+// tighten/loosen spacing:
+//
+//   1. A negative boxBorderPadding could make measureMultiBox/drawMultiBox
+//      compute a negative box width for a short label (class/ER boxes, and
+//      sequence actor/note boxes, which derive their own width the same way).
+//   2. A very small paddingX/paddingY on an ER diagram could shrink hGap/vGap
+//      below what a 2-cell crow's-foot marker needs, making same-row markers
+//      overlap or vertical markers land on the same row.
+//   3. A very small paddingY on a sequence diagram could collapse rowGap to
+//      0, so a block divider and the following message (or a block's closing
+//      border and the footer) would land on the same row and overwrite each
+//      other, rather than just rendering tightly.
+//
+// This file locks in the fixes for all three.
+// ============================================================================
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+describe('ASCII padding edge cases (issue #343 follow-up)', () => {
+  it('a negative boxBorderPadding does not produce a negative-width class box', () => {
+    const cls = `classDiagram
+      class Foo`
+    // Should not throw, and every border run should still be a real box
+    // (at least 3 chars: two corners + at least one border char).
+    const ascii = renderMermaidASCII(cls, {
+      useAscii: true,
+      boxBorderPadding: -10,
+    })
+    const borderRuns = ascii.match(/\+-+\+/g) ?? []
+    expect(borderRuns.length).toBeGreaterThan(0)
+    for (const run of borderRuns) expect(run.length).toBeGreaterThanOrEqual(3)
+    expect(ascii).toContain('Foo')
+  })
+
+  it('a negative boxBorderPadding does not produce a negative-width ER box', () => {
+    const er = `erDiagram
+      CUSTOMER {
+        string name
+      }`
+    const ascii = renderMermaidASCII(er, {
+      useAscii: true,
+      boxBorderPadding: -10,
+    })
+    const borderRuns = ascii.match(/\+-+\+/g) ?? []
+    expect(borderRuns.length).toBeGreaterThan(0)
+    for (const run of borderRuns) expect(run.length).toBeGreaterThanOrEqual(3)
+    expect(ascii).toContain('CUSTOMER')
+  })
+
+  it('a negative boxBorderPadding does not produce a negative-width sequence actor box', () => {
+    const seq = `sequenceDiagram
+      participant A
+      participant B
+      A->>B: Hi`
+    const ascii = renderMermaidASCII(seq, {
+      useAscii: true,
+      boxBorderPadding: -10,
+    })
+    const borderRuns = ascii.match(/\+-+\+/g) ?? []
+    expect(borderRuns.length).toBeGreaterThan(0)
+    for (const run of borderRuns) expect(run.length).toBeGreaterThanOrEqual(3)
+    expect(ascii).toContain('A')
+    expect(ascii).toContain('B')
+  })
+
+  it("a very negative paddingX keeps ER crow's-foot markers from overlapping", () => {
+    // Both endpoint markers ('|' for "one", '<' + 'o' for "zero-many") must
+    // still appear as distinct, non-overwriting characters in the connector
+    // segment between the two entity boxes. Extract that segment precisely
+    // (the text between "CUSTOMER |" and "| ORDER") rather than slicing from
+    // the line's first/last '|' — the "one" marker is itself a '|', so a
+    // naive first/last-pipe slice would silently include it as a false
+    // positive even when it has been overwritten by the other marker.
+    const er = `erDiagram
+      CUSTOMER ||--o{ ORDER : x`
+    const ascii = renderMermaidASCII(er, { useAscii: true, paddingX: -100 })
+    const line = ascii.split('\n').find((l) => l.includes('CUSTOMER'))
+    expect(line).toBeDefined()
+    const match = /CUSTOMER\s*\|(.*)\|\s*ORDER/.exec(line!)
+    expect(match).not.toBeNull()
+    const connector = match![1]!
+    expect(connector).toContain('|')
+    expect(connector).toContain('o')
+    expect(connector).toContain('<')
+  })
+
+  it('a very negative paddingY keeps ER vertical relationship markers on separate rows', () => {
+    // A wraps to a second row relative to C (via B forcing a 2-column grid),
+    // producing a vertical connector whose upper/lower crow's-foot markers
+    // must land on different rows even when vGap is squeezed.
+    const er = `erDiagram
+      A ||--o{ B : r1
+      A ||--o{ C : r2`
+    const ascii = renderMermaidASCII(er, { useAscii: true, paddingY: -100 })
+    const lines = ascii.split('\n')
+    // Find the two marker rows for the A-C vertical relationship: one
+    // containing the label "r2" (upper marker) and, below it, one
+    // containing the zero-many marker glyphs.
+    const r2Idx = lines.findIndex((l) => l.includes('r2'))
+    expect(r2Idx).toBeGreaterThanOrEqual(0)
+    const markerIdx = lines.findIndex(
+      (l, i) => i > r2Idx && /[o<]/.test(l) && !l.includes('CUSTOMER'),
+    )
+    expect(markerIdx).toBeGreaterThan(r2Idx)
+  })
+
+  it('very tight paddingY keeps a block divider from overwriting the next message', () => {
+    const seq = `sequenceDiagram
+      participant A
+      participant B
+      alt yes
+        A->>B: One
+      else no
+        A->>B: Two
+      end`
+    const ascii = renderMermaidASCII(seq, { useAscii: true, paddingY: -100 })
+    // Both branch labels must survive — a collision would silently drop
+    // "Two" by overwriting its row with the divider row.
+    expect(ascii).toContain('One')
+    expect(ascii).toContain('Two')
+    expect(ascii).toContain('[no]')
+  })
+
+  it('very tight paddingY keeps a block-closing border from overwriting the footer', () => {
+    const seq = `sequenceDiagram
+      participant A
+      participant B
+      alt yes
+        A->>B: One
+      end`
+    const ascii = renderMermaidASCII(seq, { useAscii: true, paddingY: -100 })
+    const lines = ascii.split('\n')
+    // The two-actor header and footer boxes each draw a "+---+   +---+"-
+    // style top border and an identical-looking bottom border — 4 such rows
+    // total. A collision between the block's closing border and the
+    // footer's top border overwrites the footer's top border entirely
+    // (verified by sabotaging the fix: the count drops to 3, and the
+    // footer's content row — "| A |     | B |" — appears directly under the
+    // block's closing border with no border row above it), rather than
+    // merely rendering close together, so counting these rows is a precise
+    // way to detect it instead of checking for adjacency.
+    const twoBoxBorderRows = lines.filter((l) =>
+      /^\s*\+-+\+\s+\+-+\+\s*$/.test(l),
+    )
+    expect(twoBoxBorderRows.length).toBe(4)
+  })
+})