@yuzhouu/canvas-kit 0.1.12 → 0.1.13

package/README.md

@@ -211,7 +211,7 @@ const options: CanvasKitRuntimeOptions = {
 - `ui`
 - `lifecycle.beforeReady()`, `lifecycle.beforeCommand()`, and `lifecycle.defer()`
 
-`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.
+`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 after Runtime is ready. Public Controller and action writes are rejected outside the ready state; seed uses a private bootstrap executor, so restore, seed, and `beforeReady` initialization do not trigger it. Parameterized built-in actions validate their value before the hook runs. Controller writes and built-in actions reuse the same internal command definitions, whose IDs come from the public read-only `CANVAS_KIT_COMMAND_TOKENS` catalog.
 
 The set-active-tool and tool-lock actions are provided by the replaceable
 Runtime default for `canvasToolActionsCapability`, so shape toolbar plugins do
@@ -223,6 +223,32 @@ are no component slots.
 
 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.
 
+Controller reads are available immediately for assembly and inspection, but
+Controller writes require `await runtime.start()`. Plugins can match
+`beforeCommand` events against stable command identities without importing
+internals:
+
+```ts
+import {
+  CANVAS_KIT_COMMAND_TOKENS,
+  canvasKitLifecycleExtension,
+  defineCanvasPlugin,
+} from "@land/canvas-kit";
+
+const analyticsPlugin = defineCanvasPlugin({
+  id: "example.command-analytics",
+  setup(context) {
+    context
+      .get(canvasKitLifecycleExtension)
+      .beforeCommand(({ commandId }) => {
+        if (commandId === CANVAS_KIT_COMMAND_TOKENS.layer.bringToFront.id) {
+          // Record the product command.
+        }
+      });
+  },
+});
+```
+
 ### Export API
 
 SVG and PNG export are async registered APIs so resource preparation and

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

@@ -66,3 +66,4 @@ export declare abstract class BindingUtil<B extends BindingRecordBase = BindingR
     getSelectionCompanionFrameGeometries?(editor: Editor, binding: B, context: BindingSelectionCompanionFrameContext): SelectionOverlayFrameGeometryState[];
 }
 export declare function resolveShapeHierarchyRootId(shapeId: ShapeRecord["id"], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ShapeRecord["id"];
+export declare function resolveShapeHierarchyRootIds(shapeIds: readonly ShapeRecord["id"][], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ReadonlyMap<ShapeRecord["id"], ShapeRecord["id"]>;

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

@@ -4,7 +4,7 @@ import type { AssetId, AssetRecord, BindingRecord, ShapeId, ShapeRecord } from "
 import type { Editor } from "./editor";
 export interface EditorClipboardPayload {
     type: "land/clipboard";
-    version: 1;
+    version: 2;
     source: {
         app: "land";
         documentId?: string;

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

@@ -24,7 +24,6 @@ export interface CreateShapeInput {
     opacity?: number;
     isHidden?: boolean;
     rotation?: number;
-    skewX?: number;
     scaleX?: number;
     scaleY?: number;
     isLocked?: boolean;
@@ -46,7 +45,6 @@ export interface ShapeUpdate {
     x?: number;
     y?: number;
     rotation?: number;
-    skewX?: number;
     scaleX?: number;
     scaleY?: number;
     opacity?: number;

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

@@ -15,9 +15,13 @@ export declare class BindingManager {
     repairLoadedBindings(source: ChangeSource): void;
     handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource): void;
     getShapeHierarchyRootId(shapeId: ShapeId): ShapeId;
+    getShapeHierarchyRootIds(shapeIds: readonly ShapeId[]): ReadonlyMap<ShapeId, ShapeId>;
+    getShapeHierarchyMemberIds(shapeIds: readonly ShapeId[]): ShapeId[];
     cleanupBindingsForDeletedShapes(ids: ShapeId[], source: ChangeSource): void;
     cleanupBindings(ids: BindingId[], source: ChangeSource): void;
     private applyEffect;
+    private syncShapeHierarchyState;
+    private getShapeHierarchyContext;
     private getAllBindings;
     private getExclusiveBindingKey;
 }

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

@@ -13,7 +13,6 @@ export interface ShapeTransformFields {
     x: number;
     y: number;
     rotation: number;
-    skewX: number;
     scaleX: number;
     scaleY: number;
 }
@@ -24,9 +23,9 @@ export interface ShapeTransformDecompositionOptions {
     preferredScaleYSign?: number;
 }
 /**
- * Decompose a shape's local-to-parent affine transform into its canonical
- * translate/rotate/skewX/scale record fields. Axis-collapsed transforms remain
- * representable; unsupported rank-one shears return null.
+ * Strictly decompose a local-to-parent affine transform into the shape model's
+ * translate/rotate/scale fields. Non-orthogonal matrices cannot be represented
+ * without shear and therefore return null.
  */
 export declare function getShapeTransformFieldsFromMatrix(matrix: Mat, localBounds: Box, options?: ShapeTransformDecompositionOptions): ShapeTransformFields | null;
 export declare function getShapeLocalBounds<S extends ShapeRecord>(shape: S, util: ShapeUtil<S>): Box;

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

@@ -10,6 +10,26 @@ export interface SelectionResizeScalesResult {
     scaleX: number;
     scaleY: number;
 }
+/** Gets the axis-aligned size after applying a shape's scale. */
+export declare function getSelectionResizeDimensionsFromLocal({ localWidth, localHeight, scaleX, scaleY, }: {
+    localWidth: number;
+    localHeight: number;
+    scaleX: number;
+    scaleY: number;
+}): {
+    width: number;
+    height: number;
+};
+/** Recovers intrinsic dimensions from an axis-aligned scaled size. */
+export declare function getLocalDimensionsFromSelectionResize({ width, height, scaleX, scaleY, }: {
+    width: number;
+    height: number;
+    scaleX: number;
+    scaleY: number;
+}): {
+    width: number;
+    height: number;
+};
 export declare function selectionResizeHandleMovesLeftEdge(handleId: SelectionResizeHandleId): boolean;
 export declare function selectionResizeHandleMovesRightEdge(handleId: SelectionResizeHandleId): boolean;
 export declare function selectionResizeHandleMovesTopEdge(handleId: SelectionResizeHandleId): boolean;

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

@@ -1,6 +1,8 @@
 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[];

package/_vendor/canvas-core/geometry/mat.d.ts

@@ -16,7 +16,6 @@ export declare class Mat {
     static Identity(): Mat;
     static Translate(x: number, y: number): Mat;
     static Rotate(angle: number): Mat;
-    static SkewX(angle: number): Mat;
     static Scale(sx: number, sy: number): Mat;
     /** Compose: this × other */
     compose(other: Mat): Mat;
@@ -27,6 +26,6 @@ export declare class Mat {
     invert(): Mat;
     toCssString(): string;
     toSvgString(): string;
-    /** Create a transform for a shape: translate * rotate * skewX * scale. */
-    static ForShape(x: number, y: number, rotation: number, scaleX?: number, scaleY?: number, skewX?: number): Mat;
+    /** Create a transform for a shape: translate * rotate * scale. */
+    static ForShape(x: number, y: number, rotation: number, scaleX?: number, scaleY?: number): Mat;
 }

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

@@ -8,7 +8,7 @@ export { getShapeGeometry, getShapeExportBounds, getShapeExportPageBounds, getSh
 export type { ShapeGeometry, ShapeTransformDecompositionOptions, ShapeTransformFields, } from "./editor/queries/shapeTransforms";
 export type { BindingPreviewState, GapSnapIndicatorGapState, GapSnapIndicatorState, PointSnapIndicatorState, SnapIndicatorState, SelectionBindingSegment, TerminalBindingGuideState, SelectionBindingMiddleHandle, SelectionBindingMiddleHandleAnchor, SelectionBindingTerminalHandle, SelectionBindingTerminalHandleAnchor, SelectionCustomHandle, SelectionCustomHandleAnchor, SelectionHandle, SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState, SelectionResizeHandle, SelectionResizeHandleAnchor, SelectionResizeHandleId, SelectionResizeMode, SelectionRotateHandle, SelectionRotateHandleAnchor, SelectionRotateHandleId, SelectionMirrorAxis, } from "./editor/selection";
 export { SELECTION_RESIZE_ALL_MODES, SELECTION_RESIZE_ASPECT_RATIO_LOCKED_ONLY_MODES, SELECTION_RESIZE_CORNER_HANDLE_IDS, SELECTION_RESIZE_FREE_ONLY_MODES, SELECTION_RESIZE_HANDLE_IDS, flipSelectionLocalBounds, getSelectionLocalBoundsFromPagePoints, mapSelectionLocalBoundsBetweenBounds, mapSelectionLocalPointBetweenBounds, mirrorSelectionLocalPoint, rotateSelectionPagePoint, selectionLocalPointToPagePoint, selectionPagePointToLocalPoint, } from "./editor/selection";
-export { getAnchoredSelectionResizeLocalBounds, getAspectRatioLockedSelectionResizeBounds, getCenteredSelectionResizeBounds, getConstrainedSelectionResizeBounds, getSelectionResizeBounds, getSelectionResizeScalesFromBounds, isSelectionResizeCorner, normalizeSelectionResizeBoundsFromEdges, selectionResizeHandleMovesBottomEdge, selectionResizeHandleMovesLeftEdge, selectionResizeHandleMovesRightEdge, selectionResizeHandleMovesTopEdge, } from "./editor/resizeGeometry";
+export { getAnchoredSelectionResizeLocalBounds, getAspectRatioLockedSelectionResizeBounds, getCenteredSelectionResizeBounds, getConstrainedSelectionResizeBounds, getLocalDimensionsFromSelectionResize, getSelectionResizeBounds, getSelectionResizeDimensionsFromLocal, getSelectionResizeScalesFromBounds, isSelectionResizeCorner, normalizeSelectionResizeBoundsFromEdges, selectionResizeHandleMovesBottomEdge, selectionResizeHandleMovesLeftEdge, selectionResizeHandleMovesRightEdge, selectionResizeHandleMovesTopEdge, } from "./editor/resizeGeometry";
 export { InteractionHandlerRegistry } from "./editor/interactions";
 export { SelectionHandleInteractionRegistry } from "./editor/selectionHandleInteractions";
 export { ShortcutManager, formatKeyboardShortcut, normalizeKeyboardShortcut, } from "./editor/managers/shortcutManager";
@@ -29,7 +29,9 @@ export type { ChangeSource, RecordUpdate, RecordsDiff, ScopedStoreRecord, StoreR
 export { SnapshotParseError, parseDocumentSnapshot, parseSessionSnapshot, } from "./schema/snapshots";
 export type { DocumentSnapshot, SessionSnapshot } from "./schema/snapshots";
 export { ShapeUtil } from "./shapes/shapeUtil";
-export type { ShapeBoundsSnapGeometry, ShapeBrushSelectInput, ShapeBrushWrapInput, ShapeClipboardCopyInput, ShapeBindingPointInput, ShapeBindingTargetHitTestInput, ShapeChildPlacementInput, ShapeChildVisibilityInput, ShapeEditEndInput, ShapeEditEndResult, ShapeGeometryInput, ShapeGroupingInput, ShapeHandleSnapContext, ShapeHandleSnapGeometry, ShapeHoverTargetInput, ShapeLineSegmentHitTestInput, ShapeLabelPathGeometry, ShapeLabelPathNearestPositionOptions, ShapePointHitTestInput, ShapeSnapPoint, ShapeSnapPointKind, ShapeTerminalBindingOutline, ShapeSelectionHandleAnchorInput, ShapeSelectionHandleAnchors, ShapeSelectionFrameInput, ShapeSelectionFlipAxis, ShapeSelectionFlipInput, ShapeSelectionOverlayInfo, ShapeSelectionOverlayInfoInput, ShapeSelectionPathStyle, ShapeSelectionPagePoints, ShapeSelectionPagePointsInput, ShapeSelectionResizeInput, ShapeSelectionResizeCapabilityInput, ShapeSelectionResizeModesInput, ShapeSelectionTransformCapabilityInput, ShapeSelectionTranslateInput, } from "./shapes/shapeUtil";
+export { CHILD_TRANSFORM_POLICY_EPSILON, formatChildTransformPolicyViolation, getChildTransformPolicyViolation, } from "./shapes/childTransformPolicy";
+export type { ChildTransformPolicy, ChildTransformPolicyProvider, ChildTransformPolicyViolation, } from "./shapes/childTransformPolicy";
+export type { ShapeBoundsSnapGeometry, ShapeBrushSelectInput, ShapeBrushWrapInput, ShapeClipboardCopyInput, ShapeBindingPointInput, ShapeChildPlacementInput, ShapeChildVisibilityInput, ShapeEditEndInput, ShapeEditEndResult, ShapeGeometryInput, ShapeGroupingInput, ShapeHandleSnapContext, ShapeHandleSnapGeometry, ShapeHoverTargetInput, ShapeLineSegmentHitTestInput, ShapeLabelPathGeometry, ShapeLabelPathNearestPositionOptions, ShapePointHitTestInput, ShapeSnapPoint, ShapeSnapPointKind, ShapeTerminalBindingOutline, ShapeSelectionHandleAnchorInput, ShapeSelectionHandleAnchors, ShapeSelectionFrameInput, ShapeSelectionFlipAxis, ShapeSelectionFlipInput, ShapeSelectionOverlayInfo, ShapeSelectionOverlayInfoInput, ShapeSelectionPathStyle, ShapeSelectionPagePoints, ShapeSelectionPagePointsInput, ShapeSelectionResizeInput, ShapeSelectionResizeCapabilityInput, ShapeSelectionResizeModesInput, ShapeSelectionTransformCapabilityInput, ShapeSelectionTranslateInput, } from "./shapes/shapeUtil";
 export type { HandleSnapContext, HandleSnapInput, HandleSnapMode, HandleSnapResult, HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapInput, ResizeSnapResult, ResizeSnapSnapshot, SnapAxis, SnapCoordinateSpace, SnapPointIndex, SnapPointIndexEntry, SnapPointKind, TranslateSnapInput, TranslateSnapResult, TranslateSnapSnapshot, } from "./editor/managers/snapTypes";
 export { ShapeUtilRegistry } from "./shapes/shapeUtilRegistry";
 export { resolveTerminalBindingAtPoint, } from "./bindings/terminalBinding";

package/_vendor/canvas-core/schema/records.d.ts

@@ -59,7 +59,6 @@ export interface ShapeRecordBase<Type extends string = string, Props extends obj
     x: number;
     y: number;
     rotation: number;
-    skewX: number;
     scaleX: number;
     scaleY: number;
     opacity: number;

package/_vendor/canvas-core/schema/snapshots.d.ts

@@ -2,12 +2,12 @@ import type { ShapeUtilRegistry } from "../shapes/shapeUtilRegistry";
 import type { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
 import type { StoreSnapshot } from "../../store/index";
 import { type DocumentRecord, type SessionRecord } from "./records";
-export type DocumentSnapshot = StoreSnapshot<DocumentRecord, 2>;
+export type DocumentSnapshot = StoreSnapshot<DocumentRecord, 3>;
 export type SessionSnapshot = StoreSnapshot<SessionRecord, 1>;
 export declare class SnapshotParseError extends Error {
     constructor(message: string);
 }
-declare const CURRENT_DOCUMENT_SNAPSHOT_VERSION: 2;
+declare const CURRENT_DOCUMENT_SNAPSHOT_VERSION: 3;
 declare const CURRENT_SESSION_SNAPSHOT_VERSION: 1;
 export declare function getSnapshotEnvelope(snapshot: unknown, kind: "document"): {
     schemaVersion: typeof CURRENT_DOCUMENT_SNAPSHOT_VERSION;

package/_vendor/canvas-core/shapes/childTransformPolicy.d.ts

@@ -0,0 +1,16 @@
+import type { ShapeRecordBase } from "../schema/records";
+export type ChildTransformPolicy = "isometry" | "similarity";
+export declare const CHILD_TRANSFORM_POLICY_EPSILON = 1e-8;
+export interface ChildTransformPolicyProvider<S extends ShapeRecordBase = ShapeRecordBase> {
+    canReceiveChildren(shape: S): boolean;
+    getChildTransformPolicy(shape: S): ChildTransformPolicy;
+}
+export interface ChildTransformPolicyViolation {
+    shapeId: ShapeRecordBase["id"];
+    shapeType: ShapeRecordBase["type"];
+    policy: ChildTransformPolicy;
+    scaleX: number;
+    scaleY: number;
+}
+export declare function getChildTransformPolicyViolation<S extends ShapeRecordBase>(shape: S, provider: ChildTransformPolicyProvider<S>, epsilon?: number): ChildTransformPolicyViolation | null;
+export declare function formatChildTransformPolicyViolation(violation: ChildTransformPolicyViolation): string;

package/_vendor/canvas-core/shapes/shapeUtil.d.ts

@@ -7,6 +7,7 @@ import { type SelectionMirrorAxis } from "../editor/selection";
 import type { SelectionBindingMiddleHandleAnchor, SelectionBindingSegment, SelectionBindingTerminalHandleAnchor, SelectionCustomHandleAnchor, SelectionHandle, SelectionResizeHandleId, SelectionResizeMode } from "../editor/selection";
 import type { ShapeId, ShapeParentId, ShapeRecordBase } from "../schema/records";
 import { type ShapeTerminalBindingPort } from "../bindings/terminalPorts";
+import type { ChildTransformPolicy } from "./childTransformPolicy";
 export interface ShapeEditEndResult {
     deleteShapeIds?: ShapeId[];
 }
@@ -94,8 +95,6 @@ export interface ShapePointHitTestInput extends ShapeGeometryInput {
     pagePoint: Vec;
     positionedPoint: Vec;
 }
-export interface ShapeBindingTargetHitTestInput extends ShapePointHitTestInput {
-}
 export interface ShapeTerminalBindingOutline {
     points: readonly Vec[];
     closed: boolean;
@@ -226,6 +225,7 @@ export declare abstract class ShapeUtil<S extends ShapeRecordBase = ShapeRecordB
     getLocalToPageTransform(shape: S): Mat;
     canEdit(_shape: S): boolean;
     canReceiveChildren(_shape: S): boolean;
+    getChildTransformPolicy(_shape: S): ChildTransformPolicy;
     canReceiveChild(shape: S, _child: ShapeRecordBase): boolean;
     isChildVisible(_shape: S, _child: ShapeRecordBase, _input: ShapeChildVisibilityInput): boolean;
     getChildPlacementMeta(_shape: S, child: ShapeRecordBase, _input: ShapeChildPlacementInput): Record<string, unknown>;
@@ -238,7 +238,7 @@ export declare abstract class ShapeUtil<S extends ShapeRecordBase = ShapeRecordB
     repairLoadedShape(_shape: S): S | null;
     onEditEnd(_shape: S, _input: ShapeEditEndInput): ShapeEditEndResult | void;
     hitTest(shape: S, positionedPoint: Vec, _input?: ShapePointHitTestInput): boolean;
-    hitTestBindingTarget(shape: S, positionedPoint: Vec, input?: ShapeBindingTargetHitTestInput): boolean;
+    hitTestBindingTarget(shape: S, positionedPoint: Vec, input?: ShapePointHitTestInput): boolean;
     hitTestLineSegment(shape: S, input: ShapeLineSegmentHitTestInput): boolean;
     resolveBindingPoint(shape: S, input: ShapeBindingPointInput): Vec;
 }

package/_vendor/plugin-text/textShapeHelpers.d.ts

@@ -7,7 +7,6 @@ export interface CreateTextShapeInput {
     parentId?: ShapeParentId;
     index?: string;
     rotation?: number;
-    skewX?: number;
     scaleX?: number;
     scaleY?: number;
     meta?: Record<string, unknown>;

package/browser/persistence.d.ts

@@ -1,4 +1,4 @@
-import type { ProductPersistenceAdapter, ProductPersistenceLoadResult } from "../core/runtime/runtimeContracts";
+import type { ProductPersistenceAdapter, ProductPersistenceLoadResult } from "../runtime/persistenceContracts";
 import { CANVAS_KIT_IMAGE_BLOB_STORE, CANVAS_KIT_INDEXEDDB_NAME, CANVAS_KIT_INDEXEDDB_VERSION, CANVAS_KIT_SNAPSHOT_STORE } from "./indexedDb";
 export declare const CANVAS_KIT_DOCUMENT_STORAGE_KEY = "canvas-kit.document";
 export declare const CANVAS_KIT_SESSION_STORAGE_KEY = "canvas-kit.session";

package/canvasKitTools.d.ts

@@ -0,0 +1,3 @@
+export declare const CANVAS_KIT_TOOL_IDS: readonly ["select", "hand", "rectangle", "ellipse", "rhombus", "triangle", "hexagon", "star", "arrow", "draw", "path", "text", "frame", "eraser", "laser"];
+export type CanvasKitToolId = (typeof CANVAS_KIT_TOOL_IDS)[number];
+export declare function assertCanvasKitToolId(toolId: string): asserts toolId is CanvasKitToolId;

package/chrome/contextMenuRuntime.d.ts

@@ -0,0 +1,7 @@
+import { type ContextMenuContext, type ContextMenuContributionTarget, type ContextMenuTarget } from "../_vendor/canvas-product-contracts/index";
+import type { Editor } from "../_vendor/canvas-core/index";
+export declare function createContextMenuContext({ editor, menu, }: {
+    editor: Editor;
+    menu: ContextMenuContext["menu"];
+}): ContextMenuContext;
+export declare function getContextMenuContributionTarget(target: ContextMenuTarget, editor: Editor): ContextMenuContributionTarget;

package/chrome/toolbar/toolbarLabels.d.ts

@@ -1,4 +1,4 @@
-import { type ToolbarGroup } from "../../_vendor/canvas-product-contracts/index";
+import type { ToolbarGroup } from "../../_vendor/canvas-product-contracts/index";
 export declare function getActiveToolLabel(groups: readonly ToolbarGroup[], activeToolId: string): string;
 export declare function getSelectionToolbarTitle({ commonShapeType, count, isMixedFrameAndPointHandleSelection, singleShapeType, }: {
     commonShapeType: string | null;

package/chrome/types.d.ts

@@ -1,6 +1,6 @@
 import { type ActiveContextMenu, type CanvasActionContext, type CanvasActionValue } from "../_vendor/canvas-product-contracts/index";
-import type { CanvasKitBaseController, CanvasKitController } from "../controller/canvasKitController";
-import type { CanvasProductLayerNode } from "../core";
+import type { CanvasKitToolId } from "../canvasKitTools";
+import type { CanvasProductController, CanvasProductLayerNode } from "../controller";
 import type { EditorSelectionMetadata, ShapeId } from "../_vendor/canvas-core/index";
 import type { HistoryControls } from "./useHistoryControls";
 import type { PageControls } from "./usePageControls";
@@ -17,7 +17,6 @@ export type { ZoomControlsState } from "./useZoomControls";
 export type { ContextMenuSurface } from "./useContextMenuSurface";
 export type { ToolbarSurfaces, } from "./toolbar/useToolbarSurfaces";
 export type { ChromeSurfaces } from "./useChromeSurfaces";
-export type CanvasKitLayerNode = CanvasProductLayerNode;
 export interface CanvasKitToolbarActionState {
     value: CanvasActionValue | undefined;
     isEnabled: boolean;
@@ -42,8 +41,8 @@ export interface CanvasKitLayerTreeSource {
     getSnapshot(pageId?: string): readonly CanvasProductLayerNode[];
     subscribe(onStoreChange: () => void): () => void;
 }
-export interface CanvasKitChromeContext<TController extends CanvasKitBaseController = CanvasKitController> {
-    controller: TController;
+export interface CanvasKitChromeContext<TToolId extends string = CanvasKitToolId> {
+    controller: CanvasProductController<TToolId>;
     chromeSurfaces: ChromeSurfaces;
     contextMenu: CanvasKitContextMenuState;
     currentPageId: string;

package/chrome/useCanvasKitChromeContext.d.ts

@@ -1,10 +1,10 @@
 import { type ActiveContextMenu, type CanvasActionContext, type CanvasActionRegistry, type CanvasChromeRegistry, type CanvasContextMenuRegistry, type CanvasToolbarRegistry } from "../_vendor/canvas-product-contracts/index";
 import { type Editor } from "../_vendor/canvas-core/index";
-import type { CanvasKitBaseController } from "../controller/canvasKitController";
-import type { ExecuteCanvasKitCommand } from "../runtime/canvasKitCommandExecutor";
+import type { CanvasProductController } from "../controller";
+import type { ExecuteCanvasKitAction } from "../runtime/canvasKitActionExecutor";
 import type { CanvasKitChromeContext, CanvasKitGridControls } from "./types";
-export declare function useCanvasKitChromeContext<TController extends CanvasKitBaseController>({ controller, activeContextMenu, grid, onActiveContextMenuChange, actionRegistry, canShowPropertiesDuringEditing, chromeRegistry, contextMenuRegistry, editor, executeCommand, toolbarRegistry, }: {
-    controller: TController;
+export declare function useCanvasKitChromeContext<TToolId extends string>({ controller, activeContextMenu, grid, onActiveContextMenuChange, actionRegistry, canShowPropertiesDuringEditing, chromeRegistry, contextMenuRegistry, editor, executeAction, toolbarRegistry, }: {
+    controller: CanvasProductController<TToolId>;
     activeContextMenu: ActiveContextMenu | null;
     grid: CanvasKitGridControls;
     onActiveContextMenuChange: (activeContextMenu: ActiveContextMenu | null) => void;
@@ -13,6 +13,6 @@ export declare function useCanvasKitChromeContext<TController extends CanvasKitB
     chromeRegistry: CanvasChromeRegistry;
     contextMenuRegistry: CanvasContextMenuRegistry;
     editor: Editor;
-    executeCommand: ExecuteCanvasKitCommand;
+    executeAction: ExecuteCanvasKitAction;
     toolbarRegistry: CanvasToolbarRegistry;
-}): CanvasKitChromeContext<TController>;
+}): CanvasKitChromeContext<TToolId>;

package/chrome/useCanvasKitLayerTree.d.ts

@@ -1,5 +1,6 @@
-import type { CanvasKitLayerTreeSource, CanvasKitLayerNode } from "./types";
+import type { CanvasProductLayerNode } from "../controller";
+import type { CanvasKitLayerTreeSource } from "./types";
 export declare function useCanvasKitLayerTree(source: CanvasKitLayerTreeSource, options?: {
     enabled?: boolean;
     pageId?: string;
-}): readonly CanvasKitLayerNode[];
+}): readonly CanvasProductLayerNode[];

package/chrome/useHistoryControls.d.ts

@@ -1,12 +1,12 @@
 import type { Editor } from "../_vendor/canvas-core/index";
-import type { ExecuteCanvasKitCommand } from "../runtime/canvasKitCommandExecutor";
+import type { CanvasProductController } from "../controller";
 export interface HistoryControls {
     canUndo: boolean;
     canRedo: boolean;
     undo(): void;
     redo(): void;
 }
-export declare function useHistoryControls({ editor, executeCommand, }: {
+export declare function useHistoryControls({ controller, editor, }: {
+    controller: CanvasProductController;
     editor: Editor;
-    executeCommand: ExecuteCanvasKitCommand;
 }): HistoryControls;

package/chrome/usePageControls.d.ts

@@ -1,16 +1,16 @@
-import type { Editor, PageId, PageRecord } from "../_vendor/canvas-core/index";
-import type { ExecuteCanvasKitCommand } from "../runtime/canvasKitCommandExecutor";
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { CanvasProductController, CanvasProductPageRef } from "../controller";
 export interface PageControls {
-    pages: readonly PageRecord[];
-    currentPage: PageRecord | null;
-    currentPageId: PageId;
+    pages: readonly CanvasProductPageRef[];
+    currentPage: CanvasProductPageRef | null;
+    currentPageId: string;
     canDeleteCurrentPage: boolean;
     createPage(): void;
     deleteCurrentPage(): void;
     renameCurrentPage(nextName: string): void;
-    selectPage(pageId: PageId): void;
+    selectPage(pageId: string): void;
 }
-export declare function usePageControls({ editor, executeCommand, }: {
+export declare function usePageControls({ controller, editor, }: {
+    controller: CanvasProductController;
     editor: Editor;
-    executeCommand: ExecuteCanvasKitCommand;
 }): PageControls;

package/chrome/useZoomControls.d.ts

@@ -1,4 +1,5 @@
 import type { Editor } from "../_vendor/canvas-core/index";
+import type { CanvasProductController } from "../controller";
 export interface ZoomControlsState {
     zoom: number;
     label: string;
@@ -6,4 +7,7 @@ export interface ZoomControlsState {
     zoomOut(): void;
     resetZoom(): void;
 }
-export declare function useZoomControls(editor: Editor): ZoomControlsState;
+export declare function useZoomControls({ controller, editor, }: {
+    controller: CanvasProductController;
+    editor: Editor;
+}): ZoomControlsState;

package/commands/command.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+export interface CanvasKitCommandToken<TId extends string = string> {
+    readonly id: TId;
+}
+export interface CanvasKitCommand<TArgs extends readonly unknown[], TResult, TId extends string = string> {
+    readonly id: TId;
+    readonly token: CanvasKitCommandToken<TId>;
+    run(editor: Editor, ...args: TArgs): TResult;
+}
+export type ExecuteCanvasKitDefinedCommand = <TArgs extends readonly unknown[], TResult>(command: CanvasKitCommand<TArgs, TResult>, ...args: TArgs) => TResult;
+export declare function defineCanvasKitCommand<const TId extends string, TArgs extends readonly unknown[], TResult>(command: Omit<CanvasKitCommand<TArgs, TResult, TId>, "id">): CanvasKitCommand<TArgs, TResult, TId>;

package/commands/commandTokens.d.ts

@@ -0,0 +1,61 @@
+import type { CanvasKitCommandToken } from "./command";
+export declare const CANVAS_KIT_COMMAND_TOKENS: Readonly<{
+    document: Readonly<{
+        updateMeta: CanvasKitCommandToken<"document.update-meta">;
+    }>;
+    session: Readonly<{
+        updateMeta: CanvasKitCommandToken<"session.update-meta">;
+    }>;
+    history: Readonly<{
+        clear: CanvasKitCommandToken<"history.clear">;
+        undo: CanvasKitCommandToken<"history.undo">;
+        redo: CanvasKitCommandToken<"history.redo">;
+    }>;
+    selection: Readonly<{
+        select: CanvasKitCommandToken<"selection.select">;
+        selectAll: CanvasKitCommandToken<"system.selection.select-all">;
+        delete: CanvasKitCommandToken<"system.selection.delete">;
+        duplicate: CanvasKitCommandToken<"system.selection.duplicate">;
+        resetRotation: CanvasKitCommandToken<"system.selection.reset-rotation">;
+        flipHorizontal: CanvasKitCommandToken<"system.selection.flip-horizontal">;
+        flipVertical: CanvasKitCommandToken<"system.selection.flip-vertical">;
+        setOpacity: CanvasKitCommandToken<"system.selection.set-opacity">;
+        align: CanvasKitCommandToken<"system.selection.align">;
+        distribute: CanvasKitCommandToken<"system.selection.distribute">;
+    }>;
+    shape: Readonly<{
+        delete: CanvasKitCommandToken<"shape.delete">;
+        update: CanvasKitCommandToken<"shape.update">;
+        updateMeta: CanvasKitCommandToken<"shape.update-meta">;
+    }>;
+    layer: Readonly<{
+        setHidden: CanvasKitCommandToken<"layer.set-hidden">;
+        setLocked: CanvasKitCommandToken<"layer.set-locked">;
+        group: CanvasKitCommandToken<"layer.group">;
+        ungroup: CanvasKitCommandToken<"layer.ungroup">;
+        sendBackward: CanvasKitCommandToken<"layer.send-backward">;
+        bringForward: CanvasKitCommandToken<"layer.bring-forward">;
+        sendToBack: CanvasKitCommandToken<"layer.send-to-back">;
+        bringToFront: CanvasKitCommandToken<"layer.bring-to-front">;
+        moveToPlacement: CanvasKitCommandToken<"layer.move-to-placement">;
+    }>;
+    tool: Readonly<{
+        setActive: CanvasKitCommandToken<"editor.tool.set-active-tool">;
+        toggleLocked: CanvasKitCommandToken<"editor.tool.toggle-locked">;
+    }>;
+    view: Readonly<{
+        centerOnShape: CanvasKitCommandToken<"view.center-on-shape">;
+        setCamera: CanvasKitCommandToken<"view.set-camera">;
+        zoomIn: CanvasKitCommandToken<"system.view.zoom-in">;
+        zoomOut: CanvasKitCommandToken<"system.view.zoom-out">;
+        resetZoom: CanvasKitCommandToken<"system.view.reset-zoom">;
+        reset: CanvasKitCommandToken<"view.reset">;
+    }>;
+    page: Readonly<{
+        create: CanvasKitCommandToken<"page.create">;
+        rename: CanvasKitCommandToken<"page.rename">;
+        updateMeta: CanvasKitCommandToken<"page.update-meta">;
+        delete: CanvasKitCommandToken<"page.delete">;
+        select: CanvasKitCommandToken<"page.select">;
+    }>;
+}>;

package/commands/documentCommands.d.ts

@@ -0,0 +1,2 @@
+export declare const updateDocumentMetaCommand: import("./command").CanvasKitCommand<[patch: Record<string, unknown>], void, "document.update-meta">;
+export declare const updateSessionMetaCommand: import("./command").CanvasKitCommand<[patch: Record<string, unknown>], void, "session.update-meta">;

package/commands/historyCommands.d.ts

@@ -0,0 +1,3 @@
+export declare const clearHistoryCommand: import("./command").CanvasKitCommand<[], void, "history.clear">;
+export declare const undoCommand: import("./command").CanvasKitCommand<[], boolean, "history.undo">;
+export declare const redoCommand: import("./command").CanvasKitCommand<[], boolean, "history.redo">;

package/commands/index.d.ts

@@ -0,0 +1,11 @@
+export type { CanvasKitCommand, CanvasKitCommandToken, ExecuteCanvasKitDefinedCommand, } from "./command";
+export { CANVAS_KIT_COMMAND_TOKENS } from "./commandTokens";
+export { updateDocumentMetaCommand, updateSessionMetaCommand, } from "./documentCommands";
+export { clearHistoryCommand, redoCommand, undoCommand, } from "./historyCommands";
+export { bringShapesForwardCommand, bringShapesToFrontCommand, groupShapesCommand, moveShapesToLayerPlacementCommand, sendShapesBackwardCommand, sendShapesToBackCommand, setShapesHiddenCommand, setShapesLockedCommand, ungroupShapesCommand, } from "./layerCommands";
+export { createPageCommand, deletePageCommand, renamePageCommand, selectPageCommand, updatePageMetaCommand, } from "./pageCommands";
+export { alignSelectionCommand, deleteSelectionCommand, distributeSelectionCommand, duplicateSelectionCommand, flipSelectionHorizontalCommand, flipSelectionVerticalCommand, resetSelectionRotationCommand, selectAllCommand, selectShapesCommand, setSelectionOpacityCommand, } from "./selectionCommands";
+export type { CanvasSelectionAlignMode, CanvasSelectionDistributeAxis, } from "./selectionCommands";
+export { deleteShapesCommand, updateShapeMetaCommand, updateShapesCommand, } from "./shapeCommands";
+export { setActiveToolCommand, toggleToolLockedCommand, } from "./toolCommands";
+export { centerOnShapeCommand, resetViewCommand, resetZoomCommand, setCameraCommand, zoomInCommand, zoomOutCommand, } from "./viewCommands";

package/commands/layerCommands.d.ts

@@ -0,0 +1,20 @@
+import type { ShapeId } from "../_vendor/canvas-core/index";
+import type { CanvasProductLayerPlacement, CanvasProductLayerPlacementResult } from "../contracts/canvasProductControllerContracts";
+export declare const setShapesHiddenCommand: import("./command").CanvasKitCommand<[input: {
+    ids: ShapeId[];
+    isHidden: boolean;
+}], `shape:${string}`[], "layer.set-hidden">;
+export declare const setShapesLockedCommand: import("./command").CanvasKitCommand<[input: {
+    ids: ShapeId[];
+    isLocked: boolean;
+}], `shape:${string}`[], "layer.set-locked">;
+export declare const groupShapesCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], `shape:${string}` | null, "layer.group">;
+export declare const ungroupShapesCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], `shape:${string}`[], "layer.ungroup">;
+export declare const sendShapesBackwardCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], boolean, "layer.send-backward">;
+export declare const bringShapesForwardCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], boolean, "layer.bring-forward">;
+export declare const sendShapesToBackCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], boolean, "layer.send-to-back">;
+export declare const bringShapesToFrontCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], boolean, "layer.bring-to-front">;
+export declare const moveShapesToLayerPlacementCommand: import("./command").CanvasKitCommand<[input: {
+    ids: ShapeId[];
+    placement: CanvasProductLayerPlacement;
+}], CanvasProductLayerPlacementResult, "layer.move-to-placement">;

package/commands/pageCommands.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasProductCreatePageInput } from "../contracts/canvasProductControllerContracts";
+export declare const createPageCommand: import("./command").CanvasKitCommand<[input?: CanvasProductCreatePageInput | undefined], import("../_vendor/canvas-core/index").PageRecord, "page.create">;
+export declare const renamePageCommand: import("./command").CanvasKitCommand<[input: {
+    pageId: string;
+    name: string;
+}], void, "page.rename">;
+export declare const updatePageMetaCommand: import("./command").CanvasKitCommand<[input: {
+    pageId: string;
+    patch: Record<string, unknown>;
+}], `page:${string}` | null, "page.update-meta">;
+export declare const deletePageCommand: import("./command").CanvasKitCommand<[pageId: string], boolean, "page.delete">;
+export declare const selectPageCommand: import("./command").CanvasKitCommand<[pageId: string], void, "page.select">;

package/commands/selectionCommands.d.ts

@@ -0,0 +1,12 @@
+export type CanvasSelectionAlignMode = "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom";
+export type CanvasSelectionDistributeAxis = "horizontal" | "vertical";
+export declare const selectShapesCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], void, "selection.select">;
+export declare const selectAllCommand: import("./command").CanvasKitCommand<[], void, "system.selection.select-all">;
+export declare const deleteSelectionCommand: import("./command").CanvasKitCommand<[], void, "system.selection.delete">;
+export declare const duplicateSelectionCommand: import("./command").CanvasKitCommand<[], `shape:${string}`[], "system.selection.duplicate">;
+export declare const resetSelectionRotationCommand: import("./command").CanvasKitCommand<[], void, "system.selection.reset-rotation">;
+export declare const flipSelectionHorizontalCommand: import("./command").CanvasKitCommand<[], void, "system.selection.flip-horizontal">;
+export declare const flipSelectionVerticalCommand: import("./command").CanvasKitCommand<[], void, "system.selection.flip-vertical">;
+export declare const setSelectionOpacityCommand: import("./command").CanvasKitCommand<[opacity: number], void, "system.selection.set-opacity">;
+export declare const alignSelectionCommand: import("./command").CanvasKitCommand<[mode: CanvasSelectionAlignMode], boolean, "system.selection.align">;
+export declare const distributeSelectionCommand: import("./command").CanvasKitCommand<[axis: CanvasSelectionDistributeAxis], boolean, "system.selection.distribute">;

package/commands/shapeCommands.d.ts

@@ -0,0 +1,8 @@
+import type { ShapeId } from "../_vendor/canvas-core/index";
+import type { CanvasProductShapeUpdate } from "../contracts/canvasProductControllerContracts";
+export declare const deleteShapesCommand: import("./command").CanvasKitCommand<[ids: `shape:${string}`[]], void, "shape.delete">;
+export declare const updateShapesCommand: import("./command").CanvasKitCommand<[updates: CanvasProductShapeUpdate[]], `shape:${string}`[], "shape.update">;
+export declare const updateShapeMetaCommand: import("./command").CanvasKitCommand<[input: {
+    id: ShapeId;
+    patch: Record<string, unknown>;
+}], `shape:${string}` | null, "shape.update-meta">;

package/commands/toolCommands.d.ts

@@ -0,0 +1,2 @@
+export declare const setActiveToolCommand: import("./command").CanvasKitCommand<[toolId: string], void, "editor.tool.set-active-tool">;
+export declare const toggleToolLockedCommand: import("./command").CanvasKitCommand<[], void, "editor.tool.toggle-locked">;

package/commands/viewCommands.d.ts

@@ -0,0 +1,10 @@
+import type { Camera } from "../_vendor/canvas-core/index";
+export declare const centerOnShapeCommand: import("./command").CanvasKitCommand<[id: `shape:${string}`], boolean, "view.center-on-shape">;
+export declare const setCameraCommand: import("./command").CanvasKitCommand<[input: {
+    camera: Partial<Camera>;
+    pageId?: string;
+}], void, "view.set-camera">;
+export declare const zoomInCommand: import("./command").CanvasKitCommand<[], void, "system.view.zoom-in">;
+export declare const zoomOutCommand: import("./command").CanvasKitCommand<[], void, "system.view.zoom-out">;
+export declare const resetZoomCommand: import("./command").CanvasKitCommand<[], void, "system.view.reset-zoom">;
+export declare const resetViewCommand: import("./command").CanvasKitCommand<[], void, "view.reset">;