@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/editor-actions/search-replace.js

@@ -1,13 +1,17 @@
-import { parse } from '../core/parser';
+import { readBlocks } from '../core/parser';
 import { cloneNode } from '../tree-operations/clone';
 import { spliceMany } from '../tree-operations/splice-many';
 import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
-import { normalizeBodyWrite, normalizeReplacementTrivia, writeOwnRaw } from '../tree-operations/node-primitives';
-import { rebuildAncestryRaw } from '../schema/container-raw';
+import { installOwnRaw, normalizeReplacementTrivia } from '../tree-operations/node-primitives';
+import { legalizeWrite } from '../tree-operations/content-write';
+import { rebuildContainerRaw } from '../schema/container-raw';
+import { rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
+import { createSharingState } from '../tree-operations/sharing';
 import { replacePreservingFirst, stampStructuralChange } from '../tree-operations/structural-change';
 import { applyRangesToText } from '../search/replace';
 import { toEditEvent } from '../editor-events';
 import { docPathFrom } from '../cursor/coordinate-spaces';
+import { documentLineEnding } from '../core/lines';
 function descend(root, rel) {
     let node = root;
     for (const i of rel)
@@ -37,29 +41,38 @@ export function createSearchReplace(deps, controller) {
             const leaf = descend(child, rel);
             if (!leaf)
                 continue;
-            // Reparsing a private clone bypasses `updateNodeContent`, so that sink's two byte
-            // rules — the kind's own raw rule and the owner's bodyWrite escape — apply here.
+            // Reparsing a private clone bypasses `updateNodeContent`, so the write rule it runs (the
+            // kind's own, then the container's) is applied here.
             const owner = rel.length > 0 ? descend(child, rel.slice(0, -1)) : null;
-            const substituted = normalizeBodyWrite(owner?.kind, applyRangesToText(leaf.raw, ranges, template));
-            writeOwnRaw(leaf, substituted, deps.grammar);
+            const target = owner?.children
+                ? { children: owner.children, owner, lineEnding: documentLineEnding(deps.doc) }
+                : deps.doc;
+            const index = owner ? rel[rel.length - 1] : topIndex;
+            const substituted = applyRangesToText(leaf.raw, ranges, template);
+            installOwnRaw(leaf, legalizeWrite(target, index, substituted, 'literal').text, deps.reading.grammar);
         }
-        // A nested leaf's edit must propagate up the clone's materialized container raw
-        // before the reparse from `child.raw`; a top-level leaf needs none.
+        // Before the reparse from `child.raw`, a nested leaf's edit is written up into the clone's
+        // container raws by the same rebuild typing uses; a top-level leaf needs none.
+        const cloneSharing = createSharingState();
         for (const ranges of byLeaf.values()) {
             const rel = ranges[0].path.slice(1);
-            if (rel.length > 0)
-                rebuildAncestryRaw(child, rel);
+            if (rel.length === 0)
+                continue;
+            const chain = [];
+            for (let depth = 1; depth < rel.length; depth++)
+                chain.push(descend(child, rel.slice(0, depth)));
+            rebuildUnsharedChain(child, chain, cloneSharing, null, deps.reading.grammar);
+            rebuildContainerRaw(child, deps.reading.grammar);
         }
-        const newNodes = parse(child.raw, { grammar: deps.grammar, scope: 'fragment' }).children;
+        const newNodes = readBlocks(child.raw, {
+            grammar: deps.reading.grammar,
+            scope: 'fragment'
+        }).children;
         // leadingTrivia is positional and lives off `raw`, so parsing `child.raw` alone drops it.
         return normalizeReplacementTrivia(child, newNodes);
     }
-    /**
-     * A match can land on a container node itself. A CHILDLESS one scanned as a leaf, and this
-     * path reparses rather than writing in place — so the kind re-derives its own metadata from
-     * the substituted bytes and nothing goes stale. One with children is excluded: its raw is a
-     * rebuild of theirs, and substituting into it would drift (G1.12/G1.13).
-     */
+    /** A childless container matched as a leaf is reparsed, so its metadata follows the new bytes;
+     *  one with children is excluded, as its raw is rebuilt from theirs. */
     function isReplaceable(match) {
         const top = deps.doc.children[match.path[0]];
         const node = top ? descend(top, match.path.slice(1)) : null;
@@ -67,15 +80,11 @@ export function createSearchReplace(deps, controller) {
             return false;
         return !getBlockKindDescriptor(node.kind).isContainer || (node.children?.length ?? 0) === 0;
     }
-    /**
-     * The one hazard the reparse cannot absorb: a substitution that breaks a container's opener
-     * line comes back as a different kind entirely — a diagram silently becoming a plain code
-     * block. Accepted for leaves, declined here.
-     */
+    /** A substitution that breaks a container's opener line reparses as another kind (a diagram
+     *  becoming a code block). Leaves accept that; a container's replace is declined. */
     function keepsItsKind(before, after) {
-        // Only where the substitution wrote the container's OWN raw — a childless one, scanned as a
-        // leaf. One with children had a CHILD edited, and re-kinding there is the ordinary
-        // structural replace every leaf already gets.
+        // Only a childless container had its own raw substituted; in one with children a child
+        // was edited, and a kind change there is the ordinary structural replace.
         const childless = (before.children?.length ?? 0) === 0;
         if (!childless || !getBlockKindDescriptor(before.kind).isContainer)
             return true;
@@ -88,52 +97,47 @@ export function createSearchReplace(deps, controller) {
         if (indices.length === 0)
             return 0;
         const seed = groups.get(indices[indices.length - 1])[0];
-        // One pushed snapshot + per-subtree skip-commits = one undo entry, so a throw
-        // mid-batch still recovers in one Ctrl+Z. Intentional.
-        // The push happens outside the commit ceremony, so its rollback register is ours too: a
-        // batch whose FIRST subtree throws applies nothing and must leave no entry behind, or the
-        // next Ctrl+Z spends itself restoring the document to where it already is.
-        const stacksBeforePush = deps.undoManager.getStacks();
-        controller.pushUndoSnapshotPath(seed.path, seed.start);
         let newBlockCount = 0;
         let applied = 0;
-        for (const topIndex of indices) {
-            const group = groups.get(topIndex);
-            let newNodes;
-            try {
-                newNodes = buildSubtree(topIndex, group, template);
-            }
-            catch (error) {
-                // buildSubtree dispatches into the kind's `rebuildRaw` — plugin code running
-                // outside every commit ceremony, so nothing else would attribute this.
-                deps.events.emit('error', {
-                    origin: 'commit',
-                    error,
-                    context: { op: 'replaceBlock', path: docPathFrom([topIndex]) }
+        // One entry for the whole batch, and none when it applies nothing.
+        await controller.undoStep({ path: docPathFrom(seed.path), offset: seed.start }, async () => {
+            for (const topIndex of indices) {
+                const group = groups.get(topIndex);
+                let newNodes;
+                try {
+                    newNodes = buildSubtree(topIndex, group, template);
+                }
+                catch (error) {
+                    // buildSubtree calls the kind's `rebuildRaw`, plugin code running outside any
+                    // commit, so nothing else would report this error.
+                    deps.events.emit('error', {
+                        origin: 'commit',
+                        error,
+                        context: { op: 'replaceBlock', path: docPathFrom([topIndex]) }
+                    });
+                    break;
+                }
+                if (!keepsItsKind(deps.doc.children[topIndex], newNodes))
+                    continue;
+                const wrote = await controller.commitStructural({
+                    snapshot: { path: docPathFrom([topIndex]), offset: 0 },
+                    mutate: (children) => {
+                        spliceMany(children, topIndex, 1, newNodes);
+                        const change = replacePreservingFirst(topIndex, 1, newNodes.length);
+                        stampStructuralChange(children, change, deps.sharing);
+                        return change;
+                    }
+                    // op omitted: no per-commit edit event; one is emitted after the batch
                 });
-                break;
+                if (!wrote)
+                    continue;
+                newBlockCount += newNodes.length;
+                applied += group.length;
             }
-            if (!keepsItsKind(deps.doc.children[topIndex], newNodes))
-                continue;
-            newBlockCount += newNodes.length;
-            applied += group.length;
-            await controller.commitStructural({
-                snapshot: 'skip', // batch shares the single snapshot pushed above
-                mutate: (children) => {
-                    spliceMany(children, topIndex, 1, newNodes);
-                    const change = replacePreservingFirst(topIndex, 1, newNodes.length);
-                    stampStructuralChange(children, change, deps.sharing);
-                    return change;
-                }
-                // op omitted → no per-commit edit event; one is emitted after the batch
-            });
-        }
-        if (applied === 0) {
-            deps.undoManager.restoreStacks(stacksBeforePush);
+        });
+        if (applied === 0)
             return 0;
-        }
-        // A single-subtree replace has one operated node, so the aggregate event carries
-        // its doc-absolute path (editor.md §12); a multi-subtree batch genuinely has none.
+        // A single-subtree replace names its block's path in the event; a multi-subtree batch has none.
         const eventPath = indices.length === 1 ? docPathFrom([indices[0]]) : [];
         deps.events.emit('edit', toEditEvent({ kind: 'replaceBlock', detail: { count: newBlockCount } }, eventPath, Date.now()));
         return applied;

package/dist/editor-actions/stored-caret.d.ts

@@ -0,0 +1,7 @@
+/** Builds the value every `updateBlockContent` returns: the write's promise, carrying its caret. */
+import type { AdmittedContentWrite, ContentWrite } from '../action-contracts';
+/** An admitted write. `storedOffset` defaults to the identity, right for a write no rule rewrites;
+ *  `keepsCaret` is false when the write places the caret itself. */
+export declare function withStoredCaret(done: Promise<boolean>, caret: number, storedOffset?: (offset: number) => number, keepsCaret?: boolean): Promise<boolean> & AdmittedContentWrite;
+/** A write the reading-mode check refused, or one with no block to write: no bytes, no caret. */
+export declare function refusedWrite(): ContentWrite;

package/dist/editor-actions/stored-caret.js

@@ -0,0 +1,10 @@
+/** Builds the value every `updateBlockContent` returns: the write's promise, carrying its caret. */
+/** An admitted write. `storedOffset` defaults to the identity, right for a write no rule rewrites;
+ *  `keepsCaret` is false when the write places the caret itself. */
+export function withStoredCaret(done, caret, storedOffset = (offset) => offset, keepsCaret = true) {
+    return Object.assign(done, { admitted: true, caret, storedOffset, keepsCaret });
+}
+/** A write the reading-mode check refused, or one with no block to write: no bytes, no caret. */
+export function refusedWrite() {
+    return Object.assign(Promise.resolve(false), { admitted: false });
+}

package/dist/editor-actions/table-context.d.ts

@@ -1,16 +1,16 @@
 /**
- * The TableContext mutation bundle. The component keeps sticky-column state,
- * focused-cell tracking, DOM helpers, and BlockComponent — only structural mutations
- * live here.
+ * The TableContext edits. The component keeps the sticky column, the focused cell, DOM
+ * helpers and BlockComponent; only structural edits live here, each handing its commit the cell
+ * the caret goes to.
  */
-import type { CellPosition, ContainerEditActions, TableContext } from '../action-contracts';
-import type { GrammarView } from '../schema/block-openers';
+import type { ContainerEditActions, TableContext } from '../action-contracts';
+import type { Reading } from '../schema/reading';
 import type { NodeView } from '../core/node-views';
 import type { UndoController } from './deps';
 import type { BlockListState } from '../reactivity/block-list-state.svelte';
 /**
- * The header (row 0) is positionally fixed. Null skips the commit, so a boundary
- * press pushes no undo entry.
+ * The header (row 0) stays where it is. Null skips the commit, so a keypress at the edge
+ * pushes no undo entry.
  */
 export declare function tableRowReorderTarget(rowIdx: number, dir: -1 | 1, rowCount: number): number | null;
 /**
@@ -28,10 +28,8 @@ export interface TableMutationsContextDeps {
     } | null;
     parentContainerEdit: ContainerEditActions;
     controller: UndoController;
-    focusCell: (rowIdx: number, colIdx: number, position: CellPosition) => void;
-    announceReorder: (message: string) => void;
-    /** The instance grammar the cell byte-write door threads (absent: the global one). */
-    grammar?: GrammarView;
+    /** The editor's reading, whose grammar the cell writes use. */
+    reading: Reading;
 }
 export type TableMutationsContext = Pick<TableContext, 'insertRowAbove' | 'insertRowBelow' | 'insertColumnLeft' | 'insertColumnRight' | 'deleteRow' | 'deleteColumn' | 'reorderRowTo' | 'moveRowUp' | 'moveRowDown' | 'reorderColumnTo' | 'moveColumnLeft' | 'moveColumnRight' | 'cycleAlignment' | 'setColumnAlignment' | 'pasteGrid'>;
 export declare function createTableMutationsContext(deps: TableMutationsContextDeps): TableMutationsContext;

package/dist/editor-actions/table-context.js

@@ -1,21 +1,21 @@
 /**
- * The TableContext mutation bundle. The component keeps sticky-column state,
- * focused-cell tracking, DOM helpers, and BlockComponent — only structural mutations
- * live here.
+ * The TableContext edits. The component keeps the sticky column, the focused cell, DOM
+ * helpers and BlockComponent; only structural edits live here, each handing its commit the cell
+ * the caret goes to.
  */
+import { CURSOR_END, CURSOR_START } from '../block-component';
 import { metadataOf } from '../core/nodes';
 import { extendDocPath, docPathFrom } from '../cursor/coordinate-spaces';
 import { getStateForNode } from '../reactivity/state-registry';
 import { assertInvariant } from '../assert';
 import { columnAligned, COLUMN_ALIGNMENT_CLEARED, DELETED_COLUMN, DELETED_ROW, INSERTED_COLUMN, INSERTED_ROW, movedColumnToPosition, movedRowToPosition } from '../a11y-strings';
 import { ensureUnsharedChildren, ensureUnsharedSubtree } from '../tree-operations/unshare';
-import { rebuildTableRowRaw, rebuildTableRaw } from '../schema/container-rebuilders';
 import { writeOwnRaw } from '../tree-operations/node-primitives';
 import { reorderChildren } from '../tree-operations/reorder';
 import { insertEmptyRow, insertEmptyColumn, deleteRow as mutDeleteRow, deleteColumn as mutDeleteColumn, moveColumn as mutMoveColumn, cycleAlignment as mutCycleAlignment, setAlignment as mutSetAlignment, canDeleteRow, canDeleteColumn } from '../tree-operations/table-mutations';
 /**
- * The header (row 0) is positionally fixed. Null skips the commit, so a boundary
- * press pushes no undo entry.
+ * The header (row 0) stays where it is. Null skips the commit, so a keypress at the edge
+ * pushes no undo entry.
  */
 export function tableRowReorderTarget(rowIdx, dir, rowCount) {
     if (rowIdx === 0)
@@ -36,8 +36,13 @@ export function tableColumnReorderTarget(colIdx, dir, colCount) {
     return to;
 }
 export function createTableMutationsContext(deps) {
+    /** The cell at `rowIdx`, `colIdx`, addressed by path so the landing can mount a windowed row. */
+    const cellAt = (rowIdx, colIdx, offset = CURSOR_START) => ({
+        path: docPathFrom([...deps.myPath, rowIdx, colIdx]),
+        offset
+    });
     async function insertRow(rowIdx, side) {
-        const { node, myPath, rowsState, parentContainerEdit, focusCell } = deps;
+        const { node, myPath, rowsState, parentContainerEdit } = deps;
         const insertAt = side === 'above' ? rowIdx : rowIdx + 1;
         await parentContainerEdit.commitContainer({
             containerNode: node,
@@ -47,7 +52,6 @@ export function createTableMutationsContext(deps) {
             mutate: (scope) => {
                 insertEmptyRow(scope.node, rowIdx, side);
                 scope.sharing.stamp(scope.children[insertAt]);
-                rebuildTableRowRaw(scope.children[insertAt]);
                 return { op: 'insert', at: insertAt, count: 1 };
             },
             op: {
@@ -55,17 +59,12 @@ export function createTableMutationsContext(deps) {
                 detail: { rowIdx, side },
                 eventPath: extendDocPath(myPath, insertAt)
             },
-            afterTick: () => {
-                focusCell(insertAt, 0, 'start');
-                deps.announceReorder(INSERTED_ROW);
-            }
+            landing: () => cellAt(insertAt, 0),
+            announce: () => INSERTED_ROW
         });
     }
-    /**
-     * The table scope plus one per MOUNTED row: a row's BlockListState registers on
-     * mount, so scoping a windowed-out row throws and takes the gesture with it. The
-     * bytes still reach every row, through the table scope.
-     */
+    /** The table scope plus one per mounted row: an unmounted row has no registered state and
+     *  would throw, and the table scope carries the bytes to every row anyway. */
     function mountedColumnScopes() {
         const { node, myPath, rowsState } = deps;
         const scopes = [{ node, state: rowsState, path: [...myPath] }];
@@ -84,33 +83,33 @@ export function createTableMutationsContext(deps) {
         const { scopes, rowIndices } = mountedColumnScopes();
         await controller.commitMultiScope({
             scopes,
-            // Columns aren't nodes: the table itself is the restore coordinate.
+            // Columns are not nodes: undo restores to the table itself.
             snapshot: { path: docPathFrom(myPath), offset: 0 },
             mutate: ([tableScope, ...rowScopes]) => {
-                // Reaches the windowed-out rows the scopes skip, so the per-row cell splice
-                // below never writes through a snapshot-shared row (G1.9).
+                // Reaches the unmounted rows the scopes skip, so the per-row cell splice below
+                // never writes through a row an undo snapshot shares (G1.9).
                 ensureUnsharedChildren(tableScope.node, tableScope.sharing);
-                // The splice walks the owned table's rows, so the row scopes' ids/refs only
-                // sync correctly while each row view IS the child at the index it covers.
+                // The splice walks the copied table's rows, so the row scopes' ids and refs only
+                // sync correctly while each row view is the child at the index it covers.
                 assertInvariant('column-scope-alignment', () => rowScopes.every((s, i) => s.node === tableScope.node.children?.[rowIndices[i]])
                     ? null
                     : {
                         code: 'column-scope-alignment',
                         message: 'commitColumnEdit: row scopes misaligned with owned table children'
                     });
-                // One change per row, in row order — pair the mounted rows with theirs.
+                // One change per row, in row order; pair the mounted rows with theirs.
                 const perRow = opts.mutateColumns(tableScope.node);
                 return [{ op: 'noop' }, ...rowIndices.map((i) => perRow[i])];
             },
             op: { ...opts.op, eventPath: docPathFrom(myPath) },
-            afterTick: opts.afterTick
+            landing: opts.landing,
+            announce: opts.announce
         });
     }
-    // Grown at the bottom and the right only, so each scope's change is one contiguous insert:
-    // rows for the table, cells for every mounted row. Cell texts go through the cell kind's own
-    // raw rule in place, and the table raw is rebuilt once, delimiter line included.
+    // The table grows only at the bottom and right, so each scope's change is one contiguous
+    // insert; cell texts take the cell kind's raw rule in place, and the commit rebuilds the table.
     async function pasteGrid(origin, grid) {
-        const { myPath, controller, focusCell } = deps;
+        const { myPath, controller } = deps;
         const rows = grid.length;
         let cols = 0;
         for (const line of grid)
@@ -122,9 +121,8 @@ export function createTableMutationsContext(deps) {
             scopes,
             snapshot: { path: docPathFrom(myPath), offset: 0 },
             mutate: ([tableScope, ...rowScopes]) => {
-                // Subtree, not children: the cell writes below land at depth two, and a row's
-                // cells stay shared with the undo snapshot when only the rows are unshared —
-                // the write would go through it and undo would restore the pasted bytes.
+                // The subtree, not just the children: cell writes land at depth two, and cells still
+                // shared with the undo snapshot would carry the paste into it.
                 ensureUnsharedSubtree(tableScope.node, tableScope.sharing);
                 assertInvariant('column-scope-alignment', () => rowScopes.every((s, i) => s.node === tableScope.node.children?.[rowIndices[i]])
                     ? null
@@ -143,9 +141,8 @@ export function createTableMutationsContext(deps) {
                     insertEmptyColumn(table, c - 1, 'right');
                 grid.forEach((line, r) => {
                     const cells = table.children[origin.rowIdx + r].children;
-                    line.forEach((text, c) => writeOwnRaw(cells[origin.colIdx + c], text, deps.grammar));
+                    line.forEach((text, c) => writeOwnRaw(cells[origin.colIdx + c], text, tableScope.lineEnding, deps.reading.grammar));
                 });
-                rebuildTableRaw(table);
                 const addedRows = needRows - oldRows;
                 const addedCols = needCols - oldCols;
                 const tableChange = addedRows > 0 ? { op: 'insert', at: oldRows, count: addedRows } : { op: 'noop' };
@@ -157,52 +154,40 @@ export function createTableMutationsContext(deps) {
                 detail: { rowIdx: origin.rowIdx, colIdx: origin.colIdx, rows, cols },
                 eventPath: docPathFrom(myPath)
             },
-            afterTick: () => focusCell(origin.rowIdx + rows - 1, origin.colIdx + cols - 1, 'end')
+            landing: () => cellAt(origin.rowIdx + rows - 1, origin.colIdx + cols - 1, CURSOR_END)
         });
     }
     async function insertColumn(colIdx, side) {
-        const { focusCell, focusedCell } = deps;
+        const { focusedCell } = deps;
         const insertAt = side === 'left' ? colIdx : colIdx + 1;
         await commitColumnEdit({
             mutateColumns: (table) => insertEmptyColumn(table, colIdx, side),
             op: { kind: 'tableInsertColumn', detail: { colIdx, side } },
-            afterTick: () => {
-                const targetRow = focusedCell?.rowIdx ?? 0;
-                focusCell(targetRow, insertAt, 'start');
-                deps.announceReorder(INSERTED_COLUMN);
-            }
+            landing: () => cellAt(focusedCell?.rowIdx ?? 0, insertAt),
+            announce: () => INSERTED_COLUMN
         });
     }
     async function reorderRowTo(from, to) {
         if (from === to)
             return;
-        const { node, myPath, rowsState, parentContainerEdit, focusCell, focusedCell } = deps;
+        const { node, myPath, rowsState, parentContainerEdit, focusedCell } = deps;
         const rowCount = node.children?.length ?? 0;
-        // Guard the SOURCE against the live count: a keyboard/menu/drag commit can carry
-        // a `from` staled by a concurrent structural edit. `to` is already clamped.
+        // Check the source against the live count: a keyboard, menu or drag commit can carry a
+        // `from` made stale by a concurrent structural edit. `to` is already clamped.
         if (from < 0 || from >= rowCount)
             return;
-        // focusout nulls focusedCell on the post-commit re-render, so capture the column
-        // now; the afterTick would otherwise land at column 0.
+        // focusout nulls focusedCell on the re-render after the commit, so read the column
+        // now; the landing would otherwise go to column 0.
         const col = focusedCell?.colIdx ?? 0;
         await parentContainerEdit.commitContainer({
             containerNode: node,
             path: [...myPath],
             state: rowsState,
             snapshot: { path: extendDocPath(myPath, from), offset: 0 },
-            mutate: (scope) => {
-                // rebuildTableRaw rewrites EVERY row's raw, so the rows must be unshared
-                // first — reorderChildren only permutes references.
-                ensureUnsharedChildren(scope.node, scope.sharing);
-                const change = reorderChildren(scope.node.children, from, to);
-                rebuildTableRaw(scope.node);
-                return change;
-            },
+            mutate: (scope) => reorderChildren(scope.node.children, from, to),
             op: { kind: 'tableReorderRow', detail: { from, to }, eventPath: extendDocPath(myPath, to) },
-            afterTick: () => {
-                focusCell(to, col, 'start');
-                deps.announceReorder(movedRowToPosition(to, rowCount - 1));
-            }
+            landing: () => cellAt(to, col),
+            announce: () => movedRowToPosition(to, rowCount - 1)
         });
     }
     async function moveRow(rowIdx, dir) {
@@ -215,21 +200,19 @@ export function createTableMutationsContext(deps) {
     async function reorderColumnTo(from, to) {
         if (from === to)
             return;
-        const { node, focusCell, focusedCell } = deps;
+        const { node, focusedCell } = deps;
         const columnCount = metadataOf(node, 'table').columnCount;
-        // Guard the SOURCE against the live count — see reorderRowTo.
+        // Check the source against the live count, as reorderRowTo does.
         if (from < 0 || from >= columnCount)
             return;
-        // focusout nulls focusedCell on the post-commit re-render, so capture the row
-        // now; the afterTick would otherwise land at row 0.
+        // focusout nulls focusedCell on the re-render after the commit, so read the row now;
+        // the landing would otherwise go to row 0.
         const row = focusedCell?.rowIdx ?? 0;
         await commitColumnEdit({
             mutateColumns: (table) => mutMoveColumn(table, from, to),
             op: { kind: 'tableReorderColumn', detail: { from, to } },
-            afterTick: () => {
-                focusCell(row, to, 'start');
-                deps.announceReorder(movedColumnToPosition(to + 1, columnCount));
-            }
+            landing: () => cellAt(row, to),
+            announce: () => movedColumnToPosition(to + 1, columnCount)
         });
     }
     async function moveColumn(colIdx, dir) {
@@ -252,7 +235,7 @@ export function createTableMutationsContext(deps) {
         moveColumnLeft: (colIdx) => moveColumn(colIdx, -1),
         moveColumnRight: (colIdx) => moveColumn(colIdx, 1),
         async deleteRow(rowIdx) {
-            const { node, myPath, rowsState, parentContainerEdit, focusCell, focusedCell } = deps;
+            const { node, myPath, rowsState, parentContainerEdit, focusedCell } = deps;
             if (!canDeleteRow(rowIdx, node.children?.length ?? 0))
                 return;
             await parentContainerEdit.commitContainer({
@@ -261,8 +244,6 @@ export function createTableMutationsContext(deps) {
                 state: rowsState,
                 snapshot: { path: extendDocPath(myPath, rowIdx), offset: 0 },
                 mutate: (scope) => {
-                    // deleteRow promotes the next row to header (a metadata write).
-                    ensureUnsharedChildren(scope.node, scope.sharing);
                     mutDeleteRow(scope.node, rowIdx);
                     return { op: 'delete', at: rowIdx, count: 1 };
                 },
@@ -271,44 +252,42 @@ export function createTableMutationsContext(deps) {
                     detail: { rowIdx },
                     eventPath: extendDocPath(myPath, rowIdx)
                 },
-                afterTick: () => {
-                    deps.announceReorder(DELETED_ROW);
-                    // Read through `deps.node`: the captured `node` is the pre-commit object
-                    // the snapshot still shares, so its child count is stale after the delete.
+                announce: () => DELETED_ROW,
+                landing: () => {
+                    // Read through `deps.node`: the `node` read above is the pre-commit object the
+                    // undo snapshot still shares, so its child count is stale after the delete.
                     const newRowCount = deps.node.children?.length ?? 0;
                     if (newRowCount === 0)
-                        return;
+                        return null;
                     const columnCount = metadataOf(deps.node, 'table').columnCount;
                     const targetRow = Math.min(rowIdx, newRowCount - 1);
                     const targetCol = focusedCell ? Math.min(focusedCell.colIdx, columnCount - 1) : 0;
-                    focusCell(targetRow, targetCol, 'start');
+                    return cellAt(targetRow, targetCol);
                 }
             });
         },
         async deleteColumn(colIdx) {
-            const { node, focusCell, focusedCell } = deps;
+            const { node, focusedCell } = deps;
             const meta = metadataOf(node, 'table');
             if (!canDeleteColumn(meta.columnCount))
                 return;
             await commitColumnEdit({
                 mutateColumns: (table) => mutDeleteColumn(table, colIdx),
                 op: { kind: 'tableDeleteColumn', detail: { colIdx } },
-                afterTick: () => {
-                    deps.announceReorder(DELETED_COLUMN);
-                    // deps.node, not the stale pre-commit capture — see deleteRow.
+                announce: () => DELETED_COLUMN,
+                landing: () => {
+                    // deps.node, not the stale pre-commit object, as in deleteRow.
                     const newColumnCount = metadataOf(deps.node, 'table').columnCount;
                     if (newColumnCount === 0)
-                        return;
-                    const targetCol = Math.min(colIdx, newColumnCount - 1);
-                    const targetRow = focusedCell?.rowIdx ?? 0;
-                    focusCell(targetRow, targetCol, 'start');
+                        return null;
+                    return cellAt(focusedCell?.rowIdx ?? 0, Math.min(colIdx, newColumnCount - 1));
                 }
             });
         },
         async cycleAlignment(colIdx) {
             const { node, myPath, rowsState, parentContainerEdit } = deps;
-            // Distinct OperationKind so consumers can count alignment cycles apart from
-            // metadata edits. The event targets the TABLE: a column index is not a path.
+            // A distinct OperationKind so consumers can count alignment cycles apart from
+            // metadata edits. The event targets the table: a column index is not a path.
             await parentContainerEdit.commitContainer({
                 containerNode: node,
                 path: [...myPath],
@@ -322,12 +301,12 @@ export function createTableMutationsContext(deps) {
             });
         },
         async setColumnAlignment(colIdx, alignment) {
-            const { node, myPath, rowsState, parentContainerEdit, focusCell, focusedCell } = deps;
-            // Capture before the menu's focusout nulls it: the alignment button unmounts
-            // on commit, so without a refocus the caret falls to <body>.
+            const { node, myPath, rowsState, parentContainerEdit, focusedCell } = deps;
+            // Read before the menu's focusout nulls it: the alignment button unmounts on
+            // commit, so without a landing the caret falls to <body>.
             const cell = focusedCell;
-            // Commits unconditionally: the first table mutation also normalizes cell
-            // padding, so a same-value set is not a byte no-op.
+            // Commits unconditionally: the first table edit also normalizes cell padding, so
+            // setting the same value is not a byte no-op.
             await parentContainerEdit.commitContainer({
                 containerNode: node,
                 path: [...myPath],
@@ -338,10 +317,8 @@ export function createTableMutationsContext(deps) {
                     return { op: 'noop' };
                 },
                 op: { kind: 'tableSetAlignment', detail: { colIdx }, eventPath: docPathFrom(myPath) },
-                afterTick: () => {
-                    focusCell(cell?.rowIdx ?? 0, colIdx, 'start');
-                    deps.announceReorder(alignment === 'none' ? COLUMN_ALIGNMENT_CLEARED : columnAligned(alignment));
-                }
+                landing: () => cellAt(cell?.rowIdx ?? 0, colIdx),
+                announce: () => (alignment === 'none' ? COLUMN_ALIGNMENT_CLEARED : columnAligned(alignment))
             });
         }
     };

package/dist/editor-actions/unwrap-strategies.d.ts

@@ -1,7 +1,6 @@
 /**
- * Unwrap strategy implementations, selected by a container's declared
- * `unwrapRole` (schema/block-kind-descriptor.ts) from the nested blockEdit
- * dispatcher.
+ * The Backspace unwrap strategies a container's declared `unwrapRole` selects, run from the
+ * container's blockEdit (`docs/design/editor.md` § Container unwrap).
  */
 import type { UnwrapRole } from '../schema/block-kind-descriptor';
 import type { BlockListState } from '../reactivity/block-list-state.svelte';
@@ -10,5 +9,5 @@ export interface UnwrapStrategyDeps {
     deps: NestedActionsDeps;
     state: BlockListState;
 }
-export declare const firstChildUnwrapStrategies: Record<UnwrapRole['firstChildBackspace'], (deps: UnwrapStrategyDeps) => Promise<void>>;
-export declare const middleChildUnwrapStrategies: Record<'list-item-cascade', (deps: UnwrapStrategyDeps, innerIndex: number) => Promise<void>>;
+export declare const firstChildUnwrapStrategies: Record<UnwrapRole['firstChildBackspace'], (deps: UnwrapStrategyDeps) => Promise<boolean>>;
+export declare const middleChildUnwrapStrategies: Record<'list-item-cascade', (deps: UnwrapStrategyDeps, innerIndex: number) => Promise<boolean>>;