zombie-mermaid 2.2.1 → 2.2.2

package/{src → packages/svg-renderer/src}/xychart/layout.ts

@@ -8,9 +8,9 @@ import type {
   GridLine,
   PlotArea,
   LegendItem,
-} from './types.ts'
+} from '@zombie-mermaid/mermaid-parser'
 import type { XyChartRenderOptions } from '@zombie-mermaid/core'
-import { estimateTextWidth } from '@zombie-mermaid/svg-renderer'
+import { estimateTextWidth } from '../styles.ts'
 
 // ============================================================================
 // XY Chart layout engine

package/{src → packages/svg-renderer/src}/xychart/renderer.ts

@@ -1,12 +1,12 @@
-import type { PositionedXYChart } from './types.ts'
+import type { PositionedXYChart } from '@zombie-mermaid/mermaid-parser'
 import type { DiagramColors, SvgEmitOptions } from '@zombie-mermaid/core'
 import { svgOpenTag, buildStyleBlock, styleOpenTag } from '@zombie-mermaid/core'
+import { withDataSrc } from '../renderer.ts'
+import { TEXT_BASELINE_SHIFT, estimateTextWidth } from '../styles.ts'
 import {
-  withDataSrc,
-  TEXT_BASELINE_SHIFT,
-  estimateTextWidth,
-} from '@zombie-mermaid/svg-renderer'
-import { getSeriesColor, CHART_ACCENT_FALLBACK } from './colors.ts'
+  getSeriesColor,
+  CHART_ACCENT_FALLBACK,
+} from '@zombie-mermaid/mermaid-parser'
 
 // ============================================================================
 // XY Chart SVG renderer

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

@@ -11,8 +11,12 @@ import {
   colorizeChar,
   colorizeLine,
   colorizeText,
-} from '../ascii/ansi.ts'
-import type { CharRole, AsciiTheme, ColorMode } from '../ascii/types.ts'
+} from '../../packages/ascii-renderer/src/ansi.ts'
+import type {
+  CharRole,
+  AsciiTheme,
+  ColorMode,
+} from '../../packages/ascii-renderer/src/types.ts'
 import type { DiagramColors } from '@zombie-mermaid/core'
 
 const RESET = '\x1b[0m'

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

@@ -17,8 +17,8 @@ import {
   mkRoleCanvas,
   write,
   getCanvasSize,
-} from '../ascii/canvas.ts'
-import type { CharRole } from '../ascii/types.ts'
+} from '../../packages/ascii-renderer/src/canvas.ts'
+import type { CharRole } from '../../packages/ascii-renderer/src/types.ts'
 
 describe('canvas.ts write()', () => {
   it('writes within bounds, including exactly on the inclusive max edge', () => {

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

@@ -9,7 +9,7 @@
  * the ASCII equivalent ('+').
  */
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+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', () => {

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

@@ -14,7 +14,7 @@
  * just that the fix's own helper agrees with itself.
  */
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 import {
   terminalDisplayWidth,
   assertUniformDisplayWidth,

package/src/__tests__/ascii-class-box-occupancy.test.ts

@@ -1,20 +1,20 @@
 // ============================================================================
 // ASCII class diagram box-occupancy invariants
 //
-// Unlike src/ascii/er-diagram.ts (which gained an occupancy guard —
-// `setCGuarded`/`boxCells`/`regionClear` — fixing issue #350),
-// src/ascii/class-diagram.ts has no equivalent mechanism: its relationship
-// line/marker/label writes all go through the plain `setC`, which only
-// bounds-checks, never occupancy-checks. This suite sweeps the same "does a
-// relationship line/label ever land on top of an unrelated class's box"
-// question issue #350 asked for ER diagrams, generalized to class diagrams —
-// where it has never been asked before. Most cases pass today (no unguarded
-// code path is exercised); two are confirmed-broken and marked `it.fails`
-// with the exact code path they hit.
+// packages/ascii-renderer/src/er-diagram.ts has an occupancy guard —
+// `setCGuarded`/`boxCells`/`regionClear` — fixing issue #350.
+// packages/ascii-renderer/src/class-diagram.ts now generalizes that same
+// guard (see its own `boxCells`/`setCGuarded`, plus an obstruction-aware
+// same-level detour row) to close issue #953's class-diagram cases. This
+// suite sweeps the same "does a relationship line/label ever land on top of
+// an unrelated class's box" question issue #350 asked for ER diagrams,
+// generalized to class diagrams. Two cases below (the same-level detour
+// crossing a taller, in-between class's box) used to be confirmed-broken and
+// marked `it.fails`; they're now plain `it()` cases, verifying the fix.
 // ============================================================================
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 import { findBoxRect, rectsOverlap } from './helpers/ascii-form.ts'
 
 function expectNoBoxOverlap(ascii: string, names: string[]): void {
@@ -101,18 +101,15 @@ describe('ASCII class diagrams — class boxes never overlap', () => {
     expectNoBoxOverlap(ascii, ['Alpha', 'Mid', 'Charlie'])
   })
 
-  it.fails(
-    // Confirmed by rendering (not just reading the code): the same-level
-    // branch's detour row — `Math.max(fromBY, toP.y + toP.height - 1) + 2`
-    // — is computed only from the *relationship's own* two endpoints
-    // (Alpha, Charlie). It never checks whether Mid, sitting between them
-    // in the same row, is taller and extends below that row. The detour's
-    // horizontal segment is drawn through plain `setC` with no occupancy
-    // check, so it cuts straight through Mid's box — see the middle
-    // attribute line missing from the assertion below.
-    '3-node cycle, Mid (middle) has 6 attributes: detour line corrupts an attribute row',
-    () => {
-      const src = `classDiagram
+  // The same-level branch's detour row used to be computed only from the
+  // relationship's own two endpoints (Alpha, Charlie), never checking
+  // whether Mid — sitting between them in the same row — was taller and
+  // extended below that row. class-diagram.ts now searches for such a
+  // same-row obstruction and routes the detour below its bottom edge too
+  // (generalizing er-diagram.ts's obstructionBottom guard, issue #350),
+  // so the detour's horizontal segment no longer cuts through Mid's box.
+  it('3-node cycle, Mid (middle) has 6 attributes: detour line corrupts an attribute row', () => {
+    const src = `classDiagram
   class Alpha
   class Mid {
 ${manyAttrs('b', 6)}
@@ -121,7 +118,79 @@ ${manyAttrs('b', 6)}
   Alpha --> Mid
   Mid --> Charlie
   Charlie --> Alpha`
-      const ascii = renderMermaidASCII(src, { useAscii: true })
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+  })
+
+  // The same-row obstruction search (see the test above) must skip a class
+  // on a *different* level/row, even when that class's box geometrically
+  // overlaps the detour's horizontal span — not just when it happens to sit
+  // off to the side where the search would ignore it anyway regardless of
+  // the `other.y !== fromP.y` filter. `Root`/`Kid` are a real root/child
+  // pair via the level-BFS (Root has no parent, Kid is its level-1 child),
+  // placed on a different row from the Alpha/Mid/Charlie cycle.
+  //
+  // Two orderings of the same Root/Kid pair are compared: declaring Root
+  // first places Kid's column off to the side, outside the Alpha-to-Charlie
+  // detour span; declaring Root between Alpha and Mid places Kid's column
+  // so it overlaps Alpha's own range instead (confirmed below via
+  // `findBoxRect`). If the different-row filter worked, both orderings
+  // render the cycle identically — Root/Kid's actual row is irrelevant to
+  // it either way. A test that only used the non-overlapping ordering would
+  // pass even with the filter deleted (verified: an earlier version of this
+  // test did exactly that, and CodeRabbit correctly flagged it as not
+  // actually exercising the filter — see the PR discussion). Sabotage-
+  // verified: deleting the filter leaves both orderings' `+ bN: String`
+  // lines intact but makes the overlapping ordering one row taller than the
+  // non-overlapping one (19 vs. 18), which the equality assertion below
+  // catches.
+  it('3-node cycle, unrelated Root->Kid pair on a different level: obstruction search ignores it regardless of whether it overlaps the detour span', () => {
+    function withRootKid(rootDeclaredBetweenAlphaAndMid: boolean): string {
+      const rootAndKid = `  class Root
+  class Kid
+`
+      return `classDiagram
+${rootDeclaredBetweenAlphaAndMid ? '' : rootAndKid}  class Alpha
+${rootDeclaredBetweenAlphaAndMid ? rootAndKid : ''}  class Mid {
+${manyAttrs('b', 6)}
+  }
+  class Charlie
+  Alpha --> Mid
+  Mid --> Charlie
+  Charlie --> Alpha
+  Root --> Kid`
+    }
+
+    const nonOverlapping = renderMermaidASCII(withRootKid(false), {
+      useAscii: true,
+    })
+    const overlapping = renderMermaidASCII(withRootKid(true), {
+      useAscii: true,
+    })
+
+    // Confirms the geometry this test relies on: in the "overlapping"
+    // ordering, Kid really does sit on a different row from the cycle, and
+    // really does overlap Alpha's own column range (i.e. the obstruction
+    // search has something to incorrectly notice if the different-row
+    // filter is missing); in the "non-overlapping" ordering, it doesn't.
+    const overlappingAlphaRect = findBoxRect(overlapping, 'Alpha')
+    const overlappingKidRect = findBoxRect(overlapping, 'Kid')
+    expect(overlappingKidRect.y0).toBeGreaterThan(overlappingAlphaRect.y1)
+    expect(overlappingKidRect.x0).toBeLessThan(overlappingAlphaRect.x1)
+    const nonOverlappingAlphaRect = findBoxRect(nonOverlapping, 'Alpha')
+    const nonOverlappingKidRect = findBoxRect(nonOverlapping, 'Kid')
+    expect(nonOverlappingKidRect.x1).toBeLessThanOrEqual(
+      nonOverlappingAlphaRect.x0,
+    )
+
+    for (const ascii of [nonOverlapping, overlapping]) {
       expectAllPresentOnce(ascii, [
         '+ b0: String',
         '+ b1: String',
@@ -130,8 +199,43 @@ ${manyAttrs('b', 6)}
         '+ b4: String',
         '+ b5: String',
       ])
-    },
-  )
+      expectNoBoxOverlap(ascii, ['Alpha', 'Mid', 'Charlie', 'Root', 'Kid'])
+    }
+
+    // The real check: Kid overlapping the detour span must not change the
+    // cycle's own rendered height compared to Kid sitting clear of it.
+    expect(overlapping.split('\n').length).toBe(
+      nonOverlapping.split('\n').length,
+    )
+  })
+
+  // `computeLabelAnchor`'s same-level branch used to recompute the label's
+  // row from scratch (`Math.max(fromBY, toBY) + 2`) instead of reusing the
+  // connector's own obstruction-aware `detourY` (`sameLevelDetourY` above)
+  // — so a *labeled* same-level relationship still landed its label inside
+  // Mid's box even after the unlabeled connector-line fix above, the same
+  // corruption in a sibling code path (caught in review on PR #957).
+  it('3-node cycle, Mid (middle) has 6 attributes, labeled wrap-around relationship: label no longer corrupts an attribute row', () => {
+    const src = `classDiagram
+  class Alpha
+  class Mid {
+${manyAttrs('b', 6)}
+  }
+  class Charlie
+  Alpha --> Mid
+  Mid --> Charlie
+  Charlie --> Alpha : a rather long descriptive label`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+    expect(ascii).toContain('a rather long descriptive label')
+  })
 
   it('3-node cycle, long relationship label, no tall obstruction', () => {
     const src = `classDiagram
@@ -176,14 +280,13 @@ ${manyAttrs('c', 6)}
     expectNoBoxOverlap(ascii, ['A', 'B', 'C', 'D'])
   })
 
-  it.fails(
-    // Confirmed by rendering: a 4-node cycle (A->B->C->D->A) plus a skip
-    // edge (A->C) also falls into the same unguarded same-level detour as
-    // the 3-node case above — a second, independently-verified topology
-    // hitting the same code gap, this time skipping over B's box.
-    '4-node cycle with a skip edge, tall middle class: detour corrupts an attribute row',
-    () => {
-      const src = `classDiagram
+  // A 4-node cycle (A->B->C->D->A) plus a skip edge (A->C) also fell into
+  // the same unguarded same-level detour as the 3-node case above — a
+  // second, independently-verified topology hitting the same code gap,
+  // this time skipping over B's box. Fixed by the same obstruction-aware
+  // detour routing (see the 3-node cycle test above).
+  it('4-node cycle with a skip edge, tall middle class: detour corrupts an attribute row', () => {
+    const src = `classDiagram
   class A
   class B {
 ${manyAttrs('b', 6)}
@@ -195,17 +298,16 @@ ${manyAttrs('b', 6)}
   C --> D
   D --> A
   A --> C`
-      const ascii = renderMermaidASCII(src, { useAscii: true })
-      expectAllPresentOnce(ascii, [
-        '+ b0: String',
-        '+ b1: String',
-        '+ b2: String',
-        '+ b3: String',
-        '+ b4: String',
-        '+ b5: String',
-      ])
-    },
-  )
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+  })
 
   it('3 siblings + 2 children, crossing inheritance edges', () => {
     const src = `classDiagram

package/src/__tests__/ascii-class-column-width-488-489.test.ts

@@ -21,7 +21,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 import { assertUniformDisplayWidth } from './helpers/terminal-display-width.ts'
 
 /** Same source as the "Class: All 6 Relationship Types" sample (samples-data.ts). */

package/src/__tests__/ascii-class-cross-level-jog-corruption.test.ts

@@ -0,0 +1,187 @@
+// ============================================================================
+// ASCII class diagram — cross-level connector jog corrupting an intervening
+// box's text
+//
+// Discovered incidentally while writing ascii-class-box-occupancy.test.ts's
+// coverage for issue #953/PR #957 (the *same-level* relationship cycle's
+// detour line lacking an occupancy guard). This is a distinct bug in a
+// different branch of src/ascii/class-diagram.ts's relationship-drawing
+// pass — the "target is below source" (and, by the same missing guard,
+// "target is above source") branch, used whenever a relationship's two
+// classes land on different levels.
+//
+// That branch's "no collision" routing draws a straight horizontal jog
+// connecting the source's lane column to the target's lane column at some
+// row between them. The *only* check that decided this was safe to draw
+// without a detour (`findClearColumn`) tests whether the source's own lane
+// column is itself clear of boxes across the full row range — it says
+// nothing about whether the horizontal jog's row is clear all the way over
+// to the target's column. When a class ends up positioned far from its
+// actual parent's column — e.g. a level's only child is always placed at
+// the leftmost slot regardless of which sibling at the level above is its
+// parent — and a *different*, taller same-level sibling's box sits between
+// those two columns, the jog cuts straight through that sibling's box,
+// silently replacing whichever attribute/method row it crosses.
+//
+// Fixed by giving src/ascii/class-diagram.ts the same kind of box-occupancy
+// guard (`boxCells`/`setCGuarded`) src/ascii/er-diagram.ts already has for
+// issue #350, scoped to the cross-level branches only — the same-level
+// branch's own detour (PR #957's scope) is untouched here.
+// ============================================================================
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+import { findBoxRect, rectsOverlap } from './helpers/ascii-form.ts'
+
+function expectNoBoxOverlap(ascii: string, names: string[]): void {
+  const rects = names.map((n) => ({ n, r: findBoxRect(ascii, n) }))
+  for (let i = 0; i < rects.length; i++) {
+    for (let j = i + 1; j < rects.length; j++) {
+      expect(
+        rectsOverlap(rects[i]!.r, rects[j]!.r),
+        `${rects[i]!.n} and ${rects[j]!.n} boxes overlap`,
+      ).toBe(false)
+    }
+  }
+}
+
+function manyAttrs(prefix: string, count: number): string {
+  return Array.from(
+    { length: count },
+    (_, i) => `    +String ${prefix}${i}`,
+  ).join('\n')
+}
+
+/** Assert every one of `needles` appears verbatim, exactly once, in `text`. */
+function expectAllPresentOnce(text: string, needles: string[]): void {
+  for (const needle of needles) {
+    const count = text.split(needle).length - 1
+    expect(count, `expected "${needle}" to appear exactly once`).toBe(1)
+  }
+}
+
+describe('ASCII class diagrams — cross-level connector jog never corrupts a box', () => {
+  it('root-level sibling sits between a source and its far-off, sole child (minimal repro)', () => {
+    // Left/TallMid/RightSrc are three unrelated level-0 roots (no cycle
+    // involved, unlike the original report — isolates this bug from the
+    // separately-tracked same-level detour issue). Kid is RightSrc's only
+    // child, so it lands at the leftmost slot of level 1 regardless of
+    // RightSrc's own (rightmost) column — the "no collision" routing then
+    // has to jog the whole width of the canvas, straight through TallMid.
+    const src = `classDiagram
+  class Left
+  class TallMid {
+${manyAttrs('b', 6)}
+  }
+  class RightSrc
+  class Kid
+  RightSrc --> Kid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+    expectNoBoxOverlap(ascii, ['Left', 'TallMid', 'RightSrc', 'Kid'])
+  })
+
+  it('originally-reported repro: same-level cycle plus an unrelated root/child pair', () => {
+    // The exact topology this bug was first reported against. Alpha/Mid/
+    // Charlie form a same-level relationship cycle (falls to level 0 via
+    // the level-BFS's "no root" fallback); Root is a genuine level-0 root
+    // (declared after the cycle) with its own child Kid at level 1. Only
+    // "+ b4: String" is asserted here — the cross-level bug this file
+    // covers. "+ b1: String" is a *separate*, already-tracked corruption
+    // (the same-level cycle's own detour, issue #953/PR #957) and is
+    // deliberately not asserted on so this suite stays independent of
+    // that fix landing.
+    const src = `classDiagram
+  class Alpha
+  class Mid {
+${manyAttrs('b', 6)}
+  }
+  class Charlie
+  class Root
+  class Kid
+  Alpha --> Mid
+  Mid --> Charlie
+  Charlie --> Alpha
+  Root --> Kid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expect(
+      ascii,
+      '"+ b4: String" was overwritten by Root->Kid\'s jog',
+    ).toContain('+ b4: String')
+  })
+
+  it('deeper tree: a tall level-0 sibling between a level-1 source and its level-2 grandchild', () => {
+    const src = `classDiagram
+  class A
+  class TallMid {
+${manyAttrs('b', 6)}
+  }
+  class B
+  class Kid1
+  class GrandKid
+  B --> Kid1
+  Kid1 --> GrandKid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+    expectNoBoxOverlap(ascii, ['A', 'TallMid', 'B', 'Kid1', 'GrandKid'])
+  })
+
+  it('more siblings: several unrelated roots plus a separate parent/child pair, inheritance marker', () => {
+    const src = `classDiagram
+  class Left
+  class TallMid {
+${manyAttrs('d', 6)}
+  }
+  class RightSrc
+  class Kid
+  RightSrc <|-- Kid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ d0: String',
+      '+ d1: String',
+      '+ d2: String',
+      '+ d3: String',
+      '+ d4: String',
+      '+ d5: String',
+    ])
+    expectNoBoxOverlap(ascii, ['Left', 'TallMid', 'RightSrc', 'Kid'])
+  })
+
+  it('"target above source" branch with a from-side marker renders without corrupting a box', () => {
+    // The "above" branch (this file's second `else if`) has no
+    // findClearColumn collision-avoidance at all — it always draws the
+    // straight jog/vertical/horizontal/vertical/jog path, so it's just as
+    // exposed to this bug as the "below" branch, and is guarded the same
+    // way here. A `Root --> A` / `A <|-- B` / `B --> A` back-edge forces
+    // A's level above B's (the level-assignment BFS keeps the *longest*
+    // path to a node, so B->A's back edge pushes A past B) — the
+    // `A <|-- B` edge then runs from the now-deeper A up to the
+    // shallower B, taking the "above" branch with its hollow-triangle
+    // marker at the 'from' end (A), a combination no other test in this
+    // file exercises.
+    const src = `classDiagram
+  class Root
+  class A
+  class B
+  class Extra
+  Root --> A
+  A <|-- B
+  B --> A`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectNoBoxOverlap(ascii, ['Root', 'A', 'B', 'Extra'])
+  })
+})

package/src/__tests__/ascii-class-detour-label-routing-487.test.ts

@@ -25,7 +25,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 const MVC_SOURCE = `classDiagram
   class Model {

package/src/__tests__/ascii-class-diagram-compartments.test.ts

@@ -3,7 +3,7 @@
 // ============================================================================
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 describe('ASCII class diagram box compartments', () => {
   it('omits the attrs compartment for a class with methods but no attributes (regression)', () => {

package/src/__tests__/ascii-class-label-box-collision.test.ts

@@ -21,7 +21,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 describe('ASCII class diagram — label collision with an intermediate box', () => {
   it('moves a skip-edge label out of an intermediate class box instead of overwriting it', () => {

package/src/__tests__/ascii-class-label-row-collision-531.test.ts

@@ -40,7 +40,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 /** paddingY values below the default (5) that the issue found all reproduce
  * the same corruption — the vertical gap floors at 1 row, so nothing about

package/src/__tests__/ascii-class-label-territory-row-awareness.test.ts

@@ -16,7 +16,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 describe('ASCII class diagram — label territory is row-aware (issue #447 follow-up)', () => {
   it('does not truncate two labels whose relationships share a source but target different, differently-positioned classes', () => {

package/src/__tests__/ascii-class-padding.test.ts

@@ -11,7 +11,7 @@
 // ============================================================================
 
 import { describe, it, expect } from 'vitest'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 // Two independent, same-level classes — exercises the horizontal gap.
 const SIDE_BY_SIDE = `classDiagram