@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selection.d.ts

@@ -0,0 +1,223 @@
+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"];
+export type SelectionResizeMode = "free" | "aspect_ratio_locked";
+export declare const SELECTION_RESIZE_ALL_MODES: readonly ["free", "aspect_ratio_locked"];
+export declare const SELECTION_RESIZE_FREE_ONLY_MODES: readonly ["free"];
+export declare const SELECTION_RESIZE_ASPECT_RATIO_LOCKED_ONLY_MODES: readonly ["aspect_ratio_locked"];
+export type SelectionRotateHandleId = "top_left_rotate" | "top_right_rotate" | "bottom_right_rotate" | "bottom_left_rotate";
+export interface SelectionResizeHandle {
+    kind: "resize";
+    id: SelectionResizeHandleId;
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionRotateHandle {
+    kind: "rotate";
+    id: SelectionRotateHandleId;
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionBindingTerminalHandle {
+    kind: "binding_terminal";
+    terminal: ConnectionTerminal;
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionBindingMiddleHandle {
+    kind: "binding_middle";
+    point: Vec;
+    bounds: Box;
+}
+export interface SelectionCustomHandle {
+    kind: "custom";
+    type: string;
+    id: string;
+    point: Vec;
+    bounds: Box;
+    cursor?: string;
+}
+export interface SelectionResizeHandleAnchor {
+    kind: "resize";
+    id: SelectionResizeHandleId;
+    point: Vec;
+}
+export interface SelectionRotateHandleAnchor {
+    kind: "rotate";
+    id: SelectionRotateHandleId;
+    point: Vec;
+}
+export interface SelectionBindingTerminalHandleAnchor {
+    kind: "binding_terminal";
+    terminal: ConnectionTerminal;
+    point: Vec;
+}
+export interface SelectionBindingMiddleHandleAnchor {
+    kind: "binding_middle";
+    point: Vec;
+}
+export interface SelectionCustomHandleAnchor {
+    kind: "custom";
+    type: string;
+    id: string;
+    point: Vec;
+    cursor?: string;
+}
+export interface SelectionRotationTransform {
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface SelectionFrame extends SelectionRotationTransform {
+    bounds: Box;
+    hasCompatibleRotation: boolean;
+}
+export interface SelectionResizeShapeSnapshot {
+    shape: ShapeRecord;
+    pageShape: ShapeRecord;
+    localBounds: Box;
+    rotation: number;
+}
+export interface SelectionResizePointShapeSnapshot {
+    shape: ShapeRecord;
+    pageShape: ShapeRecord;
+    startLocalPagePoint: Vec;
+    endLocalPagePoint: Vec;
+    middleLocalPagePoint: Vec | null;
+}
+export interface SelectionRotateShapeSnapshot {
+    shape: ShapeRecord;
+    pageShape: ShapeRecord;
+    localBounds: Box;
+    rotation: number;
+}
+export interface SelectionRotatePointShapeSnapshot {
+    shape: ShapeRecord;
+    pageShape: ShapeRecord;
+    startPagePoint: Vec;
+    endPagePoint: Vec;
+    middlePagePoint: Vec | null;
+}
+export interface SelectionResizeSnapshot extends SelectionRotationTransform {
+    startBounds: Box;
+    aspectRatio: number;
+    shapes: SelectionResizeShapeSnapshot[];
+    pointShapes: SelectionResizePointShapeSnapshot[];
+}
+export interface SelectionRotateSnapshot {
+    center: Vec;
+    initialSelectionRotation: number;
+    shapes: SelectionRotateShapeSnapshot[];
+    pointShapes: SelectionRotatePointShapeSnapshot[];
+}
+export type SelectionMirrorAxis = "horizontal" | "vertical";
+export type SelectionHandle = SelectionResizeHandle | SelectionRotateHandle | SelectionBindingTerminalHandle | SelectionBindingMiddleHandle | SelectionCustomHandle;
+export interface BindingPreviewState {
+    terminal: ConnectionTerminal;
+    targetShapeId: ShapeId;
+    resolvedPagePoint: Vec;
+    rawPagePoint: Vec;
+    guidePath?: string | null;
+}
+export interface SelectionBindingSegment {
+    terminal: ConnectionTerminal;
+    anchorPagePoint: Vec;
+    boundaryPagePoint: Vec;
+    guidePath?: string | null;
+}
+export interface TerminalBindingGuideState extends SelectionBindingSegment {
+    ownerShapeId: ShapeId;
+    targetShapeId?: ShapeId | null;
+}
+export interface PointSnapIndicatorState {
+    id: string;
+    type: "points";
+    axis: "x" | "y";
+    line: [Vec, Vec];
+    points: Vec[];
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface GapSnapIndicatorGapState {
+    startEdge: [Vec, Vec];
+    endEdge: [Vec, Vec];
+}
+export interface GapSnapIndicatorState {
+    id: string;
+    type: "gaps";
+    direction: "horizontal" | "vertical";
+    gaps: GapSnapIndicatorGapState[];
+    rotation: number;
+    rotationCenter: Vec;
+}
+export type SnapIndicatorState = PointSnapIndicatorState | GapSnapIndicatorState;
+export interface SelectionOverlayFrameGeometryState {
+    bounds: Box;
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface SelectionOverlayFrameStyleState {
+    strokeWidth: number;
+    cornerRadius: number;
+}
+export interface SelectionOverlayHandlesState {
+    resizeHandles: SelectionResizeHandle[];
+    rotateHandles: SelectionRotateHandle[];
+    terminalHandles: SelectionBindingTerminalHandle[];
+    middleHandles: SelectionBindingMiddleHandle[];
+    customHandles: SelectionCustomHandle[];
+    strokeWidth: number;
+}
+export interface SelectionOverlayHandleAnchorsState {
+    resizeHandleAnchors: SelectionResizeHandleAnchor[];
+    rotateHandleAnchors: SelectionRotateHandleAnchor[];
+    terminalHandleAnchors: SelectionBindingTerminalHandleAnchor[];
+    middleHandleAnchors: SelectionBindingMiddleHandleAnchor[];
+    customHandleAnchors: SelectionCustomHandleAnchor[];
+}
+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;
+export declare function mapSelectionLocalPointBetweenBounds({ point, fromBounds, toBounds, }: {
+    point: Vec;
+    fromBounds: Box;
+    toBounds: Box;
+}): Vec;
+export declare function mapSelectionLocalBoundsBetweenBounds({ bounds, fromBounds, toBounds, }: {
+    bounds: Box;
+    fromBounds: Box;
+    toBounds: Box;
+}): Box;
+export declare function mirrorSelectionLocalPoint({ axis, bounds, point, }: {
+    axis: SelectionMirrorAxis;
+    bounds: Box;
+    point: Vec;
+}): Vec;
+export declare function flipSelectionLocalBounds({ axis, bounds, selectionBounds, }: {
+    axis: SelectionMirrorAxis;
+    bounds: Box;
+    selectionBounds: Box;
+}): Box;
+export declare function getSelectionLocalBoundsFromPagePoints({ points, transform, }: {
+    points: readonly Vec[];
+    transform: SelectionRotationTransform;
+}): Box | null;
+export declare function getSelectionResizeSnapshot({ shapes, selectionFrame, getShapeSelectionResizePageOutlineVertices, getShapeSelectionPagePoints, getShapeSelectionPageMiddlePoint, getShapePageRecord, }: {
+    shapes: ShapeRecord[];
+    selectionFrame: SelectionFrame;
+    getShapeSelectionResizePageOutlineVertices: (shape: ShapeRecord) => Vec[];
+    getShapeSelectionPagePoints: (shape: ShapeRecord) => readonly [Vec, Vec] | null;
+    getShapeSelectionPageMiddlePoint: (shape: ShapeRecord) => Vec | null;
+    getShapePageRecord: (shape: ShapeRecord) => ShapeRecord;
+}): SelectionResizeSnapshot;
+export declare function getSelectionRotateSnapshot({ shapes, selectionFrame, getShapeLocalBounds, getShapeSelectionPagePoints, getShapeSelectionPageMiddlePoint, getShapePageRecord, }: {
+    shapes: ShapeRecord[];
+    selectionFrame: SelectionFrame;
+    getShapeLocalBounds: (shape: ShapeRecord) => Box;
+    getShapeSelectionPagePoints: (shape: ShapeRecord) => readonly [Vec, Vec] | null;
+    getShapeSelectionPageMiddlePoint: (shape: ShapeRecord) => Vec | null;
+    getShapePageRecord: (shape: ShapeRecord) => ShapeRecord;
+}): SelectionRotateSnapshot;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionBindingSegments.d.ts

@@ -0,0 +1,7 @@
+import type { SelectionBindingSegment, TerminalBindingGuideState } from "./selection";
+export declare function cloneSelectionBindingSegment<T extends SelectionBindingSegment>(segment: T): T;
+export declare function cloneSelectionBindingSegments<T extends SelectionBindingSegment>(segments: readonly T[]): T[];
+export declare function areSelectionBindingSegmentsEqual(a: SelectionBindingSegment, b: SelectionBindingSegment): boolean;
+export declare function areSelectionBindingSegmentArraysEqual(a: readonly SelectionBindingSegment[], b: readonly SelectionBindingSegment[]): boolean;
+export declare function areTerminalBindingGuideStatesEqual(a: TerminalBindingGuideState, b: TerminalBindingGuideState): boolean;
+export declare function areTerminalBindingGuideStateArraysEqual(a: readonly TerminalBindingGuideState[], b: readonly TerminalBindingGuideState[]): boolean;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionGeometry.d.ts

@@ -0,0 +1,28 @@
+import type { Signal } from "../../../signals/index";
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { ShapeGeometry } from "../queries/shapeTransforms";
+export interface SelectionGeometrySnapshot {
+    outlineVertices: Vec[];
+    pageBounds: Box | null;
+    frameBounds: Box | null;
+    rotation: number;
+    rotationCenter: Vec | null;
+    selectionAnchorPagePoint: Vec | null;
+    hasRotation: boolean;
+    hasCompatibleRotation: boolean;
+}
+export interface SelectionGeometrySignals {
+    geometry: Signal<SelectionGeometrySnapshot>;
+    pageOutlineVertices: Signal<Vec[]>;
+    pageBounds: Signal<Box | null>;
+    frameBounds: Signal<Box | null>;
+    hasRotation: Signal<boolean>;
+    rotation: Signal<number>;
+    rotationCenter: Signal<Vec | null>;
+    hasCompatibleRotation: Signal<boolean>;
+    selectionAnchorPagePoint: Signal<Vec | null>;
+}
+export declare function createSelectionGeometrySignals(editor: Editor, selectedShapeIdsSignal: Signal<ShapeId[]>, getCachedShapeGeometry: (shapeId: ShapeId) => ShapeGeometry | undefined): SelectionGeometrySignals;

package/_vendor/plugin-runtime-clipboard/_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;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionLayout.d.ts

@@ -0,0 +1,20 @@
+import type { ChangeSource } from "../../../store/index";
+import { Box } from "../../geometry/box";
+import type { PageId } from "../../schema/records";
+import type { Editor } from "../editor";
+type AlignMode = "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom";
+type DistributeAxis = "horizontal" | "vertical";
+interface ZoomToBoundsOptions {
+    padding?: number;
+    maxZoom?: number;
+    source?: ChangeSource;
+}
+export declare function canAlignEditorSelection(editor: Editor): boolean;
+export declare function alignEditorSelection(editor: Editor, mode: AlignMode, source?: ChangeSource): boolean;
+export declare function canDistributeEditorSelection(editor: Editor): boolean;
+export declare function distributeEditorSelection(editor: Editor, axis: DistributeAxis, source?: ChangeSource): boolean;
+export declare function getEditorPageBounds(editor: Editor, pageId?: PageId): Box | null;
+export declare function zoomEditorToBounds(editor: Editor, bounds: Box, options?: ZoomToBoundsOptions): boolean;
+export declare function zoomEditorToFit(editor: Editor, options?: ZoomToBoundsOptions): boolean;
+export declare function zoomEditorToSelection(editor: Editor, options?: ZoomToBoundsOptions): boolean;
+export {};

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionOverlay.d.ts

@@ -0,0 +1,25 @@
+import { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { ShapeSelectionHandleAnchors, ShapeSelectionPathStyle } from "../../shapes/shapeUtil";
+import type { SelectionBindingMiddleHandle, SelectionBindingSegment, SelectionBindingTerminalHandle, SelectionCustomHandle, SelectionFrame, SelectionOverlayHandleAnchorsState, SelectionResizeHandle, SelectionResizeHandleId, SelectionRotateHandle } from "./selection";
+export interface SelectedShapeOverlayItem {
+    id: ShapeId;
+    usesSelectionPathOverlay: boolean;
+    startPagePoint: Vec | null;
+    endPagePoint: Vec | null;
+    middlePagePoint: Vec | null;
+    path: string | null;
+    pathStyle: ShapeSelectionPathStyle | null;
+    pageClipPath: string | null;
+    bindingSegments: readonly SelectionBindingSegment[];
+}
+export interface SelectionHandleState {
+    resizeHandles: SelectionResizeHandle[];
+    rotateHandles: SelectionRotateHandle[];
+    terminalHandles: SelectionBindingTerminalHandle[];
+    middleHandles: SelectionBindingMiddleHandle[];
+    customHandles: SelectionCustomHandle[];
+}
+export declare function isSingleSelectionPathOverlay(selectedShapeItems: SelectedShapeOverlayItem[]): boolean;
+export declare function getSelectionHandleAnchorsState(selectedShapes: ShapeRecord[], selectionFrame: SelectionFrame | null, zoom: number, getShapeSelectionHandleAnchors: (shape: ShapeRecord) => ShapeSelectionHandleAnchors, canUseSelectionResizeHandles: (shape: ShapeRecord) => boolean, canUseSelectionRotateHandle: (shape: ShapeRecord) => boolean, resizeHandleIds: readonly SelectionResizeHandleId[]): SelectionOverlayHandleAnchorsState;
+export declare function materializeSelectionHandleState(anchors: SelectionOverlayHandleAnchorsState, zoom: number): SelectionHandleState;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionOverlayEquality.d.ts

@@ -0,0 +1,8 @@
+import type { SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandlesState } from "./selection";
+import type { SelectedShapeOverlayItem } from "./selectionOverlay";
+export declare function areSelectedShapeOverlayItemsEqual(a: SelectedShapeOverlayItem[], b: SelectedShapeOverlayItem[]): boolean;
+export declare function areSelectionOverlayFrameGeometryStatesEqual(a: SelectionOverlayFrameGeometryState | null, b: SelectionOverlayFrameGeometryState | null): boolean;
+export declare function areSelectionOverlayFrameGeometryArraysEqual(a: SelectionOverlayFrameGeometryState[], b: SelectionOverlayFrameGeometryState[]): boolean;
+export declare function areSelectionOverlayFrameStyleStatesEqual(a: SelectionOverlayFrameStyleState, b: SelectionOverlayFrameStyleState): boolean;
+export declare function areSelectionOverlayHandlesStatesEqual(a: SelectionOverlayHandlesState | null, b: SelectionOverlayHandlesState | null): boolean;
+export declare function areSelectionOverlayHandleAnchorsStatesEqual(a: SelectionOverlayHandleAnchorsState | null, b: SelectionOverlayHandleAnchorsState | null): boolean;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionOverlayManager.d.ts

@@ -0,0 +1,34 @@
+import type { Signal } from "../../../signals/index";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { EditorToolState } from "../state/editorReadModels";
+import type { SelectionBindingSegment, SelectionHandle, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandlesState } from "./selection";
+import { type SelectedShapeOverlayItem } from "./selectionOverlay";
+interface SelectionOverlaySignals {
+    tool: Signal<EditorToolState>;
+    selectedShapeIds: Signal<ShapeRecord["id"][]>;
+    selectedShapes: Signal<ShapeRecord[]>;
+    cameraZoom: Signal<number>;
+}
+/**
+ * Selection overlay derived state: selected items, frame geometry/style,
+ * handles, hit testing, and companion frames. Editor exposes these signals
+ * through its grouped render facade.
+ */
+export declare class SelectionOverlayManager {
+    private readonly editor;
+    private readonly signals;
+    readonly selectedShapeItemsSignal: Signal<SelectedShapeOverlayItem[]>;
+    readonly frameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly companionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly pathSignal: Signal<string | null>;
+    readonly pageClipPathSignal: Signal<string | null>;
+    readonly bindingSegmentsSignal: Signal<SelectionBindingSegment[]>;
+    readonly frameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
+    readonly handleAnchorsSignal: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly handlesSignal: Signal<SelectionOverlayHandlesState | null>;
+    constructor(editor: Editor, signals: SelectionOverlaySignals);
+    hitTestHandle(point: Vec): SelectionHandle | null;
+}
+export {};

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionResizeCapabilities.d.ts

@@ -0,0 +1,11 @@
+import type { ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type SelectionResizeHandleId, type SelectionResizeMode } from "./selection";
+export type SelectionResizeRotationCompatibility = "parallel" | "perpendicular";
+export declare function getSelectionResizeRotationCompatibility(left: number, right: number): SelectionResizeRotationCompatibility | null;
+export declare function areSelectionResizeRotationsCompatible(left: number, right: number): boolean;
+export declare function areSelectionResizeTargetRotationsCompatible(editor: Editor, resizeTargetShapes: readonly ShapeRecord[], selectionRotation: number): boolean;
+export declare function intersectSelectionResizeModes(modeSets: readonly (readonly SelectionResizeMode[])[]): SelectionResizeMode[];
+export declare function getCommonSelectionResizeModesForHandle(editor: Editor, resizeTargetShapes: readonly ShapeRecord[], handleId: SelectionResizeHandleId, selectionRotation: number): SelectionResizeMode[];
+export declare function getCommonSelectionResizeHandleIds(editor: Editor, resizeTargetShapes: readonly ShapeRecord[], selectionRotation: number): SelectionResizeHandleId[];
+export declare function resolveSelectionResizeMode(allowedModes: readonly SelectionResizeMode[], shiftKey: boolean): SelectionResizeMode | null;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionSet.d.ts

@@ -0,0 +1,9 @@
+import type { ChangeSource } from "../../../store/index";
+import type { PageId, ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function setEditorSelectedShapeIds(editor: Editor, ids: ShapeId[], options?: {
+    pageId?: PageId;
+    source?: ChangeSource;
+}): void;
+export declare function removeShapeIdsFromEditorSelection(editor: Editor, ids: ShapeId[], source?: ChangeSource): void;
+export declare function selectAllEditorShapesOnCurrentPage(editor: Editor, source?: ChangeSource): void;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionTargets.d.ts

@@ -0,0 +1,10 @@
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function getShapeIdsForSelectionTransform(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getShapeIdsForSelectionRotation(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getSelectionTransformTargetShapes(editor: Editor): ShapeRecord[];
+export declare function canResizeSelection(editor: Editor): boolean;
+export declare function canFlipSelection(editor: Editor, shapeIds?: Iterable<ShapeId>): boolean;
+export declare function canRotateSelection(editor: Editor): boolean;
+export declare function getSelectionResizeTargetShapes(editor: Editor): ShapeRecord[];
+export declare function getSelectionRotationTargetShapes(editor: Editor): ShapeRecord[];

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/selection/selectionTransforms.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeSelectionFlipAxis } from "../../shapes/shapeUtil";
+import type { ShapeUpdate } from "../commands/commandTypes";
+import type { Editor } from "../editor";
+export declare function resetEditorSelectionRotation(editor: Editor, source?: ChangeSource): void;
+export declare function getEditorSelectionFlipUpdates(editor: Editor, axis: ShapeSelectionFlipAxis): ShapeUpdate[];

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeContainment.d.ts

@@ -0,0 +1,14 @@
+import type { Vec } from "../../geometry/vec";
+import { type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type ShapeGeometryQueryCache } from "../queries/shapeGeometryQueryCache";
+import type { ShapeTreeIndex } from "../queries/shapeTreeIndex";
+export type ShapeContainment = "inside" | "intersecting" | "outside";
+export interface ContainerBoundsQueryOptions {
+    includeIntersecting?: boolean;
+}
+export declare function getShapeContainment(editor: Editor, geometry: ShapeGeometryQueryCache, containerId: ShapeId, shapeId: ShapeId): ShapeContainment | null;
+export declare function getContainingShapeParentId(editor: Editor, shapeTree: ShapeTreeIndex, geometry: ShapeGeometryQueryCache, shapeIds: Iterable<ShapeId>): ShapeParentId | null;
+export declare function getContainingShapeParentIdAtPoint(editor: Editor, shapeTree: ShapeTreeIndex, geometry: ShapeGeometryQueryCache, shapeIds: Iterable<ShapeId>, point: Vec): ShapeParentId | null;
+export declare function getContainingParentIdForShapeRecord(editor: Editor, geometry: ShapeGeometryQueryCache, shape: ShapeRecord): ShapeParentId | null;
+export declare function getShapeIdsInContainerBounds(editor: Editor, containerId: ShapeId, options?: ContainerBoundsQueryOptions): ShapeId[];

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeEditingManager.d.ts

@@ -0,0 +1,33 @@
+import type { Signal } from "../../../signals/index";
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeEditingEntryRequest, ShapeEditingSession, ShapeId, ShapeRecord } from "../../schema/records";
+import type { StartEditingShapeInput } from "../commands/commandTypes";
+import type { Editor } from "../editor";
+/**
+ * Shape editing lifecycle for the editor: edit-session entry, completion,
+ * cancellation, composition state, and focus-entry requests. The Editor exposes
+ * thin wrappers that forward here.
+ */
+export declare class ShapeEditingManager {
+    private readonly editor;
+    private readonly entryRequestAtom;
+    readonly entryRequestSignal: Signal<ShapeEditingEntryRequest | null>;
+    private nextEntryRequestId;
+    private operation;
+    constructor(editor: Editor);
+    canEditShape(shapeOrId: ShapeRecord | ShapeId | null | undefined): boolean;
+    start(input: StartEditingShapeInput, source?: ChangeSource): ShapeEditingSession | null;
+    complete(source?: ChangeSource): boolean;
+    cancel(source?: ChangeSource): boolean;
+    setComposition(isComposing: boolean, source?: ChangeSource): void;
+    consumeEntryRequest(requestId: number): void;
+    removeShapeIds(ids: ShapeId[], source?: ChangeSource): void;
+    prepareForShapeRemoval(ids: readonly ShapeId[], source?: ChangeSource): void;
+    end(options: {
+        runEditEnd: boolean;
+        source: ChangeSource;
+    }): void;
+    cancelOperation(): void;
+    private commitOperation;
+    private publishEntryRequest;
+}

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeExportTraversal.d.ts

@@ -0,0 +1,3 @@
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function getShapeExportTraversalIds(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeGeometry.d.ts

@@ -0,0 +1,21 @@
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import type { ShapeRecord } from "../../schema/records";
+import { type ShapeGeometry } from "../queries/shapeTransforms";
+import { type SelectionFrame } from "../selection/selection";
+import type { Editor } from "../editor";
+export declare function computeEditorShapePositionedBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeLocalBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeRenderBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeExportBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeLocalToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function computeEditorShapeRenderToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function computeEditorShapeExportToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function computeEditorShapePageBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeExportPageBounds(editor: Editor, shape: ShapeRecord): Box;
+export declare function computeEditorShapeGeometry(editor: Editor, shape: ShapeRecord): ShapeGeometry;
+export declare function computeEditorShapePositionedToPageTransform(editor: Editor, shape: ShapeRecord): Mat;
+export declare function getEditorSelectionFrame(editor: Editor): SelectionFrame | null;
+export declare function isPointInEditorSelectionBounds(editor: Editor, point: Vec): boolean;
+export declare function getEditorSelectionFrameLocalBoundsPoint(editor: Editor, point: Vec): Vec | null;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeGrouping.d.ts

@@ -0,0 +1,22 @@
+import type { ChangeSource } from "../../../store/index";
+import { Box } from "../../geometry/box";
+import type { ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+/** Grouping and ungrouping mutations over the physical shape tree. */
+export interface ShapeGroupState {
+    parentId: ShapeParentId;
+    shapeIds: ShapeId[];
+    /** Axis-aligned bounds of the grouped roots in their common parent's local space. */
+    parentLocalBounds: Box;
+}
+export declare function getSelectionGroupState(editor: Editor): ShapeGroupState | null;
+export declare function canGroupSelection(editor: Editor): boolean;
+export declare function canGroupShapes(editor: Editor, ids: readonly ShapeId[]): boolean;
+export declare function groupShapes(editor: Editor, ids: readonly ShapeId[], source?: ChangeSource): ShapeRecord | null;
+export declare function groupSelection(editor: Editor, source?: ChangeSource): ShapeRecord | null;
+export declare function getUngroupableSelectedShapeIds(editor: Editor): ShapeId[];
+export declare function getUngroupableShapeIds(editor: Editor, ids: readonly ShapeId[]): ShapeId[];
+export declare function canUngroupSelection(editor: Editor): boolean;
+export declare function canUngroupShapes(editor: Editor, ids: readonly ShapeId[]): boolean;
+export declare function ungroupShapes(editor: Editor, ids: readonly ShapeId[], source?: ChangeSource): ShapeId[];
+export declare function ungroupSelection(editor: Editor, source?: ChangeSource): ShapeId[];

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeOrder.d.ts

@@ -0,0 +1,32 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+import type { Editor } from "../editor";
+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 LayerOrderDirection = "backward" | "forward";
+export type LayerOrderEdge = "back" | "front";
+export declare function getSelectionParentOrderState(editor: Editor): ShapeSelectionSiblingOrderState | null;
+export declare function getSelectionSiblingOrderState(editor: Editor): ShapeSiblingOrderState | null;
+export declare function canMoveSelectionWithinParent(editor: Editor, direction: ShapeSiblingOrderDirection): boolean;
+export declare function canMoveSelectionInParentOrder(editor: Editor, direction: ShapeSiblingOrderDirection): boolean;
+export declare function getShapeParentOrderState(editor: Editor, ids: readonly ShapeId[]): ShapeSelectionSiblingOrderState | null;
+export declare function canMoveShapesInParentOrder(editor: Editor, ids: readonly ShapeId[], direction: LayerOrderDirection): boolean;
+export declare function moveShapesInParentOrder(editor: Editor, ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource): boolean;
+export declare function moveShapesToParentOrderEdge(editor: Editor, ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource): boolean;
+export declare function moveSelectionWithinParent(editor: Editor, direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+export declare function moveSelectionInParentOrder(editor: Editor, direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+export declare function moveSelectionToParentOrderEdge(editor: Editor, edge: ShapeSiblingOrderEdge, source?: ChangeSource): boolean;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeReparenting.d.ts

@@ -0,0 +1,21 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type ShapeTransformFields } from "../queries/shapeTransforms";
+export type ReparentShapePlacementFailureReason = "notFound" | "locked" | "hidden" | "invalidParent" | "cycle" | "invalidBeforeId" | "unsupportedTransform";
+export type ReparentShapePlacementResult = {
+    ok: true;
+    movedIds: ShapeId[];
+} | {
+    ok: false;
+    reason: ReparentShapePlacementFailureReason;
+};
+export interface ReparentShapePlacementInput {
+    ids: readonly ShapeId[];
+    parentId: ShapeParentId;
+    beforeId?: ShapeId;
+}
+export declare function canReceiveChildren(editor: Editor, parentId: ShapeParentId): boolean;
+export declare function canReceiveChild(editor: Editor, parentId: ShapeParentId, childId: ShapeId): boolean;
+export declare function moveShapesToParentPlacementResult(editor: Editor, input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;
+export declare function getReparentedShapeTransformUpdate(editor: Editor, shape: ShapeRecord, parentId: ShapeParentId): ShapeTransformFields | null;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeSignalManager.d.ts

@@ -0,0 +1,35 @@
+import type { Signal } from "../../../signals/index";
+import type { Vec } from "../../geometry/vec";
+import { type ShapeEditingSession, type ShapeId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+/** Cached per-shape read signals. Editor keeps the public facade methods. */
+export declare class ShapeSignalManager {
+    private readonly editor;
+    private readonly unsubscribeFromStore;
+    private readonly shapeSignals;
+    private readonly contentCutoutLocalPolygonSignals;
+    private readonly selectedSignals;
+    private readonly renderOrderSignals;
+    private readonly renderVisibleSignals;
+    private readonly documentVisibleSignals;
+    private readonly effectiveOpacitySignals;
+    private readonly editingSessionSignals;
+    private readonly dropTargetSignals;
+    private readonly hoveredSignals;
+    private readonly selectedDescendantTransformAncestorSignals;
+    constructor(editor: Editor);
+    dispose(): void;
+    isDocumentHidden(id: ShapeId): boolean;
+    getShapeSignal(id: ShapeId): Signal<ShapeRecord | undefined>;
+    getContentCutoutLocalPolygonsSignal(id: ShapeId): Signal<readonly (readonly Vec[])[]>;
+    getSelectedSignal(id: ShapeId): Signal<boolean>;
+    getRenderOrderSignal(id: ShapeId): Signal<number>;
+    getRenderVisibleSignal(id: ShapeId): Signal<boolean>;
+    getDocumentVisibleSignal(id: ShapeId): Signal<boolean>;
+    getEffectiveOpacitySignal(id: ShapeId): Signal<number>;
+    getEditingSessionSignal(id: ShapeId): Signal<ShapeEditingSession | null>;
+    getDropTargetSignal(id: ShapeId): Signal<boolean>;
+    getHoveredSignal(id: ShapeId): Signal<boolean>;
+    getSelectedDescendantTransformAncestorSignal(id: ShapeId): Signal<boolean>;
+    private evict;
+}

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeTransformSpace.d.ts

@@ -0,0 +1,6 @@
+import type { ShapeRecord } from "../../schema/records";
+import type { ShapeUpdate } from "../commands/commandTypes";
+import type { Editor } from "../editor";
+export declare function getShapePageSpaceRecord(editor: Editor, shape: ShapeRecord): ShapeRecord;
+export declare function tryGetShapePageSpaceRecord(editor: Editor, shape: ShapeRecord): ShapeRecord | null;
+export declare function getShapeParentLocalUpdateFromPageSpace(editor: Editor, shape: ShapeRecord, pageShape: ShapeRecord, pageUpdate: ShapeUpdate): ShapeUpdate | null;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/shapes/shapeTreeQueries.d.ts

@@ -0,0 +1,12 @@
+import { Box } from "../../geometry/box";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function isShapeOrAncestorLocked(editor: Editor, shapeId: ShapeId): boolean;
+export declare function hasLockedDescendant(editor: Editor, shapeId: ShapeId): boolean;
+export declare function getOutermostSelectableShapeId(editor: Editor, shapeId: ShapeId): ShapeId;
+export declare function getShapeIdsIncludingDescendants(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getDescendantPageBounds(editor: Editor, parentId: ShapeParentId): Box | null;
+export declare function getShapeSubtreePageBounds(editor: Editor, shapeId: ShapeId): Box | null;
+export declare function isShapeOrAncestorInSet(editor: Editor, shapeId: ShapeId, ids: ReadonlySet<ShapeId>): boolean;
+export declare function isShapeDescendantOf(editor: Editor, shapeId: ShapeId, ancestorId: ShapeId): boolean;
+export declare function isShapeDescendantOfAny(editor: Editor, shapeId: ShapeId, ancestorIds: ReadonlySet<ShapeId>): boolean;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/snapping/gapSnap.d.ts

@@ -0,0 +1,6 @@
+import type { Box } from "../../geometry/box";
+import type { Gap, GapAxisSnap, GapSnapOptions } from "./snapResults";
+import type { SnapAxis, SnapNode } from "./snapTypes";
+export declare function collectGaps(nodes: SnapNode[], axis: SnapAxis): Gap[];
+export declare function createGap(direction: Gap["direction"], startNode: SnapNode, endNode: SnapNode, axis: SnapAxis): Gap | null;
+export declare function getGapSnap(axis: SnapAxis, selectionBounds: Box, visibleGaps: Gap[], threshold: number, options?: GapSnapOptions): GapAxisSnap | null;

package/_vendor/plugin-runtime-clipboard/_vendor/canvas-core/editor/snapping/pointSnap.d.ts

@@ -0,0 +1,5 @@
+import type { Vec } from "../../geometry/vec";
+import type { PointAxisSnap, PointSnapOptions } from "./snapResults";
+import type { SnapAxis, SnapPoint, SnapPointIndex } from "./snapTypes";
+export declare function buildSnapPointIndex(points: readonly SnapPoint[]): SnapPointIndex;
+export declare function getPointSnap(axis: SnapAxis, selectionPoints: Vec[], pointIndex: SnapPointIndex, threshold: number, options?: PointSnapOptions): PointAxisSnap | null;