@yuzhouu/canvas-kit 0.1.13 → 0.1.14

package/_vendor/canvas-core/editor/events/canvasNavigationInteraction.d.ts

@@ -0,0 +1,2 @@
+import type { LandInteractionHandler } from "./interactions";
+export declare function createCanvasNavigationInteractionHandler(): LandInteractionHandler;

package/_vendor/canvas-core/editor/events/eventRouter.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "../editor";
+import type { CancelEditorEvent, EditorEvent, EditorEventResult } from "./events";
+export declare class EditorEventRouter {
+    private readonly editor;
+    private readonly clickRecognizer;
+    private readonly activeRoutes;
+    constructor(editor: Editor);
+    handle(event: EditorEvent): EditorEventResult;
+    cancelInteraction(reason: CancelEditorEvent["reason"], options?: {
+        notifyInteractionHandlers?: boolean;
+    }): void;
+    private routeNewEvent;
+    private routeAfterInputs;
+    private routeCancellation;
+    private routeEscape;
+}

package/_vendor/canvas-core/editor/{events.d.ts → events/events.d.ts}

@@ -1,6 +1,5 @@
-import type { Vec } from "../geometry/vec";
+import type { Vec } from "../../geometry/vec";
 export type EditorPointerType = "mouse" | "touch" | "pen";
-export type EditorClickEventName = "double_click";
 export interface PointerEditorEvent {
     type: "pointer";
     name: "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel";
@@ -9,7 +8,6 @@ export interface PointerEditorEvent {
     button: number;
     buttons: number;
     pointerType: EditorPointerType;
-    clickCount?: number;
     screenPoint: Vec;
     pagePoint: Vec;
     pressure: number;
@@ -19,10 +17,8 @@ export interface PointerEditorEvent {
     metaKey: boolean;
     accelKey: boolean;
 }
-export interface ClickEditorEvent {
-    type: "click";
-    name: EditorClickEventName;
-    phase: "down" | "up";
+export interface DoubleClickEditorEvent {
+    type: "double_click";
     timestamp: number;
     pointerId: number;
     button: number;
@@ -68,4 +64,18 @@ export interface CancelEditorEvent {
     type: "cancel";
     reason: "escape" | "pointer_cancel" | "blur" | "page_switch" | "tool_switch" | "dispose" | "command" | "restore";
 }
-export type EditorEvent = PointerEditorEvent | ClickEditorEvent | KeyboardEditorEvent | WheelEditorEvent | TickEditorEvent | CancelEditorEvent;
+export interface EditorEventContext {
+    readonly origin: "external" | "derived";
+    readonly pointer: {
+        readonly clickCount: number;
+    } | null;
+}
+export interface EditorEventRoutingEffect {
+    propagation?: "stop";
+    clickSequence?: "break";
+}
+export interface EditorEventResult {
+    claimed: boolean;
+}
+export type EditorEvent = PointerEditorEvent | DoubleClickEditorEvent | KeyboardEditorEvent | WheelEditorEvent | TickEditorEvent | CancelEditorEvent;
+export declare function mergeEditorEventRoutingEffects(left?: EditorEventRoutingEffect | void, right?: EditorEventRoutingEffect | void): EditorEventRoutingEffect | undefined;

package/_vendor/canvas-core/editor/{managers → events}/inputsManager.d.ts

@@ -1,4 +1,5 @@
-import type { EditorEvent, PointerEditorEvent } from "../events";
+import type { Atom, Computed, SignalGraph } from "../../../signals/index";
+import type { EditorEvent, PointerEditorEvent } from "./events";
 import { Vec } from "../../geometry/vec";
 export type InputDragPhase = "idle" | "pointing" | "dragging";
 export interface InputsState {
@@ -25,9 +26,10 @@ export interface InputsState {
     accelKey: boolean;
 }
 export declare class InputsManager {
-    readonly pressedKeyCodes: import("../../../signals/index").Atom<ReadonlySet<string>>;
-    readonly isSpacePressed: import("../../../signals/index").Computed<boolean>;
-    readonly state: import("../../../signals/index").Atom<InputsState>;
+    readonly pressedKeyCodes: Atom<ReadonlySet<string>>;
+    readonly isSpacePressed: Computed<boolean>;
+    readonly state: Atom<InputsState>;
+    constructor(signals: SignalGraph);
     setCurrentPointerPoint(input: {
         timestamp: number;
         pagePoint: Vec;

package/_vendor/canvas-core/editor/{interactions.d.ts → events/interactions.d.ts}

@@ -1,10 +1,10 @@
-import type { ChangeSource } from "../../store/index";
-import type { Vec } from "../geometry/vec";
-import type { ShapeId, ShapeRecord } from "../schema/records";
-import type { Editor } from "./editor";
-import type { CancelEditorEvent, EditorEvent, PointerEditorEvent } from "./events";
-import type { SelectionHandle } from "./selection";
-import type { HandleSnapContext, HandleSnapMode } from "./managers/snapTypes";
+import type { ChangeSource } from "../../../store/index";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { CancelEditorEvent, EditorEvent, EditorEventContext, EditorEventRoutingEffect, PointerEditorEvent } from "./events";
+import type { SelectionHandle } from "../selection/selection";
+import type { HandleSnapContext, HandleSnapMode } from "../snapping/snapTypes";
 export interface SelectionHandleInteractionInput {
     handle: SelectionHandle;
     shape: ShapeRecord;
@@ -12,7 +12,7 @@ export interface SelectionHandleInteractionInput {
 }
 export interface PointerDragInteractionSession {
     readonly shapeId: ShapeId;
-    readonly historyMark: string;
+    readonly operationKind: string;
     readonly shouldClearBindingPreviewOnExit?: boolean;
     onDragStart?(input: {
         editor: Editor;
@@ -62,12 +62,12 @@ export interface ShapePointerInteractionInput {
 export interface ShapePointerInteractionHandler {
     createSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
 }
-export type EditorEventInteractionDecision = "continue" | "handled";
 export interface EditorEventInteractionHandler {
-    handleEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
+    handleEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
 }
 export interface LandInteractionHandler {
     id: string;
+    enabledInReadonly?: boolean;
     editorEvent?: EditorEventInteractionHandler;
     selectionHandle?: SelectionHandleInteractionHandler;
     shapePointer?: ShapePointerInteractionHandler;
@@ -77,8 +77,8 @@ export declare class InteractionHandlerRegistry {
     private readonly registeredIds;
     register(handler: LandInteractionHandler): void;
     getHandlers(): readonly LandInteractionHandler[];
-    handleEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
-    broadcastEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
+    handleEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | undefined;
+    broadcastEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | undefined;
     createSelectionHandleSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
     createShapePointerSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
 }

package/_vendor/canvas-core/editor/events/keyboardShortcuts.d.ts

@@ -0,0 +1,23 @@
+import type { KeyboardEditorEvent } from "./events";
+export interface KeyboardShortcutChord {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    accelKey?: boolean;
+}
+export type KeyboardShortcutInput = string | KeyboardShortcutChord;
+export type KeyboardShortcutEventLike = Pick<KeyboardEditorEvent, "key" | "altKey" | "ctrlKey" | "metaKey" | "shiftKey" | "accelKey">;
+interface NormalizedKeyboardShortcutChord {
+    key: string;
+    altKey: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey: boolean;
+    accelKey?: boolean;
+}
+export declare function normalizeKeyboardShortcut(shortcut: KeyboardShortcutInput): NormalizedKeyboardShortcutChord;
+export declare function formatKeyboardShortcut(shortcut: KeyboardShortcutInput): string;
+export declare function doesKeyboardShortcutMatch(shortcut: KeyboardShortcutInput, event: KeyboardShortcutEventLike): boolean;
+export {};

package/_vendor/canvas-core/editor/events/pointerClickRecognizer.d.ts

@@ -0,0 +1,11 @@
+import type { DoubleClickEditorEvent, EditorEvent, EditorEventContext, EditorEventRoutingEffect } from "./events";
+export declare class PointerClickRecognizer {
+    private lastPointerDown;
+    private lastPointerUp;
+    private currentClickCount;
+    createContext(event: EditorEvent, origin: EditorEventContext["origin"]): EditorEventContext;
+    complete(event: EditorEvent, context: EditorEventContext, effect?: EditorEventRoutingEffect | void): DoubleClickEditorEvent | null;
+    private isContinuation;
+    private matchesCurrentPointer;
+    private reset;
+}

package/_vendor/canvas-core/editor/history/historyManager.d.ts

@@ -0,0 +1,40 @@
+import type { Signal } from "../../../signals/index";
+import { type StoreHistoryEntry } from "../../../store/index";
+import type { DocumentRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+export interface HistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+/** A temporary modal history source that takes priority over document history. */
+export interface HistoryScope {
+    getState(): HistoryState;
+    subscribe(listener: () => void): () => void;
+    undo(): boolean;
+    redo(): boolean;
+}
+/**
+ * Records undoable user commits, routes temporary history scopes, and replays
+ * document history through EditorOperationManager without recording it again.
+ */
+export declare class HistoryManager {
+    private readonly editor;
+    private readonly buffer;
+    private readonly activeScopes;
+    private readonly stateAtom;
+    private readonly unsubscribeOperations;
+    private isDisposed;
+    readonly state: Signal<HistoryState>;
+    constructor(editor: Editor);
+    clear(): void;
+    activateScope(scope: HistoryScope): () => void;
+    dispose(): void;
+    undo(): boolean;
+    redo(): boolean;
+    getEntries(): readonly StoreHistoryEntry<DocumentRecord>[];
+    private handleCommit;
+    private deactivateScope;
+    private step;
+    private replay;
+    private publishEffectiveState;
+}

package/_vendor/canvas-core/editor/{operationManager.d.ts → history/operationManager.d.ts}

@@ -1,14 +1,20 @@
-import { type ChangeSource, type RecordsDiff } from "../../store/index";
-import { type DocumentRecord } from "../schema/records";
-import type { DocumentSnapshot, SessionSnapshot } from "../schema/snapshots";
-import type { Editor } from "./editor";
+import { type ChangeSource, type RecordsDiff } from "../../../store/index";
+import { type DocumentRecord } from "../../schema/records";
+import type { DocumentSnapshot, SessionSnapshot } from "../../schema/snapshots";
+import type { Editor } from "../editor";
 export type EditorOperationHistory = "record" | "ignore";
 export interface EditorOperationOptions {
+    /** Stable semantic name such as `shape.translate` or `history.undo`. */
     kind: string;
     label?: string;
     source?: ChangeSource;
+    /** Controls undo recording without suppressing commit publication. */
     history?: EditorOperationHistory;
 }
+/**
+ * The net document change published at the end of a root editor operation.
+ * Store listeners still observe every realtime batch that produced this commit.
+ */
 export interface EditorCommit {
     id: string;
     revision: number;
@@ -37,29 +43,25 @@ interface EditorOperationState {
     parent: EditorOperationState | null;
     diff: RecordsDiff<DocumentRecord>;
     status: "active" | "committed" | "cancelled";
-    handle: EditorOperationHandle;
 }
 type CommitListener = (commit: EditorCommit) => void;
-declare class EditorOperationHandle implements EditorOperation {
-    private readonly manager;
-    readonly state: EditorOperationState;
-    constructor(manager: EditorOperationManager, state: EditorOperationState);
-    get id(): string;
-    get kind(): string;
-    get source(): ChangeSource;
-    get isActive(): boolean;
-    commit(): EditorCommit | null;
-    cancel(): void;
-}
+/**
+ * Groups realtime document Store changes into semantic editor operations.
+ *
+ * This is not the Store transaction boundary and does not own the undo stack.
+ * It collects already-committed Store diffs, supports operation rollback, and
+ * publishes one EditorCommit for HistoryManager and persistence consumers.
+ */
 export declare class EditorOperationManager {
     private readonly editor;
+    private readonly onUnhandledError;
     private readonly stack;
     private readonly commitListeners;
     private readonly commitQueue;
     private nextOperationId;
     private revision;
-    private isPublishing;
-    constructor(editor: Editor);
+    private isDrainingCommitQueue;
+    constructor(editor: Editor, onUnhandledError?: (error: unknown) => void);
     begin(options: EditorOperationOptions): EditorOperation;
     run<T>(options: EditorOperationOptions, fn: () => T): T;
     getActive(): EditorOperation | null;
@@ -70,5 +72,6 @@ export declare class EditorOperationManager {
     private getActiveState;
     private assertTopActive;
     private enqueueCommit;
+    private reportUnhandledError;
 }
 export {};

package/_vendor/canvas-core/editor/queries/bindingQueryCache.d.ts

@@ -0,0 +1,28 @@
+import type { Signal } from "../../../signals/index";
+import { type BindingRecord, type ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare class BindingQueryCache {
+    private readonly editor;
+    private state;
+    private readonly bindingsFromShapeSignals;
+    private readonly bindingsToShapeSignals;
+    private readonly bindingsForShapeSignals;
+    private draftBindingIndex;
+    private readonly unsubscribeFromStore;
+    constructor(editor: Editor);
+    dispose(): void;
+    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsFromShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
+    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsToShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
+    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsForShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
+    private handleStoreChange;
+    private updateCachedSignals;
+    private getBindingsFromState;
+    private getBindingsToState;
+    private getBindingsForState;
+    private getBindingsForIds;
+    private getDraftBindingIndex;
+    private getDraftBindingsForRelation;
+}

package/_vendor/canvas-core/editor/queries/bindingQueryState.d.ts

@@ -0,0 +1,11 @@
+import type { StoreChange } from "../../../store/index";
+import { type BindingId, type BindingRecord, type EditorRecord, type ShapeId } from "../../schema/records";
+export interface BindingQueryState {
+    bindingById: Map<BindingId, BindingRecord>;
+    bindingIdsByFromShape: Map<ShapeId, BindingId[]>;
+    bindingIdsByToShape: Map<ShapeId, BindingId[]>;
+    relatedBindingIdsByShape: Map<ShapeId, BindingId[]>;
+}
+export declare function compareBindings(left: BindingRecord, right: BindingRecord): number;
+export declare function buildBindingQueryState(records: readonly EditorRecord[]): BindingQueryState;
+export declare function updateBindingQueryState(previous: BindingQueryState, change: StoreChange<EditorRecord>): BindingQueryState;

package/_vendor/canvas-core/editor/queries/draftBindingIndex.d.ts

@@ -0,0 +1,19 @@
+import type { RecordsDiff } from "../../../store/index";
+import { type BindingId, type BindingRecord, type EditorRecord, type ShapeId } from "../../schema/records";
+export type BindingRelation = "from" | "to" | "related";
+interface DraftRelationIndex {
+    changesByShape: Map<ShapeId, Map<BindingId, BindingRecord | undefined>>;
+    cacheByShape: Map<ShapeId, readonly BindingRecord[]>;
+}
+export interface DraftBindingIndex {
+    revision: number;
+    relations: Record<BindingRelation, DraftRelationIndex>;
+}
+export declare function createDraftBindingIndex(revision: number, diff: RecordsDiff<EditorRecord>): DraftBindingIndex;
+export declare function getDraftBindingsForRelation({ committed, draftIndex, relation, shapeId, }: {
+    committed: readonly BindingRecord[];
+    draftIndex: DraftBindingIndex;
+    relation: BindingRelation;
+    shapeId: ShapeId;
+}): readonly BindingRecord[];
+export {};

package/_vendor/canvas-core/editor/queries/shapeGeometryQueryCache.d.ts

@@ -0,0 +1,34 @@
+import type { Signal } from "../../../signals/index";
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import { type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type ShapeGeometry } from "./shapeTransforms";
+type ShapeReader = (id: ShapeId) => ShapeRecord | undefined;
+export declare function resolveShapeParentToPageTransform(editor: Editor, parentId: ShapeParentId, readShape: ShapeReader): Mat | undefined;
+export declare class ShapeGeometryQueryCache {
+    private readonly editor;
+    private readonly signalsByShapeId;
+    private readonly unsubscribeFromStore;
+    constructor(editor: Editor);
+    dispose(): void;
+    getCachedShapeGeometry(shapeId: ShapeId): ShapeGeometry | undefined;
+    getShapePageBoundsSignal(shapeId: ShapeId): Signal<Box | undefined>;
+    getShapeLocalToPageTransformSignal(shapeId: ShapeId): Signal<Mat | undefined>;
+    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | undefined;
+    getShapeLocalToPageTransform(shapeId: ShapeId): Mat | undefined;
+    getShapeParentToPageTransform(parentId: ShapeParentId): Mat | undefined;
+    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | undefined;
+    getShapePageBounds(shapeId: ShapeId): Box | undefined;
+    getShapePositionedBounds(shapeId: ShapeId): Box | undefined;
+    getShapePageCenter(shapeId: ShapeId): Vec | undefined;
+    getShapePageCorners(shapeId: ShapeId): Vec[] | undefined;
+    getShapePageOutlineVertices(shapeId: ShapeId): Vec[] | undefined;
+    getShapeClipAncestorIds(shapeId: ShapeId): ShapeId[];
+    getShapeClipAncestorIdsSignal(shapeId: ShapeId): Signal<ShapeId[]>;
+    isPagePointInShapeClip(shapeId: ShapeId, point: Vec): boolean;
+    getShapeClippedPageBounds(shapeId: ShapeId): Box | null;
+    private getOrCreateSignals;
+}
+export {};

package/_vendor/canvas-core/editor/queries/shapeTransforms.d.ts

@@ -28,19 +28,16 @@ export interface ShapeTransformDecompositionOptions {
  * without shear and therefore return null.
  */
 export declare function getShapeTransformFieldsFromMatrix(matrix: Mat, localBounds: Box, options?: ShapeTransformDecompositionOptions): ShapeTransformFields | null;
-export declare function getShapeLocalBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
-export declare function getShapeRenderBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
-export declare function getShapeExportBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;
-export declare function getShapeLocalToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Mat;
-export declare function getShapePositionedToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Mat;
-export declare function getShapeRenderToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Mat;
-export declare function getShapeExportToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Mat;
-export declare function getShapePageCenter<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Vec;
-export declare function positionedShapePointToPagePoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>, parentLocalToPage?: Mat): Vec;
-export declare function pagePointToShapePositionedPoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>, parentLocalToPage?: Mat): Vec;
+export declare function getShapeLocalToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapePositionedToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapeRenderToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapeExportToPageTransform<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Mat;
+export declare function getShapePageCenter<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Vec;
+export declare function positionedShapePointToPagePoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>, parentToPage: Mat): Vec;
+export declare function pagePointToShapePositionedPoint<S extends ShapeRecord>(shape: S, point: Vec, util: ShapeUtil<S>, parentToPage: Mat): Vec;
 export declare function getShapePositionedOutlineVertices<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Vec[];
-export declare function getShapePageCorners<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Vec[];
-export declare function getShapePageOutlineVertices<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Vec[];
-export declare function getShapePageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Box;
-export declare function getShapeExportPageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): Box;
-export declare function getShapeGeometry<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentLocalToPage?: Mat): ShapeGeometry;
+export declare function getShapePageCorners<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Vec[];
+export declare function getShapePageOutlineVertices<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Vec[];
+export declare function getShapePageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Box;
+export declare function getShapeExportPageBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): Box;
+export declare function getShapeGeometry<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>, parentToPage: Mat): ShapeGeometry;

package/_vendor/canvas-core/editor/queries/shapeTreeIndex.d.ts

@@ -0,0 +1,27 @@
+import type { Signal } from "../../../signals/index";
+import { type PageId, type PageRecord, type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { ShapeTreeSnapshotEntry } from "../state/editorReadModels";
+export declare class ShapeTreeIndex {
+    private readonly editor;
+    readonly pagesSignal: Signal<PageRecord[]>;
+    readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
+    readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
+    readonly currentPageShapeTreeSignal: Signal<ShapeTreeSnapshotEntry[]>;
+    private readonly stateAtom;
+    private readonly pagesAtom;
+    private readonly pageShapeIdsSignals;
+    private readonly unsubscribeFromStore;
+    constructor(editor: Editor, currentPageIdSignal: Signal<PageId>);
+    dispose(): void;
+    getShapeIdsForPageSignal(pageId: PageId): Signal<ShapeId[]>;
+    getShapeIdsForPage(pageId: PageId): ShapeId[];
+    getShapesForPage(pageId: PageId): ShapeRecord[];
+    getChildShapeIds(parentId: ShapeParentId): ShapeId[];
+    getChildShapes(parentId: ShapeParentId): ShapeRecord[];
+    getDescendantShapeIds(parentId: ShapeParentId): ShapeId[];
+    getPageIdForShape(shapeId: ShapeId): PageId | null;
+    private getShapeIdsForPageSnapshot;
+    private getChildShapeIdsSnapshot;
+    private handleStoreChange;
+}

package/_vendor/canvas-core/editor/queries/shapeTreeIndexState.d.ts

@@ -0,0 +1,11 @@
+import type { StoreChange } from "../../../store/index";
+import { type EditorRecord, type PageId, type ShapeId, type ShapeParentId } from "../../schema/records";
+export interface ShapeTreeIndexState {
+    pageShapeIdsByPage: Map<PageId, ShapeId[]>;
+    childShapeIdsByParent: Map<ShapeParentId, ShapeId[]>;
+    pageIdByShape: Map<ShapeId, PageId>;
+}
+type ReadEditorRecord = (id: string) => EditorRecord | undefined;
+export declare function buildShapeTreeIndexState(records: readonly EditorRecord[]): ShapeTreeIndexState;
+export declare function updateShapeTreeIndexState(previous: ShapeTreeIndexState, change: StoreChange<EditorRecord>, getRecord: ReadEditorRecord): ShapeTreeIndexState;
+export {};

package/_vendor/canvas-core/editor/{managers → queries}/spatialIndexManager.d.ts

@@ -2,7 +2,8 @@ import { Box } from "../../geometry/box";
 import { Vec } from "../../geometry/vec";
 import type { PageId, ShapeRecord } from "../../schema/records";
 import type { Editor } from "../editor";
-import type { QueryManager } from "./queryManager";
+import type { ShapeGeometryQueryCache } from "./shapeGeometryQueryCache";
+import type { ShapeTreeIndex } from "./shapeTreeIndex";
 export interface SpatialQueryOptions {
     pageId?: PageId;
 }
@@ -16,9 +17,10 @@ export interface ShapeLineSegmentHitTestOptions extends SpatialQueryOptions {
 }
 export declare class SpatialIndexManager {
     private readonly editor;
-    private readonly queries;
+    private readonly shapeTree;
+    private readonly geometry;
     private readonly pageIndexSignals;
-    constructor(editor: Editor, queries: QueryManager);
+    constructor(editor: Editor, shapeTree: ShapeTreeIndex, geometry: ShapeGeometryQueryCache);
     getShapesInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
     getShapeIdsInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord["id"][];
     getShapesInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];

package/_vendor/canvas-core/editor/records/documentSnapshots.d.ts

@@ -0,0 +1,14 @@
+import { type ChangeSource } from "../../../store/index";
+import { type EditorRecord } from "../../schema/records";
+import { type DocumentSnapshot, type SessionSnapshot } from "../../schema/snapshots";
+import type { Editor } from "../editor";
+export declare function createInitialEditorRecords(documentMeta?: Record<string, unknown>): EditorRecord[];
+export declare function getEditorDocumentSnapshot(editor: Editor): DocumentSnapshot;
+export declare function getEditorSessionSnapshot(editor: Editor): SessionSnapshot;
+export declare function loadEditorDocumentSnapshot(editor: Editor, snapshot: unknown, options?: {
+    source?: ChangeSource;
+}): void;
+export declare function loadEditorSessionSnapshot(editor: Editor, snapshot: unknown, options?: {
+    source?: ChangeSource;
+}): void;
+export declare function syncAfterDocumentRestore(editor: Editor): void;

package/_vendor/canvas-core/editor/records/editorRecordFactory.d.ts

@@ -0,0 +1,19 @@
+import { type AssetRecord, type BindingRecord, type PageRecord, type ShapeRecord } from "../../schema/records";
+import type { CreateAssetInput, CreateBindingInput, CreatePageInput, CreateShapeInput } from "../commands/commandTypes";
+import type { Editor } from "../editor";
+export declare function getEditorRecordFactory(editor: Editor): EditorRecordFactory;
+export declare function createEditorRecordFactory(editor: Editor): EditorRecordFactory;
+export declare class EditorRecordFactory {
+    private readonly editor;
+    private nextShapeNumber;
+    private nextPageNumber;
+    private nextBindingNumber;
+    private nextAssetNumber;
+    constructor(editor: Editor);
+    createPage(input?: CreatePageInput): PageRecord;
+    createShape(input: CreateShapeInput): ShapeRecord;
+    createBinding(input: CreateBindingInput): BindingRecord;
+    createAsset(input: CreateAssetInput): AssetRecord;
+    createShapeIndex(shapeNumber: number): string;
+    syncCounters(): void;
+}

package/_vendor/canvas-core/editor/records/recordQueries.d.ts

@@ -0,0 +1,3 @@
+import type { AssetId, PageId, ShapeId, ShapeRecord } from "../../schema/records";
+export declare function getShapePageIdFromParentChain(shape: ShapeRecord, shapeById: ReadonlyMap<ShapeId, ShapeRecord>, pageIds: ReadonlySet<PageId>): PageId | null;
+export declare function getShapeAssetId(shape: ShapeRecord): AssetId | null;

package/_vendor/canvas-core/editor/{resizeGeometry.d.ts → selection/resizeGeometry.d.ts}

@@ -1,5 +1,5 @@
-import { Box } from "../geometry/box";
-import { Vec } from "../geometry/vec";
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
 import type { SelectionResizeHandleId } from "./selection";
 export interface SelectionResizeBoundsResult {
     bounds: Box;

package/_vendor/canvas-core/editor/{selection.d.ts → selection/selection.d.ts}

@@ -1,7 +1,7 @@
-import { Box } from "../geometry/box";
-import { Vec } from "../geometry/vec";
-import type { ConnectionTerminal } from "../bindings/terminalBinding";
-import type { ShapeId, ShapeRecord } from "../schema/records";
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { ConnectionTerminal } from "../../bindings/terminalBinding";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
 export type SelectionResizeHandleId = "top_left" | "top" | "top_right" | "right" | "bottom_right" | "bottom" | "bottom_left" | "left";
 export declare const SELECTION_RESIZE_HANDLE_IDS: readonly ["top_left", "top", "top_right", "right", "bottom_right", "bottom", "bottom_left", "left"];
 export declare const SELECTION_RESIZE_CORNER_HANDLE_IDS: readonly ["top_left", "top_right", "bottom_right", "bottom_left"];
@@ -154,25 +154,6 @@ export interface GapSnapIndicatorState {
     rotationCenter: Vec;
 }
 export type SnapIndicatorState = PointSnapIndicatorState | GapSnapIndicatorState;
-export interface SelectionOverlayState {
-    bounds: Box;
-    rotation: number;
-    rotationCenter: Vec;
-    resizeHandles: SelectionResizeHandle[];
-    rotateHandles: SelectionRotateHandle[];
-    terminalHandles: SelectionBindingTerminalHandle[];
-    middleHandles: SelectionBindingMiddleHandle[];
-    customHandles: SelectionCustomHandle[];
-    strokeWidth: number;
-    cornerRadius: number;
-}
-export interface SelectionOverlayFrameState {
-    bounds: Box;
-    rotation: number;
-    rotationCenter: Vec;
-    strokeWidth: number;
-    cornerRadius: number;
-}
 export interface SelectionOverlayFrameGeometryState {
     bounds: Box;
     rotation: number;
@@ -197,13 +178,6 @@ export interface SelectionOverlayHandleAnchorsState {
     middleHandleAnchors: SelectionBindingMiddleHandleAnchor[];
     customHandleAnchors: SelectionCustomHandleAnchor[];
 }
-export interface SelectionOverlayHandleCountsState {
-    resizeHandleCount: number;
-    rotateHandleCount: number;
-    terminalHandleCount: number;
-    middleHandleCount: number;
-    customHandleCount: number;
-}
 export declare function selectionPagePointToLocalPoint(point: Vec, transform: SelectionRotationTransform): Vec;
 export declare function selectionLocalPointToPagePoint(point: Vec, transform: SelectionRotationTransform): Vec;
 export declare function rotateSelectionPagePoint(point: Vec, transform: SelectionRotationTransform): Vec;

package/_vendor/canvas-core/editor/{managers → selection}/selectionGeometry.d.ts

@@ -1,4 +1,4 @@
-import { type Signal } from "../../../signals/index";
+import type { Signal } from "../../../signals/index";
 import { Box } from "../../geometry/box";
 import { Vec } from "../../geometry/vec";
 import type { ShapeId } from "../../schema/records";
@@ -25,4 +25,4 @@ export interface SelectionGeometrySignals {
     hasCompatibleRotation: Signal<boolean>;
     selectionAnchorPagePoint: Signal<Vec | null>;
 }
-export declare function createSelectionGeometrySignals(editor: Editor, getShapeGeometrySnapshot: (shapeId: ShapeId) => ShapeGeometry | undefined): SelectionGeometrySignals;
+export declare function createSelectionGeometrySignals(editor: Editor, selectedShapeIdsSignal: Signal<ShapeId[]>, getCachedShapeGeometry: (shapeId: ShapeId) => ShapeGeometry | undefined): SelectionGeometrySignals;

package/_vendor/canvas-core/editor/selection/selectionHandleHitTest.d.ts

@@ -0,0 +1,8 @@
+import type { Vec } from "../../geometry/vec";
+import { type SelectionFrame, type SelectionHandle, type SelectionOverlayHandlesState } from "./selection";
+export declare function hitTestSelectionHandles({ point, selectionFrame, handles, hitDistance, }: {
+    point: Vec;
+    selectionFrame: SelectionFrame | null;
+    handles: SelectionOverlayHandlesState;
+    hitDistance: number;
+}): SelectionHandle | null;