@voithos-labs/aragonite 0.10.1

package/dist/editor-actions/plugin/container.js

@@ -0,0 +1,351 @@
+/**
+ * The container-authoring seam a plugin block component builds on: the built-in
+ * container wiring collapsed into one factory, so a plugin never touches an editor
+ * context key. Call synchronously during component init — `getContext` reads the
+ * ancestor contexts and `useContainerWindowing` sets its own.
+ */
+import { DEV } from 'esm-env';
+import { getContext } from 'svelte';
+import { getBlockKindDescriptor } from '../../schema/block-kind-descriptor';
+import { expandContainerPatch, isCollapsedContainer } from '../../schema/reserved-chrome';
+import { dispatchKindCommand } from '../../schema/block-commands';
+import { eventToChord } from '../../schema/keybindings';
+import { isReadingMode } from '../../presentation-mode';
+import { devWarn } from '../../dev-warn';
+import { BLOCK_EDIT_KEY, CONTAINER_EDIT_KEY, EDITOR_DOC_KEY, EDITOR_POLICIES_KEY, EDITOR_SERVICES_KEY, FOCUS_KEY, HISTORY_KEY } from '../../editor-keys';
+import { emitCommandError } from '../../editor-events';
+import { owningPluginEditor } from '../../schema/plugin-install';
+import { createBlockListState } from '../../reactivity/block-list-state.svelte';
+import { useContainerWindowing } from '../../reactivity/use-container-windowing.svelte';
+import { createContainerExitOverrides } from '../container-exit-overrides';
+import { createContainerBlockComponent, focusAcrossBlockEdge, handleEditorGlobalChord, handleWholeBlockKeys } from '../container-block-component';
+import { composeWholeBlockFocusSurface, createWholeBlockInputProxy, holdsWholeBlockFocus, isEditableEventTarget } from '../whole-block-focus-surface';
+import { createStandardNestedActions, setNestedActionsContexts } from '../nested/nested-actions';
+const _conforms = [true, true];
+// ── Collapse gates ───────────────────────────────────────────────────────────
+/**
+ * Collapse-ness has ONE definition: the descriptor's `reservedChrome.isCollapsed`
+ * probe. An explicit dep is dev-cross-checked against it, except in reading mode,
+ * which cannot write — a reader's open section is legitimately ahead of the document.
+ */
+export function composeCollapseProbe(explicit, getNode, getPresentationMode) {
+    if (!explicit)
+        return () => isCollapsedContainer(getNode());
+    return () => {
+        const value = explicit();
+        if (DEV && value !== isCollapsedContainer(getNode()) && !isReadingMode(getPresentationMode)) {
+            devWarn('plugin-container', `isCollapsed dep disagrees with the declared reservedChrome.isCollapsed probe for kind "${getNode().kind}"`);
+        }
+        return value;
+    };
+}
+/**
+ * The expand door a reveal opens before descending into a collapsed body. Commits
+ * `reservedChrome.expandPatch` as a real undoable edit, not a view-only divergence
+ * from the CST; declines in reading mode, which commits nothing.
+ */
+export function composeExpandDoor(deps) {
+    return async () => {
+        if (!deps.isCollapsed() || isReadingMode(deps.getPresentationMode))
+            return false;
+        const patch = expandContainerPatch(deps.getNode());
+        if (!patch)
+            return false;
+        await deps.commit(patch);
+        return true;
+    };
+}
+/**
+ * The `updateOwnMetadata` gate: reading mode writes no bytes (plugin-contract.md), so the
+ * commit declines as a no-op and DEV names the kind that knocked.
+ */
+export function composeMetadataDoor(deps) {
+    return (patch, afterTick) => {
+        if (isReadingMode(deps.getPresentationMode)) {
+            devWarn('plugin-container', `updateOwnMetadata declined: reading mode writes no bytes (kind "${deps.getNode().kind}")`);
+            return;
+        }
+        return deps.commit(patch, afterTick);
+    };
+}
+/** While collapsed the body is unmounted, so `descendToBody` would mint an invisible one. */
+export function gateDescendOnCollapse(isCollapsed, descend) {
+    return async (innerIndex) => {
+        if (isCollapsed?.())
+            return;
+        await descend(innerIndex);
+    };
+}
+/**
+ * While collapsed only the chrome row is mounted, so an interior `moveFocus`
+ * targeting a body index dead-ends on the unmounted ref. Route body targets past the
+ * container instead — the same exit an open container's past-end move takes.
+ */
+export function gateMoveFocusOnCollapse(isCollapsed, moveWithin, parentFocus, getIndex) {
+    return async (innerIndex, position, options) => {
+        if (innerIndex >= 1 && isCollapsed?.()) {
+            // Omit the options arg when unset, mirroring dispatchMoveFocus's own delegation.
+            if (options)
+                await parentFocus.moveFocus(getIndex() + 1, position, options);
+            else
+                await parentFocus.moveFocus(getIndex() + 1, position);
+            return;
+        }
+        await moveWithin(innerIndex, position, options);
+    };
+}
+/** Each surface spreads its base first: a gate ADDS a member, never replaces one. */
+export function composeCollapseGates(base, gates) {
+    return {
+        ...base,
+        blockEdit: { ...base.blockEdit, descendToBody: gates.descendToBody },
+        focus: { ...base.focus, moveFocus: gates.moveFocus }
+    };
+}
+// ── Kind-command target ──────────────────────────────────────────────────────
+/**
+ * The kind-command target a plugin container bubbles into `dispatchKindCommand`.
+ * `runCommand` is inert — a plugin container owns no built-in kind commands, so a
+ * chord resolves only through a registered one.
+ */
+export function buildContainerKindTarget(deps, updateOwnMetadata, pluginEditor) {
+    return {
+        get kind() {
+            return deps.getNode().kind;
+        },
+        runCommand: () => false,
+        getCommandContext: () => ({
+            node: deps.getNode(),
+            updateMetadata: (patch) => {
+                void updateOwnMetadata(patch);
+            },
+            hooks: deps.commandHooks?.(),
+            editor: owningPluginEditor(pluginEditor, deps.getNode().kind)
+        })
+    };
+}
+// ── Factory ──────────────────────────────────────────────────────────────────
+export function createContainerBlock(deps) {
+    const parentBlockEdit = getContext(BLOCK_EDIT_KEY);
+    const parentFocus = getContext(FOCUS_KEY);
+    const parentContainerEdit = getContext(CONTAINER_EDIT_KEY);
+    const history = getContext(HISTORY_KEY);
+    const { stickyColumn, edgeAffinity, selection, reorder, events: editorEvents, registryView, activePlugins } = getContext(EDITOR_SERVICES_KEY);
+    const { keybindingOverrides, presentationMode: getPresentationMode, theme: getTheme } = getContext(EDITOR_POLICIES_KEY);
+    const editorDoc = getContext(EDITOR_DOC_KEY);
+    const pluginEditor = editorDoc?.pluginEditor;
+    const linkRef = editorDoc?.linkRef;
+    // Resolved by the kind's recorded owner, like the kind-command context's `editor`.
+    const getOptions = () => owningPluginEditor(pluginEditor, deps.getNode().kind)?.options;
+    const listState = createBlockListState(deps.getNode);
+    // One live scope over the frozen thunks, shared by every factory this seam wires.
+    // Passed by reference, never spread — spreading would snapshot the getters.
+    const scope = {
+        get index() {
+            return deps.getIndex();
+        },
+        get node() {
+            return deps.getNode();
+        },
+        get path() {
+            return deps.getPath();
+        }
+    };
+    const collapsed = composeCollapseProbe(deps.isCollapsed, deps.getNode, getPresentationMode);
+    const containerExitOverrides = createContainerExitOverrides({ scope, parentBlockEdit });
+    // All three override the same `defaults`, so they coexist; for a non-collapsing
+    // container the gates are inert.
+    const overrideFactory = (defaults) => composeCollapseGates(containerExitOverrides(defaults), {
+        descendToBody: gateDescendOnCollapse(collapsed, defaults.blockEdit.descendToBody),
+        moveFocus: gateMoveFocusOnCollapse(collapsed, defaults.focus.moveFocus, parentFocus, deps.getIndex)
+    });
+    const bundle = createStandardNestedActions(listState, {
+        scope,
+        stickyColumn,
+        grammar: registryView.grammar,
+        getPresentationMode,
+        linkRef,
+        parent: {
+            blockEdit: parentBlockEdit,
+            focus: parentFocus,
+            containerEdit: parentContainerEdit
+        }
+    }, overrideFactory);
+    setNestedActionsContexts(bundle);
+    const windowing = useContainerWindowing({
+        getIndex: deps.getIndex,
+        getParentPath: deps.getPath,
+        getChildren: () => deps.getNode().children ?? [],
+        getChildIds: () => listState.innerBlockIds,
+        getListEl: () => deps.getBoxEl()?.querySelector(':scope > .block-list') ?? null,
+        getOwnEl: () => deps.getBoxEl()?.closest('.block-host') ?? null,
+        provideLeafChannel: true,
+        isCollapsed: collapsed
+    });
+    // One composed surface feeds the shim AND the keydown gate, so a fallback-focused
+    // box passes the same containment check the affordances use.
+    const wholeBlockSurface = deps.getFocusEl
+        ? composeWholeBlockFocusSurface(deps.getFocusEl, () => deps.getBoxEl(), () => deps.getNode().kind)
+        : undefined;
+    // The editing host AltGr and IME input arrive through: keydown alone drops both, and a
+    // whole-block kind has no editable surface of its own to catch them.
+    const inputProxy = wholeBlockSurface
+        ? createWholeBlockInputProxy({
+            getBoxEl: () => deps.getBoxEl(),
+            getFocusEl: wholeBlockSurface,
+            isReading: () => isReadingMode(getPresentationMode),
+            mint: (text) => void parentBlockEdit.insertParagraph(deps.getIndex() + 1, text)
+        })
+        : undefined;
+    // Through a closure, not the `updateOwnMetadata` value: that const is declared
+    // below, and is only ever read at reveal time.
+    const expandCollapsed = composeExpandDoor({
+        getNode: deps.getNode,
+        isCollapsed: collapsed,
+        getPresentationMode,
+        commit: (patch) => updateOwnMetadata(patch)
+    });
+    const containerApi = createContainerBlockComponent({
+        // The kind's descriptor is the declaration; the mounted surface only reports it.
+        get editable() {
+            return getBlockKindDescriptor(deps.getNode().kind).editable;
+        },
+        selection,
+        get innerBlockRefs() {
+            return listState.innerBlockRefs;
+        },
+        refSlots: listState.refSlots,
+        get nodeChildrenLength() {
+            return deps.getNode().children?.length ?? 0;
+        },
+        get node() {
+            return deps.getNode();
+        },
+        revealChild: windowing.revealChild,
+        isInWindow: windowing.isInWindow,
+        isCollapsed: collapsed,
+        expandCollapsed,
+        getFocusEl: wholeBlockSurface,
+        getBoxEl: () => deps.getBoxEl(),
+        inputProxy
+    });
+    const blockListProps = {
+        get children() {
+            return deps.getNode().children ?? [];
+        },
+        get blockIds() {
+            return listState.innerBlockIds;
+        },
+        slots: listState.refSlots,
+        get parentPath() {
+            return deps.getPath();
+        },
+        get window() {
+            return windowing.window;
+        },
+        // Opaque containers are a reorder boundary, so a handle on a chrome or body row
+        // would be dead; the container itself reorders through its parent's BlockList.
+        reorderable: false,
+        get ambientPrefixForFirst() {
+            return deps.getAmbientPrefix?.() ?? '';
+        }
+    };
+    const updateOwnMetadata = composeMetadataDoor({
+        getNode: deps.getNode,
+        getPresentationMode,
+        commit: (patch, afterTick) => parentBlockEdit.updateBlockMetadata(deps.getIndex(), patch, { afterTick })
+    });
+    const kindTarget = buildContainerKindTarget(deps, updateOwnMetadata, pluginEditor);
+    const globalChordDeps = {
+        getKind: () => deps.getNode().kind,
+        history,
+        pluginEditor,
+        onCommandError: (report) => emitCommandError(editorEvents, report),
+        getKeybindingOverrides: keybindingOverrides,
+        isReading: () => isReadingMode(getPresentationMode),
+        activation: activePlugins
+    };
+    const handleKeydown = (e) => {
+        if (e.defaultPrevented)
+            return;
+        const chord = eventToChord(e);
+        // Own-surface only: a chord bubbling from an inner leaf already met the global tier
+        // there, and re-firing it here would double-fire.
+        if (chord && ownsWholeBlockFocus(e) && handleEditorGlobalChord(chord, globalChordDeps)) {
+            e.preventDefault();
+            return;
+        }
+        if (chord &&
+            dispatchKindCommand(chord, kindTarget, 
+            // A container bubble carries no range command: the leaf below it owns the format ids.
+            {
+                getPresentationMode,
+                isCrossBlockRange: () => selection.isCrossBlock,
+                crossBlockCommands: undefined
+            }, keybindingOverrides(), (report) => emitCommandError(editorEvents, report))) {
+            e.preventDefault();
+            return;
+        }
+        handleWholeBlockKeydown(e);
+    };
+    const moveFocusOut = (e) => {
+        if (e.shiftKey || e.altKey || e.ctrlKey || e.metaKey)
+            return false;
+        // Classified through the doors before the move (G2.10 / G4.31). A plugin editable
+        // exposes no caret X to measure, so a vertical exit carries the column it arrived
+        // with, exactly as a whole-block pass-through does.
+        stickyColumn.noteKey(e);
+        edgeAffinity.note(e);
+        return focusAcrossBlockEdge(e.key, { getIndex: deps.getIndex, focus: parentFocus });
+    };
+    // The three gates keep a focused sibling (a toolbar button would double-fire its click
+    // and an Enter split) and a plugin's own editable surface untouched.
+    function ownsWholeBlockFocus(e) {
+        if (!wholeBlockSurface)
+            return false;
+        const proxy = inputProxy?.el();
+        // Identity, not the attribute alone: a proxy keydown bubbling up from a nested block
+        // would otherwise read as this one's.
+        if (proxy && e.target === proxy)
+            return true;
+        const focusEl = wholeBlockSurface();
+        if (!holdsWholeBlockFocus(focusEl, proxy))
+            return false;
+        return !isEditableEventTarget(e.target);
+    }
+    // The whole-block-focus affordances, dispatched from the wrapper's bubble phase.
+    function handleWholeBlockKeydown(e) {
+        if (!ownsWholeBlockFocus(e))
+            return;
+        // A whole-block surface is tabindex-focusable independent of contenteditable,
+        // so this path is live in reading mode: arrows stay, edits gate.
+        const reading = isReadingMode(getPresentationMode);
+        // Alt-arrow reorder is inline because `runCommand` is inert here, so unlike
+        // ThematicBreak it cannot come from dispatchKindCommand.
+        if (e.altKey && (e.key === 'ArrowUp' || e.key === 'ArrowDown')) {
+            e.preventDefault();
+            if (!reading)
+                void reorder.nudgeReorderUnit(deps.getPath(), e.key === 'ArrowUp' ? -1 : 1);
+            return;
+        }
+        handleWholeBlockKeys(e, {
+            getIndex: deps.getIndex,
+            getRaw: () => deps.getNode().raw,
+            blockEdit: parentBlockEdit,
+            focus: parentFocus,
+            isReading: () => reading,
+            stickyColumn,
+            edgeAffinity
+        });
+    }
+    return {
+        blockListProps,
+        containerApi,
+        updateOwnMetadata,
+        handleKeydown,
+        moveFocusOut,
+        getPresentationMode,
+        getTheme,
+        getOptions
+    };
+}

package/dist/editor-actions/plugin/directive-container.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `rebuildRaw` factory for a directive-backed container whose reserved child 0 is an
+ * editable title emitted into the opener line. Owns the title's return to the opener
+ * info, the `children[1:]` body, and the authored `lineEnding` a hand-written copy
+ * drops. The no-title sibling is `core/directive`'s `rebuildDirectiveContainerRaw`.
+ */
+import { type CstNode } from '../../core/nodes';
+export declare function createDirectiveRebuild<M extends {
+    colonCount: number;
+    closerColonCount: number;
+    closerNewline: boolean;
+    lineEnding: string;
+}>(directiveName: (meta: M | undefined) => string): (node: CstNode) => void;

package/dist/editor-actions/plugin/directive-container.js

@@ -0,0 +1,31 @@
+/**
+ * `rebuildRaw` factory for a directive-backed container whose reserved child 0 is an
+ * editable title emitted into the opener line. Owns the title's return to the opener
+ * info, the `children[1:]` body, and the authored `lineEnding` a hand-written copy
+ * drops. The no-title sibling is `core/directive`'s `rebuildDirectiveContainerRaw`.
+ */
+import { serializeDirective } from '../../core/directive/grammar';
+import { concatChildren as serializeChildren } from '../../core/serializer';
+import { trimTrailingLineEnding, trailingLineEnding } from '../../core/lines';
+import { getPluginMetadata } from '../../core/nodes';
+export function createDirectiveRebuild(directiveName) {
+    return (node) => {
+        const meta = getPluginMetadata(node);
+        const children = node.children ?? [];
+        const title = children[0] ? trimTrailingLineEnding(children[0].raw) : '';
+        node.raw = serializeDirective({
+            colonCount: meta?.colonCount ?? 3,
+            name: directiveName(meta),
+            info: title ? ` ${title}` : '',
+            innerPrefix: node.innerPrefix ?? '',
+            body: serializeChildren(children.slice(1)),
+            innerSuffix: node.innerSuffix ?? '',
+            closerColonCount: meta?.closerColonCount ?? meta?.colonCount ?? 3,
+            closerNewline: meta?.closerNewline ?? true,
+            lineEnding: meta?.lineEnding,
+            // The parse side threads only the opener ending, so recover the closer's own
+            // off the current raw, where the closer is the last line.
+            closerLineEnding: trailingLineEnding(node.raw)
+        });
+    };
+}

package/dist/editor-actions/reorder-action.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Sibling-reorder action for the drag-and-drop and keyboard-nudge callers: resolve the unit a path
+ * points into, clamp the destination, commit one permutation. A reorder creates no node — each
+ * moved block keeps its id and ref through the `reorderChildren` idMap — and the only writes are
+ * positional separators (`reorderChildrenWithTrivia`) and marker renumbering. Where the move
+ * invalidated a join, that primitive's settle folds it, so both the caret and the announcement
+ * ride the outcome it reports rather than the destination the clamp picked.
+ */
+import type { CommandId } from '../schema/commands';
+import type { EditorActionsDeps, UndoController } from './deps';
+export interface ReorderAction {
+    moveReorderUnit(fromPath: number[], toIndex: number): Promise<void>;
+    nudgeReorderUnit(fromPath: number[], dir: -1 | 1): Promise<void>;
+}
+/** The two ids that mean a reorder nudge, folded once for every surface's `runCommand` arm. */
+export declare function reorderRunCommand(id: CommandId, reorder: Pick<ReorderAction, 'nudgeReorderUnit'>, getPath: () => number[]): boolean;
+export declare function createReorderAction(deps: EditorActionsDeps, controller: UndoController, onReorder?: (to: number, total: number) => void): ReorderAction;

package/dist/editor-actions/reorder-action.js

@@ -0,0 +1,104 @@
+/**
+ * Sibling-reorder action for the drag-and-drop and keyboard-nudge callers: resolve the unit a path
+ * points into, clamp the destination, commit one permutation. A reorder creates no node — each
+ * moved block keeps its id and ref through the `reorderChildren` idMap — and the only writes are
+ * positional separators (`reorderChildrenWithTrivia`) and marker renumbering. Where the move
+ * invalidated a join, that primitive's settle folds it, so both the caret and the announcement
+ * ride the outcome it reports rather than the destination the clamp picked.
+ */
+import { CURSOR_START } from '../block-component';
+import { reorderChildrenWithTrivia } from '../tree-operations/reorder';
+import { resolveReorderUnit } from '../tree-operations/reorder-unit';
+import { blockNodeAt, nodeAt } from '../tree-operations/node-ops';
+import { renumberOrderedList } from '../tree-operations/list/ordered-markers';
+import { expectStateForNode } from '../reactivity/state-registry';
+import { readCurrentSelection } from '../selection/native-bridge';
+import { extendDocPath, docPathFrom } from '../cursor/coordinate-spaces';
+/** The two ids that mean a reorder nudge, folded once for every surface's `runCommand` arm. */
+export function reorderRunCommand(id, reorder, getPath) {
+    if (id !== 'block.moveUp' && id !== 'block.moveDown')
+        return false;
+    void reorder.nudgeReorderUnit(getPath(), id === 'block.moveUp' ? -1 : 1);
+    return true;
+}
+export function createReorderAction(deps, controller, onReorder) {
+    function caretOffset() {
+        return readCurrentSelection(deps.selectionState, deps.blockRefs)?.focus.offset ?? 0;
+    }
+    async function commitReorder(unit, to, offset) {
+        let landing = to;
+        if (unit.scope === 'document') {
+            await controller.commitStructural({
+                snapshot: { path: docPathFrom([unit.index]), offset },
+                op: {
+                    kind: 'reorder',
+                    detail: { from: unit.index, to },
+                    eventPath: docPathFrom([unit.index])
+                },
+                mutate: (children) => {
+                    const settled = reorderChildrenWithTrivia(children, unit.index, to, deps.sharing);
+                    landing = settled.landing;
+                    return settled.change;
+                },
+                afterTick: () => deps.blockRefs[landing]?.focus(CURSOR_START)
+            });
+            return { landing, total: deps.doc.children.length };
+        }
+        const parent = blockNodeAt(deps.doc, unit.parentPath);
+        if (!parent)
+            return null;
+        const state = expectStateForNode(parent);
+        await controller.commitContainerStructural({
+            containerNode: parent,
+            path: unit.parentPath,
+            state,
+            // A drag carries no live caret: restore to the moved unit's pre-move path.
+            snapshot: { path: extendDocPath(unit.parentPath, unit.index), offset },
+            op: {
+                kind: 'reorder',
+                detail: { from: unit.index, to },
+                eventPath: docPathFrom(unit.parentPath)
+            },
+            mutate: (scope) => {
+                const settled = reorderChildrenWithTrivia(scope.children, unit.index, to, scope.sharing);
+                landing = settled.landing;
+                if (unit.renumberMarkers) {
+                    // Ordered markers are position-dependent, so this unshares each item whose
+                    // marker it rewrites; the ceremony's rebuild then concatenates fresh raws.
+                    renumberOrderedList(scope.node, 0, scope.sharing);
+                }
+                return settled.change;
+            },
+            afterTick: () => state.innerBlockRefs[landing]?.focus(CURSOR_START)
+        });
+        // Re-resolved, not `parent`: the ceremony's copy-on-write replaced that node, so the one
+        // this action resolved still holds the pre-move children.
+        return { landing, total: blockNodeAt(deps.doc, unit.parentPath)?.children?.length ?? 0 };
+    }
+    function resolveAndClamp(fromPath, computeTo) {
+        const unit = resolveReorderUnit(deps.doc, fromPath);
+        if (!unit)
+            return null;
+        const parent = unit.scope === 'document' ? deps.doc : nodeAt(deps.doc, unit.parentPath);
+        const total = parent?.children?.length ?? 0;
+        const to = Math.max(0, Math.min(computeTo(unit.index), total - 1));
+        if (to === unit.index)
+            return null;
+        return { unit, to };
+    }
+    async function run(fromPath, computeTo) {
+        const target = resolveAndClamp(fromPath, computeTo);
+        if (!target)
+            return;
+        // Drop any cross-block selection so the overlay doesn't fight the move; the
+        // commit's afterTick re-places the caret.
+        deps.selectionState.collapse();
+        const outcome = await commitReorder(target.unit, target.to, caretOffset());
+        if (outcome)
+            onReorder?.(outcome.landing, outcome.total);
+    }
+    return {
+        moveReorderUnit: (fromPath, toIndex) => run(fromPath, () => toIndex),
+        nudgeReorderUnit: (fromPath, dir) => run(fromPath, (index) => index + dir)
+    };
+}

package/dist/editor-actions/reorder-drag.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pointer drag-to-reorder: one delegated capture-phase pointerdown on the editor
+ * root, a ghost + insertion line while dragging (no tree mutation, no reflow), and
+ * ONE move committed on drop. The drop index resolves against currently-mounted
+ * siblings only; autoscroll brings off-viewport ones into the window.
+ */
+import type { UserScrollport } from '../cursor/scroll-ancestors';
+import type { ReorderAction } from './reorder-action';
+export interface ReorderDragOverlay {
+    setGhost(g: {
+        clientX: number;
+        clientY: number;
+        label: string;
+    } | null): void;
+    setLine(l: {
+        left: number;
+        top: number;
+        width: number;
+    } | null): void;
+}
+export interface ReorderDragContext {
+    editorRoot: HTMLElement;
+    /** What autoscrolls when the drag reaches an edge: the root in self mode, the
+     *  host's scroller in host mode (where the root doesn't scroll), the window when
+     *  the page scrolls. Never `editorRoot` directly — see `cursor/scroll-ancestors`. */
+    getScrollHost: () => UserScrollport | null;
+    moveReorderUnit: ReorderAction['moveReorderUnit'];
+    overlay: ReorderDragOverlay;
+    /** Aborted on editor unmount — tears down a drag whose pointerup can't fire. */
+    lifetimeSignal?: AbortSignal;
+}
+export declare function installReorderDrag(ctx: ReorderDragContext): {
+    dispose(): void;
+};