@dskripchenko/flow 0.0.0-stage → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,767 @@
+export declare type Alignment = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
+
+/** Aligns the boxes' edges or centres; returns a move command (or null for < 2 nodes). */
+export declare function alignNodes(boxes: ReadonlyMap<string, NodeBox>, ids: readonly string[], how: Alignment): Command | null;
+
+export declare interface Anchor {
+    point: Point;
+    side: PortSide;
+}
+
+/** Applies a command; returns a new graph and leaves the old one untouched. */
+export declare function applyCommand(graph: Graph, command: Command): Graph;
+
+export declare const approximateMeasurer: TextMeasurer;
+
+/** The delay after `failures` errors in a row. */
+export declare function backoffDelay(intervalMs: number, failures: number, backoff?: BackoffOptions | false): number;
+
+/**
+ * A framework-agnostic poller: calls `fetch` every `intervalMs`, pauses while
+ * the page is hidden, backs off after errors, and aborts the request in
+ * flight on stop. One request at a time; the next one is scheduled after the
+ * previous settles, so a slow endpoint is never hit twice at once.
+ */
+export declare interface BackoffOptions {
+    /** Multiplier per consecutive failure; 2 by default. */
+    factor?: number;
+    /** Upper bound of the delay; 60 s by default. */
+    maxMs?: number;
+}
+
+/** A cubic Bézier point, for the label of a direct spline. */
+export declare function bezierPoint(p0: Point, p1: Point, p2: Point, p3: Point, t: number): Point;
+
+/** Everything drawn: nodes, edge bends and labels, frames. */
+export declare function boundsOf(nodes: Map<string, NodeBox>, edges: Map<string, EdgeGeometry>, groups: Map<string, NodeBox>, outsideLabels?: number): GraphLayout['bounds'];
+
+export declare const BUILTIN_TYPES: Readonly<Record<string, NodeTypeDef>>;
+
+/** Built-in node types; any other string is a custom type from a registry. */
+export declare type BuiltinNodeType = 'start' | 'end' | 'state' | 'task' | 'decision' | 'subprocess' | 'note';
+
+/** Pans so that a graph point sits in the screen centre, keeping the zoom. */
+export declare function centreOn(v: Viewport, p: Point, width: number, height: number): Viewport;
+
+export declare function clampZoom(k: number, limits?: ZoomLimits): number;
+
+export declare type Command = {
+    type: 'addNodes';
+    nodes: FlowNode[];
+    edges?: FlowEdge[];
+} | {
+    type: 'removeElements';
+    ids: string[];
+} | {
+    type: 'updateNode';
+    id: string;
+    patch: Patch<Omit<FlowNode, 'id'>>;
+} | {
+    type: 'moveNodes';
+    moves: {
+        id: string;
+        position: Point;
+    }[];
+} | {
+    type: 'addEdge';
+    edge: FlowEdge;
+} | {
+    type: 'updateEdge';
+    id: string;
+    patch: Patch<Omit<FlowEdge, 'id'>>;
+} | {
+    type: 'setEnabled';
+    kind: Exclude<ElementKind, 'group'>;
+    id: string;
+    enabled: boolean;
+} | {
+    type: 'addGroup';
+    group: FlowGroup;
+} | {
+    type: 'updateGroup';
+    id: string;
+    patch: Patch<Omit<FlowGroup, 'id'>>;
+} | {
+    type: 'updateMeta';
+    patch: Record<string, unknown>;
+} | {
+    type: 'replace';
+    graph: Graph;
+} | {
+    type: 'batch';
+    commands: Command[];
+};
+
+/** Thrown when a command does not fit the graph (unknown id, duplicate id…). */
+export declare class CommandError extends Error {
+    readonly name = "CommandError";
+}
+
+/**
+ * Copies the selected nodes, with positions from the layout, and the edges
+ * whose both ends are selected (plus selected edges between them).
+ */
+export declare function copyFragment(graph: Graph, selected: Iterable<string>, layout?: GraphLayout): Fragment;
+
+export declare function createPoller<T>(options: PollerOptions<T>): Poller;
+
+/** A registry with the built-in types plus `custom` (which may override them). */
+export declare function createRegistry(custom?: Record<string, NodeTypeDef>): NodeTypeRegistry;
+
+/** Data values a node or an edge carries for the host: shown as key/value. */
+export declare type DataValue = string | number | boolean | null | DataValue[] | {
+    [key: string]: DataValue;
+};
+
+export declare const DEFAULT_LIMITS: ZoomLimits;
+
+export declare const defaultRegistry: NodeTypeRegistry;
+
+/** A short human description of a command, for undo tooltips and logs. */
+export declare function describeCommand(c: Command): string;
+
+export declare const DESCRIPTION_FONT: FontSpec;
+
+export declare type Direction = 'TB' | 'LR';
+
+/** Distance from a point to a polyline: hit testing edges in the editor. */
+export declare function distanceToPolyline(p: Point, points: readonly Point[]): number;
+
+/** Spaces the boxes evenly between the outermost two (gaps, not centres). */
+export declare function distributeNodes(boxes: ReadonlyMap<string, NodeBox>, ids: readonly string[], axis: 'horizontal' | 'vertical'): Command | null;
+
+export declare const EDGE_FONT: FontSpec;
+
+export declare interface EdgeGeometry {
+    id: string;
+    d: string;
+    /** The polyline the path follows. */
+    points: Point[];
+    from: Anchor;
+    to: Anchor;
+    label?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        lines: string[];
+    };
+    selfLoop?: boolean;
+}
+
+export declare interface EdgeRunState {
+    count?: number;
+    traversed?: boolean;
+}
+
+export declare type ElementKind = 'node' | 'edge' | 'group';
+
+/** A reference to one element of a graph. */
+export declare interface ElementRef {
+    kind: ElementKind;
+    id: string;
+}
+
+/** An empty model. */
+export declare function emptyGraph(meta?: Graph['meta']): Graph;
+
+export declare function emptyMonitorState(): MonitorState;
+
+/**
+ * The side of `box` that faces `toward`. `prefer` biases ties to the flow's
+ * axis: in a TB layout an edge leaves through top/bottom unless the other
+ * end is clearly beside the node.
+ */
+export declare function facingSide(box: NodeBox, toward: Point, prefer: 'vertical' | 'horizontal'): PortSide;
+
+/**
+ * The centre nearest to `near` where a box of `size` overlaps no box in
+ * `boxes` (with `padding`), searching outward ring by ring on the grid.
+ * Used to place nodes added from the palette.
+ */
+export declare function findFreeSpot(boxes: Iterable<NodeBox>, size: {
+    width: number;
+    height: number;
+}, near: Point, options?: FreeSpotOptions): Point;
+
+/**
+ * The viewport that shows `bounds` whole and centred in a `width × height`
+ * screen with `padding`; never zooms in beyond `maxFit` (small graphs stay
+ * at a readable size instead of blowing up).
+ */
+export declare function fitView(bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, width: number, height: number, padding?: number, limits?: ZoomLimits, maxFit?: number): Viewport;
+
+export declare interface FlowEdge {
+    id: string;
+    from: string;
+    to: string;
+    fromPort?: string;
+    toPort?: string;
+    label?: string;
+    /** A guard or condition, shown in the details and, when there is no label, on the edge. */
+    condition?: string;
+    enabled?: boolean;
+    /** `association` is a dashed line without an arrow (a note to its node). */
+    kind?: 'transition' | 'association';
+    data?: Record<string, DataValue>;
+}
+
+export declare interface FlowGroup {
+    id: string;
+    label?: string;
+    /** The enclosing group. */
+    parent?: string;
+}
+
+export declare interface FlowNode {
+    id: string;
+    type: NodeType;
+    label?: string;
+    /** The node's centre. Nodes without one are placed by the auto layout. */
+    position?: Point;
+    /** The group (frame) the node sits in. */
+    group?: string;
+    data?: Record<string, DataValue>;
+    /** `false` disables the node: drawn dimmed and struck through. Enabled by default. */
+    enabled?: boolean;
+    /**
+     * The node's own process: an inline graph, or a reference the host resolves
+     * (`subgraphs` prop or `loadSubgraph`). Makes the node drillable.
+     */
+    subgraph?: string | Graph;
+    /** Overrides the type's ports. */
+    ports?: Port[];
+    /** A short secondary line under the label. */
+    description?: string;
+}
+
+/**
+ * Text sizes without a DOM. Layout must be deterministic and run in Node, so
+ * the default measurer is a glyph-class table; a browser host may pass a
+ * canvas measurer for a tighter fit (the Vue component does).
+ */
+export declare interface FontSpec {
+    size: number;
+    weight?: number;
+}
+
+/** What the editor's clipboard holds: nodes and the edges among them. */
+export declare interface Fragment {
+    kind: 'dskripchenko-flow/fragment';
+    version: 1;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+}
+
+/** A group frame around its member nodes and nested groups. */
+export declare function frameAround(groupId: string, graph: Graph, nodes: Map<string, NodeBox>, pad?: number, title?: number): NodeBox | undefined;
+
+export declare interface FreeSpotOptions {
+    /** Snap candidates to this grid (0: no snapping). */
+    grid?: number;
+    /** Clear space kept around other nodes. */
+    padding?: number;
+    /** Give up after this many rings of candidates. */
+    maxRings?: number;
+}
+
+export declare interface Graph {
+    version: typeof GRAPH_VERSION;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    groups?: FlowGroup[];
+    meta?: GraphMeta;
+}
+
+/** The model format this package reads and writes. */
+export declare const GRAPH_VERSION = 1;
+
+export declare class GraphError extends Error {
+    /** Where in the input, as a JSON pointer. */
+    readonly pointer: string;
+    readonly name = "GraphError";
+    constructor(message: string, 
+    /** Where in the input, as a JSON pointer. */
+    pointer?: string);
+}
+
+export declare interface GraphLayout {
+    direction: Direction;
+    routing: Routing;
+    nodes: Map<string, NodeGeometry>;
+    edges: Map<string, EdgeGeometry>;
+    groups: Map<string, GroupGeometry>;
+    /** Waypoints the layered layout chose, by edge; valid while both ends stay put. */
+    waypoints: Map<string, Point[]>;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+
+export declare interface GraphMeta {
+    title?: string;
+    /** Auto-layout direction; `LR` by default. */
+    direction?: 'TB' | 'LR';
+    [key: string]: DataValue | undefined;
+}
+
+export declare interface GroupGeometry extends NodeBox {
+    id: string;
+    label?: string;
+}
+
+declare class History_2 {
+    private current;
+    private past;
+    private future;
+    private readonly limit;
+    private readonly mergeWindow;
+    private readonly now;
+    constructor(current: Graph, options?: HistoryOptions);
+    get graph(): Graph;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** The entry `undo` would revert. */
+    get last(): HistoryEntry | undefined;
+    get next(): HistoryEntry | undefined;
+    /** Applies a command and records it. Throws CommandError and records nothing when it does not apply. */
+    execute(command: Command, mergeKey?: string): Graph;
+    undo(): HistoryEntry | undefined;
+    redo(): HistoryEntry | undefined;
+    /**
+     * Takes a graph from outside (the host changed the model). When it is the
+     * one history already holds, nothing happens; otherwise history restarts.
+     */
+    reset(graph: Graph): void;
+    /** Ends merging: the next command starts a new entry even with the same key. */
+    seal(): void;
+}
+export { History_2 as History }
+
+export declare interface HistoryEntry {
+    command: Command;
+    before: Graph;
+    after: Graph;
+    /** Entries with the same key in a row merge into one (a drag, arrow nudges). */
+    mergeKey?: string;
+    at: number;
+}
+
+export declare interface HistoryOptions {
+    /** Entries kept; 200 by default. */
+    limit?: number;
+    /** Merge window for entries with the same `mergeKey`, ms; 800 by default. */
+    mergeWindowMs?: number;
+    now?: () => number;
+}
+
+/** `enabled` treats a missing flag as enabled. */
+export declare function isEnabled(el: {
+    enabled?: boolean;
+}): boolean;
+
+export declare function isFragment(v: unknown): v is Fragment;
+
+/** Whether the editor must leave a node alone (its type is locked). */
+export declare function isLocked(registry: NodeTypeRegistry, node: FlowNode): boolean;
+
+/**
+ * Whether the state is too old to trust: nothing received for `staleAfterMs`.
+ * A state that never received anything is not stale (it is loading).
+ */
+export declare function isStale(state: MonitorState | undefined, now: number, staleAfterMs: number): boolean;
+
+export declare interface Issue {
+    severity: IssueSeverity;
+    code: IssueCode;
+    message: string;
+    /** The element the issue is about, when there is one. */
+    target?: {
+        kind: ElementKind;
+        id: string;
+    };
+}
+
+export declare type IssueCode = 'duplicate-id' | 'unknown-node' | 'unknown-port' | 'unknown-group' | 'group-cycle' | 'unknown-type' | 'missing-start' | 'missing-end' | 'start-incoming' | 'end-outgoing' | 'unreachable' | 'dead-end' | 'empty-label';
+
+/** Issues grouped by element id, for highlighting. */
+export declare function issuesByElement(issues: readonly Issue[]): Map<string, Issue[]>;
+
+export declare type IssueSeverity = 'error' | 'warning';
+
+/** Whether a graph-space box is (mostly) inside the visible area. */
+export declare function isVisible(v: Viewport, box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, width: number, height: number, margin?: number): boolean;
+
+export declare const LABEL_FONT: FontSpec;
+
+/** Fixes every node where a layout put it: auto layout as one undoable command. */
+export declare function layoutCommand(layout: GraphLayout): Command;
+
+/**
+ * Errors of the layered layout. Copied from @dskripchenko/diagrams
+ * (src/core/errors.ts) together with the layout; the name stays so that a
+ * later switch to the diagrams export changes nothing for callers.
+ */
+export declare class LayoutError extends Error {
+    readonly line: number;
+    readonly column: number;
+    readonly hint?: string | undefined;
+    readonly name = "DiagramError";
+    constructor(message: string, line?: number, column?: number, hint?: string | undefined);
+}
+
+/** Lays out a graph. */
+export declare function layoutGraph(graph: Graph, options?: LayoutOptions): GraphLayout;
+
+export declare interface LayoutOptions {
+    /** `LR` by default (or the model's `meta.direction`). */
+    direction?: Direction;
+    routing?: Routing;
+    registry?: NodeTypeRegistry;
+    measure?: TextMeasurer;
+    /** Ignore the model's positions and lay out everything. */
+    ignorePositions?: boolean;
+    /** Space between neighbouring nodes in a rank, and between ranks. */
+    nodeSep?: number;
+    rankSep?: number;
+    /** Extra room beside edge labels (the monitoring counter pill). */
+    edgeLabelExtra?: number;
+}
+
+export declare const MAX_EDGES = 2000;
+
+export declare const MAX_NODES = 500;
+
+export declare function measureEdgeLabel(e: FlowEdge, measure: TextMeasurer, extra?: number): {
+    width: number;
+    height: number;
+    lines: string[];
+} | undefined;
+
+/** A node's size and wrapped label, before it is placed. */
+export declare function measureNode(node: FlowNode, registry: NodeTypeRegistry, measure: TextMeasurer): Omit<NodeGeometry, 'x' | 'y'>;
+
+/** Folds a snapshot into a state: the shorthand for the common case. */
+export declare function mergeSnapshot(state: MonitorState | undefined, snapshot: MonitorSnapshot, at?: number, merge?: boolean): MonitorState;
+
+/** The point halfway along a polyline: where a label goes without a layout hint. */
+export declare function midpoint(points: readonly Point[]): Point;
+
+export declare type MonitorAction = 
+/** Replaces everything with the snapshot (`merge: false`, the default) or merges into it. */
+    {
+    type: 'snapshot';
+    snapshot: MonitorSnapshot;
+    at: number;
+    merge?: boolean;
+} | {
+    type: 'error';
+    error: string;
+    at: number;
+} | {
+    type: 'reset';
+};
+
+/** One snapshot from the host: the JSON a monitoring endpoint returns. */
+export declare interface MonitorSnapshot {
+    nodes?: Record<string, NodeRunState>;
+    edges?: Record<string, EdgeRunState>;
+    /** The current instance's path: node ids in the order visited. */
+    path?: string[];
+    /** Nodes the current instance is in now. */
+    current?: string[];
+    /** When the host produced the snapshot (ISO or epoch ms). */
+    updatedAt?: string | number;
+}
+
+export declare interface MonitorState extends Required<Pick<MonitorSnapshot, 'nodes' | 'edges'>> {
+    path?: string[];
+    current?: string[];
+    /** Epoch ms of the last snapshot received. */
+    receivedAt?: number;
+    /** Epoch ms the host stamped on the last snapshot, if it did. */
+    updatedAt?: number;
+    /** The last polling error, cleared by the next snapshot. */
+    error?: string;
+    /** Errors in a row. */
+    failures: number;
+}
+
+/** The node nearest to `from` in a direction: arrow-key navigation. */
+export declare function nearestInDirection(from: Point, candidates: Iterable<{
+    id: string;
+    x: number;
+    y: number;
+}>, dir: 'up' | 'down' | 'left' | 'right'): string | undefined;
+
+/** A fresh id with a prefix: `state-3`. */
+export declare function nextId(graph: Graph, prefix: string, taken?: Set<string>): string;
+
+export declare interface NodeBox {
+    /** Centre. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare interface NodeGeometry extends NodeBox {
+    id: string;
+    lines: string[];
+    descriptionLines: string[];
+}
+
+export declare interface NodeRunState {
+    status?: NodeStatus;
+    /** How many instances are in (or went through) the node. */
+    count?: number;
+    /** A short text or number on the node's corner (e.g. an error count). */
+    badge?: string | number;
+    /** A line for the details panel (e.g. the last error). */
+    message?: string;
+    /** ISO string or epoch milliseconds. */
+    updatedAt?: string | number;
+}
+
+/** Outlines the built-in renderer can draw. */
+export declare type NodeShape = 'rect' | 'rounded' | 'circle' | 'ring' | 'diamond' | 'note' | 'pill';
+
+/** Built-in statuses; any other string is shown as a neutral status. */
+export declare type NodeStatus = 'active' | 'done' | 'error' | 'waiting' | 'skipped' | (string & {});
+
+export declare type NodeType = BuiltinNodeType | (string & {});
+
+export declare interface NodeTypeDef {
+    /** The type's name in the UI (palette, details). */
+    title: string;
+    shape: NodeShape;
+    /** A fixed size; otherwise the label decides the width between min and max. */
+    size?: {
+        width: number;
+        height: number;
+    };
+    minWidth?: number;
+    maxWidth?: number;
+    /** Minimum height; grows with wrapped label lines. */
+    height?: number;
+    /** Default ports; without them edges attach where they meet the outline. */
+    ports?: Port[];
+    /** An icon name the renderer maps to a glyph (`play`, `square`, `cog`, …). */
+    icon?: string;
+    /** The label is drawn outside the outline (start/end circles). */
+    labelOutside?: boolean;
+    /** Edges cannot end here (`start`) or start here (`end`). */
+    noIncoming?: boolean;
+    noOutgoing?: boolean;
+    /** Not part of the flow: no reachability or dead-end checks (`note`). */
+    annotation?: boolean;
+    /** The editor does not let a user change or delete nodes of this type. */
+    locked?: boolean;
+    /** The node can be drilled into (gets a "subgraph" field in the editor). */
+    drillable?: boolean;
+}
+
+export declare type NodeTypeRegistry = ReadonlyMap<string, NodeTypeDef>;
+
+/**
+ * Reads a model from parsed JSON (or a JSON string). Fills defaults, drops
+ * unknown fields of nodes and edges, and throws `GraphError` with a JSON
+ * pointer when the shape is wrong.
+ */
+export declare function parseGraph(input: unknown, at?: string): Graph;
+
+/**
+ * The command that pastes a fragment with fresh ids, shifted by `offset`
+ * (or centred on `at`). Returns the new node ids for the selection.
+ */
+export declare function pasteFragment(graph: Graph, fragment: Fragment, place?: {
+    offset?: Point;
+    at?: Point;
+}): {
+    command: Command;
+    ids: string[];
+};
+
+/** A patch sets fields; a field set to `null` is removed. */
+export declare type Patch<T> = {
+    [K in keyof T]?: T[K] | null;
+};
+
+/**
+ * The edges of a path: for each consecutive pair of nodes, the first enabled
+ * edge between them (then any edge). Pairs without an edge are skipped.
+ */
+export declare function pathEdges(graph: Graph, path: readonly string[] | undefined): string[];
+
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+export declare interface Poller {
+    start(): void;
+    stop(): void;
+    /** Fetches now (aborting a request in flight) and reschedules. */
+    refresh(): void;
+    readonly status: PollerStatus;
+    /** Errors in a row. */
+    readonly failures: number;
+    /** The delay before the next fetch, as scheduled now. */
+    readonly nextDelay: number;
+}
+
+export declare interface PollerOptions<T> {
+    fetch: (signal: AbortSignal) => Promise<T>;
+    intervalMs: number;
+    /** `false` keeps the interval after errors. On by default. */
+    backoff?: BackoffOptions | false;
+    /** Pause while the page is hidden (on by default); or a custom source. */
+    visibilityPause?: boolean | VisibilitySource;
+    onData?: (data: T) => void;
+    onError?: (error: unknown, failures: number) => void;
+    /** Fetch at start instead of after the first interval (default true). */
+    immediate?: boolean;
+}
+
+export declare type PollerStatus = 'idle' | 'running' | 'paused';
+
+/** A named connection point on a node's side. */
+export declare interface Port {
+    id: string;
+    side: PortSide;
+    /** Position along the side, 0…1 from its start (left or top); 0.5 by default. */
+    offset?: number;
+    /** `in` takes incoming edges only, `out` outgoing only; both by default. */
+    kind?: 'in' | 'out' | 'both';
+    label?: string;
+}
+
+export declare type PortSide = 'top' | 'right' | 'bottom' | 'left';
+
+/** The ports a node offers: its own, else its type's. */
+export declare function portsOf(registry: NodeTypeRegistry, node: FlowNode): readonly Port[];
+
+/** The pure reducer. Never mutates `state`. */
+export declare function reduceMonitor(state: MonitorState, action: MonitorAction): MonitorState;
+
+export declare function route(input: RouteInput): RoutedPath;
+
+declare interface RouteContext {
+    direction: Direction;
+    routing: Routing;
+    registry: NodeTypeRegistry;
+    waypoints: Map<string, Point[]>;
+    labelAt: Map<string, Point>;
+    labels: Map<string, {
+        width: number;
+        height: number;
+        lines: string[];
+    } | undefined>;
+    /** Group frames: back-edge channels keep their drops out of foreign groups. */
+    groups?: ReadonlyMap<string, NodeBox>;
+}
+
+export declare interface RoutedPath {
+    /** SVG path data. */
+    d: string;
+    /** The polyline the path follows (anchors, stubs and bends): for hit tests and the label. */
+    points: Point[];
+}
+
+/**
+ * Routes edges between placed nodes. Anchors on one side of a rectangular
+ * node are spread along it so parallel edges do not merge.
+ */
+export declare function routeEdges(graph: Graph, nodes: Map<string, NodeGeometry | NodeBox>, ctx: RouteContext, only?: Set<string>): Map<string, EdgeGeometry>;
+
+export declare interface RouteInput {
+    from: Anchor;
+    to: Anchor;
+    /** Bends between the anchors (from the layered layout), in order. */
+    waypoints?: readonly Point[];
+    routing: Routing;
+    /** Corner radius for orthogonal routes. */
+    radius?: number;
+}
+
+export declare type Routing = 'spline' | 'orthogonal';
+
+export declare function sideNormal(side: PortSide): Point;
+
+/** A point on a box side, `offset` 0…1 along it (left→right, top→bottom). */
+export declare function sidePoint(box: NodeBox, side: PortSide, offset?: number): Point;
+
+/** Snaps a point to a grid. */
+export declare function snap(p: Point, grid: number): Point;
+
+/** Built-in statuses and the kit tone each is drawn with. */
+export declare const STATUS_TONES: Readonly<Record<string, 'accent' | 'success' | 'danger' | 'warning' | 'info' | 'neutral'>>;
+
+/** Counts of nodes by status: the summary line of a monitor. */
+export declare function statusSummary(state: MonitorState | undefined): Record<string, number>;
+
+/** The model as stable JSON text (2-space indent). */
+export declare function stringifyGraph(graph: Graph): string;
+
+export declare type TextMeasurer = (text: string, font: FontSpec) => number;
+
+export declare function toEpoch(v: string | number | undefined): number | undefined;
+
+export declare function toGraph(v: Viewport, p: Point): Point;
+
+export declare function toScreen(v: Viewport, p: Point): Point;
+
+/** The definition for a node's type; an unknown type is drawn as a state. */
+export declare function typeOf(registry: NodeTypeRegistry, type: string): NodeTypeDef;
+
+/** All issues of a graph, errors first, then in model order. */
+export declare function validateGraph(graph: Graph, options?: ValidateOptions): Issue[];
+
+export declare interface ValidateOptions {
+    registry?: NodeTypeRegistry;
+    /** Report a missing start/end node (on by default; off for fragments). */
+    requireStartEnd?: boolean;
+}
+
+export declare interface Viewport {
+    x: number;
+    y: number;
+    /** Zoom factor. */
+    k: number;
+}
+
+/** Where the poller learns about page visibility; the document by default. */
+export declare interface VisibilitySource {
+    hidden(): boolean;
+    subscribe(listener: () => void): () => void;
+}
+
+/**
+ * Splits text into lines no wider than `max`, at spaces; a word longer than
+ * a line is cut with an ellipsis. At most `maxLines` lines; the last one
+ * ends with "…" when text is left over.
+ */
+export declare function wrapText(text: string, max: number, font: FontSpec, measure: TextMeasurer, maxLines?: number): string[];
+
+/** Zooms by `factor` keeping the graph point under `at` (screen) in place. */
+export declare function zoomAt(v: Viewport, factor: number, at: Point, limits?: ZoomLimits): Viewport;
+
+export declare interface ZoomLimits {
+    min: number;
+    max: number;
+}
+
+export { }