@diagrammo/dgmo 0.47.0 → 0.48.1

package/src/raci/types.ts

@@ -1,82 +0,0 @@
-// ============================================================
-// RACI / RASCI / DACI matrix — AST types
-// ============================================================
-//
-// Tasks × roles assignment matrix. Three variants share the same
-// shape; only the marker alphabet and constraint rules differ.
-// See `variants.ts` for variant-specific behavior, `parser.ts` for
-// how AST is built, `mutations.ts` for source-text edits.
-
-import type { DgmoError } from '../diagnostics';
-
-/** Marker alphabet member for any variant. */
-export type RaciMarker = 'R' | 'A' | 'S' | 'C' | 'I' | 'D';
-
-/** Variant identifier — selects alphabet + constraint rule set. */
-export type RaciVariant = 'raci' | 'rasci' | 'daci';
-
-/**
- * One `Role: <markers>` line under a task.
- *
- * `id` is the normalized role key — used by mutations to look up the
- * cell and by validation to detect unknown roles. `displayName` is the
- * first-seen casing/spacing for rendering.
- */
-export interface RaciRoleAssignment {
-  readonly id: string;
-  readonly displayName: string;
-  readonly markers: readonly RaciMarker[];
-  readonly lineNumber: number;
-  readonly endLineNumber: number;
-}
-
-/** One task — flush-left under a phase or directly under the chart. */
-export interface RaciTask {
-  readonly id: string;
-  readonly displayName: string;
-  readonly description: string;
-  readonly roleAssignments: readonly RaciRoleAssignment[];
-  readonly lineNumber: number;
-  readonly endLineNumber: number;
-}
-
-/** Optional `[Phase Label]` group header — one level deep. */
-export interface RaciPhase {
-  readonly id: string;
-  readonly displayName: string;
-  /** Optional palette color from a `[Label](color)` suffix on the bracket. */
-  readonly color?: string;
-  readonly tasks: readonly RaciTask[];
-  readonly lineNumber: number;
-  readonly endLineNumber: number;
-}
-
-/** Top-level parse result. */
-export interface ParsedRaci {
-  readonly type: 'raci';
-  /** Optional title from the chart-type header line. */
-  readonly title?: string;
-  readonly titleLineNumber?: number;
-  /** Variant selected by directive, or by chart-type id when absent. */
-  readonly variant: RaciVariant;
-  /**
-   * Canonical column order. Populated either from an explicit
-   * `roles:` directive or, when absent, from first-seen role usage.
-   */
-  readonly roles: readonly string[];
-  /** Display name for each role (parallel to `roles`). */
-  readonly roleDisplayNames: readonly string[];
-  /**
-   * Optional per-role palette color from the `Cap blue` trailing-token
-   * suffix in the roles block (or the long pipe form `Cap | color: blue`).
-   * Parallel to `roles`; entries default to `undefined` (renderer falls
-   * back to the neutral column tint).
-   */
-  readonly roleColors: ReadonlyArray<string | undefined>;
-  readonly phases: readonly RaciPhase[];
-  /** Tasks declared without a parent phase. */
-  readonly tasksWithoutPhase: readonly RaciTask[];
-  readonly options: Readonly<Record<string, string>>;
-  readonly diagnostics: readonly DgmoError[];
-  readonly error: string | null;
-}

package/src/raci/variants.ts

@@ -1,320 +0,0 @@
-// ============================================================
-// RACI variant rule sets
-// ============================================================
-//
-// Single source of truth for what each variant's marker alphabet is
-// and which structural rules apply. Adding CAIRO/PARIS later means
-// adding another entry here — parser and renderer key off this map.
-
-import { emit } from '../diagnostics';
-import type { DgmoError } from '../diagnostics';
-import { RACI_DX } from './diagnostics';
-import type { RaciMarker, RaciTask, RaciVariant } from './types';
-
-/** Codes for variant-defining structural errors (always fire). */
-export const RACI_ERROR_CODES = {
-  MULTI_ACCOUNTABLE: 'E_RACI_MULTI_ACCOUNTABLE',
-  DACI_MULTI_DRIVER: 'E_DACI_MULTI_DRIVER',
-  DACI_MULTI_ACCOUNTABLE: 'E_DACI_MULTI_ACCOUNTABLE',
-  INVALID_MARKER: 'E_RACI_INVALID_MARKER',
-  UNEXPECTED_LINE: 'E_RACI_UNEXPECTED_LINE',
-  MIXED_VARIANTS: 'E_RACI_MIXED_VARIANTS',
-} as const;
-
-/** Union of every variant's marker alphabet — used for tolerant tokenization. */
-export const ALL_MARKERS: ReadonlySet<RaciMarker> = new Set([
-  'R',
-  'A',
-  'S',
-  'C',
-  'I',
-  'D',
-]);
-
-/**
- * Resolve the chart's variant from the markers actually used. `D`
- * present → DACI; `S` present → RASCI; otherwise RACI. Returns null
- * when both `D` and `S` appear in the same chart (caller should
- * surface `E_RACI_MIXED_VARIANTS`).
- */
-export function inferVariant(
-  markers: Iterable<RaciMarker>
-): RaciVariant | null {
-  let hasD = false;
-  let hasS = false;
-  for (const m of markers) {
-    if (m === 'D') hasD = true;
-    else if (m === 'S') hasS = true;
-  }
-  if (hasD && hasS) return null;
-  if (hasD) return 'daci';
-  if (hasS) return 'rasci';
-  return 'raci';
-}
-
-/** Codes for warnings (suppressible chart-wide by the `no-rule-enforcement` directive). */
-export const RACI_WARNING_CODES = {
-  MISSING_ACCOUNTABLE: 'W_RACI_MISSING_ACCOUNTABLE',
-  MISSING_RESPONSIBLE: 'W_RACI_MISSING_RESPONSIBLE',
-  DACI_MISSING_DRIVER: 'W_DACI_MISSING_DRIVER',
-  DACI_MISSING_ACCOUNTABLE: 'W_DACI_MISSING_ACCOUNTABLE',
-  UNKNOWN_ROLE: 'W_RACI_UNKNOWN_ROLE',
-  EMPTY_TASK: 'W_RACI_EMPTY_TASK',
-  CONFLICTING_MARKERS: 'W_RACI_CONFLICTING_MARKERS',
-  TOO_MANY_RESPONSIBLE: 'W_RACI_TOO_MANY_RESPONSIBLE',
-  ORPHAN_ROLE: 'W_RACI_ORPHAN_ROLE',
-} as const;
-
-/**
- * Threshold for "too many Responsibles" diagnostic. Three is the most
- * commonly cited rule of thumb — beyond that, ownership starts to feel
- * diluted ("if everyone is R, no one is").
- */
-export const TOO_MANY_RESPONSIBLE_THRESHOLD = 3;
-
-/** A constraint rule produces zero or more diagnostics for a single task. */
-export type ConstraintRule = (task: RaciTask) => DgmoError[];
-
-export interface VariantRuleSet {
-  alphabet: ReadonlyArray<RaciMarker>;
-  /**
-   * Structural errors. Fire whenever `no-rule-enforcement` is off, like
-   * the warning rules — kept as a separate bucket so callers (e.g. the
-   * editor diagnostics panel) can style them with error severity.
-   */
-  errorRules: ConstraintRule[];
-  /** Hygiene warnings — same suppression as errors. */
-  warningRules: ConstraintRule[];
-}
-
-// ── Helper: count markers across a task's role assignments ────
-
-function countMarker(task: RaciTask, marker: RaciMarker): number {
-  let count = 0;
-  for (const assignment of task.roleAssignments) {
-    for (const m of assignment.markers) if (m === marker) count++;
-  }
-  return count;
-}
-
-function totalMarkerCount(task: RaciTask): number {
-  let n = 0;
-  for (const a of task.roleAssignments) n += a.markers.length;
-  return n;
-}
-
-function findFirstAssignmentLineWithMarker(
-  task: RaciTask,
-  marker: RaciMarker,
-  skipFirst: boolean
-): number {
-  let seen = 0;
-  for (const assignment of task.roleAssignments) {
-    if (assignment.markers.includes(marker)) {
-      seen++;
-      if (skipFirst && seen === 1) continue;
-      return assignment.lineNumber;
-    }
-  }
-  return task.lineNumber;
-}
-
-// ── Rules ─────────────────────────────────────────────────────
-
-const multiAccountableRule: ConstraintRule = (task) => {
-  if (countMarker(task, 'A') > 1) {
-    return [
-      emit(
-        RACI_DX.MULTI_ACCOUNTABLE,
-        findFirstAssignmentLineWithMarker(task, 'A', true),
-        {
-          task: task.displayName,
-        }
-      ),
-    ];
-  }
-  return [];
-};
-
-const daciMultiDriverRule: ConstraintRule = (task) => {
-  if (countMarker(task, 'D') > 1) {
-    return [
-      emit(
-        RACI_DX.DACI_MULTI_DRIVER,
-        findFirstAssignmentLineWithMarker(task, 'D', true),
-        {
-          task: task.displayName,
-        }
-      ),
-    ];
-  }
-  return [];
-};
-
-const daciMultiAccountableRule: ConstraintRule = (task) => {
-  if (countMarker(task, 'A') > 1) {
-    return [
-      emit(
-        RACI_DX.DACI_MULTI_ACCOUNTABLE,
-        findFirstAssignmentLineWithMarker(task, 'A', true),
-        {
-          task: task.displayName,
-        }
-      ),
-    ];
-  }
-  return [];
-};
-
-/**
- * Single warning for tasks that have zero markers anywhere — replaces
- * the duplicate missing-A and missing-R warnings that would otherwise
- * fire for the same line.
- */
-const emptyTaskRule: ConstraintRule = (task) => {
-  if (totalMarkerCount(task) === 0) {
-    return [
-      emit(RACI_DX.EMPTY_TASK, task.lineNumber, { task: task.displayName }),
-    ];
-  }
-  return [];
-};
-
-const missingAccountableRule: ConstraintRule = (task) => {
-  if (totalMarkerCount(task) === 0) return []; // emptyTaskRule covers it
-  if (countMarker(task, 'A') === 0) {
-    return [
-      emit(RACI_DX.MISSING_ACCOUNTABLE, task.lineNumber, {
-        task: task.displayName,
-      }),
-    ];
-  }
-  return [];
-};
-
-const missingResponsibleRule: ConstraintRule = (task) => {
-  if (totalMarkerCount(task) === 0) return []; // emptyTaskRule covers it
-  if (countMarker(task, 'R') === 0) {
-    return [
-      emit(RACI_DX.MISSING_RESPONSIBLE, task.lineNumber, {
-        task: task.displayName,
-      }),
-    ];
-  }
-  return [];
-};
-
-const daciMissingDriverRule: ConstraintRule = (task) => {
-  if (totalMarkerCount(task) === 0) return []; // emptyTaskRule covers it
-  if (countMarker(task, 'D') === 0) {
-    return [
-      emit(RACI_DX.DACI_MISSING_DRIVER, task.lineNumber, {
-        task: task.displayName,
-      }),
-    ];
-  }
-  return [];
-};
-
-const daciMissingAccountableRule: ConstraintRule = (task) => {
-  if (totalMarkerCount(task) === 0) return []; // emptyTaskRule covers it
-  if (countMarker(task, 'A') === 0) {
-    return [
-      emit(RACI_DX.DACI_MISSING_ACCOUNTABLE, task.lineNumber, {
-        task: task.displayName,
-      }),
-    ];
-  }
-  return [];
-};
-
-/**
- * Flag a single role assigned both an "active" marker (R/A/D — actually
- * doing or owning the work) and a "passive" marker (C/I — only consulted
- * or informed). The combo is internally inconsistent: you're either part
- * of the action or you're a stakeholder, not both.
- *
- * Note: A+R / D+A on the same role is *not* flagged — every major guide
- * (Atlassian, PMI, Smartsheet) explicitly allows the same person being
- * both Accountable and Responsible (or Driver and Approver).
- */
-const ACTIVE_MARKERS: ReadonlySet<RaciMarker> = new Set(['R', 'A', 'D']);
-const PASSIVE_MARKERS: ReadonlySet<RaciMarker> = new Set(['C', 'I']);
-
-const conflictingMarkersRule: ConstraintRule = (task) => {
-  const out: DgmoError[] = [];
-  for (const a of task.roleAssignments) {
-    let hasActive = false;
-    let hasPassive = false;
-    for (const m of a.markers) {
-      if (ACTIVE_MARKERS.has(m)) hasActive = true;
-      if (PASSIVE_MARKERS.has(m)) hasPassive = true;
-    }
-    if (hasActive && hasPassive) {
-      out.push(
-        emit(RACI_DX.CONFLICTING_MARKERS, a.lineNumber, {
-          role: a.displayName,
-          task: task.displayName,
-          markers: a.markers.join(' '),
-        })
-      );
-    }
-  }
-  return out;
-};
-
-/**
- * "If everyone is R, no one is R" — beyond ~3 Responsibles per task,
- * ownership feels diluted. Threshold matches the most common rule of
- * thumb across PM literature.
- */
-const tooManyResponsibleRule: ConstraintRule = (task) => {
-  const n = countMarker(task, 'R');
-  if (n > TOO_MANY_RESPONSIBLE_THRESHOLD) {
-    return [
-      emit(RACI_DX.TOO_MANY_RESPONSIBLE, task.lineNumber, {
-        task: task.displayName,
-        count: n,
-        threshold: TOO_MANY_RESPONSIBLE_THRESHOLD,
-      }),
-    ];
-  }
-  return [];
-};
-
-// ── Variant table ─────────────────────────────────────────────
-
-export const VARIANTS: Readonly<Record<RaciVariant, VariantRuleSet>> = {
-  raci: {
-    alphabet: ['R', 'A', 'C', 'I'],
-    errorRules: [multiAccountableRule],
-    warningRules: [
-      emptyTaskRule,
-      missingAccountableRule,
-      missingResponsibleRule,
-      conflictingMarkersRule,
-      tooManyResponsibleRule,
-    ],
-  },
-  rasci: {
-    alphabet: ['R', 'A', 'S', 'C', 'I'],
-    errorRules: [multiAccountableRule],
-    warningRules: [
-      emptyTaskRule,
-      missingAccountableRule,
-      missingResponsibleRule,
-      conflictingMarkersRule,
-      tooManyResponsibleRule,
-    ],
-  },
-  daci: {
-    alphabet: ['D', 'A', 'C', 'I'],
-    errorRules: [daciMultiDriverRule, daciMultiAccountableRule],
-    warningRules: [
-      emptyTaskRule,
-      daciMissingDriverRule,
-      daciMissingAccountableRule,
-      conflictingMarkersRule,
-    ],
-  },
-};

package/src/render.ts

@@ -1,268 +0,0 @@
-import { renderForExport, resolveArcChordOverride } from './d3';
-import { renderDataChartD3 } from './charts-d3';
-import { injectHoverStyles } from './utils/hover-styles';
-import { getRenderCategory, parseDgmo } from './dgmo-router';
-import type { DgmoError } from './diagnostics';
-import { getPalette } from './palettes/registry';
-import type { CompactViewState } from './sharing';
-
-// DOM globals installed for Node-side D3 rendering, scoped with ref-counting.
-//
-// These need to exist on `globalThis` while a D3 renderer runs (it reaches for
-// `document`). The naive approach — install them once and leave them — leaks a
-// jsdom `window` into the host Node process forever. That breaks hosts that run
-// their OWN SSR/SSG in the same process after calling render(): notably
-// Docusaurus static export, whose theme then believes it is in a browser
-// (`canUseDOM` true) and crashes on bare globals this shim does NOT define
-// (`requestAnimationFrame`, `MutationObserver`) or on opaque-origin
-// `localStorage`. So we install on the first concurrent render and tear down
-// once the last one finishes, leaving the host a clean Node environment.
-const DOM_GLOBALS = [
-  'document',
-  'window',
-  'navigator',
-  'HTMLElement',
-  'SVGElement',
-] as const;
-// The ref-count state lives on `globalThis` under a well-known symbol rather
-// than in module state: dist/index and dist/block are each self-contained
-// bundles, so a host importing both gets two copies of this module. With
-// per-copy state, each copy keeps its own ref-count over the SAME
-// `globalThis.document` — one copy's release tears down globals mid-render of
-// the other. `Symbol.for` puts every copy on one shared count.
-interface DomGlobalsState {
-  refCount: number;
-  installPromise: Promise<void> | null;
-  installedByUs: boolean;
-}
-const DOM_STATE_KEY = Symbol.for('diagrammo.dgmo.dom-globals');
-
-function domState(): DomGlobalsState {
-  const g = globalThis as { [DOM_STATE_KEY]?: DomGlobalsState };
-  return (g[DOM_STATE_KEY] ??= {
-    refCount: 0,
-    installPromise: null,
-    installedByUs: false,
-  });
-}
-
-async function installDom(state: DomGlobalsState): Promise<void> {
-  const { JSDOM } = await loadJsdom();
-  // Concrete URL → non-opaque origin, so host code that touches
-  // window.localStorage during a same-process render doesn't throw.
-  const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
-    url: 'http://localhost/',
-  });
-  const win = dom.window;
-  const values: Record<(typeof DOM_GLOBALS)[number], unknown> = {
-    document: win.document,
-    window: win,
-    navigator: win.navigator,
-    HTMLElement: win.HTMLElement,
-    SVGElement: win.SVGElement,
-  };
-  for (const key of DOM_GLOBALS) {
-    Object.defineProperty(globalThis, key, {
-      value: values[key],
-      configurable: true,
-    });
-  }
-  state.installedByUs = true;
-}
-
-/**
- * Make DOM globals available for the duration of a render. No-ops in a real
- * browser or any host that already provides `document` (we never touch globals
- * we did not install). Pair every successful call with `releaseDom()`.
- */
-async function acquireDom(): Promise<void> {
-  const state = domState();
-  if (typeof document !== 'undefined' && !state.installedByUs) return;
-  state.refCount++;
-  if (!state.installPromise) state.installPromise = installDom(state);
-  await state.installPromise;
-}
-
-/** Tear down the jsdom globals once no render is in flight. */
-function releaseDom(): void {
-  const state = domState();
-  if (!state.installedByUs) return;
-  if (--state.refCount > 0) return;
-  for (const key of DOM_GLOBALS) {
-    delete (globalThis as Record<string, unknown>)[key];
-  }
-  state.installedByUs = false;
-  state.installPromise = null;
-  state.refCount = 0;
-}
-
-/**
- * Load jsdom server-side. The specifier is constructed at runtime so
- * downstream bundlers (Vite, Rollup, esbuild, webpack) cannot statically
- * resolve it. Without this indirection, every browser bundle of
- * @diagrammo/dgmo emits a 5+ MB jsdom chunk even though `acquireDom()`
- * guards execution with a `typeof document` check — the guard prevents
- * runtime evaluation, but the static dependency edge still pulls jsdom
- * into the bundle.
- */
-async function loadJsdom(): Promise<typeof import('jsdom')> {
-  const spec = ['js', 'dom'].join('');
-  return import(/* @vite-ignore */ /* webpackIgnore: true */ spec) as Promise<
-    typeof import('jsdom')
-  >;
-}
-
-/**
- * Render DGMO source to an SVG string.
- *
- * Automatically detects the chart type, selects the appropriate renderer,
- * and returns a complete SVG document string.
- *
- * @param content - DGMO source text
- * @param options - Optional theme and palette settings
- * @returns Object with `svg` (SVG string, empty on error) and `diagnostics` (parse errors/warnings)
- *
- * @example
- * ```ts
- * import { render } from '@diagrammo/dgmo';
- *
- * const { svg, diagnostics } = await render(`pie Languages
- * TypeScript: 45
- * Python: 30
- * Rust: 25`);
- * ```
- */
-export async function render(
-  content: string,
-  options?: {
-    theme?: 'light' | 'dark' | 'transparent';
-    palette?: string;
-    c4Level?: 'context' | 'containers' | 'components' | 'deployment';
-    c4System?: string;
-    c4Container?: string;
-    tagGroup?: string;
-    /** Legend state for export — controls which tag group is shown in exported SVG. */
-    legendState?: { activeGroup?: string; hiddenAttributes?: string[] };
-    /** View state for export — controls interactive state (collapse, swimlanes, etc.) */
-    viewState?: CompactViewState;
-    /** Bundled map data for `map` charts in the browser, where the Node fs
-     *  `loadMapData()` seam can't run. CLI/SSR omit this and fall back to fs. */
-    mapData?: import('./map/resolved-types').MapData;
-    /** Bake pure-CSS hover into the exported SVG (no JS). Default ON — embeds
-     *  (Obsidian, doc-site wrappers) get hover feedback for free. The desktop
-     *  app renders its live preview through direct renderer calls (not this
-     *  entry), so it keeps its JS emphasis; pass `false` to opt out. */
-    bakeHover?: boolean;
-  }
-): Promise<{ svg: string; diagnostics: DgmoError[] }> {
-  const theme = options?.theme ?? 'light';
-  const paletteName = options?.palette ?? 'slate';
-  const bakeHover = options?.bakeHover ?? true;
-
-  const paletteColors =
-    getPalette(paletteName)[theme === 'dark' ? 'dark' : 'light'];
-
-  const parsed = parseDgmo(content);
-  let diagnostics = parsed.diagnostics;
-  // Arc↔chord `layout` override (#26): re-emit canonical content for the other
-  // engine so each renders its own grammar. Applied here (before the category
-  // branch) so it covers BOTH the data-chart shortcut and the unified path.
-  const acOverride = resolveArcChordOverride(
-    content,
-    parsed.chartType,
-    paletteColors
-  );
-  const renderContent = acOverride?.content ?? content;
-  const chartType = acOverride?.type ?? parsed.chartType;
-  // The arc `layout chord` override (#26/#29) re-emits canonical `chord …`
-  // content for the internal circular renderer. `chord` is no longer a registry
-  // type, so getRenderCategory returns null for it — force the data-chart branch
-  // when the override applied, otherwise the re-emitted content is re-detected as
-  // a sequence diagram (arrow-shaped edges) and renders wrong.
-  const category = acOverride
-    ? 'data-chart'
-    : chartType
-      ? getRenderCategory(chartType)
-      : null;
-
-  // Build viewState from legendState (backwards compat) or use provided viewState
-  const viewState: CompactViewState | undefined =
-    options?.viewState ??
-    (options?.legendState
-      ? {
-          ...(options.legendState.activeGroup !== undefined && {
-            tag: options.legendState.activeGroup,
-          }),
-          ...(options.legendState.hiddenAttributes !== undefined && {
-            ha: options.legendState.hiddenAttributes,
-          }),
-        }
-      : undefined);
-
-  if (category === 'data-chart') {
-    // All data-chart types render through the hand-built D3 engine (no ECharts).
-    await acquireDom();
-    try {
-      const raw = await renderDataChartD3(renderContent, theme, paletteColors);
-      // Bake pure-CSS hover while jsdom is still installed (the injector scans
-      // the SVG DOM for group values). No-op unless `chartType` has a registry
-      // row and `bakeHover` is on.
-      const svg = injectHoverStyles(raw, chartType, { bakeHover });
-      return { svg, diagnostics };
-    } finally {
-      releaseDom();
-    }
-  }
-
-  // Visualization/diagram and unknown/null types all go through the unified renderer
-  await acquireDom();
-  let svg: string;
-  try {
-    svg = await renderForExport(
-      renderContent,
-      theme,
-      paletteColors,
-      viewState,
-      {
-        ...(options?.c4Level !== undefined && { c4Level: options.c4Level }),
-        ...(options?.c4System !== undefined && { c4System: options.c4System }),
-        ...(options?.c4Container !== undefined && {
-          c4Container: options.c4Container,
-        }),
-        ...(options?.tagGroup !== undefined && { tagGroup: options.tagGroup }),
-        ...(options?.mapData !== undefined && { mapData: options.mapData }),
-      }
-    );
-    // Bake pure-CSS hover while jsdom is still installed (no-op unless the
-    // detected `chartType` has a registry row and `bakeHover` is on).
-    svg = injectHoverStyles(svg, chartType, { bakeHover });
-  } finally {
-    releaseDom();
-  }
-
-  // The map pipeline resolves names AFTER parsing (gazetteer/ISO lookup), so its
-  // unknown-place / unknown-subdivision errors live on the ResolvedMap, not the
-  // ParsedMap. Surface them through render() so the editor shows squiggles.
-  // resolveMap seeds its diagnostics with the parser's, so this is a superset.
-  // loadMapData is memoized (renderForExport already loaded it) — no double read.
-  if (chartType === 'map') {
-    try {
-      const [{ parseMap }, { resolveMap }, { loadMapData }] = await Promise.all(
-        [
-          import('./map/parser'),
-          import('./map/resolver'),
-          import('./map/load-data'),
-        ]
-      );
-      // Prefer injected data (browser); fall back to the fs loader (CLI/SSR).
-      const data = options?.mapData ?? (await loadMapData());
-      // resolveMap seeds its diagnostics with the parser's, so this is a superset.
-      // (The layout stage has no diagnostics producer, so there is nothing to merge.)
-      diagnostics = [...resolveMap(parseMap(content), data).diagnostics];
-    } catch {
-      /* asset load failed — keep the parser diagnostics */
-    }
-  }
-
-  return { svg, diagnostics };
-}