edytor 6.0.0 → 7.0.0

package/dist/selection/selection.svelte.js

@@ -16,19 +16,18 @@ import { caretBeside, shownText } from './replaceSelection.js';
  * order), comparing boundary points — a focus on an ancestor element of the
  * anchor (`(textElement, childCount)`) is after it.
  */
-export const isBackward = (selection) => {
-    const { anchorNode, focusNode } = selection;
+export const isBackward = ({ anchorNode, anchorOffset, focusNode, focusOffset }) => {
     if (!anchorNode || !focusNode)
         return false;
     if (anchorNode === focusNode)
-        return selection.focusOffset < selection.anchorOffset;
+        return focusOffset < anchorOffset;
     try {
         const range = createDomRange(anchorNode);
-        range.setStart(anchorNode, selection.anchorOffset);
-        return range.comparePoint(focusNode, selection.focusOffset) < 0;
+        range.setStart(anchorNode, anchorOffset);
+        return range.comparePoint(focusNode, focusOffset) < 0;
     }
     catch {
-        return Boolean(anchorNode.compareDocumentPosition(focusNode) & Node.DOCUMENT_POSITION_PRECEDING);
+        return !!(anchorNode.compareDocumentPosition(focusNode) & Node.DOCUMENT_POSITION_PRECEDING);
     }
 };
 /** A text suggestion's preview at a DOM point: around it, or the child at either side of it. */
@@ -56,18 +55,6 @@ const atomBetween = (start, end, yStart, yEnd) => {
     const part = from !== -1 && to === from + 2 ? content[from + 1] : null;
     return part instanceof InlineBlock ? part : null;
 };
-/**
- * Where a range ending in `block` starts (`first`) or ends (`last`): its
- * first or last shown line (a list's items, a code block's lines); a block
- * that shows none (a divider) passes to its neighbours as a caret does, the
- * next line first.
- */
-const rangeEdge = (block, edge) => {
-    const text = shownText(block, edge);
-    if (text)
-        return { text, offset: edge === 'first' ? 0 : text.length };
-    return caretBeside(block, 'blockAfter') ?? caretBeside(block, 'blockBefore');
-};
 /** One block's membership of the selected and focused sets, as its own two signals. */
 class Membership {
     selected = $state(false);
@@ -183,14 +170,18 @@ export class EdytorSelection {
             texts
         };
     };
+    /** The DOM fields observed with the current value, if they were. */
+    get #observed() {
+        return this.#surface?.value === this.value ? this.#surface : undefined;
+    }
     /** @internal The mark-edge side the DOM showed the current caret with (`marksForInsertion`). */
     get edge() {
-        return this.#surface?.value === this.value ? this.#surface.edge : undefined;
+        return this.#observed?.edge;
     }
     /** @internal Focus is in a void block's own `input` or `textarea`. */
     get voidField() {
-        const tag = getActiveElement(this.edytor.node)?.tagName.toUpperCase();
-        return this.projection.voidRoot !== null && (tag === 'INPUT' || tag === 'TEXTAREA');
+        return (this.projection.voidRoot !== null &&
+            /^(input|textarea)$/i.test(getActiveElement(this.edytor.node)?.tagName ?? ''));
     }
     /**
      * Replace the selection with `next` (none, a text range of two anchors,
@@ -206,6 +197,7 @@ export class EdytorSelection {
      * @internal
      */
     commit = (next, cause = 'model', surface) => {
+        const { edytor } = this;
         next = this.#keepPending(this.#shown(next));
         const changed = !sameValue(this.value, next);
         if (changed)
@@ -215,44 +207,39 @@ export class EdytorSelection {
         // A repair is a background display (it never takes focus); a command,
         // history or host code asks for one.
         if (cause === 'repair')
-            this.edytor.surface.update();
+            edytor.surface.update();
         else if (cause !== 'dom')
             this.display();
         if (surface)
             this.#surface = { value, ...surface };
-        const projection = project(value, this.edytor.facade);
-        const blocksOf = (ids) => ids.flatMap((id) => this.edytor.idToBlock.get(id) ?? []);
+        const projection = project(value, edytor.facade);
+        const handles = edytor.idToBlock;
+        const blocksOf = (ids) => ids.flatMap((id) => handles.get(id) ?? []);
         const atom = value.kind === 'atom' && projection.start
-            ? this.edytor.idToBlock.atom(value.blockId, value.atomId)
+            ? handles.atom(value.blockId, value.atomId)
             : undefined;
-        this.#sync(this.#selected, value.kind === 'blocks' ? blocksOf(value.ids) : [], 'selected');
-        this.#sync(this.#focused, value.kind === 'text'
-            ? blocksOf(projection.blocks)
-            : value.kind === 'atom'
-                ? blocksOf([value.blockId])
-                : [], 'focused');
+        this.#sync(this.#selected, blocksOf(value.kind === 'blocks' ? value.ids : []), 'selected');
+        this.#sync(this.#focused, blocksOf(value.kind === 'text' ? projection.blocks : value.kind === 'atom' ? [value.blockId] : []), 'focused');
         if (atom !== this.inlineBlockDeletionTarget || (!atom && this.selectedInlineBlock.size)) {
             this.selectedInlineBlock.clear();
             if (atom)
                 this.selectedInlineBlock.add(atom);
             this.inlineBlockDeletionTarget = atom ?? null;
         }
-        this.edytor.history?.selected(value);
+        edytor.history?.selected(value);
         const start = this.textAt(projection.start);
-        if (start) {
+        if (start)
             this.#lastText = start.text;
-        }
         if (!changed)
             return;
         // A dead view never publishes: its entry went with its teardown.
-        if (!this.edytor.destroyed) {
+        if (!edytor.destroyed) {
             const focus = projection.isReversed ? projection.start : projection.end;
-            this.edytor.presence.write(serialize(value, projection), focus?.block ?? null);
+            edytor.presence.write(serialize(value, projection), focus?.block ?? null);
         }
         this.edytorOnSelectionChange?.(this);
-        this.edytor.plugins.forEach((plugin) => {
+        for (const plugin of edytor.plugins)
             plugin.onSelectionChange?.(this);
-        });
     };
     /**
      * The collapsed text caret in block offsets (`{ block, offset }`, an
@@ -307,13 +294,17 @@ export class EdytorSelection {
             return next;
         const { start, end, isReversed } = project(next, this.edytor.facade);
         const caret = next.focus === next.anchor;
+        // A range's end goes to its block's first or last shown line (a list's
+        // items, a code block's lines); a caret, or a block that shows none (a
+        // divider), passes to its neighbours, the next line first.
         const moved = (at, anchor, edge) => {
             const block = at && this.edytor.idToBlock.get(at.block);
             if (!block || block.rendersContent)
                 return anchor;
-            const to = caret
-                ? (caretBeside(block, 'blockAfter') ?? caretBeside(block, 'blockBefore'))
-                : rangeEdge(block, edge);
+            const text = !caret && shownText(block, edge);
+            const to = text
+                ? { text, offset: edge === 'first' ? 0 : text.length }
+                : (caretBeside(block, 'blockAfter') ?? caretBeside(block, 'blockBefore'));
             return to && this.createTextAnchor(to.text, to.offset);
         };
         const [first, last] = isReversed ? ['last', 'first'] : ['first', 'last'];
@@ -477,8 +468,7 @@ export class EdytorSelection {
      * `inlineBlockDeletionTarget` follow the value (`commit`).
      */
     clearInlineBlockSelection = () => {
-        const value = this.value;
-        if (value.kind !== 'atom')
+        if (this.value.kind !== 'atom')
             return;
         const { start } = this.projection;
         this.select(start ? this.valueAt(start) : noSelection);
@@ -533,10 +523,11 @@ export class EdytorSelection {
     };
     /** @internal */
     applySelectionSnapshot = (selection, options = {}) => {
-        if (this.dragging && this.pointer.dragAcross(selection))
+        const { edytor, pointer } = this;
+        if (this.dragging && pointer.dragAcross(selection))
             return;
         // A block selection ignores the DOM, but the one a drag across columns made while it lasts.
-        if (this.selectedBlocks.size > 0 && !(this.dragging && this.pointer.across))
+        if (this.selectedBlocks.size > 0 && !(this.dragging && pointer.across))
             return;
         // A selection in a kind's own control (a form control, a nested
         // editable island) or a focused one belongs to it, not the model —
@@ -544,46 +535,49 @@ export class EdytorSelection {
         // corrupt the next model-routed write. Both endpoints are checked: a
         // range anchored in host text but focused inside an island must not
         // resolve either.
-        const container = this.edytor.node;
+        const container = edytor.node;
         const read = this.#read(selection);
-        if (!selection || !read || isKindControl(container, getActiveElement(container)))
+        if (!read || isKindControl(container, getActiveElement(container)))
             return;
-        const { anchorNode, focusNode, isCollapsed } = selection;
+        const { anchorNode, focusNode, isCollapsed, rangeCount } = selection;
         // A native vertical move that landed on no caret stop takes the key's line stop.
         if (isCollapsed &&
             !isTextBoundSelectionPoint(anchorNode) &&
-            !getInlineBlockOfNode(this.edytor, anchorNode) &&
-            landed(this.edytor))
+            !getInlineBlockOfNode(edytor, anchorNode) &&
+            landed(edytor))
             return;
         const { isReversed, startNode, start, endNode, end } = read;
-        const atom = getInlineBlockInSelectedRange(this.edytor, selection.rangeCount ? selection.getRangeAt(0) : undefined);
-        const startText = atom ? null : this.getTextOfNode(startNode, start);
-        let endText = startText && this.getTextOfNode(endNode, end);
+        const atom = getInlineBlockInSelectedRange(edytor, rangeCount ? selection.getRangeAt(0) : undefined);
+        const startText = atom ? null : read.startText;
+        let endText = startText && read.endText;
+        /** The atom selection: the DOM shows no range for it. */
+        const toAtom = (atom, from) => {
+            clearDomSelection(container);
+            this.selectInlineBlock(atom, from);
+        };
         if (!startText) {
-            const inlineBlock = atom ?? getInlineBlockOfNode(this.edytor, startNode);
+            const inlineBlock = atom ?? getInlineBlockOfNode(edytor, startNode);
             // A press in a non-native editable island (contenteditable=false, no control).
             const island = getElementFromNode(startNode)?.closest('[contenteditable="false"]');
-            const islandBlock = island && !isNativeInteractiveControl(island) && this.getBlockOfNode(island);
-            if (islandBlock && islandBlock.firstText)
-                return this.selectText(islandBlock.firstText, 0);
+            const first = island && !isNativeInteractiveControl(island) && this.getBlockOfNode(island)?.firstText;
+            if (first)
+                return this.selectText(first, 0);
             // A point on a white space node: the model caret is displayed again.
             if (!inlineBlock && this.textAt(this.projection.start))
                 return this.display();
-            clearDomSelection(this.edytor.node);
             if (inlineBlock)
-                this.selectInlineBlock(inlineBlock);
-            else
-                this.clearInlineBlockSelection();
-            return;
+                return toAtom(inlineBlock);
+            clearDomSelection(container);
+            return this.clearInlineBlockSelection();
         }
-        const overlay = isCollapsed ? overlayAt(startNode, start) : null;
+        const overlay = isCollapsed && overlayAt(startNode, start);
         if (overlay) {
             const text = this.getBlockOfNode(overlay)?.lastText ?? startText;
             return this.selectText(text, text.length);
         }
         const rawYStart = getYIndex(startText, startNode, start);
         const rawYEnd = isCollapsed ? rawYStart : getYIndex(endText, endNode, end);
-        let yStart = normalizeUtf16Boundary(startText.stringContent, rawYStart, isCollapsed ? 'forward' : 'backward');
+        const yStart = normalizeUtf16Boundary(startText.stringContent, rawYStart, isCollapsed ? 'forward' : 'backward');
         let yEnd = isCollapsed
             ? yStart
             : endText
@@ -599,7 +593,7 @@ export class EdytorSelection {
             endText === endText.parent.firstText &&
             yEnd === 0) {
             // The shown block before: a closed toggle's header, not its hidden body.
-            const previous = visibility.shown(endText.parent, 'blockBefore')?.lastText ?? null;
+            const previous = visibility.shown(endText.parent, 'blockBefore')?.lastText;
             if (previous?.node?.isConnected) {
                 endText = previous;
                 yEnd = previous.length;
@@ -611,11 +605,8 @@ export class EdytorSelection {
             return this.selectText(startText, startText.length);
         }
         const between = atomBetween(startText, endText, yStart, yEnd);
-        if (between) {
-            clearDomSelection(this.edytor.node);
-            this.selectInlineBlock(between, isReversed ? 'after' : 'before');
-            return;
-        }
+        if (between)
+            return toAtom(between, isReversed ? 'after' : 'before');
         const value = this.textValue(startText, yStart, endText ?? startText, yEnd, isReversed);
         // A node-bound native range (endpoints outside text elements: a block
         // node selection, a stray boundary node) is the shape engines extend
@@ -629,11 +620,11 @@ export class EdytorSelection {
             edge: isCollapsed ? getMarkEdgeSide(startText, startNode, yStart) : undefined,
             nodeBound
         });
-        this.edytor.projector.observe();
+        edytor.projector.observe();
         if (restore && options.restoreNormalizedDomRange !== false && endText) {
             // Writing the DOM under a pointer drag would reset its anchor: after it.
             if (this.dragging)
-                this.pointer.hold();
+                pointer.hold();
             else
                 this.selectText(startText, yStart, endText, yEnd, isReversed);
         }
@@ -644,7 +635,7 @@ export class EdytorSelection {
      * engine-defined and therefore intercepted by the hotkey layer.
      * @internal
      */
-    hasNativeNodeSelection = () => this.#surface?.value === this.value && this.#surface.nodeBound === true;
+    hasNativeNodeSelection = () => this.#observed?.nodeBound === true;
     /**
      * Anchor a text position into the BACKING text that owns the atom at
      * that display position — the v14 replacement for
@@ -717,16 +708,13 @@ export class EdytorSelection {
      * @internal
      */
     restoreDeadSelectionEndpoints = () => {
-        if (this.expectHistoryRestore) {
+        // A history step selects its own value; mid pointer-drag the user's
+        // in-progress range owns the selection; a command that declared its
+        // result selection owns this view's endpoints.
+        if (this.expectHistoryRestore || this.dragging || this.edytor.dispatcher.authoring)
             return;
-        }
-        // Mid pointer-drag the user's in-progress range owns the selection; a
-        // command that declared its result selection owns this view's endpoints.
-        if (this.dragging || this.edytor.dispatcher.authoring) {
-            return;
-        }
         const { value } = this;
-        const facade = this.edytor.facade;
+        const { facade } = this.edytor;
         const { start, isCollapsed } = this.projection;
         const at = this.textAt(start);
         let dead;
@@ -734,10 +722,8 @@ export class EdytorSelection {
             const live = value.ids.filter((id) => facade.isVisibleBlock(id));
             if (live.length === value.ids.length)
                 return;
-            if (live.length) {
-                this.commit(blockSelection(live), 'repair');
-                return;
-            }
+            if (live.length)
+                return this.#land(blockSelection(live));
             dead = value.ids[0] ?? null;
         }
         else if (value.kind === 'atom') {
@@ -746,32 +732,26 @@ export class EdytorSelection {
             const anchor = facade.isVisibleBlock(value.blockId)
                 ? facade.anchorAt(value.blockId, 0, 'left')
                 : null;
-            if (anchor) {
-                this.#land(textSelection(anchor));
-                return;
-            }
+            if (anchor)
+                return this.#land(textSelection(anchor));
             dead = value.blockId;
         }
         else if (value.kind === 'text') {
             // A peer or host code turned the block it rests in into one that shows
             // no content (an empty line into a divider): the nearest shown line.
             const shown = this.#shown(value);
-            if (shown !== value) {
-                this.#land(shown);
-                return;
-            }
-            if (at && start && isCollapsed && value.anchor !== value.focus) {
+            if (shown !== value)
+                return this.#land(shown);
+            if (at && isCollapsed && value.anchor !== value.focus) {
                 // A range whose content died is a caret at the seam (`sel.seam.covered-atom`):
                 // its two anchors would re-open around text re-inserted there.
                 const caret = facade.anchorAt(start.block, start.offset, 'left');
-                if (caret) {
-                    this.#land(textSelection(caret));
-                    return;
-                }
+                if (caret)
+                    return this.#land(textSelection(caret));
             }
             if (at) {
                 // The text it was displayed in died while its anchor moved on: display again.
-                if (this.#lastText !== null && !this.#lastText.isInDocument)
+                if (this.#lastText && !this.#lastText.isInDocument)
                     this.display();
                 this.#lastText = at.text;
                 return;
@@ -804,25 +784,26 @@ export class EdytorSelection {
      */
     mint = (snapshot) => {
         const read = this.#read(snapshot);
-        if (!read)
-            return null;
-        const { isReversed, startNode, start, endNode, end } = read;
-        const startText = this.getTextOfNode(startNode, start);
-        const endText = startText && this.getTextOfNode(endNode, end);
+        const { startText, endText } = read ?? {};
         if (!startText || !endText)
             return null;
+        const { isReversed, startNode, start, endNode, end } = read;
         const from = offsetIn(startText, startNode, start);
         return this.textValue(startText, from, endText, offsetIn(endText, endNode, end), isReversed);
     };
     /**
      * A DOM selection whose two endpoints are this editor's own points (not
-     * in a kind's control): its endpoints in document order and its direction.
+     * in a kind's control): its endpoints in document order, its direction,
+     * and the texts they are in (the end's only when the start is in one).
      */
     #read = (dom) => {
         const container = this.edytor.node;
         if (!dom || !isOwnPoint(container, dom.anchorNode) || !isOwnPoint(container, dom.focusNode))
             return null;
         const isReversed = isBackward(dom);
-        return { isReversed, ...ordered(dom, isReversed) };
+        const ends = ordered(dom, isReversed);
+        const startText = this.getTextOfNode(ends.startNode, ends.start);
+        const endText = startText && this.getTextOfNode(ends.endNode, ends.end);
+        return { isReversed, ...ends, startText, endText };
     };
 }

package/dist/session/commands.js

@@ -6,6 +6,7 @@ import { DEV } from 'esm-env';
 import { PreventionError, vetoable } from '../utils.js';
 import { kindOf } from './attempt.js';
 import { insertionMarksAt } from './editing/text.js';
+import { diffText } from '../utils/diffText.js';
 /** A command the view refused (readonly, a read-only document) or a hook prevented. */
 const PREVENTED = refused('view');
 /**
@@ -73,26 +74,17 @@ const textPatch = (args) => {
     };
 };
 /**
- * `next` is `previous` with one contiguous run typed in or deleted (their
- * common prefix and suffix cover the shorter one): what typing and Backspace
- * produce. Another value ('todo' → 'done', 'doing' → 'done') is not.
+ * `patch` continues `previous`: the same paths, each string edited by typing
+ * (one contiguous run typed in or deleted, what typing and Backspace produce;
+ * another value, 'todo' → 'done', is not).
  */
-const typedFrom = (previous, next) => {
-    const shorter = Math.min(previous.length, next.length);
-    let prefix = 0;
-    while (prefix < shorter && previous[prefix] === next[prefix])
-        prefix++;
-    let suffix = 0;
-    while (suffix < shorter - prefix &&
-        previous[previous.length - 1 - suffix] === next[next.length - 1 - suffix])
-        suffix++;
-    return prefix + suffix === shorter;
-};
-/** `patch` continues `previous`: the same paths, each string edited by typing. */
 const continuesTyping = (previous, patch) => patch !== null &&
     previous !== null &&
     patch.key === previous.key &&
-    patch.values.every((value, i) => typedFrom(previous.values[i], value));
+    patch.values.every((value, i) => {
+        const edit = diffText(previous.values[i], value);
+        return !edit || !edit.remove || !edit.insert;
+    });
 /** Passes one normalizer may take on one block per command: the first and 50 re-requests. */
 const MAX_PASSES = 51;
 /**
@@ -221,9 +213,10 @@ export class Dispatcher {
      * writable, and decided when it requires hydration. Every command asks
      * it first; a plugin's own write outside a command asks it too.
      */
-    permits = () => !this.edytor.readonly &&
-        this.edytor.document.writable &&
-        (this.edytor.document.ready || !this.edytor.document.requireHydration);
+    permits = () => {
+        const { readonly, document } = this.edytor;
+        return !readonly && document.writable && (document.ready || !document.requireHydration);
+    };
     /**
      * Apply the undo policy's cut before a `kind` command writes.
      * @internal
@@ -292,7 +285,7 @@ export class Dispatcher {
                 this.kind = null;
             }
         });
-        if (this.applied && this.last?.status !== 'applied' && this.last?.status !== 'failed')
+        if (this.applied && this.#last?.status !== 'applied' && this.#last?.status !== 'failed')
             this.#last = this.applied;
         this.applied = null;
         const after = () => this.cut(kind, 'after');
@@ -317,15 +310,15 @@ export class Dispatcher {
     dispatch = (operation, payload, context, body, prepare) => {
         if (this.active)
             return body(payload);
+        const { edytor } = this;
+        const { facade, plugins } = edytor;
         const lead = this.leading;
         this.leading = null;
         // A led operation, or one `alone` runs: its own step, never an insertion's.
         const led = !!lead || this.#alone;
         this.#alone = false;
-        if (!this.permits()) {
-            this.#refused(operation);
-            return undefined;
-        }
+        if (!this.permits())
+            return void this.#refused(operation);
         const original = payload;
         const replaced = new Set();
         // A lead composes with the command's plan (both prepared at this version);
@@ -334,21 +327,22 @@ export class Dispatcher {
             const own = prepare?.(p);
             if (!lead || !own || !('writes' in own))
                 return own;
-            const { displayLength, compose } = this.edytor.facade;
+            const { displayLength, compose } = facade;
             const whole = own.writes.flatMap((w) => w.op === 'deleteText' && w.offset === 0 && w.length === displayLength(w.id) ? [w.id] : []);
             const writes = lead.writes.filter((w) => !('id' in w && w.id && whole.includes(w.id)));
             return compose({ ...lead, writes }, own);
         };
         let plan = prepared(payload);
+        let planned;
         hooks: for (;;) {
             // A command refused at preparation is still shown (without steps): an
             // extension may replace or retarget it.
-            const planned = plan && 'writes' in plan ? plan : undefined;
+            planned = plan && 'writes' in plan ? plan : undefined;
             const command = { operation, payload, ...context, effect: planned?.effect };
             const steps = [...(lead && !plan ? lead.writes : []), ...(planned?.writes ?? [])];
             const changes = [command, ...this.steps(steps, planned?.effect.creates ?? [], command)];
             for (const change of changes) {
-                for (const plugin of this.edytor.plugins) {
+                for (const plugin of plugins) {
                     let out;
                     try {
                         out = vetoable((prevent) => plugin.onBeforeOperation?.({ ...change, prevent }));
@@ -384,33 +378,33 @@ export class Dispatcher {
             break;
         }
         // Refused at preparation, and no extension replaced it.
-        if (plan && !('writes' in plan)) {
+        if (plan && !planned) {
             this.#refused(operation);
             return body(payload, plan);
         }
-        const version = this.edytor.facade.version;
+        const version = facade.version;
         // A text patch typing into the strings the previous command set on the
         // same paths (a bound field) continues its step, within the capture
         // window, as typing does; another value of them is its own step.
         const patch = operation === 'patchData' ? textPatch(payload) : null;
-        const again = continuesTyping(this.patched, patch) && this.last?.operation === operation;
+        const again = continuesTyping(this.patched, patch) && this.#last?.operation === operation;
         // A write outside the history continues nothing and leaves the typing's record.
         if (!this.untracked)
             this.patched = patch;
         const cut = again ? undefined : this.policy(operation, led);
         if (cut)
-            this.edytor.undoManager?.stopCapturing();
+            edytor.undoManager?.stopCapturing();
         let result;
         try {
-            result = this.edytor.transact(() => {
+            result = edytor.transact(() => {
                 // What the step holds, recorded as the transaction ends: only an
                 // insertion's step may be continued (`history.continues`).
-                this.edytor.history.wrote(inserts(this.kind ?? operation, led));
+                edytor.history.wrote(inserts(this.kind ?? operation, led));
                 this.active = true;
                 try {
                     // An unplanned command runs after its lead, reading the state it leaves.
                     if (lead && !plan)
-                        void (this.writer?.(lead) ?? this.edytor.facade.apply(lead));
+                        void (this.writer?.(lead) ?? facade.apply(lead));
                     return body(payload, plan);
                 }
                 finally {
@@ -423,17 +417,21 @@ export class Dispatcher {
             throw error;
         }
         if (cut === 'both')
-            this.edytor.undoManager?.stopCapturing();
+            edytor.undoManager?.stopCapturing();
         const own = {
             operation,
-            status: this.edytor.facade.version === version ? 'noop' : 'applied'
+            status: facade.version === version ? 'noop' : 'applied'
         };
         this.#last = own;
         if (this.running && own.status === 'applied')
             this.applied = own;
-        const effect = plan && 'writes' in plan ? plan.effect : undefined;
-        const change = { operation, payload: original, ...context, effect };
-        for (const plugin of this.edytor.plugins)
+        const change = {
+            operation,
+            payload: original,
+            ...context,
+            effect: planned?.effect
+        };
+        for (const plugin of plugins)
             plugin.onAfterOperation?.(change);
         return result;
     };
@@ -452,10 +450,11 @@ export class Dispatcher {
         const out = this.dispatch(operation, payload, { block: block ?? this.edytor.root, ...(text && { text }) }, (p, plan = prepare(p)) => {
             const out = this.write(plan);
             // Read once written: a plan a plugin wrote says where its caret stands now.
-            at = 'writes' in plan ? plan.at : undefined;
+            at = plan.at;
             return out;
         }, prepare);
-        if (at && !this.active && out && out.status !== 'refused')
+        // A caret is set only by a body that wrote (`out` is its result).
+        if (at && !this.active && out.status !== 'refused')
             this.caret(at);
         return out ?? PREVENTED;
     };
@@ -524,22 +523,22 @@ export class Dispatcher {
     #touched(w) {
         const { facade } = this.edytor;
         const parent = (id) => facade.parentOf(id);
+        const content = (...ids) => ids.map((id) => [id, 'normalizeContent']);
         const children = (...ids) => ids.map((id) => [id ?? 'root', 'normalizeChildren']);
         if (w.op === 'insertBlocks')
-            return [...children(w.parent), ...w.specs.map(({ id }) => [id, 'normalizeContent'])];
+            return [...children(w.parent), ...content(...w.specs.map(({ id }) => id))];
         if (w.op === 'moveBlocks')
             return children(w.parent, ...w.ids.map(parent));
         if (w.op === 'deleteBlock')
             return children(parent(w.id));
         if (w.op === 'splitBlock')
-            return [[w.id, 'normalizeContent'], ...children(w.parent, parent(w.id))];
+            return [...content(w.id), ...children(w.parent, parent(w.id))];
         if (w.op === 'mergeBlocks')
-            return [[w.into, 'normalizeContent'], ...children(parent(w.from))];
+            return [...content(w.into), ...children(parent(w.from))];
         if (w.op === 'setBlockType')
-            return [[w.id, 'normalizeContent'], ...children(w.id)];
-        if (w.op === 'patchData')
-            return w.id === undefined ? [] : [[w.id, 'normalizeContent']];
-        return [[w.id, 'normalizeContent']];
+            return [...content(w.id), ...children(w.id)];
+        // A text step's block; a data patch's, none for the document's data.
+        return w.id === undefined ? [] : content(w.id);
     }
     /**
      * Run `body` with `lead` (a plan prepared now) composed into the first
@@ -654,9 +653,8 @@ export class Dispatcher {
                 const block = edytor.idToBlock.get(id);
                 if (!block)
                     continue;
-                const counts = passes.get(normalize) ?? passes.set(normalize, new Map()).get(normalize);
-                const count = (counts.get(id) ?? 0) + 1;
-                counts.set(id, count);
+                const count = (passes.get(normalize + id) ?? 0) + 1;
+                passes.set(normalize + id, count);
                 if (count > MAX_PASSES) {
                     if (DEV && count === MAX_PASSES + 1)
                         console.warn(`edytor: ${normalize} on block "${id}" exceeded ${MAX_PASSES - 1} passes — a plugin normalizer is not converging; skipping further passes`);

package/dist/surface/attributes.d.ts

@@ -32,12 +32,12 @@ export type Kind = 'block' | 'text' | 'mark' | 'atom' | 'anchor' | 'preview';
  * moves the caret by its paragraph's direction, never an inline run's.
  */
 export declare const blockDir: (text: string) => "rtl" | "ltr" | null;
-/** The text a cell's runs show (its atoms left out): what `blockDir` reads. */
-export declare const ownText: (runs: readonly ContentRun[]) => string;
+/** The text a cell's runs show, each atom as `atom` (left out: what `blockDir` reads). */
+export declare const ownText: (runs: readonly ContentRun[], atom?: string) => string;
 /** A text inside a void block is its own editing host (the core sets it at attach). */
 export declare const insideVoid: (edytor: Edytor, block: string) => boolean;
 /** What the table owns on `element` (the root, or a registered element). */
-export declare const ownedOf: (edytor: Edytor, element: Element, entry: {
+export declare const ownedOf: (edytor: Edytor, element: Element, entry?: {
     kind: Kind;
     block: string;
     name?: string;