@yuzhouu/canvas-kit 0.1.13 → 0.1.14

package/README.md

@@ -1,288 +1,76 @@
-# @land/canvas-kit
+# @yuzhouu/canvas-kit
 
-CanvasKit is the public composition root for the Land canvas. It compiles one graph of `CanvasPlugin` objects and nested plugin groups to assemble an isolated Runtime, then exposes a controller-oriented API without exposing Editor, services, registries, or private render data.
+CanvasKit is Land's plugin-agnostic canvas runtime and React host. It has no concrete first-party plugin dependencies or plugin API reexports; predefined first-party composition lives exclusively in `@yuzhouu/canvas-standard`.
 
-## React usage
+It owns plugin activation, persistence, imports, exports, lifecycle, the grouped public CanvasKit facade, and its fine-grained observable state. It does not own a toolbar, context-menu, or Chrome UI DSL.
 
-Keep the options object stable. The hook uses reference identity to decide when to replace a Runtime.
-
-```tsx
-import {
-  CanvasKitRoot,
-  useCanvasKitRuntime,
-  type CanvasKitRuntimeOptions,
-} from "@land/canvas-kit";
-
-const RUNTIME_OPTIONS: CanvasKitRuntimeOptions = {
-  id: "my-canvas",
-  storageNamespace: "my-app.canvas",
-};
-
-export function App() {
-  const state = useCanvasKitRuntime(RUNTIME_OPTIONS);
-
-  if (state.status === "error") throw state.error;
-  if (state.status !== "ready") return null;
-
-  return (
-    <CanvasKitRoot
-      runtime={state.runtime}
-      onControllerReady={(controller) => {
-        controller.setTool("select");
-      }}
-    />
-  );
-}
-```
-
-Use a module-level constant or `useMemo` for `CanvasKitRuntimeOptions`. An inline object creates and disposes a Runtime after every render.
-
-## Imperative usage
-
-The creator owns the complete lifecycle:
-
-```tsx
-import { createRoot } from "react-dom/client";
-import {
-  CanvasKitRoot,
-  createCanvasKitRuntime,
-} from "@land/canvas-kit";
-
-const runtime = createCanvasKitRuntime({ persistence: null });
-const startup = await runtime.start();
-
-const root = createRoot(document.getElementById("app")!);
-root.render(<CanvasKitRoot runtime={runtime} />);
-
-// Later:
-root.unmount();
-runtime.dispose();
-```
-
-One Runtime can be mounted by only one `CanvasKitRoot` at a time. `CanvasKitRoot` requires a ready Runtime and never calls `start()` or `dispose()`.
-
-## Runtime options
-
-```ts
-interface CanvasKitRuntimeOptions {
-  id?: string;
-  chrome?: CanvasKitChromeRenderer;
-  documentMeta?: Record<string, unknown>;
-  persistence?: ProductPersistenceAdapter | null;
-  seedDocument?: CanvasKitDocumentSeed;
-  shouldSkipStoredSnapshots?: () => boolean;
-  plugins?: readonly CanvasPluginInput[];
-  storageNamespace?: string;
-}
-```
-
-Controller callbacks, window exposure, and `windowKey` are mount concerns and
-belong on `CanvasKitRoot`. Export appearance is supplied to each export request;
-it is not stored on the Root or Runtime.
-
-`plugins` is the complete caller-supplied plugin graph. Before compiling it,
-CanvasKit adds Runtime default providers for clipboard behavior, import host,
-generic tool actions, and the export API only when the graph does not already
-provide the corresponding capability token. A plugin that provides
-`canvasClipboardRuntimeCapability`, `canvasToolActionsCapability`, or
-`canvasExportApiToken` therefore replaces that default implementation. Runtime
-defaults and caller plugins use the same `CanvasPlugin` contract and compile
-into one dependency graph.
-
-CanvasKit-specific import, keyboard, and tool-action defaults live with the
-composition root under `src/plugins/runtime`. Reusable clipboard and export
-capabilities remain independent Runtime plugin packages. Physical ownership
-does not change capability replacement semantics.
-
-## Startup result
-
-`runtime.start()` is single-flight and idempotent. It returns:
-
-```ts
-interface CanvasKitStartupResult {
-  documentSource: "restored" | "seeded" | "empty";
-  sessionRestored: boolean;
-  warnings: readonly unknown[];
-}
-```
-
-Startup loads snapshots, resets to a clean document/session, restores the document or seeds after a clean fallback, restores session state, clears history, prepares assets, runs `beforeReady`, and starts Runtime-owned persistence coordination. Recoverable load/restore/asset/hook errors are returned in `warnings`. Synchronous assembly and seed failures are fatal.
-
-Disposal aborts startup and unwinds one Runtime-owned disposer stack in reverse creation order. Persistence, plugin setup resources, Editor, and services all enter that stack. A disposed Runtime cannot restart.
-
-## Persistence adapter
-
-Persistence is IO-only; Runtime owns restore and seed ordering.
-
-```ts
-interface ProductPersistenceAdapter {
-  load?(options: {
-    signal: AbortSignal;
-  }): Promise<{
-    documentSnapshot: unknown | null;
-    sessionSnapshot: unknown | null;
-  }>;
-  saveDocument?(snapshot: DocumentSnapshot): Promise<void>;
-  saveSession?(snapshot: SessionSnapshot): Promise<void>;
-}
-```
-
-Runtime captures document state from operation commits, captures session state
-independently, applies trailing debounce, retries transient write failures, and
-passes immutable snapshots to the adapter. When no document snapshot exists,
-`seedDocument` runs once. Session restore happens after seed so persisted camera
-and selection state win.
-
-## Plugin authoring
-
-Use `defineCanvasPlugin()` and pass plugins or nested plugin groups through Runtime options:
+## Standard composition
 
 ```ts
 import {
-  createProductServiceToken,
-  createStandardCanvasKitPlugins,
-  defineCanvasPlugin,
-  type CanvasKitRuntimeOptions,
-} from "@land/canvas-kit";
-
-const analyticsToken = createProductServiceToken<{ track(name: string): void }>(
-  "example.analytics",
+  createStandardCanvasKitProfile,
+} from "@yuzhouu/canvas-standard";
+import { CanvasKitRoot } from "@yuzhouu/canvas-kit";
+
+const profile = createStandardCanvasKitProfile();
+root.render(
+  <CanvasKitRoot
+    actions={profile.actions}
+    options={{ plugins: profile.plugins, persistence: null }}
+  />,
 );
-
-const analyticsPlugin = defineCanvasPlugin({
-  id: "example.analytics",
-  provides: [analyticsToken],
-  setup(context) {
-    const analytics = context.services.add({
-      token: analyticsToken,
-      create: () => ({ track: console.log }),
-    });
-    context.actions.add({
-      id: "example.track",
-      run: () => analytics.track("canvas-action"),
-    });
-  },
-});
-
-const reportingPlugin = defineCanvasPlugin({
-  id: "example.reporting",
-  requires: [analyticsToken],
-  setup(context) {
-    context.services.get(analyticsToken)?.track("runtime-ready");
-  },
-});
-
-const options: CanvasKitRuntimeOptions = {
-  plugins: [
-    createStandardCanvasKitPlugins(),
-    [analyticsPlugin, reportingPlugin],
-  ],
-};
 ```
 
-`CanvasPlugin` has optional `editor`, `render`, and `setup` entries. `requires` lives at the plugin top level, so one dependency order applies to editor/render creation and setup installation. Depend on a plugin object when the whole extension must exist; depend on a typed API, service, or value capability token when only that cross-plugin contract matters. Providers declare those tokens in `provides` and register the matching implementation during setup. Raw `{ id }` dependency objects are rejected.
-
-Nested arrays are groups only; they do not need IDs and are flattened in declaration order. Optional features are included or omitted explicitly.
+`CanvasKitRoot` exclusively creates and disposes one private Runtime for its component lifetime. Its `onCanvasChange` callback and Chrome renderer receive a borrowed `CanvasKit` without `dispose()`. Root installs `CanvasKitProvider` without accessing Editor directly; the private Canvas render host owns `EditorContext` around the internal Canvas tree. There is no public standalone Runtime factory.
 
-Runtime creation compiles the graph, creates Editor and the Runtime resource owner, runs each setup once in dependency order, then seals all registries. Sealing validates duplicate IDs and action references, materializes registered APIs, and prevents later registration.
-
-Connector and Packaging are composed outside CanvasKit and are intentionally
-absent from the standard plugin profile. Products that need them depend on their
-plugin packages and add them explicitly:
+## Minimal actions
 
 ```ts
-import {
-  createStandardCanvasKitPlugins,
-  type CanvasKitRuntimeOptions,
-} from "@land/canvas-kit";
-import { Connector } from "@land/plugin-connector";
-import { Packaging } from "@land/plugin-packaging";
-
-const options: CanvasKitRuntimeOptions = {
-  plugins: [Connector, createStandardCanvasKitPlugins(), Packaging],
-};
+interface CanvasAction {
+  id: string;
+  shortcut?: KeyboardShortcut | readonly KeyboardShortcut[];
+  isEnabled(canvas: CanvasKit): boolean;
+  run(canvas: CanvasKit): void | Promise<void>;
+}
 ```
 
-`setup(context)` installs capabilities through focused registrars:
+CanvasKit owns shortcut matching and `applyCanvasActionShortcutOverrides()`, but
+does not install default product bindings. Profiles apply overrides while
+composing their final action arrays; `null` disables a default binding. Actions
+remain a `CanvasKitRoot` prop and never enter Runtime options.
 
-- `actions`, `toolbar`, `contextMenu`, and `apis`
-- `services`
-- `assets`
-- `ui`
-- `lifecycle.beforeReady()`, `lifecycle.beforeCommand()`, and `lifecycle.defer()`
+Toolbar and menu components import or close over actual action objects. They do not reference them through an action ID registry.
 
-`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
-not depend on the standard profile installing a Tool action provider.
-Components share one props contract and render between Canvas and chrome; there
-are no component slots.
-
-## Public controller
-
-External code should work through `runtime.controller` or the controller supplied to `onControllerReady`. The controller exposes document, selection, page, tool, camera, layer, history, export, 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";
+```tsx
+const duplicate: CanvasAction = {
+  id: "my-product.duplicate",
+  shortcut: { key: "d", accelKey: true },
+  isEnabled: (canvas) => canvas.selection.state.getSnapshot().count > 0,
+  run: (canvas) => canvas.selection.duplicate(),
+};
 
-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.
-        }
-      });
-  },
-});
+function SelectionToolbar() {
+  const canvas = useCanvasKit();
+  const selection = useCanvasValue(canvas.selection.state);
+  return (
+    <button
+      disabled={selection.count === 0}
+      onClick={() => duplicate.run(canvas)}
+    >
+      Duplicate
+    </button>
+  );
+}
 ```
 
-### Export API
+## Product-owned Chrome
 
-SVG and PNG export are async registered APIs so resource preparation and
-embedding complete before a result is returned:
+Pass a `chromeRenderer` to `CanvasKitRoot`. The renderer receives the same `CanvasKit` available from `useCanvasKit()`. Product components subscribe only to the capability they render, for example `useCanvasValue(canvas.pages.state)` or `useCanvasValue(canvas.history.state)`.
 
-```ts
-import { canvasExportApiToken } from "@land/canvas-kit";
+Zen and Professional build separate React trees and CSS from that facade. Feature controls call `canvas.api(token)` directly. Packaging UI therefore remains in Professional, while Connector is part of the standard plugin graph.
 
-const exportApi = runtime.controller.apis.get(canvasExportApiToken);
-if (!exportApi) throw new Error("Canvas export API is unavailable.");
-
-const pagePng = await exportApi.exportPng({
-  appearance: {
-    resolveThemeColor(token, fallback) {
-      return currentTheme.tokens[token] ?? fallback;
-    },
-  },
-  scope: "page",
-  pixelRatio: 2,
-});
-const selectedSvg = await exportApi.exportSvg({ scope: "selection" });
-const customSvg = await exportApi.exportSvg({ shapeIds: [shapeId] });
-```
+## Plugins and React composition
 
-`exportPng()` resolves with an `image/png` Blob and `exportSvg()` resolves with
-a self-contained SVG string when export succeeds. The API deliberately exposes
-no loading state; callers own pending-state presentation around the returned
-Promise. SVG and PNG share one internal lock and reject a concurrent export.
-When `appearance.resolveThemeColor` is omitted, core color fallbacks are used.
+Runtime plugins own editor/render facets, one direct API value, import/export/asset contributions, and cleanup. `CanvasKitRoot` directly owns the generic keyboard and import browser integration. Products wrap the Root with their own React providers and pass actions/Chrome as ordinary props; Runtime plugins do not register product UI.
 
-## Styles
-
-The package root imports its base styles. Published consumers may also use the explicit stylesheet export when their bundler requires it:
-
-```ts
-import "@land/canvas-kit/style.css";
-```
+The runtime is static after creation: plugins are ordered once, set up once, and disposed in reverse lifetime order. Third-party product UI injection is intentionally unsupported until a concrete use case justifies a small actions facet.

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

@@ -0,0 +1,33 @@
+import type { ChangeSource } from "../../store/index";
+import { type BindingId, type BindingRecord, type ShapeId, type ShapeRecord } from "../schema/records";
+import type { Editor } from "../editor/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 interface ShapeChangeEntry {
+    before: ShapeRecord;
+    after: ShapeRecord;
+}
+export declare class BindingManager {
+    private readonly editor;
+    private suppressedReactionIds;
+    constructor(editor: Editor);
+    getSuppressedReactionIds(): ReadonlySet<BindingId>;
+    runWithSuppressedReactions<T>(bindingIds: Iterable<BindingId>, callback: () => T, ..._synchronousCallbackGuard: SynchronousCallbackGuard<T>): T;
+    getConflictingBindings(binding: BindingRecord): BindingRecord[];
+    canBind(binding: BindingRecord): boolean;
+    syncCreatedBinding(binding: BindingRecord, source: ChangeSource): void;
+    syncUpdatedBinding(before: BindingRecord, after: BindingRecord, source: ChangeSource): void;
+    repairLoadedBindings(source: ChangeSource): void;
+    handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource): void;
+    getShapeCompanionRootId(shapeId: ShapeId): ShapeId;
+    getShapeCompanionRootIds(shapeIds: readonly ShapeId[], bindings?: readonly BindingRecord[]): ReadonlyMap<ShapeId, ShapeId>;
+    getShapeCompanionMemberIds(shapeIds: readonly ShapeId[]): ShapeId[];
+    cleanupBindingsForDeletedShapes(ids: ShapeId[], source: ChangeSource): void;
+    cleanupBindings(ids: BindingId[], source: ChangeSource): void;
+    private applyEffect;
+    private syncShapeCompanionState;
+    private getShapeCompanionContext;
+    private getAllBindings;
+    private getExclusiveBindingKey;
+}
+export {};

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

@@ -1,5 +1,5 @@
 import type { Editor } from "../editor/editor";
-import type { SelectionOverlayFrameGeometryState } from "../editor/selection";
+import type { SelectionOverlayFrameGeometryState } from "../editor/selection/selection";
 import type { Vec } from "../geometry/vec";
 import type { BindingId, BindingRecord, BindingRecordBase, ShapeRecord } from "../schema/records";
 export interface BindingUtilEffect {
@@ -50,11 +50,11 @@ export declare abstract class BindingUtil<B extends BindingRecordBase = BindingR
     onBeforeDeleteBinding?(editor: Editor, binding: B): BindingUtilEffect | void;
     getExportShapeIds?(editor: Editor, binding: B): ShapeRecord["id"][];
     /**
-     * Map a hierarchy companion (for example, a bound label) to the shape that
-     * owns its group lifecycle and selection semantics.
+     * Map a companion shape (for example, a bound label) to the owner shape that
+     * controls its grouping lifecycle and selection semantics.
      */
-    getShapeHierarchyRootId?(binding: B, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
-    canUseShapeHierarchy?(binding: B, context: BindingEndpointContext): boolean;
+    getShapeCompanionRootId?(binding: B, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
+    canUseShapeCompanion?(binding: B, context: BindingEndpointContext): boolean;
     getGeometryDependentShapeIds?(editor: Editor, binding: B, context: BindingShapeGeometryDependencyContext): ShapeRecord["id"][];
     /**
      * Return polygons in the target shape's local space that should be removed
@@ -65,5 +65,5 @@ export declare abstract class BindingUtil<B extends BindingRecordBase = BindingR
     getTargetShapeContentCutoutLocalPolygons?(editor: Editor, binding: B, context: BindingTargetShapeContentCutoutContext): readonly (readonly Vec[])[];
     getSelectionCompanionFrameGeometries?(editor: Editor, binding: B, context: BindingSelectionCompanionFrameContext): SelectionOverlayFrameGeometryState[];
 }
-export declare function resolveShapeHierarchyRootId(shapeId: ShapeRecord["id"], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ShapeRecord["id"];
-export declare function resolveShapeHierarchyRootIds(shapeIds: readonly ShapeRecord["id"][], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ReadonlyMap<ShapeRecord["id"], ShapeRecord["id"]>;
+export declare function resolveShapeCompanionRootId(shapeId: ShapeRecord["id"], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ShapeRecord["id"];
+export declare function resolveShapeCompanionRootIds(shapeIds: readonly ShapeRecord["id"][], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ReadonlyMap<ShapeRecord["id"], ShapeRecord["id"]>;

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

@@ -1,6 +1,6 @@
 import { Vec } from "../geometry/vec";
 import type { Editor } from "../editor/editor";
-import type { BindingPreviewState } from "../editor/selection";
+import type { BindingPreviewState } from "../editor/selection/selection";
 import type { ShapeId } from "../schema/records";
 export interface ConnectionPoint {
     x: number;

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

@@ -0,0 +1,6 @@
+import type { Editor } from "./editor";
+import type { AssetId, AssetRecord, ShapeRecord } from "../schema/records";
+export declare function getClipboardAssets(editor: Editor, shapes: readonly ShapeRecord[]): AssetRecord[];
+export declare function remapAssetIdsInRecord(record: object, assetIdMap: ReadonlyMap<AssetId, AssetId>): Record<string, unknown>;
+export declare function cloneRecordObject(value: object): Record<string, unknown>;
+export declare function cloneSerializableRecord<T>(value: T): T;

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

@@ -0,0 +1,7 @@
+import type { AssetId, AssetRecord } from "../../schema/records";
+import type { CreateAssetInput, EditorCommandOptions, UpdateAssetInput } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function createAsset(editor: Editor, input: CreateAssetInput, options?: EditorCommandOptions): AssetRecord;
+export declare function createAssetsFromRecords(editor: Editor, records: AssetRecord[], options?: EditorCommandOptions): AssetRecord[];
+export declare function updateAsset(editor: Editor, input: UpdateAssetInput, options?: EditorCommandOptions): AssetRecord | null;
+export declare function deleteAsset(editor: Editor, id: AssetId, options?: EditorCommandOptions): boolean;

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

@@ -0,0 +1,12 @@
+import type { ChangeSource } from "../../../store/index";
+import type { BindingId, BindingRecord, ShapeId } from "../../schema/records";
+import type { CreateBindingInput, EditorCommandOptions, UpdateBindingInput } from "./commandTypes";
+import type { Editor } from "../editor";
+type RepairMinimumChildContainers = (containerIds: Iterable<ShapeId>, deletedIds: Set<ShapeId>, source: ChangeSource) => void;
+interface BindingCommandSet {
+    createBinding(input: CreateBindingInput, options?: EditorCommandOptions): BindingRecord;
+    updateBinding(input: UpdateBindingInput, options?: EditorCommandOptions): BindingRecord | null;
+    deleteBinding(id: BindingId, options?: EditorCommandOptions): boolean;
+}
+export declare function createBindingCommandSet(editor: Editor, repairMinimumChildContainers: RepairMinimumChildContainers): BindingCommandSet;
+export {};

package/_vendor/canvas-core/editor/{commands.d.ts → commands/commandTypes.d.ts}

@@ -1,9 +1,9 @@
-import type { Editor } from "./editor";
-import type { ChangeSource } from "../../store/index";
-import type { AssetId, AssetRecord, AssetRecordBase, BindingId, BindingRecordBase, BindingRecord, Camera, DocumentMetadataRecord, PageId, PageRecord, ShapeId, ShapeParentId, ShapeRecordBase, ShapeRecord, ShapeEditingEntryMode } from "../schema/records";
+import type { ChangeSource } from "../../../store/index";
+import type { AssetId, AssetRecord, AssetRecordBase, BindingId, BindingRecord, BindingRecordBase, Camera, DocumentMetadataRecord, PageId, PageRecord, ShapeEditingEntryMode, ShapeId, ShapeParentId, ShapeRecord, ShapeRecordBase } from "../../schema/records";
 export interface EditorCommandOptions {
     source?: ChangeSource;
 }
+export type ShapePropsPatch = Record<string, unknown>;
 export interface CreateShapesOptions extends EditorCommandOptions {
     /** Defer spatial containment until an interactive creation gesture completes. */
     autoReparent?: boolean;
@@ -66,7 +66,7 @@ export interface StartEditingShapeInput {
         x: number;
         y: number;
     };
-    markId?: string;
+    operationKind?: string;
     reuseActiveOperation?: boolean;
     preserveInteraction?: boolean;
 }
@@ -147,5 +147,3 @@ export interface EditorCommands {
     setActiveTool(toolId: string, options?: EditorCommandOptions): void;
     setToolLocked(locked: boolean, options?: EditorCommandOptions): void;
 }
-export declare function createEditorCommands(editor: Editor): EditorCommands;
-export declare function reparentShapeToContainingParent(editor: Editor, shapeId: ShapeId, options?: EditorCommandOptions): void;

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

@@ -0,0 +1,5 @@
+import type { Editor } from "../editor";
+import type { EditorCommands } from "./commandTypes";
+export declare function createEditorCommands(editor: Editor): EditorCommands;
+export { reparentShapeToContainingParent } from "./shapeCommands";
+export type * from "./commandTypes";

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

@@ -0,0 +1,9 @@
+import type { DocumentMetadataRecord, PageId, PageRecord } from "../../schema/records";
+import type { CreatePageInput, EditorCommandOptions, MovePageInput, RenamePageInput, UpdateDocumentMetaInput, UpdatePageMetaInput } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function createPage(editor: Editor, input?: CreatePageInput, options?: EditorCommandOptions): PageRecord;
+export declare function deletePage(editor: Editor, id: PageId, options?: EditorCommandOptions): boolean;
+export declare function renamePage(editor: Editor, input: RenamePageInput, options?: EditorCommandOptions): void;
+export declare function updateDocumentMeta(editor: Editor, input: UpdateDocumentMetaInput, options?: EditorCommandOptions): DocumentMetadataRecord;
+export declare function updatePageMeta(editor: Editor, input: UpdatePageMetaInput, options?: EditorCommandOptions): PageRecord | null;
+export declare function movePage(editor: Editor, input: MovePageInput, options?: EditorCommandOptions): void;

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

@@ -0,0 +1,13 @@
+import type { ChangeSource } from "../../../store/index";
+import { type PageId, type SessionRecord, type ShapeId } from "../../schema/records";
+import type { EditorCommandOptions, SetCameraInput } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function updateSession(editor: Editor, partial: Partial<SessionRecord>, source?: ChangeSource): void;
+export declare function setCurrentPageId(editor: Editor, id: PageId, options?: EditorCommandOptions): void;
+export declare function setCamera(editor: Editor, input: SetCameraInput, options?: EditorCommandOptions): void;
+export declare function setSelectedShapeIds(editor: Editor, ids: ShapeId[], options?: EditorCommandOptions): void;
+export declare function setActiveTool(editor: Editor, toolId: string, options?: EditorCommandOptions): void;
+export declare function setToolLocked(editor: Editor, locked: boolean, options?: EditorCommandOptions): void;
+export declare function ensurePageState(editor: Editor, pageId: PageId, source?: ChangeSource): void;
+export declare function removePageState(editor: Editor, pageId: PageId, nextCurrentPageId: PageId, source?: ChangeSource): void;
+export declare function syncToolStateFromSession(editor: Editor, source: ChangeSource): void;

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

@@ -0,0 +1,9 @@
+import { type ShapeId, type ShapeRecord } from "../../schema/records";
+import type { CreateShapeInput, CreateShapesOptions, EditorCommandOptions, ReparentShapesInput, ShapeUpdate, UpdateShapesOptions } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function createShapes(editor: Editor, inputs: CreateShapeInput[], options?: CreateShapesOptions): ShapeRecord[];
+export declare function createShapesFromRecords(editor: Editor, records: ShapeRecord[], options?: EditorCommandOptions): ShapeRecord[];
+export declare function reparentShapeToContainingParent(editor: Editor, shapeId: ShapeId, options?: EditorCommandOptions): void;
+export declare function updateShapes(editor: Editor, updates: ShapeUpdate[], options?: UpdateShapesOptions): void;
+export declare function reparentShapes(editor: Editor, input: ReparentShapesInput, options?: EditorCommandOptions): boolean;
+export declare function deleteShapes(editor: Editor, ids: ShapeId[], options?: EditorCommandOptions): void;

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

@@ -0,0 +1,10 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+type ShapeBooleanFlag = "isHidden" | "isLocked";
+export declare function setShapeBooleanFlag(editor: Editor, ids: readonly ShapeId[], input: {
+    flag: ShapeBooleanFlag;
+    value: boolean;
+    source: ChangeSource;
+}): ShapeId[];
+export {};

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

@@ -0,0 +1,10 @@
+import type { ChangeSource } from "../../../store/index";
+import { type AssetId, type ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+interface RemoveShapeRecordsOptions {
+    source: ChangeSource;
+    afterRemove?: (removedIds: readonly ShapeId[]) => void;
+}
+export declare function getUnreferencedAssetIdsAfterShapeDelete(editor: Editor, shapeIds: readonly ShapeId[]): AssetId[];
+export declare function removeShapeRecords(editor: Editor, ids: readonly ShapeId[], options: RemoveShapeRecordsOptions): ShapeId[];
+export {};

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

@@ -0,0 +1,11 @@
+import type { ChangeSource } from "../../../store/index";
+import { type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function syncTransformDescendantAncestorBounds(editor: Editor, changes: Array<{
+    before: ShapeRecord;
+    after: ShapeRecord;
+}>, source: ChangeSource): void;
+export declare function syncTransformDescendantAncestorBoundsByIds(editor: Editor, ancestorIds: Iterable<ShapeId>, source: ChangeSource, excludedIds?: ReadonlySet<ShapeId>): void;
+export declare function getCurrentChildShapes(editor: Editor, parentId: ShapeParentId): ShapeRecord[];
+export declare function collectTransformDescendantAncestorIdsForShapes(editor: Editor, ids: readonly ShapeId[]): Set<ShapeId>;
+export declare function repairMinimumChildContainers(editor: Editor, ancestorIds: Iterable<ShapeId>, deletedIds: Set<ShapeId>, source: ChangeSource): ShapeId[];

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

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