@olddevs/ui 4.5.0 → 4.6.0

package/docs/conventions.en.md

@@ -1,5 +1,5 @@
 ---
-sourceHash: 84104315608a
+sourceHash: 502667bd31f1
 ---
 
 # General conventions for `@olddevs/ui`
@@ -285,7 +285,7 @@ already catches itself. A violation after which the component cannot work is not
   (`vi.stubEnv`), and it stays silent on a correct call.
 
 **An error instead of a warning: `devError(message, cause?)`.** Use it when a violation breaks the whole component
-but not the page: the Tool set of `RichTextEditor` is built incorrectly, the loader of an engine part failed,
+but not the page: the Tool set of `RichTextEditor` is built incorrectly, the loader of the Extensions failed,
 `rangeAt` of the Text card threw an exception. The field shows the author a catalog string on its own, and the
 cause goes to the developer through `console.error`, with the same rules as `devWarn`: in development, once per
 text, in English.

package/docs/conventions.md

@@ -320,7 +320,7 @@ ADR-0034.
 
 **Ошибка вместо предупреждения — `devError(message, cause?)`.** Когда нарушение
 ломает компонент целиком, но не страницу: набор Инструментов `RichTextEditor`
-собран с ошибкой, Загрузчик Части для движка упал, `rangeAt` Карточки бросил
+собран с ошибкой, Загрузчик Extensions упал, `rangeAt` Карточки бросил
 исключение. Поле само показывает автору строку каталога (`editor.toolsFailed`),
 а причина уходит разработчику через `console.error` — с теми же правилами, что у
 `devWarn`: в разработке, один раз на текст, по-английски.

package/docs/getting-started.en.md

@@ -1,5 +1,5 @@
 ---
-sourceHash: 340e1ec512cb
+sourceHash: 45289d832ab0
 ---
 
 # Setting up `@olddevs/ui`
@@ -132,12 +132,12 @@ peer dependencies are treated as external, and the metric is gzip:
 | `cn` and `tableStateToParams`                                                                            | 0.6 kB   |
 | one `Button`                                                                                             | 1.6 kB   |
 | `DataTable`                                                                                              | 9.0 kB   |
-| the whole kit (`import *`)                                                                               | 77.1 kB  |
-| `RichTextEditor` from `@olddevs/ui/editor`, without the engine, "start"                                  | 72.7 kB  |
-| `RichTextEditor` with the Tiptap engine, "start" (static graph, `basic`)                                 | 297.5 kB |
-| `RichTextEditor` with the Tiptap engine, "full" (with all lazy chunks, `full`)                           | 346.6 kB |
-| `RichTextView` from `@olddevs/ui/editor`, Tiptap engine included in the measurement                      | 12.3 kB  |
-| `sanitizeRichText` and `richTextSanitizeConfig` from `@olddevs/ui/editor/schema`, Tiptap engine included | 3.9 kB   |
+| the whole kit (`import *`)                                                                               | 77.2 kB  |
+| `RichTextEditor` from `@olddevs/ui/editor`, without the engine, "start"                                  | 75.9 kB  |
+| `RichTextEditor` with the Tiptap engine, "start" (static graph, `basic`)                                 | 305.3 kB |
+| `RichTextEditor` with the Tiptap engine, "full" (with all lazy chunks, `full`)                           | 354.6 kB |
+| `RichTextView` from `@olddevs/ui/editor`, Tiptap engine included in the measurement                      | 12.7 kB  |
+| `sanitizeRichText` and `richTextSanitizeConfig` from `@olddevs/ui/editor/schema`, Tiptap engine included | 4.0 kB   |
 | `highlightCodeBlocks` from `@olddevs/ui/editor/highlight`, with lowlight                                 | 22.6 kB  |
 | `highlightCodeNodes` from `@olddevs/ui/editor/highlight`, with lowlight                                  | 22.6 kB  |
 
@@ -146,7 +146,7 @@ The last seven rows are separate Editor entry points with their own budgets
 them are scenarios (ADR-0058, item 11.7):
 **"start"** is the static graph, what ships immediately and what the `basic` Preset costs; **"full"** is the same
 plus all the lazy chunks of the entry point, what `full` ends up loading. The code Block and the table (absent from `basic`,
-and their Engine part weighs more than 10 kB) load lazily; until they arrive, an Editor that includes them shows a Skeleton.
+and their Extensions weigh more than 10 kB) load lazily; until they arrive, an Editor that includes them shows a Skeleton.
 `npm run size` checks that their modules are not in "start". The kit's own code is measured at "start".
 
 In the scenarios the engine is **included in the measurement** on purpose: the consumer installs Tiptap, but
@@ -158,7 +158,7 @@ an app bundler with full minification produced about 133 kB (measured before the
 For `RichTextView`, Tiptap and lowlight are included in the measurement as a check. Its row contains only
 typography and the Island of the "Copy" button on code Blocks (the kit's button and tooltip, the message catalog),
 and the measurement proves that its graph contains neither the engine nor a highlighter. The lightweight
-`@olddevs/ui/editor/schema` entry point is measured the same way (3.9 kB): the Schema, `richTextSchema`, the
+`@olddevs/ui/editor/schema` entry point is measured the same way (4.0 kB): the Schema, `richTextSchema`, the
 `sanitizeRichText` sanitizer with hooks for DOMPurify, including for the rules of custom Tools, and `markRange`.
 
 Server-side highlighting in `@olddevs/ui/editor/highlight` (22.6 kB — almost entirely the highlight.js core and

package/docs/getting-started.md

@@ -129,12 +129,12 @@ peer-зависимости внешние, метрика gzip:
 | `cn` и `tableStateToParams`                                                                                 | 0,6 кБ   |
 | одна `Button`                                                                                               | 1,6 кБ   |
 | `DataTable`                                                                                                 | 9,0 кБ   |
-| весь кит целиком (`import *`)                                                                               | 77,1 кБ  |
-| `RichTextEditor` из `@olddevs/ui/editor`, без движка, «старт»                                               | 72,7 кБ  |
-| `RichTextEditor` вместе с движком Tiptap, «старт» (статический граф, `basic`)                               | 297,5 кБ |
-| `RichTextEditor` вместе с движком Tiptap, «полный» (со всеми ленивыми чанками, `full`)                      | 346,6 кБ |
-| `RichTextView` из `@olddevs/ui/editor`, движок Tiptap в замер включён                                       | 12,3 кБ  |
-| `sanitizeRichText` и `richTextSanitizeConfig` из `@olddevs/ui/editor/schema`, движок Tiptap в замер включён | 3,9 кБ   |
+| весь кит целиком (`import *`)                                                                               | 77,2 кБ  |
+| `RichTextEditor` из `@olddevs/ui/editor`, без движка, «старт»                                               | 75,9 кБ  |
+| `RichTextEditor` вместе с движком Tiptap, «старт» (статический граф, `basic`)                               | 305,3 кБ |
+| `RichTextEditor` вместе с движком Tiptap, «полный» (со всеми ленивыми чанками, `full`)                      | 354,6 кБ |
+| `RichTextView` из `@olddevs/ui/editor`, движок Tiptap в замер включён                                       | 12,7 кБ  |
+| `sanitizeRichText` и `richTextSanitizeConfig` из `@olddevs/ui/editor/schema`, движок Tiptap в замер включён | 4,0 кБ   |
 | `highlightCodeBlocks` из `@olddevs/ui/editor/highlight`, вместе с lowlight                                  | 22,6 кБ  |
 | `highlightCodeNodes` из `@olddevs/ui/editor/highlight`, вместе с lowlight                                   | 22,6 кБ  |
 
@@ -143,7 +143,7 @@ peer-зависимости внешние, метрика gzip:
 них — сценарии (ADR-0058, п. 11.7):
 **«старт»** — статический граф, то, что едет сразу и что платит Пресет `basic`; **«полный»** — он же
 плюс все ленивые чанки входа, то, что в итоге грузит `full`. Блок кода и таблица (их нет в `basic`,
-а их Часть для движка тяжелее 10 кБ) грузятся лениво; до их прихода Редактор, в котором они есть,
+а их Extensions тяжелее 10 кБ) грузятся лениво; до их прихода Редактор, в котором они есть,
 показывает Скелет. `npm run size` проверяет, что их модулей в «старте» нет. Код кита меряется на «старте».
 
 В сценариях движок **внесён в замер** намеренно: Tiptap ставит потребитель, но набор его расширений
@@ -155,7 +155,7 @@ peer-зависимости внешние, метрика gzip:
 У `RichTextView` Tiptap и lowlight внесены в замер ради проверки. В его строку входят только
 типографика и Остров кнопки «Копировать» у Блоков кода (кнопка и подсказка кита, каталог сообщений),
 и замер доказывает, что в графе нет ни движка, ни подсветчика. Так же меряется лёгкий вход
-`@olddevs/ui/editor/schema` (3,9 кБ): Схема, `richTextSchema`, очистка `sanitizeRichText` с хуками для
+`@olddevs/ui/editor/schema` (4,0 кБ): Схема, `richTextSchema`, очистка `sanitizeRichText` с хуками для
 DOMPurify, в том числе по правилам своих Инструментов, и `markRange`.
 
 Серверная подсветка `@olddevs/ui/editor/highlight` (22,6 кБ — почти целиком ядро highlight.js и

package/docs/glossary.en.md

@@ -1,5 +1,5 @@
 ---
-sourceHash: 5cc549fe1c76
+sourceHash: 5d5024cab991
 ---
 
 # Glossary of `@olddevs/ui`
@@ -136,54 +136,82 @@ Terms of `RichTextEditor` and `RichTextView` (the `@olddevs/ui/editor` entry poi
 especially easy to borrow a word from a neighboring editor (plugin, service, node) — and that
 introduces a second meaning.
 
-| Term                     | Meaning                                                                                                                                                                                                                                                                                                                                                        | Not to be confused with                                                                                                                                                                                                                            |
-| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Editor**               | `RichTextEditor` — a rich text input field                                                                                                                                                                                                                                                                                                                     | A code editor: the kit has none, code is displayed with `CodeView`                                                                                                                                                                                 |
-| **View**                 | `RichTextView` — read-only display of a saved Document                                                                                                                                                                                                                                                                                                         | The Editor's `readOnly` mode: that one carries the engine, the View does not                                                                                                                                                                       |
-| **Table of contents**    | `RichTextToc`: the list of a Document's headings next to the View or the Editor. Collapsed, it is a strip of strokes; expanded, a list; a click on an item goes to the heading                                                                                                                                                                                 | The kit's `Heading` and the navigation of the documentation site                                                                                                                                                                                   |
-| **Document**             | The Editor's value: an HTML string constrained by the Schema                                                                                                                                                                                                                                                                                                   | The ProseMirror JSON tree in the engine — it is internal; it comes out only as a JSON envelope                                                                                                                                                     |
-| **JSON envelope**        | A Document as JSON for a file and a template: `{ format: "olddevs-rich-text", version, doc }` (`getJSON()`, `setJSON()`, `defaultValue`), lossless and through the Schema                                                                                                                                                                                      | The Editor's value — the value stays HTML; the bare tree `editor.getJSON()` without an envelope                                                                                                                                                    |
-| **Schema**               | An allowlist of Blocks, Marks and attributes that the Editor accepts and returns                                                                                                                                                                                                                                                                               | Server-side sanitization — the consumer does it (`sanitizeRichText`)                                                                                                                                                                               |
-| **Block**                | A structural element of a Document: paragraph, heading, list, table, image…                                                                                                                                                                                                                                                                                    | A Mark                                                                                                                                                                                                                                             |
-| **Mark**                 | Inline formatting inside a Block: bold, link, color…                                                                                                                                                                                                                                                                                                           | A Block                                                                                                                                                                                                                                            |
-| **Atom**                 | A Block or inline element that is selected, moved and deleted as a whole: an image (the caption inside it is editable), a divider, a soft break, a mention. Always makes the field non-empty                                                                                                                                                                   | An empty Block: a paragraph without text is not an Atom and does not count as content                                                                                                                                                              |
-| **Atom text**            | The string that represents an Atom in the Document's text: `getText` and `getSelectedText` return it, its length is the Atom's weight in `maxLength`, and it is how the Atom is exported to Markdown without rules of its own. For an image it is the caption text, for a divider an empty string                                                              | A Block attribute                                                                                                                                                                                                                                  |
-| **Layout**               | A Block of columns (the `layout` Tool): six variants — from one to four equal columns, 60/40 and 40/60. Top level only, does not nest into itself; a column for its Blocks is the same as a Document                                                                                                                                                           | A table: it has data rows and cells, while the columns of a Layout are the Document's page structure. The kit's `Grid`: a screen grid, not a Block                                                                                                 |
-| **Wrapper**              | A Block that gathers a group of Blocks (the `wrapper` Tool, a `div` with `data-block="wrapper"`): they are moved, duplicated and deleted as one Block. Without a Wrapper tone it has no look of its own — the dashed outline exists only in the Editor. Neither a Wrapper nor a Layout nests into a Wrapper                                                    | A quote: it has its own look and meaning in the Document, while a Wrapper without a tone is only grouping                                                                                                                                          |
-| **Wrapper tone**         | The styling of a Wrapper as a note (`data-tone`): a background and a stripe on the left in one of five tones of the `Tone` vocabulary — "Note", "Tip", "Important", "Warning", "Caution". Chosen in the "Tone ›" item of the Block handle, the same in the Editor and the View, exported to Markdown as a GitHub alert (what GitHub and Notion call a callout) | The tone of a Field notice (`status` or `error`). Meaning: the tone carries no roles or `aria-*`; the meaning of a note is written as a word in the text                                                                                           |
-| **Toolbar**              | A set of formatting buttons; its look is set by `toolbar`. **Fixed** (`fixed`, the default) — above the field, sticks on scroll; **floating** (`floating`) — the same buttons above a non-empty selection. With `bubble` there is no Toolbar — the Selection menu takes its place, with `none` there is neither. On a touch screen the Toolbar is always fixed | The kit's `Toolbar` — the primitive that the Toolbar is built from                                                                                                                                                                                 |
-| **Insert menu**          | The "Insert" and "Turn into" list: opens on `/` in the text and on the "+" button                                                                                                                                                                                                                                                                              | The browser context menu                                                                                                                                                                                                                           |
-| **Selection menu**       | A compact pill on an inverse surface above a non-empty selection: "¶", lists, bold, italic, underline, color, "…", link, emoji; its contents are fixed by the kit. Appears in place of the Toolbar with `toolbar="bubble"` and on top of the fixed Toolbar — there `selectionMenu={false}` turns it off. Absent on a touch screen                              | The floating Toolbar: it has the full set of buttons                                                                                                                                                                                               |
-| **Block handle**         | The "⋮" on the Block that holds the caret, and its menu of actions on the whole Block: "Add ›", "Format ›", "Move up", "Move down", "Duplicate", "Delete"                                                                                                                                                                                                      | The Toolbar: it works with the selection, not with a Block                                                                                                                                                                                         |
-| **Insert item**          | A row of the Insert menu: inserts a Block or turns the current one into another. One item is visible on `/`, on "+" and in the Block handle                                                                                                                                                                                                                    | A Toolbar button                                                                                                                                                                                                                                   |
-| **Block action**         | An item of the Block handle menu that works with the whole Block, for example "Duplicate"                                                                                                                                                                                                                                                                      | A button: it works with the selection                                                                                                                                                                                                              |
-| **Shortcuts reference**  | A read-only "command — shortcut" popover behind the last button of the fixed Toolbar. The rows are the commands of the enabled Tools, including custom ones; on a phone there is no button                                                                                                                                                                     | The kit's `CommandPalette`: the rows of the Shortcuts reference are not clickable. The kit's `ShortcutsHelp`: it lists screen shortcuts, not Editor ones                                                                                           |
-| **HTML mode**            | The mode of the `source` Tool: the "HTML" button on the fixed Toolbar replaces the Document with a field holding its HTML. The field text passes through the Schema and becomes the Document in a single edit — on leaving the mode, on `blur`, on form submit and on reading through the Handle                                                               | The HTML convention: that is the form of custom content in a Document, not a mode. `CodeView`: it displays code, while the HTML field is editable                                                                                                  |
-| **Glass**                | A semi-transparent background that blurs what is behind it on everything the Editor shows above the Document: the floating Toolbar, the Selection menu, menus, popovers, the Text card. The color is the token of its own surface; with `prefers-reduced-transparency`, `prefers-contrast: more` and on iOS the background is solid                            | The kit's `Menu` and `Popover` outside the Editor: they stay solid                                                                                                                                                                                 |
-| **UI contribution**      | A UI element of a custom Tool, described as data: a button, an Insert item, a Block action or a Text card. The kit renders it in a Slot; a disabled Tool removes its UI contributions as well                                                                                                                                                                  | A React node in the interface: arbitrary React is allowed only inside the content of a button popover and a Text card                                                                                                                              |
-| **Slot**                 | One place on a surface where the UI contributions of custom Tools appear, in `tools` order: the Toolbar group before "Undo", the end of an Insert menu section, the Block handle section before "Delete"                                                                                                                                                       | A position relative to a built-in button: the ids of built-ins are not public API                                                                                                                                                                  |
-| **Preset**               | A ready-made set of built-in Tools: `full` or `basic` (`RICH_TEXT_PRESETS`). Not a frozen list: a new built-in arrives in it in a minor version                                                                                                                                                                                                                | An exact `tools` list: only the screen changes its composition                                                                                                                                                                                     |
-| **Tool**                 | One capability of the Editor: its Blocks and Marks, their rules in the Schema and their place in the UI, for example `table`. A built-in one is set by name, a custom one by a description                                                                                                                                                                     | A button: disabling a Tool also removes its Block from the Schema. A Redactor plugin: that is a class of behavior over the DOM without a Schema                                                                                                    |
-| **custom Tool**          | A Tool that the consumer describes (`CustomTool`): Schema rules as data, an Engine part and UI contributions. Passed in `tools` mixed in with the kit's names                                                                                                                                                                                                  | The kit's internal description: that is a superset of the public shape for built-ins and is not exported                                                                                                                                           |
-| **Tool options**         | What the screen sets on a Tool before the engine is created: the starting flags of Find, `offsetVar`, `levels` and `listWidth` of the Table of contents, the `defaults` of a custom Tool (`defineTool`). The screen sets them with a `tool(…)` entry and the kit reads them once, when the engine is created                                                   | `options` of a Tiptap extension: the extension's author sets those and the Engine part reads them, while Tool options are set by the screen and read by the kit. The Editor's props (`preset`, `maxHeight`): those configure the field, not a Tool |
-| **Configured Tool**      | An entry of `tools` returned by `tool(name, options)` or `tool(definition, options)`: a Tool together with its options. It switches a Tool on without the name in `tools` and wins over a bare name from a Preset                                                                                                                                              | A `defineTool` definition: that describes a Tool, while a Configured Tool is its activation with options. The description of a built-in Tool: it is not exported, and the entry only names the Tool and carries the options                        |
-| **Tool state**           | A data snapshot the screen reads with the `useRichTextToolState(ref, name)` hook: for Find, whether the panel is open, the query, the number of matches and the current one; for the Table of contents, the headings and the current section. The screen re-renders only when the snapshot changes                                                             | `storage` of a Tiptap extension: that is a mutable store inside the engine, while Tool state is read-only. `useRichTextEditorState`: that takes a slice of the live Tiptap `editor`, not a Tool's contract                                         |
-| **Tool commands**        | What the screen calls on a Tool through `handle.tool(name)`: `tool("search")?.open()`, `tool("toc")?.jumpTo(2)`. Each returns a `boolean`; `null` instead of the commands object means the Tool is not in the set, has no commands, or the engine has not been created yet                                                                                     | Handle methods (`insertHTML`, `focus`): those are common to any `tools`, while Tool commands exist only while the Tool is enabled. `editor.commands` and `commands` in Tiptap: those are engine commands and follow its major                      |
-| **Consumer prefix**      | The start of the name of everything custom — a Tool, its Blocks, Marks and attributes — up to the underscore: `acme_mergeTag`, `data-acme_size`. Kit names have no underscore, so custom names and built-in ones never collide, either in a set or in a Document                                                                                               | A Preset: that is a set of built-in Tools, not a namespace                                                                                                                                                                                         |
-| **HTML convention**      | The form of custom content in a Document: a Block is a `div` or `span` with `data-block`, a Mark is a `span` with `data-mark`, attributes are `data-<prefix>_<name>`. Frozen: extended only by adding                                                                                                                                                          | The kit's Schema tags (`p`, `table`, `img`): a custom Block cannot take them                                                                                                                                                                       |
-| **Block trait**          | A Block property that only the kit understands, not the engine: "container" (children get their own handle), "can be turned into", "Atom without a formatting menu"                                                                                                                                                                                            | A Block attribute: that one is stored in the Document                                                                                                                                                                                              |
-| **Engine part**          | The part of a Tool description needed only by the live Editor: Tiptap extensions and the node view. Supplied immediately or through a Loader                                                                                                                                                                                                                   | Schema rules: those are data, read by the server and the View without an engine                                                                                                                                                                    |
-| **Loader**               | A function with a dynamic import in place of the Engine part: `engine: () => import(…)`. The heavy built-ins outside `basic` load the same way — the code Block and the table                                                                                                                                                                                  | Preloading (`modulepreload`): the kit does not publish it, the consumer sets it up                                                                                                                                                                 |
-| **Handle**               | Imperative access from screen code to the Editor through `ref`: insert at the caret, read, focus, history, the commands of Tools (`tool(name)`)                                                                                                                                                                                                                | Redactor services: those are engine internals, not screen API                                                                                                                                                                                      |
-| **Readiness**            | The moment when the engine is created and the Loaders of all enabled Tools, custom and built-in, have finished: from then on Handle methods take effect instead of doing nothing. Happens once per mount; `onReady` reports it                                                                                                                                 | Hydration: after it the engine may still be waiting for Loaders                                                                                                                                                                                    |
-| **Field focus**          | Focus inside the Editor as a whole: the Document, the Toolbar, the kit's popovers, the HTML field. Moving between them does not lose Field focus; `onFocus` and `onBlur` are about it                                                                                                                                                                          | Document focus (the engine's `focus` and `blur`): a click in the Toolbar removes it                                                                                                                                                                |
-| **Author edit**          | A change to the Document equal to typing on a keyboard: a history step, `onChange` after a delay, the character limit applies. This also covers insert, undo and redo from the Handle                                                                                                                                                                          | An External replacement                                                                                                                                                                                                                            |
-| **External replacement** | Replacing the whole Document (`value`, `clear()`, `setMarkdown()`, `setJSON()`): the character limit does not truncate it; `onChange` fires immediately for `clear()`, `setMarkdown()` and `setJSON()`, but not for a new `value`                                                                                                                              | An Author edit                                                                                                                                                                                                                                     |
-| **Skeleton**             | The Editor's look before Readiness: the field frame, a placeholder for the Toolbar and a Document: sanitized by the Schema, it is rendered as static HTML with the same class and rhythm as the engine's Document, without input. On the server — the frame without a Document. A Loader failure turns the Skeleton into a field error with "Retry"            | The View: that is a separate read-only component, while the Skeleton is a state of the Editor that the engine replaces. The kit's `Skeleton` component: a loading placeholder                                                                      |
-| **Status line**          | A line inside the field frame under the Document: on the left the screen's content (`status`: word count, "Saved", co-author), on the right the kit's character counter                                                                                                                                                                                        | A Field notice: the line shows a lasting state of the screen, not an event                                                                                                                                                                         |
-| **Field notice**         | One event tied to the field (`showNotice`): tone `status` (only announced) or `error` (a visible line under the field until the next Author edit). A new one replaces the previous one                                                                                                                                                                         | The kit's toast: that one is global and not tied to a field                                                                                                                                                                                        |
-| **Text card**            | A non-modal card under a range of the Document, declared by a custom Tool (`textCards`): a comment, a hint from checking the text. Opens when the caret enters it or on click, focus stays in the text                                                                                                                                                         | A button popover: a button opens that one, while a Text card is opened by a place in the Document                                                                                                                                                  |
-| **Trigger character**    | A character of a custom Tool (`trigger`) that opens a list of items at the caret when typed at the start of a Block or after a space, like `/`: `@` for mentions, `#` for tags. Picking an item replaces the typed `@query` with a custom node                                                                                                                 | The Insert menu on `/`: that one is built in, while a custom character is set by a Tool                                                                                                                                                            |
-| **Paper**                | A light area of the Document in any app theme (`surface="paper"`) — for text that leaves the app on a light background: an email, print, PDF. The Toolbar, menus and field frame stay in the app theme; the View with the same `surface` shows the same Paper                                                                                                  | The `light` theme: it changes the whole app, the Paper only the Document                                                                                                                                                                           |
-| **Island**               | A client-side piece of the View that, after mounting, brings a Block in already rendered HTML to life: the "Copy" button on a code Block, the `island` of a custom Block                                                                                                                                                                                       | A node view: it lives only in the Editor engine                                                                                                                                                                                                    |
-| **Mount point**          | A place in already rendered HTML where an Island mounts a live element: the code Block header that receives the "Copy" button                                                                                                                                                                                                                                  | A Slot: that is a place in the Editor UI for the UI contributions of Tools                                                                                                                                                                         |
+| Term                     | Meaning                                                                                                                                                                                                                                                                                                                                                        | Not to be confused with                                                                                                                                                                                                                                 |
+| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Editor**               | `RichTextEditor` — a rich text input field                                                                                                                                                                                                                                                                                                                     | A code editor: the kit has none, code is displayed with `CodeView`                                                                                                                                                                                      |
+| **View**                 | `RichTextView` — read-only display of a saved Document                                                                                                                                                                                                                                                                                                         | The Editor's `readOnly` mode: that one carries the engine, the View does not                                                                                                                                                                            |
+| **Table of contents**    | `RichTextToc`: the list of a Document's headings next to the View or the Editor. Collapsed, it is a strip of strokes; expanded, a list; a click on an item goes to the heading                                                                                                                                                                                 | The kit's `Heading` and the navigation of the documentation site                                                                                                                                                                                        |
+| **Document**             | The Editor's value: an HTML string constrained by the Schema                                                                                                                                                                                                                                                                                                   | The ProseMirror JSON tree in the engine — it is internal; it comes out only as a JSON envelope                                                                                                                                                          |
+| **JSON envelope**        | A Document as JSON for a file and a template: `{ format: "olddevs-rich-text", version, doc }` (`getJSON()`, `setJSON()`, `defaultValue`), lossless and through the Schema                                                                                                                                                                                      | The Editor's value — the value stays HTML; the bare tree `editor.getJSON()` without an envelope                                                                                                                                                         |
+| **Schema**               | An allowlist of Blocks, Marks and attributes that the Editor accepts and returns                                                                                                                                                                                                                                                                               | Server-side sanitization — the consumer does it (`sanitizeRichText`)                                                                                                                                                                                    |
+| **Block**                | A structural element of a Document: paragraph, heading, list, table, image…                                                                                                                                                                                                                                                                                    | A Mark                                                                                                                                                                                                                                                  |
+| **Mark**                 | Inline formatting inside a Block: bold, link, color…                                                                                                                                                                                                                                                                                                           | A Block                                                                                                                                                                                                                                                 |
+| **Atom**                 | A Block or inline element that is selected, moved and deleted as a whole: an image (the caption inside it is editable), a divider, a soft break, a mention. Always makes the field non-empty                                                                                                                                                                   | An empty Block: a paragraph without text is not an Atom and does not count as content                                                                                                                                                                   |
+| **Atom text**            | The string that represents an Atom in the Document's text: `getText` and `getSelectedText` return it, its length is the Atom's weight in `maxLength`, and it is how the Atom is exported to Markdown without rules of its own. For an image it is the caption text, for a divider an empty string                                                              | A Block attribute                                                                                                                                                                                                                                       |
+| **Layout**               | A Block of columns (the `layout` Tool): six variants — from one to four equal columns, 60/40 and 40/60. Top level only, does not nest into itself; a column for its Blocks is the same as a Document                                                                                                                                                           | A table: it has data rows and cells, while the columns of a Layout are the Document's page structure. The kit's `Grid`: a screen grid, not a Block                                                                                                      |
+| **Wrapper**              | A Block that gathers a group of Blocks (the `wrapper` Tool, a `div` with `data-block="wrapper"`): they are moved, duplicated and deleted as one Block. Without a Wrapper tone it has no look of its own — the dashed outline exists only in the Editor. Neither a Wrapper nor a Layout nests into a Wrapper                                                    | A quote: it has its own look and meaning in the Document, while a Wrapper without a tone is only grouping                                                                                                                                               |
+| **Wrapper tone**         | The styling of a Wrapper as a note (`data-tone`): a background and a stripe on the left in one of five tones of the `Tone` vocabulary — "Note", "Tip", "Important", "Warning", "Caution". Chosen in the "Tone ›" item of the Block handle, the same in the Editor and the View, exported to Markdown as a GitHub alert (what GitHub and Notion call a callout) | The tone of a Field notice (`status` or `error`). Meaning: the tone carries no roles or `aria-*`; the meaning of a note is written as a word in the text                                                                                                |
+| **Collapsible block**    | A Block made of a title and content that the reader opens and closes (the `details` Tool, the Details extension from Tiptap; the `details` and `summary` tags). The content is Blocks; there are no Layouts or Wrappers in it. Only the `persist` option writes the open state into the Document                                                               | A Wrapper: it groups Blocks and hides nothing. The kit's `Accordion`: that is a screen component, not a Block of the Document                                                                                                                           |
+| **Toolbar**              | A set of formatting buttons; its look is set by `toolbar`. **Fixed** (`fixed`, the default) — above the field, sticks on scroll; **floating** (`floating`) — the same buttons above a non-empty selection. With `bubble` there is no Toolbar — the Selection menu takes its place, with `none` there is neither. On a touch screen the Toolbar is always fixed | The kit's `Toolbar` — the primitive that the Toolbar is built from                                                                                                                                                                                      |
+| **Insert menu**          | The "Insert" and "Turn into" list: opens on `/` in the text and on the "+" button                                                                                                                                                                                                                                                                              | The browser context menu                                                                                                                                                                                                                                |
+| **Selection menu**       | A compact pill on an inverse surface above a non-empty selection: "¶", lists, bold, italic, underline, color, "…", link, emoji; its contents are fixed by the kit. Appears in place of the Toolbar with `toolbar="bubble"` and on top of the fixed Toolbar — there `selectionMenu={false}` turns it off. Absent on a touch screen                              | The floating Toolbar: it has the full set of buttons                                                                                                                                                                                                    |
+| **Block handle**         | The "⋮" on the Block that holds the caret, and its menu of actions on the whole Block: "Add ›", "Format ›", "Move up", "Move down", "Duplicate", "Delete"                                                                                                                                                                                                      | The Toolbar: it works with the selection, not with a Block                                                                                                                                                                                              |
+| **Insert item**          | A row of the Insert menu: inserts a Block or turns the current one into another. One item is visible on `/`, on "+" and in the Block handle                                                                                                                                                                                                                    | A Toolbar button                                                                                                                                                                                                                                        |
+| **Block action**         | An item of the Block handle menu that works with the whole Block, for example "Duplicate"                                                                                                                                                                                                                                                                      | A button: it works with the selection                                                                                                                                                                                                                   |
+| **Shortcuts reference**  | A read-only "command — shortcut" popover behind the last button of the fixed Toolbar. The rows are the commands of the enabled Tools, including custom ones; on a phone there is no button                                                                                                                                                                     | The kit's `CommandPalette`: the rows of the Shortcuts reference are not clickable. The kit's `ShortcutsHelp`: it lists screen shortcuts, not Editor ones                                                                                                |
+| **HTML mode**            | The mode of the `source` Tool: the "HTML" button on the fixed Toolbar replaces the Document with a field holding its HTML. The field text passes through the Schema and becomes the Document in a single edit — on leaving the mode, on `blur`, on form submit and on reading through the Handle                                                               | The HTML convention: that is the form of custom content in a Document, not a mode. `CodeView`: it displays code, while the HTML field is editable                                                                                                       |
+| **Glass**                | A semi-transparent background that blurs what is behind it on everything the Editor shows above the Document: the floating Toolbar, the Selection menu, menus, popovers, the Text card. The color is the token of its own surface; with `prefers-reduced-transparency`, `prefers-contrast: more` and on iOS the background is solid                            | The kit's `Menu` and `Popover` outside the Editor: they stay solid                                                                                                                                                                                      |
+| **UI contribution**      | A UI element of a custom Tool, described as data: a button, an Insert item, a Block action or a Text card. The kit renders it in a Slot; a disabled Tool removes its UI contributions as well                                                                                                                                                                  | A React node in the interface: arbitrary React is allowed only inside the content of a button popover and a Text card                                                                                                                                   |
+| **Slot**                 | One place on a surface where the UI contributions of custom Tools appear, in `tools` order: the Toolbar group before "Undo", the end of an Insert menu section, the Block handle section before "Delete"                                                                                                                                                       | A position relative to a built-in button: the ids of built-ins are not public API                                                                                                                                                                       |
+| **Preset**               | A ready-made set of built-in Tools: `full` or `basic` (`RICH_TEXT_PRESETS`). Not a frozen list: a new built-in arrives in it in a minor version                                                                                                                                                                                                                | An exact `tools` list: only the screen changes its composition                                                                                                                                                                                          |
+| **Tool**                 | One capability of the Editor: its Blocks and Marks, their rules in the Schema and their place in the UI, for example `table`. A built-in one is set by name, a custom one by a description                                                                                                                                                                     | A button: disabling a Tool also removes its Block from the Schema. A Redactor plugin: that is a class of behavior over the DOM without a Schema                                                                                                         |
+| **custom Tool**          | A Tool that the consumer describes (`CustomTool`): Schema rules as data, Extensions and UI contributions. It is passed in `tools` mixed in with the kit's names                                                                                                                                                                                                | The kit's internal description: that is a superset of the public shape for built-ins and is not exported                                                                                                                                                |
+| **Tool options**         | What the screen sets on a Tool before the engine is created: the starting flags of Find, `offsetVar`, `levels` and `listWidth` of the Table of contents, the `defaults` of a custom Tool (`defineTool`). The screen sets them with a `tool(…)` entry and the kit reads them once, when the engine is created                                                   | `options` of a Tiptap extension: the extension's author sets those and the extension itself reads them, while Tool options are set by the screen and read by the kit. The Editor's props (`preset`, `maxHeight`): those configure the field, not a Tool |
+| **Configured Tool**      | An entry of `tools` returned by `tool(name, options)` or `tool(definition, options)`: a Tool together with its options. It switches a Tool on without the name in `tools` and wins over a bare name from a Preset                                                                                                                                              | A `defineTool` definition: that describes a Tool, while a Configured Tool is its activation with options. The description of a built-in Tool: it is not exported, and the entry only names the Tool and carries the options                             |
+| **Tool state**           | A data snapshot the screen reads with the `useRichTextToolState(ref, name)` hook: for Find, whether the panel is open, the query, the number of matches and the current one; for the Table of contents, the headings and the current section. The screen re-renders only when the snapshot changes                                                             | `storage` of a Tiptap extension: that is a mutable store inside the engine, while Tool state is read-only. `useRichTextEditorState`: that takes a slice of the live Tiptap `editor`, not a Tool's contract                                              |
+| **Tool commands**        | What the screen calls on a Tool through `handle.tool(name)`: `tool("search")?.open()`, `tool("toc")?.jumpTo(2)`. Each returns a `boolean`; `null` instead of the commands object means the Tool is not in the set, has no commands, or the engine has not been created yet                                                                                     | Handle methods (`insertHTML`, `focus`): those are common to any `tools`, while Tool commands exist only while the Tool is enabled. `editor.commands` and `commands` in Tiptap: those are engine commands and follow its major                           |
+| **Consumer prefix**      | The start of the name of everything custom — a Tool, its Blocks, Marks and attributes — up to the underscore: `acme_mergeTag`, `data-acme_size`. Kit names have no underscore, so custom names and built-in ones never collide, either in a set or in a Document                                                                                               | A Preset: that is a set of built-in Tools, not a namespace                                                                                                                                                                                              |
+| **HTML convention**      | The form of custom content in a Document: a Block is a `div` or `span` with `data-block`, a Mark is a `span` with `data-mark`, attributes are `data-<prefix>_<name>`. Frozen: extended only by adding                                                                                                                                                          | The kit's Schema tags (`p`, `table`, `img`): a custom Block cannot take them                                                                                                                                                                            |
+| **Block trait**          | A Block property that only the kit understands, not the engine: "container" (children get their own handle), "can be turned into", "Atom without a formatting menu"                                                                                                                                                                                            | A Block attribute: that one is stored in the Document                                                                                                                                                                                                   |
+| **Extensions**           | The Tiptap extensions in a Tool description (the `engine` field): Node, Mark, Extension, ProseMirror plugins and NodeView. Supplied directly or through a Loader                                                                                                                                                                                               | Schema rules: those are data, read by the server and the View without an engine. "Engine part": the former name (ADR-0058 uses it)                                                                                                                      |
+| **Loader**               | A function with a dynamic import in place of the Extensions themselves: `engine: () => import(…)`. The heavy built-ins outside `basic` load the same way — the code Block and the table                                                                                                                                                                        | Preloading (`modulepreload`): the kit does not publish it, the consumer sets it up                                                                                                                                                                      |
+| **Handle**               | Imperative access from screen code to the Editor through `ref`: insert at the caret, read, focus, history, the commands of Tools (`tool(name)`)                                                                                                                                                                                                                | Redactor services: those are engine internals, not screen API                                                                                                                                                                                           |
+| **Readiness**            | The moment when the engine is created and the Loaders of all enabled Tools, custom and built-in, have finished: from then on Handle methods take effect instead of doing nothing. Happens once per mount; `onReady` reports it                                                                                                                                 | Hydration: after it the engine may still be waiting for Loaders                                                                                                                                                                                         |
+| **Field focus**          | Focus inside the Editor as a whole: the Document, the Toolbar, the kit's popovers, the HTML field. Moving between them does not lose Field focus; `onFocus` and `onBlur` are about it                                                                                                                                                                          | Document focus (the engine's `focus` and `blur`): a click in the Toolbar removes it                                                                                                                                                                     |
+| **Author edit**          | A change to the Document equal to typing on a keyboard: a history step, `onChange` after a delay, the character limit applies. This also covers insert, undo and redo from the Handle                                                                                                                                                                          | An External replacement                                                                                                                                                                                                                                 |
+| **External replacement** | Replacing the whole Document (`value`, `clear()`, `setMarkdown()`, `setJSON()`): the character limit does not truncate it; `onChange` fires immediately for `clear()`, `setMarkdown()` and `setJSON()`, but not for a new `value`                                                                                                                              | An Author edit                                                                                                                                                                                                                                          |
+| **Skeleton**             | The Editor's look before Readiness: the field frame, a placeholder for the Toolbar and a Document: sanitized by the Schema, it is rendered as static HTML with the same class and rhythm as the engine's Document, without input. On the server — the frame without a Document. A Loader failure turns the Skeleton into a field error with "Retry"            | The View: that is a separate read-only component, while the Skeleton is a state of the Editor that the engine replaces. The kit's `Skeleton` component: a loading placeholder                                                                           |
+| **Status line**          | A line inside the field frame under the Document: on the left the screen's content (`status`: word count, "Saved", co-author), on the right the kit's character counter                                                                                                                                                                                        | A Field notice: the line shows a lasting state of the screen, not an event                                                                                                                                                                              |
+| **Field notice**         | One event tied to the field (`showNotice`): tone `status` (only announced) or `error` (a visible line under the field until the next Author edit). A new one replaces the previous one                                                                                                                                                                         | The kit's toast: that one is global and not tied to a field                                                                                                                                                                                             |
+| **Text card**            | A non-modal card under a range of the Document, declared by a custom Tool (`textCards`): a comment, a hint from checking the text. Opens when the caret enters it or on click, focus stays in the text                                                                                                                                                         | A button popover: a button opens that one, while a Text card is opened by a place in the Document                                                                                                                                                       |
+| **Trigger character**    | A character of a custom Tool (`trigger`) that opens a list of items at the caret when typed at the start of a Block or after a space, like `/`: `@` for mentions, `#` for tags. Picking an item replaces the typed `@query` with a custom node                                                                                                                 | The Insert menu on `/`: that one is built in, while a custom character is set by a Tool                                                                                                                                                                 |
+| **Paper**                | A light area of the Document in any app theme (`surface="paper"`) — for text that leaves the app on a light background: an email, print, PDF. The Toolbar, menus and field frame stay in the app theme; the View with the same `surface` shows the same Paper                                                                                                  | The `light` theme: it changes the whole app, the Paper only the Document                                                                                                                                                                                |
+| **Island**               | A client-side piece of the View that, after mounting, brings a Block in already rendered HTML to life: the "Copy" button on a code Block, the `island` of a custom Block                                                                                                                                                                                       | A node view: it lives only in the Editor engine                                                                                                                                                                                                         |
+| **Mount point**          | A place in already rendered HTML where an Island mounts a live element: the code Block header that receives the "Copy" button                                                                                                                                                                                                                                  | A Slot: that is a place in the Editor UI for the UI contributions of Tools                                                                                                                                                                              |
+
+## Tiptap
+
+Words of the [Tiptap](https://tiptap.dev) engine that the Editor is built on. They are kept as they
+are in Tiptap's documentation: a synonym from another editor (plugin, service) would introduce a
+second meaning next to Block and Tool. The author of a custom Tool writes Extensions in Tiptap
+and reads Tiptap's documentation — the table connects the engine's word to the kit's. In the "Meaning"
+column, first what the word means in Tiptap, then what corresponds to it in the kit.
+
+| Term                      | Meaning                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Not to be confused with                                                                                                                                                                                                                                                      |
+| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Extension**             | A unit of the Tiptap engine: nodes, Marks, commands, keyboard shortcuts and ProseMirror plugins in one class (`Extension.create`; `Node` and `Mark` are its kinds). The kit uses the same word: the Extensions of a Tool are its Tiptap extensions, and a capability as a whole is a Tool. An Extension without a Schema is a Tool without a Block (`search`, `toc`)                                                                                                   | A Tool: that one also carries Schema rules, Markdown, the View and UI contributions, while an Extension is only the engine. A Tiptap extension is not passed in `tools`: it goes into the Extensions of a custom Tool                                                        |
+| **Node**                  | A node type in the Tiptap Schema: paragraph, heading, table, image; block or inline. In the kit a block node corresponds to a Block, and an inline node without content to an inline Atom (a mention)                                                                                                                                                                                                                                                                  | A Block as a whole: a Block is Schema rules as data plus Block traits, which the server and the View read, while a Node is only one of its Extensions                                                                                                                        |
+| **Mark**                  | Inline formatting in the Tiptap Schema: bold, link, color. In the kit it is a Mark: Schema rules as data and a `Mark` in the Extensions                                                                                                                                                                                                                                                                                                                                | The `mark` tag: only the `highlight` Mark renders it. Tiptap's Text Style (an empty `span` for styles) is the base of the `color` Mark, not a Tool of its own                                                                                                                |
+| **StarterKit**, **Kit**   | A set of Tiptap extensions in one package: StarterKit, ListKit, TableKit, TextStyleKit; each extension of the set is configured or switched off by a key in `configure`. In the kit StarterKit is an internal detail of the engine build: the description of each built-in Tool contributes its share of keys (`starterKit`), the shares are merged into one `StarterKit.configure`, and a key with no share is switched off. What comes out to the screen is a Preset | A Preset (`full`, `basic`): that one is a set of Tools, not of engine extensions, and it is not frozen. The kit of this glossary — the `@olddevs/ui` design system: the word Kit in Tiptap's names has nothing to do with it. `StarterKit` cannot be enabled through `tools` |
+| **options** (`configure`) | Settings of a Tiptap extension: its author declares them in `addOptions`, the consumer changes them with `configure({…})`. In the kit these are Tool options: `tool(name, options)` for `search` and `toc`, `defaults` and `tool(definition, options)` for a custom Tool (`defineTool`). Merging works as in Tiptap v3's `configure`: nested objects are merged, arrays and functions are replaced                                                                     | The options of Tiptap extensions inside the Extensions: the kit assembles built-in ones itself and does not open them to the screen. The Editor's props (`preset`, `maxHeight`): those configure the field, not a Tool                                                       |
+| **storage**               | A mutable store of an extension inside the engine (`editor.storage.<name>`): search results, the character count. In the kit it is Tool state: a snapshot that the screen reads with the `useRichTextToolState(ref, name)` hook; a custom Tool declares it with the `state` function in `defineTool`                                                                                                                                                                   | `editor.storage`: Tool state is read-only, while storage is changed by the extension itself. Storage is part of the engine and follows its major                                                                                                                             |
+| **commands**              | The commands of a Tiptap extension (`addCommands`): `editor.commands`, the `editor.chain()` chain, the `editor.can()` check. In the kit these are Tool commands: `handle.tool(name)`, each returns a `boolean`; a custom Tool declares them with the `commands` function in `defineTool`                                                                                                                                                                               | `editor.commands` and `chain()`: those are engine commands and follow its major. Handle methods (`insertHTML`, `focus`): those are common to any `tools`, while Tool commands exist only while the Tool is enabled                                                           |
+| **`extend`**              | The way to change an existing Tiptap extension: `Bold.extend({…})`. The kit has no counterpart: a built-in Tool is not replaced (ADR-0058, item 1.5). If you need other behavior, switch the built-in one off and add your own under a name with the Consumer prefix                                                                                                                                                                                                   | `configure`: that one changes options, not behavior; the kit has its counterpart — Tool options. A custom Tool "instead of" a built-in one: it has its own name, its own Blocks and Marks                                                                                    |
+| **`priority`**            | A number on a Tiptap extension: the larger it is, the earlier the extension stands in the queue and the earlier its plugins are asked. The kit has no number: the order of built-in Tools is set by the kit itself (the rank of Marks, and with it their nesting in HTML, paste and keys depend on it), and custom ones follow the built-in ones in `tools` order, so their paste and drop handlers are asked before the built-in ones                                 | The order of entries in the Toolbar and the Insert menu: the kit sets it, while the UI contributions of custom Tools stand in a Slot in `tools` order. `priority` of a `parseHTML` rule: that one is the order of parse rules of a single node                               |
+| **NodeView**              | A custom look of a node in the Editor: instead of `renderHTML`, the node is drawn by JavaScript or React code. In the kit it is the node view in the Extensions; in the View, where there is no engine, an Island is its counterpart                                                                                                                                                                                                                                   | An Island: that one brings a Block in already rendered HTML to life without an engine, while a NodeView lives only in the Editor. `renderHTML`: it produces the Document's HTML, while a NodeView is only the look on screen                                                 |
+| **MarkView**              | The same for a Mark: a custom look of a Mark in the Editor. In the kit it is the Mark's view in the Extensions; a Mark has no Island, and in the View it stays sanitized HTML                                                                                                                                                                                                                                                                                          | NodeView: that one draws a whole node, while a MarkView draws a stretch of text with a Mark. An Island: an Island exists only for a Block                                                                                                                                    |
+| **Decoration**            | Styling on top of the Document that does not change it: a highlight, a class on a node, a widget (ProseMirror's `Decoration`). The kit uses the same word: a Decoration lives in the Extensions and does not enter the Document — this is how code highlighting, Find matches and the image upload marker work                                                                                                                                                         | A Mark: a Mark is stored in the Document and goes into `value`, a Decoration does not. A Block attribute                                                                                                                                                                     |
+| **Input rule**            | An input rule: typed text matching a pattern is replaced with a node or a Mark (`# ` — a heading, `**…**` — bold). The kit has no separate term: the rule lives in the Extensions of a Block or Mark, and the author of the text sees it as a Markdown shortcut while typing                                                                                                                                                                                           | Markdown export (`getMarkdown`, `setMarkdown`): that converts the whole Document, while an input rule fires on the typed fragment. An Insert item                                                                                                                            |
+| **Paste rule**            | A paste rule: on paste or drop, text matching a pattern (most often a link) becomes a node or a Mark. The kit has the same: a rule in the Extensions of a Tool                                                                                                                                                                                                                                                                                                         | Parsing a paste through the Schema: that cuts off what the Schema does not know, while a Paste rule turns matched text into a node. A `parseHTML` rule: that one is about HTML, not text                                                                                     |
+| **Schema**                | A description of the nodes and Marks allowed in ProseMirror: which exist and what goes inside what; Tiptap assembles it from extensions. In the kit the Schema has the same meaning plus the allowlist for the sanitizer and the View: the rules lie in a Tool's description as data, and the server and the View read them without an engine, while the engine's Schema is assembled from Extensions                                                                  | Server-side sanitization: the consumer does it (`sanitizeRichText`). The ProseMirror JSON tree: it is internal                                                                                                                                                               |
+| **Transaction**           | One change of the ProseMirror engine state: steps over the Document, the selection and metadata; the `chain().run()` chain is one transaction. The kit has no word for it: Tool state is recomputed on every transaction, and an edit made by the `run` of a Block action is one transaction, that is, one undo                                                                                                                                                        | An Author edit: that is a change to the Document equal to typing, while a transaction can also happen without changing the Document (selection, metadata). Re-rendering: Tool state re-renders the screen only when the snapshot changed, not on every transaction           |