edytor 3.0.0 → 5.0.0

package/dist/plugins/suggestions/suggestionsPlugin.d.ts

@@ -1,15 +1,26 @@
 import type { Snippet } from 'svelte';
 import type { Plugin } from '../../plugins.js';
-import type { Suggestion } from '../../session/suggestions.svelte.js';
-/** What a `bar` snippet receives: one block suggestion and its actions. */
+import type { AnySuggestion } from '../../session/suggestions.svelte.js';
+/** What a `bar` snippet receives: one suggestion (a block suggestion, or a shared one) and its actions. */
 export type SuggestionBarPayload = {
-    suggestion: Suggestion;
-    /** Place it in the document and give the editor its focus back. */
+    suggestion: AnySuggestion;
+    /** Accept it (a view-local one: place it in the document) and give the editor its focus back. */
     accept: () => void;
+    /** Drop it (a shared one: its author withdraws it, a decider rejects it). */
     discard: () => void;
+    /** Reject a shared one (a view-local one: drop it). */
+    reject: () => void;
     /** Ask for another answer (`onRetry`); `undefined` without one. */
     retry: (() => void) | undefined;
     readonly: boolean;
+    /** This view may accept or reject it (a shared one; else: not readonly). */
+    canDecide: boolean;
+    /** A shared one's author, as their profile names them ("Ada", with `suggestion.via`: "Ada (AI)"). */
+    author: {
+        id: string;
+        name?: string;
+        color?: string;
+    } | undefined;
     /** The view's keys are a Mac's: Mod is ⌘ (name the Accept key with it). */
     mac: boolean;
 };

package/dist/selection/domSelection.d.ts

@@ -3,6 +3,8 @@ export type DomSelectionSnapshot = Pick<Selection, 'anchorNode' | 'anchorOffset'
 };
 export declare const getDomSelection: (node?: Node | null) => Selection | null;
 export declare const getActiveElement: (node?: Node | null) => Element | null;
+/** The focused element when it is `node` or inside it (the editor's own focus), else `null`. */
+export declare const focusIn: (node?: Node | null) => Element | null;
 export declare const clearDomSelection: (node?: Node | null) => void;
 /**
  * The caret point under (`x`, `y`): `caretPositionFromPoint` (Firefox,

package/dist/selection/domSelection.js

@@ -7,6 +7,11 @@ const shadowOf = (node) => {
 const documentSelection = (node) => ownerOf(node)?.getSelection() ?? null;
 export const getDomSelection = (node) => shadowOf(node)?.getSelection?.() ?? documentSelection(node);
 export const getActiveElement = (node) => shadowOf(node)?.activeElement ?? ownerOf(node)?.activeElement ?? null;
+/** The focused element when it is `node` or inside it (the editor's own focus), else `null`. */
+export const focusIn = (node) => {
+    const active = getActiveElement(node);
+    return active && node?.contains(active) ? active : null;
+};
 export const clearDomSelection = (node) => {
     getDomSelection(node)?.removeAllRanges();
 };
@@ -96,8 +101,7 @@ export const scrollCaretIntoView = (root) => {
     const focusNode = selection?.focusNode;
     if (!selection || !focusNode || selection.rangeCount === 0 || !root.contains(focusNode))
         return;
-    const active = getActiveElement(root);
-    if (!active || !root.contains(active))
+    if (!focusIn(root))
         return;
     const element = focusNode instanceof Element ? focusNode : focusNode.parentElement;
     if (!element)

package/dist/selection/pointer.svelte.js

@@ -1,10 +1,10 @@
 import { blockSelection } from '../session/selection.js';
 import { toTrailingParagraph } from '../session/navigation.js';
-import { isNativeInteractiveControl, isNativeInteractiveEvent } from '../events/nativeInteractiveControl.js';
+import { isNativeInteractiveControl, isNativeInteractiveEvent, ownsPress } from '../events/nativeInteractiveControl.js';
 import { acrossColumns } from './replaceSelection.js';
 import { caretAtPoint, getDomSelectionSnapshot } from './domSelection.js';
 import { domPointOf } from '../surface/projector.svelte.js';
-import { getElementFromNode, isTextBoundSelectionPoint, offsetIn, SUGGESTION } from './selection.utils.js';
+import { editableBoundary, isTextBoundSelectionPoint, offsetIn, SUGGESTION } from './selection.utils.js';
 export class SelectionPointer {
     selection;
     /** The press's text point while a primary press (a drag) lasts; `null` after its release. */
@@ -24,13 +24,17 @@ export class SelectionPointer {
     hold = () => {
         this.#held = true;
     };
+    /**
+     * The block whose non-editable chrome `node` is in: its nearest
+     * `contenteditable` boundary is `false`. A nested editable between them
+     * (a void block's caption) is no chrome: the browser places the caret
+     * at the press, in one step (`sel.press.nested-editable`).
+     */
     #chromeBlock = (node) => {
-        const element = getElementFromNode(node);
-        const nonEditableElement = element?.closest('[contenteditable="false"]');
-        if (!(nonEditableElement instanceof HTMLElement) ||
-            !this.selection.edytor.node?.contains(nonEditableElement)) {
+        const boundary = editableBoundary(node, this.selection.edytor.node);
+        if (!boundary || boundary.editable)
             return null;
-        }
+        const nonEditableElement = boundary.element;
         // A suggestion's preview is no block's chrome: a press there is its own (cancelled).
         if (isNativeInteractiveControl(nonEditableElement) || nonEditableElement.closest(SUGGESTION)) {
             return null;
@@ -75,17 +79,17 @@ export class SelectionPointer {
     };
     #trailing = () => {
         const { edytor } = this.selection;
-        edytor.expectInternalFocus();
-        edytor.node?.focus({ preventScroll: true });
+        edytor.expectInternalFocus(edytor.node);
         toTrailingParagraph(edytor);
     };
     /** The gesture a press in the host's own area starts (`claimMargins`): the marquee's. */
     #margin = null;
     /**
-     * The host's last press went to the margin gesture (`marginPress`), until
-     * its release: its compatibility `mousedown` is cancelled (no native
-     * caret, focus or selection), and it places no caret (`pressed`) and
-     * starts no text drag (`capture`).
+     * The host's last press went to a gesture of the model's (the margin
+     * gesture's, `marginPress`; a void block's selection, `chromePress`),
+     * until its release: its compatibility `mousedown` is cancelled (no
+     * native caret, focus or selection), and it places no caret (`pressed`)
+     * and starts no text drag (`capture`).
      * @internal
      */
     claimed = false;
@@ -159,14 +163,26 @@ export class SelectionPointer {
         const point = this.#pointAt(x, at.clientY);
         if (!point)
             return;
-        edytor.expectInternalFocus();
-        host.focus({ preventScroll: true });
+        edytor.expectInternalFocus(host);
         this.selection.selectText(point.text, point.offset);
     };
-    /** @internal */
+    /**
+     * A press on a block's non-editable chrome. A void block's
+     * (`sel.press.void`, Notion): the block is selected, the host focused,
+     * no caret placed — unless the press is a control's of its own
+     * (`ownsPress`: a native control, an interactive role, an element the
+     * app marks `data-edytor-control`), which keeps it whole; Shift or Mod
+     * adds the block to a block selection. On the line of the block's text
+     * (a caption's, beside its text), the caret at the nearest point of it.
+     * Any other block's: the caret at the start of its text. A press a
+     * control owns (`ownPress`) never reaches it.
+     * @internal
+     */
     chromePress = (event) => {
         const targetNode = event.target instanceof Node ? event.target : null;
         const targetBlock = this.#chromeBlock(targetNode);
+        if (targetBlock && this.selection.edytor.facade.isVoid(targetBlock.id))
+            return this.#voidPress(event, targetBlock);
         const targetText = targetBlock?.firstText;
         // A native control inside the chrome (a void block's input) owns its press.
         if (!targetText || isNativeInteractiveEvent(event)) {
@@ -175,10 +191,40 @@ export class SelectionPointer {
         // The model answers this press: the browser's own caret placement on
         // the chrome is cancelled (a canceled pointerdown moves no selection).
         event.preventDefault();
-        this.selection.edytor.expectInternalFocus();
-        this.selection.edytor.node?.focus({ preventScroll: true });
+        this.selection.edytor.expectInternalFocus(this.selection.edytor.node);
         this.selection.selectText(targetText, 0);
     };
+    /**
+     * A press (and its whole gesture: its clicks, multi-clicks, `selectstart`
+     * and drag) a control of a block's chrome owns (`ownsPress`,
+     * `sel.press.void`): the editor does nothing with it. Every press handler
+     * asks this one rule first.
+     * @internal
+     */
+    ownPress = (event) => ownsPress(this.selection.edytor.node, event);
+    /** A press on void block `block`'s chrome selects it (`sel.press.void`). */
+    #voidPress = (event, block) => {
+        const { edytor, value } = this.selection;
+        if (event.button !== 0)
+            return;
+        // The model answers it: no native caret, focus or selection; no text drag (`claimed`).
+        event.preventDefault();
+        this.claimed = true;
+        edytor.expectInternalFocus(edytor.node);
+        // On the line of its text (a caption's, beside the text): the caret at the nearest point there.
+        const target = event.target instanceof Element && event.target !== block.node ? event.target : null;
+        const line = target?.querySelector('[data-edytor-text]');
+        const text = line && this.selection.getTextOfNode(line);
+        const box = line?.getBoundingClientRect();
+        if (text &&
+            text.parent === block &&
+            box &&
+            event.clientY >= box.top &&
+            event.clientY <= box.bottom)
+            return this.placeAt(text, event.clientX, event.clientY);
+        const adding = (event.shiftKey || event.metaKey || event.ctrlKey) && value.kind === 'blocks';
+        this.selection.select(blockSelection(adding ? [...new Set([...value.ids, block.id])] : [block.id]));
+    };
     /**
      * A triple click selects the block's content in the model; the browser's
      * own multi-click selection is cancelled at its `mousedown`
@@ -186,7 +232,7 @@ export class SelectionPointer {
      * @internal
      */
     tripleClick = (e) => {
-        if (e.detail < 3)
+        if (e.detail < 3 || this.ownPress(e))
             return;
         const targetNode = e.target instanceof Node ? e.target : null;
         const clickedBlock = this.selection.getBlockOfNode(targetNode);
@@ -202,7 +248,7 @@ export class SelectionPointer {
     };
     /** @internal */
     preventTripleClick = (e) => {
-        if (e.detail >= 3)
+        if (e.detail >= 3 && !this.ownPress(e))
             e.preventDefault();
     };
     /** The text point under the pointer, if any. */
@@ -361,39 +407,20 @@ export class SelectionPointer {
      * anchor) would anchor the DOM selection on nodes the model cannot
      * represent — block-level selection owns that surface instead.
      *
-     * The NEAREST `[contenteditable]` boundary decides: `false` means
-     * non-editable chrome, while a nested `true` (void-block captions
-     * re-enable editing on their text spans) keeps native selection.
-     * The root itself is excluded so readonly mode stays selectable.
+     * The nearest `[contenteditable]` boundary decides (`editableBoundary`,
+     * the chrome press's rule too): `false` means non-editable chrome, while
+     * a nested editable (void-block captions re-enable editing on their text
+     * spans) keeps native selection. The root itself is excluded so readonly
+     * mode stays selectable.
      * @internal
      */
     onSelectStart = (event) => {
         // Native controls (todo checkboxes, plugin inputs…) keep their own
         // selection behavior.
-        if (isNativeInteractiveEvent(event)) {
-            return;
-        }
-        const element = getElementFromNode(event.target instanceof Node ? event.target : null);
-        if (!element || !this.selection.edytor.node?.contains(element)) {
+        if (isNativeInteractiveEvent(event) || this.ownPress(event))
             return;
-        }
-        // Walk ancestors to the nearest contenteditable boundary. Both the
-        // attribute and the `contentEditable` property are checked — the
-        // attach hooks of inline/void blocks set the property, which jsdom
-        // does not reflect onto the attribute.
-        let boundary = element instanceof HTMLElement ? element : null;
-        while (boundary && boundary !== this.selection.edytor.node) {
-            const state = boundary.getAttribute('contenteditable') ?? boundary.contentEditable;
-            if (state === 'false') {
-                event.preventDefault();
-                return;
-            }
-            if (state === 'true' || state === 'plaintext-only' || state === '') {
-                // Nested editable region (e.g. void-block captions re-enabling
-                // editing on their text spans) keeps native selection.
-                return;
-            }
-            boundary = boundary.parentElement;
-        }
+        const target = event.target instanceof Node ? event.target : null;
+        if (editableBoundary(target, this.selection.edytor.node)?.editable === false)
+            event.preventDefault();
     };
 }

package/dist/selection/replaceSelection.js

@@ -1,6 +1,6 @@
 import { Text } from '../text/text.svelte.js';
 import { id, vetoable } from '../utils.js';
-import { blockSelection, noSelection } from '../session/selection.js';
+import { blockSelection, noSelection, pointOf } from '../session/selection.js';
 import { hidden, selectedMembers, shown } from './visibility.js';
 /**
  * The caret a write that decides one left (a range deletion, a placed flow:
@@ -211,11 +211,7 @@ const deleteRange = (edytor, replace, selection) => {
     const { startText, endText, yStart, yEnd } = selection ?? edytor.selection.textRange();
     if (!startText || !endText)
         return null;
-    const at = (text, offset) => ({
-        block: text.parent.id,
-        offset: text.segStart + offset
-    });
-    const [from, to] = [at(startText, yStart), at(endText, yEnd)];
+    const [from, to] = [pointOf(startText, yStart), pointOf(endText, yEnd)];
     const result = replace ? edytor.replaceRange(from, to) : edytor.deleteRange(from, to);
     if (result.status === 'refused')
         return result.reason === 'view' ? null : { text: startText, offset: yStart };

package/dist/selection/selection.svelte.d.ts

@@ -90,9 +90,9 @@ export declare class EdytorSelection {
     /** Stage (or, with `undefined`, clear) the caret's pending marks: a new value, same anchors. */
     stage: (pending: Marks | undefined) => void;
     /**
-     * A text value from wrapper endpoints (offsets inside text segments):
-     * the start binds right (boundary inserts stay outside), the end and a
-     * caret bind left; `none` when the start text is not bound to the document.
+     * A text value from wrapper endpoints (offsets inside text segments): the
+     * start binds right (boundary inserts stay outside), the end and a caret
+     * bind left; `none` when the start text is not bound to the document.
      */
     textValue: (startText: Text, yStart: number, endText?: Text, yEnd?: number, isReversed?: boolean, startAffinity?: "left" | "right") => SelectionValue;
     /**

package/dist/selection/selection.svelte.js

@@ -5,7 +5,7 @@ import { getDomSelectionSnapshot } from './domSelection.js';
 import { SvelteSet } from 'svelte/reactivity';
 import { InlineBlock } from '../block/inlineBlock.svelte.js';
 import { isKindControl, isNativeInteractiveControl, isOwnPoint } from '../events/nativeInteractiveControl.js';
-import { atomSelection, blockSelection, noSelection, project, sameEnds, sameValue, serialize, textSelection } from '../session/selection.js';
+import { atomSelection, blockSelection, noSelection, pointOf, project, sameEnds, sameValue, serialize, textSelection } from '../session/selection.js';
 import { seam } from '../crdt/anchors.js';
 import { landed } from '../session/navigation.js';
 import * as visibility from './visibility.js';
@@ -272,9 +272,8 @@ export class EdytorSelection {
      * shows no text (a divider) keeps the current value. Displayed after the flush.
      */
     setCaret = (caret) => {
-        const at = caret && caret.block.textAtOffset(Math.max(0, caret.offset));
-        if (at)
-            this.selectText(at.text, at.offset);
+        if (caret)
+            this.selectAt({ block: caret.block.id, offset: Math.max(0, caret.offset) });
     };
     /** The marks the next insertion at the caret takes (values kept). */
     get pending() {
@@ -385,20 +384,39 @@ export class EdytorSelection {
         }
     };
     /**
-     * A text value from wrapper endpoints (offsets inside text segments):
-     * the start binds right (boundary inserts stay outside), the end and a
-     * caret bind left; `none` when the start text is not bound to the document.
+     * A text value from block-offset points (an inline atom counting 1): the
+     * start binds right (boundary inserts stay outside), the end and a caret
+     * bind left; `none` when the start does not anchor (the root, an unknown block).
+     * @internal
      */
-    textValue = (startText, yStart, endText = startText, yEnd = yStart, isReversed = false, startAffinity) => {
-        const mint = this.createTextAnchor;
-        const collapsed = startText === endText && yStart === yEnd;
-        const start = mint(startText, yStart, startAffinity ?? (collapsed ? 'left' : 'right'));
-        if (!start)
+    valueAt = (start, end = start, isReversed = false, startAffinity) => {
+        const { facade } = this.edytor;
+        const collapsed = start.block === end.block && start.offset === end.offset;
+        const a = facade.anchorAt(start.block, start.offset, startAffinity ?? (collapsed ? 'left' : 'right'));
+        if (!a)
             return noSelection;
         if (collapsed)
-            return textSelection(start);
-        const end = mint(endText, yEnd, 'left') ?? start;
-        return isReversed ? textSelection(end, start) : textSelection(start, end);
+            return textSelection(a);
+        const b = facade.anchorAt(end.block, end.offset, 'left') ?? a;
+        return isReversed ? textSelection(b, a) : textSelection(a, b);
+    };
+    /**
+     * A text value from wrapper endpoints (offsets inside text segments): the
+     * start binds right (boundary inserts stay outside), the end and a caret
+     * bind left; `none` when the start text is not bound to the document.
+     */
+    textValue = (startText, yStart, endText = startText, yEnd = yStart, isReversed = false, startAffinity) => this.valueAt(pointOf(startText, yStart), pointOf(endText, yEnd), isReversed, startAffinity);
+    /**
+     * Select from `start` to `end` (block offsets, a caret by default;
+     * `isReversed` makes the end the anchor), else the seam of the start's
+     * block. The projector displays it after the flush.
+     * @internal
+     */
+    selectAt = (start, end = start, isReversed = false) => {
+        const value = this.valueAt(start, end, isReversed);
+        const target = project(value, this.edytor.facade).start ? value : this.#seamValue(start.block);
+        if (target)
+            this.select(target);
     };
     /**
      * Select from `yStart` of `startText` to `yEnd` of `endText` (a caret by
@@ -413,13 +431,8 @@ export class EdytorSelection {
     selectText = (startText, yStart, endText = startText ?? null, yEnd = yStart, isReversed = false) => {
         if (!startText || !endText)
             return;
-        const at = (text, offset) => Math.min(Math.max(offset, 0), text.length);
-        const value = this.textValue(startText, at(startText, yStart), endText, at(endText, yEnd), isReversed);
-        const target = project(value, this.edytor.facade).start
-            ? value
-            : this.#seamValue(startText.parent?.id ?? null);
-        if (target)
-            this.select(target);
+        const at = (text, offset) => pointOf(text, Math.min(Math.max(offset, 0), text.length));
+        this.selectAt(at(startText, yStart), at(endText, yEnd), isReversed);
     };
     /**
      * Select `block`'s lines (Mod+A, a triple click): from its first shown
@@ -468,8 +481,7 @@ export class EdytorSelection {
         if (value.kind !== 'atom')
             return;
         const { start } = this.projection;
-        const before = start && this.textAt(start);
-        this.select(before ? this.textValue(before.text, before.offset) : noSelection);
+        this.select(start ? this.valueAt(start) : noSelection);
     };
     selectInlineBlock = (inlineBlock, from = 'before') => {
         this.select(atomSelection(inlineBlock.parent.id, inlineBlock.id, from));
@@ -477,11 +489,7 @@ export class EdytorSelection {
     /** @internal */
     getTextOfNode = getTextOfNode.bind(this);
     /** @internal The block whose element holds `node`, in this editor. */
-    getBlockOfNode = (node) => {
-        const element = getElementFromNode(node)?.closest('[data-edytor-block]');
-        const id = element && this.edytor.node?.contains(element) && element.dataset.edytorId;
-        return (id && this.edytor.idToBlock.get(id)) || null;
-    };
+    getBlockOfNode = (node) => this.edytor.surface.blockOf(node);
     /** @internal */
     init = () => {
         if (typeof document === 'undefined')
@@ -656,9 +664,8 @@ export class EdytorSelection {
      * for the root's own text.
      */
     createTextAnchor = (text, offset, affinity = 'left') => {
-        if (text.parent.isRoot)
-            return null;
-        return this.edytor.facade.anchorAt(text.blockId, text.segStart + offset, affinity);
+        const { block, offset: at } = pointOf(text, offset);
+        return this.edytor.facade.anchorAt(block, at, affinity);
     };
     /**
      * Resolve a `TextAnchor` → `{text, offset}` (offset within the text

package/dist/selection/selection.utils.d.ts

@@ -7,6 +7,20 @@ export declare const SYNTHETIC_TEXT_OVERLAY_SELECTOR = "[data-edytor-text-sugges
 /** A block suggestion's preview group: view-only, never a selection endpoint (`session/suggestions`). */
 export declare const SUGGESTION = "[data-edytor-suggestion]";
 export declare const getElementFromNode: (node: Node | null) => Element | null;
+/**
+ * The nearest `contenteditable` boundary of `node` inside `host` (the host
+ * itself excluded), and whether it is editable: `false` is non-editable
+ * chrome (a void block's wrapper, an atom, a control's icon); a nested
+ * `true`, `plaintext-only` or `''` (a void block's caption, which turns
+ * editing on again for its text) is an editable region whose presses and
+ * drags are the browser's (`sel.press.nested-editable`). The attribute or,
+ * without one, the property (an attach hook sets it; jsdom reflects
+ * neither way). `null`: no boundary below the host.
+ */
+export declare const editableBoundary: (node: Node | null, host: Element | null | undefined) => {
+    element: Element;
+    editable: boolean;
+} | null;
 export declare const isInsideTrailingNewlineMarker: (node: Node) => boolean;
 /**
  * A selection endpoint counts as text-bound when it lives inside a

package/dist/selection/selection.utils.js

@@ -13,6 +13,31 @@ export const getElementFromNode = (node) => !node || typeof Element === 'undefin
         : node.nodeType === Node.TEXT_NODE
             ? node.parentElement
             : null;
+/**
+ * The nearest `contenteditable` boundary of `node` inside `host` (the host
+ * itself excluded), and whether it is editable: `false` is non-editable
+ * chrome (a void block's wrapper, an atom, a control's icon); a nested
+ * `true`, `plaintext-only` or `''` (a void block's caption, which turns
+ * editing on again for its text) is an editable region whose presses and
+ * drags are the browser's (`sel.press.nested-editable`). The attribute or,
+ * without one, the property (an attach hook sets it; jsdom reflects
+ * neither way). `null`: no boundary below the host.
+ */
+export const editableBoundary = (node, host) => {
+    if (!host)
+        return null;
+    for (let at = getElementFromNode(node); at && at !== host; at = at.parentElement) {
+        if (!host.contains(at))
+            return null;
+        const attribute = at.getAttribute('contenteditable');
+        const state = attribute?.toLowerCase() ?? at.contentEditable;
+        if (state === 'false')
+            return { element: at, editable: false };
+        if (state === 'true' || state === 'plaintext-only' || state === '')
+            return { element: at, editable: true };
+    }
+    return null;
+};
 /** The element around `node` (itself included) matching `selector`. */
 const closestTo = (node, selector) => getElementFromNode(node)?.closest(selector) ?? null;
 /** `node` is an element matching `selector` or holding one. */
@@ -120,7 +145,7 @@ export function getTextOfNode(node, offset) {
     if (!node)
         return null;
     const { edytor } = this;
-    const textOf = (element) => (element && edytor.nodeToText.get(element)) || null;
+    const textOf = (element) => edytor.surface.handleOf(element, 'text');
     // A point in a suggestion's preview is the stray boundary the preview sits at.
     const preview = closestTo(node, SUGGESTION);
     if (preview)
@@ -138,7 +163,7 @@ export const getInlineBlockOfNode = (edytor, node) => {
     const element = getElementFromNode(node);
     const around = element?.closest(INLINE);
     const inline = around && edytor.node?.contains(around) ? around : element?.querySelector(INLINE);
-    return (inline && edytor.nodeToInlineBlock.get(inline)) || null;
+    return edytor.surface.handleOf(inline, 'atom');
 };
 /** The one inline atom a non-collapsed range covers, touching no text. */
 export const getInlineBlockInSelectedRange = (edytor, range) => {
@@ -146,7 +171,7 @@ export const getInlineBlockInSelectedRange = (edytor, range) => {
     if (!root)
         return null;
     const inside = (selector) => [...(root.matches(selector) ? [root] : []), ...root.querySelectorAll(selector)].filter((element) => range.intersectsNode(element));
-    const atoms = new Set(inside(INLINE).flatMap((element) => edytor.nodeToInlineBlock.get(element) ?? []));
+    const atoms = new Set(inside(INLINE).flatMap((element) => edytor.surface.handleOf(element, 'atom') ?? []));
     return atoms.size === 1 && !inside(TEXT).length ? [...atoms][0] : null;
 };
 /**

package/dist/session/commands.js

@@ -1,4 +1,5 @@
 import { refused } from '../crdt/doc/plan.js';
+import { pointOf } from './selection.js';
 import { viewOf } from '../selection/visibility.js';
 import { reveal } from '../selection/replaceSelection.js';
 import { DEV } from 'esm-env';
@@ -171,6 +172,13 @@ export class Dispatcher {
     patched = null;
     /** `outside` is running: its commands cut no step and enter none. */
     untracked = false;
+    /**
+     * A plugin that writes plans itself (the shared suggestions' suggesting
+     * mode): a plan's result (its `at` set to where its caret stands now),
+     * or `null` to write it as prepared. Set by the plugin.
+     * @internal
+     */
+    writer;
     /** @internal */
     constructor(edytor) {
         this.edytor = edytor;
@@ -402,7 +410,7 @@ export class Dispatcher {
                 try {
                     // An unplanned command runs after its lead, reading the state it leaves.
                     if (lead && !plan)
-                        this.edytor.facade.apply(lead);
+                        void (this.writer?.(lead) ?? this.edytor.facade.apply(lead));
                     return body(payload, plan);
                 }
                 finally {
@@ -442,8 +450,10 @@ export class Dispatcher {
     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)) => {
+            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;
-            return this.write(plan);
+            return out;
         }, prepare);
         if (at && !this.active && out && out.status !== 'refused')
             this.caret(at);
@@ -493,13 +503,14 @@ export class Dispatcher {
             !!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);
+        const result = this.writer?.(plan) ?? 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;
+        const value = atom
+            ? selection.valueAt({ block: caret.block.id, offset: caret.offset + 1 })
+            : null;
         if (value?.kind === 'text')
             selection.select(Object.freeze({ ...value, pending }));
         for (const id of plan.effect.moves) {
@@ -575,14 +586,13 @@ export class Dispatcher {
      */
     caret = (caret, ops) => {
         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.caretIn(at?.text, at?.offset ?? 0, ops);
+        return this.#caretAt(block && { block: block.id, offset: Math.max(0, caret.offset) }, ops);
     };
     /** @internal `caret` at an offset inside a text segment. */
-    caretIn = (text, offset, ops) => {
+    caretIn = (text, offset, ops) => this.#caretAt(text && pointOf(text, Math.max(0, Math.min(offset, text.length))), ops);
+    #caretAt = (point, ops) => {
         const selection = this.edytor.selection;
-        const at = text ? Math.max(0, Math.min(offset, text.length)) : 0;
-        const value = text ? selection.textValue(text, at) : null;
+        const value = point ? selection.valueAt(point) : null;
         let out;
         if (ops) {
             const outer = this.authoring;
@@ -596,7 +606,7 @@ export class Dispatcher {
             if (out.status === 'refused')
                 return out;
         }
-        if (!text || !value || value.kind === 'none')
+        if (!value || value.kind === 'none')
             return out;
         selection.select(value);
         // Declared before its operations: gone with them after all, the seam.

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

@@ -3,9 +3,11 @@
  *
  * One IME composition is one session. Its start target (the selection at
  * `compositionstart`) is replaced at its first write through an ordinary
- * command (hooks, veto, tracked) — over a block or atom selection, which
- * shows no DOM range, at the start, so the IME writes in its place — and
- * the marks of the composed text are captured once, at the start. Previews are mechanical tracked writes (no
+ * command (hooks, veto, tracked) — at the start over a block or atom
+ * selection, which shows no DOM range, and over a text range across blocks,
+ * whose native replacement would join the blocks' elements (`ime.range.blocks`),
+ * so the IME writes in its place — and the marks of the composed text are
+ * captured once, at the start. Previews are mechanical tracked writes (no
  * hooks) inside one capture group: the group opens with the session's first
  * write and is held open before each later one (`UndoManager.lastChange`),
  * so the session and its ending are one undo step. Like a typed