@voithos-labs/aragonite 0.10.4 → 0.10.7

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

@@ -1,8 +1,8 @@
 /**
- * `rebuildRaw` factory for a directive-backed container whose reserved child 0 is an
- * editable title emitted into the opener line. Owns the title's return to the opener
- * info, the `children[1:]` body, and the authored `lineEnding` a hand-written copy
- * drops. The no-title sibling is `core/directive`'s `rebuildDirectiveContainerRaw`.
+ * `rebuildRaw` for a directive container whose reserved child 0 is an editable title
+ * written into the opener line. Puts the title back into the opener, serializes
+ * `children[1:]` as the body, and keeps the authored line ending a hand-written copy
+ * would drop. The no-title version is `core/directive`'s `rebuildDirectiveContainerRaw`.
  */
 import { type CstNode } from '../../core/nodes';
 export declare function createDirectiveRebuild<M extends {

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

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

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

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

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

@@ -1,34 +1,27 @@
 /**
- * Sibling-reorder action for the drag-and-drop and keyboard-nudge callers: resolve the unit a path
- * points into, clamp the destination, commit one permutation. A reorder creates no node — each
- * moved block keeps its id and ref through the `reorderChildren` idMap — and the only writes are
- * positional separators (`reorderChildrenWithTrivia`) and marker renumbering. Where the move
- * invalidated a join, that primitive's settle folds it, so both the caret and the announcement
- * ride the outcome it reports rather than the destination the clamp picked.
+ * Moving a block among its siblings, for drag-and-drop and the keyboard nudge, as one commit.
+ * A move can make two neighbours merge, so the caret and the announcement use the index the
+ * reorder reports, not the destination the clamp picked.
  */
 import { CURSOR_START } from '../block-component';
+import { movedBlockToPosition } from '../a11y-strings';
 import { reorderChildrenWithTrivia } from '../tree-operations/reorder';
 import { resolveReorderUnit } from '../tree-operations/reorder-unit';
-import { blockNodeAt, nodeAt } from '../tree-operations/node-primitives';
+import { blockNodeAt, documentBody, nodeAt } from '../tree-operations/node-primitives';
 import { renumberOrderedList } from '../tree-operations/list/ordered-markers';
 import { expectStateForNode } from '../reactivity/state-registry';
 import { readCurrentSelection } from '../selection/native-bridge';
 import { extendDocPath, docPathFrom } from '../cursor/coordinate-spaces';
-/** The two ids that mean a reorder nudge, folded once for every surface's `runCommand` arm. */
-export function reorderRunCommand(id, reorder, getPath) {
-    if (id !== 'block.moveUp' && id !== 'block.moveDown')
-        return false;
-    void reorder.nudgeReorderUnit(getPath(), id === 'block.moveUp' ? -1 : 1);
-    return true;
-}
-export function createReorderAction(deps, controller, onReorder) {
+export function createReorderAction(deps, controller) {
     function caretOffset() {
         return readCurrentSelection(deps.selectionState, deps.blockRefs)?.focus.offset ?? 0;
     }
-    async function commitReorder(unit, to, offset, focusAfter) {
-        let landing = to;
+    function commitReorder(unit, to, offset, focusAfter) {
+        let landedAt = to;
+        // The caret moves with the block, so a block moved off screen scrolls back into view.
+        const landing = (parentPath) => () => focusAfter ? { path: extendDocPath(parentPath, landedAt), offset: CURSOR_START } : null;
         if (unit.scope === 'document') {
-            await controller.commitStructural({
+            return controller.commitStructural({
                 snapshot: { path: docPathFrom([unit.index]), offset },
                 op: {
                     kind: 'reorder',
@@ -36,26 +29,23 @@ export function createReorderAction(deps, controller, onReorder) {
                     eventPath: docPathFrom([unit.index])
                 },
                 mutate: (children) => {
-                    const settled = reorderChildrenWithTrivia(children, unit.index, to, deps.sharing, true);
-                    landing = settled.landing;
+                    const settled = reorderChildrenWithTrivia(documentBody(deps.doc, children), unit.index, to, deps.sharing, deps.reading.grammar);
+                    landedAt = settled.landing;
                     return settled.change;
                 },
-                afterTick: () => {
-                    if (focusAfter)
-                        deps.blockRefs[landing]?.focus(CURSOR_START);
-                }
+                landing: landing([]),
+                announce: () => movedBlockToPosition(landedAt + 1, deps.doc.children.length)
             });
-            return { landing, total: deps.doc.children.length };
         }
         const parent = blockNodeAt(deps.doc, unit.parentPath);
         if (!parent)
-            return null;
+            return Promise.resolve(false);
         const state = expectStateForNode(parent);
-        await controller.commitContainerStructural({
+        return controller.commitContainerStructural({
             containerNode: parent,
             path: unit.parentPath,
             state,
-            // A drag carries no live caret: restore to the moved unit's pre-move path.
+            // A drag carries no live caret, so undo restores to the moved unit's pre-move path.
             snapshot: { path: extendDocPath(unit.parentPath, unit.index), offset },
             op: {
                 kind: 'reorder',
@@ -63,23 +53,20 @@ export function createReorderAction(deps, controller, onReorder) {
                 eventPath: docPathFrom(unit.parentPath)
             },
             mutate: (scope) => {
-                const settled = reorderChildrenWithTrivia(scope.children, unit.index, to, scope.sharing);
-                landing = settled.landing;
+                const settled = reorderChildrenWithTrivia(scope.body, unit.index, to, scope.sharing, deps.reading.grammar);
+                landedAt = settled.landing;
                 if (unit.renumberMarkers) {
-                    // Ordered markers are position-dependent, so this unshares each item whose
-                    // marker it rewrites; the ceremony's rebuild then concatenates fresh raws.
+                    // Ordered markers depend on position, so this copies each item whose marker it
+                    // rewrites; the commit's rebuild then concatenates the fresh raws.
                     renumberOrderedList(scope.node, 0, scope.sharing);
                 }
                 return settled.change;
             },
-            afterTick: () => {
-                if (focusAfter)
-                    state.innerBlockRefs[landing]?.focus(CURSOR_START);
-            }
+            landing: landing(unit.parentPath),
+            // Re-resolved, not `parent`: the commit's copy-before-write replaced that node, so the
+            // one resolved above still holds the pre-move children.
+            announce: () => movedBlockToPosition(landedAt + 1, blockNodeAt(deps.doc, unit.parentPath)?.children?.length ?? 0)
         });
-        // Re-resolved, not `parent`: the ceremony's copy-on-write replaced that node, so the one
-        // this action resolved still holds the pre-move children.
-        return { landing, total: blockNodeAt(deps.doc, unit.parentPath)?.children?.length ?? 0 };
     }
     function resolveAndClamp(fromPath, computeTo) {
         const unit = resolveReorderUnit(deps.doc, fromPath);
@@ -95,18 +82,15 @@ export function createReorderAction(deps, controller, onReorder) {
     async function run(fromPath, computeTo, focusAfter) {
         const target = resolveAndClamp(fromPath, computeTo);
         if (!target)
-            return;
-        // Drop any cross-block selection so the overlay doesn't fight the move; the
-        // commit's afterTick re-places the caret when the caller wants it.
+            return false;
+        // Drop any cross-block selection so the overlay does not fight the move; the commit's
+        // landing places the caret again when the caller wants it.
         deps.selectionState.collapse();
-        const outcome = await commitReorder(target.unit, target.to, caretOffset(), focusAfter);
-        if (outcome)
-            onReorder?.(outcome.landing, outcome.total);
+        return commitReorder(target.unit, target.to, caretOffset(), focusAfter);
     }
     return {
-        // A dropped block is not a block you asked to edit: focusing it opens whatever a caret
-        // opens there (an equation reveals its source), which is not what a drag asked for.
-        // The keyboard nudge is the opposite — the caret must ride the block it is moving.
+        // A drop leaves the caret out, since focusing a block opens whatever a caret opens there (an
+        // equation's source); the keyboard nudge moves the caret with the block.
         moveReorderUnit: (fromPath, toIndex) => run(fromPath, () => toIndex, false),
         nudgeReorderUnit: (fromPath, dir) => run(fromPath, (index) => index + dir, true)
     };

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

@@ -1,11 +1,13 @@
 /**
- * Pointer drag-to-reorder: one delegated capture-phase pointerdown on the editor
- * root, a ghost + insertion line while dragging (no tree mutation, no reflow), and
- * ONE move committed on drop. The drop index resolves against currently-mounted
- * siblings only; autoscroll brings off-viewport ones into the window.
+ * Drag-to-reorder with the pointer: one capture-phase pointerdown listener on the editor
+ * root, a ghost and an insertion line while dragging (no tree change, no reflow), and one
+ * move committed on drop. The drop index is resolved against the mounted siblings only;
+ * autoscroll brings the others into view.
  */
 import type { UserScrollport } from '../cursor/scroll-ancestors';
 import type { ReorderAction } from './reorder-action';
+import type { DocumentGetter } from '../editor-keys';
+import type { InlineReading } from '../core/inline/inline-cache';
 export interface ReorderDragOverlay {
     setGhost(g: {
         clientX: number;
@@ -20,13 +22,15 @@ export interface ReorderDragOverlay {
 }
 export interface ReorderDragContext {
     editorRoot: HTMLElement;
-    /** What autoscrolls when the drag reaches an edge: the root in self mode, the
-     *  host's scroller in host mode (where the root doesn't scroll), the window when
-     *  the page scrolls. Never `editorRoot` directly — see `cursor/scroll-ancestors`. */
+    /** What autoscrolls when the drag reaches an edge, per scroll mode: the root, the host's scroll
+     *  container, or the window. Never `editorRoot` directly (`cursor/scroll-ancestors`). */
     getScrollHost: () => UserScrollport | null;
     moveReorderUnit: ReorderAction['moveReorderUnit'];
     overlay: ReorderDragOverlay;
-    /** Aborted on editor unmount — tears down a drag whose pointerup can't fire. */
+    /** The document and its reading, which name the dragged block on the ghost. */
+    getDoc: DocumentGetter;
+    reading: InlineReading;
+    /** Aborted on editor unmount, ending a drag whose pointerup would never arrive. */
     lifetimeSignal?: AbortSignal;
 }
 export declare function installReorderDrag(ctx: ReorderDragContext): {

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

@@ -1,11 +1,14 @@
 /**
- * Pointer drag-to-reorder: one delegated capture-phase pointerdown on the editor
- * root, a ghost + insertion line while dragging (no tree mutation, no reflow), and
- * ONE move committed on drop. The drop index resolves against currently-mounted
- * siblings only; autoscroll brings off-viewport ones into the window.
+ * Drag-to-reorder with the pointer: one capture-phase pointerdown listener on the editor
+ * root, a ghost and an insertion line while dragging (no tree change, no reflow), and one
+ * move committed on drop. The drop index is resolved against the mounted siblings only;
+ * autoscroll brings the others into view.
  */
 import { createPointerDragSession } from '../selection/pointer-session';
 import { readBlockPath } from '../selection/path-lookup';
+import { isImageOnlyParagraph } from '../core/inline/picture';
+import { blockNodeAt } from '../tree-operations/node-primitives';
+import { isGridDescriptor, tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
 export function installReorderDrag(ctx) {
     const root = ctx.editorRoot;
     function onPointerDown(e) {
@@ -20,7 +23,7 @@ export function installReorderDrag(ctx) {
         const session = startSession(ctx, dragHost);
         if (!session)
             return;
-        // Capture-phase + stopPropagation so the block's own pointerdown never starts a
+        // Capture phase plus stopPropagation, so the block's own pointerdown never starts a
         // cross-block text selection; preventDefault keeps the handle from taking focus.
         e.preventDefault();
         e.stopPropagation();
@@ -50,20 +53,18 @@ function startSession(ctx, dragHost) {
     const group = dragHost.parentElement;
     if (!fromPath || fromIndex === null || !group)
         return null;
-    const siblingSelector = dragHost.classList.contains('list-item-block')
-        ? '.list-item-block'
-        : '.block-host';
-    const label = ghostLabel(dragHost);
-    // The container this unit reorders within (null at top level). Marked for the
-    // drag's duration so the scope-locked reorder reads as intentional, not broken.
-    const scopeEl = dragHost.closest('.list-block, .blockquote-block');
+    const node = blockNodeAt(ctx.getDoc(), fromPath);
+    const label = node ? ghostLabel(dragHost, node, ctx.reading) : 'Block';
+    // The container this unit moves within (null at top level). Marked for the drag's
+    // duration so a move confined to it reads as intentional, not broken.
+    const scopeEl = scopeBox(group);
     let dropTo = null;
     function siblings() {
         const out = [];
         for (const el of Array.from(group.children)) {
             if (!(el instanceof HTMLElement))
                 continue;
-            if (!el.matches(siblingSelector) || !el.classList.contains('reorder-host'))
+            if (!el.classList.contains('reorder-host'))
                 continue;
             const index = indexOf(el);
             if (index !== null)
@@ -74,9 +75,8 @@ function startSession(ctx, dragHost) {
     }
     function process(clientX, clientY) {
         const sibs = siblings();
-        // rawR = the original index to drop before. Removing the dragged item shifts
-        // later indices down by one, hence the adjustment so a downward drop lands
-        // where the line showed.
+        // rawR is the original index to drop before; removing the dragged item shifts later indices
+        // down one, so a downward drop is adjusted to land where the line showed.
         let rawR = sibs.length ? sibs[sibs.length - 1].index + 1 : fromIndex + 1;
         let line = sibs.length
             ? {
@@ -102,7 +102,7 @@ function startSession(ctx, dragHost) {
             scopeEl?.classList.add('reorder-scope');
             createPointerDragSession(down, {
                 onMove: (p) => process(p.clientX, p.clientY),
-                // A drop commits only on release, never on cancel/Escape/unmount.
+                // A drop commits only on release, never on cancel, Escape or unmount.
                 onEnd: (reason) => {
                     if (reason === 'up' && dropTo !== null && dropTo !== fromIndex) {
                         void ctx.moveReorderUnit(fromPath, dropTo);
@@ -123,15 +123,15 @@ function startSession(ctx, dragHost) {
                 disableUserSelect: true,
                 lifetimeSignal: ctx.lifetimeSignal
             });
-            // Paint from the press point before any move, so a no-move release still
-            // commits a drop.
+            // Draw from the pointer-down point before any move, so a release without moving
+            // still commits a drop.
             process(down.clientX, down.clientY);
         }
     };
 }
 // ── Element → path / index ───────────────────────────────────────────────────
-// A `.list-item-block` carries no `data-block-path`, so borrow a descendant
-// block-host's — resolveReorderUnit climbs back to the list item either way.
+// A `.list-item-block` carries no `data-block-path`, so borrow a descendant block-host's;
+// resolveReorderUnit climbs back to the list item either way.
 function pathFor(host) {
     if (host.getAttribute('data-block-path'))
         return readBlockPath(host);
@@ -145,32 +145,36 @@ function indexOf(host) {
     return readBlockPath(host.querySelector('[data-block-path]'))?.at(-2) ?? null;
 }
 /**
- * What the block IS, for the kinds whose text does not read as a label: a table's cells run
- * together into `IngredientAmountWater35 L`, an equation reads as its own source. Prose keeps
- * its first words, which is the best label it could have.
+ * The ghost's label: a table's shape, the name a kind declares for a block whose text reads badly
+ * as one (a formula's source), and otherwise the block's first words.
  */
-const KIND_LABELS = {
-    table: 'Table',
-    mathBlock: 'Equation',
-    fencedCode: 'Code',
-    mermaid: 'Diagram',
-    thematicBreak: 'Divider',
-    details: 'Details',
-    image: 'Image'
-};
-function ghostLabel(host) {
-    const kind = host.dataset.blockKind ?? '';
-    if (kind === 'table')
+function ghostLabel(host, node, reading) {
+    const descriptor = tryGetBlockKindDescriptor(node.kind);
+    if (isGridDescriptor(descriptor))
         return tableLabel(host);
-    const named = KIND_LABELS[kind];
-    if (named)
-        return named;
+    if (descriptor?.dragLabel)
+        return descriptor.dragLabel;
+    // Before the text: a linked picture shows its link's bytes as text in source mode.
+    if (isImageOnlyParagraph(node, reading))
+        return 'Image';
     const text = (host.textContent ?? '').trim().replace(/\s+/g, ' ');
     if (!text)
-        return host.querySelector('[data-image-widget]') ? 'Image' : 'Block';
+        return 'Block';
     return text.length > 40 ? text.slice(0, 40) + '…' : text;
 }
-/** Body rows × columns: the shape is what tells one table from another at a glance. */
+/**
+ * The box a drag inside a container is confined to: the whole container as drawn (a quote's bar
+ * and padding included), found from the child list marked as one whose children reorder.
+ */
+function scopeBox(group) {
+    if (!group.hasAttribute('data-reorder-scope'))
+        return null;
+    const host = group.parentElement?.closest('.block-host');
+    if (!host)
+        return null;
+    return (Array.from(host.children).find((child) => child.contains(group)) ?? null);
+}
+/** Rows by columns: the shape is what tells one table from another at a glance. */
 function tableLabel(host) {
     const rows = host.querySelectorAll('.table-row').length;
     const cols = host.querySelector('.table-row')?.childElementCount ?? 0;

package/dist/editor-actions/replacement-focus.d.ts

@@ -1,27 +1,19 @@
 /**
- * Shared helpers for `updateBlockContent`'s structural arm: the pre-commit reparse
- * probe that picks structural-vs-typing, and the post-commit caret restore.
+ * The keystroke's two helpers around its write: the trial reparse that picks between a commit and
+ * the in-place write, and putting the caret back after a write that moved it.
  */
 import { updateNodeContent } from '../tree-operations';
-import { type SettledContent } from '../tree-operations/content-write';
-import { type AnyBlockKind } from '../core/nodes';
-import type { NodeView } from '../core/node-views';
+import type { LegalWrite, WriteTarget } from '../tree-operations/content-write';
 import type { StructuralChange } from '../tree-operations/structural-change';
-import type { CommitScope } from './block-edit-scope';
+import type { CaretPosition } from '../selection/primitives';
+import type { Relanding } from '../action-contracts';
 /**
- * Preview the content update on a throwaway single-node probe to pick between the structural
- * commit and the routine typing path; the live tree is untouched. `tailSuffix` is the document's
- * folded trailing line when `node` is the tail block, else `''`: blanking the tail materializes
- * it, which is structural and must route into the ceremony.
+ * Run the content write on a throwaway copy of child `index` to pick a commit or the in-place
+ * write. The last block brings the trailing blank line, since blanking it makes that line a block.
  */
-export declare function previewContentReparse(node: NodeView, text: string, grammar: Parameters<typeof updateNodeContent>[3], ownerKind: AnyBlockKind | undefined, tailSuffix: string): StructuralChange;
-/**
- * Restore the caret after a structural content commit. A no-op when focus already moved on.
- */
-export declare function focusAfterContentReplace(scopePath: number[], at: number, settled: SettledContent, focusOffset: number, scope: CommitScope): void;
-/**
- * A typing commit needs the caret restored; a BLUR commit (source folding as focus
- * lands elsewhere) must not yank it back. The discriminator is where focus lives at
- * afterTick time — a `data-block-path` outside the replaced window means it moved on.
- */
-export declare function focusMovedOutsideReplacement(scopePath: number[], at: number, count: number): boolean;
+export declare function previewContentReparse(target: WriteTarget, index: number, write: LegalWrite, grammar: Parameters<typeof updateNodeContent>[3]): StructuralChange;
+/** `relanding`'s caret, or null when focus already left the blocks the write wrote. */
+export declare function unlessFocusMoved(relanding: Relanding): CaretPosition | null;
+/** Whether focus has left the written blocks, as after a blur commit, where putting the caret
+ *  back would pull it away from where the user went. */
+export declare function focusMovedOutsideReplacement(scopePath: readonly number[], at: number, count: number): boolean;

package/dist/editor-actions/replacement-focus.js

@@ -1,53 +1,52 @@
 /**
- * Shared helpers for `updateBlockContent`'s structural arm: the pre-commit reparse
- * probe that picks structural-vs-typing, and the post-commit caret restore.
+ * The keystroke's two helpers around its write: the trial reparse that picks between a commit and
+ * the in-place write, and putting the caret back after a write that moved it.
  */
 import { updateNodeContent } from '../tree-operations';
-import { settledCaretTarget } from '../tree-operations/content-write';
-import { makeBlockNode } from '../core/nodes';
+import { makeBlockNode, metadataOf } from '../core/nodes';
+import { documentLineEnding } from '../core/lines';
+import { followsTaskMarker } from '../tree-operations/list/task-paragraph';
 import { readBlockPath } from '../selection/path-lookup';
-// ── Reparse probe ────────────────────────────────────────────────────────────
+// ── Trial reparse ────────────────────────────────────────────────────────────
 /**
- * Preview the content update on a throwaway single-node probe to pick between the structural
- * commit and the routine typing path; the live tree is untouched. `tailSuffix` is the document's
- * folded trailing line when `node` is the tail block, else `''`: blanking the tail materializes
- * it, which is structural and must route into the ceremony.
+ * Run the content write on a throwaway copy of child `index` to pick a commit or the in-place
+ * write. The last block brings the trailing blank line, since blanking it makes that line a block.
  */
-export function previewContentReparse(node, text, grammar, ownerKind, tailSuffix) {
+export function previewContentReparse(target, index, write, grammar) {
+    const node = target.children[index];
+    const owner = 'owner' in target ? target.owner : undefined;
+    const tailSuffix = index === target.children.length - 1 && 'suffix' in target ? target.suffix : '';
+    const lineEnding = 'lineEnding' in target ? target.lineEnding : documentLineEnding(target);
     const probe = makeBlockNode({
         kind: node.kind,
         leadingTrivia: node.leadingTrivia,
         raw: node.raw
     });
-    // The owner KIND rides along or the probe answers about different bytes than the commit
-    // writes; the owner node stays out — a probe must not write real wrap slots. The suffix
-    // rides by VALUE for the same reason: the probe's settle may only spend the copy.
-    return updateNodeContent({ children: [probe], ownerKind, owner: undefined, suffix: tailSuffix }, 0, text, grammar).change;
+    // The owner and its task marker go along as a copy, so the trial reads the bytes the write will.
+    const taskItem = followsTaskMarker(owner, index) ? owner : undefined;
+    const ownerCopy = owner &&
+        makeBlockNode({
+            kind: owner.kind,
+            leadingTrivia: '',
+            raw: owner.raw,
+            metadata: taskItem ? { ...metadataOf(taskItem, 'listItem') } : undefined,
+            children: [probe]
+        });
+    return updateNodeContent({ children: [probe], owner: ownerCopy, suffix: tailSuffix, lineEnding }, 0, write, grammar).change;
 }
-// ── Post-replacement focus ───────────────────────────────────────────────────
-/**
- * Restore the caret after a structural content commit. A no-op when focus already moved on.
- */
-export function focusAfterContentReplace(scopePath, at, settled, focusOffset, scope) {
-    const { change } = settled;
-    const count = change.op === 'replace' ? change.newCount : 1;
-    // The settled window, not the slot the gesture named: a fold above moved both.
-    const windowAt = change.op === 'replace' ? change.at : at;
-    if (focusMovedOutsideReplacement(scopePath, windowAt, count))
-        return;
-    const target = settledCaretTarget(settled, at, focusOffset, scope.children());
-    scope.refAt(target.index)?.focus(target.offset);
+// ── Putting the caret back ───────────────────────────────────────────────────
+/** `relanding`'s caret, or null when focus already left the blocks the write wrote. */
+export function unlessFocusMoved(relanding) {
+    const { list, at, count } = relanding.window;
+    return focusMovedOutsideReplacement(list, at, count) ? null : relanding.caret;
 }
-/**
- * A typing commit needs the caret restored; a BLUR commit (source folding as focus
- * lands elsewhere) must not yank it back. The discriminator is where focus lives at
- * afterTick time — a `data-block-path` outside the replaced window means it moved on.
- */
+/** Whether focus has left the written blocks, as after a blur commit, where putting the caret
+ *  back would pull it away from where the user went. */
 export function focusMovedOutsideReplacement(scopePath, at, count) {
     if (typeof document === 'undefined')
         return false;
     const host = document.activeElement?.closest?.('[data-block-path]') ?? null;
-    // No locatable path reads as "a remount ate the focused el", so run the restore.
+    // No readable path means a remount removed the focused element, so the caret goes back.
     const path = readBlockPath(host);
     if (!path)
         return false;