agentic-mermaid 0.1.0 → 0.1.2

package/dist/index-x2Cj1dVv.d.ts

@@ -1,1089 +0,0 @@
-type MermaidConfigScalar = string | number | boolean | null;
-type MermaidConfigValue = MermaidConfigScalar | MermaidConfigValue[] | MermaidConfigMap;
-interface MermaidConfigMap {
-    [key: string]: MermaidConfigValue | undefined;
-}
-interface MermaidFrontmatterMap extends MermaidConfigMap {
-}
-interface MermaidThemeVariables extends MermaidConfigMap {
-    fontFamily?: string;
-}
-interface TimelineRuntimeConfig extends MermaidConfigMap {
-    disableMulticolor?: boolean;
-    sectionFills?: string[];
-    sectionColours?: string[];
-}
-interface JourneyRuntimeConfig extends MermaidConfigMap {
-    diagramMarginX?: number;
-    diagramMarginY?: number;
-    leftMargin?: number;
-    maxLabelWidth?: number;
-    width?: number;
-    height?: number;
-    boxMargin?: number;
-    boxTextMargin?: number;
-    noteMargin?: number;
-    messageMargin?: number;
-    messageAlign?: 'left' | 'center' | 'right';
-    bottomMarginAdj?: number;
-    useMaxWidth?: boolean;
-    rightAngles?: boolean;
-    taskFontSize?: string | number;
-    taskFontFamily?: string;
-    taskMargin?: number;
-    activationWidth?: number;
-    textPlacement?: string;
-    actorColours?: string[];
-    sectionFills?: string[];
-    sectionColours?: string[];
-    titleColor?: string;
-    titleFontFamily?: string;
-    titleFontSize?: string | number;
-}
-interface GanttRuntimeConfig extends MermaidConfigMap {
-    displayMode?: string;
-}
-interface MermaidRuntimeConfig extends MermaidConfigMap {
-    theme?: string;
-    fontFamily?: string;
-    themeVariables?: MermaidThemeVariables;
-    timeline?: TimelineRuntimeConfig;
-    journey?: JourneyRuntimeConfig;
-    xyChart?: MermaidConfigMap;
-    gantt?: GanttRuntimeConfig;
-    useMaxWidth?: boolean;
-    useWidth?: number;
-    themeCSS?: string;
-}
-interface NormalizedMermaidSource {
-    text: string;
-    body: string;
-    lines: string[];
-    firstLine: string;
-    config: MermaidRuntimeConfig;
-    frontmatter: MermaidFrontmatterMap;
-}
-
-interface DiagramColors {
-    /** Background color → CSS variable --bg */
-    bg: string;
-    /** Foreground / primary text color → CSS variable --fg */
-    fg: string;
-    /** Edge/connector color → CSS variable --line */
-    line?: string;
-    /** Arrow heads, highlights, special nodes → CSS variable --accent */
-    accent?: string;
-    /** Secondary text, edge labels → CSS variable --muted */
-    muted?: string;
-    /** Node/box fill tint → CSS variable --surface */
-    surface?: string;
-    /** Node/group stroke color → CSS variable --border */
-    border?: string;
-    /** Optional explicit drop shadows on node shapes. Default: false */
-    shadow?: boolean;
-    /**
-     * Font family for all text. Emitted on the SVG root as `--font`, so the family
-     * stays overridable post-render via inline style. Default: 'Inter'.
-     */
-    font?: string;
-    /**
-     * Whether to embed the Google Fonts `@import` line in the SVG `<style>` block.
-     * Default: `true` (preserves wire compatibility with all existing consumers).
-     *
-     * CLI / PNG paths set `false` explicitly to render offline / CSP-friendly.
-     * The CSS variable `--font` is always emitted on the SVG root regardless,
-     * so the family stays overridable post-render even when the @import is gone.
-     */
-    embedFontImport?: boolean;
-}
-/** Default bg/fg when no colors are provided (zinc light) */
-declare const DEFAULTS: Readonly<{
-    bg: string;
-    fg: string;
-}>;
-declare const THEMES: Record<string, DiagramColors>;
-type ThemeName = keyof typeof THEMES;
-/**
- * Minimal subset of Shiki's ThemeRegistrationResolved that we need.
- * We don't import from shiki to avoid a hard dependency.
- */
-interface ShikiThemeLike {
-    type?: string;
-    colors?: Record<string, string>;
-    tokenColors?: Array<{
-        scope?: string | string[];
-        settings?: {
-            foreground?: string;
-        };
-    }>;
-}
-/**
- * Extract diagram colors from a Shiki theme object.
- * Works with any VS Code / TextMate theme loaded by Shiki.
- *
- * Maps editor UI colors to diagram roles:
- *   editor.background         → bg
- *   editor.foreground         → fg
- *   editorLineNumber.fg       → line (optional)
- *   focusBorder / keyword     → accent (optional)
- *   comment token             → muted (optional)
- *   editor.selectionBackground→ surface (optional)
- *   editorWidget.border       → border (optional)
- *
- * @example
- * ```ts
- * import { getSingletonHighlighter } from 'shiki'
- * import { fromShikiTheme } from 'agentic-mermaid'
- *
- * const hl = await getSingletonHighlighter({ themes: ['tokyo-night'] })
- * const colors = fromShikiTheme(hl.getTheme('tokyo-night'))
- * const svg = renderMermaidSVG(code, colors)
- * ```
- */
-declare function fromShikiTheme(theme: ShikiThemeLike): DiagramColors;
-/**
- * All derived diagram colors resolved to concrete hex values.
- * Mirrors the CSS variable derivation system in buildStyleBlock().
- */
-interface ResolvedColors {
-    bg: string;
-    fg: string;
-    text: string;
-    textSec: string;
-    textMuted: string;
-    textFaint: string;
-    line: string;
-    arrow: string;
-    nodeFill: string;
-    nodeStroke: string;
-    groupFill: string;
-    groupHdr: string;
-    innerStroke: string;
-    keyBadge: string;
-}
-/**
- * Resolve all derived colors from a DiagramColors to concrete hex values.
- * Implements the same logic as the CSS color-mix() derivations in buildStyleBlock().
- */
-declare function resolveColors(colors: DiagramColors): ResolvedColors;
-/**
- * Resolve all CSS var() and color-mix() expressions in an SVG string to
- * concrete hex color values. This makes the SVG render correctly in
- * non-browser renderers (resvg, librsvg, etc.) that don't support CSS
- * custom properties or color-mix().
- *
- * Operates via iterative string replacement:
- *   1. Replace var(--name) with known resolved values
- *   2. Replace var(--name, fallback) — use value if known, else fallback
- *   3. Resolve color-mix(in srgb, #hex P%, #hex) to computed hex
- *   4. Extract CSS variable definitions from <style> and resolve remaining refs
- *   5. Repeat until stable
- *
- * When bg/fg are not hex colors (e.g. CSS variable strings for live theming),
- * the SVG is returned as-is since resolution isn't possible.
- */
-declare function inlineResolvedColors(svg: string, colors: DiagramColors): string;
-
-interface ArchitectureVisualConfig {
-    groupHeaderHeight: number;
-    groupFontSize: number;
-    groupFontWeight: number;
-    groupLetterSpacing: number;
-    groupFont?: string;
-    groupTextTransform?: TextTransform;
-    groupPaddingX: number;
-    groupPaddingY: number;
-    groupLabelPaddingX: number;
-    groupCornerRadius: number;
-    groupLineWidth: number;
-    groupText?: string;
-    serviceFontSize: number;
-    serviceFontWeight: number;
-    serviceLetterSpacing: number;
-    serviceTextTransform?: TextTransform;
-    servicePaddingX: number;
-    servicePaddingY: number;
-    serviceCornerRadius: number;
-    serviceLineWidth: number;
-    serviceText?: string;
-    edgeFontSize: number;
-    edgeFontWeight: number;
-    edgeLetterSpacing: number;
-    edgeTextTransform?: TextTransform;
-    edgeLineWidth: number;
-    edgeBendRadius: number;
-    edgeStroke?: string;
-    edgeText?: string;
-    iconSize: number;
-    serviceIconSize: number;
-    junctionOuterRadius: number;
-    junctionInnerRadius: number;
-    groupSurface?: string;
-    groupHeaderSurface?: string;
-    groupBorder?: string;
-    serviceSurface?: string;
-    serviceBorder?: string;
-}
-
-/** A partial, composable public description of how diagrams look. */
-interface StyleSpec {
-    /** Optional JSON Schema pointer for file-backed styles. Ignored at render time. */
-    $schema?: string;
-    name?: string;
-    blurb?: string;
-    /** Palette — the seven tokens every mark references. A colors-only style
-     *  is a theme. User themeVariables/color options still win over these. */
-    colors?: {
-        bg?: string;
-        fg?: string;
-        line?: string;
-        accent?: string;
-        muted?: string;
-        surface?: string;
-        border?: string;
-    };
-    /** Font family default (threaded through the --font CSS variable). PNG
-     *  export needs the family bundled or resolvable by the rasterizer. */
-    font?: string;
-    /** Stroke rendering: 'crisp' (default), 'jittered' rough.js strokes, or
-     *  'freehand' pressure-ribbon strokes. */
-    stroke?: 'crisp' | 'jittered' | 'freehand';
-    roughness?: number;
-    bowing?: number;
-    /** 1 = single stroke (disableMultiStroke), 2 = sketchy double stroke. */
-    passes?: number;
-    strokeWidth?: number;
-    fill?: 'none' | 'hachure' | 'solid' | 'wash';
-    hachureAngle?: number;
-    hachureGap?: number;
-    fillWeight?: number;
-    /** Wash fill glaze opacity / edge-darkening opacity (fill: 'wash'). */
-    washOpacity?: number;
-    washEdge?: number;
-    /** Flat page furniture drawn right after the document prelude. */
-    backdrop?: 'plain' | 'paper-ruled' | 'grid';
-    /** Expert override only — normally inferred by inferBackend(). */
-    backend?: 'default' | 'rough' | 'hybrid';
-    intent?: 'premium' | 'draft' | 'lofi';
-    /** §3.8 monochrome contract: tone via shading/weight, never extra hues. */
-    mono?: boolean;
-}
-/** What RenderOptions.style accepts: a registered name, an inline spec, or a
- *  stack of either (merged left → right). */
-type StyleInput = string | StyleSpec;
-declare function registerStyle(spec: StyleSpec): void;
-declare function getStyle(name: string): StyleSpec | undefined;
-declare function knownStyles(): string[];
-/** Which backend a style needs, derived from what it asks for — authors
- *  describe the look, the engine picks the machinery. */
-declare function inferBackend(spec: StyleSpec): 'default' | 'rough' | 'hybrid';
-declare function resolveStyleStack(input: StyleInput | StyleInput[] | undefined): StyleSpec | undefined;
-/** Validate an untrusted (e.g. JSON) style record. Returns human-readable
- *  problems; [] means the record is a usable StyleSpec. Declarative-only by
- *  construction — there is no field that can carry markup or URLs. */
-declare function validateStyleSpec(value: unknown): string[];
-
-interface MermaidGraph {
-    direction: Direction;
-    nodes: Map<string, MermaidNode>;
-    edges: MermaidEdge[];
-    subgraphs: MermaidSubgraph[];
-    classDefs: Map<string, Record<string, string>>;
-    /** Maps node IDs to their class names (from `class X className` or `:::className` shorthand) */
-    classAssignments: Map<string, string>;
-    /** Maps node IDs to inline styles (from `style X fill:#f00,stroke:#333`) */
-    nodeStyles: Map<string, Record<string, string>>;
-    /** Maps edge indices (or 'default') to inline styles from `linkStyle` directives */
-    linkStyles: Map<number | 'default', Record<string, string>>;
-}
-type Direction = 'TD' | 'TB' | 'LR' | 'BT' | 'RL';
-interface MermaidNode {
-    id: string;
-    label: string;
-    shape: NodeShape;
-}
-type NodeShape = 'rectangle' | 'service' | 'rounded' | 'diamond' | 'stadium' | 'circle' | 'subroutine' | 'doublecircle' | 'hexagon' | 'cylinder' | 'asymmetric' | 'trapezoid' | 'trapezoid-alt' | 'lean-r' | 'lean-l' | 'state-start' | 'state-end';
-interface MermaidEdge {
-    source: string;
-    target: string;
-    label?: string;
-    style: EdgeStyle;
-    /** Whether to render a marker at the start (source end) of the edge */
-    hasArrowStart: boolean;
-    /** Whether to render a marker at the end (target end) of the edge */
-    hasArrowEnd: boolean;
-    /** Marker shape at start when hasArrowStart=true. Defaults to 'arrow' if undefined. */
-    startMarker?: EdgeMarker;
-    /** Marker shape at end when hasArrowEnd=true. Defaults to 'arrow' if undefined. */
-    endMarker?: EdgeMarker;
-    /** Mermaid link length (rank-distance intent): 1 = base operator, 2 = one
-     *  extra shaft unit (`--->`, `-..->`, `====>`, `~~~~`), etc. Undefined ≡ 1,
-     *  so base-form edges serialize byte-identically. Preserved through
-     *  round-trip; layout honors this conservatively for simple primary-forward
-     *  no-subgraph DAGs and leaves grouped/cyclic cases to ELK. */
-    length?: number;
-}
-/** 'invisible' is Mermaid's `~~~` link: it participates in layout ordering
- *  but draws no stroke. */
-type EdgeStyle = 'solid' | 'dotted' | 'thick' | 'invisible';
-type EdgeMarker = 'arrow' | 'circle' | 'cross';
-interface MermaidSubgraph {
-    id: string;
-    label: string;
-    nodeIds: string[];
-    children: MermaidSubgraph[];
-    /** Optional direction override for this subgraph's internal layout */
-    direction?: Direction;
-}
-interface PositionedDiagram {
-    width: number;
-    height: number;
-}
-interface RenderContext<TPositioned extends PositionedDiagram = PositionedDiagram> {
-    positioned: TPositioned;
-    colors: DiagramColors;
-    options: RenderOptions;
-}
-interface PositionedGraph extends PositionedDiagram {
-    width: number;
-    height: number;
-    nodes: PositionedNode[];
-    edges: PositionedEdge[];
-    groups: PositionedGroup[];
-}
-interface PositionedNode {
-    id: string;
-    label: string;
-    shape: NodeShape;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Inline styles resolved from classDef + explicit `style` statements — override theme defaults */
-    inlineStyle?: Record<string, string>;
-    /** User-assigned Mermaid class names (from `class X myClass` / `:::myClass`). Emitted as SVG CSS classes so external stylesheets can target them. */
-    classNames?: string[];
-}
-interface PositionedEdge {
-    source: string;
-    target: string;
-    label?: string;
-    style: EdgeStyle;
-    hasArrowStart: boolean;
-    hasArrowEnd: boolean;
-    /** Marker shape at start when hasArrowStart=true. Defaults to 'arrow' if undefined. */
-    startMarker?: EdgeMarker;
-    /** Marker shape at end when hasArrowEnd=true. Defaults to 'arrow' if undefined. */
-    endMarker?: EdgeMarker;
-    /** Full path including bends — array of {x, y} points */
-    points: Point[];
-    /** Layout-computed label center position (avoids label-label collisions) */
-    labelPosition?: Point;
-    /** Inline styles resolved from `linkStyle` directives — override theme defaults */
-    inlineStyle?: Record<string, string>;
-    /** Index into MermaidGraph.edges this positioned edge was extracted from */
-    edgeIndex?: number;
-    /** Route contract certificate attached by the layout pipeline (docs/design/system/route-contracts.md) */
-    routeCertificate?: RouteCertificate;
-}
-type RouteClass = 'primary-forward' | 'feedback' | 'self-loop' | 'container' | 'cross-hierarchy';
-type LayoutRouteClass = RouteClass | 'family-layout';
-/** The four canonical connection points of a shape (Visio connection-point /
- *  yFiles port-candidate model). For every Mermaid shape these lie at the
- *  bbox side midpoints: the diamond's vertices, the rectangle's side
- *  midpoints, and the boundary extremes of circles, stadiums, hexagons and
- *  cylinders are the same four points, because each shape is symmetric and
- *  inscribed in its bbox. */
-type PortSide = 'N' | 'E' | 'S' | 'W';
-/** Diamond facet-midpoints: the four points halfway along each slanted edge
- *  (NE/SE/SW/NW). They lie exactly on the diamond outline and serve as
- *  designated attachment points alongside the four cardinal vertices, but are
- *  diamond-only — shapePorts() stays four-cardinal for every shape. */
-type DiamondFacet = 'NE' | 'SE' | 'SW' | 'NW';
-/** A port an endpoint may sit on: a cardinal vertex/side-midpoint, or — on a
- *  diamond — a facet-midpoint. */
-type AnyPort = PortSide | DiamondFacet;
-type PortSemanticRole = 'flow-source' | 'flow-target' | 'feedback-source' | 'feedback-target' | 'self-loop-source' | 'self-loop-target' | 'container-source' | 'container-target' | 'cross-hierarchy-source' | 'cross-hierarchy-target';
-/** Dynamic port allocation metadata: which side an endpoint semantically uses,
- *  its deterministic order among the endpoints on that side, and why it is
- *  there. This extends `sourcePort`/`targetPort` without changing their V1
- *  vocabulary: exact endpoint ports remain `AnyPort`, while the allocation
- *  records side-level slot/role intent for pre-layout and debugging. */
-interface RoutePortAssignment {
-    side: PortSide;
-    /** 0-based deterministic order along the side (N/S: left→right; E/W: top→bottom). */
-    slotIndex: number;
-    /** Number of endpoints allocated to this node side. */
-    slotCount: number;
-    role: PortSemanticRole;
-    /** Exact designated port when the final endpoint landed on one. */
-    port?: AnyPort;
-}
-interface RouteBlocker {
-    kind: 'node' | 'label' | 'channel' | 'span' | 'crossing' | 'port';
-    id: string;
-}
-type RouteInvariant = 'straight' | 'explained-detour' | 'bundle' | 'outer-feedback' | 'feedback-detour' | 'self-loop' | 'container-attach' | 'unverified-shape';
-interface RouteCertificateBase {
-    /** Index into MermaidGraph.edges */
-    edgeIndex: number;
-    routeClass: RouteClass;
-    bendCount: number;
-    directLaneClear?: boolean;
-    directLaneBlockedBy?: RouteBlocker[];
-    /** Set when the endpoint sits exactly on a port: a cardinal side-midpoint
-     *  for every shape, or a diamond facet-midpoint (NE/SE/SW/NW). */
-    sourcePort?: AnyPort;
-    /** Set when the endpoint sits exactly on a port: a cardinal side-midpoint
-     *  for every shape, or a diamond facet-midpoint (NE/SE/SW/NW). */
-    targetPort?: AnyPort;
-    /** Dynamic side/slot/role allocation for the source endpoint. */
-    sourcePortAssignment?: RoutePortAssignment;
-    /** Dynamic side/slot/role allocation for the target endpoint. */
-    targetPortAssignment?: RoutePortAssignment;
-}
-type StraightRouteCertificate = RouteCertificateBase & {
-    invariant: 'straight';
-    /** True when the certifying straightener collapsed this route */
-    straightened?: true;
-};
-type NonStraightRouteCertificate = RouteCertificateBase & {
-    invariant: Exclude<RouteInvariant, 'straight'>;
-    /** Non-straight certificates cannot claim a straightening happened. */
-    straightened?: never;
-};
-type RouteCertificate = StraightRouteCertificate | NonStraightRouteCertificate;
-type FamilyEdgeRouteCertificate = {
-    family: 'class' | 'er';
-    edgeIndex: number;
-    routeClass: 'family-layout';
-    invariant: 'orthogonal-box' | 'unverified-family-route';
-    bendCount: number;
-    orthogonal: boolean;
-    sourceBoundary: boolean;
-    targetBoundary: boolean;
-} | {
-    family: 'architecture';
-    edgeIndex: number;
-    routeClass: 'family-layout';
-    invariant: 'side-anchored' | 'unverified-family-route';
-    bendCount: number;
-    orthogonal: boolean;
-    sourceSide: 'L' | 'R' | 'T' | 'B';
-    targetSide: 'L' | 'R' | 'T' | 'B';
-    sourceBoundary: 'item' | 'group';
-    targetBoundary: 'item' | 'group';
-    sourceAnchored: boolean;
-    targetAnchored: boolean;
-} | {
-    family: 'sequence';
-    edgeIndex: number;
-    routeClass: 'family-layout';
-    invariant: 'lifeline-message' | 'self-message' | 'unverified-family-route';
-    bendCount: number;
-    horizontal: boolean;
-    sourceLifeline: boolean;
-    targetLifeline: boolean;
-    selfMessage: boolean;
-};
-type RegionContainmentCertificate = {
-    family: 'timeline' | 'xychart' | 'pie' | 'quadrant' | 'gantt';
-    elementId: string;
-    routeClass: 'family-layout';
-    invariant: 'timeline-interval' | 'plot-contained' | 'legend-contained' | 'section-contained' | 'unverified-family-layout';
-    /** Node/mark box in layout coordinates; included so cert consumers do not have to join back to nodes. */
-    bounds: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-    /** Center point used by plot/region-mark containment certs. */
-    center: {
-        x: number;
-        y: number;
-    };
-    /** Whether the cert proves the full box or the semantic mark center is contained. */
-    containment: 'bounds' | 'center';
-    withinBounds: boolean;
-    groupId?: string;
-    withinGroup?: boolean;
-};
-type EdgeRouteCertificate = RouteCertificate | FamilyEdgeRouteCertificate;
-type FamilyRouteCertificate = FamilyEdgeRouteCertificate | RegionContainmentCertificate;
-type LayoutRouteCertificate = EdgeRouteCertificate | RegionContainmentCertificate;
-interface Point {
-    x: number;
-    y: number;
-}
-interface PositionedGroup {
-    id: string;
-    label: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    children: PositionedGroup[];
-}
-type TextTransform = 'uppercase' | 'lowercase' | 'capitalize';
-interface RenderOptions {
-    /** Background color → CSS variable --bg. Default: '#FFFFFF' */
-    bg?: string;
-    /** Foreground / primary text color → CSS variable --fg. Default: '#27272A' */
-    fg?: string;
-    /** Edge/connector color → CSS variable --line */
-    line?: string;
-    /** Arrow heads, highlights → CSS variable --accent */
-    accent?: string;
-    /** Secondary text, edge labels → CSS variable --muted */
-    muted?: string;
-    /** Node/box fill tint → CSS variable --surface */
-    surface?: string;
-    /** Node/group stroke color → CSS variable --border */
-    border?: string;
-    /** Font family for all text. Default: 'Inter' */
-    font?: string;
-    /**
-     * How the diagram looks: a registered style name ('hand-drawn', 'tufte',
-     * any THEMES palette name like 'dracula'), an inline StyleSpec, or a STACK
-     * of either merged left-to-right ({ style: ['hand-drawn', 'dracula'] } is
-     * hand-drawn geometry with the dracula palette). A colors-only style is a
-     * palette.
-     * Precedence: defaults < style stack < themeVariables < explicit color
-     * options. Unknown names throw. Unset (or 'crisp') = the default renderer,
-     * byte-identical to previous releases.
-     */
-    style?: StyleInput | StyleInput[];
-    /** Canvas padding in px. Default: 40 */
-    padding?: number;
-    /** Horizontal spacing between sibling nodes. Default: 24 */
-    nodeSpacing?: number;
-    /** Vertical spacing between layers. Default: 40 */
-    layerSpacing?: number;
-    /** Spacing between disconnected components. Default: nodeSpacing (24) */
-    componentSpacing?: number;
-    /** Render with transparent background (no background style on SVG). Default: false */
-    transparent?: boolean;
-    /** Enable hover tooltips on chart data points (xychart only). Default: false */
-    interactive?: boolean;
-    /** Optional explicit drop shadows on node shapes. Default: false */
-    shadow?: boolean;
-    /** Family-specific SVG renderer options for architecture-beta diagrams. */
-    architecture?: {
-        visual?: ArchitectureVisualConfig;
-    };
-    /** Optional Mermaid-style runtime config (analogous to initialize/frontmatter config). */
-    mermaidConfig?: MermaidRuntimeConfig;
-    /**
-     * Whether to embed the Google Fonts `@import` line in the SVG `<style>` block.
-     * Default: `true` (preserves wire compatibility with all existing consumers).
-     *
-     * CLI / PNG paths set `false` explicitly to render offline / CSP-friendly.
-     * The CSS variable `--font` is always emitted on the SVG root regardless,
-     * so the family stays overridable post-render even when the @import is gone.
-     */
-    embedFontImport?: boolean;
-    /**
-     * Compact SVG output. Default `false`. When true:
-     *  - Numeric coords with 3+ fractional digits are rounded (via `roundCoord`).
-     *  - Newlines between SVG elements are collapsed (whitespace inside `<style>`
-     *    is preserved so CSS declarations don't break).
-     *  - `data-*` and `class=` attributes are preserved (agent inspection hooks).
-     *
-     * Typical reduction: 30-40% of bytes on flowchart graphs. Useful for the
-     * PNG render path (no need for human-readable SVG) and for bandwidth-
-     * sensitive consumers.
-     */
-    compact?: boolean;
-    /**
-     * Namespace prefix for all generated SVG def ids (markers, filters) and
-     * their `url(#…)` references. Default '' = current behavior (back-compat,
-     * zero snapshot churn). Set a distinct prefix per diagram when rendering
-     * multiple diagrams onto one HTML page so their `<defs>` don't collide
-     * (e.g. two `arrowhead` markers — the browser dedupes by id and the second
-     * diagram's arrows break). `am batch` auto-assigns per-line prefixes.
-     * Must be deterministic per call site to preserve render determinism.
-     */
-    idPrefix?: string;
-    /**
-     * Security posture for the rendered output. Default `'default'`.
-     * `'strict'` (agent / untrusted-diagram mode): guarantees no external-fetch
-     * references in the SVG — forces `embedFontImport` off (no Google Fonts
-     * `@import`), so the SVG renders with no network calls. The `--font` CSS
-     * variable still declares the family. Use `verifyNoExternalRefs(svg)` to
-     * assert the guarantee. Agent/untrusted SVG callers should opt into strict
-     * mode explicitly. See SECURITY.md.
-     */
-    security?: 'default' | 'strict';
-    /**
-     * Explicit "today" for the Gantt `todayMarker` (a date in the diagram's
-     * `dateFormat`, or ISO `YYYY-MM-DD`). Gantt rendering never reads the wall
-     * clock; without this value the today marker is simply not drawn, and
-     * `todayMarker off` disables it even when a clock is supplied.
-     */
-    ganttToday?: string;
-    /**
-     * Deterministic re-roll seed for stochastic styles.
-     * The same source + options + seed always produces identical bytes; it
-     * re-rolls ink wobble only — layout never moves. The crisp path ignores
-     * it. Default 0.
-     */
-    seed?: number;
-}
-
-/**
- * The internal color waist: every public color dialect is normalized to
- * DiagramColors before layout/render code sees it.
- */
-declare function resolveDiagramColors(options: RenderOptions, config: MermaidRuntimeConfig, font?: string): DiagramColors;
-
-/**
- * Parse Mermaid text into a logical graph structure.
- * Auto-detects diagram type (flowchart or state diagram).
- * Throws on invalid/unsupported input.
- */
-declare function parseMermaid(text: string): MermaidGraph;
-
-/** Configuration for ASCII rendering. */
-interface AsciiConfig {
-    /** true = ASCII chars (+,-,|), false = Unicode box-drawing (┌,─,│). Default: false */
-    useAscii: boolean;
-    /** Horizontal spacing between nodes. Default: 5 */
-    paddingX: number;
-    /** Vertical spacing between nodes. Default: 5 */
-    paddingY: number;
-    /** Padding inside node boxes. Default: 1 */
-    boxBorderPadding: number;
-    /** Graph direction: "LR" or "TD". */
-    graphDirection: 'LR' | 'TD';
-}
-/**
- * Theme colors for ASCII output — hex color strings.
- * Derived from the SVG theme system for visual consistency.
- */
-interface AsciiTheme {
-    /** Text color (node labels, edge labels) */
-    fg: string;
-    /** Box border color (node borders, subgraph borders) */
-    border: string;
-    /** Edge line color (paths between nodes) */
-    line: string;
-    /** Arrowhead color (▲▼◄► or ^v<>) */
-    arrow: string;
-    /** Theme accent color (optional, used by xycharts for series 0) */
-    accent?: string;
-    /** Background color (optional, used by xycharts for dark-mode-aware shading) */
-    bg?: string;
-    /** Corner character color (optional, defaults to line) */
-    corner?: string;
-    /** Junction character color (optional, defaults to border) */
-    junction?: string;
-}
-/** Color mode for output. */
-type ColorMode = 'none' | 'ansi16' | 'ansi256' | 'truecolor' | 'html';
-
-interface AsciiRenderOptions {
-    /** true = ASCII chars (+,-,|,>), false = Unicode box-drawing (┌,─,│,►). Default: false */
-    useAscii?: boolean;
-    /** Horizontal spacing between nodes. Default: 5 */
-    paddingX?: number;
-    /** Vertical spacing between nodes. Default: 5 */
-    paddingY?: number;
-    /** Padding inside node boxes. Default: 1 */
-    boxBorderPadding?: number;
-    /**
-     * Color mode for output.
-     * - 'none': No colors (plain text)
-     * - 'auto': Auto-detect (terminal ANSI capabilities, or HTML in browsers)
-     * - 'ansi16': 16-color ANSI
-     * - 'ansi256': 256-color xterm
-     * - 'truecolor': 24-bit RGB
-     * - 'html': HTML <span> tags with inline color styles (for browser rendering)
-     * Default: 'auto'
-     */
-    colorMode?: ColorMode | 'auto';
-    /** Theme colors for ASCII output. Uses default theme if not provided. */
-    theme?: Partial<AsciiTheme>;
-    /** Optional Mermaid-style runtime config (analogous to initialize/frontmatter config). */
-    mermaidConfig?: MermaidRuntimeConfig;
-    /**
-     * Loop 9 M13: cap output width in characters. When set, node labels wrap
-     * at word boundaries to fit within `maxWidth / 3` per node. Single words
-     * longer than `maxWidth / 2` render anyway (with a console.warn). The
-     * overall canvas may still exceed `maxWidth` if the diagram has many
-     * parallel columns; this is best-effort wrapping, not hard truncation.
-     */
-    maxWidth?: number;
-    /**
-     * Explicit "today" for the Gantt todayMarker (date in the diagram's
-     * dateFormat or ISO YYYY-MM-DD). Gantt never reads the wall clock; without
-     * this the marker is not drawn.
-     */
-    ganttToday?: string;
-}
-/**
- * Render Mermaid diagram text to an ASCII/Unicode string.
- *
- * Synchronous — no async layout engine needed (unlike the SVG renderer).
- * Auto-detects diagram type from the header line and dispatches to
- * the appropriate renderer.
- *
- * @param text - Mermaid source text (any supported diagram type)
- * @param options - Rendering options
- * @returns Multi-line ASCII/Unicode string
- *
- * @example
- * ```ts
- * const result = renderMermaidAscii(`
- *   graph LR
- *     A --> B --> C
- * `, { useAscii: true })
- *
- * // Output:
- * // +---+     +---+     +---+
- * // |   |     |   |     |   |
- * // | A |---->| B |---->| C |
- * // |   |     |   |     |   |
- * // +---+     +---+     +---+
- * ```
- */
-declare function renderMermaidASCII(text: string, options?: AsciiRenderOptions): string;
-/** @deprecated Use `renderMermaidASCII` */
-declare const renderMermaidAscii: typeof renderMermaidASCII;
-
-type ArchitectureSide = 'L' | 'R' | 'T' | 'B';
-type ArchitectureEndpointBoundary = 'item' | 'group';
-interface ArchitectureChildRef {
-    kind: 'group' | 'service' | 'junction';
-    id: string;
-}
-interface ArchitectureGroup {
-    id: string;
-    label: string;
-    icon?: string;
-    parentId?: string;
-    children: ArchitectureChildRef[];
-}
-interface ArchitectureService {
-    id: string;
-    label: string;
-    icon?: string;
-    parentId?: string;
-}
-interface ArchitectureJunction {
-    id: string;
-    parentId?: string;
-}
-interface ArchitectureEndpoint {
-    id: string;
-    side: ArchitectureSide;
-    boundary: ArchitectureEndpointBoundary;
-}
-interface ArchitectureEdge {
-    source: ArchitectureEndpoint;
-    target: ArchitectureEndpoint;
-    label?: string;
-    hasArrowStart: boolean;
-    hasArrowEnd: boolean;
-}
-interface ArchitectureDiagram {
-    groups: ArchitectureGroup[];
-    services: ArchitectureService[];
-    junctions: ArchitectureJunction[];
-    edges: ArchitectureEdge[];
-    rootChildren: ArchitectureChildRef[];
-    accessibilityTitle?: string;
-    accessibilityDescription?: string;
-}
-
-declare function parseArchitectureDiagram(lines: string[]): ArchitectureDiagram;
-declare function architectureToMermaidGraph(diagram: ArchitectureDiagram): MermaidGraph;
-
-/**
- * Measure the pixel width of a text string.
- *
- * Uses character class buckets for more accurate width estimation
- * than uniform character width assumptions.
- *
- * @param text - The text to measure
- * @param fontSize - Font size in pixels
- * @param fontWeight - Font weight (affects width slightly)
- * @returns Estimated width in pixels
- */
-interface TextMeasurementContract {
-    version: 1;
-    unit: 'px';
-    fontCalibration: 'Inter-compatible proportional estimate';
-    wideCodepoints: 'src/shared/unicode-ranges.ts';
-    emojiDetection: 'Emoji_Presentation-or-Extended_Pictographic';
-    ambiguousWidth: 'single-cell';
-}
-declare const TEXT_MEASUREMENT_CONTRACT: TextMeasurementContract;
-interface TextMeasurementInput {
-    text: string;
-    fontSize: number;
-    fontWeight: number;
-}
-interface TextMeasurementResult {
-    contract: TextMeasurementContract;
-    width: number;
-    charWidthUnits: number;
-    codePointCount: number;
-    fontSize: number;
-    fontWeight: number;
-    baseRatio: number;
-    minPadding: number;
-}
-declare function measureText(input: TextMeasurementInput): TextMeasurementResult;
-declare function measureTextWidth(text: string, fontSize: number, fontWeight: number): number;
-
-/** Semantic channels preserved across the renderer boundary (SPEC §5).
- *  `tone`/hue are style-derived outputs, not stored here. */
-interface SemanticChannels {
-    /** Hierarchy / callout weight / star magnitude. */
-    importance?: number;
-    /** Chart value or quantitative measure (normalized where known). */
-    value?: number;
-    /** Chart series, entity type, swimlane, section identity. */
-    category?: string;
-    /** e.g. gantt 'done' | 'active' | 'crit'; state 'start' | 'end'. */
-    status?: string;
-    /** Task completion in [0,1]. */
-    progress?: number;
-    /** Transit route / PCB net identity. */
-    route?: string;
-    /** Author-flagged emphasis. */
-    emphasis?: boolean;
-}
-/** Mark roles. A closed set per family keeps backends role-aware ("don't
- *  hachure a lifeline; do hatch a node") without importing family modules. */
-type SceneRole = 'node' | 'edge' | 'edge-label' | 'group' | 'group-header' | 'label' | 'actor' | 'lifeline' | 'activation' | 'message' | 'block' | 'note' | 'class-box' | 'member' | 'entity' | 'attribute' | 'relationship' | 'cardinality' | 'pie-slice' | 'legend' | 'bar' | 'series' | 'point' | 'axis' | 'grid' | 'plate' | 'section' | 'task' | 'milestone' | 'marker-line' | 'rail' | 'period' | 'event' | 'score' | 'actor-pill' | 'service' | 'junction' | 'icon' | 'title' | 'defs' | 'prelude' | 'chrome';
-/** Geometry a styled backend can redraw. Numbers are in final user units.
- *  Paint strings may be CSS var()/color-mix() refs — they resolve later via
- *  inlineResolvedColors, exactly like the crisp path. */
-type Geometry = {
-    kind: 'rect';
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rx?: number;
-    ry?: number;
-} | {
-    kind: 'circle';
-    cx: number;
-    cy: number;
-    r: number;
-} | {
-    kind: 'ellipse';
-    cx: number;
-    cy: number;
-    rx: number;
-    ry: number;
-} | {
-    kind: 'line';
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-} | {
-    kind: 'polygon';
-    points: Array<{
-        x: number;
-        y: number;
-    }>;
-} | {
-    kind: 'polyline';
-    points: Array<{
-        x: number;
-        y: number;
-    }>;
-} | {
-    kind: 'path';
-    d: string;
-} | {
-    kind: 'compound';
-    children: Geometry[];
-};
-/** The resolved paint attached to a mark — already cascaded (theme tokens,
- *  classDef, inline style, role defaults) by the family lowering. */
-interface MarkPaint {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: string;
-    strokeDasharray?: string;
-    opacity?: string;
-}
-interface SceneNodeBase {
-    /** Stable identifier for seeding and cross-references. Derived from source
-     *  semantics (node id, edge endpoints, slice label...), never list position
-     *  (§8 seed contract). */
-    id: string;
-    role: SceneRole;
-    channels?: SemanticChannels;
-    /** The exact crisp SVG serialization of this mark (possibly multi-line,
-     *  possibly '' for marks that draw nothing, e.g. invisible edges). */
-    crisp: string;
-}
-interface ShapeMark extends SceneNodeBase {
-    kind: 'shape';
-    geometry: Geometry;
-    paint: MarkPaint;
-}
-interface MarkerRef {
-    /** Def id referenced via url(#...) — 'arrowhead', 'cls-inherit', ... */
-    id: string;
-    /** Marker archetype so styled backends can redraw without parsing defs. */
-    shape: 'arrow' | 'open-arrow' | 'circle' | 'cross' | 'triangle' | 'diamond' | 'diamond-open';
-}
-interface ConnectorMark extends SceneNodeBase {
-    kind: 'connector';
-    geometry: {
-        kind: 'polyline';
-        points: Array<{
-            x: number;
-            y: number;
-        }>;
-    } | {
-        kind: 'path';
-        d: string;
-        points?: Array<{
-            x: number;
-            y: number;
-        }>;
-    } | {
-        kind: 'line';
-        x1: number;
-        y1: number;
-        x2: number;
-        y2: number;
-    };
-    lineStyle: 'solid' | 'dotted' | 'dashed' | 'thick' | 'invisible';
-    paint: MarkPaint;
-    startMarker?: MarkerRef;
-    endMarker?: MarkerRef;
-}
-interface TextMark extends SceneNodeBase {
-    kind: 'text';
-    /** Unescaped source text (may contain <br> separators for multiline). */
-    text: string;
-    /** Anchor position the crisp emitter used. */
-    x: number;
-    y: number;
-    fontSize: number;
-    anchor: 'start' | 'middle' | 'end';
-    paint: MarkPaint;
-}
-/** A semantic wrapper (<g ...>...</g>) whose children are scene nodes.
- *  Serialization is reconstructed from open/close/children + per-child indent,
- *  so styled backends can restyle children while keeping wrapper semantics
- *  (classes, data-* attributes, ARIA) byte-compatible. */
-interface GroupMark extends SceneNodeBase {
-    kind: 'group';
-    open: string;
-    close: string;
-    children: Array<{
-        node: SceneNode;
-        indent: number;
-    }>;
-    /** Joiner between open/children/close segments; '\n' everywhere today. */
-    join: string;
-}
-/** Escape hatch for chunks not yet lowered semantically (style blocks,
- *  defs bodies, icon glyph stacks...). Styled backends pass these through or
- *  replace them wholesale via their own prelude/defs policy — they must not
- *  parse them. Aim to shrink raw usage over time. */
-interface RawMark extends SceneNodeBase {
-    kind: 'raw';
-}
-/** Document prelude parameters — everything svgOpenTag/buildStyleBlock were
- *  called with, so a styled backend can re-derive its own document shell
- *  (different palette, fonts, backdrop) without string-parsing the crisp one. */
-interface PreludeMark extends SceneNodeBase {
-    kind: 'prelude';
-    prelude: {
-        width: number;
-        height: number;
-        colors: DiagramColors;
-        transparent: boolean;
-        font: string;
-        hasMonoFont: boolean;
-        /** Family-specific extra CSS appended after the shared style block ('' if none). */
-        extraCss: string;
-    };
-}
-type SceneNode = ShapeMark | ConnectorMark | TextMark | GroupMark | RawMark | PreludeMark;
-/** The lowered document: an ordered flat list of top-level marks. The crisp
- *  serialization is parts.map(crisp).join('\n') — exactly what the string
- *  renderers produced. */
-interface SceneDoc {
-    family: string;
-    width: number;
-    height: number;
-    colors: DiagramColors;
-    parts: SceneNode[];
-}
-
-interface StyleBackendContext {
-    /** User-supplied deterministic re-roll seed (RenderOptions.seed). */
-    seed: number;
-    /** The selected style (undefined on the crisp default path). */
-    style?: StyleSpec;
-}
-interface StyleBackend {
-    id: string;
-    /** Serialize one top-level mark (recursing through groups). */
-    drawNode(node: SceneNode, ctx: StyleBackendContext): string;
-    /** Serialize the whole document. */
-    render(doc: SceneDoc, ctx: StyleBackendContext): string;
-}
-declare const DefaultBackend: StyleBackend;
-declare function registerBackend(backend: StyleBackend): void;
-declare function getBackend(id: string): StyleBackend | undefined;
-
-declare function verifyNoExternalRefs(svg: string): {
-    ok: boolean;
-    refs: string[];
-};
-/**
- * Render Mermaid diagram text to an SVG string — synchronously.
- *
- * Uses elk.bundled.js with a direct FakeWorker bypass (no setTimeout(0) delay).
- * The ELK singleton is created lazily on first use and cached forever.
- *
- * Use this in React components with useMemo() to avoid flash:
- *   const svg = useMemo(() => renderMermaidSVG(code, opts), [code])
- *
- * @param text - Mermaid source text
- * @param options - Rendering options (colors, font, spacing)
- * @returns A self-contained SVG string
- *
- * @example
- * ```ts
- * const svg = renderMermaidSVG('graph TD\n  A --> B')
- *
- * // With theme
- * const svg = renderMermaidSVG('graph TD\n  A --> B', {
- *   bg: '#1a1b26', fg: '#a9b1d6'
- * })
- *
- * // With CSS variables (for live theme switching)
- * const svg = renderMermaidSVG('graph TD\n  A --> B', {
- *   bg: 'var(--background)', fg: 'var(--foreground)', transparent: true
- * })
- * ```
- */
-declare function renderMermaidSVG(text: string, options?: RenderOptions): string;
-/**
- * Render Mermaid diagram text to an SVG string — async.
- *
- * Same result as renderMermaidSVG() but returns a Promise.
- * Useful in async contexts (server handlers, data loaders, etc.)
- */
-declare function renderMermaidSVGAsync(text: string, options?: RenderOptions): Promise<string>;
-/** @deprecated Use `renderMermaidSVG` */
-declare const renderMermaidSync: typeof renderMermaidSVG;
-/** @deprecated Use `renderMermaidSVGAsync` */
-declare const renderMermaid: typeof renderMermaidSVGAsync;
-
-export { type MermaidThemeVariables as $, type AsciiConfig as A, type TextMeasurementInput as B, type ColorMode as C, type Direction as D, type EdgeStyle as E, type FamilyEdgeRouteCertificate as F, type TextMeasurementResult as G, getStyle as H, inferBackend as I, knownStyles as J, measureText as K, type LayoutRouteCertificate as L, type MermaidFrontmatterMap as M, type NodeShape as N, measureTextWidth as O, type PositionedDiagram as P, registerStyle as Q, type RouteClass as R, type SceneDoc as S, TEXT_MEASUREMENT_CONTRACT as T, resolveStyleStack as U, validateStyleSpec as V, verifyNoExternalRefs as W, DEFAULTS as X, DefaultBackend as Y, type JourneyRuntimeConfig as Z, type MermaidRuntimeConfig as _, type MermaidConfigMap as a, type PositionedGraph as a0, type ResolvedColors as a1, type SceneNode as a2, type SceneRole as a3, type SemanticChannels as a4, type StyleBackend as a5, type StyleBackendContext as a6, THEMES as a7, type ThemeName as a8, type TimelineRuntimeConfig as a9, architectureToMermaidGraph as aa, fromShikiTheme as ab, getBackend as ac, inlineResolvedColors as ad, parseArchitectureDiagram as ae, parseMermaid as af, registerBackend as ag, renderMermaid as ah, renderMermaidAscii as ai, renderMermaidSVGAsync as aj, renderMermaidSync as ak, resolveColors as al, resolveDiagramColors as am, type MermaidGraph as b, type EdgeRouteCertificate as c, type RegionContainmentCertificate as d, type MermaidNode as e, type MermaidEdge as f, type NormalizedMermaidSource as g, type RenderOptions as h, type DiagramColors as i, type RenderContext as j, type AsciiTheme as k, type AsciiRenderOptions as l, renderMermaidSVG as m, type StyleInput as n, type AnyPort as o, type DiamondFacet as p, type FamilyRouteCertificate as q, renderMermaidASCII as r, type LayoutRouteClass as s, type PortSemanticRole as t, type PortSide as u, type RouteBlocker as v, type RouteCertificate as w, type RoutePortAssignment as x, type StyleSpec as y, type TextMeasurementContract as z };