zombie-mermaid 2.2.2 → 2.2.4

package/packages/core/src/generated/mono-font-subset.ts

@@ -0,0 +1,32 @@
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * Regenerate with `pnpm run build:mono-font`
+ * (scripts/build-mono-font-subset.ts), which subsets
+ * third_party/fonts/jetbrains-mono-nl/JetBrainsMonoNL-Regular.ttf down to
+ * Basic Latin + Latin-1 Supplement — the self-hosted, embeddable
+ * `@font-face` packages/core/src/theme.ts's `buildStyleBlock()` inlines
+ * into an SVG's own `<style>` for its `.mono` rule (class-diagram method
+ * signatures, ER-diagram attribute types), replacing a Google Fonts CDN
+ * `@import` this library's SVG output previously depended on by default
+ * (#1061). See that script's header comment for why this subset is
+ * deliberately narrower than the site's own (demo/components/generated/
+ * mono-font-subset.ts).
+ */
+
+/** The self-hosted family name every consumer's font stack should list
+ * first — matches this subset's own `name` table entry. */
+export const MONO_FONT_FAMILY = 'JetBrains Mono NL'
+
+/** The `@font-face` rule embedding the subset as a base64 `woff2` data
+ * URI — no separate network request, no page-depth-relative path to get
+ * wrong (see the script header comment for why data-URI over a static
+ * asset file). */
+export const MONO_FONT_FACE_CSS = `@font-face {
+  font-family: 'JetBrains Mono NL';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(data:font/woff2;base64,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) format('woff2');
+  unicode-range: U+0020-007E, U+00A0-00FF;
+}`

package/packages/core/src/text-metrics.ts

@@ -273,6 +273,27 @@ function isGeometricShapesTextDefault(code: number): boolean {
   return code >= 0x25a0 && code <= 0x25ff
 }
 
+/**
+ * Arrows-block glyphs that carry Extended_Pictographic (emoji-capable) but
+ * no default Emoji_Presentation, and render as a single narrow column in
+ * every real terminal — the same misclassification the Geometric Shapes
+ * block above hits. Covers:
+ *
+ * - ↖ U+2196, ↗ U+2197, ↘ U+2198, ↙ U+2199 — drawn by the ASCII renderer
+ *   itself for diagonal edge-routing arrowheads
+ *   (packages/ascii-renderer/src/draw-arrows.ts's `drawArrowHead`) in place
+ *   of the filled triangles (◢◣◤◥) JetBrains Mono NL has no glyph for at
+ *   all — see issue #1062.
+ * - ↔ U+2194, ↕ U+2195, ↩ U+21A9, ↪ U+21AA — not drawn by the renderer
+ *   itself, but reachable if a diagram author types one into node/edge/note
+ *   label text, which passes through to the ASCII grid verbatim.
+ */
+function isArrowsBlockTextDefault(code: number): boolean {
+  return (
+    (code >= 0x2194 && code <= 0x2199) || code === 0x21a9 || code === 0x21aa
+  )
+}
+
 /**
  * Check if a character is an emoji (fullwidth)
  */
@@ -280,6 +301,7 @@ function isEmoji(char: string): boolean {
   if (EMOJI_PRESENTATION_REGEX.test(char)) return true
   const code = char.codePointAt(0)
   if (code !== undefined && isGeometricShapesTextDefault(code)) return false
+  if (code !== undefined && isArrowsBlockTextDefault(code)) return false
   return EXTENDED_PICTOGRAPHIC_REGEX.test(char)
 }
 

package/packages/core/src/theme.ts

@@ -13,6 +13,10 @@
 
 import { escapeXml, escapeAttr } from './multiline-utils.ts'
 import { parseHexColor } from './color-utils.ts'
+import {
+  MONO_FONT_FAMILY as SVG_MONO_FONT_FAMILY,
+  MONO_FONT_FACE_CSS as SVG_MONO_FONT_FACE_CSS,
+} from './generated/mono-font-subset.ts'
 
 // ============================================================================
 // Types
@@ -412,6 +416,21 @@ export function styleOpenTag(nonce?: string): string {
  *
  * Any other value is treated as a literal font name: sanitized and quoted
  * exactly as before.
+ *
+ * `hasMonoFont`'s `.mono` rule (class-diagram method signatures, ER-diagram
+ * attribute types) never reaches out to Google Fonts at all — it used to
+ * `@import` 'JetBrains Mono' from Google's CDN, a third-party network
+ * dependency a published library's default SVG output had no business
+ * making (#1061, filed as a follow-up from #1059's ASCII-side self-hosting
+ * fix). It now embeds {@link SVG_MONO_FONT_FACE_CSS} — a small, subsetted
+ * (Basic Latin + Latin-1 Supplement), self-hosted `@font-face` as a base64
+ * `woff2` data URI, generated by scripts/build-mono-font-subset.ts into
+ * ./generated/mono-font-subset.ts — directly in the SVG's own `<style>`
+ * block. Unlike `font` above, this isn't caller-configurable: it's the same
+ * embed for every consumer, on by default, with no network request either
+ * way — a strict improvement over the dead-or-alive CDN fetch it replaces,
+ * and the only way a *standalone* SVG (no surrounding host page providing
+ * its own copy of the font) renders `.mono` text correctly out of the box.
  */
 export function buildStyleBlock(
   font: string,
@@ -426,18 +445,11 @@ export function buildStyleBlock(
   const safeFont = isVarReference ? font.trim() : font.replace(/[<>{};'"]/g, '')
   const skipImport = isVarReference || isFontStackOrGenericFamily(font)
 
-  const fontImports = [
-    ...(skipImport
-      ? []
-      : [
-          `@import url('https://fonts.googleapis.com/css2?family=${encodeURIComponent(safeFont)}:wght@400;500;600;700&amp;display=swap');`,
-        ]),
-    ...(hasMonoFont
-      ? [
-          `@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500&amp;display=swap');`,
-        ]
-      : []),
-  ]
+  const fontImports = skipImport
+    ? []
+    : [
+        `@import url('https://fonts.googleapis.com/css2?family=${encodeURIComponent(safeFont)}:wght@400;500;600;700&amp;display=swap');`,
+      ]
 
   // Derived CSS variables: use override if set, else mix from bg+fg.
   // The --_ prefix signals "private/derived" — not meant for external override.
@@ -459,10 +471,14 @@ export function buildStyleBlock(
   return [
     styleOpenTag(nonce),
     ...(fontImports.length > 0 ? [`  ${fontImports.join('\n  ')}`] : []),
+    // Self-hosted, embedded @font-face for `.mono` text — see the doc
+    // comment above for why this never goes through the CDN-import/skip
+    // logic `font` above does.
+    ...(hasMonoFont ? [`  ${SVG_MONO_FONT_FACE_CSS}`] : []),
     `  text { font-family: ${isVarReference ? safeFont : `'${safeFont}'`}, system-ui, sans-serif; }`,
     ...(hasMonoFont
       ? [
-          `  .mono { font-family: 'JetBrains Mono', 'SF Mono', 'Fira Code', ui-monospace, monospace; }`,
+          `  .mono { font-family: '${SVG_MONO_FONT_FAMILY}', 'SF Mono', 'Fira Code', ui-monospace, monospace; }`,
         ]
       : []),
     `  svg {${derivedVars}`,

package/packages/mermaid-parser/src/xychart/parser.ts

@@ -48,7 +48,9 @@ export function parseXYChart(lines: Statement[]): XYChart {
     const xCatMatch = line.match(/^x-axis\s+(?:"([^"]*)"\s*)?\[([^\]]+)\]/)
     if (xCatMatch) {
       if (xCatMatch[1]) xAxis.title = xCatMatch[1]
-      xAxis.categories = xCatMatch[2]!.split(',').map((s) => s.trim())
+      xAxis.categories = splitCategoryList(xCatMatch[2]!).map((s) =>
+        unquote(s.trim()),
+      )
       continue
     }
 
@@ -148,6 +150,47 @@ export function parseXYChart(lines: Statement[]): XYChart {
   return { title, horizontal, xAxis, yAxis, series }
 }
 
+/**
+ * Split a categorical x-axis bracket's comma-separated contents into raw
+ * item strings, treating a comma *inside* a double-quoted item as literal
+ * text rather than a delimiter. A naive `.split(',')` would break
+ * `["Jan, Feb", "Mar"]` into three pieces instead of two — quoting a value
+ * that itself contains a comma is exactly the case quoting exists for. Each
+ * returned raw item is still trimmed and unquoted by the caller.
+ */
+function splitCategoryList(str: string): string[] {
+  const items: string[] = []
+  let current = ''
+  let inQuotes = false
+  for (const char of str) {
+    if (char === '"') {
+      inQuotes = !inQuotes
+      current += char
+    } else if (char === ',' && !inQuotes) {
+      items.push(current)
+      current = ''
+    } else {
+      current += char
+    }
+  }
+  items.push(current)
+  return items
+}
+
+/**
+ * Strip one matching pair of leading/trailing double quotes from a category
+ * item, if present — mirroring how an axis *title* capture group already
+ * unquotes via its regex. `x-axis [A, B, C]` items are only split and
+ * trimmed, so a quoted item like `"CLI output / logs"` previously kept its
+ * literal quote characters in the rendered label. See issue #1087.
+ */
+function unquote(value: string): string {
+  if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1)
+  }
+  return value
+}
+
 /**
  * Parse a `bar`/`line` series' comma-separated bracket contents into
  * numbers, throwing on any element that isn't a valid number instead of

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-class-box-occupancy.test.ts

@@ -137,70 +137,109 @@ ${manyAttrs('b', 6)}
   // 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
+  // Two variants of the same Root/Kid pair are compared: a narrow `Kid`
+  // never reaches the cycle's column span (baseline); a `Kid` wide enough
+  // to need real space, with `Root` declared right after `Alpha`, overlaps
+  // Alpha's (and Mid's) column range instead (confirmed below via
+  // `findBoxRect`). If the different-row filter worked, both variants
   // 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
+  // it either way. A test that only used the non-overlapping variant 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
+  // actually exercising the filter — see the PR discussion).
+  //
+  // Declaration order alone no longer controls Kid's column (issue #971:
+  // `Kid`, as the sole occupant of its level with exactly one qualifying
+  // parent, now aligns under Root's own — already-placed — column instead
+  // of always landing at the leftmost slot). This test used to force the
+  // overlapping/non-overlapping split by moving `Root`/`Kid`'s declaration
+  // point around the cycle alone; that no longer produces reliably
+  // different geometry, since Kid's position now tracks wherever Root
+  // ends up rather than its own declaration slot. Widening `Kid` (so its
+  // box needs more room than the gap next to Root provides) is what
+  // reliably produces a real overlap now, confirmed empirically against
+  // the current renderer rather than assumed.
+  //
+  // Sabotage-verified: deleting the filter leaves both variants' `+ bN:
+  // String` lines intact but makes the overlapping variant one row taller
+  // than the baseline (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
+    // Baseline: Root/Kid declared after the whole cycle, Kid narrow enough
+    // to never need more room than the gap next to Root provides.
+    const nonOverlapping = renderMermaidASCII(
+      `classDiagram
+  class Alpha
+  class Mid {
+${manyAttrs('b', 6)}
+  }
+  class Charlie
+  class Root
   class Kid
-`
-      return `classDiagram
-${rootDeclaredBetweenAlphaAndMid ? '' : rootAndKid}  class Alpha
-${rootDeclaredBetweenAlphaAndMid ? rootAndKid : ''}  class Mid {
+  Alpha --> Mid
+  Mid --> Charlie
+  Charlie --> Alpha
+  Root --> Kid`,
+      { useAscii: true },
+    )
+    // Overlapping: Root declared immediately after Alpha, Kid wide enough
+    // that centering it under Root's (narrow) column reaches into Alpha's.
+    const overlapping = renderMermaidASCII(
+      `classDiagram
+  class Alpha
+  class Root
+  class VeryLongKidName
+  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,
-    })
+  Root --> VeryLongKidName`,
+      { 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
+    // variant, 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.
+    // filter is missing); in the baseline, it doesn't.
     const overlappingAlphaRect = findBoxRect(overlapping, 'Alpha')
-    const overlappingKidRect = findBoxRect(overlapping, 'Kid')
+    const overlappingKidRect = findBoxRect(overlapping, 'VeryLongKidName')
     expect(overlappingKidRect.y0).toBeGreaterThan(overlappingAlphaRect.y1)
-    expect(overlappingKidRect.x0).toBeLessThan(overlappingAlphaRect.x1)
+    expect(overlappingKidRect.x0).toBeLessThanOrEqual(overlappingAlphaRect.x1)
     const nonOverlappingAlphaRect = findBoxRect(nonOverlapping, 'Alpha')
     const nonOverlappingKidRect = findBoxRect(nonOverlapping, 'Kid')
-    expect(nonOverlappingKidRect.x1).toBeLessThanOrEqual(
-      nonOverlappingAlphaRect.x0,
-    )
+    expect(
+      nonOverlappingKidRect.x1 < nonOverlappingAlphaRect.x0 ||
+        nonOverlappingKidRect.x0 > nonOverlappingAlphaRect.x1,
+    ).toBe(true)
 
-    for (const ascii of [nonOverlapping, overlapping]) {
-      expectAllPresentOnce(ascii, [
-        '+ b0: String',
-        '+ b1: String',
-        '+ b2: String',
-        '+ b3: String',
-        '+ b4: String',
-        '+ b5: String',
-      ])
-      expectNoBoxOverlap(ascii, ['Alpha', 'Mid', 'Charlie', 'Root', 'Kid'])
-    }
+    expectAllPresentOnce(nonOverlapping, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+    expectNoBoxOverlap(nonOverlapping, [
+      'Alpha',
+      'Mid',
+      'Charlie',
+      'Root',
+      'Kid',
+    ])
+    expectAllPresentOnce(overlapping, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+    expectNoBoxOverlap(overlapping, ['Alpha', 'Mid', 'Charlie', 'Root'])
 
     // The real check: Kid overlapping the detour span must not change the
     // cycle's own rendered height compared to Kid sitting clear of it.

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

@@ -26,6 +26,7 @@
 
 import { describe, it, expect } from 'vitest'
 import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+import { findBoxRect } from './helpers/ascii-form.ts'
 
 const MVC_SOURCE = `classDiagram
   class Model {
@@ -85,17 +86,16 @@ describe('ASCII class diagram — detour-aware relationship label placement (iss
     const ascii = renderMermaidASCII(MVC_SOURCE, { colorMode: 'none' })
     const lines = ascii.split('\n')
 
-    // Model's top border row (e.g. "┌───────────────────────────┐│") gives
-    // its right-edge column directly. `refreshes` — the label for the
+    // Model's box right edge (column-based, not a literal-column-0
+    // assumption — issue #971 can legitimately shift Model's own column
+    // when it has a real single qualifying parent to align under, same as
+    // it does here against Controller). `refreshes` — the label for the
     // relationship that detours around Model to reach View — must land
-    // strictly to the right of that border on every row it occupies, never
+    // strictly to the right of that edge on every row it occupies, never
     // overlapping Model's own footprint the way the straight-line midpoint
     // used to (issue #487).
-    const modelTopRow = lines.findIndex(
-      (l, i) => /^┌─+┐/.test(l) && (lines[i + 1]?.includes('Model') ?? false),
-    )
-    expect(modelTopRow).toBeGreaterThanOrEqual(0)
-    const modelRightBorder = lines[modelTopRow]!.indexOf('┐')
+    const modelRect = findBoxRect(ascii, 'Model')
+    const modelRightBorder = modelRect.x1
     expect(modelRightBorder).toBeGreaterThan(0)
 
     const refreshesRow = lines.findIndex((l) => l.includes('refreshes'))

package/src/__tests__/ascii-class-parent-alignment-971.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Regression tests for issue #971 — "ASCII class-diagram layout: single-
+ * parent x-alignment," the first implementation stage of #964's fix
+ * (docs/decisions/ascii-class-diagram-x-coordinate-assignment-970.md).
+ *
+ * Before this fix, `class-diagram.ts` packed each level's classes strictly
+ * left-to-right in declaration order, with no reference to any parent's
+ * column — a level with exactly one occupant always landed at column 0,
+ * even when its real parent sat far to the right. This fix aligns a
+ * "singleton block" (no sibling at its level shares its exact parent-id
+ * set) with exactly one qualifying (strictly-shallower) parent under that
+ * parent's own box center instead. Every other shape (no parents, an
+ * all-same-level/rootless-cycle parent set, or more than one class sharing
+ * a parent set) is out of scope here — it keeps its pre-fix left-to-right
+ * position, tracked separately by issue #972.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+import { findBoxRect } from './helpers/ascii-form.ts'
+
+describe('ASCII class diagram — single-parent x-alignment (issue #971)', () => {
+  it("#964's exact repro: a lone child aligns under its real parent's center, not the leftmost column", () => {
+    const src = `classDiagram
+  class Left
+  class TallMid {
+    +String b0
+    +String b1
+    +String b2
+    +String b3
+    +String b4
+    +String b5
+  }
+  class RightSrc
+  class Kid
+  RightSrc --> Kid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+
+    const rightSrc = findBoxRect(ascii, 'RightSrc')
+    const kid = findBoxRect(ascii, 'Kid')
+    const rightSrcCenter =
+      rightSrc.x0 + Math.floor((rightSrc.x1 - rightSrc.x0) / 2)
+    const kidCenter = kid.x0 + Math.floor((kid.x1 - kid.x0) / 2)
+
+    // Kid's box center lands on (or within 1 cell of, for odd-width
+    // rounding) RightSrc's box center -- not at column 0, where every
+    // sole-occupant level used to land regardless of its real parent.
+    expect(Math.abs(kidCenter - rightSrcCenter)).toBeLessThanOrEqual(1)
+    expect(kid.x0).toBeGreaterThan(0)
+
+    // Left is the leftmost root and must stay exactly where declaration
+    // order has always put it -- this fix only ever moves a class that has
+    // a real single parent to align to.
+    const left = findBoxRect(ascii, 'Left')
+    expect(left.x0).toBe(0)
+  })
+
+  it('a root class with no parent at all is unaffected', () => {
+    const src = `classDiagram
+  class Lonely`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    const lonely = findBoxRect(ascii, 'Lonely')
+    expect(lonely.x0).toBe(0)
+  })
+
+  it('a class whose only parent edges are same-level (a rootless relationship cycle) is unaffected', () => {
+    // A -> B -> C -> A has no external root: the level-BFS puts every
+    // member at level 0 together, but the `parents` map still records
+    // each one's in-cycle predecessor. That predecessor is same-level, not
+    // strictly shallower, so it doesn't qualify -- every member keeps its
+    // plain declaration-order position, same as before this fix.
+    const src = `classDiagram
+  class A
+  class B
+  class C
+  A --> B
+  B --> C
+  C --> A`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    const a = findBoxRect(ascii, 'A')
+    const b = findBoxRect(ascii, 'B')
+    const c = findBoxRect(ascii, 'C')
+    expect(a.x0).toBe(0)
+    expect(a.x0).toBeLessThan(b.x0)
+    expect(b.x0).toBeLessThan(c.x0)
+  })
+
+  // Two children sharing the exact same single parent are a *multi-member*
+  // block -- explicitly out of #971's scope (see #972) -- so this sample
+  // must render byte-for-byte the way it always has. Chosen because
+  // docs/decisions/ascii-class-diagram-x-coordinate-assignment-970.md
+  // names this exact samples-data.ts sample ("Class: Inheritance (<|--)")
+  // as one it verified stays unchanged.
+  it('an existing catalog sample with a multi-child parent (Class: Inheritance) keeps its exact current positions', () => {
+    const src = `classDiagram
+  class Animal {
+    +String name
+    +eat() void
+  }
+  class Dog {
+    +String breed
+    +bark() void
+  }
+  class Cat {
+    +bool isIndoor
+    +meow() void
+  }
+  Animal <|-- Dog
+  Animal <|-- Cat`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    const animal = findBoxRect(ascii, 'Animal')
+    const dog = findBoxRect(ascii, 'Dog')
+    const cat = findBoxRect(ascii, 'Cat')
+    expect(animal).toEqual({ x0: 0, x1: 17, y0: 0, y1: 6 })
+    expect(dog).toEqual({ x0: 0, x1: 18, y0: 10, y1: 16 })
+    expect(cat).toEqual({ x0: 23, x1: 42, y0: 10, y1: 16 })
+  })
+
+  it('two independent single-parent children at the same level both align, and compaction keeps them from overlapping', () => {
+    // ParentA and ParentB are both roots; KidA is ParentA's only child,
+    // KidB is ParentB's only child. Each is its own singleton block with
+    // exactly one qualifying parent, so both get a real desired center --
+    // this exercises the compaction pass itself (#971 must implement it
+    // for every block shape, not just multi-parent ones): two different
+    // singleton blocks can still want colliding desired positions.
+    const src = `classDiagram
+  class ParentA
+  class ParentB
+  class KidA
+  class KidB
+  ParentA --> KidA
+  ParentB --> KidB`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    const kidA = findBoxRect(ascii, 'KidA')
+    const kidB = findBoxRect(ascii, 'KidB')
+    // Declaration order is preserved -- KidA never lands right of KidB.
+    expect(kidA.x1).toBeLessThan(kidB.x0)
+  })
+})