@yuzhouu/canvas-kit 0.1.9 → 0.1.11

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

@@ -0,0 +1,12 @@
+import type { RichTextDocument } from "./textTypes";
+export type ShapeWideTextInlineFormat = "bold" | "italic" | "strike" | "underline";
+export type ShapeWideTextStyleProperty = "color" | "font" | "size" | "textAlign";
+export type ShapeWideTextFormatState = boolean | "mixed";
+export type ShapeWideTextBackgroundColorState = string | "mixed" | null;
+export declare function getShapeWideTextFormatState(richText: RichTextDocument, format: ShapeWideTextInlineFormat): ShapeWideTextFormatState;
+export declare function setShapeWideTextFormat(richText: RichTextDocument, format: ShapeWideTextInlineFormat, enabled: boolean): RichTextDocument;
+export declare function getShapeWideTextBackgroundColor(richText: RichTextDocument): ShapeWideTextBackgroundColorState;
+export declare function setShapeWideTextBackgroundColor(richText: RichTextDocument, backgroundColor: string | null): RichTextDocument;
+export declare function fillMissingShapeWideTextBackgroundColor(richText: RichTextDocument, backgroundColor: string): RichTextDocument;
+export declare function clearShapeWideTextStyleOverride(richText: RichTextDocument, property: ShapeWideTextStyleProperty): RichTextDocument;
+export declare function clearShapeWideTextFormatting(richText: RichTextDocument): RichTextDocument;

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

@@ -1,4 +1,5 @@
 import type { TextShapeFont } from "./textTypes";
+import type { TextTiptapEditorChangeHandler } from "./textFormatting";
 export declare const DEFAULT_TEXT_FONT: "default";
 export declare const DEFAULT_TEXT_FONT_LABEL = "Default";
 export interface TextSystemFontSource {
@@ -32,15 +33,17 @@ export interface TextFontCatalog {
     readonly fontOptions: readonly TextFontDefinition[];
     readonly fontsById: ReadonlyMap<TextShapeFont, TextFontDefinition>;
 }
-export type TextExtensionOptions = {
+export type TextPluginOptions = {
     defaultFont: TextFontDefinition;
     defaultFontLabel: string;
     fonts: readonly TextFontDefinition[];
+    formattingToolbar?: boolean;
+    onTiptapEditorChange?: TextTiptapEditorChangeHandler;
 };
 export declare const HOST_TEXT_FONT: TextFontDefinition;
-export declare function createDefaultTextExtensionOptions(): TextExtensionOptions;
+export declare function createDefaultTextPluginOptions(): TextPluginOptions;
 export declare function createDefaultTextFontCatalog(): TextFontCatalog;
-export declare function createTextFontCatalog(options: Readonly<TextExtensionOptions>): TextFontCatalog;
+export declare function createTextFontCatalog(options: Readonly<TextPluginOptions>): TextFontCatalog;
 export declare function isUsableFontId(value: unknown): value is TextShapeFont;
 export declare function isTextFontInCatalog(fontCatalog: TextFontCatalog, font: unknown): font is TextShapeFont;
 export declare function resolveTextFont(fontCatalog: TextFontCatalog, font: TextShapeFont): TextFontDefinition;

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

@@ -0,0 +1,47 @@
+import type { ShapeId } from "../canvas-core/index";
+import type { Editor as TiptapEditor } from "@tiptap/core";
+import type { TextShapeAlign, TextShapeFont, TextShapeSize } from "./textTypes";
+export type TextFormattingMixed = "mixed";
+export type TextFormattingValue<T> = T | TextFormattingMixed | null;
+export type TextFormattingTarget = "selection" | "shape";
+export type TextInlineFormat = "bold" | "italic" | "strike" | "underline";
+export interface TextFormattingSnapshot {
+    shapeId: ShapeId;
+    target: TextFormattingTarget;
+    bold: boolean | TextFormattingMixed;
+    italic: boolean | TextFormattingMixed;
+    strike: boolean | TextFormattingMixed;
+    underline: boolean | TextFormattingMixed;
+    color: TextFormattingValue<string>;
+    backgroundColor: TextFormattingValue<string>;
+    font: TextFormattingValue<TextShapeFont>;
+    size: TextFormattingValue<TextShapeSize>;
+    textAlign: TextFormattingValue<TextShapeAlign>;
+    linkHref: TextFormattingValue<string>;
+    canSetLink: boolean;
+}
+export interface TextFormattingApi {
+    readonly shapeId: ShapeId;
+    getSnapshot(): TextFormattingSnapshot | null;
+    subscribe(listener: () => void): () => void;
+    focus(): void;
+    toggle(format: TextInlineFormat): boolean;
+    setColor(color: string | null): boolean;
+    setBackgroundColor(color: string | null): boolean;
+    setFont(font: TextShapeFont | null): boolean;
+    setSize(size: TextShapeSize | null): boolean;
+    setTextAlign(align: TextShapeAlign): boolean;
+    setLink(href: string | null): boolean;
+    clearFormatting(): boolean;
+    /**
+     * Escape hatch for extensions that need native Tiptap commands. Prefer the
+     * semantic methods above so shape defaults, sanitization, and rendering stay
+     * synchronized.
+     */
+    getUnsafeTiptapEditor(): TiptapEditor | null;
+}
+export interface TextTiptapEditorHandle {
+    readonly shapeId: ShapeId;
+    readonly formatting: TextFormattingApi;
+}
+export type TextTiptapEditorChangeHandler = (handle: TextTiptapEditorHandle | null) => void;

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

@@ -0,0 +1,6 @@
+import type { Editor } from "../canvas-core/index";
+import type { TextFormattingApi, TextFormattingSnapshot } from "./textFormatting";
+export declare function activateTextFormattingSession(editor: Editor, api: TextFormattingApi): () => void;
+export declare function getActiveTextFormattingApi(editor: Editor): TextFormattingApi | null;
+export declare function getActiveTextFormattingSnapshot(editor: Editor): TextFormattingSnapshot | null;
+export declare function subscribeToTextFormattingSession(editor: Editor, listener: () => void): () => void;

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

@@ -1,13 +1,23 @@
-import type { Editor, ShapeId, ShapeRecord } from "../canvas-core/index";
+import { type Editor, type ShapeId, type ShapeParentId, type ShapeRecord, type ShapeTransformFields } from "../canvas-core/index";
 import type { TextShapeProps, TextShapeRecord } from "./textTypes";
-export declare const ARROW_LABEL_BINDING_TYPE = "arrow-label";
+export declare const PATH_LABEL_BINDING_TYPE = "path-label";
 export declare const GEO_LABEL_BINDING_TYPE = "geo-label";
-export type TextLabelBindingType = typeof ARROW_LABEL_BINDING_TYPE | typeof GEO_LABEL_BINDING_TYPE;
+export declare const PATH_LABEL_MAX_WIDTH = 120;
+export declare const PATH_LABEL_MIN_WIDTH = 24;
+export declare const PATH_LABEL_PADDING = 4.25;
+export declare const GEO_LABEL_MIN_WIDTH = 16;
+export declare const GEO_LABEL_PADDING = 16;
+export type TextLabelBindingType = typeof PATH_LABEL_BINDING_TYPE | typeof GEO_LABEL_BINDING_TYPE;
 export interface TextLabelBehavior {
     selectionTarget: "label" | "owner";
+    hoverTarget: "label" | "owner";
+    hoverDecorationTarget: "label" | "owner";
     translateTarget: "label" | "owner";
+    canSnap: boolean;
+    canReceiveTerminalBinding: boolean;
     contributesToSelectionFrame: boolean;
-    canUseSelectionFrameHandles: boolean;
+    canUseSelectionResizeHandles: boolean;
+    canUseSelectionRotateHandle: boolean;
     canPlaceCaretWhenOwnerSelected: boolean;
     showsCompanionFrameWhenOwnerSelected: boolean;
 }
@@ -17,6 +27,12 @@ export interface TextLabelTargetInfo {
     bindingType: TextLabelBindingType;
     behavior: TextLabelBehavior;
 }
+export interface TextLabelLayoutConstraints {
+    minWidth: number;
+    maxWidth: number;
+    paddingInline: number;
+}
+export declare function getTextLabelPaddingInline(constraints: TextLabelLayoutConstraints | null, width: number): number;
 export interface TextLabelCreateOptions {
     bindingType: TextLabelBindingType;
     owner: ShapeRecord;
@@ -27,14 +43,24 @@ export interface TextLabelCreateOptions {
     };
     bindingProps?: Record<string, unknown>;
 }
+export type TextLabelPageLayout = TextLabelCreateOptions["layout"];
+export declare function getTextLabelOwnerPageRotation(editor: Editor, owner: ShapeRecord): number;
+export declare function getTextLabelParentLocalTransform(editor: Editor, label: TextShapeRecord, targetParentId: ShapeParentId, pageLayout: TextLabelPageLayout): ShapeTransformFields | null;
 export declare function getTextLabelShapeForOwner(editor: Editor, ownerId: ShapeId, bindingType: TextLabelBindingType): TextShapeRecord | null;
-export declare function createBoundTextLabelShape(editor: Editor, options: TextLabelCreateOptions): TextShapeRecord;
+export declare function createBoundTextLabelShape(editor: Editor, options: TextLabelCreateOptions): TextShapeRecord | null;
 export declare function getTextLabelTargetInfo(editor: Editor, shapeId: ShapeId): TextLabelTargetInfo | null;
+export declare function getTextLabelLayoutConstraintsForOwner(editor: Editor, label: TextShapeRecord, owner: ShapeRecord, bindingType: TextLabelBindingType): TextLabelLayoutConstraints;
+export declare function getTextLabelLayoutConstraints(editor: Editor, label: TextShapeRecord): TextLabelLayoutConstraints | null;
 export declare function getTextLabelBehavior(bindingType: TextLabelBindingType): TextLabelBehavior;
 export declare function getTextLabelSelectionTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTextLabelHoverTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTextLabelHoverDecorationTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
 export declare function getTextLabelTranslateTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function textLabelCanReceiveTerminalBinding(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelCanSnap(editor: Editor, shapeId: ShapeId): boolean | null;
 export declare function textLabelContributesToSelectionFrame(editor: Editor, shapeId: ShapeId): boolean | null;
-export declare function textLabelCanUseSelectionFrameHandles(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelCanUseSelectionResizeHandles(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelCanUseSelectionRotateHandle(editor: Editor, shapeId: ShapeId): boolean | null;
 export declare function textLabelShowsCompanionFrameWhenOwnerSelected(editor: Editor, shapeId: ShapeId): boolean | null;
 export declare function canPlaceCaretInTextShapeFromSelection(editor: Editor, shapeId: ShapeId): boolean;
 export declare function startEditingTextLabel(editor: Editor, label: TextShapeRecord, options: {

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

@@ -0,0 +1,18 @@
+import { type ComponentType, type ReactNode } from "react";
+export interface TextLinkPopoverPresenterProps {
+    anchorElement: HTMLElement;
+    href: string;
+    onOpen(): void;
+    onPopoverPointerEnter(): void;
+    onPopoverPointerLeave(): void;
+}
+export type TextLinkPopoverPresenter = ComponentType<TextLinkPopoverPresenterProps>;
+export declare function TextLinkPopoverPresenterProvider({ children, presenter, }: {
+    children: ReactNode;
+    presenter: TextLinkPopoverPresenter | null;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useTextLinkPopoverPresenter(): TextLinkPopoverPresenter | null;
+export declare function shouldShowTextLinkPopover({ isEditing, isOnlySelected, }: {
+    isEditing: boolean;
+    isOnlySelected: boolean;
+}): boolean;

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

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

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

@@ -1,20 +1,24 @@
-import { Box, ShapeUtil, type ShapeId, type ShapeEditEndResult, type ShapeSelectionFrameInput, type ShapeSelectionResizeAspectRatioLockInput, type ShapeSelectionResizeInput, type ShapeSelectionTranslateInput, type ShapeUpdate } from "../canvas-core/index";
+import { Box, ShapeUtil, type ShapeId, type ShapeEditEndResult, type ShapeGeometryInput, type ShapeHoverTargetInput, type ShapeSelectionFrameInput, type ShapeSelectionResizeInput, type ShapeSelectionResizeModesInput, type ShapeSelectionTranslateInput, type ShapeUpdate } from "../canvas-core/index";
 import { type TextShapeProps, type TextShapeRecord } from "./textTypes";
 export declare class TextShapeUtil extends ShapeUtil<TextShapeRecord> {
     readonly type: "text";
     getDefaultProps(): TextShapeProps;
     validateProps(props: unknown): TextShapeProps;
-    getBounds(shape: TextShapeRecord): Box;
+    getPositionedBounds(shape: TextShapeRecord): Box;
     getLocalBounds(shape: TextShapeRecord): Box;
     getRenderBounds(shape: TextShapeRecord): Box;
     getExportBounds(shape: TextShapeRecord): Box;
-    canReceiveTerminalBinding(_shape: TextShapeRecord): boolean;
+    canSnap(shape: TextShapeRecord, input?: ShapeGeometryInput): boolean;
+    canReceiveTerminalBinding(shape: TextShapeRecord, input?: ShapeGeometryInput): boolean;
     canEdit(_shape: TextShapeRecord): boolean;
     contributesToSelectionFrame(shape: TextShapeRecord, input: ShapeSelectionFrameInput): boolean;
-    canUseSelectionFrameHandles(shape: TextShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionResizeHandles(shape: TextShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionRotateHandle(shape: TextShapeRecord, input: ShapeSelectionFrameInput): boolean;
     getSelectionTargetId(shape: TextShapeRecord, input: ShapeSelectionFrameInput): ShapeId;
+    getHoverTargetId(shape: TextShapeRecord, input: ShapeHoverTargetInput): ShapeId;
+    getHoverDecorationTargetId(shape: TextShapeRecord, input: ShapeHoverTargetInput): ShapeId;
     getTranslateTargetId(shape: TextShapeRecord, input: ShapeSelectionTranslateInput): ShapeId;
     resizeSelectionBounds(shape: TextShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
-    getSelectionResizeAspectRatioLock(_shape: TextShapeRecord, input: ShapeSelectionResizeAspectRatioLockInput): boolean | null;
+    getAllowedSelectionResizeModes(_shape: TextShapeRecord, input: ShapeSelectionResizeModesInput): readonly ["free"] | readonly ["aspect_ratio_locked"];
     onEditEnd(shape: TextShapeRecord): ShapeEditEndResult | void;
 }

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

@@ -20,6 +20,7 @@ export interface TextShapeProps {
     font: TextShapeFont;
     size: TextShapeSize;
     color: ShapeColor;
+    backgroundColor: ShapeColor;
     textAlign: TextShapeAlign;
 }
 export interface TextShapeRecord extends ShapeRecordBase<"text", TextShapeProps> {

package/_vendor/signals/core.d.ts

@@ -7,6 +7,7 @@ interface Transaction {
 export declare function getCurrentTransaction(): Transaction | null;
 export declare function transact(fn: () => void): void;
 export declare function noteInitialValue(atom: _Atom<any>, previousValue: any): void;
+export declare function isComputingSignal(): boolean;
 export declare function startCapture(child: Child): void;
 export declare function stopCapture(): Set<Signal<any>>;
 export declare function maybeCaptureParent(parent: Signal<any>): void;

package/_vendor/signals/effect.d.ts

@@ -23,7 +23,3 @@ export declare class EffectScheduler {
  * Returns a cleanup function to stop the effect.
  */
 export declare function effect(name: string, fn: () => void, opts?: EffectSchedulerOptions): () => void;
-/**
- * Alias: react() — same as effect()
- */
-export declare function react(name: string, fn: () => void, opts?: EffectSchedulerOptions): () => void;

package/_vendor/signals/index.d.ts

@@ -2,8 +2,8 @@ export { atom, isAtom } from "./atom";
 export type { Atom } from "./atom";
 export { computed, isComputed, UNINITIALIZED } from "./computed";
 export type { Computed } from "./computed";
-export { effect, react, EffectScheduler } from "./effect";
+export { effect, EffectScheduler } from "./effect";
 export type { EffectSchedulerOptions } from "./effect";
-export { transact, getGlobalEpoch } from "./core";
+export { transact, getGlobalEpoch, isComputingSignal, } from "./core";
 export { RESET_VALUE } from "./types";
 export type { Signal, Child } from "./types";

package/_vendor/store/history.d.ts

@@ -27,7 +27,7 @@ export declare class StoreHistoryBuffer<TRecord extends StoreRecord = StoreRecor
     readonly state: Signal<StoreHistoryState>;
     clear(): void;
     mark(id: string): void;
-    append(diff: RecordsDiff<TRecord>): void;
+    append(diff: RecordsDiff<TRecord>, label?: string): void;
     bailToMark(id: string): RecordsDiff<TRecord> | null;
     squashToMark(id: string, label?: string): StoreHistoryEntry<TRecord> | null;
     undo(): StoreHistoryEntry<TRecord> | null;

package/_vendor/store/store.d.ts

@@ -4,6 +4,7 @@ type StoreListener<TRecord extends StoreRecord> = (change: StoreChange<TRecord>)
 type ScopedRecord<TRecord extends StoreRecord> = Extract<TRecord, ScopedStoreRecord>;
 export declare class Store<TRecord extends StoreRecord = StoreRecord> {
     readonly recordsSignal: Atom<Map<string, TRecord>>;
+    private readonly draftRevisionSignal;
     private readonly recordSignals;
     private readonly listeners;
     private transactionDepth;
@@ -11,6 +12,8 @@ export declare class Store<TRecord extends StoreRecord = StoreRecord> {
     private pendingSource;
     constructor(initialRecords: TRecord[]);
     get(id: string): TRecord | undefined;
+    getActiveAtomicOperationRevision(): number | null;
+    getActiveAtomicOperationSnapshot(): TRecord[];
     /**
      * Per-record reactive read that still respects draft records during atomic
      * mutations. Use this inside computed values instead of wrapping `get(id)`.
@@ -22,11 +25,14 @@ export declare class Store<TRecord extends StoreRecord = StoreRecord> {
     }>>;
     listen(listener: StoreListener<TRecord>): () => void;
     atomic(fn: () => void, source?: ChangeSource): void;
+    private runAtomic;
     put(records: TRecord[], source?: ChangeSource): void;
     remove(ids: string[], source?: ChangeSource): void;
     replaceAll(records: TRecord[], source?: ChangeSource): void;
     applyDiff<TChangeRecord extends TRecord>(diff: RecordsDiff<TChangeRecord>, source?: ChangeSource): void;
     private getMutableRecords;
     private getReadableRecords;
+    private bumpDraftRevision;
+    private notifyListeners;
 }
 export {};

package/browser/indexedDb.d.ts

@@ -1,10 +1,10 @@
-export declare const LAND_DOCUMENT_INDEXEDDB_NAME = "land.canvas.persistence";
-export declare const LAND_DOCUMENT_INDEXEDDB_STORE = "snapshots";
-export declare const LAND_IMAGE_BLOB_INDEXEDDB_STORE = "imageBlobs";
-export declare const LAND_DOCUMENT_INDEXEDDB_VERSION = 2;
-export declare function openLandCanvasDatabase(): Promise<IDBDatabase | null>;
-export declare function readLandCanvasStoreValue(storeName: string, key: IDBValidKey): Promise<unknown | null>;
-export declare function readLandCanvasStoreValues(storeName: string, keys: readonly IDBValidKey[]): Promise<readonly unknown[] | null>;
-export declare function writeLandCanvasStoreValues(storeName: string, entries: readonly (readonly [IDBValidKey, unknown])[]): Promise<void>;
-export declare function deleteLandCanvasStoreValue(storeName: string, key: IDBValidKey): Promise<void>;
-export declare function getAllLandCanvasStoreKeys(storeName: string): Promise<IDBValidKey[] | null>;
+export declare const CANVAS_KIT_INDEXEDDB_NAME = "canvas-kit.persistence";
+export declare const CANVAS_KIT_SNAPSHOT_STORE = "snapshots";
+export declare const CANVAS_KIT_IMAGE_BLOB_STORE = "imageBlobs";
+export declare const CANVAS_KIT_INDEXEDDB_VERSION = 2;
+export declare function openCanvasKitDatabase(): Promise<IDBDatabase | null>;
+export declare function readCanvasKitStoreValue(storeName: string, key: IDBValidKey): Promise<unknown | null>;
+export declare function readCanvasKitStoreValues(storeName: string, keys: readonly IDBValidKey[]): Promise<readonly unknown[] | null>;
+export declare function writeCanvasKitStoreValues(storeName: string, entries: readonly (readonly [IDBValidKey, unknown])[]): Promise<void>;
+export declare function deleteCanvasKitStoreValue(storeName: string, key: IDBValidKey): Promise<void>;
+export declare function getAllCanvasKitStoreKeys(storeName: string): Promise<IDBValidKey[] | null>;

package/browser/persistence.d.ts

@@ -1,44 +1,12 @@
-import type { Editor, StoreSnapshot } from "../_vendor/canvas-core/index";
-import type { ProductPersistenceAdapter } from "../core/runtime/productDefinition";
-import { type PersistedEditorSnapshots } from "./localSnapshotRestore";
-import { LAND_DOCUMENT_INDEXEDDB_NAME, LAND_DOCUMENT_INDEXEDDB_STORE, LAND_DOCUMENT_INDEXEDDB_VERSION, LAND_IMAGE_BLOB_INDEXEDDB_STORE } from "./indexedDb";
-export declare const LAND_DOCUMENT_STORAGE_KEY = "land.canvas.document";
-export declare const LAND_SESSION_STORAGE_KEY = "land.canvas.session";
-export { LAND_DOCUMENT_INDEXEDDB_NAME, LAND_DOCUMENT_INDEXEDDB_STORE, LAND_DOCUMENT_INDEXEDDB_VERSION, LAND_IMAGE_BLOB_INDEXEDDB_STORE, };
+import type { ProductPersistenceAdapter, ProductPersistenceLoadResult } from "../core/runtime/runtimeContracts";
+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";
+export { CANVAS_KIT_IMAGE_BLOB_STORE, CANVAS_KIT_INDEXEDDB_NAME, CANVAS_KIT_INDEXEDDB_VERSION, CANVAS_KIT_SNAPSHOT_STORE, };
 export interface LocalSnapshotPersistenceOptions {
     storageNamespace?: string;
 }
 export declare function createLocalSnapshotPersistence(options?: LocalSnapshotPersistenceOptions): ProductPersistenceAdapter;
-export declare class PersistenceManager {
-    private readonly editor;
-    private static readonly SAVE_DELAY_MS;
-    private readonly getDocumentSnapshot;
-    private readonly options;
-    private unsubscribe;
-    private saveTimeoutId;
-    private hasPendingSave;
-    private isSaving;
-    private saveAgainAfterCurrentSave;
-    constructor(editor: Editor, { getDocumentSnapshot, options, }?: {
-        getDocumentSnapshot?: () => StoreSnapshot<{
-            id: string;
-        }>;
-        options?: LocalSnapshotPersistenceOptions;
-    });
-    start(): void;
-    stop(): void;
-    flush(): void;
-    private save;
-    private scheduleSave;
-    private cancelScheduledSave;
-    private readonly flushWhenHidden;
-    private readonly flushWhenPageIsLeaving;
-}
-export declare function persistEditorSnapshot(editor: Editor, options?: LocalSnapshotPersistenceOptions, { documentSnapshot, }?: {
-    documentSnapshot?: StoreSnapshot<{
-        id: string;
-    }>;
-}): Promise<void>;
-export declare function readPersistedEditorSnapshots(options?: LocalSnapshotPersistenceOptions): Promise<PersistedEditorSnapshots>;
+export declare function readPersistedEditorSnapshots(options?: LocalSnapshotPersistenceOptions): Promise<ProductPersistenceLoadResult>;
 export declare function readPersistedDocumentSnapshot(): Promise<unknown | null>;
 export declare function readPersistedSessionSnapshot(): Promise<unknown | null>;

package/chrome/floating/CanvasKitFloatingPortal.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from "react";
+export declare function CanvasKitFloatingPortalProvider({ children, }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function CanvasKitFloatingPortalHost(): import("react/jsx-runtime").JSX.Element;
+export declare function useCanvasKitFloatingPortalTarget(): HTMLDivElement | null;

package/chrome/floating/useCanvasKitFloatingPosition.d.ts

@@ -0,0 +1,11 @@
+import { type RefObject } from "react";
+import { type Placement, type ReferenceElement } from "@floating-ui/dom";
+import { type Editor } from "../../_vendor/canvas-core/index";
+export declare function useCanvasKitFloatingPosition({ editor, fallbackPlacements, floatingRef, getReferenceElement, offset, placement, }: {
+    editor: Editor;
+    fallbackPlacements: readonly Placement[];
+    floatingRef: RefObject<HTMLElement | null>;
+    getReferenceElement(): ReferenceElement | null;
+    offset?: number;
+    placement: Placement;
+}): void;

package/chrome/toolbar/CanvasKitFloatingToolbarLayer.d.ts

@@ -3,4 +3,4 @@ export declare function CanvasKitFloatingToolbarLayer({ children, className, dat
     children: ReactNode;
     className?: string;
     dataUi?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").ReactPortal | null;

package/chrome/toolbar/FloatingSelectionToolbarPageSpace.d.ts

@@ -1,9 +1,11 @@
 import { type ReactNode } from "react";
-import type { ToolbarSurfaces } from "./useToolbarSurfaces";
-export declare function FloatingSelectionToolbarPageSpace({ children, className, dataUi, offset, surfaces, }: {
+import type { CanvasActionContext } from "../../_vendor/canvas-plugin-sdk/index";
+export declare function FloatingSelectionToolbarPageSpace({ children, className, context, dataUi, horizontalAlign, offset, visible, }: {
     children: ReactNode;
     className?: string;
+    context: CanvasActionContext;
     dataUi?: string;
+    horizontalAlign?: "center" | "start";
     offset?: number;
-    surfaces: ToolbarSurfaces;
+    visible?: boolean;
 }): import("react/jsx-runtime").JSX.Element | null;

package/chrome/toolbar/toolbarLabels.d.ts

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

package/chrome/toolbar/useToolbarSurfaces.d.ts

@@ -1,26 +1,21 @@
-import type { Editor, CanvasActionContext, ToolbarGroup } from "../../_vendor/canvas-core/index";
-import type { CanvasRenderPluginHostRuntime } from "../../_vendor/canvas-react/host/index";
-export interface FloatingSelectionToolbarPageAnchor {
-    x: number;
-    y: number;
-}
+import { type CanvasActionContext, type CanvasToolbarRegistry, type ToolbarChannel, type ToolbarGroup, type ToolbarSurface } from "../../_vendor/canvas-plugin-sdk/index";
+import { type Editor } from "../../_vendor/canvas-core/index";
 export interface ToolbarSurfaces {
     context: CanvasActionContext;
+    channels: readonly ToolbarChannel[];
+    getGroups(channel: ToolbarChannel): readonly ToolbarGroup[];
+    isSurfaceActive(surface: ToolbarSurface): boolean;
     activeToolId: string;
     activeToolLabel: string;
     isToolLocked: boolean;
+    isEditing: boolean;
+    canShowPropertiesDuringEditing: boolean;
     selectionCount: number;
     hasMixedSelectionRotation: boolean;
-    toolChromeToolbarGroups: readonly ToolbarGroup[];
-    contextToolbarGroups: readonly ToolbarGroup[];
-    floatingSelectionToolbarGroups: readonly ToolbarGroup[];
-    floatingSelectionToolbarPageAnchor: FloatingSelectionToolbarPageAnchor | null;
-    contextToolbarTitle: string;
-    showContextToolbar: boolean;
-    showFloatingSelectionToolbar: boolean;
+    selectionLabel: string;
 }
-export declare function useToolbarSurfaces({ canShowContextToolbarDuringEditing, editor, pluginHostRuntime, }: {
-    canShowContextToolbarDuringEditing?: (context: CanvasActionContext) => boolean;
+export declare function useToolbarSurfaces({ canShowPropertiesDuringEditing, editor, toolbarRegistry, }: {
+    canShowPropertiesDuringEditing?: (context: CanvasActionContext) => boolean;
     editor: Editor;
-    pluginHostRuntime: CanvasRenderPluginHostRuntime;
+    toolbarRegistry: CanvasToolbarRegistry;
 }): ToolbarSurfaces;

package/chrome/types.d.ts

@@ -1,21 +1,23 @@
-import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
-import type { BuiltInCanvasLayerNode } from "../builtins";
-import type { ActiveContextMenu, EditorSelectionState, ShapeId, CanvasActionValue, CanvasActionContext } from "../_vendor/canvas-core/index";
+import { type ActiveContextMenu, type CanvasActionContext, type CanvasActionValue } from "../_vendor/canvas-plugin-sdk/index";
+import type { CanvasKitBaseController, CanvasKitController } from "../controller/canvasKitController";
+import type { CanvasProductLayerNode } from "../core";
+import type { EditorSelectionMetadata, ShapeId } from "../_vendor/canvas-core/index";
 import type { HistoryControls } from "./useHistoryControls";
 import type { PageControls } from "./usePageControls";
 import type { ZoomControlsState } from "./useZoomControls";
 import type { ContextMenuSurface } from "./useContextMenuSurface";
-import type { SvgExportControls } from "./useSvgExport";
+import type { CanvasExportApi } from "../_vendor/plugin-builtin-export/index";
 import type { ToolbarSurfaces } from "./toolbar/useToolbarSurfaces";
-import type { ProductPersistenceStatus } from "../core";
-export type { ContextMenuCommandItem, ContextMenuItem, ContextMenuSection, EditorSelectionState, ShapeId, CanvasActionValue, CanvasActionContext, ToolbarGroup, ToolbarItem, } from "../_vendor/canvas-core/index";
+import type { ChromeSurfaces } from "./useChromeSurfaces";
+export type { EditorSelectionMetadata, EditorSelectionState, ShapeId, } from "../_vendor/canvas-core/index";
+export type { CanvasActionContext, CanvasActionValue, ChromeCommandItem, ChromeItem, ChromeSection, ContextMenuCommandItem, ContextMenuItem, ContextMenuSection, ToolbarGroup, ToolbarItem, } from "../_vendor/canvas-plugin-sdk/index";
 export type { HistoryControls } from "./useHistoryControls";
 export type { PageControls } from "./usePageControls";
 export type { ZoomControlsState } from "./useZoomControls";
 export type { ContextMenuSurface } from "./useContextMenuSurface";
-export type { SvgExportControls, } from "./useSvgExport";
 export type { ToolbarSurfaces, } from "./toolbar/useToolbarSurfaces";
-export type CanvasKitLayerNode = BuiltInCanvasLayerNode;
+export type { ChromeSurfaces } from "./useChromeSurfaces";
+export type CanvasKitLayerNode = CanvasProductLayerNode;
 export interface CanvasKitToolbarActionState {
     value: CanvasActionValue | undefined;
     isEnabled: boolean;
@@ -36,27 +38,23 @@ export interface CanvasKitGridControls {
     isVisible: boolean;
     setIsVisible(isVisible: boolean): void;
 }
-export interface CanvasKitPersistenceControls {
-    discardUnsupportedRecords: (() => Promise<void>) | null;
-    isDiscardingUnsupportedRecords: boolean;
-    status: ProductPersistenceStatus | null;
-}
 export interface CanvasKitLayerTreeSource {
-    getSnapshot(pageId?: string): readonly BuiltInCanvasLayerNode[];
+    getSnapshot(pageId?: string): readonly CanvasProductLayerNode[];
     subscribe(onStoreChange: () => void): () => void;
 }
 export interface CanvasKitChromeContext<TController extends CanvasKitBaseController = CanvasKitController> {
     controller: TController;
+    chromeSurfaces: ChromeSurfaces;
     contextMenu: CanvasKitContextMenuState;
     currentPageId: string;
     currentPageShapeIds: readonly ShapeId[];
+    sessionMeta: Readonly<Record<string, unknown>>;
     history: HistoryControls;
     layerTree: CanvasKitLayerTreeSource;
     pages: PageControls;
-    selection: EditorSelectionState;
+    selection: EditorSelectionMetadata;
     selectedShapeIds: readonly ShapeId[];
-    persistence: CanvasKitPersistenceControls;
-    svgExport: SvgExportControls;
+    exportApi: CanvasExportApi;
     toolbarRuntime: CanvasKitToolbarRuntime;
     toolbarSurfaces: ToolbarSurfaces;
     grid: CanvasKitGridControls;

package/chrome/useCanvasKitChromeContext.d.ts

@@ -1,21 +1,18 @@
-import { type RefObject } from "react";
-import { type ActiveContextMenu } from "../_vendor/canvas-core/index";
+import { type ActiveContextMenu, type CanvasActionContext, type CanvasActionRegistry, type CanvasChromeRegistry, type CanvasContextMenuRegistry, type CanvasToolbarRegistry } from "../_vendor/canvas-plugin-sdk/index";
+import { type Editor } from "../_vendor/canvas-core/index";
 import type { CanvasKitBaseController } from "../controller/canvasKitController";
-import type { CanvasKitRuntime } from "../runtime/canvasKitRuntime";
-import type { CanvasKitChromeSlot, CanvasKitHostFeature } from "../runtime/canvasKitHostContracts";
-import type { ProductApiRegistry, ProductServiceRegistry } from "../core";
-import type { CanvasKitChromeContext, CanvasKitGridControls, CanvasKitPersistenceControls } from "./types";
-export declare function useCanvasKitChromeContext<TController extends CanvasKitBaseController>({ apis, controller, activeContextMenu, chromeSlots, editor, grid, hostFeatures, onActiveContextMenuChange, persistence, pluginHostRuntime, services, themeRootRef, }: {
-    apis: ProductApiRegistry;
+import type { ExecuteCanvasKitCommand } from "../runtime/canvasKitCommandExecutor";
+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;
     activeContextMenu: ActiveContextMenu | null;
-    chromeSlots: readonly CanvasKitChromeSlot<string, unknown>[];
-    editor: CanvasKitRuntime["editor"];
     grid: CanvasKitGridControls;
-    hostFeatures: readonly CanvasKitHostFeature[];
     onActiveContextMenuChange: (activeContextMenu: ActiveContextMenu | null) => void;
-    persistence: CanvasKitPersistenceControls;
-    pluginHostRuntime: CanvasKitRuntime["pluginHostRuntime"];
-    services: ProductServiceRegistry;
-    themeRootRef: RefObject<HTMLElement | null>;
+    actionRegistry: CanvasActionRegistry;
+    canShowPropertiesDuringEditing(context: CanvasActionContext): boolean;
+    chromeRegistry: CanvasChromeRegistry;
+    contextMenuRegistry: CanvasContextMenuRegistry;
+    editor: Editor;
+    executeCommand: ExecuteCanvasKitCommand;
+    toolbarRegistry: CanvasToolbarRegistry;
 }): CanvasKitChromeContext<TController>;

package/chrome/useChromeSurfaces.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasActionContext, CanvasChromeRegistry, ChromeChannel, ChromeSection } from "../_vendor/canvas-plugin-sdk/index";
+import type { Editor } from "../_vendor/canvas-core/index";
+export interface ChromeSurfaces {
+    context: CanvasActionContext;
+    channels: readonly ChromeChannel[];
+    getSections(channel: ChromeChannel): readonly ChromeSection[];
+}
+export declare function useChromeSurfaces({ context, editor, registry, }: {
+    context: CanvasActionContext;
+    editor: Editor;
+    registry: CanvasChromeRegistry;
+}): ChromeSurfaces;

package/chrome/useContextMenuSurface.d.ts

@@ -1,12 +1,12 @@
-import type { ContextMenuContext, ActiveContextMenu, ContextMenuSection, Editor } from "../_vendor/canvas-core/index";
-import type { CanvasRenderPluginHostRuntime } from "../_vendor/canvas-react/host/index";
+import { type ActiveContextMenu, type CanvasContextMenuRegistry, type ContextMenuContext, type ContextMenuSection } from "../_vendor/canvas-plugin-sdk/index";
+import type { Editor } from "../_vendor/canvas-core/index";
 export interface ContextMenuSurface {
     context: ContextMenuContext | null;
     activeContextMenu: ActiveContextMenu | null;
     sections: readonly ContextMenuSection[];
 }
-export declare function useContextMenuSurface({ editor, activeContextMenu, pluginHostRuntime, }: {
+export declare function useContextMenuSurface({ editor, activeContextMenu, contextMenuRegistry, }: {
     editor: Editor;
     activeContextMenu: ActiveContextMenu | null;
-    pluginHostRuntime: CanvasRenderPluginHostRuntime;
+    contextMenuRegistry: CanvasContextMenuRegistry;
 }): ContextMenuSurface;

package/chrome/useHistoryControls.d.ts

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