@ai-matrx/canvas 0.1.0 → 0.2.0

package/dist/index.d.cts

@@ -1,99 +1,5 @@
-/**
- * @ai-matrx/canvas — core types.
- *
- * The canvas is ONE docked column on the right edge of an application. It holds
- * panes; panes hold tabs; every tab is one CanvasItem. A CanvasItem is
- * identified by `kind` + `key`, so opening the same thing twice always lands on
- * the existing tab instead of creating a duplicate.
- *
- * Everything in CanvasState is plain JSON: it lives in the host's Redux store
- * (or the package's own standalone store), it is persisted between sessions,
- * and it can be inspected. No functions, no class instances, no React nodes.
- */
-/** Any value that survives JSON.stringify → JSON.parse unchanged. */
-type CanvasJson = string | number | boolean | null | readonly CanvasJson[] | {
-    readonly [key: string]: CanvasJson | undefined;
-};
-declare const itemIdBrand: unique symbol;
-declare const paneIdBrand: unique symbol;
-declare const splitIdBrand: unique symbol;
-/** `${kind}::${key}` — the identity of one thing on the canvas. */
-type CanvasItemId = string & {
-    readonly [itemIdBrand]: true;
-};
-type CanvasPaneId = string & {
-    readonly [paneIdBrand]: true;
-};
-type CanvasSplitId = string & {
-    readonly [splitIdBrand]: true;
-};
-interface CanvasItem {
-    readonly id: CanvasItemId;
-    /** Registered kind id (see `registerCanvasKind`). */
-    readonly kind: string;
-    /** Stable key inside the kind — an artifact id, a conversation id, "default". */
-    readonly key: string;
-    /** Explicit tab title. `null` ⇒ the kind's `title(data)` or its label. */
-    readonly title: string | null;
-    readonly data: CanvasJson;
-    readonly openedAt: number;
-    readonly updatedAt: number;
-}
-interface CanvasPane {
-    readonly id: CanvasPaneId;
-    readonly itemIds: readonly CanvasItemId[];
-    readonly activeItemId: CanvasItemId | null;
-}
-/** "horizontal" = children side by side; "vertical" = children stacked. */
-type CanvasOrientation = "horizontal" | "vertical";
-type CanvasLayoutNode = {
-    readonly type: "pane";
-    readonly paneId: CanvasPaneId;
-} | {
-    readonly type: "split";
-    readonly id: CanvasSplitId;
-    readonly orientation: CanvasOrientation;
-    readonly children: readonly CanvasLayoutNode[];
-    /** Fractions, one per child, summing to 1. */
-    readonly sizes: readonly number[];
-};
-interface CanvasState {
-    readonly version: 1;
-    readonly isOpen: boolean;
-    readonly isFullscreen: boolean;
-    /** Column width in CSS pixels (desktop). */
-    readonly width: number;
-    readonly layout: CanvasLayoutNode;
-    readonly panes: {
-        readonly [paneId: string]: CanvasPane;
-    };
-    readonly items: {
-        readonly [itemId: string]: CanvasItem;
-    };
-    readonly focusedPaneId: CanvasPaneId;
-    /** Monotonic counter for minting pane/split ids — keeps the reducer pure. */
-    readonly seq: number;
-    /** True once a persisted snapshot was applied (or there was none). */
-    readonly hydrated: boolean;
-}
-/** Where a newly opened item goes. Existing items never move on open. */
-type CanvasOpenTarget = "focused" | "split-right" | "split-down" | {
-    readonly paneId: CanvasPaneId;
-};
-interface CanvasOpenInput {
-    readonly kind: string;
-    readonly key: string;
-    readonly title?: string | null | undefined;
-    readonly data?: CanvasJson | undefined;
-    readonly target?: CanvasOpenTarget | undefined;
-    /** Reveal the canvas when it is put away. Default true. */
-    readonly reveal?: boolean | undefined;
-    /** Make the item the pane's active tab. Default true. */
-    readonly activate?: boolean | undefined;
-}
-declare const CANVAS_MIN_WIDTH = 360;
-declare const CANVAS_DEFAULT_WIDTH = 640;
-declare const CANVAS_MIN_SPLIT_FRACTION = 0.12;
+import { C as CanvasItemId, a as CanvasWindowId, b as CanvasJson, c as CanvasLayoutNode, d as CanvasPaneId, e as CanvasStoreBinding, f as CanvasState, g as CanvasAction, h as CanvasController, i as CanvasItem, j as CanvasExtraWindow, k as CanvasPane, l as canvasWindowOfItem } from './controller-Dv6J6XZm.cjs';
+export { m as CANVAS_DEFAULT_WIDTH, n as CANVAS_DESKTOP_LAYOUT_RULES, o as CANVAS_MAIN_WINDOW, p as CANVAS_MIN_SPLIT_FRACTION, q as CANVAS_MIN_WIDTH, r as CANVAS_STORAGE_KEY, s as CANVAS_WEB_LAYOUT_RULES, t as CanvasControllerOptions, u as CanvasErrorReport, v as CanvasErrorSink, w as CanvasKeyValueStore, x as CanvasLayoutRules, y as CanvasOpenInput, z as CanvasOpenTarget, A as CanvasOrientation, B as CanvasPersistencePort, D as CanvasRect, E as CanvasSessionAttachReason, F as CanvasSessionDetachReason, G as CanvasSessionEvent, H as CanvasSessionHooks, I as CanvasSplitId, J as CanvasWindowCloseMode, K as CanvasWindowFrame, L as CanvasWindowPorts, R as ReduxStoreLike, M as bindCanvasToReduxStore, N as canvasActions, O as canvasReducer, P as canvasWindowFrame, Q as canvasWindowOfPane, S as clampDraggedCanvasWidth, T as consoleCanvasErrorSink, U as createCanvasController, V as createCanvasStore, W as createInitialCanvasState, X as createKeyValueCanvasPersistence, Y as createLocalStorageCanvasPersistence, Z as defaultCanvasWidth, _ as fitCanvasWidth, $ as foldCanvasWindows, a0 as isCanvasAction, a1 as listCanvasWindowIds, a2 as resolveCanvasLayoutRules, a3 as sanitizeCanvasSnapshot, a4 as shouldStackSplit, a5 as toPersistableSnapshot } from './controller-Dv6J6XZm.cjs';
 
 declare function canvasItemId(kind: string, key: string): CanvasItemId;
 declare function parseCanvasItemId(id: CanvasItemId): {
@@ -107,6 +13,8 @@ declare function parseCanvasItemId(id: CanvasItemId): {
  */
 declare function findNonJson(value: unknown, path?: string): string | null;
 declare function isCanvasJson(value: unknown): value is CanvasJson;
+/** Brands a host's window id. `CANVAS_MAIN_WINDOW` is the default window. */
+declare function canvasWindowId(id: string): CanvasWindowId;
 
 /**
  * Pure helpers over the canvas layout tree. Every function returns a new tree
@@ -118,263 +26,121 @@ declare function listPaneIds(node: CanvasLayoutNode): CanvasPaneId[];
 declare function normalizeSizes(sizes: readonly number[], count: number): number[];
 
 /**
- * THE canvas reducer. Plain Redux-compatible reducer + action creators with no
- * Redux Toolkit dependency, so it mounts in a host's RTK store
- * (`canvasHost: canvasReducer`) or runs inside the package's own standalone
- * store with identical behaviour.
+ * A canvas store that lives in ANOTHER process — an Electron renderer bound to
+ * the one store in the main process over IPC.
  *
- * Identity law: an item is `kind::key`. Opening an item that is already on the
- * canvas never duplicates it — it refreshes its data/title, activates its tab
- * and focuses its pane, wherever that pane is.
+ *  - dispatch is async and fire-and-forget: the action goes to the owner, and
+ *    the state changes when the owner's next snapshot arrives (no optimistic
+ *    copy that could disagree with the owner);
+ *  - every update is a WHOLE snapshot with no shared object identity, so each
+ *    one is merged into the previous state structurally: anything unchanged
+ *    keeps its old reference, an identical snapshot changes nothing and wakes
+ *    nobody — selector results stay stable and useSyncExternalStore never loops;
+ *  - the binding is marked `authority: "remote"`: the owner hydrates and saves,
+ *    so a controller over it never does.
+ *
+ * The owner side (main process) is the ordinary `createCanvasStore()` +
+ * `createCanvasController({ persistence })`; see the README.
  */
 
-declare const P = "matrxCanvas/";
-type CanvasAction = {
-    type: `${typeof P}open`;
-    payload: CanvasOpenInput & {
-        now: number;
-    };
-} | {
-    type: `${typeof P}update`;
-    payload: {
-        itemId: CanvasItemId;
-        data?: CanvasJson | undefined;
-        title?: string | null | undefined;
-        now: number;
-    };
-} | {
-    type: `${typeof P}rekey`;
-    payload: {
-        itemId: CanvasItemId;
-        key: string;
-    };
-} | {
-    type: `${typeof P}closeItem`;
-    payload: {
-        itemId: CanvasItemId;
-    };
-} | {
-    type: `${typeof P}closeOthers`;
-    payload: {
-        itemId: CanvasItemId;
-    };
-} | {
-    type: `${typeof P}activate`;
-    payload: {
-        itemId: CanvasItemId;
-    };
-} | {
-    type: `${typeof P}focusPane`;
-    payload: {
-        paneId: CanvasPaneId;
-    };
-} | {
-    type: `${typeof P}moveItem`;
-    payload: {
-        itemId: CanvasItemId;
-        toPaneId: CanvasPaneId;
-        index?: number | undefined;
-    };
-} | {
-    type: `${typeof P}splitPane`;
-    payload: {
-        paneId: CanvasPaneId;
-        orientation: CanvasOrientation;
-        moveItemId?: CanvasItemId | undefined;
-    };
-} | {
-    type: `${typeof P}closePane`;
-    payload: {
-        paneId: CanvasPaneId;
-    };
-} | {
-    type: `${typeof P}resizeSplit`;
-    payload: {
-        splitId: CanvasSplitId;
-        sizes: readonly number[];
-    };
-} | {
-    type: `${typeof P}setOpen`;
-    payload: {
-        open: boolean;
-    };
-} | {
-    type: `${typeof P}toggle`;
-} | {
-    type: `${typeof P}setFullscreen`;
-    payload: {
-        fullscreen: boolean;
-    };
-} | {
-    type: `${typeof P}setWidth`;
-    payload: {
-        width: number;
-    };
-} | {
-    type: `${typeof P}hydrate`;
-    payload: {
-        snapshot: CanvasState | null;
-    };
-} | {
-    type: `${typeof P}reset`;
-};
-declare const canvasActions: {
-    readonly open: (input: CanvasOpenInput) => CanvasAction;
-    readonly update: (itemId: CanvasItemId, patch: {
-        data?: CanvasJson | undefined;
-        title?: string | null | undefined;
-    }) => CanvasAction;
-    /** Gives an item a new identity in place (e.g. a draft that was just saved and now has an id). */
-    readonly rekey: (itemId: CanvasItemId, key: string) => CanvasAction;
-    readonly closeItem: (itemId: CanvasItemId) => CanvasAction;
-    readonly closeOthers: (itemId: CanvasItemId) => CanvasAction;
-    readonly activate: (itemId: CanvasItemId) => CanvasAction;
-    readonly focusPane: (paneId: CanvasPaneId) => CanvasAction;
-    readonly moveItem: (itemId: CanvasItemId, toPaneId: CanvasPaneId, index?: number) => CanvasAction;
-    readonly splitPane: (paneId: CanvasPaneId, orientation: CanvasOrientation, moveItemId?: CanvasItemId) => CanvasAction;
-    readonly closePane: (paneId: CanvasPaneId) => CanvasAction;
-    readonly resizeSplit: (splitId: CanvasSplitId, sizes: readonly number[]) => CanvasAction;
-    readonly setOpen: (open: boolean) => CanvasAction;
-    readonly toggle: () => CanvasAction;
-    readonly setFullscreen: (fullscreen: boolean) => CanvasAction;
-    readonly setWidth: (width: number) => CanvasAction;
-    readonly hydrate: (snapshot: CanvasState | null) => CanvasAction;
-    readonly reset: () => CanvasAction;
-};
-declare function isCanvasAction(action: unknown): action is CanvasAction;
-declare function createInitialCanvasState(): CanvasState;
+interface RemoteCanvasStoreOptions {
+    /** The owner's state at connect time (e.g. from an `invoke("canvas:get")`). */
+    readonly initialSnapshot: CanvasState;
+    /** Sends one action to the owner. A rejection is reported, never swallowed. */
+    readonly dispatch: (action: CanvasAction) => Promise<void> | void;
+    /** Delivers every new owner snapshot; returns the unsubscribe. */
+    readonly subscribe: (onSnapshot: (snapshot: CanvasState) => void) => () => void;
+    /** Where a failed dispatch is reported. Default: console.error. */
+    readonly onError?: ((error: unknown, action: CanvasAction) => void) | undefined;
+}
+interface RemoteCanvasStore extends CanvasStoreBinding {
+    /** Stops listening to the owner. */
+    dispose(): void;
+}
+declare function createRemoteCanvasStore(options: RemoteCanvasStoreOptions): RemoteCanvasStore;
 /**
- * Validates a persisted snapshot. Anything malformed is dropped back to the
- * initial state rather than half-applied — a corrupt layout must never crash
- * the shell.
+ * Returns `next`, but with every subtree that is deep-equal to the same subtree
+ * of `prev` replaced by `prev`'s object. When nothing changed it returns `prev`
+ * itself. Plain JSON only (what crosses a process boundary).
  */
-declare function sanitizeCanvasSnapshot(raw: unknown): CanvasState | null;
-declare function canvasReducer(state: CanvasState | undefined, action: {
-    type: string;
-}): CanvasState;
+declare function shareStructure<T>(prev: T, next: T): T;
 
 /**
- * The store seam. The canvas never owns a second copy of its state: it reads
- * and writes through a CanvasStoreBinding.
- *
- *  - A host WITH Redux mounts `canvasReducer` in its root reducer and binds it:
- *      bindCanvasToReduxStore(store, (root) => root.canvasHost)
- *  - A host WITHOUT Redux (a Vite tool, an Electron window) calls
- *      createCanvasStore()
- *    which runs the very same reducer in a tiny standalone store.
+ * The canvas's keyboard shortcuts, as DATA. A web host gets them bound in the
+ * DOM by `CanvasProvider`; a desktop host binds the same table in its main
+ * process (menu accelerators / `before-input-event`), because keys pressed
+ * inside a native web view never reach the renderer's DOM. Every shortcut runs
+ * through `runCanvasCommand`, so both paths do exactly the same thing.
  */
 
-interface CanvasStoreBinding {
-    getState(): CanvasState;
-    dispatch(action: CanvasAction): void;
-    subscribe(listener: () => void): () => void;
-}
-declare function createCanvasStore(initial?: CanvasState): CanvasStoreBinding;
-/** The minimum of a Redux store the canvas needs. */
-interface ReduxStoreLike<TRoot> {
-    getState(): TRoot;
-    dispatch(action: CanvasAction): unknown;
-    subscribe(listener: () => void): () => void;
+type CanvasCommandId = "canvas.toggle" | "canvas.toggleFullscreen" | "canvas.exitFullscreen" | "canvas.closeTab" | "canvas.nextTab" | "canvas.previousTab" | "canvas.splitRight" | "canvas.splitDown";
+/**
+ * When a shortcut applies:
+ *  - "presented": a canvas column is on screen in this window;
+ *  - "fullscreen": the canvas is expanded (and Escape is not owned by a menu or dialog);
+ *  - "canvas-focus": keyboard focus is inside the canvas (a tab, a pane, a native body).
+ */
+type CanvasShortcutWhen = "presented" | "fullscreen" | "canvas-focus";
+interface CanvasShortcut {
+    readonly id: CanvasCommandId;
+    /** Electron accelerator syntax: "CmdOrCtrl+\\", "Escape", "Ctrl+Shift+Tab". */
+    readonly accelerator: string;
+    readonly when: CanvasShortcutWhen;
+    readonly label: string;
+    /** False when browsers reserve the keys (⌘W, Ctrl+Tab): only a desktop host can bind it. */
+    readonly web: boolean;
 }
-declare function bindCanvasToReduxStore<TRoot>(store: ReduxStoreLike<TRoot>, select: (root: TRoot) => CanvasState): CanvasStoreBinding;
-
+declare const CANVAS_SHORTCUTS: readonly CanvasShortcut[];
+/** The tooltip hint for a command, e.g. "⌘\\" on a Mac. */
+declare function canvasShortcutHint(id: CanvasCommandId, isMac: boolean): string | null;
 /**
- * Remembering the canvas between sessions — a table stake, never optional.
- *
- * The default port writes to localStorage under a versioned key. Items whose
- * kind opts out (`restore: false`, e.g. a live session that cannot come back)
- * are dropped from the snapshot, and panes they leave empty are dropped too.
+ * Runs one command against a window's canvas. Returns true when it did
+ * something (so a binding knows whether to swallow the key).
  */
-
-interface CanvasPersistencePort {
-    load(): CanvasState | null | Promise<CanvasState | null>;
-    save(snapshot: CanvasState): void | Promise<void>;
+declare function runCanvasCommand(controller: CanvasController, id: CanvasCommandId, windowId?: CanvasWindowId): boolean;
+/** The subset of a KeyboardEvent an accelerator is matched against. */
+interface CanvasKeyInput {
+    readonly key: string;
+    readonly code?: string;
+    readonly metaKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly altKey: boolean;
+    readonly shiftKey: boolean;
 }
-declare const CANVAS_STORAGE_KEY = "ai-matrx.canvas.v1";
-declare function createLocalStorageCanvasPersistence(key?: string, storage?: Pick<Storage, "getItem" | "setItem"> | null): CanvasPersistencePort;
-/** Builds the snapshot that is actually written: only restorable items. */
-declare function toPersistableSnapshot(state: CanvasState, isRestorable: (kind: string) => boolean): CanvasState;
-
 /**
- * The canvas controller: the ONE imperative API every caller uses. It wraps a
- * store binding, validates what callers hand it (so the reducer stays pure and
- * trusting), and owns hydration + autosave.
- *
- * Nothing fails silently: a refused open (non-JSON data, unknown kind) is
- * reported through the error sink and returns false.
+ * Whether a key event is this accelerator. "CmdOrCtrl" is ⌘ on a Mac and Ctrl
+ * elsewhere; symbol keys match by physical key (⌥\ types « on a Mac).
  */
+declare function matchesCanvasAccelerator(input: CanvasKeyInput, accelerator: string, isMac: boolean): boolean;
 
-interface CanvasErrorReport {
-    readonly code: "non-json-data" | "unknown-kind" | "persistence-load" | "persistence-save";
-    readonly message: string;
-    readonly detail?: unknown;
-}
-type CanvasErrorSink = (report: CanvasErrorReport) => void;
-declare const consoleCanvasErrorSink: CanvasErrorSink;
-interface CanvasControllerOptions {
-    readonly store: CanvasStoreBinding;
-    readonly persistence?: CanvasPersistencePort | null | undefined;
-    /** Kinds that may not come back after a reload. Default: every kind restores. */
-    readonly isRestorable?: ((kind: string) => boolean) | undefined;
-    /** When given, opens of an unregistered kind are refused and reported. */
-    readonly isKnownKind?: ((kind: string) => boolean) | undefined;
-    readonly onError?: CanvasErrorSink | undefined;
-    readonly saveDelayMs?: number | undefined;
-    /**
-     * Whether a remembered "open" may be restored right now. A host returns
-     * false where an open canvas would take the whole screen (a phone).
-     */
-    readonly mayRestoreOpen?: (() => boolean) | undefined;
-}
-interface CanvasController {
-    readonly store: CanvasStoreBinding;
-    getState(): CanvasState;
-    open(input: CanvasOpenInput): CanvasItemId | null;
-    update(itemId: CanvasItemId, patch: {
-        data?: CanvasJson | undefined;
-        title?: string | null | undefined;
-    }): boolean;
-    /** Gives an item a new identity in place (a draft that was saved and now has a durable id). */
-    rekey(itemId: CanvasItemId, key: string): CanvasItemId | null;
-    close(itemId: CanvasItemId): void;
-    closeOthers(itemId: CanvasItemId): void;
-    activate(itemId: CanvasItemId): void;
-    focusPane(paneId: CanvasPaneId): void;
-    moveItem(itemId: CanvasItemId, toPaneId: CanvasPaneId, index?: number): void;
-    splitPane(paneId: CanvasPaneId, orientation: CanvasOrientation, moveItemId?: CanvasItemId): void;
-    closePane(paneId: CanvasPaneId): void;
-    resizeSplit(splitId: CanvasSplitId, sizes: readonly number[]): void;
-    show(): void;
-    hide(): void;
-    toggle(): void;
-    setFullscreen(fullscreen: boolean): void;
-    setWidth(width: number): void;
-    /** Is this exact thing on the canvas right now? */
-    has(kind: string, key: string): boolean;
-    /**
-     * Is a canvas column on screen? A store can exist in a layout that shows no
-     * column (a kiosk, a meeting stage); opening there must be refused aloud.
-     */
-    isPresented(): boolean;
-    /** Called by a column on mount; returns the unmount callback. */
-    registerPresentation(): () => void;
-    subscribePresentation(listener: () => void): () => void;
-    /** Loads the persisted snapshot and starts autosave. Returns a disposer. */
-    start(): () => void;
-}
-declare function createCanvasController(options: CanvasControllerOptions): CanvasController;
+/**
+ * Selectors over CanvasState. Each returns a value that is referentially
+ * stable for an unchanged state, so they are safe in useSyncExternalStore and
+ * in a host's useSelector. Window-scoped selectors default to the main window;
+ * an unknown window reads as closed and empty.
+ */
 
-declare const selectCanvasIsOpen: (s: CanvasState) => boolean;
-declare const selectCanvasIsFullscreen: (s: CanvasState) => boolean;
-declare const selectCanvasWidth: (s: CanvasState) => number;
-declare const selectCanvasLayout: (s: CanvasState) => CanvasLayoutNode;
-declare const selectCanvasFocusedPaneId: (s: CanvasState) => CanvasPaneId;
+declare const selectCanvasIsOpen: (s: CanvasState, windowId?: CanvasWindowId) => boolean;
+declare const selectCanvasIsFullscreen: (s: CanvasState, windowId?: CanvasWindowId) => boolean;
+/** The width the person chose, or null while the host's layout rule decides. */
+declare const selectCanvasWidth: (s: CanvasState, windowId?: CanvasWindowId) => number | null;
+declare const selectCanvasLayout: (s: CanvasState, windowId?: CanvasWindowId) => CanvasLayoutNode | null;
+declare const selectCanvasFocusedPaneId: (s: CanvasState, windowId?: CanvasWindowId) => CanvasPaneId | null;
 declare const selectCanvasIsHydrated: (s: CanvasState) => boolean;
+/** Every item on the canvas, in every window. */
 declare const selectCanvasItemCount: (s: CanvasState) => number;
 declare const selectCanvasPane: (s: CanvasState, paneId: CanvasPaneId) => CanvasPane | undefined;
 declare const selectCanvasItem: (s: CanvasState, itemId: CanvasItemId) => CanvasItem | undefined;
-declare function selectCanvasPaneCount(s: CanvasState): number;
-/** The item the person is looking at in the focused pane. */
-declare function selectCanvasActiveItem(s: CanvasState): CanvasItem | null;
+declare function selectCanvasPaneCount(s: CanvasState, windowId?: CanvasWindowId): number;
+/** Items shown in one window. */
+declare function selectCanvasWindowItemCount(s: CanvasState, windowId?: CanvasWindowId): number;
+/** The item the person is looking at in a window's focused pane. */
+declare function selectCanvasActiveItem(s: CanvasState, windowId?: CanvasWindowId): CanvasItem | null;
+/** Windows other than main (second app windows and pop-outs), by id. Stable per state. */
+declare function selectCanvasWindows(s: CanvasState): CanvasState["windows"];
+/** One extra window, or undefined (main is never in this map). */
+declare const selectCanvasExtraWindow: (s: CanvasState, windowId: CanvasWindowId) => CanvasExtraWindow | undefined;
+/** The window an item is in, or null when it is not on the canvas. */
+declare const selectCanvasWindowOfItem: typeof canvasWindowOfItem;
 
-export { CANVAS_DEFAULT_WIDTH, CANVAS_MIN_SPLIT_FRACTION, CANVAS_MIN_WIDTH, CANVAS_STORAGE_KEY, type CanvasAction, type CanvasController, type CanvasControllerOptions, type CanvasErrorReport, type CanvasErrorSink, type CanvasItem, type CanvasItemId, type CanvasJson, type CanvasLayoutNode, type CanvasOpenInput, type CanvasOpenTarget, type CanvasOrientation, type CanvasPane, type CanvasPaneId, type CanvasPersistencePort, type CanvasSplitId, type CanvasState, type CanvasStoreBinding, type ReduxStoreLike, bindCanvasToReduxStore, canvasActions, canvasItemId, canvasReducer, consoleCanvasErrorSink, createCanvasController, createCanvasStore, createInitialCanvasState, createLocalStorageCanvasPersistence, findNonJson, isCanvasAction, isCanvasJson, listPaneIds, normalizeSizes, parseCanvasItemId, sanitizeCanvasSnapshot, selectCanvasActiveItem, selectCanvasFocusedPaneId, selectCanvasIsFullscreen, selectCanvasIsHydrated, selectCanvasIsOpen, selectCanvasItem, selectCanvasItemCount, selectCanvasLayout, selectCanvasPane, selectCanvasPaneCount, selectCanvasWidth, toPersistableSnapshot };
+export { CANVAS_SHORTCUTS, CanvasAction, type CanvasCommandId, CanvasController, CanvasExtraWindow, CanvasItem, CanvasItemId, CanvasJson, type CanvasKeyInput, CanvasLayoutNode, CanvasPane, CanvasPaneId, type CanvasShortcut, type CanvasShortcutWhen, CanvasState, CanvasStoreBinding, CanvasWindowId, type RemoteCanvasStore, type RemoteCanvasStoreOptions, canvasItemId, canvasShortcutHint, canvasWindowId, canvasWindowOfItem, createRemoteCanvasStore, findNonJson, isCanvasJson, listPaneIds, matchesCanvasAccelerator, normalizeSizes, parseCanvasItemId, runCanvasCommand, selectCanvasActiveItem, selectCanvasExtraWindow, selectCanvasFocusedPaneId, selectCanvasIsFullscreen, selectCanvasIsHydrated, selectCanvasIsOpen, selectCanvasItem, selectCanvasItemCount, selectCanvasLayout, selectCanvasPane, selectCanvasPaneCount, selectCanvasWidth, selectCanvasWindowItemCount, selectCanvasWindowOfItem, selectCanvasWindows, shareStructure };