@zombie-mermaid/mermaid-parser 2.2.1

package/src/expanded-shapes.ts

@@ -0,0 +1,376 @@
+// ============================================================================
+// zombie-mermaid — expanded node syntax  A@{ shape: ..., label: ... }
+//
+// Mermaid v11.3.0 added a metadata form for node definitions:
+//
+//   A@{ shape: rounded, label: "Start here" }
+//   B@{ shape: doc }
+//   C@{ icon: "fa:bell", form: "circle", label: "Alert" }
+//   D@{ img: "https://example.com/a.png", label: "Diagram", w: 120, h: 80 }
+//
+// It exposes ~30 semantic shape names (many with several aliases) that the
+// classic bracket syntax cannot express. This module owns both halves of
+// supporting it: parsing the metadata block, and resolving a semantic name to
+// the geometry this renderer draws.
+// ============================================================================
+
+import type { NodeShape } from '@zombie-mermaid/core'
+
+/**
+ * Every documented Mermaid shape name (and alias) mapped to the geometry this
+ * renderer draws for it.
+ *
+ * Mermaid's list is deliberately semantic — `database`, `manual-input`,
+ * `paper-tape` — while a renderer only has so many distinct outlines. Names
+ * that share an outline map to the same `NodeShape`; that is a rendering
+ * choice, not a parse failure, and it is documented in docs/diagrams.md so
+ * the collapse is discoverable rather than surprising.
+ *
+ * Keys are lowercase; lookup lowercases its input.
+ */
+const SHAPE_ALIASES: Record<string, NodeShape> = {
+  // --- Rectangle family ---
+  rect: 'rectangle',
+  rectangle: 'rectangle',
+  proc: 'rectangle',
+  process: 'rectangle',
+  'normal-rect': 'rectangle',
+
+  // --- Rounded ---
+  rounded: 'rounded',
+  event: 'rounded',
+  'rounded-rect': 'rounded',
+
+  // --- Stadium / terminal ---
+  stadium: 'stadium',
+  pill: 'stadium',
+  terminal: 'stadium',
+
+  // --- Subroutine / framed rectangle ---
+  subproc: 'subroutine',
+  subprocess: 'subroutine',
+  subroutine: 'subroutine',
+  'framed-rectangle': 'subroutine',
+  'fr-rect': 'subroutine',
+
+  // --- Cylinder / database ---
+  cyl: 'cylinder',
+  cylinder: 'cylinder',
+  db: 'cylinder',
+  database: 'cylinder',
+  'h-cyl': 'cylinder',
+  das: 'cylinder',
+  'horizontal-cylinder': 'cylinder',
+  'lin-cyl': 'cylinder',
+  'lined-cylinder': 'cylinder',
+  disk: 'cylinder',
+
+  // --- Circle ---
+  circ: 'circle',
+  circle: 'circle',
+  start: 'circle',
+
+  // --- Double circle ---
+  'dbl-circ': 'doublecircle',
+  'double-circle': 'doublecircle',
+  stop: 'doublecircle',
+
+  // --- Filled / crossed circles ---
+  'f-circ': 'filled-circle',
+  'filled-circle': 'filled-circle',
+  junction: 'filled-circle',
+  'cross-circ': 'crossed-circle',
+  'crossed-circle': 'crossed-circle',
+  summary: 'crossed-circle',
+
+  // --- Diamond / decision ---
+  diam: 'diamond',
+  diamond: 'diamond',
+  decision: 'diamond',
+  question: 'diamond',
+
+  // --- Hexagon / prepare ---
+  hex: 'hexagon',
+  hexagon: 'hexagon',
+  prepare: 'hexagon',
+
+  // --- Asymmetric / odd ---
+  odd: 'asymmetric',
+  'rect-left-inv-arrow': 'asymmetric',
+
+  // --- Parallelograms ---
+  'lean-r': 'parallelogram',
+  'lean-right': 'parallelogram',
+  'in-out': 'parallelogram',
+  'lean-l': 'parallelogram-alt',
+  'lean-left': 'parallelogram-alt',
+  'out-in': 'parallelogram-alt',
+
+  // --- Trapezoids ---
+  'trap-b': 'trapezoid',
+  'trapezoid-bottom': 'trapezoid',
+  priority: 'trapezoid',
+  'trap-t': 'trapezoid-alt',
+  'trapezoid-top': 'trapezoid-alt',
+  manual: 'trapezoid-alt',
+  'curv-trap': 'trapezoid-alt',
+  'curved-trapezoid': 'trapezoid-alt',
+  display: 'trapezoid-alt',
+
+  // --- Document family ---
+  doc: 'document',
+  document: 'document',
+  'lin-doc': 'document',
+  'lined-document': 'document',
+  'tag-doc': 'document',
+  'tagged-document': 'document',
+  docs: 'stacked-document',
+  documents: 'stacked-document',
+  'st-doc': 'stacked-document',
+  'stacked-document': 'stacked-document',
+
+  // --- Card / notched rectangle ---
+  'notch-rect': 'card',
+  card: 'card',
+  'notched-rectangle': 'card',
+
+  // --- Lined / divided / tagged rectangles ---
+  'lin-rect': 'lined-process',
+  'lined-rectangle': 'lined-process',
+  'lin-proc': 'lined-process',
+  'shaded-process': 'lined-process',
+  'div-rect': 'divided-process',
+  'divided-rectangle': 'divided-process',
+  'div-proc': 'divided-process',
+  'tag-rect': 'rectangle',
+  'tagged-rectangle': 'rectangle',
+  'tag-proc': 'rectangle',
+  procs: 'stacked-process',
+  processes: 'stacked-process',
+  'st-rect': 'stacked-process',
+  'stacked-rectangle': 'stacked-process',
+
+  // --- Triangles ---
+  tri: 'triangle',
+  triangle: 'triangle',
+  extract: 'triangle',
+  'flip-tri': 'flipped-triangle',
+  'flipped-triangle': 'flipped-triangle',
+  'manual-file': 'flipped-triangle',
+
+  // --- Window pane / internal storage ---
+  'win-pane': 'window-pane',
+  'window-pane': 'window-pane',
+  'internal-storage': 'window-pane',
+
+  // --- Fork / join ---
+  fork: 'fork-join',
+  join: 'fork-join',
+  'long-rect': 'fork-join',
+
+  // --- Notched pentagon / loop limit ---
+  'notch-pent': 'notched-pentagon',
+  'loop-limit': 'notched-pentagon',
+  'notched-pentagon': 'notched-pentagon',
+
+  // --- Sloped rectangle / manual input ---
+  'sl-rect': 'sloped-rectangle',
+  'sloped-rectangle': 'sloped-rectangle',
+  'manual-input': 'sloped-rectangle',
+
+  // --- Flag / paper tape ---
+  flag: 'flag',
+  'paper-tape': 'flag',
+
+  // --- Bow-tie rectangle / stored data ---
+  'bow-rect': 'bow-tie-rectangle',
+  'bow-tie-rectangle': 'bow-tie-rectangle',
+  'stored-data': 'bow-tie-rectangle',
+
+  // --- Delay / half-rounded rectangle ---
+  delay: 'half-rounded-rectangle',
+  'half-rounded-rectangle': 'half-rounded-rectangle',
+
+  // --- Braces / comment ---
+  brace: 'brace',
+  'brace-l': 'brace',
+  comment: 'brace',
+  'brace-r': 'brace-right',
+  braces: 'braces',
+
+  // --- Lightning bolt / communication link ---
+  bolt: 'bolt',
+  'com-link': 'bolt',
+  'lightning-bolt': 'bolt',
+
+  // --- Bare text, no outline ---
+  text: 'text',
+
+  // --- Anchor / hidden ---
+  anchor: 'anchor',
+}
+
+/**
+ * Resolve a Mermaid shape name to the geometry this renderer draws.
+ * Returns `undefined` for an unrecognized name so the caller can decide
+ * whether to fall back or report it.
+ */
+export function resolveShapeName(name: string): NodeShape | undefined {
+  return SHAPE_ALIASES[name.trim().toLowerCase()]
+}
+
+/** Every shape name this renderer accepts, for documentation and tests. */
+export function knownShapeNames(): string[] {
+  return Object.keys(SHAPE_ALIASES).sort()
+}
+
+/** The metadata a `@{ ... }` block can carry. */
+export interface ExpandedNodeMeta {
+  shape?: string
+  label?: string
+  icon?: string
+  img?: string
+  /** Outline drawn around an icon or image: `square`, `circle`, `rounded`. */
+  form?: string
+  /** Explicit width/height for an image node. */
+  w?: string
+  h?: string
+  /** Image fit mode Mermaid accepts alongside `img`. */
+  constraint?: string
+  /** Any other key seen, preserved rather than dropped. */
+  [key: string]: string | undefined
+}
+
+/**
+ * Parse the body of a `@{ ... }` block into key/value pairs.
+ *
+ * The body is a comma-separated list of `key: value`. Values may be quoted
+ * with `"` or `'`, and a quoted value may contain commas, colons, and braces
+ * — which is why this is a scanner rather than a `split(',')`.
+ *
+ * Mermaid also accepts a bare value with no key as shorthand for the shape
+ * (`A@{ rounded }`); that is handled by the caller, which sees an entry with
+ * an empty key.
+ */
+export function parseExpandedMeta(body: string): ExpandedNodeMeta {
+  const meta: ExpandedNodeMeta = {}
+
+  for (const entry of splitTopLevel(body, ',')) {
+    const trimmed = entry.trim()
+    if (trimmed.length === 0) continue
+
+    const colon = indexOfTopLevel(trimmed, ':')
+    if (colon === -1) {
+      // Bare value — Mermaid's shorthand for `shape: <value>`.
+      meta.shape ??= stripQuotes(trimmed)
+      continue
+    }
+
+    const key = trimmed.slice(0, colon).trim().toLowerCase()
+    const value = stripQuotes(trimmed.slice(colon + 1).trim())
+    if (key.length > 0) meta[key] = value
+  }
+
+  return meta
+}
+
+/** Split on `separator`, ignoring separators inside quotes. */
+function splitTopLevel(text: string, separator: string): string[] {
+  const parts: string[] = []
+  let current = ''
+  let quote: string | null = null
+
+  for (const ch of text) {
+    if (quote !== null) {
+      current += ch
+      if (ch === quote) quote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      current += ch
+      continue
+    }
+    if (ch === separator) {
+      parts.push(current)
+      current = ''
+      continue
+    }
+    current += ch
+  }
+
+  parts.push(current)
+  return parts
+}
+
+/** Index of the first `needle` outside quotes, or -1. */
+function indexOfTopLevel(text: string, needle: string): number {
+  let quote: string | null = null
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!
+    if (quote !== null) {
+      if (ch === quote) quote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      continue
+    }
+    if (ch === needle) return i
+  }
+  return -1
+}
+
+/** Remove one layer of matching wrapping quotes. */
+function stripQuotes(value: string): string {
+  if (
+    value.length >= 2 &&
+    ((value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'")))
+  ) {
+    return value.slice(1, -1)
+  }
+  return value
+}
+
+/**
+ * Find the `@{ ... }` block at the start of `text`, returning its body and
+ * total length.
+ *
+ * Brace matching is depth-aware and quote-aware, so a label containing `}`
+ * (`A@{ label: "a } b" }`) does not terminate the block early. Returns
+ * `undefined` if `text` does not open with `@{` or the block is unterminated.
+ */
+export function matchExpandedBlock(
+  text: string,
+): { body: string; length: number } | undefined {
+  if (!text.startsWith('@{')) return undefined
+
+  let depth = 0
+  let quote: string | null = null
+
+  for (let i = 1; i < text.length; i++) {
+    const ch = text[i]!
+
+    if (quote !== null) {
+      if (ch === quote) quote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      continue
+    }
+    if (ch === '{') {
+      depth++
+      continue
+    }
+    if (ch === '}') {
+      depth--
+      if (depth === 0) {
+        return { body: text.slice(2, i), length: i + 1 }
+      }
+    }
+  }
+
+  return undefined
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+// ============================================================================
+// @zombie-mermaid/mermaid-parser — per-type diagram parsers
+//
+// Class, ER, sequence, and XY chart diagrams have no shared generic model
+// the way flowcharts/state diagrams do (`MermaidGraph`, parsed by the
+// umbrella's own `src/parser.ts`). Both `svg-renderer` and `ascii-renderer`
+// import each type's parse function and types directly — confirmed by grep
+// (zombie-mermaid#624, umbrella #620, `monorepo-conversion-scoping.md`
+// finding 2) — so this package's public API is every per-type parse
+// function plus its types, not a single generic entry point.
+//
+// Each of `src/class/`, `src/er/`, `src/sequence/`, `src/xychart/` used to
+// mix this parser half (`parser.ts`, `types.ts`, and — per file, not
+// per-half-pair, see the scoping doc's addendum correction 3 —
+// `class/format.ts`, `sequence/box-color.ts`, `sequence/activation-check.ts`,
+// `xychart/colors.ts`) with a renderer half (`layout.ts`, `renderer.ts`) in
+// the same directory. The renderer half moved into
+// `packages/svg-renderer/src/<type>/` instead — see that package's `index.ts`
+// header for the reverse dependency this split introduces (`svg-renderer`
+// depends on this package for the positioned-diagram types and a handful of
+// parser-side helpers, an ordinary acyclic workspace shape per finding 2).
+//
+// This package depends only on `@zombie-mermaid/core` — verified: no file
+// below imports `elkjs`, `@zombie-mermaid/svg-renderer`, or anything from
+// the umbrella. `toDirection` moved here from the umbrella's `src/parser.ts`
+// (alongside `isDirection`, already `core` since #625) specifically so
+// `er/parser.ts` below could use it without importing the umbrella and
+// creating a cycle — see `packages/core/src/direction.ts`'s header.
+// ============================================================================
+
+export * from './class/parser.ts'
+export * from './class/types.ts'
+export * from './class/format.ts'
+
+export * from './er/parser.ts'
+export * from './er/types.ts'
+
+export * from './sequence/parser.ts'
+export * from './sequence/types.ts'
+export * from './sequence/box-color.ts'
+export * from './sequence/activation-check.ts'
+export * from './sequence/activation-fix.ts'
+
+export * from './xychart/parser.ts'
+export * from './xychart/types.ts'
+export * from './xychart/colors.ts'
+
+export * from './expanded-shapes.ts'

package/src/sequence/activation-check.ts

@@ -0,0 +1,149 @@
+// ============================================================================
+// Sequence diagram — activation/deactivation balance check
+//
+// A mechanical, deterministic semantic check: every `activate X` (or the
+// `+` arrow shorthand) must be closed by a matching `deactivate X` (or the
+// `-` shorthand) before the diagram ends. This doesn't need an LLM judge —
+// it's the same activation-stack bookkeeping
+// packages/svg-renderer/src/sequence/layout.ts already runs to *draw*
+// activation bars (see its `activationStacks` map), reused here to *report*
+// imbalance instead of silently rendering around it.
+//
+// Motivation (issue #539, split from #536): research on LLM-generated
+// Mermaid sequence diagrams found they fail mostly on activation handling
+// and error/status tracking, not basic syntax — which existing validators
+// (syntax checkers, and agentic-mermaid's structural/geometric/lint
+// `verify` tool: dangling edges, label overflow, duplicate/unreachable
+// nodes) already cover well. Activation balance is a concrete, narrow,
+// mechanically-checkable instance of that gap.
+// ============================================================================
+
+import type { SequenceDiagram, Message } from './types.ts'
+
+export type ActivationIssueCode =
+  'DANGLING_ACTIVATION' | 'UNMATCHED_DEACTIVATION'
+
+export interface ActivationIssue {
+  code: ActivationIssueCode
+  /** Actor whose activation is unbalanced. */
+  actorId: string
+  /** Human-readable explanation, including a source-position hint. */
+  message: string
+}
+
+export interface ActivationCheckResult {
+  /** true when every activation is balanced (no issues found). */
+  ok: boolean
+  issues: ActivationIssue[]
+}
+
+/** One `activate`/`deactivate` event in source order, whichever form wrote it. */
+interface Event {
+  actorId: string
+  kind: 'start' | 'end'
+  afterIndex: number
+}
+
+/**
+ * Describe where an event occurred, for a human-readable issue message.
+ * Mirrors the `afterIndex` semantics of `SequenceDiagram.activations` (see
+ * types.ts): -1 means "before the first message", otherwise the index of
+ * the message this event follows.
+ */
+function describePosition(
+  diagram: SequenceDiagram,
+  afterIndex: number,
+): string {
+  if (afterIndex < 0) return 'before the first message'
+  const msg: Message | undefined = diagram.messages[afterIndex]
+  if (!msg) return 'at an unresolved position'
+  const label = msg.label ? `: ${msg.label}` : ''
+  return `after message ${afterIndex + 1} ("${msg.from} -> ${msg.to}${label}")`
+}
+
+/**
+ * Check a parsed sequence diagram for activation/deactivation imbalance.
+ *
+ * Merges the inline `+`/`-` arrow shorthand (`Message.activate` /
+ * `Message.deactivate`) with standalone `activate X` / `deactivate X`
+ * statements (`SequenceDiagram.activations`) into one chronological event
+ * stream per actor — the same merge `layout.ts` performs to position
+ * activation bars — then walks a stack per actor:
+ *
+ * - A `deactivate` with nothing open on that actor's stack is reported as
+ *   `UNMATCHED_DEACTIVATION` (the renderer silently ignores this case —
+ *   see `endActivation` in layout.ts — this check surfaces it instead).
+ * - Anything left on a stack once every message has been processed is
+ *   reported as `DANGLING_ACTIVATION` (the renderer draws these extending
+ *   to the bottom of the diagram, which usually isn't what the author
+ *   intended).
+ */
+export function checkActivationBalance(
+  diagram: SequenceDiagram,
+): ActivationCheckResult {
+  // Standalone activations, grouped by the message index they follow — same
+  // grouping layout.ts builds for its `activationEventsByAfterIndex`.
+  const standaloneByAfterIndex = new Map<number, typeof diagram.activations>()
+  for (const event of diagram.activations) {
+    const list = standaloneByAfterIndex.get(event.afterIndex) ?? []
+    list.push(event)
+    standaloneByAfterIndex.set(event.afterIndex, list)
+  }
+
+  const events: Event[] = []
+  function pushStandalone(afterIndex: number): void {
+    for (const event of standaloneByAfterIndex.get(afterIndex) ?? []) {
+      events.push({ actorId: event.actorId, kind: event.kind, afterIndex })
+    }
+  }
+
+  // Events before the first message open first, same as layout.ts.
+  pushStandalone(-1)
+  for (let i = 0; i < diagram.messages.length; i++) {
+    const msg = diagram.messages[i]!
+    if (msg.activate) {
+      events.push({ actorId: msg.to, kind: 'start', afterIndex: i })
+    }
+    if (msg.deactivate) {
+      events.push({ actorId: msg.from, kind: 'end', afterIndex: i })
+    }
+    pushStandalone(i)
+  }
+
+  // actorId -> stack of afterIndex values where an activation was opened.
+  const stacks = new Map<string, number[]>()
+  const issues: ActivationIssue[] = []
+
+  for (const event of events) {
+    const stack = stacks.get(event.actorId) ?? []
+    stacks.set(event.actorId, stack)
+    if (event.kind === 'start') {
+      stack.push(event.afterIndex)
+      continue
+    }
+    const openedAt = stack.pop()
+    if (openedAt === undefined) {
+      issues.push({
+        code: 'UNMATCHED_DEACTIVATION',
+        actorId: event.actorId,
+        message:
+          `"deactivate ${event.actorId}" ${describePosition(diagram, event.afterIndex)} ` +
+          `has no matching "activate ${event.actorId}" open at that point.`,
+      })
+    }
+  }
+
+  for (const [actorId, stack] of stacks) {
+    for (const openedAt of stack) {
+      issues.push({
+        code: 'DANGLING_ACTIVATION',
+        actorId,
+        message:
+          `"activate ${actorId}" opened ${describePosition(diagram, openedAt)} ` +
+          `is never closed with a matching "deactivate ${actorId}".`,
+      })
+    }
+  }
+
+  return { ok: issues.length === 0, issues }
+}

package/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,
+  }
+}