edytor 1.0.0 → 2.0.0

package/dist/plugins.d.ts

@@ -1,6 +1,7 @@
 import type { Snippet } from 'svelte';
 import type { Edytor } from './edytor.svelte.js';
 import type { Block } from './block/block.svelte.js';
+import type { BlockMovePosition } from './session/moves.js';
 import type { JSONBlock, JSONDoc, JSONInlineBlock, JSONText } from './utils/json.js';
 import type { Text } from './text/text.svelte.js';
 import type { TextTransform } from './surface/cells.js';
@@ -42,7 +43,12 @@ export type { Prevent };
 export type BlockView<D = Record<string, any>> = {
     readonly id: string;
     readonly type: string;
-    readonly data: Readonly<D>;
+    /**
+     * The block's data as plain state (`block.data`): reactive at any depth,
+     * and writable, each write a dispatched `patchData`. In a suggestion's
+     * preview it is a copy: a write there changes nothing.
+     */
+    readonly data: D;
     readonly selected: boolean;
     readonly focused: boolean;
     /**
@@ -241,7 +247,10 @@ export type TextRuleContext = {
 };
 /** What an input rule's `replace` receives besides the match. */
 export type InputRuleContext = TextRuleContext & {
-    /** The typed text that completed the match: part of the match, not in the document. */
+    /**
+     * The typed text that completed the match: the end of the match, already
+     * in the document as its own undo step (`to` is after it).
+     */
     typed: string;
     /**
      * Remove the matched text (`from` to `to`) in the same plan as the first
@@ -267,13 +276,14 @@ export type InputRule = {
      */
     find: RegExp;
     /**
-     * The replacement. Return a string to replace the whole match with it
-     * (one command and one undo step with the matched text's removal; the
-     * caret after it), or write it yourself and return `true`, usually
-     * through `ctx.remove(() => …)`. Return `false` or `null`, writing
-     * nothing, to decline: the next rule is asked, then the typed text is
-     * inserted as usual, as it is when the replacement is refused (by the
-     * document, readonly or a plugin's veto).
+     * The replacement, run once the typed text is in the document (its own
+     * undo step, so the first undo gives the typed text back). Return a
+     * string to replace the whole match with it (one command and one undo
+     * step with the matched text's removal; the caret after it), or write it
+     * yourself and return `true`, usually through `ctx.remove(() => …)`.
+     * Return `false` or `null`, writing nothing, to decline: the next rule is
+     * asked, and the typed text stays as typed, as it does when the
+     * replacement is refused (by the document, readonly or a plugin's veto).
      */
     replace: (match: RegExpExecArray, ctx: InputRuleContext) => string | boolean | null | void;
 };
@@ -292,6 +302,11 @@ export type TriggerContext = TextRuleContext & {
 export type Trigger<T = any> = {
     /** The text that opens the menu (one or two characters: `@`, `[[`). */
     char: string;
+    /**
+     * The menu's name, read by its markup as `controller.trigger.name` (the
+     * mention plugin's `kind`: one menu snippet can serve several triggers).
+     */
+    name?: string;
     /** The rows for `query`, at once or as a promise (a search); the newest query wins. */
     items: (query: string, ctx: TriggerContext) => readonly T[] | Promise<readonly T[]>;
     /**
@@ -397,10 +412,18 @@ export type PluginOperations = {
         prevent: Prevent;
         e: ClipboardEvent;
     }) => void;
-    /** Called when a paste event is detected */
+    /**
+     * Called when a paste event is detected, and for a drop (its data as the
+     * clipboard's). `at`: where files dropped from outside land, the drop
+     * indicator's placement (beside, before, after or inside `block`).
+     */
     onPaste?: (payload: {
         prevent: Prevent;
         e: ClipboardEvent;
+        at?: {
+            block: string;
+            position: BlockMovePosition;
+        };
     }) => void;
 };
 /**
@@ -493,9 +516,11 @@ export type BlockDefinition = {
      */
     rendersContent?: boolean;
     /**
-     * The files the kind takes (the image's `image/*`, the file block's any):
-     * with the uploads plugin listed, an empty block's Upload sends one and a
-     * pasted or dropped file becomes a block of this kind (`media.files`).
+     * The files the kind takes (the image's `image/*`, the file block's any)
+     * and who sends them (`send`: the media plugins set it from their
+     * `upload` option): an empty block's Upload sends one, and a pasted or
+     * dropped file becomes a block of this kind (`media.files`). A kind
+     * without it takes no files.
      */
     upload?: KindUpload;
     /**
@@ -609,7 +634,8 @@ export type BlockDefinition = {
 export type InlineBlockView<D = Record<string, any>> = {
     readonly id: string;
     readonly type: string;
-    readonly data: Readonly<D>;
+    /** The atom's data as plain state (`atom.data`), writable; a suggested atom's is a copy. */
+    readonly data: D;
     readonly selected: boolean;
     /** The atom's id-only handle; a suggested atom has none. */
     readonly handle: InlineBlock | undefined;

package/dist/session/attempt.d.ts

@@ -18,6 +18,7 @@
  */
 import type { Edytor } from '../edytor.svelte.js';
 import type { Text } from '../text/text.svelte.js';
+import type { BlockMovePosition } from './moves.js';
 type Kind = 'text' | 'composition' | 'payload' | 'break' | 'delete' | 'history';
 export type IntentRow = {
     kind: Kind;
@@ -63,10 +64,10 @@ export declare const untargeted: (edytor: Edytor) => boolean;
  * void's own field.
  */
 declare const facts: (edytor: Edytor) => {
-    projection: import("./selection").SelectionProjection;
+    projection: import("./selection.js").SelectionProjection;
     isCollapsed: boolean;
     /** The admitted mark-edge side of a caret. */
-    edge: import("./editing/text").EdgeSide | undefined;
+    edge: import("./editing/text.js").EdgeSide | undefined;
     isVoidEditableElement: boolean;
     startText: Text | null;
     endText: Text | null;
@@ -74,7 +75,7 @@ declare const facts: (edytor: Edytor) => {
     yEnd: number;
     texts: Text[];
     /** The anchored target, fixed at admission. */
-    target: import("./selection").SelectionValue;
+    target: import("./selection.js").SelectionValue;
 };
 /**
  * How DOM drift around a model-owned attempt is repaired: the observer
@@ -107,9 +108,16 @@ export type Occurrence = {
     dataTransfer?: DataTransfer | null;
     /** The range the browser declared (`getTargetRanges()`, a drop point). */
     declared?: StaticRange | null;
+    /** Where a file drop lands, the indicator's placement (`plugins/fileDrop.ts`). */
+    placement?: DropAt | null;
     cancelable: boolean;
     event?: InputEvent;
 };
+/** A drop's placement in block terms: beside, before, after or inside `block`. */
+export type DropAt = {
+    block: string;
+    position: BlockMovePosition;
+};
 export type Attempt = ReturnType<typeof facts> & {
     id: number;
     /** The intent, fixed at admission. */
@@ -121,6 +129,7 @@ export type Attempt = ReturnType<typeof facts> & {
     dataTransfer: DataTransfer | null;
     hasDataTransferTextPayload: boolean;
     declared: StaticRange | null;
+    placement: DropAt | null;
     /** Admitted from a keydown (the key's intent wins; the browser may never announce it). */
     isStructuralKeyFallback: boolean;
     owner: 'model' | 'browser';
@@ -135,10 +144,10 @@ export declare const intentSnapshot: (edytor: Edytor, inputType: string) => Atte
 export declare const caretAt: (edytor: Edytor, text: Text | null | undefined, offset: number) => void;
 /** Re-project an attempt's anchored target when it runs later than its admission. */
 export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
-    projection: import("./selection").SelectionProjection;
+    projection: import("./selection.js").SelectionProjection;
     isCollapsed: boolean;
     /** The admitted mark-edge side of a caret. */
-    edge: import("./editing/text").EdgeSide | undefined;
+    edge: import("./editing/text.js").EdgeSide | undefined;
     isVoidEditableElement: boolean;
     startText: Text | null;
     endText: Text | null;
@@ -146,7 +155,7 @@ export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
     yEnd: number;
     texts: Text[];
     /** The anchored target, fixed at admission. */
-    target: import("./selection").SelectionValue;
+    target: import("./selection.js").SelectionValue;
 } & {
     id: number;
     /** The intent, fixed at admission. */
@@ -158,6 +167,7 @@ export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
     dataTransfer: DataTransfer | null;
     hasDataTransferTextPayload: boolean;
     declared: StaticRange | null;
+    placement: DropAt | null;
     /** Admitted from a keydown (the key's intent wins; the browser may never announce it). */
     isStructuralKeyFallback: boolean;
     owner: "model" | "browser";

package/dist/session/attempt.js

@@ -119,6 +119,7 @@ export const attemptOf = (edytor, occurrence, keyIntent) => {
         dataTransfer: occurrence.dataTransfer ?? null,
         hasDataTransferTextPayload: payload !== null,
         declared: occurrence.declared ?? null,
+        placement: occurrence.placement ?? null,
         isStructuralKeyFallback: Boolean(keyIntent),
         owner: 'model',
         expect: null,

package/dist/session/bindings.js

@@ -119,41 +119,44 @@ const moveRoots = (edytor, blocks, direction) => {
         .flatMap((moved) => moved ?? []);
 };
 /**
- * Tab / Shift+Tab: nest or unnest the selected block, or the caret's block.
+ * Tab / Shift+Tab, with `allowNesting`: nest or unnest the selected block, or the caret's block.
  * Selected blocks, or the blocks a text range spans, move one level per
  * group of siblings, a selected block's selected descendants with it, as
  * one command; the selection stays (its anchors moved with the blocks).
  */
-const nest = (operation) => ({ edytor, prevent }) => prevent(() => {
-    const { selection } = edytor;
-    const { value } = selection;
-    const direction = operation === 'nestBlock' ? 'in' : 'out';
-    const blocks = getSelectionBlocks(edytor);
-    if (blocks.length > 1) {
-        if (moveRoots(edytor, blocks, direction).length)
-            selection.select(value);
-        return;
-    }
-    const [selected] = selection.selectedBlocks;
-    const at = selection.textAt(selection.projection.start);
-    const block = selected ?? at?.text.parent;
-    if (!block)
-        return;
-    // Into the block before it; the view's move reveals a closed toggle it lands in or that adopts.
-    const into = block.previousBlock;
-    if (operation === 'nestBlock' && !into)
-        return edytor.dispatcher.record({ operation, status: 'refused' });
-    const result = operation === 'unNestBlock'
-        ? edytor.unNestBlock(block.id)
-        : edytor.nestBlock(block.id, into.id);
-    if (result.status !== 'applied')
-        return;
-    edytor.announcer.moved({ blocks: [block], direction }, [block]);
-    if (selected)
-        selection.select(blockSelection([block.id]));
-    else if (at)
-        caretAt(edytor, block.content[at.text.index], at.offset);
-});
+const nest = (operation) => ({ edytor, prevent }) => 
+// Nesting off (`allowNesting`, the default): the key is not the editor's, the browser moves the focus on.
+edytor.allowNesting &&
+    prevent(() => {
+        const { selection } = edytor;
+        const { value } = selection;
+        const direction = operation === 'nestBlock' ? 'in' : 'out';
+        const blocks = getSelectionBlocks(edytor);
+        if (blocks.length > 1) {
+            if (moveRoots(edytor, blocks, direction).length)
+                selection.select(value);
+            return;
+        }
+        const [selected] = selection.selectedBlocks;
+        const at = selection.textAt(selection.projection.start);
+        const block = selected ?? at?.text.parent;
+        if (!block)
+            return;
+        // Into the block before it; the view's move reveals a closed toggle it lands in or that adopts.
+        const into = block.previousBlock;
+        if (operation === 'nestBlock' && !into)
+            return edytor.dispatcher.record({ operation, status: 'refused' });
+        const result = operation === 'unNestBlock'
+            ? edytor.unNestBlock(block.id)
+            : edytor.nestBlock(block.id, into.id);
+        if (result.status !== 'applied')
+            return;
+        edytor.announcer.moved({ blocks: [block], direction }, [block]);
+        if (selected)
+            selection.select(blockSelection([block.id]));
+        else if (at)
+            caretAt(edytor, block.content[at.text.index], at.offset);
+    });
 /**
  * Backspace/Delete over an editor-owned selection: the selected atom, or
  * the selected blocks (the caret lands at the end of the block before them).

package/dist/session/commands.js

@@ -458,6 +458,8 @@ export class Dispatcher {
      */
     operate = (operation, args) => {
         const { edytor } = this;
+        // The property writes queued in this task go first (`session/props`).
+        edytor.dataWrites.flush();
         const own = edytor.facade.prepare[operation];
         const prepare = (a) => {
             if (operation === 'insertText' && a[3] === undefined)

package/dist/session/history.js

@@ -114,6 +114,7 @@ export class History {
     replay = (command) => !this.edytor.dispatcher.permits() ? 'refused' : this.#run(command) ? 'applied' : 'noop';
     #run(command) {
         const { undoManager: um, transaction: key, selection, facade } = this.edytor;
+        this.edytor.dataWrites.flush(); // this task's property writes are a step first
         this.#open = null;
         // Other writers (remote-apply and repair restores) stand aside while the
         // replay commits: this view's recorded value decides.

package/dist/session/inputRules.d.ts

@@ -3,9 +3,12 @@
  * (`## ` → a heading, `:smile:` → 😄). The one engine behind every
  * plugin's `inputRules`: it reads the typed text and the caret, finds the
  * first rule whose `find` ends at the typed text, and replaces the typed
- * `insertText` with the rule's replacement — a command of its own, the
- * matched text's removal leading its first operation (`dispatcher.lead`), so
- * a refusal of either writes neither and the typed text lands as typed.
+ * `insertText` with two steps: the typed text as typed (an insertion, which
+ * may continue the typing before it), then the rule's replacement, a command
+ * of its own whose first operation the matched text's removal leads
+ * (`dispatcher.lead`), so a refusal of either writes neither and the typed
+ * text stays as typed. The first undo gives the typed text back, the
+ * caret after it (as the autolink does).
  */
 import type { Block } from '../block/block.svelte.js';
 import type { Edytor } from '../edytor.svelte.js';

package/dist/session/inputRules.js

@@ -57,7 +57,8 @@ export const inputRulesHook = (edytor, rules) => {
             /** The match's start in the segment; the match in the block, `from` to the caret. */
             const start = match.index;
             const from = text.segStart + start;
-            const to = text.segStart + yStart;
+            // The typed text is in the document: the match ends after it.
+            const to = text.segStart + yStart + value.length;
             let removed = null;
             /** Remove the match in the same plan as `then`'s first operation: `ctx.remove`. */
             const remove = (then) => {
@@ -104,12 +105,15 @@ export const inputRulesHook = (edytor, rules) => {
         prevent(() => {
             running = true;
             try {
+                // The typed text first, a step the replacement does not join.
+                const last = dispatcher.last;
+                typeAsIs();
+                if (dispatcher.last === last || dispatcher.last?.status !== 'applied')
+                    return;
                 for (const { rule, match } of matches) {
-                    const written = apply(rule, match);
-                    if (written !== null)
-                        return written || typeAsIs();
+                    if (apply(rule, match) !== null)
+                        return;
                 }
-                typeAsIs();
             }
             finally {
                 running = false;

package/dist/session/moves.d.ts

@@ -25,6 +25,17 @@ export type BlockMoveRequest = {
 } | {
     direction: BlockMoveDirection;
 });
+/**
+ * The view's nesting rule (`allowNesting`, off by default): whether a user
+ * gesture may place `blocks` under `parent`. With nesting off, blocks land
+ * only at the root or in a block made to hold children — a container (a
+ * list, a column, a toggle's or a callout's body: `isContainer`, the kind's
+ * `container`), an island (a code block's lines) — or stay under the parent
+ * they already have (a document holding nested blocks still edits them).
+ * Every move (`destination`: keys, drops, menus, `edytor.move`) and every
+ * new block a drop places (`canPlaceNew`) reads it.
+ */
+export declare const nestsInto: (edytor: Edytor, parent: Block, blocks?: readonly Block[]) => boolean;
 /** Whether the move is allowed: for runs (`parts`), whether one of them may move. */
 export declare const canMove: (edytor: Edytor, request: BlockMoveRequest) => boolean;
 /**
@@ -38,3 +49,25 @@ export declare const canMove: (edytor: Edytor, request: BlockMoveRequest) => boo
  * (`announcer.moved`).
  */
 export declare const move: (edytor: Edytor, request: BlockMoveRequest) => Block[];
+/** A new block a drop places (`placeNew`): its kind, and its id when the caller names it. */
+export type NewBlock = {
+    type: string;
+    id?: string;
+};
+/**
+ * Whether new blocks of `kinds` may land at `target`'s `position` (a file
+ * dropped there, `placeNew`): the move's places (`destination`) asked of
+ * blocks not yet in the document — the container rule (`fits`) of the
+ * parent they land in, never inside a void or an island; beside, a layout
+ * kind and a target outside any island (`placeBeside` takes any block a
+ * column holds).
+ */
+export declare const canPlaceNew: (edytor: Edytor, kinds: readonly string[], target: Block, position: BlockMovePosition) => boolean;
+/**
+ * Insert new blocks at `target`'s `position` (a file drop's placement):
+ * before or after it, inside it (its last children), or beside it — inserted
+ * after the block it stands beside (`besideAt`) and moved there by the one
+ * move path (`layout.place-beside`) — in one transaction. The caller's
+ * command makes it one undo step. Answers the ids placed (none: refused).
+ */
+export declare const placeNew: (edytor: Edytor, blocks: readonly NewBlock[], target: Block, position: BlockMovePosition) => string[];

package/dist/session/moves.js

@@ -24,6 +24,22 @@ const placement = (edytor, request) => {
     return step?.[0] ? { blocks, target: step[0], position: step[1] } : null;
 };
 const POSITIONS = ['before', 'after', 'inside', ...BESIDE];
+/**
+ * The view's nesting rule (`allowNesting`, off by default): whether a user
+ * gesture may place `blocks` under `parent`. With nesting off, blocks land
+ * only at the root or in a block made to hold children — a container (a
+ * list, a column, a toggle's or a callout's body: `isContainer`, the kind's
+ * `container`), an island (a code block's lines) — or stay under the parent
+ * they already have (a document holding nested blocks still edits them).
+ * Every move (`destination`: keys, drops, menus, `edytor.move`) and every
+ * new block a drop places (`canPlaceNew`) reads it.
+ */
+export const nestsInto = (edytor, parent, blocks = []) => edytor.allowNesting ||
+    parent.isRoot ||
+    parent.isContainer ||
+    !!parent.definition.container ||
+    edytor.facade.isIsland(parent.id) ||
+    (blocks.length > 0 && blocks.every((block) => block.parent === parent));
 /**
  * The document write a move request is, or `null` when refused: a
  * well-formed request, then the document's one structural answer
@@ -59,7 +75,7 @@ const destination = (edytor, request) => {
             ? { blocks, write: () => edytor.unNestBlocks(ids) }
             : null;
     const to = parent?.isRoot ? null : parent?.id;
-    if (!parent || !edytor.facade.canPlace(ids, to))
+    if (!parent || !nestsInto(edytor, parent, blocks) || !edytor.facade.canPlace(ids, to))
         return null;
     const at = position === 'inside' ? parent.children.length : target.index + (position === 'after' ? 1 : 0);
     // The document counts the destination's children without the moved blocks.
@@ -122,3 +138,57 @@ const place = (edytor, request) => {
     const result = move.write();
     return result.status === 'applied' ? move.blocks : [];
 };
+/**
+ * Whether new blocks of `kinds` may land at `target`'s `position` (a file
+ * dropped there, `placeNew`): the move's places (`destination`) asked of
+ * blocks not yet in the document — the container rule (`fits`) of the
+ * parent they land in, never inside a void or an island; beside, a layout
+ * kind and a target outside any island (`placeBeside` takes any block a
+ * column holds).
+ */
+export const canPlaceNew = (edytor, kinds, target, position) => {
+    const { facade } = edytor;
+    if (edytor.readonly || !kinds.length || !target.isInTree || target.isRoot)
+        return false;
+    if (!POSITIONS.includes(position) || facade.insideIsland(target.id))
+        return false;
+    if (isBeside(position))
+        return ([...edytor.blocks.values()].some((definition) => definition.layout) &&
+            !facade.isIsland(target.id));
+    const parent = position === 'inside' ? target : target.parent;
+    if (!parent || !nestsInto(edytor, parent))
+        return false;
+    const to = parent.isRoot ? null : parent.id;
+    if (to !== null && (facade.isVoid(to) || facade.isIsland(to)))
+        return false;
+    return kinds.every((kind) => facade.fits(to, kind));
+};
+/**
+ * Insert new blocks at `target`'s `position` (a file drop's placement):
+ * before or after it, inside it (its last children), or beside it — inserted
+ * after the block it stands beside (`besideAt`) and moved there by the one
+ * move path (`layout.place-beside`) — in one transaction. The caller's
+ * command makes it one undo step. Answers the ids placed (none: refused).
+ */
+export const placeNew = (edytor, blocks, target, position) => {
+    const kinds = blocks.map((block) => block.type);
+    if (!canPlaceNew(edytor, kinds, target, position))
+        return [];
+    const beside = isBeside(position);
+    const at = beside ? (edytor.idToBlock.get(edytor.facade.besideAt(target.id)) ?? target) : target;
+    const parent = position === 'inside' ? target : at.parent;
+    const destination = position === 'inside'
+        ? { parent: target.id, index: target.children.length }
+        : {
+            parent: !parent || parent.isRoot ? null : parent.id,
+            index: at.index + (position === 'before' ? 0 : 1)
+        };
+    return edytor.transact(() => {
+        const { ids } = edytor.insertBlocks(destination, blocks.map((block) => ({ ...block })));
+        if (!beside || !ids.length)
+            return [...ids];
+        const placed = ids.flatMap((id) => edytor.idToBlock.get(id) ?? []);
+        move(edytor, { blocks: placed, target, position });
+        return [...ids];
+    });
+};

package/dist/session/navigation.d.ts

@@ -23,6 +23,7 @@
  * lands it on no caret stop (`landed`).
  */
 import type { Edytor } from '../edytor.svelte.js';
+import type { Block } from '../block/block.svelte.js';
 import type { HotKey } from './keymap.js';
 /**
  * With no target (`untargeted`: the value is `none`, no gesture placed the
@@ -48,6 +49,12 @@ export declare const move: (edytor: Edytor, unit: Unit, key: Dir | "left" | "rig
  * moves keep the goal column. Answers whether a text selection moved.
  */
 export declare const extendVertically: (edytor: Edytor, dir: Dir) => boolean;
+/**
+ * The block a collapsed text caret sits on the last line of (a line box
+ * where the view lays one out, else a line break), if it does: where
+ * ArrowDown leaves the block (`nav.trailing.exit`, `body.down`).
+ */
+export declare const onLastLine: (edytor: Edytor) => Block | undefined;
 /**
  * The trailing paragraph (`nav.trailing`, Notion): the caret goes to an
  * empty top-level block of the root's default kind after the document's

package/dist/session/navigation.js

@@ -255,21 +255,30 @@ const stopBelow = (edytor, block) => {
  * cell, a code line, a heading). Never in a view that writes nothing.
  */
 const leavesLastStop = (edytor) => {
-    const { selection, root } = edytor;
-    const { value, projection } = selection;
-    const at = projection.start;
-    const block = at && edytor.idToBlock.get(at.block);
-    if (value.kind !== 'text' || !projection.isCollapsed || !block || !root)
-        return false;
-    if (!edytor.dispatcher.permits())
+    const block = onLastLine(edytor);
+    const { root } = edytor;
+    if (!block || !root || !edytor.dispatcher.permits())
         return false;
     if (block.parent?.isRoot && block.type === edytor.defaultChild(root))
         return false;
+    return !stopBelow(edytor, block.id);
+};
+/**
+ * The block a collapsed text caret sits on the last line of (a line box
+ * where the view lays one out, else a line break), if it does: where
+ * ArrowDown leaves the block (`nav.trailing.exit`, `body.down`).
+ */
+export const onLastLine = (edytor) => {
+    const { value, projection } = edytor.selection;
+    const at = projection.start;
+    const block = at && edytor.idToBlock.get(at.block);
+    if (value.kind !== 'text' || !projection.isCollapsed || !block)
+        return;
     const text = stringOf(edytor, at.block);
     if (text.includes('\n', at.offset))
-        return false;
-    return (edytor.ports.surface.sameLine(at, { block: at.block, offset: text.length }) !== false &&
-        !stopBelow(edytor, at.block));
+        return;
+    const last = edytor.ports.surface.sameLine(at, { block: at.block, offset: text.length });
+    return last === false ? undefined : block;
 };
 /**
  * The trailing paragraph (`nav.trailing`, Notion): the caret goes to an

package/dist/session/props.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A view's property writes (`block.data`, `atom.data`, `edytor.data`): the
+ * data proxy (`crdt/props.ts`) over the view's one write path.
+ *
+ * The writes of one synchronous task are one dispatch: they queue per
+ * target and leave on the next microtask, or before any other operation
+ * this view dispatches, as the `patchData` operation of each target (more
+ * than one target: one user command, so one undo step, in one
+ * transaction). Hooks see that operation; a veto drops the burst. Until
+ * then the proxy reads its target's data with the queued patches applied
+ * (`dataPreview`), so a write reads back at once. A view that refuses
+ * writes (readonly, a read-only document) refuses an assignment at once:
+ * nothing is queued, the dispatcher records `refused`, nothing throws.
+ */
+import type { DataPatch } from '../crdt/data.js';
+import type { DataTarget } from '../crdt/doc/types.js';
+import type { Edytor } from '../edytor.svelte.js';
+export declare class DataWrites {
+    #private;
+    private readonly edytor;
+    constructor(edytor: Edytor);
+    /** The live proxy over `target`'s data; `read` is its reactive, committed source. */
+    proxy<T extends object>(target: DataTarget, read: () => Record<string, unknown>): T;
+    /** Queue `patches` on `target` for this task's dispatch (refused at once when the view refuses writes). */
+    write(target: DataTarget, patches: DataPatch[]): undefined;
+    /** Dispatch the queued writes now: before any other operation of this view, and at the end of the task. */
+    flush(): undefined;
+}

package/dist/session/props.js

@@ -0,0 +1,65 @@
+import { propsProxy } from '../crdt/props.js';
+const keyOf = (target) => JSON.stringify(target);
+export class DataWrites {
+    edytor;
+    #pending = new Map();
+    #scheduled = false;
+    constructor(edytor) {
+        this.edytor = edytor;
+    }
+    /** The live proxy over `target`'s data; `read` is its reactive, committed source. */
+    proxy(target, read) {
+        let preview;
+        const pending = () => this.#pending.get(keyOf(target));
+        const current = () => {
+            const base = read();
+            const queued = pending();
+            if (!queued)
+                return base;
+            const { version } = this.edytor.facade;
+            const count = queued.patches.length;
+            if (preview?.version !== version || preview.count !== count) {
+                const seen = this.edytor.facade.dataPreview(target, queued.patches);
+                preview = { version, count, data: seen?.data ?? null };
+            }
+            return preview.data ?? base;
+        };
+        return propsProxy(current, (patches) => this.write(target, patches), (path) => {
+            const queued = pending();
+            return queued
+                ? (this.edytor.facade.dataPreview(target, queued.patches)?.ids(path) ?? [])
+                : this.edytor.facade.dataItemIds(target, path);
+        });
+    }
+    /** Queue `patches` on `target` for this task's dispatch (refused at once when the view refuses writes). */
+    write(target, patches) {
+        const { edytor } = this;
+        if (!edytor.dispatcher.permits())
+            return void edytor.patchData(target, patches);
+        const key = keyOf(target);
+        const queued = this.#pending.get(key);
+        if (queued)
+            queued.patches.push(...patches);
+        else
+            this.#pending.set(key, { target, patches: [...patches] });
+        if (this.#scheduled)
+            return;
+        this.#scheduled = true;
+        queueMicrotask(() => {
+            this.#scheduled = false;
+            if (!edytor.destroyed)
+                this.flush();
+        });
+    }
+    /** Dispatch the queued writes now: before any other operation of this view, and at the end of the task. */
+    flush() {
+        if (this.#pending.size === 0)
+            return;
+        const all = [...this.#pending.values()];
+        this.#pending.clear();
+        const { edytor } = this;
+        if (all.length === 1)
+            return void edytor.patchData(all[0].target, all[0].patches);
+        edytor.dispatcher.run('patchData', () => edytor.transact(() => all.forEach(({ target, patches }) => edytor.patchData(target, patches))));
+    }
+}