@ecsplico/editor 0.0.0-stage → 2.0.0

package/dist/server/collab.js

@@ -0,0 +1,187 @@
+import { assignBlockIds } from "../core/schema/block-ids.js";
+import { EMPTY_EDITOR_CONTENT } from "../core/schema/index.js";
+import { migrateLegacyContent } from "../features/composites/legacy.js";
+import { advancedSchemaExtensions } from "../schema/advanced.js";
+import { decodeCollabState, encodeCollabState, isStateStale } from "./collab-state.js";
+import { getSchema } from "@tiptap/core";
+import { prosemirrorToYDoc, prosemirrorToYXmlFragment, yDocToProsemirrorJSON, yXmlFragmentToProsemirror } from "@tiptap/y-tiptap";
+import * as Y from "yjs";
+import { Hocuspocus } from "@hocuspocus/server";
+//#region src/server/collab.ts
+/** Y.XmlFragment the TipTap Collaboration extension binds to (its default `field`). */
+const COLLAB_FIELD = "default";
+/** Close code of a connection whose client could not be authenticated (Hocuspocus' `Unauthorized`, HTTP 401 in websocket terms). */
+const UNAUTHORIZED = {
+	code: 4401,
+	reason: "Unauthorized"
+};
+/** Context key under which `handleConnection` hands the connection's socket closer to the `onAuthenticate` hook. */
+const REJECT = Symbol("collab.reject");
+/** ProseMirror document of stored JSON content: legacy nodes migrated, empty content replaced by the empty document, block IDs assigned. */
+function contentNode(schema, loaded) {
+	const content = migrateLegacyContent(loaded);
+	const node = schema.nodeFromJSON(content.type === "doc" && content.content?.length ? content : EMPTY_EDITOR_CONTENT);
+	return assignBlockIds(node) ?? node;
+}
+/** Hocuspocus answers a thrown error's `reason` as permission-denied. */
+const denied = (message, reason) => Object.assign(new Error(message), { reason });
+/**
+* The editor's collaboration server, independent of any web framework: Hocuspocus with the editor's hooks (seeding from
+* the adapter's JSON, versioned state, block-ID backfill, debounced `storeContent`/`storeState`) over `adapter`.
+* `/nuxt` mounts one in Nitro; any Node/Bun/Deno process can serve `handleConnection` on its own websocket transport.
+*/
+function createCollabServer(options) {
+	const { adapter } = options;
+	const authorize = (user, id) => options.hooks?.authorize ? options.hooks.authorize(user, id) : adapter.authorize?.(user, id);
+	const contentVersion = (id) => options.hooks?.contentVersion ? options.hooks.contentVersion(id) : adapter.contentVersion?.(id);
+	let schema;
+	const collabSchema = () => schema ??= getSchema([...advancedSchemaExtensions(), ...(options.schemaExtensions ?? adapter.schemaExtensions?.bind(adapter))?.() ?? []]);
+	/** Loaded documents deleted via `forgetDocument`; a store still pending for them must not write their Yjs state back. */
+	const forgotten = /* @__PURE__ */ new Set();
+	/** `contentVersion` the loaded document's content mirror had when it was last read or written; only tracked for adapters with `contentVersion`. */
+	const loadedVersions = /* @__PURE__ */ new Map();
+	/** Resolvers of `close()` waiting for the last document to unload. */
+	const idle = [];
+	let closed = false;
+	/** Merges content rewritten behind the editor's back into the open document and stores its state against `version`. */
+	async function mergeRewrite(id, document, version) {
+		const rewritten = await adapter.loadContent(id);
+		if (!rewritten) return;
+		prosemirrorToYXmlFragment(contentNode(collabSchema(), rewritten), document.getXmlFragment(COLLAB_FIELD));
+		loadedVersions.set(id, version);
+		await adapter.storeState(id, encodeCollabState({
+			version,
+			update: Y.encodeStateAsUpdate(document)
+		}));
+	}
+	/** Stored state of a document, `null` when there is none usable: it was written against another content version and is removed. */
+	async function loadCurrentState(id, liveVersion) {
+		const payload = await adapter.loadState(id);
+		if (!payload) return null;
+		const { version, update } = decodeCollabState(payload);
+		if (isStateStale(version, liveVersion)) {
+			await adapter.removeState(id);
+			return null;
+		}
+		return update;
+	}
+	const hocuspocus = new Hocuspocus({
+		...options.configuration,
+		async onAuthenticate({ context, token, requestHeaders, documentName, connectionConfig }) {
+			let user = context.user;
+			if (!user) user = await adapter.authenticate({
+				headers: requestHeaders,
+				...token && { token }
+			});
+			if (!user) {
+				const socketCloser = context[REJECT];
+				socketCloser?.();
+				throw denied("Unauthorized", "unauthorized");
+			}
+			const access = await authorize(user, documentName);
+			if (access === null) throw denied("Forbidden", "forbidden");
+			if (access?.readOnly) connectionConfig.readOnly = true;
+			return { user };
+		},
+		async onLoadDocument({ documentName }) {
+			const currentSchema = collabSchema();
+			const version = await contentVersion(documentName);
+			const stored = await loadCurrentState(documentName, version);
+			if (version !== void 0) loadedVersions.set(documentName, version);
+			const persist = (doc) => adapter.storeState(documentName, encodeCollabState({
+				version: version ?? null,
+				update: Y.encodeStateAsUpdate(doc)
+			}));
+			if (stored) {
+				const doc = new Y.Doc();
+				Y.applyUpdate(doc, stored);
+				const fragment = doc.getXmlFragment(COLLAB_FIELD);
+				if (!!fragment.createTreeWalker((node) => node instanceof Y.XmlElement && node.nodeName === "section").next().done) {
+					const withIds = assignBlockIds(yXmlFragmentToProsemirror(currentSchema, fragment));
+					if (withIds) {
+						prosemirrorToYXmlFragment(withIds, fragment);
+						await persist(doc);
+					}
+					return doc;
+				}
+			}
+			const loaded = await adapter.loadContent(documentName);
+			if (!loaded) throw new Error("Dokument nicht gefunden");
+			const seeded = prosemirrorToYDoc(contentNode(currentSchema, loaded), COLLAB_FIELD);
+			await persist(seeded);
+			return seeded;
+		},
+		async onStoreDocument({ documentName, document }) {
+			if (forgotten.has(documentName)) return;
+			const tracked = loadedVersions.get(documentName);
+			const current = tracked === void 0 ? void 0 : await contentVersion(documentName);
+			if (current !== void 0 && current !== tracked) {
+				await mergeRewrite(documentName, document, current);
+				return;
+			}
+			await adapter.storeContent(documentName, yDocToProsemirrorJSON(document, COLLAB_FIELD));
+			const version = await contentVersion(documentName);
+			if (version !== void 0) loadedVersions.set(documentName, version);
+			await adapter.storeState(documentName, encodeCollabState({
+				version: version ?? null,
+				update: Y.encodeStateAsUpdate(document)
+			}));
+		},
+		async afterUnloadDocument({ documentName }) {
+			forgotten.delete(documentName);
+			loadedVersions.delete(documentName);
+			if (hocuspocus.getDocumentsCount() === 0) idle.splice(0).forEach((resolve) => resolve());
+		}
+	});
+	return {
+		hocuspocus,
+		schema: collabSchema,
+		handleConnection(socket, request, context = {}) {
+			if (closed) throw new Error("tiptap-editor: der Collab-Server ist geschlossen");
+			const reject = () => void setTimeout(() => socket.close(UNAUTHORIZED.code, UNAUTHORIZED.reason), 0);
+			return hocuspocus.handleConnection(socket, request, {
+				...context,
+				[REJECT]: reject
+			});
+		},
+		async forgetDocument(id) {
+			const doc = hocuspocus.documents.get(id);
+			if (doc) {
+				forgotten.add(id);
+				doc.broadcastStateless("deleted");
+				hocuspocus.closeConnections(id);
+			}
+			await adapter.removeState(id);
+		},
+		liveContent(id) {
+			const doc = hocuspocus.documents.get(id);
+			return doc ? yDocToProsemirrorJSON(doc, COLLAB_FIELD) : null;
+		},
+		async contentChanged(id) {
+			const doc = hocuspocus.documents.get(id);
+			if (!doc || forgotten.has(id)) return;
+			const tracked = loadedVersions.get(id);
+			if (tracked === void 0) return;
+			const current = await contentVersion(id);
+			if (current === void 0 || current === tracked) return;
+			await mergeRewrite(id, doc, current);
+		},
+		stats: () => ({
+			connections: hocuspocus.getConnectionsCount(),
+			documents: hocuspocus.getDocumentsCount()
+		}),
+		async close() {
+			closed = true;
+			if (hocuspocus.getDocumentsCount() === 0) return;
+			await new Promise((resolve) => {
+				idle.push(resolve);
+				hocuspocus.closeConnections();
+				hocuspocus.flushPendingStores();
+			});
+		}
+	};
+}
+//#endregion
+export { COLLAB_FIELD, createCollabServer };
+
+//# sourceMappingURL=collab.js.map

package/dist/server/collab.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collab.js","names":[],"sources":["../../src/server/collab.ts"],"sourcesContent":["import { type Configuration, Hocuspocus, type WebSocketLike } from '@hocuspocus/server'\nimport { type AnyExtension, getSchema, type JSONContent } from '@tiptap/core'\nimport type { Schema } from '@tiptap/pm/model'\nimport { prosemirrorToYDoc, prosemirrorToYXmlFragment, yDocToProsemirrorJSON, yXmlFragmentToProsemirror } from '@tiptap/y-tiptap'\nimport * as Y from 'yjs'\nimport { assignBlockIds, EMPTY_EDITOR_CONTENT } from '../core/schema'\nimport { LEGACY_COMPOSITE_NODE, migrateLegacyContent } from '../features/composites/schema'\nimport { advancedSchemaExtensions } from '../schema/advanced'\nimport type { EditorAdapter } from './adapter'\nimport { decodeCollabState, encodeCollabState, isStateStale } from './collab-state'\n\n/** Y.XmlFragment the TipTap Collaboration extension binds to (its default `field`). */\nexport const COLLAB_FIELD = 'default'\n\n/** Close code of a connection whose client could not be authenticated (Hocuspocus' `Unauthorized`, HTTP 401 in websocket terms). */\nconst UNAUTHORIZED = { code: 4401, reason: 'Unauthorized' }\n\n/** Context key under which `handleConnection` hands the connection's socket closer to the `onAuthenticate` hook. */\nconst REJECT = Symbol('collab.reject')\n\nexport interface CollabServerOptions {\n  /** Storage and identity of the editor backend. */\n  adapter: EditorAdapter\n  /** Extensions of host-defined nodes and marks appended to `advancedSchemaExtensions()`; defaults to `adapter.schemaExtensions`. */\n  schemaExtensions?: () => AnyExtension[]\n  /** Per-document access and content versioning; each defaults to the adapter's method of the same name. */\n  hooks?: {\n    authorize?: NonNullable<EditorAdapter['authorize']>\n    contentVersion?: NonNullable<EditorAdapter['contentVersion']>\n  }\n  /** Further Hocuspocus configuration (`debounce`, `timeout`, `quiet`, …); the editor's hooks win over equally named ones. */\n  configuration?: Partial<Configuration>\n}\n\n/** One served websocket connection: feed it the socket's messages and its close event. */\nexport interface CollabConnection {\n  handleMessage(data: Uint8Array): void\n  handleClose(event?: CloseEvent): void\n}\n\nexport interface CollabServer {\n  /**\n   * The Hocuspocus instance of this server. The Yjs state (via the adapter's `loadState`/`storeState`) is the source of\n   * truth for content, the host's JSON content (via the adapter) is a mirror kept up to date on every store.\n   */\n  hocuspocus: Hocuspocus\n  /** Schema of the collab server: `advancedSchemaExtensions()` plus the host's extensions, built on first use. */\n  schema(): Schema\n  /**\n   * Serves one websocket connection (any transport: crossws, `ws`, Bun, Deno). The user is authenticated in Hocuspocus'\n   * `onAuthenticate` from the upgrade request's headers and the client's token, unless the transport already knows it\n   * and passes it as `context.user`. Wire `handleMessage` and `handleClose` of the returned connection to the socket's events.\n   */\n  handleConnection(socket: WebSocketLike, request: Request, context?: { user?: object }): CollabConnection\n  /** Tell connected clients the document is gone, disconnect them and drop the Yjs state. Call before removing the JSON. */\n  forgetDocument(id: string): Promise<void>\n  /** Current content of a document that is open in Hocuspocus (unsaved edits included), `null` when nobody has it open. */\n  liveContent(id: string): JSONContent | null\n  /**\n   * The host rewrote the content behind the editor's back (an agent wrote the file): merge it into the open document now,\n   * as a diff-update connected clients see as an ordinary edit. Without this the merge waits for the document's next store.\n   * No-op when nobody has the document open or the content version is unchanged; needs the adapter's `contentVersion`.\n   */\n  contentChanged(id: string): Promise<void>\n  /** Open collaboration connections and loaded documents of this server. */\n  stats(): { connections: number, documents: number }\n  /** Disconnect every client, write pending stores and wait until all documents are unloaded. The server accepts no connection afterwards. */\n  close(): Promise<void>\n}\n\n/** ProseMirror document of stored JSON content: legacy nodes migrated, empty content replaced by the empty document, block IDs assigned. */\nfunction contentNode(schema: Schema, loaded: JSONContent) {\n  const content = migrateLegacyContent(loaded)\n  const node = schema.nodeFromJSON(content.type === 'doc' && content.content?.length ? content : EMPTY_EDITOR_CONTENT)\n  return assignBlockIds(node) ?? node\n}\n\n/** Hocuspocus answers a thrown error's `reason` as permission-denied. */\nconst denied = (message: string, reason: string) => Object.assign(new Error(message), { reason })\n\n/**\n * The editor's collaboration server, independent of any web framework: Hocuspocus with the editor's hooks (seeding from\n * the adapter's JSON, versioned state, block-ID backfill, debounced `storeContent`/`storeState`) over `adapter`.\n * `/nuxt` mounts one in Nitro; any Node/Bun/Deno process can serve `handleConnection` on its own websocket transport.\n */\nexport function createCollabServer(options: CollabServerOptions): CollabServer {\n  const { adapter } = options\n  const authorize = (user: object, id: string) => options.hooks?.authorize ? options.hooks.authorize(user, id) : adapter.authorize?.(user, id)\n  const contentVersion = (id: string) => options.hooks?.contentVersion ? options.hooks.contentVersion(id) : adapter.contentVersion?.(id)\n\n  let schema: Schema | undefined\n  const collabSchema = () => schema ??= getSchema([...advancedSchemaExtensions(), ...((options.schemaExtensions ?? adapter.schemaExtensions?.bind(adapter))?.() ?? [])])\n\n  /** Loaded documents deleted via `forgetDocument`; a store still pending for them must not write their Yjs state back. */\n  const forgotten = new Set<string>()\n  /** `contentVersion` the loaded document's content mirror had when it was last read or written; only tracked for adapters with `contentVersion`. */\n  const loadedVersions = new Map<string, string | null>()\n  /** Resolvers of `close()` waiting for the last document to unload. */\n  const idle: (() => void)[] = []\n  let closed = false\n\n  /** Merges content rewritten behind the editor's back into the open document and stores its state against `version`. */\n  async function mergeRewrite(id: string, document: Y.Doc, version: string | null): Promise<void> {\n    const rewritten = await adapter.loadContent(id)\n    if (!rewritten) return // removed meanwhile: nothing to merge, nothing to mirror\n    // A diff-update: unchanged blocks keep their Yjs items, so connected clients see an ordinary edit and need no reload.\n    prosemirrorToYXmlFragment(contentNode(collabSchema(), rewritten), document.getXmlFragment(COLLAB_FIELD))\n    loadedVersions.set(id, version)\n    await adapter.storeState(id, encodeCollabState({ version, update: Y.encodeStateAsUpdate(document) }))\n  }\n\n  /** Stored state of a document, `null` when there is none usable: it was written against another content version and is removed. */\n  async function loadCurrentState(id: string, liveVersion: string | null | undefined): Promise<Uint8Array | null> {\n    const payload = await adapter.loadState(id)\n    if (!payload) return null\n    const { version, update } = decodeCollabState(payload)\n    if (isStateStale(version, liveVersion)) {\n      await adapter.removeState(id)\n      return null\n    }\n    return update\n  }\n\n  const hocuspocus = new Hocuspocus({\n    ...options.configuration,\n    async onAuthenticate({ context, token, requestHeaders, documentName, connectionConfig }) {\n      // The transport may know the user already; otherwise it comes from the upgrade request's headers or the client's token.\n      let user = context.user as object | null | undefined\n      if (!user) user = await adapter.authenticate({ headers: requestHeaders, ...(token && { token }) })\n      if (!user) {\n        // After the permission-denied answer Hocuspocus sends: close the socket, so a client without credentials does not linger.\n        const socketCloser = context[REJECT] as (() => void) | undefined\n        socketCloser?.()\n        throw denied('Unauthorized', 'unauthorized')\n      }\n      const access = await authorize(user, documentName)\n      // `undefined`: no authorize hook, every authenticated user may edit. `null`: rejected; the thrown error's `reason` is answered as permission-denied.\n      if (access === null) throw denied('Forbidden', 'forbidden')\n      if (access?.readOnly) connectionConfig.readOnly = true\n      return { user }\n    },\n    async onLoadDocument({ documentName }) {\n      const currentSchema = collabSchema()\n      // Read before the content: a change in between leaves an older version on the state, which only costs a re-seed.\n      const version = await contentVersion(documentName)\n      const stored = await loadCurrentState(documentName, version)\n      if (version !== undefined) loadedVersions.set(documentName, version)\n      const persist = (doc: Y.Doc) => adapter.storeState(documentName, encodeCollabState({ version: version ?? null, update: Y.encodeStateAsUpdate(doc) }))\n      if (stored) {\n        // Decoded into a scratch doc: Hocuspocus only gets it once it is known to be current.\n        const doc = new Y.Doc()\n        Y.applyUpdate(doc, stored)\n        const fragment = doc.getXmlFragment(COLLAB_FIELD)\n        // State from before the composite family holds node names the schema no longer knows (any depth): drop it and\n        // reseed below from the migrated JSON mirror, which also rewrites the stored state.\n        const legacy = !fragment.createTreeWalker(node => node instanceof Y.XmlElement && node.nodeName === LEGACY_COMPOSITE_NODE).next().done\n        if (!legacy) {\n          // Blocks without an ID (state from before block IDs): assign them here, before any client syncs, so clients\n          // never backfill concurrently. The diff-update only sets attributes; the content keeps its Yjs items.\n          const withIds = assignBlockIds(yXmlFragmentToProsemirror(currentSchema, fragment))\n          if (withIds) {\n            prosemirrorToYXmlFragment(withIds, fragment)\n            // Persist right away: a backfill after a restart would assign other IDs than clients already hold.\n            await persist(doc)\n          }\n          return doc\n        }\n      }\n      const loaded = await adapter.loadContent(documentName)\n      if (!loaded) throw new Error('Dokument nicht gefunden') // Hocuspocus closes the connection\n      // No usable Yjs state (new, legacy, stale or restored document): seed it from the stored JSON, with block IDs.\n      const seeded = prosemirrorToYDoc(contentNode(currentSchema, loaded), COLLAB_FIELD)\n      // Persist right away: re-seeding later would create new Yjs items that duplicate what clients still hold.\n      await persist(seeded)\n      return seeded\n    },\n    async onStoreDocument({ documentName, document }) {\n      if (forgotten.has(documentName)) return\n      const tracked = loadedVersions.get(documentName)\n      const current = tracked === undefined ? undefined : await contentVersion(documentName)\n      if (current !== undefined && current !== tracked) {\n        // The content was rewritten behind the editor's back: writing the Yjs content back would clobber the rewrite.\n        // Merge the rewrite into the open document instead and store the state against the new version.\n        await mergeRewrite(documentName, document, current)\n        return\n      }\n      await adapter.storeContent(documentName, yDocToProsemirrorJSON(document, COLLAB_FIELD))\n      // After the content: the write itself moves the version, and the state must carry the one it matches.\n      const version = await contentVersion(documentName)\n      if (version !== undefined) loadedVersions.set(documentName, version)\n      await adapter.storeState(documentName, encodeCollabState({ version: version ?? null, update: Y.encodeStateAsUpdate(document) }))\n    },\n    async afterUnloadDocument({ documentName }) {\n      forgotten.delete(documentName)\n      loadedVersions.delete(documentName)\n      if (hocuspocus.getDocumentsCount() === 0) idle.splice(0).forEach(resolve => resolve())\n    },\n  })\n\n  return {\n    hocuspocus,\n    schema: collabSchema,\n    handleConnection(socket, request, context = {}) {\n      if (closed) throw new Error('tiptap-editor: der Collab-Server ist geschlossen')\n      // Deferred: Hocuspocus answers permission-denied first, then the socket closes.\n      const reject = () => void setTimeout(() => socket.close(UNAUTHORIZED.code, UNAUTHORIZED.reason), 0)\n      return hocuspocus.handleConnection(socket, request, { ...context, [REJECT]: reject })\n    },\n    async forgetDocument(id) {\n      const doc = hocuspocus.documents.get(id)\n      if (doc) {\n        forgotten.add(id)\n        doc.broadcastStateless('deleted')\n        hocuspocus.closeConnections(id)\n      }\n      await adapter.removeState(id)\n    },\n    liveContent(id) {\n      const doc = hocuspocus.documents.get(id)\n      return doc ? yDocToProsemirrorJSON(doc, COLLAB_FIELD) as JSONContent : null\n    },\n    async contentChanged(id) {\n      const doc = hocuspocus.documents.get(id)\n      if (!doc || forgotten.has(id)) return\n      const tracked = loadedVersions.get(id)\n      if (tracked === undefined) return // no `contentVersion`: a rewrite cannot be told from the server's own writes\n      const current = await contentVersion(id)\n      if (current === undefined || current === tracked) return\n      await mergeRewrite(id, doc, current)\n    },\n    stats: () => ({ connections: hocuspocus.getConnectionsCount(), documents: hocuspocus.getDocumentsCount() }),\n    async close() {\n      closed = true\n      if (hocuspocus.getDocumentsCount() === 0) return\n      await new Promise<void>((resolve) => {\n        idle.push(resolve)\n        hocuspocus.closeConnections()\n        hocuspocus.flushPendingStores()\n      })\n    },\n  }\n}\n\nexport type { WebSocketLike }\n"],"mappings":"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"}

package/dist/server/errors.d.ts

@@ -0,0 +1,17 @@
+//#region src/server/errors.d.ts
+/**
+ * A request the server answers with an HTTP status: the handlers and the model utilities throw it instead of a
+ * framework error, so they run in any Node server. A transport maps `statusCode`/`statusMessage` (and `headers`, e.g.
+ * `Retry-After` of a 429) onto its response; the Nuxt routes hand it to Nitro's `createError`.
+ */
+export declare class HttpError extends Error {
+  readonly statusCode: number;
+  readonly statusMessage: string;
+  /** Response headers the answer needs (`Retry-After`). */
+  readonly headers: Readonly<Record<string, string>>;
+  /** Machine-readable detail (the validation issues of a 400). */
+  readonly data: unknown;
+  constructor(statusCode: number, statusMessage: string, headers?: Record<string, string>, data?: unknown);
+}
+//#endregion
+//# sourceMappingURL=errors.d.ts.map

package/dist/server/errors.js

@@ -0,0 +1,26 @@
+//#region src/server/errors.ts
+/**
+* A request the server answers with an HTTP status: the handlers and the model utilities throw it instead of a
+* framework error, so they run in any Node server. A transport maps `statusCode`/`statusMessage` (and `headers`, e.g.
+* `Retry-After` of a 429) onto its response; the Nuxt routes hand it to Nitro's `createError`.
+*/
+var HttpError = class extends Error {
+	statusCode;
+	statusMessage;
+	/** Response headers the answer needs (`Retry-After`). */
+	headers;
+	/** Machine-readable detail (the validation issues of a 400). */
+	data;
+	constructor(statusCode, statusMessage, headers = {}, data) {
+		super(statusMessage);
+		this.name = "HttpError";
+		this.statusCode = statusCode;
+		this.statusMessage = statusMessage;
+		this.headers = headers;
+		this.data = data;
+	}
+};
+//#endregion
+export { HttpError };
+
+//# sourceMappingURL=errors.js.map

package/dist/server/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/server/errors.ts"],"sourcesContent":["/**\n * A request the server answers with an HTTP status: the handlers and the model utilities throw it instead of a\n * framework error, so they run in any Node server. A transport maps `statusCode`/`statusMessage` (and `headers`, e.g.\n * `Retry-After` of a 429) onto its response; the Nuxt routes hand it to Nitro's `createError`.\n */\nexport class HttpError extends Error {\n  readonly statusCode: number\n  readonly statusMessage: string\n  /** Response headers the answer needs (`Retry-After`). */\n  readonly headers: Readonly<Record<string, string>>\n  /** Machine-readable detail (the validation issues of a 400). */\n  readonly data: unknown\n\n  constructor(statusCode: number, statusMessage: string, headers: Record<string, string> = {}, data?: unknown) {\n    super(statusMessage)\n    this.name = 'HttpError'\n    this.statusCode = statusCode\n    this.statusMessage = statusMessage\n    this.headers = headers\n    this.data = data\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,YAAb,cAA+B,MAAM;CACnC;CACA;;CAEA;;CAEA;CAEA,YAAY,YAAoB,eAAuB,UAAkC,CAAC,GAAG,MAAgB;EAC3G,MAAM,aAAa;EACnB,KAAK,OAAO;EACZ,KAAK,aAAa;EAClB,KAAK,gBAAgB;EACrB,KAAK,UAAU;EACf,KAAK,OAAO;CACd;AACF"}

package/dist/server/handlers/ai.d.ts

@@ -0,0 +1,223 @@
+import { AiHandlerContext, HandlerRequest, HandlerResponse } from "./context.js";
+import { z } from "zod";
+//#region src/server/handlers/ai.d.ts
+export declare const chatBodySchema: z.ZodObject<{
+  messages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    content: z.ZodString;
+    feedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      op: z.ZodString;
+      type: z.ZodEnum<{
+        update: "update";
+        delete: "delete";
+        add: "add";
+        convert: "convert";
+      }>;
+      target: z.ZodNullable<z.ZodString>;
+      outcome: z.ZodEnum<{
+        invalid: "invalid";
+        accepted: "accepted";
+        rejected: "rejected";
+        partial: "partial";
+        pending: "pending";
+        unchanged: "unchanged";
+        missing: "missing";
+        overlap: "overlap";
+        empty: "empty";
+        blocked: "blocked";
+      }>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"assistant">;
+    content: z.ZodString;
+    ops: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      op: z.ZodString;
+      type: z.ZodLiteral<"update">;
+      id: z.ZodString;
+      markdown: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      op: z.ZodString;
+      type: z.ZodLiteral<"delete">;
+      id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      op: z.ZodString;
+      type: z.ZodLiteral<"add">;
+      afterId: z.ZodNullable<z.ZodString>;
+      markdown: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      op: z.ZodString;
+      type: z.ZodLiteral<"convert">;
+      id: z.ZodString;
+      to: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    dropped: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>], "role">>;
+  document: z.ZodString;
+  scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  nextOp: z.ZodDefault<z.ZodNumber>;
+  model: z.ZodUnion<readonly [z.ZodObject<{
+    preset: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    endpoint: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodString;
+  }, z.core.$strip>]>;
+  kinds: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      type: z.ZodEnum<{
+        number: "number";
+        date: "date";
+        text: "text";
+        select: "select";
+        textarea: "textarea";
+      }>;
+      options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodString;
+    syntax: z.ZodString;
+    example: z.ZodString;
+  }, z.core.$strip>>>;
+  targets: z.ZodArray<z.ZodString>;
+  structure: z.ZodEnum<{
+    flat: "flat";
+    composite: "composite";
+  }>;
+}, z.core.$strip>;
+/**
+ * Document chat: answers the last message of `messages` about `document`, or proposes edit operations through the
+ * `edit_document` tool. Operations pointing to IDs that are unknown or outside `scope`, or converting into a type not in
+ * `targets`, make the model retry (at most `AGENT_LIMITS.retries` times); what is still invalid then, or left out by a
+ * corrected list, is dropped. The system prompt describes the editor's block model from `kinds`, `blocks` and `targets`. SSE like
+ * `/api/ai/generate`: `delta` (text), `ops` (`{ ops: AgentOp[], dropped: AgentOpProblem[], retries: number }`, once,
+ * before `done`), `done`, `error`.
+ */
+export declare function chatPost(ctx: AiHandlerContext, request: HandlerRequest): Promise<HandlerResponse>;
+/** Body schema of `completePost`. */
+export declare const completeBodySchema: z.ZodObject<{
+  before: z.ZodString;
+  model: z.ZodUnion<readonly [z.ZodObject<{
+    preset: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    endpoint: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodString;
+  }, z.core.$strip>]>;
+}, z.core.$strip>;
+/** Short inline continuation (ghost text) of the text before the caret. Plain JSON: `{ text }`, empty when nothing fits. */
+export declare function completePost(ctx: AiHandlerContext, request: HandlerRequest): Promise<HandlerResponse>;
+/** Body schema of `generatePost`. */
+export declare const generateBodySchema: z.ZodObject<{
+  task: z.ZodEnum<{
+    generate: "generate";
+    custom: "custom";
+    continue: "continue";
+    reformulate: "reformulate";
+    "transcript-summary": "transcript-summary";
+    "transcript-minutes": "transcript-minutes";
+    "transcript-action-items": "transcript-action-items";
+    fix: "fix";
+    shorter: "shorter";
+    formal: "formal";
+    casual: "casual";
+    translate: "translate";
+    summarize: "summarize";
+    "fill-block": "fill-block";
+  }>;
+  prompt: z.ZodDefault<z.ZodString>;
+  selection: z.ZodDefault<z.ZodString>;
+  context: z.ZodDefault<z.ZodString>;
+  language: z.ZodOptional<z.ZodEnum<{
+    Deutsch: "Deutsch";
+    Englisch: "Englisch";
+    Französisch: "Französisch";
+    Spanisch: "Spanisch";
+    Italienisch: "Italienisch";
+  }>>;
+  blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodString;
+    syntax: z.ZodString;
+    example: z.ZodString;
+  }, z.core.$strip>>>;
+  block: z.ZodOptional<z.ZodObject<{
+    kind: z.ZodObject<{
+      id: z.ZodString;
+      label: z.ZodString;
+      purpose: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    path: z.ZodArray<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+      label: z.ZodString;
+      value: z.ZodString;
+    }, z.core.$strip>>;
+    instructions: z.ZodString;
+    skeleton: z.ZodString;
+    body: z.ZodString;
+    data: z.ZodArray<z.ZodObject<{
+      label: z.ZodString;
+      text: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  model: z.ZodUnion<readonly [z.ZodObject<{
+    preset: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    endpoint: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodString;
+  }, z.core.$strip>]>;
+}, z.core.$strip>;
+/** Streams one text task (rewrite, translate, generate, …) as SSE: `delta` (`{ text }`), `done`, `error` (`{ message }`). */
+export declare function generatePost(ctx: AiHandlerContext, request: HandlerRequest): Promise<HandlerResponse>;
+/**
+ * The models the client may choose from (without keys) — the adapter's `listModels` for the user, else the
+ * server-defined presets — and the default preset id per model slot, for the client's model profiles. Requires an
+ * authenticated user via the adapter; not rate limited, since it calls no model.
+ */
+export declare function modelsGet(ctx: AiHandlerContext, request: HandlerRequest): Promise<HandlerResponse>;
+/** Body schema of `transcribePost`. */
+export declare const transcribeBodySchema: z.ZodObject<{
+  documentId: z.ZodString;
+  name: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Transcribes a stored audio/video asset through the OpenAI-compatible `<endpoint>/audio/transcriptions` configured as
+ * the AI `transcription`. Plain JSON: `{ text }`. 501 while no endpoint is configured.
+ */
+export declare function transcribePost(ctx: AiHandlerContext, request: HandlerRequest): Promise<HandlerResponse>;
+/** Body schema of `transcriptCleanupPost`. */
+export declare const transcriptCleanupBodySchema: z.ZodObject<{
+  segments: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    speaker: z.ZodString;
+    text: z.ZodString;
+  }, z.core.$strip>>;
+  model: z.ZodUnion<readonly [z.ZodObject<{
+    preset: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    endpoint: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodString;
+  }, z.core.$strip>]>;
+}, z.core.$strip>;
+/**
+ * Cleans transcript segments (filler words, punctuation, casing, fragmented sentences) without touching speakers or
+ * order: the model only returns a new text per segment ID. Plain JSON: `{ cleaned, failed }`.
+ */
+export declare function transcriptCleanupPost(ctx: AiHandlerContext, request: HandlerRequest): Promise<HandlerResponse>;
+//#endregion
+//# sourceMappingURL=ai.d.ts.map