zombie-mermaid 4.2.2 → 4.2.3

package/src/__tests__/ascii-subgraph-later-edgeless-301.test.ts

@@ -1,277 +0,0 @@
-/**
- * Regression tests for #301 — "ASCII backend: a subgraph that carries no
- * edge is absorbed into an earlier subgraph's frame and its title is
- * deleted."
- *
- * This is the mirror image of #90/#143 (see ascii-subgraph-bbox.test.ts):
- * that fix deferred an edge-less *root* node's placement so it wouldn't be
- * laid out at the shared root level alongside an unrelated sibling
- * subgraph's root. But the deferred node still found its free slot via a
- * subgraph-agnostic blind slide (`reserveSpotInGrid`'s built-in collision
- * handling) — sliding one grid step at a time along the shared axis with no
- * notion of subgraph ownership. When an *earlier* subgraph has such a
- * deferred node AND a *later*, entirely edge-less sibling subgraph already
- * claimed the very next slot, the blind slide walked straight through that
- * later subgraph's root to find free space beyond it — landing the deferred
- * node on the far side. That sandwiched the later subgraph's node between
- * the earlier subgraph's own members, so the earlier subgraph's bounding box
- * (min/max over its members' positions) ballooned out to enclose the later
- * one, corrupting both frames and dropping the later subgraph's title
- * entirely.
- *
- * The fix (`src/ascii/grid.ts`): attach each subgraph's deferred nodes to
- * whichever of its own roots gets placed first, immediately, before control
- * returns to the root-placement loop — so an unrelated subgraph's root can
- * never claim the slot a deferred sibling needs (`deferredByTopSg` /
- * `placeDeferredSiblingsNextToRoot`). A `findSubgraphAdjacentSlot` fallback
- * additionally keeps the later pass (for deferred nodes whose anchor is
- * itself a non-root) from enclosing a foreign subgraph's node when sliding.
- */
-import { describe, it, expect } from 'vitest'
-import { parseMermaid } from '@zombie-mermaid/mermaid-parser'
-import { convertToAsciiGraph } from '../../packages/ascii-renderer/src/converter.ts'
-import { createMapping } from '../../packages/ascii-renderer/src/grid.ts'
-import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
-import type {
-  AsciiConfig,
-  AsciiGraph,
-  AsciiSubgraph,
-} from '../../packages/ascii-renderer/src/types.ts'
-
-function layoutFlowchart(
-  source: string,
-  direction: 'TD' | 'LR' = 'TD',
-): AsciiGraph {
-  const parsed = parseMermaid(source)
-  const config: AsciiConfig = {
-    useAscii: false,
-    paddingX: 5,
-    paddingY: 5,
-    boxBorderPadding: 1,
-    graphDirection: direction,
-  }
-  const graph = convertToAsciiGraph(parsed, config)
-  createMapping(graph)
-  return graph
-}
-
-function boxesOverlap(a: AsciiSubgraph, b: AsciiSubgraph): boolean {
-  return !(
-    a.maxX <= b.minX ||
-    b.maxX <= a.minX ||
-    a.maxY <= b.minY ||
-    b.maxY <= a.minY
-  )
-}
-
-function findSubgraph(graph: AsciiGraph, name: string): AsciiSubgraph {
-  const sg = graph.subgraphs.find((s) => s.name === name)
-  if (!sg) throw new Error(`subgraph "${name}" not found`)
-  return sg
-}
-
-/** Whether a node's drawn box sits fully inside a subgraph's bounding box. */
-function nodeInsideBox(
-  graph: AsciiGraph,
-  nodeName: string,
-  sg: AsciiSubgraph,
-): boolean {
-  const node = graph.nodes.find((n) => n.name === nodeName)
-  if (!node?.drawingCoord || !node.drawing) {
-    throw new Error(`node "${nodeName}" wasn't drawn`)
-  }
-  const minX = node.drawingCoord.x
-  const minY = node.drawingCoord.y
-  const maxX = minX + node.drawing.length - 1
-  const maxY = minY + node.drawing[0]!.length - 1
-  return (
-    minX >= sg.minX && maxX <= sg.maxX && minY >= sg.minY && maxY <= sg.maxY
-  )
-}
-
-describe('ASCII: a later edge-less subgraph is not absorbed into an earlier one (#301)', () => {
-  const issueRepro = `flowchart TB
-  subgraph a["Group A"]
-    a1["alpha"]
-    a2["bravo"]
-    a3["charlie"]
-  end
-  subgraph b["Group B"]
-    b1["delta"]
-  end
-  a1 --> a2`
-
-  it('keeps two subgraphs disjoint: earlier one has an edge-less member, later one carries no edge at all (exact issue repro)', () => {
-    const graph = layoutFlowchart(issueRepro, 'TD')
-    expect(graph.subgraphs.length).toBe(2)
-
-    const groupA = findSubgraph(graph, 'Group A')
-    const groupB = findSubgraph(graph, 'Group B')
-    expect(boxesOverlap(groupA, groupB)).toBe(false)
-
-    // delta belongs to Group B and must be drawn inside Group B's frame,
-    // not dragged into Group A's.
-    expect(nodeInsideBox(graph, 'b1', groupB)).toBe(true)
-    expect(nodeInsideBox(graph, 'b1', groupA)).toBe(false)
-
-    const output = renderMermaidASCII(issueRepro)
-    expect(output).toContain('Group A')
-    expect(output).toContain('Group B')
-  })
-
-  it('keeps the same two subgraphs disjoint in LR', () => {
-    const lrSource = issueRepro.replace('flowchart TB', 'flowchart LR')
-    const graph = layoutFlowchart(lrSource, 'LR')
-
-    const groupA = findSubgraph(graph, 'Group A')
-    const groupB = findSubgraph(graph, 'Group B')
-    expect(boxesOverlap(groupA, groupB)).toBe(false)
-    expect(nodeInsideBox(graph, 'b1', groupB)).toBe(true)
-
-    const output = renderMermaidASCII(lrSource)
-    expect(output).toContain('Group A')
-    expect(output).toContain('Group B')
-  })
-
-  it('does not collapse a third, equally edge-less subgraph into the same frame (N-subgraph case)', () => {
-    const source = `flowchart TB
-  subgraph a["Group A"]
-    a1["alpha"]
-    a2["bravo"]
-    a3["charlie"]
-  end
-  subgraph b["Group B"]
-    b1["delta"]
-  end
-  subgraph c["Group C"]
-    c1["echo"]
-  end
-  a1 --> a2`
-
-    const graph = layoutFlowchart(source, 'TD')
-    expect(graph.subgraphs.length).toBe(3)
-
-    const groupA = findSubgraph(graph, 'Group A')
-    const groupB = findSubgraph(graph, 'Group B')
-    const groupC = findSubgraph(graph, 'Group C')
-
-    for (const [nameI, sgI] of [
-      ['Group A', groupA],
-      ['Group B', groupB],
-      ['Group C', groupC],
-    ] as const) {
-      for (const [nameJ, sgJ] of [
-        ['Group A', groupA],
-        ['Group B', groupB],
-        ['Group C', groupC],
-      ] as const) {
-        if (nameI >= nameJ) continue
-        expect(
-          boxesOverlap(sgI, sgJ),
-          `subgraph "${nameI}" overlaps "${nameJ}"`,
-        ).toBe(false)
-      }
-    }
-
-    expect(nodeInsideBox(graph, 'b1', groupB)).toBe(true)
-    expect(nodeInsideBox(graph, 'c1', groupC)).toBe(true)
-    expect(nodeInsideBox(graph, 'b1', groupA)).toBe(false)
-    expect(nodeInsideBox(graph, 'c1', groupA)).toBe(false)
-
-    const output = renderMermaidASCII(source)
-    expect(output).toContain('Group A')
-    expect(output).toContain('Group B')
-    expect(output).toContain('Group C')
-  })
-
-  it('slides a second edge-less sibling past the first instead of colliding with it', () => {
-    // a3 and a4 are both edge-less and both unreachable from a1, so both
-    // get deferred and both attach to a1. The second one (a4) must slide
-    // past the first (a3) — exercising findSubgraphAdjacentSlot's "occupant
-    // belongs to the same subgraph, keep sliding" branch — rather than
-    // colliding with it.
-    const source = `flowchart TB
-  subgraph a["Group A"]
-    a1["alpha"]
-    a2["bravo"]
-    a3["charlie"]
-    a4["echo"]
-  end
-  a1 --> a2`
-
-    const graph = layoutFlowchart(source, 'TD')
-    const groupA = findSubgraph(graph, 'Group A')
-    expect(groupA.nodes.length).toBe(4)
-
-    const a3 = graph.nodes.find((n) => n.name === 'a3')!
-    const a4 = graph.nodes.find((n) => n.name === 'a4')!
-    expect(a3.gridCoord).not.toBeNull()
-    expect(a4.gridCoord).not.toBeNull()
-    // Distinct slots — a4 didn't overwrite a3's spot.
-    expect(a4.gridCoord).not.toEqual(a3.gridCoord)
-
-    const output = renderMermaidASCII(source)
-    expect(output).toContain('Group A')
-    expect(output).toContain('charlie')
-    expect(output).toContain('echo')
-  })
-
-  it('falls back gracefully (no crash, titles intact) when a non-root anchor is foreign-blocked on both sides', () => {
-    // b2 is edge-less and unreachable from b1, so it's deferred and anchors
-    // to b1 — but b1 is itself a *non-root* (a child of a1 via an edge), so
-    // this only resolves in the later fallback pass, after an unrelated
-    // external node's own child (e2) has already claimed the slot
-    // immediately next to b1, and the opposite slot is off-grid (negative).
-    // findSubgraphAdjacentSlot correctly refuses to slide through e2 in
-    // either direction (returning null), so this exercises its
-    // "foreign-blocked" path on both sides — but with no free adjacent slot
-    // available, the caller falls back to the pre-existing (#143-era) blind
-    // slide, which can still enclose e2. That fallback is a known, narrow
-    // limitation (see the "Defensive fallback" comment in grid.ts) distinct
-    // from the bug #301 fixes: it only arises when the deferred node's
-    // anchor is itself a non-root, not for the reported root-anchored case.
-    // This test guards against a crash or dropped title, not full
-    // disjointness.
-    const source = `flowchart TB
-  subgraph a["Group A"]
-    a1["alpha"]
-  end
-  subgraph b["Group B"]
-    b1["bravo"]
-    b2["charlie"]
-  end
-  e1["delta"]
-  a1 --> b1
-  e1 --> e2["echo"]`
-
-    const graph = layoutFlowchart(source, 'TD')
-    expect(graph.nodes.find((n) => n.name === 'b2')?.gridCoord).not.toBeNull()
-
-    const output = renderMermaidASCII(source)
-    expect(output).toContain('Group A')
-    expect(output).toContain('Group B')
-    expect(output).toContain('charlie')
-  })
-
-  it('OK case: continues to work when every node in the earlier subgraph is on an edge', () => {
-    const source = `flowchart TB
-  subgraph a["Group A"]
-    a1["alpha"]
-    a2["bravo"]
-  end
-  subgraph b["Group B"]
-    b1["delta"]
-  end
-  a1 --> a2`
-
-    const graph = layoutFlowchart(source, 'TD')
-    const groupA = findSubgraph(graph, 'Group A')
-    const groupB = findSubgraph(graph, 'Group B')
-    expect(boxesOverlap(groupA, groupB)).toBe(false)
-    expect(nodeInsideBox(graph, 'b1', groupB)).toBe(true)
-
-    const output = renderMermaidASCII(source)
-    expect(output).toContain('Group A')
-    expect(output).toContain('Group B')
-  })
-})

package/src/__tests__/browser.test.ts

@@ -1,34 +0,0 @@
-/**
- * Tests for the browser entry point.
- *
- * `src/browser.ts` runs in a plain `<script>` context where `window` is
- * ambient, but our test environment is Node, so we stub a fake `window`
- * before importing the module and reset the module registry so the
- * top-level assignment actually re-runs.
- */
-import { describe, it, expect, afterEach, vi } from 'vitest'
-import type { MermaidBrowserGlobal } from '../browser.ts'
-
-describe('browser entry point', () => {
-  afterEach(() => {
-    vi.unstubAllGlobals()
-    vi.resetModules()
-  })
-
-  it('attaches the mermaid API surface to window.__mermaid', async () => {
-    const fakeWindow: { __mermaid?: MermaidBrowserGlobal } = {}
-    vi.stubGlobal('window', fakeWindow)
-
-    await import('../browser.ts')
-
-    const api = fakeWindow.__mermaid
-    expect(api).toBeDefined()
-    if (!api) throw new Error('window.__mermaid was not set')
-    expect(api.renderMermaidSVGAsync).toBeTypeOf('function')
-    expect(api.renderMermaidASCII).toBeTypeOf('function')
-    expect(api.diagramColorsToAsciiTheme).toBeTypeOf('function')
-    expect(api.getSeriesColor).toBeTypeOf('function')
-    expect(api.THEMES).toBeTypeOf('object')
-    expect(typeof api.CHART_ACCENT_FALLBACK).not.toBe('undefined')
-  })
-})

package/src/__tests__/c4-integration.test.ts

@@ -1,161 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { renderMermaidSVG, renderMermaidASCII } from '../index.ts'
-
-// End-to-end coverage for C4 diagrams through both front doors (the
-// dedicated C4 renderers, not the flowchart pipeline). The fixtures ported
-// from lukilabs/beautiful-mermaid#71 live in c4-upstream-integration.test.ts.
-
-const CONTEXT = `C4Context
-  title System Context for Internet Banking
-  Person(customer, "Personal Banking Customer", "A customer of the bank")
-  Enterprise_Boundary(b0, "Bank") {
-    System(banking, "Internet Banking System", "Lets customers view accounts")
-    SystemDb(ledger, "Ledger", "Stores transactions")
-  }
-  System_Ext(mail, "E-mail System", "Sends e-mails")
-  Rel(customer, banking, "Uses", "HTTPS")
-  Rel(banking, ledger, "Reads from and writes to")
-  Rel_Back(customer, mail, "Sends e-mails to")
-  Rel(banking, mail, "Sends e-mail using")`
-
-const CONTAINER = `C4Container
-  Person(user, "User")
-  System_Boundary(sys, "Shop") {
-    Container(web, "Web App", "React", "Storefront")
-    Container(api, "API", "Node.js", "Business logic")
-    ContainerDb(db, "Database", "PostgreSQL", "Orders")
-    ContainerQueue(q, "Events", "Kafka")
-  }
-  System_Ext(pay, "Payments")
-  Rel(user, web, "Browses")
-  Rel(web, api, "Calls", "JSON/HTTPS")
-  Rel(api, db, "Reads/writes", "SQL")
-  BiRel(api, q, "Publishes", "AMQP")
-  Rel(api, pay, "Charges cards")`
-
-const COMPONENT = `C4Component
-  Container_Boundary(api, "API") {
-    Component(ctl, "Controller", "Express", "Routes")
-    Component(svc, "Service", "TypeScript", "Rules")
-  }
-  ContainerDb(db, "Database", "Postgres")
-  Rel(ctl, svc, "Uses")
-  Rel(svc, db, "Reads")`
-
-describe('C4 SVG rendering', () => {
-  for (const [name, src] of [
-    ['context', CONTEXT],
-    ['container', CONTAINER],
-    ['component', COMPONENT],
-  ] as const) {
-    it(`renders a ${name} diagram`, () => {
-      const svg = renderMermaidSVG(src)
-      expect(svg.startsWith('<svg')).toBe(true)
-      expect(svg).toContain('</svg>')
-    })
-  }
-
-  it('draws element names, type lines and boundary labels', () => {
-    const svg = renderMermaidSVG(CONTAINER)
-    for (const text of [
-      'Web App',
-      '[Container: React]',
-      '[Container: PostgreSQL]',
-      '[Software System]',
-      'Shop',
-      'Calls',
-      '[JSON/HTTPS]',
-    ]) {
-      expect(svg).toContain(text)
-    }
-  })
-
-  it('applies the C4 palette to people and external systems', () => {
-    const svg = renderMermaidSVG(CONTEXT)
-    expect(svg).toContain('#08427b') // person
-    expect(svg).toContain('#1168bd') // internal system
-    expect(svg).toContain('#999999') // external system
-  })
-
-  it('draws a cylinder for Db variants', () => {
-    const db = renderMermaidSVG(
-      'C4Context\nSystemDb(d, "DB")\nSystem(s, "S")\nRel(s, d, "x")',
-    )
-    const plain = renderMermaidSVG(
-      'C4Context\nSystem(d, "DB")\nSystem(s, "S")\nRel(s, d, "x")',
-    )
-    // Only the cylinder has elliptical caps.
-    expect(db).toContain('<ellipse')
-    expect(plain).not.toContain('<ellipse')
-  })
-
-  it('ignores the direction option in SVG, as Mermaid has none for C4', () => {
-    // Shapes are placed in rows in declaration order, whatever the direction.
-    const strip = (svg: string) => svg.replace(/zm-title-\d+/g, 'zm-title')
-    const tb = strip(renderMermaidSVG(COMPONENT))
-    for (const direction of ['BT', 'LR', 'RL'] as const) {
-      expect(strip(renderMermaidSVG(COMPONENT, { direction }))).toBe(tb)
-    }
-  })
-
-  it('surfaces parse errors with a line number', () => {
-    expect(() =>
-      renderMermaidSVG('C4Context\nSystem(a, "A")\nSystem(a, "B")'),
-    ).toThrow(/line 3: duplicate alias/)
-  })
-})
-
-describe('C4 ASCII rendering', () => {
-  for (const [name, src] of [
-    ['context', CONTEXT],
-    ['container', CONTAINER],
-    ['component', COMPONENT],
-  ] as const) {
-    it(`renders a ${name} diagram`, () => {
-      const out = renderMermaidASCII(src)
-      expect(out.length).toBeGreaterThan(0)
-      expect(out).toMatch(/[┌+]/)
-    })
-  }
-
-  it('shows element names, type lines and boundary titles', () => {
-    const out = renderMermaidASCII(CONTAINER)
-    for (const text of ['Web App', '[Container: React]', 'Shop', 'Calls']) {
-      expect(out).toContain(text)
-    }
-  })
-
-  it('is deterministic', () => {
-    expect(renderMermaidASCII(COMPONENT)).toBe(renderMermaidASCII(COMPONENT))
-  })
-
-  it('surfaces parse errors with a line number', () => {
-    expect(() => renderMermaidASCII('C4Context\nBogus(a, "A")')).toThrow(
-      /line 2: unknown C4 macro "Bogus"/,
-    )
-  })
-})
-
-describe('Rel_Back arrow direction', () => {
-  const src = `C4Context
-  System(a, "A")
-  System(b, "B")
-  Rel_Back(a, b, "Returns")`
-
-  it('puts the SVG arrowhead at the declared "from" end', () => {
-    const svg = renderMermaidSVG(src)
-    const d =
-      /<path class="c4-relationship"[^>]* d="M ([\d.-]+),([\d.-]+) /.exec(svg)!
-    const [sx, sy] = [Number(d[1]), Number(d[2])]
-    const tip = /<polygon class="c4-arrowhead" points="([\d.]+),([\d.]+) /.exec(
-      svg,
-    )!
-    expect(Math.hypot(Number(tip[1]) - sx, Number(tip[2]) - sy)).toBeLessThan(1)
-  })
-
-  it('draws exactly one ASCII arrowhead, pointing up at "from"', () => {
-    const out = renderMermaidASCII(src)
-    expect(out).toContain('▲')
-    expect(out).not.toContain('▼')
-  })
-})

package/src/__tests__/c4-orientation.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { renderMermaidSVG, renderMermaidASCII } from '../index.ts'
-
-// `RenderOptions.direction` through the C4 renderers.
-//
-// SVG follows Mermaid's C4 renderer, which has no direction: shapes are placed
-// in rows in declaration order, so the option changes nothing. What must hold
-// in every direction is that each arrowhead sits on the right end of its
-// relationship (`Rel` at `to`, `Rel_Back` at `from`, `BiRel` at both).
-//
-// ASCII keeps its own layout: top to bottom, `BT` flips it, and `LR`/`RL`
-// render like `TB`.
-
-const DIRECTIONS = ['TB', 'BT', 'LR', 'RL'] as const
-type Dir = (typeof DIRECTIONS)[number]
-
-const SOURCE = `C4Context
-  Person(a, "A")
-  Enterprise_Boundary(b0, "Bank") {
-    System(b, "B")
-    SystemDb(c, "C")
-  }
-  System_Ext(d, "D")
-  Rel(a, b, "Uses", "HTTPS")
-  Rel(b, c, "Reads from and writes to")
-  Rel_Back(a, d, "Sends to")
-  BiRel(b, d, "Syncs")`
-
-const svgOf = (dir: Dir): string => renderMermaidSVG(SOURCE, { direction: dir })
-
-interface Line {
-  from: string
-  to: string
-  start: [number, number]
-  end: [number, number]
-}
-
-/** Each relationship's end points, read from its path (`M sx,sy L|Q ... ex,ey`). */
-function lines(svg: string): Line[] {
-  return [
-    ...svg.matchAll(
-      /<path class="c4-relationship" data-from="([^"]+)" data-to="([^"]+)"[^>]* d="([^"]+)"/g,
-    ),
-  ].map((m) => {
-    const nums = m[3]!.match(/-?[\d.]+/g)!.map(Number)
-    return {
-      from: m[1]!,
-      to: m[2]!,
-      start: [nums[0]!, nums[1]!],
-      end: [nums[nums.length - 2]!, nums[nums.length - 1]!],
-    }
-  })
-}
-
-/** Arrowhead tips: the first vertex of each arrowhead polygon. */
-function tips(svg: string): [number, number][] {
-  return [
-    ...svg.matchAll(
-      /<polygon class="c4-arrowhead" points="(-?[\d.]+),(-?[\d.]+) /g,
-    ),
-  ].map((m) => [Number(m[1]), Number(m[2])])
-}
-
-const near = (p: [number, number], q: [number, number]): boolean =>
-  Math.abs(p[0] - q[0]) < 1 && Math.abs(p[1] - q[1]) < 1
-
-describe.each(DIRECTIONS)('C4 SVG, direction %s', (dir) => {
-  const svg = svgOf(dir)
-  const line = (from: string, to: string): Line => {
-    const l = lines(svg).find((x) => x.from === from && x.to === to)
-    if (!l) throw new Error(`no relationship ${from} -> ${to}`)
-    return l
-  }
-  const headsAt = (p: [number, number]): number =>
-    tips(svg).filter((t) => near(t, p)).length
-
-  it('puts the arrowhead at "to" for Rel', () => {
-    const l = line('a', 'b')
-    expect(headsAt(l.end)).toBe(1)
-    expect(headsAt(l.start)).toBe(0)
-  })
-
-  it('puts the arrowhead at "from" for Rel_Back', () => {
-    const l = line('a', 'd')
-    expect(headsAt(l.start)).toBe(1)
-    expect(headsAt(l.end)).toBe(0)
-  })
-
-  it('puts an arrowhead at both ends for BiRel', () => {
-    const l = line('b', 'd')
-    expect(headsAt(l.start)).toBe(1)
-    expect(headsAt(l.end)).toBe(1)
-  })
-
-  it('draws one arrowhead per Rel and two for BiRel', () => {
-    expect(tips(svg)).toHaveLength(1 + 1 + 1 + 2)
-  })
-
-  it('is the same drawing in every direction', () => {
-    const strip = (s: string) => s.replace(/zm-title-\d+/g, 'zm-title')
-    expect(strip(svg)).toBe(strip(svgOf('TB')))
-  })
-})
-
-describe('C4 ASCII orientations', () => {
-  const ascii = (dir: Dir): string =>
-    renderMermaidASCII(SOURCE, { direction: dir })
-
-  it('draws arrowheads on the right ends in TB', () => {
-    const out = ascii('TB')
-    // Rel, Rel, and one end each of Rel_Back and BiRel point down; the
-    // Rel_Back head and the other BiRel head point up.
-    expect([...out].filter((c) => c === '▼')).toHaveLength(3)
-    expect([...out].filter((c) => c === '▲')).toHaveLength(2)
-  })
-
-  it('reverses the rows and the arrowheads in BT', () => {
-    const tb = ascii('TB')
-    const bt = ascii('BT')
-    expect([...bt].filter((c) => c === '▲')).toHaveLength(
-      [...tb].filter((c) => c === '▼').length,
-    )
-    expect([...bt].filter((c) => c === '▼')).toHaveLength(
-      [...tb].filter((c) => c === '▲').length,
-    )
-    expect(bt.indexOf('[Person]')).toBeGreaterThan(
-      bt.indexOf('[Software System]'),
-    )
-  })
-
-  it('flips the contents of a boundary too in BT', () => {
-    const rows = ascii('BT').split('\n')
-    const at = (re: RegExp) => rows.findIndex((l) => re.test(l))
-    // B -> C flows upward, so C sits above B inside the frame.
-    expect(at(/│ +C +│/)).toBeLessThan(at(/│ +B +│/))
-  })
-
-  it.each(['TB', 'BT'] as const)(
-    'keeps every relationship label in %s, wrapped if it must be',
-    (dir) => {
-      const out = ascii(dir)
-      for (const word of [
-        'Uses',
-        '[HTTPS]',
-        'Reads',
-        'from',
-        'and',
-        'writes',
-        'to',
-        'Sends',
-        'Syncs',
-      ]) {
-        expect(out, word).toContain(word)
-      }
-    },
-  )
-
-  it('is top-to-bottom only: LR and RL render exactly like TB', () => {
-    expect(ascii('LR')).toBe(ascii('TB'))
-    expect(ascii('RL')).toBe(ascii('TB'))
-  })
-})