edytor 1.0.0-rc.2 → 1.0.0

package/dist/session/commands.js

@@ -1,33 +1,35 @@
+import { refused } from '../crdt/doc/plan.js';
+import { viewOf } from '../selection/visibility.js';
+import { reveal } from '../selection/replaceSelection.js';
 import { DEV } from 'esm-env';
 import { PreventionError, vetoable } from '../utils.js';
 import { kindOf } from './attempt.js';
+import { insertionMarksAt } from './editing/text.js';
+/** A command the view refused (readonly, a read-only document) or a hook prevented. */
+const PREVENTED = refused('view');
 /**
  * The undo policy, owned here: a user command (`run`) applies it
  * by its kind, and an operation dispatched outside one (a menu action, a
- * plugin, a headless call) by its name. Deletions, paste, drop, formatting
- * and structural operations cut the capture before they write; a paragraph
- * split also cuts after; an insertion (`INSERTIONS`) coalesces within
- * `captureTimeout` when it continues the step before it (that step is an
- * insertion's, `inserts`, and it starts where that step left this view's
- * selection, `history.continues`), else it cuts: an
- * insertion after the caret moved is its own step whatever the pause, so the
- * grouping never depends on timing alone. Every other kind or operation —
- * one the table does not list included (`run('myConvert')`) — cuts before
- * it writes, so a plugin's write never joins the typing before it. A
- * conversion (a markdown or slash trigger with the kind it completes,
- * `lead`) is its own step, so undo gives the typed trigger back. A composition session groups like an insertion and is
- * one capture group: `session/composition` holds it open between its writes,
+ * plugin, a headless call) by its name. Every kind cuts the capture before
+ * it writes — deletions, paste, drop, formatting and structural operations,
+ * and any kind this table does not list (`run('myConvert')`), so a plugin's
+ * write never joins the typing before it — except an insertion
+ * (`insertion`), which coalesces within `captureTimeout` when it continues
+ * the step before it (that step is an insertion's, `inserts`, and it starts
+ * where that step left this view's selection, `history.continues`), else it
+ * cuts: an insertion after the caret moved is its own step whatever the
+ * pause, so the grouping never depends on timing alone. The kinds listed
+ * here also cut after them. A conversion (a markdown or slash trigger with
+ * the kind it completes, `lead`) is its own step, so undo gives the typed
+ * trigger back. A composition session groups like an insertion and is one
+ * capture group: `session/composition` holds it open between its writes,
  * and no operation cuts while it is live.
  */
 const CUT = {
+    // A paragraph split.
     insertParagraph: 'both',
-    insertFromPaste: 'before',
-    insertFromPasteAsQuotation: 'before',
-    insertFromDrop: 'before',
     // A text drag's drop: typing after it is a step of its own.
     moveText: 'both',
-    insertBlock: 'before',
-    format: 'before',
     // An accepted suggestion: typing after it is a step of its own.
     acceptSuggestion: 'both',
     // A DOM change no input occurrence owns (a foreign script): its own step.
@@ -36,20 +38,10 @@ const CUT = {
 /** The origin of `Dispatcher.outside`'s transactions: no history tracks it. */
 const OUTSIDE_HISTORY = Symbol('edytor.outsideHistory');
 /**
- * The kinds that may continue a step: the insertion operations (`insertText`,
- * `addInlineBlock`) and the input types that insert text. Any other kind — a
- * structural or formatting input type, a kind the table does not list
- * (`run('myConvert')`) — cuts before it writes.
+ * The kinds that may continue a step: the input types that insert text
+ * (`insertText`, the operation too), a soft break, an atom and a link.
  */
-const INSERTIONS = new Set([
-    'insertText',
-    'addInlineBlock',
-    'insertReplacementText',
-    'insertLineBreak',
-    'insertFromYank',
-    'insertTranspose',
-    'insertLink'
-]);
+const insertion = (kind) => kindOf(kind) === 'text' || ['insertLineBreak', 'insertInline', 'insertLink'].includes(kind);
 /**
  * Whether a `kind` command's writes are text editing an insertion may
  * continue (`history.continues`): the insertions, a composition and a text
@@ -57,42 +49,25 @@ const INSERTIONS = new Set([
  * Anything else — a paste, a structural edit, a data write such as a
  * column resize — ends the step for the typing after it.
  */
-const inserts = (kind, led) => !led && (kind.includes('Composition') || INSERTIONS.has(kind) || kindOf(kind) === 'delete');
-const policyOf = (kind) => CUT[kind] ??
-    (kind.includes('Composition') ? undefined : INSERTIONS.has(kind) ? 'continue' : 'before');
+const inserts = (kind, led) => !led && (kind.includes('Composition') || insertion(kind) || kindOf(kind) === 'delete');
+const policyOf = (kind) => CUT[kind] ?? (kind.includes('Composition') ? undefined : insertion(kind) ? 'continue' : 'before');
 /** The one place a `prevent()` is recognized; anything else propagates. */
 const prevented = (error) => {
     if (error instanceof PreventionError)
         return error;
     throw error;
 };
-const isText = (part) => 'insertAt' in part;
-/** The text part showing display offset `offset` of `block`: its index and local offset. */
-const partAt = (block, offset) => {
-    let at = 0;
-    const parts = block.content;
-    for (let index = 0; index < parts.length; index++) {
-        const part = parts[index];
-        if (isText(part) && offset <= at + part.length)
-            return { index, offset: offset - at, part };
-        at += isText(part) ? part.length : 1;
-    }
-    // Past the end (a later step of the plan writes there): its last text's end.
-    const index = parts.findLastIndex(isText);
-    const part = parts[index];
-    return part ? { index, offset: part.length, part } : null;
-};
 /**
  * What a text `patchData` writes, or `null`: only a patch setting strings can
  * be typing into a bound field; a flag, a number, a delete or an object is a
  * discrete edit, its own step.
  */
-const textPatch = (block, payload) => {
-    const { ops, atom } = payload;
+const textPatch = (args) => {
+    const [target, ops] = args;
     if (!Array.isArray(ops) || ops.length === 0 || ops.some((o) => typeof o?.value !== 'string'))
         return null;
     return {
-        key: JSON.stringify([block.id, atom, ops.map((o) => o.path)]),
+        key: JSON.stringify([target, ops.map((o) => o.path)]),
         values: ops.map((o) => o.value)
     };
 };
@@ -119,15 +94,38 @@ const continuesTyping = (previous, patch) => patch !== null &&
     patch.values.every((value, i) => typedFrom(previous.values[i], value));
 /** Passes one normalizer may take on one block per command: the first and 50 re-requests. */
 const MAX_PASSES = 51;
-const specJSON = (spec) => ({
-    id: spec.id,
-    type: spec.type,
-    data: spec.data ?? {},
-    content: (spec.content ?? []).map((item) => item.kind === 'text'
-        ? { text: item.text, ...(item.marks ? { marks: item.marks } : {}) }
-        : { id: item.id, type: item.type, data: item.data ?? {} }),
-    children: (spec.children ?? []).map(specJSON)
-});
+/**
+ * The block a write's first argument names: a block, a list's first, a
+ * destination's parent, a position's or a target's block (`null`: the root).
+ */
+const subjectOf = (arg) => {
+    if (typeof arg === 'string')
+        return arg;
+    if (Array.isArray(arg))
+        return subjectOf(arg[0]);
+    if (arg === null || typeof arg !== 'object')
+        return null;
+    const at = arg;
+    return subjectOf(at.block ?? at.parent ?? at.replace ?? at.slot);
+};
+/** A planned step as the operation it performs, with that operation's arguments. */
+const ARGS = {
+    insertBlocks: (w) => [{ parent: w.parent, index: w.index }, w.specs],
+    moveBlocks: (w) => [w.ids, { parent: w.parent, index: w.index }],
+    deleteBlock: (w, keepChildren) => [w.id, { keepChildren }],
+    splitBlock: (w) => [w.id, w.offset, w.newId, w.tail],
+    mergeBlocks: (w) => [w.from, w.into],
+    setBlockType: (w) => [w.id, w.type],
+    patchData: (w) => [
+        w.inlineId !== undefined ? { block: w.id, atom: w.inlineId } : (w.id ?? null),
+        w.ops
+    ],
+    insertText: (w) => [w.id, w.offset, w.text, w.marks],
+    insertInline: (w) => [w.id, w.offset, w.atom],
+    deleteText: (w) => [w.id, w.offset, w.length],
+    removeInline: (w) => [w.id, w.inlineId],
+    formatRange: (w) => [w.id, w.offset, w.length, w.marks]
+};
 export class Dispatcher {
     edytor;
     #last = null;
@@ -157,11 +155,6 @@ export class Dispatcher {
     kind = null;
     /** The running user command's last step that applied. */
     applied = null;
-    /**
-     * The result the last top-level `dispatch` produced (its own `last`), for
-     * `answer`: a replacement that ran the same operation recorded another.
-     */
-    #produced = null;
     /** Open prevention scopes: a veto inside one aborts it. */
     depth = 0;
     /** Extensions whose replacement is running (a command is replaced at most once per extension). */
@@ -169,9 +162,7 @@ export class Dispatcher {
     /** Requested normalization passes: (block id, normalizer). */
     queue = [];
     current = null;
-    /** The drain is entering `current`'s normalizer (its own request runs it). */
-    entering = false;
-    draining = false;
+    #draining = false;
     /** A plan the next dispatched operation composes before its own (`lead`). */
     leading = null;
     /** The next dispatched operation is a step of its own, as a led one is (`alone`). */
@@ -193,12 +184,13 @@ export class Dispatcher {
      * placed. That step's undo withdraws the block, URL included
      * (`hist.undo.withdraw`), and its redo shows it again, so the paste stays
      * one step whatever the upload's delay, and the typing around it groups
-     * as if it never came. Throws, writing nothing, when a transaction is
-     * already open: its writes would take that transaction's origin and join
-     * its step (call it from a later task, as an upload's answer is).
+     * as if it never came. In development, throws, writing nothing, when a
+     * transaction is already open: its writes would take that transaction's
+     * origin and join its step (call it from a later task, as an upload's
+     * answer is).
      */
     outside = (body) => {
-        if (this.edytor.doc._transaction)
+        if (DEV && this.edytor.doc._transaction)
             throw new Error('dispatcher.outside: called inside a transaction, where its writes would join that step');
         const outer = this.untracked;
         this.untracked = true;
@@ -278,7 +270,7 @@ export class Dispatcher {
         if (this.running)
             return body();
         if (!this.permits())
-            return this.refuse(kind);
+            return void this.#refused(kind);
         this.cut(kind);
         this.applied = null;
         const out = this.scope(() => {
@@ -323,7 +315,7 @@ export class Dispatcher {
         const led = !!lead || this.#alone;
         this.#alone = false;
         if (!this.permits()) {
-            this.#produced = this.#refused(operation);
+            this.#refused(operation);
             return undefined;
         }
         const original = payload;
@@ -361,11 +353,10 @@ export class Dispatcher {
                             continue;
                         }
                         stop.by = plugin;
-                        const refused = this.#refused(operation);
+                        this.#refused(operation);
                         if (this.depth > 0)
                             throw stop;
                         this.replace(stop);
-                        this.#produced = refused;
                         return undefined;
                     }
                     if (!out)
@@ -386,16 +377,14 @@ export class Dispatcher {
         }
         // Refused at preparation, and no extension replaced it.
         if (plan && !('writes' in plan)) {
-            const refused = this.#refused(operation);
-            const out = body(payload, plan);
-            this.#produced = refused;
-            return out;
+            this.#refused(operation);
+            return body(payload, plan);
         }
         const version = this.edytor.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(context.block, payload) : null;
+        const patch = operation === 'patchData' ? textPatch(payload) : null;
         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)
@@ -434,35 +423,110 @@ export class Dispatcher {
         this.#last = own;
         if (this.running && own.status === 'applied')
             this.applied = own;
-        const change = { operation, payload: original, ...context };
+        const effect = plan && 'writes' in plan ? plan.effect : undefined;
+        const change = { operation, payload: original, ...context, effect };
         for (const plugin of this.edytor.plugins)
             plugin.onAfterOperation?.(change);
-        this.#produced = own;
         return result;
     };
     /**
-     * Record what a handle mutator answered on its result (`last.value`), and
-     * answer it. Only on the result its own `dispatch` produced: a nested
-     * operation (a step of the running command) has none, and a vetoed call
-     * whose replacement ran the same operation leaves the replacement's
-     * result (and value) as `last`.
+     * Dispatch `operation` as the plan `prepare` makes of `payload` (a hook's
+     * replacement payload is prepared again), about `block` (the root by
+     * default): hooks see it and each planned step before any write; one
+     * transaction; the blocks it touched normalized and the blocks it moved
+     * shown (closed toggles open); the caret it decides (`plan.at`: a range
+     * deletion, a placed flow) selected. Answers its result: `refused` when
+     * the document refused it, `refused` with the reason `'view'` when the
+     * view did (readonly, a read-only document) or a hook prevented it.
+     */
+    plan = (operation, payload, prepare, block, text) => {
+        let at;
+        const out = this.dispatch(operation, payload, { block: block ?? this.edytor.root, ...(text && { text }) }, (p, plan = prepare(p)) => {
+            at = 'writes' in plan ? plan.at : undefined;
+            return this.write(plan);
+        }, prepare);
+        if (at && !this.active && out && out.status !== 'refused')
+            this.caret(at);
+        return out ?? PREVENTED;
+    };
+    /**
+     * Dispatch the document write `operation` with `args` (`edytor.<op>(…)`):
+     * the view's own arguments filled in — an insertion without marks takes
+     * the insertion's (`marksForInsertion`), a range or a flow is read in
+     * this view (`viewOf`) — then {@link plan}.
      * @internal
      */
-    answer = (value) => {
-        const own = this.#produced;
-        this.#produced = null;
-        if (!this.active && own && this.last === own)
-            this.#amend({ value });
-        return value;
+    operate = (operation, args) => {
+        const { edytor } = this;
+        const own = edytor.facade.prepare[operation];
+        const prepare = (a) => {
+            if (operation === 'insertText' && a[3] === undefined)
+                return own(a[0], a[1], a[2], insertionMarksAt(edytor, a[0], a[1]));
+            if (/^(deleteRange|replaceRange|insertFlow)$/.test(operation) && a[2] === undefined)
+                return own(a[0], a[1], viewOf(edytor));
+            return own(...a);
+        };
+        const block = edytor.idToBlock.block(subjectOf(args[0]) ?? 'root');
+        const text = typeof args[0] === 'string' && typeof args[1] === 'number'
+            ? block.textAtOffset(args[1])?.text
+            : undefined;
+        return this.plan(operation, args, prepare, block, text);
     };
-    /** Amend `last` in place of a new result, keeping it the one its `dispatch` produced. */
-    #amend(patch) {
-        if (!this.last)
-            return;
-        const next = { ...this.last, ...patch };
-        if (this.#produced === this.last)
-            this.#produced = next;
-        this.#last = next;
+    /**
+     * Write `plan` in the running command's transaction (a composed command's
+     * body writes its stages here): request the normalization of what its
+     * steps touch (read before the write), apply it, and show the blocks it
+     * moved. The caret's pending marks are a text insertion's at the caret,
+     * which consumes them; an atom inserted at the caret passes them to the
+     * caret after it. A refusal passes through.
+     * @internal
+     */
+    write = (plan) => {
+        if (!('writes' in plan))
+            return plan;
+        const { facade, idToBlock, selection } = this.edytor;
+        const touched = plan.writes.flatMap((w) => this.#touched(w));
+        const { caret, pending } = selection;
+        const at = (op) => !!pending &&
+            !!caret &&
+            plan.writes.some((w) => w.op === op && w.id === caret.block.id && w.offset === caret.offset);
+        const [typed, atom] = [at('insertText'), at('insertInline')];
+        const result = facade.apply(plan);
+        for (const [id, hook] of touched)
+            this.request(id, hook);
+        if (typed)
+            selection.stage(undefined);
+        const after = atom ? caret.block.textAtOffset(caret.offset + 1) : null;
+        const value = after ? selection.textValue(after.text, after.offset) : null;
+        if (value?.kind === 'text')
+            selection.select(Object.freeze({ ...value, pending }));
+        for (const id of plan.effect.moves) {
+            const block = idToBlock.get(id);
+            if (block)
+                reveal(block);
+        }
+        return result;
+    };
+    /** The normalization a step asks for: the blocks whose content it writes, the parents whose children it changes. */
+    #touched(w) {
+        const { facade } = this.edytor;
+        const parent = (id) => facade.parentOf(id);
+        const children = (...ids) => ids.map((id) => [id ?? 'root', 'normalizeChildren']);
+        if (w.op === 'insertBlocks')
+            return [...children(w.parent), ...w.specs.map(({ id }) => [id, 'normalizeContent'])];
+        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))];
+        if (w.op === 'mergeBlocks')
+            return [[w.into, 'normalizeContent'], ...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']];
     }
     /**
      * Run `body` with `lead` (a plan prepared now) composed into the first
@@ -515,8 +579,9 @@ export class Dispatcher {
         }
         const ops = rest[0];
         const caret = target;
-        // `{ block, offset }`: block offsets, mapped to the text segment that shows the offset.
-        const at = caret?.block?.textAtOffset(Math.max(0, caret.offset));
+        // `{ block, offset }`: block offsets (a handle or an id), mapped to the text segment that shows the offset.
+        const block = typeof caret?.block === 'string' ? this.edytor.idToBlock.get(caret.block) : caret?.block;
+        const at = block?.textAtOffset(Math.max(0, caret.offset));
         return this.#caret(at?.text, at?.offset ?? 0, ops);
     };
     #caret = (text, offset, ops) => {
@@ -533,42 +598,22 @@ export class Dispatcher {
             finally {
                 this.authoring = outer;
             }
-            if (!out)
+            if (out.status === 'refused')
                 return out;
         }
         if (!text || !value || value.kind === 'none')
             return out;
-        selection.clearModelSelectionPreservation();
         selection.select(value);
         // Declared before its operations: gone with them after all, the seam.
         if (!selection.projection.start)
             selection.restoreDeadSelectionEndpoints();
-        this.#amend({ selection: selection.value });
+        if (this.#last)
+            this.#last = { ...this.#last, selection: selection.value };
         return out;
     };
     /**
-     * Inside an operation (or a normalization pass), normalization is
-     * requested, not run: each (block, normalizer) runs once per request, at
-     * the end of the command's transaction. Answers whether the request was
-     * queued.
-     * @internal
-     */
-    defer = (block, normalize) => {
-        const [id, fn] = this.current ?? [];
-        if (this.entering && id === block.id && fn === normalize)
-            return (this.entering = false);
-        if (!this.active)
-            return false;
-        this.request(block.id, normalize);
-        return true;
-    };
-    /**
-     * A normalizer's work: part of the command's transaction (its operations are steps).
-     * @internal
-     */
-    write = (work) => this.edytor.transact(work);
-    /**
-     * Request a normalization pass of block `id` (deduped against the pending ones).
+     * Request a normalization pass of block `id` (deduped against the pending
+     * ones): it runs at the end of the command's transaction, inside it.
      * @internal
      */
     request = (id, normalize) => {
@@ -578,15 +623,18 @@ export class Dispatcher {
     };
     /**
      * Run the requested normalization at the end of the outermost transaction,
-     * inside it, also when the transaction's callback threw: its writes stay. A pass reads handles over the index, so a normalizer sees what
-     * the command (and the previous pass) wrote; a pass that asks for its
-     * block again runs again, at most {@link MAX_PASSES} times.
+     * inside it, also when the transaction's callback threw: its writes stay.
+     * A pass is the block's kind's normalizer, over handles that read the
+     * index, so it sees what the command (and the previous pass) wrote; the
+     * work it answers runs in the same transaction (its operations are
+     * steps), and the block is normalized again, at most {@link MAX_PASSES}
+     * times.
      * @internal
      */
     drain = () => {
-        if (this.draining)
+        if (this.#draining)
             return;
-        this.draining = true;
+        this.#draining = true;
         const passes = new Map();
         const { edytor } = this;
         try {
@@ -605,25 +653,27 @@ export class Dispatcher {
                 counts.set(id, count);
                 if (count > MAX_PASSES) {
                     if (count === MAX_PASSES + 1)
-                        console.warn(`edytor: ${normalize.name} on block "${id}" exceeded ${MAX_PASSES - 1} passes — a plugin normalizer is not converging; skipping further passes`);
+                        console.warn(`edytor: ${normalize} on block "${id}" exceeded ${MAX_PASSES - 1} passes — a plugin normalizer is not converging; skipping further passes`);
                     continue;
                 }
                 this.current = entry;
-                this.entering = true;
                 this.active = true;
                 try {
-                    normalize.call(block);
+                    const work = edytor.definitionOf(block.type)[normalize]?.({ block });
+                    if (work) {
+                        edytor.transact(work);
+                        this.request(id, normalize);
+                    }
                 }
                 finally {
                     this.active = false;
-                    this.entering = false;
                 }
             }
         }
         finally {
             this.queue = [];
             this.current = null;
-            this.draining = false;
+            this.#draining = false;
         }
     };
     /**
@@ -646,10 +696,6 @@ export class Dispatcher {
         const { history, selection } = this.edytor;
         return history.continues(selection.value) ? undefined : 'before';
     }
-    refuse(operation) {
-        this.#refused(operation);
-        return undefined;
-    }
     /** Record `operation` as refused; answers that result. */
     #refused(operation) {
         return (this.#last = { operation, status: 'refused' });
@@ -689,76 +735,28 @@ export class Dispatcher {
         }
     }
     /**
-     * The planned steps as hooks see them, under the documented
-     * operation names. A step that is the command itself (same name, same
-     * block) is not repeated; a write into a block the plan creates is part
-     * of that creation. (A `removeInline` step is only ever its own command,
-     * `removeInlineBlock`; `formatRange` steps belong to no dispatched plan
-     * yet: no mapping. A document data patch shows on the root.)
+     * The planned steps as hooks see them: each as the operation it performs,
+     * with that operation's arguments (`ARGS`), about the block it writes
+     * (the root for the document's data). A step that is the command itself
+     * (same name, same block) is not repeated; a write into a block the plan
+     * creates is part of that creation.
      */
     steps(writes, creates, command) {
-        const { idToBlock, root } = this.edytor;
+        const { idToBlock, root, facade } = this.edytor;
         const created = new Set(creates);
-        const block = (id) => (id === null ? root : idToBlock.get(id));
-        const path = (parent, index) => parent === null ? [index] : [...(block(parent)?.path ?? []), index];
         const out = [];
-        const show = (operation, block, payload, text) => out.push({ operation, block, payload, ...(text ? { text } : {}) });
         for (const w of writes) {
-            const target = w.op === 'patchData'
-                ? (w.id ?? null)
-                : 'id' in w
-                    ? w.id
-                    : w.op === 'mergeBlocks'
-                        ? w.from
-                        : w.parent;
-            const b = block(target);
-            if ((target !== null && created.has(target)) || !b)
+            const keeps = w.op === 'deleteBlock' && facade.childrenIds(w.id).some((c) => !w.removes.includes(c));
+            const args = ARGS[w.op](w, keeps);
+            const target = subjectOf(args[0]);
+            const block = target === null ? root : idToBlock.get(target);
+            if ((target !== null && created.has(target)) || !block)
                 continue;
-            const at = (offset) => partAt(b, offset) ?? { index: 0, offset: 0, part: undefined };
-            // A text step shows on a text: a block without one shows none.
-            const t = 'offset' in w && w.offset !== undefined ? at(w.offset) : undefined;
-            const text = t?.part;
-            if (/^(insertText|insertInline|splitBlock)$/.test(w.op) && !text)
+            if (w.op === command.operation && block === command.block)
                 continue;
-            if (w.op === 'insertBlocks')
-                show('addChildBlocks', b, { blocks: w.specs.map(specJSON), index: w.index });
-            else if (w.op === 'moveBlocks' && w.ids.length === 1)
-                show('moveBlock', block(w.ids[0]), { path: path(w.parent, w.index) });
-            else if (w.op === 'moveBlocks')
-                show('moveBlocks', block(w.ids[0]), {
-                    blocks: w.ids.map(block),
-                    path: path(w.parent, w.index)
-                });
-            else if (w.op === 'deleteBlock')
-                show('removeBlock', b, {
-                    keepChildren: b.children.some((child) => !w.removes.includes(child.id))
-                });
-            else if (w.op === 'splitBlock')
-                show('splitBlock', b, { index: t.offset, text });
-            else if (w.op === 'mergeBlocks')
-                show('mergeBlockBackward', b, {});
-            else if (w.op === 'setBlockType')
-                show('setBlock', b, { value: { type: w.type } });
-            else if (w.op === 'patchData')
-                show('patchData', b, { ops: w.ops, ...(w.inlineId !== undefined && { atom: w.inlineId }) });
-            else if (w.op === 'insertText') {
-                const [start, end, value, marks] = [t.offset, t.offset, w.text, w.marks];
-                show('insertText', b, { value, start, end, marks }, text);
-            }
-            else if (w.op === 'insertInline')
-                show('addInlineBlock', b, {
-                    index: t.offset,
-                    text,
-                    block: { ...w.atom, data: w.atom.data ?? {} }
-                });
-            else if (w.op === 'deleteText') {
-                const end = at(w.offset + w.length);
-                show('deleteContentAtRange', b, {
-                    start: [t.index, t.offset],
-                    end: [end.index, end.offset]
-                });
-            }
+            const text = typeof args[1] === 'number' ? block.textAtOffset(args[1])?.text : undefined;
+            out.push({ operation: w.op, block, payload: args, ...(text && { text }) });
         }
-        return out.filter((c) => c.operation !== command.operation || c.block !== command.block);
+        return out;
     }
 }

package/dist/session/composition.svelte.d.ts

@@ -52,8 +52,8 @@
  * — until the next non-composition occurrence, or `TAIL_MS` compared at use.
  *
  * The facts a display gate reads: `host` (the text whose element a live
- * session owns), `owns(node)`, and `ended(fn)` (the session end, after its
- * writes: where the catch-up display runs).
+ * session owns; the pin answers which nodes it holds) and `ended(fn)` (the
+ * session end, after its writes: where the catch-up display runs).
  */
 import type { DocChange } from '../crdt/index.js';
 import type { Edytor } from '../edytor.svelte.js';
@@ -87,8 +87,6 @@ export declare class Composition {
     swallows: number;
     constructor(edytor: Edytor);
     get live(): boolean;
-    /** `node` lies inside the element a live session owns (the pinned element). */
-    owns: (node: Node | null | undefined) => boolean;
     /** Run `fn` once the live session has ended (after its writes), or now when none is live. */
     ended: (fn: () => void) => void;
     /**