@pixerate/editor 0.25.0 → 0.26.1

package/dist/{arrangeShortcuts-sLlD2rSX.d.ts → arrange-BICutYPk.d.ts}

@@ -1,4 +1,245 @@
-import { R as Rect, X as XYPosition, C as CanvasNode, a as CanvasNodeStyle } from './types-DX4Mh4SL.js';
+/**
+ * Generic coordinate and boundary primitives.
+ */
+interface XYPosition {
+    x: number;
+    y: number;
+}
+type Point = readonly [number, number];
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type Position = 'top' | 'right' | 'bottom' | 'left';
+type Side = 'right' | 'below' | 'left' | 'above';
+/**
+ * Node style: a CSS string (SvelteFlow) or a style object (React Flow / xyflow).
+ */
+type CanvasNodeStyle = string | Record<string, any>;
+/**
+ * Generic canvas node structure compatible across SvelteFlow and ReactFlow.
+ */
+interface CanvasNode<TData extends Record<string, any> = Record<string, any>, TType extends string | undefined = string | undefined> {
+    id: string;
+    position: XYPosition;
+    data: TData;
+    type?: TType;
+    selected?: boolean;
+    draggable?: boolean;
+    selectable?: boolean;
+    deletable?: boolean;
+    parentId?: string;
+    width?: number;
+    height?: number;
+    measured?: {
+        width?: number;
+        height?: number;
+    };
+    style?: CanvasNodeStyle;
+    className?: string;
+    class?: string;
+    [key: string]: any;
+}
+/**
+ * Generic canvas edge structure.
+ */
+interface CanvasEdge<TData extends Record<string, any> = Record<string, any>, TType extends string | undefined = string | undefined> {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+    data?: TData;
+    type?: TType;
+    label?: string;
+    selected?: boolean;
+    animated?: boolean;
+    style?: string;
+    [key: string]: any;
+}
+/**
+ * Differences computed between two graph states.
+ */
+interface GraphDifferences<TNode extends CanvasNode = CanvasNode, TEdge extends CanvasEdge = CanvasEdge> {
+    changedNodes: TNode[];
+    changedEdges: TEdge[];
+    removedNodes: TNode[];
+    removedEdges: TEdge[];
+}
+/**
+ * Standard serialized clipboard payload for nodes and optional edges.
+ */
+interface CanvasClipboardPayload<TNode extends CanvasNode = CanvasNode, TEdge extends CanvasEdge = CanvasEdge> {
+    version?: number;
+    nodes: TNode[];
+    edges?: TEdge[];
+}
+/**
+ * Options for Dagre graph layout.
+ */
+interface CanvasLayoutOptions {
+    direction?: 'LR' | 'TB' | 'RL' | 'BT';
+    ranksep?: number;
+    nodesep?: number;
+    defaultNodeWidth?: number;
+    defaultNodeHeight?: number;
+}
+/**
+ * Incremental layout options.
+ */
+interface IncrementalLayoutOptions extends CanvasLayoutOptions {
+    /**
+     * Stored known coordinates for nodes, e.g. from user manual layout or persistence.
+     */
+    storedPositions?: Record<string, XYPosition>;
+}
+/**
+ * Options for directional collision-aware placement.
+ */
+interface PlaceBesideOptions {
+    gap?: number;
+    ignore?: string[];
+    stepIncrement?: number;
+    maxAttempts?: number;
+}
+/**
+ * Parametric point returned by a trajectory evaluation.
+ */
+interface TrajectoryPoint {
+    position: XYPosition;
+    scale?: number;
+    opacity?: number;
+}
+/**
+ * Trajectory evaluation function determining path, scale, and opacity over time t in [0, 1].
+ */
+type TrajectoryFunction = (origin: XYPosition, target: XYPosition, progress: number, index: number, total: number) => TrajectoryPoint;
+/**
+ * Options for fan-out trajectory generator.
+ */
+interface FanOutTrajectoryOptions {
+    curvature?: number;
+    spreadAngle?: number;
+    startScale?: number;
+    endScale?: number;
+    startOpacity?: number;
+    endOpacity?: number;
+}
+/**
+ * Single node animation transition definition.
+ */
+interface NodeTransition<TNode extends CanvasNode = CanvasNode> {
+    node: TNode;
+    from: XYPosition;
+    to: XYPosition;
+    trajectory?: TrajectoryFunction;
+    delay?: number;
+    duration?: number;
+    easing?: (t: number) => number;
+    index?: number;
+    total?: number;
+}
+/**
+ * Displacement axis / direction.
+ */
+type DisplacementDirection = 'right' | 'left' | 'down' | 'up' | 'vertical';
+/**
+ * Options for directional displacement calculation.
+ */
+interface DirectionalDisplacementOptions {
+    direction?: DisplacementDirection;
+    gap?: number;
+    spreadSiblingLanes?: boolean;
+    siblingTolerance?: number;
+    minY?: number;
+}
+/**
+ * Options for Dagre reflow displacement calculation.
+ */
+interface ReflowDisplacementOptions extends CanvasLayoutOptions {
+    anchorNodeId: string;
+}
+/**
+ * Snapshot of canvas graph state prior to node explosion, enabling exact reversibility.
+ */
+interface ExplosionSnapshot<TNode extends CanvasNode = CanvasNode, TEdge extends CanvasEdge = CanvasEdge> {
+    parentId: string;
+    childNodeIds: string[];
+    childEdgeIds: string[];
+    displacedNodes: {
+        id: string;
+        originalPosition: XYPosition;
+    }[];
+    timestamp: number;
+}
+/**
+ * Options for exploding a node.
+ */
+interface ExplodeNodeOptions<TNode extends CanvasNode = CanvasNode, TEdge extends CanvasEdge = CanvasEdge> {
+    childNodes: TNode[];
+    childEdges?: TEdge[];
+    connectParentToChildren?: boolean | 'first' | 'all';
+    connectChildrenToDownstream?: boolean;
+    displacementStrategy?: 'directional' | 'dagre' | 'none';
+    directionalOptions?: DirectionalDisplacementOptions;
+    reflowOptions?: Partial<ReflowDisplacementOptions>;
+    trajectory?: TrajectoryFunction;
+    duration?: number;
+    staggerDelay?: number;
+    easing?: (t: number) => number;
+    onComplete?: () => void;
+}
+/**
+ * Options for collapsing an exploded node.
+ */
+interface CollapseNodeOptions {
+    duration?: number;
+    staggerDelay?: number;
+    easing?: (t: number) => number;
+    trajectory?: TrajectoryFunction;
+    onComplete?: () => void;
+}
+/**
+ * Strategy used to resolve the primary dock target when multiple targets intersect a dragged node.
+ */
+type DockStrategy = 'center-point' | 'max-overlap' | 'pointer' | 'first';
+/**
+ * Docking and intersection callbacks.
+ */
+interface CanvasDockingCallbacks<TNode extends CanvasNode = CanvasNode> {
+    onDockHover?: (dockTarget: TNode, draggedNode: TNode) => void;
+    onDockLeave?: (dockTarget: TNode, draggedNode: TNode) => void;
+    onDockDrop?: (dockTarget: TNode, draggedNode: TNode) => void;
+}
+
+/**
+ * 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. Built on the command system's `ShortcutMap` (matching `event.code`).
+ */
+declare function matchArrangeShortcut(event: KeyboardEvent, bindings?: readonly ArrangeShortcutBinding[]): CanvasArrangeAction | null;
 
 /**
  * Edge (or centre line) used by `alignNodes`.
@@ -154,31 +395,4 @@ declare function applyNodeUpdates<TNode extends CanvasNode>(nodes: TNode[], upda
  */
 declare function invertNodeUpdates(nodes: CanvasNode[], updates: CanvasNodeUpdate[]): CanvasNodeUpdate[];
 
-/**
- * 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. Built on the command system's `ShortcutMap` (matching `event.code`).
- */
-declare function matchArrangeShortcut(event: KeyboardEvent, bindings?: readonly ArrangeShortcutBinding[]): CanvasArrangeAction | null;
-
-export { type AlignEdge as A, type CanvasArrangeAction as C, type DistributeAxis as D, LOCKED_DATA_KEY as L, type MatchSizeOptions as M, type NodeRectOptions as N, type SizeDimension as S, type ZOrderOperation as Z, type DistributeMode as a, type CanvasNodeUpdate as b, type AlignNodesOptions as c, type DistributeNodesOptions as d, type ArrangeShortcutBinding as e, DEFAULT_ARRANGE_SHORTCUTS as f, LOCKED_PREVIOUS_FLAGS_KEY as g, alignNodes as h, applyNodeUpdates as i, createNodeLookup as j, distributeNodes as k, getAbsolutePosition as l, getNodeRect as m, getNodeSize as n, invertNodeUpdates as o, isLocked as p, lockNodes as q, matchArrangeShortcut as r, matchSize as s, readStyleSize as t, reorderNodes as u, toggleLockNodes as v, unlockNodes as w, withStyleSize as x };
+export { reorderNodes as $, type AlignEdge as A, createNodeLookup as B, type CanvasArrangeAction as C, type DistributeAxis as D, type ExplodeNodeOptions as E, type FanOutTrajectoryOptions as F, type GraphDifferences as G, distributeNodes as H, type IncrementalLayoutOptions as I, getAbsolutePosition as J, getNodeRect as K, LOCKED_DATA_KEY as L, type MatchSizeOptions as M, type NodeTransition as N, getNodeSize as O, type PlaceBesideOptions as P, invertNodeUpdates as Q, type Rect as R, type Side as S, type TrajectoryFunction as T, isLocked as U, lockNodes as V, matchArrangeShortcut as W, type XYPosition as X, matchSize as Y, type ZOrderOperation as Z, readStyleSize as _, type DistributeMode as a, toggleLockNodes as a0, unlockNodes as a1, withStyleSize as a2, type CanvasNode as b, type CanvasEdge as c, type CanvasLayoutOptions as d, type CanvasNodeStyle as e, type ReflowDisplacementOptions as f, type DirectionalDisplacementOptions as g, type CanvasClipboardPayload as h, type CanvasNodeUpdate as i, type NodeRectOptions as j, type Position as k, type Point as l, type AlignNodesOptions as m, type DistributeNodesOptions as n, type SizeDimension as o, type ArrangeShortcutBinding as p, type CanvasDockingCallbacks as q, type CollapseNodeOptions as r, DEFAULT_ARRANGE_SHORTCUTS as s, type DisplacementDirection as t, type DockStrategy as u, type ExplosionSnapshot as v, LOCKED_PREVIOUS_FLAGS_KEY as w, type TrajectoryPoint as x, alignNodes as y, applyNodeUpdates as z };

package/dist/builtins-CdPcLwwF.d.cts

@@ -0,0 +1,176 @@
+import { H as HistoryState } from './types-GT5a5YAX.cjs';
+import { C as CanvasArrangeAction, A as AlignEdge, D as DistributeAxis, a as DistributeMode, Z as ZOrderOperation } from './arrange-BICutYPk.cjs';
+import { S as ShortcutBinding, C as CommandSpec, K as KeyboardEventLike, P as Platform } from './registry-D0GADKc7.cjs';
+
+/** Minimal history surface (`HistoryManager` satisfies it). */
+interface HistoryCommandTarget {
+    undo(): boolean | void;
+    redo(): boolean | void;
+    getState(): Pick<HistoryState, 'canUndo' | 'canRedo'> & Partial<Pick<HistoryState, 'undoName' | 'redoName'>>;
+}
+/** Default history bindings: `Mod+Z` undo; `Mod+Shift+Z` redo, plus `Mod+Y` off macOS. */
+declare const DEFAULT_HISTORY_SHORTCUTS: readonly ShortcutBinding[];
+interface HistoryCommandOptions {
+    /** Id prefix (default `history.`). */
+    prefix?: string;
+    group?: string;
+    scope?: string;
+}
+/** `history.undo` / `history.redo` commands for a `HistoryManager` (disabled with a reason when empty). */
+declare function createHistoryCommands(history: HistoryCommandTarget, options?: HistoryCommandOptions): CommandSpec[];
+/**
+ * Resolves a keydown event to `undo` / `redo` with the default history bindings
+ * (`Mod` is ⌘ on macOS and Ctrl elsewhere). Events from text inputs and
+ * contenteditable elements are ignored unless `allowInEditable`.
+ */
+declare function matchHistoryShortcut(event: KeyboardEventLike, options?: {
+    platform?: Platform;
+    allowInEditable?: boolean;
+}): 'undo' | 'redo' | null;
+/** Minimal arrange controller surface (`createCanvasArrangeController` satisfies it). */
+interface ArrangeCommandTarget {
+    align(edge: AlignEdge, ids?: Iterable<string>): unknown;
+    distribute(axis: DistributeAxis, mode?: DistributeMode, ids?: Iterable<string>): unknown;
+    reorder(operation: ZOrderOperation, ids?: Iterable<string>): unknown;
+    lock(ids?: Iterable<string>): unknown;
+    unlock(ids?: Iterable<string>): unknown;
+}
+interface ArrangeCommandOptions {
+    /** Id prefix (default `canvas.`). */
+    prefix?: string;
+    group?: string;
+    /** Scope of the commands and their shortcuts (default `canvas`). Pass `null` for global. */
+    scope?: string | null;
+    /** Current selection, used for enablement ("Select at least two nodes"). */
+    getSelectedIds?: () => string[];
+    /** Scene navigation (`nextScene` / `previousScene`); those commands are only added when given. */
+    scenes?: {
+        next(): unknown;
+        previous(): unknown;
+    };
+    /** Use these bindings instead of `DEFAULT_ARRANGE_SHORTCUTS`. */
+    bindings?: readonly {
+        action: CanvasArrangeAction;
+        label: string;
+    }[];
+}
+/**
+ * Commands for the canvas arrange actions (`canvas.alignLeft`, `canvas.bringToFront`, …)
+ * with the default arrange shortcuts. Each accepts `{ ids? }`; enablement checks the
+ * named ids, or the selection when none are named.
+ */
+declare function createArrangeCommands(controller: ArrangeCommandTarget, options?: ArrangeCommandOptions): CommandSpec[];
+/** Shape operations surface of the arrange controller (`createCanvasArrangeController` satisfies it). */
+interface ShapeCommandTarget {
+    combineShapes(operation: 'unite' | 'intersect' | 'subtract' | 'exclude' | 'divide', ids?: Iterable<string>): unknown;
+    canCombineShapes(ids?: Iterable<string>): boolean;
+    offsetShapes(distance: number, ids?: Iterable<string>, options?: {
+        join?: 'miter' | 'round' | 'bevel';
+        miterLimit?: number;
+    }): unknown;
+    canOffsetShapes(ids?: Iterable<string>): boolean;
+    outlineStroke(ids?: Iterable<string>, options?: {
+        join?: 'miter' | 'round' | 'bevel';
+        cap?: 'butt' | 'round' | 'square';
+        miterLimit?: number;
+    }): unknown;
+    canOutlineStroke(ids?: Iterable<string>): boolean;
+}
+interface ShapeCommandOptions {
+    /** Id prefix (default `canvas.`). */
+    prefix?: string;
+    group?: string;
+    /** Scope (default `canvas`). Pass `null` for global. */
+    scope?: string | null;
+    /** Offset distance used when `canvas.offsetPath` is run without one (default 10). */
+    defaultOffset?: number;
+}
+/**
+ * Palette / context-menu / agent commands for the shape operations: `canvas.unite`,
+ * `canvas.intersect`, `canvas.subtract`, `canvas.exclude`, `canvas.divide`,
+ * `canvas.offsetPath` (`{ distance, join?, miterLimit?, ids? }`) and `canvas.outlineStroke`
+ * (`{ join?, cap?, miterLimit?, ids? }`). Each is one undoable step when the controller has a
+ * history; enablement explains why a command cannot run.
+ */
+declare function createShapeCommands(controller: ShapeCommandTarget, options?: ShapeCommandOptions): CommandSpec[];
+type ComponentActionResult = {
+    ok: true;
+    ids: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+/** Components surface of the components controller (`createCanvasComponentsController` satisfies it). */
+interface ComponentCommandTarget {
+    createComponent(ids?: Iterable<string>): ComponentActionResult;
+    canCreateComponent(ids?: Iterable<string>): true | string;
+    combineAsVariants(ids?: Iterable<string>): ComponentActionResult;
+    canCombineAsVariants(ids?: Iterable<string>): true | string;
+    createInstance(componentId: string, options?: {
+        parentId?: string;
+        position?: {
+            x: number;
+            y: number;
+        };
+        properties?: Record<string, boolean | string>;
+    }): ComponentActionResult;
+    canCreateInstance(componentId?: string, parentId?: string): true | string;
+    detachInstance(ids?: Iterable<string>): ComponentActionResult;
+    canDetachInstance(ids?: Iterable<string>): true | string;
+    resetOverrides(id?: string, group?: string): ComponentActionResult;
+    canResetOverrides(id?: string): true | string;
+    pushOverrides(id?: string): ComponentActionResult;
+    canPushOverrides(id?: string): true | string;
+    swapInstance(componentId: string, ids?: Iterable<string>): ComponentActionResult;
+    canSwapInstance(componentId?: string, ids?: Iterable<string>): true | string;
+    setInstanceProperties(properties: Record<string, unknown>, ids?: Iterable<string>): ComponentActionResult;
+    canSetInstanceProperties(ids?: Iterable<string>): true | string;
+    restoreMainComponent(id?: string): ComponentActionResult;
+    canRestoreMainComponent(id?: string): true | string;
+    goToMainComponent(id?: string): string | undefined;
+    canGoToMainComponent(id?: string): true | string;
+    list(): unknown;
+    inspect(id?: string): unknown;
+}
+interface ComponentCommandOptions {
+    /** Id prefix (default `canvas.`). */
+    prefix?: string;
+    group?: string;
+    /** Scope (default `canvas`). Pass `null` for global. */
+    scope?: string | null;
+}
+/**
+ * Palette / context-menu / agent commands for components and instances:
+ * `canvas.createComponent`, `canvas.combineAsVariants`, `canvas.createInstance`
+ * (`{ componentId, parentId?, x?, y?, properties? }`), `canvas.detachInstance`,
+ * `canvas.resetOverrides` (`{ id?, group? }`), `canvas.pushOverrides`, `canvas.goToMainComponent`,
+ * `canvas.swapInstance` (`{ componentId, ids? }`), `canvas.setInstanceProperties`
+ * (`{ properties, ids? }`: variant and component property values), `canvas.restoreMainComponent`
+ * and the read-only `canvas.listComponents` / `canvas.inspectInstance`. Each action is one
+ * undoable step when the controller has a history; enablement explains why it cannot run.
+ */
+declare function createComponentCommands(controller: ComponentCommandTarget, options?: ComponentCommandOptions): CommandSpec[];
+/** Spreadsheet controller surface used by `createSpreadsheetCommands`. */
+interface SpreadsheetCommandTarget {
+    selectedRange: unknown;
+    getFilterState(): {
+        enabled: boolean;
+        rules: readonly unknown[];
+    };
+    toggleFilters(): void;
+    clearFilters(): void;
+    unhideAll(): void;
+    mergeCells(): boolean;
+    unmergeCells(): boolean;
+    transposeRange(): boolean;
+}
+interface SpreadsheetCommandOptions {
+    /** Id prefix (default `spreadsheet.`). */
+    prefix?: string;
+    /** Scope (default `spreadsheet`). Pass `null` for global. */
+    scope?: string | null;
+}
+/** Palette / agent commands for common spreadsheet table actions (no default shortcuts). */
+declare function createSpreadsheetCommands(controller: SpreadsheetCommandTarget, options?: SpreadsheetCommandOptions): CommandSpec[];
+
+export { type ArrangeCommandOptions as A, type ComponentCommandOptions as C, DEFAULT_HISTORY_SHORTCUTS as D, type HistoryCommandOptions as H, type ShapeCommandOptions as S, type ArrangeCommandTarget as a, type ComponentCommandTarget as b, type HistoryCommandTarget as c, type ShapeCommandTarget as d, type SpreadsheetCommandOptions as e, type SpreadsheetCommandTarget as f, createArrangeCommands as g, createComponentCommands as h, createHistoryCommands as i, createShapeCommands as j, createSpreadsheetCommands as k, matchHistoryShortcut as m };

package/dist/builtins-Chj6zv_O.d.ts

@@ -0,0 +1,176 @@
+import { H as HistoryState } from './types-GT5a5YAX.js';
+import { C as CanvasArrangeAction, A as AlignEdge, D as DistributeAxis, a as DistributeMode, Z as ZOrderOperation } from './arrange-BICutYPk.js';
+import { S as ShortcutBinding, C as CommandSpec, K as KeyboardEventLike, P as Platform } from './registry-DhVUZioj.js';
+
+/** Minimal history surface (`HistoryManager` satisfies it). */
+interface HistoryCommandTarget {
+    undo(): boolean | void;
+    redo(): boolean | void;
+    getState(): Pick<HistoryState, 'canUndo' | 'canRedo'> & Partial<Pick<HistoryState, 'undoName' | 'redoName'>>;
+}
+/** Default history bindings: `Mod+Z` undo; `Mod+Shift+Z` redo, plus `Mod+Y` off macOS. */
+declare const DEFAULT_HISTORY_SHORTCUTS: readonly ShortcutBinding[];
+interface HistoryCommandOptions {
+    /** Id prefix (default `history.`). */
+    prefix?: string;
+    group?: string;
+    scope?: string;
+}
+/** `history.undo` / `history.redo` commands for a `HistoryManager` (disabled with a reason when empty). */
+declare function createHistoryCommands(history: HistoryCommandTarget, options?: HistoryCommandOptions): CommandSpec[];
+/**
+ * Resolves a keydown event to `undo` / `redo` with the default history bindings
+ * (`Mod` is ⌘ on macOS and Ctrl elsewhere). Events from text inputs and
+ * contenteditable elements are ignored unless `allowInEditable`.
+ */
+declare function matchHistoryShortcut(event: KeyboardEventLike, options?: {
+    platform?: Platform;
+    allowInEditable?: boolean;
+}): 'undo' | 'redo' | null;
+/** Minimal arrange controller surface (`createCanvasArrangeController` satisfies it). */
+interface ArrangeCommandTarget {
+    align(edge: AlignEdge, ids?: Iterable<string>): unknown;
+    distribute(axis: DistributeAxis, mode?: DistributeMode, ids?: Iterable<string>): unknown;
+    reorder(operation: ZOrderOperation, ids?: Iterable<string>): unknown;
+    lock(ids?: Iterable<string>): unknown;
+    unlock(ids?: Iterable<string>): unknown;
+}
+interface ArrangeCommandOptions {
+    /** Id prefix (default `canvas.`). */
+    prefix?: string;
+    group?: string;
+    /** Scope of the commands and their shortcuts (default `canvas`). Pass `null` for global. */
+    scope?: string | null;
+    /** Current selection, used for enablement ("Select at least two nodes"). */
+    getSelectedIds?: () => string[];
+    /** Scene navigation (`nextScene` / `previousScene`); those commands are only added when given. */
+    scenes?: {
+        next(): unknown;
+        previous(): unknown;
+    };
+    /** Use these bindings instead of `DEFAULT_ARRANGE_SHORTCUTS`. */
+    bindings?: readonly {
+        action: CanvasArrangeAction;
+        label: string;
+    }[];
+}
+/**
+ * Commands for the canvas arrange actions (`canvas.alignLeft`, `canvas.bringToFront`, …)
+ * with the default arrange shortcuts. Each accepts `{ ids? }`; enablement checks the
+ * named ids, or the selection when none are named.
+ */
+declare function createArrangeCommands(controller: ArrangeCommandTarget, options?: ArrangeCommandOptions): CommandSpec[];
+/** Shape operations surface of the arrange controller (`createCanvasArrangeController` satisfies it). */
+interface ShapeCommandTarget {
+    combineShapes(operation: 'unite' | 'intersect' | 'subtract' | 'exclude' | 'divide', ids?: Iterable<string>): unknown;
+    canCombineShapes(ids?: Iterable<string>): boolean;
+    offsetShapes(distance: number, ids?: Iterable<string>, options?: {
+        join?: 'miter' | 'round' | 'bevel';
+        miterLimit?: number;
+    }): unknown;
+    canOffsetShapes(ids?: Iterable<string>): boolean;
+    outlineStroke(ids?: Iterable<string>, options?: {
+        join?: 'miter' | 'round' | 'bevel';
+        cap?: 'butt' | 'round' | 'square';
+        miterLimit?: number;
+    }): unknown;
+    canOutlineStroke(ids?: Iterable<string>): boolean;
+}
+interface ShapeCommandOptions {
+    /** Id prefix (default `canvas.`). */
+    prefix?: string;
+    group?: string;
+    /** Scope (default `canvas`). Pass `null` for global. */
+    scope?: string | null;
+    /** Offset distance used when `canvas.offsetPath` is run without one (default 10). */
+    defaultOffset?: number;
+}
+/**
+ * Palette / context-menu / agent commands for the shape operations: `canvas.unite`,
+ * `canvas.intersect`, `canvas.subtract`, `canvas.exclude`, `canvas.divide`,
+ * `canvas.offsetPath` (`{ distance, join?, miterLimit?, ids? }`) and `canvas.outlineStroke`
+ * (`{ join?, cap?, miterLimit?, ids? }`). Each is one undoable step when the controller has a
+ * history; enablement explains why a command cannot run.
+ */
+declare function createShapeCommands(controller: ShapeCommandTarget, options?: ShapeCommandOptions): CommandSpec[];
+type ComponentActionResult = {
+    ok: true;
+    ids: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+/** Components surface of the components controller (`createCanvasComponentsController` satisfies it). */
+interface ComponentCommandTarget {
+    createComponent(ids?: Iterable<string>): ComponentActionResult;
+    canCreateComponent(ids?: Iterable<string>): true | string;
+    combineAsVariants(ids?: Iterable<string>): ComponentActionResult;
+    canCombineAsVariants(ids?: Iterable<string>): true | string;
+    createInstance(componentId: string, options?: {
+        parentId?: string;
+        position?: {
+            x: number;
+            y: number;
+        };
+        properties?: Record<string, boolean | string>;
+    }): ComponentActionResult;
+    canCreateInstance(componentId?: string, parentId?: string): true | string;
+    detachInstance(ids?: Iterable<string>): ComponentActionResult;
+    canDetachInstance(ids?: Iterable<string>): true | string;
+    resetOverrides(id?: string, group?: string): ComponentActionResult;
+    canResetOverrides(id?: string): true | string;
+    pushOverrides(id?: string): ComponentActionResult;
+    canPushOverrides(id?: string): true | string;
+    swapInstance(componentId: string, ids?: Iterable<string>): ComponentActionResult;
+    canSwapInstance(componentId?: string, ids?: Iterable<string>): true | string;
+    setInstanceProperties(properties: Record<string, unknown>, ids?: Iterable<string>): ComponentActionResult;
+    canSetInstanceProperties(ids?: Iterable<string>): true | string;
+    restoreMainComponent(id?: string): ComponentActionResult;
+    canRestoreMainComponent(id?: string): true | string;
+    goToMainComponent(id?: string): string | undefined;
+    canGoToMainComponent(id?: string): true | string;
+    list(): unknown;
+    inspect(id?: string): unknown;
+}
+interface ComponentCommandOptions {
+    /** Id prefix (default `canvas.`). */
+    prefix?: string;
+    group?: string;
+    /** Scope (default `canvas`). Pass `null` for global. */
+    scope?: string | null;
+}
+/**
+ * Palette / context-menu / agent commands for components and instances:
+ * `canvas.createComponent`, `canvas.combineAsVariants`, `canvas.createInstance`
+ * (`{ componentId, parentId?, x?, y?, properties? }`), `canvas.detachInstance`,
+ * `canvas.resetOverrides` (`{ id?, group? }`), `canvas.pushOverrides`, `canvas.goToMainComponent`,
+ * `canvas.swapInstance` (`{ componentId, ids? }`), `canvas.setInstanceProperties`
+ * (`{ properties, ids? }`: variant and component property values), `canvas.restoreMainComponent`
+ * and the read-only `canvas.listComponents` / `canvas.inspectInstance`. Each action is one
+ * undoable step when the controller has a history; enablement explains why it cannot run.
+ */
+declare function createComponentCommands(controller: ComponentCommandTarget, options?: ComponentCommandOptions): CommandSpec[];
+/** Spreadsheet controller surface used by `createSpreadsheetCommands`. */
+interface SpreadsheetCommandTarget {
+    selectedRange: unknown;
+    getFilterState(): {
+        enabled: boolean;
+        rules: readonly unknown[];
+    };
+    toggleFilters(): void;
+    clearFilters(): void;
+    unhideAll(): void;
+    mergeCells(): boolean;
+    unmergeCells(): boolean;
+    transposeRange(): boolean;
+}
+interface SpreadsheetCommandOptions {
+    /** Id prefix (default `spreadsheet.`). */
+    prefix?: string;
+    /** Scope (default `spreadsheet`). Pass `null` for global. */
+    scope?: string | null;
+}
+/** Palette / agent commands for common spreadsheet table actions (no default shortcuts). */
+declare function createSpreadsheetCommands(controller: SpreadsheetCommandTarget, options?: SpreadsheetCommandOptions): CommandSpec[];
+
+export { type ArrangeCommandOptions as A, type ComponentCommandOptions as C, DEFAULT_HISTORY_SHORTCUTS as D, type HistoryCommandOptions as H, type ShapeCommandOptions as S, type ArrangeCommandTarget as a, type ComponentCommandTarget as b, type HistoryCommandTarget as c, type ShapeCommandTarget as d, type SpreadsheetCommandOptions as e, type SpreadsheetCommandTarget as f, createArrangeCommands as g, createComponentCommands as h, createHistoryCommands as i, createShapeCommands as j, createSpreadsheetCommands as k, matchHistoryShortcut as m };