@pixerate/editor 0.22.0 → 0.24.0

package/dist/canvas/index.d.cts

@@ -1,6 +1,8 @@
-import { R as Rect, C as CanvasNode, X as XYPosition, a as CanvasEdge, I as IncrementalLayoutOptions, S as Side, b as CanvasLayoutOptions, P as PlaceBesideOptions, T as TrajectoryFunction, F as FanOutTrajectoryOptions, N as NodeTransition, c as CanvasNodeStyle, d as ReflowDisplacementOptions, D as DirectionalDisplacementOptions, e as CanvasClipboardPayload, f as Position, g as Point } from '../types-CJ4U-HHI.cjs';
-export { h as CanvasDockingCallbacks, i as CollapseNodeOptions, j as DisplacementDirection, k as DockStrategy, E as ExplodeNodeOptions, l as ExplosionSnapshot, G as GraphDifferences, m as TrajectoryPoint } from '../types-CJ4U-HHI.cjs';
-import { C as Command } from '../types-BZgcDsC5.cjs';
+import { R as Rect, C as CanvasNode, X as XYPosition, b as CanvasEdge, I as IncrementalLayoutOptions, S as Side, c as CanvasLayoutOptions, P as PlaceBesideOptions, T as TrajectoryFunction, F as FanOutTrajectoryOptions, N as NodeTransition, a as CanvasNodeStyle, d as ReflowDisplacementOptions, D as DirectionalDisplacementOptions, e as CanvasClipboardPayload, f as Position, g as Point } from '../types-DX4Mh4SL.cjs';
+export { h as CanvasDockingCallbacks, i as CollapseNodeOptions, j as DisplacementDirection, k as DockStrategy, E as ExplodeNodeOptions, l as ExplosionSnapshot, G as GraphDifferences, m as TrajectoryPoint } from '../types-DX4Mh4SL.cjs';
+import { b as CanvasNodeUpdate, N as NodeRectOptions, A as AlignEdge, c as AlignNodesOptions, D as DistributeAxis, a as DistributeMode, d as DistributeNodesOptions, S as SizeDimension, M as MatchSizeOptions, Z as ZOrderOperation, C as CanvasArrangeAction } from '../arrangeShortcuts-B8O3f8-P.cjs';
+export { e as ArrangeShortcutBinding, f as DEFAULT_ARRANGE_SHORTCUTS, L as LOCKED_DATA_KEY, g as LOCKED_PREVIOUS_FLAGS_KEY, h as alignNodes, i as applyNodeUpdates, j as createNodeLookup, k as distributeNodes, l as getAbsolutePosition, m as getNodeRect, n as getNodeSize, o as invertNodeUpdates, p as isLocked, q as lockNodes, r as matchArrangeShortcut, s as matchSize, t as readStyleSize, u as reorderNodes, v as toggleLockNodes, w as unlockNodes, x as withStyleSize } from '../arrangeShortcuts-B8O3f8-P.cjs';
+import { C as Command } from '../types-GT5a5YAX.cjs';
 
 declare const DEFAULT_NODE_WIDTH = 200;
 declare const DEFAULT_NODE_HEIGHT = 60;
@@ -328,172 +330,30 @@ declare function blendLayout<TNode extends CanvasNode = CanvasNode>(from: TNode[
  */
 declare function connectedOnly<TNode extends CanvasNode = CanvasNode, TEdge extends CanvasEdge = CanvasEdge>(nodes: TNode[], edges: TEdge[]): TNode[];
 
-/**
- * Edge (or centre line) used by `alignNodes`.
- * `center` aligns horizontal centres (a vertical line); `middle` aligns vertical centres.
- */
-type AlignEdge = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
-/** Axis used by `distributeNodes`. `both` distributes horizontally and vertically. */
-type DistributeAxis = 'horizontal' | 'vertical' | 'both';
-/**
- * `gaps` leaves equal space between neighbouring nodes, `centres` spaces their centres equally.
- */
-type DistributeMode = 'gaps' | 'centres';
-/** Dimension(s) copied by `matchSize`. */
-type SizeDimension = 'width' | 'height' | 'both';
-/**
- * Partial node change produced by the arrange helpers. `position` is in the node's own
- * coordinate space (relative to its `parentId` parent when it has one).
- */
-interface CanvasNodeUpdate {
-    id: string;
-    position?: XYPosition;
-    width?: number;
-    height?: number;
-    zIndex?: number;
-}
-interface NodeRectOptions {
-    /** Width used when a node has no measured, explicit or style size and estimation is off. */
-    defaultWidth?: number;
-    /** Height used when a node has no measured, explicit or style size and estimation is off. */
-    defaultHeight?: number;
-    /** Estimate unmeasured node sizes from their label via `estimateNodeSize` (default `true`). */
-    estimate?: boolean;
-}
-/** Data key marking a node as locked. See `lockNodes`. */
-declare const LOCKED_DATA_KEY = "locked";
-/** Data key holding the interaction flags a node had before it was locked. */
-declare const LOCKED_PREVIOUS_FLAGS_KEY = "lockedPrevious";
-/**
- * Reads a pixel `width` / `height` from a node style, which may be a CSS string (SvelteFlow)
- * or a style object (React Flow). Non-pixel values (`%`, `auto`, ...) are ignored.
- */
-declare function readStyleSize(style: CanvasNodeStyle | undefined | null): {
-    width?: number;
-    height?: number;
-};
-/**
- * Returns `style` with its pixel `width` / `height` replaced, keeping its representation
- * (string or object). Only dimensions already present in the style are rewritten, because
- * xyflow applies the node's own `width` / `height` props otherwise.
- */
-declare function withStyleSize(style: CanvasNodeStyle | undefined | null, size: {
-    width?: number;
-    height?: number;
-}): CanvasNodeStyle | undefined;
-/**
- * Resolves a node's size: measured DOM size, then explicit `width` / `height`, then a pixel
- * size in `style`, then a label-based estimate (or the defaults when `estimate` is `false`).
- */
-declare function getNodeSize(node: CanvasNode, options?: NodeRectOptions): {
-    width: number;
-    height: number;
-};
-/**
- * Absolute (flow-space) position of a node, following its `parentId` chain.
- * Cycles and missing parents are tolerated.
- */
-declare function getAbsolutePosition(node: CanvasNode, lookup: ReadonlyMap<string, CanvasNode>): XYPosition;
-/** Builds an id lookup for a node array. */
-declare function createNodeLookup<TNode extends CanvasNode>(nodes: TNode[]): Map<string, TNode>;
-/** Absolute flow-space rectangle of a node. */
-declare function getNodeRect(node: CanvasNode, lookup?: ReadonlyMap<string, CanvasNode>, options?: NodeRectOptions): Rect;
-/**
- * Whether a node has been locked with `lockNodes`.
- */
-declare function isLocked(node: CanvasNode | undefined | null): boolean;
-/**
- * Locks nodes: marks `data.locked = true` and sets `draggable: false` and `deletable: false`
- * so both SvelteFlow and React Flow stop dragging and deleting them. Nodes stay `selectable`
- * so they can be unlocked again. The previous flags are kept in `data.lockedPrevious` and
- * restored by `unlockNodes`. Returns a new array; untouched nodes keep their identity.
- */
-declare function lockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
-/**
- * Reverses `lockNodes`, restoring the `draggable` / `deletable` flags the node had before.
- */
-declare function unlockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
-/** Locks the given nodes if any of them is unlocked, otherwise unlocks them all. */
-declare function toggleLockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
-interface AlignNodesOptions extends NodeRectOptions {
-    /**
-     * What to align to: the selection bounding box (default) or a fixed rectangle.
-     * Locked nodes never move but still count towards the selection bounds, so they act as anchors.
-     */
-    to?: 'selection' | Rect;
-}
-/**
- * Aligns nodes to a shared edge or centre line of their bounding box (Freeform's
- * Align Left / Center / Right / Top / Middle / Bottom). Needs at least two nodes unless
- * `options.to` is a rectangle. Locked nodes are not moved.
- */
-declare function alignNodes(nodes: CanvasNode[], ids: Iterable<string>, edge: AlignEdge, options?: AlignNodesOptions): CanvasNodeUpdate[];
-interface DistributeNodesOptions extends NodeRectOptions {
-    /** Explicit gap between neighbours for `gaps` mode. Default: spread evenly between the outer nodes. */
-    gap?: number;
-}
-/**
- * Distributes nodes along an axis (Freeform's Distribute Horizontally / Vertically / Evenly).
- * The outermost nodes stay put and the others are spaced with equal gaps (`gaps`, default)
- * or equally spaced centres (`centres`). Needs at least three nodes (two with an explicit
- * `gap`). Locked nodes keep their place in the order but are not moved.
- */
-declare function distributeNodes(nodes: CanvasNode[], ids: Iterable<string>, axis: DistributeAxis, mode?: DistributeMode, options?: DistributeNodesOptions): CanvasNodeUpdate[];
-interface MatchSizeOptions extends NodeRectOptions {
-    /**
-     * Size source: the `largest` (default) or `smallest` node, the `first` id given,
-     * or a specific node id.
-     */
-    reference?: 'largest' | 'smallest' | 'first' | {
-        id: string;
-    };
-    /** Keep each node's centre in place instead of its top-left corner (default `false`). */
-    keepCentre?: boolean;
-}
-/**
- * Makes nodes the same width, height or both (Freeform's Make Same Size). Returns size
- * updates (plus position updates with `keepCentre`). Locked nodes are not resized but can
- * be the reference.
- */
-declare function matchSize(nodes: CanvasNode[], ids: Iterable<string>, dimension: SizeDimension, options?: MatchSizeOptions): CanvasNodeUpdate[];
-/** Z-order operation. */
-type ZOrderOperation = 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack';
-/**
- * Restacks nodes (Bring Forward / Send Backward / Bring to Front / Send to Back).
- *
- * Both SvelteFlow and React Flow stack nodes by `zIndex` (missing = 0) and, for equal
- * `zIndex`, by array order. This computes that effective order for the siblings that share
- * the targets' parent, applies the operation, and returns `zIndex` updates assigning each
- * sibling its new rank. The array order is left alone, because xyflow requires parents to
- * precede their children. Locked nodes are not restacked. "Forward" moves past the next
- * sibling the node overlaps, falling back to the next sibling when nothing overlaps.
- */
-declare function reorderNodes(nodes: CanvasNode[], ids: Iterable<string>, operation: ZOrderOperation, options?: NodeRectOptions): CanvasNodeUpdate[];
-/**
- * Applies `CanvasNodeUpdate`s to a node array, returning a new array. Unchanged nodes keep
- * their identity. Size updates set `width` / `height` and rewrite pixel sizes already present
- * in `style` (string or object). An existing `measured` size is updated too, so geometry
- * helpers see the new size before xyflow re-measures the node.
- */
-declare function applyNodeUpdates<TNode extends CanvasNode>(nodes: TNode[], updates: CanvasNodeUpdate[]): TNode[];
-/**
- * Inverse of a set of updates against the current nodes, for undo. Restores the previous
- * position / size / zIndex of every node an update touches.
- */
-declare function invertNodeUpdates(nodes: CanvasNode[], updates: CanvasNodeUpdate[]): CanvasNodeUpdate[];
-
 /**
  * A guide line to render while dragging, in flow coordinates.
  * `edge` and `centre` guides are alignment lines; `spacing` guides mark equal gaps.
+ * `measure` lines (with a distance `label`) and dashed `extension` lines come from the
+ * distance measuring helpers (`measureBetween`, `measureSelection`).
  */
 interface GuideLine {
     orientation: 'vertical' | 'horizontal';
-    kind: 'edge' | 'centre' | 'spacing';
+    kind: 'edge' | 'centre' | 'spacing' | 'measure' | 'extension';
     x1: number;
     y1: number;
     x2: number;
     y2: number;
+    /** Text drawn at the middle of the line (measuring distances). */
+    label?: string;
 }
+/**
+ * Snaps `value` to a grid with the given `spacing` and `origin`. A spacing of 0 or less
+ * (or a non-finite one) leaves the value unchanged.
+ *
+ * Ported from vectorcraft-main/crates/geom/src/snap.rs (MIT OR Apache-2.0, © ArtCraft Team
+ * and contributors). See THIRD_PARTY_NOTICES.md.
+ */
+declare function snapToGrid(value: number, spacing: number, origin?: number): number;
 interface SnapGuidesOptions {
     /** Current viewport zoom; the threshold is in screen pixels and divided by it (default 1). */
     zoom?: number;
@@ -505,6 +365,13 @@ interface SnapGuidesOptions {
     centres?: boolean;
     /** Snap to equal spacing between neighbouring shapes in the same row / column (default `true`). */
     spacing?: boolean;
+    /**
+     * Grid spacing in flow units (default 0, off). An axis that does not snap to a shape snaps
+     * its top-left (drag) or moving edge (resize) to the grid; grid snaps draw no guides.
+     */
+    gridSize?: number;
+    /** Grid origin in flow units (default `{ x: 0, y: 0 }`). */
+    gridOrigin?: XYPosition;
 }
 interface SnapResult {
     /** Snapped top-left of the moving rectangle. */
@@ -513,6 +380,7 @@ interface SnapResult {
     offset: XYPosition;
     /** Guide segments to draw for the snap that was applied. */
     guides: GuideLine[];
+    /** Whether x snapped to a shape (grid snaps do not count). */
     snappedX: boolean;
     snappedY: boolean;
 }
@@ -738,33 +606,6 @@ declare function fitViewportToNodes(nodes: CanvasNode[], size: {
     height: number;
 }, ids?: Iterable<string>, options?: FitViewportOptions & NodeRectOptions): CanvasViewport | null;
 
-/**
- * Canvas arrangement actions that have keyboard shortcuts.
- */
-type CanvasArrangeAction = 'alignLeft' | 'alignCenter' | 'alignRight' | 'alignTop' | 'alignMiddle' | 'alignBottom' | 'distributeHorizontal' | 'distributeVertical' | 'lock' | 'unlock' | 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack' | 'nextScene' | 'previousScene';
-interface ArrangeShortcutBinding {
-    action: CanvasArrangeAction;
-    /** `KeyboardEvent.code` (layout- and Option-independent, e.g. `KeyA`, `BracketRight`). */
-    code: string;
-    mod?: boolean;
-    alt?: boolean;
-    shift?: boolean;
-    /** Human readable label, e.g. for menus. `Mod` is ⌘ on macOS and Ctrl elsewhere. */
-    label: string;
-}
-/**
- * Default bindings. Align/distribute follow Figma (Option/Alt + letter), layer order follows
- * the common `Mod+]` / `Mod+[` convention, lock follows Keynote/Freeform (`Mod+L`,
- * `Mod+Alt+L` to unlock) and scenes step with PageDown / PageUp.
- */
-declare const DEFAULT_ARRANGE_SHORTCUTS: readonly ArrangeShortcutBinding[];
-/**
- * Resolves a keydown event to an arrange action, or `null`. Events from text inputs,
- * textareas, selects, contenteditable and ProseMirror are ignored (see `isEventFromTextInput`).
- * `Mod` is ⌘ or Ctrl.
- */
-declare function matchArrangeShortcut(event: KeyboardEvent, bindings?: readonly ArrangeShortcutBinding[]): CanvasArrangeAction | null;
-
 /**
  * Polygon boolean operations (union, intersection, difference, xor and divide) on
  * multi-polygons with holes.
@@ -1040,6 +881,16 @@ interface PolygonToPathOptions {
         x: number;
         y: number;
     };
+    /**
+     * `'lines'` (default) writes every ring as `M`/`L`/`Z`. `'fit'` fits cubic Béziers to each
+     * ring (`fitPathData`), so flattened curves come back as smooth `C` curves while sharp
+     * corners (turning more than `cornerAngleDeg`) and straight edges stay as they are.
+     */
+    curves?: 'lines' | 'fit';
+    /** Curve-fitting tolerance in path units for `curves: 'fit'` (default 0.25). */
+    curveTolerance?: number;
+    /** Corner threshold in degrees for `curves: 'fit'` (default 30). */
+    cornerAngleDeg?: number;
 }
 /**
  * Converts a multi-polygon (or a list of rings) to SVG path data using `M`/`L`/`Z`. Holes
@@ -1103,6 +954,16 @@ interface CombineShapeNodesOptions extends ShapeNodePolygonOptions {
     precision?: number;
     /** Ramer–Douglas–Peucker simplification tolerance for the result (default 0, off). */
     simplify?: number;
+    /**
+     * How the result's outline is written: `'fit'` (default) fits smooth cubic curves to the
+     * flattened result, so booleans of curved shapes stay curved (sharp corners and straight
+     * edges are kept); `'lines'` writes the polygon as straight segments.
+     */
+    curves?: 'lines' | 'fit';
+    /** Curve-fitting tolerance in flow units for `curves: 'fit'` (default: `tolerance`, 0.25). */
+    curveTolerance?: number;
+    /** Corner threshold in degrees for `curves: 'fit'` (default 30). */
+    cornerAngleDeg?: number;
     /** Point-merge tolerance passed to the boolean engine. */
     epsilon?: number;
     /** Select the new nodes (default `true`). */
@@ -1169,6 +1030,284 @@ declare function revertShapeCombination<TNode extends CanvasNode>(nodes: TNode[]
     nodes: TNode[];
 }, previous: TNode[]): TNode[];
 
+/** A resize handle, named like xyflow's `ControlPosition`. */
+type ResizeHandle = 'top-left' | 'top' | 'top-right' | 'right' | 'bottom-right' | 'bottom' | 'bottom-left' | 'left';
+declare const RESIZE_HANDLES: readonly ResizeHandle[];
+/** Which edge of each axis a handle moves: -1 the start (left / top), 1 the end, 0 none. */
+declare function resizeHandleAxes(handle: ResizeHandle): {
+    x: -1 | 0 | 1;
+    y: -1 | 0 | 1;
+};
+/**
+ * The handle a resize from `start` to `next` was made with, from the edges that moved, or
+ * `null` when no edge moved.
+ */
+declare function inferResizeHandle(start: Rect, next: Rect, eps?: number): ResizeHandle | null;
+interface SnapResizeOptions extends Omit<SnapGuidesOptions, 'spacing'> {
+    /**
+     * Keep the input box's aspect ratio. A corner snaps whichever axis is closer to a target
+     * and the other follows; a side scales the other axis about its centre.
+     */
+    keepAspectRatio?: boolean;
+    /** Smallest width a snap may leave (default: anything above 0). */
+    minWidth?: number;
+    /** Smallest height a snap may leave (default: anything above 0). */
+    minHeight?: number;
+}
+interface SnapResizeResult {
+    /** The snapped box. */
+    rect: Rect;
+    /** Guide segments for the shape snaps that were applied (grid snaps draw none). */
+    guides: GuideLine[];
+    /** Whether the moving x edge snapped to a shape. */
+    snappedX: boolean;
+    /** Whether the moving y edge snapped to a shape. */
+    snappedY: boolean;
+    /** Whether `rect` differs from the input. */
+    changed: boolean;
+}
+/**
+ * Snaps a resize of the axis-aligned box `rect` made with `handle` against `targets`. The
+ * opposite edge (side handles) or corner (corner handles) stays fixed:
+ *
+ * - A **side** handle snaps its one moving edge to the nearest target edge or centre within
+ *   `threshold` screen pixels.
+ * - A **corner** handle snaps x and y independently (unless `keepAspectRatio`).
+ * - A snap that would collapse or flip the box (or go below `minWidth` / `minHeight`) is
+ *   rejected; the next nearest target is tried, else the edge stays where it was dragged.
+ * - With `gridSize`, an axis without a shape snap snaps its moving edge to the grid.
+ *
+ * Returns the snapped box and the guides to draw (same shape as drag snapping).
+ */
+declare function snapResize(rect: Rect, handle: ResizeHandle, targets: Rect[] | GuideIndex, options?: SnapResizeOptions): SnapResizeResult;
+interface SnapNodeResizeOptions extends SnapResizeOptions, NodeRectOptions {
+    /** Index from `createNodeGuideIndex(nodes, [id])`, reused across resize frames. */
+    index?: GuideIndex;
+}
+interface SnapNodeResizeResult extends SnapResizeResult {
+    /** Position / size update for the node (parent-relative position), or none. */
+    updates: CanvasNodeUpdate[];
+}
+/**
+ * Snaps a node that is being resized. `rect` is the node's proposed absolute box (e.g. from
+ * a resize event) and `handle` the handle being dragged. Locked nodes are never snapped.
+ * The node itself and its descendants are not snap targets.
+ */
+declare function snapNodeResize(nodes: CanvasNode[], id: string, rect: Rect, handle: ResizeHandle, options?: SnapNodeResizeOptions): SnapNodeResizeResult;
+/**
+ * Absolute box of a node while it is being resized: flow libraries write the new size to
+ * `width` / `height` before the DOM is re-measured, so those win over `measured` here.
+ */
+declare function getResizingNodeRect(node: CanvasNode, lookup: ReadonlyMap<string, CanvasNode>, options?: NodeRectOptions): Rect;
+
+/**
+ * Figma-style auto layout for xyflow sub-flows.
+ *
+ * A *frame* is any node with `data.layout` (an {@link AutoLayout}); its children are the nodes
+ * whose `parentId` is the frame, in node-array order. Children may carry `data.childLayout`
+ * (an {@link AutoLayoutChild}) for their own sizing, min / max, absolute positioning,
+ * constraints and grid cell. The functions here are pure: they return `CanvasNodeUpdate`s
+ * (positions relative to the parent, sizes) for `applyNodeUpdates`.
+ */
+/** Data key holding a frame's {@link AutoLayout}. */
+declare const AUTO_LAYOUT_DATA_KEY = "layout";
+/** Data key holding a child's {@link AutoLayoutChild}. */
+declare const CHILD_LAYOUT_DATA_KEY = "childLayout";
+type AutoLayoutMode = 'horizontal' | 'vertical' | 'grid';
+/** `fixed` keeps the size, `hug` fits the content (frames and text), `fill` shares the parent's free space. */
+type AutoLayoutSizing = 'fixed' | 'hug' | 'fill';
+type AutoLayoutAlignMain = 'start' | 'center' | 'end' | 'space-between' | 'space-around' | 'space-evenly';
+type AutoLayoutAlignCross = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+/** How wrapped lines share the free cross space: packed by `alignCross` (`auto`) or spread (`space-between`). */
+type AutoLayoutAlignContent = 'auto' | 'space-between';
+/** `number` (all sides), `[vertical, horizontal]`, `[top, right, bottom, left]` or per side. */
+type AutoLayoutPadding = number | [number, number] | [number, number, number, number] | {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+interface AutoLayoutSize {
+    width?: number;
+    height?: number;
+}
+interface AutoLayoutSizingPair {
+    width?: AutoLayoutSizing;
+    height?: AutoLayoutSizing;
+}
+/** A grid track: pixels, `'hug'` (fits its content), `'2fr'` or `{ fr: 2 }` (shares the rest like CSS `fr`). */
+type AutoLayoutGridTrack = number | 'hug' | `${number}fr` | {
+    fr: number;
+};
+interface AutoLayoutGrid {
+    /** Column count (all `1fr`) or the column tracks (default 2 columns). */
+    columns?: number | AutoLayoutGridTrack[];
+    /** Minimum row count or the row tracks (default 1); rows are added to fit the children. Missing tracks are `1fr`. */
+    rows?: number | AutoLayoutGridTrack[];
+}
+/** A frame's auto layout (`node.data.layout`). */
+interface AutoLayout {
+    mode: AutoLayoutMode;
+    /** Main-axis gap (grid: column gap). Negative gaps overlap. Default 0. */
+    gap?: number;
+    /** Gap between wrapped lines (grid: row gap). Default: `gap`. */
+    rowGap?: number;
+    /** Default 0. */
+    padding?: AutoLayoutPadding;
+    /** Horizontal / vertical: wrap into lines when the main axis runs out (ignored while hugging it). */
+    wrap?: boolean;
+    /** Default `start`. Grid: the cell alignment along x (`start`, `center`, `end`). */
+    alignMain?: AutoLayoutAlignMain;
+    /** Default `start`. `baseline` applies to horizontal layouts. Grid: the cell alignment along y. */
+    alignCross?: AutoLayoutAlignCross;
+    alignContent?: AutoLayoutAlignContent;
+    /** The frame's own sizing (`childLayout.sizing` wins when both are set). Default `fixed`. */
+    sizing?: AutoLayoutSizingPair;
+    /** The frame's own limits (`childLayout.min` / `max` win when set). */
+    min?: AutoLayoutSize;
+    max?: AutoLayoutSize;
+    grid?: AutoLayoutGrid;
+}
+type AutoLayoutHorizontalConstraint = 'left' | 'right' | 'leftRight' | 'center' | 'scale';
+type AutoLayoutVerticalConstraint = 'top' | 'bottom' | 'topBottom' | 'center' | 'scale';
+interface AutoLayoutConstraints {
+    horizontal?: AutoLayoutHorizontalConstraint;
+    vertical?: AutoLayoutVerticalConstraint;
+}
+type AutoLayoutCellAlign = 'start' | 'center' | 'end';
+/** A grid child's cell. Column / row are 0-based anchors; unanchored children flow in reading order. */
+interface AutoLayoutGridArea {
+    column?: number;
+    row?: number;
+    columnSpan?: number;
+    rowSpan?: number;
+    /** The child's own alignment in its cell (wins over the frame's). */
+    alignX?: AutoLayoutCellAlign;
+    alignY?: AutoLayoutCellAlign;
+}
+/** A child's layout properties (`node.data.childLayout`). */
+interface AutoLayoutChild {
+    sizing?: AutoLayoutSizingPair;
+    min?: AutoLayoutSize;
+    max?: AutoLayoutSize;
+    /** Ignore auto layout: keep its place and follow `constraints` when the frame resizes. */
+    absolute?: boolean;
+    /** How the child follows its parent's resizes (default left / top). */
+    constraints?: AutoLayoutConstraints;
+    gridArea?: AutoLayoutGridArea;
+}
+/**
+ * Measuring hooks. `size` defaults to `getNodeSize` (xyflow `measured` size, then `width` /
+ * `height`, then style). Nodes for which `textSize` returns a size are *text-like*: they can
+ * hug, and wrap (`textHeight`) when their width is set by the layout.
+ */
+interface AutoLayoutMeasure {
+    size?: (node: CanvasNode) => {
+        width: number;
+        height: number;
+    } | undefined;
+    /** Natural (unwrapped) size of a text-like node. */
+    textSize?: (node: CanvasNode) => {
+        width: number;
+        height: number;
+    } | undefined;
+    /** Height of a text-like node wrapped at `width`. */
+    textHeight?: (node: CanvasNode, width: number) => number | undefined;
+    /** Distance from the node's top to its first text baseline (for `alignCross: 'baseline'`). */
+    textBaseline?: (node: CanvasNode) => number | undefined;
+}
+interface AutoLayoutOptions {
+    measure?: AutoLayoutMeasure;
+    /** Size resolution for unmeasured nodes when `measure.size` is not given. */
+    rectOptions?: NodeRectOptions;
+}
+type Axis = 'width' | 'height';
+/** Clamps a size to `[min, max]`; non-finite or negative sizes become 0 and min wins over a smaller max. */
+declare function clampLayoutSize(value: number, min?: number, max?: number): number;
+/** The node's auto layout, or `undefined` when it is not an auto layout frame. */
+declare function getAutoLayout(node: CanvasNode | undefined | null): AutoLayout | undefined;
+/** Whether the node is an auto layout frame. */
+declare function isAutoLayoutFrame(node: CanvasNode | undefined | null): boolean;
+/** The node's child layout properties (empty when unset). */
+declare function getChildLayout(node: CanvasNode | undefined | null): AutoLayoutChild;
+/** Effective sizing of a node on one axis: `childLayout.sizing`, then `layout.sizing`, then `fixed`. */
+declare function getLayoutSizing(node: CanvasNode, axis: Axis): AutoLayoutSizing;
+/** Padding as `[top, right, bottom, left]`, sanitised (non-finite and negative values become 0). */
+declare function resolvePadding(padding: AutoLayoutPadding | undefined): [number, number, number, number];
+/** A grid child's cell (0-based column / row and spans). */
+interface AutoLayoutGridCell {
+    id: string;
+    column: number;
+    row: number;
+    columnSpan: number;
+    rowSpan: number;
+}
+/** A grid frame's resolved geometry (frame-local): column x ranges, row y ranges, cells and the size it wants. */
+interface AutoLayoutGridGeometry {
+    columns: [number, number][];
+    rows: [number, number][];
+    cells: AutoLayoutGridCell[];
+    width: number;
+    height: number;
+}
+/**
+ * Lays out one auto layout frame's children and sizes the frame when it hugs (nested frames
+ * that are resized by the layout are laid out again). Returns the position / size updates.
+ */
+declare function layoutFrame(nodes: CanvasNode[], frameId: string, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/** Lays out every auto layout frame, children before parents, so nested hugging settles in one pass. */
+declare function layoutAll(nodes: CanvasNode[], options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/**
+ * Lays out `changedId` (when it is a frame) and then each of its auto layout ancestors,
+ * innermost first. Use it after a node inside a frame was added, removed, resized or moved.
+ */
+declare function layoutUp(nodes: CanvasNode[], changedId: string, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/** {@link layoutUp} for several changed nodes at once (each chain once, innermost frames first). */
+declare function layoutUpMany(nodes: CanvasNode[], changedIds: Iterable<string>, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/**
+ * Children of `parentId` follow their constraints after the parent was resized from
+ * `previousSize` to its current size. In an auto layout frame only absolute children move
+ * (the layout places the others). Returns the updates.
+ */
+declare function applyConstraints(nodes: CanvasNode[], parentId: string, previousSize: {
+    width: number;
+    height: number;
+}, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/** The resolved grid of a grid frame (frame-local), from its children's current sizes. */
+declare function getAutoLayoutGrid(nodes: CanvasNode[], frameId: string, options?: AutoLayoutOptions): AutoLayoutGridGeometry | undefined;
+/** Ids of the children a frame places (visible, not absolute), in order. */
+declare function getFlowChildren(nodes: CanvasNode[], frameId: string): string[];
+/** The nearest auto layout frame that places `id` (its parent, when `id` is a flow child). */
+declare function getLayoutParent(nodes: CanvasNode[], id: string): CanvasNode | undefined;
+/**
+ * Makes a node's sizing coherent with where it sits, and that of its children: `fill` needs an
+ * auto layout parent that does not hug that axis (and a flow child), `hug` needs an auto layout
+ * frame or a text-like node (see `measure.textSize`); otherwise the axis becomes `fixed`.
+ * Writes `data.childLayout.sizing`. Returns a new array (unchanged nodes keep their identity).
+ */
+declare function makeSizingCoherent<TNode extends CanvasNode>(nodes: TNode[], id: string, options?: AutoLayoutOptions): TNode[];
+interface AutoLayoutInsertTarget {
+    frameId: string;
+    /** Index among the frame's flow children, not counting the dragged node. */
+    index: number;
+    /** Insertion marker (absolute flow coordinates) for `<CanvasGuidesLayer>`. */
+    guide: GuideLine;
+}
+/**
+ * Where a node dropped at `point` (absolute flow coordinates) goes among the flow children of
+ * auto layout frame `frameId`: the reading-order index of the slot under the point. `excludeId`
+ * (the dragged node) is left out of the siblings.
+ */
+declare function getAutoLayoutInsertTarget(nodes: CanvasNode[], frameId: string, point: XYPosition, options?: AutoLayoutOptions & {
+    excludeId?: string;
+}): AutoLayoutInsertTarget | undefined;
+/**
+ * Moves child `childId` of an auto layout frame to flow index `index` (among its flow siblings)
+ * by reordering the node array; parents still precede their children. Returns a new array
+ * (the same array when nothing moves).
+ */
+declare function moveLayoutChild<TNode extends CanvasNode>(nodes: TNode[], childId: string, index: number): TNode[];
+
 /** Minimal history surface (`HistoryManager` satisfies it). */
 interface ArrangeHistoryTarget {
     execute(command: Command): void;
@@ -1186,10 +1325,23 @@ interface CanvasArrangeControllerOptions<TNode extends CanvasNode = CanvasNode>
     guides?: Omit<SnapGuidesOptions, 'zoom'>;
     /** Turns drag snapping off while keeping the arrange actions (default `true`). */
     snapping?: boolean;
+    /** Turns resize snapping off (default: follows `snapping`). */
+    resizeSnapping?: boolean;
+    /** Resize options passed to `snapResize` (`keepAspectRatio`, `minWidth`, `minHeight`). */
+    resize?: {
+        keepAspectRatio?: boolean;
+        minWidth?: number;
+        minHeight?: number;
+    };
     /** Size resolution for unmeasured nodes. */
     rectOptions?: NodeRectOptions;
     /** Called whenever the guide segments change (set while dragging, cleared on drop). */
     onGuidesChange?: (guides: GuideLine[]) => void;
+    /**
+     * Re-run auto layout (`data.layout` frames) around the nodes an arrange action moves or
+     * resizes, in the same undoable step. `true` uses the default measuring.
+     */
+    autoLayout?: boolean | AutoLayoutOptions;
 }
 /**
  * A React Flow / SvelteFlow style node change; only `position` changes are inspected.
@@ -1256,6 +1408,31 @@ declare function createCanvasArrangeController<TNode extends CanvasNode = Canvas
      * A batch without a dragging position change ends the drag and clears the guides.
      */
     snapPositionChanges<TChange extends PositionChangeLike>(changes: TChange[]): TChange[];
+    /**
+     * Starts resize snapping for node `id`: records its box (to tell which handle is
+     * dragged) and caches the snap targets. Optional: `resize` starts lazily.
+     */
+    beginResize(id: string): void;
+    /**
+     * Snaps node `id` as currently sized in `getNodes()` (call it after the flow wrote the
+     * new size, e.g. SvelteFlow's `NodeResizer` `onResize`, deferred by a microtask) and
+     * writes the snapped box back through `setNodes` (not recorded in history). `handle`
+     * defaults to the one inferred from the edges that moved since `beginResize`. A locked
+     * node is restored to its starting box.
+     */
+    resize(id: string, handle?: ResizeHandle): SnapNodeResizeResult | null;
+    /**
+     * Ends resize snapping: clears guides and re-applies the last snapped box if the flow
+     * wrote the raw pointer size afterwards.
+     */
+    endResize(): void;
+    /**
+     * React Flow style: snaps the `dimensions` (and matching `position`) changes a
+     * `NodeResizer` emits in an `onNodesChange` batch and updates `guides`. The resize-end
+     * change (`resizing: false`) carries the raw pointer size, so the last snapped size is
+     * kept. Resize changes of locked nodes are dropped. Returns the (possibly new) changes.
+     */
+    snapResizeChanges<TChange extends PositionChangeLike>(changes: TChange[]): TChange[];
     /**
      * Clears guides and the cached snap targets. Call it from the flow's drag-stop
      * handler: flow libraries write the raw pointer position when a drag ends, so the
@@ -1265,4 +1442,249 @@ declare function createCanvasArrangeController<TNode extends CanvasNode = Canvas
 };
 type CanvasArrangeController<TNode extends CanvasNode = CanvasNode> = ReturnType<typeof createCanvasArrangeController<TNode>>;
 
-export { type AlignEdge, type AlignNodesOptions, type ArrangeHistoryTarget, type ArrangeShortcutBinding, CONNECTION_LINE_TYPES, type CanvasArrangeAction, type CanvasArrangeController, type CanvasArrangeControllerOptions, CanvasClipboardPayload, type CanvasConnectionLineType, CanvasEdge, type CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeStyle, type CanvasNodeUpdate, type CanvasScene, type CanvasScenesOptions, type CanvasScenesState, CanvasScenesStore, type CanvasViewport, type Clock, type CombineShapeNodesOptions, type CombineShapeNodesRefusal, type CombineShapeNodesResult, type ConnectorSnap, type ConnectorSnapOptions, type ConnectorSnapTarget, DEFAULT_ARRANGE_SHORTCUTS, DEFAULT_NODE_HEIGHT, DEFAULT_NODE_WIDTH, DEFAULT_PLACEMENT_GAP, DirectionalDisplacementOptions, type DistributeAxis, type DistributeMode, type DistributeNodesOptions, type EllipseShape, FanOutTrajectoryOptions, type FitViewportOptions, type FlattenOptions, type GuideIndex, type GuideLine, IncrementalLayoutOptions, LOCKED_DATA_KEY, LOCKED_PREVIOUS_FLAGS_KEY, ManualClock, type MatchSizeOptions, type MultiNodeTransitionOptions, type MultiPolygon, type NodeRectOptions, NodeTransition, type PathCommand, type PathShape, PlaceBesideOptions, Point, type PolygonBooleanOperation, type PolygonBooleanOptions, type PolygonFillRule, type PolygonInput, type PolygonOperand, type PolygonPiece, type PolygonRing, type PolygonToPathOptions, type PolygonWithHoles, Position, type PositionChangeLike, Rect, type RectShape, ReflowDisplacementOptions, type RegularPolygonShape, SHAPE_DATA_KEY, SHAPE_KINDS, SHAPE_NODE_TYPE, SHAPE_OPERATIONS, type SerializedCanvasScenes, type ShapeDescription, type ShapeKind, type ShapeNodePolygonOptions, type ShapeOperation, type ShapePaint, type ShapeRenderData, type ShapeSize, Side, type SizeDimension, type SnapGuidesOptions, type SnapNodeDragOptions, type SnapNodeDragResult, type SnapResult, type StarShape, StreamingLayoutManager, type StreamingLayoutManagerOptions, TrajectoryFunction, XYPosition, type ZOrderOperation, alignNodes, applyNodeUpdates, applyShapeCombination, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canCombineShapeNodes, canvasHeight, centerNodes, centre, collectDescendantIds, combineShapeNodes, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasArrangeController, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, createNodeLookup, defaultEasing, distributeNodes, dividePolygons, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitViewportToNodes, fitViewportToRect, flattenSvgPath, flowSide, formatNumber, getAbsolutePosition, getCenteredNodePosition, getLayoutedNodes, getNodeRect, getNodeShape, getNodeSize, getShapeRenderData, getShapeSvg, handlePoint, intersectPolygons, invertNodeUpdates, isEventFromTextInput, isLocked, isShapeDescription, isShapeNode, isValidCanvasEdge, isValidCanvasNode, isValidCanvasScene, isValidUrl, layoutBounds, linearPositionTrajectory, linearTrajectory, lockNodes, matchArrangeShortcut, matchSize, multiPolygonArea, multiPolygonBounds, nearestHandlePositions, oppositePosition, overlaps, pageHidden, parseCanvasClipboardData, parseCanvasScenes, parseSvgPath, placeBeside, pointInMultiPolygon, pointInRings, polygonArea, polygonBoolean, polygonToSvgPath, positionToSide, readStyleSize, realClock, remapPastedNodes, reorderNodes, repositionNodesTo, revertShapeCombination, ringSignedArea, runMultiNodeTransition, serializeCanvasNodes, shapeNodeToPolygon, shapeToPolygon, sideToPosition, simplifyRing, snapNodeDrag, subtractPolygons, toggleLockNodes, unionPolygons, unlockNodes, withStyleOpacity, withStyleSize, xorPolygons };
+/**
+ * A measuring line in flow coordinates. `measure` lines carry a `label` (the distance);
+ * `extension` lines are dashed, unlabelled lines that carry a gap over to the measured box
+ * when the gap line passes beside it.
+ */
+interface MeasureGuide extends GuideLine {
+    kind: 'measure' | 'extension';
+    /** The distance as shown on the label (`measure` lines only). */
+    label?: string;
+}
+/** A distance as shown on a label: absolute value, up to two decimals, no trailing zeros. */
+declare function measureLabel(distance: number): string;
+/**
+ * Distance lines from box `a` (the selection) to box `b` (the hovered shape):
+ *
+ * - **One inside the other**: from the inner box to each edge of the outer one, along the
+ *   inner box's centre lines (the same lines either way round).
+ * - **Overlapping**: between the matching edges (left to left, right to right, ...).
+ * - **Apart**: the horizontal and/or vertical gap, across the shared rows / columns, or from
+ *   the middle of `a` with a dashed `extension` line to `b` when the gap line passes beside it.
+ *   Touching boxes have no gap to draw.
+ */
+declare function measureBetween(a: Rect, b: Rect): MeasureGuide[];
+/**
+ * Distance lines from box `a` to an infinite guide line (`vertical` at x = `at`, otherwise
+ * horizontal at y = `at`): to the nearer side, or to both sides when the line crosses the box.
+ */
+declare function measureToLine(a: Rect, orientation: 'vertical' | 'horizontal', at: number): MeasureGuide[];
+interface MeasureSelectionResult {
+    /** Measuring lines in flow coordinates. */
+    guides: MeasureGuide[];
+    /** The box measured to (to outline), or `null` when nothing is measured. */
+    target: Rect | null;
+    /** The selection's bounding box, or `null` without a selection. */
+    selection: Rect | null;
+}
+interface MeasureSelectionOptions extends NodeRectOptions {
+}
+/**
+ * Alt-hover measuring on canvas nodes: from the bounding box of `selectedIds` (absolute,
+ * union of several nodes) to the hovered node. Hovering the selection itself, or nothing
+ * (`hoveredId` null), measures to the selection's parent (`parentId`) when it has one;
+ * a top-level selection then measures nothing. Hidden nodes are ignored.
+ */
+declare function measureSelection(nodes: CanvasNode[], selectedIds: Iterable<string>, hoveredId: string | null | undefined, options?: MeasureSelectionOptions): MeasureSelectionResult;
+/**
+ * Whether the measuring modifier (Alt / Option) is held after a keyboard or pointer event.
+ * `keyup` of Alt releases it; `keydown` of Alt or any event with `altKey` holds it.
+ */
+declare function isMeasureModifierHeld(event: {
+    type?: string;
+    key?: string;
+    altKey?: boolean;
+} | null | undefined): boolean;
+
+/**
+ * Least-squares cubic Bézier fitting of point sequences (Schneider-style: fit one cubic with
+ * fixed end tangents, reparameterise with Newton steps, split at the worst point), with
+ * corner preservation by a turning-angle test.
+ *
+ * Portions ported from vectorcraft-main/crates/pathops/src/fit.rs and
+ * vectorcraft-main/crates/pathops/src/edit.rs (MIT OR Apache-2.0, © ArtCraft Team and
+ * contributors). See THIRD_PARTY_NOTICES.md.
+ */
+
+/** One cubic Bézier segment. */
+interface CubicSegment {
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    p3: Point;
+}
+interface FitCubicsOptions {
+    /**
+     * Vertices where the polyline turns by more than this many degrees stay sharp corners
+     * (default 30). Use 180 to smooth through every vertex.
+     */
+    cornerAngleDeg?: number;
+    /** Treat the points as a closed ring (the last point connects back to the first). */
+    closed?: boolean;
+}
+/** Evaluates a cubic segment at `t` ∈ [0, 1]. */
+declare function cubicPointAt(c: CubicSegment, t: number): Point;
+/**
+ * Fits a G1-continuous chain of cubics through `points` (an open run) with the unit
+ * tangents `t0` (leaving the first point) and `t1` (arriving at the last point, forward);
+ * both are estimated from the end points when omitted. Every point lies within `tolerance`
+ * of the curve at its fitted parameter.
+ */
+declare function fitCubicRun(points: readonly Point[], tolerance: number, t0?: Point, t1?: Point): CubicSegment[];
+/**
+ * Fits cubic Bézier segments to a polyline (`closed` for a ring), keeping vertices that turn
+ * by more than `cornerAngleDeg` (default 30°) as sharp corners. Each stretch between corners
+ * is fitted Schneider-style so that every input point is within `tolerance` of the result.
+ *
+ * Returns the segments in order (consecutive segments share end points; a closed result ends
+ * where it starts). Fewer than two distinct points give an empty array.
+ */
+declare function fitCubics(points: readonly Point[], tolerance: number, options?: FitCubicsOptions): CubicSegment[];
+/** Whether a cubic is (within `tol`) the straight line from `p0` to `p3`. */
+declare function isStraightCubic(c: CubicSegment, tol: number): boolean;
+interface FitPathDataOptions extends FitCubicsOptions {
+    /** Fitting tolerance in path units (default 0.5). */
+    tolerance?: number;
+    /** Decimal places (default 3). */
+    precision?: number;
+    /** Added to every point before formatting. */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Keep the original polyline when fitting would need more segments than it has edges
+     * (default `true`), so fitting never makes a path heavier.
+     */
+    noWorse?: boolean;
+}
+/** SVG `d` for fitted segments (`L` for straight ones, `C` otherwise). */
+declare function cubicsToPathData(segments: readonly CubicSegment[], options?: {
+    precision?: number;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    closed?: boolean;
+    straightTolerance?: number;
+}): string;
+/**
+ * Fits smooth curves to a polygon ring (closed by default) and returns SVG path data with
+ * `C` curves for smooth stretches, `L` lines for straight ones and sharp corners kept.
+ * Use it for boolean results of curved shapes or to smooth freehand strokes
+ * (`{ closed: false }`, see `fitFreehandPath`).
+ */
+declare function fitPathData(ring: readonly Point[], options?: FitPathDataOptions): string;
+/**
+ * Smooths a freehand stroke (pointer samples) into an open SVG path of cubic curves.
+ * `tolerance` is the largest distance (in the points' units) a sample may be from the
+ * curve (default 1); sharp turns above `cornerAngleDeg` (default 30) stay corners.
+ */
+declare function fitFreehandPath(points: readonly Point[], options?: Omit<FitPathDataOptions, 'closed'>): string;
+
+interface CanvasAutoLayoutControllerOptions<TNode extends CanvasNode = CanvasNode> extends AutoLayoutOptions {
+    getNodes: () => TNode[];
+    setNodes: (nodes: TNode[]) => void;
+    /** When set, controller actions (add / remove / resize / reorder / apply) are one undoable step each. */
+    history?: ArrangeHistoryTarget;
+    /** Turns automatic relayout off (explicit `applyAutoLayout` still works). Default `true`. */
+    enabled?: boolean;
+    /** Reorder flow children by dragging them inside their frame (default `true`). */
+    dragReorder?: boolean;
+    /** Called when the drop marker of a reorder drag changes (empty when none). */
+    onGuidesChange?: (guides: GuideLine[]) => void;
+}
+/**
+ * Merges the updates of several layout passes (later ones win per field).
+ */
+declare function mergeNodeUpdates(...lists: CanvasNodeUpdate[][]): CanvasNodeUpdate[];
+/**
+ * Updates that re-run auto layout around `ids` after a change: each id's own layout (if a
+ * frame) and its auto layout ancestors, plus the frames that lost removed children
+ * (`parentIds`). Pure helper used by the controllers.
+ */
+declare function relayoutUpdates(nodes: CanvasNode[], ids: Iterable<string>, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/**
+ * Framework-agnostic auto layout controller shared by the React hook and the Svelte rune.
+ * Applies auto layout to frames (`data.layout`) after nodes inside them are added, removed,
+ * resized or reordered, either through its own (undoable) actions or by watching the flow's
+ * node changes (`noteChanges` + `flush`), and reorders flow children dragged within a frame.
+ */
+declare function createCanvasAutoLayoutController<TNode extends CanvasNode = CanvasNode>(options: CanvasAutoLayoutControllerOptions<TNode>): {
+    /** Drop marker of the active reorder drag (flow coordinates); empty otherwise. */
+    readonly guides: GuideLine[];
+    /**
+     * Lays out frame `frameId` and its auto layout ancestors (default: every frame) as one
+     * (optionally undoable) step. Returns the updates.
+     */
+    applyAutoLayout(frameId?: string): CanvasNodeUpdate[];
+    /** Updates that relayout around `ids` on the current nodes, without applying them. */
+    layoutUpdates(ids: Iterable<string>): CanvasNodeUpdate[];
+    /**
+     * Applies the relayout around `ids` (frames, or nodes inside frames) directly, not
+     * recorded in history: auto layout is derived state, re-run after any change.
+     */
+    relayout(ids: Iterable<string>): CanvasNodeUpdate[];
+    /**
+     * Adds `node` (into the frame named by its `parentId`, at flow `index` when given) and
+     * lays out its frame, as one step.
+     */
+    addNode(node: TNode, addOptions?: {
+        index?: number;
+    }): CanvasNodeUpdate[];
+    /** Removes nodes (and their descendants) and lays out the frames they leave, as one step. */
+    removeNodes(ids: Iterable<string>): CanvasNodeUpdate[];
+    /**
+     * Resizes node `id` (its children follow their constraints) and lays out around it,
+     * as one step.
+     */
+    resizeNode(id: string, size: {
+        width?: number;
+        height?: number;
+    }): CanvasNodeUpdate[];
+    /** Moves flow child `childId` to flow index `index` in its frame and lays it out, as one step. */
+    moveChild(childId: string, index: number): CanvasNodeUpdate[];
+    /** Where flow child `id` would drop if released at `point` (default: its centre). */
+    getInsertTarget(id: string, point?: XYPosition): AutoLayoutInsertTarget | undefined;
+    /** Records the start position of a reorder drag. Optional: `dragReorder` records it lazily. */
+    beginReorderDrag(id: string): void;
+    /**
+     * While flow child `id` is dragged (as currently positioned in `getNodes()`): updates the
+     * drop marker. Returns the insert target.
+     */
+    dragReorder(id: string, point?: XYPosition): AutoLayoutInsertTarget | undefined;
+    /**
+     * Ends a reorder drag: moves `id` to the slot under `point` (default: its centre) and lays
+     * the frame out, as one undoable step whose undo puts the node back where the drag began.
+     */
+    endReorderDrag(id: string, point?: XYPosition): CanvasNodeUpdate[];
+    /**
+     * Notes a batch of React Flow / SvelteFlow style node changes (before or after they are
+     * applied) so `flush` can relayout: dimension changes (measured sizes, resize ends),
+     * added and removed nodes, and position changes of flow children (reorder drags).
+     * Returns the changes unchanged.
+     */
+    noteChanges<TChange extends PositionChangeLike>(changes: TChange[]): TChange[];
+    /**
+     * Notes nodes that were already removed (e.g. SvelteFlow's `ondelete`), so `flush`
+     * relayouts the frames they left. The nodes must still carry their `parentId`.
+     */
+    noteRemoved(removed: Iterable<{
+        id: string;
+        parentId?: string;
+    }>): void;
+    /** Whether `noteChanges` left work for `flush`. */
+    readonly hasPending: boolean;
+    /**
+     * Applies the work noted by `noteChanges` to the current nodes: drop markers while
+     * dragging, committed reorders on drop (undoable), and a relayout (not recorded) for
+     * size, add and remove changes. Call it once the changes are applied.
+     */
+    flush(): CanvasNodeUpdate[];
+    /** Whether `id` is an auto layout frame. */
+    isFrame: (id: string) => boolean;
+};
+type CanvasAutoLayoutController<TNode extends CanvasNode = CanvasNode> = ReturnType<typeof createCanvasAutoLayoutController<TNode>>;
+
+export { AUTO_LAYOUT_DATA_KEY, AlignEdge, AlignNodesOptions, type ArrangeHistoryTarget, type AutoLayout, type AutoLayoutAlignContent, type AutoLayoutAlignCross, type AutoLayoutAlignMain, type AutoLayoutCellAlign, type AutoLayoutChild, type AutoLayoutConstraints, type AutoLayoutGrid, type AutoLayoutGridArea, type AutoLayoutGridCell, type AutoLayoutGridGeometry, type AutoLayoutGridTrack, type AutoLayoutHorizontalConstraint, type AutoLayoutInsertTarget, type AutoLayoutMeasure, type AutoLayoutMode, type AutoLayoutOptions, type AutoLayoutPadding, type AutoLayoutSize, type AutoLayoutSizing, type AutoLayoutSizingPair, type AutoLayoutVerticalConstraint, CHILD_LAYOUT_DATA_KEY, CONNECTION_LINE_TYPES, CanvasArrangeAction, type CanvasArrangeController, type CanvasArrangeControllerOptions, type CanvasAutoLayoutController, type CanvasAutoLayoutControllerOptions, CanvasClipboardPayload, type CanvasConnectionLineType, CanvasEdge, type CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeStyle, CanvasNodeUpdate, type CanvasScene, type CanvasScenesOptions, type CanvasScenesState, CanvasScenesStore, type CanvasViewport, type Clock, type CombineShapeNodesOptions, type CombineShapeNodesRefusal, type CombineShapeNodesResult, type ConnectorSnap, type ConnectorSnapOptions, type ConnectorSnapTarget, type CubicSegment, DEFAULT_NODE_HEIGHT, DEFAULT_NODE_WIDTH, DEFAULT_PLACEMENT_GAP, DirectionalDisplacementOptions, DistributeAxis, DistributeMode, DistributeNodesOptions, type EllipseShape, FanOutTrajectoryOptions, type FitCubicsOptions, type FitPathDataOptions, type FitViewportOptions, type FlattenOptions, type GuideIndex, type GuideLine, IncrementalLayoutOptions, ManualClock, MatchSizeOptions, type MeasureGuide, type MeasureSelectionOptions, type MeasureSelectionResult, type MultiNodeTransitionOptions, type MultiPolygon, NodeRectOptions, NodeTransition, type PathCommand, type PathShape, PlaceBesideOptions, Point, type PolygonBooleanOperation, type PolygonBooleanOptions, type PolygonFillRule, type PolygonInput, type PolygonOperand, type PolygonPiece, type PolygonRing, type PolygonToPathOptions, type PolygonWithHoles, Position, type PositionChangeLike, RESIZE_HANDLES, Rect, type RectShape, ReflowDisplacementOptions, type RegularPolygonShape, type ResizeHandle, SHAPE_DATA_KEY, SHAPE_KINDS, SHAPE_NODE_TYPE, SHAPE_OPERATIONS, type SerializedCanvasScenes, type ShapeDescription, type ShapeKind, type ShapeNodePolygonOptions, type ShapeOperation, type ShapePaint, type ShapeRenderData, type ShapeSize, Side, SizeDimension, type SnapGuidesOptions, type SnapNodeDragOptions, type SnapNodeDragResult, type SnapNodeResizeOptions, type SnapNodeResizeResult, type SnapResizeOptions, type SnapResizeResult, type SnapResult, type StarShape, StreamingLayoutManager, type StreamingLayoutManagerOptions, TrajectoryFunction, XYPosition, ZOrderOperation, applyConstraints, applyShapeCombination, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canCombineShapeNodes, canvasHeight, centerNodes, centre, clampLayoutSize, collectDescendantIds, combineShapeNodes, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasArrangeController, createCanvasAutoLayoutController, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, cubicPointAt, cubicsToPathData, defaultEasing, dividePolygons, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitCubicRun, fitCubics, fitFreehandPath, fitPathData, fitViewportToNodes, fitViewportToRect, flattenSvgPath, flowSide, formatNumber, getAutoLayout, getAutoLayoutGrid, getAutoLayoutInsertTarget, getCenteredNodePosition, getChildLayout, getFlowChildren, getLayoutParent, getLayoutSizing, getLayoutedNodes, getNodeShape, getResizingNodeRect, getShapeRenderData, getShapeSvg, handlePoint, inferResizeHandle, intersectPolygons, isAutoLayoutFrame, isEventFromTextInput, isMeasureModifierHeld, isShapeDescription, isShapeNode, isStraightCubic, isValidCanvasEdge, isValidCanvasNode, isValidCanvasScene, isValidUrl, layoutAll, layoutBounds, layoutFrame, layoutUp, layoutUpMany, linearPositionTrajectory, linearTrajectory, makeSizingCoherent, measureBetween, measureLabel, measureSelection, measureToLine, mergeNodeUpdates, moveLayoutChild, multiPolygonArea, multiPolygonBounds, nearestHandlePositions, oppositePosition, overlaps, pageHidden, parseCanvasClipboardData, parseCanvasScenes, parseSvgPath, placeBeside, pointInMultiPolygon, pointInRings, polygonArea, polygonBoolean, polygonToSvgPath, positionToSide, realClock, relayoutUpdates, remapPastedNodes, repositionNodesTo, resizeHandleAxes, resolvePadding, revertShapeCombination, ringSignedArea, runMultiNodeTransition, serializeCanvasNodes, shapeNodeToPolygon, shapeToPolygon, sideToPosition, simplifyRing, snapNodeDrag, snapNodeResize, snapResize, snapToGrid, subtractPolygons, unionPolygons, withStyleOpacity, xorPolygons };