@yuzhouu/canvas-kit 0.1.13 → 0.1.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yuzhouu/canvas-kit",
-  "version": "0.1.13",
-  "description": "Extensible Land canvas runtime, standard React product profile, and typed API surface.",
+  "version": "0.1.14",
+  "description": "Extensible Land canvas runtime, React product primitives, and typed API surface.",
   "type": "module",
   "main": "./index.mjs",
   "module": "./index.mjs",
@@ -22,19 +22,7 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
-  "dependencies": {
-    "@tiptap/core": "3.27.3",
-    "@tiptap/extension-bold": "3.27.3",
-    "@tiptap/extension-italic": "3.27.3",
-    "@tiptap/extension-link": "3.27.3",
-    "@tiptap/extension-strike": "3.27.3",
-    "@tiptap/extension-text-align": "3.27.3",
-    "@tiptap/extension-text-style": "3.27.3",
-    "@tiptap/extension-underline": "3.27.3",
-    "@tiptap/extensions": "3.27.3",
-    "@tiptap/react": "3.27.3",
-    "@tiptap/starter-kit": "3.27.3"
-  },
+  "dependencies": {},
   "publishConfig": {
     "access": "public"
   }

package/react/CanvasKitContext.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from "react";
+import type { CanvasKit, CanvasReadable } from "../runtime/canvasKitContracts";
+export declare function CanvasKitProvider({ canvas, children, }: {
+    canvas: CanvasKit;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useCanvasKit(): CanvasKit;
+export declare function useCanvasValue<T>(readable: CanvasReadable<T>): T;

package/react/CanvasKitRoot.d.ts

@@ -1,11 +1,2 @@
-import type { CanvasKitToolId } from "../canvasKitTools";
-import type { CanvasProductController } from "../controller";
-import type { CanvasKitRuntime } from "../runtime/canvasKitRuntimeContracts";
-export interface CanvasKitRootProps {
-    runtime: CanvasKitRuntime;
-    onControllerReady?: (controller: CanvasProductController<CanvasKitToolId>) => void;
-    onControllerDispose?: () => void;
-    exposeControllerOnWindow?: boolean;
-    windowKey?: string;
-}
-export declare function CanvasKitRoot({ runtime, onControllerReady, onControllerDispose, exposeControllerOnWindow, windowKey, }: CanvasKitRootProps): import("react/jsx-runtime").JSX.Element | null;
+import type { CanvasKitRootProps } from "./canvasKitRootContracts";
+export declare function CanvasKitRoot({ actions, chromeRenderer, onCanvasChange, options, }: CanvasKitRootProps): import("react/jsx-runtime").JSX.Element | null;

package/react/canvasActions.d.ts

@@ -0,0 +1,3 @@
+import type { CanvasAction, CanvasActionShortcut, CanvasActionShortcutOverrides, KeyboardShortcut } from "./canvasKitRootContracts";
+export declare function getCanvasActionShortcuts(shortcut: CanvasActionShortcut | undefined): readonly KeyboardShortcut[];
+export declare function applyCanvasActionShortcutOverrides(actions: readonly CanvasAction[], overrides: CanvasActionShortcutOverrides | undefined): readonly CanvasAction[];

package/react/canvasKitRootContracts.d.ts

@@ -0,0 +1,19 @@
+import type { KeyboardShortcutInput } from "../_vendor/canvas-core/index";
+import type { ReactNode } from "react";
+import type { CanvasKit, CanvasKitOptions } from "../runtime/canvasKitContracts";
+export type KeyboardShortcut = KeyboardShortcutInput;
+export type CanvasActionShortcut = KeyboardShortcut | readonly KeyboardShortcut[];
+export type CanvasActionShortcutOverrides = Readonly<Record<string, CanvasActionShortcut | null>>;
+export type CanvasKitChromeRenderer = (canvas: CanvasKit) => ReactNode;
+export interface CanvasAction {
+    readonly id: string;
+    readonly shortcut?: CanvasActionShortcut;
+    isEnabled(canvas: CanvasKit): boolean;
+    run(canvas: CanvasKit): void | Promise<void>;
+}
+export interface CanvasKitRootProps {
+    options: CanvasKitOptions;
+    actions?: readonly CanvasAction[];
+    chromeRenderer?: CanvasKitChromeRenderer;
+    onCanvasChange?(canvas: CanvasKit | null): void;
+}

package/react/host/CanvasKitCanvasHost.d.ts

@@ -0,0 +1,7 @@
+import type { CanvasKitRenderHostBindings } from "../../runtime/canvasKitRootRuntime";
+import type { CanvasErrorHandler } from "../../runtime/canvasKitContracts";
+export declare function CanvasKitCanvasHost({ bindings, getHostElement, onError, }: {
+    bindings: CanvasKitRenderHostBindings;
+    getHostElement(): HTMLElement | null;
+    onError: CanvasErrorHandler;
+}): import("react/jsx-runtime").JSX.Element;

package/react/host/import/CanvasImportHost.d.ts

@@ -0,0 +1,13 @@
+import type { Vec } from "../../../_vendor/canvas-core/index";
+import { type CanvasImportContribution, type CanvasImportPreview, type CanvasImportRequest, type CanvasImportResult } from "../../../_vendor/canvas-extension-contracts/index";
+export declare function CanvasImportHost({ contributions, getHostElement, isEditing, onError, screenToPage, }: {
+    contributions: readonly CanvasImportContribution[];
+    getHostElement(): HTMLElement | null;
+    isEditing(): boolean;
+    onError(error: unknown): void;
+    screenToPage(point: Vec): Vec;
+}): null;
+export declare function canImportCanvasContent(contributions: readonly CanvasImportContribution[], request: CanvasImportRequest): boolean;
+export declare function canImportCanvasContentPreview(contributions: readonly CanvasImportContribution[], preview: CanvasImportPreview): boolean;
+export declare function importCanvasContent(contributions: readonly CanvasImportContribution[], request: CanvasImportRequest): Promise<CanvasImportResult>;
+export declare function getImportPreview(dataTransfer: DataTransfer | null): CanvasImportPreview;

package/react/host/keyboard/useCanvasKeyboardShortcuts.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasAction } from "../../canvasKitRootContracts";
+import type { CanvasKit } from "../../../runtime/canvasKitContracts";
+export declare function useCanvasKeyboardShortcuts({ actions, canvas, isEditing, onError, }: {
+    actions: readonly CanvasAction[];
+    canvas: CanvasKit;
+    isEditing(): boolean;
+    onError(error: unknown): void;
+}): void;

package/react/reportCanvasHostError.d.ts

@@ -0,0 +1 @@
+export declare function reportCanvasHostError(error: unknown): void;

package/react/useCanvasKitRootRuntime.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasKitOptions } from "../runtime/canvasKitContracts";
+import type { CanvasKitRootRuntime } from "../runtime/canvasKitRootRuntime";
+export type CanvasKitRootRuntimeState = {
+    readonly status: "starting";
+} | {
+    readonly status: "ready";
+    readonly runtime: CanvasKitRootRuntime;
+} | {
+    readonly status: "error";
+    readonly error: unknown;
+};
+export declare function useCanvasKitRootRuntime(options: CanvasKitOptions): CanvasKitRootRuntimeState;

package/runtime/activateCanvasPlugins.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { CanvasPlugin, CanvasPluginInstance, ScopedProductApiRegistryView } from "../_vendor/canvas-extension-contracts/index";
+import type { CanvasRuntimeOwner } from "./canvasRuntimeOwner";
+import type { ProductApiRegistryRuntime } from "./registries/productApiRegistry";
+export type CanvasPluginContributions = Required<Pick<CanvasPluginInstance<unknown>, "assetResolvers" | "exports" | "imports">>;
+export interface ActivatedCanvasPlugins {
+    readonly apis: ScopedProductApiRegistryView;
+    readonly contributions: CanvasPluginContributions;
+}
+export declare function activateCanvasPlugins({ apis, canvasPlugins, editor, owner, productId, }: {
+    apis: ProductApiRegistryRuntime;
+    canvasPlugins: readonly CanvasPlugin<unknown>[];
+    editor: Editor;
+    owner: CanvasRuntimeOwner;
+    productId: string;
+}): ActivatedCanvasPlugins;

package/runtime/canvasExportController.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { CanvasExportContribution, CanvasProductExportController, CanvasTaskRunner } from "../_vendor/canvas-extension-contracts/index";
+export interface CanvasExportController extends CanvasProductExportController {
+    subscribe(listener: () => void): () => void;
+    dispose(): void;
+}
+export declare function createCanvasExportController({ editor, contributions, tasks, }: {
+    editor: Editor;
+    contributions: readonly CanvasExportContribution[];
+    tasks: CanvasTaskRunner;
+}): CanvasExportController;

package/runtime/canvasKit.d.ts

@@ -0,0 +1,3 @@
+import type { CanvasKitRootRuntime } from "./canvasKitRootRuntime";
+import type { CanvasKitCreateControl, CanvasKitOptions } from "./canvasKitContracts";
+export declare function createCanvasKitRootRuntime(options: CanvasKitOptions, control?: CanvasKitCreateControl): Promise<CanvasKitRootRuntime>;

package/runtime/canvasKitContracts.d.ts

@@ -0,0 +1,192 @@
+import type { AssetId, Camera, LayerOrderDirection, LayerOrderEdge, ShapeId } from "../_vendor/canvas-core/index";
+import type { ActiveCanvasContextMenu, CanvasApiToken, CanvasPluginInput, CanvasProductAssetData, CanvasProductCreatePageInput, CanvasProductDocumentRef, CanvasProductExportController, CanvasProductExportStatus, CanvasProductLayerActionState, CanvasProductLayerNode, CanvasProductLayerPlacement, CanvasProductLayerPlacementResult, CanvasProductPageRef, CanvasProductShapeData, CanvasProductShapeUpdate, CanvasSelectionAlignMode, CanvasSelectionDistributeAxis, CanvasProductSnapshot, CanvasStartupResult, ProductPersistenceAdapter } from "../_vendor/canvas-extension-contracts/index";
+export type CanvasKitStartupResult = CanvasStartupResult;
+export type CanvasKitSnapshot = CanvasProductSnapshot<string>;
+export type CanvasErrorHandler = (error: unknown) => void;
+export interface CanvasPersistenceFlushEvents {
+    subscribe(requestFlush: () => void): () => void;
+}
+export interface CanvasReadable<T> {
+    getSnapshot(): T;
+    subscribe(listener: () => void): () => void;
+}
+export interface CanvasDocumentApi {
+    readonly state: CanvasReadable<CanvasProductDocumentRef>;
+    readonly readonlyState: CanvasReadable<boolean>;
+    getSnapshot(): CanvasKitSnapshot;
+    updateMeta(patch: Readonly<Record<string, unknown>>): CanvasProductDocumentRef;
+}
+export interface CanvasSessionState {
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasSessionApi {
+    readonly state: CanvasReadable<CanvasSessionState>;
+    updateMeta(patch: Readonly<Record<string, unknown>>): CanvasSessionState;
+}
+export interface CanvasSelectionBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface CanvasSelectionState {
+    readonly count: number;
+    readonly singleShapeType: string | null;
+    readonly commonShapeType: string | null;
+    readonly canFlipSelection: boolean;
+    readonly hasPointHandleSelection: boolean;
+    readonly hasFrameSelection: boolean;
+    readonly isMixedFrameAndPointHandleSelection: boolean;
+    readonly canDragPointHandles: boolean;
+    readonly hasSelectionRotation: boolean;
+    readonly hasMixedSelectionRotation: boolean;
+    readonly canResetSelectionRotation: boolean;
+    readonly ids: readonly ShapeId[];
+    readonly shapes: readonly CanvasProductShapeData[];
+    readonly pageBounds: CanvasSelectionBounds | null;
+    readonly anchorPagePoint: {
+        readonly x: number;
+        readonly y: number;
+    } | null;
+    readonly isTranslating: boolean;
+}
+export interface CanvasSelectionApi {
+    readonly state: CanvasReadable<CanvasSelectionState>;
+    select(ids: readonly ShapeId[]): void;
+    selectAll(): void;
+    clear(): void;
+    delete(): void;
+    duplicate(): readonly ShapeId[];
+    resetRotation(): void;
+    flip(axis: "horizontal" | "vertical"): void;
+    setOpacity(opacity: number): void;
+    align(mode: CanvasSelectionAlignMode): boolean;
+    distribute(axis: CanvasSelectionDistributeAxis): boolean;
+}
+export interface CanvasPagesState {
+    readonly pages: readonly CanvasProductPageRef[];
+    readonly currentPage: CanvasProductPageRef | null;
+    readonly currentPageId: string;
+    readonly currentPageShapeIds: readonly ShapeId[];
+    readonly canDeleteCurrentPage: boolean;
+}
+export interface CanvasPagesApi {
+    readonly state: CanvasReadable<CanvasPagesState>;
+    create(input?: CanvasProductCreatePageInput): CanvasProductPageRef;
+    rename(pageId: string, name: string): void;
+    updateMeta(pageId: string, patch: Readonly<Record<string, unknown>>): string | null;
+    delete(pageId: string): boolean;
+    deleteCurrent(): boolean;
+    setCurrent(pageId: string): void;
+}
+export interface CanvasHistoryState {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}
+export interface CanvasHistoryApi {
+    readonly state: CanvasReadable<CanvasHistoryState>;
+    clear(): void;
+    undo(): boolean;
+    redo(): boolean;
+}
+export interface CanvasViewportState {
+    readonly camera: Readonly<Camera>;
+    readonly zoom: number;
+    readonly pageTransform: string;
+}
+export interface CanvasGridApi {
+    readonly state: CanvasReadable<boolean>;
+    setVisible(isVisible: boolean): void;
+    toggle(): void;
+}
+export interface CanvasViewportApi {
+    readonly state: CanvasReadable<CanvasViewportState>;
+    readonly grid: CanvasGridApi;
+    setCamera(camera: Partial<Camera>, pageId?: string): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    resetZoom(): void;
+    reset(): void;
+}
+export interface CanvasToolsState {
+    readonly currentToolId: string;
+    readonly isLocked: boolean;
+    readonly isEditing: boolean;
+}
+export interface CanvasToolsApi {
+    readonly state: CanvasReadable<CanvasToolsState>;
+    setCurrent(toolId: string): void;
+    setLocked(isLocked: boolean): void;
+    toggleLocked(): void;
+}
+export interface CanvasShapesApi {
+    get(id: ShapeId): CanvasProductShapeData | null;
+    getMany(ids: readonly ShapeId[]): readonly CanvasProductShapeData[];
+    getAll(): readonly CanvasProductShapeData[];
+    update(updates: readonly CanvasProductShapeUpdate[]): readonly ShapeId[];
+    updateMeta(id: ShapeId, patch: Readonly<Record<string, unknown>>): ShapeId | null;
+    delete(ids: readonly ShapeId[]): void;
+}
+export interface CanvasAssetsApi {
+    get(id: AssetId): CanvasProductAssetData | null;
+    resolveUrl(id: AssetId): string | null;
+}
+export interface CanvasLayerCenterOptions {
+    readonly animation?: {
+        readonly durationMs: number;
+    };
+}
+export interface CanvasLayersApi {
+    readonly state: CanvasReadable<readonly CanvasProductLayerNode[]>;
+    getTree(pageId?: string): readonly CanvasProductLayerNode[];
+    getNode(id: ShapeId): CanvasProductLayerNode | null;
+    getActionState(ids: readonly ShapeId[]): CanvasProductLayerActionState;
+    centerOn(id: ShapeId, options?: CanvasLayerCenterOptions): boolean;
+    setHidden(ids: readonly ShapeId[], isHidden: boolean): readonly ShapeId[];
+    setLocked(ids: readonly ShapeId[], isLocked: boolean): readonly ShapeId[];
+    group(ids: readonly ShapeId[]): ShapeId | null;
+    ungroup(ids: readonly ShapeId[]): readonly ShapeId[];
+    move(ids: readonly ShapeId[], direction: LayerOrderDirection): boolean;
+    moveToEdge(ids: readonly ShapeId[], edge: LayerOrderEdge): boolean;
+    moveToPlacement(ids: readonly ShapeId[], placement: CanvasProductLayerPlacement): CanvasProductLayerPlacementResult;
+}
+export interface CanvasContextMenuApi {
+    readonly state: CanvasReadable<ActiveCanvasContextMenu | null>;
+    dismiss(): void;
+}
+export interface CanvasExportApi extends CanvasProductExportController {
+    readonly state: CanvasReadable<CanvasProductExportStatus>;
+}
+export interface CanvasKit {
+    readonly startup: CanvasKitStartupResult;
+    readonly document: CanvasDocumentApi;
+    readonly session: CanvasSessionApi;
+    readonly selection: CanvasSelectionApi;
+    readonly pages: CanvasPagesApi;
+    readonly history: CanvasHistoryApi;
+    readonly viewport: CanvasViewportApi;
+    readonly tools: CanvasToolsApi;
+    readonly shapes: CanvasShapesApi;
+    readonly assets: CanvasAssetsApi;
+    readonly layers: CanvasLayersApi;
+    readonly contextMenu: CanvasContextMenuApi;
+    readonly exports: CanvasExportApi;
+    api<TApi>(token: CanvasApiToken<TApi>): TApi | undefined;
+}
+export interface CanvasKitOptions {
+    readonly id?: string;
+    readonly plugins: readonly CanvasPluginInput[];
+    readonly documentMeta?: Record<string, unknown>;
+    /**
+     * Used only when persistence reports that no stored document exists.
+     * Persistence and snapshot validation failures reject CanvasKit creation.
+     */
+    readonly initialDocumentSnapshot?: unknown;
+    readonly persistence: ProductPersistenceAdapter | null;
+    readonly readonly?: boolean;
+    readonly onError?: CanvasErrorHandler;
+}
+export interface CanvasKitCreateControl {
+    readonly signal?: AbortSignal;
+    readonly persistenceFlushEvents?: CanvasPersistenceFlushEvents;
+}

package/runtime/canvasKitRootRuntime.d.ts

@@ -0,0 +1,17 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { ActiveCanvasContextMenu, CanvasImportContribution } from "../_vendor/canvas-extension-contracts/index";
+import type { CanvasRenderBindings } from "../_vendor/canvas-react/host/index";
+import type { CanvasErrorHandler, CanvasKit } from "./canvasKitContracts";
+export interface CanvasKitRenderHostBindings {
+    readonly editor: Editor;
+    readonly renderBindings: CanvasRenderBindings;
+    readonly importContributions: readonly CanvasImportContribution[];
+    readonly onError?: CanvasErrorHandler;
+    setContextMenu(request: ActiveCanvasContextMenu | null): void;
+}
+export interface CanvasKitRootRuntime {
+    readonly canvas: CanvasKit;
+    readonly productId: string;
+    readonly render: CanvasKitRenderHostBindings;
+    dispose(): Promise<void>;
+}

package/runtime/canvasPluginGraph.d.ts

@@ -1,15 +1,9 @@
-import type { EditorPlugin, ShapeRecordBase } from "../_vendor/canvas-core/index";
+import type { EditorPlugin } from "../_vendor/canvas-core/index";
+import type { CanvasPlugin, CanvasPluginInput } from "../_vendor/canvas-extension-contracts/index";
 import type { CanvasRenderPlugin } from "../_vendor/canvas-react/host/index";
-import { type CanvasPlugin, type CanvasPluginCapabilityToken, type CanvasPluginInput } from "../_vendor/canvas-plugin-sdk/index";
-type CanvasPluginSetupLike = (context: never) => unknown;
-export interface CompiledCanvasPlugins<TSetup extends CanvasPluginSetupLike> {
-    readonly plugins: readonly CanvasPlugin<TSetup>[];
-    readonly pluginIds: readonly string[];
+export interface CompiledCanvasPlugins {
+    readonly canvasPlugins: readonly CanvasPlugin<unknown>[];
     readonly editorPlugins: readonly EditorPlugin[];
     readonly renderPlugins: readonly CanvasRenderPlugin[];
-    readonly shapeTypes: readonly ShapeRecordBase["type"][];
 }
-export declare function compileCanvasPlugins<TSetup extends CanvasPluginSetupLike>(input: readonly CanvasPluginInput<TSetup>[]): CompiledCanvasPlugins<TSetup>;
-export declare function assertValidCanvasPluginGraph<TSetup extends CanvasPluginSetupLike>(input: readonly CanvasPluginInput<TSetup>[]): void;
-export declare function hasCanvasPluginCapabilityProvider<TSetup extends CanvasPluginSetupLike>(input: readonly CanvasPluginInput<TSetup>[], token: CanvasPluginCapabilityToken): boolean;
-export {};
+export declare function compileCanvasPlugins(input: readonly CanvasPluginInput[]): CompiledCanvasPlugins;

package/runtime/canvasRuntimeInitialization.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { CanvasAssetResolverContribution, ProductPersistenceAdapter } from "../_vendor/canvas-extension-contracts/index";
+import type { CanvasKitStartupResult } from "./canvasKitContracts";
+import type { PersistenceCoordinator } from "./persistenceCoordinator";
+export declare function initializeCanvasDocument({ assetResolvers, editor, initialDocumentSnapshot, persistenceAdapter, persistenceCoordinator, signal, }: {
+    assetResolvers: readonly CanvasAssetResolverContribution[];
+    editor: Editor;
+    initialDocumentSnapshot?: unknown;
+    persistenceAdapter: ProductPersistenceAdapter | null;
+    persistenceCoordinator: PersistenceCoordinator | null;
+    signal: AbortSignal;
+}): Promise<CanvasKitStartupResult>;

package/runtime/canvasRuntimeOwner.d.ts

@@ -0,0 +1,16 @@
+import type { CanvasTaskRunner } from "../_vendor/canvas-extension-contracts/index";
+type RuntimeResourceCleanup<TValue> = ((value: TValue) => void | Promise<void>) | {
+    shutdown(value: TValue): void | Promise<void>;
+    rollback?(value: TValue): void | Promise<void>;
+};
+export interface CanvasRuntimeOwner {
+    readonly signal: AbortSignal;
+    readonly tasks: CanvasTaskRunner;
+    own<TValue>(value: TValue, cleanup: RuntimeResourceCleanup<TValue>): TValue;
+    publish(options?: {
+        readonly beforeShutdown?: () => void;
+    }): () => Promise<void>;
+    rollback(cause: unknown): Promise<never>;
+}
+export declare function createCanvasRuntimeOwner(): CanvasRuntimeOwner;
+export {};

package/runtime/createCanvasKitEditor.d.ts

@@ -3,5 +3,6 @@ export interface CreateCanvasKitEditorOptions {
     editorPlugins: readonly EditorPlugin[];
     documentMeta?: Record<string, unknown>;
     resolveAssetUrl?: (assetId: AssetId) => string | null;
+    onUnhandledError?: (error: unknown) => void;
 }
 export declare function createCanvasKitEditor(options: CreateCanvasKitEditorOptions): Editor;

package/runtime/facade/canvasProductData.d.ts

@@ -0,0 +1,14 @@
+import type { AssetRecord, DocumentMetadataRecord, Editor, PageId, PageRecord, ShapeId, ShapeRecord } from "../../_vendor/canvas-core/index";
+import type { CanvasProductAssetData, CanvasProductDocumentRef, CanvasProductPageRef, CanvasProductShapeData, CanvasProductShapeUpdate, CanvasProductSnapshot } from "../../_vendor/canvas-extension-contracts/index";
+export interface CanvasProductSnapshotContext {
+    readonly editor: Editor;
+    readonly productId: string;
+    assertToolId(toolId: string): void;
+}
+export declare function toCanvasProductPageRef(page: PageRecord): CanvasProductPageRef;
+export declare function toCanvasProductDocumentRef(documentMetadata: DocumentMetadataRecord | undefined): CanvasProductDocumentRef;
+export declare function toCanvasProductShapeData(shape: ShapeRecord, pageId: PageId | null): CanvasProductShapeData;
+export declare function toCanvasProductAssetData(asset: AssetRecord): CanvasProductAssetData;
+export declare function toCanvasProductSnapshot(context: CanvasProductSnapshotContext): CanvasProductSnapshot<string>;
+export declare function updateCanvasProductShapes(editor: Editor, updates: readonly CanvasProductShapeUpdate[]): ShapeId[];
+export declare function setCanvasSelectionOpacity(editor: Editor, opacity: number): void;

package/runtime/facade/canvasReadable.d.ts

@@ -0,0 +1,13 @@
+import { type ReadonlyValue } from "../../_vendor/canvas-core/index";
+import type { CanvasReadable } from "../canvasKitContracts";
+export interface MutableCanvasReadable<T> {
+    readonly readable: CanvasReadable<T>;
+    set(value: T): void;
+}
+export declare function createMutableCanvasReadable<T>(initialValue: T): MutableCanvasReadable<T>;
+export declare function createEditorCanvasReadable<TDependencies extends readonly unknown[], TSnapshot>({ getDependencies, getSnapshot, name, signals, }: {
+    getDependencies(): TDependencies;
+    getSnapshot(dependencies: TDependencies): TSnapshot;
+    name: string;
+    signals: ReadonlyValue<unknown>["graph"];
+}): CanvasReadable<TSnapshot>;

package/runtime/facade/createCanvasKitFacade.d.ts

@@ -0,0 +1,17 @@
+import type { Editor } from "../../_vendor/canvas-core/index";
+import type { ActiveCanvasContextMenu, ScopedProductApiRegistryView } from "../../_vendor/canvas-extension-contracts/index";
+import type { CanvasExportController } from "../canvasExportController";
+import type { CanvasKit, CanvasKitStartupResult } from "../canvasKitContracts";
+export interface CanvasKitHostController {
+    setContextMenu(request: ActiveCanvasContextMenu | null): void;
+}
+export declare function createCanvasKitFacade({ apis, editor, exports, productId, startup, }: {
+    apis: ScopedProductApiRegistryView;
+    editor: Editor;
+    exports: CanvasExportController;
+    productId: string;
+    startup: CanvasKitStartupResult;
+}): {
+    readonly canvas: CanvasKit;
+    readonly host: CanvasKitHostController;
+};

package/runtime/facade/layerTree.d.ts

@@ -0,0 +1,12 @@
+import type { BindingRecord, Editor, PageId, ShapeId, ShapeRecord } from "../../_vendor/canvas-core/index";
+import type { CanvasProductLayerNode } from "../../_vendor/canvas-extension-contracts/index";
+export declare function getCanvasProductLayerTree({ bindings, editor, pageId, shapes, }: {
+    bindings: readonly BindingRecord[];
+    editor: Editor;
+    pageId: PageId;
+    shapes: readonly ShapeRecord[];
+}): CanvasProductLayerNode[];
+export declare function getCanvasProductLayerNode({ editor, id, }: {
+    editor: Editor;
+    id: ShapeId;
+}): CanvasProductLayerNode | null;

package/runtime/persistenceCoordinator.d.ts

@@ -1,10 +1,13 @@
 import type { Editor } from "../_vendor/canvas-core/index";
-import type { ProductPersistenceAdapter } from "./persistenceContracts";
+import type { ProductPersistenceAdapter } from "../_vendor/canvas-extension-contracts/index";
+import type { CanvasErrorHandler, CanvasPersistenceFlushEvents } from "./canvasKitContracts";
 export declare class PersistenceCoordinator {
     private readonly editor;
     private readonly adapter;
+    private readonly options;
     private unsubscribeDocument;
     private unsubscribeSession;
+    private unsubscribeFlushEvents;
     private documentTimer;
     private sessionTimer;
     private pendingDocument;
@@ -14,11 +17,25 @@ export declare class PersistenceCoordinator {
     private documentRetryCount;
     private sessionRetryCount;
     private writeChain;
+    private flushChain;
     private isRunning;
-    constructor(editor: Editor, adapter: ProductPersistenceAdapter);
+    private disposeMode;
+    private disposePromise;
+    constructor(editor: Editor, adapter: ProductPersistenceAdapter, options?: {
+        flushEvents?: CanvasPersistenceFlushEvents;
+        onError?: CanvasErrorHandler;
+    });
     start(): void;
-    stop(): void;
     flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    rollback(): Promise<void>;
+    private dispose;
+    private finishShutdown;
+    private finishRollback;
+    private stopIntake;
+    private flushNow;
+    private flushPendingSnapshots;
+    private discardPendingSnapshots;
     private savePendingDocument;
     private savePendingSession;
     private queueWrite;
@@ -28,6 +45,6 @@ export declare class PersistenceCoordinator {
     private scheduleSessionRetry;
     private cancelDocumentTimer;
     private cancelSessionTimer;
-    private readonly flushWhenHidden;
-    private readonly flushWhenPageIsLeaving;
+    private readonly flushForHostLifecycle;
+    private reportError;
 }

package/runtime/registries/productApiRegistry.d.ts

@@ -1,5 +1,14 @@
-import { type ProductApiRegistry, type ProductApiToken } from "../../_vendor/canvas-product-contracts/index";
-export interface ProductApiRegistryRuntime extends ProductApiRegistry {
-    register<TApi>(token: ProductApiToken<TApi>, api: TApi): void;
+import type { CanvasApiToken, ScopedProductApiRegistryView } from "../../_vendor/canvas-extension-contracts/index";
+export interface ProductApiRegistryRuntime {
+    register<TApi>(input: {
+        readonly token: CanvasApiToken<TApi>;
+        readonly api: TApi;
+        readonly pluginId: string;
+    }): void;
+    view(input: {
+        readonly allowedTokenIds?: ReadonlySet<string>;
+        readonly ownerLabel: string;
+    }): ScopedProductApiRegistryView;
+    clear(): void;
 }
 export declare function createProductApiRegistry(): ProductApiRegistryRuntime;

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

@@ -1,7 +0,0 @@
-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/canvasPanInteraction.d.ts

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

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

@@ -1,6 +0,0 @@
-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/editorComputedHelpers.d.ts

@@ -1,24 +0,0 @@
-import type { Box } from "../geometry/box";
-import type { Vec } from "../geometry/vec";
-import type { AssetId, PageId, PageRecord, ShapeId, ShapeRecord } from "../schema/records";
-import type { BindingPreviewState } from "./selection";
-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;
-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;
-export declare function areOverlayDebugStatesEqual(a: EditorOverlayDebugState, b: EditorOverlayDebugState): boolean;
-export declare function getBoxDebugSummary(box: Box | null): string;
-export declare function getShapePageIdFromParentChain(shape: ShapeRecord, shapeById: ReadonlyMap<ShapeId, ShapeRecord>, pageIds: ReadonlySet<PageId>): PageId | null;
-export declare function areBindingPreviewStatesEqual(a: BindingPreviewState | null, b: BindingPreviewState | null): boolean;
-export declare function areRenderItemsEqual(a: RenderItem[], b: RenderItem[]): boolean;
-export declare function areShapeIdSetsEqual(a: Set<ShapeId>, b: Set<ShapeId>): boolean;
-export declare function getCommonShapeType(shapes: readonly ShapeRecord[]): ShapeRecord["type"] | null;
-export declare function getShapeAssetId(shape: ShapeRecord): AssetId | null;
-export declare function areSerializableValuesEqual(a: unknown, b: unknown): boolean;
-export declare function areShapePropsPatchesEqual(a: Readonly<Record<string, unknown>>, b: Readonly<Record<string, unknown>>): boolean;

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

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