@draftably/editor 0.0.0-stage → 0.2.0

package/dist/types/src/state/session/index.d.ts

@@ -0,0 +1,496 @@
+export interface ConfirmRequest {
+    title: string;
+    message: string;
+    confirmLabel: string;
+    onConfirm: () => void;
+}
+export interface SessionOptions {
+    /** Keep the diagram (and its last layout timeline) in browser storage under this key. */
+    storageKey?: string;
+    /** Read and write the shown emphasis state in the page URL (`?state=`). */
+    urlState?: boolean;
+    /** Ask before an action that replaces the diagram. Without it the action goes ahead. */
+    confirm?: (request: ConfirmRequest) => void;
+    /** Open an object's link. Without it a URL opens in a new tab and other links do nothing. */
+    openLink?: (href: string) => void;
+    /** The user started a gesture or a tool on the canvas; a host closes its menus here. */
+    onInteract?: () => void;
+}
+export declare function createDiagramSession(options?: SessionOptions): {
+    dispose: () => void;
+} & {
+    selectedText: import("solid-js").Accessor<string | null>;
+    setSelectedText: import("solid-js").Setter<string | null>;
+} & {
+    options: 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("./document").HistoryEntry[]>;
+    redoStack: import("solid-js").Accessor<import("./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("./document").EditKind) => boolean) | null) => ((before: string, label: string, kind: import("./document").EditKind) => boolean) | null;
+    editsGoToFile: () => boolean;
+    commit: (before: string, label?: string, kind?: import("./document").EditKind) => boolean;
+    pushUndo: (entry: import("./document").HistoryEntry) => void;
+    annotateLastUndo: (holds: import("./document").HistoryEntry["holds"]) => void;
+    transact: (label: string, fn: (draft: import("../../model/types").Diagram) => void, kind?: import("./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("./document").HistoryEntry, direction: "undo" | "redo") => void) => void;
+    setHistoryHandler: (handler: import("./document").HistoryHandler | null) => import("./document").HistoryHandler | null;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    setCamera: (camera: import("../../model/types").Camera) => void;
+    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("./file-session").FileSessionInfo | null>;
+    fileMode: () => boolean;
+    exampleMode: () => boolean;
+    scratchName: () => "Draft" | "Example";
+    exampleEdited: () => boolean;
+    leaveAgreed: () => boolean;
+    agreeToLeave: () => undefined;
+    fileStatus: import("solid-js").Accessor<import("./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("./editor").NodeGeometry | null>;
+    setSculptGeometry: import("solid-js").Setter<import("./editor").NodeGeometry | null>;
+    animationGeometry: import("solid-js").Accessor<import("./editor").NodeGeometry | null>;
+    setAnimationGeometry: import("solid-js").Setter<import("./editor").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("./editor").Tool>;
+    setToolSignal: import("solid-js").Setter<import("./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("./editor").DragFeedback | null>;
+    setDrag: import("solid-js").Setter<import("./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("./layout").LayoutPreview | null>;
+    labScope: import("solid-js").Accessor<import("./layout").LabScope>;
+    setLabScope: import("solid-js").Setter<import("./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("./layout").RunLayoutOptions) => Promise<import("./layout").LayoutOutcome>;
+    runLabLayout: (mode?: "pass" | "rebuild", preview?: boolean, settings?: import("../../engines/layout-engine").LayoutOptions) => Promise<import("./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("./layout").LayoutOutcome>;
+    previewRouting: (routing: import("../../model/types").RoutingSettings) => Promise<import("./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("./editor").Tool) => boolean) => (tool: import("./editor").Tool) => boolean;
+    setTool: (next: import("./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("./routing").RoutePreset) => void;
+    activeRoutePreset: () => "Balanced" | "Fewer crossings" | null;
+} & {
+    importTimeline: (input: unknown) => void;
+    timeline: import("solid-js").Accessor<import("./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("./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;
+};
+export type DiagramSession = ReturnType<typeof createDiagramSession>;

package/dist/types/src/state/session/layout.d.ts

@@ -0,0 +1,79 @@
+import { type LayoutOptions, type LayoutReport, type LayoutScope } from '../../engines/layout-engine.js';
+import { type ShapeChange } from '../../dsl/layout-edits';
+import type { Diagram, LayoutAlgorithmId, RoutingSettings } from '../../model/types';
+import type { DocumentPart } from './document';
+import type { FileSessionPart } from './file-session';
+import type { EditorPart } from './editor';
+import type { ScenePart } from './scene';
+export type LabScope = 'auto' | LayoutScope;
+export interface LayoutPreview {
+    before: string;
+    mode: 'pass' | 'rebuild';
+    /** Objects a bounded pass moved; a rebuild's preview is a new drawing, so it has no count. */
+    moved?: number;
+    /** In a diagram file: the source that Keep saves, the line it changes, what it says once saved. */
+    file?: {
+        source: string;
+        label: string;
+        message: string;
+        line: string | null;
+        removed: number;
+        /** The direction and format asked for so far. A further choice builds on them. */
+        shape?: ShapeChange;
+        /** The connection preset asked for, which Keep saves with the shape. */
+        routing?: RoutingSettings;
+    };
+}
+export interface RunLayoutOptions extends LayoutOptions {
+    preview?: boolean;
+    fit?: boolean;
+}
+export type LayoutOutcome = {
+    status: 'busy' | 'cancelled';
+}
+/** A diagram file's layout recipe was previewed or saved. */
+ | {
+    status: 'recipe' | 'recipe-preview';
+    source: string;
+} | {
+    status: 'error';
+    message: string;
+} | ({
+    status: 'complete' | 'preview';
+} & LayoutReport);
+export declare function createLayout(s: DocumentPart & FileSessionPart & EditorPart & ScenePart): {
+    layoutBusy: import("solid-js").Accessor<boolean>;
+    layoutReport: import("solid-js").Accessor<LayoutReport | null>;
+    setLayoutReport: import("solid-js").Setter<LayoutReport | null>;
+    layoutPreview: import("solid-js").Accessor<LayoutPreview | null>;
+    labScope: import("solid-js").Accessor<LabScope>;
+    setLabScope: import("solid-js").Setter<LabScope>;
+    labEngine: import("solid-js").Accessor<LayoutAlgorithmId | null>;
+    setLabEngine: import("solid-js").Setter<LayoutAlgorithmId | null>;
+    layoutCheckpoint: import("solid-js").Accessor<Diagram | null>;
+    currentScope: () => {
+        scope: 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?: RunLayoutOptions) => Promise<LayoutOutcome>;
+    runLabLayout: (mode?: "pass" | "rebuild", preview?: boolean, settings?: LayoutOptions) => Promise<LayoutOutcome>;
+    previewSettings: (patch: Partial<Pick<LayoutOptions, "direction" | "aspect">>) => Promise<void>;
+    arrangeScope: () => string | null;
+    movesBlocked: () => string | null;
+    rebuildBlocked: () => string | null;
+    routesBlocked: () => string | null;
+    previewShape: (change: ShapeChange) => Promise<LayoutOutcome>;
+    previewRouting: (routing: RoutingSettings) => Promise<LayoutOutcome>;
+    acceptPreview: () => void;
+    discardPreview: () => void;
+    holdPreviewBefore: (held: boolean) => void;
+    updateLayoutSettings: (patch: Partial<Diagram["settings"]>) => void;
+    captureCheckpoint: () => void;
+    setDocumentOpener: (open: (doc: Diagram, label: string) => void) => (doc: Diagram, label: string) => void;
+    restoreCheckpoint: () => void;
+};
+export type LayoutPart = ReturnType<typeof createLayout>;

package/dist/types/src/state/session/pointer.d.ts

@@ -0,0 +1,19 @@
+import type { EditorPart } from './editor';
+import type { DocumentPart } from './document';
+import type { ScenePart } from './scene';
+import type { SculptPart } from './sculpt';
+import type { ActionsPart } from './actions';
+import type { LayoutPart } from './layout';
+export declare function createPointer(s: EditorPart & DocumentPart & ScenePart & SculptPart & ActionsPart & LayoutPart): {
+    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;
+};
+export type PointerPart = ReturnType<typeof createPointer>;

package/dist/types/src/state/session/routing.d.ts

@@ -0,0 +1,20 @@
+import type { RoutingSettings } from '../../model/types';
+import type { DocumentPart } from './document';
+import type { FileSessionPart } from './file-session';
+import type { LayoutPart } from './layout';
+import type { ScenePart } from './scene';
+export declare const ROUTE_PRESETS: {
+    Balanced: {};
+    'Fewer crossings': {
+        crossingPenalty: number;
+        sharedPenalty: number;
+        portStability: number;
+    };
+};
+export type RoutePreset = keyof typeof ROUTE_PRESETS;
+export declare function createRouting(s: DocumentPart & FileSessionPart & LayoutPart & ScenePart): {
+    setRouting: (patch: Partial<RoutingSettings>, label: string) => void;
+    applyRoutePreset: (preset: RoutePreset) => void;
+    activeRoutePreset: () => "Balanced" | "Fewer crossings" | null;
+};
+export type RoutingPart = ReturnType<typeof createRouting>;