zombie-mermaid 2.2.1 → 2.2.2

package/packages/mermaid-parser/src/sequence/activation-fix.ts

@@ -0,0 +1,112 @@
+// ============================================================================
+// Sequence diagram — activation/deactivation auto-fix
+//
+// Extends activation-check.ts (issue #539) with the "optionally proposes a
+// fix" half of that issue's scope. Deliberately narrow: only
+// `DANGLING_ACTIVATION` (an `activate X` never closed) is auto-fixable —
+// the mechanical, unambiguous repair is to append a matching `deactivate X`
+// after the diagram's last statement, which is always syntactically valid
+// regardless of block nesting (Mermaid's `deactivate` isn't block-scoped).
+//
+// `UNMATCHED_DEACTIVATION` (a `deactivate X` with nothing open) is
+// deliberately NOT auto-fixed: fixing it means either deleting that
+// specific statement or inserting a preceding `activate X`, and this
+// package doesn't track source line/position per activation statement (see
+// SequenceDiagram.activations — only a message-index `afterIndex`, no raw
+// line offset), so a text-level edit could not target the right occurrence
+// with confidence when the same statement text repeats. Rather than guess
+// and risk mangling unrelated source, this case is reported back as a
+// remaining (unfixable) issue for a human — or a fuzzier LLM-based layer,
+// per the issue's own caveat about unvalidated frontier-model behavior — to
+// resolve.
+// ============================================================================
+
+import { detectDiagramType, splitStatements } from '@zombie-mermaid/core'
+import { parseSequenceDiagram } from './parser.ts'
+import {
+  checkActivationBalance,
+  type ActivationIssue,
+} from './activation-check.ts'
+
+export interface ActivationFixResult {
+  /** true when the returned diagram has no remaining activation issues. */
+  ok: boolean
+  /** Original diagram, unchanged if there was nothing fixable. */
+  originalDiagram: string
+  /**
+   * Diagram with a "deactivate X" statement appended for every
+   * DANGLING_ACTIVATION issue found. Identical to `originalDiagram` when
+   * there was nothing to fix.
+   */
+  fixedDiagram: string
+  /** Human-readable description of each fix actually applied. */
+  fixesApplied: string[]
+  /**
+   * Issues that could not be auto-fixed (currently always
+   * UNMATCHED_DEACTIVATION — see module header). Empty when `ok` is true.
+   */
+  remainingIssues: ActivationIssue[]
+}
+
+/**
+ * Check a Mermaid sequence diagram for activation/deactivation imbalance
+ * and, where mechanically safe, return a corrected version.
+ *
+ * Throws the same way `parseSequenceDiagram`/`detectDiagramType` do on
+ * invalid or non-sequence input — callers (e.g. the MCP tool handler) are
+ * expected to catch and translate, matching `check-sequence-activations.ts`'s
+ * own error handling.
+ */
+export function fixActivationBalance(
+  sourceDiagram: string,
+): ActivationFixResult {
+  const diagramType = detectDiagramType(sourceDiagram)
+  if (diagramType !== 'sequence') {
+    throw new Error(
+      'fixActivationBalance only supports sequence diagrams (source must ' +
+        `start with "sequenceDiagram"); detected diagram type: "${diagramType}".`,
+    )
+  }
+
+  const lines = splitStatements(sourceDiagram)
+  const diagram = parseSequenceDiagram(lines)
+  const result = checkActivationBalance(diagram)
+
+  if (result.ok) {
+    return {
+      ok: true,
+      originalDiagram: sourceDiagram,
+      fixedDiagram: sourceDiagram,
+      fixesApplied: [],
+      remainingIssues: [],
+    }
+  }
+
+  const dangling = result.issues.filter(
+    (issue) => issue.code === 'DANGLING_ACTIVATION',
+  )
+  const remainingIssues = result.issues.filter(
+    (issue) => issue.code !== 'DANGLING_ACTIVATION',
+  )
+
+  const appended = dangling
+    .map((issue) => `  deactivate ${issue.actorId}`)
+    .join('\n')
+  const fixedDiagram =
+    dangling.length === 0
+      ? sourceDiagram
+      : `${sourceDiagram.replace(/\s+$/, '')}\n${appended}`
+
+  const fixesApplied = dangling.map(
+    (issue) =>
+      `Appended "deactivate ${issue.actorId}" to close: ${issue.message}`,
+  )
+
+  return {
+    ok: remainingIssues.length === 0,
+    originalDiagram: sourceDiagram,
+    fixedDiagram,
+    fixesApplied,
+    remainingIssues,
+  }
+}

package/{src → packages/mermaid-parser/src}/sequence/parser.ts

@@ -1,5 +1,5 @@
 import type { SequenceDiagram, Message, Block, Actor } from './types.ts'
-import { normalizeBrTags } from '@zombie-mermaid/core'
+import { normalizeBrTags, type Statement } from '@zombie-mermaid/core'
 import { parseBoxHeader } from './box-color.ts'
 
 /**
@@ -120,7 +120,7 @@ const MESSAGE_ANY_ARROW_RE =
 // any of these guarantees, but removing the `!` would only replace a
 // proven-safe assertion with an unreachable guard. Left as-is; no
 // behavior change.
-export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
+export function parseSequenceDiagram(lines: Statement[]): SequenceDiagram {
   const diagram: SequenceDiagram = {
     actors: [],
     messages: [],
@@ -136,6 +136,9 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
   // only mean the box — but this parser is lenient about other statements,
   // and a `loop` opened inside a box must still own the next `end`.
   let boxOpenedAtDepth = 0
+  // Line the currently-open box started on, for the unclosed-box error at
+  // EOF below (issue #762) — `boxCtx.open` alone doesn't carry position.
+  let boxOpenLine: number | undefined
 
   // Track actor IDs to auto-create actors referenced in messages
   const actorIds = new Set<string>()
@@ -145,6 +148,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
     label: string
     startIndex: number
     dividers: Block['dividers']
+    line: number
   }> = []
 
   // `autonumber` state — a bare `autonumber` turns numbering on starting at 1
@@ -163,7 +167,8 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
   let pendingDestroy: string | undefined
 
   for (let i = 1; i < lines.length; i++) {
-    const line = lines[i]!
+    const stmt = lines[i]!
+    const line = stmt.text
 
     // --- box <color?> <label?> ---
     // Opens a participant group; closed by `end`. Boxes cannot nest
@@ -173,7 +178,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
     if (boxMatch) {
       if (boxCtx.open !== undefined) {
         throw new Error(
-          'Sequence diagram: a box cannot be nested inside another box — close the open box with "end" first',
+          `Line ${stmt.line}: Sequence diagram: a box cannot be nested inside another box — close the open box with "end" first`,
         )
       }
       const { color, label } = parseBoxHeader(boxMatch[1] ?? '')
@@ -185,6 +190,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
       diagram.boxes.push(box)
       boxCtx.open = diagram.boxes.length - 1
       boxOpenedAtDepth = blockStack.length
+      boxOpenLine = stmt.line
       continue
     }
 
@@ -202,7 +208,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
       if (actorIds.has(id)) {
         // Mermaid's own wording (sequenceDb `createParticipant`).
         throw new Error(
-          "It is not possible to have actors with the same id, even if one is destroyed before the next is created. Use 'AS' aliases to simulate the behavior",
+          `Line ${stmt.line}: It is not possible to have actors with the same id, even if one is destroyed before the next is created. Use 'AS' aliases to simulate the behavior`,
         )
       }
       actorIds.add(id)
@@ -211,7 +217,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
         label: normalizeBrTags(createMatch[3]?.trim() ?? id),
         type,
       })
-      joinOpenBox(diagram, boxCtx, id)
+      joinOpenBox(diagram, boxCtx, id, stmt.line)
       pendingCreate = id
       continue
     }
@@ -221,7 +227,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
     const destroyMatch = line.match(/^destroy\s+(.+)$/)
     if (destroyMatch) {
       const id = destroyMatch[1]!.trim()
-      ensureActor(diagram, actorIds, boxCtx, id)
+      ensureActor(diagram, actorIds, boxCtx, id, stmt.line)
       pendingDestroy = id
       continue
     }
@@ -262,7 +268,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
       }
       // A re-declaration inside a box joins it (or errors if it already
       // belongs to a different one) — Mermaid's `addActor` rule.
-      joinOpenBox(diagram, boxCtx, id)
+      joinOpenBox(diagram, boxCtx, id, stmt.line)
       continue
     }
 
@@ -279,7 +285,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
 
       // Ensure actors exist
       for (const aid of noteActorIds) {
-        ensureActor(diagram, actorIds, boxCtx, aid)
+        ensureActor(diagram, actorIds, boxCtx, aid, stmt.line)
       }
 
       let position: 'left' | 'right' | 'over' = 'over'
@@ -308,6 +314,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
         label,
         startIndex: diagram.messages.length,
         dividers: [],
+        line: stmt.line,
       })
       continue
     }
@@ -333,6 +340,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
       blockStack.length === boxOpenedAtDepth
     ) {
       boxCtx.open = undefined
+      boxOpenLine = undefined
       continue
     }
 
@@ -349,6 +357,17 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
       continue
     }
 
+    // --- Unmatched end ---
+    // Neither branch above claimed this "end" — no box and no block is
+    // currently open, so there's nothing for it to close. Previously
+    // silently ignored (#762); mirrors the "box cannot be nested" throw
+    // above in surfacing a structural mistake instead of dropping it.
+    if (line === 'end') {
+      throw new Error(
+        `Line ${stmt.line}: Sequence diagram: "end" does not match any open block ("loop"/"alt"/"opt"/"par"/"critical"/"break"/"rect") or "box" — nothing is currently open to close.`,
+      )
+    }
+
     // --- Standalone activate / deactivate ---
     // "activate A" / "deactivate A". Mermaid's own grammar expands the `+`/`-`
     // arrow shorthand into exactly this (message, then an activeStart for the
@@ -361,7 +380,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
     const activationMatch = line.match(/^(activate|deactivate)\s+(.+)$/)
     if (activationMatch) {
       const actorId = activationMatch[2]!.trim()
-      ensureActor(diagram, actorIds, boxCtx, actorId)
+      ensureActor(diagram, actorIds, boxCtx, actorId, stmt.line)
       diagram.activations.push({
         actorId,
         kind: activationMatch[1] === 'activate' ? 'start' : 'end',
@@ -403,6 +422,22 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
     const msgMatch =
       line.match(MESSAGE_LONG_ARROW_RE) ?? line.match(MESSAGE_ANY_ARROW_RE)
     if (msgMatch) {
+      // Mermaid's own unquoted actor-name grammar excludes `>` and `)` from
+      // ever starting an identifier (see the FROM/TO comment above) — so a
+      // TO capture starting with either one means the real arrow in the
+      // source is longer than what the alternation above actually matched
+      // (e.g. "->>>" only matches as "->>", leaving a stray ">" to be
+      // absorbed into TO as part of a garbled actor name) rather than a
+      // genuinely valid, if unusual, message. Reject it with an actionable
+      // error instead of silently minting that garbled actor — see the
+      // `Alice->>>Bob: Hello` example in issue #762.
+      const arrowToken = msgMatch[2]!
+      const toFirstChar = msgMatch[4]![0]
+      if (toFirstChar === '>' || toFirstChar === ')') {
+        throw new Error(
+          `Line ${stmt.line}: Malformed sequence-diagram arrow in "${line}" — "${arrowToken}${toFirstChar}" is not a recognized arrow. Expected one of: ->, -->, ->>, -->>, -x, --x, -), --), <<->>, <<-->>.`,
+        )
+      }
       pushMessage(
         diagram,
         actorIds,
@@ -413,13 +448,14 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
         msgMatch[3],
         msgMatch[4]!,
         msgMatch[5]!,
+        stmt.line,
       )
       const msgIndex = diagram.messages.length - 1
       const msg = diagram.messages[msgIndex]!
       if (pendingCreate !== undefined) {
         if (msg.to !== pendingCreate) {
           throw new Error(
-            `The created participant ${pendingCreate} does not have an associated creating message after its declaration. Please check the sequence diagram.`,
+            `Line ${stmt.line}: The created participant ${pendingCreate} does not have an associated creating message after its declaration. Please check the sequence diagram.`,
           )
         }
         findActor(diagram, pendingCreate).createdAt = msgIndex
@@ -428,7 +464,7 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
       if (pendingDestroy !== undefined) {
         if (msg.from !== pendingDestroy && msg.to !== pendingDestroy) {
           throw new Error(
-            `The destroyed participant ${pendingDestroy} does not have an associated destroying message after its declaration. Please check the sequence diagram.`,
+            `Line ${stmt.line}: The destroyed participant ${pendingDestroy} does not have an associated destroying message after its declaration. Please check the sequence diagram.`,
           )
         }
         findActor(diagram, pendingDestroy).destroyedAt = msgIndex
@@ -438,6 +474,25 @@ export function parseSequenceDiagram(lines: string[]): SequenceDiagram {
     }
   }
 
+  // A block/box left open at EOF is a structural mistake, not something to
+  // silently accept as "closed by end of input" — mirrors the class-diagram
+  // parser's unclosed-body check (#761) for the same reason: previously
+  // this was silently ignored (#762). Checked innermost-first (the block
+  // stack) since an unclosed block is the more specific, more actionable
+  // thing to report when both are open.
+  if (blockStack.length > 0) {
+    const unclosed = blockStack[blockStack.length - 1]!
+    throw new Error(
+      `Line ${unclosed.line}: Sequence diagram: unclosed "${unclosed.type}" block — expected a matching "end" before the diagram ends.`,
+    )
+  }
+  if (boxCtx.open !== undefined) {
+    const openBox = diagram.boxes[boxCtx.open]!
+    throw new Error(
+      `Line ${boxOpenLine}: Sequence diagram: unclosed "box${openBox.label ? ` ${openBox.label}` : ''}" — expected a matching "end" before the diagram ends.`,
+    )
+  }
+
   return diagram
 }
 
@@ -461,12 +516,13 @@ function ensureActor(
   actorIds: Set<string>,
   boxCtx: BoxContext,
   id: string,
+  lineNumber: number,
 ): void {
   if (!actorIds.has(id)) {
     actorIds.add(id)
     diagram.actors.push({ id, label: id, type: 'participant' })
   }
-  joinOpenBox(diagram, boxCtx, id)
+  joinOpenBox(diagram, boxCtx, id, lineNumber)
 }
 
 /**
@@ -478,6 +534,7 @@ function joinOpenBox(
   diagram: SequenceDiagram,
   boxCtx: BoxContext,
   id: string,
+  lineNumber: number,
 ): void {
   const open = boxCtx.open
   if (open === undefined) return
@@ -487,7 +544,7 @@ function joinOpenBox(
     const from = diagram.boxes[existing]!.label
     const to = diagram.boxes[open]!.label
     throw new Error(
-      `A same participant should only be defined in one Box: ${id} can't be in '${from}' and in '${to}' at the same time.`,
+      `Line ${lineNumber}: A same participant should only be defined in one Box: ${id} can't be in '${from}' and in '${to}' at the same time.`,
     )
   }
   boxCtx.membership.set(id, open)
@@ -510,9 +567,10 @@ function pushMessage(
   activationMark: string | undefined,
   to: string,
   rawLabel: string,
+  lineNumber: number,
 ): void {
-  ensureActor(diagram, actorIds, boxCtx, from)
-  ensureActor(diagram, actorIds, boxCtx, to)
+  ensureActor(diagram, actorIds, boxCtx, from, lineNumber)
+  ensureActor(diagram, actorIds, boxCtx, to, lineNumber)
 
   const bidirectional = arrow === '<<->>' || arrow === '<<-->>'
   const lineStyle = bidirectional

package/{src → packages/mermaid-parser/src}/xychart/parser.ts

@@ -1,4 +1,5 @@
 import type { XYChart, XYAxis, XYChartSeries } from './types.ts'
+import type { Statement } from '@zombie-mermaid/core'
 
 // ============================================================================
 // XY Chart parser
@@ -21,14 +22,15 @@ import type { XYChart, XYAxis, XYChartSeries } from './types.ts'
  * Parse a Mermaid xychart-beta diagram from preprocessed lines.
  * Lines should already be trimmed and comment-stripped.
  */
-export function parseXYChart(lines: string[]): XYChart {
+export function parseXYChart(lines: Statement[]): XYChart {
   const xAxis: XYAxis = {}
   const yAxis: XYAxis = {}
   const series: XYChartSeries[] = []
   let title: string | undefined
   let horizontal = false
 
-  for (const line of lines) {
+  for (const stmt of lines) {
+    const line = stmt.text
     // Header line — detect horizontal
     if (/^xychart(-beta)?\b/i.test(line)) {
       if (/\bhorizontal\b/i.test(line)) horizontal = true
@@ -86,16 +88,42 @@ export function parseXYChart(lines: string[]): XYChart {
     // bar [...]
     const barMatch = line.match(/^bar\s+\[([^\]]+)\]/)
     if (barMatch) {
-      series.push({ type: 'bar', data: parseNumericArray(barMatch[1]!) })
+      series.push({
+        type: 'bar',
+        data: parseNumericArray(barMatch[1]!, 'bar', line, stmt.line),
+      })
       continue
     }
 
     // line [...]
     const lineMatch = line.match(/^line\s+\[([^\]]+)\]/)
     if (lineMatch) {
-      series.push({ type: 'line', data: parseNumericArray(lineMatch[1]!) })
+      series.push({
+        type: 'line',
+        data: parseNumericArray(lineMatch[1]!, 'line', line, stmt.line),
+      })
       continue
     }
+
+    // None of the recognized directive shapes matched. A line that doesn't
+    // start with any known xychart-beta keyword at all falls through
+    // silently below, same as before — but a line that *does* start with
+    // one of the five keyworded directives (x-axis/y-axis/bar/line/title)
+    // and still failed every pattern above is almost certainly an attempt
+    // at that directive with broken syntax (an unclosed bracket, a missing
+    // quote, a malformed range). Previously this was silently dropped —
+    // the diagram would render with that axis/series just missing and no
+    // indication why. Surface an actionable error instead. See issue #541
+    // (parser error-message quality audit — this parser had zero throw
+    // sites before this pass).
+    const keywordMatch = line.match(/^(x-axis|y-axis|bar|line|title)\b/i)
+    if (keywordMatch) {
+      throw malformedDirectiveError(
+        keywordMatch[1]!.toLowerCase(),
+        line,
+        stmt.line,
+      )
+    }
   }
 
   // Auto-derive y-axis range from data if not specified
@@ -120,6 +148,56 @@ export function parseXYChart(lines: string[]): XYChart {
   return { title, horizontal, xAxis, yAxis, series }
 }
 
-function parseNumericArray(str: string): number[] {
-  return str.split(',').map((s) => parseFloat(s.trim()))
+/**
+ * Parse a `bar`/`line` series' comma-separated bracket contents into
+ * numbers, throwing on any element that isn't a valid number instead of
+ * silently coercing it to `NaN` (which serializes as `null` and can
+ * propagate into layout math with no indication anything was wrong — see
+ * issue #541's audit finding on this exact parser).
+ */
+function parseNumericArray(
+  str: string,
+  seriesType: 'bar' | 'line',
+  line: string,
+  lineNumber: number,
+): number[] {
+  return str.split(',').map((raw, index) => {
+    const trimmed = raw.trim()
+    const value = parseFloat(trimmed)
+    if (trimmed.length === 0 || Number.isNaN(value)) {
+      throw new Error(
+        `Line ${lineNumber}: Invalid numeric value ${JSON.stringify(trimmed)} at position ${
+          index + 1
+        } in "${line}". Every value in a ${seriesType} [...] list must be a number.`,
+      )
+    }
+    return value
+  })
+}
+
+/** Expected-syntax hint per xychart-beta keyword, for `malformedDirectiveError`. */
+const XYCHART_DIRECTIVE_HELP: Record<string, string> = {
+  'x-axis':
+    'x-axis [A, B, C] (categories) or x-axis 0 --> 100 (numeric range), either optionally preceded by a quoted title',
+  'y-axis':
+    'y-axis 0 --> 100 (numeric range) or y-axis "Title" (title only), optionally preceded by a quoted title before a range',
+  bar: 'bar [10, 20, 30] — a comma-separated numeric array in square brackets',
+  line: 'line [10, 20, 30] — a comma-separated numeric array in square brackets',
+  title: 'title "Chart Title" — a double-quoted string',
+}
+
+/**
+ * Build the error for a line that starts with a recognized xychart-beta
+ * keyword (x-axis/y-axis/bar/line/title) but doesn't match that keyword's
+ * expected syntax in any of the forms this parser supports.
+ */
+function malformedDirectiveError(
+  keyword: string,
+  line: string,
+  lineNumber: number,
+): Error {
+  const help = XYCHART_DIRECTIVE_HELP[keyword] ?? keyword
+  return new Error(
+    `Line ${lineNumber}: Malformed xychart-beta "${keyword}" directive: "${line}". Expected: ${help}.`,
+  )
 }

package/packages/svg-renderer/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Craft Docs
+Copyright (c) 2026 Dustin Fadler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -16,23 +16,27 @@ import type {
   PositionedClassNode,
   PositionedClassNote,
   PositionedClassRelationship,
-} from './types.ts'
-import { formatClassMember } from './format.ts'
+} from '@zombie-mermaid/mermaid-parser'
+import { formatClassMember } from '@zombie-mermaid/mermaid-parser'
 import type { ClassRenderOptions } from '@zombie-mermaid/core'
 import {
   estimateTextWidth,
   estimateMonoTextWidth,
   FONT_WEIGHTS,
   resolveFontSizes,
-  elkLayoutSync,
+} from '../styles.ts'
+import { elkLayoutSync } from '../elk-instance.ts'
+import {
   extractEdgePoints,
   extractEdgeLabelPosition,
+} from '../layout-engine/elk-adapter-utils.ts'
+import {
   ELK_DIRECTION_FALLBACK,
   baseElkLayoutOptions,
   buildElkEdge,
   buildElkLeafNode,
   directionToElk,
-} from '@zombie-mermaid/svg-renderer'
+} from '../layout-engine/elk-graph-builder.ts'
 import { measureMultilineText, resolveNodeStyle } from '@zombie-mermaid/core'
 
 /** Layout constants for class diagrams */

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

@@ -5,7 +5,7 @@ import type {
   PositionedClassRelationship,
   ClassMember,
   RelationshipType,
-} from './types.ts'
+} from '@zombie-mermaid/mermaid-parser'
 import type { DiagramColors, SvgEmitOptions } from '@zombie-mermaid/core'
 import {
   svgOpenTag,
@@ -17,14 +17,14 @@ import {
   escapeAttr,
   safeHref,
 } from '@zombie-mermaid/core'
+import { withDataSrc } from '../renderer.ts'
 import {
-  withDataSrc,
   FONT_SIZES,
   FONT_WEIGHTS,
   STROKE_WIDTHS,
   TEXT_BASELINE_SHIFT,
-} from '@zombie-mermaid/svg-renderer'
-import type { FontSizes } from '@zombie-mermaid/svg-renderer'
+} from '../styles.ts'
+import type { FontSizes } from '../styles.ts'
 import { CLS } from './layout.ts'
 
 // ============================================================================
@@ -61,7 +61,8 @@ const CLS_FONT = {
  * @param decorative - Marks the SVG decorative (from `options.decorative`).
  * @param linksEnabled - Whether `click`-based `<a href>` links and `<title>`
  *                       tooltips render (from `options.interactivity !==
- *                       'none'`, see `resolveLinksEnabled` in src/index.ts).
+ *                       'none'`, see `resolveLinksEnabled` in
+ *                       src/diagram-registry.ts).
  *                       Default true — matches the flowchart/state renderer.
  * @param emit - Strict-CSP controls (from `options.nonce` /
  *               `options.styleAttribute`, see #216). Default: no nonce,
@@ -399,7 +400,7 @@ const NOTE_FOLD = 6
 /**
  * Render a note as a dog-eared box: a polygon with its top-right corner
  * clipped plus a small fold triangle — the same shape the sequence renderer
- * draws for its notes (src/sequence/renderer.ts renderNote), so notes look
+ * draws for its notes (../sequence/renderer.ts renderNote), so notes look
  * alike across diagram types. Wrapped in <g class="class-note"> with
  * `data-for` naming the class it's attached to, if any.
  */