@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/editor-actions/block-edit-scope.d.ts

@@ -1,79 +1,92 @@
 /**
- * Per-level adapter for the shared block-edit core: commit ceremony, child addressing, refs and
- * unshare, for a top-level edit vs a container one. Both factories are the SINGLE mint point for
- * the commit args' doc-absolute paths, as `DocPath` — the core hands over local indices only.
- * G1.16 stays the runtime belt for the JS callers types don't bind.
+ * What the shared block-edit core needs of one block list, the document root or a container.
+ * The factories here are the only place the commit's document-absolute paths (`DocPath`) are
+ * made; the core hands over local indices only, and a dev-mode check covers JS callers.
  */
 import type { OpDescriptor } from '../schema/operations';
-import type { CommitAfterTick, ContainerScope } from '../action-contracts';
-import type { AnyBlockKind, CstNode } from '../core/nodes';
+import type { CommitAfterTick, CommitLanding, InPlaceResult } from '../action-contracts';
+import { type BodyParent } from '../tree-operations/node-primitives';
+import type { CstNode } from '../core/nodes';
 import type { NodeView } from '../core/node-views';
 import type { StructuralChange } from '../tree-operations/structural-change';
 import type { SharingState } from '../tree-operations/sharing';
-import type { GrammarView } from '../schema/block-openers';
-import type { InlineResolverRef } from '../schema/inline-construct-policy';
-import type { PresentationModeGetter } from '../editor-keys';
-import type { BlockComponent } from '../block-component';
-import type { EditorActionsDeps, UndoController } from './deps';
+import type { TrackedPosition } from '../tree-operations/settle';
+import type { LegalWrite, WriteTarget } from '../tree-operations/content-write';
+import type { Reading } from '../schema/reading';
+import type { CaretMemory } from '../cursor/caret-memory';
+import { type DocPath } from '../selection/path-math';
+import type { CaretPosition } from '../selection/primitives';
+import type { LandingOutcome, RevealPolicy } from '../selection/caret-landing';
+import { type RemovalGesture } from '../selection/caret-target';
+import type { EditorActionsDeps, EditorRoot, UndoController } from './deps';
 import type { NestedActionsDeps } from './nested/nested-actions';
 import type { BlockListState } from '../reactivity/block-list-state.svelte';
-/** Owned mutation view the core's `mutate` writes through — uniform across levels. */
+/** The copied children the core's `mutate` writes through, the same shape at both levels. */
 export interface MutationView {
-    children: CstNode[];
-    sharing: SharingState;
-    /** The container these children belong to, for mutations whose bytes must satisfy
-     *  its grammar (`bodyWrite`). Absent at the document root. */
-    ownerKind?: AnyBlockKind;
-    /** The container NODE itself, for settles that write its wrap slots. Nullable
-     *  rather than optional so each adapter answers; `undefined` is the document root. */
-    owner: CstNode | undefined;
-    /** The instance's block grammar, for mutations that re-parse. Absent = the global grammar. */
-    grammar?: GrammarView;
-    /** Live EFFECTIVE mode, for mutations whose bytes depend on what the mode paints. Nullable
-     *  rather than optional so each adapter answers; `undefined` reads as not-live. */
-    getPresentationMode: PresentationModeGetter | undefined;
-    /** The instance's link-reference resolver, so a rewrite parses the reference forms the render
-     *  path drew. Nullable for the same reason as the mode; `undefined` reads them as brackets. */
-    linkRef: InlineResolverRef | undefined;
-    /** Copy-out-of-sharing the child at `i` before an in-place write; returns the owned node. */
+    /** The children this mutation writes and the container they belong to. */
+    readonly body: BodyParent;
+    readonly sharing: SharingState;
+    /** The editor's reading, for mutations that re-parse and joins that clean up after themselves. */
+    readonly reading: Reading;
+    /** Copy the child at `i` out of the undo snapshot before an in-place write; returns the copy. */
     unshareChild(i: number): CstNode;
 }
 export interface ScopeCommitArgs {
-    /** Snapshot coordinate in THIS scope's local index space, or 'skip' to join a caller's entry. */
+    /** Where undo puts the caret back, as a local index in this list, when nothing is focused. */
     snapshot: {
         index: number;
         offset: number;
-    } | 'skip';
+    };
     /** Local index the edit event targets; the factory prefixes the scope's absolute path. */
     eventTarget: number;
     op: OpDescriptor;
     mutate: (view: MutationView) => StructuralChange;
     afterTick?: CommitAfterTick;
-    /**
-     * Leaves the dev staleness oracle checks when `mutate` returns `noop`. The owned
-     * copy exists only after `mutate` runs, hence a stable array. Top-level only.
-     */
+    /** Where the caret goes, read after the commit; built with the scope's `at`. */
+    landing?: CommitLanding;
+    /** How far the landing moves the viewport; `'into-view'` when absent. */
+    reveal?: RevealPolicy;
+    /** Filled by `mutate` for the dev-mode stale-raw check when it returns `noop`; only the root
+     *  reads them, since a container's commit checks its whole copied container. */
     touchedNodes?: CstNode[];
-    /**
-     * A structural op that can legitimately no-op, so the ceremony discards the snapshot
-     * rather than mint a dead entry. Never on content/metadata commits — their `noop`
-     * still carries a byte change (action-contracts `DiscardIfNoop`).
-     */
+    /** A structural edit that can change nothing, so the commit discards its snapshot. Never on
+     *  content or metadata commits, whose `noop` still carries a byte change (`DiscardIfNoop`). */
     discardIfNoop?: boolean;
+    /** A local position the list's fix-up updates in place, read back by the landing. */
+    trackCaret?: TrackedPosition;
 }
 export interface CommitScope {
-    /** Read accessor — mutation happens through the commit's owned view, never this. */
+    /** This list's document path: empty at the root. */
+    readonly path: DocPath;
+    /** How the editor reads its bytes: the reading-mode check and the reparse grammar. */
+    readonly reading: Reading;
+    /** How the caret arrived; a keystroke's write forgets it. */
+    readonly caretMemory: Pick<CaretMemory, 'forget'>;
+    /** Read only; mutation goes through the commit's copied view, never this. */
     children(): readonly NodeView[];
-    refAt(i: number): BlockComponent | undefined;
-    /** Empty replaceBlock emits `delete` (container) vs `replaceBlock{count:0}` (top-level). */
+    /** The list as a write target before any write: its container and line ending, and at the
+     *  root the document with its trailing blank line. What the write rule and the trial read. */
+    target(): WriteTarget;
+    /** The id the typing batch keys on for child `i`. */
+    idAt(i: number): string;
+    /** Where the caret goes once child `i` is gone, read after the commit that removed it. */
+    survivor(i: number, gesture: RemovalGesture): CaretPosition | null;
+    /** An empty replaceBlock emits `delete` (container) or `replaceBlock{count:0}` (top-level). */
     collapseEmptyReplaceToDelete: boolean;
-    commit(args: ScopeCommitArgs): Promise<void>;
+    /** Resolves to whether bytes landed. */
+    commit(args: ScopeCommitArgs): Promise<boolean>;
+    /** One keystroke into child `i`, grouped with its typing burst: the burst's undo entry is on
+     *  the stack before `work` starts, and whatever `work` commits before it first yields joins it. */
+    typeIn<T>(i: number, preEditOffset: number, work: () => Promise<T>): Promise<T>;
+    /** The keystroke's in-place write, for a write the trial reparse keeps in its block. */
+    writeInPlace(i: number, write: LegalWrite, caret: number): InPlaceResult;
+    /** A position below child `i`. */
+    at(i: number, subPath: readonly number[], offset: number): CaretPosition;
+    /** Put the caret at `pos` through the editor's caret landing, for an edit with no commit. */
+    land(pos: CaretPosition): Promise<LandingOutcome>;
 }
-/** The byte/settle sinks' owner answer for a container commit's own scope — {@link MutationView}'s twin. */
-export declare const scopeParentOf: (scope: ContainerScope) => {
-    children: CstNode[];
-    ownerKind: "heading" | "setextHeading" | "paragraph" | "fencedCode" | "thematicBreak" | "indentedCode" | "htmlBlock" | "linkReferenceDefinition" | "tableCell" | "unrecognized" | "blockquote" | "list" | "listItem" | "table" | "tableRow" | import("../plugin").PluginBlockKind;
-    owner: CstNode;
-};
 export declare function createTopLevelScope(deps: EditorActionsDeps, controller: UndoController): CommitScope;
 export declare function createContainerScope(state: BlockListState, deps: NestedActionsDeps): CommitScope;
+/** The list at `parentPath` (the root's at `[]`), null where no container stands; build it after a
+ *  gesture's earlier commit. */
+export declare function createPathScope(root: EditorRoot, parentPath: DocPath): CommitScope | null;

package/dist/editor-actions/block-edit-scope.js

@@ -1,76 +1,128 @@
 /**
- * Per-level adapter for the shared block-edit core: commit ceremony, child addressing, refs and
- * unshare, for a top-level edit vs a container one. Both factories are the SINGLE mint point for
- * the commit args' doc-absolute paths, as `DocPath` — the core hands over local indices only.
- * G1.16 stays the runtime belt for the JS callers types don't bind.
+ * What the shared block-edit core needs of one block list, the document root or a container.
+ * The factories here are the only place the commit's document-absolute paths (`DocPath`) are
+ * made; the core hands over local indices only, and a dev-mode check covers JS callers.
  */
+import { blockNodeAt, documentBody } from '../tree-operations/node-primitives';
 import { ensureUnsharedPath, ensureUnsharedChild } from '../tree-operations';
+import { containerScopeState } from '../tree-operations/paste/parent-scope';
 import { asDocPath } from '../selection/path-math';
-import { extendDocPath } from '../cursor/coordinate-spaces';
-/** The byte/settle sinks' owner answer for a container commit's own scope — {@link MutationView}'s twin. */
-export const scopeParentOf = (scope) => ({
-    children: scope.children,
-    ownerKind: scope.node.kind,
-    owner: scope.node
-});
+import { survivorAfterRemoval } from '../selection/caret-target';
+import { docPathFrom, extendDocPath } from '../cursor/coordinate-spaces';
+import { getStateForNode } from '../reactivity/state-registry';
+import { createLeafTyping } from './leaf-write';
+import { createContainerEditActions } from './container-edit';
 // ── Top-level adapter ────────────────────────────────────────────────────────
 export function createTopLevelScope(deps, controller) {
+    const typing = createLeafTyping(deps, controller);
     return {
+        path: asDocPath([]),
+        get reading() {
+            return deps.reading;
+        },
+        caretMemory: deps.caretMemory,
         children: () => deps.doc.children,
-        refAt: (i) => deps.blockRefs[i],
+        target: () => deps.doc,
+        idAt: (i) => deps.blockIds[i],
+        survivor: (i, gesture) => survivorAfterRemoval(deps.doc, [i], gesture),
         collapseEmptyReplaceToDelete: false,
-        commit({ snapshot, eventTarget, op, mutate, afterTick, touchedNodes, discardIfNoop }) {
+        commit({ snapshot, eventTarget, op, mutate, afterTick, landing, reveal, touchedNodes, discardIfNoop, trackCaret }) {
             return controller.commitStructural({
-                snapshot: snapshot === 'skip'
-                    ? 'skip'
-                    : { path: asDocPath([snapshot.index]), offset: snapshot.offset },
+                snapshot: { path: asDocPath([snapshot.index]), offset: snapshot.offset },
                 mutate: (children) => mutate({
-                    children,
+                    body: documentBody(deps.doc, children),
                     sharing: deps.sharing,
-                    owner: undefined,
-                    grammar: deps.grammar,
-                    getPresentationMode: deps.getPresentationMode,
-                    linkRef: deps.linkRef,
+                    reading: deps.reading,
                     unshareChild: (i) => ensureUnsharedPath({ children }, [i], deps.sharing)[0]
                 }),
                 op: { ...op, eventPath: asDocPath([eventTarget]) },
                 afterTick,
+                landing,
+                reveal,
                 touchedNodes,
-                discardIfNoop
+                discardIfNoop,
+                trackCaret
             });
-        }
+        },
+        typeIn: (i, preEditOffset, work) => typing.typeInLeaf(docPathFrom([i]), preEditOffset, deps.blockIds[i], work),
+        writeInPlace: (i, write, caret) => typing.writeLeafInPlace(docPathFrom([i]), write, caret),
+        at: (i, subPath, offset) => ({ path: docPathFrom([i, ...subPath]), offset }),
+        land: (pos) => deps.caretLanding.land(pos)
     };
 }
-// ── Container adapter ────────────────────────────────────────────────────────
 export function createContainerScope(state, deps) {
+    return containerScope({
+        node: () => deps.node,
+        path: () => deps.path,
+        state,
+        reading: () => deps.reading,
+        caretMemory: deps.caretMemory,
+        containerEdit: deps.parent.containerEdit
+    });
+}
+/** The list at `parentPath` (the root's at `[]`), null where no container stands; build it after a
+ *  gesture's earlier commit. */
+export function createPathScope(root, parentPath) {
+    const { deps, controller } = root;
+    if (parentPath.length === 0)
+        return createTopLevelScope(deps, controller);
+    const node = blockNodeAt(deps.doc, parentPath);
+    if (!node?.children)
+        return null;
+    return containerScope({
+        node: () => blockNodeAt(deps.doc, parentPath) ?? node,
+        path: () => parentPath,
+        state: containerScopeState({ resolveState: getStateForNode }, node),
+        reading: () => deps.reading,
+        caretMemory: deps.caretMemory,
+        containerEdit: createContainerEditActions(deps, controller)
+    });
+}
+function containerScope(parts) {
     return {
-        // A fold at this container's own slot detaches it (`tree-operations/chain-rebuild.ts`), so a
-        // post-commit read can find the scope gone rather than merely empty.
-        children: () => deps.node?.children ?? [],
-        refAt: (i) => state.innerBlockRefs[i],
+        get path() {
+            return docPathFrom(parts.path());
+        },
+        get reading() {
+            return parts.reading();
+        },
+        caretMemory: parts.caretMemory,
+        // A collapse at this container's own index detaches it (`tree-operations/chain-rebuild.ts`),
+        // so a post-commit read can find the container gone rather than merely empty.
+        children: () => parts.node()?.children ?? [],
+        target: () => ({
+            children: parts.node()?.children ?? [],
+            owner: parts.node(),
+            lineEnding: parts.containerEdit.lineEnding()
+        }),
+        idAt: (i) => parts.state.innerBlockIds[i],
+        survivor: (i, gesture) => parts.containerEdit.survivorAfterRemoval(extendDocPath(parts.path(), i), gesture),
         collapseEmptyReplaceToDelete: true,
-        commit({ snapshot, eventTarget, op, mutate, afterTick, discardIfNoop }) {
-            return deps.parent.containerEdit.commitContainer({
-                containerNode: deps.node,
-                path: deps.path,
-                state,
-                snapshot: snapshot === 'skip'
-                    ? 'skip'
-                    : { path: extendDocPath(deps.path, snapshot.index), offset: snapshot.offset },
-                mutate: (scope) => mutate({
-                    children: scope.children,
-                    sharing: scope.sharing,
-                    ownerKind: scope.node.kind,
-                    owner: scope.node,
-                    grammar: deps.grammar,
-                    getPresentationMode: deps.getPresentationMode,
-                    linkRef: deps.linkRef,
-                    unshareChild: (i) => ensureUnsharedChild(scope.node, i, scope.sharing)
+        commit({ snapshot, eventTarget, op, mutate, afterTick, landing, reveal, discardIfNoop, trackCaret }) {
+            return parts.containerEdit.commitContainer({
+                containerNode: parts.node(),
+                path: parts.path(),
+                state: parts.state,
+                snapshot: { path: extendDocPath(parts.path(), snapshot.index), offset: snapshot.offset },
+                mutate: (view) => mutate({
+                    body: view.body,
+                    sharing: view.sharing,
+                    reading: parts.reading(),
+                    unshareChild: (i) => ensureUnsharedChild(view.node, i, view.sharing)
                 }),
-                op: { ...op, eventPath: extendDocPath(deps.path, eventTarget) },
+                op: { ...op, eventPath: extendDocPath(parts.path(), eventTarget) },
                 afterTick,
-                discardIfNoop
+                landing,
+                reveal,
+                discardIfNoop,
+                trackCaret
             });
-        }
+        },
+        typeIn: (i, preEditOffset, work) => parts.containerEdit.typeInLeaf(extendDocPath(parts.path(), i), preEditOffset, parts.state.innerBlockIds[i], work),
+        writeInPlace: (i, write, caret) => parts.containerEdit.writeLeafInPlace(extendDocPath(parts.path(), i), write, caret),
+        at: (i, subPath, offset) => ({ path: docPathFrom([...parts.path(), i, ...subPath]), offset }),
+        // Through the editor root rather than this list's refs: a write that changed this
+        // container's kind replaced its component, and its refs with it.
+        land: (pos) => parts.containerEdit.land(pos)
     };
 }

package/dist/editor-actions/block-edit.d.ts

@@ -1,7 +1,6 @@
 /**
- * Top-level BlockEditActions factory. Structural mutations route through the shared
- * `block-edit-core` against a top-level `CommitScope`; this factory adds the edge
- * guards and the one per-level body the core can't share, `updateBlockContent`.
+ * The top-level BlockEditActions: the shared `block-edit-core` against a top-level
+ * `CommitScope`, with the edge guards the root adds.
  */
 import type { BlockEditActions } from '../action-contracts';
 import type { EditorActionsDeps, UndoController } from './deps';

package/dist/editor-actions/block-edit.js

@@ -1,111 +1,35 @@
 /**
- * Top-level BlockEditActions factory. Structural mutations route through the shared
- * `block-edit-core` against a top-level `CommitScope`; this factory adds the edge
- * guards and the one per-level body the core can't share, `updateBlockContent`.
+ * The top-level BlockEditActions: the shared `block-edit-core` against a top-level
+ * `CommitScope`, with the edge guards the root adds.
  */
-import { tick } from 'svelte';
-import { updateNodeContent as performUpdate, ensureUnsharedPath } from '../tree-operations';
-import { publishScopeFold } from './ancestry-folds';
-import { stampStructuralChange } from '../tree-operations/structural-change';
+import { documentLineEnding } from '../core/lines';
 import { createTopLevelScope } from './block-edit-scope';
-import { createBlockEditCore } from './block-edit-core';
+import { contentUpdate, createBlockEditCore } from './block-edit-core';
 import { withEnterCompletion } from './enter-completion';
-import { previewContentReparse, focusAfterContentReplace } from './replacement-focus';
 export function createBlockEditActions(deps, controller) {
     const scope = createTopLevelScope(deps, controller);
     const core = createBlockEditCore(scope);
-    // The keystroke's own work, split out so `updateBlockContent` owns the batch ceremony
-    // around it and nothing inside can return past the pause arm.
-    async function applyContentUpdate(blockIndex, text, preEditOffset, postEditFocusOffset) {
-        // The structural path's live mutation runs inside the ceremony, so a
-        // multi-block splice never touches the live children array out-of-commit.
-        const preview = previewContentReparse(deps.doc.children[blockIndex], text, deps.grammar, undefined, blockIndex === deps.doc.children.length - 1 ? deps.doc.suffix : '');
-        if (preview.op !== 'noop') {
-            const focusOffset = postEditFocusOffset ?? preEditOffset ?? 0;
-            let settled = { change: { op: 'noop' }, textStart: 0 };
-            await scope.commit({
-                snapshot: 'skip',
-                eventTarget: blockIndex,
-                op: { kind: 'updateContent', detail: { length: text.length } },
-                // ownerKind undefined is the ANSWER, not an omission: the document root
-                // imposes no body grammar. The suffix rides as accessors so the tail
-                // settle folds against the live document.
-                mutate: (view) => {
-                    view.unshareChild(blockIndex);
-                    settled = performUpdate({
-                        children: view.children,
-                        ownerKind: undefined,
-                        owner: undefined,
-                        get suffix() {
-                            return deps.doc.suffix;
-                        },
-                        set suffix(value) {
-                            deps.doc.suffix = value;
-                        }
-                    }, blockIndex, text, deps.grammar, view.sharing);
-                    stampStructuralChange(view.children, settled.change, view.sharing);
-                    return settled.change;
-                },
-                afterTick: () => focusAfterContentReplace([], blockIndex, settled, focusOffset, scope)
-            });
-            return;
-        }
-        // Routine typing: an out-of-ceremony in-place write, so copy the node first when a
-        // snapshot shares it. Slotless parent on purpose — the preview already routed every
-        // suffix materialization into the ceremony, so none can happen here.
-        ensureUnsharedPath(deps.doc, [blockIndex], deps.sharing);
-        const settled = performUpdate({ children: deps.doc.children, ownerKind: undefined, owner: undefined }, blockIndex, text, deps.grammar, deps.sharing);
-        // A blank-fill settle can still FOLD here — the single-node preview probe has no
-        // neighbour to absorb it — so this path publishes its own descriptor and re-lands the
-        // caret, which the ceremony would otherwise have done.
-        if (settled.change.op !== 'noop')
-            publishScopeFold(deps, undefined, settled.change);
-        // After that publish, as the ceremony announces after its own, and ahead of the no-fold
-        // return: the leaf's raw is already written, and the ordinary keystroke settles to `noop`.
-        deps.bumpContentVersion();
-        if (settled.change.op === 'noop')
-            return;
-        await tick();
-        focusAfterContentReplace([], blockIndex, settled, postEditFocusOffset ?? preEditOffset ?? 0, scope);
-    }
     const actions = {
         // ── Structural split / merge / delete (shared core) ───────────────────
         splitBlock: (blockIndex, offset) => core.split(blockIndex, offset),
         descendToBody: (blockIndex) => core.descendToBody(blockIndex),
         insertParagraph: (boundaryIndex, text) => core.insertParagraph(boundaryIndex, text),
         async mergeWithPrevious(blockIndex) {
-            deps.stickyColumn.reset();
-            deps.edgeAffinity.reset();
+            deps.caretMemory.forget();
             if (blockIndex <= 0)
-                return;
-            await core.mergeWithPreviousInterior(blockIndex);
+                return false;
+            return core.mergeWithPreviousInterior(blockIndex);
         },
         async mergeWithNext(blockIndex) {
-            deps.stickyColumn.reset();
-            deps.edgeAffinity.reset();
+            deps.caretMemory.forget();
             if (blockIndex >= deps.doc.children.length - 1)
-                return;
-            await core.mergeWithNextInterior(blockIndex);
+                return false;
+            return core.mergeWithNextInterior(blockIndex);
         },
-        deleteBlock: (blockIndex) => core.deleteInterior(blockIndex),
+        deleteBlock: (blockIndex, gesture) => core.deleteInterior(blockIndex, gesture),
         updateBlockMetadata: (blockIndex, metadata, options) => core.updateBlockMetadata(blockIndex, metadata, options),
-        replaceBlock: (blockIndex, replacement, focus, options) => core.replaceBlock(blockIndex, replacement, focus, options),
-        // ── Content update (per-level) ────────────────────────────────────────
-        async updateBlockContent(blockIndex, text, preEditOffset, postEditFocusOffset) {
-            deps.stickyColumn.reset();
-            deps.edgeAffinity.reset();
-            // Keyed by block, not by slot: a bare index identifies the position, so a
-            // different block arriving at the same slot would continue its batch.
-            controller.pushUndoSnapshotDebounced([blockIndex], preEditOffset ?? 0, deps.blockIds[blockIndex]);
-            // The pause window opens once this keystroke's own work is done, throw included: an
-            // unarmed batch never ends by pause and would swallow every later keystroke.
-            try {
-                await applyContentUpdate(blockIndex, text, preEditOffset, postEditFocusOffset);
-            }
-            finally {
-                controller.armUndoPause();
-            }
-        }
+        replaceBlock: async (blockIndex, replacement, focus, options) => (await core.replaceBlock(blockIndex, replacement, focus, options)) !== null,
+        updateBlockContent: contentUpdate(scope)
     };
-    return withEnterCompletion(actions, (blockIndex) => scope.children()[blockIndex]);
+    return withEnterCompletion(actions, (blockIndex) => scope.children()[blockIndex], deps.reading.grammar, () => documentLineEnding(deps.doc));
 }

package/dist/editor-actions/commit/history.d.ts

@@ -1,8 +1,8 @@
 /**
- * HistoryActions factory: capture current state for the swap entry, replay the
- * entry's snapshot, restore the saved selection. Snapshots share the live tree's
- * nodes, so a restore re-marks the epoch and re-copies the children array — else a
- * later publish writes the stack's own entry.
+ * Undo and redo: capture the current state for the opposite stack, install the entry's
+ * snapshot, restore its selection. Snapshots share the live tree's nodes, so a restore marks
+ * the tree shared again and copies the children array; otherwise a later commit would write
+ * into the stack's own entry.
  */
 import type { HistoryActions } from '../../action-contracts';
 import type { EditorActionsDeps, UndoController } from '../deps';

package/dist/editor-actions/commit/history.js

@@ -1,62 +1,59 @@
 /**
- * HistoryActions factory: capture current state for the swap entry, replay the
- * entry's snapshot, restore the saved selection. Snapshots share the live tree's
- * nodes, so a restore re-marks the epoch and re-copies the children array — else a
- * later publish writes the stack's own entry.
+ * Undo and redo: capture the current state for the opposite stack, install the entry's
+ * snapshot, restore its selection. Snapshots share the live tree's nodes, so a restore marks
+ * the tree shared again and copies the children array; otherwise a later commit would write
+ * into the stack's own entry.
  */
 import { tick } from 'svelte';
-import { isGapSelection } from '../../undo/types';
 import { assertInvariant } from '../../assert';
 import { checkSnapshotIntegrity } from '../../invariants/snapshot-integrity';
-import { restoreGapCaret, restoreSelection } from '../../selection/selection-restore';
+import { admitsWrite } from './reading-write-gate';
 export function createHistoryActions(deps, controller) {
     async function restore(entry, op) {
         assertInvariant('snapshot-integrity', () => {
             const violation = checkSnapshotIntegrity(entry);
             return violation && { ...violation, message: `${op}: ${violation.message}` };
         });
-        // Ahead of the swap itself, so a landing awaiting across it reads the new stamp
-        // whichever side of the doc write its reveal resolves on.
-        controller.noteHistorySwap();
+        // Before the swap itself, so a caret placement waiting across it sees the new counter
+        // whichever side of the document write its scroll-into-view finishes on.
+        deps.caretLanding.noteTreeSwap();
         deps.sharing.markSnapshotTaken();
+        // The standing range addresses the outgoing tree; read during the render below, its path
+        // could name another block in the incoming one.
+        deps.selectionState.dropForDocumentSwap();
         deps.setDoc({ ...entry.snapshot, children: [...entry.snapshot.children] });
         deps.bumpContentVersion();
         // A copy: live state splices this array in place, and the entry stays on the stack.
         deps.setBlockIds([...entry.blockIds]);
-        // The tick belongs to the doc swap above, not to the restore: the new tree
-        // must render before the shared seam can reveal or address anything in it.
+        // The tick belongs to the document swap above, not to the restore: the new tree must
+        // render before the selection restore can scroll to or address anything in it.
         await tick();
-        const restoreDeps = {
-            getDoc: () => deps.doc,
-            selectionState: deps.selectionState,
-            getBlockElByPath: deps.getBlockElByPath,
-            // Mount, not scroll into view: a history swap must not move the viewport for
-            // a target already on screen.
-            revealTarget: async (path) => (await deps.revealPath(path)) !== null
-        };
-        const outcome = isGapSelection(entry.selection)
-            ? await restoreGapCaret(entry.selection.gapCaret, restoreDeps)
-            : await restoreSelection(entry.selection, restoreDeps);
-        // An entry can name a slot that never existed in its own snapshot (append-past-end declares
-        // the one-past-the-end coordinate as its restore fallback). The seam declines without side
-        // effects, so clearing is this caller's policy: the one place that knows the doc changed.
-        if (outcome === 'unresolvable')
-            deps.selectionState.clear();
+        // Into view, not held: a caret the undo put off screen comes to the nearest edge, and one
+        // already on screen stays where it is.
+        const outcome = await deps.caretLanding.restore(entry.selection, { reveal: 'into-view' });
+        // An entry can name an index its own snapshot never had, and the restore then declines. Clear
+        // here and announce it, since the swap already dropped the range without a notification.
+        if (outcome === 'unresolvable') {
+            deps.selectionState.batch(() => {
+                deps.selectionState.clear();
+                deps.selectionState.announceSelection();
+            });
+        }
         deps.events.emit('edit', { op, path: [], timestamp: Date.now() });
     }
-    // Flush, not discard: interrupt clears the debounce timer so it can't push a stale
-    // snapshot after the stack moves, AND emits the batch's pending `input` event so
-    // its bytes aren't dropped from the edit channel.
+    // Flush, not discard: the pending batch's `input` event must still be emitted, and its timer
+    // must not push a stale snapshot after the stack moves.
     function beginHistorySwap() {
-        deps.stickyColumn.reset();
-        deps.edgeAffinity.reset();
+        deps.caretMemory.forget();
         controller.flushDebouncedCheckpoint();
     }
     return {
         async requestUndo() {
+            if (!admitsWrite(deps.reading, 'undo'))
+                return;
             beginHistorySwap();
-            // Check the stack before capturing: captureCurrentState marks the whole tree
-            // snapshot-shared, forcing copy-on-write spines on the next edit.
+            // Check the stack before capturing: captureCurrentState marks the whole tree as
+            // shared with a snapshot, forcing the next edit to copy its path first.
             if (!deps.undoManager.canUndo)
                 return;
             const entry = deps.undoManager.undo(controller.captureCurrentState());
@@ -65,6 +62,8 @@ export function createHistoryActions(deps, controller) {
             await restore(entry, 'undo');
         },
         async requestRedo() {
+            if (!admitsWrite(deps.reading, 'redo'))
+                return;
             beginHistorySwap();
             if (!deps.undoManager.canRedo)
                 return;

package/dist/editor-actions/commit/reading-write-gate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Reading mode writes no bytes, and every entry point that writes the document asks here first.
+ * A write in reading mode is declined, and a dev build names the operation and its caller, since
+ * the gesture that reached it offered a write the mode should not have. Ask synchronously, before
+ * the first await, or the report loses the caller.
+ */
+import type { Reading } from '../../schema/reading';
+export declare const READING_WRITE_TAG = "reading-write";
+/**
+ * Whether a write naming `op` may land: false in reading mode, with a dev warning that names the
+ * block kind `kindOf` answers, so a plugin author can tell which of their blocks asked.
+ */
+export declare function admitsWrite(reading: Reading, op: string, kindOf?: () => string | undefined): boolean;
+/**
+ * For an undo snapshot pushed ahead of a write: declined in reading mode so no empty entry is
+ * left on the stack, and silent, because the write that follows reports itself.
+ */
+export declare function admitsSnapshot(reading: Reading): boolean;