@mocanvas/editor 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2066 @@
+import * as _mocanvas_store from '@mocanvas/store';
+import { RecordId, IndexKey, Store, MigrationSequence, SerializedStore, StoreSnapshot, StoreSchema, UnknownRecord } from '@mocanvas/store';
+import { StyleWords, FrameBuffers, CameraState, EngineBridge, ClipRect } from '@mocanvas/wasm';
+export { CameraState, ClipRect, EngineBridge, FLAG, PATH_OP, StyleWords, loadEngine, loadEngineSync } from '@mocanvas/wasm';
+import * as react from 'react';
+import { ReactNode, CSSProperties } from 'react';
+export { track, useAtom, useComputed, useQuickReactor, useReactor, useValue } from '@mocanvas/state/react';
+
+interface VecLike {
+    x: number;
+    y: number;
+}
+interface BoxLike {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+declare class Vec {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    static From(p: VecLike): Vec;
+    static Add(a: VecLike, b: VecLike): Vec;
+    static Sub(a: VecLike, b: VecLike): Vec;
+    static Mul(a: VecLike, s: number): Vec;
+    static Div(a: VecLike, s: number): Vec;
+    static Dist(a: VecLike, b: VecLike): number;
+    static Dist2(a: VecLike, b: VecLike): number;
+    static Len(a: VecLike): number;
+    static Dot(a: VecLike, b: VecLike): number;
+    static Cross(a: VecLike, b: VecLike): number;
+    static Lrp(a: VecLike, b: VecLike, t: number): Vec;
+    static Angle(a: VecLike, b: VecLike): number;
+    static Rot(a: VecLike, r: number): Vec;
+    static RotWith(a: VecLike, center: VecLike, r: number): Vec;
+    static Uni(a: VecLike): Vec;
+    static Per(a: VecLike): Vec;
+    static Equals(a: VecLike, b: VecLike): boolean;
+    static NearestPointOnLineSegment(a: VecLike, b: VecLike, p: VecLike): Vec;
+    static DistanceToLineSegment(a: VecLike, b: VecLike, p: VecLike): number;
+    add(b: VecLike): this;
+    sub(b: VecLike): this;
+    mul(s: number): this;
+    clone(): Vec;
+    toJson(): VecLike;
+}
+declare class Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    constructor(x?: number, y?: number, w?: number, h?: number);
+    static From(b: BoxLike): Box;
+    static FromPoints(points: VecLike[]): Box;
+    static FromMinMax(minX: number, minY: number, maxX: number, maxY: number): Box;
+    static Common(boxes: BoxLike[]): Box;
+    static Contains(a: BoxLike, b: BoxLike): boolean;
+    static ContainsPoint(a: BoxLike, p: VecLike, margin?: number): boolean;
+    static Collides(a: BoxLike, b: BoxLike): boolean;
+    static Expand(a: BoxLike, d: number): Box;
+    get minX(): number;
+    get minY(): number;
+    get maxX(): number;
+    get maxY(): number;
+    get width(): number;
+    get height(): number;
+    get center(): Vec;
+    get corners(): Vec[];
+    clone(): Box;
+    toJson(): BoxLike;
+}
+interface Geometry2dOptions {
+    isFilled: boolean;
+    isClosed: boolean;
+    isLabel?: boolean;
+}
+/** Base class for shape geometry. */
+declare abstract class Geometry2d {
+    readonly isFilled: boolean;
+    readonly isClosed: boolean;
+    readonly isLabel: boolean;
+    private _vertices;
+    private _bounds;
+    constructor(opts: Geometry2dOptions);
+    /** Flattened outline vertices in shape-local space. */
+    abstract getVertices(): Vec[];
+    /** Serialize to the engine's flat path encoding. */
+    abstract toPathWords(): number[];
+    get vertices(): Vec[];
+    get bounds(): Box;
+    get center(): Vec;
+    nearestPoint(point: VecLike): Vec;
+    distanceToPoint(point: VecLike, hitInside?: boolean): number;
+    hitTestPoint(point: VecLike, margin?: number, hitInside?: boolean): boolean;
+}
+declare function pointInPolygon(p: VecLike, poly: VecLike[]): boolean;
+declare class Rectangle2d extends Geometry2d {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+    constructor(opts: {
+        x?: number;
+        y?: number;
+        width: number;
+        height: number;
+        isFilled: boolean;
+        isLabel?: boolean;
+    });
+    getVertices(): Vec[];
+    toPathWords(): number[];
+}
+declare class Ellipse2d extends Geometry2d {
+    readonly w: number;
+    readonly h: number;
+    constructor(opts: {
+        width: number;
+        height: number;
+        isFilled: boolean;
+    });
+    getVertices(): Vec[];
+    toPathWords(): number[];
+}
+declare class Circle2d extends Ellipse2d {
+    constructor(opts: {
+        radius: number;
+        isFilled: boolean;
+    });
+}
+declare class Polygon2d extends Geometry2d {
+    readonly points: Vec[];
+    constructor(opts: {
+        points: VecLike[];
+        isFilled: boolean;
+    });
+    getVertices(): Vec[];
+    toPathWords(): number[];
+}
+declare class Polyline2d extends Geometry2d {
+    readonly points: Vec[];
+    constructor(opts: {
+        points: VecLike[];
+    });
+    getVertices(): Vec[];
+    toPathWords(): number[];
+}
+declare class Edge2d extends Polyline2d {
+    constructor(opts: {
+        start: VecLike;
+        end: VecLike;
+    });
+}
+/** Cubic bézier spline through control points, serialized natively. */
+declare class CubicSpline2d extends Geometry2d {
+    readonly segments: {
+        p0: Vec;
+        c1: Vec;
+        c2: Vec;
+        p1: Vec;
+    }[];
+    constructor(opts: {
+        segments: {
+            p0: VecLike;
+            c1: VecLike;
+            c2: VecLike;
+            p1: VecLike;
+        }[];
+        isClosed?: boolean;
+        isFilled?: boolean;
+    });
+    getVertices(): Vec[];
+    toPathWords(): number[];
+}
+/** Several geometries drawn as one shape (e.g. a geo shape and its label). */
+declare class Group2d extends Geometry2d {
+    readonly children: Geometry2d[];
+    constructor(opts: {
+        children: Geometry2d[];
+    });
+    getVertices(): Vec[];
+    toPathWords(): number[];
+    nearestPoint(point: VecLike): Vec;
+    hitTestPoint(point: VecLike, margin?: number, hitInside?: boolean): boolean;
+}
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+interface Document {
+    readonly id: DocumentId;
+    readonly typeName: "document";
+    gridSize: number;
+    name: string;
+    meta: JsonObject;
+}
+type DocumentId = RecordId<Document>;
+declare const DocumentRecordType: _mocanvas_store.RecordType<Document, never>;
+declare const DOCUMENT_ID: DocumentId;
+interface Page {
+    readonly id: PageId;
+    readonly typeName: "page";
+    name: string;
+    index: IndexKey;
+    meta: JsonObject;
+}
+type PageId = RecordId<Page>;
+declare const PageRecordType: _mocanvas_store.RecordType<Page, "name" | "index">;
+declare function isPageId(id: string): id is PageId;
+interface Camera {
+    readonly id: CameraId;
+    readonly typeName: "camera";
+    x: number;
+    y: number;
+    z: number;
+    meta: JsonObject;
+}
+type CameraId = RecordId<Camera>;
+declare const CameraRecordType: _mocanvas_store.RecordType<Camera, never>;
+interface Instance {
+    readonly id: InstanceId;
+    readonly typeName: "instance";
+    currentPageId: PageId;
+    followingUserId: string | null;
+    isFocusMode: boolean;
+    isDebugMode: boolean;
+    isToolLocked: boolean;
+    isGridMode: boolean;
+    isReadonly: boolean;
+    isFocused: boolean;
+    isPenMode: boolean;
+    isChangingStyle: boolean;
+    exportBackground: boolean;
+    screenBounds: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    insets: boolean[];
+    cursor: {
+        type: string;
+        rotation: number;
+    };
+    scribbles: Scribble[];
+    brush: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+    zoomBrush: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+    openMenus: string[];
+    devicePixelRatio: number;
+    isCoarsePointer: boolean;
+    isHoveringCanvas: boolean | null;
+    stylesForNextShape: Record<string, unknown>;
+    duplicateProps: {
+        shapeIds: string[];
+        offset: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    meta: JsonObject;
+}
+type InstanceId = RecordId<Instance>;
+interface Scribble {
+    id: string;
+    points: {
+        x: number;
+        y: number;
+        z?: number;
+    }[];
+    size: number;
+    color: string;
+    opacity: number;
+    state: "starting" | "paused" | "active" | "stopping";
+    delay: number;
+    shrink: number;
+    taper: boolean;
+}
+declare const InstanceRecordType: _mocanvas_store.RecordType<Instance, "currentPageId">;
+declare const INSTANCE_ID: InstanceId;
+interface InstancePageState {
+    readonly id: InstancePageStateId;
+    readonly typeName: "instance_page_state";
+    pageId: PageId;
+    selectedShapeIds: ShapeId[];
+    hintingShapeIds: ShapeId[];
+    erasingShapeIds: ShapeId[];
+    hoveredShapeId: ShapeId | null;
+    editingShapeId: ShapeId | null;
+    croppingShapeId: ShapeId | null;
+    focusedGroupId: ShapeId | null;
+    meta: JsonObject;
+}
+type InstancePageStateId = RecordId<InstancePageState>;
+declare const InstancePageStateRecordType: _mocanvas_store.RecordType<InstancePageState, "pageId">;
+interface BaseShape<Type extends string, Props extends object> {
+    readonly id: ShapeId;
+    readonly typeName: "shape";
+    type: Type;
+    x: number;
+    y: number;
+    rotation: number;
+    index: IndexKey;
+    parentId: ParentId;
+    isLocked: boolean;
+    opacity: number;
+    props: Props;
+    meta: JsonObject;
+}
+type UnknownShape = BaseShape<string, object>;
+type Shape = UnknownShape;
+type ShapeId = RecordId<UnknownShape>;
+type ParentId = PageId | ShapeId;
+declare const ShapeRecordType: _mocanvas_store.RecordType<UnknownShape, "props" | "type" | "index" | "parentId">;
+declare function createShapeId(id?: string): ShapeId;
+declare function isShapeId(id: unknown): id is ShapeId;
+declare function isShape(record: unknown): record is UnknownShape;
+type ShapePartial<T extends UnknownShape = UnknownShape> = {
+    id: ShapeId;
+    type: T["type"];
+} & Partial<Omit<T, "id" | "type" | "props" | "meta">> & {
+    props?: Partial<T["props"]>;
+    meta?: Partial<T["meta"]>;
+};
+/** A shape partial without a required id (id and index are assigned on create). */
+type ShapeCreate<T extends UnknownShape = UnknownShape> = Omit<ShapePartial<T>, "id"> & {
+    id?: ShapeId;
+};
+
+interface VecModel {
+    x: number;
+    y: number;
+    z?: number;
+}
+type UiEventType = "pointer" | "click" | "keyboard" | "wheel" | "pinch" | "cancel" | "complete" | "interrupt" | "tick" | "misc";
+type PointerEventName = "pointer_down" | "pointer_move" | "pointer_up" | "right_click" | "middle_click";
+type ClickEventName = "double_click" | "triple_click" | "quadruple_click";
+type KeyboardEventName = "key_down" | "key_up" | "key_repeat";
+type PointerTarget = {
+    target: "canvas";
+} | {
+    target: "shape";
+    shape: UnknownShape;
+} | {
+    target: "selection";
+    handle?: SelectionHandle;
+} | {
+    target: "handle";
+    shape: UnknownShape;
+    handle: ShapeHandle;
+};
+type SelectionHandle = "top" | "right" | "bottom" | "left" | "top_left" | "top_right" | "bottom_left" | "bottom_right" | "rotate" | "mobile_rotate" | "top_left_rotate" | "top_right_rotate" | "bottom_left_rotate" | "bottom_right_rotate";
+interface ShapeHandle {
+    id: string;
+    type: "vertex" | "virtual" | "create" | "clone";
+    index: string;
+    x: number;
+    y: number;
+}
+interface BaseEventInfo {
+    type: UiEventType;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+type PointerEventInfo = BaseEventInfo & PointerTarget & {
+    type: "pointer";
+    name: PointerEventName;
+    point: VecModel;
+    pointerId: number;
+    button: number;
+    isPen: boolean;
+};
+type ClickEventInfo = BaseEventInfo & PointerTarget & {
+    type: "click";
+    name: ClickEventName;
+    point: VecModel;
+    pointerId: number;
+    button: number;
+    isPen: boolean;
+    phase: "down" | "up" | "settle";
+};
+interface KeyboardEventInfo extends BaseEventInfo {
+    type: "keyboard";
+    name: KeyboardEventName;
+    key: string;
+    code: string;
+}
+interface WheelEventInfo extends BaseEventInfo {
+    type: "wheel";
+    name: "wheel";
+    delta: VecModel;
+    point: VecModel;
+}
+interface PinchEventInfo extends BaseEventInfo {
+    type: "pinch";
+    name: "pinch_start" | "pinch" | "pinch_end";
+    point: VecModel;
+    delta: VecModel;
+}
+interface CancelEventInfo extends BaseEventInfo {
+    type: "cancel";
+    name: "cancel";
+}
+interface CompleteEventInfo extends BaseEventInfo {
+    type: "complete";
+    name: "complete";
+}
+interface InterruptEventInfo extends BaseEventInfo {
+    type: "interrupt";
+    name: "interrupt";
+}
+interface TickEventInfo extends BaseEventInfo {
+    type: "tick";
+    name: "tick";
+    elapsed: number;
+}
+type EventInfo = PointerEventInfo | ClickEventInfo | KeyboardEventInfo | WheelEventInfo | PinchEventInfo | CancelEventInfo | CompleteEventInfo | InterruptEventInfo | TickEventInfo;
+type EventHandlers = {
+    onPointerDown?(info: PointerEventInfo): void;
+    onPointerMove?(info: PointerEventInfo): void;
+    onPointerUp?(info: PointerEventInfo): void;
+    onRightClick?(info: PointerEventInfo): void;
+    onMiddleClick?(info: PointerEventInfo): void;
+    onDoubleClick?(info: ClickEventInfo): void;
+    onTripleClick?(info: ClickEventInfo): void;
+    onQuadrupleClick?(info: ClickEventInfo): void;
+    onKeyDown?(info: KeyboardEventInfo): void;
+    onKeyUp?(info: KeyboardEventInfo): void;
+    onKeyRepeat?(info: KeyboardEventInfo): void;
+    onWheel?(info: WheelEventInfo): void;
+    onCancel?(info: CancelEventInfo): void;
+    onComplete?(info: CompleteEventInfo): void;
+    onInterrupt?(info: InterruptEventInfo): void;
+    onTick?(info: TickEventInfo): void;
+};
+declare const EVENT_NAME_MAP: Record<string, keyof EventHandlers>;
+interface EditorEvents {
+    mount: () => void;
+    "max-shapes": (info: {
+        name: string;
+        pageId: string;
+        count: number;
+    }) => void;
+    change: (info: {
+        source: "user" | "remote";
+    }) => void;
+    update: () => void;
+    event: (info: EventInfo) => void;
+    tick: (elapsed: number) => void;
+    frame: (info: {
+        drawn: number;
+        culled: number;
+        ms: number;
+    }) => void;
+    "select-all-text": (info: {
+        shapeId: ShapeId;
+    }) => void;
+    "stop-camera-animation": () => void;
+    "stop-following": () => void;
+}
+/** Minimal typed event emitter. */
+declare class EventEmitter<Events extends {
+    [K in keyof Events]: (...args: any[]) => void;
+}> {
+    private listeners;
+    on<K extends keyof Events>(name: K, fn: Events[K]): () => void;
+    once<K extends keyof Events>(name: K, fn: Events[K]): () => void;
+    off<K extends keyof Events>(name: K, fn: Events[K]): void;
+    emit<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): void;
+    removeAllListeners(): void;
+}
+
+interface ShapeUtilConstructor<T extends UnknownShape = UnknownShape, U extends ShapeUtil<T> = ShapeUtil<T>> {
+    new (editor: Editor): U;
+    type: T["type"];
+    props?: Record<string, unknown>;
+    migrations?: unknown;
+}
+interface ResizeInfo<T extends UnknownShape> {
+    newPoint: VecLike;
+    handle: SelectionHandle;
+    mode: "scale_shape" | "resize_bounds";
+    scaleX: number;
+    scaleY: number;
+    initialBounds: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    initialShape: T;
+}
+interface TranslateInfo<T extends UnknownShape> {
+    initialShape: T;
+}
+/** Export-wide settings handed to `ShapeUtil.toSvg` / `toBackgroundSvg`. */
+interface ShapeSvgContext {
+    /** Whether the export is being drawn against the dark theme. */
+    darkMode: boolean;
+    /** The page background colour of the export, as `#rrggbb`. */
+    background: string;
+}
+/**
+ * What an SVG export callback may return: a raw markup string (inserted
+ * verbatim, so it must be well-formed and escaped by the util) or a React node
+ * the exporter serializes. `undefined` means "I have nothing to draw", which
+ * lets the exporter fall through to its own renderers.
+ */
+type ShapeSvgResult = string | ReactNode;
+/**
+ * Describes how a shape type behaves: its default props, geometry, rendering
+ * and interaction callbacks. One instance per shape type per editor.
+ */
+declare abstract class ShapeUtil<T extends UnknownShape = UnknownShape> {
+    readonly editor: Editor;
+    static type: string;
+    static props?: Record<string, unknown>;
+    static migrations?: unknown;
+    constructor(editor: Editor);
+    get type(): T["type"];
+    abstract getDefaultProps(): T["props"];
+    abstract getGeometry(shape: T): Geometry2d;
+    abstract component(shape: T): ReactNode;
+    /**
+     * The outline drawn over the shape when it is selected or hovered, in
+     * shape-local coordinates. The indicators layer supplies `fill: none`, the
+     * selection colour and a zoom-independent stroke width, so an indicator is
+     * usually just a bare `<path>` or `<rect>`. Return `null` to fall back to a
+     * rectangle around the shape's geometry bounds.
+     */
+    abstract indicator(shape: T): ReactNode;
+    /**
+     * The shape as SVG, in shape-local coordinates: the exporter wraps the
+     * result in a `<g>` carrying the shape's page transform and opacity.
+     * Implement it to make a custom shape exportable without registering
+     * anything; leave it undefined to fall through to the exporter's own
+     * renderers.
+     */
+    toSvg?(shape: T, ctx: ShapeSvgContext): ShapeSvgResult;
+    /**
+     * Extra SVG drawn *behind* every exported shape (a backdrop, a drop shadow,
+     * a grid). Same coordinate space and wrapping as `toSvg`.
+     */
+    toBackgroundSvg?(shape: T, ctx: ShapeSvgContext): ShapeSvgResult;
+    /**
+     * GPU style for the shape's geometry. Return `null` (the default) to render
+     * the shape through `component` in the DOM overlay instead.
+     */
+    getRenderStyle(_shape: T): StyleWords | null;
+    /** Whether the shape should be drawn by the DOM overlay even if it has a render style (e.g. while editing). */
+    needsOverlay(shape: T): boolean;
+    /**
+     * Whether `component` should be rendered in the DOM overlay *in addition to*
+     * the GPU geometry (e.g. a text label on a filled shape).
+     */
+    hasOverlayLabel(_shape: T): boolean;
+    /**
+     * Whether the shape clips its descendants to its own geometry bounds (e.g.
+     * frames). Children are then rendered with a scissor rect on the GPU.
+     */
+    isClipShape(_shape: T): boolean;
+    canEdit(_shape: T): boolean;
+    canResize(_shape: T): boolean;
+    canBind(_opts: {
+        fromShapeType: string;
+        toShapeType: string;
+        bindingType: string;
+    }): boolean;
+    canCrop(_shape: T): boolean;
+    canScroll(_shape: T): boolean;
+    canSnap(_shape: T): boolean;
+    canReceiveNewChildrenOfType(_shape: T, _type: string): boolean;
+    canDropShapes(_shape: T, _shapes: UnknownShape[]): boolean;
+    hideRotateHandle(_shape: T): boolean;
+    hideResizeHandles(_shape: T): boolean;
+    hideSelectionBoundsBg(_shape: T): boolean;
+    hideSelectionBoundsFg(_shape: T): boolean;
+    isAspectRatioLocked(_shape: T): boolean;
+    getHandles?(shape: T): ShapeHandle[];
+    getText?(shape: T): string | undefined;
+    onBeforeCreate?(next: T): T | void;
+    onBeforeUpdate?(prev: T, next: T): T | void;
+    onResize?(shape: T, info: ResizeInfo<T>): Partial<T> | void;
+    onResizeStart?(shape: T): void;
+    onResizeEnd?(initial: T, current: T): void;
+    onTranslateStart?(shape: T): Partial<T> | void;
+    onTranslate?(initial: T, current: T): Partial<T> | void;
+    onTranslateEnd?(initial: T, current: T): Partial<T> | void;
+    onRotateStart?(shape: T): void;
+    onRotate?(initial: T, current: T): Partial<T> | void;
+    onRotateEnd?(initial: T, current: T): void;
+    onHandleDrag?(shape: T, info: {
+        handle: ShapeHandle;
+        isPrecise: boolean;
+        initial?: T;
+    }): Partial<T> | void;
+    onDoubleClick?(shape: T): Partial<T> | void;
+    onDoubleClickEdge?(shape: T): Partial<T> | void;
+    onDoubleClickHandle?(shape: T, handle: ShapeHandle): Partial<T> | void;
+    onEditEnd?(shape: T): void;
+    onChildrenChange?(shape: T): Partial<UnknownShape>[] | void;
+    onDragShapesOver?(shape: T, shapes: UnknownShape[]): void;
+    onDragShapesOut?(shape: T, shapes: UnknownShape[]): void;
+    onDropShapesOver?(shape: T, shapes: UnknownShape[]): void;
+}
+/** Shapes with `w` and `h` props. */
+declare abstract class BaseBoxShapeUtil<T extends UnknownShape & {
+    props: {
+        w: number;
+        h: number;
+    };
+}> extends ShapeUtil<T> {
+    onResize(shape: T, info: ResizeInfo<T>): Partial<T>;
+}
+
+/** A directed relationship between two shapes (e.g. an arrow end attached to a shape). */
+interface BaseBinding<Type extends string, Props extends object> {
+    readonly id: BindingId;
+    readonly typeName: "binding";
+    type: Type;
+    fromId: ShapeId;
+    toId: ShapeId;
+    props: Props;
+    meta: JsonObject;
+}
+type UnknownBinding = BaseBinding<string, object>;
+type Binding = UnknownBinding;
+type BindingId = RecordId<UnknownBinding>;
+declare const BindingRecordType: _mocanvas_store.RecordType<UnknownBinding, "props" | "type" | "fromId" | "toId">;
+declare function createBindingId(id?: string): BindingId;
+declare function isBindingId(id: unknown): id is BindingId;
+declare function isBinding(record: unknown): record is UnknownBinding;
+type BindingCreate<B extends UnknownBinding = UnknownBinding> = {
+    id?: BindingId;
+    type: B["type"];
+    fromId: ShapeId;
+    toId: ShapeId;
+    props?: Partial<B["props"]>;
+    meta?: Partial<B["meta"]>;
+};
+type BindingPartial<B extends UnknownBinding = UnknownBinding> = {
+    id: BindingId;
+    type: B["type"];
+} & Partial<Omit<B, "id" | "type" | "props" | "meta">> & {
+    props?: Partial<B["props"]>;
+    meta?: Partial<B["meta"]>;
+};
+
+interface BindingUtilConstructor<B extends UnknownBinding = UnknownBinding, U extends BindingUtil<B> = BindingUtil<B>> {
+    new (editor: Editor): U;
+    type: B["type"];
+    props?: Record<string, unknown>;
+    migrations?: unknown;
+}
+interface BindingOnCreateOptions<B extends UnknownBinding> {
+    binding: B;
+}
+interface BindingOnChangeOptions<B extends UnknownBinding> {
+    bindingBefore: B;
+    bindingAfter: B;
+}
+interface BindingOnShapeChangeOptions<B extends UnknownBinding> {
+    binding: B;
+    shapeBefore: UnknownShape;
+    shapeAfter: UnknownShape;
+    /** Why the shape changed: itself, or because an ancestor moved. */
+    reason: "self" | "ancestry";
+}
+interface BindingOnShapeIsolateOptions<B extends UnknownBinding> {
+    binding: B;
+    /** The shape leaving this binding's context (deleted, or copied without its partner). */
+    removedShape?: UnknownShape;
+}
+interface BindingOnShapeDeleteOptions<B extends UnknownBinding> {
+    binding: B;
+    shape: UnknownShape;
+}
+/**
+ * Describes how a binding type behaves. One instance per binding type per editor.
+ * Callbacks run inside the store transaction that caused them.
+ */
+declare abstract class BindingUtil<B extends UnknownBinding = UnknownBinding> {
+    readonly editor: Editor;
+    static type: string;
+    static props?: Record<string, unknown>;
+    static migrations?: unknown;
+    constructor(editor: Editor);
+    get type(): B["type"];
+    abstract getDefaultProps(): Partial<B["props"]>;
+    onBeforeCreate?(options: BindingOnCreateOptions<B>): B | void;
+    onAfterCreate?(options: BindingOnCreateOptions<B>): void;
+    onBeforeChange?(options: BindingOnChangeOptions<B>): B | void;
+    onAfterChange?(options: BindingOnChangeOptions<B>): void;
+    onBeforeDelete?(options: {
+        binding: B;
+    }): void;
+    onAfterDelete?(options: {
+        binding: B;
+    }): void;
+    /** The `from` shape changed (moved, resized, ...). */
+    onAfterChangeFromShape?(options: BindingOnShapeChangeOptions<B>): void;
+    /** The `to` shape changed. */
+    onAfterChangeToShape?(options: BindingOnShapeChangeOptions<B>): void;
+    /** The `from` shape is about to be deleted; the binding is deleted right after. */
+    onBeforeDeleteFromShape?(options: BindingOnShapeDeleteOptions<B>): void;
+    /** The `to` shape is about to be deleted; the binding is deleted right after. */
+    onBeforeDeleteToShape?(options: BindingOnShapeDeleteOptions<B>): void;
+    /** The `from` shape is being isolated (partner going away); typically the binding converts to a static value. */
+    onBeforeIsolateFromShape?(options: BindingOnShapeIsolateOptions<B>): void;
+    onBeforeIsolateToShape?(options: BindingOnShapeIsolateOptions<B>): void;
+}
+
+/** Pixel dimensions and source of an image file. `src` is a URL or data URL; `null` while uploading. */
+interface ImageAssetProps {
+    w: number;
+    h: number;
+    name: string;
+    isAnimated: boolean;
+    mimeType: string | null;
+    src: string | null;
+    fileSize?: number;
+}
+type VideoAssetProps = ImageAssetProps;
+interface BookmarkAssetProps {
+    title: string;
+    description: string;
+    image: string;
+    favicon: string;
+    src: string | null;
+}
+/** A document-scoped record describing external media referenced by shapes (images, videos, bookmarks). */
+interface BaseAsset<Type extends string, Props extends object> {
+    readonly id: AssetId;
+    readonly typeName: "asset";
+    type: Type;
+    props: Props;
+    meta: JsonObject;
+}
+type ImageAsset = BaseAsset<"image", ImageAssetProps>;
+type VideoAsset = BaseAsset<"video", VideoAssetProps>;
+type BookmarkAsset = BaseAsset<"bookmark", BookmarkAssetProps>;
+type Asset = ImageAsset | VideoAsset | BookmarkAsset;
+type AssetType = Asset["type"];
+type AssetId = RecordId<Asset>;
+declare const AssetRecordType: _mocanvas_store.RecordType<Asset, "props" | "type">;
+declare function createAssetId(id?: string): AssetId;
+declare function isAssetId(id: unknown): id is AssetId;
+declare function isAsset(record: unknown): record is Asset;
+/** An asset to create: `id` and `meta` are optional, `props` must be complete. */
+type AssetCreate<A extends Asset = Asset> = {
+    id?: AssetId;
+    type: A["type"];
+    props: A["props"];
+    meta?: Partial<A["meta"]>;
+};
+type AssetPartial<A extends Asset = Asset> = {
+    id: AssetId;
+    type: A["type"];
+    props?: Partial<A["props"]>;
+    meta?: Partial<A["meta"]>;
+};
+/** Content dropped or pasted onto the canvas. `point` is in page space; defaults to the viewport center. */
+type ExternalContent = {
+    type: "files";
+    files: File[];
+    point?: VecLikeJson;
+} | {
+    type: "text";
+    text: string;
+    point?: VecLikeJson;
+} | {
+    type: "url";
+    url: string;
+    point?: VecLikeJson;
+} | {
+    type: "svg-text";
+    text: string;
+    point?: VecLikeJson;
+};
+type ExternalContentType = ExternalContent["type"];
+/** Something an asset can be produced from. */
+type ExternalAssetContent = {
+    type: "file";
+    file: File;
+} | {
+    type: "url";
+    url: string;
+};
+type ExternalAssetType = ExternalAssetContent["type"];
+type ExternalContentHandler<T extends ExternalContentType = ExternalContentType> = (info: Extract<ExternalContent, {
+    type: T;
+}>) => void | Promise<void>;
+type ExternalAssetHandler<T extends ExternalAssetType = ExternalAssetType> = (info: Extract<ExternalAssetContent, {
+    type: T;
+}>) => Asset | undefined | Promise<Asset | undefined>;
+/** Plain `{ x, y }`; kept structural so records stay JSON-serializable. */
+interface VecLikeJson {
+    x: number;
+    y: number;
+}
+
+type StateNodeType = "branch" | "leaf" | "root";
+interface StateNodeConstructor {
+    new (editor: Editor, parent?: StateNode): StateNode;
+    id: string;
+    initial?: string;
+    children?(): StateNodeConstructor[];
+    isLockable?: boolean;
+    useCoalescedEvents?: boolean;
+}
+/**
+ * A node in the tool state machine. Tools are trees of StateNodes: the root
+ * holds one child per tool, each tool holds its own states.
+ */
+declare abstract class StateNode {
+    static id: string;
+    static initial?: string;
+    static children?: () => StateNodeConstructor[];
+    static isLockable: boolean;
+    static useCoalescedEvents: boolean;
+    readonly id: string;
+    readonly type: StateNodeType;
+    readonly initial: string | undefined;
+    readonly children?: Record<string, StateNode>;
+    readonly parent: StateNode | undefined;
+    readonly editor: Editor;
+    private readonly _isActive;
+    private readonly _current;
+    private readonly _path;
+    /** Whether the shape kind this tool creates should be kept selected after creation etc. */
+    shapeType?: string;
+    /** Tools can declare the interaction they perform when locked. */
+    static get isLockableTool(): boolean;
+    constructor(editor: Editor, parent?: StateNode);
+    getPath(): string;
+    getCurrent(): StateNode | undefined;
+    getIsActive(): boolean;
+    getDescendant<T extends StateNode>(path: string): T | undefined;
+    /** Dispatch an event to this node, then to its active child. */
+    handleEvent(info: EventInfo): void;
+    /** Move this node's current child to `id`, exiting the old one and entering the new one. */
+    transition(id: string, info?: object): this;
+    enter(info: Record<string, unknown>, from: string): void;
+    exit(info: Record<string, unknown>, to: string): void;
+    /** Change the active tool from anywhere in the tree. */
+    setCurrentToolIdMask(_mask: string | undefined): void;
+    onEnter?(info: Record<string, unknown>, from: string): void;
+    onExit?(info: Record<string, unknown>, to: string): void;
+    onPointerDown?(info: PointerEventInfo): void;
+    onPointerMove?(info: PointerEventInfo): void;
+    onPointerUp?(info: PointerEventInfo): void;
+    onRightClick?(info: PointerEventInfo): void;
+    onMiddleClick?(info: PointerEventInfo): void;
+    onDoubleClick?(info: ClickEventInfo): void;
+    onTripleClick?(info: ClickEventInfo): void;
+    onQuadrupleClick?(info: ClickEventInfo): void;
+    onKeyDown?(info: KeyboardEventInfo): void;
+    onKeyUp?(info: KeyboardEventInfo): void;
+    onKeyRepeat?(info: KeyboardEventInfo): void;
+    onWheel?(info: WheelEventInfo): void;
+    onCancel?(info: CancelEventInfo): void;
+    onComplete?(info: CompleteEventInfo): void;
+    onInterrupt?(info: InterruptEventInfo): void;
+    onTick?(info: TickEventInfo): void;
+}
+
+/** Convenience for subclass typing. */
+type StateNodeClass = typeof StateNode & StateNodeConstructor;
+
+type RGBA = [number, number, number, number];
+interface DrawOptions {
+    /** Clear color, normalized. */
+    background: RGBA;
+}
+/** Anything the GPU can sample as a texture. */
+type TextureSource = TexImageSource | ImageData;
+interface TextureOptions {
+    /**
+     * Whether `source` already holds premultiplied alpha. Defaults to `false`;
+     * the upload always produces a premultiplied texture, matching the blend mode.
+     */
+    premultiplied?: boolean;
+    /** Bilinear filtering (default `true`). `false` gives nearest-neighbour sampling. */
+    smooth?: boolean;
+}
+/** A GPU backend that can draw one engine frame. Implementations: WebGL2 (now), WebGPU (later). */
+interface RenderBackend {
+    readonly kind: "webgl2" | "webgpu";
+    /** Resize the drawing buffer. Sizes are CSS pixels; `dpr` is the device pixel ratio. */
+    resize(width: number, height: number, dpr: number): void;
+    /**
+     * Draw one frame. Batches are bound to the texture named by their texture
+     * word (0 = solid colour) and, when they carry a clip rect, scissored to it.
+     */
+    draw(frame: FrameBuffers, camera: CameraState, options: DrawOptions): void;
+    /**
+     * Create or replace the texture with host id `id` (must be non-zero; 0 is the
+     * built-in solid texture). Shapes reference it through `StyleWords.texture`.
+     */
+    uploadTexture(id: number, source: TextureSource, opts?: TextureOptions): void;
+    /** Release a texture. Batches still referencing `id` fall back to solid colour. */
+    deleteTexture(id: number): void;
+    dispose(): void;
+}
+
+/** Eight colours that stay readable on the canvas background in any order. */
+declare const PRESENCE_COLORS: readonly ["#e0575b", "#ef8b3a", "#d8a72e", "#4f9d55", "#2fa39a", "#3f86d8", "#7a63d8", "#c05aa8"];
+declare function randomPresenceColor(): string;
+/**
+ * What one other person is doing right now: where their cursor is, what they
+ * have selected, which page they are on.
+ *
+ * Presence records live in the `presence` scope: they are shared with
+ * collaborators but never written to a `.tldr` file and never enter history.
+ */
+interface InstancePresence {
+    readonly id: InstancePresenceId;
+    readonly typeName: "instance_presence";
+    /** Stable id of the person (survives reconnects; one person may have many tabs). */
+    userId: string;
+    userName: string;
+    /** CSS colour used for their cursor, name chip and selection outlines. */
+    color: string;
+    currentPageId: PageId;
+    cursor: {
+        x: number;
+        y: number;
+        type: string;
+        rotation: number;
+    };
+    camera: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    selectedShapeIds: ShapeId[];
+    brush: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+    scribbles: Scribble[];
+    followingUserId: string | null;
+    /** `Date.now()` on the sender when the record was produced. */
+    lastActivityTimestamp: number;
+    chatMessage: string;
+    meta: JsonObject;
+}
+type InstancePresenceId = RecordId<InstancePresence>;
+declare const InstancePresenceRecordType: _mocanvas_store.RecordType<InstancePresence, "currentPageId" | "userId">;
+declare function isInstancePresenceId(id: string): id is InstancePresenceId;
+/**
+ * The local person's identity, held in a signal so that renaming or
+ * recolouring re-renders anything that shows it. Session-only: nothing here is
+ * persisted with the document.
+ */
+interface UserPreferences {
+    getId(): string;
+    getName(): string;
+    getColor(): string;
+    setName(name: string): void;
+    setColor(color: string): void;
+}
+interface UserPreferencesInit {
+    id?: string;
+    name?: string;
+    color?: string;
+}
+/** Create a `UserPreferences` backed by one session atom. */
+declare function createUserPreferences(init?: UserPreferencesInit): UserPreferences;
+
+type EditorRecord = Document | Page | UnknownShape | UnknownBinding | Asset | Camera | Instance | InstancePageState | InstancePresence;
+type EditorStore = Store<EditorRecord, EditorStoreProps>;
+type EditorStoreSnapshot = StoreSnapshot<EditorRecord>;
+interface EditorStoreProps {
+    defaultName: string;
+}
+interface CreateStoreOptions {
+    migrations?: MigrationSequence[];
+    initialData?: SerializedStore<EditorRecord>;
+    snapshot?: EditorStoreSnapshot;
+    defaultName?: string;
+    id?: string;
+}
+declare function createSchema(migrations?: MigrationSequence[]): StoreSchema<EditorRecord, EditorStoreProps>;
+/** Create a store with the editor's record types. */
+declare function createStore(options?: CreateStoreOptions): EditorStore;
+
+/** Interns string ids to dense u32 engine handles. Handle 0 is reserved. */
+declare class HandleTable {
+    private toHandle;
+    private toId;
+    private free;
+    get size(): number;
+    handle(id: string): number;
+    peek(id: string): number | undefined;
+    id(handle: number): string | undefined;
+    release(id: string): number | undefined;
+    clear(): void;
+}
+
+/** Produces the pixels for a texture. Rejecting marks the texture as failed. */
+type TextureLoader = () => Promise<TextureSource>;
+type TextureState = "pending" | "ready" | "error";
+interface TextureInfo {
+    /** Host texture id, `1`-based. `StyleWords.texture` references it. */
+    readonly id: number;
+    /** Number of outstanding `acquire` calls. */
+    readonly refs: number;
+    readonly state: TextureState;
+    /** Pixel size of the decoded source; `0` until it is ready. */
+    readonly width: number;
+    readonly height: number;
+}
+interface TextureManagerOptions {
+    /**
+     * Called (in a microtask) with the keys whose state just changed, so the host
+     * can re-write the shapes holding them and redraw.
+     */
+    onChange?: (keys: readonly string[]) => void;
+}
+/** Largest device-pixel scale a rasterized texture is rendered at. */
+declare const MAX_TEXTURE_RESOLUTION = 8;
+/** Largest zoom factor that still increases texture resolution. */
+declare const MAX_TEXTURE_ZOOM = 4;
+/**
+ * `dpr × min(MAX_TEXTURE_ZOOM, zoom)` snapped up to a power of two, so panning
+ * and zooming only re-rasterize a texture when it crosses a bucket boundary.
+ */
+declare function bucketTextureResolution(zoom: number, dpr?: number): number;
+/**
+ * Owns the host's GPU textures: allocates ids, refcounts them by key, loads
+ * their pixels asynchronously and uploads them through the current
+ * `RenderBackend`.
+ *
+ * `acquire` hands back the id straight away so a shape can be written to the
+ * engine in the same tick; the texture only appears once the load resolves, so
+ * callers keep a DOM fallback until `isReady(key)`. A key whose load rejected
+ * resolves to `0` (no texture — the shape falls back to its plain fill).
+ *
+ * Callers that re-derive their textures on every write (a `ShapeUtil` in
+ * `getRenderStyle`) should acquire inside `withOwner`, which reconciles the
+ * keys an owner holds instead of piling up references.
+ */
+declare class TextureManager {
+    private readonly options;
+    private readonly entries;
+    /** owner id → keys that owner currently holds a reference to. */
+    private readonly ownerKeys;
+    /** key → owner ids, so the host can find the shapes to re-write. */
+    private readonly keyOwners;
+    private backend;
+    private nextId;
+    private disposed;
+    private owner;
+    private touched;
+    constructor(options?: TextureManagerOptions);
+    /** Number of live texture entries. */
+    get size(): number;
+    getBackend(): RenderBackend | null;
+    /**
+     * Reference the texture for `key`, starting `load` the first time. Returns
+     * the host texture id, or `0` when the key previously failed to load.
+     */
+    acquire(key: string, load: TextureLoader, opts?: TextureOptions): number;
+    /** Drop one reference. The texture is deleted when the last one goes. */
+    release(key: string): void;
+    /** Whether the texture for `key` is uploaded and safe to draw. */
+    isReady(key: string): boolean;
+    getState(key: string): TextureState | undefined;
+    /** Current id for `key`: `0` when unknown or failed. */
+    getId(key: string): number;
+    getInfo(key: string): TextureInfo | undefined;
+    /** Owners (shape ids) currently holding `key`. */
+    getOwners(key: string): readonly string[];
+    /** Every owner holding at least one texture. */
+    getAllOwners(): readonly string[];
+    /**
+     * Run `fn` with every `acquire` inside it attributed to `owner`. Keys the
+     * owner held before but did not acquire again are released, so re-deriving a
+     * shape's style neither leaks references nor keeps a stale texture alive.
+     */
+    withOwner<T>(owner: string, fn: () => T): T;
+    /** Release every key an owner holds (the shape was deleted). */
+    releaseOwner(owner: string): void;
+    /**
+     * Point the manager at the backend that owns the GPU textures. Everything
+     * already decoded is uploaded again; anything still loading uploads when it
+     * resolves. The previous backend keeps (and frees) its own GL objects.
+     */
+    setBackend(backend: RenderBackend | null): void;
+    dispose(): void;
+    private addOwner;
+    private removeOwner;
+    private load;
+    private upload;
+    private destroy;
+}
+
+/** Style value unions shared by the default shapes. Kept identical for file compatibility. */
+declare const DEFAULT_COLORS: readonly ["black", "grey", "light-violet", "violet", "blue", "light-blue", "yellow", "orange", "green", "light-green", "light-red", "red", "white"];
+type DefaultColorStyle$1 = (typeof DEFAULT_COLORS)[number];
+declare const DEFAULT_FILLS: readonly ["none", "semi", "solid", "pattern", "fill"];
+type DefaultFillStyle$1 = (typeof DEFAULT_FILLS)[number];
+declare const DEFAULT_DASHES: readonly ["draw", "solid", "dashed", "dotted"];
+type DefaultDashStyle$1 = (typeof DEFAULT_DASHES)[number];
+declare const DEFAULT_SIZES: readonly ["s", "m", "l", "xl"];
+type DefaultSizeStyle$1 = (typeof DEFAULT_SIZES)[number];
+declare const DEFAULT_FONTS: readonly ["draw", "sans", "serif", "mono"];
+type DefaultFontStyle$1 = (typeof DEFAULT_FONTS)[number];
+declare const DEFAULT_H_ALIGNS: readonly ["start", "middle", "end", "start-legacy", "end-legacy", "middle-legacy"];
+type DefaultHorizontalAlignStyle$1 = (typeof DEFAULT_H_ALIGNS)[number];
+declare const DEFAULT_V_ALIGNS: readonly ["start", "middle", "end"];
+type DefaultVerticalAlignStyle$1 = (typeof DEFAULT_V_ALIGNS)[number];
+declare const GEO_SHAPE_KINDS: readonly ["rectangle", "ellipse", "triangle", "diamond", "pentagon", "hexagon", "octagon", "star", "rhombus", "rhombus-2", "oval", "trapezoid", "arrow-right", "arrow-left", "arrow-up", "arrow-down", "x-box", "check-box", "cloud", "heart"];
+type GeoShapeKind = (typeof GEO_SHAPE_KINDS)[number];
+/** Stroke widths in page units per size, matching the classic look. */
+declare const STROKE_SIZES: Record<DefaultSizeStyle$1, number>;
+declare const FONT_SIZES: Record<DefaultSizeStyle$1, number>;
+interface ThemeColor {
+    solid: string;
+    semi: string;
+    pattern: string;
+    fill: string;
+    note: {
+        fill: string;
+        text: string;
+    };
+    highlight: {
+        srgb: string;
+        p3: string;
+    };
+}
+/**
+ * A palette in the spirit of the classic light theme. Values are our own picks:
+ * hue-matched, tuned for contrast on white and on the semi fills.
+ */
+declare const LIGHT_THEME: Record<DefaultColorStyle$1, ThemeColor> & {
+    background: string;
+    solid: string;
+    text: string;
+};
+/** Parse `#rrggbb` or `#rrggbbaa` to the engine's `0xRRGGBBAA`. */
+declare function hexToRgba(hex: string, alpha?: number): number;
+
+/**
+ * A shape prop that is a *style*: shared across shape types, remembered for
+ * the next created shape, and editable for a whole selection at once.
+ */
+declare class StyleProp<T> {
+    readonly id: string;
+    readonly defaultValue: T;
+    private readonly validator?;
+    /** Define a style with a free-form value. */
+    static define<T>(id: string, options: {
+        defaultValue: T;
+        validate?: (value: unknown) => T;
+    }): StyleProp<T>;
+    /** Define a style whose value is one of a fixed set of strings. */
+    static defineEnum<const V extends readonly string[]>(id: string, options: {
+        defaultValue: V[number];
+        values: V;
+    }): EnumStyleProp<V[number]>;
+    protected constructor(id: string, defaultValue: T, validator?: ((value: unknown) => T) | undefined);
+    validate(value: unknown): T;
+}
+declare class EnumStyleProp<T extends string> extends StyleProp<T> {
+    readonly values: readonly T[];
+    constructor(id: string, defaultValue: T, values: readonly T[]);
+}
+declare const GeoShapeGeoStyle: EnumStyleProp<"rectangle" | "ellipse" | "triangle" | "diamond" | "pentagon" | "hexagon" | "octagon" | "star" | "rhombus" | "rhombus-2" | "oval" | "trapezoid" | "arrow-right" | "arrow-left" | "arrow-up" | "arrow-down" | "x-box" | "check-box" | "cloud" | "heart">;
+
+declare const DefaultColorStyle: EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+type DefaultColorStyle = DefaultColorStyle$1;
+declare const DefaultLabelColorStyle: EnumStyleProp<"black" | "grey" | "light-violet" | "violet" | "blue" | "light-blue" | "yellow" | "orange" | "green" | "light-green" | "light-red" | "red" | "white">;
+type DefaultLabelColorStyle = DefaultColorStyle$1;
+declare const DefaultFillStyle: EnumStyleProp<"fill" | "none" | "semi" | "solid" | "pattern">;
+type DefaultFillStyle = DefaultFillStyle$1;
+declare const DefaultDashStyle: EnumStyleProp<"solid" | "draw" | "dashed" | "dotted">;
+type DefaultDashStyle = DefaultDashStyle$1;
+declare const DefaultSizeStyle: EnumStyleProp<"s" | "m" | "l" | "xl">;
+type DefaultSizeStyle = DefaultSizeStyle$1;
+declare const DefaultFontStyle: EnumStyleProp<"draw" | "sans" | "serif" | "mono">;
+type DefaultFontStyle = DefaultFontStyle$1;
+declare const DefaultHorizontalAlignStyle: EnumStyleProp<"start" | "middle" | "end" | "start-legacy" | "end-legacy" | "middle-legacy">;
+type DefaultHorizontalAlignStyle = DefaultHorizontalAlignStyle$1;
+declare const DefaultVerticalAlignStyle: EnumStyleProp<"start" | "middle" | "end">;
+type DefaultVerticalAlignStyle = DefaultVerticalAlignStyle$1;
+type SharedStyle<T> = {
+    type: "shared";
+    value: T;
+} | {
+    type: "mixed";
+};
+/** Styles shared by a set of shapes: one entry per style prop, `mixed` when values differ. */
+declare class SharedStyleMap {
+    private readonly map;
+    get size(): number;
+    get<T>(prop: StyleProp<T>): SharedStyle<T> | undefined;
+    getAsKnownValue<T>(prop: StyleProp<T>): T | undefined;
+    has(prop: StyleProp<unknown>): boolean;
+    /** Record a value seen on a shape. */
+    applyValue<T>(prop: StyleProp<T>, value: T): void;
+    [Symbol.iterator](): IterableIterator<[StyleProp<unknown>, SharedStyle<unknown>]>;
+    keys(): IterableIterator<StyleProp<unknown>>;
+}
+/** Style props declared on a ShapeUtil's `static props` map, by prop key. */
+declare function getStylePropsOf(props: Record<string, unknown> | undefined): Map<string, StyleProp<unknown>>;
+
+/**
+ * Undo/redo over store diffs. Every user-sourced document change is recorded;
+ * marks delimit undo steps. Undo applies the reverse of every diff back to the
+ * previous mark.
+ */
+declare class HistoryManager<R extends UnknownRecord> {
+    private readonly store;
+    private readonly onBatchComplete?;
+    private undos;
+    private redos;
+    private ignoring;
+    private pendingDiff;
+    private readonly _version;
+    private readonly dispose;
+    constructor(store: Store<R>, onBatchComplete?: (() => void) | undefined);
+    private pushDiff;
+    /** Reactive counter for UI. */
+    getVersion(): number;
+    getNumUndos(): number;
+    getNumRedos(): number;
+    /** Run `fn` without recording its changes. */
+    ignore<T>(fn: () => T): T;
+    /** Place a stopping point. Returns the mark id. */
+    mark(id?: string): string;
+    private apply;
+    undo(): this;
+    redo(): this;
+    /** Undo to the previous mark and drop the undone entries (no redo). */
+    bail(): this;
+    /** Undo back to a specific mark and drop the entries. */
+    bailToMark(id: string): this;
+    /** Merge every diff since `id` into one step (the mark stays). */
+    squashToMark(id: string): this;
+    clear(): void;
+    private step;
+    destroy(): void;
+}
+
+interface SnapLine {
+    id: string;
+    /** Page-space points along the line (at least two). */
+    points: Vec[];
+}
+interface SnapResult {
+    /** Adjustment to add to the proposed delta/position. */
+    nudge: Vec;
+    lines: SnapLine[];
+}
+/**
+ * Edge and center snapping against nearby shapes. Candidate shapes are taken
+ * from the engine's spatial index (viewport query), so cost does not grow with
+ * page size.
+ */
+declare class SnapManager {
+    private readonly editor;
+    private readonly _lines;
+    /** Snap distance in screen pixels. */
+    threshold: number;
+    constructor(editor: Editor);
+    getLines(): SnapLine[];
+    clearLines(): void;
+    /** Bounds of shapes near the viewport that are not being moved. */
+    private getSnapTargets;
+    private static pointsOf;
+    /**
+     * Snap a moving box (already offset by the proposed delta) to nearby shapes.
+     * Returns the extra nudge to apply and the guide lines to show.
+     */
+    snapTranslate(moving: BoxLike, exclude: ReadonlySet<ShapeId>, opts?: {
+        lockX?: boolean;
+        lockY?: boolean;
+    }): SnapResult;
+}
+
+interface EditorOptions {
+    store: EditorStore;
+    shapeUtils: readonly ShapeUtilConstructor[];
+    bindingUtils?: readonly BindingUtilConstructor[];
+    tools: readonly StateNodeConstructor[];
+    engine: EngineBridge;
+    /** Id of the tool to start in. Defaults to the first tool. */
+    initialState?: string;
+    getContainer: () => HTMLElement;
+    options?: Partial<EditorConfig>;
+}
+interface EditorConfig {
+    maxShapesPerPage: number;
+    dragDistanceSquared: number;
+    /** Hit-test tolerance in screen pixels. */
+    hitTestMargin: number;
+    zoomMin: number;
+    zoomMax: number;
+    zoomSteps: number[];
+    backgroundColor: [number, number, number, number];
+    animationMediumMs: number;
+}
+declare const DEFAULT_EDITOR_CONFIG: EditorConfig;
+interface EditorInputs {
+    originPagePoint: Vec;
+    originScreenPoint: Vec;
+    previousPagePoint: Vec;
+    previousScreenPoint: Vec;
+    currentPagePoint: Vec;
+    currentScreenPoint: Vec;
+    keys: Set<string>;
+    buttons: Set<number>;
+    isPen: boolean;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+    isDragging: boolean;
+    isPointing: boolean;
+    isPinching: boolean;
+    isEditing: boolean;
+    isPanning: boolean;
+    pointerVelocity: Vec;
+}
+interface HitTestOptions {
+    margin?: number;
+    hitInside?: boolean;
+    hitLocked?: boolean;
+    hitFrameInside?: boolean;
+    filter?: (shape: UnknownShape) => boolean;
+}
+/**
+ * The editor: document access, selection, camera, tool dispatch, and the
+ * bridge that mirrors the current page into the WASM engine.
+ */
+declare class Editor extends EventEmitter<EditorEvents> {
+    readonly store: EditorStore;
+    readonly engine: EngineBridge;
+    readonly history: HistoryManager<EditorRecord>;
+    readonly root: StateNode;
+    readonly shapeUtils: Readonly<Record<string, ShapeUtil>>;
+    readonly bindingUtils: Readonly<Record<string, BindingUtil>>;
+    readonly options: EditorConfig;
+    readonly inputs: EditorInputs;
+    readonly handles: HandleTable;
+    /** GPU textures referenced by shape styles (images, rasterized text). */
+    readonly textures: TextureManager;
+    readonly snaps: SnapManager;
+    readonly getContainer: () => HTMLElement;
+    readonly sideEffects: EditorStore["sideEffects"];
+    private readonly kindIds;
+    private readonly _frameEpoch;
+    private readonly _overlayShapeIds;
+    private readonly _overlayClips;
+    private readonly _isDisposed;
+    private readonly _lastFrame;
+    private readonly disposables;
+    private syncedPageId;
+    /** Shapes whose last write to the engine threw; they are warned about once. */
+    private readonly brokenShapeIds;
+    constructor(opts: EditorOptions);
+    dispose(): void;
+    getIsDisposed(): boolean;
+    private ensureBaseRecords;
+    private ensurePageSessionRecords;
+    /** Increments whenever the GPU frame must be redrawn. */
+    getFrameEpoch(): number;
+    private bumpFrame;
+    /** Stats for the last rendered frame. */
+    getLastFrameStats(): {
+        drawn: number;
+        culled: number;
+        ms: number;
+    };
+    /** Shapes the DOM overlay must render this frame, in draw order. */
+    getOverlayShapeIds(): readonly ShapeId[];
+    /**
+     * Page-space clip rects for the overlay shapes, parallel to
+     * `getOverlayShapeIds()`; `undefined` where the shape is unclipped.
+     */
+    getOverlayClips(): readonly (ClipRect | undefined)[];
+    run<T>(fn: () => T, opts?: {
+        history?: "record" | "ignore" | "record-preserveRedoStack";
+    }): T;
+    /** @deprecated use `run` */
+    batch<T>(fn: () => T): T;
+    markHistoryStoppingPoint(name?: string): string;
+    /** Alias of `markHistoryStoppingPoint`. */
+    mark(name?: string): string;
+    undo(): this;
+    redo(): this;
+    bail(): this;
+    bailToMark(id: string): this;
+    squashToMark(id: string): this;
+    getCanUndo(): boolean;
+    getCanRedo(): boolean;
+    getDocumentSettings(): Document;
+    updateDocumentSettings(settings: Partial<Omit<Document, "id" | "typeName">>): this;
+    private readonly _pages;
+    getPages(): Page[];
+    getPage(id: PageId): Page | undefined;
+    getInstanceState(): Instance;
+    updateInstanceState(partial: Partial<Omit<Instance, "id" | "typeName">>): this;
+    getCurrentPageId(): PageId;
+    getCurrentPage(): Page;
+    setCurrentPage(pageId: PageId): this;
+    createPage(page?: Partial<Omit<Page, "id" | "typeName" | "index">> & {
+        id?: PageId;
+    }): this;
+    deletePage(id: PageId): this;
+    renamePage(id: PageId, name: string): this;
+    getCurrentPageState(): InstancePageState;
+    updateCurrentPageState(partial: Partial<Omit<InstancePageState, "id" | "typeName" | "pageId">>): this;
+    private readonly _allShapes;
+    private readonly _currentPageShapes;
+    private readonly _currentPageShapeIds;
+    getShape<T extends UnknownShape = UnknownShape>(id: ShapeId | T): T | undefined;
+    getShapeUtil<T extends UnknownShape>(shape: T | T["type"]): ShapeUtil<T>;
+    hasShapeUtil(type: string): boolean;
+    getCurrentPageShapes(): UnknownShape[];
+    getCurrentPageShapeIds(): Set<ShapeId>;
+    getCurrentPageShapesSorted(): UnknownShape[];
+    getPageShapeIds(pageId: PageId): ShapeId[];
+    getAncestorPageId(shape: UnknownShape | ShapeId | undefined): PageId | undefined;
+    getShapeParent(shape: UnknownShape | ShapeId): UnknownShape | undefined;
+    getSortedChildIdsForParent(parentId: ParentId): ShapeId[];
+    getHighestIndexForParent(parentId: ParentId): IndexKey;
+    getShapeGeometry<G extends Geometry2d = Geometry2d>(shape: UnknownShape | ShapeId): G;
+    /** Local → parent transform components. */
+    getShapeLocalTransform(shape: UnknownShape): {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        e: number;
+        f: number;
+    };
+    getShapeParentTransform(shape: UnknownShape): {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        e: number;
+        f: number;
+    };
+    getShapePageTransform(shape: UnknownShape | ShapeId): {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        e: number;
+        f: number;
+    };
+    getShapePageBounds(shape: UnknownShape | ShapeId): Box | undefined;
+    getShapeGeometryBounds(shape: UnknownShape | ShapeId): Box | undefined;
+    /** Transform a page point into the shape's local space. */
+    getPointInShapeSpace(shape: UnknownShape | ShapeId, point: VecLike): Vec;
+    getPointInParentSpace(shape: UnknownShape | ShapeId, point: VecLike): Vec;
+    getShapeParentAtPoint(_point: VecLike): UnknownShape | undefined;
+    private hitFilterBits;
+    getShapeAtPoint(point: VecLike, opts?: HitTestOptions): UnknownShape | undefined;
+    /** Shapes under a point, topmost first. */
+    getShapesAtPoint(point: VecLike, opts?: HitTestOptions): UnknownShape[];
+    /** Shapes fully inside a page box, in draw order. */
+    getShapesInsideBounds(box: BoxLike, opts?: HitTestOptions): UnknownShape[];
+    /** Shapes whose outline touches a page box, in draw order. */
+    getShapesIntersectingBounds(box: BoxLike, opts?: HitTestOptions): UnknownShape[];
+    private handlesToShapes;
+    /**
+     * Union of every shape's page bounds on the current page, or undefined when
+     * the page is empty.
+     *
+     * Geometry, not ink: this is the union of `getShapePageBounds()` and excludes
+     * the half-stroke pad the engine keeps for culling. The pad is per-shape, so
+     * including it would both inflate the box and shift its centre whenever the
+     * outermost shapes carry different stroke widths.
+     */
+    getCurrentPageBounds(): Box | undefined;
+    createShape<T extends UnknownShape>(partial: ShapeCreate<T>): this;
+    createShapes<T extends UnknownShape>(partials: readonly ShapeCreate<T>[]): this;
+    updateShape<T extends UnknownShape>(partial: ShapePartial<T> | null | undefined): this;
+    updateShapes<T extends UnknownShape>(partials: readonly (ShapePartial<T> | null | undefined)[]): this;
+    deleteShape(id: ShapeId | UnknownShape): this;
+    deleteShapes(ids: readonly (ShapeId | UnknownShape)[]): this;
+    reparentShapes(ids: readonly ShapeId[], parentId: ParentId, insertIndex?: IndexKey): this;
+    private readonly _allBindings;
+    getBindingUtil<B extends UnknownBinding>(binding: B | B["type"]): BindingUtil<B>;
+    hasBindingUtil(type: string): boolean;
+    getBinding<B extends UnknownBinding = UnknownBinding>(id: BindingId): B | undefined;
+    getBindingsFromShape<B extends UnknownBinding = UnknownBinding>(shape: UnknownShape | ShapeId, type?: B["type"]): B[];
+    getBindingsToShape<B extends UnknownBinding = UnknownBinding>(shape: UnknownShape | ShapeId, type?: B["type"]): B[];
+    getBindingsInvolvingShape<B extends UnknownBinding = UnknownBinding>(shape: UnknownShape | ShapeId, type?: B["type"]): B[];
+    createBinding<B extends UnknownBinding>(partial: BindingCreate<B>): this;
+    createBindings<B extends UnknownBinding>(partials: readonly BindingCreate<B>[]): this;
+    updateBinding<B extends UnknownBinding>(partial: BindingPartial<B>): this;
+    updateBindings<B extends UnknownBinding>(partials: readonly BindingPartial<B>[]): this;
+    deleteBinding(id: BindingId | UnknownBinding, opts?: {
+        isolateShapes?: boolean;
+    }): this;
+    deleteBindings(ids: readonly (BindingId | UnknownBinding)[], opts?: {
+        isolateShapes?: boolean;
+    }): this;
+    /** Store side effects that keep bindings consistent with their shapes. */
+    private registerBindingSideEffects;
+    /** Duplicate shapes (and their descendants) with new ids, offset by `offset` in page space. Returns the new top-level ids. */
+    duplicateShapes(ids?: readonly ShapeId[], offset?: VecLike): ShapeId[];
+    /** Serializable content for the clipboard: shapes (with descendants) and bindings between them. */
+    getContentFromCurrentPage(ids: readonly ShapeId[]): {
+        shapes: UnknownShape[];
+        bindings: UnknownBinding[];
+    } | undefined;
+    /** Insert clipboard content at a page point (centered), with fresh ids. Returns the new ids. */
+    putContentOntoCurrentPage(content: {
+        shapes: UnknownShape[];
+        bindings?: UnknownBinding[];
+    }, opts?: {
+        point?: VecLike;
+        select?: boolean;
+    }): ShapeId[];
+    private readonly stylePropCache;
+    /** Style props declared by the ShapeUtil for a type, keyed by prop name. */
+    getStylePropsForType(type: string): Map<string, StyleProp<unknown>>;
+    getStyleForNextShape<T>(style: StyleProp<T>): T;
+    setStyleForNextShapes<T>(style: StyleProp<T>, value: T): this;
+    /** Set a style on every selected shape that declares it. */
+    setStyleForSelectedShapes<T>(style: StyleProp<T>, value: T): this;
+    /** Styles of the selection (or of the next shape when nothing is selected). */
+    getSharedStyles(): SharedStyleMap;
+    /** Move shapes by a page-space offset. */
+    nudgeShapes(ids: readonly ShapeId[], offset: VecLike): this;
+    /** Rotate shapes by `delta` radians around the center of their common page bounds. */
+    rotateShapesBy(ids: readonly ShapeId[], delta: number, center?: VecLike): this;
+    /** Mirror shapes across the center of their common bounds. Positions flip; geometry is not mirrored. */
+    flipShapes(ids: readonly ShapeId[], operation: "horizontal" | "vertical"): this;
+    /** Align shapes along an edge or center of their common bounds. */
+    alignShapes(ids: readonly ShapeId[], operation: "left" | "center-horizontal" | "right" | "top" | "center-vertical" | "bottom"): this;
+    /** Space shapes evenly between the first and last along an axis. */
+    distributeShapes(ids: readonly ShapeId[], operation: "horizontal" | "vertical"): this;
+    /** Stack shapes edge to edge with a fixed gap along an axis (order by current position). */
+    stackShapes(ids: readonly ShapeId[], operation: "horizontal" | "vertical", gap?: number): this;
+    /** Toggle the locked state of shapes. */
+    toggleLock(ids?: readonly ShapeId[]): this;
+    /** Wrap shapes in a new `group` shape (requires a registered "group" ShapeUtil). Returns the group id. */
+    groupShapes(ids?: readonly ShapeId[], groupId?: ShapeId): ShapeId | undefined;
+    /** Dissolve groups, re-parenting their children to the group's parent. */
+    ungroupShapes(ids?: readonly ShapeId[]): this;
+    /** The outermost group containing a shape, or undefined. */
+    getOutermostSelectableShape(shape: UnknownShape | ShapeId): UnknownShape | undefined;
+    bringToFront(ids?: readonly ShapeId[]): this;
+    sendToBack(ids?: readonly ShapeId[]): this;
+    bringForward(ids?: readonly ShapeId[]): this;
+    sendBackward(ids?: readonly ShapeId[]): this;
+    private reorder;
+    getSelectedShapeIds(): ShapeId[];
+    getSelectedShapes(): UnknownShape[];
+    getOnlySelectedShape(): UnknownShape | undefined;
+    setSelectedShapes(ids: readonly (ShapeId | UnknownShape)[]): this;
+    select(...ids: (ShapeId | UnknownShape)[]): this;
+    selectAll(): this;
+    selectNone(): this;
+    isShapeOrAncestorLocked(shape: UnknownShape | ShapeId): boolean;
+    private readonly _selectionPageBounds;
+    getSelectionPageBounds(): Box | undefined;
+    getSelectionRotation(): number;
+    getHoveredShapeId(): ShapeId | null;
+    getHoveredShape(): UnknownShape | undefined;
+    setHoveredShape(id: ShapeId | UnknownShape | null): this;
+    getEditingShapeId(): ShapeId | null;
+    getEditingShape(): UnknownShape | undefined;
+    setEditingShape(id: ShapeId | UnknownShape | null): this;
+    setErasingShapes(ids: readonly ShapeId[]): this;
+    getErasingShapeIds(): ShapeId[];
+    private cameraId;
+    getCamera(): Camera;
+    getZoomLevel(): number;
+    setCamera(point: Partial<VecModel>, _opts?: {
+        animation?: {
+            duration: number;
+        };
+    }): this;
+    getViewportScreenBounds(): Box;
+    getViewportScreenCenter(): Vec;
+    getViewportPageBounds(): Box;
+    getViewportPageCenter(): Vec;
+    updateViewportScreenBounds(bounds: Box | BoxLike, center?: boolean): this;
+    /** Screen (container-relative) → page. */
+    screenToPage(point: VecLike): Vec;
+    /** Page → screen (container-relative). */
+    pageToScreen(point: VecLike): Vec;
+    /** Zoom keeping the given screen point fixed. */
+    zoomToPointAt(screenPoint: VecLike, nextZoom: number): this;
+    zoomIn(point?: VecLike): this;
+    zoomOut(point?: VecLike): this;
+    resetZoom(point?: VecLike): this;
+    zoomToBounds(bounds: BoxLike, opts?: {
+        inset?: number;
+        targetZoom?: number;
+    }): this;
+    zoomToFit(): this;
+    zoomToSelection(): this;
+    centerOnPoint(point: VecLike): this;
+    pan(offsetScreen: VecLike): this;
+    getCurrentTool(): StateNode;
+    getCurrentToolId(): string;
+    setCurrentTool(id: string, info?: Record<string, unknown>): this;
+    getPath(): string;
+    isIn(path: string): boolean;
+    isInAny(...paths: string[]): boolean;
+    getStateDescendant<T extends StateNode>(path: string): T | undefined;
+    cancel(): this;
+    complete(): this;
+    interrupt(): this;
+    private modifierState;
+    /** Route an event to the tool tree, updating `inputs` first. */
+    dispatch(info: EventInfo): this;
+    private updatePointer;
+    private handleWheel;
+    private kindId;
+    /** Apply pending engine commands. Cheap when nothing is pending. */
+    flushEngine(): void;
+    private syncChanges;
+    /** Clear the engine and upload every shape on `pageId`. */
+    private syncPage;
+    /**
+     * Write one shape to the engine, isolating it from its siblings.
+     *
+     * A shape util can throw on a shape it does not fully understand (a prop a
+     * file left out, a value it did not expect). That must cost that one shape,
+     * never the rest of the page: the failure is logged once and the shape is
+     * skipped, so a single bad record can no longer blank the canvas.
+     */
+    private writeShapeToEngine;
+    private writeShapeToEngineUnsafe;
+    /** Build and draw one frame. Called by the canvas component inside rAF. */
+    renderFrame(backend: RenderBackend): FrameBuffers;
+    /**
+     * Device-pixel scale at which rasterized textures (text labels) should be
+     * drawn: the device pixel ratio times the zoom, bucketed to powers of two.
+     */
+    getTextureResolution(): number;
+    private textureResolution;
+    /** Re-derive texture-backed styles when the resolution bucket changes. */
+    private syncTextureResolution;
+    private registerTextureSideEffects;
+    /** A texture finished (or failed) loading: re-write its shapes and redraw. */
+    private onTexturesChanged;
+    private rewriteTextureOwners;
+    /** Degrees → radians. */
+    static degToRad(d: number): number;
+    private readonly _allAssets;
+    getAsset<A extends Asset = Asset>(id: AssetId | A): A | undefined;
+    /** Every asset in the document (assets are not per page). */
+    getAssets(): Asset[];
+    createAsset<A extends Asset>(asset: AssetCreate<A>): this;
+    createAssets<A extends Asset>(assets: readonly AssetCreate<A>[]): this;
+    updateAsset<A extends Asset>(partial: AssetPartial<A>): this;
+    updateAssets<A extends Asset>(partials: readonly AssetPartial<A>[]): this;
+    deleteAsset(id: AssetId | Asset): this;
+    deleteAssets(ids: readonly (AssetId | Asset)[]): this;
+    private readonly externalContentHandlers;
+    private readonly externalAssetHandlers;
+    /**
+     * Register the handler for one kind of dropped/pasted content. Replaces any
+     * previous handler for that type; `null` removes it. Returns a function that
+     * removes the handler again (only if it is still the registered one).
+     */
+    registerExternalContentHandler<T extends ExternalContentType>(type: T, handler: ExternalContentHandler<T> | null): () => void;
+    /** Register how an asset record is produced from a file or url. Returns a function that removes it again. */
+    registerExternalAssetHandler<T extends ExternalAssetType>(type: T, handler: ExternalAssetHandler<T> | null): () => void;
+    hasExternalContentHandler(type: ExternalContentType): boolean;
+    hasExternalAssetHandler(type: ExternalAssetType): boolean;
+    /**
+     * Handle content dropped or pasted onto the canvas by dispatching to the
+     * registered handler for `info.type`. Resolves once the handler is done;
+     * resolves immediately when no handler is registered.
+     */
+    putExternalContent(info: ExternalContent): Promise<void>;
+    /**
+     * Produce (but do not store) an asset record for a file or url through the
+     * registered asset handler. `undefined` when there is no handler or the
+     * handler declines the content.
+     */
+    getAssetForExternalContent(info: ExternalAssetContent): Promise<Asset | undefined>;
+    /**
+     * The local person's identity: a random id for this session plus a name and
+     * a colour that can be changed at any time. Session-only, never persisted.
+     */
+    readonly user: UserPreferences;
+    /** Presence records of everyone else in the room, in arrival order. */
+    getCollaborators(): InstancePresence[];
+    /** The subset of `getCollaborators()` looking at the page we are on. */
+    getCollaboratorsOnCurrentPage(): InstancePresence[];
+    /**
+     * Scale one shape by `scale` about a point, letting its `ShapeUtil.onResize`
+     * produce the prop change — the same contract the select tool's resize state
+     * uses. The shape's origin is moved by the same scale about `scaleOrigin`
+     * (its page bounds center by default), measured in a frame rotated by
+     * `scaleAxisRotation`.
+     *
+     * Locked shapes and shapes whose util says `canResize` is false are left
+     * alone. `onResizeStart` / `onResizeEnd` bracket the change; the util is
+     * told the resize came from the `bottom_right` handle.
+     */
+    resizeShape(id: ShapeId | UnknownShape, scale: VecLike, options?: ResizeShapeOptions): this;
+    /**
+     * Scale several shapes by the same factor about one point — by default the
+     * center of their common page bounds, so the group scales as a unit.
+     */
+    resizeShapes(ids: readonly (ShapeId | UnknownShape)[], scale: VecLike, options?: Omit<ResizeShapeOptions, "initialBounds">): this;
+    /**
+     * Resize shapes so each one spans the common bounds of all of them on one
+     * axis. Every shape given contributes to the common bounds, but only the
+     * unlocked, resizable ones are stretched.
+     */
+    stretchShapes(ids: readonly ShapeId[], operation: "horizontal" | "vertical"): this;
+    /**
+     * Serialize shapes to an SVG string; `undefined` when there is nothing to
+     * export. Defaults to the selection, or the whole page when nothing is
+     * selected. Throws until an export implementation is registered.
+     */
+    getSvgString(ids?: readonly ShapeId[], opts?: EditorSvgExportOptions): EditorSvgExportResult | undefined;
+    /**
+     * Render shapes to an image blob (`png` by default). Same shape selection
+     * rules as `getSvgString`. Throws until an export implementation is
+     * registered.
+     */
+    toImage(ids?: readonly ShapeId[], opts?: EditorImageExportOptions): Promise<EditorImageExportResult>;
+    /**
+     * Measures runs of text the way the editor renders them. Installed through
+     * the same seam as the export functions; throws until something registers
+     * one.
+     */
+    get textMeasure(): EditorTextMeasure;
+    /** Which menus are open right now. Backed by the `instance` session record. */
+    readonly menus: MenuManager;
+}
+interface ResizeShapeOptions {
+    /** Shape-local bounds the scale is measured against. Defaults to the shape's geometry bounds. */
+    initialBounds?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** Page point that stays put. Defaults to the center of the shape's page bounds. */
+    scaleOrigin?: VecLike;
+    /** Rotation (radians) of the frame the scale axes are measured in. Defaults to 0. */
+    scaleAxisRotation?: number;
+    /** Force (or forbid) a uniform scale. Defaults to the util's `isAspectRatioLocked`. */
+    isAspectRatioLocked?: boolean;
+    /** Handed to `onResize`. Defaults to `"scale_shape"`. */
+    mode?: "scale_shape" | "resize_bounds";
+}
+interface EditorSvgExportOptions {
+    /** Page units added around the shapes' bounds. */
+    padding?: number;
+    /** Paint a full-size background rectangle. */
+    background?: boolean;
+    /** Multiplier applied to the output `width`/`height`. */
+    scale?: number;
+    /** Use the dark background colour. */
+    darkMode?: boolean;
+}
+interface EditorSvgExportResult {
+    svg: string;
+    /** Output size in CSS pixels (bounds × scale). */
+    width: number;
+    height: number;
+}
+interface EditorImageExportOptions extends EditorSvgExportOptions {
+    /** Output format. Implementations default to `"png"`. */
+    format?: "svg" | "png" | "jpeg" | "webp";
+    /** Encoder quality for lossy formats (0..1). */
+    quality?: number;
+    /** Device pixel ratio multiplier for raster output. */
+    pixelRatio?: number;
+}
+interface EditorImageExportResult {
+    blob: Blob;
+    width: number;
+    height: number;
+}
+interface EditorExportImplementation {
+    getSvgString(editor: Editor, ids?: readonly ShapeId[], opts?: EditorSvgExportOptions): EditorSvgExportResult | undefined;
+    toImage(editor: Editor, ids?: readonly ShapeId[], opts?: EditorImageExportOptions): Promise<EditorImageExportResult>;
+}
+/**
+ * Install the implementation behind `Editor.getSvgString` and `Editor.toImage`.
+ * `mocanvas` calls this at import time; pass `null` to remove it. Returns a
+ * function that removes the implementation again (only if it is still the
+ * registered one).
+ */
+declare function registerExportImplementation(impl: EditorExportImplementation | null): () => void;
+/** The registered export implementation, or `null` when nothing has registered one. */
+declare function getExportImplementation(): EditorExportImplementation | null;
+interface EditorTextMeasureOptions {
+    fontFamily: string;
+    fontSize: number;
+    fontWeight?: string | number;
+    /** Unitless line height (multiplier of the font size). */
+    lineHeight: number;
+    /** Wrap width in CSS px, including `padding`. Omit for a single unwrapped run per paragraph. */
+    maxWidth?: number;
+    /** Padding applied on every side; included in the returned `w`/`h`. */
+    padding?: number;
+}
+interface EditorTextMeasurement {
+    w: number;
+    h: number;
+    lineCount: number;
+}
+interface EditorTextMeasure {
+    measureText(text: string, opts: EditorTextMeasureOptions): EditorTextMeasurement;
+}
+type EditorTextMeasureProvider = (editor: Editor) => EditorTextMeasure;
+/**
+ * Install the measurer behind `Editor.textMeasure`. `mocanvas` calls this at
+ * import time; pass `null` to remove it. Returns a function that removes the
+ * provider again (only if it is still the registered one).
+ */
+declare function registerTextMeasureImplementation(provider: EditorTextMeasureProvider | null): () => void;
+/** The registered text measure provider, or `null` when nothing has registered one. */
+declare function getTextMeasureProvider(): EditorTextMeasureProvider | null;
+/**
+ * The set of menus that are open, kept in the `instance` session record so it
+ * survives tool changes, is visible to anything reading the store, and is
+ * reactive: reading `getOpenMenus()` inside a signal re-runs it on every change.
+ *
+ * Ids are opaque strings owned by the UI; nothing here interprets them.
+ */
+declare class MenuManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    /** The open menu ids, in the order they were opened. */
+    getOpenMenus(): string[];
+    isMenuOpen(id: string): boolean;
+    /** Mark a menu as open. Opening an already-open menu changes nothing. */
+    addOpenMenu(id: string): this;
+    /** Mark a menu as closed. Closing a menu that is not open changes nothing. */
+    removeOpenMenu(id: string): this;
+    /** Close every open menu. */
+    clearOpenMenus(): this;
+}
+
+/**
+ * Half the size of a selection handle's pointer target, in screen pixels.
+ * 12 gives a 24x24 target, the smallest that stays comfortable on a trackpad
+ * and on touch. It shrinks on small selections — see `getHandleHitRadius`.
+ */
+declare const HANDLE_HIT_RADIUS = 12;
+declare const ROTATE_HANDLE_OFFSET = 20;
+/**
+ * The effective hit radius for the current selection. On a selection smaller
+ * than a few handles across, full-size targets would cover the whole shape and
+ * leave nothing to drag, so the radius shrinks to keep an interior free.
+ */
+declare function getHandleHitRadius(screenW: number, screenH: number): number;
+interface SelectionHandleHit {
+    handle: SelectionHandle;
+    /** Screen-space position of the handle. */
+    point: Vec;
+}
+/**
+ * Screen-space positions of the selection handles for the current selection,
+ * or null if nothing is selected / handles are hidden.
+ */
+declare function getSelectionHandlePositions(editor: Editor): {
+    bounds: Box;
+    rotation: number;
+    handles: SelectionHandleHit[];
+    screenW: number;
+    screenH: number;
+} | null;
+/** The selection handle under a screen point, if any. */
+declare function hitTestSelectionHandles(editor: Editor, screenPoint: VecLike, radius?: number): SelectionHandle | undefined;
+/** Is the screen point inside the selection bounds (for dragging the selection as a whole)? */
+declare function hitTestSelectionBounds(editor: Editor, pagePoint: VecLike): boolean;
+
+/**
+ * Normalization for records read out of a `.tldr` file.
+ *
+ * Files written by different generations of the format spell the same
+ * information in different ways: a shape's label may arrive as a plain string
+ * or as a rich-text document, and a freehand stroke's points may arrive as an
+ * array or as one packed binary blob. Nothing downstream should have to know
+ * that, so the load path runs every record through here first and the shape
+ * utils only ever see the props they declare.
+ *
+ * Everything in this module is pure and total: it never throws, and whatever it
+ * cannot make sense of is reported as a warning string instead.
+ */
+
+/**
+ * Flatten a rich-text document to the plain string mocanvas stores in
+ * `props.text`.
+ *
+ * The document is a tree of `{ type, content?, text? }` nodes. `text` nodes
+ * contribute their string, `hardBreak` nodes a newline, top-level paragraphs
+ * are joined by newlines, and any other node is recursed into so unknown marks
+ * or wrappers still yield their text. `unknownNodeTypes`, when passed, collects
+ * the node types that were not understood.
+ */
+declare function richTextToPlainText(doc: unknown, unknownNodeTypes?: Set<string>): string;
+/** A point of a freehand stroke: position plus pen pressure. */
+interface DecodedDrawPoint {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Decode a packed freehand segment path into its points, or `null` when the
+ * blob is not in the layout we understand.
+ *
+ * Layout, as observed in the files themselves: base64 of a little-endian
+ * buffer holding the first point as three `float32` (x, y, pressure) followed
+ * by one `float16` triple per further point, each a delta from the previous
+ * point.
+ */
+declare function decodeDrawSegmentPath(path: string): DecodedDrawPoint[] | null;
+interface NormalizeOptions {
+    /** The registered shape utils, keyed by shape type. Used for default props. */
+    shapeUtils: Readonly<Record<string, Pick<ShapeUtil, "getDefaultProps">>>;
+}
+interface NormalizeResult {
+    records: UnknownRecord[];
+    warnings: string[];
+}
+/**
+ * Rewrite loaded records so the shape utils see the props they declare.
+ *
+ * Per shape: `props.richText` becomes `props.text` (the rich-text document is
+ * dropped, not kept alongside), packed freehand `segments[].path` becomes
+ * `segments[].points`, and any prop the util declares a default for but the
+ * file omits is filled in from that default. Props the util does not declare
+ * are left untouched so a round trip preserves them, and shapes of a type with
+ * no registered util are passed through unchanged.
+ *
+ * Records are only copied when something actually changes.
+ */
+declare function normalizeLoadedRecords(records: readonly UnknownRecord[], options: NormalizeOptions): NormalizeResult;
+
+/** The root of the tool tree. Its children are the tools. */
+declare class RootState extends StateNode {
+    static id: string;
+    static initial: string;
+    static children: () => StateNodeConstructor[];
+    onKeyDown(info: KeyboardEventInfo): void;
+}
+/** Build a root state class with the given tools and initial tool id. */
+declare function createRootState(tools: readonly StateNodeConstructor[], initial: string): StateNodeConstructor;
+
+/** WebGL2 backend: one interleaved VBO, one IBO, one program, one draw call per batch. */
+declare class WebGL2Backend implements RenderBackend {
+    readonly canvas: HTMLCanvasElement;
+    readonly kind: "webgl2";
+    private readonly gl;
+    private readonly program;
+    private readonly vao;
+    private readonly vbo;
+    private readonly ibo;
+    private readonly uCam;
+    private readonly uVp;
+    /** Texture 0: 1×1 opaque white, so solid batches use the same shader. */
+    private readonly whiteTex;
+    private readonly textures;
+    private vboBytes;
+    private iboBytes;
+    /**
+     * `FrameBuffers.version` currently sitting in the VBO/IBO, or -1 when they hold
+     * nothing usable. The engine's vertex data is page-space, so panning and zooming
+     * change only the camera uniform: while the version is unchanged this skips the
+     * (multi-megabyte, at scale) `bufferSubData` and just re-issues the draw calls.
+     */
+    private uploadedVersion;
+    private width;
+    private height;
+    private pixelWidth;
+    private pixelHeight;
+    private dpr;
+    private disposed;
+    constructor(canvas: HTMLCanvasElement, options?: {
+        antialias?: boolean;
+    });
+    resize(width: number, height: number, dpr: number): void;
+    uploadTexture(id: number, source: TextureSource, opts?: TextureOptions): void;
+    deleteTexture(id: number): void;
+    draw(frame: FrameBuffers, camera: CameraState, options: DrawOptions): void;
+    dispose(): void;
+}
+/**
+ * Create the synchronous WebGL2 backend. For WebGPU (async device setup) or
+ * automatic selection use `createBackendAsync` from `./createBackend`.
+ */
+declare function createBackend(canvas: HTMLCanvasElement): RenderBackend;
+
+interface CanvasProps {
+    editor: Editor;
+    className?: string;
+    style?: CSSProperties;
+    /** Extra layers rendered above the canvas (UI, menus). */
+    children?: ReactNode;
+    /** Override the default selection/brush indicators. */
+    components?: Partial<CanvasComponents>;
+}
+interface CanvasComponents {
+    Indicators: (props: {
+        editor: Editor;
+    }) => ReactNode;
+    Brush: (props: {
+        editor: Editor;
+    }) => ReactNode;
+    Background: (props: {
+        editor: Editor;
+    }) => ReactNode;
+}
+/**
+ * The canvas: a WebGL2 surface driven by the engine, a DOM overlay for shapes
+ * that render through `ShapeUtil.component`, and an SVG layer for indicators.
+ */
+declare function Canvas({ editor, className, style, children, components }: CanvasProps): react.JSX.Element;
+/**
+ * The outline to draw over one shape: whatever its util's `indicator()`
+ * returns, or a rectangle around the shape's geometry bounds when the util has
+ * no indicator (or returns nothing). Both are expressed in *shape-local*
+ * coordinates; the caller wraps them in the shape's page transform.
+ *
+ * Pure and exported so a custom `Indicators` component can reuse the same rule
+ * instead of guessing at it.
+ */
+declare function getShapeIndicatorNode<T extends UnknownShape>(util: {
+    indicator?(shape: T): ReactNode;
+}, shape: T, bounds: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+} | undefined): ReactNode;
+
+declare const EditorContext: react.Context<Editor | null>;
+/** The editor of the nearest `<EditorProvider>` / `<Canvas>`. */
+declare function useEditor(): Editor;
+declare function useMaybeEditor(): Editor | null;
+declare const EditorProvider: react.Provider<Editor | null>;
+
+export { type Asset, type AssetCreate, type AssetId, type AssetPartial, AssetRecordType, type AssetType, type BaseAsset, type BaseBinding, BaseBoxShapeUtil, type BaseEventInfo, type BaseShape, type Binding, type BindingCreate, type BindingId, type BindingOnChangeOptions, type BindingOnCreateOptions, type BindingOnShapeChangeOptions, type BindingOnShapeDeleteOptions, type BindingOnShapeIsolateOptions, type BindingPartial, BindingRecordType, BindingUtil, type BindingUtilConstructor, type BookmarkAsset, type BookmarkAssetProps, Box, type BoxLike, type Camera, type CameraId, CameraRecordType, type CancelEventInfo, Canvas, type CanvasComponents, type CanvasProps, Circle2d, type ClickEventInfo, type ClickEventName, type DefaultColorStyle$1 as ColorValue, type CompleteEventInfo, type CreateStoreOptions, CubicSpline2d, DEFAULT_COLORS, DEFAULT_DASHES, DEFAULT_EDITOR_CONFIG, DEFAULT_FILLS, DEFAULT_FONTS, DEFAULT_H_ALIGNS, DEFAULT_SIZES, DEFAULT_V_ALIGNS, DOCUMENT_ID, type DefaultDashStyle$1 as DashValue, type DecodedDrawPoint, DefaultColorStyle, DefaultDashStyle, DefaultFillStyle, DefaultFontStyle, DefaultHorizontalAlignStyle, DefaultLabelColorStyle, DefaultSizeStyle, DefaultVerticalAlignStyle, type Document, type DocumentId, DocumentRecordType, type DrawOptions, EVENT_NAME_MAP, Edge2d, Editor, type EditorConfig, EditorContext, type EditorEvents, type EditorExportImplementation, type EditorImageExportOptions, type EditorImageExportResult, type EditorInputs, type EditorOptions, EditorProvider, type EditorRecord, type EditorStore, type EditorStoreProps, type EditorStoreSnapshot, type EditorSvgExportOptions, type EditorSvgExportResult, type EditorTextMeasure, type EditorTextMeasureOptions, type EditorTextMeasureProvider, type EditorTextMeasurement, Ellipse2d, EnumStyleProp, EventEmitter, type EventHandlers, type EventInfo, type ExternalAssetContent, type ExternalAssetHandler, type ExternalAssetType, type ExternalContent, type ExternalContentHandler, type ExternalContentType, FONT_SIZES, type DefaultFillStyle$1 as FillValue, type DefaultFontStyle$1 as FontValue, GEO_SHAPE_KINDS, GeoShapeGeoStyle, type GeoShapeKind, Geometry2d, type Geometry2dOptions, Group2d, HANDLE_HIT_RADIUS, type DefaultHorizontalAlignStyle$1 as HAlignValue, HandleTable, HistoryManager, type HitTestOptions, INSTANCE_ID, type ImageAsset, type ImageAssetProps, type Instance, type InstanceId, type InstancePageState, type InstancePageStateId, InstancePageStateRecordType, type InstancePresence, type InstancePresenceId, InstancePresenceRecordType, InstanceRecordType, type InterruptEventInfo, type JsonObject, type JsonPrimitive, type JsonValue, type KeyboardEventInfo, type KeyboardEventName, LIGHT_THEME, MAX_TEXTURE_RESOLUTION, MAX_TEXTURE_ZOOM, MenuManager, type NormalizeOptions, type NormalizeResult, PRESENCE_COLORS, type Page, type PageId, PageRecordType, type ParentId, type PinchEventInfo, type PointerEventInfo, type PointerEventName, type PointerTarget, Polygon2d, Polyline2d, type RGBA, ROTATE_HANDLE_OFFSET, Rectangle2d, type RenderBackend, type ResizeInfo, type ResizeShapeOptions, RootState, STROKE_SIZES, type Scribble, type SelectionHandle, type SelectionHandleHit, type Shape, type ShapeCreate, type ShapeHandle, type ShapeId, type ShapePartial, ShapeRecordType, type ShapeSvgContext, type ShapeSvgResult, ShapeUtil, type ShapeUtilConstructor, type SharedStyle, SharedStyleMap, type DefaultSizeStyle$1 as SizeValue, type SnapLine, SnapManager, type SnapResult, StateNode, type StateNodeClass, type StateNodeConstructor, type StateNodeType, StyleProp, type TextureInfo, type TextureLoader, TextureManager, type TextureManagerOptions, type TextureOptions, type TextureSource, type TextureState, type ThemeColor, type TickEventInfo, type TranslateInfo, type UiEventType, type UnknownBinding, type UnknownShape, type UserPreferences, type UserPreferencesInit, type DefaultVerticalAlignStyle$1 as VAlignValue, Vec, type VecLike, type VecModel, type VideoAsset, type VideoAssetProps, WebGL2Backend, type WheelEventInfo, bucketTextureResolution, createAssetId, createBackend, createBindingId, createRootState, createSchema, createShapeId, createStore, createUserPreferences, decodeDrawSegmentPath, getExportImplementation, getHandleHitRadius, getSelectionHandlePositions, getShapeIndicatorNode, getStylePropsOf, getTextMeasureProvider, hexToRgba, hitTestSelectionBounds, hitTestSelectionHandles, isAsset, isAssetId, isBinding, isBindingId, isInstancePresenceId, isPageId, isShape, isShapeId, normalizeLoadedRecords, pointInPolygon, randomPresenceColor, registerExportImplementation, registerTextMeasureImplementation, richTextToPlainText, useEditor, useMaybeEditor };