edytor 0.1.0-next.36 → 0.1.0-next.40

package/README.md

@@ -10,20 +10,22 @@
 <p>
     <a href="https://edytor.dev/docs">Documentation</a> •
     <a href="#quick-start">Quick start</a> •
-    <a href="https://edytor.dev/docs/reference/migration">Migrating from 0.0.11</a>
+    <a href="https://edytor.dev/docs/reference/migration">Changelog</a>
   </p>
 </div>
 
 Edytor aims to be for Svelte what Slate.js is for React: a heavily customizable editor with an API to build any kind of collaborative rich text editor.
 
-> **Work in progress.** Edytor is a pre-release (`0.1.0-next.36`, `edytor@next` on npm) and not ready for production; the API changes between releases without a compatibility layer. The untagged `edytor@0.0.11` on npm predates the current API. Issues and PRs are welcome: when you report a bug, include the document's JSON value.
+> **Work in progress.** Edytor is a pre-release (`0.1.0-next.40`, `edytor@next` on npm) and not ready for production; the API changes between releases without a compatibility layer. The untagged `edytor@0.0.11` on npm predates the current API. Issues and PRs are welcome: when you report a bug, include the document's JSON value.
 
 ## Features
 
 - **Notion-style editing out of the box.** `<Edytor />` alone is a rich text editor with images and block handles: headings, toggle headings, lists, to-dos, toggles, callouts, quotes, dividers, ten marks and Notion's hotkeys. Add the Notion theme, a block menu (block colours; drag one block, or every block the selection covers), a slash menu, a selection toolbar, markdown shortcuts (`markdownShortcutsPlugin`) and code blocks.
 - **Pages and a table of contents, opt-in.** `createPagePlugin` links a block to another document (a page per room, opened and named by your app), and `tocPlugin` lists the headings live ([Page](https://edytor.dev/docs/plugins/page), [Table of contents](https://edytor.dev/docs/plugins/table-of-contents)).
 - **Columns, opt-in.** List `columnsPlugin` for Notion's multi-column layouts: drag a block to the edge of another to put them side by side, or pick "2 columns" to "5 columns"; drag the gap to resize. Layouts converge across collaborators and the room ([Columns](https://edytor.dev/docs/plugins/columns)).
+- **Tables, opt-in.** List `tablePlugin` for Notion's simple table: cells of text, <kbd>Tab</kbd> between them, rows and columns added, moved and deleted from the table's edges and grips, resizable columns, header row and column, HTML tables pasted and copied. Concurrent row and column edits converge on every replica ([Table](https://edytor.dev/docs/plugins/table)).
 - **Mentions, page links and your own triggers.** `createMentionPlugin` (`@` people) and `createPageLinkPlugin` (`[[` pages) take your app's search; a plugin's `inputRules` (`:smile:` → 😄) and `triggers` (a menu on a typed character) declare the rest ([Input rules and triggers](https://edytor.dev/docs/plugins/input-rules)).
+- **Comments, opt-in.** `createCommentsPlugin` adds Notion's comment threads: select text, press Comment, and the thread shows in a sidebar beside it with replies, Resolve and Re-open. The room keeps the threads beside the document and sends each change live; the anchor follows the text through edits and is not copied ([Comments](https://edytor.dev/docs/plugins/comments)).
 - **Your markup.** Blocks, marks and inline atoms render through your Svelte snippets; the slash menu, toolbar, block menu and handles take a snippet and keep their behavior.
 - **Your language.** Every word the chrome shows or says, slash keywords included, comes from a labels dictionary each plugin takes; English by default ([Localization](https://edytor.dev/docs/customization/localization)).
 - **Synced properties.** `block.data`, `atom.data` and `edytor.data` read and write like plain objects (`bind:value={block.data.title}`); each property and each array item syncs on its own, so concurrent edits of different properties, or of different items of one array, merge.
@@ -102,11 +104,11 @@ The [documentation site](https://edytor.dev/docs) is the single source for the A
 - [Editor](https://edytor.dev/docs/editor/edytor-component): the component, commands, selection, history, clipboard, readonly
 - [Plugins](https://edytor.dev/docs/plugins) and [customization](https://edytor.dev/docs/customization/blocks): bundled plugins, custom blocks and marks, [hotkeys and editing behavior](https://edytor.dev/docs/customization/hotkeys)
 - [Collaboration](https://edytor.dev/docs/collaboration) and [server](https://edytor.dev/docs/server/quick-start): documents, providers, presence, the Durable Object room and its protocol
-- [Reference](https://edytor.dev/docs/reference/document-api): the document API, [troubleshooting](https://edytor.dev/docs/reference/troubleshooting), [migration from 0.0.11](https://edytor.dev/docs/reference/migration), limitations, [platform support](https://edytor.dev/docs/reference/platform-support)
+- [Reference](https://edytor.dev/docs/reference/document-api): the document API, [troubleshooting](https://edytor.dev/docs/reference/troubleshooting), the [changelog](https://edytor.dev/docs/reference/migration) (with [migration from 0.0.11](https://edytor.dev/docs/reference/migration#upgrading-from-0011)), [importing v13 documents](https://edytor.dev/docs/reference/v13-import), limitations, [platform support](https://edytor.dev/docs/reference/platform-support)
 
 ## Contributing
 
-`CONTRIBUTING.md` lists the test lanes, what CI runs, and the pull request checklist; `AGENTS.md` describes the architecture (one owner per fact) and where to fix what. The docs live in `site/content/docs`; a change to public behavior updates them in the same commit.
+`CONTRIBUTING.md` lists the test lanes, what CI runs, and the pull request checklist; `AGENTS.md` describes the architecture (one owner per fact) and where to fix what, and `docs/agents/` holds the rules of each area. The docs live in `site/content/docs`; a change to public behavior updates them in the same commit.
 
 ```bash
 pnpm install

package/dist/block/block.svelte.d.ts

@@ -1,18 +1,22 @@
 import { Text } from '../text/text.svelte.js';
-import { Edytor } from '../edytor.svelte.js';
+import type { Edytor } from '../edytor.svelte.js';
 import type { JSONBlock, JSONText, JSONInlineBlock } from '../utils/json.js';
 import { type BlockOperations } from './block.utils.js';
 import type { BlockDefinition } from '../plugins.js';
 import { InlineBlock } from './inlineBlock.svelte.js';
 import type { DocBlock } from '../crdt/index.js';
-/**
- * An id-only block handle (§2.4 "Handles", R4): every getter reads the
- * document index (transaction-aware), every mutator issues a command. The
- * view keeps one per id (`edytor.idToBlock`); `node` is the element the core
- * renders for it (O45).
- */
 /** Mark an element inside a block's markup as non-editable chrome (`block.void`, a preview's too). */
 export declare const voidChrome: (node: HTMLElement) => void;
+/**
+ * An id-only block handle: every getter reads the document index
+ * (transaction-aware), every mutator issues a command. The view keeps one per
+ * id (`edytor.idToBlock`); `node` is the element the core renders for it.
+ *
+ * A reactive reader (a template, a `$derived`, an `$effect`) of a getter
+ * depends on the cells the answer comes from (this block's, its parent's,
+ * the root's list), so it re-runs when a commit changes them, as `data`
+ * does; a read anywhere else is a plain read of the document.
+ */
 export declare class Block {
     #private;
     readonly: boolean;
@@ -60,13 +64,6 @@ export declare class Block {
     get path(): number[];
     /** The block is visible in the document (a dead handle answers false). */
     get isInTree(): boolean;
-    /**
-     * @deprecated `edytor.suggestions` with `{ end: block.id }`. The content of
-     * this block's latest `end` suggestion, as parts (a text's runs, or an
-     * atom); setting it replaces this block's `end` suggestions, `null` drops them.
-     */
-    get suggestions(): (JSONText[] | JSONInlineBlock)[] | null;
-    set suggestions(value: (JSONText[] | JSONInlineBlock)[] | null);
     get nextBlock(): Block | null;
     get previousBlock(): Block | null;
     get closestPreviousBlock(): Block | null;
@@ -173,10 +170,6 @@ export declare class Block {
     }) => Text | null | undefined;
     normalizeContent: () => void;
     normalizeChildren: () => void;
-    /** @deprecated `edytor.suggestions.add({ end: block.id }, …)`. */
-    suggestText: (payload: BlockOperations["suggestText"]) => void;
-    /** @deprecated `suggestion.accept()`. */
-    acceptSuggestedText: () => void;
     deleteContentAtRange: (payload: {
         start: [number, number];
         end: [number, number];

package/dist/block/block.svelte.js

@@ -1,22 +1,25 @@
 import { Text } from '../text/text.svelte.js';
-import { Edytor } from '../edytor.svelte.js';
-import { batch, removeInlineBlock, addChildBlock, insertBlockAfter, insertBlockBefore, mergeBlockBackward, mergeBlockForward, nestBlock, removeBlock, setBlock, splitBlock, prepareSplit, duplicateBlock, prepareDuplicate, prepareSet, prepareMove, prepareMoves, prepareInsertAfter, prepareInsertBefore, prepareRemove, prepareMergeBackward, prepareMergeForward, prepareUnNest, prepareNest, prepareRemoveInline, preparePatch, patchData, prepareDeleteRange, addChildBlocks, pushContentIntoBlock, unNestBlock, moveBlock, moveBlocks, normalizeContent, addInlineBlock, textAfterAtom, blockOf, acceptSuggestedText, suggestText, deleteContentAtRange, normalizeChildren } from './block.utils.js';
+import { batch, removeInlineBlock, addChildBlock, insertBlockAfter, insertBlockBefore, mergeBlockBackward, mergeBlockForward, nestBlock, removeBlock, setBlock, splitBlock, prepareSplit, duplicateBlock, prepareDuplicate, prepareSet, prepareMove, prepareMoves, prepareInsertAfter, prepareInsertBefore, prepareRemove, prepareMergeBackward, prepareMergeForward, prepareUnNest, prepareNest, prepareRemoveInline, preparePatch, patchData, prepareDeleteRange, addChildBlocks, pushContentIntoBlock, unNestBlock, moveBlock, moveBlocks, normalizeContent, addInlineBlock, textAfterAtom, blockOf, deleteContentAtRange, normalizeChildren } from './block.utils.js';
 import { jsonBlockToSpec, jsonContentToItems } from '../utils/json.js';
 import { InlineBlock } from './inlineBlock.svelte.js';
 import { revealed } from '../selection/replaceSelection.js';
 import { propsProxy } from '../session/props.js';
-/**
- * An id-only block handle (§2.4 "Handles", R4): every getter reads the
- * document index (transaction-aware), every mutator issues a command. The
- * view keeps one per id (`edytor.idToBlock`); `node` is the element the core
- * renders for it (O45).
- */
 /** Mark an element inside a block's markup as non-editable chrome (`block.void`, a preview's too). */
 export const voidChrome = (node) => {
     node.setAttribute('data-edytor-void', `true`);
     node.style.userSelect = 'none';
     node.setAttribute('contenteditable', 'false');
 };
+/**
+ * An id-only block handle: every getter reads the document index
+ * (transaction-aware), every mutator issues a command. The view keeps one per
+ * id (`edytor.idToBlock`); `node` is the element the core renders for it.
+ *
+ * A reactive reader (a template, a `$derived`, an `$effect`) of a getter
+ * depends on the cells the answer comes from (this block's, its parent's,
+ * the root's list), so it re-runs when a commit changes them, as `data`
+ * does; a read anywhere else is a plain read of the document.
+ */
 export class Block {
     readonly = false;
     edytor;
@@ -29,21 +32,43 @@ export class Block {
     get isRoot() {
         return this.id === 'root';
     }
+    /**
+     * Under a reactive reader, depend on block `id`'s cell (the root: its
+     * child list): the commit that patches it re-runs the reader. A cell
+     * that goes away (the block died) re-runs it too.
+     */
+    #track(id = this.id) {
+        if (!$effect.tracking())
+            return;
+        const cells = this.edytor.cells;
+        if (id === 'root')
+            void cells?.rootIds;
+        else
+            cells?.get(id);
+    }
     /** The typed document node — `null` for the root. */
     get model() {
         return this.isRoot ? null : this.edytor.facade.block(this.id);
     }
     /** The display parent (the root for a top-level block); none for the root or a dead block. */
     get parent() {
-        const at = this.isRoot ? null : this.edytor.facade.positionOf(this.id);
+        if (this.isRoot)
+            return undefined;
+        this.#track();
+        const at = this.edytor.facade.positionOf(this.id);
+        // The parent's child list names this block: a move patches it.
+        if (at)
+            this.#track(at.parent ?? 'root');
         return at ? this.edytor.idToBlock.block(at.parent ?? 'root') : undefined;
     }
     get children() {
+        this.#track();
         const { facade, idToBlock } = this.edytor;
         return facade.childrenIds(this.isRoot ? null : this.id).map(idToBlock.block);
     }
     /** Text segments and inline atoms, alternating, starting and ending with a text. */
     get content() {
+        this.#track();
         const handles = this.edytor.idToBlock;
         let ordinal = 0;
         return handles
@@ -53,7 +78,10 @@ export class Block {
             : handles.atom(this.id, part.item.id));
     }
     get type() {
-        return this.isRoot ? 'root' : (this.edytor.facade.blockTypeOf(this.id) ?? '');
+        if (this.isRoot)
+            return 'root';
+        this.#track();
+        return this.edytor.facade.blockTypeOf(this.id) ?? '';
     }
     /** Retype the block — the `setBlock` command (readonly, hooks, `dispatcher.last`). */
     set type(value) {
@@ -139,7 +167,13 @@ export class Block {
         return undefined;
     }
     get index() {
-        return (!this.isRoot && this.edytor.facade.positionOf(this.id)?.index) || 0;
+        if (this.isRoot)
+            return 0;
+        const at = this.edytor.facade.positionOf(this.id);
+        this.#track();
+        if (at)
+            this.#track(at.parent ?? 'root');
+        return at?.index || 0;
     }
     get depth() {
         return this.parent ? this.parent.depth + 1 : 0;
@@ -155,33 +189,10 @@ export class Block {
     }
     /** The block is visible in the document (a dead handle answers false). */
     get isInTree() {
-        return this.isRoot || this.edytor.facade.isVisibleBlock(this.id);
-    }
-    /**
-     * @deprecated `edytor.suggestions` with `{ end: block.id }`. The content of
-     * this block's latest `end` suggestion, as parts (a text's runs, or an
-     * atom); setting it replaces this block's `end` suggestions, `null` drops them.
-     */
-    get suggestions() {
-        const content = this.edytor.suggestions?.at(this.id).end.at(-1)?.content[0]?.content;
-        if (!content?.length)
-            return null;
-        const parts = [];
-        for (const part of content)
-            if ('type' in part)
-                parts.push(part);
-            else if (Array.isArray(parts.at(-1)))
-                parts.at(-1).push(part);
-            else
-                parts.push([part]);
-        return parts;
-    }
-    set suggestions(value) {
-        const { suggestions } = this.edytor;
-        for (const suggestion of suggestions.at(this.id).end)
-            suggestion.discard();
-        if (value)
-            suggestions.add({ end: this.id }, [{ type: this.type, content: value.flat() }]);
+        if (this.isRoot)
+            return true;
+        this.#track();
+        return this.edytor.facade.isVisibleBlock(this.id);
     }
     get nextBlock() {
         return this.parent ? this.parent.children[this.index + 1] : null;
@@ -211,6 +222,9 @@ export class Block {
     }
     /** This block's JSON — the document's one serializer (`facade.blockJSON`). */
     get value() {
+        // Its subtree's: every commit re-runs a reactive reader.
+        if ($effect.tracking())
+            void this.edytor.valueRevision;
         if (!this.isRoot)
             return this.edytor.facade.blockJSON(this.id);
         const { data = {}, children } = this.edytor.facade.toJSON();
@@ -310,10 +324,6 @@ export class Block {
     };
     normalizeContent = batch('normalizeContent', normalizeContent);
     normalizeChildren = batch('normalizeChildren', normalizeChildren);
-    /** @deprecated `edytor.suggestions.add({ end: block.id }, …)`. */
-    suggestText = (payload) => suggestText.call(this, payload);
-    /** @deprecated `suggestion.accept()`. */
-    acceptSuggestedText = () => acceptSuggestedText.call(this);
     deleteContentAtRange = batch('deleteContentAtRange', deleteContentAtRange, prepareDeleteRange);
     /** Mark an element inside the block's markup as non-editable chrome (a header, a caption bar). */
     void = voidChrome;
@@ -342,7 +352,7 @@ export class Block {
         }
         return hit;
     };
-    // ── JSON insertion (K5: specs are data; `new Block({block})` is gone) ──
+    // ── JSON insertion (specs are data; `new Block({block})` is gone) ──
     /**
      * Insert children at `index`: a JSON spec is created (its id kept, minted
      * when missing); a block handle moves there with its identity.
@@ -385,9 +395,9 @@ export class Block {
     /** The declared view state (`open` on a `details`) the block's last element held. */
     #viewState = [];
     /**
-     * Register the element the core rendered for this block (O45) and run the
+     * Register the element the core rendered for this block and run the
      * attach hooks. A re-rendered block (moved, re-parented) keeps its declared
-     * view state (R11): an open toggle stays open.
+     * view state: an open toggle stays open.
      * @internal
      */
     attach = (node) => {
@@ -398,6 +408,8 @@ export class Block {
                 node.setAttribute(name, value);
         this.node = node;
         const release = this.edytor.surface.register(node, 'block', this.id);
+        // A block laid out again with no commit moves the chrome beside it (the overlay measures).
+        const unobserve = this.edytor.overlay.observe(node);
         const onDestroy = this.edytor.plugins.flatMap((plugin) => {
             const action = plugin.onBlockAttached?.({ node, block: this });
             return typeof action === 'function' ? [action] : [];
@@ -408,6 +420,7 @@ export class Block {
                 if (this.node === node)
                     this.node = undefined;
                 release();
+                unobserve();
                 onDestroy.forEach((destroy) => destroy());
             }
         };

package/dist/block/block.utils.d.ts

@@ -1,5 +1,5 @@
 /**
- * View-side command adapter for block operations (U2 delegation contract).
+ * View-side command adapter for block operations: each delegates to one document operation.
  *
  * These functions are the `BlockOperations` layer bound onto `Block` via
  * `batch()`, which dispatches each call as a command (admission, plugin
@@ -8,8 +8,8 @@
  * sibling lookup for `nestBlock`), the plan of an operation
  * that is one document op (`prepare*`) and its normalization requests.
  *
- * OPERATIONS READ AND WRITE ONLY THE DOCUMENT (R3): `Block`/`Text` are id-only
- * handles whose getters read the index (R4), so what a caller needs after the
+ * OPERATIONS READ AND WRITE ONLY THE DOCUMENT: `Block`/`Text` are id-only
+ * handles whose getters read the index, so what a caller needs after the
  * write (the new block, the text after an inserted atom, the caret a range op
  * decided) is the op's document result as a handle (`batch`'s `resolve`) —
  * inside an outer transaction too.
@@ -19,13 +19,13 @@
  * as "refused" — no view-side re-checks of the rules the document already
  * enforces (island sealing, void/island destinations, own-subtree moves,
  * merges across island boundaries; see `edytor-doc.ts` `canPlace` and
- * `canMerge`, R5). Removing a view-side semantic guard must never
+ * `canMerge`). Removing a view-side semantic guard must never
  * change document behavior — if a rule matters here it belongs in the
  * facade, not in this file.
  *
  * Content preparation produces `BlockSpec`/`ContentItem` DIRECTLY from
  * JSON (`jsonBlockToSpec`/`jsonContentToItems` in `utils/json.ts`): specs are
- * data (K5: `new Block({block})` is gone). The live-content invariant
+ * data (`new Block({block})` is gone). The live-content invariant
  * (text-first/text-last, no adjacent same-kind parts) is derived by the
  * document's projection on read, so stored content needs no
  * pre-normalization.
@@ -36,7 +36,7 @@ import type { Flow, FlowTarget } from '../crdt/flow.js';
 import type { Plan, Prepared } from '../crdt/edytor-doc.js';
 import type { DataPatch } from '../crdt/data.js';
 import type { ResolvedAt } from '../session/suggestions.svelte.js';
-import { type JSONBlock, type JSONInlineBlock, type JSONText } from '../utils/json.js';
+import { type JSONBlock, type JSONInlineBlock } from '../utils/json.js';
 import { InlineBlock } from './inlineBlock.svelte.js';
 /** A move beside `target`, to its `side` (`prepare.placeBeside`, `layout.place-beside`). */
 export type BlockBeside = {
@@ -108,12 +108,6 @@ export type BlockOperations = {
     };
     normalizeContent: {};
     normalizeChildren: {};
-    /** @deprecated `edytor.suggestions.add({ end: block.id }, …)`. */
-    suggestText: {
-        value: (JSONText | JSONInlineBlock)[] | string | null;
-    };
-    /** @deprecated `suggestion.accept()`; the command hooks see is `acceptSuggestion`. */
-    acceptSuggestedText: {};
     /** A suggestion placed in the document (`edytor.suggestions`, `suggestion.accept()`). */
     acceptSuggestion: {
         suggestion: {
@@ -135,6 +129,19 @@ export type BlockOperations = {
         }[];
         replacement: string;
     };
+    /**
+     * A comment thread's anchor (`plugins/comments`): its `comment:<thread>`
+     * mark over each run of the text it was made on, one plan, one undo step
+     * (its steps: a `formatRange` per run).
+     */
+    addComment: {
+        thread: string;
+        runs: {
+            block: string;
+            offset: number;
+            length: number;
+        }[];
+    };
     deleteContentAtRange: {
         start: [number, number];
         end: [number, number];
@@ -146,6 +153,30 @@ export type BlockOperations = {
         flow: Flow;
         target: FlowTarget;
     };
+    /**
+     * A text range dragged inside the editor and dropped at `to` (block
+     * offsets): its content placed at `to`, then the range deleted — or,
+     * with `copy` (Alt), only placed. Both are prepared before any write:
+     * hooks see the placement's planned steps and the deletion's, and a
+     * veto or a refusal of either writes nothing.
+     */
+    moveText: {
+        from: {
+            start: {
+                block: string;
+                offset: number;
+            };
+            end: {
+                block: string;
+                offset: number;
+            };
+        };
+        to: {
+            block: string;
+            offset: number;
+        };
+        copy: boolean;
+    };
     deleteBlocks: {
         blocks: Block[];
     };
@@ -157,6 +188,38 @@ export type BlockOperations = {
     };
     /** A divider at the caret: its steps are the conversion, insertion or split it plans. */
     insertDivider: {};
+    /** A table's row at `index`, one empty cell per column (`table.insert-row`). */
+    insertTableRow: {
+        index: number;
+    };
+    /** A table's rows, with their cells (`table.delete-row`). */
+    deleteTableRows: {
+        rows: Block[];
+    };
+    /** A table's column at `index`, an empty cell in every row (`table.insert-column`). */
+    insertTableColumn: {
+        index: number;
+        width?: number;
+    };
+    /** A table's column, by id or position, with its cells (`table.delete-column`). */
+    deleteTableColumn: {
+        column: string | number;
+    };
+    /** A table's column moved to position `to` (`table.move-column`). */
+    moveTableColumn: {
+        column: string | number;
+        to: number;
+    };
+    /** A table's rows moved to position `to` among its rows (`table.move-row`). */
+    moveTableRows: {
+        rows: Block[];
+        to: number;
+    };
+    /** The cell a row shows none of in `column`, created (`table.pad`). */
+    fillTableCell: {
+        row: string;
+        column: string | number;
+    };
 };
 /**
  * Bind an operation onto its wrapper: every call is dispatched as a command
@@ -223,7 +286,7 @@ export declare function prepareMove(this: Block, { path }: BlockOperations['move
 export declare function moveBlock(this: Block, payload: BlockOperations['moveBlock'], plan?: Prepared): Block | null;
 /**
  * Grouped move — the operation-layer counterpart of `moveBlock` for
- * drags/multi-moves (D5). `path` is the same view-tree address shape:
+ * drags/multi-moves. `path` is the same view-tree address shape:
  * the prefix resolves the destination PARENT block, the last element is
  * the FINAL index — already discounted for the moved members by the
  * caller (the `facade.moveBlocks` contract, which counts the
@@ -260,20 +323,16 @@ export declare function patchData(this: Block, payload: BlockOperations['patchDa
  * ({@link textAfterAtom}), where the caret's pending marks follow.
  */
 export declare function addInlineBlock(this: Block, { index, block, text }: BlockOperations['addInlineBlock']): string;
-/** The text after atom `atom` of this block; the caret's pending marks follow it there (L4). */
+/** The text after atom `atom` of this block; the caret's pending marks follow it there. */
 export declare function textAfterAtom(this: Block, atom: string | undefined): Text | null | undefined;
 /**
  * Normalization runs at the end of the command's transaction
  * (`Dispatcher.drain`): a normalizer reads handles over the index; when a
  * plugin hook answers work, the work runs in the same transaction and the
- * block is requested again (bounded by the dispatcher's pass limit, D25).
+ * block is requested again (bounded by the dispatcher's pass limit).
  */
 export declare function normalizeContent(this: Block): void;
 export declare function normalizeChildren(this: Block): void;
-/** @deprecated A thin wrapper over an `{ end: block.id }` suggestion (`edytor.suggestions`). */
-export declare function suggestText(this: Block, { value }: BlockOperations['suggestText']): void;
-/** @deprecated Accepts this block's latest `{ end }` suggestion (`suggestion.accept()`). */
-export declare function acceptSuggestedText(this: Block): void;
 export declare function prepareDeleteRange(this: Block, { start: [startIndex, startOffset], end: [endIndex, endOffset] }: {
     start: number[];
     end: number[];

package/dist/block/block.utils.js

@@ -96,7 +96,7 @@ export function duplicateBlock(_ = {}, plan = prepareDuplicate.call(this)) {
 export function prepareSplit({ index, text }) {
     if (!text || !this.parent || !this.model)
         return REFUSED;
-    // G5: the sibling takes its parent's default child type and no data — a
+    // The sibling takes its parent's default child type and no data — a
     // list-like kind (`continues`) keeps its own, with its first preset's data.
     const { continues, presets } = this.definition;
     const tail = continues
@@ -183,7 +183,7 @@ export function moveBlock(payload, plan = prepareMove.call(this, payload)) {
 }
 /**
  * Grouped move — the operation-layer counterpart of `moveBlock` for
- * drags/multi-moves (D5). `path` is the same view-tree address shape:
+ * drags/multi-moves. `path` is the same view-tree address shape:
  * the prefix resolves the destination PARENT block, the last element is
  * the FINAL index — already discounted for the moved members by the
  * caller (the `facade.moveBlocks` contract, which counts the
@@ -298,7 +298,7 @@ export function addInlineBlock({ index, block, text }) {
     this.normalizeContent();
     return atom.id;
 }
-/** The text after atom `atom` of this block; the caret's pending marks follow it there (L4). */
+/** The text after atom `atom` of this block; the caret's pending marks follow it there. */
 export function textAfterAtom(atom) {
     if (atom === undefined)
         return undefined;
@@ -317,7 +317,7 @@ export function textAfterAtom(atom) {
  * Normalization runs at the end of the command's transaction
  * (`Dispatcher.drain`): a normalizer reads handles over the index; when a
  * plugin hook answers work, the work runs in the same transaction and the
- * block is requested again (bounded by the dispatcher's pass limit, D25).
+ * block is requested again (bounded by the dispatcher's pass limit).
  */
 export function normalizeContent() {
     if (this.edytor.dispatcher.defer(this, normalizeContent))
@@ -341,17 +341,6 @@ export function normalizeChildren() {
         this.normalizeChildren();
     }
 }
-/** @deprecated A thin wrapper over an `{ end: block.id }` suggestion (`edytor.suggestions`). */
-export function suggestText({ value }) {
-    this.suggestions =
-        typeof value === 'string'
-            ? [[{ text: value }]]
-            : (value?.map((part) => ('type' in part ? part : [part])) ?? null);
-}
-/** @deprecated Accepts this block's latest `{ end }` suggestion (`suggestion.accept()`). */
-export function acceptSuggestedText() {
-    this.edytor.suggestions.at(this.id).end.at(-1)?.accept();
-}
 export function prepareDeleteRange({ start: [startIndex, startOffset], end: [endIndex, endOffset] }) {
     const parts = this.edytor.idToBlock.parts(this.id);
     const [startPart, endPart] = [parts.at(startIndex), parts.at(endIndex)];

package/dist/block/colors.d.ts

@@ -45,3 +45,18 @@ export declare const colorable: (block: Block) => boolean;
  * that block as it was. Answers whether any block changed.
  */
 export declare const setBlockColor: (edytor: Edytor, blocks: Iterable<Block>, field: BlockColorField, value: string | null) => boolean;
+/**
+ * A block's colours as the classes Notion's HTML export writes
+ * (`block-color-red`, `block-color-red_background`), space-separated; empty
+ * when it holds none. The copy's `text/html` names them so.
+ */
+export declare const colorClasses: (data: Readonly<Record<string, unknown>> | undefined) => string;
+/**
+ * The palette colours `element`'s classes name as Notion's HTML export does
+ * (its `teal` read as green): what a paste keeps. A class naming no palette
+ * colour adds nothing.
+ */
+export declare const colorsOfClasses: (element: Element) => {
+    color?: string;
+    background?: string;
+};

package/dist/block/colors.js

@@ -72,3 +72,35 @@ export const setBlockColor = (edytor, blocks, field, value) => {
     });
     return applied.some(Boolean);
 };
+/** The class Notion's HTML export gives a block's colour: `block-color-<name>`, `block-color-<name>_background`. */
+const CLASS = /^block-color-([a-z]+)(_background)?$/;
+/** Notion's export names the palette's green `teal`. */
+const EXPORTED = { teal: 'green' };
+/**
+ * A block's colours as the classes Notion's HTML export writes
+ * (`block-color-red`, `block-color-red_background`), space-separated; empty
+ * when it holds none. The copy's `text/html` names them so.
+ */
+export const colorClasses = (data) => {
+    const color = colorName(data?.color);
+    const background = colorName(data?.background);
+    return [color && `block-color-${color}`, background && `block-color-${background}_background`]
+        .filter(Boolean)
+        .join(' ');
+};
+/**
+ * The palette colours `element`'s classes name as Notion's HTML export does
+ * (its `teal` read as green): what a paste keeps. A class naming no palette
+ * colour adds nothing.
+ */
+export const colorsOfClasses = (element) => {
+    const found = {};
+    for (const name of element.classList) {
+        const [, raw, background] = CLASS.exec(name) ?? [];
+        const color = raw && (EXPORTED[raw] ?? raw);
+        if (!color || !BLOCK_COLORS.includes(color))
+            continue;
+        found[background ? 'background' : 'color'] = color;
+    }
+    return found;
+};

package/dist/block/inlineBlock.svelte.d.ts

@@ -5,7 +5,8 @@ import type { Block } from './block.svelte.js';
 /**
  * An id-only inline-atom handle: atom `id`, shown in
  * block `blockId`. Getters read the document index; `node` is the element
- * that renders it (a Surface fact).
+ * that renders it (a Surface fact). A reactive reader of a getter depends on
+ * the block's cell, so it re-runs when a commit changes the block's content.
  */
 export declare class InlineBlock {
     #private;

package/dist/block/inlineBlock.svelte.js

@@ -1,11 +1,11 @@
-import { clearDomSelection } from '../selection/domSelection.js';
 import { propsProxy } from '../session/props.js';
 const INLINE_EDGE_CARET_THRESHOLD_PX = 4;
 const isTextPart = (part) => part !== undefined && !(part instanceof InlineBlock);
 /**
  * An id-only inline-atom handle: atom `id`, shown in
  * block `blockId`. Getters read the document index; `node` is the element
- * that renders it (a Surface fact).
+ * that renders it (a Surface fact). A reactive reader of a getter depends on
+ * the block's cell, so it re-runs when a commit changes the block's content.
  */
 export class InlineBlock {
     _def = 'inline';
@@ -25,6 +25,8 @@ export class InlineBlock {
         return this.edytor.idToBlock.block(this.blockId);
     }
     get #item() {
+        if ($effect.tracking())
+            this.edytor.cells?.get(this.blockId);
         const parts = this.edytor.idToBlock.parts(this.blockId);
         const part = parts.find((part) => part.kind === 'inline' && part.item.id === this.id);
         return part?.kind === 'inline' ? part.item : undefined;
@@ -88,10 +90,10 @@ export class InlineBlock {
             if (event.clientX >= rect.right - INLINE_EDGE_CARET_THRESHOLD_PX && isTextPart(after))
                 return selection.setAtTextOffset(after, 0);
             selection.selectInlineBlock(this);
-            clearDomSelection(this.edytor.node);
+            this.edytor.ports.surface.clear();
             // The atom took the press: the caret the browser still leaves for it
             // (Chromium parks one at the host's start before the release) is its own.
-            this.edytor.projector.parked();
+            this.edytor.ports.surface.parked();
         };
         node.addEventListener('pointerdown', selectInlineBlock);
         return {