zombie-mermaid 2.2.1 → 2.2.2

package/src/__tests__/er-parser-error-messages.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Error-message quality tests for the ER diagram parser (issue #541).
+ *
+ * Before this pass, `parseErDiagram` had zero `throw`/`Error` statements in
+ * the entire file (see docs/parser-error-audit-541.md): a relationship line
+ * with invalid cardinality tokens or a missing `: label` silently dropped
+ * the *entire* line — both entities included — with no indication anything
+ * was wrong. These tests assert the parser now throws an actionable error
+ * instead, while confirming valid syntax and genuinely unrelated lines
+ * (e.g. `click`, which ER's own grammar has no directive for) are
+ * unaffected.
+ */
+import { describe, it, expect } from 'vitest'
+import { parseErDiagram } from '@zombie-mermaid/mermaid-parser'
+import { splitStatements } from '@zombie-mermaid/core'
+
+function parse(text: string) {
+  return parseErDiagram(splitStatements(text))
+}
+
+describe('parseErDiagram – invalid cardinality tokens', () => {
+  it('throws on non-crow-foot cardinality characters', () => {
+    expect(() =>
+      parse(`erDiagram
+        CUSTOMER ??--?? ORDER : places`),
+    ).toThrow(/Invalid ER relationship cardinality "\?\?--\?\?"/)
+  })
+
+  it('throws on a left-side cardinality that is not one of the four valid tokens', () => {
+    expect(() =>
+      parse(`erDiagram
+        CUSTOMER |--|| ORDER : places`),
+    ).toThrow(/Invalid ER relationship cardinality "\|--\|\|"/)
+  })
+
+  it('mentions the valid cardinality tokens in the message', () => {
+    expect(() =>
+      parse(`erDiagram
+        CUSTOMER ??--?? ORDER : places`),
+    ).toThrow(/\|\|, \|o, \}\|, \}o/)
+  })
+})
+
+describe('parseErDiagram – missing relationship label', () => {
+  it('throws when the colon has no label after it', () => {
+    expect(() =>
+      parse(`erDiagram
+        CUSTOMER ||--o{ ORDER :`),
+    ).toThrow(/missing a ": label"/)
+  })
+
+  it('throws when there is no colon at all', () => {
+    expect(() =>
+      parse(`erDiagram
+        CUSTOMER ||--o{ ORDER`),
+    ).toThrow(/missing a ": label"/)
+  })
+})
+
+describe('parseErDiagram – valid syntax and unrelated lines are unaffected', () => {
+  it('still parses a fully valid relationship without throwing', () => {
+    const d = parse(`erDiagram
+      CUSTOMER ||--o{ ORDER : places`)
+    expect(d.relationships).toHaveLength(1)
+    expect(d.entities.map((e) => e.id).sort()).toEqual(['CUSTOMER', 'ORDER'])
+  })
+
+  it('does not throw for a click line (no ER click grammar; see er-click-unsupported.test.ts)', () => {
+    expect(() =>
+      parse(`erDiagram
+        CUSTOMER ||--o{ ORDER : places
+        click CUSTOMER "https://example.com" "Tooltip"`),
+    ).not.toThrow()
+  })
+
+  it('does not throw for a standalone entity name with no relationship or block', () => {
+    expect(() =>
+      parse(`erDiagram
+        CUSTOMER`),
+    ).not.toThrow()
+  })
+})

package/src/__tests__/er-parser.test.ts

@@ -5,15 +5,12 @@
  * relationships with all cardinality types, identifying/non-identifying lines.
  */
 import { describe, it, expect } from 'vitest'
-import { parseErDiagram } from '../er/parser.ts'
+import { parseErDiagram } from '@zombie-mermaid/mermaid-parser'
+import { splitStatements } from '@zombie-mermaid/core'
 
 /** Helper to parse — preprocesses text the same way index.ts does */
 function parse(text: string) {
-  const lines = text
-    .split('\n')
-    .map((l) => l.trim())
-    .filter((l) => l.length > 0 && !l.startsWith('%%'))
-  return parseErDiagram(lines)
+  return parseErDiagram(splitStatements(text))
 }
 
 // ============================================================================

package/src/__tests__/expanded-shapes.test.ts

@@ -14,7 +14,7 @@ import {
   matchExpandedBlock,
   resolveShapeName,
   knownShapeNames,
-} from '../expanded-shapes.ts'
+} from '@zombie-mermaid/mermaid-parser'
 
 function parse(statement: string) {
   return parseMermaid(`flowchart TD\n  ${statement}`)

package/src/__tests__/grid-occupancy.test.ts

@@ -8,7 +8,7 @@ import {
   pathCells,
   cloneGrid,
   NODE_BLOCK_SIZE,
-} from '../ascii/grid-occupancy.ts'
+} from '../../packages/ascii-renderer/src/grid-occupancy.ts'
 
 describe('grid-occupancy', () => {
   it('createGrid starts empty', () => {

package/src/__tests__/mcp-check-sequence-activations-tool.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { checkSequenceActivationsHandler } from '../mcp/tools/check-sequence-activations.ts'
+import { checkSequenceActivationsHandler } from '../../packages/mcp/src/tools/check-sequence-activations.ts'
 
 function parseReport(text: string): { ok: boolean; issues: unknown[] } {
   return JSON.parse(text) as { ok: boolean; issues: unknown[] }

package/src/__tests__/mcp-fix-sequence-activations-tool.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest'
+import { fixSequenceActivationsHandler } from '../../packages/mcp/src/tools/fix-sequence-activations.ts'
+
+interface FixReport {
+  ok: boolean
+  fixedDiagram: string
+  fixesApplied: string[]
+  remainingIssues: unknown[]
+}
+
+function parseReport(text: string): FixReport {
+  return JSON.parse(text) as FixReport
+}
+
+describe('fixSequenceActivationsHandler', () => {
+  it('reports ok: true with no fixes for an already-balanced diagram', () => {
+    const result = fixSequenceActivationsHandler({
+      diagram: 'sequenceDiagram\n  A->>+B: hello\n  B-->>-A: world',
+    })
+    expect(result.isError).toBeUndefined()
+    const [content] = result.content
+    if (content?.type !== 'text') {
+      throw new Error('Expected text content')
+    }
+    const report = parseReport(content.text)
+    expect(report.ok).toBe(true)
+    expect(report.fixesApplied).toEqual([])
+    expect(report.remainingIssues).toEqual([])
+    expect(report.fixedDiagram).toBe(
+      'sequenceDiagram\n  A->>+B: hello\n  B-->>-A: world',
+    )
+  })
+
+  it('appends a matching deactivate for a dangling activation', () => {
+    const result = fixSequenceActivationsHandler({
+      diagram: 'sequenceDiagram\n  activate A\n  A->>B: hello',
+    })
+    expect(result.isError).toBeUndefined()
+    const [content] = result.content
+    if (content?.type !== 'text') {
+      throw new Error('Expected text content')
+    }
+    const report = parseReport(content.text)
+    expect(report.ok).toBe(true)
+    expect(report.fixesApplied).toHaveLength(1)
+    expect(report.remainingIssues).toEqual([])
+    expect(report.fixedDiagram.trim().endsWith('deactivate A')).toBe(true)
+  })
+
+  it('fixes multiple dangling activations across different actors', () => {
+    const result = fixSequenceActivationsHandler({
+      diagram: 'sequenceDiagram\n  activate A\n  activate B\n  A->>B: hello',
+    })
+    expect(result.isError).toBeUndefined()
+    const [content] = result.content
+    if (content?.type !== 'text') {
+      throw new Error('Expected text content')
+    }
+    const report = parseReport(content.text)
+    expect(report.ok).toBe(true)
+    expect(report.fixesApplied).toHaveLength(2)
+    expect(report.fixedDiagram).toContain('deactivate A')
+    expect(report.fixedDiagram).toContain('deactivate B')
+  })
+
+  it('does not auto-fix an unmatched deactivation, reporting it instead', () => {
+    const result = fixSequenceActivationsHandler({
+      diagram: 'sequenceDiagram\n  A->>B: hello\n  deactivate A',
+    })
+    expect(result.isError).toBeUndefined()
+    const [content] = result.content
+    if (content?.type !== 'text') {
+      throw new Error('Expected text content')
+    }
+    const report = parseReport(content.text)
+    expect(report.ok).toBe(false)
+    expect(report.fixesApplied).toEqual([])
+    expect(report.fixedDiagram).toBe(
+      'sequenceDiagram\n  A->>B: hello\n  deactivate A',
+    )
+    expect(report.remainingIssues).toEqual([
+      expect.objectContaining({
+        code: 'UNMATCHED_DEACTIVATION',
+        actorId: 'A',
+      }),
+    ])
+  })
+
+  it('fixes the dangling activation while still reporting an unmatched one', () => {
+    const result = fixSequenceActivationsHandler({
+      diagram: 'sequenceDiagram\n  activate A\n  A->>B: hello\n  deactivate B',
+    })
+    expect(result.isError).toBeUndefined()
+    const [content] = result.content
+    if (content?.type !== 'text') {
+      throw new Error('Expected text content')
+    }
+    const report = parseReport(content.text)
+    expect(report.ok).toBe(false)
+    expect(report.fixesApplied).toHaveLength(1)
+    expect(report.fixedDiagram).toContain('deactivate A')
+    expect(report.remainingIssues).toEqual([
+      expect.objectContaining({
+        code: 'UNMATCHED_DEACTIVATION',
+        actorId: 'B',
+      }),
+    ])
+  })
+
+  it('rejects a non-sequence diagram with a clear error instead of a false report', () => {
+    const result = fixSequenceActivationsHandler({
+      diagram: 'graph LR\n  A --> B',
+    })
+    expect(result.isError).toBe(true)
+    const [content] = result.content
+    if (content?.type !== 'text') {
+      throw new Error('Expected text content')
+    }
+    expect(content.text).toContain('only fixes sequence diagrams')
+    expect(content.text).toContain('"flowchart"')
+  })
+
+  it('returns an MCP tool error instead of throwing on invalid sequence syntax', () => {
+    const result = fixSequenceActivationsHandler({
+      diagram: 'sequenceDiagram\n  box\n  box',
+    })
+    expect(result.isError).toBe(true)
+    const [content] = result.content
+    if (content?.type !== 'text') {
+      throw new Error('Expected text content')
+    }
+    expect(content.text).toContain('Failed to fix diagram activations')
+  })
+})

package/src/__tests__/mcp-render-ascii-tool.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest'
-import { renderAsciiHandler } from '../mcp/tools/render-ascii.ts'
-import { renderMermaidASCII } from '../ascii/index.ts'
+import { renderAsciiHandler } from '../../packages/mcp/src/tools/render-ascii.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 // ============================================================================
 // renderMermaidASCII is wrapped (not fully replaced) so every test above
@@ -8,8 +8,9 @@ import { renderMermaidASCII } from '../ascii/index.ts'
 // non-Error throw (impossible to provoke from real Mermaid source, since
 // the renderer only ever throws Error instances) overrides it per-call.
 // ============================================================================
-vi.mock('../ascii/index.ts', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../ascii/index.ts')>()
+vi.mock('@zombie-mermaid/ascii-renderer', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@zombie-mermaid/ascii-renderer')>()
   return { ...actual, renderMermaidASCII: vi.fn(actual.renderMermaidASCII) }
 })
 

package/src/__tests__/mcp-render-svg-theme-guard.test.ts

@@ -29,8 +29,8 @@ describe('render-svg.ts module load — theme registry invariant', () => {
     }))
     vi.resetModules()
 
-    await expect(import('../mcp/tools/render-svg.ts')).rejects.toThrow(
-      'Expected at least one built-in theme to be registered',
-    )
+    await expect(
+      import('../../packages/mcp/src/tools/render-svg.ts'),
+    ).rejects.toThrow('Expected at least one built-in theme to be registered')
   })
 })

package/src/__tests__/mcp-render-svg-tool.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, vi } from 'vitest'
 import {
   renderSvgHandler,
   renderSvgInputShape,
-} from '../mcp/tools/render-svg.ts'
+} from '../../packages/mcp/src/tools/render-svg.ts'
 import { THEMES } from '@zombie-mermaid/core'
 import { renderMermaidSVG } from '../index.ts'
 

package/src/__tests__/mcp-server.test.ts

@@ -11,7 +11,7 @@ import { describe, it, expect, beforeAll, afterAll } from 'vitest'
 import { Client } from '@modelcontextprotocol/sdk/client/index.js'
 import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { createMcpServer } from '../mcp/server.ts'
+import { createMcpServer } from '../../packages/mcp/src/server.ts'
 
 let server: McpServer
 let client: Client
@@ -39,6 +39,7 @@ describe('createMcpServer', () => {
     const names = tools.map((t) => t.name).sort()
     expect(names).toEqual([
       'check_mermaid_sequence_activations',
+      'fix_mermaid_sequence_activations',
       'render_mermaid_ascii',
       'render_mermaid_svg',
     ])
@@ -131,4 +132,32 @@ describe('createMcpServer', () => {
       expect.objectContaining({ code: 'DANGLING_ACTIVATION', actorId: 'A' }),
     ])
   })
+
+  it('fixes a dangling activation via a real tool call', async () => {
+    const result = await client.callTool({
+      name: 'fix_mermaid_sequence_activations',
+      arguments: {
+        diagram: 'sequenceDiagram\n  activate A\n  A->>B: hello',
+      },
+    })
+    expect(result.isError).toBeFalsy()
+    const content = result.content
+    if (
+      !Array.isArray(content) ||
+      content[0]?.type !== 'text' ||
+      typeof content[0].text !== 'string'
+    ) {
+      throw new Error('Expected text content')
+    }
+    const report = JSON.parse(content[0].text) as {
+      ok: boolean
+      fixedDiagram: string
+      fixesApplied: string[]
+      remainingIssues: unknown[]
+    }
+    expect(report.ok).toBe(true)
+    expect(report.fixedDiagram).toContain('deactivate A')
+    expect(report.fixesApplied).toHaveLength(1)
+    expect(report.remainingIssues).toEqual([])
+  })
 })

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

@@ -10,18 +10,26 @@
  */
 import { describe, it, expect } from 'vitest'
 import { parseMermaid } from '../parser.ts'
-import { parseSequenceDiagram } from '../sequence/parser.ts'
-import { parseClassDiagram } from '../class/parser.ts'
-import { parseErDiagram } from '../er/parser.ts'
+import {
+  parseSequenceDiagram,
+  parseClassDiagram,
+  parseErDiagram,
+} from '@zombie-mermaid/mermaid-parser'
 import {
   measureMultilineText,
   LINE_HEIGHT_RATIO,
   measureTextWidth,
   normalizeBrTags,
   stripFormattingTags,
+  splitStatements,
 } from '@zombie-mermaid/core'
 import { renderMermaid } from '../index.ts'
 
+/** Build a `Statement[]` from plain source lines, one statement per line. */
+function toLines(sourceLines: string[]) {
+  return splitStatements(sourceLines.join('\n'))
+}
+
 // ============================================================================
 // Parser: <br> tag normalization
 // ============================================================================
@@ -131,45 +139,45 @@ describe('parseMermaid – <br> tag normalization', () => {
 
   describe('sequence diagram labels', () => {
     it('normalizes <br> in participant alias labels', () => {
-      const lines = [
+      const lines = toLines([
         'sequenceDiagram',
         'participant A as First<br>Line',
         'A->>A: test',
-      ]
+      ])
       const diagram = parseSequenceDiagram(lines)
       expect(diagram.actors[0]!.label).toBe('First\nLine')
     })
 
     it('normalizes <br> in message labels', () => {
-      const lines = ['sequenceDiagram', 'A->>B: Hello<br>World']
+      const lines = toLines(['sequenceDiagram', 'A->>B: Hello<br>World'])
       const diagram = parseSequenceDiagram(lines)
       expect(diagram.messages[0]!.label).toBe('Hello\nWorld')
     })
 
     it('normalizes <br> in note text', () => {
-      const lines = [
+      const lines = toLines([
         'sequenceDiagram',
         'A->>B: Hello',
         'Note over A,B: First<br>Second',
-      ]
+      ])
       const diagram = parseSequenceDiagram(lines)
       expect(diagram.notes[0]!.text).toBe('First\nSecond')
     })
 
     it('normalizes <br> in block labels', () => {
-      const lines = [
+      const lines = toLines([
         'sequenceDiagram',
         'A->>B: Hello',
         'loop Every<br>30s',
         'A->>B: Ping',
         'end',
-      ]
+      ])
       const diagram = parseSequenceDiagram(lines)
       expect(diagram.blocks[0]!.label).toBe('Every\n30s')
     })
 
     it('normalizes <br> in divider labels', () => {
-      const lines = [
+      const lines = toLines([
         'sequenceDiagram',
         'A->>B: Hello',
         'alt First<br>case',
@@ -177,7 +185,7 @@ describe('parseMermaid – <br> tag normalization', () => {
         'else Second<br>case',
         'A->>B: b',
         'end',
-      ]
+      ])
       const diagram = parseSequenceDiagram(lines)
       expect(diagram.blocks[0]!.dividers[0]!.label).toBe('Second\ncase')
     })
@@ -185,19 +193,19 @@ describe('parseMermaid – <br> tag normalization', () => {
 
   describe('class diagram labels', () => {
     it('normalizes <br> in relationship labels', () => {
-      const lines = ['classDiagram', 'A --> B : uses<br>internally']
+      const lines = toLines(['classDiagram', 'A --> B : uses<br>internally'])
       const diagram = parseClassDiagram(lines)
       expect(diagram.relationships[0]!.label).toBe('uses\ninternally')
     })
 
     it('normalizes <br> in fromCardinality labels', () => {
-      const lines = ['classDiagram', 'A "one<br>to" --> B']
+      const lines = toLines(['classDiagram', 'A "one<br>to" --> B'])
       const diagram = parseClassDiagram(lines)
       expect(diagram.relationships[0]!.fromCardinality).toBe('one\nto')
     })
 
     it('normalizes <br> in toCardinality labels', () => {
-      const lines = ['classDiagram', 'A --> "many<br>items" B']
+      const lines = toLines(['classDiagram', 'A --> "many<br>items" B'])
       const diagram = parseClassDiagram(lines)
       expect(diagram.relationships[0]!.toCardinality).toBe('many\nitems')
     })
@@ -205,18 +213,21 @@ describe('parseMermaid – <br> tag normalization', () => {
 
   describe('ER diagram labels', () => {
     it('normalizes <br> in relationship labels', () => {
-      const lines = ['erDiagram', 'CUSTOMER ||--o{ ORDER : places<br>orders']
+      const lines = toLines([
+        'erDiagram',
+        'CUSTOMER ||--o{ ORDER : places<br>orders',
+      ])
       const diagram = parseErDiagram(lines)
       expect(diagram.relationships[0]!.label).toBe('places\norders')
     })
 
     it('normalizes <br> in attribute comments', () => {
-      const lines = [
+      const lines = toLines([
         'erDiagram',
         'CUSTOMER {',
         'int id PK "primary<br>key"',
         '}',
-      ]
+      ])
       const diagram = parseErDiagram(lines)
       expect(diagram.entities[0]!.attributes[0]!.comment).toBe('primary\nkey')
     })

package/src/__tests__/parser.test.ts

@@ -10,11 +10,14 @@
  * - Comments and error cases
  */
 import { describe, it, expect } from 'vitest'
-import { parseMermaid, toDirection } from '../parser.ts'
-// `isDirection` moved to @zombie-mermaid/core under #625 — `toDirection`
-// (still here) is its only in-parser caller, and core's
-// `direction-override.ts` needs the guard without importing the parser.
-import { isDirection } from '@zombie-mermaid/core'
+import { parseMermaid } from '../parser.ts'
+// `isDirection` moved to @zombie-mermaid/core under #625; `toDirection`
+// followed it under #624 once `er/parser.ts` (now
+// packages/mermaid-parser/src/er/parser.ts) became a second caller that
+// can't import this file without a cycle. `../parser.ts` still re-exports
+// it for backward compatibility, but the tests below import it straight
+// from `core`, same as `isDirection`.
+import { isDirection, toDirection } from '@zombie-mermaid/core'
 
 // ============================================================================
 // Graph header parsing
@@ -374,6 +377,115 @@ describe('parseMermaid – edges (original)', () => {
   })
 })
 
+// ============================================================================
+// Continuation-line edge chains (mermaid-js/mermaid#6049)
+//
+// Mermaid lets a vertex-chain statement wrap across lines, with the link
+// operator leading the next line rather than trailing the previous one.
+// `splitStatements` only splits on newlines/`;`, so without merging these
+// back together the continuation lines look like they start with a bare
+// arrow and no source node — parseEdgeLine can't find a node group, so it
+// dropped the node and edge entirely instead of continuing the chain.
+// ============================================================================
+
+describe('parseMermaid – continuation-line edge chains (mermaid-js/mermaid#6049)', () => {
+  it('chains a vertex statement split across lines, same as one line', () => {
+    const g = parseMermaid(
+      [
+        'flowchart TB',
+        '    start([Start])',
+        '    ==> green([Change some code])',
+        '    ==> finish([Finish])',
+      ].join('\n'),
+    )
+
+    expect([...g.nodes.keys()]).toEqual(['start', 'green', 'finish'])
+    expect(g.nodes.get('start')!.label).toBe('Start')
+    expect(g.nodes.get('green')!.label).toBe('Change some code')
+    expect(g.nodes.get('finish')!.label).toBe('Finish')
+
+    expect(g.edges).toHaveLength(2)
+    expect(g.edges[0]).toMatchObject({
+      source: 'start',
+      target: 'green',
+      style: 'thick',
+    })
+    expect(g.edges[1]).toMatchObject({
+      source: 'green',
+      target: 'finish',
+      style: 'thick',
+    })
+  })
+
+  it('keeps a self-loop on a later, unrelated line intact', () => {
+    const g = parseMermaid(
+      [
+        'flowchart TB',
+        '    start([Start])',
+        '    ==> green([Change some code])',
+        '    ==> finish([Finish])',
+        '',
+        '    green -.->|Incomplete ?| green',
+      ].join('\n'),
+    )
+
+    expect(g.edges).toHaveLength(3)
+    expect(g.edges[2]).toMatchObject({
+      source: 'green',
+      target: 'green',
+      label: 'Incomplete ?',
+      style: 'dotted',
+    })
+  })
+
+  it('matches the equivalent single-line chain', () => {
+    const multiline = parseMermaid(
+      [
+        'flowchart TB',
+        '    start([Start])',
+        '    ==> green([Change some code])',
+        '    ==> finish([Finish])',
+      ].join('\n'),
+    )
+    const singleLine = parseMermaid(
+      'flowchart TB\n    start([Start]) ==> green([Change some code]) ==> finish([Finish])',
+    )
+
+    expect([...multiline.nodes.entries()]).toEqual([
+      ...singleLine.nodes.entries(),
+    ])
+    expect(multiline.edges).toEqual(singleLine.edges)
+  })
+
+  // Regressions caught in review (PR #730): the continuation-merge heuristic
+  // above must not (a) mistake a bare `x`/`o` node id for the `x`/`o`
+  // start-marker ARROW_REGEX also accepts, or (b) merge across an explicit
+  // `;` statement boundary on the same physical line.
+
+  it('does not misread a bare node id "x" as a marked-continuation opener', () => {
+    const g = parseMermaid('flowchart TD\nx-->Y')
+    expect(g.direction).toBe('TD')
+    expect([...g.nodes.keys()]).toEqual(['x', 'Y'])
+    expect(g.edges).toHaveLength(1)
+    expect(g.edges[0]).toMatchObject({ source: 'x', target: 'Y' })
+  })
+
+  it('does not misread a bare node id "o" as a marked-continuation opener', () => {
+    const g = parseMermaid('flowchart TD\no-->Y')
+    expect(g.direction).toBe('TD')
+    expect([...g.nodes.keys()]).toEqual(['o', 'Y'])
+    expect(g.edges).toHaveLength(1)
+    expect(g.edges[0]).toMatchObject({ source: 'o', target: 'Y' })
+  })
+
+  it('keeps an explicit `;` a real statement boundary, not a continuation', () => {
+    const g = parseMermaid('flowchart TD\nA --> B; --> C')
+    expect([...g.nodes.keys()]).toEqual(['A', 'B'])
+    expect(g.edges).toHaveLength(1)
+    expect(g.edges[0]).toMatchObject({ source: 'A', target: 'B' })
+  })
+})
+
 // ============================================================================
 // Circle-end / cross-end edges: --o, --x (issue #65)
 //

package/src/__tests__/pathfinder.test.ts

@@ -5,10 +5,17 @@ import {
   mergePath,
   createPathBudget,
   DEFAULT_PATH_BUDGET,
-} from '../ascii/pathfinder.ts'
-import type { GridCoord, PathBudget } from '../ascii/types.ts'
-import { createGrid, placeBlock, type Grid } from '../ascii/grid-occupancy.ts'
-import { renderMermaidASCII } from '../ascii/index.ts'
+} from '../../packages/ascii-renderer/src/pathfinder.ts'
+import type {
+  GridCoord,
+  PathBudget,
+} from '../../packages/ascii-renderer/src/types.ts'
+import {
+  createGrid,
+  placeBlock,
+  type Grid,
+} from '../../packages/ascii-renderer/src/grid-occupancy.ts'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
 
 /**
  * Helper to build an occupied grid from a list of coordinates, going through