@pixerate/editor 0.55.0 → 0.56.0

package/dist/diagram/index.d.cts

@@ -1,5 +1,5 @@
-import { M as MetaCarrier, a as MermaidDocument, E as EditOp, D as DiagramFamily, b as DiagramAdapter, S as SupportTier, P as Preamble, c as DiagramMeta, d as EdgePattern, A as ArrowHead, G as GraphEdge, e as Point, f as DiagramGraph } from '../types-BULrFyuQ.cjs';
-export { g as AdapterParseContext, h as DIRECTIONS, i as Diagnostic, j as Direction, k as GraphGroup, l as GraphNode } from '../types-BULrFyuQ.cjs';
+import { f as MetaCarrier, M as MermaidDocument, e as EditOp, D as DiagramFamily, g as DiagramAdapter, S as SupportTier, h as Preamble, b as DiagramMeta, E as EdgePattern, A as ArrowHead, d as GraphEdge, i as AdapterParseContext, a as DiagramGraph, j as Diagnostic, G as GraphNode, P as Point, c as GraphGroup } from '../types-DYkjhzdz.cjs';
+export { k as DIRECTIONS, l as Direction } from '../types-DYkjhzdz.cjs';
 import { H as HistoryManager } from '../HistoryManager-DeQQMBCj.cjs';
 import { A as AgentToolProvider } from '../registry-DIpIaCkH.cjs';
 import { g as PresenceStore, e as PresenceClock, d as PresenceActorInfo } from '../presence-Cb6WhcrQ.cjs';
@@ -33,7 +33,7 @@ declare function applyEdits(doc: MermaidDocument, ops: EditOp[]): MermaidDocumen
 /** Registers (or replaces) the adapter for a family. */
 declare function registerDiagramAdapter(adapter: DiagramAdapter<unknown>): void;
 declare function getDiagramAdapter(family: DiagramFamily): DiagramAdapter<unknown>;
-/** `editable` for flowchart, state, class and ER diagrams; `render-only` otherwise. */
+/** `editable` for every family with an adapter; `render-only` for sankey, block, packet, kanban, treemap and the rest. */
 declare function supportTierOf(family: DiagramFamily): SupportTier;
 
 interface SplitSource {
@@ -470,6 +470,1712 @@ declare const ER_PATTERNS: {
     title: string;
 }[];
 
+/**
+ * Shared scaffolding for statement-based adapters whose semantics do not fit
+ * the flowchart-like line-grammar engine (sequence, gantt, pie, mindmap,
+ * timeline, journey, gitGraph, architecture, quadrant…).
+ *
+ * A grammar turns body lines into typed statements that always keep their
+ * `raw` text. Serialisation emits `raw` for untouched statements and
+ * `format(stmt)` for dirty ones, so untouched documents round-trip
+ * byte-for-byte. Edits mutate a shallow copy of the statement list, then the
+ * document is serialised and re-parsed so `graph` always matches `source`.
+ *
+ * The base handles metadata ops (`moveNodes`, `resizeNode`, `setViewport`,
+ * `setMetaExt`), `replaceSource` and a frontmatter fallback for `setTitle`;
+ * everything else is delegated to `grammar.edit`.
+ *
+ * @module
+ */
+/** Minimum shape of a statement: raw text plus a dirty flag. */
+interface BaseStatement {
+    raw: string;
+    indent: string;
+    /** When true, {@link StatementGrammar.format} regenerates the text. */
+    dirty?: boolean;
+}
+interface StatementBody<S extends BaseStatement> {
+    statements: S[];
+}
+type StatementDocument<S extends BaseStatement> = MermaidDocument<StatementBody<S>>;
+interface GraphBuildContext {
+    header: string;
+    /** `title` from the frontmatter, if any. */
+    frontmatterTitle?: string;
+    meta: AdapterParseContext["meta"];
+}
+interface EditContext<S extends BaseStatement> {
+    /** The document the edit is applied to (read-only; `statements` is the working copy). */
+    doc: StatementDocument<S>;
+    /** Mutable working copy of the statement list. */
+    statements: S[];
+    /** Mutable copy of the metadata (layout/sizes already cloned). */
+    meta: AdapterParseContext["meta"];
+    /** Indentation unit detected in the document (or the grammar default). */
+    indent: string;
+    /** Replaces the header line (families that encode settings in it). */
+    setHeader(header: string): void;
+    /** Replaces the preamble lines (frontmatter edits). */
+    setPreambleLines(lines: string[]): void;
+}
+interface StatementGrammar<S extends BaseStatement> {
+    family: DiagramFamily;
+    /** Groups physical lines into logical statements (default: one per line). */
+    joinLines?(lines: string[]): string[];
+    parseLine(line: string, index: number, all: string[]): S;
+    /** Regenerates the text of a dirty statement (may return several lines joined by `\n`). */
+    format(stmt: S): string;
+    buildGraph(statements: S[], ctx: GraphBuildContext): {
+        graph: DiagramGraph;
+        diagnostics?: Diagnostic[];
+    };
+    /**
+     * Applies a structural edit by mutating `ctx.statements` (and/or header,
+     * preamble, meta). Return `false` for ops the family does not support; the
+     * document is then returned unchanged.
+     */
+    edit(op: EditOp, ctx: EditContext<S>): boolean;
+    /**
+     * Optional hook for families whose positions are data rather than layout
+     * metadata (quadrant points: moving a point rewrites its coordinates). Called
+     * before the base's own handling of `moveNodes`, `resizeNode`, `setViewport`
+     * and `setMetaExt`; return `true` when the op was handled (the document is
+     * then serialised and re-parsed), `false` to fall back to the default.
+     */
+    interceptMeta?(op: EditOp, ctx: EditContext<S>): boolean;
+    /** Indentation unit used when the document has none. */
+    defaultIndent?: string;
+    /**
+     * Whether `setTitle` is handled by `edit` (a `title` statement) rather than
+     * by the frontmatter fallback. Default false.
+     */
+    titleAsStatement?: boolean;
+}
+declare function parseStatementDocument<S extends BaseStatement>(grammar: StatementGrammar<S>, source: string, ctx: AdapterParseContext): StatementDocument<S>;
+declare function serializeStatementDocument<S extends BaseStatement>(grammar: StatementGrammar<S>, doc: StatementDocument<S>): string;
+declare function applyStatementEdit<S extends BaseStatement>(grammar: StatementGrammar<S>, doc: StatementDocument<S>, op: EditOp): StatementDocument<S>;
+/** Creates a full adapter from a statement grammar. */
+declare function createStatementAdapter<S extends BaseStatement>(grammar: StatementGrammar<S>): DiagramAdapter<StatementBody<S>>;
+/** Leading whitespace of a line. */
+declare function indentOf(line: string): string;
+/** Lower-case, `_`-joined identifier derived from free text; `fallback` when empty. */
+declare function slugId(text: string, fallback?: string): string;
+/** Returns `base`, or `base_2`, `base_3`… until unused in `taken` (which is updated). */
+declare function uniqueId(base: string, taken: Set<string>): string;
+/** Removes the elements for which `keep` is false, in place. */
+declare function filterInPlace<T>(arr: T[], keep: (item: T, index: number) => boolean): void;
+/** Moves metadata (layout, size) from one id to another, e.g. after a rename. */
+declare function renameMetaKey(meta: AdapterParseContext["meta"], from: string, to: string): void;
+/** Removes metadata for ids that no longer exist. */
+declare function dropMetaKeys(meta: AdapterParseContext["meta"], ids: Iterable<string>): void;
+/** Wraps text in double quotes, escaping inner quotes Mermaid-style. */
+declare function quote(text: string): string;
+/** Strips one layer of matching double quotes. */
+declare function unquote(text: string): string;
+/** Splits on a separator outside quotes/brackets. */
+declare function splitOutsideQuotes(text: string, sep: string): string[];
+
+interface ShapeOption {
+    value: string;
+    label: string;
+    category?: string;
+}
+interface EdgeKindOption {
+    value: string;
+    label: string;
+    arrowStart: ArrowHead;
+    arrowEnd: ArrowHead;
+    pattern: EdgePattern;
+}
+/**
+ * A data field the inspector edits generically. `node` fields are written with
+ * `setNodeData`, `edge` fields with `setEdgeData`, `diagram` fields with
+ * `setGraphData`; the adapter decides how each key is serialised.
+ */
+interface FieldSpec {
+    key: string;
+    label: string;
+    /** `numbers`: a comma-separated list of numbers (chart values). */
+    type: "text" | "number" | "numbers" | "lines" | "select" | "boolean" | "tags";
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    placeholder?: string;
+    hint?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Offer the field only on nodes of these shapes (e.g. an image's picture on `image` nodes). */
+    shapes?: string[];
+}
+interface FamilyUI {
+    family: DiagramFamily;
+    title: string;
+    shapes: ShapeOption[];
+    edgeKinds: EdgeKindOption[];
+    patterns: {
+        value: EdgePattern;
+        label: string;
+    }[];
+    arrowHeads: {
+        value: ArrowHead;
+        label: string;
+    }[];
+    groups: {
+        supported: boolean;
+        label: string;
+    };
+    /** Whether nodes carry an explicit label distinct from their id. */
+    labels: boolean;
+    nodeNoun: string;
+    /** Suggests an id for a new node. */
+    nextId(graph: DiagramGraph): string;
+    /** Whether a node in this family may be moved out of its group. */
+    canDetach: boolean;
+    /** Node data fields the inspector offers (written with `setNodeData`). */
+    nodeFields?: FieldSpec[];
+    /** Edge data fields (written with `setEdgeData`). */
+    edgeFields?: FieldSpec[];
+    /** Diagram-level fields (written with `setGraphData`). */
+    diagramFields?: FieldSpec[];
+    /** Show classes / inline style / link / classDef controls (default true). */
+    styling?: boolean;
+    /** Whether dragging a handle to another node creates an edge (default true). */
+    connectable?: boolean;
+    /** Trees: "Add" attaches the new node under the selected node. */
+    hierarchy?: boolean;
+    /** Offer the direction selector (default true). */
+    directions?: boolean;
+    /** Offer a per-group direction in the inspector (default true; git graphs have one direction). */
+    groupDirections?: boolean;
+    /** Offer "Arrange" (dagre). False when positions derive from the data (default true). */
+    arrange?: boolean;
+    /**
+     * Show Mermaid's own rendering next to the canvas by default. Every built-in
+     * family draws its Mermaid picture on the canvas itself, so this is off.
+     */
+    preview?: boolean;
+    /**
+     * Whether the family is drawn on the canvas (default true). Every built-in
+     * family is: flowchart, state, class and ER as nodes and edges, the rest as
+     * their own picture (`mermaidToScene` in `@pixerate/editor/canvas`). A host
+     * family without a drawing can set it false and show Mermaid's rendering.
+     */
+    canvas?: boolean;
+    /** Offer From / To selects for edges in the inspector (`reconnectEdge`). */
+    endpoints?: boolean;
+    /** Noun for edges in the UI ("Message", "Dependency"…). Default "Edge". */
+    edgeNoun?: string;
+    /** Default payload for a node created from the toolbar. */
+    newNode?(graph: DiagramGraph, parentId?: string): Partial<GraphNode>;
+}
+
+declare const pieUI: FamilyUI;
+
+/**
+ * Mind map vocabulary. Topics form a tree: "Add" attaches the new topic under
+ * the selected one (`hierarchy`), and dragging a topic onto another topic
+ * moves it (with its subtree) under that topic. The canvas draws Mermaid's own
+ * picture (`canvases/mindmap.tsx`) with positions derived from the tree, so
+ * there is no "Arrange", direction or connection handle. Branches cannot be
+ * deleted on their own; delete the child topic instead.
+ */
+declare const mindmapUI: FamilyUI;
+
+/**
+ * Quadrant chart vocabulary. The canvas draws Mermaid's chart; points sit
+ * where their coordinates put them (dragging one rewrites its `[x, y]`, and
+ * its quadrant follows), the four quadrants are fixed (renamable on the
+ * canvas, not movable) and there are no edges.
+ */
+declare const quadrantUI: FamilyUI;
+
+/** Toolbar / inspector vocabulary for C4 diagrams (all five C4 types). */
+declare const c4UI: FamilyUI;
+
+/** Toolbar / inspector vocabulary for `architecture-beta` diagrams. */
+declare const architectureUI: FamilyUI;
+
+/** Toolbar / inspector vocabulary for `sequenceDiagram`. */
+declare const sequenceUI: FamilyUI;
+
+/**
+ * Toolbar / inspector vocabulary for `gitGraph`. Branches are groups: "Group"
+ * starts a new branch at the end of the history (selected commits are not
+ * moved), and connecting two branch tips appends a `merge`. The canvas draws
+ * Mermaid's own picture (`canvases/gitgraph.tsx`): positions follow the commit
+ * order, so there is no "Arrange"; the direction is the header's `LR`/`TB`/`BT`.
+ */
+declare const gitGraphUI: FamilyUI;
+
+declare const ganttUI: FamilyUI;
+
+declare const timelineUI: FamilyUI;
+
+declare const journeyUI: FamilyUI;
+
+declare const xyChartUI: FamilyUI;
+
+declare const radarUI: FamilyUI;
+
+/** A field as agents and hosts see it: what can be written and how. */
+interface FieldDescription {
+    key: string;
+    label: string;
+    type: FieldSpec["type"];
+    options?: string[];
+    min?: number;
+    max?: number;
+    hint?: string;
+    /** Only on nodes of these shapes. */
+    shapes?: string[];
+}
+/** {@link FieldSpec}s without the inspector-only details (placeholders, steps, option labels). */
+declare function describeFields(fields: readonly FieldSpec[] | undefined): FieldDescription[];
+/** The values of `data` that `fields` declare (what a reader needs, without parser internals). */
+declare function pickFieldData(fields: readonly FieldSpec[] | undefined, data: Record<string, unknown> | undefined): Record<string, unknown>;
+/**
+ * Checks a data patch against a family's fields and returns it as the adapters expect it
+ * (`null` or `""` clears a field, so it becomes `undefined`). Throws a sentence naming the
+ * problem and the allowed values when a key is unknown, does not apply to `shape`, or a
+ * value has the wrong type or is out of range. Nothing is changed when it throws.
+ *
+ * Value types: `text` and `select` take a string, `number` a number, `boolean` a boolean,
+ * `numbers` an array of numbers, `lines` and `tags` an array of strings.
+ */
+declare function checkFieldData(fields: readonly FieldSpec[] | undefined, data: Record<string, unknown>, what: string, shape?: string): Record<string, unknown>;
+
+declare const flowchartUI: FamilyUI;
+declare const stateUI: FamilyUI;
+declare const classUI: FamilyUI;
+declare const erUI: FamilyUI;
+declare function familyUI(family: DiagramFamily): FamilyUI | null;
+declare const FAMILY_TITLES: Record<DiagramFamily, string>;
+/** Starter sources for new documents, by family. */
+declare const FAMILY_TEMPLATES: Partial<Record<DiagramFamily, string>>;
+/**
+ * The smallest source for each family in {@link FAMILY_TEMPLATES}: an empty
+ * canvas Mermaid still accepts (class diagrams need a statement, C4 a title).
+ * For "start blank" flows where the user or an agent fills the diagram in.
+ */
+declare const FAMILY_BLANKS: Partial<Record<DiagramFamily, string>>;
+/** One line on what each family in {@link FAMILY_TEMPLATES} is for, for type pickers. */
+declare const FAMILY_DESCRIPTIONS: Partial<Record<DiagramFamily, string>>;
+
+/**
+ * Family layouts: families whose positions come from their data (quadrant points,
+ * sequence participants, pie slices, Gantt bars…) register one here so the canvas
+ * shows the diagram's own geometry instead of a generic graph layout. The dagre layout
+ * in `@pixerate/editor/canvas` asks this registry first. Kept here, free of dagre, so
+ * family adapters can register without pulling in the canvas.
+ *
+ * @module
+ */
+interface Size {
+    width: number;
+    height: number;
+}
+/** Absolute top-left positions and sizes for every node and group. */
+interface LayoutResult {
+    positions: Record<string, Point>;
+    sizes: Record<string, Size>;
+}
+/** Options a family layout receives (the canvas layout options, with a measure resolved). */
+interface FamilyLayoutOptions {
+    /** Node size estimator. */
+    measure: (node: GraphNode) => Size;
+    /** Gap between nodes in a rank, in px. */
+    nodeSep?: number;
+    /** Gap between ranks, in px. */
+    rankSep?: number;
+    /** Padding inside groups around their children, in px. */
+    groupPadding?: number;
+    /** Height reserved for a group's title, in px. */
+    groupTitleHeight?: number;
+}
+/**
+ * A family-specific layout. Receives the graph, the stored metadata and the resolved
+ * options; returns absolute positions and sizes for every node and group.
+ */
+type FamilyLayout = (graph: DiagramGraph, meta: DiagramMeta, options: FamilyLayoutOptions) => LayoutResult;
+/** Registers (or replaces) the layout used for a family. */
+declare function registerFamilyLayout(family: DiagramFamily, layout: FamilyLayout): void;
+declare function getFamilyLayout(family: DiagramFamily | undefined): FamilyLayout | undefined;
+/** The frame XY charts are drawn in (Mermaid's default 700 × 500). */
+declare const XY_CHART_BOX: {
+    readonly x: 0;
+    readonly y: 0;
+    readonly width: 700;
+    readonly height: 500;
+};
+/** The frame radar charts are drawn in (Mermaid's default 600 × 600). */
+declare const RADAR_CHART_BOX: {
+    readonly x: 0;
+    readonly y: 0;
+    readonly width: 600;
+    readonly height: 600;
+};
+/** A layout that gives every node and group the same frame (charts drawn as one picture). */
+declare function sharedFrameLayout(box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): FamilyLayout;
+
+/**
+ * `pie` adapter.
+ *
+ * ```
+ * pie showData
+ *   title Pets adopted
+ *   "Dogs" : 386
+ *   "Cats" : 85
+ * ```
+ *
+ * Canvas model: one node per slice (shape `slice`, `data.value`), no edges,
+ * no groups. `graph.data.showData` mirrors the header flag; the title comes
+ * from a `title` statement (or the header's `title …` suffix). Slice ids are
+ * derived from their labels (`Dogs` → `Dogs`, `Hot dogs` → `Hot_dogs`), made
+ * unique with `_2`, `_3`… and kept stable through edits other than renames.
+ *
+ * Positions are data: the registered layout puts every slice on the pie's
+ * bounding square (see `./geometry`), and drop positions are ignored.
+ *
+ * @module
+ */
+type PieStatement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "title";
+    title: string;
+}) | (BaseStatement & {
+    kind: "slice";
+    label: string;
+    value: number;
+});
+declare const pieGrammar: StatementGrammar<PieStatement>;
+declare const pieAdapter: DiagramAdapter<StatementBody<PieStatement>>;
+
+/**
+ * `xychart-beta` adapter.
+ *
+ * ```
+ * xychart-beta
+ *   title "Sales revenue"
+ *   x-axis [jan, feb, mar]
+ *   y-axis "Revenue (in $)" 4000 --> 11000
+ *   bar [5000, 6000, 7500]
+ *   line "Target" [5500, 6500, 7000]
+ * ```
+ *
+ * Canvas model: one node per series (shape `bar` or `line`, `data.values`
+ * in x-axis order), no edges, no groups. Series ids are their kind and
+ * ordinal (`bar1`, `bar2`, `line1`), so a rename keeps the id; the label is
+ * the series title, or `Bar 1` / `Line 1` when it has none
+ * (`data.titled: false`). The axes and orientation are diagram data:
+ * `graph.data` holds `categories` (the x-axis bands), `xTitle`, `xMin` /
+ * `xMax` (a numeric x-axis), `yTitle`, `yMin` / `yMax` and `horizontal`.
+ *
+ * Drawn with the chart module (`@pixerate/editor/canvas` family scenes); every series
+ * node shares the chart frame.
+ *
+ * @module
+ */
+type XySeriesKind = "bar" | "line";
+type XyStatement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "title";
+    title: string;
+}) | (BaseStatement & {
+    kind: "xaxis";
+    title?: string;
+    categories?: string[];
+    range?: [number, number];
+}) | (BaseStatement & {
+    kind: "yaxis";
+    title?: string;
+    range?: [number, number];
+}) | (BaseStatement & {
+    kind: "series";
+    series: XySeriesKind;
+    title?: string;
+    values: number[];
+});
+declare const xyChartGrammar: StatementGrammar<XyStatement>;
+declare const xyChartAdapter: DiagramAdapter<StatementBody<XyStatement>>;
+
+/**
+ * `radar-beta` adapter.
+ *
+ * ```
+ * radar-beta
+ *   title Skills
+ *   axis m["Math"], s["Science"], e["English"]
+ *   curve alice["Alice"]{85, 90, 80}
+ *   curve bob["Bob"]{ e: 70, m: 75, s: 85 }
+ *   max 100
+ * ```
+ *
+ * Canvas model: one node per curve (shape `curve`, `data.values` in axis
+ * order; keyed entries are resolved and missing axes read 0), no edges, no
+ * groups. Node ids are the curve ids and labels their `["…"]` labels (or the
+ * id). The axes and options are diagram data: `graph.data` holds `axes`
+ * (labels), `axisIds`, `max`, `min`, `ticks`, `graticule` and `showLegend`.
+ * Edited curves are written positionally; editing the axes rewrites them as
+ * one `axis` line and every curve to the new axis count.
+ *
+ * Drawn with the chart module (`@pixerate/editor/canvas` family scenes); every series
+ * node shares the chart frame.
+ *
+ * @module
+ */
+interface AxisEntry {
+    id: string;
+    label?: string;
+}
+interface CurveEntry {
+    axis?: string;
+    value: number;
+}
+declare const OPTIONS: readonly ["max", "min", "ticks", "graticule", "showLegend"];
+type OptionName = (typeof OPTIONS)[number];
+type RadarStatement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "title";
+    title: string;
+}) | (BaseStatement & {
+    kind: "axis";
+    axes: AxisEntry[];
+}) | (BaseStatement & {
+    kind: "curve";
+    id: string;
+    label?: string;
+    entries: CurveEntry[];
+}) | (BaseStatement & {
+    kind: "option";
+    name: OptionName;
+    value: string;
+});
+declare const radarGrammar: StatementGrammar<RadarStatement>;
+declare const radarAdapter: DiagramAdapter<StatementBody<RadarStatement>>;
+
+/**
+ * Geometry of a quadrant chart as Mermaid draws it (`quadrantBuilder.ts`): a
+ * 500×500 chart with the title on top, the y-axis labels in a strip on the
+ * left, the x-axis labels in a strip under the chart (above it when there
+ * are no points), the square chart area split into four quadrants, and every
+ * point a circle on its `[x, y]` with its label just below. Shared by the
+ * layout, the editor (dragging a point rewrites its coordinates) and the
+ * React canvas, so all three agree.
+ *
+ * All coordinates are canvas pixels in the frame of Mermaid's SVG.
+ *
+ * @module
+ */
+/** Mermaid's `quadrantChart` defaults. */
+declare const QUADRANT_METRICS: {
+    readonly chartWidth: 500;
+    readonly chartHeight: 500;
+    readonly titleFontSize: 20;
+    readonly titlePadding: 10;
+    readonly quadrantPadding: 5;
+    readonly xAxisLabelPadding: 5;
+    readonly yAxisLabelPadding: 5;
+    readonly xAxisLabelFontSize: 16;
+    readonly yAxisLabelFontSize: 16;
+    readonly quadrantLabelFontSize: 16;
+    readonly quadrantTextTopPadding: 5;
+    readonly pointTextPadding: 5;
+    readonly pointLabelFontSize: 12;
+    readonly pointRadius: 5;
+    readonly internalBorderWidth: 1;
+    readonly externalBorderWidth: 2;
+};
+/** Side of the square node box every point gets on the canvas (centred on the point). */
+declare const POINT_BOX = 24;
+interface QuadrantSpace {
+    /** Left / top of the chart area (the four quadrants). */
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** Mermaid moves the x-axis labels under the chart once there are points. */
+    xAxisPosition: "top" | "bottom";
+}
+interface QuadrantSpaceInput {
+    title: boolean;
+    xAxis: boolean;
+    yAxis: boolean;
+    points: boolean;
+}
+/** Mermaid's `calculateSpace`. */
+declare function quadrantSpace({ title, xAxis, yAxis, points }: QuadrantSpaceInput): QuadrantSpace;
+type GraphLike = Pick<DiagramGraph, "nodes" | "title" | "data">;
+/** What the space depends on, read from a graph. */
+declare function spaceInput(graph: GraphLike, pointCount?: number): QuadrantSpaceInput;
+/** Centre of a point with coordinates `[x, y]` (0–1). */
+declare function pointCentre(x: number, y: number, space: QuadrantSpace): Point;
+/** Top-left of a point's node box (see {@link POINT_BOX}). */
+declare function pointPosition(x: number, y: number, space: QuadrantSpace): Point;
+/** Coordinates (0–1, two decimals, clamped) of a point whose node box is at `position`. */
+declare function positionToData(position: Point, space: QuadrantSpace): {
+    x: number;
+    y: number;
+};
+interface QuadrantBox {
+    n: 1 | 2 | 3 | 4;
+    /** Group id (`quadrant-1`…). */
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Label anchor: centred horizontally; `top` hangs from y, `middle` is centred on it. */
+    labelX: number;
+    labelY: number;
+    labelBaseline: "top" | "middle";
+}
+type AxisKey = "xAxisLeft" | "xAxisRight" | "yAxisBottom" | "yAxisTop";
+interface QuadrantAxisLabel {
+    key: AxisKey;
+    text: string;
+    /** Anchor; the text hangs from it (rotated −90° for the y axis, reading upwards). */
+    x: number;
+    y: number;
+    anchor: "start" | "middle";
+    rotation: 0 | -90;
+    /** Length of the strip the label belongs to (for hit boxes). */
+    span: number;
+}
+interface QuadrantPointGeometry {
+    id: string;
+    label: string;
+    cx: number;
+    cy: number;
+    radius: number;
+    color?: string;
+    strokeColor?: string;
+    strokeWidth?: string;
+}
+interface QuadrantBorder {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    external: boolean;
+}
+interface QuadrantGeometry {
+    space: QuadrantSpace;
+    /** Title anchor (centred, hanging from y), when there is a title. */
+    title?: {
+        text: string;
+        x: number;
+        y: number;
+    };
+    quadrants: QuadrantBox[];
+    axisLabels: QuadrantAxisLabel[];
+    borders: QuadrantBorder[];
+    points: QuadrantPointGeometry[];
+}
+/** Computes the chart as Mermaid would draw `graph`. */
+declare function quadrantGeometry(graph: GraphLike & Partial<Pick<DiagramGraph, "classDefs">>): QuadrantGeometry;
+
+/**
+ * `quadrantChart` adapter.
+ *
+ * ```
+ * quadrantChart
+ *   title Feature prioritisation
+ *   x-axis Low effort --> High effort
+ *   y-axis Low impact --> High impact
+ *   quadrant-1 Plan carefully
+ *   Dark mode: [0.3, 0.45] radius: 8, color: #ff9900
+ * ```
+ *
+ * Canvas model: one node per point (shape `point`, `data.x` / `data.y` in
+ * 0–1, optional `radius` / `color`), the four quadrants as locked groups
+ * (`quadrant-1` top-right, `quadrant-2` top-left, `quadrant-3` bottom-left,
+ * `quadrant-4` bottom-right) with each point inside the quadrant it falls in.
+ * Axis labels live in `graph.data` (`xAxisLeft`, `xAxisRight`, `yAxisBottom`,
+ * `yAxisTop`). Point ids are derived from labels like pie slices.
+ *
+ * Positions are data: the registered layout places points from their
+ * coordinates on Mermaid's 500×500 chart (see `./geometry`), and dragging a
+ * point (`moveNodes`) rewrites its `[x, y]` instead of storing layout
+ * metadata. A quadrant without a `quadrant-N` statement is labelled
+ * `Quadrant N` with `data.placeholder` (Mermaid draws no label for it).
+ *
+ * @module
+ */
+type PointStatement = BaseStatement & {
+    kind: "point";
+    label: string;
+    quoted?: boolean;
+    className?: string;
+    x: number;
+    y: number;
+    /** Trailing styling, e.g. `radius: 10, color: #ff0000`. */
+    styles: string;
+};
+type AxisStatement = BaseStatement & {
+    kind: "axis";
+    axis: "x" | "y";
+    from: string;
+    to?: string;
+};
+type QuadrantStatement = BaseStatement & {
+    kind: "quadrant";
+    n: 1 | 2 | 3 | 4;
+    label: string;
+};
+type QuadrantChartStatement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "title";
+    title: string;
+}) | (BaseStatement & {
+    kind: "classDef";
+    name: string;
+    styles: string;
+}) | AxisStatement | QuadrantStatement | PointStatement;
+declare const quadrantGrammar: StatementGrammar<QuadrantChartStatement>;
+declare const quadrantAdapter: DiagramAdapter<StatementBody<QuadrantChartStatement>>;
+
+/**
+ * `mindmap` adapter.
+ *
+ * ```
+ * mindmap
+ *   root((Generative Diagrams))
+ *     Authoring
+ *       Canvas editing
+ *     Rendering
+ *       ::icon(fa fa-image)
+ * ```
+ *
+ * Canvas model: one node per mindmap line, one solid tree edge (`data.tree`)
+ * from each node to each child, no groups. Hierarchy comes from indentation:
+ * a node is the child of the nearest shallower node above. Positions are
+ * derived (see `./geometry`): the root in the centre, branches around it.
+ *
+ * The bracket form is kept in `data.form` (`default`, `square`, `rounded`,
+ * `circle`, `bang`, `cloud`, `hexagon`) and mapped to a diagram shape
+ * (`text` for the default form); a
+ * leading Mermaid id (`root((…))`) is kept (`data.explicitId`), otherwise the
+ * id is derived from the label (`Canvas editing` → `Canvas_editing`).
+ * `::icon(…)` and `:::class` lines decorate the node above them and move or
+ * disappear with it.
+ *
+ * Edits: `addNode` (as last child of `node.parentId`, default the root),
+ * `renameNode`, `setNodeShape`, `removeNodes` (with the whole subtree),
+ * `addEdge` / `reconnectEdge` (re-parent the target, with its subtree, under
+ * the source), `setNodeData` (`icon`). Tree edges cannot be removed on their
+ * own; `setTitle` uses the frontmatter. `moveNodes` never stores positions: a
+ * topic dropped onto another topic is re-parented under it (`interceptMeta`).
+ *
+ * @module
+ */
+/** Bracket forms of a mindmap node. `default` is plain text. */
+type MindmapForm = "default" | "square" | "rounded" | "circle" | "bang" | "cloud" | "hexagon";
+type NodeStatement = BaseStatement & {
+    kind: "node";
+    /** The Mermaid id written before the brackets, if any. */
+    id?: string;
+    label: string;
+    form: MindmapForm;
+    /** Whether the label was written in double quotes. */
+    quoted?: boolean;
+};
+type IconStatement = BaseStatement & {
+    kind: "icon";
+    icon: string;
+};
+type ClassStatement = BaseStatement & {
+    kind: "class";
+    classes: string[];
+};
+type MindmapStatement = (BaseStatement & {
+    kind: "raw";
+}) | NodeStatement | IconStatement | ClassStatement;
+declare const mindmapGrammar: StatementGrammar<MindmapStatement>;
+declare const mindmapAdapter: DiagramAdapter<StatementBody<MindmapStatement>>;
+
+/**
+ * Geometry of a sequence diagram as Mermaid draws it: participants in a row
+ * of equal-height boxes, a lifeline under each, and one row per message,
+ * note or fragment boundary, top to bottom in document order. Shared by the
+ * layout (participant boxes), the editor (dragging a participant reorders the
+ * columns) and the React canvas (lifelines, message rows, notes, fragments
+ * and activation bars), so all three agree.
+ *
+ * @module
+ */
+/** Ordered things that take vertical space, exposed as `graph.data.events`. */
+type SequenceEvent = {
+    kind: "message";
+    edgeId: string;
+    from: string;
+    to: string;
+    mod: "" | "+" | "-";
+} | {
+    kind: "note";
+    placement: "over" | "left" | "right";
+    targets: string[];
+    text: string;
+} | {
+    kind: "open";
+    keyword: string;
+    text: string;
+} | {
+    kind: "else";
+    keyword: string;
+    text: string;
+} | {
+    kind: "end";
+} | {
+    kind: "activate" | "deactivate";
+    target: string;
+};
+/** Mermaid's sequence defaults (actor width 150, height 65, margin 50…), in canvas pixels. */
+declare const SEQUENCE_METRICS: {
+    readonly actorWidth: 150;
+    readonly actorHeight: 65;
+    readonly actorGap: 50;
+    readonly boxPad: 12;
+    readonly boxTitle: 26;
+    readonly firstRow: 34;
+    readonly messageRow: 46;
+    readonly selfMessageRow: 64;
+    readonly noteRow: 48;
+    readonly openRow: 36;
+    readonly elseRow: 32;
+    readonly endRow: 18;
+    readonly bottomGap: 24;
+    readonly activationWidth: 10;
+};
+interface SequenceColumn {
+    id: string;
+    x: number;
+    width: number;
+    center: number;
+}
+interface SequenceMessageRow {
+    edgeId: string;
+    /** y of the arrow line. */
+    y: number;
+    self: boolean;
+}
+interface SequenceNoteBox {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface SequenceFragment {
+    keyword: string;
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** `else` / `and` / `option` dividers. */
+    dividers: {
+        y: number;
+        text: string;
+    }[];
+    depth: number;
+}
+interface SequenceActivation {
+    participant: string;
+    x: number;
+    top: number;
+    bottom: number;
+}
+interface SequenceGeometry {
+    columns: Map<string, SequenceColumn>;
+    order: string[];
+    messages: SequenceMessageRow[];
+    notes: SequenceNoteBox[];
+    fragments: SequenceFragment[];
+    activations: SequenceActivation[];
+    /** Box (group) frames, spanning the full height. */
+    boxes: Map<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    lifelineTop: number;
+    lifelineBottom: number;
+    /** Total width and height (bottom of the mirrored participants). */
+    width: number;
+    height: number;
+}
+declare function sequenceGeometry(graph: DiagramGraph): SequenceGeometry;
+
+/**
+ * `sequenceDiagram` adapter.
+ *
+ * ```
+ * sequenceDiagram
+ *   autonumber
+ *   actor U as Customer
+ *   participant W as Web app
+ *   U->>W: Place order
+ *   alt Approved
+ *     W-->>U: Order confirmed
+ *   end
+ * ```
+ *
+ * Canvas model: one node per participant (shape `rect`, or `actor` for
+ * `actor` declarations), declared ones first in declaration order, then the
+ * ones only mentioned in messages. One edge per message line in document
+ * order; `data.index` is the message's position, `data.kind` the arrow token,
+ * `data.activate` / `data.deactivate` the `+` / `-` suffixes. `box … end`
+ * blocks are groups (`data.color` keeps the box colour). Fragments (`alt`,
+ * `loop`, `par`…), notes, activations and every other line are kept verbatim;
+ * messages inside fragments are still edges. `graph.data.autonumber` mirrors
+ * the `autonumber` statement.
+ *
+ * Message edge ids are `L_<from>_<to>_<n>` where `n` counts messages of the
+ * same pair in document order, so unrelated edits keep them stable.
+ *
+ * @module
+ */
+type ParticipantKeyword = "participant" | "actor";
+type Modifier = "" | "+" | "-";
+type SequenceStatement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "title";
+    title: string;
+    colon: boolean;
+}) | (BaseStatement & {
+    kind: "autonumber";
+    off: boolean;
+}) | (BaseStatement & {
+    kind: "participant";
+    keyword: ParticipantKeyword;
+    id: string;
+    alias?: string;
+    /** `@{ … }` participant configuration, kept verbatim. */
+    config?: string;
+    create: boolean;
+}) | (BaseStatement & {
+    kind: "message";
+    from: string;
+    to: string;
+    arrow: string;
+    mod: Modifier;
+    text: string;
+}) | (BaseStatement & {
+    kind: "box";
+    color?: string;
+    label: string;
+})
+/** Fragment openers (`alt`, `loop`…) and continuations (`else`, `and`, `option`). */
+ | (BaseStatement & {
+    kind: "block";
+    keyword: string;
+    text: string;
+    opens: boolean;
+}) | (BaseStatement & {
+    kind: "end";
+})
+/** Lines that reference participants (`Note`, `activate`, `destroy`, `link`…). */
+ | (BaseStatement & {
+    kind: "ref";
+    keyword: string;
+    targets: string[];
+});
+declare const sequenceGrammar: StatementGrammar<SequenceStatement>;
+declare const sequenceAdapter: DiagramAdapter<StatementBody<SequenceStatement>>;
+
+/**
+ * Shared machinery for "sections of items" families (gantt, timeline,
+ * journey). Their documents share one shape:
+ *
+ * ```
+ * <header>
+ *   title Some title
+ *   item before any section
+ *   section First
+ *     item
+ *     item
+ *   section Second
+ *     item
+ * ```
+ *
+ * - `section X` starts a group; every following item belongs to it until the
+ *   next `section` line. Items before the first section have no group.
+ * - Groups get ids `uniqueId(slugId(label))`; items get ids from the family
+ *   (explicit ids first, then slugs of their text). Explicit ids are reserved
+ *   first, then item slugs, then section slugs, so that structural edits on
+ *   sections (ungroup, rename) never change item ids.
+ * - {@link editSections} implements the shared edits (title, add/remove/rename
+ *   items, grouping, re-parenting) and re-keys layout metadata by statement
+ *   identity after every edit, so any id change (rename, explicit id edit)
+ *   carries the stored position along.
+ *
+ * Families plug in with a {@link SectionsSpec}: how to recognise and create
+ * items, how to rename them, and which characters their grammar forbids.
+ *
+ * @module
+ */
+/** `title …` statement. */
+interface TitleStatement extends BaseStatement {
+    kind: "title";
+    title: string;
+}
+/** `section …` statement (starts a group). */
+interface SectionStatement extends BaseStatement {
+    kind: "section";
+    label: string;
+}
+/** A statement the diagram module does not model; always emitted verbatim. */
+interface RawStatement extends BaseStatement {
+    kind: "raw";
+}
+
+declare const GANTT_METRICS: {
+    /** Mermaid's barHeight 20 / barGap 4, scaled up a little for editing. */
+    readonly barHeight: 24;
+    readonly barGap: 6;
+    /** Width of the section-name column left of the chart. */
+    readonly labelWidth: 150;
+    readonly rightPadding: 40;
+    /** Space for the date ticks under the chart. */
+    readonly axisHeight: 32;
+    readonly milestoneSize: 22;
+    readonly minChartWidth: 960;
+    readonly maxPxPerDay: 48;
+    readonly minPxPerDay: 4;
+};
+interface GanttRow {
+    id: string;
+    /** Section id, if the task belongs to one. */
+    section?: string;
+    sectionIndex: number;
+    row: number;
+    /** Bar box (absolute). */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    milestone: boolean;
+    start?: number;
+    end?: number;
+}
+interface GanttBand {
+    id?: string;
+    label?: string;
+    index: number;
+    y: number;
+    height: number;
+}
+interface GanttTick {
+    x: number;
+    time: number;
+    label: string;
+}
+interface GanttGeometry {
+    origin: number;
+    pxPerDay: number;
+    rows: GanttRow[];
+    rowById: Map<string, GanttRow>;
+    bands: GanttBand[];
+    /** Chart area (right of the section labels). */
+    chartX: number;
+    chartWidth: number;
+    top: number;
+    bottom: number;
+    ticks: GanttTick[];
+    today?: number;
+}
+declare function ganttGeometry(graph: DiagramGraph, now?: number): GanttGeometry;
+/** Formats UTC time with the d3 specifiers Mermaid's `axisFormat` uses (`%Y-%m-%d`, `%b %d`…). */
+declare function formatAxis(t: number, format?: string): string;
+
+/**
+ * `gantt` adapter.
+ *
+ * ```
+ * gantt
+ *   title Q4 delivery roadmap
+ *   dateFormat YYYY-MM-DD
+ *   section Platform
+ *     Design system v9 rollout :done, ds, 2026-10-01, 14d
+ *     Observability upgrade    :ob, after ds, 14d
+ * ```
+ *
+ * Canvas model: one node per task (shape `task`, or `milestone` when tagged
+ * so), sections as groups, and one dependency edge `X → task` per id in a
+ * task's `after X Y` start (`data.dependency: true`). Task ids are the
+ * explicit Mermaid ids, or slugs of the task names for tasks without one.
+ * Task data: `tags`, `start`, `end` (as written), `explicitId`, plus the
+ * resolved `startTime` / `endTime` (UTC epoch ms, when computable) that the
+ * time-axis layout uses. Config lines (`dateFormat`, `axisFormat`,
+ * `excludes`, `tickInterval`, `todayMarker`) are exposed as `graph.data`.
+ *
+ * @module
+ */
+/** Task tags Mermaid recognises before the id/start/end parts. */
+declare const GANTT_TAGS: readonly ["done", "active", "crit", "milestone", "vert"];
+/** Diagram-level settings edited with `setGraphData`. */
+declare const GANTT_CONFIG_KEYS: readonly ["dateFormat", "axisFormat", "excludes", "tickInterval", "todayMarker"];
+type ConfigKey = (typeof GANTT_CONFIG_KEYS)[number];
+/** A task line: `Name :tags, id, start, end`. */
+interface GanttTask extends BaseStatement {
+    kind: "task";
+    name: string;
+    tags: string[];
+    id?: string;
+    start?: string;
+    end: string;
+    /** Text after the task data that Mermaid ignores (`; …`, `# …`), kept on format. */
+    suffix: string;
+}
+/** One of the {@link GANTT_CONFIG_KEYS} lines. */
+interface GanttConfig extends BaseStatement {
+    kind: "config";
+    key: ConfigKey;
+    value: string;
+}
+type GanttStatement = RawStatement | TitleStatement | SectionStatement | GanttConfig | GanttTask;
+/** `after a b` → `["a", "b"]`; `[]` for any other start. */
+declare function afterIds(start: string | undefined): string[];
+/**
+ * Parses a date written in a dayjs-style `dateFormat` (`YYYY`, `MM`, `DD`,
+ * `HH`, `mm`, `ss`… plus `x` / `X` timestamps). Falls back to ISO / `Date`
+ * parsing like Mermaid does. Returns UTC epoch milliseconds.
+ */
+declare function parseGanttDate(text: string, format?: string): number | undefined;
+/** Formats UTC epoch ms with a `dateFormat`; unsupported formats fall back to `YYYY-MM-DD`. */
+declare function formatGanttDate(ms: number, format?: string): string;
+declare const ganttGrammar: StatementGrammar<GanttStatement>;
+declare const ganttAdapter: DiagramAdapter<StatementBody<GanttStatement>>;
+
+/**
+ * `timeline` adapter.
+ *
+ * ```
+ * timeline
+ *   title Platform milestones
+ *   2024 : Unified portal launched
+ *        : Design system v1
+ *   section Later
+ *   2025 : AI chat assistant : Generative forms
+ * ```
+ *
+ * Canvas model: one node per period (shape `rounded`, `data.events`),
+ * sections as groups and synthetic "next" edges between consecutive periods
+ * (not editable; the canvas does not draw them, as Mermaid has no such
+ * arrows). Positions derive from the order of the periods (see
+ * `./geometry`): moving a period (`moveNodes`) reorders it, possibly into
+ * another section, instead of storing a position. A period line and the continuation lines that follow it
+ * directly (`     : more`) form ONE statement whose `raw` keeps the original
+ * line breaks; when edited it is re-emitted with the colons aligned under the
+ * period's colon. Period ids are slugs of the period text (`2024` → `2024`).
+ *
+ * @module
+ */
+/** A period with its events (possibly spanning several physical lines). */
+interface TimelinePeriod extends BaseStatement {
+    kind: "period";
+    period: string;
+    events: string[];
+}
+type TimelineStatement = RawStatement | TitleStatement | SectionStatement | TimelinePeriod;
+declare const timelineGrammar: StatementGrammar<TimelineStatement>;
+declare const timelineAdapter: DiagramAdapter<StatementBody<TimelineStatement>>;
+/**
+ * Mermaid's geometry: periods in one row (in document order) under their
+ * section headers; stored positions are ignored.
+ */
+declare const timelineLayout: FamilyLayout;
+
+/**
+ * `journey` (user journey) adapter.
+ *
+ * ```
+ * journey
+ *   title Requesting a new laptop
+ *   section Discover
+ *     Find IT portal: 3: Employee
+ *     Read policy: 2: Employee, IT
+ * ```
+ *
+ * Canvas model: one node per task (shape `rect`, `data.score` 1–5,
+ * `data.actors`), sections as groups and synthetic "next" edges between
+ * consecutive tasks (not editable; the canvas does not draw them, as Mermaid
+ * has no such arrows). Positions derive from the order of the tasks (see
+ * `./geometry`): moving a task (`moveNodes`) reorders it, possibly into
+ * another section, instead of storing a position. Task ids are slugs of the task names
+ * (`Find IT portal` → `Find_IT_portal`), made unique with `_2`, `_3`….
+ *
+ * @module
+ */
+/** A task line: `Name: score: actor1, actor2`. */
+interface JourneyTask extends BaseStatement {
+    kind: "task";
+    name: string;
+    score: number;
+    actors: string[];
+}
+type JourneyStatement = RawStatement | TitleStatement | SectionStatement | JourneyTask;
+declare const journeyGrammar: StatementGrammar<JourneyStatement>;
+declare const journeyAdapter: DiagramAdapter<StatementBody<JourneyStatement>>;
+/**
+ * Mermaid's geometry: tasks in one row (in document order) under their
+ * section bars; stored positions are ignored.
+ */
+declare const journeyLayout: FamilyLayout;
+
+/**
+ * `gitGraph` adapter.
+ *
+ * ```
+ * gitGraph LR:
+ *   commit id: "init"
+ *   branch develop
+ *   checkout develop
+ *   commit id: "feat" tag: "v0.1"
+ *   checkout main
+ *   merge develop
+ * ```
+ *
+ * Canvas model: the statements are simulated in order like Mermaid does
+ * (`branch` also checks the new branch out, the starting branch is `main`).
+ * Every `commit`, `merge` and `cherry-pick` is a node (shape `commit`, or
+ * `merge-commit` for merges); edges are parent links (parent → child, two
+ * parents for merges, and a dotted second link from the picked commit for
+ * cherry-picks, as Mermaid records it); every branch is a group whose members are its commits.
+ * Node ids are the explicit `id:` values, or `c<n>` (the commit's 1-based
+ * ordinal in the document) for commits without one — Mermaid generates random
+ * ids for those, so they are only stable until an earlier commit is inserted.
+ *
+ * Edits never produce text Mermaid rejects: after removals, merges and
+ * cherry-picks that became invalid (same head, missing source…) are dropped,
+ * and `addEdge` only appends a `merge` when it is valid at the end of the
+ * document.
+ *
+ * @module
+ */
+interface Attr {
+    key: string;
+    value: string;
+    quoted: boolean;
+}
+type GitStatement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "commit";
+    attrs: Attr[];
+    /** Attributes the diagram module could not read; the line is never regenerated. */
+    opaque: boolean;
+}) | (BaseStatement & {
+    kind: "merge";
+    branch: string;
+    attrs: Attr[];
+    opaque: boolean;
+}) | (BaseStatement & {
+    kind: "cherryPick";
+    attrs: Attr[];
+    opaque: boolean;
+}) | (BaseStatement & {
+    kind: "branch";
+    name: string;
+    order?: string;
+}) | (BaseStatement & {
+    kind: "checkout";
+    keyword: "checkout" | "switch";
+    name: string;
+});
+declare const gitGraphGrammar: StatementGrammar<GitStatement>;
+declare const gitGraphAdapter: DiagramAdapter<StatementBody<GitStatement>>;
+
+/**
+ * C4 geometry as Mermaid draws it, shared by the layout (positions), the
+ * canvas (shapes and text placement) and the relation renderer.
+ *
+ * Mermaid lays C4 elements out in rows inside each boundary (four per row by
+ * default, `UpdateLayoutConfig` changes it), nested boundaries below their
+ * parent's elements (two per row), with 50px margins; every element is 216px
+ * wide and as tall as its text. The shapes are Mermaid's unified ones:
+ * `person` (a head over a rounded body), rounded rectangles for systems,
+ * containers and components, `cylinder` for `*Db` and a horizontal
+ * cylinder for `*Queue`. The text is a bold name, a `[Type: technology]`
+ * line and the description, each wrapped to the shape's width.
+ *
+ * Text sizes are estimated (no DOM): close to Mermaid's for the default
+ * "Open Sans" font, so the canvas has the same rows, gaps and proportions.
+ *
+ * @module
+ */
+/** Mermaid's C4 defaults (`config.c4`). */
+declare const C4_METRICS: {
+    readonly shapeMargin: 50;
+    readonly shapePadding: 20;
+    readonly width: 216;
+    readonly diagramMarginX: 50;
+    readonly diagramMarginY: 10;
+    readonly shapeInRow: 4;
+    readonly boundaryInRow: 2;
+    readonly nextLinePaddingX: 0;
+    /** Element name size; the type line is 0.75em of it, the description 0.82em. */
+    readonly fontSize: 14;
+    readonly boundaryFontSize: 14;
+    readonly messageFontSize: 12;
+    /** Gap between the name, type and description blocks. */
+    readonly sectionGap: 3;
+    readonly lineHeight: 1.15;
+    /** Mermaid wraps against `screen.availWidth`; used when there is no screen. */
+    readonly screenWidth: 1920;
+    /** Size given to a boundary with nothing in it (Mermaid draws it 0×0). */
+    readonly emptyBoundary: {
+        readonly width: 216;
+        readonly height: 100;
+    };
+};
+type C4Base = "person" | "system" | "container" | "component";
+type C4ShapeKind = "person" | "rounded" | "cylinder" | "h-cyl";
+/** Mermaid's element type (`external_container_db`…) for an element keyword. */
+interface C4ElementType {
+    base: C4Base;
+    variant: "" | "db" | "queue";
+    external: boolean;
+    /** `person`, `external_system_db`…, as Mermaid's `typeC4Shape`. */
+    type: string;
+}
+declare function c4ElementType(node: GraphNode): C4ElementType;
+/** Which of the element's text parts a section shows (and edits). */
+type C4TextPart = "label" | "tech" | "descr";
+interface C4TextSection {
+    part: C4TextPart;
+    /** The text shown (the type line is `[Container: tech]`). */
+    text: string;
+    lines: string[];
+    fontSize: number;
+    bold: boolean;
+    height: number;
+}
+interface C4ElementGeometry {
+    type: C4ElementType;
+    shape: C4ShapeKind;
+    width: number;
+    height: number;
+    /** Width the text wraps at. */
+    wrapWidth: number;
+    sections: C4TextSection[];
+    textHeight: number;
+    /** Centre of the text block, relative to the element's top-left. */
+    textCenter: {
+        x: number;
+        y: number;
+    };
+    /** Person: head radius, where the body starts and its corner radius. */
+    person?: {
+        headRadius: number;
+        bodyTop: number;
+        bodyRadius: number;
+    };
+    /** Cylinders: the end-cap ellipse radii (`rx` along the axis for `h-cyl`). */
+    cylinder?: {
+        rx: number;
+        ry: number;
+    };
+}
+/** The `[Type]` / `[Type: technology]` line Mermaid prints under the name. */
+declare function c4Stereotype(type: C4ElementType, tech?: string): string;
+/** Size, shape and text layout of one element, as Mermaid computes them. */
+declare function c4ElementGeometry(node: GraphNode): C4ElementGeometry;
+interface C4BoundaryText {
+    label: string;
+    /** `[system]`, `[node]`… (Mermaid's default type per boundary keyword). */
+    type: string;
+    descr?: string;
+    /** Centre lines of the label, type and description, from the boundary's top. */
+    labelY: number;
+    typeY: number;
+    descrY?: number;
+    /** Height the texts take above the boundary (Mermaid's `Y`). */
+    height: number;
+    /** Deployment nodes are drawn with a solid border. */
+    solid: boolean;
+}
+declare function c4BoundaryText(group: Pick<GraphGroup, "label" | "data">): C4BoundaryText;
+interface C4Layout extends LayoutResult {
+    elements: Map<string, C4ElementGeometry>;
+    boundaries: Map<string, C4BoundaryText>;
+}
+interface C4LayoutOptions {
+    /** Mermaid wraps rows against the screen width (`screen.availWidth`). */
+    screenWidth?: number;
+}
+/**
+ * Element and boundary boxes as Mermaid's C4 renderer computes them, then
+ * stored positions (elements the user dragged) on top; boundaries that
+ * contain a moved element are re-fitted around their content with Mermaid's
+ * margins.
+ */
+declare function c4Layout(graph: DiagramGraph, meta?: DiagramMeta, options?: C4LayoutOptions): C4Layout;
+interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface C4RelGeometry {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    /** Quadratic control point: Mermaid draws every relation but the first as a curve. */
+    control?: {
+        x: number;
+        y: number;
+    };
+    /** Left edge of the label block (Mermaid starts the label at the midpoint), vertically centred. */
+    label: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * A relation between two element boxes: endpoints where the centre-to-centre
+ * line leaves each box, the first relation straight and the others as
+ * Mermaid's quadratic curves, the label at the midpoint.
+ */
+declare function c4RelGeometry(from: Box, to: Box, index: number): C4RelGeometry;
+/**
+ * Mermaid's C4 arrowhead (a 10×10 triangle, `refX` 9) at `tip`, pointing
+ * along the direction from `from` to `tip`; as an SVG `points` list.
+ */
+declare function c4ArrowHead(tip: {
+    x: number;
+    y: number;
+}, from: {
+    x: number;
+    y: number;
+}): string;
+
+/**
+ * C4 adapter (`C4Context`, `C4Container`, `C4Component`, `C4Dynamic`,
+ * `C4Deployment`).
+ *
+ * ```
+ * C4Container
+ *   title Containers
+ *   Person(user, "User")
+ *   System_Boundary(sb, "Portal") {
+ *     Container(web, "Web app", "React", "The UI")
+ *   }
+ *   Rel(user, web, "Uses", "HTTPS")
+ * ```
+ *
+ * Canvas model: one node per element (`Person`, `System*`, `Container*`,
+ * `Component*`; id = alias, shape `c4-*`, `data = { kind, descr, tech, extra,
+ * details }`), one group per boundary block (`*_Boundary`, `Boundary`,
+ * `Node*`, `Deployment_Node`; `data = { kind, type, descr }`) and one edge per
+ * relation (`Rel`, `BiRel`, `Rel_Back`, `Rel_U`…, `RelIndex`; `data = { kind,
+ * tech }`). Named `$…` arguments are kept verbatim and re-emitted after the
+ * positional ones. `UpdateRelStyle` / `UpdateElementStyle` lines are kept as
+ * written but dropped with the element or relation they style.
+ *
+ * Mermaid's C4 lexer does not understand `#quot;`, so inner double quotes are
+ * written as `'`.
+ *
+ * For the canvas, `graph.data` carries the diagram type (`c4Type`, e.g.
+ * `C4Dynamic` numbers its relations) and `UpdateLayoutConfig` values
+ * (`c4ShapeInRow`, `c4BoundaryInRow`); `UpdateElementStyle` colours are
+ * mirrored to `node.data.c4Style` (`bgColor`, `fontColor`, `borderColor`) and
+ * `UpdateRelStyle` ones to `edge.data.c4Style` (`textColor`, `lineColor`,
+ * `offsetX`, `offsetY`). The layout is Mermaid's own (see `./geometry`).
+ *
+ * @module
+ */
+/** Positional arguments shared by elements, boundaries and relations. */
+interface Args {
+    label: string;
+    /** Positional values beyond the ones the diagram module models (sprite, tags, link…), unquoted. */
+    rest: string[];
+    /** Named `$key=value` arguments, verbatim. */
+    extra: string[];
+}
+type C4Statement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "title";
+    title: string;
+}) | (BaseStatement & Args & {
+    kind: "element";
+    keyword: string;
+    alias: string;
+    tech?: string;
+    descr?: string;
+}) | (BaseStatement & Args & {
+    kind: "boundary";
+    keyword: string;
+    alias: string;
+    type?: string;
+    descr?: string;
+}) | (BaseStatement & {
+    kind: "close";
+}) | (BaseStatement & Args & {
+    kind: "rel";
+    keyword: string;
+    /** `RelIndex` sequence number. */
+    index?: string;
+    from: string;
+    to: string;
+    tech?: string;
+}) | (BaseStatement & {
+    kind: "relStyle";
+    from: string;
+    to: string;
+    rest: string[];
+}) | (BaseStatement & {
+    kind: "elementStyle";
+    alias: string;
+});
+declare const c4Grammar: StatementGrammar<C4Statement>;
+/** C4 adapter (all five C4 diagram types). */
+declare const c4Adapter: DiagramAdapter<StatementBody<C4Statement>>;
+
+/**
+ * `architecture-beta` geometry as Mermaid draws it, shared by the layout and
+ * the canvas.
+ *
+ * Mermaid derives a spatial map from the edges' port sides (`a:R --> L:b`
+ * puts `b` one cell to the right of `a`, `a:B --> T:b` one cell below) and
+ * hands it to cytoscape's fcose layout as alignment and relative-placement
+ * constraints. This module builds the same spatial map and turns it into a
+ * grid deterministically: cells one icon plus the ideal edge length (120px)
+ * apart, more where neighbours sit on either side of a group border; groups
+ * wrap their members (labels included) with Mermaid's padding. Measured
+ * against Mermaid's own output this puts every icon within a few pixels for
+ * typical diagrams. Services are 80px icon squares with the label beneath;
+ * junctions are points.
+ *
+ * @module
+ */
+type ArchSide = "L" | "R" | "T" | "B";
+/** Mermaid's `config.architecture` defaults plus the drawing constants of its renderer. */
+declare const ARCH_METRICS: {
+    readonly iconSize: 80;
+    readonly padding: 40;
+    /** A group's frame around its members: the padding plus cytoscape's compound border, as Mermaid draws it. */
+    readonly groupPadding: 42.5;
+    readonly fontSize: 16;
+    /** Service labels wrap at 1.5 × the icon size. */
+    readonly labelWidth: 120;
+    readonly lineHeight: 17.6;
+    /** Gap between neighbouring icons (Mermaid's ideal edge length, 1.5 × the icon). */
+    readonly gap: 120;
+    /** Junctions are invisible in Mermaid; the canvas draws a small point. */
+    readonly junctionSize: 12;
+    readonly arrowSize: number;
+    readonly groupIconSize: 30;
+    /** How far `{group}` edges extend past the service, to the group's border. */
+    readonly groupEdgeShift: 44;
+};
+/** A service label wrapped as Mermaid wraps it (at 1.5 × the icon size). */
+declare function serviceLabelLines(label: string): string[];
+interface ArchitectureLayout extends LayoutResult {
+    /** The spatial map: grid cell of every service and junction (x right, y down). */
+    cells: Map<string, Point>;
+}
+/**
+ * Positions and sizes for every service, junction and group, as described
+ * in the module docs; nodes the user dragged keep their stored positions and
+ * groups are re-fitted around their members.
+ */
+declare function architectureLayout(graph: DiagramGraph, meta?: DiagramMeta): ArchitectureLayout;
+interface ArchEdgeRoute {
+    points: {
+        x: number;
+        y: number;
+    }[];
+    /** Where Mermaid puts the title: the middle of the line, or the bend. */
+    label: {
+        x: number;
+        y: number;
+    };
+    /** `X`: horizontal text, `Y`: rotated −90°, `XY`: rotated ±45° at the bend. */
+    axis: "X" | "Y" | "XY";
+    /** Rotation of the title, in degrees. */
+    rotate: number;
+}
+/**
+ * The orthogonal line between two ports: straight between aligned ports, an
+ * L with one bend for a horizontal-to-vertical pair (Mermaid's `segments`
+ * edge, bending at the source's axis), and a Z (or U, for same-side ports)
+ * when the ends are no longer aligned after a drag.
+ */
+declare function architectureEdgeRoute(s: {
+    x: number;
+    y: number;
+}, sourceSide: ArchSide, t: {
+    x: number;
+    y: number;
+}, targetSide: ArchSide): ArchEdgeRoute;
+/** Mermaid's arrowhead at a port: a triangle pointing into the node, its tip 2px inside. */
+declare function architectureArrow(point: {
+    x: number;
+    y: number;
+}, side: ArchSide): string;
+
+/**
+ * `architecture-beta` adapter.
+ *
+ * ```
+ * architecture-beta
+ *   group api(cloud)[API tier]
+ *   service db(database)[Postgres] in api
+ *   junction j in api
+ *   gateway:R --> L:server
+ * ```
+ *
+ * Canvas model: services are nodes (shape `arch-service`, `data.icon`;
+ * `data.untitled` when the declaration has no `[label]`, so the label is the id),
+ * junctions are small circles (shape `sm-circ`, `data.junction`), groups are
+ * groups (`data.icon`, nested with `in`), and edges carry the sides they
+ * attach to (`data.sourceSide` / `targetSide`, `L|R|T|B`) and whether they
+ * leave a group boundary (`{group}` → `data.sourceGroup` / `targetGroup`).
+ * Arrow tokens map to heads: `--` none, `-->` end, `<--` start, `<-->` both.
+ * The optional edge title (`-[label]-`) is the edge label. Icon names
+ * (`cloud`, `logos:aws-lambda`…) are kept verbatim.
+ *
+ * Positions follow Mermaid's arrangement by port sides (see `./geometry`);
+ * a new edge drawn on the canvas gets the sides that face each other there.
+ *
+ * @module
+ */
+type Side = "L" | "R" | "T" | "B";
+type ArchitectureStatement = (BaseStatement & {
+    kind: "raw";
+}) | (BaseStatement & {
+    kind: "title";
+    title: string;
+}) | (BaseStatement & {
+    kind: "group" | "service";
+    id: string;
+    icon?: string;
+    label?: string;
+    parent?: string;
+}) | (BaseStatement & {
+    kind: "junction";
+    id: string;
+    parent?: string;
+}) | (BaseStatement & {
+    kind: "edge";
+    lhs: string;
+    lhsGroup: boolean;
+    lhsSide: Side;
+    rhs: string;
+    rhsGroup: boolean;
+    rhsSide: Side;
+    arrowStart: boolean;
+    arrowEnd: boolean;
+    label?: string;
+});
+declare const architectureGrammar: StatementGrammar<ArchitectureStatement>;
+/** `architecture-beta` adapter. */
+declare const architectureAdapter: DiagramAdapter<StatementBody<ArchitectureStatement>>;
+
+/**
+ * Reading Mermaid `sankey-beta` / `sankey` diagrams into data, for hosts that
+ * draw them with their own components (`familyViews`). Sankey diagrams stay
+ * render-only: the text is kept verbatim and not edited through `EditOp`s.
+ *
+ * The grammar follows Mermaid's: after the header, one CSV record per line,
+ * `source,target,value`. Fields may be double-quoted, which allows commas and
+ * line breaks inside them and `""` for a quote. Fields are trimmed and the
+ * value is read with `parseFloat`. Blank lines and `%%` comment lines are
+ * skipped. Unlike Mermaid, characters outside ASCII are accepted.
+ *
+ * @module
+ */
+interface SankeyLink {
+    source: string;
+    target: string;
+    value: number;
+}
+interface SankeyData {
+    /** Node names in order of first appearance (a link's source, then its target). */
+    nodes: string[];
+    links: SankeyLink[];
+}
+/** What went wrong reading a diagram, with its 1-based line in the source. */
+interface DiagramDataError {
+    error: string;
+    line?: number;
+}
+type SankeyParse = {
+    data: SankeyData;
+} | DiagramDataError;
+/**
+ * Reads a sankey diagram's links. `source` is the whole Mermaid text (with
+ * frontmatter and header), e.g. a passthrough document's `doc.source`.
+ * Returns an error for text Mermaid would reject (a record without exactly
+ * three fields, an unterminated quote, no records) or that has no usable
+ * number as its value.
+ */
+declare function parseSankey(source: string): SankeyParse;
+
+/**
+ * Reading Mermaid `treemap-beta` / `treemap` diagrams into data, for hosts
+ * that draw them with their own components (`familyViews`). Treemaps stay
+ * render-only: the text is kept verbatim and not edited through `EditOp`s.
+ *
+ * The grammar follows Mermaid's: one item per line, nested by indentation.
+ * A section is a quoted name (`"Sales"` or `'Sales'`); a leaf adds a value
+ * after `:` or `,` (`"Q1": 1,200`, commas in the number are dropped). Either
+ * may end with a `:::class`. `title`, `accTitle` and `accDescr` lines are
+ * read; `classDef` lines and `%%` comments are skipped. Styling is not
+ * returned.
+ *
+ * @module
+ */
+interface TreemapItem {
+    name: string;
+    /** Leaves only. */
+    value?: number;
+    /** Sections only (possibly empty). */
+    children?: TreemapItem[];
+    /** The `:::class` the item names, if any. */
+    className?: string;
+}
+interface TreemapData {
+    /** `title` line in the body (frontmatter titles stay on `doc.graph.title`). */
+    title?: string;
+    accTitle?: string;
+    accDescr?: string;
+    /** Top-level items; Mermaid allows several. */
+    items: TreemapItem[];
+}
+type TreemapParse = {
+    data: TreemapData;
+} | DiagramDataError;
+/**
+ * Reads a treemap's items. `source` is the whole Mermaid text (with
+ * frontmatter and header), e.g. a passthrough document's `doc.source`.
+ * Returns an error for a line Mermaid would reject (an unquoted name, a
+ * missing or negative value) or when there are no items.
+ */
+declare function parseTreemap(source: string): TreemapParse;
+/** A treemap item's value: a leaf's own, or the sum of a section's leaves. */
+declare function treemapValue(item: TreemapItem): number;
+
 /** Body of a render-only document: the raw body lines. */
 interface PassthroughBody {
     lines: string[];
@@ -480,12 +2186,17 @@ interface PassthroughBody {
  */
 declare function createPassthroughAdapter(family: DiagramFamily, tier?: SupportTier): DiagramAdapter<PassthroughBody>;
 
-/** Families that can be edited on the canvas; every other family is kept as text. */
-declare const EDITABLE_DIAGRAM_FAMILIES: readonly ["flowchart", "state", "class", "er"];
-/** The shapes a node of `family` can take (`setNodeShape`), as canonical names. */
+/** Families that can be edited statement by statement; every other family is kept as text. */
+declare const EDITABLE_DIAGRAM_FAMILIES: readonly ["flowchart", "state", "class", "er", "pie", "mindmap", "quadrant", "c4", "architecture", "sequence", "gitGraph", "gantt", "timeline", "journey", "xychart", "radar"];
+/**
+ * The shapes a node of `family` can take (`setNodeShape`), as canonical names. Empty when
+ * the family has nothing to choose between (class boxes, ER entities, pie slices…).
+ */
 declare function diagramShapes(family: DiagramFamily): string[];
-/** Whether the family has groups (subgraphs, composite states, namespaces). ER diagrams do not. */
+/** Whether the family has groups (subgraphs, composite states, namespaces, boxes, sections…). */
 declare function diagramSupportsGroups(family: DiagramFamily): boolean;
+/** Whether the family has a direction (`setDirection`): false for families whose positions follow their data (pie, sequence, Gantt…). */
+declare function diagramSupportsDirection(family: DiagramFamily): boolean;
 /**
  * Checks an edit against the document before it is applied. Returns a sentence saying
  * what is wrong and how to fix it, or `null` when the edit is valid. Ids are checked
@@ -508,7 +2219,7 @@ interface DiagramState {
     /** The Mermaid text, always in step with `document`. */
     source: string;
     family: DiagramFamily;
-    /** True for flowchart, state, class and ER diagrams that are not read-only. */
+    /** True for families with an adapter (see {@link EDITABLE_DIAGRAM_FAMILIES}) that are not read-only. */
     editable: boolean;
     readOnly: boolean;
     /** Selected node, group or edge ids. */
@@ -743,7 +2454,20 @@ declare function describeDiagram(doc: MermaidDocument): {
         severity: "info" | "error" | "warning";
         message: string;
     }[] | undefined;
+    positions: {
+        [k: string]: {
+            x: number;
+            y: number;
+        };
+    };
+    fields?: {
+        diagram?: FieldDescription[] | undefined;
+        edge?: FieldDescription[] | undefined;
+        node?: FieldDescription[] | undefined;
+    } | undefined;
+    settings?: Record<string, unknown> | undefined;
     nodes: {
+        data?: Record<string, unknown> | undefined;
         synthetic?: boolean | undefined;
         styles?: string[] | undefined;
         classes?: string[] | undefined;
@@ -753,6 +2477,7 @@ declare function describeDiagram(doc: MermaidDocument): {
         shape: string;
     }[];
     edges: {
+        data?: Record<string, unknown> | undefined;
         pattern: EdgePattern;
         arrowEnd: ArrowHead;
         label?: string | undefined;
@@ -767,12 +2492,6 @@ declare function describeDiagram(doc: MermaidDocument): {
         label: string;
     }[];
     shapes: string[];
-    positions: {
-        [k: string]: {
-            x: number;
-            y: number;
-        };
-    };
     title?: string | undefined;
     family: DiagramFamily;
     editable: boolean;
@@ -807,4 +2526,4 @@ declare function draftFrames(current: string, target: string, options?: DraftOpt
 /** Ids of nodes and groups in `after` that are new or changed since `before`. */
 declare function changedItems(before: DiagramGraph, after: DiagramGraph): string[];
 
-export { ArrowHead, CLASS_RELATIONS, type Chain, type ClassMember, type ClassRelation, type DiagramActionResult, DiagramAdapter, DiagramController, type DiagramControllerOptions, DiagramDirector, type DiagramDirectorOptions, DiagramFamily, DiagramGraph, DiagramMeta, type DiagramPerformanceResult, type DiagramPerformanceStep, type DiagramPlacement, type DiagramState, type DiagramToolProviderOptions, type DraftOptions, EDITABLE_DIAGRAM_FAMILIES, ER_CARDINALITIES, ER_PATTERNS, EdgePattern, type EdgeSpec, EditOp, type ErAttribute, FLOWCHART_SHAPES, type FlowStatement, type FlowchartBody, type FlowchartDocument, type FoundMermaid, GraphEdge, type LineBody, type LineDocument, type LineGrammar, type LineStatement, type LinkRef, type LinkSpec, META_COMMENT_PREFIX, META_FRONTMATTER_KEY, MermaidDocument, MetaCarrier, type NodeDecl, type NodeRef, type ParseOptions, type PassthroughBody, Point, Preamble, PresenceActorInfo, PresenceClock, PresenceStore, STATE_SHAPES, type ShapeDef, type SplitSource, SupportTier, applyEdit, applyEdits, canonicalShape, changedItems, classGrammar, createDiagramToolProvider, createLineAdapter, createPassthroughAdapter, describeDiagram, detectFamily, detectFamilyFromHeader, diagramShapes, diagramSupportsGroups, draftFrames, emptyMeta, erGrammar, findMermaidSources, flowchartAdapter, formatChain, formatLink, formatNode, getDiagramAdapter, isMetaEmpty, mergeMeta, parseAttributes, parseChain, parseFlowchartSource, parseLink, parseMembers, parseMermaid, parseStatement, planDiagramEdit, planDiagramEdits, quoteLabelIfNeeded, registerDiagramAdapter, relationFor, resolveShape, serializeMermaid, serializeMeta, splitSource, splitStatements, stateGrammar, supportTierOf, validateDiagramEdit };
+export { ARCH_METRICS, AdapterParseContext, type ArchSide, type ArchitectureStatement, ArrowHead, type BaseStatement, type C4Statement, C4_METRICS, CLASS_RELATIONS, type Chain, type ClassMember, type ClassRelation, Diagnostic, type DiagramActionResult, DiagramAdapter, DiagramController, type DiagramControllerOptions, type DiagramDataError, DiagramDirector, type DiagramDirectorOptions, DiagramFamily, DiagramGraph, DiagramMeta, type DiagramPerformanceResult, type DiagramPerformanceStep, type DiagramPlacement, type DiagramState, type DiagramToolProviderOptions, type DraftOptions, EDITABLE_DIAGRAM_FAMILIES, ER_CARDINALITIES, ER_PATTERNS, type EdgeKindOption, EdgePattern, type EdgeSpec, type EditContext, EditOp, type ErAttribute, FAMILY_BLANKS, FAMILY_DESCRIPTIONS, FAMILY_TEMPLATES, FAMILY_TITLES, FLOWCHART_SHAPES, type FamilyLayout, type FamilyLayoutOptions, type FamilyUI, type FieldDescription, type FieldSpec, type FlowStatement, type FlowchartBody, type FlowchartDocument, type FoundMermaid, GANTT_CONFIG_KEYS, GANTT_METRICS, GANTT_TAGS, type GanttConfig, type GanttStatement, type GanttTask, type GitStatement, type GraphBuildContext, GraphEdge, GraphGroup, GraphNode, type JourneyStatement, type JourneyTask, type LayoutResult, type LineBody, type LineDocument, type LineGrammar, type LineStatement, type LinkRef, type LinkSpec, META_COMMENT_PREFIX, META_FRONTMATTER_KEY, MermaidDocument, MetaCarrier, type MindmapForm, type MindmapStatement, type NodeDecl, type NodeRef, POINT_BOX, type ParseOptions, type PassthroughBody, type PieStatement, Point, Preamble, PresenceActorInfo, PresenceClock, PresenceStore, QUADRANT_METRICS, type QuadrantChartStatement, type QuadrantGeometry, type QuadrantSpace, RADAR_CHART_BOX, type RadarStatement, SEQUENCE_METRICS, STATE_SHAPES, type SankeyData, type SankeyLink, type SankeyParse, type SequenceEvent, type SequenceStatement, type ShapeDef, type ShapeOption, type Size, type SplitSource, type StatementBody, type StatementDocument, type StatementGrammar, SupportTier, type TimelinePeriod, type TimelineStatement, type TreemapData, type TreemapItem, type TreemapParse, XY_CHART_BOX, type XySeriesKind, type XyStatement, afterIds, applyEdit, applyEdits, applyStatementEdit, architectureAdapter, architectureArrow, architectureEdgeRoute, architectureGrammar, architectureLayout, architectureUI, c4Adapter, c4ArrowHead, c4BoundaryText, c4ElementGeometry, c4ElementType, c4Grammar, c4Layout, c4RelGeometry, c4Stereotype, c4UI, canonicalShape, changedItems, checkFieldData, classGrammar, classUI, createDiagramToolProvider, createLineAdapter, createPassthroughAdapter, createStatementAdapter, describeDiagram, describeFields, detectFamily, detectFamilyFromHeader, diagramShapes, diagramSupportsDirection, diagramSupportsGroups, draftFrames, dropMetaKeys, emptyMeta, erGrammar, erUI, familyUI, filterInPlace, findMermaidSources, flowchartAdapter, flowchartUI, formatAxis, formatChain, formatGanttDate, formatLink, formatNode, ganttAdapter, ganttGeometry, ganttGrammar, ganttUI, getDiagramAdapter, getFamilyLayout, gitGraphAdapter, gitGraphGrammar, gitGraphUI, indentOf, isMetaEmpty, journeyAdapter, journeyGrammar, journeyLayout, journeyUI, mergeMeta, mindmapAdapter, mindmapGrammar, mindmapUI, parseAttributes, parseChain, parseFlowchartSource, parseGanttDate, parseLink, parseMembers, parseMermaid, parseSankey, parseStatement, parseStatementDocument, parseTreemap, pickFieldData, pieAdapter, pieGrammar, pieUI, planDiagramEdit, planDiagramEdits, pointCentre, pointPosition, positionToData, quadrantAdapter, quadrantGeometry, quadrantGrammar, quadrantSpace, quadrantUI, quote, quoteLabelIfNeeded, radarAdapter, radarGrammar, radarUI, registerDiagramAdapter, registerFamilyLayout, relationFor, renameMetaKey, resolveShape, sequenceAdapter, sequenceGeometry, sequenceGrammar, sequenceUI, serializeMermaid, serializeMeta, serializeStatementDocument, serviceLabelLines, sharedFrameLayout, slugId, spaceInput, splitOutsideQuotes, splitSource, splitStatements, stateGrammar, stateUI, supportTierOf, timelineAdapter, timelineGrammar, timelineLayout, timelineUI, treemapValue, uniqueId, unquote, validateDiagramEdit, xyChartAdapter, xyChartGrammar, xyChartUI };