@ecsplico/editor 2.1.1 → 3.0.0

package/dist/nuxt/module.js

@@ -1,9 +1,10 @@
+import { defineEditorConfig, publicConfig, serverConfig } from "../config/index.js";
 import { addPlugin, addServerScanDir, createResolver, defineNuxtModule } from "nuxt/kit";
 //#region src/nuxt/module.ts
 /**
 * Nuxt/Nitro integration of the editor package: the client context plugin (settings persistence, AI configuration),
-* the Nitro API routes, the collaboration websocket and the AI configuration with its server-only secrets. The host
-* plugs in through `setEditorAdapter()` (`@ecsplico/editor/server`) in a Nitro plugin (auth, loading and storing
+* a server plugin that mounts the editor's routes and the collaboration websocket (`installEditorServer`) and the AI configuration with its server-only secrets. The host
+* plugs in through `setEditorPorts()` (`@ecsplico/editor/server`) in a Nitro plugin (auth, loading and storing
 * document content). Components are imported explicitly from the package entries; nothing is auto-registered.
 */
 var module_default = defineNuxtModule({
@@ -11,33 +12,6 @@ var module_default = defineNuxtModule({
 		name: "tiptap-editor",
 		configKey: "tiptapEditor"
 	},
-	defaults: {
-		locale: "de",
-		collab: { authenticateUpgrade: false },
-		ai: {
-			presets: {
-				sonnet: {
-					label: "Claude Sonnet 4.5 (OpenRouter)",
-					endpoint: "https://openrouter.ai/api/v1",
-					model: "anthropic/claude-sonnet-4.5"
-				},
-				flashLite: {
-					label: "Gemini 2.5 Flash Lite (OpenRouter)",
-					endpoint: "https://openrouter.ai/api/v1",
-					model: "google/gemini-2.5-flash-lite"
-				}
-			},
-			slots: {
-				complete: "flashLite",
-				rewrite: "sonnet",
-				generate: "sonnet"
-			},
-			rateLimit: {
-				max: 30,
-				windowMs: 6e4
-			}
-		}
-	},
 	setup(options, nuxt) {
 		const { resolve } = createResolver(import.meta.url);
 		const packageSrc = resolve("..");
@@ -67,30 +41,13 @@ var module_default = defineNuxtModule({
 				packageSrc
 			]
 		};
+		const config = defineEditorConfig(options);
 		nuxt.options.runtimeConfig.tiptapEditor = {
-			collab: { authenticateUpgrade: options.collab.authenticateUpgrade },
-			ai: {
-				apiKey: "",
-				presets: Object.fromEntries(Object.entries(options.ai.presets).map(([id, preset]) => [id, {
-					...preset,
-					apiKey: preset.apiKey ?? ""
-				}])),
-				slots: options.ai.slots,
-				rateLimit: options.ai.rateLimit,
-				...options.ai.transcription && { transcription: {
-					...options.ai.transcription,
-					apiKey: options.ai.transcription.apiKey ?? ""
-				} }
-			},
+			...serverConfig(config),
 			...nuxt.options.runtimeConfig.tiptapEditor
 		};
 		nuxt.options.runtimeConfig.public.tiptapEditor = {
-			locale: options.locale,
-			...options.messages && { messages: options.messages },
-			ai: {
-				slots: options.ai.slots,
-				transcription: Boolean(options.ai.transcription)
-			},
+			...publicConfig(config),
 			...nuxt.options.runtimeConfig.public.tiptapEditor
 		};
 	}

package/dist/nuxt/module.js.map

@@ -1 +1 @@
-{"version":3,"file":"module.js","names":[],"sources":["../../src/nuxt/module.ts"],"sourcesContent":["import { addPlugin, addServerScanDir, createResolver, defineNuxtModule } from 'nuxt/kit'\nimport type { Locale, Messages } from '../i18n'\nimport type { ModelSlot } from '../settings'\n\nexport interface ModuleOptions {\n  /** Language of the editor's strings: `'de'` (default) or `'en'`. Set once per app; a host that switches languages at run time recreates the editor context. */\n  locale: Locale\n  /** Overrides of single messages by key (see `MessageKey`), applied on top of the catalog of `locale`; must be JSON-serialisable. */\n  messages?: Partial<Messages>\n  ai: {\n    /**\n     * Server-defined model presets (any OpenAI-compatible chat completions endpoint), keyed by preset id. The key is\n     * per preset or the shared `apiKey`, both from env only: `NUXT_TIPTAP_EDITOR_AI_PRESETS_<ID>_API_KEY` (`<ID>` = the\n     * preset id in upper snake case, e.g. `flashLite` → `FLASH_LITE`) or `NUXT_TIPTAP_EDITOR_AI_API_KEY`. Preset ids\n     * must be camelCase so the env names map onto them.\n     */\n    presets: Record<string, { label: string, endpoint: string, model: string, apiKey?: string }>\n    /** Default preset per slot; users may override in settings. The `complete` model must support assistant prefill. */\n    slots: Record<ModelSlot, string>\n    /** Per-user limit shared by all AI endpoints: at most `max` requests per sliding `windowMs`. */\n    rateLimit: { max: number, windowMs: number }\n    /**\n     * Speech-to-text for audio/video `document` composites: any OpenAI-compatible `<endpoint>/audio/transcriptions`\n     * (e.g. OpenAI `whisper-1`; OpenRouter presets do not provide one). Absent = the action and the endpoint are off.\n     * The key comes from env only: `NUXT_TIPTAP_EDITOR_AI_TRANSCRIPTION_API_KEY`.\n     */\n    transcription?: { endpoint: string, model: string, apiKey?: string }\n  }\n  collab: {\n    /**\n     * Authenticate the `/collab/:id` websocket upgrade itself (`EditorAdapter.authenticate` with the upgrade request's\n     * headers) and refuse it with HTTP 401 for an unknown user. Default `false`: the upgrade always succeeds, the user\n     * is authenticated afterwards from the headers or the provider's `token`, and an unauthenticated socket is closed\n     * with code 4401. Enable only when every client authenticates by cookie/headers: a client that sends its identity\n     * as `collaboration.token` (no cookies) cannot connect then. Env override:\n     * `NUXT_TIPTAP_EDITOR_COLLAB_AUTHENTICATE_UPGRADE=true`.\n     */\n    authenticateUpgrade: boolean\n  }\n}\n\n/**\n * Nuxt/Nitro integration of the editor package: the client context plugin (settings persistence, AI configuration),\n * the Nitro API routes, the collaboration websocket and the AI configuration with its server-only secrets. The host\n * plugs in through `setEditorAdapter()` (`@ecsplico/editor/server`) in a Nitro plugin (auth, loading and storing\n * document content). Components are imported explicitly from the package entries; nothing is auto-registered.\n */\nexport default defineNuxtModule<ModuleOptions>({\n  meta: { name: 'tiptap-editor', configKey: 'tiptapEditor' },\n  defaults: {\n    locale: 'de',\n    collab: { authenticateUpgrade: false },\n    ai: {\n      presets: {\n        sonnet: { label: 'Claude Sonnet 4.5 (OpenRouter)', endpoint: 'https://openrouter.ai/api/v1', model: 'anthropic/claude-sonnet-4.5' },\n        flashLite: { label: 'Gemini 2.5 Flash Lite (OpenRouter)', endpoint: 'https://openrouter.ai/api/v1', model: 'google/gemini-2.5-flash-lite' },\n      },\n      slots: { complete: 'flashLite', rewrite: 'sonnet', generate: 'sonnet' },\n      rateLimit: { max: 30, windowMs: 60_000 },\n    },\n  },\n  setup(options, nuxt) {\n    const { resolve } = createResolver(import.meta.url)\n    // `resolve('..')` is the package root of the built output (`dist`) or of `src` in this repository's app: both\n    // hold the stylesheets and the unbundled `nuxt/runtime` files, which Nuxt compiles for the client and Nitro for the server.\n    const packageSrc = resolve('..')\n    nuxt.options.build.transpile.push(packageSrc)\n    // The Nuxt UI token map comes first: the feature sheets (and an Obsidian theme, `themes.css`, last) read and may override `--sk-*`.\n    nuxt.options.css.push(resolve('../vue/kit/nuxt-ui.css'))\n    nuxt.options.css.push(\n      resolve('../styles/core.css'),\n      resolve('../styles/media.css'),\n      resolve('../styles/mentions.css'),\n      resolve('../styles/authors.css'),\n      resolve('../styles/comments.css'),\n      resolve('../styles/transcript.css'),\n      resolve('../styles/composites.css'),\n      resolve('../styles/ai.css'),\n      resolve('../styles/collab.css'),\n      resolve('../styles/block-ui.css'),\n      resolve('../styles/themes.css'),\n    )\n    addPlugin({ src: resolve('./runtime/plugins/editor-context-nuxt-ui.client.ts'), mode: 'client' })\n    addServerScanDir(resolve('./runtime/server'))\n    // Tailwind only scans the app layers listed in Nuxt UI's generated `ui.css` (`@source \"<layer>/app/**/*\"`), so the\n    // utility classes used by the package's components would never be generated. Append its source. `@nuxt/ui` must be\n    // registered before this module.\n    nuxt.hook('modules:done', () => {\n      const uiCss = nuxt.options.build.templates.find(t => t.filename === 'ui.css')\n      if (!uiCss?.getContents) throw new Error('tiptap-editor: @nuxt/ui muss vor diesem Modul registriert sein (ui.css-Template fehlt)')\n      const getContents = uiCss.getContents\n      uiCss.getContents = async data => `@source \"${packageSrc}/**/*\";\\n${await getContents(data)}`\n    })\n    nuxt.options.nitro.experimental = { ...nuxt.options.nitro.experimental, websocket: true }\n    // Nitro bundles the package (the runtime files import `h3` and `nitropack/runtime`, which the host's Nitro resolves): never leave it external.\n    nuxt.options.nitro.externals = { ...nuxt.options.nitro.externals, inline: [...(nuxt.options.nitro.externals?.inline ?? []), '@ecsplico/editor', packageSrc] }\n    nuxt.options.runtimeConfig.tiptapEditor = {\n      collab: { authenticateUpgrade: options.collab.authenticateUpgrade },\n      ai: {\n        apiKey: '',\n        // Every preset gets an empty `apiKey`, so its env variable has a key to override.\n        presets: Object.fromEntries(Object.entries(options.ai.presets).map(([id, preset]) => [id, { ...preset, apiKey: preset.apiKey ?? '' }])),\n        slots: options.ai.slots,\n        rateLimit: options.ai.rateLimit,\n        // `apiKey` defaults to '' so its env variable has a key to override.\n        ...(options.ai.transcription && { transcription: { ...options.ai.transcription, apiKey: options.ai.transcription.apiKey ?? '' } }),\n      },\n      ...(nuxt.options.runtimeConfig.tiptapEditor as object | undefined),\n    }\n    // Default slot presets for the client before `GET /api/ai/models` has answered; read by the client context plugin.\n    nuxt.options.runtimeConfig.public.tiptapEditor = {\n      locale: options.locale,\n      ...(options.messages && { messages: options.messages }),\n      ai: { slots: options.ai.slots, transcription: Boolean(options.ai.transcription) },\n      ...(nuxt.options.runtimeConfig.public.tiptapEditor as object | undefined),\n    }\n  },\n})\n"],"mappings":";;;;;;;;AA+CA,IAAA,iBAAe,iBAAgC;CAC7C,MAAM;EAAE,MAAM;EAAiB,WAAW;CAAe;CACzD,UAAU;EACR,QAAQ;EACR,QAAQ,EAAE,qBAAqB,MAAM;EACrC,IAAI;GACF,SAAS;IACP,QAAQ;KAAE,OAAO;KAAkC,UAAU;KAAgC,OAAO;IAA8B;IAClI,WAAW;KAAE,OAAO;KAAsC,UAAU;KAAgC,OAAO;IAA+B;GAC5I;GACA,OAAO;IAAE,UAAU;IAAa,SAAS;IAAU,UAAU;GAAS;GACtE,WAAW;IAAE,KAAK;IAAI,UAAU;GAAO;EACzC;CACF;CACA,MAAM,SAAS,MAAM;EACnB,MAAM,EAAE,YAAY,eAAe,YAAY,GAAG;EAGlD,MAAM,aAAa,QAAQ,IAAI;EAC/B,KAAK,QAAQ,MAAM,UAAU,KAAK,UAAU;EAE5C,KAAK,QAAQ,IAAI,KAAK,QAAQ,wBAAwB,CAAC;EACvD,KAAK,QAAQ,IAAI,KACf,QAAQ,oBAAoB,GAC5B,QAAQ,qBAAqB,GAC7B,QAAQ,wBAAwB,GAChC,QAAQ,uBAAuB,GAC/B,QAAQ,wBAAwB,GAChC,QAAQ,0BAA0B,GAClC,QAAQ,0BAA0B,GAClC,QAAQ,kBAAkB,GAC1B,QAAQ,sBAAsB,GAC9B,QAAQ,wBAAwB,GAChC,QAAQ,sBAAsB,CAChC;EACA,UAAU;GAAE,KAAK,QAAQ,oDAAoD;GAAG,MAAM;EAAS,CAAC;EAChG,iBAAiB,QAAQ,kBAAkB,CAAC;EAI5C,KAAK,KAAK,sBAAsB;GAC9B,MAAM,QAAQ,KAAK,QAAQ,MAAM,UAAU,MAAK,MAAK,EAAE,aAAa,QAAQ;GAC5E,IAAI,CAAC,OAAO,aAAa,MAAM,IAAI,MAAM,wFAAwF;GACjI,MAAM,cAAc,MAAM;GAC1B,MAAM,cAAc,OAAM,SAAQ,YAAY,WAAW,WAAW,MAAM,YAAY,IAAI;EAC5F,CAAC;EACD,KAAK,QAAQ,MAAM,eAAe;GAAE,GAAG,KAAK,QAAQ,MAAM;GAAc,WAAW;EAAK;EAExF,KAAK,QAAQ,MAAM,YAAY;GAAE,GAAG,KAAK,QAAQ,MAAM;GAAW,QAAQ;IAAC,GAAI,KAAK,QAAQ,MAAM,WAAW,UAAU,CAAC;IAAI;IAAoB;GAAU;EAAE;EAC5J,KAAK,QAAQ,cAAc,eAAe;GACxC,QAAQ,EAAE,qBAAqB,QAAQ,OAAO,oBAAoB;GAClE,IAAI;IACF,QAAQ;IAER,SAAS,OAAO,YAAY,OAAO,QAAQ,QAAQ,GAAG,OAAO,CAAC,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,IAAI;KAAE,GAAG;KAAQ,QAAQ,OAAO,UAAU;IAAG,CAAC,CAAC,CAAC;IACtI,OAAO,QAAQ,GAAG;IAClB,WAAW,QAAQ,GAAG;IAEtB,GAAI,QAAQ,GAAG,iBAAiB,EAAE,eAAe;KAAE,GAAG,QAAQ,GAAG;KAAe,QAAQ,QAAQ,GAAG,cAAc,UAAU;IAAG,EAAE;GAClI;GACA,GAAI,KAAK,QAAQ,cAAc;EACjC;EAEA,KAAK,QAAQ,cAAc,OAAO,eAAe;GAC/C,QAAQ,QAAQ;GAChB,GAAI,QAAQ,YAAY,EAAE,UAAU,QAAQ,SAAS;GACrD,IAAI;IAAE,OAAO,QAAQ,GAAG;IAAO,eAAe,QAAQ,QAAQ,GAAG,aAAa;GAAE;GAChF,GAAI,KAAK,QAAQ,cAAc,OAAO;EACxC;CACF;AACF,CAAC"}
+{"version":3,"file":"module.js","names":[],"sources":["../../src/nuxt/module.ts"],"sourcesContent":["import { addPlugin, addServerScanDir, createResolver, defineNuxtModule } from 'nuxt/kit'\nimport { defineEditorConfig, type EditorConfigInput, publicConfig, serverConfig } from '../config'\n\n/** Module options (`tiptapEditor` in `nuxt.config`): the editor's configuration with every key optional, see `EditorConfig`. */\nexport type ModuleOptions = EditorConfigInput\n\n/**\n * Nuxt/Nitro integration of the editor package: the client context plugin (settings persistence, AI configuration),\n * a server plugin that mounts the editor's routes and the collaboration websocket (`installEditorServer`) and the AI configuration with its server-only secrets. The host\n * plugs in through `setEditorPorts()` (`@ecsplico/editor/server`) in a Nitro plugin (auth, loading and storing\n * document content). Components are imported explicitly from the package entries; nothing is auto-registered.\n */\nexport default defineNuxtModule<ModuleOptions>({\n  meta: { name: 'tiptap-editor', configKey: 'tiptapEditor' },\n  setup(options, nuxt) {\n    const { resolve } = createResolver(import.meta.url)\n    // `resolve('..')` is the package root of the built output (`dist`) or of `src` in this repository's app: both\n    // hold the stylesheets and the unbundled `nuxt/runtime` files, which Nuxt compiles for the client and Nitro for the server.\n    const packageSrc = resolve('..')\n    nuxt.options.build.transpile.push(packageSrc)\n    // The Nuxt UI token map comes first: the feature sheets (and an Obsidian theme, `themes.css`, last) read and may override `--sk-*`.\n    nuxt.options.css.push(resolve('../vue/kit/nuxt-ui.css'))\n    nuxt.options.css.push(\n      resolve('../styles/core.css'),\n      resolve('../styles/media.css'),\n      resolve('../styles/mentions.css'),\n      resolve('../styles/authors.css'),\n      resolve('../styles/comments.css'),\n      resolve('../styles/transcript.css'),\n      resolve('../styles/composites.css'),\n      resolve('../styles/ai.css'),\n      resolve('../styles/collab.css'),\n      resolve('../styles/block-ui.css'),\n      resolve('../styles/themes.css'),\n    )\n    addPlugin({ src: resolve('./runtime/plugins/editor-context-nuxt-ui.client.ts'), mode: 'client' })\n    addServerScanDir(resolve('./runtime/server'))\n    // Tailwind only scans the app layers listed in Nuxt UI's generated `ui.css` (`@source \"<layer>/app/**/*\"`), so the\n    // utility classes used by the package's components would never be generated. Append its source. `@nuxt/ui` must be\n    // registered before this module.\n    nuxt.hook('modules:done', () => {\n      const uiCss = nuxt.options.build.templates.find(t => t.filename === 'ui.css')\n      if (!uiCss?.getContents) throw new Error('tiptap-editor: @nuxt/ui muss vor diesem Modul registriert sein (ui.css-Template fehlt)')\n      const getContents = uiCss.getContents\n      uiCss.getContents = async data => `@source \"${packageSrc}/**/*\";\\n${await getContents(data)}`\n    })\n    nuxt.options.nitro.experimental = { ...nuxt.options.nitro.experimental, websocket: true }\n    // Nitro bundles the package (the runtime files import `h3` and `nitropack/runtime`, which the host's Nitro resolves): never leave it external.\n    nuxt.options.nitro.externals = { ...nuxt.options.nitro.externals, inline: [...(nuxt.options.nitro.externals?.inline ?? []), '@ecsplico/editor', packageSrc] }\n    const config = defineEditorConfig(options)\n    // The server view keeps an empty `apiKey` on the shared key, every preset and the transcription, so their `NUXT_TIPTAP_EDITOR_AI_*` env variables have a key to override.\n    nuxt.options.runtimeConfig.tiptapEditor = {\n      ...serverConfig(config),\n      ...(nuxt.options.runtimeConfig.tiptapEditor as object | undefined),\n    }\n    // Default slot presets for the client before `GET /api/ai/models` has answered; read by the client context plugin.\n    nuxt.options.runtimeConfig.public.tiptapEditor = {\n      ...publicConfig(config),\n      ...(nuxt.options.runtimeConfig.public.tiptapEditor as object | undefined),\n    }\n  },\n})\n"],"mappings":";;;;;;;;;AAYA,IAAA,iBAAe,iBAAgC;CAC7C,MAAM;EAAE,MAAM;EAAiB,WAAW;CAAe;CACzD,MAAM,SAAS,MAAM;EACnB,MAAM,EAAE,YAAY,eAAe,YAAY,GAAG;EAGlD,MAAM,aAAa,QAAQ,IAAI;EAC/B,KAAK,QAAQ,MAAM,UAAU,KAAK,UAAU;EAE5C,KAAK,QAAQ,IAAI,KAAK,QAAQ,wBAAwB,CAAC;EACvD,KAAK,QAAQ,IAAI,KACf,QAAQ,oBAAoB,GAC5B,QAAQ,qBAAqB,GAC7B,QAAQ,wBAAwB,GAChC,QAAQ,uBAAuB,GAC/B,QAAQ,wBAAwB,GAChC,QAAQ,0BAA0B,GAClC,QAAQ,0BAA0B,GAClC,QAAQ,kBAAkB,GAC1B,QAAQ,sBAAsB,GAC9B,QAAQ,wBAAwB,GAChC,QAAQ,sBAAsB,CAChC;EACA,UAAU;GAAE,KAAK,QAAQ,oDAAoD;GAAG,MAAM;EAAS,CAAC;EAChG,iBAAiB,QAAQ,kBAAkB,CAAC;EAI5C,KAAK,KAAK,sBAAsB;GAC9B,MAAM,QAAQ,KAAK,QAAQ,MAAM,UAAU,MAAK,MAAK,EAAE,aAAa,QAAQ;GAC5E,IAAI,CAAC,OAAO,aAAa,MAAM,IAAI,MAAM,wFAAwF;GACjI,MAAM,cAAc,MAAM;GAC1B,MAAM,cAAc,OAAM,SAAQ,YAAY,WAAW,WAAW,MAAM,YAAY,IAAI;EAC5F,CAAC;EACD,KAAK,QAAQ,MAAM,eAAe;GAAE,GAAG,KAAK,QAAQ,MAAM;GAAc,WAAW;EAAK;EAExF,KAAK,QAAQ,MAAM,YAAY;GAAE,GAAG,KAAK,QAAQ,MAAM;GAAW,QAAQ;IAAC,GAAI,KAAK,QAAQ,MAAM,WAAW,UAAU,CAAC;IAAI;IAAoB;GAAU;EAAE;EAC5J,MAAM,SAAS,mBAAmB,OAAO;EAEzC,KAAK,QAAQ,cAAc,eAAe;GACxC,GAAG,aAAa,MAAM;GACtB,GAAI,KAAK,QAAQ,cAAc;EACjC;EAEA,KAAK,QAAQ,cAAc,OAAO,eAAe;GAC/C,GAAG,aAAa,MAAM;GACtB,GAAI,KAAK,QAAQ,cAAc,OAAO;EACxC;CACF;AACF,CAAC"}

package/dist/nuxt/runtime/install-context.d.ts

@@ -1,16 +1,20 @@
 import { VueUiKit } from "../../vue/kit/types.js";
 import { App } from "vue";
+import { $Fetch } from "ofetch";
 //#region src/nuxt/runtime/install-context.d.ts
 /**
  * Installs the editor context on a Nuxt app (client only: TipTap does not render on the server). Settings are kept per
  * account through the host's `/api/editor/settings`; the AI configuration is the module's public runtime config,
- * passed on as inert data. Features request through ofetch, which is what Nuxt's `$fetch` is on the client. `locale`
+ * passed on as inert data. The backend is the HTTP adapter over Nuxt's `$fetch` with `probe: true`: it asks the server
+ * which capabilities it serves and drops the others (no comments port, no themes, …), so compositions pruned by `backend`
+ * match the server. The returned promise settles once that is known; await it in the plugin so no editor mounts before. `locale`
  * and `messages` are the module's options of the same name. The kit is passed in by the plugin file the module registers
- * (`nuxtUiKit()`). Only the Vue app is read, so the parameter is structural: a host's
+ * (`nuxtUiKit()`). Only the Vue app and `$fetch` are read, so the parameter is structural: a host's
  * augmented `NuxtApp` (plugins adding `$router`, `$auth`, ...) and the `_NuxtApp` a plugin receives both fit.
  */
 export declare function installEditorContext(nuxtApp: {
   vueApp: App;
-}, kit: VueUiKit): void;
+  $fetch?: $Fetch;
+}, kit: VueUiKit): Promise<void>;
 //#endregion
 //# sourceMappingURL=install-context.d.ts.map

package/dist/nuxt/runtime/install-context.js

@@ -1,23 +1,29 @@
+import { createHttpBackend } from "../../adapters/http.js";
 import { createEditor } from "../../vue/context.js";
 import { useRuntimeConfig } from "#app";
 //#region src/nuxt/runtime/install-context.ts
 /**
 * Installs the editor context on a Nuxt app (client only: TipTap does not render on the server). Settings are kept per
 * account through the host's `/api/editor/settings`; the AI configuration is the module's public runtime config,
-* passed on as inert data. Features request through ofetch, which is what Nuxt's `$fetch` is on the client. `locale`
+* passed on as inert data. The backend is the HTTP adapter over Nuxt's `$fetch` with `probe: true`: it asks the server
+* which capabilities it serves and drops the others (no comments port, no themes, …), so compositions pruned by `backend`
+* match the server. The returned promise settles once that is known; await it in the plugin so no editor mounts before. `locale`
 * and `messages` are the module's options of the same name. The kit is passed in by the plugin file the module registers
-* (`nuxtUiKit()`). Only the Vue app is read, so the parameter is structural: a host's
+* (`nuxtUiKit()`). Only the Vue app and `$fetch` are read, so the parameter is structural: a host's
 * augmented `NuxtApp` (plugins adding `$router`, `$auth`, ...) and the `_NuxtApp` a plugin receives both fit.
 */
-function installEditorContext(nuxtApp, kit) {
-	const { ai, locale, messages } = useRuntimeConfig().public.tiptapEditor;
+async function installEditorContext(nuxtApp, kit) {
+	const config = useRuntimeConfig().public.tiptapEditor;
+	const backend = createHttpBackend({
+		probe: true,
+		...nuxtApp.$fetch && { fetch: nuxtApp.$fetch }
+	});
 	nuxtApp.vueApp.use(createEditor({
 		kit,
-		settings: { remote: true },
-		...ai && { ai },
-		...locale && { locale },
-		...messages && { messages }
+		backend,
+		...config
 	}));
+	await backend.ready;
 }
 //#endregion
 export { installEditorContext };

package/dist/nuxt/runtime/install-context.js.map

@@ -1 +1 @@
-{"version":3,"file":"install-context.js","names":[],"sources":["../../../src/nuxt/runtime/install-context.ts"],"sourcesContent":["import type { App } from 'vue'\nimport { useRuntimeConfig } from '#app'\nimport type { EditorAiConfig } from '../../core/context'\nimport type { Locale, Messages } from '../../i18n'\nimport { createEditor } from '../../vue/context'\nimport type { VueUiKit } from '../../vue/kit/types'\n\n/**\n * Installs the editor context on a Nuxt app (client only: TipTap does not render on the server). Settings are kept per\n * account through the host's `/api/editor/settings`; the AI configuration is the module's public runtime config,\n * passed on as inert data. Features request through ofetch, which is what Nuxt's `$fetch` is on the client. `locale`\n * and `messages` are the module's options of the same name. The kit is passed in by the plugin file the module registers\n * (`nuxtUiKit()`). Only the Vue app is read, so the parameter is structural: a host's\n * augmented `NuxtApp` (plugins adding `$router`, `$auth`, ...) and the `_NuxtApp` a plugin receives both fit.\n */\nexport function installEditorContext(nuxtApp: { vueApp: App }, kit: VueUiKit): void {\n  const { ai, locale, messages } = useRuntimeConfig().public.tiptapEditor as { ai?: EditorAiConfig, locale?: Locale, messages?: Partial<Messages> }\n  nuxtApp.vueApp.use(createEditor({ kit, settings: { remote: true }, ...(ai && { ai }), ...(locale && { locale }), ...(messages && { messages }) }))\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,qBAAqB,SAA0B,KAAqB;CAClF,MAAM,EAAE,IAAI,QAAQ,aAAa,iBAAiB,CAAC,CAAC,OAAO;CAC3D,QAAQ,OAAO,IAAI,aAAa;EAAE;EAAK,UAAU,EAAE,QAAQ,KAAK;EAAG,GAAI,MAAM,EAAE,GAAG;EAAI,GAAI,UAAU,EAAE,OAAO;EAAI,GAAI,YAAY,EAAE,SAAS;CAAG,CAAC,CAAC;AACnJ"}
+{"version":3,"file":"install-context.js","names":[],"sources":["../../../src/nuxt/runtime/install-context.ts"],"sourcesContent":["import type { $Fetch } from 'ofetch'\nimport type { App } from 'vue'\nimport { useRuntimeConfig } from '#app'\nimport { createHttpBackend } from '../../adapters/http'\nimport type { EditorPublicConfig } from '../../config'\nimport { createEditor } from '../../vue/context'\nimport type { VueUiKit } from '../../vue/kit/types'\n\n/**\n * Installs the editor context on a Nuxt app (client only: TipTap does not render on the server). Settings are kept per\n * account through the host's `/api/editor/settings`; the AI configuration is the module's public runtime config,\n * passed on as inert data. The backend is the HTTP adapter over Nuxt's `$fetch` with `probe: true`: it asks the server\n * which capabilities it serves and drops the others (no comments port, no themes, …), so compositions pruned by `backend`\n * match the server. The returned promise settles once that is known; await it in the plugin so no editor mounts before. `locale`\n * and `messages` are the module's options of the same name. The kit is passed in by the plugin file the module registers\n * (`nuxtUiKit()`). Only the Vue app and `$fetch` are read, so the parameter is structural: a host's\n * augmented `NuxtApp` (plugins adding `$router`, `$auth`, ...) and the `_NuxtApp` a plugin receives both fit.\n */\nexport async function installEditorContext(nuxtApp: { vueApp: App, $fetch?: $Fetch }, kit: VueUiKit): Promise<void> {\n  const config = useRuntimeConfig().public.tiptapEditor as EditorPublicConfig\n  const backend = createHttpBackend({ probe: true, ...(nuxtApp.$fetch && { fetch: nuxtApp.$fetch }) })\n  nuxtApp.vueApp.use(createEditor({ kit, backend, ...config }))\n  await backend.ready\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,eAAsB,qBAAqB,SAA2C,KAA8B;CAClH,MAAM,SAAS,iBAAiB,CAAC,CAAC,OAAO;CACzC,MAAM,UAAU,kBAAkB;EAAE,OAAO;EAAM,GAAI,QAAQ,UAAU,EAAE,OAAO,QAAQ,OAAO;CAAG,CAAC;CACnG,QAAQ,OAAO,IAAI,aAAa;EAAE;EAAK;EAAS,GAAG;CAAO,CAAC,CAAC;CAC5D,MAAM,QAAQ;AAChB"}

package/dist/nuxt/runtime/plugins/editor-context-nuxt-ui.client.ts

@@ -3,6 +3,6 @@ import { installEditorContext } from '../install-context'
 import { defineNuxtPlugin } from '#app'
 
 // Registered by the module; see `install-context.ts`.
-export default defineNuxtPlugin((nuxtApp) => {
-  installEditorContext(nuxtApp, nuxtUiKit())
+export default defineNuxtPlugin(async (nuxtApp) => {
+  await installEditorContext(nuxtApp, nuxtUiKit())
 })

package/dist/nuxt/runtime/server/plugins/editor-server.js

@@ -1,18 +1,26 @@
-import { configureEditorServer } from "../../../../server/host.js";
+import { useEditorPorts, useEditorSchema } from "../../../../server/host.js";
+import { installEditorServer } from "../../../../adapters/nitro.js";
 import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
 //#region src/nuxt/runtime/server/plugins/editor-server.ts
-var editor_server_default = defineNitroPlugin(() => {
-	const { ai } = useRuntimeConfig().tiptapEditor;
-	configureEditorServer({
-		ai: {
-			presets: ai.presets,
-			apiKey: ai.apiKey,
-			slots: ai.slots,
-			transcription: ai.transcription,
-			missingKeyHint: (id) => ` (NUXT_TIPTAP_EDITOR_AI_PRESETS_${id.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase()}_API_KEY oder NUXT_TIPTAP_EDITOR_AI_API_KEY)`
-		},
-		rateLimit: ai.rateLimit
+var editor_server_default = defineNitroPlugin((nitroApp) => {
+	let server;
+	nitroApp.hooks.hook("request", () => {
+		server ??= install();
 	});
+	function install() {
+		const { ai, rateLimit, collab } = useRuntimeConfig().tiptapEditor;
+		const ports = useEditorPorts();
+		return installEditorServer(nitroApp, {
+			ports,
+			collab: ports.collabState ? collab : false,
+			ai: {
+				...ai,
+				missingKeyHint: (id) => ` (NUXT_TIPTAP_EDITOR_AI_PRESETS_${id.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase()}_API_KEY oder NUXT_TIPTAP_EDITOR_AI_API_KEY)`
+			},
+			rateLimit,
+			schema: useEditorSchema()
+		});
+	}
 });
 //#endregion
 export { editor_server_default as default };

package/dist/nuxt/runtime/server/plugins/editor-server.js.map

@@ -1 +1 @@
-{"version":3,"file":"editor-server.js","names":[],"sources":["../../../../../src/nuxt/runtime/server/plugins/editor-server.ts"],"sourcesContent":["// Nitro's auto-imports are not applied to files under node_modules (the built package), so every Nitro/h3 helper is imported explicitly.\nimport { defineNitroPlugin, useRuntimeConfig } from 'nitropack/runtime'\nimport { configureEditorServer } from '../../../../server/host'\n\n// The AI configuration (presets, keys, slots, transcription) and the rate limit come from the module's runtime config.\nexport default defineNitroPlugin(() => {\n  const { ai } = useRuntimeConfig().tiptapEditor\n  configureEditorServer({\n    ai: {\n      presets: ai.presets,\n      apiKey: ai.apiKey,\n      slots: ai.slots,\n      // Absent from the runtime config unless the module option is set, so it is missing from the generated config type.\n      transcription: (ai as { transcription?: { endpoint: string, model: string, apiKey?: string } }).transcription,\n      // Env names use the preset id in upper snake case (`flashLite` → `FLASH_LITE`), like Nuxt's runtime config mapping.\n      missingKeyHint: id => ` (NUXT_TIPTAP_EDITOR_AI_PRESETS_${id.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase()}_API_KEY oder NUXT_TIPTAP_EDITOR_AI_API_KEY)`,\n    },\n    rateLimit: ai.rateLimit,\n  })\n})\n"],"mappings":";;;AAKA,IAAA,wBAAe,wBAAwB;CACrC,MAAM,EAAE,OAAO,iBAAiB,CAAC,CAAC;CAClC,sBAAsB;EACpB,IAAI;GACF,SAAS,GAAG;GACZ,QAAQ,GAAG;GACX,OAAO,GAAG;GAEV,eAAgB,GAAgF;GAEhG,iBAAgB,OAAM,mCAAmC,GAAG,QAAQ,sBAAsB,OAAO,CAAC,CAAC,YAAY,EAAE;EACnH;EACA,WAAW,GAAG;CAChB,CAAC;AACH,CAAC"}
+{"version":3,"file":"editor-server.js","names":[],"sources":["../../../../../src/nuxt/runtime/server/plugins/editor-server.ts"],"sourcesContent":["// Nitro's auto-imports are not applied to files under node_modules (the built package), so every Nitro/h3 helper is imported explicitly.\nimport { defineNitroPlugin, useRuntimeConfig } from 'nitropack/runtime'\nimport { type EditorServer, installEditorServer } from '../../../../adapters/nitro'\nimport type { EditorServerConfig } from '../../../../config'\nimport { useEditorPorts, useEditorSchema } from '../../../../server/host'\n\n// Mounts the editor's routes and the collaboration websocket (`installEditorServer`) over the ports the host registered\n// with `setEditorPorts()`, and takes the AI configuration (presets, keys, slots, transcription), the rate limit and\n// `collab.authenticateUpgrade` from the module's runtime config.\n//\n// The host registers its ports in a Nitro plugin of its own, and Nitro does not order plugins of different layers and\n// modules reliably; the first request is the first moment every plugin has run (the routes it served before this\n// were file-based and read the ports per request, too). A failed install is retried by the next request.\nexport default defineNitroPlugin((nitroApp) => {\n  let server: EditorServer | undefined\n  nitroApp.hooks.hook('request', () => {\n    server ??= install()\n  })\n\n  function install(): EditorServer {\n    // The module's `serverConfig(defineEditorConfig(options))`, with the host's runtime-config and env overrides applied.\n    const { ai, rateLimit, collab } = useRuntimeConfig().tiptapEditor as EditorServerConfig\n    const ports = useEditorPorts()\n    return installEditorServer(nitroApp, {\n      ports,\n      // Without persisted collaboration state the editor runs without the websocket (documents still load and save over HTTP).\n      collab: ports.collabState ? collab : false,\n      // Env names use the preset id in upper snake case (`flashLite` → `FLASH_LITE`), like Nuxt's runtime config mapping.\n      ai: { ...ai, missingKeyHint: id => ` (NUXT_TIPTAP_EDITOR_AI_PRESETS_${id.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase()}_API_KEY oder NUXT_TIPTAP_EDITOR_AI_API_KEY)` },\n      rateLimit,\n      schema: useEditorSchema(),\n    })\n  }\n})\n"],"mappings":";;;;AAaA,IAAA,wBAAe,mBAAmB,aAAa;CAC7C,IAAI;CACJ,SAAS,MAAM,KAAK,iBAAiB;EACnC,WAAW,QAAQ;CACrB,CAAC;CAED,SAAS,UAAwB;EAE/B,MAAM,EAAE,IAAI,WAAW,WAAW,iBAAiB,CAAC,CAAC;EACrD,MAAM,QAAQ,eAAe;EAC7B,OAAO,oBAAoB,UAAU;GACnC;GAEA,QAAQ,MAAM,cAAc,SAAS;GAErC,IAAI;IAAE,GAAG;IAAI,iBAAgB,OAAM,mCAAmC,GAAG,QAAQ,sBAAsB,OAAO,CAAC,CAAC,YAAY,EAAE;GAA8C;GAC5K;GACA,QAAQ,gBAAgB;EAC1B,CAAC;CACH;AACF,CAAC"}

package/dist/presets/compose.d.ts

@@ -0,0 +1,94 @@
+import { EditorBackend } from "../core/backend.js";
+import { EditorFeature, EditorPreset } from "../core/feature.js";
+import { CommentsFeatureOptions } from "../features/comments/feature.js";
+import { CompositeKind } from "../features/composites/kinds.js";
+import { CompositeFeatureOptions } from "../features/composites/feature.js";
+//#region src/presets/compose.d.ts
+/** The id of a catalog feature (`CONTENT`, `INTERACTION`, `AI`) or of a host feature passed to `remove`. */
+export type FeatureId = string;
+/** How much document model the editor has: `basic` = `core-content`, `rich` = the full content catalog. */
+export type ContentLevel = 'basic' | 'rich';
+/** How much editing UX the editor has: `minimal` = `core-ui`, `full` = every interaction feature. */
+export type InteractionLevel = 'minimal' | 'full';
+/** The content features of each level, in canonical (schema) order. */
+export declare const CONTENT: Record<ContentLevel, readonly FeatureId[]>;
+/** The interaction features of each level, in canonical order. */
+export declare const INTERACTION: Record<InteractionLevel, readonly FeatureId[]>;
+/** The AI features (`ai: true`): the AI feature and the integrations that need it; each is installed when its `requires` are met. */
+export declare const AI: readonly FeatureId[];
+/**
+ * The features a UI layer binds, keyed by id; the other catalog features are framework-free and built here. The AI
+ * features are bound too, although `composite-ai` and `transcript-ai` have no components: the layer owns every import of
+ * `features/ai`, so a composition without `ai` binds none of them and its bundle holds no AI code. Each binding is a
+ * factory, called only for a feature the composition selects (`themes` reads the current Vue app when built, so
+ * unselected features are never built). `composites` receives the composition's `compositeKinds`, `comments` its
+ * `comments` options. `core-ui` takes no parameter here: the framework-free `simpleEditor()` has no command palette;
+ * a layer that has one (the `SimpleEditor` surfaces) builds `coreUiFeature({ palette })` itself.
+ */
+export interface UiBindings<C> {
+  'core-ui': () => EditorFeature<C>;
+  'media': () => EditorFeature<C>;
+  'transcript': () => EditorFeature<C>;
+  'composites': (options: CompositeFeatureOptions) => EditorFeature<C>;
+  'authors': () => EditorFeature<C>;
+  'comments': (options: CommentsFeatureOptions) => EditorFeature<C>;
+  'ai': () => EditorFeature<C>;
+  'composite-ai': () => EditorFeature<C>;
+  'transcript-ai': () => EditorFeature<C>;
+  'collab': () => EditorFeature<C>;
+  'block-ui': () => EditorFeature<C>;
+  'themes': () => EditorFeature<C>;
+}
+/** What `composeEditor` builds the editor from. */
+export interface ComposeOptions<C> {
+  /** The document model: a level or the content feature ids to install (`core-content` is always installed). */
+  content: ContentLevel | readonly FeatureId[];
+  /** The editing UX: a level or the interaction feature ids (`core-ui` is installed with any non-empty list); `[]` = a viewer without any interaction feature. */
+  interaction: InteractionLevel | readonly FeatureId[];
+  /** Installs `ai` and every integration whose `requires` are met (composite-AI iff composites, transcript-AI iff transcript). */
+  ai: boolean;
+  /** The backend the editor runs on: features needing a capability it lacks are omitted. Absent = nothing is pruned by capability. */
+  backend?: EditorBackend;
+  /**
+   * The host supplies the collaboration session itself (the surface's `collaboration` prop, e.g. from its own Hocuspocus
+   * provider), so `collab` and `comments` need no `collaboration` capability from the backend. Only a backend that must
+   * open the collaboration (`useEditorDocument(id, { collaboration: true })`) has to offer it. Default `false`.
+   */
+  collaboration?: boolean;
+  /** Host features, appended after the catalog in the given order. */
+  add?: readonly EditorFeature<C>[];
+  /** Features left out (catalog or host); features that require them are omitted as well. */
+  remove?: readonly FeatureId[];
+  /** The composite kinds („Bausteine“) offered in the editor (default: the built-in kinds); read once. */
+  compositeKinds?: readonly CompositeKind[];
+  /** Options of the comments feature, e.g. a host `model` (then comments need no `collab`). */
+  comments?: CommentsFeatureOptions;
+}
+/** The composed preset and the features that were selected but dropped, in composition order, with the reason. */
+export interface ComposedEditor<C> extends EditorPreset<C> {
+  readonly omitted: readonly {
+    id: FeatureId;
+    reason: string;
+  }[];
+}
+/**
+ * Composes an editor from three dimensions plus the backend's capabilities, over the UI bindings of a layer.
+ *
+ * The feature list is `content` + `interaction` (+ the AI features when `ai`) + `add`, minus `remove`. `core-content` is
+ * always part of it and `core-ui` of every non-empty interaction list. Features that require a missing feature, or a
+ * backend capability `options.backend` lacks, are dropped until the list is stable and reported in `omitted` (so
+ * `ai: true` over a backend without `ai` installs no AI and says why). The catalog features keep their canonical order
+ * (content, interaction, AI), host features follow in the order given; the result is validated by `defineEditor`.
+ * Throws when an id of `content` is not a content feature, an id of `interaction` not an interaction feature, an id
+ * names no catalog feature, `remove` names `core-content`, or a selected feature has no binding in `ui`.
+ */
+export declare function composeEditor<C>(ui: Partial<UiBindings<C>>, options: ComposeOptions<C>): ComposedEditor<C>;
+/**
+ * The simple editor: `core-content` and `core-ui` (formatting, headings, lists, quotes, code, undo/redo). No backend, no AI,
+ * no collaboration, and no ⌘K command palette (`coreUiFeature()` gets no `palette` component here, the framework-free
+ * layer has none; the `SimpleEditor` components and the `composeEditor` of `/vue/advanced` and `/react/advanced` bind it).
+ * Component-free (`ComposedEditor<never>`), so both the Vue and the React surface accept it.
+ */
+export declare const simpleEditor: () => ComposedEditor<never>;
+//#endregion
+//# sourceMappingURL=compose.d.ts.map

package/dist/presets/compose.js

@@ -0,0 +1,164 @@
+import { defineEditor } from "../core/define-editor.js";
+import { coreContentFeature, coreUiFeature } from "../core/core-feature.js";
+import { CommentMark } from "../features/comments/schema.js";
+import { mentionsFeature } from "../features/mentions/index.js";
+import { tablesFeature } from "../features/tables/feature.js";
+import { compositeMediaFeature } from "../integrations/composite-media/index.js";
+//#region src/presets/compose.ts
+/** The content features of each level, in canonical (schema) order. */
+const CONTENT = {
+	basic: ["core-content"],
+	rich: [
+		"core-content",
+		"media",
+		"transcript",
+		"composites",
+		"mentions",
+		"authors",
+		"tables",
+		"composite-media"
+	]
+};
+/** The interaction features of each level, in canonical order. */
+const INTERACTION = {
+	minimal: ["core-ui"],
+	full: [
+		"core-ui",
+		"collab",
+		"comments",
+		"block-ui",
+		"themes"
+	]
+};
+/** The AI features (`ai: true`): the AI feature and the integrations that need it; each is installed when its `requires` are met. */
+const AI = [
+	"ai",
+	"composite-ai",
+	"transcript-ai"
+];
+/** Canonical feature order: content, interaction, AI. The composed feature list, its schema order and its toolbar order follow it. */
+const CANONICAL = [
+	...CONTENT.rich,
+	...INTERACTION.full,
+	...AI
+];
+function fail(message) {
+	throw new Error(`@ecsplico/editor: composeEditor: ${message}`);
+}
+/**
+* Builds the catalog feature `id`. A framework binding the composition needs but `ui` lacks fails here, naming it.
+* `ui` is partial on purpose: a host that never selects a feature (a viewer has no `block-ui`) binds only the rest, so
+* the bundle holds no code of the others.
+*/
+function build(id, ui, options) {
+	const bound = (key) => ui[key] ?? fail(`no UI binding for feature "${key}"`);
+	switch (id) {
+		case "core-content": return coreContentFeature();
+		case "mentions": return mentionsFeature();
+		case "tables": return tablesFeature();
+		case "composite-media": return compositeMediaFeature();
+		case "core-ui": return bound("core-ui")();
+		case "composite-ai": return bound("composite-ai")();
+		case "transcript-ai": return bound("transcript-ai")();
+		case "media": return bound("media")();
+		case "transcript": return bound("transcript")();
+		case "composites": return bound("composites")(options.compositeKinds ? { kinds: options.compositeKinds } : {});
+		case "authors": return bound("authors")();
+		case "comments": return bound("comments")(options.comments ?? {});
+		case "ai": return bound("ai")();
+		case "collab": return bound("collab")();
+		case "block-ui": return bound("block-ui")();
+		case "themes": return bound("themes")();
+		default: return fail(`unknown catalog feature "${id}" (host features go in \`add\`)`);
+	}
+}
+/** Why `feature` cannot stay in a composition holding `ids` over `backend`, or `undefined`. A host session satisfies `collaboration`. */
+function unmet(feature, ids, options) {
+	const { backend } = options;
+	for (const capability of feature.backend ?? []) {
+		if (capability === "collaboration" && options.collaboration) continue;
+		if (backend && backend[capability] === void 0) return `backend "${backend.name}" lacks "${capability}"`;
+	}
+	for (const required of feature.requires ?? []) if (!ids.has(required)) return `requires "${required}"`;
+}
+/**
+* The comment mark is part of the document model (stored documents carry it), but only the `comments` feature brings it.
+* A composition that keeps `authors` (every rich one) yet has no `comments` (a viewer, a backend without collaboration,
+* `remove`) gets the mark through `authors`, inert there, so such documents still load. The catalog is the one place
+* that may couple the two features; each stays importable on its own.
+*/
+function withCommentMark(features) {
+	if (features.some((feature) => feature.id === "comments")) return [...features];
+	return features.map((feature) => feature.id !== "authors" ? feature : {
+		...feature,
+		schemaExtensions: () => [...feature.schemaExtensions?.() ?? [], CommentMark],
+		extensions: (ctx) => [...feature.extensions?.(ctx) ?? [], CommentMark]
+	});
+}
+/**
+* Composes an editor from three dimensions plus the backend's capabilities, over the UI bindings of a layer.
+*
+* The feature list is `content` + `interaction` (+ the AI features when `ai`) + `add`, minus `remove`. `core-content` is
+* always part of it and `core-ui` of every non-empty interaction list. Features that require a missing feature, or a
+* backend capability `options.backend` lacks, are dropped until the list is stable and reported in `omitted` (so
+* `ai: true` over a backend without `ai` installs no AI and says why). The catalog features keep their canonical order
+* (content, interaction, AI), host features follow in the order given; the result is validated by `defineEditor`.
+* Throws when an id of `content` is not a content feature, an id of `interaction` not an interaction feature, an id
+* names no catalog feature, `remove` names `core-content`, or a selected feature has no binding in `ui`.
+*/
+function composeEditor(ui, options) {
+	if (options.remove?.includes("core-content")) fail("\"core-content\" cannot be removed");
+	const removed = new Set(options.remove ?? []);
+	const catalog = /* @__PURE__ */ new Map();
+	const select = (ids, dimension) => {
+		for (const id of ids) {
+			if (removed.has(id) || catalog.has(id)) continue;
+			const feature = build(id, ui, options);
+			if (feature.dimension !== dimension) fail(`"${id}" is not ${dimension === "ai" ? "an AI" : `a${dimension === "interaction" ? "n" : ""} ${dimension}`} feature`);
+			catalog.set(id, feature);
+		}
+	};
+	const content = typeof options.content === "string" ? CONTENT[options.content] : options.content;
+	const interaction = typeof options.interaction === "string" ? INTERACTION[options.interaction] : options.interaction;
+	select(["core-content", ...content], "content");
+	select(interaction.length ? ["core-ui", ...interaction] : [], "interaction");
+	select(options.ai ? AI : [], "ai");
+	const all = [...[...catalog.values()].sort((a, b) => CANONICAL.indexOf(a.id) - CANONICAL.indexOf(b.id)), ...(options.add ?? []).filter((feature) => !removed.has(feature.id))];
+	const reasons = /* @__PURE__ */ new Map();
+	let alive = all;
+	for (;;) {
+		const ids = new Set(alive.map((feature) => feature.id));
+		const dropped = /* @__PURE__ */ new Map();
+		for (const feature of alive) {
+			const reason = unmet(feature, ids, options);
+			if (reason) dropped.set(feature.id, reason);
+		}
+		if (!dropped.size) break;
+		for (const [id, reason] of dropped) reasons.set(id, reason);
+		alive = alive.filter((feature) => !dropped.has(feature.id));
+	}
+	const preset = defineEditor({ features: withCommentMark(alive) });
+	const omitted = all.flatMap((feature) => reasons.has(feature.id) ? [{
+		id: feature.id,
+		reason: reasons.get(feature.id)
+	}] : []);
+	return Object.freeze({
+		...preset,
+		omitted: Object.freeze(omitted)
+	});
+}
+/**
+* The simple editor: `core-content` and `core-ui` (formatting, headings, lists, quotes, code, undo/redo). No backend, no AI,
+* no collaboration, and no ⌘K command palette (`coreUiFeature()` gets no `palette` component here, the framework-free
+* layer has none; the `SimpleEditor` components and the `composeEditor` of `/vue/advanced` and `/react/advanced` bind it).
+* Component-free (`ComposedEditor<never>`), so both the Vue and the React surface accept it.
+*/
+const simpleEditor = () => composeEditor({ "core-ui": coreUiFeature }, {
+	content: "basic",
+	interaction: "minimal",
+	ai: false
+});
+//#endregion
+export { AI, CONTENT, INTERACTION, composeEditor, simpleEditor };
+
+//# sourceMappingURL=compose.js.map

package/dist/presets/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","names":[],"sources":["../../src/presets/compose.ts"],"sourcesContent":["import type { EditorBackend } from '../core/backend'\nimport { coreContentFeature, coreUiFeature } from '../core/core-feature'\nimport { defineEditor } from '../core/define-editor'\nimport type { EditorFeature, EditorPreset } from '../core/feature'\nimport type { CommentsFeatureOptions } from '../features/comments/feature'\nimport { CommentMark } from '../features/comments/schema'\nimport type { CompositeFeatureOptions } from '../features/composites/feature'\nimport type { CompositeKind } from '../features/composites/kinds'\nimport { mentionsFeature } from '../features/mentions'\nimport { tablesFeature } from '../features/tables'\nimport { compositeMediaFeature } from '../integrations/composite-media'\n\n/** The id of a catalog feature (`CONTENT`, `INTERACTION`, `AI`) or of a host feature passed to `remove`. */\nexport type FeatureId = string\n\n/** How much document model the editor has: `basic` = `core-content`, `rich` = the full content catalog. */\nexport type ContentLevel = 'basic' | 'rich'\n\n/** How much editing UX the editor has: `minimal` = `core-ui`, `full` = every interaction feature. */\nexport type InteractionLevel = 'minimal' | 'full'\n\n/** The content features of each level, in canonical (schema) order. */\nexport const CONTENT: Record<ContentLevel, readonly FeatureId[]> = {\n  basic: ['core-content'],\n  rich: ['core-content', 'media', 'transcript', 'composites', 'mentions', 'authors', 'tables', 'composite-media'],\n}\n\n/** The interaction features of each level, in canonical order. */\nexport const INTERACTION: Record<InteractionLevel, readonly FeatureId[]> = {\n  minimal: ['core-ui'],\n  full: ['core-ui', 'collab', 'comments', 'block-ui', 'themes'],\n}\n\n/** The AI features (`ai: true`): the AI feature and the integrations that need it; each is installed when its `requires` are met. */\nexport const AI: readonly FeatureId[] = ['ai', 'composite-ai', 'transcript-ai']\n\n/** Canonical feature order: content, interaction, AI. The composed feature list, its schema order and its toolbar order follow it. */\nconst CANONICAL: readonly FeatureId[] = [...CONTENT.rich, ...INTERACTION.full, ...AI]\n\n/**\n * The features a UI layer binds, keyed by id; the other catalog features are framework-free and built here. The AI\n * features are bound too, although `composite-ai` and `transcript-ai` have no components: the layer owns every import of\n * `features/ai`, so a composition without `ai` binds none of them and its bundle holds no AI code. Each binding is a\n * factory, called only for a feature the composition selects (`themes` reads the current Vue app when built, so\n * unselected features are never built). `composites` receives the composition's `compositeKinds`, `comments` its\n * `comments` options. `core-ui` takes no parameter here: the framework-free `simpleEditor()` has no command palette;\n * a layer that has one (the `SimpleEditor` surfaces) builds `coreUiFeature({ palette })` itself.\n */\nexport interface UiBindings<C> {\n  'core-ui': () => EditorFeature<C>\n  'media': () => EditorFeature<C>\n  'transcript': () => EditorFeature<C>\n  'composites': (options: CompositeFeatureOptions) => EditorFeature<C>\n  'authors': () => EditorFeature<C>\n  'comments': (options: CommentsFeatureOptions) => EditorFeature<C>\n  'ai': () => EditorFeature<C>\n  'composite-ai': () => EditorFeature<C>\n  'transcript-ai': () => EditorFeature<C>\n  'collab': () => EditorFeature<C>\n  'block-ui': () => EditorFeature<C>\n  'themes': () => EditorFeature<C>\n}\n\n/** What `composeEditor` builds the editor from. */\nexport interface ComposeOptions<C> {\n  /** The document model: a level or the content feature ids to install (`core-content` is always installed). */\n  content: ContentLevel | readonly FeatureId[]\n  /** The editing UX: a level or the interaction feature ids (`core-ui` is installed with any non-empty list); `[]` = a viewer without any interaction feature. */\n  interaction: InteractionLevel | readonly FeatureId[]\n  /** Installs `ai` and every integration whose `requires` are met (composite-AI iff composites, transcript-AI iff transcript). */\n  ai: boolean\n  /** The backend the editor runs on: features needing a capability it lacks are omitted. Absent = nothing is pruned by capability. */\n  backend?: EditorBackend\n  /**\n   * The host supplies the collaboration session itself (the surface's `collaboration` prop, e.g. from its own Hocuspocus\n   * provider), so `collab` and `comments` need no `collaboration` capability from the backend. Only a backend that must\n   * open the collaboration (`useEditorDocument(id, { collaboration: true })`) has to offer it. Default `false`.\n   */\n  collaboration?: boolean\n  /** Host features, appended after the catalog in the given order. */\n  add?: readonly EditorFeature<C>[]\n  /** Features left out (catalog or host); features that require them are omitted as well. */\n  remove?: readonly FeatureId[]\n  /** The composite kinds („Bausteine“) offered in the editor (default: the built-in kinds); read once. */\n  compositeKinds?: readonly CompositeKind[]\n  /** Options of the comments feature, e.g. a host `model` (then comments need no `collab`). */\n  comments?: CommentsFeatureOptions\n}\n\n/** The composed preset and the features that were selected but dropped, in composition order, with the reason. */\nexport interface ComposedEditor<C> extends EditorPreset<C> {\n  readonly omitted: readonly { id: FeatureId, reason: string }[]\n}\n\nfunction fail(message: string): never {\n  throw new Error(`@ecsplico/editor: composeEditor: ${message}`)\n}\n\n/**\n * Builds the catalog feature `id`. A framework binding the composition needs but `ui` lacks fails here, naming it.\n * `ui` is partial on purpose: a host that never selects a feature (a viewer has no `block-ui`) binds only the rest, so\n * the bundle holds no code of the others.\n */\nfunction build<C>(id: FeatureId, ui: Partial<UiBindings<C>>, options: ComposeOptions<C>): EditorFeature<C> {\n  const bound = <K extends keyof UiBindings<C>>(key: K): UiBindings<C>[K] => ui[key] ?? fail(`no UI binding for feature \"${key}\"`)\n  switch (id) {\n    case 'core-content': return coreContentFeature()\n    case 'mentions': return mentionsFeature()\n    case 'tables': return tablesFeature()\n    case 'composite-media': return compositeMediaFeature()\n    case 'core-ui': return bound('core-ui')()\n    case 'composite-ai': return bound('composite-ai')()\n    case 'transcript-ai': return bound('transcript-ai')()\n    case 'media': return bound('media')()\n    case 'transcript': return bound('transcript')()\n    case 'composites': return bound('composites')(options.compositeKinds ? { kinds: options.compositeKinds } : {})\n    case 'authors': return bound('authors')()\n    case 'comments': return bound('comments')(options.comments ?? {})\n    case 'ai': return bound('ai')()\n    case 'collab': return bound('collab')()\n    case 'block-ui': return bound('block-ui')()\n    case 'themes': return bound('themes')()\n    default: return fail(`unknown catalog feature \"${id}\" (host features go in \\`add\\`)`)\n  }\n}\n\n/** Why `feature` cannot stay in a composition holding `ids` over `backend`, or `undefined`. A host session satisfies `collaboration`. */\nfunction unmet(feature: Pick<EditorFeature, 'backend' | 'requires'>, ids: ReadonlySet<FeatureId>, options: Pick<ComposeOptions<unknown>, 'backend' | 'collaboration'>): string | undefined {\n  const { backend } = options\n  for (const capability of feature.backend ?? []) {\n    if (capability === 'collaboration' && options.collaboration) continue\n    if (backend && backend[capability] === undefined) return `backend \"${backend.name}\" lacks \"${capability}\"`\n  }\n  for (const required of feature.requires ?? []) {\n    if (!ids.has(required)) return `requires \"${required}\"`\n  }\n  return undefined\n}\n\n/**\n * The comment mark is part of the document model (stored documents carry it), but only the `comments` feature brings it.\n * A composition that keeps `authors` (every rich one) yet has no `comments` (a viewer, a backend without collaboration,\n * `remove`) gets the mark through `authors`, inert there, so such documents still load. The catalog is the one place\n * that may couple the two features; each stays importable on its own.\n */\nfunction withCommentMark<C>(features: readonly EditorFeature<C>[]): EditorFeature<C>[] {\n  if (features.some(feature => feature.id === 'comments')) return [...features]\n  return features.map(feature => feature.id !== 'authors'\n    ? feature\n    : {\n        ...feature,\n        schemaExtensions: () => [...(feature.schemaExtensions?.() ?? []), CommentMark],\n        extensions: ctx => [...(feature.extensions?.(ctx) ?? []), CommentMark],\n      })\n}\n\n/**\n * Composes an editor from three dimensions plus the backend's capabilities, over the UI bindings of a layer.\n *\n * The feature list is `content` + `interaction` (+ the AI features when `ai`) + `add`, minus `remove`. `core-content` is\n * always part of it and `core-ui` of every non-empty interaction list. Features that require a missing feature, or a\n * backend capability `options.backend` lacks, are dropped until the list is stable and reported in `omitted` (so\n * `ai: true` over a backend without `ai` installs no AI and says why). The catalog features keep their canonical order\n * (content, interaction, AI), host features follow in the order given; the result is validated by `defineEditor`.\n * Throws when an id of `content` is not a content feature, an id of `interaction` not an interaction feature, an id\n * names no catalog feature, `remove` names `core-content`, or a selected feature has no binding in `ui`.\n */\nexport function composeEditor<C>(ui: Partial<UiBindings<C>>, options: ComposeOptions<C>): ComposedEditor<C> {\n  if (options.remove?.includes('core-content')) fail('\"core-content\" cannot be removed')\n  const removed = new Set(options.remove ?? [])\n  const catalog = new Map<FeatureId, EditorFeature<C>>()\n  const select = (ids: readonly FeatureId[], dimension: 'content' | 'interaction' | 'ai') => {\n    for (const id of ids) {\n      if (removed.has(id) || catalog.has(id)) continue\n      const feature = build(id, ui, options)\n      if (feature.dimension !== dimension) fail(`\"${id}\" is not ${dimension === 'ai' ? 'an AI' : `a${dimension === 'interaction' ? 'n' : ''} ${dimension}`} feature`)\n      catalog.set(id, feature)\n    }\n  }\n  const content = typeof options.content === 'string' ? CONTENT[options.content] : options.content\n  const interaction = typeof options.interaction === 'string' ? INTERACTION[options.interaction] : options.interaction\n  select(['core-content', ...content], 'content')\n  select(interaction.length ? ['core-ui', ...interaction] : [], 'interaction')\n  select(options.ai ? AI : [], 'ai')\n\n  const ordered = [...catalog.values()].sort((a, b) => CANONICAL.indexOf(a.id) - CANONICAL.indexOf(b.id))\n  const all: EditorFeature<C>[] = [...ordered, ...(options.add ?? []).filter(feature => !removed.has(feature.id))]\n\n  const reasons = new Map<FeatureId, string>()\n  let alive = all\n  for (;;) {\n    const ids = new Set(alive.map(feature => feature.id))\n    const dropped = new Map<FeatureId, string>()\n    for (const feature of alive) {\n      const reason = unmet(feature, ids, options)\n      if (reason) dropped.set(feature.id, reason)\n    }\n    if (!dropped.size) break\n    for (const [id, reason] of dropped) reasons.set(id, reason)\n    alive = alive.filter(feature => !dropped.has(feature.id))\n  }\n\n  const preset = defineEditor({ features: withCommentMark(alive) })\n  const omitted = all.flatMap(feature => reasons.has(feature.id) ? [{ id: feature.id, reason: reasons.get(feature.id)! }] : [])\n  return Object.freeze({ ...preset, omitted: Object.freeze(omitted) })\n}\n\n/**\n * The simple editor: `core-content` and `core-ui` (formatting, headings, lists, quotes, code, undo/redo). No backend, no AI,\n * no collaboration, and no ⌘K command palette (`coreUiFeature()` gets no `palette` component here, the framework-free\n * layer has none; the `SimpleEditor` components and the `composeEditor` of `/vue/advanced` and `/react/advanced` bind it).\n * Component-free (`ComposedEditor<never>`), so both the Vue and the React surface accept it.\n */\nexport const simpleEditor = (): ComposedEditor<never> => composeEditor<never>({ 'core-ui': coreUiFeature }, { content: 'basic', interaction: 'minimal', ai: false })\n"],"mappings":"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"}

package/dist/react/AdvancedEditor.d.ts

@@ -1,23 +1,23 @@
-import { EditorSurfaceHandle, EditorSurfaceProps } from "./EditorSurface.js";
-import { CompositeKind } from "../features/composites/kinds.js";
+import { ComposedEditorHandle, ComposedEditorProps } from "./composed-surface.js";
 //#region src/react/AdvancedEditor.d.ts
 /**
  * Props of the advanced editor: the surface's own (collaboration session or standalone `value`/`onChange`, metadata,
- * abilities, extensions, block actions, slash commands, `documentId`/`upload`, `editable`, `settingsUi`, the open
- * state of the sidebar and comments margin, `onReady` and the other callbacks) except the preset, which the advanced
- * editor owns, plus the composite kinds.
+ * abilities, extensions, block actions, commands, `documentId`, `editable`, `settingsUi`, the open state of the sidebar
+ * and comments margin, `onReady` and the other callbacks) except the preset, plus the composition: `content`,
+ * `interaction`, `ai`, `add`, `remove`, `backend` and the composite kinds. The defaults are the advanced editor's:
+ * `content: 'rich'`, `interaction: 'full'`, `ai: true`.
  */
-export interface AdvancedEditorProps extends Omit<EditorSurfaceProps, 'preset'> {
-  /** Composite kinds („Bausteine“) offered in the editor (default: `defaultCompositeKinds(t)`); read once at mount. */
-  compositeKinds?: readonly CompositeKind[];
-}
+export type AdvancedEditorProps = ComposedEditorProps;
 /**
- * The advanced editor on the React surface: `advancedEditor()` mounted through `EditorSurface`. The feature list is
- * fixed at mount like the kinds it is built from; hosts remount (`key`) to change either. Place `EditorToolbar`
- * (with the same `preset`: build it with `advancedEditor()` and pass it to both) and, with `settingsUi: 'external'`,
- * `EditorSettingsModal`/`EditorSettingsPanel` beside it; `useEditorUi(editor)` reaches the chrome of a ready editor.
- * Collaboration is active only when a `collaboration` session is passed; mount `Toaster` once for notices.
+ * The advanced editor on the React surface: `composeEditor({ content: 'rich', interaction: 'full', ai: true })` mounted
+ * through `EditorSurface`; every dimension is overridable by its prop, and the backend (default: the editor context's)
+ * prunes what it cannot serve. The ref's `preset` is the composed preset (`omitted` lists the dropped features). The
+ * composition is fixed at mount like the kinds it is built from; hosts remount (`key`) to change it. Place
+ * `EditorToolbar` and, with `settingsUi: 'external'`, `EditorSettingsModal`/`EditorSettingsPanel` beside it and give
+ * them the editor from `onReady`; `useEditorUi(editor)` reaches the chrome of a ready editor. Collaboration is active
+ * only when a `collaboration` session is passed; mount `Toaster` once for notices.
  */
-export declare const AdvancedEditor: import("react").ForwardRefExoticComponent<AdvancedEditorProps & import("react").RefAttributes<EditorSurfaceHandle>>;
+export declare const AdvancedEditor: import("react").ForwardRefExoticComponent<ComposedEditorProps & import("react").RefAttributes<ComposedEditorHandle>>;
 //#endregion
+export type { ComposedEditorHandle as AdvancedEditorHandle };
 //# sourceMappingURL=AdvancedEditor.d.ts.map