@kolosal-ai/rivet 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1012 @@
+import { R as Rect, V as Vec2, A as AlignmentGuide, E as EdgeChange, a as RivetEdge, b as NodeChange, c as RivetNode, N as NodeId, d as NodeProps, e as NodeTypes, f as HandleType, H as HandlePosition, S as Size, g as Viewport, h as EdgeTypes, D as DefaultEdgeOptions, i as EdgeRendererFactory, j as SwimlaneGroup, k as SwimlaneMargin, l as SwimlaneHeaderProps, m as SwimlaneLabelProps, n as SwimlaneSizeChange, L as LaneChange, C as Connection, o as RivetSelection, p as EdgeId, q as HandleRecord, r as ReconnectDelegate, P as PendingConnection, s as RivetControls, t as RivetSnapshot, u as EdgeRenderer, v as EdgeRendererOptions, w as EdgeDrawExtras, x as EdgeEnd, y as EdgePathFn } from './types-B8AAJ60T.js';
+export { z as CenterNodeOptions, B as EdgeMarker, F as EdgePath, G as EdgePathParams, I as EdgeStyle, J as FitViewOptions, K as NodeComponent } from './types-B8AAJ60T.js';
+import { ReactNode, CSSProperties, MouseEvent, RefObject } from 'react';
+import { b as AnchorOptions, d as AnchorRecord, f as AnchorRegistrationOptions, R as ResolvedAnchorOptions, e as AnchorRegistration } from './registry-Dkk4ZKt-.js';
+import { ResolvedLane, ViewportElements, ResolvedSwimlaneGroup, ResolvedMargin } from './swimlane/index.js';
+
+/**
+ * Find the closest edge alignment between the moving rect and any static rect,
+ * within `threshold` (world units), independently per axis. Returns the offset
+ * to apply to `moving` so its aligned edge lands exactly on the neighbor's, plus
+ * the guide line(s) to draw. Pure — the drag loop supplies the rects.
+ */
+declare function alignRect(moving: Rect, statics: readonly Rect[], threshold: number): {
+    offset: Vec2;
+    guides: AlignmentGuide[];
+};
+
+/**
+ * Apply a batch of {@link NodeChange}s to a nodes array, returning a new array
+ * (the input is not mutated). Order is preserved; added nodes are appended.
+ *
+ * Pair this with the graph's `onNodesChange` to run controlled mode:
+ * ```ts
+ * const [nodes, setNodes] = useState(initial)
+ * <Rivet nodes={nodes} onNodesChange={(c) => setNodes((ns) => applyNodeChanges(c, ns))} />
+ * ```
+ */
+declare function applyNodeChanges<TData = unknown>(changes: NodeChange<TData>[], nodes: RivetNode<TData>[]): RivetNode<TData>[];
+/**
+ * Apply a batch of {@link EdgeChange}s to an edges array, returning a new array.
+ * Order is preserved; added edges are appended. See {@link applyNodeChanges}.
+ */
+declare function applyEdgeChanges<TData = unknown>(changes: EdgeChange<TData>[], edges: RivetEdge<TData>[]): RivetEdge<TData>[];
+
+/** Options for {@link cloneElements}. */
+type CloneOptions = {
+    /**
+     * World-space offset applied to every top-level clone's position. Children of
+     * a copied parent keep their parent-relative position and ride along.
+     * Default `{0,0}`.
+     */
+    offset?: Vec2;
+    /** Id generator for the clones. Default `crypto.randomUUID`. */
+    makeId?: () => NodeId;
+};
+/** The result of {@link cloneElements}: fresh nodes and their internal edges. */
+type ClonedElements<TNodeData = unknown, TEdgeData = unknown> = {
+    nodes: RivetNode<TNodeData>[];
+    edges: RivetEdge<TEdgeData>[];
+};
+/**
+ * Clone a set of nodes (and the edges wholly between them) with fresh ids —
+ * the core of copy/paste and duplicate. Edges are kept only when **both**
+ * endpoints are in the set (dangling connections to un-copied nodes are
+ * dropped). `parentId` is remapped when the parent is also copied, else cleared
+ * so the clone isn't orphaned to a missing parent. Transient flags are stripped;
+ * selecting the clones is the caller's job.
+ */
+declare function cloneElements<TNodeData = unknown, TEdgeData = unknown>(nodes: RivetNode<TNodeData>[], edges: RivetEdge<TEdgeData>[], options?: CloneOptions): ClonedElements<TNodeData, TEdgeData>;
+
+type ControlsProps = {
+    /** Show the zoom-in / zoom-out buttons (default true). */
+    showZoom?: boolean;
+    /** Show the fit-view button (default true). */
+    showFitView?: boolean;
+    /** Extra buttons appended after the defaults. */
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+};
+/** A small zoom / fit-view button panel. Must be a child of `<Rivet>`. */
+declare function Controls({ showZoom, showFitView, children, className, style, }: ControlsProps): React.ReactElement;
+
+/** Fallback node used when a node's `type` has no entry in `nodeTypes`. */
+declare function DefaultNode({ data, selected, hovered }: NodeProps): React.ReactElement;
+
+/**
+ * Built-in container node (`type: "group"`) — the visual basis for sub-flows.
+ * A styled region with no content or handles of its own; children point at it
+ * via `parentId` (and `extent: "parent"` to stay confined). Give it explicit
+ * `width`/`height` — a group has no intrinsic content to measure. Children
+ * render above it automatically (z-index follows nesting depth).
+ */
+declare function GroupNode({ data, selected, hovered }: NodeProps): React.ReactElement;
+/** The built-in node components, keyed by `type`. Consumer `nodeTypes` win. */
+declare const BUILTIN_NODE_TYPES: NodeTypes;
+
+type HandleProps = {
+    /**
+     * Whether this handle is a connection `source` or `target`. Optional — an
+     * untyped handle resolves to `"either"` and can start or receive a
+     * connection; a pair is valid when one end can source and the other can
+     * target. Set an explicit type to constrain direction.
+     */
+    type?: HandleType;
+    /**
+     * Distinguishes multiple handles on a node. Defaults to the resolved
+     * `position`, since each side of a node is unique. Set an explicit `id` when a
+     * node has several handles sharing one side.
+     */
+    id?: string;
+    position?: HandlePosition;
+    className?: string;
+    style?: CSSProperties;
+    /**
+     * Accessible name for the handle. Defaults to naming the handle and its node
+     * (e.g. `"right handle of node a"`) so a keyboard user tabbing across the
+     * graph can tell same-sided handles on different nodes apart.
+     */
+    ariaLabel?: string;
+};
+/**
+ * A connection point placed inside a node component. It measures its own
+ * position within the node (so edges anchor precisely) and starts a
+ * drag-to-connect gesture.
+ */
+declare function Handle({ type, id, position, className, style, ariaLabel, }: HandleProps): React.ReactElement;
+
+type MiniMapProps = {
+    width?: number;
+    height?: number;
+    nodeColor?: string;
+    selectedColor?: string;
+    /** Fill for the area outside the current viewport. */
+    maskColor?: string;
+    className?: string;
+    style?: CSSProperties;
+};
+/**
+ * An overview of the whole graph with a viewport indicator. Redraws on every
+ * canvas frame (via the store's frame channel) and recenters on click/drag.
+ * Must be a child of `<Rivet>`.
+ */
+declare function MiniMap({ width, height, nodeColor, selectedColor, maskColor, className, style, }: MiniMapProps): React.ReactElement;
+
+type NodeResizerProps = {
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    /** Lock the width/height ratio while resizing from a corner. */
+    keepAspectRatio?: boolean;
+    /** Handle color. */
+    color?: string;
+    /** Called on every resize step (live). */
+    onResize?: (size: Size, position: Vec2) => void;
+    /** Called once when the resize gesture ends. */
+    onResizeEnd?: (size: Size, position: Vec2) => void;
+};
+/**
+ * Drop inside a node component to make it resizable. Renders eight drag handles
+ * that write the node's explicit `width`/`height` (and move its origin for
+ * top/left handles) via {@link RivetStore.resizeNode} — so it works with
+ * controlled mode (emits dimension changes) and nested nodes alike.
+ */
+declare function NodeResizer({ minWidth, minHeight, maxWidth, maxHeight, keepAspectRatio, color, onResize, onResizeEnd, }: NodeResizerProps): React.ReactElement;
+
+/**
+ * Edge alignment — the library-level policy for when an edge's endpoints
+ * re-side to face the peer node.
+ *
+ * A handle chosen by the user (grabbed or dropped on) is *pinned*: rivet
+ * renders the edge exactly there. The alignment policy decides when geometry
+ * may override that pin. Under `"on-move"`, a committed position change of an
+ * endpoint node re-sides both ends of its edges toward each other — the user
+ * visibly changed the layout, so the pin yields. Nothing else triggers it:
+ * data replaces (description edits, history restores) and dimension echoes
+ * must never move an edge the user didn't touch or rewrite handles an undo
+ * just faithfully restored.
+ *
+ * The store performs the move and the re-side in one internal batch, so
+ * "move + realign = one undo step" holds by construction.
+ */
+
+/**
+ * When pinned edge endpoints re-side to face the peer node.
+ *
+ * - `"manual"` — never; a chosen handle is kept until the user reconnects.
+ * - `"on-move"` — on a committed position change of an endpoint node.
+ * - `"live"` — as `"on-move"`, plus: while an endpoint node is dragging, the
+ *   edge's pinned ends *render* as if auto — re-siding per frame to face each
+ *   other, with hysteresis — and the displayed sides commit on drop, inside
+ *   the move's history step. Nothing is persisted mid-gesture.
+ */
+type EdgeAlignment = "manual" | "on-move" | "live";
+/** The side of `node` that faces `peer`, by dominant center-to-center axis. */
+declare function facingSide(node: Rect, peer: Rect): HandlePosition;
+/**
+ * How much the losing axis must dominate before a per-frame resolved side
+ * switches axes: with a current horizontal side, the edge flips to top/bottom
+ * only once `|dy| > |dx| * ratio` (and symmetrically). `1` disables the band.
+ */
+declare const DEFAULT_ALIGNMENT_HYSTERESIS = 1.2;
+/**
+ * Per-frame side resolution with hysteresis. Without a `previous` side this is
+ * exactly {@link facingSide}; with one, the side keeps its current axis until
+ * the other axis dominates by `hysteresis`, so near-diagonal positions don't
+ * flicker between sides frame to frame. Within the kept axis the sign always
+ * tracks (a left↔right swap at a mostly-horizontal layout is a real crossing,
+ * not jitter — jitter near the diagonal is an axis change, which the band
+ * absorbs).
+ */
+declare function resolveFacingSide(node: Rect, peer: Rect, previous?: HandlePosition, hysteresis?: number): HandlePosition;
+
+/** Resolved graph context for a pane right-click, passed to `onPaneContextMenu`. */
+type PaneContextMenuContext = {
+    /** The click position in world coordinates (already unprojected). */
+    world: Vec2;
+    /** The swimlane lane whose body sits under the cursor, or `null`. */
+    lane: ResolvedLane | null;
+};
+type RivetProps = {
+    /**
+     * Nodes to seed the graph with (uncontrolled). Read once on mount to initialize
+     * the internal store — later changes to this array are ignored. Use {@link nodes}
+     * + {@link onNodesChange} for controlled mode instead. Defaults to `[]`.
+     */
+    defaultNodes?: RivetNode[];
+    /**
+     * Edges to seed the graph with (uncontrolled). See {@link defaultNodes}. An edge
+     * whose `source` or `target` node is absent is skipped by the renderer. Defaults to `[]`.
+     */
+    defaultEdges?: RivetEdge[];
+    /**
+     * Controlled nodes. When provided, the graph mirrors this array — hold the nodes
+     * in your own state and feed back the batches from {@link onNodesChange} (apply
+     * them with `applyNodeChanges`). Node drags are suppressed from reconciling
+     * mid-drag so the graph stays smooth. Takes precedence over {@link defaultNodes}.
+     */
+    nodes?: RivetNode[];
+    /** Controlled edges. See {@link nodes}. Takes precedence over {@link defaultEdges}. */
+    edges?: RivetEdge[];
+    /** Change batches the graph wants applied to your nodes (controlled mode). */
+    onNodesChange?: (changes: NodeChange[]) => void;
+    /** Change batches the graph wants applied to your edges (controlled mode). */
+    onEdgesChange?: (changes: EdgeChange[]) => void;
+    /**
+     * Initial pan/zoom. `x`/`y` are the screen-space offset in pixels and `zoom`
+     * is the scale factor. Defaults to `{ x: 0, y: 0, zoom: 1 }` (origin, 1:1).
+     */
+    defaultViewport?: Viewport;
+    /**
+     * Maps a node's `type` to the React component that renders it. A node whose
+     * `type` has no entry here (or no `type` at all) falls back to
+     * {@link DefaultNode}. Defaults to `{}`.
+     */
+    nodeTypes?: NodeTypes;
+    /**
+     * Registry of custom edge shapes, keyed by `edge.type`. Each is a pure geometry
+     * function (see {@link EdgePathFn}) so edges stay canvas/GPU-renderable. Merged
+     * over the built-ins `bezier` (default), `smoothstep`, `step`, and `straight`.
+     */
+    edgeTypes?: EdgeTypes;
+    /** Defaults merged into every edge that doesn't set the field (type, style, markers…). */
+    defaultEdgeOptions?: DefaultEdgeOptions;
+    /** Accessible name for the graph surface (`aria-label` on the pane). Defaults to "Node graph". */
+    ariaLabel?: string;
+    /**
+     * Backend factory for the edge layers — swap Canvas2D for another
+     * {@link EdgeRenderer}. Defaults to {@link canvas2DEdgeRenderer}. Pass a stable/memoized
+     * reference; a new identity re-creates the renderers.
+     */
+    renderer?: EdgeRendererFactory;
+    /**
+     * Lower bound on `viewport.zoom`. All zooming (wheel, controls, `fitView`) is
+     * clamped to this. Defaults to `0.2` (zoomed out to 20%).
+     */
+    minZoom?: number;
+    /**
+     * Upper bound on `viewport.zoom`. All zooming is clamped to this. Defaults to
+     * `2.5` (zoomed in to 250%).
+     */
+    maxZoom?: number;
+    /**
+     * Spacing in world units between background grid dots. The grid scales with
+     * zoom, so this is measured at `zoom === 1`. Defaults to `24`.
+     */
+    gridGap?: number;
+    /**
+     * Snap dragged nodes to a `[x, y]` world-unit grid. A `0` axis is left free.
+     * Omit (default) for free positioning. Independent of {@link gridGap} (the
+     * visual dot grid) — pass the same value to snap to the dots you see.
+     */
+    snapGrid?: [number, number];
+    /**
+     * While dragging a single node, show alignment guides and snap its edges/center
+     * to nearby nodes' edges/centers. Defaults to `false`.
+     */
+    alignmentGuides?: boolean;
+    /**
+     * Placement policy for anchor chrome — the grab dots and stray perimeter
+     * handles rivet renders for registered anchors (see {@link Anchor}). Omitted
+     * fields fall back to the defaults.
+     */
+    anchorOptions?: AnchorOptions;
+    /**
+     * Which mouse buttons pan when dragging the pane: `true` = left only, `false` =
+     * none, or a list of `MouseEvent.button` codes (`0` left, `1` middle, `2` right).
+     * e.g. `[1, 2]` pans with middle/right and frees left for selection. Defaults to
+     * `true`. Pass a stable reference; a new array identity re-binds the listeners.
+     */
+    panOnDrag?: boolean | number[];
+    /**
+     * Draw a selection marquee on a plain left-drag instead of panning. Pair with
+     * `panOnDrag={[1, 2]}` so left selects and middle/right pan. A marquee that
+     * ends over nodes leaves a persistent selection box around them — drag it to
+     * move the whole selection; a click elsewhere or Escape dismisses it.
+     * Defaults to `false`.
+     */
+    selectionOnDrag?: boolean;
+    /**
+     * Key(s) that force a marquee on a left-drag when held (e.g. `"Shift"`, `"Meta"`,
+     * or `["Shift", "Meta"]`). `null` disables. Defaults to `"Shift"`.
+     */
+    selectionKeyCode?: string | string[] | null;
+    /**
+     * Key(s) that make a click or marquee **add to** the selection instead of
+     * replacing it. Defaults to `["Meta", "Control", "Shift"]`. Use modifier keys
+     * (`Shift`/`Meta`/`Control`/`Alt`) — other keys only resolve during a pane drag.
+     */
+    multiSelectionKeyCode?: string | string[];
+    /**
+     * Pan the viewport on wheel / two-finger trackpad scroll instead of zooming.
+     * A pinch gesture (reported by the browser as ctrl+wheel) still zooms. When
+     * `false` (default), scrolling zooms toward the cursor.
+     */
+    scrollToPan?: boolean;
+    /**
+     * Wheel/pinch zoom sensitivity — larger zooms faster per scroll delta.
+     * Defaults to `0.0015`. Try `~0.003` for faster trackpad pinch zoom.
+     */
+    zoomSpeed?: number;
+    /**
+     * Swimlanes drawn behind the graph — a decorative background of labeled lane
+     * groups (like planout's swimlanes). Not nodes or edges; just layout regions.
+     * Omit for no swimlanes.
+     */
+    swimlane?: SwimlaneGroup[];
+    /**
+     * Bind node dragging to the swimlanes: on drop each node snaps fully inside
+     * one lane (honoring {@link swimlaneMargin}) and is reassigned to the lane it
+     * lands in via {@link RivetNode.laneId}. Defaults to `true` when
+     * {@link swimlane} is provided, `false` otherwise. Ignored with no swimlanes.
+     */
+    clampToSwimlane?: boolean;
+    /**
+     * Inner clearance kept between a clamped node and its lane's edges. A number
+     * applies to all sides; per-side values override it. Defaults to `16`.
+     */
+    swimlaneMargin?: number | SwimlaneMargin;
+    /** Screen height of the sticky group header band, in px. Defaults to `32`. */
+    swimlaneHeaderHeight?: number;
+    /**
+     * Show a resize handle on each lane's bottom edge to change its height.
+     * Defaults to `true` when {@link swimlane} is provided.
+     */
+    swimlaneResizable?: boolean;
+    /**
+     * Fraction of the last lane's height that must stay visible when scrolled to
+     * the bottom — the down-scroll stop. `0.5` (default) keeps half of it in view.
+     * Only applies when {@link clampToSwimlane} is on.
+     */
+    swimlaneBottomReveal?: number;
+    /** Render custom content for a group's sticky header (replaces the default). */
+    renderSwimlaneHeader?: (props: SwimlaneHeaderProps) => ReactNode;
+    /** Render custom content for a lane's sticky label (replaces the default). */
+    renderSwimlaneLabel?: (props: SwimlaneLabelProps) => ReactNode;
+    /**
+     * Called when a lane's height changes — from a resize drag or from auto-fit
+     * growing it to contain a node that grew. The graph owns lane heights, so this
+     * is a notification (persist it if you like), not a request to update state.
+     */
+    onSwimlaneSizeChange?: (change: SwimlaneSizeChange) => void;
+    /**
+     * Right-click on empty canvas (not over a node or swimlane chrome). The second
+     * argument carries the resolved graph context — the world position and the lane
+     * under the cursor — so you don't have to re-derive them.
+     */
+    onPaneContextMenu?: (event: MouseEvent, context: PaneContextMenuContext) => void;
+    /** Right-click on a lane's sticky label. */
+    onSwimlaneHeaderContextMenu?: (laneId: string, event: MouseEvent) => void;
+    /** Right-click on a group's sticky header. */
+    onSwimlaneGroupHeaderContextMenu?: (groupId: string, event: MouseEvent) => void;
+    /** Called when a dragged node is reassigned to a different lane. */
+    onLaneChange?: (change: LaneChange) => void;
+    /** Veto a proposed connection; return false to reject it. Applies to reconnection too. */
+    isValidConnection?: (connection: Connection) => boolean;
+    /**
+     * Rewrite a validated connection before it commits — normalize handle ids
+     * (e.g. redirect an in-content grab handle to its canonical perimeter
+     * handle), or force direction conventions. Returning `null` cancels the
+     * drop. Applies to new connections and reconnections; `isValidConnection`
+     * sees the raw connection, `onConnect`/`onReconnect` see the mapped one.
+     */
+    mapConnection?: (connection: Connection) => Connection | null;
+    /** Called after a valid connection is made (the edge is already added). */
+    onConnect?: (connection: Connection) => void;
+    /**
+     * Allow reconnecting edges by dragging an endpoint onto a new handle. Per-edge
+     * `reconnectable` overrides this. Defaults to `false`.
+     */
+    edgesReconnectable?: boolean;
+    /**
+     * When edge endpoints re-side to face the peer node. `"manual"` (default)
+     * never rewrites a chosen handle; `"on-move"` re-sides both ends of a moved
+     * node's edges when the move commits — in the same batch as the move, so one
+     * undo restores position and handles together. `"live"` additionally renders
+     * a dragging node's edges as if their ends were auto — re-siding per frame
+     * to face each other, with hysteresis so near-diagonal positions don't
+     * flicker — and commits the displayed sides on drop, inside the move's
+     * history step; nothing is persisted mid-gesture. Only committed position
+     * changes trigger a rewrite: data replaces and dimension changes never
+     * re-side, and a freshly created or reconnected edge keeps exactly the
+     * handles the user grabbed or dropped on. Anchor and bare-side ends rewrite
+     * their side directly; plain handles re-side to a registered handle of a
+     * compatible type on the facing side, or stay pinned when the node has none
+     * there. Independent of the policy, an end with *no* side — a missing
+     * handle, or an `anchorAutoHandleId` anchor end — always floats: the
+     * renderer resolves its facing side per frame and never writes it back.
+     */
+    edgeAlignment?: EdgeAlignment;
+    /** Called when an endpoint drag re-points an edge (the edge is already updated). */
+    onReconnect?: (edge: RivetEdge, connection: Connection) => void;
+    /** Called when an endpoint reconnection drag starts. */
+    onReconnectStart?: (edge: RivetEdge) => void;
+    /** Called when an endpoint reconnection drag ends (committed or cancelled). */
+    onReconnectEnd?: (edge: RivetEdge) => void;
+    /** Called whenever the selected nodes and/or edges change. */
+    onSelectionChange?: (selection: RivetSelection) => void;
+    /**
+     * Called when keyboard focus moves to a node (or leaves the graph — `null`).
+     * The same state is available inside `<Rivet>` via {@link useRivetFocusedNode}.
+     * Rivet draws no focus ring; use this (or the wrapper's `:focus-visible`) to
+     * render your own indicator.
+     */
+    onFocusChange?: (id: NodeId | null) => void;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+};
+/**
+ * The graph surface. Stacks a background grid canvas, an edge canvas, and a DOM
+ * node layer — all driven by one shared viewport (see {@link useRivetRuntime}).
+ */
+declare function Rivet({ defaultNodes, defaultEdges, nodes: controlledNodes, edges: controlledEdges, onNodesChange, onEdgesChange, defaultViewport, nodeTypes, edgeTypes, defaultEdgeOptions, ariaLabel, renderer, minZoom, maxZoom, gridGap, snapGrid, alignmentGuides, anchorOptions, panOnDrag, selectionOnDrag, selectionKeyCode, multiSelectionKeyCode, scrollToPan, zoomSpeed, swimlane, clampToSwimlane, swimlaneMargin, swimlaneHeaderHeight, swimlaneResizable, swimlaneBottomReveal, renderSwimlaneHeader, renderSwimlaneLabel, onSwimlaneSizeChange, onPaneContextMenu, onSwimlaneHeaderContextMenu, onSwimlaneGroupHeaderContextMenu, onLaneChange, isValidConnection, mapConnection, onConnect, edgesReconnectable, edgeAlignment, onReconnect, onReconnectStart, onReconnectEnd, onSelectionChange, onFocusChange, className, style, children, }: RivetProps): React.ReactElement;
+
+/** Composite key for the handle/anchor registries. */
+declare function handleKey(nodeId: NodeId, handleId: string): string;
+
+type RivetStoreInit = {
+    nodes: RivetNode[];
+    edges: RivetEdge[];
+    viewport: Viewport;
+};
+type ViewportClamp = {
+    minX: number;
+    minY: number;
+    maxY?: number;
+};
+type ChangeHandlers = {
+    nodes?: (changes: NodeChange[]) => void;
+    edges?: (changes: EdgeChange[]) => void;
+};
+/**
+ * The single source of truth for a graph instance — the public contract. It's an
+ * interface so consumers depend on the shape, not the implementation ({@link
+ * RivetGraphStore}); pure graph algorithms live in `graph.ts`.
+ *
+ * Subscriptions are deliberately granular so touching one node never re-renders
+ * the others:
+ *  - **per-node** channel — a `NodeWrapper` subscribes to only its own node, so
+ *    selecting/moving/measuring node A re-renders A alone.
+ *  - the `NodeLayer`'s list is driven by the culled `visibleIds` prop, so it
+ *    re-renders only when the visible set changes, never on node data.
+ *  - **viewport** and **frame** channels drive the canvas (and the label
+ *    layer's imperative positioning) without touching React at all.
+ */
+type RivetStore = {
+    readonly nodes: Map<NodeId, RivetNode>;
+    readonly edges: Map<EdgeId, RivetEdge>;
+    readonly handles: Map<string, HandleRecord>;
+    getNodeVersion: (id: NodeId) => number;
+    subscribeNode: (id: NodeId, listener: () => void) => () => void;
+    registerNodeElement: (id: NodeId, el: HTMLElement) => void;
+    unregisterNodeElement: (id: NodeId, el: HTMLElement) => void;
+    getNodeElement: (id: NodeId) => HTMLElement | undefined;
+    /**
+     * Register the controlled-mode change sinks. When set, node/edge mutations emit
+     * {@link NodeChange}/{@link EdgeChange} batches so a consumer can own the state.
+     * Emission is suppressed while {@link reconcile} is applying incoming props, so
+     * feeding changes back in never loops.
+     */
+    setChangeHandlers: (handlers: ChangeHandlers) => void;
+    /**
+     * Sync the store to controlled `nodes`/`edges` props. Adds/removes/updates to
+     * match, without re-emitting changes. No-op writes are skipped so unrelated
+     * nodes don't re-render.
+     */
+    reconcile: (nodes: RivetNode[], edges: RivetEdge[]) => void;
+    /** Add a node (imperative CRUD). Ignored if the id already exists. */
+    addNode: (node: RivetNode) => void;
+    /** Replace a node wholesale by id (imperative CRUD). Ignored if absent. */
+    replaceNode: (id: NodeId, node: RivetNode) => void;
+    getViewport: () => Viewport;
+    setViewport: (viewport: Viewport) => void;
+    subscribeViewport: (listener: (viewport: Viewport) => void) => () => void;
+    /**
+     * Bound panning against the swimlane area. `minX`/`minY` pin the top-left: you
+     * can't scroll left of `minX` or up above `minY`. `maxY` (optional) pins the
+     * bottom: you can't scroll down far enough to push the world-y `maxY` above the
+     * pane top. Pass `null` to remove the bound. Applied to every viewport change,
+     * including zoom and programmatic sets.
+     */
+    setViewportClamp: (clamp: ViewportClamp | null) => void;
+    subscribeFrame: (listener: () => void) => () => void;
+    notifyFrame: () => void;
+    /** Move a node. `commit` re-renders just that node; skip it during drag. */
+    moveNode: (id: NodeId, position: Vec2, commit: boolean) => void;
+    setNodeSize: (id: NodeId, size: Size) => void;
+    /**
+     * Set a node's explicit `width`/`height` (from {@link NodeResizer}), optionally
+     * moving its origin (for top/left resize handles). Re-renders the node every
+     * frame so its box and geometry props update live; `commit` only marks the
+     * emitted change final (`resizing`/`dragging` false → recordable to history).
+     */
+    resizeNode: (id: NodeId, size: Size, position?: Vec2, commit?: boolean) => void;
+    /** Absolute world position of a node, resolving its {@link RivetNode.parentId} chain. */
+    getNodeWorldPosition: (id: NodeId) => Vec2;
+    /**
+     * World positions for every node (parent chains applied), cached and rebuilt only
+     * when node geometry changes — so pan/zoom frames, where nothing moved, reuse it.
+     */
+    getWorldPositions: () => ReadonlyMap<NodeId, Vec2>;
+    /** A node's world-space box (`getNodeWorldPosition` + measured/default size). */
+    getNodeRect: (id: NodeId) => Rect;
+    /** How many ancestors a node has (0 for a top-level node). Drives z-stacking. */
+    getNodeDepth: (id: NodeId) => number;
+    /** Ids of every descendant of a node (children, grandchildren, …). */
+    getDescendantIds: (id: NodeId) => NodeId[];
+    /**
+     * Of the given ids, the ones whose ancestor isn't also in the set — the nodes a
+     * group move should actually translate (a selected child of a selected parent
+     * rides along with the parent, so moving it too would double its travel).
+     */
+    getMovers: (ids: NodeId[]) => NodeId[];
+    /**
+     * Reassign a node's swimlane. Returns the previous lane id if it changed (so
+     * the caller can fire a lane-change callback), or `false` when unchanged.
+     */
+    setNodeLane: (id: NodeId, laneId: string | null) => string | null | false;
+    /**
+     * Set the edge-alignment policy (the `edgeAlignment` prop). Under
+     * `"on-move"`, a committed position change re-sides the moved node's edges
+     * to face their peers, inside the same emission batch as the move.
+     */
+    setEdgeAlignment: (mode: EdgeAlignment) => void;
+    /** The current edge-alignment policy (the runtime reads it per frame). */
+    getEdgeAlignment: () => EdgeAlignment;
+    /**
+     * Hysteresis memory for per-frame side resolution, keyed by
+     * `displayedSideKey(edgeId, end)`. The render loop hands this map to the
+     * renderer, which reads each auto-resolved end's last displayed side and
+     * writes the new one back; a `"live"` alignment commit re-sides pinned ends
+     * to exactly what was displayed, then drops those entries. Never persisted.
+     */
+    getDisplayedSides: () => Map<string, HandlePosition>;
+    /**
+     * Nodes currently mid-drag — populated by uncommitted {@link moveNode}
+     * frames, emptied on commit (and cleared as a backstop when
+     * {@link setNodeDragging} ends the gesture). Under `edgeAlignment: "live"`,
+     * edges touching these nodes render both ends as auto.
+     */
+    getDraggingNodeIds: () => ReadonlySet<NodeId>;
+    /** True while a node drag is in progress (pauses swimlane auto-fit). */
+    isNodeDragging: () => boolean;
+    setNodeDragging: (dragging: boolean) => void;
+    /**
+     * True while a resize gesture is in progress — set by {@link resizeNode}'s live
+     * frames and cleared by its commit. Guards controlled-mode reconciliation the
+     * same way {@link isNodeDragging} does: mid-gesture the consumer's props lag
+     * the store (live frames may be dropped, and measurement echoes carry `size`
+     * but not the explicit `width`/`height`), so reconciling them would stomp the
+     * live box back to its pre-gesture value every frame.
+     */
+    isNodeResizing: () => boolean;
+    /**
+     * Select node(s). `additive` toggles `id` in the current selection (Shift/Cmd
+     * click); otherwise the selection is replaced. Passing `null` clears it.
+     */
+    selectNode: (id: NodeId | null, additive?: boolean) => void;
+    /** Replace (or, if `additive`, extend) the node selection with `ids`. */
+    selectNodes: (ids: NodeId[], additive?: boolean) => void;
+    /** The currently selected node ids. */
+    getSelectedNodes: () => NodeId[];
+    /** True if the node is part of the current selection. */
+    isNodeSelected: (id: NodeId) => boolean;
+    /** The current selection (nodes + edges) as full records. */
+    getSelection: () => RivetSelection;
+    /** Subscribe to selection changes (nodes and/or edges). */
+    subscribeSelection: (listener: (selection: RivetSelection) => void) => () => void;
+    /**
+     * The persistent selection box left behind by a marquee — a draggable rect
+     * over the selected nodes' bounding box. Activated by the marquee's end;
+     * deactivated by any other selection change (a node/edge/pane click, a
+     * programmatic select, Escape, or deleting the selection).
+     */
+    setSelectionBoxActive: (active: boolean) => void;
+    isSelectionBoxActive: () => boolean;
+    /**
+     * Version channel for the selection box: bumped when the flag flips and, while
+     * active, when the boxed selection's membership or geometry changes — so the
+     * box component can re-render its bounding rect from a single subscription.
+     */
+    getSelectionBoxVersion: () => number;
+    subscribeSelectionBox: (listener: () => void) => () => void;
+    /** Set (or clear, with `null`) the hovered node. */
+    hoverNode: (id: NodeId | null) => void;
+    /**
+     * The node that currently holds keyboard focus, or `null`. View state, like
+     * hover — never recorded to history, never emitted as a change, and stripped
+     * from snapshots. Tracked from the node elements' focus/blur by the node
+     * layer; set it programmatically to move real DOM focus to a node (the
+     * runtime follows this channel, centering the viewport first when the node
+     * is culled out of the DOM).
+     */
+    getFocusedNode: () => NodeId | null;
+    /** Focus a node by id, or clear with `null`. Unknown ids are ignored. */
+    setFocusedNode: (id: NodeId | null) => void;
+    /** Subscribe to focused-node changes. */
+    subscribeFocus: (listener: (id: NodeId | null) => void) => () => void;
+    selectEdge: (id: EdgeId | null) => void;
+    /** The selected edge's id, or null. */
+    getSelectedEdge: () => EdgeId | null;
+    /**
+     * Runtime binding for the reconnect gateway. `<Handle>` consults it on
+     * pointer-down so a press that lands on a handle coinciding with a
+     * reconnectable edge's endpoint moves that edge instead of starting a new
+     * connection. Bound by the runtime (like {@link bindRenderRequester}).
+     */
+    bindReconnectDelegate: (delegate: ReconnectDelegate | null) => void;
+    getReconnectDelegate: () => ReconnectDelegate | null;
+    addEdge: (edge: RivetEdge) => void;
+    /** Replace an edge wholesale by id (imperative CRUD). Ignored if absent. */
+    replaceEdge: (id: EdgeId, edge: RivetEdge) => void;
+    /** Re-point an edge's source/target (from an endpoint reconnection drag). */
+    reconnectEdge: (id: EdgeId, connection: Connection) => void;
+    removeEdge: (id: EdgeId) => void;
+    removeNode: (id: NodeId) => void;
+    /** Delete the selected node (and its edges) and/or edge. Returns true if any. */
+    deleteSelection: () => boolean;
+    /** Revert the last recordable change. Returns false when there's nothing to undo. */
+    undo: () => boolean;
+    /** Re-apply the last undone change. Returns false when there's nothing to redo. */
+    redo: () => boolean;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    /** Drop all history and reset the baseline to the current graph. */
+    clearHistory: () => void;
+    /** Subscribe to history changes (drives `canUndo`/`canRedo` reactivity). */
+    subscribeHistory: (listener: () => void) => () => void;
+    getEdgeLabelAnchors: () => Map<EdgeId, Vec2>;
+    setEdgeLabelAnchors: (anchors: Map<EdgeId, Vec2>) => void;
+    /** Alignment/snap guides to draw for the current drag (world space). Empty when idle. */
+    getAlignmentGuides: () => AlignmentGuide[];
+    setAlignmentGuides: (guides: AlignmentGuide[]) => void;
+    registerHandle: (record: HandleRecord) => void;
+    unregisterHandle: (nodeId: NodeId, handleId: string) => void;
+    readonly anchors: Map<string, AnchorRecord>;
+    /**
+     * Register (or re-bind) an anchor. Idempotent on the `(nodeId, anchorId)`
+     * key: calling again with a new element re-attaches it, keeping any
+     * last-known geometry until the next successful measurement.
+     */
+    registerAnchor: (nodeId: NodeId, anchorId: string, element: Element, options?: AnchorRegistrationOptions) => void;
+    /**
+     * Mark an anchor's element gone without removing the anchor — the stale
+     * retention signal. Geometry (and the stray handles rendered from it) is
+     * kept so edges stay put while the display is unmounted.
+     */
+    detachAnchor: (nodeId: NodeId, anchorId: string) => void;
+    /** Explicitly remove an anchor and the chrome rendered for it. */
+    unregisterAnchor: (nodeId: NodeId, anchorId: string) => void;
+    /**
+     * Re-measure a node's anchors. Called automatically when the node's box
+     * resizes; call it directly after content reflows *without* a resize (an
+     * editor transaction, a font load) — rivet can't observe those.
+     */
+    remeasureAnchors: (nodeId: NodeId) => void;
+    /** The node's anchors, in registration order. */
+    getNodeAnchors: (nodeId: NodeId) => AnchorRecord[];
+    getNodeAnchorsVersion: (nodeId: NodeId) => number;
+    subscribeNodeAnchors: (nodeId: NodeId, listener: () => void) => () => void;
+    getEdgesVersion: () => number;
+    subscribeEdges: (listener: () => void) => () => void;
+    getPending: () => PendingConnection | null;
+    beginConnection: (pending: PendingConnection) => void;
+    updateConnection: (to: Vec2, toPosition?: HandlePosition) => void;
+    endConnection: () => void;
+    /** Ask the runtime to schedule a canvas frame. */
+    requestRender: () => void;
+    bindRenderRequester: (fn: () => void) => void;
+};
+/** Create a graph store. The public entry point; the class is an implementation detail. */
+declare function createRivetStore(init: RivetStoreInit): RivetStore;
+
+type RivetContextValue = {
+    store: RivetStore;
+    nodeTypes: NodeTypes;
+    paneRef: RefObject<HTMLDivElement | null>;
+    /** Imperative viewport controls (zoom, fit-view). */
+    controls: RivetControls;
+    /** Keys that make a click add to (toggle in) the selection. */
+    multiSelectionKeys: string[];
+    /**
+     * Publish a message to the pane's visually-hidden live region, so screen
+     * readers narrate keyboard interactions (grab/move/drop, connect).
+     */
+    announce: (message: string) => void;
+    /** Id of the pane's hidden keyboard-instructions element (`aria-describedby` target). */
+    nodeDescriptionId: string;
+    /** Defaults merged into every edge — the label layer reads `labelStyle`. */
+    defaultEdgeOptions?: DefaultEdgeOptions;
+    /** Grid to snap dragged nodes to (`[x, y]` world units), or null for free movement. */
+    snapGrid: [number, number] | null;
+    /** Whether a single-node drag shows alignment guides and snaps to neighbors. */
+    alignmentGuides: boolean;
+    /** Resolved placement policy for anchor chrome (dots + stray handles). */
+    anchorOptions: ResolvedAnchorOptions;
+    /** Snapshot the nodes and lanes currently on screen. Imperative — never subscribes. */
+    getViewportElements: () => ViewportElements;
+    /** Resolved swimlane groups (header + lanes, world space). Empty when unused. */
+    swimlaneGroups: ResolvedSwimlaneGroup[];
+    /** Every group's lanes, flattened — the clamp targets. */
+    swimlaneLanes: ResolvedLane[];
+    /** Whether node drags are bounded to a lane and reassign lane membership. */
+    clampToSwimlane: boolean;
+    /** Inner clearance kept between a clamped node and its lane edges. */
+    swimlaneMargin: ResolvedMargin;
+    /** Screen width of the sticky lane-label strip, in px. */
+    swimlaneLabelWidth: number;
+    /** Screen height of the sticky group header band, in px. */
+    swimlaneHeaderSize: number;
+    /** Whether lanes show a bottom resize handle. */
+    swimlaneResizable: boolean;
+    /**
+     * Resize a lane. `commit` fires the consumer's `onSwimlaneSizeChange` with the
+     * new height; `reason` tags it (`"resize"` for a drag, `"autofit"` for a
+     * fit-to-content snap). Defaults to `"resize"`.
+     */
+    resizeSwimlane: (laneId: string, height: number, commit: boolean, reason?: SwimlaneSizeChange["reason"]) => void;
+    /** Consumer override for the sticky group header content. */
+    renderSwimlaneHeader?: (props: SwimlaneHeaderProps) => ReactNode;
+    /** Consumer override for the sticky lane label content. */
+    renderSwimlaneLabel?: (props: SwimlaneLabelProps) => ReactNode;
+    /** Called when a dragged node crosses into a different lane. */
+    onLaneChange?: (change: LaneChange) => void;
+    /** Veto a proposed connection; return false to reject. */
+    isValidConnection?: (connection: Connection) => boolean;
+    /** Rewrite a validated connection before commit; `null` cancels the drop. */
+    mapConnection?: (connection: Connection) => Connection | null;
+    /** Called after a valid connection is made. */
+    onConnect?: (connection: Connection) => void;
+};
+declare function useRivetContext(): RivetContextValue;
+/** Access the imperative viewport controls from inside `<Rivet>`. */
+declare function useRivetControls(): RivetControls;
+/** Subscribe to the live viewport — re-renders on every pan/zoom. */
+declare function useRivetViewport(): Viewport;
+/** Reactive undo/redo state + actions — re-renders when `canUndo`/`canRedo` flip. */
+declare function useRivetHistory(): {
+    canUndo: boolean;
+    canRedo: boolean;
+    undo: () => boolean;
+    redo: () => boolean;
+    clearHistory: () => void;
+};
+/**
+ * The node holding keyboard focus, or `null` — re-renders as focus roves.
+ * Rendering a focus indicator is the consumer's job (rivet is headless); this
+ * is the state to drive it from, along with the wrapper's native `:focus-visible`.
+ */
+declare function useRivetFocusedNode(): NodeId | null;
+
+/**
+ * Structured edge ends — the semantic model over the string handle ids that
+ * `RivetEdge.sourceHandle`/`targetHandle` persist.
+ *
+ * An end is `{ nodeId, anchorId?, side? }`:
+ *  - `anchorId` present — the end binds to a registered {@link Anchor}.
+ *  - `side` present — the end is *pinned*: the user chose it (grabbed a dot,
+ *    dropped on a handle) and rivet renders it exactly there until the
+ *    alignment policy says otherwise.
+ *  - `side` absent — the end is *auto* (floating): the renderer resolves the
+ *    facing side per frame from the two node boxes. Nothing is written while a
+ *    node drags, so live re-anchoring is free and cannot touch history.
+ *
+ * Strings remain the wire format, so persisted graphs and external schemas
+ * keep working; this module is the codec between the two forms:
+ *
+ * | structured                      | handle string        |
+ * |---------------------------------|----------------------|
+ * | `{ anchorId, side }`            | `inode-<id>-<side>`  |
+ * | `{ anchorId }` (auto)           | `inode-<id>-auto`    |
+ * | `{ side }` (plain, pinned)      | `"<side>"`           |
+ * | `{}` (plain, auto)              | `undefined`          |
+ *
+ * A custom handle id (anything else) stays a plain pinned end whose side lives
+ * in the handle registry; `parseEdgeEndpoint` reads it from there when given
+ * the registry, and otherwise leaves `side` unset.
+ */
+
+/** One end of an edge, structurally. See the module doc for the string mapping. */
+type EdgeEndpoint = {
+    nodeId: NodeId;
+    /** Anchor this end binds to; absent for a plain node end. */
+    anchorId?: string;
+    /** Pinned side; absent = auto — the renderer resolves the facing side per frame. */
+    side?: HandlePosition;
+};
+/** Parse a bare-side handle id (`"left"`, `"top"`, …) — a side-pinned plain end. */
+declare function parseSideHandleId(handleId: string | null | undefined): HandlePosition | null;
+/**
+ * The handle string for a structured end — what `sourceHandle`/`targetHandle`
+ * stores. `undefined` (a plain auto end) means "no handle": the renderer
+ * resolves the side per frame. A plain pinned end that should attach to a
+ * specific registered handle keeps using that handle's own id directly; this
+ * codec covers the library-owned grammars.
+ */
+declare function edgeEndpointHandle(end: EdgeEndpoint): string | undefined;
+/**
+ * Parse one end of an edge into the structured form. Library grammars (anchor
+ * stray/auto ids, bare sides, absent handles) round-trip exactly; a custom
+ * handle id resolves its side through `handles` when provided (the store's
+ * registry), and otherwise comes back with `side` unset — which callers must
+ * not read as auto without that context.
+ */
+declare function parseEdgeEndpoint(nodeId: NodeId, handleId: string | null | undefined, handles?: ReadonlyMap<string, HandleRecord>): EdgeEndpoint;
+
+/**
+ * Confine a child's parent-relative position so its box stays fully inside the
+ * parent (the `extent: "parent"` sub-flow constraint). Pure geometry — the
+ * caller supplies both measured sizes.
+ */
+declare function clampChildToParent(position: Vec2, childSize: Size, parentSize: Size): Vec2;
+/** Snap a position to the nearest multiple of `[gx, gy]`. A `0` axis is left free. */
+declare function snapToGrid(position: Vec2, grid: readonly [number, number]): Vec2;
+/** The tight bounding rect over a set of rects, or `null` when empty. */
+declare function boundingRect(rects: readonly Rect[]): Rect | null;
+/**
+ * True when nothing the consumer controls has changed between two versions of a
+ * node — so reconcile can keep the existing one (preserving store-owned transient
+ * state like `hovered`). Compares only fields a controlled consumer owns.
+ */
+/**
+ * A serializable snapshot of the graph. Store-owned geometry (`position`, `size`)
+ * is cloned so mutating the snapshot can't reach back into the store, and purely
+ * transient node flags (`hovered`, `dragging`) are dropped — you never want to
+ * persist "was mid-drag". `data` is copied by reference, matching the
+ * controlled-mode contract (the consumer owns it).
+ */
+declare function serializeGraph<TNodeData = unknown, TEdgeData = unknown>(nodes: Iterable<RivetNode<TNodeData>>, edges: Iterable<RivetEdge<TEdgeData>>, viewport: Viewport): RivetSnapshot<TNodeData, TEdgeData>;
+
+type Updater<T> = T | ((current: T) => T);
+/**
+ * Imperative handle to the graph, returned by {@link useRivet}. Parameterize it
+ * with your node/edge `data` types — `useRivet<MyNodeData, MyEdgeData>()` — so
+ * `getNodes`, `toObject`, etc. hand those types back instead of `unknown`.
+ */
+type RivetInstance<TNodeData = unknown, TEdgeData = unknown> = RivetControls & {
+    /** Snapshot the nodes and lanes currently on screen. Reads the viewport once — never subscribes. */
+    getViewportElements: () => ViewportElements<TNodeData>;
+    /** Serializable snapshot of nodes, edges, and viewport. Safe to `JSON.stringify`. */
+    toObject: () => RivetSnapshot<TNodeData, TEdgeData>;
+    getNodes: () => RivetNode<TNodeData>[];
+    getNode: (id: NodeId) => RivetNode<TNodeData> | undefined;
+    setNodes: (nodes: Updater<RivetNode<TNodeData>[]>) => void;
+    addNodes: (nodes: RivetNode<TNodeData> | RivetNode<TNodeData>[]) => void;
+    updateNode: (id: NodeId, patch: Updater<RivetNode<TNodeData>>) => void;
+    getEdges: () => RivetEdge<TEdgeData>[];
+    getEdge: (id: EdgeId) => RivetEdge<TEdgeData> | undefined;
+    setEdges: (edges: Updater<RivetEdge<TEdgeData>[]>) => void;
+    addEdges: (edges: RivetEdge<TEdgeData> | RivetEdge<TEdgeData>[]) => void;
+    updateEdge: (id: EdgeId, patch: Updater<RivetEdge<TEdgeData>>) => void;
+    /** Delete nodes (and their edges) and/or edges by id. */
+    deleteElements: (elements: {
+        nodes?: NodeId[];
+        edges?: EdgeId[];
+    }) => void;
+    /**
+     * Bind an anchor — a connectable point — to a DOM element inside a node.
+     * The imperative core behind `<Anchor>`, for consumers whose content DOM is
+     * owned by another renderer (a rich-text editor's contentEditable, say).
+     * Idempotent on `(nodeId, anchorId)`; the returned registration re-binds a
+     * replaced element or unregisters explicitly.
+     */
+    registerAnchor: (nodeId: NodeId, anchorId: string, element: Element, options?: AnchorRegistrationOptions) => AnchorRegistration;
+    /**
+     * Explicitly remove an anchor and its chrome. Unmounting `<Anchor>` (or
+     * rebinding `null`) only *detaches* — geometry and edges are retained — so
+     * call this when the anchored content is gone for good, alongside deleting
+     * its edges.
+     */
+    unregisterAnchor: (nodeId: NodeId, anchorId: string) => void;
+    /**
+     * Re-measure a node's anchors. Automatic on node resize; needed after a
+     * content reflow that keeps the node box (an editor transaction, a font
+     * load) — rivet can't observe those.
+     */
+    remeasureAnchors: (nodeId: NodeId) => void;
+    /** Copy nodes (default: the current selection) to the in-memory clipboard. */
+    copy: (ids?: NodeId[]) => void;
+    /** Copy then delete nodes (default: the current selection). */
+    cut: (ids?: NodeId[]) => void;
+    /** Paste the clipboard as fresh, selected nodes offset from the originals. No-op when empty. */
+    paste: (options?: {
+        offset?: Vec2;
+    }) => ClonedElements<TNodeData, TEdgeData> | undefined;
+    /** Clone nodes (default: the current selection) in place with fresh ids, and select them. */
+    duplicate: (ids?: NodeId[]) => ClonedElements<TNodeData, TEdgeData> | undefined;
+    /** Revert the last recordable change. Returns false when there's nothing to undo. */
+    undo: () => boolean;
+    /** Re-apply the last undone change. Returns false when there's nothing to redo. */
+    redo: () => boolean;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    /** Drop all undo/redo history and reset the baseline to the current graph. */
+    clearHistory: () => void;
+};
+/**
+ * Imperative access to the graph from any component inside `<Rivet>` — CRUD on
+ * nodes/edges plus the viewport controls. Backed by the same store that drives
+ * rendering, so mutations are reflected immediately and (in controlled mode) emit
+ * changes to `onNodesChange`/`onEdgesChange`.
+ *
+ * Parameterize with your `data` types to keep them through the API:
+ * `const rivet = useRivet<MyNodeData, MyEdgeData>()`.
+ */
+declare function useRivet<TNodeData = unknown, TEdgeData = unknown>(): RivetInstance<TNodeData, TEdgeData>;
+
+/**
+ * The default {@link EdgeRenderer}. Strokes each edge's sampled polyline (built by
+ * its {@link EdgePathFn}) on a 2D canvas, with per-edge style, arrowheads, and an
+ * animated dash. The geometry it draws comes from {@link buildEdges}, which is
+ * backend-neutral.
+ */
+declare class Canvas2DEdgeRenderer implements EdgeRenderer {
+    private readonly canvas;
+    private readonly ctx;
+    private dpr;
+    private width;
+    private height;
+    private readonly edgeTypes;
+    private readonly defaults;
+    /** Screen-space polylines from the last frame, keyed by edge id, for picking. */
+    private readonly geometry;
+    /** Screen-space endpoints per edge, for endpoint (reconnection) picking. */
+    private readonly endpoints;
+    /** Screen-space label anchor per edge that has a label. */
+    private readonly labels;
+    constructor(canvas: HTMLCanvasElement, options?: EdgeRendererOptions);
+    resize(width: number, height: number, dpr: number): void;
+    /** Screen-space label anchors for the edges drawn last frame. */
+    getLabels(): Map<EdgeId, Vec2>;
+    /** Screen-space endpoints per edge from the last frame (reconnect affordance). */
+    getEndpoints(): ReadonlyMap<EdgeId, {
+        source: Vec2;
+        target: Vec2;
+    }>;
+    draw(edges: RivetEdge[], nodes: Map<NodeId, RivetNode>, viewport: Viewport, extras?: EdgeDrawExtras): void;
+    pick(x: number, y: number, tolerance?: number): EdgeId | null;
+    pickEndpoint(x: number, y: number): {
+        edgeId: EdgeId;
+        end: EdgeEnd;
+    } | null;
+    dispose(): void;
+}
+/** The built-in {@link EdgeRendererFactory} — the default backend for `<Rivet>`. */
+declare const canvas2DEdgeRenderer: EdgeRendererFactory;
+
+/** A straight line between the two ends. */
+declare const getStraightPath: EdgePathFn;
+/**
+ * A cubic bezier that leaves each end perpendicular to its handle's side, so
+ * edges curve cleanly out of left/right/top/bottom handles. This is the default.
+ */
+declare const getBezierPath: EdgePathFn;
+/** An axis-aligned step path with rounded corners. */
+declare const getSmoothStepPath: EdgePathFn;
+/** An axis-aligned step path with sharp corners. */
+declare const getStepPath: EdgePathFn;
+/** The built-in edge shapes, keyed by `type`. `bezier` is the default. */
+declare const BUILTIN_EDGE_TYPES: Record<string, EdgePathFn>;
+
+/** Convert a world-space point to screen-space pixels. */
+declare function worldToScreen(point: Vec2, viewport: Viewport): Vec2;
+/** Convert a screen-space point (e.g. a pointer event) to world space. */
+declare function screenToWorld(point: Vec2, viewport: Viewport): Vec2;
+/**
+ * Zoom toward an anchor point (usually the cursor) so the world point under the
+ * anchor stays put. Returns a new viewport; the input is not mutated.
+ */
+declare function zoomAt(viewport: Viewport, anchor: Vec2, nextZoom: number, minZoom?: number, maxZoom?: number): Viewport;
+/** The CSS transform string applied to the DOM node layer. */
+declare function viewportToCss(viewport: Viewport): string;
+/** The visible world-space rectangle for a viewport of the given pixel size. */
+declare function visibleWorldRect(viewport: Viewport, width: number, height: number): Rect;
+/** True if two axis-aligned rectangles overlap (used for node culling). */
+declare function rectsIntersect(a: Rect, b: Rect): boolean;
+
+declare const VERSION = "0.0.0";
+
+export { AlignmentGuide, BUILTIN_EDGE_TYPES, BUILTIN_NODE_TYPES, Canvas2DEdgeRenderer, type CloneOptions, type ClonedElements, Connection, Controls, type ControlsProps, DEFAULT_ALIGNMENT_HYSTERESIS, DefaultEdgeOptions, DefaultNode, type EdgeAlignment, EdgeChange, EdgeDrawExtras, EdgeEnd, type EdgeEndpoint, EdgeId, EdgePathFn, EdgeRenderer, EdgeRendererFactory, EdgeRendererOptions, EdgeTypes, GroupNode, Handle, HandlePosition, type HandleProps, HandleRecord, HandleType, MiniMap, type MiniMapProps, NodeChange, NodeId, NodeProps, NodeResizer, type NodeResizerProps, NodeTypes, type PaneContextMenuContext, PendingConnection, ReconnectDelegate, Rect, Rivet, RivetControls, RivetEdge, type RivetInstance, RivetNode, type RivetProps, RivetSelection, RivetSnapshot, type RivetStore, Size, VERSION, Vec2, Viewport, alignRect, applyEdgeChanges, applyNodeChanges, boundingRect, canvas2DEdgeRenderer, clampChildToParent, cloneElements, createRivetStore, edgeEndpointHandle, facingSide, getBezierPath, getSmoothStepPath, getStepPath, getStraightPath, handleKey, parseEdgeEndpoint, parseSideHandleId, rectsIntersect, resolveFacingSide, screenToWorld, serializeGraph, snapToGrid, useRivet, useRivetContext, useRivetControls, useRivetFocusedNode, useRivetHistory, useRivetViewport, viewportToCss, visibleWorldRect, worldToScreen, zoomAt };