agentic-mermaid 0.1.1 → 0.2.0

package/src/cli/init-agent.ts

@@ -1,147 +0,0 @@
-// `am init-agent` — write a repo-local, agent-agnostic onboarding drop-in.
-//
-// The generated files are meant for consumer repositories, not this repository:
-//   - AGENTS.md: a marked section with the Agentic Mermaid contract.
-//   - skills/agentic-mermaid-diagram-workflow/SKILL.md: generic SKILL.md bundle.
-//   - .mcp.json: sample MCP config for Code Mode.
-//
-// The command is idempotent and non-clobbering by default. It deliberately uses
-// root `skills/` instead of `.claude/` or `.agents/` so the output mirrors this
-// repo's agent-agnostic skill layout.
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { BUILTIN_FAMILY_METADATA } from '../agent/families.ts'
-
-const HOSTED_BASE = 'https://agentic-mermaid.dev'
-const HOSTED_LLMS_TXT = `${HOSTED_BASE}/llms.txt`
-const HOSTED_AGENT_GUIDE = `${HOSTED_BASE}/agent-instructions.md`
-
-export const AGENTS_MARKER = '<!-- agentic-mermaid:start -->'
-const AGENTS_MARKER_END = '<!-- agentic-mermaid:end -->'
-const STRUCTURED_NARROWERS = BUILTIN_FAMILY_METADATA.map(f => `\`${f.narrower}\``).join(' / ')
-
-export const AGENTS_SNIPPET = `${AGENTS_MARKER}
-## Editing Mermaid diagrams
-
-Use **Agentic Mermaid** whenever you create or edit Mermaid diagrams. Do not
-regenerate an existing diagram from scratch when a typed edit path exists.
-
-New diagrams: author Mermaid source directly, then parse, verify, and render.
-Existing structured diagrams: parse → narrow (${STRUCTURED_NARROWERS}) → mutate
-→ verify → serialize. Run verify at every commit point and never serialize a
-diagram whose verify result you have not inspected. For styled output pass
-\`style\` (a name like \`hand-drawn\`, a JSON record, or a stack) and \`seed\`
-to any render call — \`npx agentic-mermaid styles\` lists what is available.
-
-Useful entrypoints:
-
-- Hosted discovery digest: ${HOSTED_LLMS_TXT}
-- Hosted agent guide: ${HOSTED_AGENT_GUIDE}
-- Local/package guide: \`npx agentic-mermaid --agent-instructions\`
-- Capabilities: \`npx agentic-mermaid capabilities --json\`
-- Repo skill: \`skills/agentic-mermaid-diagram-workflow/SKILL.md\`
-${AGENTS_MARKER_END}
-`
-
-export const INIT_SKILL_MD = `---
-name: agentic-mermaid-diagram-workflow
-description: Agent-agnostic workflow for authoring and editing Mermaid diagrams with Agentic Mermaid's parse, narrow, mutate, verify, serialize, and render APIs. Use when creating or modifying Mermaid diagrams.
----
-
-# Agentic Mermaid — diagram workflow
-
-Use Agentic Mermaid for Mermaid diagram work. Prefer the narrowest safe channel:
-
-- MCP connected: use \`agentic-mermaid-mcp\` Code Mode and the global \`mermaid.*\` SDK.
-- JS/TS available: import from \`agentic-mermaid/agent\`.
-- Shell only: use \`npx agentic-mermaid --agent-instructions\` and \`npx agentic-mermaid capabilities --json\`.
-
-## Safe edit loop
-
-New diagrams: author Mermaid source directly, then parse, verify, and render.
-Existing structured diagrams:
-
-1. \`parseMermaid(source)\`.
-2. Narrow with ${STRUCTURED_NARROWERS}.
-3. Edit with \`mutate(d, op)\`; mutation ops use \`kind\`, not \`type\`.
-4. Run \`verifyMermaid(d)\` and inspect \`ok\`, \`warnings\`, and layout evidence.
-5. Serialize only after inspected verification passes.
-
-Do not concatenate strings or regenerate a whole existing structured diagram when a typed op exists. Every built-in renderable family ships a typed path when the body narrows; only opaque fallback bodies are source-level-only. If you deliberately edit source for an opaque fallback, re-parse and verify before returning it.
-
-## Output artifacts
-
-Agentic Mermaid outputs SVG, PNG, and ASCII:
-
-\`\`\`bash
-npx agentic-mermaid render diagram.mmd --format svg > diagram.svg
-npx agentic-mermaid render diagram.mmd --format png --output diagram.png
-npx agentic-mermaid render diagram.mmd --format ascii > diagram.txt
-\`\`\`
-
-Docs:
-
-- ${HOSTED_LLMS_TXT}
-- ${HOSTED_AGENT_GUIDE}
-`
-
-export const MCP_CONFIG_SAMPLE = JSON.stringify(
-  {
-    mcpServers: {
-      'agentic-mermaid': {
-        command: 'npx',
-        args: ['-y', '--package', 'agentic-mermaid', 'agentic-mermaid-mcp'],
-      },
-    },
-  },
-  null,
-  2,
-) + '\n'
-
-export interface InitAgentResult {
-  written: string[]
-  appended: string[]
-  skipped: string[]
-}
-
-function ensureDir(file: string): void {
-  const dir = dirname(file)
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
-}
-
-function writeIfMissing(path: string, content: string, result: InitAgentResult, force: boolean): void {
-  if (existsSync(path) && !force) {
-    result.skipped.push(path)
-    return
-  }
-  ensureDir(path)
-  writeFileSync(path, content)
-  result.written.push(path)
-}
-
-export function initAgentFiles(opts: { dir: string; force?: boolean }): InitAgentResult {
-  const { dir, force = false } = opts
-  const result: InitAgentResult = { written: [], appended: [], skipped: [] }
-
-  const agentsPath = join(dir, 'AGENTS.md')
-  if (!existsSync(agentsPath)) {
-    ensureDir(agentsPath)
-    writeFileSync(agentsPath, AGENTS_SNIPPET)
-    result.written.push(agentsPath)
-  } else {
-    const existing = readFileSync(agentsPath, 'utf8')
-    if (existing.includes(AGENTS_MARKER)) {
-      result.skipped.push(agentsPath)
-    } else {
-      const sep = existing.endsWith('\n') ? '\n' : '\n\n'
-      writeFileSync(agentsPath, existing + sep + AGENTS_SNIPPET)
-      result.appended.push(agentsPath)
-    }
-  }
-
-  writeIfMissing(join(dir, 'skills', 'agentic-mermaid-diagram-workflow', 'SKILL.md'), INIT_SKILL_MD, result, force)
-  writeIfMissing(join(dir, '.mcp.json'), MCP_CONFIG_SAMPLE, result, force)
-
-  return result
-}

package/src/cli/run-entrypoint.ts

@@ -1,10 +0,0 @@
-import { runCli } from './index.ts'
-
-/** Route the package-name binary's registry command to the existing MCP CLI. */
-export async function runAmCli(argv: string[]): Promise<number> {
-  if (argv[0] === 'mcp') {
-    const { runMcpCli } = await import('../mcp/mcp-cli.ts')
-    return runMcpCli(argv.slice(1))
-  }
-  return runCli(argv)
-}

package/src/color-resolver.ts

@@ -1,152 +0,0 @@
-import type { MermaidGraph, RenderOptions } from './types.ts'
-import { tryParseHex, luma255 } from './shared/color-math.ts'
-import type { DiagramColors } from './theme.ts'
-import { DEFAULTS, THEMES } from './theme.ts'
-import type { MermaidRuntimeConfig, MermaidThemeVariables } from './mermaid-source.ts'
-
-const ZINC_DARK = THEMES['zinc-dark'] ?? { bg: '#18181B', fg: '#FAFAFA' }
-
-const MERMAID_THEME_COLORS: Record<string, DiagramColors> = {
-  default: { bg: DEFAULTS.bg, fg: DEFAULTS.fg },
-  base: { bg: DEFAULTS.bg, fg: DEFAULTS.fg },
-  neutral: { bg: '#ffffff', fg: '#1f2937', line: '#9ca3af', accent: '#6b7280', muted: '#6b7280' },
-  dark: {
-    bg: ZINC_DARK.bg,
-    fg: ZINC_DARK.fg,
-    line: ZINC_DARK.line,
-    accent: ZINC_DARK.accent,
-    muted: ZINC_DARK.muted,
-    surface: ZINC_DARK.surface,
-    border: ZINC_DARK.border,
-  },
-  forest: { bg: '#f0fdf4', fg: '#14532d', line: '#4d7c0f', accent: '#15803d', muted: '#65a30d', border: '#86efac' },
-}
-
-/** Mermaid themeVariables keys read per DiagramColors channel — the single
- *  source of truth shared by resolveDiagramColors and the aesthetic-defaults
- *  composition in index.ts (user theming must beat style palettes). */
-export const CHANNEL_THEME_KEYS = {
-  bg: ['background', 'mainBkg'],
-  fg: ['primaryTextColor', 'textColor', 'nodeTextColor'],
-  line: ['lineColor', 'defaultLinkColor'],
-  accent: ['arrowheadColor', 'primaryColor'],
-  muted: ['secondaryTextColor', 'tertiaryTextColor'],
-  surface: ['primaryColor', 'nodeBkg', 'mainBkg'],
-  border: ['primaryBorderColor', 'secondaryBorderColor'],
-} as const
-
-/**
- * The internal color waist: every public color dialect is normalized to
- * DiagramColors before layout/render code sees it.
- */
-export function resolveDiagramColors(
-  options: RenderOptions,
-  config: MermaidRuntimeConfig,
-  font?: string,
-): DiagramColors {
-  const theme = resolveThemeColors(config.theme)
-  const vars = config.themeVariables
-
-  return {
-    bg: options.bg ?? readThemeValue(vars, ...CHANNEL_THEME_KEYS.bg) ?? theme?.bg ?? DEFAULTS.bg,
-    fg: options.fg ?? readThemeValue(vars, ...CHANNEL_THEME_KEYS.fg) ?? theme?.fg ?? DEFAULTS.fg,
-    line: options.line ?? readThemeValue(vars, ...CHANNEL_THEME_KEYS.line) ?? theme?.line,
-    accent: options.accent ?? readThemeValue(vars, ...CHANNEL_THEME_KEYS.accent) ?? theme?.accent,
-    muted: options.muted ?? readThemeValue(vars, ...CHANNEL_THEME_KEYS.muted) ?? theme?.muted,
-    surface: options.surface ?? readThemeValue(vars, ...CHANNEL_THEME_KEYS.surface) ?? theme?.surface,
-    border: options.border ?? readThemeValue(vars, ...CHANNEL_THEME_KEYS.border) ?? theme?.border,
-    shadow: options.shadow ?? theme?.shadow,
-    font,
-    embedFontImport: options.embedFontImport,
-  }
-}
-
-export function resolveThemeColors(themeName: string | undefined): DiagramColors | undefined {
-  if (!themeName) return undefined
-  if (themeName in THEMES) return THEMES[themeName as keyof typeof THEMES]
-  return MERMAID_THEME_COLORS[themeName.toLowerCase()]
-}
-
-export function readThemeValue(vars: MermaidThemeVariables | undefined, ...keys: string[]): string | undefined {
-  if (!vars) return undefined
-
-  for (const key of keys) {
-    const value = vars[key]
-    if (typeof value === 'string' && value.length > 0) return value
-  }
-
-  return undefined
-}
-
-/**
- * Resolve inline node styles from Mermaid classDef/class/style directives.
- * Class styles are applied first; explicit style directives override them.
- */
-export function resolveNodeInlineStyle(
-  nodeId: string,
-  graph: MermaidGraph,
-): Record<string, string> | undefined {
-  let result: Record<string, string> | undefined
-
-  const className = graph.classAssignments.get(nodeId)
-  if (className) {
-    const classDef = graph.classDefs.get(className)
-    if (classDef) result = { ...classDef }
-  }
-
-  const nodeStyle = graph.nodeStyles.get(nodeId)
-  if (nodeStyle) result = result ? { ...result, ...nodeStyle } : { ...nodeStyle }
-
-  return result
-}
-
-/**
- * Resolve inline edge styles from Mermaid linkStyle directives. Default link
- * style is applied first; edge-index-specific style overrides it.
- */
-export function resolveEdgeInlineStyle(
-  edgeIndex: number,
-  graph: MermaidGraph,
-): Record<string, string> | undefined {
-  let result: Record<string, string> | undefined
-
-  const defaultStyle = graph.linkStyles.get('default')
-  if (defaultStyle) result = { ...defaultStyle }
-
-  const indexStyle = graph.linkStyles.get(edgeIndex)
-  if (indexStyle) result = result ? { ...result, ...indexStyle } : { ...indexStyle }
-
-  return result
-}
-
-function parseHexToRgb(hex: string): { r: number; g: number; b: number } | null {
-  const rgb = tryParseHex(hex)
-  return rgb ? { r: rgb[0], g: rgb[1], b: rgb[2] } : null
-}
-
-function parseRgbFunction(color: string): { r: number; g: number; b: number } | null {
-  const match = color.match(/^rgba?\(\s*(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})/i)
-  if (!match) return null
-  const rgb = {
-    r: Number.parseInt(match[1]!, 10),
-    g: Number.parseInt(match[2]!, 10),
-    b: Number.parseInt(match[3]!, 10),
-  }
-  return Object.values(rgb).every(v => v >= 0 && v <= 255) ? rgb : null
-}
-
-export function contrastTextColor(fill: string): string | undefined {
-  const rgb = parseHexToRgb(fill) ?? parseRgbFunction(fill)
-  if (!rgb) return undefined
-  const brightness = luma255(rgb.r, rgb.g, rgb.b)
-  return brightness > 140 ? '#000000' : '#FFFFFF'
-}
-
-export function resolveInlineNodeTextColor(
-  inlineStyle: Record<string, string> | undefined,
-  fallback: string = 'var(--_text)',
-): string {
-  if (inlineStyle?.color) return inlineStyle.color
-  if (inlineStyle?.fill) return contrastTextColor(inlineStyle.fill) ?? fallback
-  return fallback
-}

package/src/elk-instance.ts

@@ -1,114 +0,0 @@
-/**
- * Shared ELK instance singleton.
- *
- * Uses elk.bundled.js (pure synchronous JS, ~1.6 MB) for all environments.
- * The singleton is created lazily on first use and cached forever.
- *
- * ELK's FakeWorker wraps both postMessage and onmessage in setTimeout(0),
- * making the normal API fully async. To bypass this:
- *   1. During construction, we capture setTimeout(0) callbacks and flush them
- *      synchronously — this registers the layout algorithms immediately.
- *   2. For layout calls, we call dispatcher.saveDispatch() directly (skipping
- *      the FakeWorker's postMessage setTimeout) and intercept the result via
- *      rawWorker.onmessage (which the dispatcher calls synchronously).
- */
-
-import type { ElkNode } from 'elkjs'
-// @ts-ignore — static import of bundled ELK
-import ELKBundled from 'elkjs/lib/elk.bundled.js'
-
-interface RawFakeWorker {
-  postMessage(msg: unknown): void
-  onmessage: ((e: { data: Record<string, unknown> }) => void) | null
-  dispatcher: {
-    saveDispatch(msg: { data: Record<string, unknown> }): void
-  }
-}
-
-let elk: unknown = null
-let rawWorker: RawFakeWorker | null = null
-
-/**
- * Ensure the ELK singleton exists.
- *
- * Patches setTimeout during construction to capture and synchronously flush
- * the algorithm registration callback that ELK queues via setTimeout(0).
- * Without this, layout calls fail with "algorithm not found" until the
- * next macrotask.
- */
-function ensureElk(): void {
-  if (elk) return
-
-  // Capture setTimeout(0) callbacks queued during ELK construction
-  const pending: (() => void)[] = []
-  const origSetTimeout = globalThis.setTimeout
-  // @ts-ignore — simplified signature for our interception
-  globalThis.setTimeout = (fn: () => void, delay?: number) => {
-    if (delay === 0) { pending.push(fn); return 0 }
-    return origSetTimeout(fn, delay)
-  }
-
-  // Bun and Cloudflare workerd define `self` (= globalThis) but not
-  // `document`, which tricks elk-worker.min.js into taking the Web Worker
-  // branch (registering self.onmessage, exporting no Worker) instead of the
-  // CJS branch that exports {Worker: FakeWorker}. Deleting `self` worked on
-  // Bun but not on workerd, where the global is undeletable. Temporarily
-  // defining `document` flips the same branch condition on both runtimes:
-  // elk-worker checks `typeof document === 'undefined' && typeof self !==
-  // 'undefined'` before falling through to module.exports.
-  const g = globalThis as Record<string, unknown>
-  const hadDocument = typeof g.document !== 'undefined'
-  if (!hadDocument) g.document = {}
-
-  elk = new ELKBundled()
-
-  if (!hadDocument) delete g.document
-
-  // Restore setTimeout immediately
-  globalThis.setTimeout = origSetTimeout
-
-  // Flush captured callbacks synchronously — registers layout algorithms
-  pending.forEach(fn => fn())
-
-  // Cache the raw FakeWorker for elkLayoutSync()
-  rawWorker = (elk as unknown as { worker: { worker: RawFakeWorker } }).worker.worker
-}
-
-/**
- * Run ELK layout synchronously.
- *
- * Bypasses BOTH of ELK's setTimeout(0) wrappers:
- *   - FakeWorker.postMessage wraps dispatch in setTimeout(0) — bypassed by
- *     calling dispatcher.saveDispatch() directly
- *   - PromisedWorker.onmessage wraps receive in setTimeout(0) — bypassed by
- *     replacing rawWorker.onmessage with a direct interceptor
- */
-export function elkLayoutSync(graph: ElkNode): ElkNode {
-  ensureElk()
-
-  let result: ElkNode | undefined
-  let error: unknown
-
-  // Replace onmessage to intercept the result synchronously
-  // (the dispatcher calls this directly, without setTimeout)
-  const origOnmessage = rawWorker!.onmessage
-  rawWorker!.onmessage = (answer: { data: Record<string, unknown> }) => {
-    if (answer.data.error) {
-      error = answer.data.error
-    } else {
-      result = answer.data.data as ElkNode
-    }
-  }
-
-  // Call dispatcher.saveDispatch directly — bypasses FakeWorker.postMessage's
-  // setTimeout(0) wrapper. The dispatcher processes the layout synchronously
-  // and calls rawWorker.onmessage with the result.
-  rawWorker!.dispatcher.saveDispatch({ data: { id: 0, cmd: 'layout', graph } as unknown as Record<string, unknown> })
-
-  // Restore original handler
-  rawWorker!.onmessage = origOnmessage
-
-  if (error) throw error
-  if (!result) throw new Error('ELK layout did not return synchronously')
-  return result
-}

package/src/er/layout.ts

@@ -1,187 +0,0 @@
-/**
- * ER diagram layout engine (ELK.js).
- *
- * Each entity box has:
- *   1. Header (entity name)
- *   2. Attribute rows (type, name, keys)
- */
-
-import type { ElkNode, ElkExtendedEdge } from 'elkjs'
-import type { ErDiagram, ErEntity, PositionedErDiagram, PositionedErEntity, PositionedErRelationship } from './types.ts'
-import type { RenderOptions, Point } from '../types.ts'
-import { applyTextTransform, estimateTextWidth, estimateMonoTextWidth, FONT_SIZES, FONT_WEIGHTS, STROKE_WIDTHS, resolveRenderStyle } from '../styles.ts'
-import type { RenderStyleDefaults } from '../styles.ts'
-import { measureMultilineText } from '../text-metrics.ts'
-import { elkLayoutSync } from '../elk-instance.ts'
-
-/** Layout constants for ER diagrams */
-const ER = {
-  padding: 40,
-  boxPadX: 14,
-  headerHeight: 34,
-  rowHeight: 22,
-  minWidth: 140,
-  attrFontSize: 11,
-  attrFontWeight: 400,
-  nodeSpacing: 70,
-  layerSpacing: 90,
-} as const
-
-/** Shared by layout (sizing) and renderer (drawing) — keep it single-sourced. */
-export const ER_STYLE_DEFAULTS: RenderStyleDefaults = {
-  nodeLabelFontSize: FONT_SIZES.nodeLabel,
-  edgeLabelFontSize: FONT_SIZES.edgeLabel,
-  groupHeaderFontSize: FONT_SIZES.groupHeader,
-  nodeLabelFontWeight: 700, // entity headers are drawn bold; measure them bold too
-  edgeLabelFontWeight: FONT_WEIGHTS.edgeLabel,
-  groupHeaderFontWeight: FONT_WEIGHTS.groupHeader,
-  nodePaddingX: ER.boxPadX,
-  nodePaddingY: 8,
-  nodeCornerRadius: 0,
-  nodeLineWidth: STROKE_WIDTHS.outerBox,
-  edgeLineWidth: STROKE_WIDTHS.connector,
-  groupCornerRadius: 0,
-  groupPaddingX: ER.boxPadX,
-  groupPaddingY: 8,
-  groupLineWidth: STROKE_WIDTHS.outerBox,
-}
-
-type EntitySizeMap = Map<string, { width: number; height: number; headerHeight: number }>
-
-/** Build ELK graph and size map from an ER diagram. */
-function buildErElkGraph(
-  diagram: ErDiagram,
-  options: RenderOptions
-): { elkGraph: ElkNode; entitySizes: EntitySizeMap } {
-  const style = resolveRenderStyle(options, ER_STYLE_DEFAULTS)
-  const entitySizes: EntitySizeMap = new Map()
-
-  for (const entity of diagram.entities) {
-    const label = applyTextTransform(entity.label, style.nodeTextTransform)
-    const headerTextW = estimateTextWidth(label, style.nodeLabelFontSize, style.nodeLabelFontWeight)
-    let maxAttrW = 0
-    for (const attr of entity.attributes) {
-      const attrText = `${attr.type}  ${attr.name}${attr.keys.length > 0 ? '  ' + attr.keys.join(',') : ''}`
-      const w = estimateMonoTextWidth(attrText, ER.attrFontSize)
-      if (w > maxAttrW) maxAttrW = w
-    }
-    const width = Math.max(ER.minWidth, headerTextW + style.nodePaddingX * 2, maxAttrW + style.nodePaddingX * 2)
-    const headerHeight = Math.max(ER.headerHeight, measureMultilineText(label, style.nodeLabelFontSize, style.nodeLabelFontWeight).height + style.nodePaddingY * 2)
-    const height = headerHeight + Math.max(entity.attributes.length, 1) * ER.rowHeight
-    entitySizes.set(entity.id, { width, height, headerHeight })
-  }
-
-  const elkGraph: ElkNode = {
-    id: 'root',
-    layoutOptions: {
-      'elk.algorithm': 'layered',
-      'elk.direction': 'RIGHT',
-      'elk.spacing.nodeNode': String(ER.nodeSpacing),
-      'elk.layered.spacing.nodeNodeBetweenLayers': String(ER.layerSpacing),
-      'elk.padding': `[top=${ER.padding},left=${ER.padding},bottom=${ER.padding},right=${ER.padding}]`,
-      'elk.edgeRouting': 'ORTHOGONAL',
-      'elk.edgeLabels.placement': 'CENTER',
-    },
-    children: [],
-    edges: [],
-  }
-
-  for (const entity of diagram.entities) {
-    const size = entitySizes.get(entity.id)!
-    elkGraph.children!.push({ id: entity.id, width: size.width, height: size.height })
-  }
-
-  for (let i = 0; i < diagram.relationships.length; i++) {
-    const rel = diagram.relationships[i]!
-    const edge: ElkExtendedEdge = { id: `e${i}`, sources: [rel.entity1], targets: [rel.entity2] }
-    if (rel.label) {
-      const label = applyTextTransform(rel.label, style.edgeTextTransform)
-      const metrics = measureMultilineText(label, style.edgeLabelFontSize, style.edgeLabelFontWeight)
-      edge.labels = [{ text: label, width: metrics.width + 8, height: metrics.height + 6 }]
-    }
-    elkGraph.edges!.push(edge)
-  }
-
-  return { elkGraph, entitySizes }
-}
-
-/** Extract positioned entities and relationships from ELK result. */
-function extractErLayout(
-  result: ElkNode,
-  diagram: ErDiagram,
-  entitySizes: EntitySizeMap
-): PositionedErDiagram {
-  const entityLookup = new Map<string, ErEntity>()
-  for (const entity of diagram.entities) entityLookup.set(entity.id, entity)
-
-  const positionedEntities: PositionedErEntity[] = []
-  for (const child of result.children ?? []) {
-    const entity = entityLookup.get(child.id)
-    if (entity) {
-      positionedEntities.push({
-        id: entity.id,
-        label: entity.label,
-        attributes: entity.attributes,
-        x: child.x ?? 0,
-        y: child.y ?? 0,
-        width: child.width ?? entitySizes.get(entity.id)!.width,
-        height: child.height ?? entitySizes.get(entity.id)!.height,
-        headerHeight: entitySizes.get(entity.id)!.headerHeight,
-        rowHeight: ER.rowHeight,
-      })
-    }
-  }
-
-  const relationships: PositionedErRelationship[] = []
-  for (let i = 0; i < (result.edges?.length ?? 0); i++) {
-    const elkEdge = result.edges![i]!
-    const rel = diagram.relationships[i]!
-
-    const points: Point[] = []
-    if (elkEdge.sections && elkEdge.sections.length > 0) {
-      const section = elkEdge.sections[0]!
-      points.push({ x: section.startPoint.x, y: section.startPoint.y })
-      if (section.bendPoints) {
-        for (const bp of section.bendPoints) {
-          points.push({ x: bp.x, y: bp.y })
-        }
-      }
-      points.push({ x: section.endPoint.x, y: section.endPoint.y })
-    }
-
-    relationships.push({
-      entity1: rel.entity1,
-      entity2: rel.entity2,
-      cardinality1: rel.cardinality1,
-      cardinality2: rel.cardinality2,
-      label: rel.label,
-      identifying: rel.identifying,
-      points,
-    })
-  }
-
-  return {
-    width: result.width ?? 600,
-    height: result.height ?? 400,
-    accessibilityTitle: diagram.accessibilityTitle,
-    accessibilityDescription: diagram.accessibilityDescription,
-    entities: positionedEntities,
-    relationships,
-  }
-}
-
-/**
- * Lay out a parsed ER diagram using ELK.js.
- */
-export function layoutErDiagram(
-  diagram: ErDiagram,
-  options: RenderOptions = {}
-): PositionedErDiagram {
-  if (diagram.entities.length === 0) {
-    return { width: 0, height: 0, accessibilityTitle: diagram.accessibilityTitle, accessibilityDescription: diagram.accessibilityDescription, entities: [], relationships: [] }
-  }
-
-  const { elkGraph, entitySizes } = buildErElkGraph(diagram, options)
-  const result = elkLayoutSync(elkGraph)
-  return extractErLayout(result, diagram, entitySizes)
-}