@voithos-labs/aragonite 0.10.1

package/dist/selection/cross-block/dispatch.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cross-block event dispatch, wired by `components/blocks/editable-surface.ts` and by
+ * `Editor.svelte` for editor-root routing. The factory returns handlers each caller runs at the
+ * top of its own event handlers; single-block handling stays with the caller. This file is the
+ * composer: keydown in keydown.ts, pointer in pointer.ts, paste / type-replace passthroughs.
+ */
+import type { BlockEditActions, HistoryActions } from '../../action-contracts';
+import type { BlockComponent } from '../../block-component';
+import type { BlockElLookup, DocumentGetter, LinkReferenceResolverRef, PluginEditorLookup, PresentationModeGetter } from '../../editor-keys';
+import type { UserScrollport } from '../../cursor/scroll-ancestors';
+import type { SelectionState } from '../selection-state.svelte';
+import type { StickyColumnState } from '../../cursor/sticky-column';
+import type { EdgeAffinityState } from '../../cursor/edge-affinity';
+import type { CommitController } from '../../action-contracts';
+import type { KeybindingOverrideMap } from '../../schema/keybinding-overrides';
+import type { CommandErrorSink, CrossBlockCommandRouter } from '../../schema/block-commands';
+import type { EditorEvents } from '../../editor-events';
+import type { GrammarView } from '../../schema/block-openers';
+import type { PluginActivation } from '../../schema/plugin-activation';
+import type { PasteCommitCoordinator } from '../../tree-operations/paste/paste-deps';
+export interface CrossBlockDispatchContext {
+    getEl: () => HTMLElement | null;
+    getMyPath: () => number[];
+    getIndex: () => number;
+    selection: SelectionState;
+    getDoc: DocumentGetter;
+    getBlockElByPath: BlockElLookup;
+    revealPath: (path: number[]) => Promise<BlockComponent | null>;
+    getEditorRoot: () => HTMLElement | null;
+    /** What autoscrolls a drag-select that reaches an edge: the root, the host's scroller, or the
+     *  window. See `cursor/scroll-ancestors`. */
+    getScrollHost: () => UserScrollport | null;
+    /** Aborted when the owning editor unmounts. See the document facet's `lifetime`. */
+    getEditorLifetime: () => AbortSignal | null;
+    stickyColumn: StickyColumnState;
+    edgeAffinity: EdgeAffinityState;
+    blockEdit: BlockEditActions;
+    controller: CommitController;
+    history: HistoryActions;
+    pluginEditor: PluginEditorLookup | undefined;
+    /** The effective presentation mode; the destructive-branch reading gate keys off this. */
+    getPresentationMode: PresentationModeGetter | undefined;
+    /** The instance's link-reference resolver, forwarded to the delete's join seam. Required-
+     *  nullable like `pluginEditor`, so a new construction site can't silently skip the thread. */
+    linkRef: LinkReferenceResolverRef | undefined;
+    onCommandError: CommandErrorSink | undefined;
+    /** The arm a format chord takes over the live range; the seam routes there rather than
+     *  declining. Non-nullable: without it a rewrite chord is swallowed and nothing else. */
+    crossBlockCommands: CrossBlockCommandRouter;
+    getKeybindingOverrides: () => KeybindingOverrideMap;
+    pasteCoordinator: PasteCommitCoordinator;
+    /** Block grammar forwarded to the join-paste reparse. Required-nullable like `pluginEditor`
+     *  so a new construction site can't silently skip the thread; `undefined` = global. */
+    grammar: GrammarView | undefined;
+    /** The plugins this instance activated, forwarded to the paste-transform pipeline.
+     *  Required-nullable like `grammar`; `undefined` means every installed plugin. */
+    activePlugins: PluginActivation | undefined;
+    /** The instance event surface, the paste arm's only channel for a gesture it consumed but
+     *  could not land. Non-nullable: skipping it drops a paste in silence. */
+    events: EditorEvents;
+    getCursorOffset: () => number | null;
+    /** Svelte's tick() — awaited after mutations so the DOM settles. */
+    afterReactivity: () => Promise<void>;
+}
+export interface CrossBlockHandlers {
+    /** Returns true if the event was fully handled (caller should return). */
+    handleKeyDown(e: KeyboardEvent): Promise<boolean>;
+    handlePointerDown(e: PointerEvent): boolean;
+    /** `replacement` stands in for the clipboard's own text, for a caller that already turned the
+     *  payload into markdown and must not re-read the event past its awaits. A null event is a
+     *  programmatic insertion: no gesture to consume, so `replacement` carries the payload. */
+    handlePaste(e: ClipboardEvent | null, replacement?: string): Promise<boolean>;
+    handleBeforeInput(e: InputEvent): Promise<boolean>;
+    handleCompositionStart(): boolean;
+    /** Cross-block range delete for Cut handlers, after they synchronously wrote the clipboard. */
+    performCrossBlockDeleteFromEvent(): Promise<void>;
+}
+export declare function createCrossBlockHandlers(ctx: CrossBlockDispatchContext): CrossBlockHandlers;

package/dist/selection/cross-block/dispatch.js

@@ -0,0 +1,57 @@
+/**
+ * Cross-block event dispatch, wired by `components/blocks/editable-surface.ts` and by
+ * `Editor.svelte` for editor-root routing. The factory returns handlers each caller runs at the
+ * top of its own event handlers; single-block handling stays with the caller. This file is the
+ * composer: keydown in keydown.ts, pointer in pointer.ts, paste / type-replace passthroughs.
+ */
+import { isReadingMode } from '../../presentation-mode';
+import { performCrossBlockDelete } from './ops';
+import { handleCrossBlockPaste } from './paste';
+import { handleCrossBlockTypeReplace } from './type-replace';
+import { createCrossBlockKeydown } from './keydown';
+import { createCrossBlockPointer } from './pointer';
+export function createCrossBlockHandlers(ctx) {
+    const mutationCtx = {
+        selection: ctx.selection,
+        getDoc: ctx.getDoc,
+        getBlockElByPath: ctx.getBlockElByPath,
+        revealPath: ctx.revealPath,
+        controller: ctx.controller,
+        pushUndoSnapshot: () => ctx.controller.pushUndoSnapshot(ctx.getIndex(), ctx.getCursorOffset() ?? 0),
+        grammar: ctx.grammar,
+        getPresentationMode: ctx.getPresentationMode,
+        linkRef: ctx.linkRef
+    };
+    const keydown = createCrossBlockKeydown(ctx, mutationCtx);
+    const pointer = createCrossBlockPointer(ctx);
+    // Reading-mode gates for the mutating halves live at the composer, so every construction site
+    // (each editable surface, the editor root) inherits them. Keydown gates its own destructive
+    // branches, since it also carries navigation, which stays live.
+    const reading = () => isReadingMode(ctx.getPresentationMode);
+    return {
+        handleKeyDown: keydown.handleKeyDown,
+        handleCompositionStart: keydown.handleCompositionStart,
+        handlePointerDown: pointer.handlePointerDown,
+        handlePaste: async (e, replacement) => {
+            if (reading()) {
+                e?.preventDefault();
+                return true;
+            }
+            return handleCrossBlockPaste(ctx, mutationCtx, e, replacement);
+        },
+        handleBeforeInput: async (e) => {
+            if (reading()) {
+                e.preventDefault();
+                return true;
+            }
+            return handleCrossBlockTypeReplace(ctx, mutationCtx, e);
+        },
+        performCrossBlockDeleteFromEvent: async () => {
+            // Reached from cut handlers after the clipboard write; declining the delete
+            // degrades a reading-mode cut to a copy.
+            if (reading())
+                return;
+            await performCrossBlockDelete(mutationCtx);
+        }
+    };
+}

package/dist/selection/cross-block/format-range.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The per-block spans a cross-block format toggle rewrites, and the write over them. Pure over
+ * the tree, like `../range-delete`: the commit ceremony lives in `./format-toggle`. Direction is
+ * coverage across the WHOLE range — every span covered unapplies, anything else applies — so an
+ * apply leaves an already-marked block alone instead of toggling it the other way. Each span goes
+ * through the single-block seam, so its arms, candidates and mode verification are the same ones.
+ * A grid joins by its cells, which the range covers whole.
+ */
+import type { DocumentView } from '../../core/node-views';
+import type { InlineMarkKind } from '../../schema/inline-construct-policy';
+import type { PresentationMode } from '../../presentation-mode';
+import type { GrammarView } from '../../schema/block-openers';
+import { type NodeParent } from '../../tree-operations/node-ops';
+import type { SharingState } from '../../tree-operations/sharing';
+import { type SelectionPoint } from '../primitives';
+export interface CrossBlockFormatWrite {
+    path: number[];
+    /** The block's display bytes after the toggle — its raw minus the trailing line ending. */
+    newDisplay: string;
+    newSelStart: number;
+    newSelEnd: number;
+}
+export interface CrossBlockFormatPlan {
+    writes: CrossBlockFormatWrite[];
+    /** The range's own endpoints after the rewrite, in document order, each in the space its own
+     *  endpoint addresses: a char offset in prose and in the grid cell a deep path names, a cell
+     *  index where the endpoint counts cells. */
+    startOffset: number;
+    endOffset: number;
+}
+/** Null where no block participates: the press is still consumed, but nothing is written. */
+export declare function planCrossBlockFormat(doc: DocumentView, start: SelectionPoint, end: SelectionPoint, format: InlineMarkKind, mode: PresentationMode | undefined): CrossBlockFormatPlan | null;
+/** The pressed-state a toolbar paints over a range, every mark at once: one is active where
+ *  EVERY participating span carries it. All marks together, because a toolbar asks once per
+ *  button against the same range and the decomposition is the cost. */
+export declare function crossBlockActiveFormats(doc: DocumentView, start: SelectionPoint, end: SelectionPoint): ReadonlySet<InlineMarkKind>;
+/** Write a plan into the tree, copy-path-on-write. The caller owns the commit ceremony. */
+export declare function applyCrossBlockFormat(root: NodeParent, plan: CrossBlockFormatPlan, sharing: SharingState, grammar: GrammarView | undefined): void;

package/dist/selection/cross-block/format-range.js

@@ -0,0 +1,193 @@
+/**
+ * The per-block spans a cross-block format toggle rewrites, and the write over them. Pure over
+ * the tree, like `../range-delete`: the commit ceremony lives in `./format-toggle`. Direction is
+ * coverage across the WHOLE range — every span covered unapplies, anything else applies — so an
+ * apply leaves an already-marked block alone instead of toggling it the other way. Each span goes
+ * through the single-block seam, so its arms, candidates and mode verification are the same ones.
+ * A grid joins by its cells, which the range covers whole.
+ */
+import { activeInlineFormats, inlineFormatsCovering, isInlineFormatActive, isInlineFormatActiveAfter, toggleInlineFormat } from '../../core/inline/format-toggle';
+import { getContentRange } from '../../core/inline';
+import { ownTrailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
+import { tryGetBlockKindDescriptor } from '../../schema/block-kind-descriptor';
+import { normalizeBodyWrite, writeOwnRaw } from '../../tree-operations/node-ops';
+import { ensureUnsharedPath, rebuildUnsharedChain } from '../../tree-operations/unshare';
+import { comparePaths } from '../path-math';
+import { charOffsetOf } from '../primitives';
+import { coveredGridCells, gridEndpointCellIndex } from '../table-endpoint-snap';
+const TAG = 'cross-block-format';
+/** Null where no block participates: the press is still consumed, but nothing is written. */
+export function planCrossBlockFormat(doc, start, end, format, mode) {
+    const spans = spansInRange(doc, start, end);
+    if (spans.length === 0)
+        return null;
+    // Read once per span: the vote and the per-span skip below ask the same question, and the
+    // answer costs a parse of the block's inlines.
+    const covered = spans.map((span) => isInlineFormatActive(span.edit, format));
+    const unapply = covered.every(Boolean);
+    // Each endpoint's own space, carried rather than read: a participating span overwrites its side
+    // with a char offset, and an endpoint counting cells owns no span, so its index stands.
+    const plan = {
+        writes: [],
+        startOffset: start.offset,
+        endOffset: end.offset
+    };
+    for (const [index, span] of spans.entries()) {
+        if (covered[index] !== unapply)
+            continue;
+        const toggled = toggleInlineFormat(span.edit, format, mode);
+        if (!toggled || !landedOnIntendedSide(span.edit, toggled, format, unapply))
+            continue;
+        plan.writes.push({
+            path: span.path,
+            newDisplay: toggled.newDisplay,
+            newSelStart: toggled.newSelStart,
+            newSelEnd: toggled.newSelEnd
+        });
+        if (span.isStart)
+            plan.startOffset = toggled.newSelStart;
+        if (span.isEnd)
+            plan.endOffset = toggled.newSelEnd;
+    }
+    return plan.writes.length === 0 ? null : plan;
+}
+/** The pressed-state a toolbar paints over a range, every mark at once: one is active where
+ *  EVERY participating span carries it. All marks together, because a toolbar asks once per
+ *  button against the same range and the decomposition is the cost. */
+export function crossBlockActiveFormats(doc, start, end) {
+    const spans = spansInRange(doc, start, end);
+    if (spans.length === 0)
+        return new Set();
+    // The running intersection is the next span's candidate set, so a span costs one parse and a
+    // walk per mark still standing, and it empties where a per-mark `every` would stop.
+    let active = activeInlineFormats(spans[0].edit);
+    for (let index = 1; index < spans.length && active.size > 0; index++)
+        active = inlineFormatsCovering(spans[index].edit, active);
+    return active;
+}
+/** Write a plan into the tree, copy-path-on-write. The caller owns the commit ceremony. */
+export function applyCrossBlockFormat(root, plan, sharing, grammar) {
+    const chains = [];
+    for (const write of plan.writes) {
+        const chain = ensureUnsharedPath(root, write.path, sharing);
+        const owned = chain[chain.length - 1];
+        if (!owned)
+            continue;
+        // A line ending reaching a cell's raw would be normalized into a space at the write sink.
+        const raw = write.newDisplay + ownTrailingLineEnding(owned.raw);
+        writeOwnRaw(owned, normalizeBodyWrite(chain[chain.length - 2]?.kind, raw), grammar);
+        chains.push(chain);
+    }
+    // Every write lands before any rebuild, and a chain rebuild re-emits its whole ancestry from
+    // children that are already current, so chain order is free.
+    for (const chain of chains)
+        rebuildUnsharedChain(root, chain, sharing, null, grammar);
+}
+/**
+ * The anchor block's tail, every middle block's content, the focus block's head — in document
+ * order. Participation is the kind's own declaration, never its name: an editable, inline-bearing
+ * leaf with a non-blank span joins, and a grid hands over its covered cells, which are leaves of
+ * that same shape.
+ */
+function spansInRange(doc, start, end) {
+    const spans = [];
+    const visit = (holder, path) => {
+        const children = holder.children ?? [];
+        for (let index = 0; index < children.length; index++) {
+            const here = [...path, index];
+            // Everything past the end endpoint is out of the range, subtrees included.
+            if (comparePaths(here, end.path) > 0)
+                return;
+            const child = children[index];
+            if (child.children) {
+                if (tryGetBlockKindDescriptor(child.kind)?.containerContract === 'grid') {
+                    // Appended, never spread: covered cells outnumber an argument list (G4.60).
+                    for (const span of gridSpans(child, here, start, end))
+                        spans.push(span);
+                }
+                else {
+                    visit(child, here);
+                }
+                continue;
+            }
+            const span = spanFor(child, here, start, end);
+            if (span)
+                spans.push(span);
+        }
+    };
+    visit(doc, []);
+    return spans;
+}
+function spanFor(node, path, start, end) {
+    if (comparePaths(path, start.path) < 0 || comparePaths(path, end.path) > 0)
+        return null;
+    const isStart = comparePaths(path, start.path) === 0;
+    const isEnd = comparePaths(path, end.path) === 0;
+    const body = contentSpan(node, path, isStart ? charOffsetOf(start, TAG) : null, isEnd ? charOffsetOf(end, TAG) : null);
+    return body && { ...body, isStart, isEnd };
+}
+/**
+ * A grid's covered cells, each contributing its WHOLE content. An endpoint inside a grid resolves
+ * to one of its cells, so no cell is ever cut in half: an endpoint counting cells stays on the one
+ * it named, while one naming its cell by path follows that cell's own write.
+ */
+function gridSpans(grid, path, start, end) {
+    const from = gridEndpointCellIndex(grid, path, start);
+    // No endpoint of its own, and the range starts after it: the grid sits wholly before the range.
+    if (from === null && comparePaths(path, start.path) < 0)
+        return [];
+    const cells = coveredGridCells(grid, path, from, gridEndpointCellIndex(grid, path, end));
+    const spans = [];
+    for (const cell of cells) {
+        const body = contentSpan(cell.node, cell.path, null, null);
+        if (body)
+            spans.push({
+                ...body,
+                isStart: addressesCell(start, cell.path),
+                isEnd: addressesCell(end, cell.path)
+            });
+    }
+    return spans;
+}
+/** Whether the endpoint names this cell BY PATH, which is the same question as whether its offset
+ *  is a CHAR offset: only the deep `[grid, row, col]` endpoint G1.29 permits can match a cell path,
+ *  so a table's cell index keeps its own space while a plugin grid's edge follows its cell's
+ *  rewrite, as a prose edge follows its block's. */
+function addressesCell(point, cellPath) {
+    return comparePaths(point.path, cellPath) === 0;
+}
+/**
+ * What one leaf contributes between two char offsets — null on a side meaning the block's own
+ * content edge. Null where the kind declares itself out of inline marking, or where the boundary
+ * trim leaves nothing to mark.
+ */
+function contentSpan(node, path, from, to) {
+    const descriptor = tryGetBlockKindDescriptor(node.kind);
+    if (!descriptor?.supportsInline || !descriptor.editable || descriptor.isContainer)
+        return null;
+    const display = trimTrailingLineEnding(node.raw);
+    const content = getContentRange(node);
+    const selection = withoutBoundaryWhitespace(display, clampToContent(from ?? content.start, content), clampToContent(to ?? content.end, content));
+    return selection && { path, edit: { display, content, selection } };
+}
+/** The span minus its boundary whitespace, null once nothing is left. Markdown opens and closes a
+ *  run against a word, never a space, so an untrimmed edge yields delimiters that form no
+ *  construct — which the modes that paint them write anyway (`wrapCandidates` is unverified there). */
+function withoutBoundaryWhitespace(display, from, to) {
+    let start = from;
+    let end = to;
+    while (start < end && /\s/.test(display[start]))
+        start++;
+    while (end > start && /\s/.test(display[end - 1]))
+        end--;
+    return start === end ? null : { start, end };
+}
+const clampToContent = (offset, content) => Math.min(Math.max(offset, content.start), content.end);
+/**
+ * Whether the span actually changed sides. The single-block seam decides its own arm from the
+ * span alone, so a block whose write disagreed with the range's direction is dropped rather than
+ * committed against the press the user made.
+ */
+function landedOnIntendedSide(edit, toggled, format, unapply) {
+    return isInlineFormatActiveAfter(edit, toggled, format) !== unapply;
+}

package/dist/selection/cross-block/format-toggle.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The cross-block arm of the inline format toggles: plan the per-block spans (`./format-range`),
+ * write them all under ONE undo entry through the multi-scope ceremony, then put the range back
+ * over the result through the shared restore road. The dispatch seam reaches this through an
+ * injected router, so `schema/` keeps no edge to selection machinery.
+ */
+import type { BlockComponent } from '../../block-component';
+import type { CommitController } from '../../action-contracts';
+import type { BlockElLookup, DocumentGetter, PresentationModeGetter } from '../../editor-keys';
+import type { CrossBlockCommandRouter } from '../../schema/block-commands';
+import type { GrammarView } from '../../schema/block-openers';
+import type { SelectionState } from '../selection-state.svelte';
+export interface CrossBlockCommandDeps {
+    selection: SelectionState;
+    getDoc: DocumentGetter;
+    getBlockElByPath: BlockElLookup;
+    revealPath: (path: number[]) => Promise<BlockComponent | null>;
+    controller: CommitController;
+    /** The mode each per-block rewrite verifies against. Required-nullable like the cross-block
+     *  dispatch context's own threads; `undefined` reads as source. */
+    getPresentationMode: PresentationModeGetter | undefined;
+    grammar: GrammarView | undefined;
+    /** The pressed-state memo's key alongside the range: the document is mutated in place, so its
+     *  identity witnesses nothing (`docs/design/editor.md` § 7). */
+    getContentVersion: () => number;
+}
+export declare function createCrossBlockCommands(deps: CrossBlockCommandDeps): CrossBlockCommandRouter;

package/dist/selection/cross-block/format-toggle.js

@@ -0,0 +1,109 @@
+/**
+ * The cross-block arm of the inline format toggles: plan the per-block spans (`./format-range`),
+ * write them all under ONE undo entry through the multi-scope ceremony, then put the range back
+ * over the result through the shared restore road. The dispatch seam reaches this through an
+ * injected router, so `schema/` keeps no edge to selection machinery.
+ */
+import { ownTrailingLineEnding } from '../../core/lines';
+import { docPathFrom } from '../../cursor/coordinate-spaces';
+import { inlineMarkForCommand } from '../../schema/inline-construct-policy';
+import { blockNodeAt } from '../../tree-operations/node-ops';
+import { comparePaths } from '../path-math';
+import { restoreSelection } from '../selection-restore';
+import { applyCrossBlockFormat, crossBlockActiveFormats, planCrossBlockFormat } from './format-range';
+export function createCrossBlockCommands(deps) {
+    const activeFormats = createActiveFormatMemo(deps);
+    return {
+        // Reachability of the arm, not participation: whether any block joins is only known once
+        // the range is decomposed, and a press that reaches no block writes nothing.
+        canRun: (id) => inlineMarkForCommand(id) !== null,
+        run: (id) => {
+            const mark = inlineMarkForCommand(id);
+            if (!mark)
+                return false;
+            void toggleFormatOverRange(deps, mark.kind);
+            return true;
+        },
+        isActive: (id) => {
+            const mark = inlineMarkForCommand(id);
+            return mark !== null && activeFormats().has(mark.kind);
+        }
+    };
+}
+// ── The pressed-state memo ─────────────────────────────────────────────────
+const NO_MARKS = new Set();
+/** One slot rather than a cache: a toolbar asks once per button against one range, and the previous
+ *  key is dead the moment the selection moves. Outside reactive state like `inline-cache.ts`, since
+ *  a derived read that wrote `$state` would be a write during a read. */
+function createActiveFormatMemo(deps) {
+    let slot = null;
+    return () => {
+        const { start, end } = deps.selection;
+        if (!start || !end)
+            return NO_MARKS;
+        const key = `${deps.getContentVersion()}|${pointKey(start)}|${pointKey(end)}`;
+        if (slot?.key !== key) {
+            slot = { key, marks: crossBlockActiveFormats(deps.getDoc(), start, end) };
+        }
+        return slot.marks;
+    };
+}
+/** The offset's SPACE is part of the identity: a cell point counts cells where a char point
+ *  counts bytes, so the flag rides the key. */
+const pointKey = (point) => `${point.path.join(',')}@${point.offset}${point.cellCoordinate ? 'c' : ''}`;
+// ── The commit ─────────────────────────────────────────────────────────────
+async function toggleFormatOverRange(deps, format) {
+    const { anchor, focus, start, end } = deps.selection;
+    if (!anchor || !focus || !start || !end)
+        return;
+    const doc = deps.getDoc();
+    const plan = planCrossBlockFormat(doc, start, end, format, deps.getPresentationMode?.());
+    if (!plan)
+        return;
+    const restored = restoredRange(anchor, focus, start, end, plan);
+    await deps.controller.commitMultiScope({
+        // Doc scope alone: the writes are bytes, not splices, so no container's children array
+        // or id list moves and each touched spine rebuilds from the leaf it owns.
+        scopes: [deps.controller.getDocScope()],
+        // The endpoint's own space, like the plan's offsets: undo restores through the clamp that
+        // reads a grid's path as cell indices.
+        snapshot: { path: docPathFrom(start.path), offset: start.offset },
+        mutate: ([docScope]) => {
+            applyCrossBlockFormat({ children: docScope.children }, plan, docScope.sharing, deps.grammar);
+            return [{ op: 'noop' }];
+        },
+        op: {
+            kind: 'updateContent',
+            detail: { length: startBlockLength(doc, start, plan), crossBlock: true },
+            eventPath: docPathFrom(start.path)
+        },
+        afterTick: async () => {
+            await restoreSelection(restored, {
+                getDoc: deps.getDoc,
+                selectionState: deps.selection,
+                getBlockElByPath: deps.getBlockElByPath,
+                revealTarget: async (path) => (await deps.revealPath(path)) !== null
+            });
+        }
+    });
+}
+/** The same pair, re-offset, with the user's anchor still on the side it was drawn from. */
+function restoredRange(anchor, focus, start, end, plan) {
+    const order = comparePaths(anchor.path, focus.path);
+    const anchorLeads = order < 0 || (order === 0 && anchor.offset <= focus.offset);
+    const first = withOffset(start, plan.startOffset);
+    const last = withOffset(end, plan.endOffset);
+    return anchorLeads ? { anchor: first, focus: last } : { anchor: last, focus: first };
+}
+const withOffset = (point, offset) => ({
+    ...point,
+    path: point.path.slice(),
+    offset
+});
+/** The event detail's post-write length, read off the plan: `op` is spent before `mutate` runs.
+ *  A block the plan does not write reports the length it already stands at (`schema/operations.ts`). */
+function startBlockLength(doc, start, plan) {
+    const raw = blockNodeAt(doc, start.path)?.raw ?? '';
+    const write = plan.writes.find((entry) => comparePaths(entry.path, start.path) === 0);
+    return write ? write.newDisplay.length + ownTrailingLineEnding(raw).length : raw.length;
+}

package/dist/selection/cross-block/keydown.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Keydown + compositionstart half of the cross-block dispatcher. See dispatch.ts for the
+ * composer that wires this together with the pointer half.
+ */
+import type { CrossBlockMutationContext } from './ops';
+import type { CrossBlockDispatchContext } from './dispatch';
+export interface CrossBlockKeydown {
+    handleKeyDown(e: KeyboardEvent): Promise<boolean>;
+    handleCompositionStart(): boolean;
+}
+export declare function createCrossBlockKeydown(ctx: CrossBlockDispatchContext, mutCtx: CrossBlockMutationContext): CrossBlockKeydown;