@yuzhouu/canvas-kit 0.1.8 → 0.1.10

package/README.md

@@ -1,151 +1,207 @@
 # @land/canvas-kit
 
-`@land/canvas-kit` is the public React SDK for the Land canvas kit. It includes the product runtime, built-in canvas extensions, image integration, persistence, chrome context, and typed controller surface behind one package root.
+CanvasKit is the public composition root for the Land canvas. It compiles one graph of `CanvasPlugin` objects and nested plugin groups to assemble an isolated Runtime, then exposes a controller-oriented API without exposing Editor, services, registries, or private render data.
 
-## Install
+## React usage
 
-```bash
-pnpm add @land/canvas-kit react react-dom
-```
-
-## Basic Usage
+Keep the options object stable. The hook uses reference identity to decide when to replace a Runtime.
 
 ```tsx
-import { useMemo } from "react";
 import {
   CanvasKitRoot,
-  defineCanvasKit,
+  useCanvasKitRuntime,
+  type CanvasKitRuntimeOptions,
 } from "@land/canvas-kit";
-import "@land/canvas-kit/style.css";
+
+const RUNTIME_OPTIONS: CanvasKitRuntimeOptions = {
+  id: "my-canvas",
+  storageNamespace: "my-app.canvas",
+};
 
 export function App() {
-  const product = useMemo(
-    () =>
-      defineCanvasKit({
-        onControllerReady(controller) {
-          console.log(controller.snapshot());
-        },
-      }),
-    [],
-  );
+  const state = useCanvasKitRuntime(RUNTIME_OPTIONS);
+
+  if (state.status === "error") throw state.error;
+  if (state.status !== "ready") return null;
 
   return (
-    <div style={{ width: "100%", height: "100vh" }}>
-      <CanvasKitRoot product={product} />
-    </div>
+    <CanvasKitRoot
+      runtime={state.runtime}
+      onControllerReady={(controller) => {
+        controller.setTool("select");
+      }}
+    />
   );
 }
 ```
 
-The host element must provide a size. `CanvasKitRoot` fills the space provided by its parent and mounts the canvas runtime for the product.
+Use a module-level constant or `useMemo` for `CanvasKitRuntimeOptions`. An inline object creates and disposes a Runtime after every render.
 
-## Custom Chrome
+## Imperative usage
 
-Use the `chrome` option when you want to provide your own toolbar, panels, or menus while keeping the kit runtime and built-in extensions.
+The creator owns the complete lifecycle:
 
 ```tsx
-import { useMemo } from "react";
+import { createRoot } from "react-dom/client";
 import {
   CanvasKitRoot,
-  defineCanvasKit,
-  type CanvasKitController,
-  type CanvasKitChromeContext,
+  createCanvasKitRuntime,
 } from "@land/canvas-kit";
-import "@land/canvas-kit/style.css";
 
-function MyChrome({
-  context,
-}: {
-  context: CanvasKitChromeContext<CanvasKitController>;
-}) {
-  return (
-    <>
-      <button
-        type="button"
-        disabled={!context.history.canUndo}
-        onClick={context.history.undo}
-      >
-        Undo
-      </button>
-      <button type="button" onClick={context.zoom.zoomIn}>
-        Zoom in
-      </button>
-      <button
-        type="button"
-        disabled={context.selection.count === 0}
-        onClick={() => context.controller.deleteShapes([...context.selectedShapeIds])}
-      >
-        Delete
-      </button>
-    </>
-  );
-}
+const runtime = createCanvasKitRuntime({ persistence: null });
+const startup = await runtime.start();
 
-export function App() {
-  const product = useMemo(
-    () =>
-      defineCanvasKit({
-        chrome: (context) => <MyChrome context={context} />,
-      }),
-    [],
-  );
+const root = createRoot(document.getElementById("app")!);
+root.render(<CanvasKitRoot runtime={runtime} />);
 
-  return (
-    <div style={{ width: "100%", height: "100vh" }}>
-      <CanvasKitRoot product={product} />
-    </div>
-  );
+// Later:
+root.unmount();
+runtime.dispose();
+```
+
+One Runtime can be mounted by only one `CanvasKitRoot` at a time. `CanvasKitRoot` requires a ready Runtime and never calls `start()` or `dispose()`.
+
+## Runtime options
+
+```ts
+interface CanvasKitRuntimeOptions {
+  id?: string;
+  chrome?: CanvasKitChromeRenderer;
+  documentMeta?: Record<string, unknown>;
+  persistence?: ProductPersistenceAdapter | null;
+  seedDocument?: CanvasKitDocumentSeed;
+  shouldSkipStoredSnapshots?: () => boolean;
+  plugins?: readonly CanvasPluginInput[];
+  storageNamespace?: string;
 }
 ```
 
-Chrome should operate through `CanvasKitChromeContext` and `context.controller`. The product shell owns canvas mounting, so custom chrome should render controls and overlays rather than the canvas itself. It should not import `@land/canvas-core`, `@land/canvas-react`, built-in plugin packages, or kit internals.
+Controller callbacks, window exposure, and `windowKey` are mount concerns and belong on `CanvasKitRoot`.
 
-The package no longer exposes a one-component direct render entry. Apps should define a product with `defineCanvasKit` and render it through `CanvasKitRoot`.
+## Startup result
 
-## Local Persistence
+`runtime.start()` is single-flight and idempotent. It returns:
 
-Default browser persistence restores supported records even when a saved
-snapshot also contains unsupported shape or binding types. Unsupported raw
-records are preserved outside the live editor and merged back into future saves.
-When this happens, `CanvasKitRoot` shows a persistence notice and custom
-chrome can inspect `context.persistence.status` or call
-`context.persistence.discardUnsupportedRecords?.()` after explicit user
-confirmation.
+```ts
+interface CanvasKitStartupResult {
+  documentSource: "restored" | "seeded" | "empty";
+  sessionRestored: boolean;
+  warnings: readonly unknown[];
+}
+```
 
-## Internal Assembly
+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.
 
-The public product remains opaque. Internally, `defineCanvasKit()` resolves options into explicit product fields:
+Disposal aborts startup, stops persistence, runs setup disposers in reverse order, then disposes Editor and services. A disposed Runtime cannot restart.
 
-- `LandExtension[]` installs editor/canvas render plugins through `@land/canvas-react/host`.
-- `CanvasKitHostExtension[]` installs product-host behavior such as clipboard, toolbar, context menu, image import, asset URL resolution, SVG asset inlining, and controller components.
-- Service factories and asset resolver tokens wire product-level services into runtime.
-- `CanvasKitRuntime` creates services, the plugin host runtime, the editor, controller registry, and then runs product runtime setup.
+## Persistence adapter
 
-Advanced products can pass additional `hostExtensions` to `defineCanvasKit()`
-for product-host behavior that should compose with the built-in runtime instead
-of being hard-coded in chrome or canvas runtime modules.
+Persistence is IO-only; Runtime owns restore and seed ordering.
 
-This keeps app chrome on the root package controller while keeping browser-specific host behavior out of concrete shape plugins and out of `canvas-core`.
+```ts
+interface ProductPersistenceAdapter {
+  load?(options: {
+    signal: AbortSignal;
+  }): Promise<{
+    documentSnapshot: unknown | null;
+    sessionSnapshot: unknown | null;
+  }>;
+  start?(editor: Editor): () => void;
+  flushSnapshot?(editor: Editor): Promise<void>;
+}
+```
 
-## Public Exports
+When no document snapshot exists, `seedDocument` runs once. Session restore happens after seed so persisted camera and selection state win.
 
-The published package intentionally exposes only:
+## Plugin authoring
 
-- `@land/canvas-kit`
-- `@land/canvas-kit/style.css`
+Use `defineCanvasPlugin()` and pass plugins or nested plugin groups through Runtime options:
+
+```ts
+import {
+  createProductServiceToken,
+  createStandardCanvasKitPlugins,
+  defineCanvasPlugin,
+  type CanvasKitRuntimeOptions,
+} from "@land/canvas-kit";
 
-Package subpaths are internal implementation details.
+const analyticsToken = createProductServiceToken<{ track(name: string): void }>(
+  "example.analytics",
+);
+
+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"),
+        },
+      ];
+    },
+  }),
+});
+
+const reportingPlugin = defineCanvasPlugin({
+  id: "example.reporting",
+  requires: [analyticsPlugin],
+  product: () => ({
+    setup({ services }) {
+      services.get(analyticsToken)?.track("runtime-ready");
+    },
+  }),
+});
+
+const options: CanvasKitRuntimeOptions = {
+  plugins: [
+    createStandardCanvasKitPlugins(),
+    [analyticsPlugin, reportingPlugin],
+  ],
+};
+```
 
-## Local Build
+`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.
 
-Run from the workspace root:
+Packaging is intentionally outside the standard plugin profile. Products that
+need it add the public plugin explicitly:
 
-```bash
-pnpm build:canvas-kit:bundle
+```ts
+import {
+  Packaging,
+  createStandardCanvasKitPlugins,
+  type CanvasKitRuntimeOptions,
+} from "@land/canvas-kit";
+
+const options: CanvasKitRuntimeOptions = {
+  plugins: [createStandardCanvasKitPlugins(), Packaging],
+};
 ```
 
-The publish-ready output is written to:
+The flat product contribution has two assembly/startup hooks:
+
+- `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.
+
+`beforeCommand` is a repeatable interceptor executed by the Runtime-bound command executor; it is not a lifecycle stage.
+
+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.
+
+## Public controller
 
-```text
-packages/canvas-kit/dist-component/
+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.
+
+## Styles
+
+The package root imports its base styles. Published consumers may also use the explicit stylesheet export when their bundler requires it:
+
+```ts
+import "@land/canvas-kit/style.css";
 ```

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

@@ -11,6 +11,7 @@ export interface BindingShapeChangeContext {
     before: ShapeRecord;
     after: ShapeRecord;
     role: "from" | "to";
+    reason: "self" | "ancestry";
 }
 export interface BindingShapeDeleteContext {
     shape: ShapeRecord;
@@ -40,6 +41,13 @@ export declare abstract class BindingUtil<B extends BindingRecordBase = BindingR
     onBeforeDeleteShape?(editor: Editor, binding: B, context: BindingShapeDeleteContext): BindingUtilEffect | void;
     onBeforeDeleteBinding?(editor: Editor, binding: B): BindingUtilEffect | void;
     getExportShapeIds?(editor: Editor, binding: B): ShapeRecord["id"][];
+    /**
+     * Map a hierarchy companion (for example, a bound label) to the shape that
+     * owns its group lifecycle and selection semantics.
+     */
+    getShapeHierarchyRootId?(binding: B, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
+    canUseShapeHierarchy?(binding: B, context: BindingEndpointContext): boolean;
     getGeometryDependentShapeIds?(editor: Editor, binding: B, context: BindingShapeGeometryDependencyContext): ShapeRecord["id"][];
     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/editor/cameraPanSession.d.ts

@@ -0,0 +1,9 @@
+import type { Vec } from "../geometry/vec";
+import type { Camera } from "../schema/records";
+import type { Editor } from "./editor";
+export interface CameraPanSession {
+    originScreenPoint: Vec;
+    originCamera: Camera;
+}
+export declare function createCameraPanSession(editor: Editor, originScreenPoint: Vec): CameraPanSession;
+export declare function updateCameraPanSession(editor: Editor, session: CameraPanSession, screenPoint: Vec): void;

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

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

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

@@ -4,6 +4,16 @@ import type { AssetId, AssetRecord, AssetRecordBase, BindingId, BindingRecordBas
 export interface EditorCommandOptions {
     source?: ChangeSource;
 }
+export interface CreateShapesOptions extends EditorCommandOptions {
+    /** Defer spatial containment until an interactive creation gesture completes. */
+    autoReparent?: boolean;
+    /** Internal: allow a container to receive children later in the same atomic command. */
+    deferMinimumChildRepair?: boolean;
+}
+export interface UpdateShapesOptions extends EditorCommandOptions {
+    /** Internal recursion guard for binding-driven shape updates. */
+    skipBindingIds?: ReadonlySet<BindingId>;
+}
 export interface CreateShapeInput {
     type: ShapeRecordBase["type"];
     x: number;
@@ -14,6 +24,7 @@ export interface CreateShapeInput {
     opacity?: number;
     isHidden?: boolean;
     rotation?: number;
+    skewX?: number;
     scaleX?: number;
     scaleY?: number;
     isLocked?: boolean;
@@ -35,6 +46,7 @@ export interface ShapeUpdate {
     x?: number;
     y?: number;
     rotation?: number;
+    skewX?: number;
     scaleX?: number;
     scaleY?: number;
     opacity?: number;
@@ -106,19 +118,19 @@ export interface EditorCommands {
     updateDocumentMeta(input: UpdateDocumentMetaInput, options?: EditorCommandOptions): DocumentMetadataRecord;
     updatePageMeta(input: UpdatePageMetaInput, options?: EditorCommandOptions): PageRecord | null;
     movePage(input: MovePageInput, options?: EditorCommandOptions): void;
-    createShapes(inputs: CreateShapeInput[], options?: EditorCommandOptions): ShapeRecord[];
+    createShapes(inputs: CreateShapeInput[], options?: CreateShapesOptions): ShapeRecord[];
     /**
      * Persist already-built shape records (with their existing ids) through the
      * command pipeline. Used by paste/duplicate where ids must be assigned before
      * parent/binding remapping. Prefer `createShapes` for fresh shapes.
      */
     createShapesFromRecords(records: ShapeRecord[], options?: EditorCommandOptions): ShapeRecord[];
-    updateShapes(updates: ShapeUpdate[], options?: EditorCommandOptions): void;
+    updateShapes(updates: ShapeUpdate[], options?: UpdateShapesOptions): void;
     /**
      * Move shapes to a new parent, appending shapes that are entering that parent
      * to the end of its child order in the order provided by `ids`.
      */
-    reparentShapes(input: ReparentShapesInput, options?: EditorCommandOptions): void;
+    reparentShapes(input: ReparentShapesInput, options?: EditorCommandOptions): boolean;
     deleteShapes(ids: ShapeId[], options?: EditorCommandOptions): void;
     createAsset(input: CreateAssetInput, options?: EditorCommandOptions): AssetRecord;
     /**

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

@@ -0,0 +1,6 @@
+import { type EditorPlugin } from "../plugins";
+import { Editor, type EditorOptions } from "./editor";
+export interface CreateEditorWithPluginsOptions extends Omit<EditorOptions, "shapeUtils" | "shapeSvgExporters" | "bindingUtils" | "shapeCapabilities"> {
+    plugins?: readonly EditorPlugin[];
+}
+export declare function createEditorWithPlugins(options?: CreateEditorWithPluginsOptions): Editor;

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

@@ -5,6 +5,7 @@ import { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
 import { Box } from "../geometry/box";
 import { Mat } from "../geometry/mat";
 import { Vec } from "../geometry/vec";
+import { EditorRuntimeRegistry } from "../plugins/editorRuntimeRegistry";
 import { type BindingId, type BindingRecord, type AssetId, type AssetRecord, type Camera, type DocumentMetadataRecord, 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";
@@ -21,8 +22,8 @@ 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 { InteractionTransientManager } from "./managers/interactionTransientManager";
+import { QueryManager, type ShapeHierarchySnapshotEntry, 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";
@@ -87,7 +88,7 @@ export interface ShapeSelectionSiblingOrderState {
     canMoveBackward: boolean;
     canMoveForward: boolean;
 }
-export type ReparentShapePlacementFailureReason = "notFound" | "locked" | "hidden" | "invalidParent" | "cycle" | "invalidBeforeId";
+export type ReparentShapePlacementFailureReason = "notFound" | "locked" | "hidden" | "invalidParent" | "cycle" | "invalidBeforeId" | "unsupportedTransform";
 export type ReparentShapePlacementResult = {
     ok: true;
     movedIds: ShapeId[];
@@ -103,7 +104,8 @@ export interface ReparentShapePlacementInput {
 export interface ShapeGroupState {
     parentId: ShapeParentId;
     shapeIds: ShapeId[];
-    bounds: Box;
+    /** Axis-aligned bounds of the grouped roots in their common parent's local space. */
+    parentLocalBounds: Box;
 }
 export type LayerOrderDirection = "backward" | "forward";
 export type LayerOrderEdge = "back" | "front";
@@ -131,6 +133,7 @@ export interface EditorSelectionState {
     frameRotationCenter: Vec | null;
     selectionAnchorPagePoint: Vec | null;
 }
+export type EditorSelectionMetadata = Omit<EditorSelectionState, "frameBounds" | "frameRotation" | "frameRotationCenter" | "selectionAnchorPagePoint">;
 export interface EditorRenderHostDebugState {
     culledCount: number;
     visibleCount: number;
@@ -193,6 +196,7 @@ export declare class Editor {
     readonly bindingUtils: BindingUtilRegistry;
     readonly interactions: InteractionHandlerRegistry;
     readonly selectionHandleInteractions: SelectionHandleInteractionRegistry;
+    readonly runtime: EditorRuntimeRegistry;
     readonly queries: QueryManager;
     readonly bindings: BindingManager;
     readonly spatialIndex: SpatialIndexManager;
@@ -206,12 +210,6 @@ export declare class Editor {
     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<BindingPreviewState | null>;
     readonly bindingPreviewActiveSignal: Signal<boolean>;
     readonly terminalBindingGuidesSignal: Signal<TerminalBindingGuideState[]>;
@@ -234,9 +232,12 @@ export declare class Editor {
     private assetUrlResolver;
     private get _internalStore();
     readonly sessionSignal: import("../../signals/index").Computed<SessionRecord>;
+    /** Read the latest session draft, including writes made inside store.atomic. */
+    getSessionRecord(): SessionRecord;
     readonly currentPageIdSignal: import("../../signals/index").Computed<`page:${string}`>;
     readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
     readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
+    readonly currentPageShapeHierarchySignal: Signal<ShapeHierarchySnapshotEntry[]>;
     readonly culledShapeIdsSignal: Signal<ShapeId[]>;
     readonly renderVisibleShapeIdsSignal: Signal<ShapeId[]>;
     readonly retainedShapeIdsSignal: Signal<ShapeId[]>;
@@ -257,6 +258,7 @@ export declare class Editor {
     readonly selectedShapesSignal: import("../../signals/index").Computed<ShapeRecord[]>;
     readonly selectedShapeOverlayItemsSignal: import("../../signals/index").Computed<SelectedShapeOverlayItem[]>;
     readonly selectionStateSignal: import("../../signals/index").Computed<EditorSelectionState>;
+    readonly selectionMetadataSignal: import("../../signals/index").Computed<EditorSelectionMetadata>;
     readonly pageTransformSignal: import("../../signals/index").Computed<Mat>;
     readonly cameraZoomSignal: import("../../signals/index").Computed<number>;
     readonly viewportPageBoundsSignal: import("../../signals/index").Computed<Box | null>;
@@ -274,10 +276,10 @@ export declare class Editor {
     private readonly shapeRenderOrderSignals;
     private readonly shapeRenderVisibleSignals;
     private readonly shapeDocumentVisibleSignals;
+    private readonly shapeEffectiveOpacitySignals;
     private readonly shapeEditingSessionSignals;
     private readonly shapeDropTargetSignals;
     private readonly shapeHoveredSignals;
-    private readonly shapeErasingSignals;
     private readonly shapeSelectedDescendantTransformAncestorSignals;
     private lastPointerDownForClickCount;
     private lastPointerUpForClickCount;
@@ -367,7 +369,6 @@ export declare class Editor {
      * 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;
@@ -393,14 +394,15 @@ export declare class Editor {
     resolveAssetUrl(assetId: AssetId): string | null;
     getUnreferencedAssetIdsAfterShapeDelete(shapeIds: readonly ShapeId[]): AssetId[];
     getShapeSignal(id: ShapeId): Signal<ShapeRecord | undefined>;
+    getShapeLocalToPageTransformSignal(id: ShapeId): Signal<Mat | undefined>;
     getShapeSelectedSignal(id: ShapeId): Signal<boolean>;
     getShapeRenderOrderSignal(id: ShapeId): Signal<number>;
     getShapeRenderVisibleSignal(id: ShapeId): Signal<boolean>;
     getShapeDocumentVisibleSignal(id: ShapeId): Signal<boolean>;
+    getShapeEffectiveOpacitySignal(id: ShapeId): Signal<number>;
     getShapeEditingSessionForShapeSignal(id: ShapeId): Signal<ShapeEditingSession | null>;
     getShapeDropTargetSignal(id: ShapeId): Signal<boolean>;
     getShapeHoveredSignal(id: ShapeId): Signal<boolean>;
-    getShapeErasingSignal(id: ShapeId): Signal<boolean>;
     getShapeSelectedDescendantTransformAncestorSignal(id: ShapeId): Signal<boolean>;
     getBinding(id: BindingId): BindingRecord | undefined;
     getShapesForPage(pageId: PageId): ShapeRecord[];
@@ -420,6 +422,9 @@ export declare class Editor {
     getShapeIdsForSelectionTransform(shapeIds: Iterable<ShapeId>): ShapeId[];
     getShapeIdsForSelectionRotation(shapeIds: Iterable<ShapeId>): ShapeId[];
     getSelectionTransformTargetShapes(): ShapeRecord[];
+    canResizeSelection(): boolean;
+    canRotateSelection(): boolean;
+    getSelectionResizeTargetShapes(): ShapeRecord[];
     getSelectionRotationTargetShapes(): ShapeRecord[];
     getShapeExportTraversalIds(shapeIds: Iterable<ShapeId>): ShapeId[];
     getShapeContainment(containerId: ShapeId, shapeId: ShapeId): ShapeContainment | null;
@@ -434,7 +439,7 @@ export declare class Editor {
     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;
+    computeShapePositionedBounds(shape: ShapeRecord): Box;
     computeShapeLocalBounds(shape: ShapeRecord): Box;
     computeShapeRenderBounds(shape: ShapeRecord): Box;
     computeShapeExportBounds(shape: ShapeRecord): Box;
@@ -448,7 +453,7 @@ export declare class Editor {
     computeShapePageCenter(shape: ShapeRecord): Vec;
     computeShapePageCorners(shape: ShapeRecord): Vec[];
     computeShapePageOutlineVertices(shape: ShapeRecord): Vec[];
-    getShapeBounds(shapeId: ShapeId): Box | null;
+    getShapePositionedBounds(shapeId: ShapeId): Box | null;
     getShapePageBounds(shapeId: ShapeId): Box | null;
     getShapeGeometry(shapeId: ShapeId): ShapeGeometry | null;
     getShapePositionedToPageTransform(shapeId: ShapeId): Mat | null;
@@ -463,16 +468,6 @@ export declare class Editor {
     getSelectionAnchorPagePoint(): 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: BindingPreviewState | null): void;
     setTerminalBindingGuides(guides: readonly TerminalBindingGuideState[] | null): void;
     setDropTargetShapeId(shapeId: ShapeId | null): void;
@@ -507,7 +502,9 @@ export declare class Editor {
     }): void;
     syncAfterDocumentRestore(): void;
     cancelInteractionForCommand(): void;
-    cancelInteractionAndClearTransients(reason: CancelEditorEvent["reason"]): void;
+    cancelInteractionAndClearTransients(reason: CancelEditorEvent["reason"], options?: {
+        notifyInteractionHandlers?: boolean;
+    }): void;
     syncToolStateFromSession(source: ChangeSource): void;
     createShapeRecord(input: CreateShapeInput): ShapeRecord;
     createBindingRecord(input: CreateBindingInput): BindingRecord;
@@ -564,6 +561,7 @@ export declare class Editor {
     syncPageCounter(): void;
     syncBindingCounter(): void;
     syncAssetCounter(): void;
+    dispose(): void;
     private createPageId;
     private createPageIndex;
     private handleWheelEvent;

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

@@ -1,8 +1,10 @@
 import type { Box } from "../geometry/box";
 import type { Vec } from "../geometry/vec";
-import type { AssetId, PageId, ShapeId, ShapeRecord } from "../schema/records";
+import type { AssetId, PageId, PageRecord, ShapeId, ShapeRecord } from "../schema/records";
 import type { BindingPreviewState } from "./selection";
-import type { EditorOverlayDebugState, EditorRenderHostDebugState, RenderItem } from "./editor";
+import type { EditorOverlayDebugState, EditorRenderHostDebugState, EditorSelectionMetadata, RenderItem } from "./editor";
+export declare function arePageRecordArraysEqual(a: readonly PageRecord[], b: readonly PageRecord[]): boolean;
+export declare function areEditorSelectionMetadataEqual(a: EditorSelectionMetadata, b: EditorSelectionMetadata): boolean;
 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;

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

@@ -1,18 +1,39 @@
+import { type Signal } from "../../signals/index";
 import { type StoreHistoryEntry, type StoreHistoryState } from "../../store/index";
 import { type DocumentRecord } from "../schema/records";
 import type { Editor } from "./editor";
+export interface HistoryScopeState {
+    canUndo: boolean;
+    canRedo: boolean;
+    undoDepth?: number;
+    redoDepth?: number;
+}
+export interface HistoryScope {
+    readonly id: string;
+    getState(): HistoryScopeState;
+    subscribe(listener: () => void): () => void;
+    undo(): boolean;
+    redo(): boolean;
+}
 export type HistoryState = StoreHistoryState;
 export declare class HistoryManager {
     private readonly editor;
     private readonly buffer;
-    readonly state: import("../../signals/index").Signal<StoreHistoryState>;
+    private readonly scopeActivations;
+    private readonly _state;
+    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 deactivateActivation;
+    private publishEffectiveState;
 }