@yuzhouu/canvas-kit 0.1.2 → 0.1.3

package/_vendor/canvas-core/editor/Editor.d.ts

@@ -0,0 +1,564 @@
+import { type Signal } from "../../signals/index";
+import type { ArrowTerminalBindingResolver, ArrowTerminalBindingResolverInput, ResolvedArrowTerminalBinding } from "../bindings/arrow/arrowBindingHelpers";
+import type { BindingUtil } from "../bindings/BindingUtil";
+import { BindingUtilRegistry } from "../bindings/BindingUtilRegistry";
+import { Box } from "../geometry/Box";
+import { Mat } from "../geometry/Mat";
+import { Vec } from "../geometry/Vec";
+import { type BindingId, type BindingRecord, type AssetId, type AssetRecord, type Camera, type PageId, type PageRecord, type EditorRecord, type RecordScope, type SessionRecord, type ShapeId, type ShapeParentId, type ShapeRecord, type ShapeEditingEntryRequest, type ShapeEditingSession } from "../schema/records";
+import { type DocumentSnapshot, type SessionSnapshot } from "../schema/snapshots";
+import type { ShapeSelectionFlipAxis, ShapeUtil } from "../shapes/ShapeUtil";
+import { ShapeUtilRegistry } from "../shapes/ShapeUtilRegistry";
+import { ShapeSvgExporterRegistry, type ShapeSvgExporter, type SvgExportOptions, type SvgExportResult } from "../exports/svg";
+import { type ExportIntegrityRepairResult, type ExportIntegrityReport } from "../exports/integrity";
+import { type ShapeCapabilityDefinition, type ShapeCapabilityManifest } from "../shapes/capabilities";
+import { Store, type ChangeSource, type StoreChange } from "../../store/index";
+import { type CreateAssetInput, type CreateBindingInput, type CreatePageInput, type CreateShapeInput, type StartEditingShapeInput, type EditorCommands } from "./commands";
+import type { CancelEditorEvent, EditorEvent } from "./events";
+import { HistoryManager, type HistoryState } from "./HistoryManager";
+import { BindingManager } from "./managers/BindingManager";
+import { CameraManager } from "./managers/CameraManager";
+import { ClipboardManager } from "./managers/ClipboardManager";
+import { DocumentSnapshotManager } from "./managers/DocumentSnapshotManager";
+import { InputsManager } from "./managers/InputsManager";
+import { InteractionTransientManager, type LaserTrailState } from "./managers/InteractionTransientManager";
+import { QueryManager, type ShapeContainment } from "./managers/QueryManager";
+import { SpatialIndexManager, type ShapeAtPointOptions, type ShapeLineSegmentHitTestOptions, type SpatialQueryOptions } from "./managers/SpatialIndexManager";
+import { SnapManager } from "./managers/SnapManager";
+import { SideEffectManager } from "./managers/SideEffectManager";
+import { SelectionLayoutManager } from "./managers/SelectionLayoutManager";
+import { SelectionManager } from "./managers/SelectionManager";
+import { SelectionOverlayManager } from "./managers/SelectionOverlayManager";
+import { ShapeEditingManager } from "./managers/ShapeEditingManager";
+import { ShapeGeometryManager } from "./managers/ShapeGeometryManager";
+import { ShapeHierarchyManager } from "./managers/ShapeHierarchyManager";
+import { RenderWindowManager } from "./managers/RenderWindowManager";
+import { ToolManager } from "./managers/ToolManager";
+import type { ShapeGeometry } from "./queries/shapeTransforms";
+import { editorStoreSymbol } from "./internal";
+import type { DuplicateSelectionInput, EditorClipboardPayload, PasteClipboardPayloadInput } from "./clipboard";
+import { InteractionHandlerRegistry } from "./interactions";
+import { SelectionHandleInteractionRegistry } from "./selectionHandleInteractions";
+import { type SelectedShapeOverlayItem } from "./selectionOverlay";
+import type { ArrowBindingPreviewState, SnapIndicatorState, SelectionHandle, SelectionFrame, SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState } from "./selection";
+export interface EditorOptions {
+    shapeUtils?: ShapeUtil[];
+    shapeSvgExporters?: ShapeSvgExporter[];
+    bindingUtils?: BindingUtil[];
+    shapeCapabilities?: readonly ShapeCapabilityDefinition[];
+    resolveAssetUrl?: (assetId: AssetId) => string | null;
+    documentSnapshot?: unknown;
+    sessionSnapshot?: unknown;
+}
+export interface ContainerBoundsQueryOptions {
+    includeIntersecting?: boolean;
+}
+export interface RenderItem {
+    id: ShapeId;
+    shape: ShapeRecord;
+    bounds: Box;
+    isSelected: boolean;
+}
+export interface EditorPageState {
+    pages: PageRecord[];
+    currentPageId: PageId;
+    currentPage: PageRecord | null;
+    canDeleteCurrentPage: boolean;
+}
+export interface EditorToolState {
+    activeToolId: string;
+    isToolLocked: boolean;
+}
+export type ShapeSiblingOrderDirection = "backward" | "forward";
+export type ShapeSiblingOrderEdge = "back" | "front";
+export interface ShapeSiblingOrderState {
+    parentId: ShapeParentId;
+    index: number;
+    count: number;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export interface ShapeSelectionSiblingOrderState {
+    parentId: ShapeParentId;
+    selectedCount: number;
+    count: number;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export type ReparentShapePlacementFailureReason = "notFound" | "locked" | "hidden" | "invalidParent" | "cycle" | "invalidBeforeId";
+export type ReparentShapePlacementResult = {
+    ok: true;
+    movedIds: ShapeId[];
+} | {
+    ok: false;
+    reason: ReparentShapePlacementFailureReason;
+};
+export interface ReparentShapePlacementInput {
+    ids: readonly ShapeId[];
+    parentId: ShapeParentId;
+    beforeId?: ShapeId;
+}
+export interface ShapeGroupState {
+    parentId: ShapeParentId;
+    shapeIds: ShapeId[];
+    bounds: Box;
+}
+export interface LayerTreeNode {
+    id: ShapeId;
+    parentId: ShapeParentId;
+    pageId: PageId;
+    type: ShapeRecord["type"];
+    childIds: ShapeId[];
+    index: number;
+    depth: number;
+    isHidden: boolean;
+    isLocked: boolean;
+    isEffectivelyHidden: boolean;
+    isEffectivelyLocked: boolean;
+}
+export type LayerOrderDirection = "backward" | "forward";
+export type LayerOrderEdge = "back" | "front";
+export type ShapePropsPatch = Record<string, unknown>;
+export interface EditorShapeEditingState {
+    editingShapeId: ShapeId | null;
+    session: ShapeEditingSession | null;
+}
+export interface EditorShapeEditingEntryRequestState {
+    request: ShapeEditingEntryRequest | null;
+}
+export interface EditorSelectionState {
+    count: number;
+    singleShapeType: ShapeRecord["type"] | null;
+    commonShapeType: ShapeRecord["type"] | null;
+    hasPointHandleSelection: boolean;
+    hasFrameSelection: boolean;
+    isMixedFrameAndPointHandleSelection: boolean;
+    canDragPointHandles: boolean;
+    hasSelectionRotation: boolean;
+    hasMixedSelectionRotation: boolean;
+    canResetSelectionRotation: boolean;
+    frameBounds: Box | null;
+    frameRotation: number;
+    frameRotationCenter: Vec | null;
+    toolbarAnchorPagePoint: Vec | null;
+}
+export interface EditorRenderHostDebugState {
+    culledCount: number;
+    visibleCount: number;
+    retainedCount: number;
+    retainedBaseCount: number;
+    culledRangeCount: number;
+    culledRangeSpan: number;
+    culledRangesSummary: string;
+    retainedBaseRangeCount: number;
+    retainedBaseRangeSpan: number;
+    retainedBaseRangesSummary: string;
+    retainedRangeCount: number;
+    retainedRangeSpan: number;
+    retainedRangesSummary: string;
+    retainedChangeCount: number;
+    retainedAddedCount: number;
+    retainedRemovedCount: number;
+    selectedOutsideCulledCount: number;
+}
+export interface EditorOverlayDebugState {
+    selectionFrameActive: boolean;
+    selectionHandlesActive: boolean;
+    bindingPreviewActive: boolean;
+    brushBoxActive: boolean;
+    selectionFrameChangeCount: number;
+    selectionHandlesChangeCount: number;
+    resizeHandleCount: number;
+    rotateHandleCount: number;
+    terminalHandleCount: number;
+    middleHandleCount: number;
+    customHandleCount: number;
+    boundsSummary: string;
+    rotation: number | null;
+    strokeWidth: number | null;
+}
+interface ReadonlyStore {
+    readonly recordsSignal: Signal<Map<string, EditorRecord>>;
+    get(id: string): EditorRecord | undefined;
+    getAll(): EditorRecord[];
+    getByScope(scope: RecordScope): EditorRecord[];
+    listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
+}
+export declare class Editor {
+    readonly store: ReadonlyStore;
+    readonly [editorStoreSymbol]: Store<EditorRecord>;
+    readonly inputs: InputsManager;
+    readonly snapshots: DocumentSnapshotManager;
+    readonly clipboard: ClipboardManager;
+    readonly tools: ToolManager;
+    readonly camera: CameraManager;
+    readonly selection: SelectionManager;
+    readonly selectionLayout: SelectionLayoutManager;
+    readonly editing: ShapeEditingManager;
+    readonly geometry: ShapeGeometryManager;
+    readonly hierarchy: ShapeHierarchyManager;
+    readonly shapeUtils: ShapeUtilRegistry;
+    readonly shapeSvgExporters: ShapeSvgExporterRegistry;
+    readonly bindingUtils: BindingUtilRegistry;
+    readonly interactions: InteractionHandlerRegistry;
+    readonly selectionHandleInteractions: SelectionHandleInteractionRegistry;
+    readonly queries: QueryManager;
+    readonly bindings: BindingManager;
+    readonly spatialIndex: SpatialIndexManager;
+    readonly snaps: SnapManager;
+    readonly renderWindow: RenderWindowManager;
+    readonly selectionOverlay: SelectionOverlayManager;
+    readonly transients: InteractionTransientManager;
+    readonly history: HistoryManager;
+    readonly sideEffects: SideEffectManager;
+    readonly commands: EditorCommands;
+    private readonly shapeCapabilityDefinitions;
+    readonly brushBoxSignal: Signal<Box | null>;
+    readonly brushBoxActiveSignal: Signal<boolean>;
+    readonly erasingShapeIdsSignal: Signal<ShapeId[]>;
+    readonly erasingShapeIdsActiveSignal: Signal<boolean>;
+    readonly eraserTrailSignal: Signal<Vec[]>;
+    readonly eraserTrailActiveSignal: Signal<boolean>;
+    readonly laserTrailSignal: Signal<LaserTrailState | null>;
+    readonly laserTrailActiveSignal: Signal<boolean>;
+    readonly bindingPreviewSignal: Signal<ArrowBindingPreviewState | null>;
+    readonly bindingPreviewActiveSignal: Signal<boolean>;
+    readonly dropTargetShapeIdSignal: Signal<ShapeId | null>;
+    readonly snapIndicatorsSignal: Signal<SnapIndicatorState[]>;
+    readonly snapIndicatorsActiveSignal: Signal<boolean>;
+    get viewportScreenSizeSignal(): Signal<{
+        w: number;
+        h: number;
+    }>;
+    readonly shapeEditingEntryRequestSignal: Signal<ShapeEditingEntryRequest | null>;
+    private readonly _shapeDefaultPropsByTypeSignal;
+    readonly shapeDefaultPropsByTypeSignal: Signal<ReadonlyMap<ShapeRecord["type"], ShapePropsPatch>>;
+    private nextShapeNumber;
+    private nextPageNumber;
+    private nextBindingNumber;
+    private nextAssetNumber;
+    private assetUrlResolver;
+    private get _internalStore();
+    readonly sessionSignal: import("../../signals/index").Computed<SessionRecord>;
+    readonly currentPageIdSignal: import("../../signals/index").Computed<`page:${string}`>;
+    readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
+    readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
+    readonly culledShapeIdsSignal: Signal<ShapeId[]>;
+    readonly renderVisibleShapeIdsSignal: Signal<ShapeId[]>;
+    readonly retainedShapeIdsSignal: Signal<ShapeId[]>;
+    readonly selectionPageBoundsSignal: Signal<Box | null>;
+    readonly selectionFrameBoundsSignal: Signal<Box | null>;
+    readonly selectionToolbarAnchorPagePointSignal: Signal<Vec | null>;
+    readonly pagesSignal: import("../../signals/index").Computed<PageRecord[]>;
+    readonly currentPageSignal: import("../../signals/index").Computed<PageRecord | null>;
+    readonly pageStateSignal: import("../../signals/index").Computed<EditorPageState>;
+    readonly toolStateSignal: import("../../signals/index").Computed<EditorToolState>;
+    readonly editingShapeIdSignal: import("../../signals/index").Computed<`shape:${string}` | null>;
+    readonly shapeEditingSessionSignal: import("../../signals/index").Computed<ShapeEditingSession | null>;
+    readonly shapeEditingStateSignal: import("../../signals/index").Computed<EditorShapeEditingState>;
+    readonly currentCameraSignal: import("../../signals/index").Computed<Camera>;
+    readonly selectedShapeIdsSignal: import("../../signals/index").Computed<`shape:${string}`[]>;
+    readonly selectedShapeIdSetSignal: import("../../signals/index").Computed<Set<`shape:${string}`>>;
+    readonly selectedShapesSignal: import("../../signals/index").Computed<ShapeRecord[]>;
+    readonly selectedShapeOverlayItemsSignal: import("../../signals/index").Computed<SelectedShapeOverlayItem[]>;
+    readonly selectionStateSignal: import("../../signals/index").Computed<EditorSelectionState>;
+    readonly pageTransformSignal: import("../../signals/index").Computed<Mat>;
+    readonly cameraZoomSignal: import("../../signals/index").Computed<number>;
+    readonly viewportPageBoundsSignal: import("../../signals/index").Computed<Box | null>;
+    readonly renderViewportPageBoundsSignal: import("../../signals/index").Computed<Box | null>;
+    readonly renderItemsSignal: Signal<RenderItem[]>;
+    readonly renderHostDebugStateSignal: Signal<EditorRenderHostDebugState>;
+    readonly historyStateSignal: Signal<HistoryState>;
+    readonly shapeRenderOrderByIdSignal: Signal<Map<ShapeId, number>>;
+    readonly culledShapeIdSetSignal: Signal<Set<ShapeId>>;
+    readonly selectedShapeIdsOutsideCulledSignal: Signal<ShapeId[]>;
+    readonly selectedShapeIdsOutsideCulledSetSignal: Signal<Set<ShapeId>>;
+    readonly renderVisibleShapeIdSetSignal: Signal<Set<ShapeId>>;
+    private readonly shapeSignals;
+    private readonly shapeSelectedSignals;
+    private readonly shapeRenderOrderSignals;
+    private readonly shapeRenderVisibleSignals;
+    private readonly shapeDocumentVisibleSignals;
+    private readonly shapeEditingSessionSignals;
+    private readonly shapeDropTargetSignals;
+    private readonly shapeErasingSignals;
+    private readonly shapeSelectedDescendantTransformAncestorSignals;
+    private lastPointerDownForClickCount;
+    private lastPointerUpForClickCount;
+    private currentPointerClickCount;
+    readonly selectionOverlayFrameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly selectionOverlayCompanionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly selectionOverlayArrowPathSignal: Signal<string | null>;
+    readonly selectionOverlayFrameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
+    readonly selectionOverlayFrameSignal: Signal<SelectionOverlayFrameState | null>;
+    readonly selectionOverlayHandleAnchorsSignal: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly selectionOverlayHandlesSignal: Signal<SelectionOverlayHandlesState | null>;
+    readonly selectionOverlayHandleCountsSignal: Signal<SelectionOverlayHandleCountsState | null>;
+    readonly selectionOverlaySignal: Signal<SelectionOverlayState | null>;
+    readonly overlayDebugStateSignal: Signal<EditorOverlayDebugState>;
+    constructor(options?: EditorOptions);
+    private registerBuiltInSideEffects;
+    dispatch(event: EditorEvent): void;
+    handleInteractionEvent(event: EditorEvent): boolean;
+    private normalizeEvent;
+    private getDoubleClickEvent;
+    listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
+    getRenderItems(): RenderItem[];
+    getPages(): PageRecord[];
+    getCurrentPageId(): PageId;
+    getActiveToolId(): string;
+    isToolLocked(): boolean;
+    isActiveToolInInitialState(): boolean;
+    getEditingShapeId(): ShapeId | null;
+    getShapeEditingSession(): ShapeEditingSession | null;
+    getShapeEditingEntryRequest(): ShapeEditingEntryRequest | null;
+    resetPointerClickTracking(): void;
+    getCurrentPageShapeIds(): ShapeId[];
+    getPage(id: PageId): PageRecord | undefined;
+    getCurrentCamera(): Camera;
+    undo(): boolean;
+    redo(): boolean;
+    createPageAndSelect(input?: CreatePageInput, source?: ChangeSource): PageRecord;
+    selectPage(pageId: PageId, source?: ChangeSource): void;
+    renamePage(pageId: PageId, name: string, source?: ChangeSource): void;
+    deletePage(pageId: PageId, source?: ChangeSource): boolean;
+    setActiveTool(toolId: string, source?: ChangeSource): void;
+    setToolLocked(locked: boolean, source?: ChangeSource): void;
+    toggleToolLocked(source?: ChangeSource): void;
+    getCamera(pageId?: PageId): Camera;
+    pageToScreen(point: Vec, pageId?: PageId): Vec;
+    screenToPage(point: Vec, pageId?: PageId): Vec;
+    getSelectedShapeIds(pageId?: PageId): ShapeId[];
+    isShapeHidden(shapeId: ShapeId): boolean;
+    getSelectedShapes(): ShapeRecord[];
+    getDefaultShapeProps<TProps extends object = object>(type: ShapeRecord["type"]): TProps;
+    updateDefaultShapeProps(type: ShapeRecord["type"], props: ShapePropsPatch): void;
+    getSelectionParentOrderState(): ShapeSelectionSiblingOrderState | null;
+    getSelectionGroupState(): ShapeGroupState | null;
+    canGroupSelection(): boolean;
+    getLayerTree(pageId?: PageId): LayerTreeNode[];
+    getLayerNode(id: ShapeId): LayerTreeNode | null;
+    canGroupShapes(ids: readonly ShapeId[]): boolean;
+    groupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeRecord | null;
+    groupSelection(source?: ChangeSource): ShapeRecord | null;
+    getUngroupableSelectedShapeIds(): ShapeId[];
+    getUngroupableShapeIds(ids: readonly ShapeId[]): ShapeId[];
+    canUngroupSelection(): boolean;
+    canUngroupShapes(ids: readonly ShapeId[]): boolean;
+    ungroupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeId[];
+    ungroupSelection(source?: ChangeSource): ShapeId[];
+    getSelectionSiblingOrderState(): ShapeSiblingOrderState | null;
+    canMoveSelectionWithinParent(direction: ShapeSiblingOrderDirection): boolean;
+    canMoveSelectionInParentOrder(direction: ShapeSiblingOrderDirection): boolean;
+    canMoveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection): boolean;
+    moveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource): boolean;
+    moveShapesToParentOrderEdge(ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource): boolean;
+    moveSelectionWithinParent(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+    /**
+     * Align selected top-level shapes along an edge or center of their combined
+     * page bounds. Only shapes parented directly to the current page are moved so
+     * the page-space delta maps directly onto `x`/`y`. Needs at least two shapes.
+     */
+    alignSelection(mode: "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom", source?: ChangeSource): boolean;
+    /**
+     * Distribute selected top-level shapes so the gaps between them are equal
+     * along the given axis. Needs at least three shapes.
+     */
+    distributeSelection(axis: "horizontal" | "vertical", source?: ChangeSource): boolean;
+    moveShapesToParentPlacement(input: ReparentShapePlacementInput, source?: ChangeSource): boolean;
+    moveShapesToParentPlacementResult(input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;
+    moveSelectionInParentOrder(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+    moveSelectionToParentOrderEdge(edge: ShapeSiblingOrderEdge, source?: ChangeSource): boolean;
+    canEditShape(shapeOrId: ShapeRecord | ShapeId | null | undefined): boolean;
+    startEditingShape(input: StartEditingShapeInput, source?: ChangeSource): ShapeEditingSession | null;
+    completeEditing(source?: ChangeSource): boolean;
+    cancelEditing(source?: ChangeSource): boolean;
+    setShapeEditingComposition(isComposing: boolean, source?: ChangeSource): void;
+    consumeShapeEditingEntryRequest(requestId: number): void;
+    deleteSelection(source?: ChangeSource): void;
+    deleteShapesById(ids: readonly ShapeId[], source?: ChangeSource): void;
+    setShapesHidden(ids: readonly ShapeId[], isHidden: boolean, source?: ChangeSource): ShapeId[];
+    setShapesLocked(ids: readonly ShapeId[], isLocked: boolean, source?: ChangeSource): ShapeId[];
+    createClipboardPayloadFromSelection(): EditorClipboardPayload | null;
+    pasteClipboardPayload(input: PasteClipboardPayloadInput): ShapeId[];
+    duplicateSelection(input?: DuplicateSelectionInput): ShapeId[];
+    selectAllCurrentPage(source?: ChangeSource): void;
+    resetSelectionRotation(source?: ChangeSource): void;
+    flipSelection(axis: ShapeSelectionFlipAxis, source?: ChangeSource): void;
+    getShape(id: ShapeId): ShapeRecord | undefined;
+    getAsset(id: AssetId): AssetRecord | undefined;
+    getAssets(): AssetRecord[];
+    resolveAssetUrl(assetId: AssetId): string | null;
+    getUnreferencedAssetIdsAfterShapeDelete(shapeIds: readonly ShapeId[]): AssetId[];
+    getShapeSignal(id: ShapeId): Signal<ShapeRecord | undefined>;
+    getShapeSelectedSignal(id: ShapeId): Signal<boolean>;
+    getShapeRenderOrderSignal(id: ShapeId): Signal<number>;
+    getShapeRenderVisibleSignal(id: ShapeId): Signal<boolean>;
+    getShapeDocumentVisibleSignal(id: ShapeId): Signal<boolean>;
+    getShapeEditingSessionForShapeSignal(id: ShapeId): Signal<ShapeEditingSession | null>;
+    getShapeDropTargetSignal(id: ShapeId): Signal<boolean>;
+    getShapeErasingSignal(id: ShapeId): Signal<boolean>;
+    getShapeSelectedDescendantTransformAncestorSignal(id: ShapeId): Signal<boolean>;
+    getBinding(id: BindingId): BindingRecord | undefined;
+    getShapesForPage(pageId: PageId): ShapeRecord[];
+    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
+    getChildShapeIds(parentId: ShapeParentId): ShapeId[];
+    getChildShapes(parentId: ShapeParentId): ShapeRecord[];
+    getDescendantShapeIds(parentId: ShapeParentId): ShapeId[];
+    getDescendantPageBounds(parentId: ShapeParentId): Box | null;
+    getShapeSubtreePageBounds(shapeId: ShapeId): Box | null;
+    getShapePageId(shapeId: ShapeId): PageId | null;
+    isShapeOrAncestorLocked(shapeId: ShapeId): boolean;
+    hasLockedDescendant(shapeId: ShapeId): boolean;
+    getOutermostSelectableShapeId(shapeId: ShapeId): ShapeId;
+    getShapeIdsIncludingDescendants(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeIdsForSelectionTransform(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeIdsForSelectionRotation(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getSelectionTransformTargetShapes(): ShapeRecord[];
+    getSelectionRotationTargetShapes(): ShapeRecord[];
+    getShapeExportTraversalIds(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeContainment(containerId: ShapeId, shapeId: ShapeId): ShapeContainment | null;
+    getContainingShapeParentId(shapeIds: Iterable<ShapeId>): ShapeParentId | null;
+    getContainingParentIdForShapeRecord(shape: ShapeRecord): ShapeParentId | null;
+    getShapeClipAncestorIds(shapeId: ShapeId): ShapeId[];
+    getShapeClipAncestorIdsSignal(shapeId: ShapeId): Signal<ShapeId[]>;
+    isPagePointInShapeClip(shapeId: ShapeId, point: Vec): boolean;
+    getShapeClippedPageBounds(shapeId: ShapeId): Box | null;
+    getShapeIdsInContainerBounds(containerId: ShapeId, options?: ContainerBoundsQueryOptions): ShapeId[];
+    canUseShapeParent(parentId: ShapeParentId, childId?: ShapeId): boolean;
+    getShapeUtil<S extends ShapeRecord>(shape: S): ShapeUtil<S>;
+    getBindingUtil<B extends BindingRecord>(binding: B): BindingUtil<B>;
+    computeShapeBounds(shape: ShapeRecord): Box;
+    computeShapeLocalBounds(shape: ShapeRecord): Box;
+    computeShapeRenderBounds(shape: ShapeRecord): Box;
+    computeShapeExportBounds(shape: ShapeRecord): Box;
+    computeShapeLocalToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeRenderToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeExportToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageBounds(shape: ShapeRecord): Box;
+    computeShapeExportPageBounds(shape: ShapeRecord): Box;
+    computeShapeGeometry(shape: ShapeRecord): ShapeGeometry;
+    computeShapePositionedToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageCenter(shape: ShapeRecord): Vec;
+    computeShapePageCorners(shape: ShapeRecord): Vec[];
+    computeShapePageOutlineVertices(shape: ShapeRecord): Vec[];
+    getShapeBounds(shapeId: ShapeId): Box | null;
+    getShapePageBounds(shapeId: ShapeId): Box | null;
+    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | null;
+    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | null;
+    getShapePageCenter(shapeId: ShapeId): Vec | null;
+    getShapePageCorners(shapeId: ShapeId): Vec[] | null;
+    getShapePageOutlineVertices(shapeId: ShapeId): Vec[];
+    getSelectionPageBounds(): Box | null;
+    getSelectionFrame(): SelectionFrame | null;
+    isPointInSelectionBounds(point: Vec): boolean;
+    getSelectionFrameLocalBoundsPoint(point: Vec): Vec | null;
+    getSelectionPageOutlineVertices(): Vec[];
+    getSelectionToolbarAnchorPagePoint(): Vec | null;
+    hitTestSelectionHandle(point: Vec): SelectionHandle | null;
+    setBrushBox(brushBox: Box | null): void;
+    getErasingShapeIds(): ShapeId[];
+    setErasingShapeIds(shapeIds: readonly ShapeId[]): void;
+    clearErasingShapeIds(): void;
+    getEraserTrail(): Vec[];
+    setEraserTrail(points: readonly Vec[]): void;
+    clearEraserTrail(): void;
+    startLaserTrail(): number;
+    setLaserTrail(sessionId: number, points: readonly Vec[]): void;
+    finishLaserTrail(sessionId: number): void;
+    clearLaserTrail(sessionId: number): void;
+    setBindingPreview(preview: ArrowBindingPreviewState | null): void;
+    setDropTargetShapeId(shapeId: ShapeId | null): void;
+    setSnapIndicators(indicators: SnapIndicatorState[] | null): void;
+    setArrowTerminalBindingResolver(resolver: ArrowTerminalBindingResolver): void;
+    resolveArrowTerminalBinding(input: ArrowTerminalBindingResolverInput): ResolvedArrowTerminalBinding;
+    clearSelectionTransients(): void;
+    hitTestShape(point: Vec): ShapeRecord | null;
+    hitTestShapesAtPoint(point: Vec, options?: ShapeAtPointOptions): ShapeRecord[];
+    hitTestShapesByLineSegment(start: Vec, end: Vec, options?: ShapeLineSegmentHitTestOptions): ShapeRecord[];
+    getShapeIdsInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeId[];
+    getShapesInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getShapesInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getDocumentSnapshot(): DocumentSnapshot;
+    getSessionSnapshot(): SessionSnapshot;
+    getSvgString(shapeIds?: Iterable<ShapeId>, options?: SvgExportOptions): SvgExportResult | null;
+    getExportIntegrityReport(shapeIds?: Iterable<ShapeId>): ExportIntegrityReport;
+    repairExportIntegrity(shapeIds?: Iterable<ShapeId>): ExportIntegrityRepairResult;
+    getShapeCapabilityManifest(): ShapeCapabilityManifest;
+    createPageRecord(input?: {
+        name?: string;
+        index?: string;
+        meta?: Record<string, unknown>;
+    }): PageRecord;
+    loadDocumentSnapshot(snapshot: unknown, options?: {
+        source?: ChangeSource;
+    }): void;
+    loadSessionSnapshot(snapshot: unknown, options?: {
+        source?: ChangeSource;
+    }): void;
+    syncAfterDocumentRestore(): void;
+    cancelInteractionForCommand(): void;
+    cancelInteractionAndClearTransients(reason: CancelEditorEvent["reason"]): void;
+    syncToolStateFromSession(source: ChangeSource): void;
+    createShapeRecord(input: CreateShapeInput): ShapeRecord;
+    createBindingRecord(input: CreateBindingInput): BindingRecord;
+    createAssetRecord(input: CreateAssetInput): AssetRecord;
+    updateSession(partial: Partial<SessionRecord>, source?: ChangeSource): void;
+    setCurrentPage(pageId: PageId, source?: ChangeSource): void;
+    setSelectedShapeIds(ids: ShapeId[], options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    removeShapeIdsFromSelection(ids: ShapeId[], source?: ChangeSource): void;
+    removeShapeIdsFromEditingSession(ids: ShapeId[], source?: ChangeSource): void;
+    ensurePageSessionState(pageId: PageId, source?: ChangeSource): void;
+    removePageSessionState(pageId: PageId, nextCurrentPageId: PageId, source?: ChangeSource): void;
+    setCamera(partial: Partial<Camera>, options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    panCamera(delta: Vec, source?: ChangeSource): void;
+    zoomCameraAtScreenPoint(screenPoint: Vec, deltaY: number, source?: ChangeSource): void;
+    zoomCameraToScreenPoint(screenPoint: Vec, zoom: number, source?: ChangeSource): void;
+    zoomAtViewportCenter(deltaY: number, source?: ChangeSource): void;
+    resetZoom(source?: ChangeSource): void;
+    setViewportScreenSize(size: {
+        w: number;
+        h: number;
+    }): void;
+    /** Combined page bounds of every shape on a page, or null when empty. */
+    getCurrentPageBounds(pageId?: PageId): Box | null;
+    /**
+     * Move and zoom the camera so `bounds` fits inside the viewport with optional
+     * padding (screen px). Returns false when the viewport or bounds are empty.
+     */
+    zoomToBounds(bounds: Box, options?: {
+        padding?: number;
+        maxZoom?: number;
+        source?: ChangeSource;
+    }): boolean;
+    /** Fit all shapes on the current page into the viewport. */
+    zoomToFit(options?: {
+        padding?: number;
+        source?: ChangeSource;
+    }): boolean;
+    /** Fit the current selection into the viewport. */
+    zoomToSelection(options?: {
+        padding?: number;
+        source?: ChangeSource;
+    }): boolean;
+    private createShapeId;
+    createShapeIndex(shapeNumber: number): string;
+    private createBindingId;
+    private createAssetId;
+    syncShapeCounter(): void;
+    syncPageCounter(): void;
+    syncBindingCounter(): void;
+    syncAssetCounter(): void;
+    private createPageId;
+    private createPageIndex;
+    private handleWheelEvent;
+}
+export {};

package/_vendor/canvas-core/editor/HistoryManager.d.ts

@@ -0,0 +1,18 @@
+import { type StoreHistoryEntry, type StoreHistoryState } from "../../store/index";
+import { type DocumentRecord } from "../schema/records";
+import type { Editor } from "./Editor";
+export type HistoryState = StoreHistoryState;
+export declare class HistoryManager {
+    private readonly editor;
+    private readonly buffer;
+    readonly state: import("../../signals/index").Signal<StoreHistoryState>;
+    constructor(editor: Editor);
+    clear(): void;
+    mark(id: string): void;
+    bailToMark(id: string): void;
+    squashToMark(id: string, label?: string): void;
+    undo(): boolean;
+    redo(): boolean;
+    getEntries(): readonly StoreHistoryEntry<DocumentRecord>[];
+    private handleStoreChange;
+}

package/_vendor/canvas-core/editor/StateNode.d.ts

@@ -0,0 +1,31 @@
+import type { Editor } from "./Editor";
+import type { CancelEditorEvent, ClickEditorEvent, EditorEvent, KeyboardEditorEvent, PointerEditorEvent, TickEditorEvent, WheelEditorEvent } from "./events";
+export declare abstract class StateNode {
+    readonly editor: Editor;
+    readonly id: string;
+    readonly parent?: StateNode | undefined;
+    protected readonly children: Map<string, StateNode>;
+    protected currentChild: StateNode | null;
+    protected initial: string | null;
+    constructor(editor: Editor, id: string, parent?: StateNode | undefined);
+    protected addChild(child: StateNode): void;
+    enter(info?: unknown): void;
+    exit(info?: unknown): void;
+    transition(id: string, info?: unknown): void;
+    isInInitialState(): boolean;
+    dispatch(event: EditorEvent): void;
+    protected onEnter(_info?: unknown): void;
+    protected onExit(_info?: unknown): void;
+    protected onPointerDown(_event: PointerEditorEvent): void;
+    protected onPointerMove(_event: PointerEditorEvent): void;
+    protected onPointerUp(_event: PointerEditorEvent): void;
+    protected onDoubleClick(_event: ClickEditorEvent): void;
+    protected onCancel(_event: CancelEditorEvent): void;
+    protected onKeyDown(_event: KeyboardEditorEvent): void;
+    protected onKeyUp(_event: KeyboardEditorEvent): void;
+    protected onWheel(_event: WheelEditorEvent): void;
+    protected onTick(_event: TickEditorEvent): void;
+    private handlePointerEvent;
+    private handleClickEvent;
+    private handleKeyboardEvent;
+}

package/_vendor/canvas-core/editor/camera.d.ts

@@ -0,0 +1,3 @@
+export declare const CAMERA_MIN_ZOOM = 0.1;
+export declare const CAMERA_MAX_ZOOM = 8;
+export declare function clampCameraZoom(zoom: number): number;

package/_vendor/canvas-core/editor/clipboard.d.ts

@@ -0,0 +1,43 @@
+import type { ChangeSource } from "../../store/index";
+import { Vec } from "../geometry/Vec";
+import type { AssetId, AssetRecord, BindingRecord, ShapeId, ShapeRecord } from "../schema/records";
+import type { Editor } from "./Editor";
+export interface EditorClipboardPayload {
+    type: "land/clipboard";
+    version: 1;
+    source: {
+        app: "land";
+        documentId?: string;
+    };
+    rootShapeIds: readonly ShapeId[];
+    records: {
+        shapes: readonly ShapeRecord[];
+        bindings: readonly BindingRecord[];
+        assets: readonly AssetRecord[];
+    };
+    bounds: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+export interface ClipboardAssetSidecar {
+    assetId: AssetId;
+    kind: "local-image-blob";
+    storageKey: string;
+}
+export interface PasteClipboardPayloadInput {
+    payload: EditorClipboardPayload;
+    pagePoint?: Vec;
+    offset?: Vec;
+    source?: ChangeSource;
+}
+export interface DuplicateSelectionInput {
+    offset?: Vec;
+    source?: ChangeSource;
+}
+export declare function isEditorClipboardPayload(value: unknown): value is EditorClipboardPayload;
+export declare function createEditorClipboardPayloadFromSelection(editor: Editor): EditorClipboardPayload | null;
+export declare function pasteEditorClipboardPayload(editor: Editor, input: PasteClipboardPayloadInput): ShapeId[];
+export declare function duplicateEditorSelection(editor: Editor, input?: DuplicateSelectionInput): ShapeId[];