@ecsplico/editor 2.1.1 → 3.0.0

package/dist/adapters/forge.js.map

@@ -1 +1 @@
-{"version":3,"file":"forge.js","names":[],"sources":["../../src/adapters/forge.ts"],"sourcesContent":["import { type AnyExtension, Editor } from '@tiptap/core'\nimport { DocumentMarkdown } from '../core'\nimport { contentToMarkdown, hasFatalDiagnostics, joinFrontmatter, type MarkdownDiagnostic, type MarkdownPolicy, markdownToContent, splitFrontmatter } from '../markdown'\nimport type { EditorAdapter } from '../server'\nimport type { AdapterHooks } from './shared'\n\n/** A Markdown file of the host, as the host stores it: the whole text with its frontmatter, and an opaque version of that file. */\nexport interface ForgeFile {\n  markdown: string\n  /** Changes whenever the file's content changes (mtime and size, a hash, a revision); no NUL character. Becomes `contentVersion`. */\n  version: string\n}\n\n/** Where the host keeps its Markdown documents. The adapter never touches a file system itself. */\nexport interface ForgeContent {\n  /** The file behind a document id, `null` = it does not exist. */\n  read(id: string): Promise<ForgeFile | null>\n  /** Writes the file (frontmatter included). Only called for documents that exist. */\n  write(id: string, markdown: string): Promise<void>\n  /** Called after every `write` the adapter made (change notifications, indexes). */\n  onWritten?(id: string): void | Promise<void>\n  /** Ids of all documents, for `listContents` (the tag index). Omitted: `listContents` is empty. */\n  list?(): Promise<string[]>\n}\n\n/** What the adapter delegates to a storage adapter that has no use for Markdown: Yjs state, assets, settings, themes (`createJsonAdapter` or `createDrizzleAdapter` fit). */\nexport type ForgeState = Pick<EditorAdapter, 'loadState' | 'storeState' | 'removeState' | 'storeAsset' | 'loadAsset'>\n  & Partial<Pick<EditorAdapter, 'loadSettings' | 'storeSettings' | 'listThemes' | 'loadTheme' | 'storeTheme' | 'removeTheme'>>\n\nexport interface ForgeAdapterOptions extends Omit<AdapterHooks, 'authenticate'> {\n  content: ForgeContent\n  state: ForgeState\n  /**\n   * The complete TipTap extension list of the Markdown conversion, e.g. `[...advancedSchemaExtensions(), MermaidBlock]`:\n   * nodes and marks with their Markdown handlers. Host nodes also go to the collaboration schema through `schemaExtensions`\n   * (which lists only the additions to `advancedSchemaExtensions()`).\n   */\n  schema: AnyExtension[]\n  /** The host's session check; there is no default for a host that owns its Markdown files. */\n  authenticate: EditorAdapter['authenticate']\n  /** Markdown policy of the conversion (raw HTML, data URLs); the default drops both. */\n  policy?: MarkdownPolicy\n  /** Called with the diagnostics of every load that produced some (dropped HTML or URLs, unknown fences kept verbatim). */\n  onDiagnostics?(id: string, diagnostics: MarkdownDiagnostic[]): void\n}\n\nconst OPTIONAL_STATE = ['loadSettings', 'storeSettings', 'listThemes', 'loadTheme', 'storeTheme', 'removeTheme'] as const\n\n/**\n * The editor's adapter over the host's Markdown files (concept documents, vault pages). The host keeps owning the\n * files, their locations, change notifications and access rules and passes them in as functions; this adapter does the\n * Markdown ↔ TipTap JSON conversion and the contract:\n *\n * - `loadContent` splits off the frontmatter and parses the body (`markdownToContent`); a body the conversion could not\n *   keep intact (unclosed fence, malformed fence metadata) is refused with an error instead of loaded lossy.\n * - `storeContent` re-reads the file, keeps its current frontmatter verbatim, writes the serialized body and calls\n *   `onWritten`. A file that is gone is not recreated, and an unchanged result is not rewritten.\n * - `contentVersion` is the file's own version, read after the write so it reflects what the editor stored.\n *\n * Yjs state, assets and settings are `state`'s. The converter is one headless editor per adapter, built on first use.\n */\nexport function createForgeAdapter(options: ForgeAdapterOptions): EditorAdapter {\n  const { content, state, schema, policy, onDiagnostics, authenticate, authorize, schemaExtensions, users } = options\n\n  let converter: Editor | undefined\n  // No `window` is needed as long as the editor starts from JSON content, not an HTML string.\n  const editor = () => converter ??= new Editor({ content: { type: 'doc', content: [{ type: 'paragraph' }] }, extensions: [DocumentMarkdown, ...schema] })\n\n  // Present only when `state` has them: the routes and the settings client test for the methods.\n  const optionalState = Object.fromEntries(OPTIONAL_STATE\n    .filter(method => state[method])\n    .map(method => [method, (...args: unknown[]) => (state[method] as (...args: unknown[]) => unknown).apply(state, args)])) as Partial<EditorAdapter>\n\n  function parse(id: string, file: ForgeFile) {\n    const { content: json, diagnostics } = markdownToContent(editor(), splitFrontmatter(file.markdown).body, policy ? { policy } : {})\n    if (diagnostics.length) onDiagnostics?.(id, diagnostics)\n    if (hasFatalDiagnostics(diagnostics)) {\n      const problems = diagnostics.filter(diagnostic => diagnostic.severity === 'error').map(diagnostic => diagnostic.message)\n      throw new Error(`@ecsplico/editor: document \"${id}\" cannot be converted without losing content: ${problems.join(' ')}`)\n    }\n    return json\n  }\n\n  return {\n    authenticate: request => authenticate(request),\n    listUsers: async () => (await users?.()) ?? [],\n    ...(authorize && { authorize: (user: object, id: string) => authorize(user, id) }),\n    ...(schemaExtensions && { schemaExtensions: () => schemaExtensions() }),\n\n    async loadContent(id) {\n      const file = await content.read(id)\n      return file && parse(id, file)\n    },\n    async storeContent(id, json) {\n      const current = await content.read(id)\n      if (!current) return // deleted while a store was pending\n      const instance = editor()\n      instance.commands.setContent(json, { emitUpdate: false })\n      const body = contentToMarkdown(instance)\n      const markdown = joinFrontmatter(splitFrontmatter(current.markdown).frontmatter, body && `${body}\\n`)\n      if (markdown === current.markdown) return\n      await content.write(id, markdown)\n      await content.onWritten?.(id)\n    },\n    async contentVersion(id) {\n      return (await content.read(id))?.version ?? null\n    },\n    async listContents() {\n      const entries = await Promise.all((await content.list?.() ?? []).map(async (id) => {\n        const file = await content.read(id)\n        return file && { id, content: parse(id, file) }\n      }))\n      return entries.filter((entry): entry is NonNullable<typeof entry> => entry !== null)\n    },\n\n    loadState: id => state.loadState(id),\n    storeState: (id, bytes) => state.storeState(id, bytes),\n    removeState: id => state.removeState(id),\n    storeAsset: (id, asset) => state.storeAsset(id, asset),\n    loadAsset: (id, name) => state.loadAsset(id, name),\n    ...optionalState,\n  }\n}\n"],"mappings":";;;;;;AA8CA,MAAM,iBAAiB;CAAC;CAAgB;CAAiB;CAAc;CAAa;CAAc;AAAa;;;;;;;;;;;;;;AAe/G,SAAgB,mBAAmB,SAA6C;CAC9E,MAAM,EAAE,SAAS,OAAO,QAAQ,QAAQ,eAAe,cAAc,WAAW,kBAAkB,UAAU;CAE5G,IAAI;CAEJ,MAAM,eAAe,cAAc,IAAI,OAAO;EAAE,SAAS;GAAE,MAAM;GAAO,SAAS,CAAC,EAAE,MAAM,YAAY,CAAC;EAAE;EAAG,YAAY,CAAC,kBAAkB,GAAG,MAAM;CAAE,CAAC;CAGvJ,MAAM,gBAAgB,OAAO,YAAY,eACtC,QAAO,WAAU,MAAM,OAAO,CAAC,CAC/B,KAAI,WAAU,CAAC,SAAS,GAAG,SAAqB,MAAM,OAAO,CAAqC,MAAM,OAAO,IAAI,CAAC,CAAC,CAAC;CAEzH,SAAS,MAAM,IAAY,MAAiB;EAC1C,MAAM,EAAE,SAAS,MAAM,gBAAgB,kBAAkB,OAAO,GAAG,iBAAiB,KAAK,QAAQ,CAAC,CAAC,MAAM,SAAS,EAAE,OAAO,IAAI,CAAC,CAAC;EACjI,IAAI,YAAY,QAAQ,gBAAgB,IAAI,WAAW;EACvD,IAAI,oBAAoB,WAAW,GAAG;GACpC,MAAM,WAAW,YAAY,QAAO,eAAc,WAAW,aAAa,OAAO,CAAC,CAAC,KAAI,eAAc,WAAW,OAAO;GACvH,MAAM,IAAI,MAAM,+BAA+B,GAAG,gDAAgD,SAAS,KAAK,GAAG,GAAG;EACxH;EACA,OAAO;CACT;CAEA,OAAO;EACL,eAAc,YAAW,aAAa,OAAO;EAC7C,WAAW,YAAa,MAAM,QAAQ,KAAM,CAAC;EAC7C,GAAI,aAAa,EAAE,YAAY,MAAc,OAAe,UAAU,MAAM,EAAE,EAAE;EAChF,GAAI,oBAAoB,EAAE,wBAAwB,iBAAiB,EAAE;EAErE,MAAM,YAAY,IAAI;GACpB,MAAM,OAAO,MAAM,QAAQ,KAAK,EAAE;GAClC,OAAO,QAAQ,MAAM,IAAI,IAAI;EAC/B;EACA,MAAM,aAAa,IAAI,MAAM;GAC3B,MAAM,UAAU,MAAM,QAAQ,KAAK,EAAE;GACrC,IAAI,CAAC,SAAS;GACd,MAAM,WAAW,OAAO;GACxB,SAAS,SAAS,WAAW,MAAM,EAAE,YAAY,MAAM,CAAC;GACxD,MAAM,OAAO,kBAAkB,QAAQ;GACvC,MAAM,WAAW,gBAAgB,iBAAiB,QAAQ,QAAQ,CAAC,CAAC,aAAa,QAAQ,GAAG,KAAK,GAAG;GACpG,IAAI,aAAa,QAAQ,UAAU;GACnC,MAAM,QAAQ,MAAM,IAAI,QAAQ;GAChC,MAAM,QAAQ,YAAY,EAAE;EAC9B;EACA,MAAM,eAAe,IAAI;GACvB,QAAQ,MAAM,QAAQ,KAAK,EAAE,EAAA,EAAI,WAAW;EAC9C;EACA,MAAM,eAAe;GAKnB,QAAO,MAJe,QAAQ,KAAK,MAAM,QAAQ,OAAO,KAAK,CAAC,EAAA,CAAG,IAAI,OAAO,OAAO;IACjF,MAAM,OAAO,MAAM,QAAQ,KAAK,EAAE;IAClC,OAAO,QAAQ;KAAE;KAAI,SAAS,MAAM,IAAI,IAAI;IAAE;GAChD,CAAC,CAAC,EAAA,CACa,QAAQ,UAA8C,UAAU,IAAI;EACrF;EAEA,YAAW,OAAM,MAAM,UAAU,EAAE;EACnC,aAAa,IAAI,UAAU,MAAM,WAAW,IAAI,KAAK;EACrD,cAAa,OAAM,MAAM,YAAY,EAAE;EACvC,aAAa,IAAI,UAAU,MAAM,WAAW,IAAI,KAAK;EACrD,YAAY,IAAI,SAAS,MAAM,UAAU,IAAI,IAAI;EACjD,GAAG;CACL;AACF"}
+{"version":3,"file":"forge.js","names":[],"sources":["../../src/adapters/forge.ts"],"sourcesContent":["import { type AnyExtension, Editor } from '@tiptap/core'\nimport { DocumentMarkdown } from '../core'\nimport { contentToMarkdown, hasFatalDiagnostics, joinFrontmatter, type MarkdownDiagnostic, type MarkdownPolicy, markdownToContent, splitFrontmatter } from '../markdown'\nimport type { CollabStateStore, AssetStore, EditorPorts, Identity, SettingsStore, ThemeStore } from '../server'\nimport { type AdapterHooks, directoryOf, identityOf } from './shared'\n\n/** A Markdown file of the host, as the host stores it: the whole text with its frontmatter, and an opaque version of that file. */\nexport interface ForgeFile {\n  markdown: string\n  /** Changes whenever the file's content changes (mtime and size, a hash, a revision); no NUL character. Becomes `contentVersion`. */\n  version: string\n}\n\n/** Where the host keeps its Markdown documents. The adapter never touches a file system itself. */\nexport interface ForgeContent {\n  /** The file behind a document id, `null` = it does not exist. */\n  read(id: string): Promise<ForgeFile | null>\n  /** Writes the file (frontmatter included). Only called for documents that exist. */\n  write(id: string, markdown: string): Promise<void>\n  /** Called after every `write` the adapter made (change notifications, indexes). */\n  onWritten?(id: string): void | Promise<void>\n  /** Ids of all documents, for `listContents` (the tag index). Omitted: `listContents` is empty. */\n  list?(): Promise<string[]>\n}\n\n/** What the adapter delegates to a storage adapter that has no use for Markdown: the `collabState`, `assets`, `settings` and `themes` ports (the result of `createJsonAdapter` or `createDrizzleAdapter` fits). */\nexport interface ForgeState {\n  collabState: CollabStateStore\n  assets: AssetStore\n  settings?: SettingsStore\n  themes?: ThemeStore\n}\n\nexport interface ForgeAdapterOptions extends Omit<AdapterHooks, 'authenticate'> {\n  content: ForgeContent\n  state: ForgeState\n  /**\n   * The complete TipTap extension list of the Markdown conversion, e.g. `[...advancedSchemaExtensions(), MermaidBlock]`:\n   * nodes and marks with their Markdown handlers. Host nodes also go to the collaboration schema through the server's\n   * `schema` option (`() => [...advancedSchemaExtensions(), MermaidBlock]`).\n   */\n  schema: AnyExtension[]\n  /** The host's session check; there is no default for a host that owns its Markdown files. */\n  authenticate: Identity['authenticate']\n  /** Markdown policy of the conversion (raw HTML, data URLs); the default drops both. */\n  policy?: MarkdownPolicy\n  /** Called with the diagnostics of every load that produced some (dropped HTML or URLs, unknown fences kept verbatim). */\n  onDiagnostics?(id: string, diagnostics: MarkdownDiagnostic[]): void\n}\n\n/**\n * The editor's adapter over the host's Markdown files (concept documents, vault pages). The host keeps owning the\n * files, their locations, change notifications and access rules and passes them in as functions; this adapter does the\n * Markdown ↔ TipTap JSON conversion and the contract:\n *\n * - `loadContent` splits off the frontmatter and parses the body (`markdownToContent`); a body the conversion could not\n *   keep intact (unclosed fence, malformed fence metadata) is refused with an error instead of loaded lossy.\n * - `storeContent` re-reads the file, keeps its current frontmatter verbatim, writes the serialized body and calls\n *   `onWritten`. A file that is gone is not recreated, and an unchanged result is not rewritten.\n * - `contentVersion` is the file's own version, read after the write so it reflects what the editor stored.\n *\n * Yjs state, assets and settings are `state`'s. The converter is one headless editor per adapter, built on first use.\n */\nexport function createForgeAdapter(options: ForgeAdapterOptions): EditorPorts {\n  const { content, state, schema, policy, onDiagnostics, authenticate, authorize } = options\n\n  let converter: Editor | undefined\n  // No `window` is needed as long as the editor starts from JSON content, not an HTML string.\n  const editor = () => converter ??= new Editor({ content: { type: 'doc', content: [{ type: 'paragraph' }] }, extensions: [DocumentMarkdown, ...schema] })\n\n  function parse(id: string, file: ForgeFile) {\n    const { content: json, diagnostics } = markdownToContent(editor(), splitFrontmatter(file.markdown).body, policy ? { policy } : {})\n    if (diagnostics.length) onDiagnostics?.(id, diagnostics)\n    if (hasFatalDiagnostics(diagnostics)) {\n      const problems = diagnostics.filter(diagnostic => diagnostic.severity === 'error').map(diagnostic => diagnostic.message)\n      throw new Error(`@ecsplico/editor: document \"${id}\" cannot be converted without losing content: ${problems.join(' ')}`)\n    }\n    return json\n  }\n\n  return {\n    identity: identityOf({ authenticate, authorize }),\n    directory: directoryOf(options),\n\n    documents: {\n      async loadContent(id) {\n        const file = await content.read(id)\n        return file && parse(id, file)\n      },\n      async storeContent(id, json) {\n        const current = await content.read(id)\n        if (!current) return // deleted while a store was pending\n        const instance = editor()\n        instance.commands.setContent(json, { emitUpdate: false })\n        const body = contentToMarkdown(instance)\n        const markdown = joinFrontmatter(splitFrontmatter(current.markdown).frontmatter, body && `${body}\\n`)\n        if (markdown === current.markdown) return\n        await content.write(id, markdown)\n        await content.onWritten?.(id)\n      },\n      async contentVersion(id) {\n        return (await content.read(id))?.version ?? null\n      },\n      async listContents() {\n        const entries = await Promise.all((await content.list?.() ?? []).map(async (id) => {\n          const file = await content.read(id)\n          return file && { id, content: parse(id, file) }\n        }))\n        return entries.filter((entry): entry is NonNullable<typeof entry> => entry !== null)\n      },\n    },\n\n    collabState: state.collabState,\n    assets: state.assets,\n    // Present only when `state` has them: the routes and the settings client test for the ports.\n    ...(state.settings && { settings: state.settings }),\n    ...(state.themes && { themes: state.themes }),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,mBAAmB,SAA2C;CAC5E,MAAM,EAAE,SAAS,OAAO,QAAQ,QAAQ,eAAe,cAAc,cAAc;CAEnF,IAAI;CAEJ,MAAM,eAAe,cAAc,IAAI,OAAO;EAAE,SAAS;GAAE,MAAM;GAAO,SAAS,CAAC,EAAE,MAAM,YAAY,CAAC;EAAE;EAAG,YAAY,CAAC,kBAAkB,GAAG,MAAM;CAAE,CAAC;CAEvJ,SAAS,MAAM,IAAY,MAAiB;EAC1C,MAAM,EAAE,SAAS,MAAM,gBAAgB,kBAAkB,OAAO,GAAG,iBAAiB,KAAK,QAAQ,CAAC,CAAC,MAAM,SAAS,EAAE,OAAO,IAAI,CAAC,CAAC;EACjI,IAAI,YAAY,QAAQ,gBAAgB,IAAI,WAAW;EACvD,IAAI,oBAAoB,WAAW,GAAG;GACpC,MAAM,WAAW,YAAY,QAAO,eAAc,WAAW,aAAa,OAAO,CAAC,CAAC,KAAI,eAAc,WAAW,OAAO;GACvH,MAAM,IAAI,MAAM,+BAA+B,GAAG,gDAAgD,SAAS,KAAK,GAAG,GAAG;EACxH;EACA,OAAO;CACT;CAEA,OAAO;EACL,UAAU,WAAW;GAAE;GAAc;EAAU,CAAC;EAChD,WAAW,YAAY,OAAO;EAE9B,WAAW;GACT,MAAM,YAAY,IAAI;IACpB,MAAM,OAAO,MAAM,QAAQ,KAAK,EAAE;IAClC,OAAO,QAAQ,MAAM,IAAI,IAAI;GAC/B;GACA,MAAM,aAAa,IAAI,MAAM;IAC3B,MAAM,UAAU,MAAM,QAAQ,KAAK,EAAE;IACrC,IAAI,CAAC,SAAS;IACd,MAAM,WAAW,OAAO;IACxB,SAAS,SAAS,WAAW,MAAM,EAAE,YAAY,MAAM,CAAC;IACxD,MAAM,OAAO,kBAAkB,QAAQ;IACvC,MAAM,WAAW,gBAAgB,iBAAiB,QAAQ,QAAQ,CAAC,CAAC,aAAa,QAAQ,GAAG,KAAK,GAAG;IACpG,IAAI,aAAa,QAAQ,UAAU;IACnC,MAAM,QAAQ,MAAM,IAAI,QAAQ;IAChC,MAAM,QAAQ,YAAY,EAAE;GAC9B;GACA,MAAM,eAAe,IAAI;IACvB,QAAQ,MAAM,QAAQ,KAAK,EAAE,EAAA,EAAI,WAAW;GAC9C;GACA,MAAM,eAAe;IAKnB,QAAO,MAJe,QAAQ,KAAK,MAAM,QAAQ,OAAO,KAAK,CAAC,EAAA,CAAG,IAAI,OAAO,OAAO;KACjF,MAAM,OAAO,MAAM,QAAQ,KAAK,EAAE;KAClC,OAAO,QAAQ;MAAE;MAAI,SAAS,MAAM,IAAI,IAAI;KAAE;IAChD,CAAC,CAAC,EAAA,CACa,QAAQ,UAA8C,UAAU,IAAI;GACrF;EACF;EAEA,aAAa,MAAM;EACnB,QAAQ,MAAM;EAEd,GAAI,MAAM,YAAY,EAAE,UAAU,MAAM,SAAS;EACjD,GAAI,MAAM,UAAU,EAAE,QAAQ,MAAM,OAAO;CAC7C;AACF"}

package/dist/adapters/http.d.ts

@@ -0,0 +1,20 @@
+import { EditorBackend } from "../core/backend.js";
+import { FetchBackendOptions } from "../core/http-backend.js";
+//#region src/adapters/http.d.ts
+export interface HttpBackendOptions extends FetchBackendOptions {
+  /**
+   * Ask the server which capabilities it serves (`GET /api/editor/capabilities`, see `serverCapabilities`) once and drop
+   * the others from the backend, so a composition pruned by `backend` (`composeEditor`) matches the server. The request
+   * settles `backend.ready`, which `createEditorContext` awaits. A failed probe keeps every capability and warns once.
+   * Default `false`: no request, every capability assumed (an unserved one answers 404/501 on use).
+   */
+  probe?: boolean;
+}
+/**
+ * Every backend capability over HTTP. `fetch` sends the requests (default: the platform `fetch`; a Nuxt app passes `useNuxtApp().$fetch`),
+ * `base` prefixes every path (`https://api.example.com`; default `''`, same origin). Failed requests reject with
+ * `BackendError` (`status`); a missing document loads as `null`.
+ */
+export declare function createHttpBackend(options?: HttpBackendOptions): EditorBackend;
+//#endregion
+//# sourceMappingURL=http.d.ts.map

package/dist/adapters/http.js

@@ -0,0 +1,68 @@
+import { CAPABILITIES_ROUTE, COLLAB_PATH, commentsUrl } from "../core/api-routes.js";
+import { createFetchBackend, createTransport } from "../core/http-backend.js";
+import { BACKEND_CAPABILITIES } from "../core/backend-capability.js";
+import { createRestCommentsModel } from "./comments/rest-model.js";
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import * as Y from "yjs";
+//#region src/adapters/http.ts
+/**
+* Every backend capability over HTTP. `fetch` sends the requests (default: the platform `fetch`; a Nuxt app passes `useNuxtApp().$fetch`),
+* `base` prefixes every path (`https://api.example.com`; default `''`, same origin). Failed requests reject with
+* `BackendError` (`status`); a missing document loads as `null`.
+*/
+function createHttpBackend(options = {}) {
+	const { base = "" } = options;
+	const transport = createTransport(options.fetch);
+	const data = createFetchBackend(options);
+	const collabUrl = `${(base || (typeof location === "undefined" ? "" : location.origin)).replace(/^http/, "ws")}${COLLAB_PATH}`;
+	const backend = {
+		...data,
+		collaboration: { connect(id, token) {
+			const ydoc = new Y.Doc();
+			const provider = new HocuspocusProvider({
+				url: `${collabUrl}/${encodeURIComponent(id)}`,
+				name: id,
+				document: ydoc,
+				...token !== void 0 && { token }
+			});
+			return {
+				ydoc,
+				provider,
+				dispose() {
+					provider.destroy();
+					ydoc.destroy();
+				}
+			};
+		} },
+		comments: (documentId, { user, canComment, getEditor, onError }) => createRestCommentsModel({
+			fetch: async (url, init) => {
+				const response = await transport.send(`${base}${url}`, init);
+				return {
+					ok: response.ok,
+					status: response.status,
+					json: () => response.json()
+				};
+			},
+			documentId,
+			endpoint: commentsUrl(documentId),
+			user,
+			canComment,
+			getEditor,
+			...onError && { onError }
+		}),
+		...options.probe && { ready: Promise.resolve().then(async () => {
+			try {
+				const served = await (await transport.request(`${base}${CAPABILITIES_ROUTE}`)).json();
+				if (!Array.isArray(served)) throw new TypeError("the answer is not a list of capabilities");
+				for (const capability of BACKEND_CAPABILITIES) if (!served.includes(capability)) delete backend[capability];
+			} catch (error) {
+				console.warn("@ecsplico/editor: the capability probe of the \"http\" backend failed; every capability is kept", error);
+			}
+		}) }
+	};
+	return backend;
+}
+//#endregion
+export { createHttpBackend };
+
+//# sourceMappingURL=http.js.map

package/dist/adapters/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","names":[],"sources":["../../src/adapters/http.ts"],"sourcesContent":["import { HocuspocusProvider } from '@hocuspocus/provider'\nimport * as Y from 'yjs'\nimport type { EditorBackend } from '../core/backend'\nimport { BACKEND_CAPABILITIES } from '../core/backend-capability'\nimport { createFetchBackend, createTransport, type FetchBackendOptions } from '../core/http-backend'\nimport { CAPABILITIES_ROUTE, COLLAB_PATH, commentsUrl } from '../core/api-routes'\nimport { createRestCommentsModel } from './comments/rest-model'\n\n// The HTTP adapter of `EditorBackend`: the `/api/editor` and `/api/ai` routes that the Nuxt module (`@ecsplico/editor/nuxt`)\n// and `installEditorServer` (`@ecsplico/editor/server/nitro`) serve, the collaboration websocket and the comments endpoint.\n\nexport interface HttpBackendOptions extends FetchBackendOptions {\n  /**\n   * Ask the server which capabilities it serves (`GET /api/editor/capabilities`, see `serverCapabilities`) once and drop\n   * the others from the backend, so a composition pruned by `backend` (`composeEditor`) matches the server. The request\n   * settles `backend.ready`, which `createEditorContext` awaits. A failed probe keeps every capability and warns once.\n   * Default `false`: no request, every capability assumed (an unserved one answers 404/501 on use).\n   */\n  probe?: boolean\n}\n\n/**\n * Every backend capability over HTTP. `fetch` sends the requests (default: the platform `fetch`; a Nuxt app passes `useNuxtApp().$fetch`),\n * `base` prefixes every path (`https://api.example.com`; default `''`, same origin). Failed requests reject with\n * `BackendError` (`status`); a missing document loads as `null`.\n */\nexport function createHttpBackend(options: HttpBackendOptions = {}): EditorBackend {\n  const { base = '' } = options\n  const transport = createTransport(options.fetch)\n  const data = createFetchBackend(options)\n  // The websocket lives next to the API: `http(s)://host` → `ws(s)://host`; without a base, the page's own origin.\n  const origin = base || (typeof location === 'undefined' ? '' : location.origin)\n  const collabUrl = `${origin.replace(/^http/, 'ws')}${COLLAB_PATH}`\n\n  const backend: EditorBackend = {\n    ...data,\n    collaboration: {\n      connect(id, token) {\n        const ydoc = new Y.Doc()\n        const provider = new HocuspocusProvider({ url: `${collabUrl}/${encodeURIComponent(id)}`, name: id, document: ydoc, ...(token !== undefined && { token }) })\n        return {\n          ydoc,\n          provider,\n          dispose() {\n            provider.destroy()\n            ydoc.destroy()\n          },\n        }\n      },\n    },\n    comments: (documentId, { user, canComment, getEditor, onError }) => createRestCommentsModel({\n      // The model reads `ok`, `status` and the parsed JSON body; a refusal is a result here, not an exception.\n      fetch: async (url, init) => {\n        const response = await transport.send(`${base}${url}`, init)\n        return { ok: response.ok, status: response.status, json: () => response.json() as Promise<unknown> }\n      },\n      documentId,\n      endpoint: commentsUrl(documentId),\n      user,\n      canComment,\n      getEditor,\n      ...(onError && { onError }),\n    }),\n    ...(options.probe && {\n      // Runs after the object is built (the microtask): it prunes `backend` itself, the one the context holds.\n      ready: Promise.resolve().then(async () => {\n        try {\n          const served: unknown = await (await transport.request(`${base}${CAPABILITIES_ROUTE}`)).json()\n          if (!Array.isArray(served)) throw new TypeError('the answer is not a list of capabilities')\n          for (const capability of BACKEND_CAPABILITIES) {\n            if (!served.includes(capability)) delete backend[capability]\n          }\n        }\n        catch (error) {\n          console.warn('@ecsplico/editor: the capability probe of the \"http\" backend failed; every capability is kept', error)\n        }\n      }),\n    }),\n  }\n  return backend\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAgB,kBAAkB,UAA8B,CAAC,GAAkB;CACjF,MAAM,EAAE,OAAO,OAAO;CACtB,MAAM,YAAY,gBAAgB,QAAQ,KAAK;CAC/C,MAAM,OAAO,mBAAmB,OAAO;CAGvC,MAAM,YAAY,IADH,SAAS,OAAO,aAAa,cAAc,KAAK,SAAS,QAAA,CAC5C,QAAQ,SAAS,IAAI,IAAI;CAErD,MAAM,UAAyB;EAC7B,GAAG;EACH,eAAe,EACb,QAAQ,IAAI,OAAO;GACjB,MAAM,OAAO,IAAI,EAAE,IAAI;GACvB,MAAM,WAAW,IAAI,mBAAmB;IAAE,KAAK,GAAG,UAAU,GAAG,mBAAmB,EAAE;IAAK,MAAM;IAAI,UAAU;IAAM,GAAI,UAAU,KAAA,KAAa,EAAE,MAAM;GAAG,CAAC;GAC1J,OAAO;IACL;IACA;IACA,UAAU;KACR,SAAS,QAAQ;KACjB,KAAK,QAAQ;IACf;GACF;EACF,EACF;EACA,WAAW,YAAY,EAAE,MAAM,YAAY,WAAW,cAAc,wBAAwB;GAE1F,OAAO,OAAO,KAAK,SAAS;IAC1B,MAAM,WAAW,MAAM,UAAU,KAAK,GAAG,OAAO,OAAO,IAAI;IAC3D,OAAO;KAAE,IAAI,SAAS;KAAI,QAAQ,SAAS;KAAQ,YAAY,SAAS,KAAK;IAAsB;GACrG;GACA;GACA,UAAU,YAAY,UAAU;GAChC;GACA;GACA;GACA,GAAI,WAAW,EAAE,QAAQ;EAC3B,CAAC;EACD,GAAI,QAAQ,SAAS,EAEnB,OAAO,QAAQ,QAAQ,CAAC,CAAC,KAAK,YAAY;GACxC,IAAI;IACF,MAAM,SAAkB,OAAO,MAAM,UAAU,QAAQ,GAAG,OAAO,oBAAoB,EAAA,CAAG,KAAK;IAC7F,IAAI,CAAC,MAAM,QAAQ,MAAM,GAAG,MAAM,IAAI,UAAU,0CAA0C;IAC1F,KAAK,MAAM,cAAc,sBACvB,IAAI,CAAC,OAAO,SAAS,UAAU,GAAG,OAAO,QAAQ;GAErD,SACO,OAAO;IACZ,QAAQ,KAAK,mGAAiG,KAAK;GACrH;EACF,CAAC,EACH;CACF;CACA,OAAO;AACT"}

package/dist/adapters/index.d.ts

@@ -1,13 +1,13 @@
 import { AnchorSource, AnchorTransaction, DocRange, OrphanedAnchor, PointAnchor, PortableAnchor, RangeAnchor } from "./anchors.js";
-import { CommentsFetch, CommentsFetchResponse, RestCommentsModel, RestCommentsModelOptions } from "./comments/client.js";
-import { AuthenticateRequest, EditorAdapter } from "../server/adapter.js";
+import { AuthenticateRequest } from "../server/auth.js";
+import { Annotation, Comment, CommentAction, CommentStore, CommentThread, CreateThreadInput, Discussion, NewThread, ThreadStatus } from "./comments/types.js";
+import { DocumentAdmin, EditorPorts } from "../server/ports.js";
 import "../server/index.js";
-import { AdapterHooks, DocumentAdmin, StoredEditorAdapter } from "./shared.js";
+import { AdapterHooks, StoredPorts } from "./shared.js";
 import { DrizzleAdapterOptions, EditorDb, EditorTables } from "./drizzle.js";
-import { Annotation, Comment, CommentAction, CommentStore, CommentThread, CreateThreadInput, Discussion, NewThread, ThreadStatus } from "./comments/types.js";
 import { CommentTables, DrizzleCommentStoreOptions } from "./comments/drizzle.js";
 import { JsonCommentStoreOptions } from "./comments/json.js";
 import { CommentsRequest, CommentsResponse } from "./comments/server.js";
 import { ForgeAdapterOptions, ForgeContent, ForgeFile, ForgeState } from "./forge.js";
 import { JsonAdapterOptions } from "./json.js";
-export type { AdapterHooks, AnchorSource, AnchorTransaction, Annotation, AuthenticateRequest, Comment, CommentAction, CommentStore, CommentTables, CommentThread, CommentsFetch, CommentsFetchResponse, CommentsRequest, CommentsResponse, CreateThreadInput, Discussion, DocRange, DocumentAdmin, DrizzleAdapterOptions, DrizzleCommentStoreOptions, EditorAdapter, EditorDb, EditorTables, ForgeAdapterOptions, ForgeContent, ForgeFile, ForgeState, JsonAdapterOptions, JsonCommentStoreOptions, NewThread, OrphanedAnchor, PointAnchor, PortableAnchor, RangeAnchor, RestCommentsModel, RestCommentsModelOptions, StoredEditorAdapter, ThreadStatus };
+export type { AdapterHooks, AnchorSource, AnchorTransaction, Annotation, AuthenticateRequest, Comment, CommentAction, CommentStore, CommentTables, CommentThread, CommentsRequest, CommentsResponse, CreateThreadInput, Discussion, DocRange, DocumentAdmin, DrizzleAdapterOptions, DrizzleCommentStoreOptions, EditorDb, EditorPorts, EditorTables, ForgeAdapterOptions, ForgeContent, ForgeFile, ForgeState, JsonAdapterOptions, JsonCommentStoreOptions, NewThread, OrphanedAnchor, PointAnchor, PortableAnchor, RangeAnchor, StoredPorts, ThreadStatus };

package/dist/adapters/json.d.ts

@@ -1,4 +1,4 @@
-import { AdapterHooks, StoredEditorAdapter } from "./shared.js";
+import { AdapterHooks, StoredPorts } from "./shared.js";
 //#region src/adapters/json.d.ts
 export interface JsonAdapterOptions extends AdapterHooks {
   /** Directory the adapter owns; created on demand. Single node only: the files are not coordinated across processes. */
@@ -17,8 +17,8 @@ export interface JsonAdapterOptions extends AdapterHooks {
  * A missing file reads as `null`; every write goes through a temp file and a rename. `contentVersion` is the content
  * file's modification time (nanoseconds) and size, read after every write the editor makes, so a document edited by
  * hand or by another tool invalidates the stored Yjs state. `storeContent` only updates existing documents: create
- * them with `putDocument`. The adapter has no theme library (the themes routes answer 501).
+ * them with `putDocument`. The adapter has no theme library (the themes routes are not mounted).
  */
-export declare function createJsonAdapter(options: JsonAdapterOptions): StoredEditorAdapter;
+export declare function createJsonAdapter(options: JsonAdapterOptions): StoredPorts;
 //#endregion
 //# sourceMappingURL=json.d.ts.map

package/dist/adapters/json.js

@@ -1,4 +1,4 @@
-import { bytesOf, identityPart, settingsKey } from "./shared.js";
+import { bytesOf, directoryOf, identityOf, settingsKey } from "./shared.js";
 import { isMissing, readOrNull, writeAtomic } from "./files.js";
 import { promises } from "node:fs";
 import path from "node:path";
@@ -47,7 +47,7 @@ function keyedLock() {
 * A missing file reads as `null`; every write goes through a temp file and a rename. `contentVersion` is the content
 * file's modification time (nanoseconds) and size, read after every write the editor makes, so a document edited by
 * hand or by another tool invalidates the stored Yjs state. `storeContent` only updates existing documents: create
-* them with `putDocument`. The adapter has no theme library (the themes routes answer 501).
+* them with `putDocument`. The adapter has no theme library (the themes routes are not mounted).
 */
 function createJsonAdapter(options) {
 	const root = path.resolve(options.dir);
@@ -70,56 +70,65 @@ function createJsonAdapter(options) {
 	}
 	const loadContent = async (id) => readJson(contentFile(id));
 	return {
-		...identityPart(options),
-		loadContent,
-		storeContent: (id, content) => locked(id, async () => {
-			if (!await promises.stat(contentFile(id)).then(() => true, () => false)) return;
-			await writeAtomic(contentFile(id), JSON.stringify(content));
-		}),
-		async contentVersion(id) {
-			try {
-				const { mtimeNs, size } = await promises.stat(contentFile(id), { bigint: true });
-				return `${mtimeNs}:${size}`;
-			} catch (error) {
-				if (isMissing(error)) return null;
-				throw error;
-			}
-		},
-		async listContents() {
-			return (await Promise.all((await listDocumentIds()).map(async (id) => ({
-				id,
-				content: await loadContent(id)
-			})))).filter((entry) => entry.content !== null);
-		},
-		async loadState(id) {
-			const data = await readOrNull(stateFile(id));
-			return data && bytesOf(data);
+		identity: identityOf(options),
+		directory: directoryOf(options),
+		documents: {
+			loadContent,
+			storeContent: (id, content) => locked(id, async () => {
+				if (!await promises.stat(contentFile(id)).then(() => true, () => false)) return;
+				await writeAtomic(contentFile(id), JSON.stringify(content));
+			}),
+			async contentVersion(id) {
+				try {
+					const { mtimeNs, size } = await promises.stat(contentFile(id), { bigint: true });
+					return `${mtimeNs}:${size}`;
+				} catch (error) {
+					if (isMissing(error)) return null;
+					throw error;
+				}
+			},
+			async listContents() {
+				return (await Promise.all((await listDocumentIds()).map(async (id) => ({
+					id,
+					content: await loadContent(id)
+				})))).filter((entry) => entry.content !== null);
+			},
+			putDocument: (id, content) => locked(id, () => writeAtomic(contentFile(id), JSON.stringify(content))),
+			deleteDocument: (id) => locked(id, async () => {
+				await promises.rm(contentFile(id), { force: true });
+				await promises.rm(stateFile(id), { force: true });
+				await promises.rm(assetDir(id), {
+					recursive: true,
+					force: true
+				});
+			}),
+			listDocumentIds
 		},
-		storeState: async (id, state) => writeAtomic(stateFile(id), state),
-		removeState: async (id) => promises.rm(stateFile(id), { force: true }),
-		async storeAsset(id, { data, ...record }) {
-			await writeAtomic(assetFile(id, record.name), data);
-			await writeAtomic(recordFile(id, record.name), JSON.stringify(record));
+		collabState: {
+			async loadState(id) {
+				const data = await readOrNull(stateFile(id));
+				return data && bytesOf(data);
+			},
+			storeState: async (id, state) => writeAtomic(stateFile(id), state),
+			removeState: async (id) => promises.rm(stateFile(id), { force: true })
 		},
-		async loadAsset(id, name) {
-			const [record, data] = await Promise.all([readJson(recordFile(id, name)), readOrNull(assetFile(id, name))]);
-			return record && data ? {
-				record,
-				data
-			} : null;
+		assets: {
+			async storeAsset(id, { data, ...record }) {
+				await writeAtomic(assetFile(id, record.name), data);
+				await writeAtomic(recordFile(id, record.name), JSON.stringify(record));
+			},
+			async loadAsset(id, name) {
+				const [record, data] = await Promise.all([readJson(recordFile(id, name)), readOrNull(assetFile(id, name))]);
+				return record && data ? {
+					record,
+					data
+				} : null;
+			}
 		},
-		loadSettings: async (user) => readJson(settingsFile(user)),
-		storeSettings: async (user, settings) => writeAtomic(settingsFile(user), JSON.stringify(settings)),
-		putDocument: (id, content) => locked(id, () => writeAtomic(contentFile(id), JSON.stringify(content))),
-		deleteDocument: (id) => locked(id, async () => {
-			await promises.rm(contentFile(id), { force: true });
-			await promises.rm(stateFile(id), { force: true });
-			await promises.rm(assetDir(id), {
-				recursive: true,
-				force: true
-			});
-		}),
-		listDocumentIds
+		settings: {
+			loadSettings: async (user) => readJson(settingsFile(user)),
+			storeSettings: async (user, settings) => writeAtomic(settingsFile(user), JSON.stringify(settings))
+		}
 	};
 }
 //#endregion

package/dist/adapters/json.js.map

@@ -1 +1 @@
-{"version":3,"file":"json.js","names":["fs"],"sources":["../../src/adapters/json.ts"],"sourcesContent":["import { type Dirent, promises as fs } from 'node:fs'\nimport path from 'node:path'\nimport type { JSONContent } from '@tiptap/core'\nimport type { AssetRecord } from '../features/media/schema'\nimport { isMissing, readOrNull, writeAtomic } from './files'\nimport { type AdapterHooks, bytesOf, identityPart, settingsKey, type StoredEditorAdapter } from './shared'\n\nexport interface JsonAdapterOptions extends AdapterHooks {\n  /** Directory the adapter owns; created on demand. Single node only: the files are not coordinated across processes. */\n  dir: string\n}\n\nconst CONTENT_EXT = '.json'\nconst STATE_EXT = '.ystate'\nconst SETTINGS_DIR = 'settings'\nconst ASSETS_DIR = 'assets'\nconst RECORDS_DIR = '.records'\n\n/**\n * A file name for `value`: percent-encoded (reversible, no separators, no `.`/`..`), and a leading dot escaped so no\n * key ever collides with the dot-named temp files and the `.records` directory.\n */\nfunction fileKey(value: string): string {\n  if (value === '') throw new TypeError('@ecsplico/editor: empty id')\n  const encoded = encodeURIComponent(value)\n  return encoded.startsWith('.') ? `%2E${encoded.slice(1)}` : encoded\n}\n\nasync function readJson<T>(file: string): Promise<T | null> {\n  const data = await readOrNull(file)\n  return data === null ? null : JSON.parse(data.toString('utf8')) as T\n}\n\n/** Runs the actions of one key one after another, so a delete cannot interleave with an update of the same document. */\nfunction keyedLock() {\n  const tails = new Map<string, Promise<unknown>>()\n  return <T>(key: string, action: () => Promise<T>): Promise<T> => {\n    const run = (tails.get(key) ?? Promise.resolve()).then(action, action)\n    const tail = run.catch(() => {})\n    tails.set(key, tail)\n    void tail.then(() => {\n      if (tails.get(key) === tail) tails.delete(key)\n    })\n    return run\n  }\n}\n\n/**\n * The editor's adapter on plain files under `dir`:\n *\n *     <dir>/<id>.json                         TipTap JSON of a document\n *     <dir>/<id>.ystate                       the collab server's state bytes\n *     <dir>/settings/<user>.json              per-user editor settings\n *     <dir>/assets/<id>/<name>                an uploaded file\n *     <dir>/assets/<id>/.records/<name>.json  its `AssetRecord`\n *\n * Ids, user keys and asset names are percent-encoded into file names (`a/b` → `a%2Fb.json`), so no input leaves `dir`.\n * A missing file reads as `null`; every write goes through a temp file and a rename. `contentVersion` is the content\n * file's modification time (nanoseconds) and size, read after every write the editor makes, so a document edited by\n * hand or by another tool invalidates the stored Yjs state. `storeContent` only updates existing documents: create\n * them with `putDocument`. The adapter has no theme library (the themes routes answer 501).\n */\nexport function createJsonAdapter(options: JsonAdapterOptions): StoredEditorAdapter {\n  const root = path.resolve(options.dir)\n  const contentFile = (id: string) => path.join(root, `${fileKey(id)}${CONTENT_EXT}`)\n  const stateFile = (id: string) => path.join(root, `${fileKey(id)}${STATE_EXT}`)\n  const settingsFile = (user: object) => path.join(root, SETTINGS_DIR, `${fileKey(settingsKey(user))}${CONTENT_EXT}`)\n  const assetDir = (id: string) => path.join(root, ASSETS_DIR, fileKey(id))\n  const assetFile = (id: string, name: string) => path.join(assetDir(id), fileKey(name))\n  const recordFile = (id: string, name: string) => path.join(assetDir(id), RECORDS_DIR, `${fileKey(name)}${CONTENT_EXT}`)\n  const locked = keyedLock()\n\n  async function listDocumentIds(): Promise<string[]> {\n    let entries: Dirent[]\n    try {\n      entries = await fs.readdir(root, { withFileTypes: true })\n    }\n    catch (error) {\n      if (isMissing(error)) return []\n      throw error\n    }\n    return entries\n      .filter(entry => entry.isFile() && !entry.name.startsWith('.') && entry.name.endsWith(CONTENT_EXT))\n      .map(entry => decodeURIComponent(entry.name.slice(0, -CONTENT_EXT.length)))\n      .sort()\n  }\n\n  const loadContent = async (id: string) => readJson<JSONContent>(contentFile(id))\n\n  return {\n    ...identityPart(options),\n\n    loadContent,\n    storeContent: (id, content) => locked(id, async () => {\n      // Deleted while a store was pending: writing would resurrect the document.\n      if (!await fs.stat(contentFile(id)).then(() => true, () => false)) return\n      await writeAtomic(contentFile(id), JSON.stringify(content))\n    }),\n    async contentVersion(id) {\n      try {\n        const { mtimeNs, size } = await fs.stat(contentFile(id), { bigint: true })\n        return `${mtimeNs}:${size}`\n      }\n      catch (error) {\n        if (isMissing(error)) return null\n        throw error\n      }\n    },\n    async listContents() {\n      const contents = await Promise.all((await listDocumentIds()).map(async id => ({ id, content: await loadContent(id) })))\n      return contents.filter((entry): entry is { id: string, content: JSONContent } => entry.content !== null)\n    },\n\n    async loadState(id) {\n      const data = await readOrNull(stateFile(id))\n      return data && bytesOf(data)\n    },\n    storeState: async (id, state) => writeAtomic(stateFile(id), state),\n    removeState: async id => fs.rm(stateFile(id), { force: true }),\n\n    async storeAsset(id, { data, ...record }) {\n      await writeAtomic(assetFile(id, record.name), data)\n      await writeAtomic(recordFile(id, record.name), JSON.stringify(record))\n    },\n    async loadAsset(id, name) {\n      const [record, data] = await Promise.all([readJson<AssetRecord>(recordFile(id, name)), readOrNull(assetFile(id, name))])\n      return record && data ? { record, data } : null\n    },\n\n    loadSettings: async user => readJson(settingsFile(user)),\n    storeSettings: async (user, settings) => writeAtomic(settingsFile(user), JSON.stringify(settings)),\n\n    putDocument: (id, content) => locked(id, () => writeAtomic(contentFile(id), JSON.stringify(content))),\n    deleteDocument: id => locked(id, async () => {\n      await fs.rm(contentFile(id), { force: true })\n      await fs.rm(stateFile(id), { force: true })\n      await fs.rm(assetDir(id), { recursive: true, force: true })\n    }),\n    listDocumentIds,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"json.js","names":["fs"],"sources":["../../src/adapters/json.ts"],"sourcesContent":["import { type Dirent, promises as fs } from 'node:fs'\nimport path from 'node:path'\nimport type { JSONContent } from '@tiptap/core'\nimport type { AssetRecord } from '../features/media/schema'\nimport { isMissing, readOrNull, writeAtomic } from './files'\nimport { type AdapterHooks, bytesOf, directoryOf, identityOf, settingsKey, type StoredPorts } from './shared'\n\nexport interface JsonAdapterOptions extends AdapterHooks {\n  /** Directory the adapter owns; created on demand. Single node only: the files are not coordinated across processes. */\n  dir: string\n}\n\nconst CONTENT_EXT = '.json'\nconst STATE_EXT = '.ystate'\nconst SETTINGS_DIR = 'settings'\nconst ASSETS_DIR = 'assets'\nconst RECORDS_DIR = '.records'\n\n/**\n * A file name for `value`: percent-encoded (reversible, no separators, no `.`/`..`), and a leading dot escaped so no\n * key ever collides with the dot-named temp files and the `.records` directory.\n */\nfunction fileKey(value: string): string {\n  if (value === '') throw new TypeError('@ecsplico/editor: empty id')\n  const encoded = encodeURIComponent(value)\n  return encoded.startsWith('.') ? `%2E${encoded.slice(1)}` : encoded\n}\n\nasync function readJson<T>(file: string): Promise<T | null> {\n  const data = await readOrNull(file)\n  return data === null ? null : JSON.parse(data.toString('utf8')) as T\n}\n\n/** Runs the actions of one key one after another, so a delete cannot interleave with an update of the same document. */\nfunction keyedLock() {\n  const tails = new Map<string, Promise<unknown>>()\n  return <T>(key: string, action: () => Promise<T>): Promise<T> => {\n    const run = (tails.get(key) ?? Promise.resolve()).then(action, action)\n    const tail = run.catch(() => {})\n    tails.set(key, tail)\n    void tail.then(() => {\n      if (tails.get(key) === tail) tails.delete(key)\n    })\n    return run\n  }\n}\n\n/**\n * The editor's adapter on plain files under `dir`:\n *\n *     <dir>/<id>.json                         TipTap JSON of a document\n *     <dir>/<id>.ystate                       the collab server's state bytes\n *     <dir>/settings/<user>.json              per-user editor settings\n *     <dir>/assets/<id>/<name>                an uploaded file\n *     <dir>/assets/<id>/.records/<name>.json  its `AssetRecord`\n *\n * Ids, user keys and asset names are percent-encoded into file names (`a/b` → `a%2Fb.json`), so no input leaves `dir`.\n * A missing file reads as `null`; every write goes through a temp file and a rename. `contentVersion` is the content\n * file's modification time (nanoseconds) and size, read after every write the editor makes, so a document edited by\n * hand or by another tool invalidates the stored Yjs state. `storeContent` only updates existing documents: create\n * them with `putDocument`. The adapter has no theme library (the themes routes are not mounted).\n */\nexport function createJsonAdapter(options: JsonAdapterOptions): StoredPorts {\n  const root = path.resolve(options.dir)\n  const contentFile = (id: string) => path.join(root, `${fileKey(id)}${CONTENT_EXT}`)\n  const stateFile = (id: string) => path.join(root, `${fileKey(id)}${STATE_EXT}`)\n  const settingsFile = (user: object) => path.join(root, SETTINGS_DIR, `${fileKey(settingsKey(user))}${CONTENT_EXT}`)\n  const assetDir = (id: string) => path.join(root, ASSETS_DIR, fileKey(id))\n  const assetFile = (id: string, name: string) => path.join(assetDir(id), fileKey(name))\n  const recordFile = (id: string, name: string) => path.join(assetDir(id), RECORDS_DIR, `${fileKey(name)}${CONTENT_EXT}`)\n  const locked = keyedLock()\n\n  async function listDocumentIds(): Promise<string[]> {\n    let entries: Dirent[]\n    try {\n      entries = await fs.readdir(root, { withFileTypes: true })\n    }\n    catch (error) {\n      if (isMissing(error)) return []\n      throw error\n    }\n    return entries\n      .filter(entry => entry.isFile() && !entry.name.startsWith('.') && entry.name.endsWith(CONTENT_EXT))\n      .map(entry => decodeURIComponent(entry.name.slice(0, -CONTENT_EXT.length)))\n      .sort()\n  }\n\n  const loadContent = async (id: string) => readJson<JSONContent>(contentFile(id))\n\n  return {\n    identity: identityOf(options),\n    directory: directoryOf(options),\n\n    documents: {\n      loadContent,\n      storeContent: (id, content) => locked(id, async () => {\n        // Deleted while a store was pending: writing would resurrect the document.\n        if (!await fs.stat(contentFile(id)).then(() => true, () => false)) return\n        await writeAtomic(contentFile(id), JSON.stringify(content))\n      }),\n      async contentVersion(id) {\n        try {\n          const { mtimeNs, size } = await fs.stat(contentFile(id), { bigint: true })\n          return `${mtimeNs}:${size}`\n        }\n        catch (error) {\n          if (isMissing(error)) return null\n          throw error\n        }\n      },\n      async listContents() {\n        const contents = await Promise.all((await listDocumentIds()).map(async id => ({ id, content: await loadContent(id) })))\n        return contents.filter((entry): entry is { id: string, content: JSONContent } => entry.content !== null)\n      },\n\n      putDocument: (id, content) => locked(id, () => writeAtomic(contentFile(id), JSON.stringify(content))),\n      deleteDocument: id => locked(id, async () => {\n        await fs.rm(contentFile(id), { force: true })\n        await fs.rm(stateFile(id), { force: true })\n        await fs.rm(assetDir(id), { recursive: true, force: true })\n      }),\n      listDocumentIds,\n    },\n\n    collabState: {\n      async loadState(id) {\n        const data = await readOrNull(stateFile(id))\n        return data && bytesOf(data)\n      },\n      storeState: async (id, state) => writeAtomic(stateFile(id), state),\n      removeState: async id => fs.rm(stateFile(id), { force: true }),\n    },\n\n    assets: {\n      async storeAsset(id, { data, ...record }) {\n        await writeAtomic(assetFile(id, record.name), data)\n        await writeAtomic(recordFile(id, record.name), JSON.stringify(record))\n      },\n      async loadAsset(id, name) {\n        const [record, data] = await Promise.all([readJson<AssetRecord>(recordFile(id, name)), readOrNull(assetFile(id, name))])\n        return record && data ? { record, data } : null\n      },\n    },\n\n    settings: {\n      loadSettings: async user => readJson(settingsFile(user)),\n      storeSettings: async (user, settings) => writeAtomic(settingsFile(user), JSON.stringify(settings)),\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/adapters/memory.d.ts

@@ -0,0 +1,21 @@
+import { EditorBackend } from "../core/backend.js";
+import { MentionUser } from "../core/backend-types.js";
+import { JSONContent } from "@tiptap/core";
+//#region src/adapters/memory.d.ts
+export interface MemoryBackendSeed {
+  /** Documents by id, as `documents.load` returns them. */
+  documents?: Record<string, JSONContent>;
+  /** The people `@` offers. */
+  users?: readonly MentionUser[];
+  /** The tags `#` offers (normalized like the server's). */
+  tags?: readonly string[];
+}
+/**
+ * An `EditorBackend` that keeps everything in memory: `documents` (a Map seeded from `seed.documents`; `load` answers a
+ * copy, `null` for an unknown id), `assets` (`upload` answers a `blob:` URL of the file, valid for the page's life),
+ * `users` and `tags` (case-insensitive lookups over the seed, prefix matches first) and `settings` (`load` answers
+ * `null` until something was saved).
+ */
+export declare function createMemoryBackend(seed?: MemoryBackendSeed): EditorBackend;
+//#endregion
+//# sourceMappingURL=memory.d.ts.map

package/dist/adapters/memory.js

@@ -0,0 +1,53 @@
+import { normalizeTagName } from "../core/tag-name.js";
+//#region src/adapters/memory.ts
+/** The most suggestions one lookup returns, as the HTTP routes. */
+const MAX_SUGGESTIONS = 20;
+/** Prefix matches first, then the other substring matches; the order within each group is kept. */
+function prefixFirst(items, needle, text) {
+	const matches = items.filter((item) => text(item).includes(needle));
+	const prefixed = matches.filter((item) => text(item).startsWith(needle));
+	return [...prefixed, ...matches.filter((item) => !prefixed.includes(item))].slice(0, MAX_SUGGESTIONS);
+}
+/**
+* An `EditorBackend` that keeps everything in memory: `documents` (a Map seeded from `seed.documents`; `load` answers a
+* copy, `null` for an unknown id), `assets` (`upload` answers a `blob:` URL of the file, valid for the page's life),
+* `users` and `tags` (case-insensitive lookups over the seed, prefix matches first) and `settings` (`load` answers
+* `null` until something was saved).
+*/
+function createMemoryBackend(seed = {}) {
+	const documents = new Map(Object.entries(seed.documents ?? {}).map(([id, content]) => [id, structuredClone(content)]));
+	const users = [...seed.users ?? []].sort((a, b) => a.username.localeCompare(b.username, "de"));
+	const tags = (seed.tags ?? []).map(normalizeTagName).filter(Boolean);
+	let settings = null;
+	return {
+		name: "memory",
+		documents: {
+			load: (id) => Promise.resolve(documents.has(id) ? structuredClone(documents.get(id)) : null),
+			save: (id, content) => {
+				documents.set(id, structuredClone(content));
+				return Promise.resolve();
+			}
+		},
+		assets: { upload: (_documentId, file) => Promise.resolve({ url: URL.createObjectURL(file) }) },
+		users: { search: (query) => {
+			const needle = query.trim().toLowerCase();
+			return Promise.resolve(prefixFirst(users, needle, (user) => user.username.toLowerCase()).map(({ id, username, color }) => ({
+				id,
+				username,
+				color
+			})));
+		} },
+		tags: { search: (query) => Promise.resolve(prefixFirst(tags, normalizeTagName(query), (tag) => tag)) },
+		settings: {
+			load: () => Promise.resolve(settings === null ? null : structuredClone(settings)),
+			save: (value) => {
+				settings = structuredClone(value);
+				return Promise.resolve();
+			}
+		}
+	};
+}
+//#endregion
+export { createMemoryBackend };
+
+//# sourceMappingURL=memory.js.map

package/dist/adapters/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","names":[],"sources":["../../src/adapters/memory.ts"],"sourcesContent":["import type { JSONContent } from '@tiptap/core'\nimport type { EditorBackend } from '../core/backend'\nimport type { MentionUser } from '../core/backend-types'\nimport { normalizeTagName } from '../core/tag-name'\nimport type { EditorSettings } from '../settings'\n\n// The in-memory adapter of `EditorBackend` for hosts without a data layer: documents, assets (blob URLs), seeded\n// mention users and tags, and settings that live as long as the page. No AI, themes, collaboration or comments: a\n// feature that needs one of them fails when its surface mounts (see `EditorFeature.backend`).\n\nexport interface MemoryBackendSeed {\n  /** Documents by id, as `documents.load` returns them. */\n  documents?: Record<string, JSONContent>\n  /** The people `@` offers. */\n  users?: readonly MentionUser[]\n  /** The tags `#` offers (normalized like the server's). */\n  tags?: readonly string[]\n}\n\n/** The most suggestions one lookup returns, as the HTTP routes. */\nconst MAX_SUGGESTIONS = 20\n\n/** Prefix matches first, then the other substring matches; the order within each group is kept. */\nfunction prefixFirst<T>(items: readonly T[], needle: string, text: (item: T) => string): T[] {\n  const matches = items.filter(item => text(item).includes(needle))\n  const prefixed = matches.filter(item => text(item).startsWith(needle))\n  return [...prefixed, ...matches.filter(item => !prefixed.includes(item))].slice(0, MAX_SUGGESTIONS)\n}\n\n/**\n * An `EditorBackend` that keeps everything in memory: `documents` (a Map seeded from `seed.documents`; `load` answers a\n * copy, `null` for an unknown id), `assets` (`upload` answers a `blob:` URL of the file, valid for the page's life),\n * `users` and `tags` (case-insensitive lookups over the seed, prefix matches first) and `settings` (`load` answers\n * `null` until something was saved).\n */\nexport function createMemoryBackend(seed: MemoryBackendSeed = {}): EditorBackend {\n  const documents = new Map(Object.entries(seed.documents ?? {}).map(([id, content]) => [id, structuredClone(content)]))\n  const users = [...(seed.users ?? [])].sort((a, b) => a.username.localeCompare(b.username, 'de'))\n  const tags = (seed.tags ?? []).map(normalizeTagName).filter(Boolean)\n  let settings: EditorSettings | null = null\n\n  return {\n    name: 'memory',\n    documents: {\n      load: id => Promise.resolve(documents.has(id) ? structuredClone(documents.get(id)!) : null),\n      save: (id, content) => {\n        documents.set(id, structuredClone(content))\n        return Promise.resolve()\n      },\n    },\n    assets: {\n      upload: (_documentId, file) => Promise.resolve({ url: URL.createObjectURL(file) }),\n    },\n    users: {\n      search: (query) => {\n        const needle = query.trim().toLowerCase()\n        return Promise.resolve(prefixFirst(users, needle, user => user.username.toLowerCase()).map(({ id, username, color }) => ({ id, username, color })))\n      },\n    },\n    tags: {\n      search: (query) => Promise.resolve(prefixFirst(tags, normalizeTagName(query), tag => tag)),\n    },\n    settings: {\n      load: () => Promise.resolve(settings === null ? null : structuredClone(settings)),\n      save: (value) => {\n        settings = structuredClone(value)\n        return Promise.resolve()\n      },\n    },\n  }\n}\n"],"mappings":";;;AAoBA,MAAM,kBAAkB;;AAGxB,SAAS,YAAe,OAAqB,QAAgB,MAAgC;CAC3F,MAAM,UAAU,MAAM,QAAO,SAAQ,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC;CAChE,MAAM,WAAW,QAAQ,QAAO,SAAQ,KAAK,IAAI,CAAC,CAAC,WAAW,MAAM,CAAC;CACrE,OAAO,CAAC,GAAG,UAAU,GAAG,QAAQ,QAAO,SAAQ,CAAC,SAAS,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,eAAe;AACpG;;;;;;;AAQA,SAAgB,oBAAoB,OAA0B,CAAC,GAAkB;CAC/E,MAAM,YAAY,IAAI,IAAI,OAAO,QAAQ,KAAK,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,aAAa,CAAC,IAAI,gBAAgB,OAAO,CAAC,CAAC,CAAC;CACrH,MAAM,QAAQ,CAAC,GAAI,KAAK,SAAS,CAAC,CAAE,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,SAAS,cAAc,EAAE,UAAU,IAAI,CAAC;CAC/F,MAAM,QAAQ,KAAK,QAAQ,CAAC,EAAA,CAAG,IAAI,gBAAgB,CAAC,CAAC,OAAO,OAAO;CACnE,IAAI,WAAkC;CAEtC,OAAO;EACL,MAAM;EACN,WAAW;GACT,OAAM,OAAM,QAAQ,QAAQ,UAAU,IAAI,EAAE,IAAI,gBAAgB,UAAU,IAAI,EAAE,CAAE,IAAI,IAAI;GAC1F,OAAO,IAAI,YAAY;IACrB,UAAU,IAAI,IAAI,gBAAgB,OAAO,CAAC;IAC1C,OAAO,QAAQ,QAAQ;GACzB;EACF;EACA,QAAQ,EACN,SAAS,aAAa,SAAS,QAAQ,QAAQ,EAAE,KAAK,IAAI,gBAAgB,IAAI,EAAE,CAAC,EACnF;EACA,OAAO,EACL,SAAS,UAAU;GACjB,MAAM,SAAS,MAAM,KAAK,CAAC,CAAC,YAAY;GACxC,OAAO,QAAQ,QAAQ,YAAY,OAAO,SAAQ,SAAQ,KAAK,SAAS,YAAY,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,UAAU,aAAa;IAAE;IAAI;IAAU;GAAM,EAAE,CAAC;EACpJ,EACF;EACA,MAAM,EACJ,SAAS,UAAU,QAAQ,QAAQ,YAAY,MAAM,iBAAiB,KAAK,IAAG,QAAO,GAAG,CAAC,EAC3F;EACA,UAAU;GACR,YAAY,QAAQ,QAAQ,aAAa,OAAO,OAAO,gBAAgB,QAAQ,CAAC;GAChF,OAAO,UAAU;IACf,WAAW,gBAAgB,KAAK;IAChC,OAAO,QAAQ,QAAQ;GACzB;EACF;CACF;AACF"}

package/dist/adapters/nitro.d.ts

@@ -1,10 +1,9 @@
-import { EditorAdapter } from "../server/adapter.js";
 import { AiModels, AiModelsConfig } from "../server/ai.js";
+import { EditorPorts } from "../server/ports.js";
 import { CollabServer, CollabServerOptions } from "../server/collab.js";
 import { RateLimiterOptions } from "../server/rate-limit.js";
 import "../server/index.js";
-import { DocumentAdmin } from "./shared.js";
-import { CommentStore } from "./comments/types.js";
+import { AnyExtension } from "@tiptap/core";
 import { Router } from "h3";
 //#region src/adapters/nitro.d.ts
 /** The part of a Nitro app this entry uses; `nitroApp` of a Nitro plugin fits. */
@@ -15,28 +14,31 @@ export interface NitroHost {
   };
 }
 export interface EditorServerOptions {
-  /** Storage and identity. An adapter that also manages documents (`json`, `drizzle`) lets `PUT /api/editor/documents/:id` create them. */
-  adapter: EditorAdapter & Partial<DocumentAdmin>;
+  /** Identity, storage and everything else the backend serves, one port per capability: a route is mounted only when its port is present. A documents port that also manages documents (`json`, `drizzle`) lets `PUT /api/editor/documents/:id` create them; the `comments` port mounts the comments endpoint, `models` the host's language models. */
+  ports: EditorPorts;
   /**
-   * The collaboration websocket (`/collab/:id`). Extensions, hooks and Hocuspocus configuration of `createCollabServer`;
-   * `{}` takes everything from the adapter. `false` mounts no websocket (documents then only load and save over HTTP).
+   * The collaboration websocket (`/collab/:id`). Schema, hooks and Hocuspocus configuration of `createCollabServer`;
+   * `{}` takes everything from the ports (the `collabState` port is required). `false` mounts no websocket (documents then only load and save over HTTP).
+   * `authenticateUpgrade`: authenticate the upgrade request itself (`Identity.authenticate` with its headers; cookies,
+   * not the provider's `token`) and refuse it with HTTP 401, instead of closing an unauthenticated socket with 4401
+   * after the upgrade; the user then travels with the connection and is not authenticated a second time.
    * Needs `experimental: { websocket: true }` in the Nitro config.
    */
-  collab: Omit<CollabServerOptions, 'adapter'> | false;
+  collab: (Omit<CollabServerOptions, 'ports'> & {
+    authenticateUpgrade?: boolean;
+  }) | false;
   /**
    * Mounts the AI endpoints (`/api/ai/*`): presets, shared key, transcription, slots of `createAiModels`; `languageModel`
-   * and `listModels` default to the adapter's. Omitted: no AI routes.
+   * and `listModels` default to those of the `models` port. Omitted: no AI routes.
    */
   ai?: Partial<AiModelsConfig>;
-  /** Per-user limit of the AI endpoints; default 30 requests per minute. */
+  /** Per-user limit of the AI endpoints; default: that of `defineEditorConfig` (30 requests per minute). */
   rateLimit?: RateLimiterOptions;
-  /** Mounts the comments endpoint (`/api/editor/comments/:id`) over this store; omitted: no comments routes. */
-  comments?: {
-    store: CommentStore;
-  };
+  /** The collaboration schema (see `CollabServerOptions.schema`); default `advancedSchemaExtensions()`, host nodes: `() => [...advancedSchemaExtensions(), Callout]`. */
+  schema?: () => AnyExtension[];
 }
 export interface EditorServer {
-  adapter: EditorServerOptions['adapter'];
+  ports: EditorPorts;
   /** The collaboration server, `undefined` with `collab: false`. */
   collab: CollabServer | undefined;
   /** The AI models, `undefined` without `ai`. */
@@ -47,14 +49,15 @@ export interface EditorServer {
 /**
  * Wires the editor backend into `nitroApp` (call it from a Nitro plugin):
  *
- *     /api/editor/{settings,users,tags,assets/…,themes/…}   the editor's own endpoints
+ *     /api/editor/{capabilities,settings,users,tags,assets/…,themes/…}   the editor's own endpoints, each with its port; `capabilities` lists what is served
  *     /api/editor/documents/:id                              GET/PUT a document's TipTap JSON (what `useEditorDocument` uses)
- *     /api/editor/comments/:id                               GET/POST comments, with `comments`
- *     /api/ai/{models,chat,complete,generate,transcribe,transcript-cleanup}   with `ai`
+ *     /api/editor/comments/:id                               GET/POST comments, with `ports.comments`
+ *     /api/ai/{models,chat,complete,generate,extract,transcript-cleanup}   with `ai`
  *     /collab/:id                                            the collaboration websocket, unless `collab: false`
  *
- * Every route authenticates through `adapter.authenticate`. The collaboration server is closed with Nitro's `close`
- * hook. The paths are the ones `@ecsplico/editor/nuxt` serves, so the editor's client works unchanged.
+ * Every route authenticates through `ports.identity.authenticate`. The collaboration server is closed with Nitro's `close`
+ * hook. The installed server is also the process-wide one of `@ecsplico/editor/server` (`useCollabServer`, `useAiModels`,
+ * `liveContent`, …) until it closes. The paths are the ones the editor's client (`createHttpBackend`) calls.
  */
 export declare function installEditorServer(nitroApp: NitroHost, options: EditorServerOptions): EditorServer;
 //#endregion