@skaile/forge-editor 0.0.0-stage → 5.0.1

package/CHANGELOG.md

@@ -0,0 +1,436 @@
+# Changelog
+
+## 5.0.1 - 2026-10-26
+
+### Fixed
+
+- Optional peer `@skaile/forge-app-actions` accepts `^0.1.0 || ^0.2.0`. A caret on 0.x excludes the next minor, so a host on forge-app-actions 0.2 (the `./chat` binding that turns `documentActions` into chat tools) got a peer warning and a second copy.
+
+## 5.0.0 - 2026-10-26
+
+### Added
+
+- `@skaile/forge-editor/ai/actions`: `documentActions({ editor, review, scope?, targets? })` returns two forge actions (`@skaile/forge-app-actions`, optional peer `^0.1.0`) that put the document chat into any chat with client tools: `doc.read` (the document as block lines, `[<block id>] <Markdown>`) and `doc.propose_ops` (edit operations in the shape and limits of the `edit_document` tool, checked with `checkAgentOps` against the block IDs, the `scope` and the convert `targets`; valid ones open as review hunks in `review`, invalid ones come back as `problems` for the model to correct). Operation IDs continue the review's own counter (`nextOp`/`advanceOp`), so the numbering holds across turns and next to the editor's own document chat. The capability names are `app.doc.read` and `app.doc.propose_ops`.
+- `TransferFeatureOptions.extraTransforms`: transforms offered after the default list (or after `transforms`), so an add-on's transforms join the built-in ones without the host listing them again. `AdvancedEditor` (Vue and React `ComposedSurface`) takes `transfer` and `explore` and passes them to `composeEditor`, so a host opts into `'transfer'` and `'explore'` by catalog id with their options instead of adding the features through `add`.
+- Add-on helpers (`/core`: `createCatalogTranslator`, `CatalogTranslate`, `CatalogParams`, `renderFileNameOf`, `MAX_RENDER_FILE_STEM`, `safeLinkUrl`, `SafeLinkOptions`): `createCatalogTranslator(catalog, overrides?)` is the `{name}` translator over one language's string catalog (the library's own `createTranslator` and the string tables of the add-ons use it); `renderFileNameOf(content, fallback, extension)` is the file name a render target gives its output (title of a Typed block, else first heading or paragraph of a Document, cleaned of characters a file system rejects, cut to 80 characters); `safeLinkUrl(value, { relative? })` returns a link that cannot run script (`http:`, `https:`, `mailto:`, relative unless `relative: false`), read the way a browser reads it (`java\tscript:` is refused), else `null`. The `markdown` render target uses `renderFileNameOf`, so a Document whose first heading follows a paragraph is now named after the heading.
+- Node views by Block type id (`/composites`: `CompositeNodeViews.byType`; `CompositeFeatureOptions.blockNodeViews`, `ComposeOptions.blockNodeViews`, the `blockNodeViews` prop of `AdvancedEditor` and `ComposedSurface`): an add-on that draws its own Block type (the charts add-on's `chart`) replaces the standard Typed block view for that type. Also exported for add-ons: `displayEnv`, `subscribeBlockChanges`, `FOREIGN_CONTENT_REFRESH_MS`.
+- Embeddings port and search by meaning (`/server`: `Embedder`, `EditorPorts.embeddings`, `BlockIndex.nearest?`, `BlockIndex.related?`; `/core`: `fuseRanks`, `RANK_FUSION_K`, `DEFAULT_FUSION_WEIGHTS`; new entry `/adapters/embeddings`: `createOpenAiEmbedder(options)` over an OpenAI-compatible `/embeddings` endpoint, `OPENAI_EMBEDDING_DIMENSIONS`; `BackendCapability` unchanged, the server lists `embeddings` in `GET /api/editor/capabilities` as `ServerCapability`): `embeddings` is the port that turns text into vectors, an index that keeps vectors (`@skaile/forge-editor-index-pg`) takes the same embedder. `GET /api/editor/search` fuses the keyword hits with the `nearest` Blocks by reciprocal rank fusion (`fuseRanks`, k = 60, weights 0.7 / 0.3) when the host has the port and the index has `nearest`, and answers the keyword hits when the embedder fails; `GET /api/editor/blocks/:documentId/:blockId/related` prefers `index.related` and falls back to the shared-tags heuristic. Without `embeddings` nothing changes.
+- Query builder (`/composites`: `QueryBuilder` Vue and React forms, `createQueryBuilderModel`, `createEditorQueryBuilder`, `opsOfField`, `valueInputOf`, `fieldChoicesOf`, `conditionValueOf`): data views get a form that edits their stored query: Block type, a flat AND list of `field op value` conditions (fields are the properties of the type plus the pseudo-fields, the operators are the `ops` of the field's kind, the value input follows the kind and operator), one sort and one group field. A complete, valid query is written to `meta.query` (`validateQuery`); an unfinished row writes nothing, and parts the form has no control for (search, aggregates, further sorts, other types, a filter with `or`) are kept. The layout bar of a data view has a button that opens the form.
+- Data views (`/composites`: `DATA_VIEW_TYPE`, `DATA_VIEW_QUERY_KEY`, `DATA_VIEW_LAYOUT_KEY`, `dataViewQueryOf`, `dataViewLayoutOf`, `newDataViewMeta`, `createDataViewModel`, `createEditorDataViewModel`, `chooseDataViewLayout`, `insertDataView`, `mostUsedBlockTypeOf`, `localRowsOf`, `VIEW_LAYOUTS`, `LAYOUT_IDS`, `viewModelOf`, `missingRequirementsOf`, `tableColumnsOf`, `fieldColumnsOf`, `DataView` Vue and React node views, `CompositeNodeViews.dataView`): Block type `dataView` stores only its query and layout (`meta.query`, `meta.layout`), never rows, and shows the answer as table, list or board (a board needs a group; its lanes are the options of the grouped property, `status` groups included). The model asks `backend.index.query` (else the Blocks of the open Document through `evaluateQuery`), asks again after a debounced change of the Blocks and every `FOREIGN_CONTENT_REFRESH_MS` while on screen. `/ansicht` inserts a view over the Document's most used Typed block type (`insertComposite(kind, meta)` takes the new block's `meta`). The Typed blocks table (`tableViewOf`, `CompositeTable`) now reads its columns from the `table` layout (`cellTextOf` exported), so there is one table implementation; the column derivation (`fieldColumnsOf`) moved to `views/layouts`. Guide "Data views".
+- Speech and render records exported from `/core` (`SpeechEngineInfo`, `SpeechVoice`, `SpeechFormat`, `SpeechRequest`, `SpeechBody`, `SpeechSegment`, `RenderTargetInfo`, `RenderInput`, `RenderBody`, `RenderProgress`, `RenderDone`, `RenderResult`): types only, so an add-on names what `EditorBackend['speech']` and `EditorBackend['render']` take and return (both resolve with `RenderResult`) without a path into the library's source.
+- Knowledge graph port (`/server`: `KnowledgeGraph`, `EditorPorts.knowledge`; `/core`: `KnowledgeNode`, `KnowledgeHit`, `KnowledgeEdge`, `KnowledgeNeighbours`, `KNOWLEDGE_QUERY_MAX`, `KNOWLEDGE_ID_MAX`; new entry `/adapters/knowledge`: `createMemoryKnowledgeGraph(nodes, edges)`, `MEMORY_KNOWLEDGE_LIMIT`): the host's graph of sources, concepts and notes outside the Documents, read only (`search(q, user)`, `neighbours(id, user)` and an optional `origin(id, user)`: where a node came from). New capability `knowledge` and routes `knowledgeSearch` (`GET /api/editor/knowledge/search?q=`) and `knowledgeNeighbours` (`GET /api/editor/knowledge/nodes/:id/neighbours`), `401` without a user, `400` for a blank, missing or over-long input, `501` without the port; `EditorBackend.knowledge?: { search(query, signal?), neighbours(id, signal?) }`. The Explore panel gets a fourth tab `knowledge` („Wissensgraph“, `ExploreTab`, `ExploreState.knowledge`, `.query`, `.focus`, `ExploreModel.focusNode`, `exploreTabLabel`, `exploreKnowledgeLinksOf`) when the backend has the capability: the nodes the graph finds for the Block's title (label, kind, score), and the neighbours of the node you click. The add-on `@skaile/forge-editor-kgs` provides the port over the KGS SDK. Guide: `guides/knowledge-graph`.
+- Explore feature (new entries `/explore`, `/explore/vue`, `/explore/react`: `exploreFeature`, `exploreFeatureCore`, `createExploreModel`, `exploreTabsOf`, `exploreCountOf`, `exploreKindLabel`, `ExplorePanel`, `ExploreSection`, `useExploreModel`; `/core`: `derivationTrailOf`, `TRAIL_MAX_HOPS`, `TrailStep`, `TrailSource`, `relatedBlocks`, `relatedScore`, `RELATED_LIMIT`; catalog id `explore` and `ComposeOptions.explore`): an opt-in interaction feature (in no level list: `interaction: [...INTERACTION.full, 'explore']`; `requires` `composites` and the backend capability `index`) that shows for one Block its backlinks (the incoming Edges without `tag`), its related Blocks and its Derivation trail in the `ExplorePanel` the host places, plus the inspector section „Verknüpfungen“ with the counts and a button to the panel (`show`, else inline). New route `blockRelated` (`GET /api/editor/blocks/:documentId/:blockId/related`, answers `BlockSearchHit[]`: 2 points per shared tag, 3 per shared reference target, 1 when the text holds every word of the title, best ten, the Block itself never; `[]` for an unknown Block, `401` without a user, `403` for an unreadable Document, `501` without the `index` port) and `EditorBackend.index.related?`; the in-memory backend ranks with the same `relatedBlocks`. `derivationTrailOf(address, index)` follows `derivedFrom` through `blockGet` up to 8 Derivations back, the original first, each step with the state the row badge shows. Messages `explore.*` (de, en). Guide `32.explore.md`.
+- Block type `collection` (`/composites`: `COLLECTION_TYPE`, `COLLECTION_ITEMS_KEY`, `COLLECTION_QUERY_KEY`, `collectionItemsOf`, `collectionQueryOf`, `withCollectionItems`, `collectionViewOf`, `collectionChoicesOf`, `addToCollection`, `moveCollectionItem`, `removeCollectionItem`, `setCollectionItems`, `fillCollectionFromQuery`, `typedBlockViewOptions`; `CompositeNodeViews.collection?`; Vue and React `CollectionView`): a Typed block that lists other Blocks as an ordered `reference-list` property `items` (an address with `documentId` `''` is a Block of this Document) and keeps an optional `DataQuery` as JSON text in the hidden property `query`. Its node view shows the entries as reference pills in order, with move up, move down and remove, and a „Aus Abfrage füllen“ button (only with a stored query and a backend whose `index.query` exists) that runs the query and appends the hits that are not listed yet. New block action `collection-add` („Zu Sammlung hinzufügen“, a menu of the collections of the open Document) on every Typed block. The Markdown export of a collection (`documentCompositeMarkdown`, `headingsMarkdown`, `compositeChromeBlocks`; new `collectionItemBlocks`) lists its entries as `[@id]` lines in the stored order, and the meta line leaves out hidden and `reference-list` properties. The Vue and React `typedBlock` renderers now take `typedBlockViewOptions` (a Typed block whose type changes gets the other view) and `CompositeView` renders `children` after its content. Guide `30.collections`.
+- Property kind `source-anchor` and the anchor locator (`/core`: `SourceAnchor`, `AnchorRect`, `AnchorQuote`, `sourceAnchorOf`, `sourceAnchorText`, `anchorLocatorOf`, `parseAnchorLocator`, `locatorLabelOf`; `/composites`: `REVEAL_ANCHOR_EVENT`, `SourceLocator` gains `anchor`): `PROPERTY_TYPES` gains `source-anchor`, a passage of a PDF `{ page, rects, quote: { exact, prefix?, suffix? } }` (`rects` are fractions of the page, so the passage survives a change of zoom). `PROPERTY_KINDS['source-anchor']` orders, compares and groups by page, reads as the quoted text and takes `eq` `ne` `lt` `lte` `gt` `gte` `contains` `isEmpty` `isNotEmpty`; `metaWithProperty` keeps only a valid anchor, the field editors (Vue and React) show page and quote read-only, and the AI context and the chat model learn the type. A reference chip locator may now be `page=<n>&anchor=<base64url JSON>`: `parseLocator` returns `{ page, anchor }`, chips and backlinks show it as `S. <n>` (`locatorLabelOf`), and `revealSource` dispatches `sk-reveal-anchor` (`REVEAL_ANCHOR_EVENT`, `detail` = the `SourceAnchor`) after `sk-reveal-page` on the PDF source block, so a viewer can scroll to the passage. The PDF viewer is the add-on `@skaile/forge-editor-pdf-viewer`.
+- Edge graph route (`/core`: `GraphData`, `GraphNode`, `GraphSource`, `GraphWalkOptions`, `walkGraph`, `graphSourceOfRows`, `DEFAULT_GRAPH_DEPTH`, `GRAPH_MAX_DEPTH`, `GRAPH_MAX_NODES`): `walkGraph` is a breadth-first walk over the Edges of the Block index in both directions, at most three hops deep and at most 500 Blocks (`truncated` says when more were left out); `tag` Edges and Edges to Blocks outside the scope are never part of it. New route `graph` (`GET /api/editor/graph?documentId=&blockId=&depth=`, answers `GraphData` `{ nodes: { address, title, type }[], edges: BlockEdge[], truncated }`, `depth` 1 to 3 with default 2, `400` for another `depth` or without `documentId`, `401` without a user, `403` for an unreadable Document, `404` for an unknown `blockId`, `501` without the `index` port) and `EditorBackend.index.graph?` (optional; the memory backend answers it too). It is what the `@skaile/forge-editor-graph` add-on draws.
+- Query model and evaluator (`/core`: `DataQuery`, `SourceRef`, `BlockScope`, `FilterNode`, `FilterCondition`, `SortSpec`, `GroupSpec`, `AggregateSpec`, `SearchClause`, `DataRow`, `DataResult`, `QueryIssue`, `QueryRequestBody`, `PSEUDO_FIELDS`, `MAX_QUERY_ROWS`, `validateQuery`, `evaluateQuery`, `narrowScope`): a query is data (`{ v: 1, source, filter?, search?, sorts?, group?, aggregates?, select?, page? }`) over the Blocks of the Block index, filtered with and/or conditions whose operators come from `PROPERTY_KINDS`, with the pseudo-fields `$title`, `$tags`, `$type`, `$id`, `$doc`, `$basket`, sorted with `nulls`, grouped and totalled, paged by a cursor (the base64 row offset). `BlockIndex.query(query, scope, env, definitions?)` (`/server`; memory and drizzle adapters evaluate `evaluateQuery` in JS, `queryDefinitionsOf` gives the Property definitions of the host's Block types, `HandlerContext.blockTypes` carries them to the handler; a custom `BlockIndex` must implement it). New route `dataQuery` (`POST /api/editor/query`, body `{ query, env? }`, port `index`, handler `blockQuery`; `401` without a user, `400` for a body that is no query, `422` with the issues for a query with an error issue, `501` without the `index` port) and `EditorBackend.index.query?(query, { env?, signal? })`. The `find_blocks` tool of `createWorkspaceTools()` takes `blockType` and `filter` and then lists the Blocks of that type whose Properties satisfy the filter (with `query`: only hits of the search), each hit with its `values`. Guide: [Query](https://skaile-ai.github.io/skaile-editor/guides/query).
+- Import duplicate check (`/core`: `ImportCheckBody`, `ImportMatch`, `ImportMatchReason`, `importMatchesOf`, `settleImportMatches`, `normalizeDoi`, `MAX_IMPORT_MATCHES`, `SHA256_HEX`; `/media`: `fileImportOptions`, `FileImportOptions`; `Notice.secondaryAction`): new route `importCheck` (`POST /api/editor/import/check`, body `{ sha256?, doi?, title?, type? }`, answers `ImportMatch[]` `{ address, title, reason: 'sha256' | 'doi' | 'title' }`, `400` without one of the three, `401`, `501` without the `index` port) and `EditorBackend.index.importCheck?` (optional: a backend without it imports without the check). `projectDocument` copies the SHA-256 of an uploaded file into `properties.sha256` of its Block (a media block, or a Typed block whose first body block is the file). `fileImport` / `useFileImport()` hash a dropped file and ask the index before the upload, and for every Typed block of the plan (title, DOI); a hit is offered in a notice: reference the existing Block (a reference chip) or insert anyway. The route needs no new `BlockIndex` method: it reads through `byDocument`, `documentIds` and `search`. `fileImport(notify, t, options?)` takes a third argument. Guide: `34.importers`.
+- Speech port (`/server`: `SpeechProvider`, `createSpeechBudget`, `SPEECH_CHARS_PER_DAY`, `SpeechBudget`, `SpeechBudgetOptions`; `/core`: `SpeechEngineInfo`, `SpeechVoice`, `SpeechRequest`, `SpeechBody`, `SpeechFormat`, `SpeechSegment`; capability `speech`, `EditorPorts.speech?`): the host passes one `SpeechProvider` (`engines(user)`, `synthesize(request, user, signal)`, optional `transcribe`). New routes `speechEngines` (`GET /api/editor/speech/engines`) and `speechSynthesize` (`POST /api/editor/speech`, SSE `progress`, then `done { asset, fileName, mime }` or `error { message }`; the audio is stored as an asset of the Document through the `assets` port, `501` without it, `404` unknown engine or voice, `403` unreadable Document), handlers `speechEnginesGet`/`speechSynthesizePost` in `/server/handlers`, `EditorBackend.speech?: { engines(), synthesize(request, { onProgress, signal }) }` (the HTTP backend shares the SSE loop with `render`). Each user may synthesize `SPEECH_CHARS_PER_DAY` (50 000) characters per UTC day, counted in memory per process (`HandlerContext.speechBudget` replaces the budget, e.g. in a test); beyond it the route answers `429` with `Retry-After`, and a failed synthesis gives its characters back. New entry `@skaile/forge-editor/adapters/speech` (`createOpenAiSpeech` over `POST <endpoint>/audio/speech`, `OPENAI_VOICES`, `createMemorySpeech` answering a second of silent WAV, `silentWav`). `/transcript` gains the pure subtitle writers `vttOf(cues)` and `srtOf(cues)`, `transcriptCuesOf(node)` and the type `TranscriptCue`, and the transcript feature the read-only block action „Untertitel exportieren“ (`transcript-export`) that downloads the timed segments of a Typed block as `.vtt` or `.srt` (message keys `transcript.export.*`). Guide: [Speech](https://skaile-ai.github.io/skaile-editor/guides/speech).
+- Freigabestatus `vorgeschlagen` and the export check (`/composites`: `isAiProposal`, `exportIssuesOf`, `ExportIssue`, `ExportIssueCode`, `exportCheckSectionOf`, `exportCheckInspectorSection`, `provideCheckProbe`, `CheckProbe`, `subscribeExportCheck`; `/composites/vue` and `/composites/react`: `ExportCheckSection`; `CompositesUi.exportCheck`): a Typed block whose Derivation names the model (`method` `ai:<type>` or `activity.agent`) and whose body is still the text the model wrote (`outputHash` equals the live body hash) reads `vorgeschlagen` for every Prüfung kind without a record, where it read `offen`; an edit of the body ends the proposal (`offen`), a record makes it `geprueft`. `PruefungKindStatus` gains the value, `freigabeOf` counts it as open, the chip shows „KI-Vorschlag“ (`pruefung.status.vorgeschlagen`), `pruefungKindLabel` is exported from `/pruefung`. Nothing is stored: the decision stays the Prüfung. The block action „Als Markdown exportieren“ now runs `exportIssuesOf` (`ai-unchecked`, `stale-derived`, `source-missing`, `unresolved-reference`), shows „n Hinweise“ as a warning notice when there are any, and still exports; the inspector section „Export-Hinweise“ lists them. The `pruefung` feature tells the check through `provideCheckProbe` whether a block still waits for a Prüfung. Guide: [AI proposals and the export check](https://skaile-ai.github.io/skaile-editor/guides/export-check).
+- Edges in the Block index (`/core`: `BlockEdge`, `BlockEdgeRow`, `EdgeKind`, `EdgeOrigin`, `AuthoredEdge`, `META_EDGES_KEY`, `authoredEdgesOf`, `blockEdgesOf`, `edgesInto`, `isTagEdgeTarget`; `BlockRow.edges`): `projectDocument` lists the connections of every Block: `reference` (reference chips), `derivation` (the Block the Derivation names), `embed` (`blockEmbed`), `tag` (target `{ tag }`) and, with `origin: 'meta'`, the Edges a person added in `meta.edges`. `BlockIndex.edges(address, direction, scope)` (`/server`) answers `'out'` (written in the Block) or `'in'` (the backlinks: other Blocks pointing at it, never `tag` Edges) within the scope; a custom `BlockIndex` must implement it. New route `blockEdges` (`GET /api/editor/blocks/:documentId/:blockId/edges?direction=in|out`, `in` by default, port `index`, handler `blockEdges` in `adapters/index/handlers`; `403` for an unreadable Document, `400` for another direction), `EditorBackend.index.edges?(address, direction?, signal?)` (optional). The drizzle adapter writes a second table `editor_block_edges` in the transaction of `replace` with an index on the target: `blockIndexTables()` now returns `{ blocks, edges }` (a host that passed the single table to its drizzle schema adds both), `bootstrapBlockIndexTables` creates both. The composites feature adds the inspector and details section „Kanten“ (`CompositesUi.edges`; `/composites/vue` and `/composites/react`: `EdgesSection`; `/composites`: `edgesSectionOf`, `addAuthoredEdge`, `removeAuthoredEdge`, `edgeTargetChoicesOf`, `edgesInspectorSection`) to list, add (kind as text, target from the `[@` popup's list) and remove authored Edges. New message keys `composites.edges.*`. Guide: [Edges](https://skaile-ai.github.io/skaile-editor/guides/edges).
+- Renderer port (`/server`: `Renderer`, `RenderProgressReporter`, `EditorPorts.render`; `/core`: `RenderTargetInfo`, `RenderInput`, `RenderBody`, `RenderProgress`, `RenderDone`, `RenderResult`; capability `render`, appended to `BACKEND_CAPABILITIES`): export formats beyond the editor's own. New routes `renderTargets` (`GET /api/editor/render/targets`) and `renderPost` (`POST /api/editor/render`, server-sent events `progress`, then `done { asset, fileName, mime }` or `error { message }`; the result is stored as an asset of the Document through the `assets` port, `501` without it, `404` unknown target, `422` a Block type the target does not accept). `EditorBackend.render?: { targets(), render(target, input, { onProgress, signal }) }`. New entry `@skaile/forge-editor/adapters/render` (`createRenderer(targets)`, `RenderTarget`, built-in `markdownTarget(options?)`). `core/sse.ts` holds the one SSE client: `readSseStream` (the parser the HTTP backend used inline) and the generic `postSse(events, onEvent)`; `postAiSse` now delegates to it. `documentCompositeBlocks(schema, node, kinds)` is split out of `documentCompositeMarkdown`. The composites feature adds the block action `render` („Erzeugen als …“, a menu of the targets that accept the Block type) and the command `render-document` (⌘K) when the backend serves `render`; `downloadUrl` joins `downloadText` in `/core`. Guide: [Render](https://skaile-ai.github.io/skaile-editor/guides/render), reference: Renderer port.
+- Importer registry (`/core`: `Importer`, `ImportPlan`, `ImportFallback`, `importersOf`, `planImport`; feature field `importers`): the singleton pipeline hook `wrapImport` (and `wrapImportBlocks`) is replaced by an additive list of file importers. The first importer in feature order whose `accepts` (MIME types, `.ext`, `*`) matches plans the file; no match falls back to the media/file import. An importer accepting `*` wraps the plan of the others: `composite-media` is now `importers: [mediaImporter]` with the same wrapping behaviour, and it merges the plan's `properties` into the Typed block's `meta`. `defineEditor` throws for a duplicate importer id, `checks/composition.ts` covers it. The `media` feature contributes `markdownImporter` (frontmatter becomes `properties`, via `parseFrontmatter`), `subtitleImporter` (`.vtt`, `.srt` become one transcript block with a `transcriptSegment` per cue, `parseSubtitles`, `cueTime`) and `bibImporter` (`.bib` becomes one `paper` or `book` block per entry, new `parseBibtex` to CSL; all exported from `/media`). `fileImport` reports plan warnings in a notice (`media.import.warnings`). Breaking for feature authors: replace `blocks: { wrapImport }` by `importers`. Guide `34.importers.md`.
+- Derivation v2 (`/core`): `Derivation.inputs` (named inputs `{ from, hash }` of an N-to-1 Derivation) and `Derivation.activity` (`{ id, agent?, at? }`, the run that produced the Block). New `derivationFingerprint({ method, inputs })` (SHA-256 over the method and the input hashes by input name; the key order does not matter), `derivedStateOf(state)` and `DerivedStateId` (`'fresh' | 'stale' | 'edited' | 'missing' | 'foreign'`). `derivationState` takes a sixth argument `inputHashOf(from)`: a Derivation with `inputs` is `stale` when any input's live hash differs, `null` without the lookup. The AI rendition (`createRendition`) and „Ableiten (KI)“ (`deriveComposite`) record their `activity`. The composites feature adds the row badge `derivedRowBadge` (`/composites`: `derivedRowBadge`, `derivedChipOf`, `derivedStateLabel`): „veraltet“ for a Derived block whose original changed, „Quelle fehlt“ for one whose original is gone; the Document tree shows a dot with the reason for a stale, missing or edited Derived block. New message keys `composites.derivation.state.<fresh|stale|edited|missing|foreign>`.
+- Property kinds (`/core`: `PROPERTY_KINDS`, `PropertyKind`, `statusGroupOf`, `PropertyType`, `PropertyOption`, `STATUS_GROUPS`, `StatusGroup`, `blockAddressesOf`; types `FilterOp`, `AggregateFn`, `QueryEnv`, `Scalar` from the new `core/query-types.ts`): one registry entry per entry of `PROPERTY_TYPES` says which filter operators apply, how a value sorts and groups, which aggregates fit and how it reads as text. `PROPERTY_TYPES` gains `checkbox` (stored `true`; unchecked removes the key), `url`, `status` (a select whose options carry a `group`: `todo`, `doing` or `done`; the status chip follows the group) and `reference-list` (`BlockAddress[]`, `documentId` `''` = this Document); the Vue and React field editors edit all four (`ReferenceListFieldEditor`) and the AI chat and brief know them. `PropertyDefinition.hidden` keeps a property out of the Block inspector, the details popover and the Block table. A `PropertyDefinition` key that starts with `$` is rejected in a Block type (reserved for the pseudo-fields of a Block query). Guide: [Block properties](https://skaile-ai.github.io/skaile-editor/guides/block-properties).
+- Inline `cite` node (`/composites`, `/composites/schema`: `CiteNode`, `CITE_NODE`, `CITE_TRIGGER`, `citeMarkdown`, `citeAttrsOf`, `citeEntriesOf`, `citeText`, `resolveCite`, `citeSuggestion`; commands `insertCite`, `setCiteLocator`; `bibtexKey` is now exported; Vue and React `CiteView`; `CompositeNodeViews.cite` is optional): `/zitat` or `[cite:` opens a picker over the Document's bibliography entries (Typed blocks with `meta.bib`), and the chip shows `(Autor Jahr)` or `(Autor Jahr, S. 12)` through `citeShort`, follows edits of the entry, reveals it on click and takes a locator on double click. `key` is the entry's BibTeX key (the one `bibtexOf` writes). Markdown is `[cite:<key>]` / `[cite:<key>, <locator>]` (`[@` stays the reference chip's); it parses straight back into the node. The Block index text of a Block holds `[cite:<key>]` for a citation. Guide: [Citations](https://skaile-ai.github.io/skaile-editor/guides/citations).
+- Preset bundles: `composeBundle(bundle, options?)` (`/vue/advanced`, `/react/advanced`; `composeBundle(ui, bundle, options?)` in `presets/compose`) composes the named bundles `simple`, `writing`, `collaborative` and `advanced` (`BUNDLES`, `BundleId`, `Bundle`), with `with` (catalog features added on top, an AI id switches `ai` on; an id outside the catalog throws) and `without` (merged into `remove`) in `BundleOptions`. `simpleEditor()` and `advancedEditor(options)` are bundle calls; the `advancedEditor` options are now `BundleOptions`, so `content`, `interaction` and `ai` are no longer overridable there (use `composeEditor`). Guide: Bundles in [Feature composition](https://skaile-ai.github.io/skaile-editor/guides/composition#bundles).
+- Brand naming and the optional-peer check: `check:editor-entries` fails when a `peerDependenciesMeta` entry lacks `optional: true` or when `react`, `react-dom`, `vue`, `nuxt`, `@nuxt/ui`, `@tiptap/react`, `@tiptap/vue-3`, `@iconify/react` or `@iconify/vue` is a peer without such an entry. `--sk-success` in `vue/kit/nuxt-ui.css` and `--ui-success` in the Obsidian bridge (`styles/themes.css`) read `var(--color-success, …)` first, so the brand bridge wins when present (as in `react/styles/ui-vars.css`). The React examples pin `@skaile/brand` `^0.6.0` (`@ecsplico/brand` exports only `./nuxt-ui.css`, so they keep `@skaile/brand/theme.css`); `docs/content/3.guides/12.themes.md` explains which package is which.
+- `BlockAction.readOnly?: boolean` and `BlockAction.onHover?(ctx, entering)` (`/core`, `BlockActionContext` as in `run`): a Block action marked `readOnly` is offered in a read-only editor too; every other action is hidden there (`blockActionsFor`). `selectedBlockOf` no longer returns null for a read-only editor, and the Vue and React `BlockActionsOverlay` show the bar whenever an action remains and call `onHover` when the pointer enters or leaves an action's button. New hover action `composite-details` („Details“, `i-lucide-info`, order 405, `ABILITY.compositeMeta`, `readOnly`) opens the details popover of a Typed block through `openCompositeDetails(editor, node)`; the chrome binds each popover to the new `CompositeStorage.detailsOpen` store. Guide: [Block UI](https://skaile-ai.github.io/skaile-editor/guides/block-ui#actions-in-a-read-only-editor).
+- Dokumentvorlagen (`/core`: `expandTemplate`, `expandTemplateContent`, `templatesOf`, `TEMPLATES_FOLDER`, `TemplateEnv`, `ExpandedTemplate`): `expandTemplate(text, { title, now, locale })` expands `{{title}}`, `{{date}}` (medium), `{{date:short|medium|long|iso}}`, `{{time}}` and `{{cursor}}` (removed, its offset is returned) and leaves every other `{{…}}` as written. A Document inside the folder named `Dokumentvorlagen` is a Dokumentvorlage: `POST /api/editor/documents` takes an optional `templateId` (`API.documentCreate`, `EditorBackend.documents.create`), and the new Document starts as a copy of that Dokumentvorlage with every text node expanded (`{{title}}` is the new title, dates use the first `Accept-Language` tag, default `de`); the route answers `404` for an id outside the Dokumentvorlagen folder and `403` for a Dokumentvorlage the user may not read, and the Dokumentvorlage itself stays unchanged. The reference app's Documents page lists the Dokumentvorlagen under „Aus Dokumentvorlage“. Guide: [Templates](https://skaile-ai.github.io/skaile-editor/guides/templates).
+- Documentation of the workspace layer: the guide [Workspace](https://skaile-ai.github.io/skaile-editor/guides/workspace) (Block index and its adapters, the block route, Workspace search, references across Documents, Document routes and the `DocumentMutator`, Tool providers, change sets, `blockEmbed`), `docs/adr/0003-one-host-now-apps-ejectable-later.md` (what the library owns and what a host chooses) and the glossary entries **Block address**, **Block index**, **Workspace search**, **Change set**, **Embed** (home and mount) and **Tool provider** in `CONTEXT.md`. Five snippets under `docs/snippets/` (`workspace-*.ts`) are typechecked code.
+- `BlockIndex.documentIds()` (`/server`; memory and drizzle adapters): the Documents that have at least one row, listed without reading any Document. A custom `BlockIndex` must implement it. `readableDocumentsOf` takes its candidates from `documents.listDocumentIds`, else `index.documentIds()`, else the IDs of `listContents`.
+- One read rule for Documents (`server/readable-documents.ts`: `documentAccess`, `readableAmong`, `mayReadDocument`, `mayEditDocument`, `readableDocumentsOf`; `/server` exports `mayReadDocument` and `readableDocumentsOf`): `identity.readableDocuments(user)` decides what a user may read when the host has it, else `authorize(user, id)` does, and with neither every authenticated user may. A Document that `readableDocuments` names but `authorize` refuses is read-only. `accessOf` delegates to it, so the block route, the tree and list, the ops route, the document GET, the search and the chat's tools answer the same for a host that implements only `readableDocuments`, only `authorize` or both.
+- Embeds are bounded: they nest 3 levels deep (`MAX_EMBED_DEPTH`) and one outermost embed mounts at most 24 embeds at once (`MAX_EMBED_VIEWS`); past either bound an embed shows the new state `limit` (`data-state="limit"`, message `composites.embed.limit`) and neither reads nor follows its Block. Before, a chain of Blocks that embed the next one twice mounted 2^n views.
+- Change sets: `changeSetOwner(user)` (`adapters/change-sets/owner.ts`) is the one function that derives the owner key (`ChangeSet.by`) for the chat route, the store and the change set routes, and `AGENT_OP_ID` (`core/change-set.ts`) is the pattern of an operation ID (`op1`, `op2`, …) that the chat route and the change set routes share. Accepting hunks claims them atomically, so two concurrent requests cannot apply the same hunk twice, and a failure of the `DocumentMutator` that is no `HttpError` marks the hunk `invalid` instead of leaving it `pending`.
+- Maintenance of the Block index after a write (`withBlockIndex`, `DocumentMutator`) never fails the write: a failed re-projection is logged, and the next write of the Document re-projects it.
+- The agent operation types `AgentOp`, `ModelAgentOp` and `AgentOpFeedback` live in `core/agent-op-types.ts`, and `DocumentSummary` and `TreeFolder` in `core/document-summary.ts`, because `/core` contracts (`EditorBackend`, `API`, `ChangeSet`) name them and core must not import a feature or the tree module. `features/ai/protocol/agent-ops.ts` and `tree/types.ts` re-export them, so the public entries (`/ai` protocol, `/tree`) export them as before.
+- `blockEmbed` (`/composites`: `BlockEmbedNode`, `BLOCK_EMBED_NODE`, `blockEmbedMarkdown`, `blockEmbedSuggestion`, `embedStateOf`, `embedChainOf`, `mountEmbed`; Vue and React `BlockEmbedView`): a Block of any Document mounted read-only in another Document and edited at its home. An atom block node (`documentId`, `blockId`, `mode: 'block' | 'children'`, `label`) with no content in the Yjs state; Markdown `![[<documentId>#<blockId>]]` (`|children` mounts the Blocks nested in it). The node view renders the home Block's current content from the Block index (a Block of the open Document is read from the editor itself, so its edits show at once) and refreshes it every 4 s, shows `gone`, `unavailable` and `loading` states, nests embeds recursively and stops an embed whose home Block is inside its own chain (`cycle`, no endless render). `![[` opens a picker over `index.search` (also `/einbetten`); „Am Ursprung bearbeiten“ calls the new option `openBlock(address)` of `compositeFeature` (`composeEditor`, `AdvancedEditor` and the React `ComposedSurface` pass it as `openBlock`). `CompositeNodeViews.blockEmbed` is optional: a binding without it shows the embed's static label. The block route takes `?content=block|children` and answers the Block's nodes from the collaboration server's live content (else the stored one) in `BlockSummary.content` (`400` for any other value); `EditorBackend.index.blockGet(address, signal?, content?: BlockContentMode)` and the memory backend carry it, `blockContentOf` and `BlockContentMode` are exported from `/core`. The foreign Block cache keeps answers with content apart from summaries (`foreignBlockLookup`, `FOREIGN_CONTENT_REFRESH_MS`).
+- Document routes (`/server`, `/core`): `DocumentAdmin` gains `listTree()`, `createDocument({ title?, folder? })` and `moveDocument(id, folder)` (a documents port that implements them serves the routes below; without them they answer `501`). New rows of `API`: `GET /api/editor/documents` (`documentList`: the Documents the user may read, newest first), `GET /api/editor/tree` (`documentTree`), `POST /api/editor/documents` (`documentCreate`, `201` with the `DocumentSummary`), `PUT /api/editor/documents/:id/folder` (`documentMove`), `DELETE /api/editor/documents/:id` (`documentDelete`: the collaboration server forgets the Document first, then `deleteDocument`, and the Block index drops its rows) and `POST /api/editor/documents/:id/ops` (`documentOps`). The HTTP backend offers them as `EditorBackend.documents.list/tree/create/move/remove/applyOps`. The Nuxt reference host's tree store is a client of them; its `/api/documents` list/create/delete routes and `/api/tree` are gone.
+- Cross-Document agent edits as a change set. `AgentOp.documentId?` (`/ai`, `features/ai/protocol/agent-ops.ts`) aims an operation of `edit_document` at another Document of the workspace; `checkAgentOps` checks the block IDs per Document (`AgentOpContext.documents`: the lines of the other Documents the user may edit; a Document it does not know is an `AgentOpProblem` with the new reason `document`), `AgentOpFeedback.documentId` carries the Document back to the model, and `agentOpSummary` names it. Operations for the open Document keep feeding `review.propose`; the others become a stored `ChangeSet` (`/core`: `ChangeSet`, `ChangeSetHunk`, `ChangeSetHunkStatus`, `ChangeSetOp`, `ChangeSetFeed`, `ChangeSetDecisionBody`, `hunkFeedback`, `changeSetDocuments`, `CHANGE_SET_HUNK_STATUSES`). New port `EditorPorts.changeSets` (a `ChangeSetStore`: `list(owner)`, `get`, `create`, `decide`; capability `changeSets` in `PORT_CAPABILITY`, JSON adapter `createJsonAdapter(...).changeSets` on `.change-sets.json`, in-memory store in `adapters/change-sets/memory`). New rows of `API`: `GET /api/editor/change-sets` (`changeSetList`), `POST /api/editor/change-sets/:id/accept` (`changeSetAccept`: each pending hunk named in `{ hunks: ['op3', …] }` is applied through the `DocumentMutator`; `409` becomes the hunk status `stale`, `403`/`404`/`422` `invalid`, with the server's message) and `POST /api/editor/change-sets/:id/reject` (`changeSetReject`). `chatPost` takes the open Document's ID as `documentId` in the body, offers `documentId` in the `edit_document` schema (only for Documents the user may read and edit, and only with a `DocumentMutator` and the `changeSets` port), and streams the stored change set as the SSE event `change-set` (`AiStreamEvent` gains `'change-set'`). `EditorBackend.changeSets` (`list`, `accept`, `reject`; HTTP backend over the routes; capability `changeSets`). `createDocumentChat({ …, changeSets? })` hands the received change set to the panel's model and sends its decisions as feedback with the next message; `AiSidebar` (Vue and React) takes the model as the prop `changeSets`, `useDocumentChat(editor, changeSets?)`.
+- Change set panel (`@skaile/forge-editor/change-sets`, `/change-sets/vue`, `/change-sets/react`): `ChangeSetPanel` renders what the chat proposed for other Documents, grouped by Document, each hunk with the snippet of its block (`agentOpSnippet`'s text, now `blockSnippet` in `/core`, with `BlockExcerpt` and `blockExcerptText`), accept or reject per hunk or per Document, the server's message for a `stale` or `invalid` hunk. `createChangeSetModel({ backend })` (`ChangeSetModel`, `ChangeSetState`, `ChangeSetGroup`, `ChangeSetEntry`, `ChangeSetFailure`), `groupChangeSets`, `hunkLabel`, `HUNK_STATUS_KEYS` and `useChangeSetModel({ backend })` are the framework-free model and the hooks. The reference app mounts the panel in the sidebar (`app/composables/useChangeSets.ts`) and passes the model to the chat.
+- `createDocumentMutator({ ports, collab?, reindex?, blockTypes?, schema? })` (`@skaile/forge-editor/server`; `DocumentMutator`, `MutationContext`): `apply(documentId, ops, { user })` checks the operations with `checkAgentOps`, applies `update`, `add`, `delete` and `convert` to a Document nobody has open (through `storeContent`) or to an open one (inside its Y.Doc through the collaboration server, so connected clients see an ordinary edit), and re-projects the Block index. It refuses with `403` (read-only or no access), `404`, `409` (a Block is gone) and `422` (invalid operation; `data` lists the problems). `EditorServer.mutator` is the instance of an installed server.
+- `createMarkdownBlocks({ schema?, blockTypes? })` (`@skaile/forge-editor/server`): the editor-free Markdown to Block parser, the counterpart of `createBlockMarkdown`; it runs the `parseBlocks` and `normalize` stages (reference chips) without an `Editor`.
+- Tool registry of the document chat (`@skaile/forge-editor/server`; code in `server/tools.ts`, `server/workspace-tools.ts`): `ToolProvider { name, tool, handle(ctx, input) }` (a read-only tool: its AI SDK definition and the server-side handler), `ToolContext` (`ports`, `user`, `signal`, `liveContent`), `toolRegistry(providers)`, the option `tools` of `installEditorServer` / `provideEditorServer` (the providers; `installEditorServer` builds the registry once and refuses a duplicate name or `edit_document`) and `AiHandlerContext.tools` (the built `ToolRegistry`). `chatPost` offers `edit_document` plus the registered tools, runs the calls of a registered tool itself (at most 5 turns, 8 calls per turn), feeds the results back as `tool-result` before the next turn and streams each call as a `tool` event `{ name, input, output }` (`AiStreamEvent` gains `'tool'`). `edit_document` stays the chat's own tool: it cannot be registered, and a retry still forces it. The system prompt lists the registered tools. `DocumentChatMessage` of an assistant turn gains `tools?: ChatToolCall[]` (`CHAT_LIMITS.tools`, `CHAT_LIMITS.toolOutput`), which `documentChatMessages(…, tools)` replays with their results; the chat model keeps the `tool` events on the turn and sends them back.
+- `createWorkspaceTools(options?)` (`@skaile/forge-editor/server`): the first two providers. `find_blocks(query, limit?)` searches the Block index over the Documents the user may read; `read_block(documentId, blockId)` returns one Block as Markdown (live content of an open Document first), and refuses an unreadable Document and an unknown Block with the same sentence. `mayReadDocument(ports, user, documentId)` is `readableDocumentsOf` for one Document. The reference host registers them in `server/plugins/editor-adapter.ts`.
+- `createAiReviewBar({ notify, t, editor })` (`/ai`): the framework-free model of the in-document AI review bar (`AiReviewBarModel`, `AiReviewBarState`, `AiReviewAnchor`, `AiReviewBarOptions`). It holds the pending Review hunk count and the clicked hunk, navigates (`go`), decides the active hunk (`decide`) or all (`acceptAll`, `rejectAll`), raises the notice about hunks dropped because their original text was edited, and gives the popover its `anchor`. The Vue and React review bars only render it; their behaviour is unchanged.
+- `AiFlowContext` (`/integrations/composite-ai`): the one context object of a composite AI flow, `{ ai, modelRef, notify, t }` (the AI client, the Model reference of a role, the notifier, the translator).
+- The Typed block as a concept of `/core` (code in `core/typed-block.ts`): `isTypedBlock(node)`, `typedBlockAt(doc, pos)` (the Typed block that starts at `pos`; `null` for any other node or an invalid position), `metaOf(block)` / `withMeta(block, key, value)` / `withoutMeta(block, key)` (read `attrs.meta`, and copies of it that never change the block) and `findBlockType(blockTypes, node)`. `TYPED_BLOCK`, `TYPED_BLOCK_TITLE`, `TYPED_BLOCK_DESCRIPTION`, `TYPED_BLOCK_TAGS` and `BLOCK_TYPE_ATTR` are exported from `/core`; `Derivation`, `DerivationMethod`, `DerivationSource`, `DERIVATION_KEY` and `derivationOf` are defined there and stay exported from `/core` (and the types from the package root).
+- `@skaile/forge-editor/adapters/block-index/drizzle`: `createDrizzleBlockIndex({ db, tables: blockIndexTables() })`, `blockIndexTables()` and `bootstrapBlockIndexTables(db)`, the Block index (`ports.index`) on Postgres or PGlite through drizzle (`drizzle-orm/pg-core`). The whole `BlockRow` is stored as JSON next to generated `tsvector` columns over the folded title and text words (the search folds with the core ranking's own `searchWords`, so it needs neither the `unaccent` extension nor a database locale); `search` runs in SQL with the scope as a filter, title hits first, the last word as a prefix and the limits of `searchLimit`, and gives the memory adapter's answers. The Nuxt reference host picks it with `NUXT_BLOCK_INDEX=pglite` (default `memory`).
+- Block route `GET /api/editor/blocks/:documentId/:blockId` answers `{ title, type, hash, sourceHash, gone }` (`BlockSummary`, `/core`). `sourceHash` is the hash of the Block's body (for a Typed block without its title line); a Derived block whose original is in another Document compares it with the `inputHash` its Derivation recorded to show its stale badge. A custom `EditorBackend.index.blockGet` must return it.
+- Workspace tag list (`GET /api/editor/tags`): with the `index` port the names come from the Block index, so no stored Document is read; Documents open in the collaboration server are still read from their live Y.Doc (a tag removed in an open Document stays listed until the store re-projects it).
+- Documented exception in [Dependency rules](https://skaile-ai.github.io/skaile-editor/reference/dependency-rules): `server` imports the framework-free composite modules (`block-types`, `convert`, `fences`, `reference-text`, `legacy`) it needs to convert Markdown and project Blocks without an editor; no other feature implementation and never a UI framework.
+- `typeIdOf(block)` (`/core`): the Block type id of a Typed block, read from a node or its JSON (`''` when it has none). `isTypedBlock` also accepts the JSON of a block or a `ConvertTarget` and narrows it; the `ConvertTarget` of a Typed block is typed `{ type: typeof TYPED_BLOCK, blockType }` (still `'typedBlock'` at runtime).
+- `EditorServer` handle (`@skaile/forge-editor/server/nitro`): `installEditorServer` returns it with `forgetDocument(id)`, `liveContent(id)`, `enforceRateLimit(request)` and `resolveModel(ref, user)` (the four operations host code needs), next to `ports`, `collab`, `models` and `close()`. Nuxt hosts: `provideEditorServer({ ports, schema?, blockTypes? })` in a Nitro plugin hands the ports to the module, and `useEditorServer()` returns the installed handle in host routes. `installProvidedEditorServer(nitroApp, config)` is what the Nuxt module's server plugin calls.
+- `loadCurrentContent(documents, id)`, `listCurrentContents(documents)` and `currentContent(json)` (`@skaile/forge-editor/server`; code in `server/stored-content.ts`): the one load operation of stored document content, returning it in the current shape with the stored-content migration (old persisted names including the earliest `section` family, the flat `meta.transcript`) applied once and completely. The collaboration load, the tag index and the document GET (`GET /api/editor/documents/:id`) use it; a host reads stored content through it too.
+- `DraftField.typeOver(text, stored)` (`/core`): the user typed `text` while the stored value is `stored`; typing back the stored value resets the draft instead of scheduling a commit. The Vue and React image studio dialogs use it instead of choosing between `reset` and `input` themselves.
+- `EditorBackend.collaboration.patchProperty(id, patch)` and the `PropertyPatch` type (`/core`): store one Block property of a Block through the collaboration server (see Fixed). `metaWithProperty` moved to `core/properties.ts` so the server patch uses it; it is still exported from `/composites`.
+- The `pruefung` feature (`/pruefung`, `/pruefung/schema`; `pruefungFeature({ model? })`, opt-in: `interaction: [..., 'pruefung']`, option `pruefung` of `composeEditor`): a user records a Prüfung (`redaktionell`, `fachlich`, …) of a Typed block, pinned to the block's content hash (`pruefungHash`: SHA-256 of the title line and the body Markdown, `pruefungMarkdown`; meta, tags, description and baskets do not count). A Block type opts in with the block capability `pruefung` (`{ kinds, chain?, lock? }`); the block action „Prüfung eintragen“ (ability `ABILITY.pruefungRecord` = `pruefung.record`, granted per mount through `abilities`) records directly for one kind and opens a kind menu for several (`pruefung-record`, `pruefung-record-menu`). `pruefungModelOf(editor)` is the model (`createPruefungModel`, `createRestPruefungModel` over `EditorBackend.pruefung`): `state`, `refresh`, `record(blockId, kind, note?)`, `mayRecord`, the derived Freigabestatus `statusOf(node)` (`geprueft`, `veraltet`, `offen` per kind) and `freigabeOf()` (`freigegeben`/`offen`, open count). A refused record shows the server's message as a warning notice. The `lock` option and the chip and inspector UI follow separately.
+- Prüfung lock (`pruefung` feature): a Block type with `lock: <kind>` in its `pruefung` config refuses edits to a block (a `TransactionGuard`, notice „Block ist freigegeben und gesperrt“) while that kind is `geprueft` at the block's current hash; only blocks a transaction touches are hashed, remote y-sync transactions pass. The block action „Sperre aufheben“ (ability `pruefung.record`, visible on locked blocks) records a Prüfung of kind `entsperrt` (`UNLOCK_KIND`) at that hash, which lifts the lock until the block changes. A host that limits kinds through `AccessControl.pruefungKinds` must list `entsperrt` for users who may unlock. `isBlockLocked(editor, node)` is exported from `/pruefung`.
+- Prüfung chip and Prüfstand (`pruefung` feature; `/pruefung/vue`, `/pruefung/react` export `pruefungFeature` and `PruefungBadge`, `pruefungFeatureCore<C>({ section }, options)` builds it for another layer): a block whose Block type lists `pruefung` shows the chip `Geprüft` (every kind `geprueft`) or `Prüfung veraltet` (a kind `veraltet`) after its title, nothing while a kind is still `offen`; the inspector's „Dokument“ section shows the Freigabestatus `Freigegeben` / `Offen (n Blöcke)`; the Typed block inspector and the details card get the section „Prüfstand“ (kinds with their status, the records with kind, user, date and note, and „Geprüften Stand anzeigen“, which shows the checked Markdown and the current one as two columns). The chips re-read on document changes and on changes of the Prüfung model. In the catalog the `pruefung` row now has a `ui` part (`UiBindings` of a custom layer needs a `pruefung` binding).
+- New extension points of `EditorFeature` for the composites chrome and inspector, collected into `EditorEntry` like the other contributions: `rowBadges(ctx): RowBadge[]` (a chip after a Typed block's title: `{ id, of(editor, row) => BadgeChip | null, subscribe? }`), `documentBadges(ctx): DocumentBadge[]` (a chip in the inspector's document section) and `inspectorSections(ctx): InspectorSection<C>[]` (`{ id, title, component, appliesTo? }`, a section of the Typed block inspector and the details card; the component receives `{ editor, node }`). `BadgeChip`, `BadgeRow`, `RowBadge`, `DocumentBadge`, `InspectorSection` and `chromeContributionsOf(preset, ctx)` are exported from `/core`. The composites feature draws them (`CompositeChrome`, `CompositeInspector`, `CompositeDetails`, Vue and React) and knows nothing about the features that add them.
+- Documentation: the guide [Block capabilities, abilities and actions](https://skaile-ai.github.io/skaile-editor/guides/block-capabilities#abilities) explains what an ability is, how it resolves at a position, what it gates (commands, shortcuts and input rules, block actions, conversion targets, suggestions, AI) and that it refuses no edit; the glossary gains **Ability**, and Block actions name both gates. An ability is no longer called a permission in the docs.
+- `RowReorder` (`/tree`, with the types `TreeItem`, `DragPayload`, `DropVerdict` it uses) and the `reorder` prop of `DocumentTree` (`/tree/vue`, `/tree/react`): a host's say on dragging the tree's own rows among each other. `verdict(source, target)` is judged before the library's drop rules (`null` leaves it to them), `drop(source, target)` performs an allowed drop (the tree emits no `moveBlock`), and the optional `step(item, direction)` moves a row one place among its siblings.
+- Ctrl+↑ / Ctrl+↓ on a focused row of `DocumentTree` calls `reorder.step`; Ctrl+arrow does nothing else in the tree.
+- Slots `block-badges` and `block-actions` of the Vue `DocumentTree` (React: `blockBadges`, `blockActions`): host content on Typed block rows, always visible after the label and in the hover controls. Rows carry `data-tree-key` (Vue).
+- `range?: { from, to }` on `collectHeadings` and as `options.range` of `sanitizeOutline` (`/integrations/composite-ai`, type `OutlineRange`): „Gliederung bereinigen (KI)“ for the headings that start inside the range only.
+- `/core` exports `API` and `routeUrl` (the route table, so a script calls the editor API without a copy of the paths) with the types `Route`, `RouteResponse`, `RouteUrlArgs`, `DocumentSummary` and `TreeFolder`, `splitFrontmatter`, `joinFrontmatter`, `SplitMarkdown`, `parseFrontmatter` and `normalizeTagName`, `MAX_TAG_NAME_LENGTH`, so add-ons read and write Markdown frontmatter and tag names without a UI entry. `parseFrontmatter` moved from the `media` importers into `core/frontmatter` (`/media` still exports it). The add-on `@skaile/forge-editor-obsidian` imports and exports Obsidian vaults with them.
+- Block capability `titleHidden` (composites; no config; `read` returns whether `meta.titleHidden` is set): a Block type that lists it gets the eye button „Titel ausblenden“ / „Titel einblenden“ in the chrome of its Typed blocks (Vue and React `CompositeChrome`). `defaultBlockTypes` lists it on every built-in type, so nothing changes for them. Shipped in 4.3.2.
+
+### Fixed
+
+- Document tree: converting headings into Typed blocks („Überschriften in Blöcke“) no longer drops outline entries. The outline showed only Typed blocks in Structure mode and only headings in Flat mode, so the headings left inside a block's body (sub-headings with „Nur oberste Ebene“) vanished from the tree. The tree now reads `documentOutline` (`/composites`), headings and Typed blocks as one tree in both modes, and the Block type filter can hide headings („Überschriften“, `HEADING_KIND` from `/tree`). The basket filter hides a heading unless a shown Typed block is below it.
+- Vue and React image studio dialog: a pending description edit is committed to the image it was typed for when the host swaps `store`; before, it went to the new image. The draft then shows the new store's description. The Vue `useDraftField` takes an optional `target` getter and `commit(text, target)` receives the target the text was typed against; the React `useDraftField` resets the draft to `stored` when its `target` changes, also while the input has the focus. The React dialog tells stores apart by their `update` function, so keep it stable per image.
+- JSON adapter (`createJsonAdapter`): the content version is a SHA-256 of the document file instead of its modification time and size. Two writes of the same size within one filesystem timestamp tick got the same version, so a host edit could leave a stale collaboration state in place.
+- Block properties under collaboration: two users who set different properties of one Block at the same time no longer lose one of them. `meta` is one node attribute that Yjs syncs as a whole value, so each client's whole-`meta` write replaced the other's key. In a collaboration session whose backend offers `collaboration.patchProperty` (the HTTP backend), `setBlockProperty` now sends the one key to `POST /api/editor/documents/:id/property` (served with the `collabState` port), where the collaboration server writes it into the open Y.Doc; the sync delivers it, nothing is written locally. If the server refuses (document not open there, read-only, unknown Block) the value is written locally and a notice says it was not saved in sync. Without a session, or for a Block without an ID, nothing changes.
+- React image studio gallery: the search field shows its placeholder ("Galerie durchsuchen"), like the Vue one; before it only had an `aria-label`.
+- Speech engines list the formats they make (`SpeechEngineInfo.formats`, absent: `mp3` and `wav`; `createMemorySpeech` lists `wav`). The add-on's "read aloud" (`audio-tts`) asks an engine for `mp3` unless it lists formats without it, so it works with the memory engine instead of failing with "Die Memory-Engine erzeugt nur WAV".
+- Docs and examples: the Tailwind `@source` for React and Vue hosts covers the whole library (`dist` of the installed package, `src` in this repository), not only `react` (or `src/react`). The Features' own components (`features/*/react`, `features/*/components`, e.g. the image studio dialog) sit outside that directory, so their classes were missing and the dialog rendered as one tall column. `examples/react-simple` scans `src`; the Vue guides name `dist` instead of the unpublished `src`.
+- Ctrl+↑ / Ctrl+↓ in `DocumentTree` (Vue and React): after the host's `reorder.step` moved a row, the keyboard focus stayed at the old place (on the row that took it), so the next press moved that neighbour back. The focus now follows the moved row once the tree shows the new order. React Typed block rows carry `data-tree-key` too.
+
+### Changed
+
+- Internal: `TreeEditor.outline` takes no `structure` argument and `Outline` is `readonly DocumentOutlineEntry[]` instead of `{ structure, nodes }`; `readOutline(editor, t)` drops its `structure` parameter. A host that builds its own `TreeEditor` returns `documentOutline(doc, untitled, …)`. `filterKinds` no longer takes `structure`.
+- A `collection` made in the editor can be filled: its node view (Vue and React `CollectionView`) has a „Abfrage“ toggle that opens the query builder of the data views and writes the collection's `query`, so „Aus Abfrage füllen“ is offered. Both bindings run on `createCollectionViewModel`, `setCollectionQuery` and `createEdgesFormModel` (`/composites`), the framework-free models of the node view and of the „Kanten“ section.
+- The „Kanten“ of a Typed block store exactly `{ to, kind }` in `meta.edges`: adding or removing an Edge no longer writes the display label of the other entries into the document.
+- One lookup of the Property definitions of a query's Block types (`queryPropertiesOf` in `block-types.ts`, first definition of a key wins) behind the data views, the query builder, the server's `queryDefinitionsOf` and the columns of the table layout, so a column, its sort and a filter of one key use one definition. The Typed blocks table sorts texts in the editor's locale (`TableSource.locale`) instead of always German.
+- The Typed blocks table (`features/composites/table-model.ts`, Vue and React `CompositeTable`) runs on the Property kind registry and the query evaluator, with one implementation of filtering and sorting: cell text, sort keys, the long-text hint and the column alignment come from `PROPERTY_KINDS[type]` (`fieldText`, `fieldSort`, `isLongText`; `fieldDisplay` takes an optional `QueryEnv` and words every type but `reference`, `reference-list`, `bibliography` and `derivation` by the registry, so a `checkbox`, `url` or `status` cell reads like it does in a query), sorting orders with `collatorOf` (accent- and case-insensitive, numeric) instead of a fixed German collator, and the filters of the table (Block types, tags, select options, search text) are one `DataQuery` that `evaluateQuery` answers over the table's rows as `BlockRow`s (`rowsAsBlockRows`, `tableQueryOf` in `table-model`; the rows keep document order). `collator` is no longer exported from `table-model`.
+- **`derivedChromeOf` returns `{ state }`** (a `DerivedStateId`) instead of `{ stale, sourceMissing }`, and it now also tells `edited` (the body hash is kept per node). `OutlineNode.sourceMissing` and `TreeItem.sourceMissing` are replaced by `derived` (`DerivedStateId | null` and `DerivedStateId | undefined`); the tree row marker `data-source-missing` is now `data-derived="<state>"`. The composites chrome no longer draws its own „Quelle geändert“ / „Quelle fehlt“ chips on a Derived block: the row badge shows „veraltet“ / „Quelle fehlt“ instead (the details card keeps its chips).
+- The Vue AI sidebar (`AiSidebar`) renders on `@skaile/forge-chat` (`ChatPanel`, new dependency): the conversation is mapped to chat messages by `sidebarMessages`, and the answer, the proposed operations and the generation card are part renderers. Props (`editor`, `v-model:open`) and behaviour are unchanged; the React sidebar is untouched. `styles/ai.css` imports `@skaile/forge-chat/styles/chat.css`; plain Vue hosts add `@source` for `@skaile/forge-chat/dist` next to the one for the library (the Nuxt module does both).
+- Internal: the commit delays of the Draft fields are named constants (`features/composites/commit-delays.ts`, `DESCRIPTION_COMMIT_DELAY_MS` in `image-studio/state`) read by the Vue and React twins; the values are unchanged.
+- `GET /api/editor/documents/:id` answers a stored document written by an earlier release with its content migrated (old persisted names, the earliest `section` family, a flat `meta.transcript`); before, the content of the port came back as stored when the document was not open in the collaboration server.
+- Internal: the feature catalog is split by entry with one key set. `presets/catalog.ts` holds the data rows (dimension, level lists, `ui` parts, canonical order); `presets/compose` adds the builders, `schema/advanced` the schema sources, and each UI layer its bindings, all keyed by those rows. `UiBindings<C>` is derived from the rows with a `ui` part (same keys and signatures as before; now a mapped type instead of an interface), the order of the rich-content server schema is the `SCHEMA_IDS` list of `presets/schema-ids`, a leaf module the server's `schema/advanced` reads so the server program never type-checks the catalog and the feature code its option types reach (the schema snapshot is unchanged), `vue/compose` and `react/compose` share `presets/layer` (`composeEditor`, `advancedEditor` and the AI bindings), and the entry checks take the feature families from `src/features/`. Adding a catalog feature is one catalog row plus its parts in those entries; a missing part fails to compile.
+- `fillComposite(editor, pos, flow)`, `summarizeComposite(editor, pos, flow)` and `generateCompositeBody(editor, pos, flow, signal)` (`/integrations/composite-ai`) take an `AiFlowContext` instead of the separate `ai`, `modelRef`, `notify` and `t` arguments. Fill and summary run as one AI edit session (abort when the editor is destroyed, outcome notices, anchor on the edited range released at the end); what users see is unchanged. `CompositeBodyResult` no longer carries a partial `output` on `aborted`, `rate-limited`, `data-error` and `error` (only `done` has the text); the request streams through the same helper as the other AI flows.
+- `sanitizeOutline(editor, flow)`, `splitCompositeWithAi(editor, pos, mode, flow, { targetChars, defaultBlockType })`, `deriveComposite(editor, pos, kindId, flow)`, `createRendition(editor, pos, flow, options?)`, `regenerateRendition(editor, pos, flow)` and `fetchBibliography(editor, pos, flow, documentId?)` (`/integrations/composite-ai`) take an `AiFlowContext` instead of the separate `ai`, `modelRef`, `notify` and `t` arguments, like fill and summary. All six flows run as AI edit sessions now, as do the AI transforms of the block transfer (`summaryTransform`, `bulletsTransform`); what users see is unchanged. `writeDerivedBody(editor, id, markdown, { derivation?, notify, done })` no longer takes `discard` and `t`, shows no notice for an empty result or a vanished Typed block, and returns `'empty'` / `'gone'` for those instead of `false` (nothing for a written body, previously `true`); the caller removes the empty Typed block (`discardDerived`).
+- `AiReviewChange` (`/ai`): the ranges of a change (`range`, and `at` of an insertion, now a plain position) are positions in the document when `startAiReview` is called, no longer `DocAnchor`s. `startAiReview` keeps the anchors of its hunks itself, so callers capture and release none (`agentOpChange` and the transcript cleanup no longer do); a caller that tracks a range while a request runs resolves its anchor (`resolveRange`) and passes the result.
+- Nuxt hosts provide their ports with `provideEditorServer({ ports, schema?, blockTypes? })` (`@skaile/forge-editor/server/nitro`) instead of `setEditorPorts(ports, { schema, blockTypes })`; host routes call `useEditorServer().forgetDocument(id)` / `.liveContent(id)` / `.enforceRateLimit(event)` / `.resolveModel(ref, user)` instead of `forgetCollabDocument`, `liveContent`, `enforceAiRateLimit` and `resolveModel` from `@skaile/forge-editor/server`. The registration is consumed by the module's install; without provided ports the first request logs `@skaile/forge-editor: provideEditorServer() was not called`.
+- Internal: the Block type switch of the Typed block details popover (`createCompositeDetails` in `features/composites/details-model.ts`: pending Block type, the values it would drop, reset when the row's Block type changes, apply) and the filter and sort state of the Typed blocks table (`createTableControls` and `tableViewOf` in `features/composites/table-model.ts`) are framework-free, store-backed models; the Vue and React `CompositeDetails` and `CompositeTable` only render them. What users see is unchanged, including the warning that lists the values a switch drops. The names of these models use Block type wording (`blockTypes` instead of `kinds` in the filter picks); `pendingKindOf`, `applyKindChange`, `lostFieldsOf`, `activeFilterOf`, `filterRows`, `nextSort`, `activeSortOf`, `toggled` and the other table helpers the view now wraps are no longer exported.
+- A position that is outside the document or does not start a Typed block no longer throws a `RangeError` in the functions that take one: they read it as "nothing there" and return `null`, `false`, an empty list or do nothing, like `typedBlockAt`. Affected, per entry: `/core` `startBlockDrag` (`false`), `derivedOf` (`[]`), `derivationOriginOf` and `derivationState` (`null`); `/composites` `compositeAiBrief`, `propertyHostOf` and `compositeOfRow` (`null`); `/integrations/composite-ai` `canDeriveAfter` (`false`) and `fillComposite`, `generateCompositeBody`, `summarizeComposite`, `deriveComposite`, `createRendition`, `regenerateRendition`, `splitCompositeWithAi` and `fetchBibliography` (no edit).
+- Internal: the rows of the feature catalog name their schema (`schema: <id>`), and `presets/schema-ids` stays the one place of the schema order; a row without its id in `SCHEMA_IDS`, or an id without a row, fails to compile.
+
+### Changed (breaking)
+
+Shipped in 4.3.2 (release/4.3), ported here. Only Block types a host defines are affected; the built-in ones list `titleHidden`.
+
+- The eye button of the chrome shows only for a Block type that lists `titleHidden`. A Block type from a host that does not list it (for a host that shows or edits the title elsewhere) gets no button; a stored `meta.titleHidden` stays in the document. Host Block types that relied on the button must add `{ id: 'titleHidden' }` to their `capabilities`.
+- Renamed: the package is `@skaile/forge-editor` (was `@ecsplico/editor`), from the repository `skaile-ai/forge-editor` (was `skaile-ai/skaile-editor`). Nothing else in the API changes with the name: replace the package name in `package.json` and in every import specifier (`@ecsplico/editor/core` becomes `@skaile/forge-editor/core`, and so on), and the error prefix `@ecsplico/editor:` of developer errors becomes `@skaile/forge-editor:`. The documentation site moved to https://skaile-ai.github.io/forge-editor/. The add-on packages follow the same rule and are named `@skaile/forge-editor-<name>` (`audio`, `charts`, `graph`, `index-pg`, `kgs`, `obsidian`, `pdf-viewer`, `slides`, `typst`); their peer is `@skaile/forge-editor ^5.0.0`. The old name `@ecsplico/editor` is deprecated on npm and receives no further releases.
+
+### Removed
+
+- `compositeJSON`, `REFERENCE_NODE`, `BIB_KEY` and `derivedStateLabel` are no longer exported from `/composites` and `/composites/schema` (and `nodes.ts`, `reference.ts`, `meta-keys.ts`, `bibliography.ts` and `badges.ts` no longer define them): each is one definition in `/core`. Use `newTypedBlockJSON(blockType, body?, meta?, title?)` for `compositeJSON(kind, body?, meta?)` (same result), and import `REFERENCE_NODE`, `BIB_KEY` and `derivedStateLabel` from `@skaile/forge-editor/core`.
+- `sameAddress` is no longer exported from `/composites` (and `embed-model.ts` no longer defines it): it is the one function of `/core` (`core/block-index.ts`). Import it from `@skaile/forge-editor/core`.
+
+**Breaking.** The Typed block module (`core/typed-block.ts`) is the only place that defines the persisted Typed block names and the Typed block helpers; the second definitions and re-exports are gone.
+
+| Removed | Use | Entry |
+|---|---|---|
+| `TYPED_BLOCK`, `TYPED_BLOCK_TITLE`, `TYPED_BLOCK_DESCRIPTION`, `TYPED_BLOCK_TAGS`, `BLOCK_TYPE_ATTR` | the same names | `/core/schema` no longer exports them; import them from `/core` |
+| `blockTypeIdOf(node)` (`string \| null`) | `typeIdOf(block)` (`''` where it returned `null`; also reads the JSON of a block) | `/core` |
+| `splitCompositeFences(markdown)`, `CompositeFence`, `FenceSegment` | none: the fence grammar is internal; `blocksFromMarkdown(parse, markdown, blockTypes)` is the public way from Markdown with fences to blocks | `/composites`, `/composites/schema` |
+| `migrateLegacyContent(json)` | `currentContent(json)` of `@skaile/forge-editor/server` (the same migration, applied through the one stored-content module); the client applies it itself through `defineEditor`'s `migrateContent` hook | `/composites`, `/composites/schema` |
+| `compositeFromMarkdown(parse, fence, blockTypes)` | `blocksFromMarkdown(parse, markdown, blockTypes)` (it builds the Typed block of every fence of a registered Block type) | `/composites`, `/composites/schema` |
+
+- The process-wide server registry of `@skaile/forge-editor/server` (`server/host.ts`) is gone: `setEditorPorts`, `useEditorPorts`, `useCollabServer`, `useAiModels`, `closeEditorServer`, `forgetCollabDocument`, `liveContent`, `resolveModel`, `enforceAiRateLimit` and `listAiModels` are replaced by the `EditorServer` handle (see Added/Changed). `useRateLimiter`, `collabStats` and `collabContentChanged` have no replacement on the handle: read `server.collab?.stats()` and `server.collab?.contentChanged(id)` from the handle's `collab`. The server no longer throws `@skaile/forge-editor: server not installed`; `installEditorServer` is the only place that builds one, and a plain Nitro host keeps the handle it returns.
+
+## 4.2.0 - 2026-10-22
+
+### Added
+
+- `collapsedOutline: Store<string[]>` on `TreeViewModel` (`/tree`), and as `collapsedOutline` from `useTreeView()` (`/tree/vue`: a ref; `/tree/react`: the plain value): the keys of the closed outline rows (`outline:<block id>`). A host can set it to start a tree with rows closed.
+
+### Changed
+
+- A closed outline row of the document tree stays closed for the session in every tree of the app, also in a tree mounted again (it was the state of one tree and lost when the tree unmounted).
+
+## 4.1.0 - 2026-10-22
+
+### Added
+
+- Gallery tab of the Bild-Studio dialog (`/image-studio`, Vue and React): a store with `library?: ImageStudioLibrary` gets the tabs «Dieser Block» and «Galerie». The gallery searches (300 ms after the last keystroke), filters with one select per host facet (`ImageStudioLibraryFacet`; the first option is the default, values must be non-empty), lists `ImageStudioLibraryItem`s and offers «Als Bild verwenden», «Als Referenz», renaming (`rename`, optional) and removing (`remove`, optional; a rejection's message is shown and the tile stays). New types `ImageStudioLibrary`, `ImageStudioLibraryFacet`, `ImageStudioLibraryQuery`, `ImageStudioLibraryItem`. Without `library` the dialog is unchanged.
+- `placeholderUrl?: string` on `ImageStudioStore` and `ImageStudioReactStore`: shown in the preview while no image is selected (instead of the «Noch kein Bild» text).
+- `adoptImage(state, image)` reducer: makes an image the selection, adding it to the references unless the state already holds it as a reference or generation; unchanged when it is already selected.
+
+## 4.0.0 - 2026-10-21
+
+### Added
+
+- Block vocabulary: `BlockType`, `BlockTypeAi`, `defaultBlockTypes`, `blockTypeOf`, `acceptsChild` (`/composites`, `/composites/schema`; code in `features/composites/block-types.ts`), `PropertyDefinition` and `derivedChildrenOf` (`/core`), `ModelRole` / `MODEL_ROLES` (stored as `ai.roles`, see Changed, "Persisted names (settings)"), `ModelPresetConfig` (`/config`, `/server`), `AccessControl` and `DocumentContentStore` of the server ports (`/server`). The former names are listed under Removed.
+- `blockTypes` option: `compositeFeature({ blockTypes })`, `compositeSchemaExtensions({ blockTypes })`, `composeEditor({ blockTypes })`, the `blockTypes` prop of `AdvancedEditor` and `ComposedSurface`.
+- `contentTemplate` on a Block type's `ai` brief and as the AI wire field `block.contentTemplate` (client and server of the AI endpoints ship in the same package).
+- Block capabilities (`@ecsplico/editor/core`): `EditorFeature.blockCapabilities` declares `BlockCapability` descriptors (`id`, `appliesTo(node, { blockTypeId })`, optional `storage` description); `defineEditor` merges them and rejects a duplicate id, also against the built-in `container` (nodes declaring `editorBlockContainer`) and `title` (first child is chrome). `capabilitiesAt(editor, pos)` / `capabilitiesOf(editor, node)` answer which capabilities a block has, memoised per node type and Block type id (`attrs.blockType`), so predicates read only the node type and `blockTypeId`. A capability describes and never installs schema; abilities stay the permission mechanism. `BlockAction.requires` lists capability ids the block must have; `blockActionsFor` hides the action otherwise and `blockActionsOf` throws when an action requires an id no Feature declares. `EditorPreset.capabilities` is the merged `CapabilityIndex`.
+- Block types as data: `BlockType` is `id`, presentation (`label`, `icon`, `titlePlaceholder`, `descriptionPlaceholder`, `chrome`) and `capabilities: { id, config? }[]` (`BlockTypeData` / `BlockTypeCapability` in `@ecsplico/editor/core`). The former switches move into capability entries: `fields` → `properties` (`{ definitions }`), `source` → `source` (`{ media }`), `accepts` → `container` (`{ accepts }`), `ai` → `ai-brief`, plus the new `basket` and `bibliography` entries. Accessors: `propertiesOf`, `sourceMediaOf`, `aiBriefOf`, `acceptsOf`, `blockTypeConfigOf` (`/composites`, `/composites/schema`).
+- The composites feature declares the `properties`, `source`, `bibliography`, `basket`, `ai-brief` and `references` capabilities through `blockCapabilities`; core only has `container` and `title`. `BlockCapability` gains `configSchema` (zod, validates the config a Block type gives) and `read(node, ctx)` (the contents or value in a block: the source child, the basket id, the bibliography record); `appliesTo` stays type-level and memoised per node type and Block type id. `CapabilityContext` gains `blockTypeOf(node)` and `configOf(node, capability)`. New exports (`@ecsplico/editor/core`): `capabilityConfigOf`, `capabilityDataOf`, `blockTypeIdOf`, `listsCapability`, `createCapabilityRegistry`, `validateBlockTypes`, `EditorFeature.blockTypes`, `BlockAction.blockTypes` (type-specific actions only). An editor checks every Block type when it is created: an unknown capability id or an invalid config throws.
+- Derive methods (`@ecsplico/editor/core`): `EditorFeature.deriveMethods` contributes `DeriveMethod` entries (`id`, `label`, `icon`, `ability?`, `order?`, `placement?`, `requires` capability ids on the original, `available(ctx)` for backend flags and per-block conditions, `run` or `menu`). `defineEditor` merges them into `preset.deriveMethods` (`DeriveRegistry`) and rejects a duplicate id, a method with neither or both of `run` and `menu`, and a `requires` entry no feature declares; `blockActionsOf` turns every method into a block action (`deriveActionsOf`), `deriveMethodsAt(editor, ctx, pos)` lists the methods that can run on a block. New `derived` capability (declared by the composites feature; a block has it when `meta.derivation` is present, so `BlockCapability.perNode` lets a capability decide per node instead of per node type) and the memoised reverse index `derivationIndexOf(doc)` / `derivedOf(doc, pos)` / `derivationOriginOf(doc, pos, documentId?)`, computed from block IDs per document node; the original stores no back-pointer.
+- Block types from a JSON file (`@ecsplico/editor/composites`, `/composites/schema`): `parseBlockTypes(input, { registry? })` reads a `BlockType[]` (the file's text or its parsed value) and checks every entry against the capability registry (unknown capability, capability listed twice, invalid `config` per the capability's `configSchema`, duplicate id); it throws one `BlockTypeJsonError` that names the Block type, the capability and the path for every problem (`issues` carries them as data). `mergeBlockTypes(base, extra)` layers the file over `defaultBlockTypes(t)`; the result goes to the existing `blockTypes` option. `examples/vue-two-pane` defines the Block type „Idee“ only in `shared/block-types.json`.
+- Block types on the server: `installEditorServer({ blockTypes })` (`EditorServerOptions.blockTypes`), `AiHandlerContext.blockTypes` and `setEditorPorts(ports, { blockTypes })` (Nuxt) give the server the host's Block types. `POST /api/ai/chat` then describes them to the model and ignores the `blockTypes` of the request; without them it behaves as before. `aiBlockTypesOf(blockTypes)` (`/composites`, `/composites/schema`) builds the chat's Block type list for the editor's `aiContext` and the server alike.
+- One Property definition for every Block (`PropertyDefinition`, `PROPERTY_TYPES` in `@ecsplico/editor/core`; `BlockType`'s `properties` config, the inspector, `AiContextBlockType.fields` and the server's chat schema use it). The `properties` capability applies to any node with a `meta` attribute whose Block type lists it. New helpers `carriesProperties(node)`, `blockPropertiesAt(editor, $pos, blockTypes)`, `propertyHostOf(doc, target)`, `blockPropertiesOf`, `setBlockProperty(editor, target, key, value)` and `metaWithProperty` (`/composites`); `CompositeInspectorState` gains `properties` (the Block properties at the caret) and the Vue `useCompositeInspector` a `properties` ref.
+- The Block inspector shows a Block properties section for any block that has the `properties` capability (heading „Blockeigenschaften“ / "Block properties"), driven by the definitions of its Block type; `CompositeInspector` and `CompositeFieldEditor` write through `setBlockProperty`. Storage, Markdown fences, copy/paste and the Yjs state are unchanged.
+- The Block inspector shows the Derivation of every Derived block, whatever its Block type, with the source-missing state („Quelle fehlt“ / "Source missing"); a Block type that also has a `derivation` Property definition shows it once (`CompositeInspectorState.derivation`, `InspectorDerivation`).
+- The `container` config gains `root: true`: the document tree takes the Block type that sets it as the type of its document rows (`isRootBlockType`, `/composites`); the built-in Document type sets it, and no code looks the type up by its id any more.
+- `capabilityIssues(registry, type)` (`/core`) is the one validator of a Block type's capabilities: `validateBlockTypes` throws on its issues and `parseBlockTypes` collects them. The wording of the unknown, duplicate and invalid-config messages changed.
+- Documentation: the guides [Block capabilities and actions](https://skaile-ai.github.io/skaile-editor/guides/block-capabilities), [Block types in code and JSON](https://skaile-ai.github.io/skaile-editor/guides/block-types), [Derive methods and the Derivation index](https://skaile-ai.github.io/skaile-editor/guides/derive-methods) and [Block properties](https://skaile-ai.github.io/skaile-editor/guides/block-properties), and the reference pages Block capability contract, Block type contract and Derive method contract. Their code samples come from `docs/snippets`, which `bun run check:docs-snippets` keeps in sync.
+- `BlockAction.target?: 'block' | 'typedBlock'` (`/core`, default `'block'`): on the toolbar surface an action with `target: 'typedBlock'` is checked against and runs with the Typed block around the selected block (the block itself when it is one), so its split, merge, export, bibliography and focus actions stay on the toolbar while the caret is in a paragraph inside the Typed block; with no Typed block around, the action is absent. `blockActionsFor` evaluates `ability`, `requires`, `blockTypes` and `isVisible` against that Typed block and passes its `node` and `pos` in the context; the hover bar ignores the field, and the bar still docks at the selected block. `typedBlockAround(editor, target)` (`/block-ui`) finds the Typed block. The composites feature's eight Typed-block actions declare `target: 'typedBlock'`.
+
+### Fixed
+
+- The workspace tag list (`GET /api/editor/tags`) again offers the tags of stored documents that still use the old persisted names; it reads them through the old-name migration.
+
+### Changed
+
+- Inspector, details popover, table, tree, outline and the AI brief read capabilities instead of Block type fields. The Basket menu and stripe need the `basket` capability, the BibTeX export action the `bibliography` capability, the Block properties the `properties` capability; a host Block type that relied on the former defaults must list them (migration guide, "Block types as data").
+- Block actions decide by `requires` (BibTeX export, source replacement, AI fill, readable rendition, literature lookup) instead of node-name and Block-type-name checks.
+- The Focus block action (`composite-focus`) is gated by `requires: ['container']` instead of a node-name check; it still appears only on Typed blocks.
+- The built-in Folder and Document Block types declare `accepts: 'all'` themselves (in their `container` config); the id-keyed default is gone. A Block type without `accepts`, and a type id a list does not define, accepts no nested Typed blocks (`acceptsChild`); a host list that defines its own `folder` or `document` type must set `accepts` on it.
+- Derivation lives in core: `Derivation`, `derivationOf`, `derivedChildrenOf`, `derivationState` and `DERIVATION_KEY` moved from `features/composites/derivation.ts` to `core/derivation.ts` (import them from `@ecsplico/editor/core`; the Source-media helpers `sourceOf`, `bodyMarkdown` and `SourceBlock` stay in `features/composites/source.ts`). **`derivationState` signature changed**: it takes `(doc, derivedPos, bodyHash, documentId?)` and finds the original itself (was `(composite, derived, bodyHash, kinds, documentId?)`), and its `source` field is `'found' | 'missing' | 'foreign'` (was `foreign: boolean`). A Derived block whose original was deleted or is gone from the document stays and shows „Quelle fehlt“ / „Source missing“ in the chrome row, the details card, the Block inspector and the Block outline (`OutlineNode.sourceMissing`, `TreeItem.sourceMissing`).
+- The block actions `composite-fill`, `composite-summarize`, `composite-derive`, `bibliography-fetch`, `rendition-create` and `rendition-regenerate` are generated from derive methods; ids, labels, order and abilities are unchanged. `rendition-regenerate` now requires the `derived` capability instead of `container` and `title`.
+- The Document Block type is plain configuration; no code tests the type id `document` any more. New capabilities of the composites feature: `export` (the block action „Exportieren“, `document-export`, is `requires: ['export']` instead of `blockTypes: ['document']`; the built-in Document type lists it, a host type may too) and `import` (config `{ media?: SourceMedia[] }`: the imported-file wrapping of `composite-media` and "Datei importieren" use the type whose `import` takes the file's media, by default `recording` for audio/video, `figure` for images and `document` as the catch-all; the tree's "Datei importieren" entry is offered below Typed blocks whose type accepts such a type). New helpers `importTypeOf`, `acceptsImport` (`/composites`, `/composites/schema`). A host Block type list that wrapped files by the ids `document`/`recording`/`figure` must list `import` on them. The server's legacy migration of the flat `meta.transcript` keys on that property (`hasFlatTranscript`), not on the Block type; stored documents open as before.
+- Block UI addresses the outer block: with the caret or pointer inside a list item or a blockquote paragraph, the hover bar, the toolbar block actions (`selectedBlockOf`) and the drag handle act on the whole list or quote, because list items are not Blocks of their own. The rule is the outermost block below the nearest block container (`doc` or a Container block such as a Typed block); new framework-free resolvers `outerBlocksAt($pos)`, `outerBlockAt($pos)` and the drag-handle rule `outerBlockRule` (`@ecsplico/editor/block-ui`). Nested paragraphs keep their block IDs. `handleLeftOf` no longer takes a node; `gutterShiftOf` is removed.
+- UI labels in the agreed vocabulary. English: „Building block“ → „Typed block“, „Kind“ → „Block type“ (inspector, table, filter, icon setting, default type), the rendition type → „Readable rendition“, „Darstellung“ → „Theme“ with „Default appearance“, the inspector's document section → „Document facts“, the structure setting → „Structure mode“ / „Flat mode“, „Baustein“ in reference chips → „block“. German: Baustein → Block (palette group „Typisierte Blöcke“), Bausteinart / Art → Blocktyp; Korb and Lesefassung stay. Message keys are unchanged.
+- The library, the reference app, the examples and the docs use only the new names. The tree command `createBausteinFolder` is now `createFolderBlock` (`TreeCommand`, `@ecsplico/editor/tree`); a host executor that switches on the command type must use the new string. German demo and error strings that said Baustein now say Block or Dokument (`Keine gültige Dokumentdatei`).
+- **Persisted names (documents).** The node `composite` is stored as `typedBlock`, its chrome nodes `compositeTitle`/`compositeDescription`/`compositeTags` as `typedBlockTitle`/`typedBlockDescription`/`typedBlockTags`, and the attribute `kind` of a Typed block and of `opaqueFence` as `blockType` (block IDs, `meta` and the `::: <Block type id>` Markdown fences are unchanged). HTML: `section[data-type="typedBlock"][data-block-type]`; the old `data-type="composite"` / `data-kind` markup and the legacy `section` markup still parse. `BlockTransfer.kind` is `BlockTransfer.blockType` (an old drag payload is read). The editor's node storage is `editor.storage.typedBlock` (was `composite`); the `ConvertTarget` of a Typed block is `{ type: 'typedBlock', blockType }` (id `typedBlock:<id>`); `data-kind-tone` is `data-block-type-tone`. Everything stored before loads through one migration (`migratePersistedNames` in `core/schema/persisted-names.ts`, run by `migrateLegacyContent`, `defineEditor` ahead of any contributed `migrateContent`, the server's `contentNode` and, for Yjs state, by `onLoadDocument` before any client syncs); old names are read, never written; the Yjs migration is idempotent and keeps block IDs and content ([migration guide](https://skaile-ai.github.io/skaile-editor/guides/migration), "Persisted names").
+- **Persisted names (settings).** Settings version 2: `ai.slots` is `ai.roles`, `blocks.defaultKind` is `blocks.defaultBlockType`, `blocks.kindIcon` is `blocks.blockTypeIcon`, and the `blocks.structure` value `'composite'` is `'structured'` (`STRUCTURE_MODES = ['flat', 'structured']`). Saved settings (server store, `localStorage`) migrate on load through `migrateEditorSettings` and are rewritten once. `KIND_ICON_VISIBILITIES` / `KindIconVisibility` are `BLOCK_TYPE_ICON_VISIBILITIES` / `BlockTypeIconVisibility` (`/settings`). Host config: `ai.slots` is `ai.roles` (`EditorConfig`, `publicConfig`, `serverConfig`, `DirectAiOptions`); this needs a code change, there is no migration. `GET /api/ai/models` answers `{ presets, roles }` (was `slots`); client and server ship in the same package.
+- The rename of old persisted names always runs: `defineEditor` applies it ahead of any contributed `migrateContent`, so a host hook receives current names and can no longer drop it.
+- Further vocabulary renames (migration guide, "Block vocabulary"): `aiKindsOf` → `aiBlockTypesOf`, `derivableKindsOf` → `derivableBlockTypesOf`, `AiContextKind` → `AiContextBlockType`, `AiContext.kinds` / `ChatBlockModel.kinds` / the AI chat request field `kinds` → `blockTypes`, `ConvertTarget.kind` → `blockType`, `BlockProperties.fields` → `definitions`, the settings tab prop `kinds` → `blockTypes`, CSS `--sk-kind-tone` / `--sk-kind-tone-mix` → `--sk-block-type-tone` / `--sk-block-type-tone-mix`. One helper each for a Block type's capabilities: `listsCapability(type, id)` and `blockTypeConfigOf(type, id)` in `/core` (replacing `listsBlockTypeCapability` and the `(ctx, node, id)` form); `configOf` and `capabilityConfigOf` return `undefined` when absent (was `null`). `BlockTypeSpec` is gone; use `BlockType`.
+- The Derivation helpers and `PropertyDefinition` are exported only from `@ecsplico/editor/core` (no longer re-exported from `/composites` and `/composites/schema`).
+
+### Removed
+
+**Breaking.** The deprecated aliases and the remaining old names are gone; migrate to the new names ([migration guide](https://skaile-ai.github.io/skaile-editor/guides/migration), "Block vocabulary"). Persisted names are covered under Changed ("Persisted names").
+
+| Removed | Use | Entry |
+|---|---|---|
+| `CompositeKind`, `CompositeKindAi`, `CompositeMetaField` | `BlockType`, `BlockTypeAi`, `PropertyDefinition` | `/composites`, `/composites/schema`; `PropertyDefinition` from `/core` |
+| `CompositeKind.nestedAfterContent` (3.6.0) | `nestedAfterContent` in the Block type's `container` config (`{ id: 'container', config: { accepts, nestedAfterContent: true } }`; `nestedAfterContentOf(type)`) | `/composites`, `/composites/schema` |
+| `defaultCompositeKinds`, `fallbackCompositeKinds`, `compositeKind`, `kindAccepts` | `defaultBlockTypes`, `fallbackBlockTypes`, `blockTypeOf`, `acceptsChild` | `/composites`, `/composites/schema` |
+| `compositeKindsOf(editor)` | `blockTypesOf(editor)` | `/composites`, `/composites/schema` |
+| `setCompositeKind(kind, pos?)` (editor command) | `changeBlockType(blockTypeId, pos?)` (not `setBlockType`: ProseMirror uses that name for node-type changes) | editor commands |
+| `CompositeKindCount`, `CompositeKindOption`, `ChatCompositeKind` | `BlockTypeCount`, `BlockTypeOption`, `ChatBlockType` | `/composites`, `/ai` |
+| `renditionsOf` | `derivedChildrenOf` | `/core` |
+| `compositeMetaWith`, `setCompositeMetaField` | `metaWithProperty`, `setBlockProperty` | `/composites` |
+| the `kinds` and `compositeKinds` options (`compositeFeature`, `compositeSchemaExtensions`, `composeEditor`, `AdvancedEditor`, `ComposedSurface`) | `blockTypes` | |
+| `skeleton` in the `ai-brief` config and `BlockTypeAi`; the AI wire field `block.skeleton` (`AI_LIMITS.block.skeleton`, the server schema) | `contentTemplate` | `/composites`, `/ai`, `/server` |
+| `ModelSlot`, `MODEL_SLOTS`, `MODEL_SLOT_KEYS` | `ModelRole`, `MODEL_ROLES`, `MODEL_ROLE_KEYS` | `/settings` |
+| `PresetConfig` | `ModelPresetConfig` | `/config`, `/server` |
+| `Identity`, `DocumentStore` (server ports) | `AccessControl`, `DocumentContentStore` | `/server` |
+
+The Document tree's own `DocumentStore` (`/tree`) keeps its name.
+
+## 3.6.0 - 2026-10-21
+
+### Added
+
+- `CompositeKind.nestedAfterContent?: boolean` (default `false`): the sub-Bausteine of a Baustein of that kind follow its own content, and `mergeCompositeWithNext` keeps that order. Merging A = `[Ca, Na]` and B = `[Cb, Nb]` (C the leading blocks of the body that are not Bausteine, N the rest from the first sub-Baustein on) gives `[Ca, Cb, Na, Nb]`; without the flag the result stays `[Ca, Na, Cb, Nb]`. Still one undo step, the empty-paragraph rule and the `accepts` check are unchanged.
+
+## 3.5.1 - 2026-10-21
+
+### Added
+
+- React entry of the Bild-Studio, `@ecsplico/editor/image-studio/react`: `imageStudioFeature()` (the `imageStudio` block with its shadcn node view), `ImageStudioDialog` (props `open`, `onOpenChange`, `store`, `title?`; same behaviour and texts as the Vue dialog) and `ImageStudioReactStore`, the dialog's contract with plain values instead of refs (`state`, `promptBlocks`, `problem`, `update`, `generate`, `upload`; the host re-renders with the new `state` after `update`). `useImageStudioNodeStore({ editor, getPos, backend, documentId })` is the store of one node.
+- `createImageStudioNodeCore(options)` (`ImageStudioNodeCore`, `ImageStudioNodeSnapshot`, `ImageStudioNodeCoreOptions`, exported from `/image-studio/react`): the framework-free store of one `imageStudio` node (`get()`, `subscribe(listener)`, `update`, `generate`, `upload`, `dispose()`). `createImageStudioNodeStore` (Vue) is now a wrapper over it; its public API is unchanged.
+
+## 3.5.0 - 2026-10-21
+
+### Added
+
+- Bild-Studio (`@ecsplico/editor/image-studio`, `/image-studio/vue`, `/image-studio/schema`): an atom block `imageStudio` (attrs `src`, `alt`, `studio`; ability `ABILITY.imageStudio` = `insert.imageStudio`, revokes text abilities) that holds the text describing an image, the active Prompt-Bausteine, references, previous generations, the selected image and a chat log (`ImageStudioState`, `ImageStudioImage`, `ImageStudioTurn`, `ImageStudioPromptBlock`). `src` always mirrors the selected image. Markdown form `[Bild-Studio: <alt>](<src>) <!-- {"studio": …} -->`, round-trip stable; HTML `<img data-image-studio data-studio>`. Commands `insertImageStudio(attrs?)` and `setImageStudioState(pos, state)` (one transaction, `src` follows), `/` entry „Bild-Studio“, block action `image-studio.open` „Im Bild-Studio öffnen“ (placement `both`, event `IMAGE_STUDIO_OPEN`). Pure reducers `EMPTY_IMAGE_STUDIO_STATE`, `setDescription`, `togglePromptBlock`, `toggleImage`, `select`, `removeImage`, `addReference`, `addGeneration` (appends and selects), `selectedImage`, `normalizeImageStudioState`, `isEmptyImageStudioState`.
+- `ImageStudioDialog` (Vue): three columns (description and Prompt-Bausteine as switches; references with upload and drop zone, previous generations, tiles to activate, select or remove; the selected image with a chat that generates, `Enter` sends, closing aborts) driven by an `ImageStudioStore` (`state`, `promptBlocks`, `update`, `generate`, `upload`, `problem`), so a host can keep the state outside the document. `imageStudioFeature()` adds the node view (`ImageStudioView`) and the node's own store `createImageStudioNodeStore({ editor, getPos, backend, documentId })`.
+- Backend port `EditorBackend.images?` (`promptBlocks()`, `generate(body: ImageStudioGenerateBody, signal?)`, `upload(documentId, file)`), capability `images` (probed by the HTTP backend; the memory backend has none and the node view shows „Bildgenerierung ist nicht eingerichtet“). Server port `EditorPorts.images?: ImageProvider` with routes `GET /api/editor/images/prompt-blocks`, `POST /api/editor/images/generate`, `POST /api/editor/images/upload`, mounted and listed in the capabilities only with the port. Guide „Bild-Studio“.
+
+### Changed
+
+- `attrComment` and `mediaTokenizer` are exported from `@ecsplico/editor/media/schema` (shared with the Bild-Studio's Markdown form); `attrComment` escapes U+2028 and U+2029 in the JSON comment so such text survives a Markdown round trip.
+
+## 3.4.0 - 2026-10-21
+
+### Added
+
+- `CompositeKind.chrome.controls?: boolean` (default `true`). With `controls: false` the chrome of a Baustein of that kind is read-only although the editor is editable (Vue and React `CompositeChrome`; `CompositeRow.controls`): no basket menu, status menu, title-visibility button, tag removal or `+` chip and no drag handle on the kind icon, and a read-only details popover; existing basket, status and tags stay visible as chips. `mergeCompositeWithNext` also refuses (so `TreeModel.canMerge`, the row button and the block action disappear) when the Baustein or the one it would absorb has such a kind. For kinds whose attributes a host guard refuses to change.
+
+### Changed
+
+- Outline label of a Baustein without a title: instead of „(ohne Titel)“ the document tree (Vue and React rows) shows the text of the first heading of the Baustein's own body, else the start of the first non-empty text of its own body (cut at 60 characters with „…“); text inside a nested Baustein is not used, and only a Baustein with an empty body keeps „(ohne Titel)“. `compositeOutline` marks such a label with `OutlineNode.labelFromBody` and `TreeItem.labelFromBody` (rows render it muted and italic, `data-label-from-body`), and the title filter matches the derived label too. A Baustein with a title is unchanged.
+
+## 3.3.0 - 2026-10-21
+
+### Added
+
+- Kind tone: `CompositeKind.chrome.tone` (a CSS colour or `var(...)`). A Baustein of such a kind gets `data-kind-tone` and `--sk-kind-tone` on its wrapper (Vue and React `CompositeView`), a tinted surface and a left border in the tone (`composites.css`; strength `--sk-kind-tone-mix`, `8%` under `:where(:root)`, `14%` under `:where(.dark)`), and its document-tree rows tint the kind icon (`TreeItem.tone`). Kinds without a tone are unchanged.
+- Merging a Baustein with the next one (`@ecsplico/editor/composites`): the command `mergeCompositeWithNext(pos?)` makes a Baustein absorb the Baustein that directly follows it (body and sub-Bausteine appended; the first keeps title, description, tags, id, kind and meta) in one undo step, refused without a following Baustein, when the first kind does not accept a nested kind, or when read-only. Block action „Mit nächstem zusammenführen“, a merge button on `DocumentTree` rows (Vue and React; `TreeCommand` `{ type: 'mergeBlock', id }`, `TreeModel.canMerge(item)` / `merge(item)`; a host-built `TreeEditor` must now provide `canMerge(id)`), exported `CompositeMerge` and `mergeBody`.
+
+## 3.2.0 - 2026-10-20
+
+### Added
+
+- `basketById(baskets, id)` (`/composites`, `/composites/schema`); `basketOf` and `titleHiddenOf` also accept a `CompositeRow`.
+- `clampSplitTargetChars(typed, current)` (`/settings`), shared by both `SettingsEditingTab` files.
+- Block transfer between editor surfaces (`@ecsplico/editor/transfer`, `/transfer/vue`, `/transfer/react`): `transferFeature({ transforms?, defaultTransform? })`, a `BlockDropTarget` extension that accepts a Baustein dragged out of another editor or document tree (`BLOCK_MIME`). A plain drop runs the default transform `copyTransform` (fresh ids on the block and everything inside it, `meta.derivation` with `from: { block, document }`, method `copy`); Shift at the drop opens a menu at the drop point (`TransferMenu`, mounted as an overlay) with the available transforms: `copyTransform`, `summaryTransform` and `bulletsTransform` (exported from `@ecsplico/editor/integrations/composite-ai`, not from `/transfer`: the transfer feature imports no AI code and `requires` `composites`; `composeEditor` adds both to the `transfer` row when `ai` is on, `transferFeature()` alone offers the copy; `TransformContext` and `TransferEnv` carry `app: EditorContext` instead of `modelRef`; new Baustein whose body the model streams in, recorded as a derivation; available only with an AI backend and Markdown, tasks `transfer-summary` / `transfer-bullets`). A host passes its own `BlockTransform` list (`id`, `label`, `available`, `creates`, `run`). Insert guards apply (refusal toast, document unchanged), a drop onto the dragged block's own position in the same document is refused, a same-editor move stays native. Commands `transferBlock({ payload, pos, menu, x?, y? })` and `cancelTransfer()`; `runTransform`, `transferRequest` (pure request-body builder) and `isSelfDrop` are exported. `composeEditor` knows the catalog id `transfer` (in no level list: `interaction: [...INTERACTION.full, 'transfer']`, option `transfer`). `deriveComposite` shares its write-back with the transforms as `writeDerivedBody` (`@ecsplico/editor/integrations/composite-ai`).
+- Document tree: basket filter and focus (`@ecsplico/editor/tree`, Vue and React `DocumentTree`). A paint-bucket button next to the title filter (only with a live editor that offers baskets) shows only the Bausteine of the checked baskets (none checked = all) plus their ancestors, which are dimmed; documents, folders and headings are never hidden. The choice persists under `tip-tree:basket-filter` (`TreeViewModel.basketFilter`, `setBasketShown`, `clearBasketFilter`; `TreeState.basketFilter`, `TreeRowState.dimmed`). Every Baustein row gets a focus button: `TreeModel.focus(key)` / `defocus()` list only the children of the focused row under a breadcrumb (`TreeState.focusKey`, `focusPath`; the first crumb is the document and leaves focus, the others refocus), emit the new `TreeCommand` `{ type: 'focusBlock', id }` after the state changed, and the executor runs `focusComposite(id)` on the editor, so the editor hides everything else. A focused Baustein that disappears (or another editor) resets the focus.
+- Colour baskets and hidden titles on Bausteine. A Baustein can sit in one of the host's baskets (`meta.basket`, an id of `compositeFeature({ baskets })` / `composeEditor({ compositeBaskets })`; default `defaultBaskets(t)`: red, orange, yellow, green, blue, coloured by the `--sk-basket-<id>` CSS variables) and its title can be hidden (`meta.titleHidden`); a hidden title reappears for the rest of the editor session once the caret enters it (`CompositeStorage.revealedTitles`). Both keys are kept by every kind and survive Markdown round trips (`BASKET_KEY`, `TITLE_HIDDEN_KEY`, `keepsMetaKey`). New commands `setCompositeBasket(basket | null, pos?)` (refuses an unknown id, `null` removes the key) and `setCompositeTitleHidden(hidden, pos?)` (showing also ends the reveal); new exports `Basket`, `BASKET_IDS`, `defaultBaskets`, `basketOf`, `titleHiddenOf`, `compositeBasketsOf`; de/en keys `composites.basket.*` and `composites.titleHidden.*`.
+- Block-action placement: `BlockAction.placement` (`'hover' | 'toolbar' | 'both'`, default `'both'`) and `BlockUiOptions.actions` (`'hover'` default, `'toolbar'`, `'both'`, `'none'`) chosen with `blockUiFeature(options)`, `blockUiFeatureCore(ui, options)` or `composeEditor({ blockUi })`. The new toolbar surface shows the actions of the block holding the selection at its corner (`block-actions-toolbar` class; Vue and React); with `'both'` the hover bar yields on the selected block, so one bar shows per block; `'none'` leaves the drag handle and targeting only. Abilities stay permissions: the option only chooses where allowed actions appear. Also exported from `@ecsplico/editor/block-ui`: `selectedBlockOf`, `sameBlock`, `actionSurfacesOf`; `blockActionsFor` takes the `surface` as a fourth argument. `EditorFeature.blockUi` and `EditorEntry.blockUi` carry the options to the overlay. Hosts passing nothing see no change.
+- Editor focus mode on a Baustein (`@ecsplico/editor/composites`): the command `focusComposite(id | null)` hides every sibling of the focused Baustein and of each of its ancestors, so only the Baustein and the titles around it stay (decorations `sk-focus-hidden`, `sk-focus-target`, `sk-focus-ancestor` from the `CompositeFocus` extension; exported `compositeFocusKey`, `compositeFocusOf`, `focusDecorations`). The focus resets by itself when the Baustein is deleted. New block action „Fokussieren“ on every Baustein and a focus chip „Fokus: <Titel> · Aufheben“ (`FocusChip`, Vue and React; `CompositesUi` gains `focusChip`, mounted as an overlay of `compositeFeature`).
+- `CoreContentOptions` (`headings: false | { levels }`, `lists`, `blockquote`, `codeBlock`, `rule`: each `false` to drop it) for the content base: `coreContentFeature(options)`, `coreContentSchemaExtensions(options)` and `composeEditor({ coreContent })`. One options object feeds the editor and the server schema (`starterKitOf` is the shared StarterKit mapping), so they cannot drift; everything stays on by default. A command whose created node type is not in the schema is hidden (`commandState` → `visible: false`) in the toolbar, the `/` menu and the ⌘K palette instead of greyed out; with `headings: { levels }` the heading commands of other levels are hidden.
+- `AdvancedEditor` (Vue and React) and the React `ComposedSurface` take `blockUi` and `coreContent` and pass them to `composeEditor` (read once at setup, like the other composition props).
+- AI splitting and outline cleanup (`@ecsplico/editor/integrations/composite-ai`): the block actions „Mit KI in Unter-Bausteine teilen“ / „Mit KI in Bausteine teilen“ (`splitCompositeWithAi(editor, pos, mode, ai, modelRef, notify, t, { targetChars, defaultKind })`) ask the model (task `split-block`) to insert `##` headings into a Baustein's body and split it at them; the model may only insert headings, so a result whose text minus those headings differs from the original (`bodyUnchanged`) writes nothing and shows a warning. „Gliederung bereinigen (KI)“ (`sanitizeOutline(editor, ai, modelRef, notify, t)`, ⌘K entry and block action on headings; task `outline-sanitize`) sends all headings of the document and applies the repaired outline (no skipped levels, numbering and trailing punctuation removed, empty headings merged into the next) in one undoable step, or nothing when the answer is malformed. The pure parts are exported (`bodyUnchanged`, `splitByInsertedHeadings`, `collectHeadings`, `parseOutlineResponse`, `applyOutline`). Both tasks are in `AI_TASK_IDS` and carry the new `AiTask.programmatic` flag, which keeps tasks that only a block action or command sends out of the AI sidebar.
+- Splitting a Baustein (`@ecsplico/editor/composites`): the commands `splitCompositeAtCaret({ mode })` (in front of the body block holding the caret; refused at the first body block) and `splitCompositeByLength({ mode, targetChars?, pos? })` (parts of about `blocks.splitTargetChars` characters, never cutting inside a block; refused with fewer than two parts) cut a Baustein into sibling Bausteine (`'siblings'`: the original keeps the first part) or sub-Bausteine (`'children'`: of the default kind, else the parent's own kind, refused when neither is accepted). Generated parts get a title from their first sentence and hide it (`meta.titleHidden`). The pure parts are exported (`splitBodyByLength`, `generatedTitle`, `childKindFor`, `splitComposite`, `SplitMode`), the four block actions „Baustein hier teilen“, „In Unter-Bausteine teilen“, „Nach Länge in Unter-Bausteine teilen“ and „Nach Länge in Bausteine teilen“ are offered on Bausteine, and the new setting `blocks.splitTargetChars` (default 1500, 200–20000) has a field in the „Bearbeiten“ tab (Vue and React).
+- Client-safe AI run modules in `@ecsplico/editor/ai/protocol`: `generateBodySchema`, `completeBodySchema` (moved from the server handlers, which keep re-exporting them), `ChatMessage`, `ChatStream`, `GenerateInput`, `generateProblem`, `runGenerate` and `runCompletion`; `runTranscriptCleanup` and `TranscriptCleanupUnreadableError` in the transcript-AI protocol. They take a `ChatStream` and hold the validation, streaming, early-stop and chunk policy, so the server handlers (AI SDK stream) and a browser-direct adapter share one implementation. Server behaviour is unchanged; `ChatMessage` of `@ecsplico/editor/server` is the same type.
+- `@ecsplico/editor/adapters/direct-ai`: `createDirectAi({ presets, slots?, users?, fetch? })`, an `EditorBackend['ai']` that calls OpenAI-compatible chat-completion endpoints (`<endpoint>/chat/completions`, base URL like `PresetConfig.endpoint`) straight from the browser, so `{ ...createMemoryBackend(), ai: createDirectAi({ presets }) }` is an editor with AI and no server. It serves `models`, `complete`, `stream('generate')` and `transcriptCleanup` through the shared protocol modules (same prompts, limits and results as the handlers) over a plain `fetch` and a small SSE reader, with no AI SDK in the bundle. A refused model request rejects with a `BackendError` carrying the upstream status before anything streams. Limits: `stream('chat')` (tool calls) and `extract` (transcription, OCR) answer `BackendError` 501 (use the HTTP backend's `ai` for them); the preset keys are readable by the page; the per-user rate limit exists in the server handlers only. Bundle-isolation fixture `adapters-direct-ai`. The guides document the capability locality (`local`, `relay`, `session`) and the new adapter.
+- Block payload for drags between editors and document trees (`@ecsplico/editor/core`): `startBlockDrag` writes the Baustein as `application/x-tip-block` (`BLOCK_MIME`, `BlockTransfer`: document id, block id, kind, title, JSON, Markdown) after `text/plain`; `writeBlockTransfer`, `readBlockTransfer` (null for a missing, unparsable or misshapen payload) and `blockTransferOf(editor, pos)` (Markdown empty without `editor.markdown`). The new `BlockTransferStorage` extension of `coreContentFeature` carries the editor's `documentId` (`editor.storage.blockTransfer`).
+- Foreign Bausteine in the document tree (`@ecsplico/editor/tree`, Vue and React `DocumentTree`): a Baustein dragged in from another editor surface or tree (`BLOCK_MIME`) is accepted on the document root or on a Baustein row in the open document (`DragPayload` `{ type: 'foreign-block' }`, `TreeModel.foreignDragOver(item)`, `TreeModel.dropForeign(item, payload, menu, x, y)`); other targets show the refusal „Hier lassen sich keine Bausteine ablegen“, and an open editor without the transfer feature (no `blockDropTarget` storage or `transferBlock` command: `TreeEditor.canTransfer`, `DropEnv.canTransfer`) refuses every foreign drop (the executor returns `false` instead of throwing, `dropForeign` never rejects). The model emits `TreeCommand` `transferBlock { payload, targetId, menu, x, y }` and the executor runs `editor.commands.transferBlock` at the end of that Baustein (Shift = transform menu). A Baustein row now also writes its block payload (`BLOCK_MIME`) when dragged, so it can be dropped into another surface or tree.
+- Example `examples/vue-two-pane` (`bun run example:two-pane`, port 3047): two document trees over two editors on the bare Nitro server of `vue-nitro-json`, showing nested Bausteine from a Markdown import with AI outline repair, splitting by length, colour baskets with filter and focus in the trees, and dragging Bausteine from one pane into the other with a transform. New guide „Content tree mechanics“ and additions to the composites, document-tree, AI and composition guides and the exports reference.
+
+### Fixed
+
+- `--sk-basket-*` now live under `:where(:root)` with dark values under `:where(.dark)` (like `tokens.css`); a host's override now wins at any specificity.
+
+### Changed
+
+- Internal: the composition catalog of `presets/compose` is one table (`CATALOG`, one row per feature: dimension, level lists, builder; its key order is the canonical order). `CONTENT`, `INTERACTION` and `AI` are derived from it with unchanged names and values; `composeEditor` output is identical. Adding a catalog feature is one row, plus a `UiBindings` key and both binding records when the feature is UI-bound.
+- `TreeCommand` gains `focusBlock` and `transferBlock`, and `DragPayload` gains `{ type: 'foreign-block' }`: a host that switches exhaustively over either needs the new cases. `TreeEditor` gains `canTransfer` and `DropEnv` gains `canTransfer`; `TransferDrop` `{ payload, pos, menu, x, y }` is the one type of a drop (`PendingDrop` is `TransferDrop` with `menu` on).
+- `CompositesUi.focusChip` is optional: without it `compositeFeatureCore` mounts no focus chip (the focus mode and its block action stay).
+- `DEFAULT_TRANSFORMS` of `/transfer` is `[copyTransform]`; hosts that built `transferFeature()` by hand and want the AI transforms pass `transforms: [copyTransform, summaryTransform, bulletsTransform]`. `UiBindings` of `presets/compose` gains `transfer-ai`, the AI transforms the layer binds (bound only with `ai` on and no own `transfer.transforms`).
+- `DerivationSource` `{ block }` may carry `document` (the document the source block lives in); the details card reports `stale: null` for a source in another document (it is not looked up here), and the badge shows „aus anderem Dokument“ (`composites.derivation.foreign`, `derivationIsForeign`, `isForeignSource`, `DerivationDetails.foreign`) instead of comparing hashes.
+- A Baustein row of the document tree, and every block dragged with `startBlockDrag`, now writes its block payload (`BLOCK_MIME`) besides `text/plain`, so it can be dropped into another surface or tree. Hosts that read only `text/plain` see no change.
+
+
+## 3.1.1
+
+### Fixed
+
+- Composites: picking an option of a `multiselect` field in the Vue meta panel stores it. The Nuxt UI `InputMenu` emitted the whole option objects, which the field dropped, so nothing could be chosen; it now picks by `value` (`value-key="value"`). The kit's `InputMenuProps` gains `valueKey`. React was not affected.
+
+## 3.1.0
+
+### Added
+
+- Composites: field type `multiselect` (`CompositeMetaField`; `options` required, value stored as `string[]`; the key is removed when none is chosen). It is rendered in the details popover and inspector (Vue `InputMenu`, React checkbox list), in table cells and sort keys, in the AI brief and in the chat block model.
+- Composites: `CompositeKind.chrome?: { tags?: boolean }`; `chrome: { tags: false }` hides that kind's tag chips, `+` chip and inspector tags field (`CompositeRow.tagsVisible`).
+- `EditorFeature.transactionGuards(ctx)` and the `TransactionGuard` type: features can refuse a whole document-changing transaction by returning a notice string. The first refusal wins and the string is shown through `notify`. The `TransactionGuards` extension and `transactionGuardExtensions(preset, ctx)` are exported from `core`.
+- `EditorServerOptions.routes` (`installEditorServer`): a function that filters or reorders the route table before it is mounted, so a host that serves some paths itself (for example `/api/editor/assets/*`) can drop them. The `RouteDef` type is exported from `@ecsplico/editor/server/nitro`.
+- `@ecsplico/editor/comments/server` exports the pure discussion operations `createThread`, `addComment`, `editComment`, `removeComment`, `setThreadStatus`, `updateAnchor`, `removeThread` and `emptyDiscussion`, so a host `CommentStore` over its own database applies them to a stored `Discussion` instead of reimplementing the rules (guide „Storage adapters“, section „Your own store“).
+
+## 3.0.0
+
+### Added
+
+- Asset hashes: `POST /api/editor/assets/:id` answers `{ url, name, sha256 }` and stores `sha256` in the `AssetRecord`; `backend.assets.upload` may resolve `{ url, sha256? }`. Image, audio, video and file nodes have a `hash` attribute (`data-hash`), set by every upload path; the memory backend leaves it empty. `composite-media` imports audio/video as `recording`, images as `figure`, other files as `document`, and adds the block action „Quelle ersetzen“ (`source-replace`).
+- Source-holding Bausteine: the composite kinds `recording` (audio/video; `recordedAt`, `participants`, `durationSeconds`), `paper` and `book` (PDF; `bib`, `doi` / `isbn`), `figure` (image; `credit`) and `rendition` („Lesefassung“: derived readable content; `derivation`, `language`), next to `document`. `CompositeKind.source` (with `SOURCE_MEDIA_TYPES`) names the media block types of a source-holding kind; `sourceOf(composite, kinds)` finds the source block (`{ node, index, asset, hash }`), `renditionsOf(composite)` its derived children. The source is the `audio|video|image|file` block in the Baustein's body, the readable form a child `rendition` Baustein whose body is the derived block tree (chapters as nested `section` Bausteine in composite structure). No new container node and no new feature.
+- Provenance: `meta.derivation` (`Derivation`: `from` (`{ asset }` or `{ block }`), `method`, `model?`, `createdAt`, `inputHash`, `outputHash`, `output?`) on any Baustein, with `DERIVATION_KEY`, `derivationOf`, `derivationState` (`stale`/`edited`), `bodyMarkdown` and `sha256Hex` (`core`, pure JS via `@noble/hashes`). A derived Baustein starts collapsed to a faded preview (chevron with `aria-expanded`, expands with the caret), shows an „abgeleitet“ badge and, for an asset source, „Quelle geändert“ when the source block's `hash` differs from `inputHash`; the details card adds method, model, date, „bearbeitet“ (body differs from `outputHash`), „Quelle geändert“ for block-derived Bausteine (the source block's Markdown hash differs from `inputHash`) and a link to the stored raw output. Provenance and `bib` survive Markdown fences of every kind.
+- Bibliographic data: `meta.bib` as CSL-JSON (`CslItem`, `CslName`, `CslDate`, `CslType`, `CSL_TYPES`, `BIB_KEY`) with `bibOf`, `cslOf`, `citeShort` („Doe et al. 2024“), `citeFull`, `bibtexOf`, `yearOf`, `cslTypeOptions`. The Baustein title is the work's title; `bib` never stores one. Block action „Literaturangabe exportieren (BibTeX)“ (`.bib` download) on every Baustein with `bib`.
+- Composite field types `reference` (a Baustein of the document, optionally restricted by `CompositeMetaField.targets`), `bibliography` (form editor for `meta.bib` with „BibTeX kopieren“ and, with the AI capability, „DOI abrufen“) and `derivation` (read-only provenance), in the Baustein table, the details card (Vue and React), the AI brief (`compositeAiBrief`) and the chat prompt.
+- Inline `reference` chip (`ReferenceNode`, `REFERENCE_NODE`, ability `insert.reference`, `/verweis`): `[@` opens a suggestion over the document's Bausteine; the chip shows the live `citeShort` (or the title), has a „Stelle“ locator (`S. 12`, `3:07`) and reveals the target on click. Markdown is `[@<block id>]` or `[@<block id>, <locator>]` (`referencesFromText`, `normalizeReferences`, `compositeIdsOf`); AI-written `[@id]` text becomes chips through the `normalize` stage, and the chat knows the syntax. The details card lists backlinks („Verweise“: `compositeBacklinks`, `CompositeBacklink`, `CompositeReference`).
+- Markdown fences carry the block id of a referenced Baustein: `::: kind #<block id> {meta}` is written only for Bausteine that a `reference` chip or field points at, so `[@id]` survives a Markdown round trip (source mode, import); other fences are unchanged. The pre-pass runs through the new `NodeConfig.markdownPrepare(json, editor)` hook of the document Markdown serializer.
+- Transcript segments carry `start`/`end` (seconds; `data-start`/`data-end`, JSON/Yjs only, not in Markdown); the segment shows a `mm:ss` button that seeks and plays the source audio/video. `revealSource(editor, targetId, locator)`, `seekSource`, `parseLocator`, `SourceLocator` and the `SourceReveal` extension (command `seekSource`) show a Baustein's source at a locator: a time seeks the media, a page opens the PDF viewer at `#page=N`; a `reference` chip with a locator does this on click.
+- `POST /api/ai/extract` (`extractPost`, `extractBodySchema`) and `backend.ai.extract(body, signal)`: one route for the readable form of a stored asset, `method` `auto` (by MIME type), `transcription` (timestamped segments, `verbose_json`), `pdf-text` (pdf.js, page markers `<!-- page N -->`), `ocr` (rasterised pages through the `generate` model; falls back to the text layer with `warnings: ['ocr-unavailable']`), `description` (image) or `bibliography` (Crossref by DOI, else model extraction); the response carries `markdown`, `segments?`, `bib?`, `inputHash`, `outputHash` and the asset name of the stored raw output (`output`), plus `warnings`. New dependencies `pdfjs-dist` and `@noble/hashes`, optional dependency `@napi-rs/canvas` (OCR page rasterisation).
+- Deepgram speech-to-text: `TranscriptionConfig.provider: 'deepgram'` sends the raw audio to `<endpoint>/listen` (e.g. `https://api.deepgram.com/v1`, model `nova-3`, key as `Token`) and turns Deepgram's utterances into the timed transcript segments; `'openai'` (default) keeps the OpenAI-compatible `/audio/transcriptions`. `TranscriptionConfig.language` fixes the spoken language (else OpenAI guesses and Deepgram detects it). `ExtractResponse.model` names the speech-to-text model, which `meta.derivation.model` of a transcript records; the PDF text layer records no model. The repository's Nuxt host enables Deepgram when `NUXT_TIPTAP_EDITOR_AI_TRANSCRIPTION_API_KEY` is set.
+- `composite-ai` actions (all behind the ability `composite.derive`): „Lesefassung erzeugen“ (`createRendition`, `canCreateRendition`: a new `rendition` child after the source block, transcript segments with timestamps, structured full text, or an image description; fills an empty `bib` and title from `bibliography`), „Neu erzeugen (ersetzen)“ (`regenerateRendition`, `canRegenerateRendition`, `RenditionOptions`; warns when the body was edited since generation, keeps the block id), „Ableiten (KI)“ (`deriveComposite`, `canDeriveAfter`, `derivableKindsOf`, `isDerivableSource`: a sibling Baustein of any kind with `ai` generated from the Baustein's body, `derivation.from.block`, so a translation or summary is a rendition of a rendition) and „Literaturangaben abrufen“ (`fetchBibliography`, `canFetchBibliography`, `doiOf`; the editor command `fetchCompositeBibliography` is behind the bibliography editor's „DOI abrufen“). `generateCompositeBody` is the request part of `fillComposite`, reused by `deriveComposite`.
+- The ⌘K command palette: `core-ui` binds `Mod-k` and mounts `EditorCommandPalette` (`@ecsplico/editor/vue` on Nuxt UI `UCommandPalette` in a `UModal`, `@ecsplico/editor/react` on shadcn `CommandDialog`) as an overlay of the surface. It lists every command with `palette !== false` (features' and the host's `commands` transformer), grouped like the toolbar (`ToolbarGroupDef.labelKey` names the heading's i18n key), disabled where `commandState` disables it, filtered by label or id; a `menu` command opens its rows as a second level; selecting runs the command and closes. `coreUiFeature(ui?: CoreUi<C>)` takes the palette component (`advancedEditor()`, `composeEditor()` of `/vue/advanced` and `/react/advanced`, `SimpleEditor` and `AdvancedEditor` pass it; the framework-free `simpleEditor()` has no palette); `EditorUi` gains `togglePalette()` and `paletteOpen` (implemented by the Vue and React `EditorSurface`, exposed by `useEditorUi`); the framework-free model is `paletteGroupsOf`/`filterPalette` (`core`). The Nuxt UI kit gains the `CommandPalette` widget (`VueUiKit.CommandPalette`, `CommandPaletteProps`). Message keys `palette.*` (de/en).
+- The client port `EditorBackend` (`core`: `EditorBackend`, `BackendCapability`, `BackendError`, `AiStreamEvent`, `CollaborationToken`) and its HTTP adapter `createHttpBackend({ fetch?, base? })` (`/adapters/http`), which owns the editor's paths. `createEditorContext({ backend })` and `FeatureContext.backend` carry it (default: the HTTP backend over `fetch`); the Nuxt module installs it over `$fetch`.
+- Bundle-isolation fixture `adapters-http`.
+- The in-memory backend `createMemoryBackend({ documents?, users?, tags? })` (`/adapters/memory`, name `'memory'`): documents, `blob:` asset URLs, seeded `@`/`#` lookups and settings, for hosts without a data layer; the simple and markdown examples run on it without any `/api` request. Bundle-isolation fixture `adapters-memory`.
+- `EditorFeature.backend`: the backend capabilities a feature cannot work without (`ai`: `ai`, `media`: `assets`, `themes`: `themes`, `collab`: `collaboration`). A surface session over a backend that lacks one throws `feature "<id>" needs backend capability "<cap>", which "<name>" lacks` (the collaboration capability is never required by a session: the surface only consumes the session the host opened, through its own provider or `useEditorDocument`).
+- `serverRoutesOf(ports, { ai })` (`server/routes.ts`): the editor's HTTP routes as one table, each served only when its port is present; `installEditorServer` mounts it for Nuxt and plain Nitro hosts alike. `collab.authenticateUpgrade` (refuse the `/collab/:id` upgrade with HTTP 401) is available on `installEditorServer`.
+- One editor configuration with three views (`/config`): `defineEditorConfig(input)` applies every default once (locale `'de'`, the `sonnet` and `flashLite` OpenRouter presets and their slots, 30 AI requests per user and minute, `collab.authenticateUpgrade: false`, empty `apiKey`s so env variables can override them); `serverConfig(config)` is the server view (presets with keys, shared key, slots, transcription, rate limit, collab; spread it into `installEditorServer`), `publicConfig(config)` the browser view (locale, messages, slots, `transcription` flag; `createEditor({ ...publicConfig })`). `PresetConfig`/`TranscriptionConfig` live there (the server entry re-exports them); `EditorAiConfig` is `EditorPublicConfig['ai']`. The Nuxt module options are `EditorConfigInput` and both runtime configs come from the two views, so `ai.transcription` is typed without a cast. The rate limit now sits at `runtimeConfig.tiptapEditor.rateLimit` (was `…ai.rateLimit`; the module option stays `ai.rateLimit`).
+- `useEditorDocument` for React (`/adapters/react`, the twin of the Vue composable: `modelValue`, `onChange`, `ready`, `dirty`, `save`, `reload`, `error`, `collaboration`, `comments`, `bind`), reading its backend from `EditorContextProvider`; a `null`/`undefined` id keeps it idle. Bundle-isolation fixture `adapters-react`; the entry name is no longer reserved. The react-advanced example opens its collaboration session with it.
+- `GET /api/editor/capabilities` (`CAPABILITIES_ROUTE`, handler `capabilitiesGet`): lists what the installed server serves (`serverCapabilities(ports, { ai?, collaboration? })`: `ai` and `collaboration` follow what the installer really mounted), behind `authenticate`. `createHttpBackend({ probe: true })` asks it once, drops the capabilities the server lacks and exposes the request as `EditorBackend.ready`, which `createEditorContext` awaits before its `ready` store turns true; a failed probe keeps every capability and warns once. Default `probe: false` (no request). The Nuxt module installs its backend with `probe: true`, and its client plugin finishes only after the probe, so no editor mounts before the capabilities are known. `BACKEND_CAPABILITIES` (`core/backend-capability`) lists the capability names.
+- `AdvancedEditor` (Vue and React) takes the composition: `content`, `interaction`, `ai`, `add`, `remove`, `backend` (defaults `'rich'`/`'full'`/`true`; `backend` defaults to the editor context's), builds its preset with `composeEditor` once at setup and exposes it (`preset` on the Vue component instance, on the React ref handle `AdvancedEditorHandle`, with `omitted`). `<AdvancedEditor :remove="['tables']" />` and `<AdvancedEditor content="basic" interaction="minimal" :ai="true" />` need no hand-built preset. `SimpleEditor` takes `add` (host features after `core-content` and `core-ui`, e.g. `aiFeature()`) and exposes the `preset` it mounts (React: `SimpleEditorHandle`); it does not use `composeEditor`, which keeps the simple entry's bundle free of every catalog feature.
+
+### Changed
+
+- Documentation moved to https://skaile-ai.github.io/skaile-editor/; the package no longer ships `docs/`.
+- `composeEditor` takes `collaboration?: boolean`: with a host-supplied collaboration session (the surface's `collaboration` prop; `AdvancedEditor` on Vue and React sets it itself) `collab` and `comments` stay whatever capabilities the backend offers, so a host with its own Hocuspocus provider works over the default backend. Without it a backend lacking `collaboration` still prunes both (`omitted`).
+- The comment mark belongs to the document model: `composeEditor` adds `CommentMark` (schema and extension, inert) to the `authors` feature when the final list has no `comments`, so every rich composition, including viewers and ones over a backend without collaboration, loads documents that carry comments and has the schema of the server. The features themselves stay independent: `authors` does not import the comments feature.
+- `composeEditor` throws `"core-content" cannot be removed` instead of silently ignoring `remove: ['core-content']`.
+- The React `AdvancedEditor` waits for `backend.ready` before composing and renders nothing until then, like the Vue surface and the Nuxt plugin.
+- Settings persistence, the media upload, `@`/`#` lookups and the theme list, stylesheet, upload and delete go through the backend (`settings`, `assets`, `users`, `tags`, `themes`) instead of `ctx.fetch`; a backend without a capability offers no mention suggestions.
+- The Nuxt module no longer ships per-route files (`runtime/server/api/**`, `routes/collab/[id].ts`); its server plugin calls `installEditorServer` on first request (after the host's plugins have registered the ports). Nuxt hosts now answer `GET`/`PUT /api/editor/documents/:id` and, with a `comments` port, `GET`/`POST /api/editor/comments/:id`. Routes of a port the host did not register are no longer mounted (404) instead of answering 501.
+- The process-wide server of `@ecsplico/editor/server` is what `installEditorServer` adopted: `configureEditorServer` and `EditorServerConfig` are gone (pass `ai`/`rateLimit`/`collab` to `installEditorServer`, e.g. `...serverConfig(defineEditorConfig(...))`). `useCollabServer`, `useAiModels`, `useRateLimiter`, `resolveModel`, `listAiModels`, `enforceAiRateLimit`, `liveContent`, `collabStats` and `collabContentChanged` throw `@ecsplico/editor: server not installed` before installation; `useAiModels`/`useRateLimiter` also throw when it was installed without `ai`, `useCollabServer` with `collab: false`. `setEditorPorts` only records the ports (and schema) a later installer reads. `installEditorServer`'s rate-limit default is the one of `defineEditorConfig`.
+- `useEditorDocument` (`/adapters/vue`) loads, saves, connects collaboration and builds the comments model through the backend: `useEditorDocument(id, { backend?, user?, canComment?, collaboration?: boolean | { token? } })`, the backend defaulting to the editor context's. The `fetch` option and the `collaboration: { url, token }` option are gone (the HTTP backend derives the websocket URL from its `base`). The default context backend has neither collaboration nor comments: install `createHttpBackend()` (`createEditor({ backend })`) or pass `backend`.
+- `ai.transcribe` is replaced by `ai.extract` (see Removed); `EditorPublicConfig.ai.transcription` stays the „transcription configured“ signal and gates „Lesefassung erzeugen“ for audio/video.
+- Imported audio/video land in a `recording` Baustein and images in a `figure` Baustein (before: `document` for every file); PDFs and other files stay `document` until the user switches the kind to `paper` or `book`. `document` accepts every source media type.
+- „Zusammenfassung erzeugen (KI)“ (`compositeSourceText`) summarises the Baustein body only, which now holds the rendition children, instead of falling back to a transcript field.
+
+### Removed (breaking)
+
+- `@ecsplico/editor/presets/simple` and `@ecsplico/editor/presets/advanced` are one module now: import `composeEditor`, `simpleEditor`, `CONTENT`, `INTERACTION`, `AI` and the types from `@ecsplico/editor/presets/compose`. `simpleEditor` is no longer re-exported by `@ecsplico/editor/vue/advanced` or `/react/advanced`.
+
+- `EditorContextOptions.fetch`, `EditorContextOptions.settings.remote`, `EditorContext.fetch` and `FeatureContext.fetch`: pass `backend` instead (`createEditorContext({ backend })`, `createEditor({ backend })`; to send through your own HTTP client use `createHttpBackend({ fetch })`). Settings sync per account whenever the backend offers `settings` (the default backend does); use `createMemoryBackend()` for local-only settings.
+- `FeatureContext.upload`, `FeatureContextOptions.upload`, `UploadFn` and the `upload` prop of `EditorSurface`, `AdvancedEditor` (Vue and React): uploads go through `backend.assets.upload(documentId, file)`; provide it in a custom `EditorBackend`.
+- `createRestCommentsModel` and the entry `@ecsplico/editor/comments/client` (with its fixture `headless-comments-client`): the REST comments model is `backend.comments(documentId, …)` of `createHttpBackend()` (`/adapters/http`).
+- The `preset` prop of `EditorToolbar`, `EditorSettingsPanel` and `EditorSettingsModal` (Vue and React): they take the `editor` (from the surface's `ready`/`onReady`) and read its preset through the registered editor entry. Without an editor the toolbar renders no groups and the panel/modal nothing (before, `preset` rendered a disabled toolbar). The `preset` prop of `SimpleEditor` and `AdvancedEditor` is gone as well (compose with the dimension props, or mount an `EditorSurface` over `advancedEditor(...)`).
+- `EditorFeature.toolbar`, `EditorFeature.slashCommands`, the surface prop `slashCommands` (now `commands`), `ToolbarItem`, `ToolbarItemBase`, `SlashCommandItem`, `commandItem`, `mergeToolbarGroups` and the adapter `core/legacy-commands.ts`: a feature contributes `commands(ctx)` (`CommandDef`, one declaration per command with `toolbar: { group, order? }` and/or `slash: { id? }` placements, `creates`, `ability`, `can`) plus `toolbarGroups`; build chain commands with `command({ ..., command: chain => ... })`. Every built-in feature (composites, tables, media, transcript, ai, comments, authors, composite-media) and the app callout are migrated; the callout's toolbar button and `/hinweis` entry are one command. Host commands that were `SlashCommandItem`s become `CommandDef`s with `slash: {}`.
+- `ai.transcribe`, `POST /api/ai/transcribe` (`transcribePost`, `transcribeBodySchema`) and `transcribeDocument`: use `backend.ai.extract({ documentId, name, method: 'transcription', model })` / `POST /api/ai/extract` (the HTTP backend maps it; a custom `EditorBackend` or server must provide `extract`). `mediaAssetOf` is gone as well: `sourceOf(composite, kinds)` finds the source block by the kind's `source` types, not by position.
+- The `transcript` field of the `document` kind (`meta.transcript`): stored documents are migrated on load (`migrateLegacyContent`) into a `rendition` child titled „Transkript“ with `meta.derivation` (`method: 'transcription'`, the source asset's name, empty hashes) and one paragraph per blank-line-separated chunk; the summary no longer reads the field.
+- The ability `composite.transcribe` (`ABILITY.compositeTranscribe`) is renamed `composite.derive` (`ABILITY.compositeDerive`); hosts that grant or deny it through `abilities` must use the new id.
+
+### Changed (commands)
+
+- Creating a Baustein respects Accepted children everywhere: the composites feature contributes an insert guard over `kindAccepts` (the rule `AcceptedChildren` enforces on transactions), so `/` lists no Baustein kind a parent refuses (inside an `Aufgabe`, for example) and the toolbar greys the insert button there. Commands with `creates` (tables, task lists, composites, callout, core blocks) are also greyed or hidden where the schema does not allow the node, e.g. `Tabelle einfügen` inside a table. `canGroup`/`canFlatten` are defined once for the toolbar menu and `/` entries.
+- The surface session warns once per command, when it mounts, whose `ability` is neither in `ROOT_ABILITIES` nor granted by `abilities.root` (`@ecsplico/editor: command "<id>" needs ability "<a>", ...`); such a command never shows.
+- „In Baustein umwandeln“ follows the same rule: `convertBlockTo` (and with it the toolbar's and the palette's „In Baustein umwandeln“ menu and the block action) refuses a Baustein kind the parent Baustein does not accept (`guardsAccept`, exported from `core/commands`, runs the registered insert guards for the node the target creates). The conversion of a Baustein with nested Bausteine into a kind that refuses them is still caught only by `AcceptedChildren` on the transaction.
+- Two commands with the same `id` in one editor now fail at session creation (`@ecsplico/editor: command "<id>" is declared by "<a>" and "<b>"`; a command added by the host's `commands` transformer counts as `"host"`).
+- The Vue ⌘K palette filters with `filterPalette` like the React one (prefix matches first, then substring, on label and command id; no search in `description`) instead of Nuxt UI's own matching: `CommandPaletteGroup.ignoreFilter` and `CommandPaletteProps.searchTerm` are new on the Vue kit contract.
+
+### Changed (transport)
+
+- The default backend (`createFetchBackend`, `createHttpBackend`) sends through the platform `fetch` and no longer imports `ofetch`; a host hands in `$fetch` explicitly (`createHttpBackend({ fetch })`, as the Nuxt plugin does). The `simple` entries fixture asserts its bundle holds no `ofetch`.
+- Core no longer imports features, integrations or adapters: the wire and model types `EditorBackend` names (`MentionUser`, `ModelProfile`, `ModelRef`, `ThemeRecord`, the transcript-cleanup request/response, the comment thread and `CommentsModel` types) are defined in `core/backend-types.ts` and exported by the same public entries as before (`/mentions/schema`, `/ai/protocol`, `/themes/schema`, `/comments/schema`, `/integrations/transcript-ai/protocol`); the route constants moved from `adapters/routes` to `core/api-routes`, and `server/adapter.ts` (only `AuthenticateRequest`) to `server/auth.ts`. The `setEditorPorts` error reads `@ecsplico/editor: setEditorPorts() was not called`.
+
+## 2.1.2
+
+### Added
+
+- `BLOCK_CORNER_ATTR` (`data-block-corner`), `blockCornerOf(dom)` and the type `BlockCorner` from `/block-ui`: a block marks the icons in its top-right corner with the attribute, and the hover action bar (Vue and React `BlockActionsOverlay`) docks immediately left of them, vertically centred, instead of covering them. Blocks without marked elements keep the bar at the editor's right edge.
+
+## 2.1.1
+
+### Changed
+
+- The comment stores and `handleCommentsRequest` (`/comments/server`, `/comments/json`, `/comments/drizzle`) answer refused requests (`400`/`404`/`405`/`409`) with German `error` texts, like the editor's other server routes (e.g. `Kommentar-Thread „t1“ nicht gefunden`). Status codes and `CommentStoreError.code` are unchanged; clients that matched the old English texts must match the status or code instead.
+- Errors thrown by `useEditorDocument` (`/adapters/vue`) and `createRestCommentsModel` (`/comments/client`) start with `@ecsplico/editor:` like the editor's other developer errors.
+
+## 2.1.0
+
+### Added
+
+- The storage and connection layer of the former `@ecsplico/editor-adapters`, as 11 subpath entries (guide: https://skaile-ai.github.io/skaile-editor/guides/storage-adapters): `@ecsplico/editor/adapters` (types only), `/adapters/json`, `/adapters/drizzle`, `/adapters/forge`, `/adapters/vue` (`useEditorDocument`), `/anchors`, `/comments/server`, `/comments/json`, `/comments/drizzle`, `/comments/client` and `/server/nitro` (`installEditorServer`, the Nuxt-free Nitro host). Exported names are unchanged.
+- Optional peer dependency `drizzle-orm` (`^0.45.0`), needed only by `/adapters/drizzle` and `/comments/drizzle`.
+- Bundle-isolation fixtures `adapters-node`, `adapters-drizzle`, `adapters-nitro`, `adapters-vue` and `headless-comments-client`: Vue is reachable only from `/adapters/vue`, Nitro only from `/server/nitro`, drizzle only from the two drizzle entries, React from none.
+- Example `examples/vue-nitro-json` (`bun run proto:vue-nitro-json`): a Vue editor on a bare Nitro server with JSON-file storage.
+- Framework-free models behind the Vue and React components: `createCompositeInspector` (`/composites`), `createAiSelectionFlow` (`/ai`) and the comments margin (`createMarginController`, `layoutMargin`, `marginCards` in `/comments`; orphaned threads sit at their deletion point). The document tree reports why a drop is refused and filters by title.
+- Accepted children per Baustein kind, enforced in the editor: `AcceptedChildren`, `kindAccepts`, `moveIntoVerdict` (`/composites`).
+- The block-lines module owning the `[id] …` line format the AI sees (`readBlockLines`, `BlockLines` and the `BLOCK_LINE_*` texts in `/ai` and `/ai/protocol`): IDs inside fenced code are ignored, `add` requires `afterId`, operations on a block inside a block another operation replaces or deletes are dropped (`AgentOpProblemReason` `inside`), and operations on blocks deleted since the document went to the model are reported as `stale` (`AgentOpOutcome`).
+
+### Changed (breaking)
+
+These shipped in a minor release by mistake; the only known consumer (skaile-forge) is migrated.
+
+- `documentBlockIds(text)` is removed from `/ai` and `/ai/protocol`: use `readBlockLines(text).ids`.
+- `AgentOpContext` (`checkAgentOps`): `known: (id) => boolean` is replaced by `lines: BlockLines`; pass `lines: readBlockLines(documentChatText(editor))`.
+- `CommentsSnapshot` has a required `orphanAt` (thread id → deletion position); a host's own `CommentsModel` must fill it (an empty map is valid).
+- `AgentOpOutcome` and `AgentOpProblemReason` gained `stale` and `inside`; exhaustive maps over them need the new keys.
+
+### Notes
+
+- `@ecsplico/editor-adapters` is deprecated and will receive no further releases. `@ecsplico/editor-adapters/vue` is now `@ecsplico/editor/adapters/vue`; every other subpath keeps its name under `@ecsplico/editor` (for example `@ecsplico/editor-adapters/adapters/json` → `@ecsplico/editor/adapters/json`, `@ecsplico/editor-adapters/server/nitro` → `@ecsplico/editor/server/nitro`, `@ecsplico/editor-adapters/anchors` → `@ecsplico/editor/anchors`). The root entry of the old package (types) is `@ecsplico/editor/adapters`.
+- `./adapters/react`, `./server/nest` and `./adapters/prisma` are reserved names and not exported.
+
+### Fixed
+
+- `createEditor()` without arguments threw a `TypeError` (destructuring `undefined`); `app.use(createEditor())` now installs with the default `nuxtUiKit()` as documented.
+
+## 2.0.0
+
+### Removed (breaking)
+
+- The PrimeVue kit: `@ecsplico/editor/vue/kit/primevue` (`primeVueKit()`) and the stylesheet `@ecsplico/editor/vue/kit/primevue.css`. The Vue binding renders through Nuxt UI only; hosts that used `primeVueKit()` move to `nuxtUiKit()` (`@ecsplico/editor/vue/kit/nuxt-ui`) and import `@ecsplico/editor/vue/kit/nuxt-ui.css`.
+- The Nuxt module option `kit` (`tiptapEditor: { kit: 'nuxt-ui' | 'primevue' }`). The module always adds `vue/kit/nuxt-ui.css`, patches Nuxt UI's `ui.css` so Tailwind scans the package and registers the Nuxt UI context plugin; `@nuxt/ui` must be registered before it.
+- The peer dependency `primevue` (and its optional peer metadata).
+- The `advanced-primevue` bundle-isolation fixture and the `examples/vue-primevue` example.
+
+### Changed
+
+- `createEditor({ kit })`: `kit` is optional and defaults to `nuxtUiKit()`. `app.use(createEditor())` is enough; pass a `VueUiKit` only to render the chrome with another library.
+- React: `react/styles/ui-vars.css` sets `--sk-success` from `--color-success` (the `@skaile/brand` token), falling back to the former `oklch(0.72 0.19 150)`.
+
+## 1.0.0
+
+First release on npmjs as `@ecsplico/editor` (Vue: Nuxt UI or PrimeVue kit; React: shadcn/ui; optional React and Vue peers).