@yuzhouu/canvas-kit 0.1.10 → 0.1.12

package/README.md

@@ -76,7 +76,23 @@ interface CanvasKitRuntimeOptions {
 }
 ```
 
-Controller callbacks, window exposure, and `windowKey` are mount concerns and belong on `CanvasKitRoot`.
+Controller callbacks, window exposure, and `windowKey` are mount concerns and
+belong on `CanvasKitRoot`. Export appearance is supplied to each export request;
+it is not stored on the Root or Runtime.
+
+`plugins` is the complete caller-supplied plugin graph. Before compiling it,
+CanvasKit adds Runtime default providers for clipboard behavior, import host,
+generic tool actions, and the export API only when the graph does not already
+provide the corresponding capability token. A plugin that provides
+`canvasClipboardRuntimeCapability`, `canvasToolActionsCapability`, or
+`canvasExportApiToken` therefore replaces that default implementation. Runtime
+defaults and caller plugins use the same `CanvasPlugin` contract and compile
+into one dependency graph.
+
+CanvasKit-specific import, keyboard, and tool-action defaults live with the
+composition root under `src/plugins/runtime`. Reusable clipboard and export
+capabilities remain independent Runtime plugin packages. Physical ownership
+does not change capability replacement semantics.
 
 ## Startup result
 
@@ -90,9 +106,9 @@ interface CanvasKitStartupResult {
 }
 ```
 
-Startup loads snapshots, resets to a clean document/session, restores the document or seeds after a clean fallback, restores session state, clears history, prepares assets, runs `beforeReady`, and starts persistence. Recoverable load/restore/asset/hook/persistence errors are returned in `warnings`. Synchronous assembly and seed failures are fatal.
+Startup loads snapshots, resets to a clean document/session, restores the document or seeds after a clean fallback, restores session state, clears history, prepares assets, runs `beforeReady`, and starts Runtime-owned persistence coordination. Recoverable load/restore/asset/hook errors are returned in `warnings`. Synchronous assembly and seed failures are fatal.
 
-Disposal aborts startup, stops persistence, runs setup disposers in reverse order, then disposes Editor and services. A disposed Runtime cannot restart.
+Disposal aborts startup and unwinds one Runtime-owned disposer stack in reverse creation order. Persistence, plugin setup resources, Editor, and services all enter that stack. A disposed Runtime cannot restart.
 
 ## Persistence adapter
 
@@ -106,12 +122,16 @@ interface ProductPersistenceAdapter {
     documentSnapshot: unknown | null;
     sessionSnapshot: unknown | null;
   }>;
-  start?(editor: Editor): () => void;
-  flushSnapshot?(editor: Editor): Promise<void>;
+  saveDocument?(snapshot: DocumentSnapshot): Promise<void>;
+  saveSession?(snapshot: SessionSnapshot): Promise<void>;
 }
 ```
 
-When no document snapshot exists, `seedDocument` runs once. Session restore happens after seed so persisted camera and selection state win.
+Runtime captures document state from operation commits, captures session state
+independently, applies trailing debounce, retries transient write failures, and
+passes immutable snapshots to the adapter. When no document snapshot exists,
+`seedDocument` runs once. Session restore happens after seed so persisted camera
+and selection state win.
 
 ## Plugin authoring
 
@@ -131,33 +151,25 @@ const analyticsToken = createProductServiceToken<{ track(name: string): void }>(
 
 const analyticsPlugin = defineCanvasPlugin({
   id: "example.analytics",
-  product: () => ({
-    services: [
-      {
-        token: analyticsToken,
-        create: () => ({ track: console.log }),
-      },
-    ],
-    createActions({ services }) {
-      const analytics = services.get(analyticsToken);
-      return [
-        {
-          id: "example.track",
-          run: () => analytics?.track("canvas-action"),
-        },
-      ];
-    },
-  }),
+  provides: [analyticsToken],
+  setup(context) {
+    const analytics = context.services.add({
+      token: analyticsToken,
+      create: () => ({ track: console.log }),
+    });
+    context.actions.add({
+      id: "example.track",
+      run: () => analytics.track("canvas-action"),
+    });
+  },
 });
 
 const reportingPlugin = defineCanvasPlugin({
   id: "example.reporting",
-  requires: [analyticsPlugin],
-  product: () => ({
-    setup({ services }) {
-      services.get(analyticsToken)?.track("runtime-ready");
-    },
-  }),
+  requires: [analyticsToken],
+  setup(context) {
+    context.services.get(analyticsToken)?.track("runtime-ready");
+  },
 });
 
 const options: CanvasKitRuntimeOptions = {
@@ -168,35 +180,78 @@ const options: CanvasKitRuntimeOptions = {
 };
 ```
 
-`CanvasPlugin` keeps its optional `editor`, `render`, and `product` facets. `requires` lives at the plugin top level, so one dependency order applies to every facet. Nested arrays are groups only; they do not need IDs and are flattened in declaration order. Optional features are included or omitted explicitly in these arrays; product factories always return a contribution. Runtime creation validates missing or circular dependencies, duplicate IDs, and action references before creating Editor state.
+`CanvasPlugin` has optional `editor`, `render`, and `setup` entries. `requires` lives at the plugin top level, so one dependency order applies to editor/render creation and setup installation. Depend on a plugin object when the whole extension must exist; depend on a typed API, service, or value capability token when only that cross-plugin contract matters. Providers declare those tokens in `provides` and register the matching implementation during setup. Raw `{ id }` dependency objects are rejected.
+
+Nested arrays are groups only; they do not need IDs and are flattened in declaration order. Optional features are included or omitted explicitly.
+
+Runtime creation compiles the graph, creates Editor and the Runtime resource owner, runs each setup once in dependency order, then seals all registries. Sealing validates duplicate IDs and action references, materializes registered APIs, and prevents later registration.
 
-Packaging is intentionally outside the standard plugin profile. Products that
-need it add the public plugin explicitly:
+Connector and Packaging are composed outside CanvasKit and are intentionally
+absent from the standard plugin profile. Products that need them depend on their
+plugin packages and add them explicitly:
 
 ```ts
 import {
-  Packaging,
   createStandardCanvasKitPlugins,
   type CanvasKitRuntimeOptions,
 } from "@land/canvas-kit";
+import { Connector } from "@land/plugin-connector";
+import { Packaging } from "@land/plugin-packaging";
 
 const options: CanvasKitRuntimeOptions = {
-  plugins: [createStandardCanvasKitPlugins(), Packaging],
+  plugins: [Connector, createStandardCanvasKitPlugins(), Packaging],
 };
 ```
 
-The flat product contribution has two assembly/startup hooks:
+`setup(context)` installs capabilities through focused registrars:
 
-- `setup(context)` runs during synchronous Runtime creation and may return a disposer.
-- `beforeReady({ startup, signal, ...context })` runs serially during `start()` after restore/seed and asset preparation.
+- `actions`, `toolbar`, `contextMenu`, and `apis`
+- `services`
+- `assets`
+- `ui`
+- `lifecycle.beforeReady()`, `lifecycle.beforeCommand()`, and `lifecycle.defer()`
 
-`beforeCommand` is a repeatable interceptor executed by the Runtime-bound command executor; it is not a lifecycle stage.
+`setup` returns nothing. Every owned resource registers cleanup through `lifecycle.defer()`, which gives Runtime one cleanup protocol and reverse-order resource stack. `beforeReady` runs serially during `start()` after restore/seed and asset preparation. `beforeCommand` is a repeatable interceptor executed by the Runtime-bound command executor.
 
-Services, `createActions`, APIs, hooks, providers, components, and asset integration all live directly on the product contribution. API contributions use only `token.id` for identity. Components share one props contract and render between Canvas and chrome; there are no component slots.
+The set-active-tool and tool-lock actions are provided by the replaceable
+Runtime default for `canvasToolActionsCapability`, so shape toolbar plugins do
+not depend on the standard profile installing a Tool action provider.
+Components share one props contract and render between Canvas and chrome; there
+are no component slots.
 
 ## Public controller
 
-External code should work through `runtime.controller` or the controller supplied to `onControllerReady`. The controller exposes document, selection, page, tool, camera, layer, history, export, built-in shape creation, and registered API operations without exposing the raw store.
+External code should work through `runtime.controller` or the controller supplied to `onControllerReady`. The controller exposes document, selection, page, tool, camera, layer, history, export, standard shape creation, and registered API operations without exposing the raw store.
+
+### Export API
+
+SVG and PNG export are async registered APIs so resource preparation and
+embedding complete before a result is returned:
+
+```ts
+import { canvasExportApiToken } from "@land/canvas-kit";
+
+const exportApi = runtime.controller.apis.get(canvasExportApiToken);
+if (!exportApi) throw new Error("Canvas export API is unavailable.");
+
+const pagePng = await exportApi.exportPng({
+  appearance: {
+    resolveThemeColor(token, fallback) {
+      return currentTheme.tokens[token] ?? fallback;
+    },
+  },
+  scope: "page",
+  pixelRatio: 2,
+});
+const selectedSvg = await exportApi.exportSvg({ scope: "selection" });
+const customSvg = await exportApi.exportSvg({ shapeIds: [shapeId] });
+```
+
+`exportPng()` resolves with an `image/png` Blob and `exportSvg()` resolves with
+a self-contained SVG string when export succeeds. The API deliberately exposes
+no loading state; callers own pending-state presentation around the returned
+Promise. SVG and PNG share one internal lock and reject a concurrent export.
+When `appearance.resolveThemeColor` is omitted, core color fallbacks are used.
 
 ## Styles
 

package/_vendor/canvas-core/bindings/bindingUtil.d.ts

@@ -1,11 +1,14 @@
 import type { Editor } from "../editor/editor";
 import type { SelectionOverlayFrameGeometryState } from "../editor/selection";
+import type { Vec } from "../geometry/vec";
 import type { BindingId, BindingRecord, BindingRecordBase, ShapeRecord } from "../schema/records";
 export interface BindingUtilEffect {
     shapes?: ShapeRecord[];
     bindings?: BindingRecord[];
     deleteShapeIds?: ShapeRecord["id"][];
     deleteBindingIds?: BindingId[];
+    /** Suppress these bindings while applying this effect and its derived writes. */
+    suppressBindingIds?: BindingId[];
 }
 export interface BindingShapeChangeContext {
     before: ShapeRecord;
@@ -28,6 +31,10 @@ export interface BindingShapeGeometryDependencyContext {
     shape: ShapeRecord;
     role: "from" | "to";
 }
+export interface BindingTargetShapeContentCutoutContext {
+    fromShape: ShapeRecord;
+    toShape: ShapeRecord;
+}
 export declare abstract class BindingUtil<B extends BindingRecordBase = BindingRecordBase> {
     abstract readonly type: B["type"];
     abstract getDefaultProps(): B["props"];
@@ -37,6 +44,7 @@ export declare abstract class BindingUtil<B extends BindingRecordBase = BindingR
     onBindingCreate?(editor: Editor, binding: B): BindingUtilEffect | void;
     onBindingUpdate?(editor: Editor, before: B, after: B): BindingUtilEffect | void;
     onBindingLoad?(editor: Editor, binding: B): BindingUtilEffect | void;
+    onInvalidBindingLoad?(editor: Editor, binding: B): BindingUtilEffect | void;
     onAfterShapeChange?(editor: Editor, binding: B, context: BindingShapeChangeContext): BindingUtilEffect | void;
     onBeforeDeleteShape?(editor: Editor, binding: B, context: BindingShapeDeleteContext): BindingUtilEffect | void;
     onBeforeDeleteBinding?(editor: Editor, binding: B): BindingUtilEffect | void;
@@ -48,6 +56,13 @@ export declare abstract class BindingUtil<B extends BindingRecordBase = BindingR
     getShapeHierarchyRootId?(binding: B, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
     canUseShapeHierarchy?(binding: B, context: BindingEndpointContext): boolean;
     getGeometryDependentShapeIds?(editor: Editor, binding: B, context: BindingShapeGeometryDependencyContext): ShapeRecord["id"][];
+    /**
+     * Return polygons in the target shape's local space that should be removed
+     * from its rendered content. This lets a binding-owned companion such as a
+     * text label create a transparent gap without coupling the target plugin to
+     * the companion shape implementation.
+     */
+    getTargetShapeContentCutoutLocalPolygons?(editor: Editor, binding: B, context: BindingTargetShapeContentCutoutContext): readonly (readonly Vec[])[];
     getSelectionCompanionFrameGeometries?(editor: Editor, binding: B, context: BindingSelectionCompanionFrameContext): SelectionOverlayFrameGeometryState[];
 }
 export declare function resolveShapeHierarchyRootId(shapeId: ShapeRecord["id"], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ShapeRecord["id"];

package/_vendor/canvas-core/bindings/terminalPorts.d.ts

@@ -0,0 +1,67 @@
+import type { Editor } from "../editor/editor";
+import { Vec } from "../geometry/vec";
+import type { ShapeRecord } from "../schema/records";
+export type TerminalBindingPortId = "top" | "right" | "bottom" | "left" | (string & {});
+export interface ShapeTerminalBindingPort {
+    id: TerminalBindingPortId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    outwardNormal: {
+        x: number;
+        y: number;
+    };
+}
+export interface ResolvedShapeTerminalBindingPort {
+    id: TerminalBindingPortId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    pagePoint: Vec;
+    pageOutwardNormal: Vec;
+}
+export declare const DEFAULT_TERMINAL_BINDING_PORTS: readonly [{
+    readonly id: "top";
+    readonly normalizedAnchor: {
+        readonly x: 0.5;
+        readonly y: 0;
+    };
+    readonly outwardNormal: {
+        readonly x: 0;
+        readonly y: -1;
+    };
+}, {
+    readonly id: "right";
+    readonly normalizedAnchor: {
+        readonly x: 1;
+        readonly y: 0.5;
+    };
+    readonly outwardNormal: {
+        readonly x: 1;
+        readonly y: 0;
+    };
+}, {
+    readonly id: "bottom";
+    readonly normalizedAnchor: {
+        readonly x: 0.5;
+        readonly y: 1;
+    };
+    readonly outwardNormal: {
+        readonly x: 0;
+        readonly y: 1;
+    };
+}, {
+    readonly id: "left";
+    readonly normalizedAnchor: {
+        readonly x: 0;
+        readonly y: 0.5;
+    };
+    readonly outwardNormal: {
+        readonly x: -1;
+        readonly y: 0;
+    };
+}];
+export declare function getResolvedShapeTerminalBindingPorts(editor: Editor, shape: ShapeRecord): ResolvedShapeTerminalBindingPort[];
+export declare function getResolvedShapeTerminalBindingPort(editor: Editor, shape: ShapeRecord, portId: TerminalBindingPortId): ResolvedShapeTerminalBindingPort | null;

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

@@ -0,0 +1,7 @@
+import type { BindingId } from "../schema/records";
+import type { Editor } from "./editor";
+declare const SYNCHRONOUS_CALLBACK_ERROR = "Binding reaction scope callbacks must be synchronous";
+type SynchronousCallbackGuard<T> = T extends PromiseLike<unknown> ? [error: typeof SYNCHRONOUS_CALLBACK_ERROR] : [];
+export declare function getSuppressedBindingReactionIds(editor: Editor): ReadonlySet<BindingId>;
+export declare function runWithSuppressedBindingReactions<T>(editor: Editor, bindingIds: Iterable<BindingId>, callback: () => T, ..._synchronousCallbackGuard: SynchronousCallbackGuard<T>): T;
+export {};

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

@@ -11,8 +11,8 @@ export interface CreateShapesOptions extends EditorCommandOptions {
     deferMinimumChildRepair?: boolean;
 }
 export interface UpdateShapesOptions extends EditorCommandOptions {
-    /** Internal recursion guard for binding-driven shape updates. */
-    skipBindingIds?: ReadonlySet<BindingId>;
+    /** Suppress these bindings while applying this update and its derived writes. */
+    suppressBindingIds?: ReadonlySet<BindingId>;
 }
 export interface CreateShapeInput {
     type: ShapeRecordBase["type"];
@@ -69,7 +69,7 @@ export interface StartEditingShapeInput {
         y: number;
     };
     markId?: string;
-    reuseExistingMark?: boolean;
+    reuseActiveOperation?: boolean;
     preserveInteraction?: boolean;
 }
 export interface CreateBindingInput {

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

@@ -17,6 +17,7 @@ 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 { EditorOperationManager } from "./operationManager";
 import { BindingManager } from "./managers/bindingManager";
 import { CameraManager } from "./managers/cameraManager";
 import { ClipboardManager } from "./managers/clipboardManager";
@@ -121,6 +122,7 @@ export interface EditorSelectionState {
     count: number;
     singleShapeType: ShapeRecord["type"] | null;
     commonShapeType: ShapeRecord["type"] | null;
+    canFlipSelection: boolean;
     hasPointHandleSelection: boolean;
     hasFrameSelection: boolean;
     isMixedFrameAndPointHandleSelection: boolean;
@@ -172,6 +174,8 @@ export interface EditorOverlayDebugState {
 interface ReadonlyStore {
     readonly recordsSignal: Signal<Map<string, EditorRecord>>;
     get(id: string): EditorRecord | undefined;
+    getActiveAtomicOperationRevision(): number | null;
+    getActiveAtomicOperationSnapshot(): EditorRecord[];
     getRecordSignal(id: string): Signal<EditorRecord | undefined>;
     getAll(): EditorRecord[];
     getByScope(scope: RecordScope): EditorRecord[];
@@ -205,6 +209,7 @@ export declare class Editor {
     readonly selectionOverlay: SelectionOverlayManager;
     readonly transients: InteractionTransientManager;
     readonly history: HistoryManager;
+    readonly operations: EditorOperationManager;
     readonly sideEffects: SideEffectManager;
     readonly commands: EditorCommands;
     private readonly shapeCapabilityDefinitions;
@@ -256,6 +261,7 @@ export declare class Editor {
     readonly selectionCountSignal: import("../../signals/index").Computed<number>;
     readonly selectedShapeIdSetSignal: import("../../signals/index").Computed<Set<`shape:${string}`>>;
     readonly selectedShapesSignal: import("../../signals/index").Computed<ShapeRecord[]>;
+    readonly selectionCanFlipSignal: import("../../signals/index").Computed<boolean>;
     readonly selectedShapeOverlayItemsSignal: import("../../signals/index").Computed<SelectedShapeOverlayItem[]>;
     readonly selectionStateSignal: import("../../signals/index").Computed<EditorSelectionState>;
     readonly selectionMetadataSignal: import("../../signals/index").Computed<EditorSelectionMetadata>;
@@ -272,6 +278,7 @@ export declare class Editor {
     readonly selectedShapeIdsOutsideCulledSetSignal: Signal<Set<ShapeId>>;
     readonly renderVisibleShapeIdSetSignal: Signal<Set<ShapeId>>;
     private readonly shapeSignals;
+    private readonly shapeContentCutoutLocalPolygonSignals;
     private readonly shapeSelectedSignals;
     private readonly shapeRenderOrderSignals;
     private readonly shapeRenderVisibleSignals;
@@ -287,6 +294,7 @@ export declare class Editor {
     readonly selectionOverlayFrameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
     readonly selectionOverlayCompanionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
     readonly selectionOverlayPathSignal: Signal<string | null>;
+    readonly selectionOverlayPageClipPathSignal: Signal<string | null>;
     readonly selectionOverlayBindingSegmentsSignal: Signal<SelectionBindingSegment[]>;
     readonly selectionOverlayFrameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
     readonly selectionOverlayFrameSignal: Signal<SelectionOverlayFrameState | null>;
@@ -358,15 +366,16 @@ export declare class Editor {
     moveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource): boolean;
     moveShapesToParentOrderEdge(ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource): boolean;
     moveSelectionWithinParent(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+    canAlignSelection(): 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.
+     * Align selected, unlocked siblings along an edge or center of their combined
+     * page bounds. Needs at least two eligible shapes.
      */
     alignSelection(mode: "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom", source?: ChangeSource): boolean;
+    canDistributeSelection(): boolean;
     /**
-     * Distribute selected top-level shapes so the gaps between them are equal
-     * along the given axis. Needs at least three shapes.
+     * Distribute selected, unlocked siblings so the gaps between them are equal
+     * along the given axis. Needs at least three eligible shapes.
      */
     distributeSelection(axis: "horizontal" | "vertical", source?: ChangeSource): boolean;
     moveShapesToParentPlacementResult(input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;
@@ -394,6 +403,7 @@ export declare class Editor {
     resolveAssetUrl(assetId: AssetId): string | null;
     getUnreferencedAssetIdsAfterShapeDelete(shapeIds: readonly ShapeId[]): AssetId[];
     getShapeSignal(id: ShapeId): Signal<ShapeRecord | undefined>;
+    getShapeContentCutoutLocalPolygonsSignal(id: ShapeId): Signal<readonly (readonly Vec[])[]>;
     getShapeLocalToPageTransformSignal(id: ShapeId): Signal<Mat | undefined>;
     getShapeSelectedSignal(id: ShapeId): Signal<boolean>;
     getShapeRenderOrderSignal(id: ShapeId): Signal<number>;
@@ -407,8 +417,11 @@ export declare class Editor {
     getBinding(id: BindingId): BindingRecord | undefined;
     getShapesForPage(pageId: PageId): ShapeRecord[];
     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[]>;
     getChildShapeIds(parentId: ShapeParentId): ShapeId[];
     getChildShapes(parentId: ShapeParentId): ShapeRecord[];
     getDescendantShapeIds(parentId: ShapeParentId): ShapeId[];
@@ -423,6 +436,7 @@ export declare class Editor {
     getShapeIdsForSelectionRotation(shapeIds: Iterable<ShapeId>): ShapeId[];
     getSelectionTransformTargetShapes(): ShapeRecord[];
     canResizeSelection(): boolean;
+    canFlipSelection(): boolean;
     canRotateSelection(): boolean;
     getSelectionResizeTargetShapes(): ShapeRecord[];
     getSelectionRotationTargetShapes(): ShapeRecord[];
@@ -517,6 +531,7 @@ export declare class Editor {
     }): void;
     removeShapeIdsFromSelection(ids: ShapeId[], source?: ChangeSource): void;
     removeShapeIdsFromEditingSession(ids: ShapeId[], source?: ChangeSource): void;
+    prepareShapeIdsForRemoval(ids: readonly ShapeId[], source?: ChangeSource): void;
     ensurePageSessionState(pageId: PageId, source?: ChangeSource): void;
     removePageSessionState(pageId: PageId, nextCurrentPageId: PageId, source?: ChangeSource): void;
     setCamera(partial: Partial<Camera>, options?: {

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

@@ -8,6 +8,7 @@ export declare function areEditorSelectionMetadataEqual(a: EditorSelectionMetada
 export declare function areShapeIdArraysEqual(a: ShapeId[], b: ShapeId[]): boolean;
 export declare function areVecsEqual(a: Vec | null, b: Vec | null): boolean;
 export declare function areVecArraysEqual(a: readonly Vec[], b: readonly Vec[]): boolean;
+export declare function areVecPolygonArraysEqual(a: readonly (readonly Vec[])[], b: readonly (readonly Vec[])[]): boolean;
 export declare function areBoxesEqual(a: Box | null, b: Box | null): boolean;
 export declare function isValidBox(box: Box): boolean;
 export declare function areRenderHostDebugStatesEqual(a: EditorRenderHostDebugState, b: EditorRenderHostDebugState): boolean;

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

@@ -1,6 +1,6 @@
 import { type Signal } from "../../signals/index";
 import { type StoreHistoryEntry, type StoreHistoryState } from "../../store/index";
-import { type DocumentRecord } from "../schema/records";
+import type { DocumentRecord } from "../schema/records";
 import type { Editor } from "./editor";
 export interface HistoryScopeState {
     canUndo: boolean;
@@ -24,16 +24,13 @@ export declare class HistoryManager {
     readonly state: Signal<HistoryState>;
     constructor(editor: Editor);
     clear(): void;
-    mark(id: string): void;
-    bailToMark(id: string): void;
-    squashToMark(id: string, label?: string): void;
     activateScope(scope: HistoryScope): () => void;
     deactivateScope(scope: HistoryScope): boolean;
     getActiveScope(): HistoryScope | null;
     undo(): boolean;
     redo(): boolean;
     getEntries(): readonly StoreHistoryEntry<DocumentRecord>[];
-    private handleStoreChange;
+    private handleCommit;
     private deactivateActivation;
     private publishEffectiveState;
 }

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

@@ -2,7 +2,7 @@ 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 } from "./events";
+import type { CancelEditorEvent, EditorEvent, PointerEditorEvent } from "./events";
 import type { SelectionHandle } from "./selection";
 import type { HandleSnapContext, HandleSnapMode } from "./managers/snapTypes";
 export interface SelectionHandleInteractionInput {
@@ -10,36 +10,58 @@ export interface SelectionHandleInteractionInput {
     shape: ShapeRecord;
     originPagePoint: Vec;
 }
-export interface SelectionHandleInteractionSession {
+export interface PointerDragInteractionSession {
     readonly shapeId: ShapeId;
     readonly historyMark: string;
-    readonly handleSnapMode?: HandleSnapMode;
-    readonly handleSnapContext?: HandleSnapContext;
-    readonly allowSelfSnap?: boolean;
-    readonly excludedSnapShapeIds?: readonly ShapeId[];
     readonly shouldClearBindingPreviewOnExit?: boolean;
+    onDragStart?(input: {
+        editor: Editor;
+    }): void;
     onClick?(input: {
         editor: Editor;
         source: ChangeSource;
     }): void;
+    onDoubleClick?(input: {
+        editor: Editor;
+        source: ChangeSource;
+    }): void;
     onCancel?(input: {
         editor: Editor;
         reason: CancelEditorEvent["reason"];
     }): void;
+    onComplete?(input: {
+        editor: Editor;
+    }): void;
     update(input: {
         editor: Editor;
         pagePoint: Vec;
         accelKey: boolean;
         source: ChangeSource;
-    }): "continue" | "stop" | SelectionHandleInteractionUpdateResult;
+    }): "continue" | "stop" | PointerDragInteractionUpdateResult;
 }
-export interface SelectionHandleInteractionUpdateResult {
+export interface PointerDragInteractionUpdateResult {
     status: "continue" | "stop";
     finalPagePoint?: Vec | null;
 }
+export interface SelectionHandleInteractionSession extends PointerDragInteractionSession {
+    readonly handleSnapMode?: HandleSnapMode;
+    readonly handleSnapContext?: HandleSnapContext;
+    readonly allowSelfSnap?: boolean;
+    readonly excludedSnapShapeIds?: readonly ShapeId[];
+}
+export type SelectionHandleInteractionUpdateResult = PointerDragInteractionUpdateResult;
 export interface SelectionHandleInteractionHandler {
     createSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
 }
+export interface ShapePointerInteractionInput {
+    shape: ShapeRecord;
+    selectionTargetId: ShapeId;
+    originPagePoint: Vec;
+    event: PointerEditorEvent;
+}
+export interface ShapePointerInteractionHandler {
+    createSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
+}
 export type EditorEventInteractionDecision = "continue" | "handled";
 export interface EditorEventInteractionHandler {
     handleEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
@@ -48,6 +70,7 @@ export interface LandInteractionHandler {
     id: string;
     editorEvent?: EditorEventInteractionHandler;
     selectionHandle?: SelectionHandleInteractionHandler;
+    shapePointer?: ShapePointerInteractionHandler;
 }
 export declare class InteractionHandlerRegistry {
     private readonly handlers;
@@ -55,6 +78,7 @@ export declare class InteractionHandlerRegistry {
     register(handler: LandInteractionHandler): void;
     getHandlers(): readonly LandInteractionHandler[];
     handleEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
-    broadcastEvent(editor: Editor, event: EditorEvent): void;
+    broadcastEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
     createSelectionHandleSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+    createShapePointerSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
 }

package/_vendor/canvas-core/editor/managers/bindingManager.d.ts

@@ -8,17 +8,12 @@ export interface ShapeChangeEntry {
 export declare class BindingManager {
     private readonly editor;
     constructor(editor: Editor);
-    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
-    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
-    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
     getConflictingBindings(binding: BindingRecord): BindingRecord[];
     canBind(binding: BindingRecord): boolean;
     syncCreatedBinding(binding: BindingRecord, source: ChangeSource): void;
     syncUpdatedBinding(before: BindingRecord, after: BindingRecord, source: ChangeSource): void;
     repairLoadedBindings(source: ChangeSource): void;
-    handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource, options?: {
-        skipBindingIds?: ReadonlySet<BindingId>;
-    }): void;
+    handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource): void;
     getShapeHierarchyRootId(shapeId: ShapeId): ShapeId;
     cleanupBindingsForDeletedShapes(ids: ShapeId[], source: ChangeSource): void;
     cleanupBindings(ids: BindingId[], source: ChangeSource): void;

package/_vendor/canvas-core/editor/managers/queryManager.d.ts

@@ -30,6 +30,10 @@ export declare class QueryManager {
     readonly selectionAnchorPagePointSignal: Signal<Vec | null>;
     private readonly stateAtom;
     private readonly shapeQuerySignals;
+    private readonly bindingsFromShapeSignals;
+    private readonly bindingsToShapeSignals;
+    private readonly bindingsForShapeSignals;
+    private draftBindingIndex;
     constructor(editor: Editor);
     getShapeIdsForPage(pageId: PageId): ShapeId[];
     getShapesForPage(pageId: PageId): ShapeRecord[];
@@ -54,6 +58,7 @@ export declare class QueryManager {
     private getShapeIdsForPageSnapshot;
     private getChildShapeIdsSnapshot;
     private handleStoreChange;
+    private updateCachedBindingSignals;
     private getShapeLocalToPageTransformSnapshot;
     private getShapeParentToPageTransformSnapshot;
     private getShapeQuerySignals;
@@ -84,6 +89,14 @@ export declare class QueryManager {
     getBindingIdsToShape(shapeId: ShapeId): BindingId[];
     getBindingIdsForShape(shapeId: ShapeId): BindingId[];
     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 getBindingsFromState;
+    private getBindingsToState;
+    private getBindingsForState;
+    private getBindingsForIds;
+    private getDraftBindingIndex;
 }

package/_vendor/canvas-core/editor/managers/selectionLayoutManager.d.ts

@@ -18,13 +18,16 @@ export interface ZoomToBoundsOptions {
 export declare class SelectionLayoutManager {
     private readonly editor;
     constructor(editor: Editor);
+    canAlign(): boolean;
     align(mode: AlignMode, source?: ChangeSource): boolean;
+    canDistribute(): boolean;
     distribute(axis: DistributeAxis, source?: ChangeSource): boolean;
     getCurrentPageBounds(pageId?: PageId): Box | null;
     zoomToBounds(bounds: Box, options?: ZoomToBoundsOptions): boolean;
     zoomToFit(options?: ZoomToBoundsOptions): boolean;
     zoomToSelection(options?: ZoomToBoundsOptions): boolean;
     private boundsOfShapeIds;
+    private canLayoutSelection;
     private getAlignableEntries;
     private getPageToParentTransform;
     private pageDeltaToParentDelta;