@voithos-labs/aragonite 0.10.3 → 0.10.7

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

@@ -1,8 +1,6 @@
 /**
- * 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.
+ * Cross-block event dispatch: handlers an editable block, or the editor root, runs at the top of
+ * its own event handlers, before its single-block handling.
  */
 import { isReadingMode } from '../../presentation-mode';
 import { performCrossBlockDelete } from './ops';
@@ -17,19 +15,15 @@ export function createCrossBlockHandlers(ctx) {
         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
+        reading: ctx.reading
     };
     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);
+    // The reading-mode checks for the mutating handlers live here so every caller inherits them;
+    // keydown checks its own destructive branches, since its navigation stays live.
+    const refusesWrites = () => isReadingMode(ctx.reading.mode);
     const insertText = async (text) => {
-        if (reading())
+        if (refusesWrites())
             return true;
         if (!ctx.selection.isCrossBlock)
             return false;
@@ -41,29 +35,24 @@ export function createCrossBlockHandlers(ctx) {
         handleCompositionStart: keydown.handleCompositionStart,
         handlePointerDown: pointer.handlePointerDown,
         handlePaste: async (e, replacement) => {
-            if (reading()) {
+            if (refusesWrites()) {
                 e?.preventDefault();
                 return true;
             }
             return handleCrossBlockPaste(ctx, mutationCtx, e, replacement);
         },
         handleBeforeInput: async (e) => {
-            if (reading()) {
-                e.preventDefault();
-                return true;
-            }
             if (!ctx.selection.isCrossBlock || e.inputType !== 'insertText')
                 return false;
             e.preventDefault();
             return insertText(e.data ?? '');
         },
         insertText,
-        performCrossBlockDeleteFromEvent: async () => {
-            // Reached from cut handlers after the clipboard write; declining the delete
-            // degrades a reading-mode cut to a copy.
-            if (reading())
+        performCrossBlockCut: async () => {
+            // Declining the delete degrades a reading-mode cut to a copy.
+            if (refusesWrites())
                 return;
-            await performCrossBlockDelete(mutationCtx);
+            await performCrossBlockDelete(mutationCtx, 'cut');
         }
     };
 }

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

@@ -1,38 +1,35 @@
 /**
- * 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.
+ * The per-block spans a cross-block format toggle rewrites, and the write over them; pure over
+ * the tree, with the commit in `./format-toggle`. The direction is decided over the whole range:
+ * every span already marked removes the mark, anything else adds it. Each span goes through the
+ * single-block toggle, and a table joins by its covered cells.
  */
 import type { DocumentView } from '../../core/node-views';
 import type { InlineMarkKind } from '../../schema/inline-construct-policy';
-import type { PresentationMode } from '../../presentation-mode';
+import type { Reading } from '../../schema/reading';
 import type { GrammarView } from '../../schema/block-openers';
-import { type NodeParent } from '../../tree-operations/node-primitives';
+import { type BodyParent } from '../../tree-operations/node-primitives';
 import type { SharingState } from '../../tree-operations/sharing';
-import { type SelectionPoint } from '../primitives';
+import { type CoveredRange } from '../range-coverage';
 export interface CrossBlockFormatWrite {
     path: number[];
-    /** The block's display bytes after the toggle — its raw minus the trailing line ending. */
+    /** 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. */
+    /** The range's endpoints after the rewrite, each in its own space: a character offset in a
+     *  text block or a path-named grid cell, 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;
+/** Null where no block participates: the keystroke is still consumed, but nothing is written. */
+export declare function planCrossBlockFormat(doc: DocumentView, range: CoveredRange, format: InlineMarkKind, reading: Reading): CrossBlockFormatPlan | null;
+/** A mark is active where every participating span carries it. All marks at once, since
+ *  splitting the range into spans is the cost and a toolbar asks once per button. */
+export declare function crossBlockActiveFormats(doc: DocumentView, range: CoveredRange, reading: Reading): ReadonlySet<InlineMarkKind>;
+/** Writes a plan into the document body, copying each chain before writing. The caller owns the
+ *  commit. */
+export declare function applyCrossBlockFormat(body: BodyParent, plan: CrossBlockFormatPlan, sharing: SharingState, grammar: GrammarView): void;

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

@@ -1,33 +1,35 @@
 /**
- * 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.
+ * The per-block spans a cross-block format toggle rewrites, and the write over them; pure over
+ * the tree, with the commit in `./format-toggle`. The direction is decided over the whole range:
+ * every span already marked removes the mark, anything else adds it. Each span goes through the
+ * single-block toggle, and a table joins by its covered cells.
  */
 import { activeInlineFormats, inlineFormatsCovering, isInlineFormatActive, isInlineFormatActiveAfter, toggleInlineFormat, withoutBoundaryWhitespace } 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-primitives';
+import { blockNodeAt } from '../../tree-operations/node-primitives';
+import { rewriteLeafInPlace } from '../../tree-operations/content-write';
 import { ensureUnsharedPath } from '../../tree-operations/unshare';
-import { rebuildUnsharedChain } from '../../tree-operations/chain-rebuild';
-import { comparePaths } from '../path-math';
+import { rebuildUnsharedChain, sharedChainLevels } from '../../tree-operations/chain-rebuild';
+import { pathsEqual } from '../path-math';
 import { charOffsetOf } from '../primitives';
-import { coveredGridCells, gridEndpointCellIndex } from '../table-endpoint-snap';
+import { rangeCoverage } from '../range-coverage';
+import { gridCellsInRect, gridCellsInRun } 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);
+/** Null where no block participates: the keystroke is still consumed, but nothing is written. */
+export function planCrossBlockFormat(doc, range, format, reading) {
+    const coverage = rangeCoverage(doc, range);
+    const { start, end } = range;
+    const spans = spansInRange(doc, coverage, reading);
     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.
+    // Each endpoint keeps its own space: a participating span overwrites its side with a
+    // character offset, and an endpoint counting cells owns no span, so its index stands.
     const plan = {
         writes: [],
         startOffset: start.offset,
@@ -36,7 +38,7 @@ export function planCrossBlockFormat(doc, start, end, format, mode) {
     for (const [index, span] of spans.entries()) {
         if (covered[index] !== unapply)
             continue;
-        const toggled = toggleInlineFormat(span.edit, format, mode);
+        const toggled = toggleInlineFormat(span.edit, format);
         if (!toggled || !landedOnIntendedSide(span.edit, toggled, format, unapply))
             continue;
         plan.writes.push({
@@ -49,14 +51,17 @@ export function planCrossBlockFormat(doc, start, end, format, mode) {
             plan.startOffset = toggled.newSelStart;
         if (span.isEnd)
             plan.endOffset = toggled.newSelEnd;
+        // An end block held whole stays held at its new last byte.
+        if (!coverage.endEdge && pathsEqual(span.path, end.path)) {
+            plan.endOffset = toggled.newDisplay.length;
+        }
     }
     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);
+/** A mark is active where every participating span carries it. All marks at once, since
+ *  splitting the range into spans is the cost and a toolbar asks once per button. */
+export function crossBlockActiveFormats(doc, range, reading) {
+    const spans = spansInRange(doc, rangeCoverage(doc, range), reading);
     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
@@ -66,117 +71,113 @@ export function crossBlockActiveFormats(doc, start, end) {
         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) {
+/** Writes a plan into the document body, copying each chain before writing. The caller owns the
+ *  commit. */
+export function applyCrossBlockFormat(body, plan, sharing, grammar) {
     const chains = [];
     for (const write of plan.writes) {
-        const chain = ensureUnsharedPath(root, write.path, sharing);
+        const chain = ensureUnsharedPath(body, 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 owner = chain[chain.length - 2];
+        const holder = owner ? { children: owner.children, owner, lineEnding: body.lineEnding } : body;
+        // A line ending reaching a cell's raw would be turned into a space by the cell's write rule.
         const raw = write.newDisplay + ownTrailingLineEnding(owned.raw);
-        writeOwnRaw(owned, normalizeBodyWrite(chain[chain.length - 2]?.kind, raw), grammar);
+        rewriteLeafInPlace(holder, write.path[write.path.length - 1], raw, grammar, sharing);
         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);
+    // Every write lands before any rebuild, and an ancestor the chains share is rebuilt once, by the
+    // last chain holding it, after every chain below it.
+    const levels = sharedChainLevels(chains);
+    chains.forEach((chain, i) => {
+        rebuildUnsharedChain(body, chain, sharing, null, grammar, undefined, levels[i]);
+    });
 }
-/**
- * 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) {
+/** The start edge's tail, every block the range holds whole and the end edge's head, in document
+ *  order, read off `rangeCoverage`. A kind joins by what its descriptor declares, never by name. */
+function spansInRange(doc, coverage, reading) {
+    const { start, end } = coverage.range;
     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);
-        }
+    // Pushed one by one, never spread: a large grid's cells can exceed the argument-list limit
+    // (G4.60).
+    const push = (cells) => {
+        for (const span of cells)
+            spans.push(span);
     };
-    visit(doc, []);
+    if (coverage.grid) {
+        const { path, rect } = coverage.grid;
+        const table = blockNodeAt(doc, path);
+        if (table)
+            push(cellSpans(gridCellsInRect(table, path, rect), reading));
+        return spans;
+    }
+    if (coverage.startEdge && coverage.endEdge && pathsEqual(start.path, end.path)) {
+        push(edgeSpans(doc, start, end, null, reading));
+        return spans;
+    }
+    if (coverage.startEdge)
+        push(edgeSpans(doc, start, null, coverage.startCells, reading));
+    for (const root of coverage.wholeRoots)
+        push(wholeSpans(doc, root, reading));
+    if (coverage.endEdge)
+        push(edgeSpans(doc, null, end, coverage.endCells, reading));
     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 kept edge's part of its block: the text from the start or up to the end, or the cells a
+ *  table edge hands over. */
+function edgeSpans(doc, start, end, cells, reading) {
+    const point = (start ?? end);
+    const node = blockNodeAt(doc, point.path);
+    if (!node)
+        return [];
+    if (cells)
+        return cellSpans(gridCellsInRun(node, point.path, cells.from, cells.to - 1), reading);
+    const body = contentSpan(node, point.path, start ? charOffsetOf(start, TAG) : null, end ? charOffsetOf(end, TAG) : null, reading);
+    return body ? [{ ...body, isStart: start !== null, isEnd: end !== null }] : [];
 }
-/**
- * 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)
+/** Every leaf of a subtree the range holds whole, each whole, in document order. */
+function wholeSpans(doc, root, reading) {
+    const node = blockNodeAt(doc, [...root]);
+    if (!node)
         return [];
-    const cells = coveredGridCells(grid, path, from, gridEndpointCellIndex(grid, path, end));
+    const spans = [];
+    const visit = (at, atPath) => {
+        if (at.children) {
+            at.children.forEach((child, index) => visit(child, [...atPath, index]));
+            return;
+        }
+        const body = contentSpan(at, atPath, null, null, reading);
+        if (body)
+            spans.push({ ...body, isStart: false, isEnd: false });
+    };
+    visit(node, [...root]);
+    return spans;
+}
+/** Each cell whole; a table endpoint counting cells never names a cell path (G1.29). */
+function cellSpans(cells, reading) {
     const spans = [];
     for (const cell of cells) {
-        const body = contentSpan(cell.node, cell.path, null, null);
+        const body = contentSpan(cell.node, cell.path, null, null, reading);
         if (body)
-            spans.push({
-                ...body,
-                isStart: addressesCell(start, cell.path),
-                isEnd: addressesCell(end, cell.path)
-            });
+            spans.push({ ...body, isStart: false, isEnd: false });
     }
     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) {
+/** What one leaf contributes between two character offsets, a null side meaning its content
+ *  edge. Null for a kind outside inline marking, or when trimming whitespace leaves nothing. */
+function contentSpan(node, path, from, to, reading) {
     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 } };
+    return selection && { path, edit: { display, content, selection, reading } };
 }
 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.
- */
+/** Whether the span's toggle went the range's way. The single-block toggle decides from the span
+ *  alone, so a block that went the other way is dropped rather than written. */
 function landedOnIntendedSide(edit, toggled, format, unapply) {
     return isInlineFormatActiveAfter(edit, toggled, format) !== unapply;
 }

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

@@ -1,27 +1,22 @@
 /**
- * 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.
+ * The cross-block half of the inline format toggles: plan the per-block spans, write them under
+ * one undo entry, and put the range back over the result. The key dispatcher reaches this module
+ * through an injected router, so `schema/` keeps no import of selection code.
  */
-import type { BlockComponent } from '../../block-component';
 import type { CommitController } from '../../action-contracts';
-import type { BlockElLookup, DocumentGetter, PresentationModeGetter } from '../../editor-keys';
+import type { DocumentGetter } from '../../editor-keys';
 import type { CrossBlockCommandRouter } from '../../schema/block-commands';
-import type { GrammarView } from '../../schema/block-openers';
+import type { Reading } from '../../schema/reading';
 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). */
+    /** How the blocks were drawn: each span's toggle reads its link definitions and grammar, and
+     *  verifies its rewrite against its mode. */
+    reading: Reading;
+    /** The active-marks memo's key alongside the range: the document is mutated in place, so its
+     *  identity says nothing about whether it changed. */
     getContentVersion: () => number;
 }
 export declare function createCrossBlockCommands(deps: CrossBlockCommandDeps): CrossBlockCommandRouter;

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

@@ -1,21 +1,20 @@
 /**
- * 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.
+ * The cross-block half of the inline format toggles: plan the per-block spans, write them under
+ * one undo entry, and put the range back over the result. The key dispatcher reaches this module
+ * through an injected router, so `schema/` keeps no import of selection code.
  */
 import { ownTrailingLineEnding } from '../../core/lines';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 import { inlineMarkForCommand } from '../../schema/inline-construct-policy';
 import { blockNodeAt } from '../../tree-operations/node-primitives';
 import { comparePaths } from '../path-math';
-import { restoreSelection } from '../selection-restore';
+import { coverRange } from '../range-coverage';
 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.
+        // Whether the command has a cross-block handler, not whether any block joins, which is known
+        // only once the range splits into spans; a keystroke that reaches no block writes nothing.
         canRun: (id) => inlineMarkForCommand(id) !== null,
         run: (id) => {
             const mark = inlineMarkForCommand(id);
@@ -30,46 +29,49 @@ export function createCrossBlockCommands(deps) {
         }
     };
 }
-// ── The pressed-state memo ─────────────────────────────────────────────────
+// ── The active-marks 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. */
+/** One entry, not a cache: the previous key is dead once the selection moves. Outside reactive
+ *  state, 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)
+        const { anchor, focus } = deps.selection;
+        if (!anchor || !focus)
             return NO_MARKS;
-        const key = `${deps.getContentVersion()}|${pointKey(start)}|${pointKey(end)}`;
+        const key = `${deps.getContentVersion()}|${pointKey(anchor)}|${pointKey(focus)}`;
         if (slot?.key !== key) {
-            slot = { key, marks: crossBlockActiveFormats(deps.getDoc(), start, end) };
+            const doc = deps.getDoc();
+            const range = coverRange(doc, anchor, focus);
+            slot = { key, marks: crossBlockActiveFormats(doc, range, deps.reading) };
         }
         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. */
+/** The offset's space is part of the identity: a cell point counts cells where a character
+ *  point counts bytes, so the flag goes in 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)
+    const { anchor, focus } = deps.selection;
+    if (!anchor || !focus)
         return;
     const doc = deps.getDoc();
-    const plan = planCrossBlockFormat(doc, start, end, format, deps.getPresentationMode?.());
+    const range = coverRange(doc, anchor, focus);
+    const plan = planCrossBlockFormat(doc, range, format, deps.reading);
     if (!plan)
         return;
+    const { start, end } = range;
     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.
+        // The document scope alone: the writes are bytes, not splices, so no container's children
+        // array or id list moves and each touched chain rebuilds from its own leaf.
         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);
+            applyCrossBlockFormat(docScope.body, plan, docScope.sharing, deps.reading.grammar);
             return [{ op: 'noop' }];
         },
         op: {
@@ -77,14 +79,7 @@ async function toggleFormatOverRange(deps, format) {
             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
-            });
-        }
+        landing: () => restored
     });
 }
 /** The same pair, re-offset, with the user's anchor still on the side it was drawn from. */
@@ -100,8 +95,8 @@ const withOffset = (point, offset) => ({
     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`). */
+/** The event detail's post-write length, read off the plan, since `op` is evaluated before
+ *  `mutate` runs. A block the plan doesn't write reports its current length. */
 function startBlockLength(doc, start, plan) {
     const raw = blockNodeAt(doc, start.path)?.raw ?? '';
     const write = plan.writes.find((entry) => comparePaths(entry.path, start.path) === 0);

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

@@ -1,11 +1,11 @@
-/**
- * Keydown + compositionstart half of the cross-block dispatcher. See dispatch.ts for the
- * composer that wires this together with the pointer half.
- */
+/** The keydown and compositionstart half of cross-block dispatch. */
 import type { CrossBlockMutationContext } from './ops';
 import type { CrossBlockDispatchContext } from './dispatch';
+import type { AnyCommandId } from '../../schema/command-id';
 export interface CrossBlockKeydown {
     handleKeyDown(e: KeyboardEvent): Promise<boolean>;
     handleCompositionStart(): boolean;
 }
 export declare function createCrossBlockKeydown(ctx: CrossBlockDispatchContext, mutCtx: CrossBlockMutationContext): CrossBlockKeydown;
+/** What a keypress resolves to at the block at `getMyPath`, or at global scope with none. */
+export declare function commandAtBlock(e: KeyboardEvent, ctx: Pick<CrossBlockDispatchContext, 'getDoc' | 'getMyPath' | 'commands'>): AnyCommandId | null;