f1ow 0.1.0

package/dist/hooks/useEfficientZoom.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Snap a continuous zoom value to the nearest efficient level.
+ *
+ * Algorithm: binary-search the midpoints between adjacent levels.
+ * O(log n) with n = 8 levels ≈ 3 comparisons.
+ */
+export declare function computeEfficientZoom(zoom: number): number;
+/**
+ * React hook wrapping `computeEfficientZoom`.
+ * The returned value is memoised — it only changes when the zoom
+ * crosses a level boundary, keeping downstream consumers (LOD,
+ * stroke scaling) stable during rapid zoom gestures.
+ */
+export declare function useEfficientZoom(zoom: number): number;

package/dist/hooks/useElbowShapeFingerprint.d.ts

@@ -0,0 +1,21 @@
+import { CanvasElement } from '../types';
+/**
+ * Compute a stable fingerprint string from the spatial properties
+ * (x, y, width, height, rotation) of all connectable shapes.
+ *
+ * Used as a `useMemo` dependency in ArrowShape/LineShape instead of
+ * the raw `allElements` array — which gets a new reference on every
+ * render cycle and causes unnecessary elbow recomputation.
+ *
+ * The fingerprint only changes when a connectable shape's position,
+ * size, rotation, or visibility changes — style changes, text content
+ * changes, etc. are ignored since they don't affect routing.
+ *
+ * Returns both the fingerprint string AND the elements array ref.
+ * The elements ref is stable (won't trigger re-renders) and is used
+ * to pass to `computeElbowPoints` when the fingerprint changes.
+ */
+export declare function useElbowShapeFingerprint(allElements: CanvasElement[] | undefined): {
+    fingerprint: string;
+    elementsRef: React.MutableRefObject<CanvasElement[]>;
+};

package/dist/hooks/useElbowWorker.d.ts

@@ -0,0 +1,23 @@
+import { CanvasElement, Binding, Point } from '../types';
+/**
+ * Hook that computes elbow route points, offloading to a Web Worker
+ * when beneficial.
+ *
+ * @param isElbow - whether elbow routing is active (skip if false)
+ * @param params - routing parameters (start/end points, bindings)
+ * @param allElements - all canvas elements (for obstacle detection)
+ * @param fingerprint - stable spatial fingerprint (for dependency tracking)
+ * @returns flat number[] of elbow route points (relative to startWorld)
+ */
+export declare function useElbowWorker(isElbow: boolean, params: {
+    startWorld: Point;
+    endWorld: Point;
+    startBinding: Binding | null;
+    endBinding: Binding | null;
+    minStubLength?: number;
+}, allElements: CanvasElement[], fingerprint: string): number[] | null;
+/**
+ * Cleanup function to dispose the Worker.
+ * Call from FlowCanvas's cleanup effect.
+ */
+export { disposeElbowWorkerManager } from '../utils/elbowWorkerManager';

package/dist/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+/**
+ * Keyboard shortcuts handler — canvas-standard hotkeys
+ * @param enabled - Whether shortcuts are active (false = hooks still called, events ignored)
+ * @param containerRef - Optional ref to canvas container (needed for zoomToFit/zoomToSelection)
+ */
+export declare function useKeyboardShortcuts(enabled?: boolean, containerRef?: React.RefObject<HTMLDivElement | null>): void;

package/dist/hooks/useProgressiveRender.d.ts

@@ -0,0 +1,52 @@
+import { CanvasElement } from '../types';
+export interface UseProgressiveRenderOptions {
+    /** Elements per batch (default: 500) */
+    batchSize?: number;
+    /** Minimum element count to activate progressive mode (default: 500) */
+    threshold?: number;
+    /** Whether progressive rendering is enabled (default: true) */
+    enabled?: boolean;
+}
+export interface ProgressiveRenderState {
+    /** Elements to render this frame (progressively grows) */
+    visibleElements: CanvasElement[];
+    /** Whether progressive loading is in progress */
+    isLoading: boolean;
+    /** Progress ratio (0 → 1) */
+    progress: number;
+}
+/**
+ * Progressive render hook for time-sliced element rendering.
+ *
+ * @param elements - Full array of elements to render
+ * @param options - Configuration options
+ * @returns Progressive render state with growing visible element list
+ *
+ * Usage:
+ * ```tsx
+ * const { visibleElements, isLoading } = useProgressiveRender(staticElements, {
+ *   batchSize: 500,
+ *   threshold: 500,
+ * });
+ * // Use visibleElements for rendering instead of staticElements
+ * ```
+ */
+export declare function useProgressiveRender(elements: CanvasElement[], options?: UseProgressiveRenderOptions): ProgressiveRenderState;
+/**
+ * Schedule non-critical work during browser idle time.
+ * Falls back to setTimeout(100ms) if requestIdleCallback is unavailable.
+ *
+ * Use cases:
+ *   - Pre-compute spatial data
+ *   - Prefetch image thumbnails
+ *   - Update minimap
+ *   - Rebuild spatial indices
+ */
+export declare function scheduleIdleWork(work: () => void, options?: {
+    timeout?: number;
+}): void;
+/**
+ * Yield to browser main thread (let browser handle input events).
+ * Used inside long-running loops to prevent frame drops.
+ */
+export declare function yieldToMain(): Promise<void>;

package/dist/hooks/useSpatialIndex.d.ts

@@ -0,0 +1,9 @@
+import { CanvasElement, ViewportState } from '../types';
+/**
+ * Hook returning only elements visible in the current viewport,
+ * using an R-tree spatial index for large canvases.
+ *
+ * Drop-in replacement for the original `useViewportCulling` hook —
+ * same input/output contract.
+ */
+export declare function useSpatialIndex(elements: CanvasElement[], viewport: ViewportState, stageWidth: number, stageHeight: number, selectedIds: string[], padding?: number): CanvasElement[];

package/dist/hooks/useViewportCulling.d.ts

@@ -0,0 +1,13 @@
+import { CanvasElement, ViewportState } from '../types';
+/**
+ * Returns only the elements that are visible in the current viewport
+ * plus any selected elements (always visible for transformer).
+ *
+ * @param elements - all resolved elements
+ * @param viewport - current pan/zoom state
+ * @param stageWidth - Stage pixel width
+ * @param stageHeight - Stage pixel height
+ * @param selectedIds - currently selected element IDs
+ * @param padding - extra world-space padding (default 200)
+ */
+export declare function useViewportCulling(elements: CanvasElement[], viewport: ViewportState, stageWidth: number, stageHeight: number, selectedIds: string[], padding?: number): CanvasElement[];

package/dist/lib/FlowCanvas.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { FlowCanvasProps, FlowCanvasRef } from './FlowCanvasProps';
+declare const FlowCanvas: React.ForwardRefExoticComponent<FlowCanvasProps & React.RefAttributes<FlowCanvasRef>>;
+export default FlowCanvas;

package/dist/lib/FlowCanvasProps.d.ts

@@ -0,0 +1,154 @@
+import { CanvasElement, ElementStyle, ToolType } from '../types';
+import { ContextMenuItem } from '../components/ContextMenu/ContextMenu';
+import { CollaborationConfig } from '../collaboration/types';
+export type { ContextMenuItem };
+/** Context passed to custom context menu renderers */
+export interface ContextMenuContext {
+    /** IDs of currently selected elements */
+    selectedIds: string[];
+    /** All elements on the canvas */
+    elements: CanvasElement[];
+    /** Screen-space position of the right-click */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Close the context menu */
+    close: () => void;
+}
+export interface FlowCanvasProps {
+    /** Initial elements to render on the canvas */
+    initialElements?: CanvasElement[];
+    /** Controlled elements (makes the component controlled) */
+    elements?: CanvasElement[];
+    /** Callback when elements change */
+    onChange?: (elements: CanvasElement[]) => void;
+    /** Callback when selection changes */
+    onSelectionChange?: (selectedIds: string[]) => void;
+    /** Callback when an element is created */
+    onElementCreate?: (element: CanvasElement) => void;
+    /** Callback when an element is deleted */
+    onElementDelete?: (ids: string[]) => void;
+    /**
+     * Callback when an element is double-clicked.
+     * Return `true` to prevent the default behavior (create/edit bound text).
+     * Return `false` or `undefined` to let the default behavior proceed.
+     */
+    onElementDoubleClick?: (elementId: string, element: CanvasElement) => boolean | void;
+    /** Width of the canvas (default: 100% of container) */
+    width?: number | string;
+    /** Height of the canvas (default: 100% of container) */
+    height?: number | string;
+    /** Which tools to display in toolbar */
+    tools?: ToolType[];
+    /** Default drawing style */
+    defaultStyle?: Partial<ElementStyle>;
+    /** Show/hide the toolbar */
+    showToolbar?: boolean;
+    /** Show/hide the style panel */
+    showStylePanel?: boolean;
+    /** Show/hide the status bar */
+    showStatusBar?: boolean;
+    /** Show grid by default */
+    showGrid?: boolean;
+    /** Enable keyboard shortcuts */
+    enableShortcuts?: boolean;
+    /** Theme customization */
+    theme?: Partial<FlowCanvasTheme>;
+    /** Readonly mode — disable editing */
+    readOnly?: boolean;
+    /** Additional CSS class for the root container */
+    className?: string;
+    /**
+     * Additional context menu items to append after the built-in items.
+     * Can be static items or a function that receives selection context.
+     */
+    contextMenuItems?: ContextMenuItem[] | ((ctx: ContextMenuContext) => ContextMenuItem[]);
+    /**
+     * Completely replace the built-in context menu with a custom renderer.
+     * When provided, the built-in context menu is NOT shown.
+     * Return a React element to render as the context menu.
+     */
+    renderContextMenu?: (ctx: ContextMenuContext) => React.ReactNode;
+    /**
+     * Enable real-time CRDT collaboration.
+     * Pass a `CollaborationConfig` to connect, or `undefined`/`null` to disable.
+     */
+    collaboration?: CollaborationConfig | null;
+}
+export interface FlowCanvasTheme {
+    /** Canvas background color */
+    canvasBackground: string;
+    /** Grid line color */
+    gridColor: string;
+    /** Selection highlight color */
+    selectionColor: string;
+    /** Toolbar background */
+    toolbarBg: string;
+    /** Toolbar border color */
+    toolbarBorder: string;
+    /** Panel background */
+    panelBg: string;
+    /** Active tool highlight */
+    activeToolColor: string;
+    /** Text color */
+    textColor: string;
+    /** Muted text color */
+    mutedTextColor: string;
+}
+export declare const DEFAULT_THEME: FlowCanvasTheme;
+export interface FlowCanvasRef {
+    /** Get current elements */
+    getElements: () => CanvasElement[];
+    /** Set elements programmatically */
+    setElements: (elements: CanvasElement[]) => void;
+    /** Add a single element */
+    addElement: (element: CanvasElement) => void;
+    /** Delete elements by ids */
+    deleteElements: (ids: string[]) => void;
+    /** Get selected element ids */
+    getSelectedIds: () => string[];
+    /** Select elements by ids */
+    setSelectedIds: (ids: string[]) => void;
+    /** Clear selection */
+    clearSelection: () => void;
+    /** Set active tool */
+    setActiveTool: (tool: ToolType) => void;
+    /** Get active tool */
+    getActiveTool: () => ToolType;
+    /** Undo last action */
+    undo: () => void;
+    /** Redo last undone action */
+    redo: () => void;
+    /** Zoom to a specific scale */
+    zoomTo: (scale: number) => void;
+    /** Reset zoom and position */
+    resetView: () => void;
+    /**
+     * Scroll and zoom the viewport to center a specific element.
+     * Optionally specify a zoom level (defaults to current zoom, clamped to at least 1).
+     */
+    scrollToElement: (id: string, options?: {
+        zoom?: number;
+        animate?: boolean;
+    }) => void;
+    /**
+     * Zoom the viewport to fit all elements (or a subset) within the visible area.
+     * Pass element IDs to fit only those elements; omit to fit all.
+     */
+    zoomToFit: (ids?: string[], options?: {
+        padding?: number;
+        maxZoom?: number;
+        animate?: boolean;
+    }) => void;
+    /** Export canvas as PNG data URL */
+    exportPNG: () => string | null;
+    /** Export elements as JSON string */
+    exportJSON: () => string;
+    /** Export elements as SVG string */
+    exportSVG: () => string;
+    /** Import elements from JSON string */
+    importJSON: (json: string) => void;
+    /** Get the Konva Stage instance */
+    getStage: () => unknown;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,57 @@
+export { default as FlowCanvas } from './FlowCanvas';
+export type { FlowCanvasProps, FlowCanvasRef, FlowCanvasTheme, ContextMenuItem, ContextMenuContext, } from './FlowCanvasProps';
+export { DEFAULT_THEME } from './FlowCanvasProps';
+export type { CanvasElement, RectangleElement, EllipseElement, DiamondElement, LineElement, ArrowElement, FreeDrawElement, TextElement, ImageElement, BaseElement, ElementStyle, ElementType, ToolType, Point, ViewportState, ConnectionAnchor, BoundElement, Binding, SnapTarget, Arrowhead, LineType, TextAlign, VerticalAlign, ImageScaleMode, ImageCrop, ElementMeta, CanvasOperation, } from '../types';
+export { useCanvasStore } from '../store/useCanvasStore';
+export { DEFAULT_STYLE, STROKE_COLORS, FILL_COLORS, STROKE_WIDTHS, TOOLS, ARROWHEAD_TYPES, LINE_TYPES, ROUGHNESS_CONFIGS } from '../constants';
+export { generateId } from '../utils/id';
+export { distance, normalizeRect, rotatePoint, isPointInRect, getDiamondPoints, getStrokeDash } from '../utils/geometry';
+export { exportToDataURL, downloadPNG, exportToJSON, downloadJSON, exportToSVG, downloadSVG } from '../utils/export';
+export { drawArrowhead, arrowheadSize, flatToPoints } from '../utils/arrowheads';
+export { computeCurveControlPoint, quadBezierAt, quadBezierTangent, curveArrowPrev, CURVE_RATIO } from '../utils/curve';
+export { computeElbowPoints, computeElbowRoute, simplifyElbowPath, clearElbowRouteCache, directionFromFixedPoint, directionFromPoints, directionFromShapeToPoint, directionFromEdgePoint, getElbowPreferredDirection, } from '../utils/elbow';
+export type { Direction } from '../utils/elbow';
+export { getConnectionPoints, getEdgePoint, getEdgePointFromFixedPoint, computeFixedPoint, getAnchorPosition, findNearestSnapTarget, isConnectable, recomputeBoundPoints, findConnectorsForElement, addBoundElement, removeBoundElement, syncBoundElements, } from '../utils/connection';
+export { fileToDataURL, loadImage, computeImageElementDimensions, createImageElement, getImageFilesFromDataTransfer, extractImageDataFromClipboard, clipboardHasImage, resolveImageSource, openImageFilePicker, } from '../utils/image';
+export { getVisibleBounds, getElementAABB, aabbOverlaps, cullToViewport, buildElementMap, cloneElementsForHistory, rafThrottle, batchElementUpdates, } from '../utils/performance';
+export type { AABB } from '../utils/performance';
+export { computeEfficientZoom, useEfficientZoom } from '../hooks/useEfficientZoom';
+export { SpatialIndex, getSharedSpatialIndex, elementToSpatialItem } from '../utils/spatialIndex';
+export type { SpatialItem } from '../utils/spatialIndex';
+export { getElbowWorkerManager, disposeElbowWorkerManager } from '../utils/elbowWorkerManager';
+export type { RouteParams } from '../utils/elbowWorkerManager';
+export { zoomAtPoint, getNextZoomStep, getPrevZoomStep, getElementsBounds, computeZoomToFit, animateViewport, cancelViewportAnimation, ZOOM_STEPS, DEFAULT_ANIMATION_DURATION, } from '../utils/camera';
+export type { ZoomAtPointOptions, ZoomToFitOptions } from '../utils/camera';
+export { getToolHandler } from '../tools';
+export type { ToolHandler, ToolContext } from '../tools';
+export { SpatialSoA, getSharedSpatialSoA, ELEMENT_TYPE_MAP } from '../utils/spatialSoA';
+export type { SpatialSoAData } from '../utils/spatialSoA';
+export { useProgressiveRender, scheduleIdleWork, yieldToMain } from '../hooks/useProgressiveRender';
+export type { UseProgressiveRenderOptions, ProgressiveRenderState } from '../hooks/useProgressiveRender';
+export { getExportWorkerManager, disposeExportWorkerManager, ExportWorkerManager } from '../utils/exportWorkerManager';
+export { generateKeyBetween, generateNKeysBetween, isValidFractionalIndex, compareFractionalKeys, } from '../utils/fractionalIndex';
+export { OperationLog, opAdd, opDelete, opMove, opResize, opStyle, opRotate, opReorder, opUpdatePoints, opSetText, opBatch, applyOperation, detectOperations, } from '../utils/crdtPrep';
+export type { OperationEntry } from '../utils/crdtPrep';
+export type { CollaborationUser, AwarenessState, CollaborationConfig, ConnectionStatus, CollaborationEvent, } from '../collaboration/types';
+export { createCollaborationProvider, destroyCollaborationProvider, getYDoc, getYProvider, getYElements, isCollaborationActive, onStatusChange, updateAwareness, getRemoteAwareness, } from '../collaboration/yjsProvider';
+export { startSync, stopSync } from '../collaboration/syncBridge';
+export { elementToYMap, yMapToElement, SYNC_FIELDS, STYLE_FIELDS } from '../collaboration/syncBridgeCodec';
+export { CollaborationManager } from '../collaboration/CollaborationManager';
+export { SyncWorkerAdapter } from '../collaboration/syncWorker';
+export type { WorkerInMessage, WorkerOutMessage, SyncWorkerCallbacks } from '../collaboration/syncWorker';
+export { useCollaboration } from '../collaboration/useCollaboration';
+export type { UseCollaborationReturn } from '../collaboration/useCollaboration';
+export { default as CursorOverlay } from '../collaboration/CursorOverlay';
+export { TileCache, tileKey } from '../rendering/tileCache';
+export type { TileCoord } from '../rendering/tileCache';
+export { TileRenderer, TILE_SIZE, discreteZoom, worldTileSize, getVisibleTiles, tileBounds, getElementTiles, } from '../rendering/tileRenderer';
+export type { TileDrawFn, TileRendererOptions } from '../rendering/tileRenderer';
+export { useTileRenderer } from '../rendering/useTileRenderer';
+export type { UseTileRendererOptions, UseTileRendererReturn } from '../rendering/useTileRenderer';
+export { TextureAtlas } from '../webgl/textureAtlas';
+export type { AtlasRegion, AtlasEntry, ElementRasterFn } from '../webgl/textureAtlas';
+export { WebGLHybridRenderer } from '../webgl/WebGLHybridRenderer';
+export type { WebGLHybridRendererOptions } from '../webgl/WebGLHybridRenderer';
+export { buildViewMatrix } from '../webgl/glUtils';
+export { useWebGLHybrid } from '../webgl/useWebGLHybrid';
+export type { UseWebGLHybridOptions, UseWebGLHybridReturn } from '../webgl/useWebGLHybrid';

package/dist/store/useCanvasStore.d.ts

@@ -0,0 +1,127 @@
+import { CanvasElement, ElementStyle, ElementType, ToolType, ViewportState, Point, LineType, Arrowhead } from '../types';
+/** Single element diff: tracks what changed for one element */
+interface ElementDiff {
+    type: 'add' | 'modify' | 'delete';
+    elementId: string;
+    /** Element state before the change (for modify/delete) */
+    before?: CanvasElement;
+    /** Element state after the change (for add/modify) */
+    after?: CanvasElement;
+}
+/**
+ * Diff-based history entry.
+ * Instead of storing full snapshots, we only store what changed.
+ * This drastically reduces memory usage for large canvases.
+ */
+interface HistoryEntry {
+    diffs: ElementDiff[];
+    /** Optional named mark/checkpoint for grouping */
+    mark?: string;
+    /** Timestamp for squash heuristics */
+    timestamp: number;
+}
+interface CanvasState {
+    elements: CanvasElement[];
+    selectedIds: string[];
+    activeTool: ToolType;
+    currentStyle: ElementStyle;
+    currentLineType: LineType;
+    currentStartArrowhead: Arrowhead | null;
+    currentEndArrowhead: Arrowhead | null;
+    viewport: ViewportState;
+    isDrawing: boolean;
+    drawStart: Point | null;
+    history: HistoryEntry[];
+    historyIndex: number;
+    /** Baseline snapshot for computing diffs against current state */
+    _historyBaseline: Map<string, CanvasElement>;
+    /** Whether history recording is temporarily paused */
+    _historyPaused: boolean;
+    showGrid: boolean;
+    addElement: (element: CanvasElement) => void;
+    updateElement: (id: string, updates: Partial<CanvasElement>) => void;
+    /** Batch-update multiple elements in a single store write.
+     *  Dramatically reduces re-renders when dragging N selected elements
+     *  (1 array allocation instead of N per frame). */
+    batchUpdateElements: (updates: Array<{
+        id: string;
+        updates: Partial<CanvasElement>;
+    }>) => void;
+    deleteElements: (ids: string[]) => void;
+    setElements: (elements: CanvasElement[]) => void;
+    duplicateElements: (ids: string[]) => void;
+    convertElementType: (ids: string[], targetType: ElementType) => void;
+    bringToFront: (ids: string[]) => void;
+    sendToBack: (ids: string[]) => void;
+    bringForward: (ids: string[]) => void;
+    sendBackward: (ids: string[]) => void;
+    toggleLockElements: (ids: string[]) => void;
+    groupElements: (ids: string[]) => void;
+    ungroupElements: (ids: string[]) => void;
+    setSelectedIds: (ids: string[]) => void;
+    clearSelection: () => void;
+    setActiveTool: (tool: ToolType) => void;
+    setCurrentStyle: (style: Partial<ElementStyle>) => void;
+    setCurrentLineType: (lineType: LineType) => void;
+    setCurrentStartArrowhead: (arrowhead: Arrowhead | null) => void;
+    setCurrentEndArrowhead: (arrowhead: Arrowhead | null) => void;
+    setViewport: (viewport: Partial<ViewportState>) => void;
+    /**
+     * Zoom in one step. If `center` is provided (screen-space point),
+     * zoom toward that point; otherwise zoom toward viewport center.
+     */
+    zoomIn: (center?: {
+        x: number;
+        y: number;
+    }, options?: {
+        animate?: boolean;
+    }) => void;
+    /**
+     * Zoom out one step. If `center` is provided (screen-space point),
+     * zoom toward that point; otherwise zoom toward viewport center.
+     */
+    zoomOut: (center?: {
+        x: number;
+        y: number;
+    }, options?: {
+        animate?: boolean;
+    }) => void;
+    resetZoom: (options?: {
+        animate?: boolean;
+    }) => void;
+    /**
+     * Zoom the viewport to fit all elements (or specific IDs).
+     * Requires stageWidth/stageHeight to calculate proper fit.
+     */
+    zoomToFit: (stageWidth: number, stageHeight: number, ids?: string[], options?: {
+        padding?: number;
+        maxZoom?: number;
+        animate?: boolean;
+    }) => void;
+    /**
+     * Zoom the viewport to fit currently selected elements.
+     */
+    zoomToSelection: (stageWidth: number, stageHeight: number, options?: {
+        padding?: number;
+        maxZoom?: number;
+        animate?: boolean;
+    }) => void;
+    setIsDrawing: (isDrawing: boolean) => void;
+    setDrawStart: (point: Point | null) => void;
+    pushHistory: (mark?: string) => void;
+    undo: () => void;
+    redo: () => void;
+    /** Squash the last N history entries into one (for continuous ops like drag) */
+    squashHistory: (count?: number) => void;
+    /** Pause history recording (for batch operations) */
+    pauseHistory: () => void;
+    /** Resume history recording */
+    resumeHistory: () => void;
+    /** Check if history can undo */
+    canUndo: () => boolean;
+    /** Check if history can redo */
+    canRedo: () => boolean;
+    toggleGrid: () => void;
+}
+export declare const useCanvasStore: import('zustand').UseBoundStore<import('zustand').StoreApi<CanvasState>>;
+export {};

package/dist/store/useLinearEditStore.d.ts

@@ -0,0 +1,25 @@
+interface LinearEditStoreState {
+    /** ID of the element being edited, or null */
+    elementId: string | null;
+    /** Full editing mode (point handles visible & interactive) */
+    isEditing: boolean;
+    /** Indices of selected point(s) */
+    selectedPointIndices: number[];
+    /** Hovered point index (-1 = none) */
+    hoveredPointIndex: number;
+    /** Hovered midpoint index (null = none) */
+    hoveredMidpointIndex: number | null;
+    /** Currently dragging a point */
+    isDraggingPoint: boolean;
+    enterEditMode: (elementId: string) => void;
+    exitEditMode: () => void;
+    setSelectedPoints: (indices: number[]) => void;
+    togglePointSelection: (index: number) => void;
+    setHoveredPoint: (index: number) => void;
+    setHoveredMidpoint: (index: number | null) => void;
+    setIsDraggingPoint: (dragging: boolean) => void;
+    /** Reset everything */
+    reset: () => void;
+}
+export declare const useLinearEditStore: import('zustand').UseBoundStore<import('zustand').StoreApi<LinearEditStoreState>>;
+export {};