@draftably/editor 0.2.0 → 0.4.0

package/dist/types/src/editor/internal.d.ts

@@ -0,0 +1,483 @@
+/** The session behind a mounted editor, for this repository's tests and proofs only. */
+import type { DiagramSession } from '../state/session';
+export declare const sessions: WeakMap<object, {
+    dispose: () => void;
+} & {
+    selectedText: import("solid-js").Accessor<string | null>;
+    setSelectedText: import("solid-js").Setter<string | null>;
+} & {
+    options: import("../state/session").SessionOptions;
+    doc: import("../model/types").Diagram;
+    setDoc: import("solid-js/store").SetStoreFunction<import("../model/types").Diagram>;
+    saveStatus: import("solid-js").Accessor<"saved" | "saving" | "preview" | "failed">;
+    undoStack: import("solid-js").Accessor<import("../state/session/document").HistoryEntry[]>;
+    redoStack: import("solid-js").Accessor<import("../state/session/document").HistoryEntry[]>;
+    revision: import("solid-js").Accessor<number>;
+    snapshotDoc: () => import("../model/types").Diagram;
+    snapshot: () => string;
+    selection: import("solid-js").Accessor<ReadonlySet<string>>;
+    selectedIds: () => string[];
+    isSelected: (id: string) => boolean;
+    singleSelection: () => string | undefined;
+    setSelection: (ids: Iterable<string>) => void;
+    selectItems: (ids: string[], { add, toggle }?: {
+        add?: boolean | undefined;
+        toggle?: boolean | undefined;
+    }) => void;
+    clearSelection: () => void;
+    selectText: (id: string) => void;
+    onBeforeEdit: (handler: () => void) => void;
+    prepareForEdit: () => void;
+    onSourceIdMap: (handler: (mapId: (id: string) => string) => void) => void;
+    mapSourceIds: (mapId: (id: string) => string) => void;
+    setCommitHandler: (handler: ((before: string, label: string, kind: import("../state/session/document").EditKind) => boolean) | null) => ((before: string, label: string, kind: import("../state/session/document").EditKind) => boolean) | null;
+    editsGoToFile: () => boolean;
+    commit: (before: string, label?: string, kind?: import("../state/session/document").EditKind) => boolean;
+    pushUndo: (entry: import("../state/session/document").HistoryEntry) => void;
+    annotateLastUndo: (holds: import("../state/session/document").HistoryEntry["holds"]) => void;
+    transact: (label: string, fn: (draft: import("../model/types").Diagram) => void, kind?: import("../state/session/document").EditKind) => boolean;
+    mutate: (fn: (draft: import("../model/types").Diagram) => void) => void;
+    restoreDocument: (next: import("../model/types").Diagram, { keepCamera }?: {
+        keepCamera?: boolean | undefined;
+    }) => void;
+    onHistoryStep: (handler: (entry: import("../state/session/document").HistoryEntry, direction: "undo" | "redo") => void) => void;
+    setHistoryHandler: (handler: import("../state/session/document").HistoryHandler | null) => import("../state/session/document").HistoryHandler | null;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    setCamera: (camera: import("../model/types").Camera, reason?: import("./mount").CameraReason) => void;
+    onCamera: (listener: (reason: import("./mount").CameraReason) => void) => () => boolean;
+    disableBrowserStorage: () => boolean;
+    setPersistenceBlocked: (blocked: boolean) => void;
+    persist: () => void;
+    persistNow: () => void;
+    restoreSavedDocument: () => {
+        restored: boolean;
+        notice?: string;
+    };
+    watchOtherTabs: () => () => void;
+} & {
+    openSource: (source: string, onChange?: (source: string) => void) => Promise<void>;
+    receiveSource: (source: string) => Promise<void>;
+    liveSource: import("solid-js").Accessor<string>;
+    sourceDraft: import("solid-js").Accessor<string | null>;
+    fileSession: import("solid-js").Accessor<import("../state/session/file-session").FileSessionInfo | null>;
+    fileMode: () => boolean;
+    exampleMode: () => boolean;
+    scratchName: () => "Draft" | "Example";
+    exampleEdited: () => boolean;
+    leaveAgreed: () => boolean;
+    agreeToLeave: () => undefined;
+    fileStatus: import("solid-js").Accessor<import("../state/session/file-session").FileStatus>;
+    sourceError: import("solid-js").Accessor<{
+        message: string;
+        line: number;
+    } | null>;
+    fileScene: import("solid-js").Accessor<import("../dsl/compile").Scene | null>;
+    fileDiagnostics: () => import("../dsl/compile").Diagnostic[];
+    conflictProposal: import("solid-js").Accessor<string | null>;
+    movedByChange: import("solid-js").Accessor<string[]>;
+    fileCompiling: import("solid-js").Accessor<boolean>;
+    exampleRestored: () => boolean;
+    currentSource: () => string;
+    setRouteSink: (sink: {
+        adopt: (routes: {
+            fingerprint: string;
+            result: import("../engines/routing-engine").RoutingResult;
+        }) => void;
+        quick: (on: boolean) => void;
+        awaiting: (on: boolean) => void;
+    }) => {
+        adopt: (routes: {
+            fingerprint: string;
+            result: import("../engines/routing-engine").RoutingResult;
+        }) => void;
+        quick: (on: boolean) => void;
+        awaiting: (on: boolean) => void;
+    };
+    showSource: (source: string, selection?: string[] | (() => string[]), mapId?: (id: string) => string) => Promise<import("../dsl/compile").Scene | null>;
+    keepDiskVersion: () => void;
+    saveProposalOverDisk: () => void;
+    retrySave: () => undefined;
+    typeSource: (next: string, burst: number) => Promise<null | undefined>;
+    commitSource: (next: string, label: string, message: string) => Promise<boolean>;
+    fileBlocked: () => string | null;
+    sourceWithRecipe: (scope: string, settings: import("../model/types").LayoutSettings, direction?: "right" | "down") => {
+        source: string;
+        removed: number;
+    };
+    sourceWithShape: (scope: string, change: import("../dsl/layout-edits").ShapeChange) => {
+        source: string;
+        removed: number;
+    };
+    changedLines: (source: string) => string[];
+    changedLine: (source: string) => string;
+    sourceWithRouting: (routing: import("../model/types").RoutingSettings, base?: string) => string;
+    projectSource: (source: string) => Promise<import("../model/types").Diagram>;
+    reflowSelectedGroup: (id: string) => void;
+    openFileSession: (file: string) => Promise<boolean>;
+    prefetchFile: (file: string) => Promise<void>;
+    settleSave: () => Promise<void>;
+    closeFileSession: () => void;
+    openExampleSession: (id: string, title: string, source: string, key?: string) => Promise<void>;
+    resetExample: () => void;
+    markExampleSaved: () => void;
+    fileStatusText: () => string;
+} & {
+    sculptGeometry: import("solid-js").Accessor<import("../model/types").NodeGeometry | null>;
+    setSculptGeometry: import("solid-js").Setter<import("../model/types").NodeGeometry | null>;
+    animationGeometry: import("solid-js").Accessor<import("../model/types").NodeGeometry | null>;
+    setAnimationGeometry: import("solid-js").Setter<import("../model/types").NodeGeometry | null>;
+    setQuickRouting: import("solid-js").Setter<boolean>;
+    routePrior: import("solid-js").Accessor<import("../engines/routing-engine").PriorRoute[] | null>;
+    setRoutePrior: import("solid-js").Setter<import("../engines/routing-engine").PriorRoute[] | null>;
+    setAdoptedRoutes: import("solid-js").Setter<{
+        fingerprint: string;
+        result: import("../engines/routing-engine").RoutingResult;
+    } | null>;
+    geometry: (id: string) => import("../model/types").NodeLayout;
+    visibleScene: import("solid-js").Accessor<import("../model/graph").VisibleGraph>;
+    nodeIds: import("solid-js").Accessor<string[]>;
+    groupIds: import("solid-js").Accessor<string[]>;
+    edgeIds: import("solid-js").Accessor<string[]>;
+    sceneRects: import("solid-js").Accessor<Map<string, import("../model/types").Rect>>;
+    routing: import("solid-js").Accessor<import("../model/routes").SceneRoutes>;
+    routesById: import("solid-js").Accessor<Map<string, import("../model/routes").DrawnRoute>>;
+    routeIds: import("solid-js").Accessor<string[]>;
+    routesPending: () => boolean;
+    resetRoutes: () => void;
+    routeInputFor: () => {
+        nodes: ({
+            shape: import("../model/types").ShapeKind;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+            was?: string;
+            wasShape?: import("../model/types").ShapeKind;
+            wasCount?: number | string;
+            href?: string;
+            count?: number | string;
+            span?: number | "var";
+            parentId?: string;
+            image?: string;
+            lifeline?: number;
+        } | {
+            parentId?: string | undefined;
+            frame?: boolean | undefined;
+            shape: import("../model/types").ShapeKind;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+        })[];
+        groups: {
+            titleHeight?: number | undefined;
+            collapsed: boolean;
+            titleWidth: number;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+            was?: string;
+            href?: string;
+            parentId?: string;
+            frame?: "soft" | "none";
+            titleLines?: number;
+            hull?: import("../model/types").Rect[];
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            cfg: import("../model/types").EdgeLayout;
+            a: string;
+            b: string;
+            id: string;
+            label: string;
+            was?: string;
+            directed: boolean;
+            head?: import("../model/markers").EndMarker;
+            tail?: import("../model/markers").EndMarker;
+            emphasis: boolean;
+            dashed: boolean;
+            status?: import("../model/status").Status;
+            spot?: import("../model/status").Spot;
+        }[];
+    };
+    routes: () => import("../model/routes").DrawnRoute[];
+    routingReport: () => import("../engines/routing-engine").RoutingReport;
+    blockedRouteIds: () => string[];
+    sceneBounds: () => import("../model/types").Rect;
+    viewerFrame: () => {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        natural: number;
+        head: {
+            w: number;
+            h: number;
+        };
+        key: {
+            w: number;
+            h: number;
+            row: number;
+            items: {
+                x: number;
+                y: number;
+                legend?: import("../model/appearance").LegendEntry;
+                status?: import("../model/status").StatusCount;
+                label: string;
+            }[];
+        };
+        heading: {
+            x: number;
+            y: number;
+            wrap: number;
+        };
+        legend: {
+            x: number;
+            y: number;
+        };
+        foot: {
+            x: number;
+            y: number;
+            type: import("../model/fonts").TypeProfile;
+            gutter: number;
+            items: {
+                note: import("../model/footnote").Footnote;
+                lines: import("../model/rich-text").Run[][];
+                y: number;
+            }[];
+            h: number;
+        };
+        notes: import("../model/note").PlacedNote[];
+    };
+} & {
+    states: () => import("../model/appearance").EmphasisState[];
+    activeState: () => string | null;
+    gridOpen: import("solid-js").Accessor<boolean>;
+    setGridOpen: import("solid-js").Setter<boolean>;
+    showState: (id: string | null) => void;
+    stepState: (by: 1 | -1) => boolean;
+    drawnDoc: () => import("../model/types").Diagram;
+} & {
+    tool: import("solid-js").Accessor<import("../state/session/editor").Tool>;
+    setToolSignal: import("solid-js").Setter<import("../state/session/editor").Tool>;
+    connectFrom: import("solid-js").Accessor<{
+        id: string;
+        side: import("../model/types").PortSide;
+    } | null>;
+    setConnectFrom: import("solid-js").Setter<{
+        id: string;
+        side: import("../model/types").PortSide;
+    } | null>;
+    pointer: import("solid-js").Accessor<import("../model/types").Point | null>;
+    setPointer: import("solid-js").Setter<import("../model/types").Point | null>;
+    drag: import("solid-js").Accessor<import("../state/session/editor").DragFeedback | null>;
+    setDrag: import("solid-js").Setter<import("../state/session/editor").DragFeedback | null>;
+    inlineEditId: import("solid-js").Accessor<string | null>;
+    setInlineEditId: import("solid-js").Setter<string | null>;
+    spaceHeld: import("solid-js").Accessor<boolean>;
+    setSpaceHeld: import("solid-js").Setter<boolean>;
+    measuredStageSize: import("solid-js").Accessor<{
+        width: number;
+        height: number;
+    }>;
+    setMeasuredStageSize: import("solid-js").Setter<{
+        width: number;
+        height: number;
+    }>;
+    reducedMotion: import("solid-js").Accessor<boolean>;
+    setReducedMotion: import("solid-js").Setter<boolean>;
+    registerCanvas: (el: SVGSVGElement) => SVGSVGElement;
+    canvasElement: () => SVGSVGElement | undefined;
+    focusCanvas: () => void | undefined;
+    stageSize: () => {
+        width: number;
+        height: number;
+    };
+    screenToWorld: (clientX: number, clientY: number) => import("../model/types").Point;
+    canvasCenter: () => import("../model/types").Point;
+    zoomAt: (factor: number, clientX?: number, clientY?: number) => void;
+    panBy: (dx: number, dy: number) => void;
+    setStageSize: (size: {
+        width: number;
+        height: number;
+    }) => void;
+    fitView: () => void;
+    diagramClipped: () => boolean;
+    fitRects: (rects: import("../model/types").Rect[], reservedBottom?: number) => void;
+    revealObject: (id: string) => void;
+    centerSelection: () => void;
+} & {
+    layoutBusy: import("solid-js").Accessor<boolean>;
+    layoutReport: import("solid-js").Accessor<import("../engines/layout-engine").LayoutReport | null>;
+    setLayoutReport: import("solid-js").Setter<import("../engines/layout-engine").LayoutReport | null>;
+    layoutPreview: import("solid-js").Accessor<import("../state/session/layout").LayoutPreview | null>;
+    labScope: import("solid-js").Accessor<import("../state/session/layout").LabScope>;
+    setLabScope: import("solid-js").Setter<import("../state/session/layout").LabScope>;
+    labEngine: import("solid-js").Accessor<import("../model/types").LayoutAlgorithmId | null>;
+    setLabEngine: import("solid-js").Setter<import("../model/types").LayoutAlgorithmId | null>;
+    layoutCheckpoint: import("solid-js").Accessor<import("../model/types").Diagram | null>;
+    currentScope: () => {
+        scope: import("../engines/layout-engine").LayoutScope;
+        containerId?: string;
+    };
+    layoutTarget: () => "the whole diagram" | "the selection and its neighbours" | "this group" | "the selection";
+    setFixedIdsProvider: (provider: () => string[]) => () => string[];
+    fixedIds: () => string[];
+    cancelLayout: () => void;
+    runLayout: (options?: import("../state/session/layout").RunLayoutOptions) => Promise<import("../state/session/layout").LayoutOutcome>;
+    runLabLayout: (mode?: "pass" | "rebuild", preview?: boolean, settings?: import("../engines/layout-engine").LayoutOptions) => Promise<import("../state/session/layout").LayoutOutcome>;
+    previewSettings: (patch: Partial<Pick<import("../engines/layout-engine").LayoutOptions, "direction" | "aspect">>) => Promise<void>;
+    arrangeScope: () => string | null;
+    movesBlocked: () => string | null;
+    rebuildBlocked: () => string | null;
+    routesBlocked: () => string | null;
+    previewShape: (change: import("../dsl/layout-edits").ShapeChange) => Promise<import("../state/session/layout").LayoutOutcome>;
+    previewRouting: (routing: import("../model/types").RoutingSettings) => Promise<import("../state/session/layout").LayoutOutcome>;
+    acceptPreview: () => void;
+    discardPreview: () => void;
+    holdPreviewBefore: (held: boolean) => void;
+    updateLayoutSettings: (patch: Partial<import("../model/types").Diagram["settings"]>) => void;
+    captureCheckpoint: () => void;
+    setDocumentOpener: (open: (doc: import("../model/types").Diagram, label: string) => void) => (doc: import("../model/types").Diagram, label: string) => void;
+    restoreCheckpoint: () => void;
+} & {
+    inlineDraft: import("solid-js").Accessor<string>;
+    setInlineDraft: import("solid-js").Setter<string>;
+    setToolInterceptor: (fn: (tool: import("../state/session/editor").Tool) => boolean) => (tool: import("../state/session/editor").Tool) => boolean;
+    setTool: (next: import("../state/session/editor").Tool) => void;
+    startInlineEdit: (id: string) => void;
+    finishInlineEdit: (save?: boolean) => void;
+    addNode: (partial?: import("../model/edits").NewNode, at?: import("../model/types").Point, edit?: boolean) => string;
+    addEdge: (partial: import("../model/edits").NewEdge) => string;
+    completeConnection: (targetId: string, side?: import("../model/types").Side | "auto") => void;
+    quickExtend: ({ side, sibling, at, from, }?: {
+        side?: import("../model/types").Side | null;
+        sibling?: boolean;
+        at?: import("../model/types").Point | null;
+        from?: string | null;
+    }) => string | undefined;
+    insertStep: (edgeId: string, at?: import("../model/types").Point | null) => string | undefined;
+    buildFromList: (lines: string[], options?: {
+        mode?: import("../model/edits").BuildMode;
+        title?: string;
+        source?: string | null;
+        parentId?: string | null;
+    }) => string[];
+    wrapSelection: () => string;
+    drawContainer: (rect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }) => void;
+    deleteSelection: (deep?: boolean) => void;
+    ungroupSelection: () => void;
+    togglePin: () => void;
+    clearManualMarkers: () => void;
+    alignSelection: (kind: import("../model/edits").AlignKind) => void;
+    nudgeSelection: (dx: number, dy: number) => boolean;
+    setColor: (color: import("../model/types").Diagram["styles"][string]["color"]) => void;
+    chooseTheme: (theme: import("../model/appearance").ThemeId) => void;
+    setAppearanceOverrides: (patch: Partial<import("../model/appearance").AppearanceOverrides>, label?: string) => void;
+    setShade: (shade: import("../model/appearance").Shade | undefined) => void;
+    fitSelectedContainer: () => void;
+    toggleCollapse: (id?: string | undefined) => void;
+    reverseSelectedEdge: () => void;
+    resetSelectedBends: () => void;
+    setLayoutIntent: (role: import("../model/types").IntentRole, id: string | null, placement?: import("../model/types").IntentPlacement) => void;
+    markSelectedAs: (role: import("../model/types").IntentRole) => void;
+    addWaypointAt: (edgeId: string, point?: import("../model/types").Point) => void;
+    removeWaypoint: (edgeId: string, index: number) => void;
+    reroute: ({ auto }?: {
+        auto?: boolean | undefined;
+    }) => void;
+    toggleTheme: () => void;
+    copySelection: () => import("../model/edits").ClipboardFragment | null;
+    hasClipboard: () => boolean;
+    pasteFragment: (part?: import("../model/edits").ClipboardFragment | null) => void;
+    duplicateSelection: () => void;
+    openDocument: (input: unknown, { fit, label }?: {
+        fit?: boolean | undefined;
+        label?: string | undefined;
+    }) => import("../model/types").Diagram;
+    newDocument: () => void;
+    openSample: (id: string) => import("../model/types").Diagram | undefined;
+} & {
+    setRouting: (patch: Partial<import("../model/types").RoutingSettings>, label: string) => void;
+    applyRoutePreset: (preset: import("../state/session/routing").RoutePreset) => void;
+    activeRoutePreset: () => "Balanced" | "Fewer crossings" | null;
+} & {
+    importTimeline: (input: unknown) => void;
+    timeline: import("solid-js").Accessor<import("../state/session/sculpt").TimelineState | null>;
+    playing: import("solid-js").Accessor<boolean>;
+    brushActive: import("solid-js").Accessor<boolean>;
+    brushSettings: import("solid-js").Accessor<import("../engines/sculpt-engine").BrushSettings>;
+    brushPoint: import("solid-js").Accessor<import("../model/types").Point | null>;
+    brushHover: import("solid-js").Accessor<import("../engines/sculpt-engine").DabResult | null>;
+    stroking: import("solid-js").Accessor<boolean>;
+    restoreKey: import("solid-js").Accessor<boolean>;
+    referenceLabel: import("solid-js").Accessor<string>;
+    timelineOpen: () => boolean;
+    sculptInteracting: () => boolean;
+    heldIds: () => string[];
+    restoreArchive: () => void;
+    openTimeline: (options?: Record<string, unknown>) => Promise<void>;
+    closeTimeline: () => void;
+    scrub: (index: number, { peek }?: {
+        peek?: boolean | undefined;
+    }) => number | undefined;
+    endPeek: () => void;
+    setGhost: (ghost: import("../state/session/sculpt").GhostMode) => void;
+    bookmarkStep: () => void;
+    keepStep: ({ brush }?: {
+        brush?: boolean | undefined;
+    }) => boolean;
+    stopPlayback: () => void;
+    togglePlayback: () => void;
+    fitTimelinePath: (reservedBottom: number) => void;
+    reopenTimeline: () => void;
+    saveTimelineFile: () => void;
+    activateBrush: (options?: Partial<import("../engines/sculpt-engine").BrushSettings>) => void;
+    deactivateBrush: () => void;
+    toggleBrush: () => void;
+    updateBrushSettings: (patch: Partial<import("../engines/sculpt-engine").BrushSettings>) => void;
+    useCurrentAsReference: () => void;
+    brushPointerDown: (e: PointerEvent, target: Element) => boolean;
+    brushPointerMove: (e: PointerEvent) => boolean;
+    brushPointerUp: (e?: PointerEvent) => boolean;
+    brushPointerLeave: () => void;
+    cancelStroke: () => boolean;
+    brushDab: (point?: import("../model/types").Point) => import("../engines/sculpt-engine").DabResult;
+    clearHolds: () => void;
+    sculptUndo: () => boolean;
+    sculptKey: (e: KeyboardEvent) => boolean;
+    sculptBlur: () => void;
+    sculptBeforeUnload: () => void;
+    hasArchivedTimeline: import("solid-js").Accessor<boolean>;
+    setComparisonCloser: (fn: () => void) => () => void;
+} & {
+    isDragging: () => boolean;
+    cancelGesture: () => void;
+    resetModifiers: () => void;
+    onWheel: (e: WheelEvent) => void;
+    onPointerDown: (e: PointerEvent) => void;
+    onPointerMove: (e: PointerEvent) => void;
+    onPointerUp: (e: PointerEvent | null) => void;
+    onDoubleClick: (e: MouseEvent) => void;
+    selectForContextMenu: (e: MouseEvent) => void;
+    dragKind: () => string | undefined;
+} & {
+    describeLink: (href: string) => string;
+}>;
+export declare const sessionOf: (editor: object) => DiagramSession;

package/dist/types/src/editor/mount.d.ts

@@ -1,18 +1,79 @@
-import { type DiagramSession, type SessionOptions } from '../state/session';
+import { type SessionOptions } from '../state/session';
+import { type Camera, type CameraReason, type FrameOptions, type MoveResult } from '../runtime/camera';
+import { type Geometry } from '../runtime/geometry';
+import { type Anchor, type DraftSlot } from '../runtime/anchors';
+import type { Diagnostic } from '../runtime/types';
 import '../styles/app.css';
-export interface MountOptions extends SessionOptions {
+/** The options a host sets on `<draft-editor>`: every mount option but the text and `onChange`. */
+export type EditorOptions = Pick<SessionOptions, 'storageKey' | 'openLink' | 'confirm' | 'onInteract'> & {
+    /** `auto` (default) hides slot bodies and shows titles again below a zoom of 0.4. */
+    detail?: 'auto' | 'full';
+};
+export interface MountOptions extends EditorOptions {
     /** The `.draft` text to edit. */
     source: string;
     /** Receives the new text after every kept edit, undo and redo. */
     onChange?: (source: string) => void;
 }
+/** What `on` reports. `camera` comes at most once per animation frame. */
+export interface EditorEvents {
+    /** After each drawing, after `anchor()`, and with `[]` before `destroy` detaches the targets. */
+    anchors: {
+        anchors: readonly Anchor[];
+    };
+    /** Slot warnings: an unknown slot, or content larger than its node. */
+    diagnostics: {
+        revision: number;
+        diagnostics: readonly Diagnostic[];
+        stale: boolean;
+    };
+    camera: {
+        camera: Camera;
+        reason: CameraReason;
+    };
+    /** The selection changed, by the user or through `select()`. */
+    select: {
+        ids: readonly string[];
+        reason: 'user' | 'api';
+    };
+    /** A right-click; `id` is null on the background. The editor shows no menu of its own. */
+    contextmenu: {
+        id: string | null;
+        kind?: 'node' | 'group' | 'edge';
+        clientX: number;
+        clientY: number;
+        preventDefault(): void;
+    };
+}
+/** An editor update's outcome. The editor draws in its own session, so it has no SVG value. */
+export type EditorUpdateResult = {
+    status: 'committed' | 'error' | 'destroyed';
+    revision: number;
+};
+/** The editor's handle: the viewer's camera, plus editing. */
 export interface MountedEditor {
-    session: DiagramSession;
+    /** Resolves once the first text is drawn. */
+    readonly ready: Promise<EditorUpdateResult>;
     /** The text as the editor holds it now. */
     source(): string;
     /** Show text the host changed. Resolves once it is drawn. */
-    update(source: string): Promise<void>;
-    /** Remove the editor and stop its session. */
+    update(source: string): Promise<EditorUpdateResult>;
+    /** Where each item is drawn, in world units: the viewer's shapes. The same object for one revision. */
+    geometry(): Geometry | null;
+    /** Select these items (unknown IDs are dropped); `[]` clears the selection. */
+    select(ids: readonly string[]): void;
+    selection(): readonly string[];
+    /** Plain-DOM hosts only: keep a target per slot; `<draft-editor>` sets this from its children. */
+    anchor(slots: readonly DraftSlot[]): void;
+    getCamera(): Camera;
+    /** Zoom is clamped to `ZOOM_MIN`–`ZOOM_MAX`, as in the viewer. */
+    setCamera(camera: Camera): void;
+    /** Frame these items, or the whole drawing without ids. At most actual size by default. */
+    fit(ids?: readonly string[], options?: FrameOptions): MoveResult;
+    /** The least move that shows the item; zooms out only if it does not fit. */
+    reveal(id: string, options?: FrameOptions): MoveResult;
+    on<K extends keyof EditorEvents>(type: K, listener: (event: EditorEvents[K]) => void): () => void;
+    /** Remove the editor and stop its session. Safe to call twice. */
     destroy(): void;
 }
 /**
@@ -21,3 +82,7 @@ export interface MountedEditor {
  * host a size; the canvas fills it.
  */
 export declare function mountEditor(host: HTMLElement, options: MountOptions): MountedEditor;
+export type { Camera, CameraReason, FrameOptions, MoveResult } from '../runtime/camera';
+export type { Box, EdgeOut, Geometry, PlacedBox } from '../runtime/geometry';
+export type { Anchor, DraftSlot } from '../runtime/anchors';
+export { ZOOM_MAX, ZOOM_MIN } from '../runtime/camera';