@ecsplico/editor 2.1.2 → 3.1.0

package/CHANGELOG.md

@@ -1,5 +1,82 @@
 # Changelog
 
+## 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
@@ -17,7 +94,7 @@
 
 ### Added
 
-- The storage and connection layer of the former `@ecsplico/editor-adapters`, as 11 subpath entries (guide: `docs/integration.md` §14): `@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.
+- 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.

package/README.md

@@ -1,6 +1,6 @@
 # @ecsplico/editor
 
-A Vue and React editor library on TipTap v3. Editors are assembled from **features**: the *simple* editor is the core feature alone (formatting, headings, lists, quotes, code, undo/redo) and needs no backend, no Yjs and no feature code; the *advanced* editor composes every feature (media, mentions, transcripts, composites, authors, comments, AI, collaboration, block UI, site-wide Obsidian themes and their integrations) on both surfaces. The framework-free `./core` holds the feature model, and every feature's logic is framework-free too (`./<feature>`): a feature is built from a typed **UI binding** (`<x>FeatureCore(ui)`) that the Vue layer (`./<feature>/vue`, Nuxt UI chrome) and the React layer (`./<feature>/react`, shadcn/ui on Radix and Tailwind) fill with their components, node views and notice seam. Toolbar, settings panel and modal, outline, AI sidebar, comments margin, composite table and inspector, and the file browser are components you place anywhere beside an editor; both layers ship the simple editor (`./vue/simple`, `./react/simple`) and the advanced editor (`./vue/advanced`, `./react/advanced`).
+A Vue and React editor library on TipTap v3. Editors are assembled from **features**: the *simple* editor is the core features alone (formatting, headings, lists, quotes, code, undo/redo) and needs no backend, no Yjs and no feature code; the *advanced* editor composes every feature (media, mentions, transcripts, composites, authors, comments, AI, collaboration, block UI, site-wide Obsidian themes and their integrations) on both surfaces. The framework-free `./core` holds the feature model, and every feature's logic is framework-free too (`./<feature>`): a feature is built from a typed **UI binding** (`<x>FeatureCore(ui)`) that the Vue layer (`./<feature>/vue`, Nuxt UI chrome) and the React layer (`./<feature>/react`, shadcn/ui on Radix and Tailwind) fill with their components, node views and notice seam. Toolbar, settings panel and modal, outline, AI sidebar, comments margin, composite table and inspector, and the file browser are components you place anywhere beside an editor; both layers ship the simple editor (`./vue/simple`, `./react/simple`) and the advanced editor (`./vue/advanced`, `./react/advanced`).
 
 ## Prerequisites
 
@@ -52,38 +52,45 @@ const content = ref()
 </template>
 ```
 
-The module's API routes call the host's `EditorAdapter` (identity and storage). Register one in a Nitro plugin; without it the client logs „Einstellungen konnten nicht geladen werden“ and every route answers 500. This minimal adapter keeps settings in the browser and everything else in memory, and lets any visitor in (replace `authenticate` and the storage with yours):
+The module's API routes call the host's `EditorPorts` (identity first, then one port per capability: `documents`, `collabState`, `directory`, `assets`, `settings`, `themes`, `models`, `comments`). Register them in a Nitro plugin; without them the client logs „Einstellungen konnten nicht geladen werden“ and every route answers 500. A route whose port you leave out answers 501. These minimal ports keep everything in memory and let any visitor in (replace `authenticate` and the storage with yours):
 
 ```ts
 // server/plugins/editor-adapter.ts
 import type { JSONContent } from '@tiptap/core'
-import { type EditorAdapter, setEditorAdapter } from '@ecsplico/editor/server'
+import { type AssetStore, setEditorPorts } from '@ecsplico/editor/server'
 
 export default defineNitroPlugin(() => {
   const contents = new Map<string, JSONContent>()
   const states = new Map<string, Uint8Array>()
-  const assets = new Map<string, Parameters<EditorAdapter['storeAsset']>[1]>()
-  setEditorAdapter({
-    authenticate: async () => ({ id: 'demo', username: 'demo' }), // `null` = 401 on API routes; on /collab the socket is closed with 4401 (HTTP 401 at the upgrade with `collab.authenticateUpgrade`)
-    loadContent: async id => contents.get(id) ?? null,
-    storeContent: async (id, content) => { contents.set(id, content) },
-    listUsers: async () => [],
-    listContents: async () => [...contents].map(([id, content]) => ({ id, content })),
-    loadState: async id => states.get(id) ?? null,
-    storeState: async (id, state) => { states.set(id, state) },
-    removeState: async (id) => { states.delete(id) },
-    storeAsset: async (id, asset) => { assets.set(`${id}/${asset.name}`, asset) },
-    loadAsset: async (id, name) => {
-      const asset = assets.get(`${id}/${name}`)
-      if (!asset) return null
-      const { data, ...record } = asset
-      return { record, data }
+  const assets = new Map<string, Parameters<AssetStore['storeAsset']>[1]>()
+  setEditorPorts({
+    // `null` = 401 on API routes; on /collab the socket is closed with 4401 (HTTP 401 at the upgrade with `collab.authenticateUpgrade`)
+    identity: { authenticate: async () => ({ id: 'demo', username: 'demo' }) },
+    documents: {
+      loadContent: async id => contents.get(id) ?? null,
+      storeContent: async (id, content) => { contents.set(id, content) },
+      listContents: async () => [...contents].map(([id, content]) => ({ id, content })),
+    },
+    collabState: {
+      loadState: async id => states.get(id) ?? null,
+      storeState: async (id, state) => { states.set(id, state) },
+      removeState: async (id) => { states.delete(id) },
+    },
+    directory: { listUsers: async () => [] },
+    assets: {
+      storeAsset: async (id, asset) => { assets.set(`${id}/${asset.name}`, asset) },
+      loadAsset: async (id, name) => {
+        const asset = assets.get(`${id}/${name}`)
+        if (!asset) return null
+        const { data, ...record } = asset
+        return { record, data }
+      },
     },
   })
 })
 ```
 
-The advanced editor, every adapter method, collaboration and AI are covered in the [guide for coding agents](./docs/llms.md#minimal-integration-nuxt) and the [integration guide](./docs/integration.md).
+The advanced editor, every adapter method, collaboration and AI are covered in the [Nuxt quick start](https://skaile-ai.github.io/skaile-editor/getting-started/quick-start-nuxt) and the [`EditorPorts` guide](https://skaile-ai.github.io/skaile-editor/guides/editor-ports).
 
 ### Building and developing in this repository
 
@@ -91,144 +98,20 @@ The advanced editor, every adapter method, collaboration and AI are covered in t
 
 Each `exports` entry carries a custom **`skaile-source`** condition first (pointing at `src`) followed by `types`/`import` (or `default`) pointing into `dist`. This repository's Nuxt app (`nuxt.config.ts`) and the examples (`examples/*/vite.config.ts`, `tsconfig.json#customConditions`) enable that condition for Vite, Nitro and the type checker, so **editing the library needs no build step in dev**. Consumers outside the repository never set the condition and get `dist`. `bun run check:editor-entries` builds first and judges the **built** output through `exports` (no `skaile-source`), so it proves what is published; `bun run check:editor-composition` builds first and loads the built entries; `bun run typecheck:editor` resolves through `src` (`customConditions: ["skaile-source"]` in `packages/editor/tsconfig.json`).
 
-## Public exports
-
-Every entry is an explicit subpath of `package.json#exports`; there is no wildcard into internal folders and no runtime umbrella barrel. Importing an entry registers nothing globally.
-
-| Import | Contents |
-|---|---|
-| `@ecsplico/editor` | Type-only: `EditorSettings`, `EditorFeature`, `EditorPreset`, `FeatureContext`, `AnchorResolver`, `ToolbarGroup`, `ToolbarItem`, `BlockAction`, `SlashCommandItem`, `AbilitiesOptions`, `EditorMetadata`, `MetadataItem`, `AuthorIdentity`, … |
-| `@ecsplico/editor/vue` | The Vue layer (Nuxt UI chrome): `createEditor` (Vue plugin around `createEditorContext`), `EDITOR_CONTEXT`, `useEditorContext`, `useEditorSettings`, `useNotifier`, `trackedStore`, `useStoreRef`, `useWritableStoreRef`, `storeFromRef`, `EDITOR_UI`, `useEditorUi` (`openSettings`, `toggleSidebar`, `toggleComments`, `commentsOpen`), `vueSuggestionRenderer`, the components `EditorSurface`, `EditorToolbar`, `EditorSettingsPanel`, `EditorSettingsModal`, `SettingsSection`, `SuggestionList`, and the types `VueFeature`, `VuePreset` (the preset components are the two entries below) |
-| `@ecsplico/editor/vue/simple` | `SimpleEditor` component |
-| `@ecsplico/editor/vue/advanced` | `AdvancedEditor` component (every feature, optional collaboration session) and `advancedEditor(options): VuePreset` (the preset for `EditorToolbar`/`EditorSettingsPanel`/`EditorSettingsModal` beside it, and the base for own feature lists) |
-| `@ecsplico/editor/react` | The React layer (shadcn/ui chrome; Vue-free): `EditorContextProvider`, `useEditorContext`, the components `EditorSurface` (ref handle `EditorSurfaceHandle`: `editor`, `openSettings`), `EditorToolbar`, `EditorSettingsPanel`, `EditorSettingsModal`, `SettingsSection`, `SuggestionList`, `Icon`, the hooks `useEditorSettings` (`settings`, `update`, `set`, `ready`, `synced`), `useEditorUi`, `useNotifier`, `useStore`, `EditorUiContext`, `reactSuggestionRenderer`, the notice seam `reactNotifier` and sonner's `Toaster` (mount it once per page), the `cn` class helper, and the types `ReactFeature`, `ReactPreset`, `EditorSurfaceProps`, `EditorSurfaceHandle`, `SuggestionListHandle`. Presets are `defineEditor({ features })` from `/core` over the `/<feature>/react` bindings and framework-free features, or `advancedEditor()` from `/react/advanced` |
-| `@ecsplico/editor/react/simple` | `SimpleEditor` component (core feature only), `SimpleEditorProps` |
-| `@ecsplico/editor/react/advanced` | `AdvancedEditor` component (every feature and integration with its React binding, optional collaboration session; props `AdvancedEditorProps` = `EditorSurface`'s except `preset`, plus `compositeKinds`) and `advancedEditor(options): ReactPreset`; mount `Toaster` from `/react` beside it |
-| `@ecsplico/editor/react/styles/ui-vars.css` | Maps the shadcn tokens (`--primary`, `--background`, …) to the `--ui-*` variables the feature sheets read; import it before `core.css` |
-| `@ecsplico/editor/react/styles/advanced.css` | One import for React hosts of the advanced editor: `ui-vars.css`, `core.css`, every feature sheet and `themes.css` (with the shadcn bridge for Obsidian themes), in the order the Nuxt module registers them |
-| `@ecsplico/editor/presets/simple` | `simpleEditor(): EditorPreset` (core feature only) |
-| `@ecsplico/editor/presets/advanced` | Framework-free: `ADVANCED_FEATURE_IDS` (feature ids in schema order: `core`, `media`, `transcript`, `composites`, `mentions`, `authors`, `comments`, `ai`, `collab`, `block-ui`, `composite-media`, `composite-ai`, `transcript-ai`, `themes`), `advancedEditorCore(bound, options)` (assembles that list: the layer binds only the UI-bound features, `AdvancedFeatures<C>`; core, mentions and the three integrations are added here), `AdvancedEditorOptions`. The ready presets are `advancedEditor` of `/vue/advanced` and `/react/advanced` |
-| `@ecsplico/editor/core` | Framework-free (Tiptap/ProseMirror only; imports no `vue`, `@tiptap/vue-3`, `@nuxt/ui` or React): `defineEditor`, `coreFeature`, `createEditorContext` (settings context and the translator `ctx.t`, options `locale: 'de' | 'en'` and partial `messages`; with `createStore` `createStore`, `derived`, `Store`, `ReadonlyStore`), the notice seam (`Notice`, `Notifier`, `silentNotifier`), the suggestion renderer seam (`SuggestionPopup`, `suggestionPopupOf`, `SuggestionListProps`, `SuggestionPopupHandle`, `SuggestionPopupRenderer`), `registerEditor`, `Abilities` and ability helpers, `BlockFlash`, `SlashCommand`, `Metadata`, `parseBlocks` / `DEFAULT_BLOCK_PIPELINE`, generic helpers `downloadText` and `fetchErrorMessage`, the feature/toolbar/extension-point types (`EditorFeature<C>`, `FeatureContext`, `ToolbarItem`, `MenuItem`, …), `commandItem` / `mergeToolbarGroups`, and the block-conversion engine for own features (`ConversionProvider`, `ConvertTarget` with its `custom` member for host blocks, `createConverter`, `convertCoreBlocks`, `finishConversion`) |
-| `@ecsplico/editor/core/schema` | Vue-free base schema: `coreSchemaExtensions()`, `EMPTY_EDITOR_CONTENT`, `StrikeX`, `BlockId` helpers (`BLOCK_ID_TYPES`, `blockIdOf`, `findBlockById`, `assignBlockIds`), `NodeFlags` (copies the node flags `editorBlockContainer`, `editorChrome` and `editorBlock` onto the node spec; `editorBlock: true` gives an own node block IDs), `isEditorBlock`, `isBlockContainer`, `isChromeNode`, the ability vocabulary (`ABILITY`, `ROOT_ABILITIES`) |
-| `@ecsplico/editor/schema/simple` | Vue-free `simpleSchemaExtensions()` for servers and validators |
-| `@ecsplico/editor/settings` | `EditorSettings`, `EDITOR_SETTINGS_VERSION`, `EDITOR_SETTINGS_DEFAULTS`, `editorSettingsSchema`, `parseEditorSettings`, inert value constants (`MODEL_SLOTS`, `STRUCTURE_MODES`, `TREE_ROOTS`, `KIND_ICON_VISIBILITIES`, `DRAG_HANDLE_VISIBILITIES`, `AI_LANGUAGES`, `AUTHOR_COLOR_STYLES`, `COMMENTS_LAYOUTS`, …) |
-| `@ecsplico/editor/outline`, `/outline/vue`, `/outline/react` | `/vue` and `/react`: `EditorOutline`; framework-free: `headingOutline`, `revealBlockInEditor`, `HeadingOutlineNode` (imports no tree and no composite code) |
-| `@ecsplico/editor/tree`, `/tree/vue`, `/tree/react`, `/tree/types` | File browser. `/vue` and `/react`: `DocumentTree` (Vue: props `store`, `editor`, `v-model:selectedFolder`, slot `document-actions`; React: props `store`, `editor`, `selectedFolder`/`onSelectedFolderChange` (uncontrolled when omitted), `documentActions`, `className`; needs `EditorContextProvider` and a mounted `Toaster`), `useTreeView` (Vue: `nodeFilters`/`expanded` as refs; React: as values); framework-free: `DocumentStore` (store-based: `tree`, `documents`, `activeId` are `ReadonlyStore`s plus the host's operations), `createTreeView`, `treeView(context)` (the per-app view state: node filters, expanded folders), `TreeViewModel`, `NodeFilters`, `TreeFolder`, `DocumentSummary`; `/vue` also `useStoreRef` and `storeFromRef` (adapters from Vue refs to the store shape). Depends on core, outline, composites and media; see the [integration guide](./docs/integration.md#10-the-file-browser-and-documentstore). `/tree/types` has the `TreeFolder`/`DocumentSummary` types alone, for servers whose typecheck has no DOM |
-| `@ecsplico/editor/media`, `/media/vue`, `/media/react`, `/media/schema` | `/vue` and `/react`: `mediaFeature`, `useFileImport`, `AudioRecorderModal`, `useAudioRecorder`; framework-free: `mediaFeatureCore`, `fileImport`, `createAudioRecorder`, `pickFiles`, `openAudioRecorder`, `postUpload`, `mediaSchemaExtensions()`, `MEDIA_TYPES`, `MAX_MEDIA_BYTES`, asset helpers |
-| `@ecsplico/editor/mentions`, `/mentions/schema` | `mentionsFeature`, `mentionSuggestion`, `tagSuggestion`; Vue-free: `mentionsSchemaExtensions()`, `MentionNode`, `TagNode`, `mentionsFromText`, `tagsFromText`, `normalizeTagName` |
-| `@ecsplico/editor/tables`, `/tables/schema` | `tablesFeature()` (GFM tables and task lists: the nodes, toolbar group `table` with insert 3×3, add/delete row, add/delete column, delete table, slash entries `table.insert` and `task.insert`; no components, so it fits both framework layers); Vue-free: `tablesSchemaExtensions()` (also part of `/schema/simple` and `/schema/advanced`) |
-| `@ecsplico/editor/markdown`, `/markdown/vue`, `/markdown/react` | Framework-free: `splitFrontmatter(text)` / `joinFrontmatter(frontmatter, body)` (YAML block at offset 0 only, kept verbatim), `markdownToContent(editor, body, { policy? }): { content, diagnostics }` (policy `{ allowHtml?, allowDataUrls? }`: raw HTML, links and media with unsafe URLs are dropped and reported as `MarkdownDiagnostic`s — `raw-html`, `unsafe-url`, `unknown-fence` (info), `unclosed-fence` and `invalid-fence-meta` (errors); `hasFatalDiagnostics`), `contentToMarkdown(editor)`, `MarkdownClipboard.configure({ policy })` (an extension: pastes `text/markdown` and plain text with block syntax as blocks, sanitizes pasted HTML, copies and cuts as `text/markdown` next to `text/html` and `text/plain`), `createSourceMode({ getEditor, toMarkdown?, fromMarkdown?, policy? }): SourceMode` (`state` store `{ mode: 'visual' \| 'source', source, diagnostics }`, `enter()`, `edit(text)`, `commit(): boolean` — false with the editor untouched on a fatal diagnostic or a document the schema rejects —, `cancel()`). Unknown `::: kind` fences are `OpaqueFence` nodes (in `coreSchemaExtensions()`) that are written back byte for byte; kinds a composite feature registers parse first. Vue: `MarkdownSurface` (`v-model` is the Markdown string, frontmatter included; props, emits and slots of `EditorSurface` forwarded; an incoming value equal to the last emitted one is ignored; prop `policy` (also configures the `MarkdownClipboard` it installs), prop `sourceMode` (a `SourceMode`: while its state is `source` the surface shows the draft in a text area with the diagnostics of a rejected commit and Apply/Cancel, `sourceLabels` for their texts), event `diagnostics`). React: `MarkdownSurface` (`value` / `onChange` / `onFrontmatterChange` / `onDiagnostics`, prop `policy` (also configures the installed `MarkdownClipboard`), the `EditorSurface` props forwarded, same semantics; no source view). Neither imports CodeMirror |
-| `@ecsplico/editor/code`, `/code/vue`, `/code/react` | CodeMirror 6 on a string, themed by the shared `--sk-*` tokens (`styles/tokens.css`; fallbacks are the token defaults). Framework-free: `createCodeEditor({ parent, doc?, readOnly?, wordWrap?, language?, onSaveShortcut?, onChange? })`, `setReadOnly`, `setWordWrap`, `setLanguage(view, support)`, `loadLanguage(view, id)`, `setDocument(view, text)` (a host text, not an edit), `registerLanguage(id, loader, { core? })` / `resolveLanguage(id)` / `isCoreLang(id)` (language packs are the host's: register the `@codemirror/lang-*` packs you depend on; `jsonl` is built in), `formatJsonInEditor(view)`, `formatJsonText`, `jsonlLanguage`, `kindOf(path, mime?)` (`'markdown' \| 'code' \| 'binary'`), `languageOf(path)`. `/code/vue`: `CodeSurface` (`v-model` string, `editable`, `language`, `wordWrap`; emits `update:modelValue`, `save` on Mod-S, `ready(view)`). `/code/react`: `CodeSurface` (`value`, `onChange`, `onSave`, `onReady`, same flags). No ProseMirror or TipTap is reachable from these entries |
-| `@ecsplico/editor/document/vue`, `/document/react` | `DocumentSurface`: `MarkdownSurface` for `kindOf(path, mime) === 'markdown'` (props `markdown`: the Markdown surface's own props, `preset` at least), `CodeSurface` for text (language from `languageOf(path)` unless `language` is given), a `binary` slot (Vue) / `binary(path)` render prop (React) otherwise. `ready` carries `{ kind: 'markdown', editor }` or `{ kind: 'code', view }`. These entries reach both editors; use `/markdown/*` or `/code/*` alone to keep one out of a bundle |
-| `@ecsplico/editor/transcript`, `/transcript/vue`, `/transcript/react`, `/transcript/schema` | `/vue` and `/react`: `transcriptFeature`, `TranscriptSegmentView`; framework-free: `transcriptFeatureCore`, `transcriptSegment`, `speakerConversions`, `segmentSpeakerLines`, `transcriptSchemaExtensions()`, `speakerParagraphsToSegments`, `lastSpeaker`, `speakersIn` |
-| `@ecsplico/editor/authors`, `/authors/vue`, `/authors/react`, `/authors/schema` | `/vue` and `/react`: `authorsFeature`, `AuthorColorsPanel`, `AuthorColorsButton`, `SettingsAuthorsTab`; framework-free: `authorsFeatureCore`, `currentAuthor`, `AuthorAttribution`, `authorsSchemaExtensions()`, `AuthorMark`, `documentAuthors`, `AuthorIdentity`, `AUTHOR_COLOR_STYLES`, `AuthorColorStyle` |
-| `@ecsplico/editor/themes`, `/themes/vue`, `/themes/react`, `/themes/schema` | `/vue` and `/react`: `themesFeature()` (site-wide Obsidian themes: its `setup` hook starts the theme runtime and returns its teardown, its `appearance` settings tab picks the theme), `SettingsAppearanceTab`; framework-free: `themesFeatureCore`, `startObsidianTheme(ctx)` (reference-counted per app, returns the release), `scopeThemeCss`, `THEME_SCOPE_CLASS`; Vue-free schema: `ThemeRecord`, `ThemeManifest`, `themeManifestSchema`, `THEME_ID`, `MAX_THEME_BYTES`. Needs an adapter with `listThemes`/`loadTheme`; see the [usage guide](./docs/usage.md#themes-obsidian) |
-| `@ecsplico/editor/comments`, `/comments/vue`, `/comments/react`, `/comments/schema` | `/vue` and `/react`: `commentsFeature` (requires `collab`), `useComments`, `CommentsMargin`, `CommentsPopover`, `CommentsListMenu`, `CommentThreadView`, `CommentComposer`, `CommentBubble`, `SettingsCommentsTab` (`/vue` also the type `CommentsStore`); framework-free: `commentsFeatureCore`, `createCommentsModel`, `Comments` plugin helpers, `commentsSchemaExtensions()`, `CommentMark`, `CommentThread`, `CommentReply`, `COMMENT_LIMITS`, `COMMENTS_LAYOUTS`, `CommentsLayout`, and the margin's layout (the active thread pinned to its text's line, the others one-line cards out of its way): `layoutMargin(entries, activeId, { gap, minTop })` (with `MarginEntry`, `MarginLayout`, `MARGIN_GAP`), `marginCards` (with `MarginCard`, `DRAFT_CARD`; an orphaned thread sits at its deletion point, `CommentsSnapshot.orphanAt`, which host models may omit), `createMarginController` (with `MarginController`, `MarginSource`, `MarginState`: measuring and scheduling for both `CommentsMargin`s) |
-| `@ecsplico/editor/composites/vue`, `/composites/react` | `compositeFeature()` (Vue: Nuxt UI, React: shadcn), the host-placed `CompositeTable` and `CompositeInspector`, `SettingsEditingTab`, `CompositeChrome`, `CompositeDetails`, `CompositeView` and editors, `useCompositeRows`, `useCompositeAnchors` |
-| `@ecsplico/editor/composites`, `/composites/schema` | Framework-free: `compositeFeatureCore`, `Composite`, `defaultCompositeKinds`, `compositeKind`, `kindAccepts` (the kinds' accepted children, `CompositeKind.accepts`), `AcceptedChildren` (the editor extension that enforces them; registered by `compositeFeatureCore`), `compositeOutline`, `moveBlockInto` (returns whether the document changed), `moveIntoVerdict(editor, id, targetId, t)` (with `MoveVerdict`: `{ ok: true }` or `{ ok: false, reason }` in the language of `t`), `canMoveBlockInto` (`moveIntoVerdict(...).ok`), `headingsMarkdown`, `documentCompositeMarkdown`, `Structure`, `createCompositeRows`, `createCompositeInspector`, `compositeFieldText`, `observeCompositeAnchors`, `compositeRows`, `setCompositeMetaField`, `setCompositeTags`, `setCompositeDescription`, `compositeDescriptionText`, `compositeSchemaExtensions()`, `compositeJSON`, `blocksFromMarkdown`, `splitCompositeFences`, `migrateLegacyContent`, conversions and heading↔composite transforms |
-| `@ecsplico/editor/ai`, `/ai/protocol` | Framework-free: `aiFeatureCore`, `modelProfiles(app)`, `createAiAssistant`, `createDocumentChat`, `createAiSelectionFlow` (with `AI_SELECTION_MENU_KEY`), `createAgentOpReview({ notify, t })` (host-driven agent edit review), `notifyAiRateLimited(notify, t)`, review/apply helpers (`startAiReview`, `applyAiResult`, …) and the protocol (`AI_TASKS`, `ModelRef`, `AGENT_OP_TYPES`, `AGENT_OP_OUTCOMES`, `CHAT_LIMITS`, …), importable alone from `/ai/protocol`; the model-facing agent texts (`checkAgentOps`, `agentShownMessage`, `agentFeedbackText`, `agentRetryMessage`) take a `locale: 'de' \| 'en'` option (default `de`), and `agentRetryMessage(problems, scoped, { locale, tool })` names the `tool` the model must call again (default `edit_document`). The `[id]` line format of the chat's document text has one owner there, `block-lines`: writer helpers (`blockLine`, `singleBlockLine`, `nestedLinePrefix`, `quoteLinePrefix`, `listLinePrefix`, `continuedLinePrefix`, `compositeChromePart`, `compositeLineHeader`, `compositeLineClose`, `TRUNCATED_LINE`), the reader `readBlockLines` (the block ids and which blocks lie inside which; lines in fenced code are not block lines; type `BlockLines`), the echo strippers `stripBlockLineEcho` and `stripListMarkerEcho`, and the (German, model-facing) prompt texts `BLOCK_LINES_LABEL`, `BLOCK_LINE_INTRO`, `BLOCK_LINE_MARKERS`, `BLOCK_LINE_LIST_TEXT`, `BLOCK_LINE_HOST_TEXT`, `BLOCK_LINE_COMPOSITE_TEXT`, `BLOCK_LINE_ECHO_TEXT`, `BLOCK_LINE_IDS_HINT` with the example (`BLOCK_LINE_EXAMPLE`, `BLOCK_LINE_EXAMPLE_ID`, `BLOCK_LINE_EXAMPLE_TEXT`) |
-| `@ecsplico/editor/ai/vue`, `/ai/react` | `aiFeature()`, `AiSidebar`, `ModelQuickSwitch`, `AiReviewBar`, `AiSelectionMenu`, `SettingsAiTab`, `SettingsModelProfiles`; `/ai/vue` also `useAiAssistant`, `useDocumentChat`, `useModelProfiles` (thin hooks over the models) |
-| `@ecsplico/editor/integrations/composite-ai` | Framework-free: `compositeAiFeature` (requires `composites`, `ai`, `media`), `fillComposite`, `summarizeComposite`, `transcribeDocument`, `compositeSourceText`, `mediaAssetOf` |
-| `@ecsplico/editor/integrations/composite-media` | Framework-free: `compositeMediaFeature` (requires `composites`, `media`): imported files become `document` composites |
-| `@ecsplico/editor/integrations/transcript-ai`, `/transcript-ai/protocol` | Framework-free: `transcriptAiFeature` (requires `transcript`, `ai`), `createTranscriptCleanup`, `hasTranscriptSegments`; server contract: `TRANSCRIPT_CLEANUP_LIMITS`, `transcriptCleanupRequestSchema`, `transcriptCleanupMessages`, `transcriptCleanupChunks`, `parseTranscriptCleanup` |
-| `@ecsplico/editor/collab`, `/collab/vue`, `/collab/react` | Framework-free: `collabFeatureCore(ui?)` (Yjs `Collaboration`/`CollaborationCaret`, active only with a `collaboration` session on the surface), `yjsAnchorResolver`; `/vue` and `/react`: `collabFeature()` (the Vue one adds the `@tiptap/vue-3` state-sync workaround, the React one needs none) |
-| `@ecsplico/editor/block-ui`, `/block-ui/vue`, `/block-ui/react` | `/vue` and `/react`: `blockUiFeature()`, `BlockUi`, `BlockActionsOverlay`; framework-free: `blockUiFeatureCore`, `blockActionsFor`, `effectiveTarget`, `BLOCK_CORNER_ATTR` and `blockCornerOf` (a node view marks its own top-right icons with `data-block-corner`; the hover bar docks left of them): drag handle, hover targeting and block actions (opt-in; the simple editor never includes it) |
-| `@ecsplico/editor/schema/advanced` | Vue-free `advancedSchemaExtensions()`: the advanced schema for servers, validators and migrations |
-| `@ecsplico/editor/server`, `/server/handlers`, `/server/node`, `/nuxt` | Server side without a web framework: `createCollabServer`, `createAiModels`, `createRateLimiter`, `EditorAdapter`, one request handler per route (`/server/handlers`), `listenCollab` for a plain Node script (`/server/node`); the Nitro registry `setEditorAdapter`, `forgetCollabDocument`, `liveContent`, `collabStats`; the Nuxt module (config key `tiptapEditor`) wraps the same core. See the [integration guide](./docs/integration.md) |
-| `@ecsplico/editor/styles/core.css` (required), `/composites.css`, `/media.css`, `/mentions.css`, `/tables.css`, `/authors.css`, `/comments.css`, `/transcript.css`, `/ai.css`, `/collab.css`, `/block-ui.css`, `/themes.css` | Feature CSS (import after Tailwind, Nuxt UI (Vue) or `ui-vars.css` (React) and `core.css`; `themes.css` after the feature sheets). The Nuxt module adds all of them itself |
-
-Nuxt apps use the same entries; the Nuxt client plugin (`src/nuxt/runtime/plugins/editor-context-nuxt-ui.client.ts`) installs the editor context with account-synced settings.
-
-## Presets and features
-
-| Preset | Features | Backend / Yjs | Bundle isolation (`check:editor-entries`) |
-|---|---|---|---|
-| `simple` (`SimpleEditor`, `simpleEditor()`) | `core` | none | no feature, integration, AI SDK, Yjs, y-tiptap, Hocuspocus, Nuxt or server modules in the emitted chunks |
-| React `SimpleEditor` + `EditorToolbar` (`./react/simple`, `./react`) | `core` | none | no `vue`, `@vue`, `@tiptap/vue-3`, Nuxt UI or Vue-layer module in the emitted chunks (`react-simple` fixture); the headless core (`core-headless` fixture) contains no Vue, React or layer module at all |
-| `core` + `mediaFeature()` | `core`, `media` | uploads only (or a host `upload` function) | no composite, AI, Yjs, Nuxt or sibling-feature modules |
-| `core` + `mentionsFeature()` | `core`, `mentions` | built-in `@`/`#` lists only (or host lists) | same |
-| `core` + `transcriptFeature()` | `core`, `transcript` | none | same |
-| `core` + `authorsFeature()` | `core`, `authors` | none | same |
-| `core` + `themesFeature()` | `core`, `themes` | `/api/editor/themes[/:id]` (adapter `listThemes`/`loadTheme`) | no composite, AI, media, mentions, transcript, authors, comments, collaboration, block-UI, integration, Yjs or Nuxt modules |
-| `core` + `collabFeature()` + `commentsFeature()` | `core`, `collab`, `comments` | `/collab/:id` websocket (comments live in the Y.Doc) | no composite, AI, media, mentions, transcript, authors, block-UI, integration or Nuxt modules; Yjs is bundled |
-| `core` + `aiFeature()` | `core`, `ai` | `/api/ai/{models,generate,chat,complete}` (see the usage guide) | no composite, transcript, media, mentions, collaboration, integration, Yjs or Nuxt modules |
-| `core` + `media` + `composites` + `aiFeature()` + `compositeAiFeature()` | `core`, `media`, `composites`, `ai`, `composite-ai` | AI endpoints plus `/api/ai/transcribe` | no transcript, mentions, collaboration, other integration, Yjs or Nuxt modules |
-| `core` + `transcriptFeature()` + `aiFeature()` + `transcriptAiFeature()` | `core`, `transcript`, `ai`, `transcript-ai` | AI endpoints plus `/api/ai/transcript-cleanup` | no composites, media, mentions, collaboration, other integration, Yjs or Nuxt modules |
-| `core` + `collabFeature()` | `core`, `collab` | `/collab/:id` websocket (Nuxt module) or any Hocuspocus server on the advanced schema | no composite, AI, media, mentions, block-UI, integration or Nuxt modules; Yjs is bundled |
-| `core` + `blockUiFeature()` | `core`, `block-ui` | none | no composite, AI, media, mentions, collab-feature or Nuxt modules (the drag handle's upstream package bundles Yjs support code) |
-| `core` + `compositeFeature()` | `core`, `composites` | none | no AI, media, transcript, mentions, collaboration, block-UI, integration, Yjs or Nuxt modules |
-| `core` + `media` + `composites` + `compositeMediaFeature()` | `core`, `media`, `composites`, `composite-media` | uploads only | no AI, transcript, mentions, collaboration, other integration, Yjs or Nuxt modules |
-| `DocumentTree` (`./tree/vue` or `./tree/react`) beside `core` + `media` + `composites` | tree, `core`, `media`, `composites` | the host's `DocumentStore` | no AI, transcript, mentions, collaboration, block-UI, integration, Yjs or Nuxt modules; the `simple` bundle never contains the tree; the React tree contains no Vue module (`tree-react` fixture), the framework-free `./tree` no Vue and no React (`headless-tree` fixture) |
-| `advancedEditor()` / `AdvancedEditor` (`./vue/advanced`) | every feature (including `themes`) and integration, Vue bindings | `/collab/:id`, AI endpoints, assets, users/tags, themes (Nuxt module plus a host adapter, or a host server) | requires all feature and integration modules; no React, `sonner`, Nuxt, `nitropack`, `h3`, vue-router or server code in the browser bundle (`advanced` fixture) |
-| `advancedEditor()` / `AdvancedEditor` (`./react/advanced`) | every feature (including `themes`) and integration, React bindings | the same endpoints, through the Nuxt host or a host server (`examples/react-advanced` proxies `/api` and `/collab` to the Nuxt app) | requires all feature and integration modules; no `vue`, `@vue`, `@tiptap/vue-3`, Nuxt UI, Vue-layer or `.vue` module, no Nuxt or server code (`advanced-react` fixture) |
-| Any feature on one layer (`<x>/vue`, `<x>/react`, `<x>` alone) | `core` + that feature | as listed above | `<x>-react` fixtures contain no Vue or Nuxt UI module; the Vue fixtures no React, `react-dom` or `sonner`; the framework-free `headless-<x>` fixtures neither framework |
-
-Settings are stored as one inert, versioned JSON object shared by all editors of an app (`EditorSettings`); a simple editor installs no feature that reads the non-core parts.
-
-## CSS and UI-provider requirements
-
-- Design tokens: `@ecsplico/editor/styles/tokens.css` declares the shared `--sk-*` variables (`--sk-bg`, `--sk-fg`, `--sk-muted`, `--sk-border`, `--sk-primary`, `--sk-primary-fg`, `--sk-success`, `--sk-warning`, `--sk-danger`, `--sk-radius`, `--sk-font`) with light defaults under `:where(:root)` and dark values under `:where(.dark)`. Every feature stylesheet reads them; a UI kit maps them onto its own variables (Nuxt UI: `vue/kit/nuxt-ui.css`, React/shadcn: `react/styles/ui-vars.css`), a host may override them once.
-
-- Vue UI kit: the Vue binding is built on Nuxt UI. The chrome renders through the kit handed to `createEditor({ kit })`; `kit` is optional and defaults to `nuxtUiKit()` (`@ecsplico/editor/vue/kit/nuxt-ui`, needs `@nuxt/ui`, stylesheet `@ecsplico/editor/vue/kit/nuxt-ui.css`). `@ecsplico/editor/vue/kit` holds the `VueUiKit` contract and `useUiKit()`; pass your own `VueUiKit` only to render the chrome with another library. Only the `nuxt-ui` kit entry imports `@nuxt/ui`. The Nuxt module has no `kit` option: it always adds `vue/kit/nuxt-ui.css`, patches Nuxt UI's `ui.css` so Tailwind scans the package (`@nuxt/ui` must be registered before the module) and installs the Nuxt UI context plugin.
-
-- Import the core CSS **after** Tailwind and Nuxt UI, and let Tailwind see the library's classes:
-
-  ```css
-  @import "tailwindcss";
-  @import "@nuxt/ui";
-  @import "@ecsplico/editor/styles/core.css";
-  @source "../../../packages/editor/src"; /* relative path from this CSS file to the package's src */
-  ```
-
-  The Nuxt module needs none of this: it adds `core.css` and every feature sheet to `css` (`themes.css` last) and appends the package to Tailwind's `@source` list. In plain Vue also import the sheet of each feature you use, e.g. `@ecsplico/editor/styles/media.css`, after `core.css`.
-
-- Plain Vue: Vite plugins `vue()` and `ui({ router: false })` from `@nuxt/ui/vite`, `app.use(ui)` with `import ui from '@nuxt/ui/vue-plugin'`, and the editor context `app.use(createEditor())` (`createEditor` from `@ecsplico/editor/vue`). Wrap the page in `<UApp>` (overlays, toasts, tooltips).
-- React: Vite with `@vitejs/plugin-react` and `@tailwindcss/vite`. The CSS needs Tailwind, `tw-animate-css`, `@ecsplico/editor/react/styles/ui-vars.css`, `core.css` (plus the sheet of each feature you use, e.g. `mentions.css`), the shadcn theme block (`:root`/`.dark` tokens and `@theme inline`; `bunx shadcn@latest init` generates it) and `@source` for the library's `src/react`. For the advanced editor import `@ecsplico/editor/react/styles/advanced.css` instead of those three library sheets: it bundles `ui-vars.css`, `core.css`, every feature sheet and `themes.css` (last). Preload the icons with `addCollection(lucide)` from `@iconify/react`, wrap the tree in `<EditorContextProvider context={createEditorContext({ notify: reactNotifier })}>` and mount `<Toaster />` (sonner, from `@ecsplico/editor/react`) once so notices show up; see the [usage guide](./docs/usage.md#simple-editor-in-react), [Advanced editor in React](./docs/usage.md#advanced-editor-in-react), [`examples/react-simple`](../../examples/react-simple) and [`examples/react-advanced`](../../examples/react-advanced).
-- Icons: Nuxt UI resolves `i-lucide-*` names at build time. A workspace library lies outside the Vite root that Nuxt UI scans, so list its icons for the client bundle (see how `examples/vue-simple/vite.config.ts` collects them) to avoid Iconify API requests at runtime.
-- The editor context is mandatory: Vue `EditorSurface`, `SimpleEditor` and `EditorToolbar` throw a descriptive error without `createEditor()`, the React components without `<EditorContextProvider>`. Both wrap the framework-free `createEditorContext()` from `@ecsplico/editor/core`; the host owns the React context and may call `context.dispose()` itself.
-
-## Runnable examples
-
-- **Plain Vue, no backend:** [`examples/vue-simple`](../../examples/vue-simple) — `SimpleEditor` with a sibling toolbar and heading outline, JSON `v-model`, read-only toggle, external replacement, host `/datum` command and an own block, the „Hinweis“ callout, added through the `extensions` and `slashCommands` props (`/hinweis`, `Mod-Shift-h`, tone select, `!!!` Markdown form). A sample picker loads five demo documents (Start, Formatierung, Gliederung, Hinweise, and „Ungültig (Baustein-JSON)“, which the simple schema rejects through `contentError`); next to the editor the JSON (with block IDs) and the Markdown of the document are shown.
-- **Plain React, no backend:** [`examples/react-simple`](../../examples/react-simple) — the same document picker, read-only toggle and JSON/Markdown panes with the React layer: `EditorToolbar` beside `EditorSurface` over `defineEditor({ features: [coreFeature(), mentionsFeature()] })`, the host `/` commands, `@` mentions from `metadata`, and rejected content through `onContentError`. Vite, Tailwind 4 and shadcn tokens, no Nuxt UI.
-- **Advanced, Nuxt:** this repository's application (`bun run dev`, port 3031) — collaborative documents under switchable demo users (no login: `server/middleware/demo-session.ts` signs every API request into a demo user, `server/api/auth/switch.post.ts` switches it; `app/pages/documents/[id].vue`), the file drawer with `DocumentTree` and a host `DocumentStore` (`app/components/AppDocumentTree.vue`, `app/composables/useDocumentStore.ts`), and a playground with two independent editors, switched in the page header together with the shown editor's sample (`app/pages/playground.vue`, panes in `app/components/PlaygroundPane.vue`, each opening its settings in the `EditorSettingsModal` popup). Editor A is an `AdvancedEditor` with host props (metadata, abilities, a hover action, a `/` command, an own composite kind) on the „Überblick“, „Gliederung“, „Transkript“ and „Leer“ samples; Editor B is an `EditorSurface` on `advancedEditor().features` plus an own feature, the callout (`app/editor/callout/`: toolbar button, `/hinweis`, a tone menu on hover, „Umwandeln in Hinweis“, Markdown form), with a „Markdown einfügen“ button. The „Darstellung“ settings tab switches the whole site between „Standard“ and the seven builtin Obsidian themes (`server/themes/`: Nord, Things, Minimal, Catppuccin, Border, Blue Topaz, Tokyo Night) or an uploaded one, served by the adapter in `server/plugins/editor-adapter.ts`. Walkthrough: [Advanced Nuxt example](./docs/usage.md#advanced-nuxt-example). How to add a block of your own: the [extending guide](./docs/extending.md).
-- **Advanced, React:** [`examples/react-advanced`](../../examples/react-advanced) (`bun run --cwd examples/react-advanced dev`, port 3043; needs the Nuxt app running, Vite proxies `/api` and `/collab` to it) — the React counterpart of the Nuxt document page: a document picker over the host's `/api/documents`, a collaborative `AdvancedEditor` over `HocuspocusProvider` as the demo session's user, `EditorToolbar`, `EditorSettingsModal`, `CommentsMargin`, `CompositeTable`/`CompositeInspector`, `EditorOutline`, `AiSidebar`, `DocumentTree` over an `/api` adapter of `DocumentStore`, and `Toaster`. Vite, Tailwind 4 and shadcn tokens, no Nuxt UI, no Vue.
-
-## Commands
-
-From the repository root, after `bun install`:
-
-```sh
-bun run dev                                   # Nuxt demo app, http://localhost:3031
-bun run typecheck                             # nuxt typecheck of the demo app
-bun run --cwd examples/vue-simple dev        # http://localhost:3040
-bun run --cwd examples/vue-simple build      # prepares the Nuxt UI theme aliases the library typecheck needs
-bun run --cwd examples/vue-simple typecheck
-bun run --cwd examples/react-simple dev     # http://localhost:3041
-bun run --cwd examples/react-simple typecheck
-bun run --cwd examples/react-advanced dev   # http://localhost:3043, needs `bun run dev` (Nuxt host, port 3031)
-bun run --cwd examples/react-advanced typecheck
-bun run --cwd examples/vue-markdown dev     # http://localhost:3045, MarkdownSurface with frontmatter, tables and source mode
-bun run typecheck:editor                      # vue-tsc --noEmit -p packages/editor/tsconfig.json (no Nuxt globals)
-bun run check:editor-entries                  # production build per fixture, module-graph isolation rules
-bun run check:editor-markdown-clipboard       # MarkdownClipboard paste/copy cases (HTML, Markdown, plain text, data-URL opt-in) in happy-dom
-bun run check:editor-composition              # defineEditor rejects missing `requires`; accepted compositions; one formatAiResult contributor
-bun run test:editor                           # bun test over packages/editor/test: framework-free models on a mounted editor (happy-dom)
-```
-
-On a clean checkout run the example build once before `typecheck:editor`.
-
-### Bundle isolation proof
+## Documentation
 
-`bun run check:editor-entries` builds each fixture in `packages/editor/checks/fixtures/<name>/` as its own production Vite app, collects the module IDs of every emitted chunk and fails on forbidden modules (or on a missing required one, so exported factories cannot be tree-shaken away unnoticed). Last result for `simple`: 325 modules, JS 1082.5 kB (gzip 331.1 kB), CSS 194.5 kB (gzip 25.2 kB); for `tree`: 433 modules, JS 1314.5 kB (gzip 389.2 kB), CSS 197.6 kB (gzip 25.7 kB). The `code-only` and `code-only-react` fixtures prove the code surface carries CodeMirror and no ProseMirror or TipTap (and nothing of this package outside `src/code`), and the `markdown-vue` and `tables` fixtures prove the Markdown entries contain no CodeMirror. The check also bundles the advanced schema for Node and compares it with a snapshot (`checks/schema.ts`).
+The documentation lives at **https://skaile-ai.github.io/skaile-editor/** (the package itself no longer ships guides):
 
-## For LLMs and coding agents
+- [Getting started](https://skaile-ai.github.io/skaile-editor/getting-started/introduction): what the package is, installation, quick starts for Nuxt, plain Vue and React, glossary.
+- [Tutorial](https://skaile-ai.github.io/skaile-editor/tutorial/overview): build one editor step by step, including an own block, the backend, AI and the React surface.
+- [Guides](https://skaile-ai.github.io/skaile-editor/guides/composition): feature composition, Nuxt module, `EditorPorts`, collaboration, AI, themes, composites, file browser, production, storage adapters, migration.
+- [Reference](https://skaile-ai.github.io/skaile-editor/reference/exports): every public export, presets and features, the feature contract, CSS and UI-provider requirements, dependency rules, commands, changelog.
+- [AI agents](https://skaile-ai.github.io/skaile-editor/ai-agents): how coding agents read these docs, integrate and extend the editor, invariants and verification.
 
-Start with the [guide for LLM coding agents](./docs/llms.md): what the package is, which entry to import for what, a minimal Nuxt integration, how to choose presets and features, how to contribute a custom feature (`defineEditor`, `setup`, settings tabs, toolbar), the `EditorAdapter`, settings and themes, the pitfalls that break integrations (CSS order, `<UApp>`, `createEditor()`, SSR, bundle isolation, `settingsUi`) and the verification commands. It links the three detail guides instead of repeating them.
+Machine-readable entry points: [`llms.txt`](https://skaile-ai.github.io/skaile-editor/llms.txt), [`llms-full.txt`](https://skaile-ai.github.io/skaile-editor/llms-full.txt), and an installable Agent Skill:
 
-## Documentation
+```sh
+npx skills add https://skaile-ai.github.io/skaile-editor
+```
 
-- [Guide for LLM coding agents](./docs/llms.md): task-oriented orientation with copyable snippets, invariants and the verification commands.
-- [Integration guide](./docs/integration.md): feature composition and the per-feature entries, the UI binding contract, notices and `setup` teardown, browser versus schema/server entries, settings persistence and app lifetime, Nuxt module, `EditorAdapter`, routes and authentication, storage ownership, AI secrets and env names, collaboration on the client, block UI, the Vue-free advanced schema, the file browser and `DocumentStore`, production, migration from `#tiptap-editor` and the dependency rules.
-- [Extending guide](./docs/extending.md): add a block of your own, with the runnable „Hinweis“ callout as the example — through the `extensions`/`slashCommands` props or as a full feature (toolbar, `/` command, hover action, „Umwandeln in …“, Markdown form), what the `editorBlock` flag and custom abilities do, and what collaboration servers and AI need.
-- [Usage guide](./docs/usage.md): plain Vue setup and the `SimpleEditor`, the React setup (`EditorContextProvider`, `EditorSurface`, `EditorToolbar`, `SimpleEditor`, `Toaster`), media/mentions/transcript, authors and comments, themes, composites and the settings UI, file import, AI and its integrations, the file browser, the advanced editor in React (`./react/advanced`), and the Advanced Nuxt example (a walkthrough of this repository's app).
+Runnable examples live in the repository: [`examples/`](https://github.com/skaile-ai/skaile-editor/tree/main/examples) and the Nuxt app (`bun run dev`, port 3056). To work on the documentation site from a checkout of the repository, run `bun run docs:dev` (development server) or `bun run docs:build` (static build); see [`docs/README.md`](https://github.com/skaile-ai/skaile-editor/blob/main/docs/README.md).

package/dist/adapters/comments/drizzle.d.ts

@@ -1,6 +1,6 @@
 import { PortableAnchor } from "../anchors.js";
-import { EditorDb } from "../drizzle.js";
 import { CommentStore } from "./types.js";
+import { EditorDb } from "../drizzle.js";
 import { SQLiteColumn } from "drizzle-orm/sqlite-core";
 //#region src/adapters/comments/drizzle.d.ts
 declare const COMMENT_TABLES: {

package/dist/adapters/comments/record.d.ts

@@ -0,0 +1,15 @@
+import { Annotation, Comment, CommentThread, Discussion, NewThread, ThreadStatus } from "./types.js";
+//#region src/adapters/comments/record.d.ts
+export declare const emptyDiscussion: () => Discussion;
+export declare function createThread(record: Discussion, input: NewThread): {
+  annotation: Annotation;
+  thread: CommentThread;
+};
+export declare function addComment(record: Discussion, threadId: string, comment: Comment): CommentThread;
+export declare function editComment(record: Discussion, threadId: string, commentId: string, body: string, editedAt: string): CommentThread;
+export declare function removeComment(record: Discussion, threadId: string, commentId: string): CommentThread;
+export declare function setThreadStatus(record: Discussion, threadId: string, status: ThreadStatus): CommentThread;
+export declare function updateAnchor(record: Discussion, annotation: Annotation): Annotation;
+export declare function removeThread(record: Discussion, threadId: string): void;
+//#endregion
+//# sourceMappingURL=record.d.ts.map

package/dist/adapters/comments/{client.js → rest-model.js}

@@ -1,10 +1,10 @@
 import { captureAnchor, capturePoint, mapAnchor, resolveAnchor } from "../anchors.js";
 import { createStore } from "../../core/store.js";
 import { releaseRanges, resolveRange } from "../../core/doc-anchors.js";
-import { COMMENT_LIMITS } from "../../features/comments/schema.js";
 import { cancelCommentDraft, commentsKey, setActiveComment, startCommentDraft } from "../../features/comments/comments-plugin.js";
+import { COMMENT_LIMITS } from "../../features/comments/schema.js";
 import { EMPTY_SNAPSHOT, NO_POSITIONS, NO_RANGES, sameOrphanAt, sameRange, sameRanges, sameUser } from "../../features/comments/snapshot-equality.js";
-//#region src/adapters/comments/client.ts
+//#region src/adapters/comments/rest-model.ts
 /** Neutral colour of authors that stored no colour. */
 const FALLBACK_COLOR = "#6b7280";
 /** Characters of context that must agree for an orphan to be re-attached on load. */
@@ -533,4 +533,4 @@ function createRestCommentsModel(options) {
 //#endregion
 export { createRestCommentsModel };
 
-//# sourceMappingURL=client.js.map
+//# sourceMappingURL=rest-model.js.map

package/dist/adapters/comments/rest-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-model.js","names":[],"sources":["../../../src/adapters/comments/rest-model.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { Transaction } from '@tiptap/pm/state'\nimport { type AuthorIdentity, createStore, releaseRanges, resolveRange } from '../../core'\nimport { cancelCommentDraft, COMMENT_LIMITS, type CommentReply, type CommentsModel, type CommentsSnapshot, type CommentThread as EditorThread, commentsKey, type DocRange, setActiveComment, startCommentDraft } from '../../features/comments'\nimport { EMPTY_SNAPSHOT, NO_POSITIONS, NO_RANGES, NO_THREADS, sameOrphanAt, sameRange, sameRanges, sameUser } from '../../features/comments/snapshot-equality'\nimport { captureAnchor, capturePoint, type PortableAnchor, resolveAnchor, mapAnchor } from '../anchors'\nimport type { Annotation, Comment, CommentAction, CommentThread, Discussion } from './types'\n\n// A `CommentsModel` for the editor's comments feature (`commentsFeature({ model })`) whose threads live behind a REST\n// endpoint (`handleCommentsRequest` serves it) instead of the document's Y.Doc. The text a thread hangs on is a\n// portable anchor (`../anchors`), not a `comment` mark: anchors are resolved against the document when the threads\n// load, follow every edit of the editor, and are written back to the endpoint when they moved. Not an entry of its own:\n// hosts get it as `createHttpBackend().comments(documentId, …)` (`../http`).\n\n/** The part of a `Response` the model reads; `globalThis.fetch` fits. */\nexport interface CommentsFetchResponse {\n  ok: boolean\n  status: number\n  json(): Promise<unknown>\n}\n\nexport type CommentsFetch = (url: string, init?: { method?: string, headers?: Record<string, string>, body?: string }) => Promise<CommentsFetchResponse>\n\nexport interface RestCommentsModelOptions {\n  /** How requests are sent: `globalThis.fetch`, or a wrapper that adds the base URL and credentials. */\n  fetch: CommentsFetch\n  /** The document the threads belong to. */\n  documentId: string\n  /** The document's comments endpoint (`GET` → `Discussion`, `POST` → `CommentAction`); default `/comments/<encoded documentId>`. */\n  endpoint?: string\n  /** Who writes: the author of new comments and the only one who may edit or delete them; `null` while nobody is signed in (no comments then). */\n  user: AuthorIdentity | null | (() => AuthorIdentity | null)\n  /** Whether the user may compose and change comments now; readers of a read-only document may be allowed. */\n  canComment: boolean | (() => boolean)\n  /** The editor the threads belong to; may return no editor yet or a destroyed one. */\n  getEditor: () => Editor | undefined\n  /** Milliseconds a changed anchor waits before it is written back (typing moves many); default 500. `idle()` writes at once. */\n  persistDelay?: number\n  /** Called with every failed request; the model reloads the threads afterwards, so the local state falls back to the server's. */\n  onError?: (error: Error) => void\n}\n\nexport interface RestCommentsModel extends CommentsModel {\n  /** Fetches the threads again and resolves their anchors against the current document. */\n  reload(): Promise<void>\n  /** Resolves once every change made so far has been sent (and the threads loaded, if a load was requested). */\n  idle(): Promise<void>\n}\n\n/** Neutral colour of authors that stored no colour. */\nconst FALLBACK_COLOR = '#6b7280'\n/** Characters of context that must agree for an orphan to be re-attached on load. */\nconst REATTACH_CONTEXT = 24\n\nconst newId = (prefix: string) => `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`\n/** The `error` message of a refused request's JSON body. */\nfunction errorOf(body: unknown): unknown {\n  return typeof body === 'object' && body !== null && 'error' in body ? body.error : undefined\n}\n\nfunction isDiscussion(value: unknown): value is Discussion {\n  return typeof value === 'object' && value !== null && 'annotations' in value && Array.isArray(value.annotations) && 'threads' in value && Array.isArray(value.threads)\n}\n\nconst sameJson = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)\n\nconst authorOf = (comment: Comment): EditorThread['author'] => ({ id: comment.authorId, name: comment.authorName ?? comment.authorId, color: comment.authorColor ?? FALLBACK_COLOR })\n\nfunction quoteOf(anchor: PortableAnchor | undefined): string {\n  if (!anchor) return ''\n  if (anchor.kind === 'range') return anchor.quote\n  if (anchor.kind === 'orphan') return anchor.quote ?? (anchor.previous.kind === 'range' ? anchor.previous.quote : '')\n  return ''\n}\n\nfunction viewOf(thread: CommentThread, anchor: PortableAnchor | undefined): EditorThread {\n  const [first, ...replies] = thread.comments\n  return {\n    id: thread.id,\n    author: first ? authorOf(first) : { id: '', name: '', color: FALLBACK_COLOR },\n    text: first?.body ?? '',\n    createdAt: first?.createdAt ?? '',\n    ...(first?.editedAt !== undefined && { editedAt: first.editedAt }),\n    quote: quoteOf(anchor),\n    resolved: thread.status === 'resolved',\n    replies: replies.map((reply): CommentReply => ({\n      id: reply.id,\n      author: authorOf(reply),\n      text: reply.body,\n      createdAt: reply.createdAt,\n      ...(reply.editedAt !== undefined && { editedAt: reply.editedAt }),\n    })),\n  }\n}\n\nfunction rangeOf(anchor: PortableAnchor | undefined): DocRange | null {\n  if (!anchor || anchor.kind === 'orphan') return null\n  return anchor.kind === 'range' ? { from: anchor.from, to: anchor.to } : { from: anchor.position, to: anchor.position }\n}\n\n/** A document is \"empty\" while the host has not put its content in yet: nothing to resolve anchors against. */\nconst isBlank = (doc: { textContent: string }) => doc.textContent === ''\n\n/** Whether the text at `candidate` still reads like the context `previous` was written in (one side suffices). */\nfunction contextAgrees(candidate: PortableAnchor, previous: PortableAnchor): boolean {\n  if (candidate.kind === 'orphan' || previous.kind === 'orphan') return false\n  const before = previous.contextBefore?.slice(-REATTACH_CONTEXT)\n  const after = previous.contextAfter?.slice(0, REATTACH_CONTEXT)\n  if (!before && !after) return true\n  return (!!before && !!candidate.contextBefore?.endsWith(before)) || (!!after && !!candidate.contextAfter?.startsWith(after))\n}\n\n/**\n * The comments of one editor over a REST endpoint, as a `CommentsModel` (the host passes `() => model` as the\n * `model` factory of `commentsFeature`/`commentsFeatureCore`; one instance serves the plugin and every hook).\n *\n * - **Load.** `refresh()` (called by the feature once the editor exists) fetches `GET endpoint`; each annotation's\n *   anchor is resolved against the document (exact offsets, else quote and context search). An anchor that moved is\n *   re-captured and written back; an anchor whose text is gone becomes an `orphan` (the thread stays, without a range)\n *   and an orphan whose text is back with the same surroundings is re-attached. While the document is still empty the\n *   resolving waits for its content.\n * - **Edits.** Every transaction carries all anchors with it (`mapAnchor`), so ranges, quotes and contexts follow the\n *   text; changed anchors are written back after `persistDelay`. Text deleted under an anchor orphans it for good (it is\n *   never silently re-attached to other text during editing; `reload()` re-attaches it when its text and context\n *   are found again, e.g. after the content was replaced).\n * - **Writes** are applied locally at once and sent in order; a failed request is reported to `onError` and the threads\n *   are reloaded. Without a `user` or while `canComment` is false nothing is written. Only the author may edit or\n *   delete a comment.\n * - **Lifecycle.** The model follows the editor `getEditor` names until that editor is destroyed; `dispose()` writes\n *   pending anchor changes and does not stop it (the feature and its hooks share the instance and dispose it on their\n *   own schedule).\n */\nexport function createRestCommentsModel(options: RestCommentsModelOptions): RestCommentsModel {\n  const { fetch, documentId, getEditor, onError } = options\n  const endpoint = options.endpoint ?? `/comments/${encodeURIComponent(documentId)}`\n  const persistDelay = options.persistDelay ?? 500\n  const store = createStore<CommentsSnapshot>(EMPTY_SNAPSHOT)\n\n  const userNow = () => (typeof options.user === 'function' ? options.user() : options.user)\n  const canCommentNow = () => (typeof options.canComment === 'function' ? options.canComment() : options.canComment)\n  /** Editors that announced their destruction: their view is still alive while `destroy` is emitted. */\n  const gone = new WeakSet<Editor>()\n  const current = () => {\n    const instance = getEditor()\n    return instance && !instance.isDestroyed && !gone.has(instance) ? instance : undefined\n  }\n\n  // -- Data: what the endpoint holds (annotation anchors are the local truth until written back) -----------------------\n  let threads: readonly CommentThread[] = []\n  let anchors = new Map<string, PortableAnchor>()\n  /** The anchor each annotation has on the server, serialised. */\n  const persisted = new Map<string, string>()\n  const dirty = new Set<string>()\n  /**\n   * Where the text of an annotation that became an orphan during this session was: the deletion point, mapped through\n   * every later edit. Keyed by annotation id (`orphanAt` in the snapshot is keyed by thread id; `orphanPositions` translates).\n   * Deletion points are session-local: `load()` clears them, and an anchor that arrives already orphaned has none, because\n   * the server stores no deletion point. Such threads get no `orphanAt` entry and sit after the placed ones in the margin.\n   */\n  const deletedAt = new Map<string, number>()\n  /** Anchors wait for the document content (resolve on load) before they get a range. */\n  let unresolved = false\n  /** A load was requested / the first one succeeded: writes wait for it, so a load never overwrites a newer local change. */\n  let loaded = false\n  let ready = false\n\n  // -- Requests: one queue, so a reply never overtakes its thread's creation ---------------------------------------------\n  let chain: Promise<void> = Promise.resolve()\n  let timer: ReturnType<typeof setTimeout> | undefined\n\n  function enqueue(task: () => Promise<void>, reloadOnError = true): void {\n    chain = chain.then(task).catch((error: unknown) => {\n      onError?.(error instanceof Error ? error : new Error(String(error)))\n      if (reloadOnError) enqueue(load, false)\n    })\n  }\n\n  async function request(init?: { method: string, body: CommentAction }): Promise<unknown> {\n    const response = await fetch(endpoint, init && { method: init.method, headers: { 'content-type': 'application/json' }, body: JSON.stringify(init.body) })\n    if (!response.ok) {\n      const detail = await response.json().then(errorOf, () => undefined)\n      throw new Error(`@ecsplico/editor: comments request ${init?.method ?? 'GET'} ${endpoint} failed: ${response.status}${typeof detail === 'string' ? ` ${detail}` : ''}`)\n    }\n    return response.json()\n  }\n\n  const send = (body: CommentAction) => enqueue(async () => void await request({ method: 'POST', body }))\n\n  function writeAnchors(): void {\n    timer = undefined\n    if (!userNow() || !ready || !canCommentNow()) {\n      dirty.clear()\n      return\n    }\n    for (const id of dirty) {\n      const anchor = anchors.get(id)\n      const threadId = threads.find(thread => thread.annotationId === id)?.id\n      if (!anchor || !threadId || persisted.get(id) === JSON.stringify(anchor)) continue\n      persisted.set(id, JSON.stringify(anchor))\n      send({ action: 'update-annotation', annotation: { id, threadId, anchor } })\n    }\n    dirty.clear()\n  }\n\n  function markDirty(id: string): void {\n    dirty.add(id)\n    if (timer === undefined) timer = setTimeout(writeAnchors, persistDelay)\n  }\n\n  function flush(): void {\n    clearTimeout(timer)\n    writeAnchors()\n  }\n\n  // -- Anchors ------------------------------------------------------------------------------------------------------------\n\n  /** `anchor` read against `editor`'s document: the moved/re-captured anchor, an orphan, or the same object. */\n  function resolveOne(editor: Editor, anchor: PortableAnchor): PortableAnchor {\n    const live = anchor.kind === 'orphan' ? anchor.previous : anchor\n    const found = resolveAnchor(editor.state.doc, live)\n    if (!found) {\n      return anchor.kind === 'orphan'\n        ? anchor\n        : { kind: 'orphan', previous: anchor, quote: quoteOf(anchor) || undefined, contextBefore: anchor.contextBefore, contextAfter: anchor.contextAfter, reason: 'unresolvable' }\n    }\n    const next = live.kind === 'range' ? captureAnchor(editor, found) : capturePoint(editor, found.from)\n    if (anchor.kind === 'orphan' && !contextAgrees(next, live)) return anchor\n    return sameJson(next, anchor) ? anchor : next\n  }\n\n  function resolveAll(editor: Editor): void {\n    if (isBlank(editor.state.doc)) {\n      unresolved = anchors.size > 0\n      return\n    }\n    unresolved = false\n    for (const [id, anchor] of anchors) {\n      const next = resolveOne(editor, anchor)\n      if (next !== anchor) {\n        anchors.set(id, next)\n        if (next.kind !== 'orphan') deletedAt.delete(id)\n        markDirty(id)\n      }\n    }\n  }\n\n  function carry(transactions: readonly Transaction[]): void {\n    for (const transaction of transactions) {\n      if (!transaction.docChanged) continue\n      for (const [id, position] of deletedAt) deletedAt.set(id, transaction.mapping.map(position, 1))\n      for (const [id, anchor] of anchors) {\n        const next = mapAnchor(anchor, transaction)\n        if (next !== anchor) {\n          anchors.set(id, next)\n          if (next.kind === 'orphan' && anchor.kind !== 'orphan') {\n            deletedAt.set(id, transaction.mapping.map(anchor.kind === 'range' ? anchor.from : anchor.position, 1))\n          }\n          markDirty(id)\n        }\n      }\n    }\n  }\n\n  // -- Snapshot -----------------------------------------------------------------------------------------------------------\n\n  function rangesOf(editor: Editor | undefined): ReadonlyMap<string, DocRange> {\n    if (!editor || unresolved) return NO_RANGES\n    const size = editor.state.doc.content.size\n    const ranges = new Map<string, DocRange>()\n    for (const thread of threads) {\n      const range = rangeOf(anchors.get(thread.annotationId))\n      if (range && range.from <= size) ranges.set(thread.id, { from: range.from, to: Math.min(range.to, size) })\n    }\n    return ranges\n  }\n\n  /**\n   * The snapshot's `orphanAt`, keyed by thread id: where each open thread without a text range was, read from `deletedAt`\n   * (keyed by annotation id). Empty when there is no tracked deletion point; threads loaded already orphaned never have one\n   * (the server stores none) and are left out, so they sit after the placed ones in the margin.\n   */\n  function orphanPositions(editor: Editor | undefined, ranges: ReadonlyMap<string, DocRange>): ReadonlyMap<string, number> {\n    if (!editor || unresolved || deletedAt.size === 0) return NO_POSITIONS\n    const size = editor.state.doc.content.size\n    let found: Map<string, number> | undefined\n    for (const thread of threads) {\n      if (thread.status === 'resolved' || ranges.has(thread.id)) continue\n      const position = deletedAt.get(thread.annotationId)\n      if (position !== undefined && position <= size) (found ??= new Map()).set(thread.id, position)\n    }\n    return found ?? NO_POSITIONS\n  }\n\n  function recompute(): void {\n    const editor = current()\n    const previous = store.get()\n    const user = userNow()\n    const available = user !== null\n    const canComment = available && ready && canCommentNow()\n    const views = threads.map(thread => viewOf(thread, anchors.get(thread.annotationId)))\n    const nextRanges = rangesOf(editor)\n    const ranges = sameRanges(nextRanges, previous.ranges) ? previous.ranges : nextRanges\n    const nextOrphanAt = orphanPositions(editor, ranges)\n    const orphanAt = sameOrphanAt(nextOrphanAt, previous.orphanAt) ? previous.orphanAt : nextOrphanAt\n    const plugin = editor && commentsKey.getState(editor.state)\n    const active = plugin?.active ?? null\n    const anchor = plugin?.draft\n    const draft = editor && anchor ? resolveRange(editor.state, anchor) : null\n    const draftQuote = editor && draft ? editor.state.doc.textBetween(draft.from, draft.to, ' ').slice(0, COMMENT_LIMITS.quote) : ''\n    const sameViews = (views.length === previous.threads.length && views.every((view, index) => sameJson(view, previous.threads[index])))\n    const threadsOut = sameViews ? previous.threads : views\n\n    if (\n      available === previous.available && canComment === previous.canComment && sameUser(user, previous.user) && threadsOut === previous.threads\n      && ranges === previous.ranges && orphanAt === previous.orphanAt && active === previous.active && sameRange(draft, previous.draft) && draftQuote === previous.draftQuote\n    ) return\n\n    const kept = threadsOut === previous.threads && ranges === previous.ranges\n    store.set({\n      available,\n      canComment,\n      user,\n      threads: threadsOut,\n      ranges,\n      orphanAt,\n      active,\n      draft: sameRange(draft, previous.draft) ? previous.draft : draft,\n      draftQuote,\n      open: kept\n        ? previous.open\n        : threadsOut\n            .filter(thread => !thread.resolved)\n            .sort((a, b) => (ranges.get(a.id)?.from ?? Infinity) - (ranges.get(b.id)?.from ?? Infinity) || a.createdAt.localeCompare(b.createdAt)),\n      resolved: threadsOut === previous.threads ? previous.resolved : threadsOut.filter(thread => thread.resolved).sort((a, b) => b.createdAt.localeCompare(a.createdAt)),\n    })\n  }\n\n  // -- Editor binding -----------------------------------------------------------------------------------------------------\n\n  let bound: Editor | undefined\n\n  function onTransaction({ transaction, appendedTransactions }: { transaction: Transaction, appendedTransactions?: readonly Transaction[] }): void {\n    const editor = bound\n    if (editor && anchors.size) {\n      const all = [transaction, ...(appendedTransactions ?? [])]\n      if (all.some(tr => tr.docChanged)) {\n        if (isBlank(editor.state.doc)) unresolved = true\n        else if (unresolved) resolveAll(editor)\n        else carry(all)\n      }\n    }\n    recompute()\n  }\n\n  function onDestroy(): void {\n    if (bound) gone.add(bound)\n    unbind()\n    recompute()\n  }\n\n  function unbind(): void {\n    bound?.off('transaction', onTransaction)\n    bound?.off('update', recompute)\n    bound?.off('destroy', onDestroy)\n    bound = undefined\n  }\n\n  function refresh(): void {\n    const editor = current()\n    if (editor !== bound) {\n      unbind()\n      bound = editor\n      editor?.on('transaction', onTransaction)\n      // `setEditable` emits `update` only, and `canComment` may follow it.\n      editor?.on('update', recompute)\n      editor?.on('destroy', onDestroy)\n      if (editor && loaded) resolveAll(editor)\n    }\n    if (!loaded) {\n      loaded = true\n      enqueue(load, false)\n    }\n    recompute()\n  }\n\n  function dispose(): void {\n    flush()\n  }\n\n  async function load(): Promise<void> {\n    const discussion = await request()\n    if (!isDiscussion(discussion)) throw new Error(`@ecsplico/editor: comments request GET ${endpoint} did not answer a discussion`)\n    threads = discussion.threads\n    anchors = new Map(discussion.annotations.map((annotation: Annotation) => [annotation.id, annotation.anchor]))\n    persisted.clear()\n    for (const [id, anchor] of anchors) persisted.set(id, JSON.stringify(anchor))\n    dirty.clear()\n    deletedAt.clear()\n    ready = true\n    const editor = current()\n    unresolved = anchors.size > 0\n    if (editor) resolveAll(editor)\n    recompute()\n  }\n\n  function reload(): Promise<void> {\n    flush()\n    loaded = true\n    enqueue(load, false)\n    return idle()\n  }\n\n  async function idle(): Promise<void> {\n    flush()\n    const seen = chain\n    await seen\n    // A request that failed queued a reload, a finished one may have moved anchors.\n    if (chain !== seen || timer !== undefined || dirty.size > 0) await idle()\n  }\n\n  // -- Mutations ----------------------------------------------------------------------------------------------------------\n\n  /** Trimmed and cut to the limit; '' when nothing is left. */\n  const clean = (text: string) => text.trim().slice(0, COMMENT_LIMITS.text)\n\n  function writer(): AuthorIdentity | null {\n    const user = userNow()\n    return user && ready && canCommentNow() ? user : null\n  }\n\n  const commentOf = (user: AuthorIdentity, body: string): Comment => ({ id: newId('cm'), body, authorId: user.id, authorName: user.name, authorColor: user.color, createdAt: new Date().toISOString() })\n\n  function setThreads(next: readonly CommentThread[]): void {\n    threads = next\n    recompute()\n  }\n\n  const threadById = (id: string) => threads.find(thread => thread.id === id)\n\n  function replaceThread(id: string, change: (thread: CommentThread) => CommentThread): void {\n    setThreads(threads.map(thread => (thread.id === id ? change(thread) : thread)))\n  }\n\n  function add(text: string): string | null {\n    const editor = current()\n    const user = writer()\n    const body = clean(text)\n    const draft = editor && commentsKey.getState(editor.state)?.draft\n    const range = editor && draft ? resolveRange(editor.state, draft) : null\n    if (!editor || !user || !draft || !range || range.from >= range.to || !body) return null\n    const threadId = newId('ct')\n    const annotation: Annotation = { id: newId('ca'), threadId, anchor: captureAnchor(editor, range) }\n    const comment = commentOf(user, body)\n    editor.view.dispatch(editor.state.tr.setMeta(commentsKey, { draft: null, active: threadId }).setMeta('addToHistory', false))\n    releaseRanges(editor, [draft])\n    anchors.set(annotation.id, annotation.anchor)\n    persisted.set(annotation.id, JSON.stringify(annotation.anchor))\n    threads = [...threads, { id: threadId, annotationId: annotation.id, status: 'open', comments: [comment] }]\n    recompute()\n    send({ action: 'create', annotation, thread: { id: threadId, annotationId: annotation.id, initialComment: comment } })\n    return threadId\n  }\n\n  function reply(threadId: string, text: string): void {\n    const user = writer()\n    const body = clean(text)\n    if (!user || !body || !threadById(threadId)) return\n    const comment = commentOf(user, body)\n    replaceThread(threadId, thread => ({ ...thread, comments: [...thread.comments, comment] }))\n    send({ action: 'reply', threadId, comment })\n  }\n\n  function edit(threadId: string, replyId: string | null, text: string): void {\n    const user = writer()\n    const body = clean(text)\n    const thread = threadById(threadId)\n    const target = thread && (replyId === null ? thread.comments[0] : thread.comments.find(comment => comment.id === replyId))\n    if (!user || !body || !thread || !target || target.authorId !== user.id || target.body === body) return\n    const editedAt = new Date().toISOString()\n    replaceThread(threadId, item => ({ ...item, comments: item.comments.map(comment => (comment.id === target.id ? { ...comment, body, editedAt } : comment)) }))\n    send({ action: 'edit', threadId, commentId: target.id, body, editedAt })\n  }\n\n  const activeThread = () => {\n    const editor = current()\n    return editor ? commentsKey.getState(editor.state)?.active ?? null : null\n  }\n\n  function setResolved(threadId: string, resolved: boolean): void {\n    const thread = threadById(threadId)\n    if (!writer() || !thread || (thread.status === 'resolved') === resolved) return\n    const status = resolved ? 'resolved' : 'open'\n    replaceThread(threadId, item => ({ ...item, status }))\n    if (resolved && activeThread() === threadId) activate(null)\n    send({ action: 'status', threadId, status })\n  }\n\n  function remove(threadId: string): void {\n    const user = writer()\n    const thread = threadById(threadId)\n    if (!user || !thread || thread.comments[0]?.authorId !== user.id) return\n    if (activeThread() === threadId) activate(null)\n    anchors.delete(thread.annotationId)\n    persisted.delete(thread.annotationId)\n    dirty.delete(thread.annotationId)\n    deletedAt.delete(thread.annotationId)\n    setThreads(threads.filter(item => item.id !== threadId))\n    send({ action: 'remove', threadId })\n  }\n\n  function removeReply(threadId: string, replyId: string): void {\n    const user = writer()\n    const thread = threadById(threadId)\n    const target = thread?.comments.slice(1).find(comment => comment.id === replyId)\n    if (!user || !thread || !target || target.authorId !== user.id) return\n    replaceThread(threadId, item => ({ ...item, comments: item.comments.filter(comment => comment.id !== replyId) }))\n    send({ action: 'remove-comment', threadId, commentId: replyId })\n  }\n\n  function activate(id: string | null, activateOptions: { reveal?: boolean } = {}): void {\n    const editor = current()\n    if (editor) setActiveComment(editor, id, activateOptions)\n  }\n\n  function startDraft(): void {\n    const editor = current()\n    if (editor && writer()) startCommentDraft(editor)\n  }\n\n  function cancelDraft(): void {\n    const editor = current()\n    if (editor) cancelCommentDraft(editor)\n  }\n\n  return { state: store, refresh, dispose, add, reply, edit, setResolved, remove, removeReply, activate, startDraft, cancelDraft, reload, idle }\n}\n"],"mappings":";;;;;;;;AAkDA,MAAM,iBAAiB;;AAEvB,MAAM,mBAAmB;AAEzB,MAAM,SAAS,WAAmB,GAAG,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC;;AAE/G,SAAS,QAAQ,MAAwB;CACvC,OAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,WAAW,OAAO,KAAK,QAAQ,KAAA;AACrF;AAEA,SAAS,aAAa,OAAqC;CACzD,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,iBAAiB,SAAS,MAAM,QAAQ,MAAM,WAAW,KAAK,aAAa,SAAS,MAAM,QAAQ,MAAM,OAAO;AACvK;AAEA,MAAM,YAAY,GAAY,MAAe,KAAK,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC;AAEnF,MAAM,YAAY,aAA8C;CAAE,IAAI,QAAQ;CAAU,MAAM,QAAQ,cAAc,QAAQ;CAAU,OAAO,QAAQ,eAAe;AAAe;AAEnL,SAAS,QAAQ,QAA4C;CAC3D,IAAI,CAAC,QAAQ,OAAO;CACpB,IAAI,OAAO,SAAS,SAAS,OAAO,OAAO;CAC3C,IAAI,OAAO,SAAS,UAAU,OAAO,OAAO,UAAU,OAAO,SAAS,SAAS,UAAU,OAAO,SAAS,QAAQ;CACjH,OAAO;AACT;AAEA,SAAS,OAAO,QAAuB,QAAkD;CACvF,MAAM,CAAC,OAAO,GAAG,WAAW,OAAO;CACnC,OAAO;EACL,IAAI,OAAO;EACX,QAAQ,QAAQ,SAAS,KAAK,IAAI;GAAE,IAAI;GAAI,MAAM;GAAI,OAAO;EAAe;EAC5E,MAAM,OAAO,QAAQ;EACrB,WAAW,OAAO,aAAa;EAC/B,GAAI,OAAO,aAAa,KAAA,KAAa,EAAE,UAAU,MAAM,SAAS;EAChE,OAAO,QAAQ,MAAM;EACrB,UAAU,OAAO,WAAW;EAC5B,SAAS,QAAQ,KAAK,WAAyB;GAC7C,IAAI,MAAM;GACV,QAAQ,SAAS,KAAK;GACtB,MAAM,MAAM;GACZ,WAAW,MAAM;GACjB,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,MAAM,SAAS;EACjE,EAAE;CACJ;AACF;AAEA,SAAS,QAAQ,QAAqD;CACpE,IAAI,CAAC,UAAU,OAAO,SAAS,UAAU,OAAO;CAChD,OAAO,OAAO,SAAS,UAAU;EAAE,MAAM,OAAO;EAAM,IAAI,OAAO;CAAG,IAAI;EAAE,MAAM,OAAO;EAAU,IAAI,OAAO;CAAS;AACvH;;AAGA,MAAM,WAAW,QAAiC,IAAI,gBAAgB;;AAGtE,SAAS,cAAc,WAA2B,UAAmC;CACnF,IAAI,UAAU,SAAS,YAAY,SAAS,SAAS,UAAU,OAAO;CACtE,MAAM,SAAS,SAAS,eAAe,MAAM,GAAiB;CAC9D,MAAM,QAAQ,SAAS,cAAc,MAAM,GAAG,gBAAgB;CAC9D,IAAI,CAAC,UAAU,CAAC,OAAO,OAAO;CAC9B,OAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,UAAU,eAAe,SAAS,MAAM,KAAO,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,cAAc,WAAW,KAAK;AAC5H;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,wBAAwB,SAAsD;CAC5F,MAAM,EAAE,OAAO,YAAY,WAAW,YAAY;CAClD,MAAM,WAAW,QAAQ,YAAY,aAAa,mBAAmB,UAAU;CAC/E,MAAM,eAAe,QAAQ,gBAAgB;CAC7C,MAAM,QAAQ,YAA8B,cAAc;CAE1D,MAAM,gBAAiB,OAAO,QAAQ,SAAS,aAAa,QAAQ,KAAK,IAAI,QAAQ;CACrF,MAAM,sBAAuB,OAAO,QAAQ,eAAe,aAAa,QAAQ,WAAW,IAAI,QAAQ;;CAEvG,MAAM,uBAAO,IAAI,QAAgB;CACjC,MAAM,gBAAgB;EACpB,MAAM,WAAW,UAAU;EAC3B,OAAO,YAAY,CAAC,SAAS,eAAe,CAAC,KAAK,IAAI,QAAQ,IAAI,WAAW,KAAA;CAC/E;CAGA,IAAI,UAAoC,CAAC;CACzC,IAAI,0BAAU,IAAI,IAA4B;;CAE9C,MAAM,4BAAY,IAAI,IAAoB;CAC1C,MAAM,wBAAQ,IAAI,IAAY;;;;;;;CAO9B,MAAM,4BAAY,IAAI,IAAoB;;CAE1C,IAAI,aAAa;;CAEjB,IAAI,SAAS;CACb,IAAI,QAAQ;CAGZ,IAAI,QAAuB,QAAQ,QAAQ;CAC3C,IAAI;CAEJ,SAAS,QAAQ,MAA2B,gBAAgB,MAAY;EACtE,QAAQ,MAAM,KAAK,IAAI,CAAC,CAAC,OAAO,UAAmB;GACjD,UAAU,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;GACnE,IAAI,eAAe,QAAQ,MAAM,KAAK;EACxC,CAAC;CACH;CAEA,eAAe,QAAQ,MAAkE;EACvF,MAAM,WAAW,MAAM,MAAM,UAAU,QAAQ;GAAE,QAAQ,KAAK;GAAQ,SAAS,EAAE,gBAAgB,mBAAmB;GAAG,MAAM,KAAK,UAAU,KAAK,IAAI;EAAE,CAAC;EACxJ,IAAI,CAAC,SAAS,IAAI;GAChB,MAAM,SAAS,MAAM,SAAS,KAAK,CAAC,CAAC,KAAK,eAAe,KAAA,CAAS;GAClE,MAAM,IAAI,MAAM,sCAAsC,MAAM,UAAU,MAAM,GAAG,SAAS,WAAW,SAAS,SAAS,OAAO,WAAW,WAAW,IAAI,WAAW,IAAI;EACvK;EACA,OAAO,SAAS,KAAK;CACvB;CAEA,MAAM,QAAQ,SAAwB,QAAQ,YAAY,KAAK,MAAM,QAAQ;EAAE,QAAQ;EAAQ;CAAK,CAAC,CAAC;CAEtG,SAAS,eAAqB;EAC5B,QAAQ,KAAA;EACR,IAAI,CAAC,QAAQ,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG;GAC5C,MAAM,MAAM;GACZ;EACF;EACA,KAAK,MAAM,MAAM,OAAO;GACtB,MAAM,SAAS,QAAQ,IAAI,EAAE;GAC7B,MAAM,WAAW,QAAQ,MAAK,WAAU,OAAO,iBAAiB,EAAE,CAAC,EAAE;GACrE,IAAI,CAAC,UAAU,CAAC,YAAY,UAAU,IAAI,EAAE,MAAM,KAAK,UAAU,MAAM,GAAG;GAC1E,UAAU,IAAI,IAAI,KAAK,UAAU,MAAM,CAAC;GACxC,KAAK;IAAE,QAAQ;IAAqB,YAAY;KAAE;KAAI;KAAU;IAAO;GAAE,CAAC;EAC5E;EACA,MAAM,MAAM;CACd;CAEA,SAAS,UAAU,IAAkB;EACnC,MAAM,IAAI,EAAE;EACZ,IAAI,UAAU,KAAA,GAAW,QAAQ,WAAW,cAAc,YAAY;CACxE;CAEA,SAAS,QAAc;EACrB,aAAa,KAAK;EAClB,aAAa;CACf;;CAKA,SAAS,WAAW,QAAgB,QAAwC;EAC1E,MAAM,OAAO,OAAO,SAAS,WAAW,OAAO,WAAW;EAC1D,MAAM,QAAQ,cAAc,OAAO,MAAM,KAAK,IAAI;EAClD,IAAI,CAAC,OACH,OAAO,OAAO,SAAS,WACnB,SACA;GAAE,MAAM;GAAU,UAAU;GAAQ,OAAO,QAAQ,MAAM,KAAK,KAAA;GAAW,eAAe,OAAO;GAAe,cAAc,OAAO;GAAc,QAAQ;EAAe;EAE9K,MAAM,OAAO,KAAK,SAAS,UAAU,cAAc,QAAQ,KAAK,IAAI,aAAa,QAAQ,MAAM,IAAI;EACnG,IAAI,OAAO,SAAS,YAAY,CAAC,cAAc,MAAM,IAAI,GAAG,OAAO;EACnE,OAAO,SAAS,MAAM,MAAM,IAAI,SAAS;CAC3C;CAEA,SAAS,WAAW,QAAsB;EACxC,IAAI,QAAQ,OAAO,MAAM,GAAG,GAAG;GAC7B,aAAa,QAAQ,OAAO;GAC5B;EACF;EACA,aAAa;EACb,KAAK,MAAM,CAAC,IAAI,WAAW,SAAS;GAClC,MAAM,OAAO,WAAW,QAAQ,MAAM;GACtC,IAAI,SAAS,QAAQ;IACnB,QAAQ,IAAI,IAAI,IAAI;IACpB,IAAI,KAAK,SAAS,UAAU,UAAU,OAAO,EAAE;IAC/C,UAAU,EAAE;GACd;EACF;CACF;CAEA,SAAS,MAAM,cAA4C;EACzD,KAAK,MAAM,eAAe,cAAc;GACtC,IAAI,CAAC,YAAY,YAAY;GAC7B,KAAK,MAAM,CAAC,IAAI,aAAa,WAAW,UAAU,IAAI,IAAI,YAAY,QAAQ,IAAI,UAAU,CAAC,CAAC;GAC9F,KAAK,MAAM,CAAC,IAAI,WAAW,SAAS;IAClC,MAAM,OAAO,UAAU,QAAQ,WAAW;IAC1C,IAAI,SAAS,QAAQ;KACnB,QAAQ,IAAI,IAAI,IAAI;KACpB,IAAI,KAAK,SAAS,YAAY,OAAO,SAAS,UAC5C,UAAU,IAAI,IAAI,YAAY,QAAQ,IAAI,OAAO,SAAS,UAAU,OAAO,OAAO,OAAO,UAAU,CAAC,CAAC;KAEvG,UAAU,EAAE;IACd;GACF;EACF;CACF;CAIA,SAAS,SAAS,QAA2D;EAC3E,IAAI,CAAC,UAAU,YAAY,OAAO;EAClC,MAAM,OAAO,OAAO,MAAM,IAAI,QAAQ;EACtC,MAAM,yBAAS,IAAI,IAAsB;EACzC,KAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,QAAQ,QAAQ,QAAQ,IAAI,OAAO,YAAY,CAAC;GACtD,IAAI,SAAS,MAAM,QAAQ,MAAM,OAAO,IAAI,OAAO,IAAI;IAAE,MAAM,MAAM;IAAM,IAAI,KAAK,IAAI,MAAM,IAAI,IAAI;GAAE,CAAC;EAC3G;EACA,OAAO;CACT;;;;;;CAOA,SAAS,gBAAgB,QAA4B,QAAoE;EACvH,IAAI,CAAC,UAAU,cAAc,UAAU,SAAS,GAAG,OAAO;EAC1D,MAAM,OAAO,OAAO,MAAM,IAAI,QAAQ;EACtC,IAAI;EACJ,KAAK,MAAM,UAAU,SAAS;GAC5B,IAAI,OAAO,WAAW,cAAc,OAAO,IAAI,OAAO,EAAE,GAAG;GAC3D,MAAM,WAAW,UAAU,IAAI,OAAO,YAAY;GAClD,IAAI,aAAa,KAAA,KAAa,YAAY,MAAM,CAAC,0BAAU,IAAI,IAAI,EAAA,CAAG,IAAI,OAAO,IAAI,QAAQ;EAC/F;EACA,OAAO,SAAS;CAClB;CAEA,SAAS,YAAkB;EACzB,MAAM,SAAS,QAAQ;EACvB,MAAM,WAAW,MAAM,IAAI;EAC3B,MAAM,OAAO,QAAQ;EACrB,MAAM,YAAY,SAAS;EAC3B,MAAM,aAAa,aAAa,SAAS,cAAc;EACvD,MAAM,QAAQ,QAAQ,KAAI,WAAU,OAAO,QAAQ,QAAQ,IAAI,OAAO,YAAY,CAAC,CAAC;EACpF,MAAM,aAAa,SAAS,MAAM;EAClC,MAAM,SAAS,WAAW,YAAY,SAAS,MAAM,IAAI,SAAS,SAAS;EAC3E,MAAM,eAAe,gBAAgB,QAAQ,MAAM;EACnD,MAAM,WAAW,aAAa,cAAc,SAAS,QAAQ,IAAI,SAAS,WAAW;EACrF,MAAM,SAAS,UAAU,YAAY,SAAS,OAAO,KAAK;EAC1D,MAAM,SAAS,QAAQ,UAAU;EACjC,MAAM,SAAS,QAAQ;EACvB,MAAM,QAAQ,UAAU,SAAS,aAAa,OAAO,OAAO,MAAM,IAAI;EACtE,MAAM,aAAa,UAAU,QAAQ,OAAO,MAAM,IAAI,YAAY,MAAM,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,GAAG,eAAe,KAAK,IAAI;EAE9H,MAAM,aADa,MAAM,WAAW,SAAS,QAAQ,UAAU,MAAM,OAAO,MAAM,UAAU,SAAS,MAAM,SAAS,QAAQ,MAAM,CAAC,IACpG,SAAS,UAAU;EAElD,IACE,cAAc,SAAS,aAAa,eAAe,SAAS,cAAc,SAAS,MAAM,SAAS,IAAI,KAAK,eAAe,SAAS,WAChI,WAAW,SAAS,UAAU,aAAa,SAAS,YAAY,WAAW,SAAS,UAAU,UAAU,OAAO,SAAS,KAAK,KAAK,eAAe,SAAS,YAC7J;EAEF,MAAM,OAAO,eAAe,SAAS,WAAW,WAAW,SAAS;EACpE,MAAM,IAAI;GACR;GACA;GACA;GACA,SAAS;GACT;GACA;GACA;GACA,OAAO,UAAU,OAAO,SAAS,KAAK,IAAI,SAAS,QAAQ;GAC3D;GACA,MAAM,OACF,SAAS,OACT,WACG,QAAO,WAAU,CAAC,OAAO,QAAQ,CAAC,CAClC,MAAM,GAAG,OAAO,OAAO,IAAI,EAAE,EAAE,CAAC,EAAE,QAAQ,aAAa,OAAO,IAAI,EAAE,EAAE,CAAC,EAAE,QAAQ,aAAa,EAAE,UAAU,cAAc,EAAE,SAAS,CAAC;GAC3I,UAAU,eAAe,SAAS,UAAU,SAAS,WAAW,WAAW,QAAO,WAAU,OAAO,QAAQ,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,UAAU,cAAc,EAAE,SAAS,CAAC;EACpK,CAAC;CACH;CAIA,IAAI;CAEJ,SAAS,cAAc,EAAE,aAAa,wBAA2G;EAC/I,MAAM,SAAS;EACf,IAAI,UAAU,QAAQ,MAAM;GAC1B,MAAM,MAAM,CAAC,aAAa,GAAI,wBAAwB,CAAC,CAAE;GACzD,IAAI,IAAI,MAAK,OAAM,GAAG,UAAU,GAAG;IACjC,IAAI,QAAQ,OAAO,MAAM,GAAG,GAAG,aAAa;SACvC,IAAI,YAAY,WAAW,MAAM;SACjC,MAAM,GAAG;GAChB;EACF;EACA,UAAU;CACZ;CAEA,SAAS,YAAkB;EACzB,IAAI,OAAO,KAAK,IAAI,KAAK;EACzB,OAAO;EACP,UAAU;CACZ;CAEA,SAAS,SAAe;EACtB,OAAO,IAAI,eAAe,aAAa;EACvC,OAAO,IAAI,UAAU,SAAS;EAC9B,OAAO,IAAI,WAAW,SAAS;EAC/B,QAAQ,KAAA;CACV;CAEA,SAAS,UAAgB;EACvB,MAAM,SAAS,QAAQ;EACvB,IAAI,WAAW,OAAO;GACpB,OAAO;GACP,QAAQ;GACR,QAAQ,GAAG,eAAe,aAAa;GAEvC,QAAQ,GAAG,UAAU,SAAS;GAC9B,QAAQ,GAAG,WAAW,SAAS;GAC/B,IAAI,UAAU,QAAQ,WAAW,MAAM;EACzC;EACA,IAAI,CAAC,QAAQ;GACX,SAAS;GACT,QAAQ,MAAM,KAAK;EACrB;EACA,UAAU;CACZ;CAEA,SAAS,UAAgB;EACvB,MAAM;CACR;CAEA,eAAe,OAAsB;EACnC,MAAM,aAAa,MAAM,QAAQ;EACjC,IAAI,CAAC,aAAa,UAAU,GAAG,MAAM,IAAI,MAAM,0CAA0C,SAAS,6BAA6B;EAC/H,UAAU,WAAW;EACrB,UAAU,IAAI,IAAI,WAAW,YAAY,KAAK,eAA2B,CAAC,WAAW,IAAI,WAAW,MAAM,CAAC,CAAC;EAC5G,UAAU,MAAM;EAChB,KAAK,MAAM,CAAC,IAAI,WAAW,SAAS,UAAU,IAAI,IAAI,KAAK,UAAU,MAAM,CAAC;EAC5E,MAAM,MAAM;EACZ,UAAU,MAAM;EAChB,QAAQ;EACR,MAAM,SAAS,QAAQ;EACvB,aAAa,QAAQ,OAAO;EAC5B,IAAI,QAAQ,WAAW,MAAM;EAC7B,UAAU;CACZ;CAEA,SAAS,SAAwB;EAC/B,MAAM;EACN,SAAS;EACT,QAAQ,MAAM,KAAK;EACnB,OAAO,KAAK;CACd;CAEA,eAAe,OAAsB;EACnC,MAAM;EACN,MAAM,OAAO;EACb,MAAM;EAEN,IAAI,UAAU,QAAQ,UAAU,KAAA,KAAa,MAAM,OAAO,GAAG,MAAM,KAAK;CAC1E;;CAKA,MAAM,SAAS,SAAiB,KAAK,KAAK,CAAC,CAAC,MAAM,GAAG,eAAe,IAAI;CAExE,SAAS,SAAgC;EACvC,MAAM,OAAO,QAAQ;EACrB,OAAO,QAAQ,SAAS,cAAc,IAAI,OAAO;CACnD;CAEA,MAAM,aAAa,MAAsB,UAA2B;EAAE,IAAI,MAAM,IAAI;EAAG;EAAM,UAAU,KAAK;EAAI,YAAY,KAAK;EAAM,aAAa,KAAK;EAAO,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;CAAE;CAEpM,SAAS,WAAW,MAAsC;EACxD,UAAU;EACV,UAAU;CACZ;CAEA,MAAM,cAAc,OAAe,QAAQ,MAAK,WAAU,OAAO,OAAO,EAAE;CAE1E,SAAS,cAAc,IAAY,QAAwD;EACzF,WAAW,QAAQ,KAAI,WAAW,OAAO,OAAO,KAAK,OAAO,MAAM,IAAI,MAAO,CAAC;CAChF;CAEA,SAAS,IAAI,MAA6B;EACxC,MAAM,SAAS,QAAQ;EACvB,MAAM,OAAO,OAAO;EACpB,MAAM,OAAO,MAAM,IAAI;EACvB,MAAM,QAAQ,UAAU,YAAY,SAAS,OAAO,KAAK,CAAC,EAAE;EAC5D,MAAM,QAAQ,UAAU,QAAQ,aAAa,OAAO,OAAO,KAAK,IAAI;EACpE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,SAAS,MAAM,QAAQ,MAAM,MAAM,CAAC,MAAM,OAAO;EACpF,MAAM,WAAW,MAAM,IAAI;EAC3B,MAAM,aAAyB;GAAE,IAAI,MAAM,IAAI;GAAG;GAAU,QAAQ,cAAc,QAAQ,KAAK;EAAE;EACjG,MAAM,UAAU,UAAU,MAAM,IAAI;EACpC,OAAO,KAAK,SAAS,OAAO,MAAM,GAAG,QAAQ,aAAa;GAAE,OAAO;GAAM,QAAQ;EAAS,CAAC,CAAC,CAAC,QAAQ,gBAAgB,KAAK,CAAC;EAC3H,cAAc,QAAQ,CAAC,KAAK,CAAC;EAC7B,QAAQ,IAAI,WAAW,IAAI,WAAW,MAAM;EAC5C,UAAU,IAAI,WAAW,IAAI,KAAK,UAAU,WAAW,MAAM,CAAC;EAC9D,UAAU,CAAC,GAAG,SAAS;GAAE,IAAI;GAAU,cAAc,WAAW;GAAI,QAAQ;GAAQ,UAAU,CAAC,OAAO;EAAE,CAAC;EACzG,UAAU;EACV,KAAK;GAAE,QAAQ;GAAU;GAAY,QAAQ;IAAE,IAAI;IAAU,cAAc,WAAW;IAAI,gBAAgB;GAAQ;EAAE,CAAC;EACrH,OAAO;CACT;CAEA,SAAS,MAAM,UAAkB,MAAoB;EACnD,MAAM,OAAO,OAAO;EACpB,MAAM,OAAO,MAAM,IAAI;EACvB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,QAAQ,GAAG;EAC7C,MAAM,UAAU,UAAU,MAAM,IAAI;EACpC,cAAc,WAAU,YAAW;GAAE,GAAG;GAAQ,UAAU,CAAC,GAAG,OAAO,UAAU,OAAO;EAAE,EAAE;EAC1F,KAAK;GAAE,QAAQ;GAAS;GAAU;EAAQ,CAAC;CAC7C;CAEA,SAAS,KAAK,UAAkB,SAAwB,MAAoB;EAC1E,MAAM,OAAO,OAAO;EACpB,MAAM,OAAO,MAAM,IAAI;EACvB,MAAM,SAAS,WAAW,QAAQ;EAClC,MAAM,SAAS,WAAW,YAAY,OAAO,OAAO,SAAS,KAAK,OAAO,SAAS,MAAK,YAAW,QAAQ,OAAO,OAAO;EACxH,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,UAAU,OAAO,aAAa,KAAK,MAAM,OAAO,SAAS,MAAM;EACjG,MAAM,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY;EACxC,cAAc,WAAU,UAAS;GAAE,GAAG;GAAM,UAAU,KAAK,SAAS,KAAI,YAAY,QAAQ,OAAO,OAAO,KAAK;IAAE,GAAG;IAAS;IAAM;GAAS,IAAI,OAAQ;EAAE,EAAE;EAC5J,KAAK;GAAE,QAAQ;GAAQ;GAAU,WAAW,OAAO;GAAI;GAAM;EAAS,CAAC;CACzE;CAEA,MAAM,qBAAqB;EACzB,MAAM,SAAS,QAAQ;EACvB,OAAO,SAAS,YAAY,SAAS,OAAO,KAAK,CAAC,EAAE,UAAU,OAAO;CACvE;CAEA,SAAS,YAAY,UAAkB,UAAyB;EAC9D,MAAM,SAAS,WAAW,QAAQ;EAClC,IAAI,CAAC,OAAO,KAAK,CAAC,UAAW,OAAO,WAAW,eAAgB,UAAU;EACzE,MAAM,SAAS,WAAW,aAAa;EACvC,cAAc,WAAU,UAAS;GAAE,GAAG;GAAM;EAAO,EAAE;EACrD,IAAI,YAAY,aAAa,MAAM,UAAU,SAAS,IAAI;EAC1D,KAAK;GAAE,QAAQ;GAAU;GAAU;EAAO,CAAC;CAC7C;CAEA,SAAS,OAAO,UAAwB;EACtC,MAAM,OAAO,OAAO;EACpB,MAAM,SAAS,WAAW,QAAQ;EAClC,IAAI,CAAC,QAAQ,CAAC,UAAU,OAAO,SAAS,EAAE,EAAE,aAAa,KAAK,IAAI;EAClE,IAAI,aAAa,MAAM,UAAU,SAAS,IAAI;EAC9C,QAAQ,OAAO,OAAO,YAAY;EAClC,UAAU,OAAO,OAAO,YAAY;EACpC,MAAM,OAAO,OAAO,YAAY;EAChC,UAAU,OAAO,OAAO,YAAY;EACpC,WAAW,QAAQ,QAAO,SAAQ,KAAK,OAAO,QAAQ,CAAC;EACvD,KAAK;GAAE,QAAQ;GAAU;EAAS,CAAC;CACrC;CAEA,SAAS,YAAY,UAAkB,SAAuB;EAC5D,MAAM,OAAO,OAAO;EACpB,MAAM,SAAS,WAAW,QAAQ;EAClC,MAAM,SAAS,QAAQ,SAAS,MAAM,CAAC,CAAC,CAAC,MAAK,YAAW,QAAQ,OAAO,OAAO;EAC/E,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,UAAU,OAAO,aAAa,KAAK,IAAI;EAChE,cAAc,WAAU,UAAS;GAAE,GAAG;GAAM,UAAU,KAAK,SAAS,QAAO,YAAW,QAAQ,OAAO,OAAO;EAAE,EAAE;EAChH,KAAK;GAAE,QAAQ;GAAkB;GAAU,WAAW;EAAQ,CAAC;CACjE;CAEA,SAAS,SAAS,IAAmB,kBAAwC,CAAC,GAAS;EACrF,MAAM,SAAS,QAAQ;EACvB,IAAI,QAAQ,iBAAiB,QAAQ,IAAI,eAAe;CAC1D;CAEA,SAAS,aAAmB;EAC1B,MAAM,SAAS,QAAQ;EACvB,IAAI,UAAU,OAAO,GAAG,kBAAkB,MAAM;CAClD;CAEA,SAAS,cAAoB;EAC3B,MAAM,SAAS,QAAQ;EACvB,IAAI,QAAQ,mBAAmB,MAAM;CACvC;CAEA,OAAO;EAAE,OAAO;EAAO;EAAS;EAAS;EAAK;EAAO;EAAM;EAAa;EAAQ;EAAa;EAAU;EAAY;EAAa;EAAQ;CAAK;AAC/I"}

package/dist/adapters/comments/server.d.ts

@@ -1,5 +1,6 @@
 import { Annotation, Comment, CommentAction, CommentStore, CommentThread, CreateThreadInput, Discussion, NewThread, ThreadStatus } from "./types.js";
 import { CommentStoreError } from "./errors.js";
+import { addComment, createThread, editComment, emptyDiscussion, removeComment, removeThread, setThreadStatus, updateAnchor } from "./record.js";
 //#region src/adapters/comments/server.d.ts
 export interface CommentsRequest {
   method: string;
@@ -19,5 +20,5 @@ export interface CommentsResponse {
  */
 export declare function handleCommentsRequest(store: CommentStore, request: CommentsRequest): Promise<CommentsResponse>;
 //#endregion
-export { type Annotation, type Comment, type CommentAction, type CommentStore, CommentStoreError, type CommentThread, type CreateThreadInput, type Discussion, type NewThread, type ThreadStatus };
+export { type Annotation, type Comment, type CommentAction, type CommentStore, CommentStoreError, type CommentThread, type CreateThreadInput, type Discussion, type NewThread, type ThreadStatus, addComment, createThread, editComment, emptyDiscussion, removeComment, removeThread, setThreadStatus, updateAnchor };
 //# sourceMappingURL=server.d.ts.map

package/dist/adapters/comments/server.js

@@ -1,5 +1,6 @@
 import { isPortableAnchor } from "../anchors.js";
 import { CommentStoreError, invalid } from "./errors.js";
+import { addComment, createThread, editComment, emptyDiscussion, removeComment, removeThread, setThreadStatus, updateAnchor } from "./record.js";
 //#region src/adapters/comments/server.ts
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isText = (value) => typeof value === "string";
@@ -97,6 +98,6 @@ async function handleCommentsRequest(store, request) {
 	}
 }
 //#endregion
-export { CommentStoreError, handleCommentsRequest };
+export { CommentStoreError, addComment, createThread, editComment, emptyDiscussion, handleCommentsRequest, removeComment, removeThread, setThreadStatus, updateAnchor };
 
 //# sourceMappingURL=server.js.map