@ecsplico/editor 0.0.0-stage → 1.0.0

package/dist/react/ui/tooltip.js

@@ -0,0 +1,37 @@
+import { cn } from "./utils.js";
+import "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Tooltip } from "radix-ui";
+//#region src/react/ui/tooltip.tsx
+function TooltipProvider({ delayDuration = 0, ...props }) {
+	return /* @__PURE__ */ jsx(Tooltip.Provider, {
+		"data-slot": "tooltip-provider",
+		delayDuration,
+		...props
+	});
+}
+function Tooltip$1({ ...props }) {
+	return /* @__PURE__ */ jsx(Tooltip.Root, {
+		"data-slot": "tooltip",
+		...props
+	});
+}
+function TooltipTrigger({ ...props }) {
+	return /* @__PURE__ */ jsx(Tooltip.Trigger, {
+		"data-slot": "tooltip-trigger",
+		...props
+	});
+}
+function TooltipContent({ className, sideOffset = 0, children, ...props }) {
+	return /* @__PURE__ */ jsx(Tooltip.Portal, { children: /* @__PURE__ */ jsxs(Tooltip.Content, {
+		"data-slot": "tooltip-content",
+		sideOffset,
+		className: cn("z-50 inline-flex w-fit max-w-xs origin-(--radix-tooltip-content-transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95", className),
+		...props,
+		children: [children, /* @__PURE__ */ jsx(Tooltip.Arrow, { className: "z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground" })]
+	}) });
+}
+//#endregion
+export { Tooltip$1 as Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };
+
+//# sourceMappingURL=tooltip.js.map

package/dist/react/ui/tooltip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.js","names":["TooltipPrimitive","Tooltip"],"sources":["../../../src/react/ui/tooltip.tsx"],"sourcesContent":["import * as React from \"react\"\nimport { cn } from \"./utils\"\nimport { Tooltip as TooltipPrimitive } from \"radix-ui\"\n\nfunction TooltipProvider({\n  delayDuration = 0,\n  ...props\n}: React.ComponentProps<typeof TooltipPrimitive.Provider>) {\n  return (\n    <TooltipPrimitive.Provider\n      data-slot=\"tooltip-provider\"\n      delayDuration={delayDuration}\n      {...props}\n    />\n  )\n}\n\nfunction Tooltip({\n  ...props\n}: React.ComponentProps<typeof TooltipPrimitive.Root>) {\n  return <TooltipPrimitive.Root data-slot=\"tooltip\" {...props} />\n}\n\nfunction TooltipTrigger({\n  ...props\n}: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {\n  return <TooltipPrimitive.Trigger data-slot=\"tooltip-trigger\" {...props} />\n}\n\nfunction TooltipContent({\n  className,\n  sideOffset = 0,\n  children,\n  ...props\n}: React.ComponentProps<typeof TooltipPrimitive.Content>) {\n  return (\n    <TooltipPrimitive.Portal>\n      <TooltipPrimitive.Content\n        data-slot=\"tooltip-content\"\n        sideOffset={sideOffset}\n        className={cn(\n          \"z-50 inline-flex w-fit max-w-xs origin-(--radix-tooltip-content-transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95\",\n          className\n        )}\n        {...props}\n      >\n        {children}\n        <TooltipPrimitive.Arrow className=\"z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground\" />\n      </TooltipPrimitive.Content>\n    </TooltipPrimitive.Portal>\n  )\n}\n\nexport { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger }\n"],"mappings":";;;;;AAIA,SAAS,gBAAgB,EACvB,gBAAgB,GAChB,GAAG,SACsD;CACzD,OACE,oBAACA,QAAiB,UAAlB;EACE,aAAU;EACK;EACf,GAAI;CACL,CAAA;AAEL;AAEA,SAASC,UAAQ,EACf,GAAG,SACkD;CACrD,OAAO,oBAACD,QAAiB,MAAlB;EAAuB,aAAU;EAAU,GAAI;CAAQ,CAAA;AAChE;AAEA,SAAS,eAAe,EACtB,GAAG,SACqD;CACxD,OAAO,oBAACA,QAAiB,SAAlB;EAA0B,aAAU;EAAkB,GAAI;CAAQ,CAAA;AAC3E;AAEA,SAAS,eAAe,EACtB,WACA,aAAa,GACb,UACA,GAAG,SACqD;CACxD,OACE,oBAACA,QAAiB,QAAlB,EAAA,UACE,qBAACA,QAAiB,SAAlB;EACE,aAAU;EACE;EACZ,WAAW,GACT,8rBACA,SACF;EACA,GAAI;EAPN,UAAA,CASG,UACD,oBAACA,QAAiB,OAAlB,EAAwB,WAAU,qGAAsG,CAAA,CAChH;CACH,CAAA,EAAA,CAAA;AAE7B"}

package/dist/react/ui/utils.d.ts

@@ -0,0 +1,5 @@
+import { ClassValue } from "clsx";
+//#region src/react/ui/utils.d.ts
+export declare function cn(...inputs: ClassValue[]): string;
+//#endregion
+//# sourceMappingURL=utils.d.ts.map

package/dist/react/ui/utils.js

@@ -0,0 +1,10 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+//#region src/react/ui/utils.ts
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+//#endregion
+export { cn };
+
+//# sourceMappingURL=utils.js.map

package/dist/react/ui/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/react/ui/utils.ts"],"sourcesContent":["import { type ClassValue, clsx } from 'clsx'\nimport { twMerge } from 'tailwind-merge'\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs))\n}\n"],"mappings":";;;AAGA,SAAgB,GAAG,GAAG,QAAsB;CAC1C,OAAO,QAAQ,KAAK,MAAM,CAAC;AAC7B"}

package/dist/react/use-editor-i18n.d.ts

@@ -0,0 +1,12 @@
+import { Locale, Translate } from "../i18n/index.js";
+//#region src/react/use-editor-i18n.d.ts
+/**
+ * The app's UI language and translator (`createEditorContext({ locale, messages })`): `t('toolbar.bold')`. The
+ * language is fixed for the life of the context, so both values are stable across renders.
+ */
+export declare function useEditorI18n(): {
+  t: Translate;
+  locale: Locale;
+};
+//#endregion
+//# sourceMappingURL=use-editor-i18n.d.ts.map

package/dist/react/use-editor-i18n.js

@@ -0,0 +1,17 @@
+import { useEditorContext } from "./context.js";
+//#region src/react/use-editor-i18n.ts
+/**
+* The app's UI language and translator (`createEditorContext({ locale, messages })`): `t('toolbar.bold')`. The
+* language is fixed for the life of the context, so both values are stable across renders.
+*/
+function useEditorI18n() {
+	const { t, locale } = useEditorContext();
+	return {
+		t,
+		locale
+	};
+}
+//#endregion
+export { useEditorI18n };
+
+//# sourceMappingURL=use-editor-i18n.js.map

package/dist/react/use-editor-i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-editor-i18n.js","names":[],"sources":["../../src/react/use-editor-i18n.ts"],"sourcesContent":["import type { Locale, Translate } from '../i18n'\nimport { useEditorContext } from './context'\n\n/**\n * The app's UI language and translator (`createEditorContext({ locale, messages })`): `t('toolbar.bold')`. The\n * language is fixed for the life of the context, so both values are stable across renders.\n */\nexport function useEditorI18n(): { t: Translate, locale: Locale } {\n  const { t, locale } = useEditorContext()\n  return { t, locale }\n}\n"],"mappings":";;;;;;AAOA,SAAgB,gBAAkD;CAChE,MAAM,EAAE,GAAG,WAAW,iBAAiB;CACvC,OAAO;EAAE;EAAG;CAAO;AACrB"}

package/dist/react/use-notifier.d.ts

@@ -0,0 +1,11 @@
+import { Notifier } from "../core/notify.js";
+import { Editor } from "@tiptap/core";
+//#region src/react/use-notifier.d.ts
+/**
+ * The notifier of `editor`'s surface (its toasts), else the app context's (see `notifierOf`): what
+ * `createEditorContext({ notify })` of the host receives. Stable across renders and resolved when a notice is shown,
+ * so a request that finishes after an await still reaches the current surface.
+ */
+export declare function useNotifier(editor?: Editor): Notifier;
+//#endregion
+//# sourceMappingURL=use-notifier.d.ts.map

package/dist/react/use-notifier.js

@@ -0,0 +1,25 @@
+import { notifierOf } from "../core/editor-ui.js";
+import { useEditorContext } from "./context.js";
+import { useMemo, useRef } from "react";
+//#region src/react/use-notifier.ts
+/**
+* The notifier of `editor`'s surface (its toasts), else the app context's (see `notifierOf`): what
+* `createEditorContext({ notify })` of the host receives. Stable across renders and resolved when a notice is shown,
+* so a request that finishes after an await still reaches the current surface.
+*/
+function useNotifier(editor) {
+	const app = useEditorContext();
+	const latest = useRef({
+		app,
+		editor
+	});
+	latest.current = {
+		app,
+		editor
+	};
+	return useMemo(() => notifierOf(() => latest.current.editor, () => latest.current.app), []);
+}
+//#endregion
+export { useNotifier };
+
+//# sourceMappingURL=use-notifier.js.map

package/dist/react/use-notifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notifier.js","names":[],"sources":["../../src/react/use-notifier.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport { useMemo, useRef } from 'react'\nimport { notifierOf } from '../core/editor-ui'\nimport type { Notifier } from '../core/notify'\nimport { useEditorContext } from './context'\n\n/**\n * The notifier of `editor`'s surface (its toasts), else the app context's (see `notifierOf`): what\n * `createEditorContext({ notify })` of the host receives. Stable across renders and resolved when a notice is shown,\n * so a request that finishes after an await still reaches the current surface.\n */\nexport function useNotifier(editor?: Editor): Notifier {\n  const app = useEditorContext()\n  const latest = useRef({ app, editor })\n  latest.current = { app, editor }\n  return useMemo(() => notifierOf(() => latest.current.editor, () => latest.current.app), [])\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,YAAY,QAA2B;CACrD,MAAM,MAAM,iBAAiB;CAC7B,MAAM,SAAS,OAAO;EAAE;EAAK;CAAO,CAAC;CACrC,OAAO,UAAU;EAAE;EAAK;CAAO;CAC/B,OAAO,cAAc,iBAAiB,OAAO,QAAQ,cAAc,OAAO,QAAQ,GAAG,GAAG,CAAC,CAAC;AAC5F"}

package/dist/react/use-store.d.ts

@@ -0,0 +1,6 @@
+import { ReadonlyStore } from "../core/store.js";
+//#region src/react/use-store.d.ts
+/** The current value of `store`; the component re-renders when it changes. */
+export declare function useStore<T>(store: ReadonlyStore<T>): T;
+//#endregion
+//# sourceMappingURL=use-store.d.ts.map

package/dist/react/use-store.js

@@ -0,0 +1,10 @@
+import { useSyncExternalStore } from "react";
+//#region src/react/use-store.ts
+/** The current value of `store`; the component re-renders when it changes. */
+function useStore(store) {
+	return useSyncExternalStore(store.subscribe, store.get, store.get);
+}
+//#endregion
+export { useStore };
+
+//# sourceMappingURL=use-store.js.map

package/dist/react/use-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-store.js","names":[],"sources":["../../src/react/use-store.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react'\nimport type { ReadonlyStore } from '../core/store'\n\n/** The current value of `store`; the component re-renders when it changes. */\nexport function useStore<T>(store: ReadonlyStore<T>): T {\n  return useSyncExternalStore(store.subscribe, store.get, store.get)\n}\n"],"mappings":";;;AAIA,SAAgB,SAAY,OAA4B;CACtD,OAAO,qBAAqB,MAAM,WAAW,MAAM,KAAK,MAAM,GAAG;AACnE"}

package/dist/schema/advanced.d.ts

@@ -0,0 +1,14 @@
+import { AnyExtension } from "@tiptap/core";
+//#region src/schema/advanced.d.ts
+/**
+ * The Vue-free schema of the advanced editor, free of node views, UI and collaboration runtime: the server builds the
+ * same schema with `getSchema(advancedSchemaExtensions())` to convert between TipTap JSON and Yjs. The order is the
+ * order of the client's schema-bearing extensions: StarterKit/StrikeX, the generic node flags, the opaque fence, media (image, audio,
+ * video, file), transcript, the composite family, mentions/tags, the author and comment marks, the GFM table and task-list
+ * nodes (for hosts whose preset adds `tablesFeature()`; the advanced preset itself has none) and last `BlockId`, which
+ * adds the `id` attribute to every block type (its ID-assigning plugins only run in an editor). `undoRedo: false`:
+ * under collaboration the Collaboration extension provides the (per-user) undo manager.
+ */
+export declare const advancedSchemaExtensions: () => AnyExtension[];
+//#endregion
+//# sourceMappingURL=advanced.d.ts.map

package/dist/schema/advanced.js

@@ -0,0 +1,43 @@
+import { BlockId } from "../core/schema/block-ids.js";
+import { NodeFlags } from "../core/schema/node-flags.js";
+import { OpaqueFence } from "../core/schema/opaque-fence.js";
+import { StrikeX } from "../core/schema/strike.js";
+import { mentionsSchemaExtensions } from "../features/mentions/schema.js";
+import { compositeSchemaExtensions } from "../features/composites/schema.js";
+import { mediaSchemaExtensions } from "../features/media/schema.js";
+import { authorsSchemaExtensions } from "../features/authors/schema.js";
+import { commentsSchemaExtensions } from "../features/comments/schema.js";
+import { tablesSchemaExtensions } from "../features/tables/schema.js";
+import { transcriptSchemaExtensions } from "../features/transcript/schema.js";
+import StarterKit from "@tiptap/starter-kit";
+//#region src/schema/advanced.ts
+/**
+* The Vue-free schema of the advanced editor, free of node views, UI and collaboration runtime: the server builds the
+* same schema with `getSchema(advancedSchemaExtensions())` to convert between TipTap JSON and Yjs. The order is the
+* order of the client's schema-bearing extensions: StarterKit/StrikeX, the generic node flags, the opaque fence, media (image, audio,
+* video, file), transcript, the composite family, mentions/tags, the author and comment marks, the GFM table and task-list
+* nodes (for hosts whose preset adds `tablesFeature()`; the advanced preset itself has none) and last `BlockId`, which
+* adds the `id` attribute to every block type (its ID-assigning plugins only run in an editor). `undoRedo: false`:
+* under collaboration the Collaboration extension provides the (per-user) undo manager.
+*/
+const advancedSchemaExtensions = () => [
+	StarterKit.configure({
+		strike: false,
+		undoRedo: false
+	}),
+	StrikeX,
+	NodeFlags,
+	OpaqueFence,
+	...mediaSchemaExtensions(),
+	...transcriptSchemaExtensions(),
+	...compositeSchemaExtensions(),
+	...mentionsSchemaExtensions(),
+	...authorsSchemaExtensions(),
+	...commentsSchemaExtensions(),
+	...tablesSchemaExtensions(),
+	BlockId
+];
+//#endregion
+export { advancedSchemaExtensions };
+
+//# sourceMappingURL=advanced.js.map

package/dist/schema/advanced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.js","names":[],"sources":["../../src/schema/advanced.ts"],"sourcesContent":["import type { AnyExtension } from '@tiptap/core'\nimport StarterKit from '@tiptap/starter-kit'\nimport { BlockId, NodeFlags, OpaqueFence, StrikeX } from '../core/schema'\nimport { authorsSchemaExtensions } from '../features/authors/schema'\nimport { commentsSchemaExtensions } from '../features/comments/schema'\nimport { compositeSchemaExtensions } from '../features/composites/schema'\nimport { mediaSchemaExtensions } from '../features/media/schema'\nimport { mentionsSchemaExtensions } from '../features/mentions/schema'\nimport { tablesSchemaExtensions } from '../features/tables/schema'\nimport { transcriptSchemaExtensions } from '../features/transcript/schema'\n\n/**\n * The Vue-free schema of the advanced editor, free of node views, UI and collaboration runtime: the server builds the\n * same schema with `getSchema(advancedSchemaExtensions())` to convert between TipTap JSON and Yjs. The order is the\n * order of the client's schema-bearing extensions: StarterKit/StrikeX, the generic node flags, the opaque fence, media (image, audio,\n * video, file), transcript, the composite family, mentions/tags, the author and comment marks, the GFM table and task-list\n * nodes (for hosts whose preset adds `tablesFeature()`; the advanced preset itself has none) and last `BlockId`, which\n * adds the `id` attribute to every block type (its ID-assigning plugins only run in an editor). `undoRedo: false`:\n * under collaboration the Collaboration extension provides the (per-user) undo manager.\n */\nexport const advancedSchemaExtensions = (): AnyExtension[] => [\n  StarterKit.configure({ strike: false, undoRedo: false }),\n  StrikeX,\n  NodeFlags,\n  OpaqueFence,\n  ...mediaSchemaExtensions(),\n  ...transcriptSchemaExtensions(),\n  ...compositeSchemaExtensions(),\n  ...mentionsSchemaExtensions(),\n  ...authorsSchemaExtensions(),\n  ...commentsSchemaExtensions(),\n  ...tablesSchemaExtensions(),\n  BlockId,\n]\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,iCAAiD;CAC5D,WAAW,UAAU;EAAE,QAAQ;EAAO,UAAU;CAAM,CAAC;CACvD;CACA;CACA;CACA,GAAG,sBAAsB;CACzB,GAAG,2BAA2B;CAC9B,GAAG,0BAA0B;CAC7B,GAAG,yBAAyB;CAC5B,GAAG,wBAAwB;CAC3B,GAAG,yBAAyB;CAC5B,GAAG,uBAAuB;CAC1B;AACF"}

package/dist/schema/simple.d.ts

@@ -0,0 +1,10 @@
+import { AnyExtension } from "@tiptap/core";
+//#region src/schema/simple.d.ts
+/**
+ * The Vue-free schema of the simple editor: the core nodes (see `coreSchemaExtensions`) and the GFM table and task-list
+ * nodes (`tablesSchemaExtensions`), so a server accepts documents of an editor with `tablesFeature()`. Servers and
+ * validators build the schema from it with `getSchema(simpleSchemaExtensions())`.
+ */
+export declare const simpleSchemaExtensions: () => AnyExtension[];
+//#endregion
+//# sourceMappingURL=simple.d.ts.map

package/dist/schema/simple.js

@@ -0,0 +1,13 @@
+import { coreSchemaExtensions } from "../core/schema/index.js";
+import { tablesSchemaExtensions } from "../features/tables/schema.js";
+//#region src/schema/simple.ts
+/**
+* The Vue-free schema of the simple editor: the core nodes (see `coreSchemaExtensions`) and the GFM table and task-list
+* nodes (`tablesSchemaExtensions`), so a server accepts documents of an editor with `tablesFeature()`. Servers and
+* validators build the schema from it with `getSchema(simpleSchemaExtensions())`.
+*/
+const simpleSchemaExtensions = () => [...coreSchemaExtensions(), ...tablesSchemaExtensions()];
+//#endregion
+export { simpleSchemaExtensions };
+
+//# sourceMappingURL=simple.js.map

package/dist/schema/simple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.js","names":[],"sources":["../../src/schema/simple.ts"],"sourcesContent":["import type { AnyExtension } from '@tiptap/core'\nimport { coreSchemaExtensions } from '../core/schema'\nimport { tablesSchemaExtensions } from '../features/tables/schema'\n\n/**\n * The Vue-free schema of the simple editor: the core nodes (see `coreSchemaExtensions`) and the GFM table and task-list\n * nodes (`tablesSchemaExtensions`), so a server accepts documents of an editor with `tablesFeature()`. Servers and\n * validators build the schema from it with `getSchema(simpleSchemaExtensions())`.\n */\nexport const simpleSchemaExtensions = (): AnyExtension[] => [...coreSchemaExtensions(), ...tablesSchemaExtensions()]\n"],"mappings":";;;;;;;;AASA,MAAa,+BAA+C,CAAC,GAAG,qBAAqB,GAAG,GAAG,uBAAuB,CAAC"}

package/dist/server/adapter.d.ts

@@ -0,0 +1,101 @@
+import { EditorSettings } from "../settings/index.js";
+import { ModelProfile, ModelRef } from "../features/ai/protocol/models.js";
+import "../features/ai/protocol/index.js";
+import { AssetRecord } from "../features/media/assets.js";
+import "../features/media/schema.js";
+import { MentionUser } from "../features/mentions/mention.js";
+import "../features/mentions/schema.js";
+import { ThemeRecord } from "../features/themes/schema.js";
+import { AnyExtension, JSONContent } from "@tiptap/core";
+import { LanguageModel } from "ai";
+//#region src/server/adapter.d.ts
+/** What `EditorAdapter.authenticate` gets: the headers of the request (the websocket upgrade for collaboration) and the connection's `token`. */
+export interface AuthenticateRequest {
+  headers: Headers;
+  /** The collaboration client's token (`HocuspocusProvider` `token`, sent right after the socket opened); absent for plain HTTP requests and token-less clients. */
+  token?: string;
+}
+export interface EditorAdapter {
+  /**
+   * The user behind a request, `null` = not authenticated (HTTP routes answer 401). Collaboration: called in Hocuspocus
+   * `onAuthenticate` with the upgrade request's `headers` and the client's `token` (`undefined` when it sent none, so cookie
+   * hosts keep working and bearer-only hosts read `token`); `null` closes the connection with 4401. With the Nuxt module
+   * option `collab.authenticateUpgrade` it runs once at the upgrade with the `headers` only and `null` refuses the upgrade
+   * with HTTP 401. The value becomes the connection context's `user`.
+   */
+  authenticate(request: AuthenticateRequest): Promise<object | null>;
+  /**
+   * Per-document access for the collaboration websocket, called in Hocuspocus `onAuthenticate` (right after `authenticate`) with the user.
+   * `null` rejects the connection; `{ readOnly: true }` lets it sync but applies none of its edits. Omit it to let every
+   * authenticated user edit every document.
+   */
+  authorize?(user: object, id: string): Promise<{
+    readOnly: boolean;
+  } | null>;
+  /**
+   * Opaque version of the stored content of a document (mtime, hash, revision), `null` = unknown, no NUL. The collab server
+   * keeps it next to the Yjs state. When it differs from the live version (the content changed behind the editor's back) the
+   * state is discarded on load, removed through `removeState` and the document is re-seeded from `loadContent`. A document
+   * that is open when its version moves is not written back: the next store merges the new `loadContent` into the open
+   * Y.Doc. The version is read right after every `storeContent`, so it must reflect what the editor itself just wrote.
+   * Omit it to never discard state.
+   */
+  contentVersion?(id: string): Promise<string | null>;
+  /** TipTap extensions of host-defined nodes and marks, appended to `advancedSchemaExtensions()` in the server's collab schema so they survive JSON↔Yjs conversion. Vue-free node files only, no node views. */
+  schemaExtensions?(): AnyExtension[];
+  /** TipTap JSON to seed a document's Y.Doc from; `null` = the document does not exist. */
+  loadContent(id: string): Promise<JSONContent | null>;
+  /** Mirror of the current Yjs state, called debounced after edits and on shutdown. Must tolerate ids deleted meanwhile. */
+  storeContent(id: string, content: JSONContent): Promise<void>;
+  /** All users that can be `@`-mentioned (served by `GET /api/editor/users`); must not include credentials. */
+  listUsers(): Promise<MentionUser[]>;
+  /** Stored TipTap JSON of every document in the workspace, e.g. to collect the `#` tags in use (`GET /api/editor/tags`). */
+  listContents(): Promise<{
+    id: string;
+    content: JSONContent;
+  }[]>;
+  /** The bytes `storeState` stored (opaque to the host: the Yjs update behind a content-version prefix; state stored by earlier releases is a raw update and still loads); `null` = none yet (the Y.Doc is then seeded from `loadContent`). */
+  loadState(id: string): Promise<Uint8Array | null>;
+  /** Persists the state bytes unchanged; called on every store and when block IDs were backfilled. Must tolerate ids deleted meanwhile. */
+  storeState(id: string, state: Uint8Array): Promise<void>;
+  /** Drops the Yjs state of a deleted document (the next load re-seeds from `loadContent`). */
+  removeState(id: string): Promise<void>;
+  /** Stores an uploaded file (`GET /api/editor/assets/:id/:name` serves it). `id` is a document id or `SCRATCH_DOCUMENT_ID`; it may name no existing document. */
+  storeAsset(id: string, asset: AssetRecord & {
+    data: Buffer;
+  }): Promise<void>;
+  /** A stored file with its record; `null` = unknown id or name. */
+  loadAsset(id: string, name: string): Promise<{
+    record: AssetRecord;
+    data: Buffer;
+  } | null>;
+  /** Per-user editor settings as stored (`null` = none yet), validated by `GET /api/editor/settings`. Omit both settings methods to let the client keep settings in localStorage only. */
+  loadSettings?(user: object): Promise<unknown | null>;
+  /** Stores validated settings for the user from `authenticate`. */
+  storeSettings?(user: object, settings: EditorSettings): Promise<void>;
+  /** Theme library shared by all users (`GET /api/editor/themes`). Omit the theme methods to leave the themes feature uninstalled: its routes answer 501. */
+  listThemes?(): Promise<ThemeRecord[]>;
+  /** A theme's record and `theme.css` (`GET /api/editor/themes/:id`); `null` = unknown id. */
+  loadTheme?(id: string): Promise<{
+    record: ThemeRecord;
+    css: string;
+  } | null>;
+  /** Stores an uploaded theme (`POST /api/editor/themes`). */
+  storeTheme?(record: Omit<ThemeRecord, 'builtin'>, css: string): Promise<void>;
+  /** Deletes an uploaded theme (`DELETE /api/editor/themes/:id`); `false` = not found or builtin. */
+  removeTheme?(id: string): Promise<boolean>;
+  /**
+   * The language model for `ref`, so the AI endpoints use the host's own providers; consulted before the runtime-config
+   * presets for every model reference. `user` is what `authenticate` returned. `null` falls through to the presets
+   * (and answers 400 for a preset that is not configured either).
+   */
+  languageModel?(ref: ModelRef, user: object | null): Promise<LanguageModel | null>;
+  /**
+   * The models `GET /api/ai/models` lists for `user`, instead of the runtime-config presets (list them with
+   * `source: 'preset'` and the `id` that `languageModel` receives as `{ preset: id }`). `null` (or omitting the method)
+   * lists the presets.
+   */
+  listModels?(user: object | null): Promise<ModelProfile[] | null>;
+}
+//#endregion
+//# sourceMappingURL=adapter.d.ts.map

package/dist/server/ai.d.ts

@@ -0,0 +1,101 @@
+import { ModelSlot } from "../settings/values.js";
+import "../settings/index.js";
+import { ModelProfile, ModelRef } from "../features/ai/protocol/models.js";
+import "../features/ai/protocol/index.js";
+import { HttpError } from "./errors.js";
+import { LanguageModel, ModelMessage, ToolChoice, ToolSet } from "ai";
+//#region src/server/ai.d.ts
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+/** A streamed text delta, or a finished tool call (`invalid`: unparsable input or unknown tool). */
+export type ChatTurnPart = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'tool-call';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  invalid: boolean;
+};
+/** Server-defined model preset (any OpenAI-compatible chat completions endpoint); its key falls back to the shared `apiKey`. */
+export interface PresetConfig {
+  label: string;
+  endpoint: string;
+  model: string;
+  apiKey?: string;
+}
+/** Speech-to-text endpoint: any OpenAI-compatible `<endpoint>/audio/transcriptions`. */
+export interface TranscriptionConfig {
+  endpoint: string;
+  model: string;
+  apiKey?: string;
+}
+/** Everything the AI endpoints need, passed explicitly: no runtime config, no globals. */
+export interface AiModelsConfig {
+  /** Server-defined model presets, keyed by preset id. */
+  presets: Record<string, PresetConfig>;
+  /** Shared key of presets without their own. */
+  apiKey?: string;
+  /** Default preset per model slot, answered by `GET /api/ai/models`. */
+  slots?: Record<ModelSlot, string>;
+  /** Speech-to-text for audio/video composites; absent = the transcription endpoint answers 501. */
+  transcription?: TranscriptionConfig;
+  /**
+   * The host's own language model for `ref` (`EditorAdapter.languageModel`), consulted before the presets for every
+   * model reference; `user` is what `authenticate` returned. `null` or nothing falls through to the presets.
+   */
+  languageModel?: (ref: ModelRef, user: object | null) => Promise<LanguageModel | null | undefined>;
+  /** The models listed for `user` instead of the presets (`EditorAdapter.listModels`); `null` or nothing lists the presets. */
+  listModels?: (user: object | null) => Promise<ModelProfile[] | null | undefined>;
+  /** Appended to the error of a preset without key, e.g. the environment variable names that set it. */
+  missingKeyHint?: (presetId: string) => string;
+}
+export interface AiModels {
+  /**
+   * AI SDK language model for `ref` (an OpenAI-compatible chat completions endpoint), for direct `ai` calls. The
+   * host's `languageModel(ref, user)` is asked first (`user`: what `authenticate` returned); a model it returns is
+   * used as is, `null` (or no such hook) falls through to the configured presets. A preset uses its own key or the
+   * shared `apiKey`; a user ref brings its own. Throws `HttpError` 400 for an unknown preset and 500 for a preset
+   * without key, so routes can call it before streaming starts.
+   */
+  resolveModel(ref: ModelRef, user: object | null): Promise<LanguageModel>;
+  /**
+   * The configured presets as the client may see them: without their keys. `user` is what the host's `authenticate`
+   * returned; the `listModels` hook supplies the list when it returns one (replacing the presets).
+   */
+  listModels(user: object | null): Promise<ModelProfile[]>;
+  readonly slots: Record<ModelSlot, string> | undefined;
+  readonly transcription: TranscriptionConfig | undefined;
+  streamChat: typeof streamChat;
+  streamChatTurn: typeof streamChatTurn;
+}
+/** The AI model utilities over an explicit configuration. */
+export declare function createAiModels(config: AiModelsConfig): AiModels;
+export declare function upstreamError(error: unknown): HttpError;
+/**
+ * Streams the text deltas of a chat completion (AI SDK `streamText`) on the resolved language model `model` (see
+ * `resolveModel`). System messages may appear in `messages`; a trailing assistant message is a prefill the model
+ * continues. Upstream failures throw a 502 `HttpError`; aborting `signal` cancels the upstream request and makes the
+ * generator throw.
+ */
+export declare function streamChat(opts: {
+  model: LanguageModel;
+  messages: ChatMessage[];
+  signal: AbortSignal;
+}): AsyncGenerator<string>;
+/**
+ * Like `streamChat`, with `tools` the model may call (tools without `execute`: the turn ends with the calls, which are
+ * yielded for the caller to handle) and structured `messages` (tool calls and results in the history).
+ */
+export declare function streamChatTurn(opts: {
+  model: LanguageModel;
+  messages: ModelMessage[];
+  signal: AbortSignal;
+  tools?: ToolSet;
+  toolChoice?: ToolChoice<ToolSet>;
+}): AsyncGenerator<ChatTurnPart>;
+//#endregion
+//# sourceMappingURL=ai.d.ts.map

package/dist/server/ai.js

@@ -0,0 +1,105 @@
+import { HttpError } from "./errors.js";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { APICallError, streamText } from "ai";
+//#region src/server/ai.ts
+/** The AI model utilities over an explicit configuration. */
+function createAiModels(config) {
+	return {
+		async resolveModel(ref, user) {
+			const hosted = await config.languageModel?.(ref, user);
+			if (hosted) return hosted;
+			if (!("preset" in ref)) return createOpenAICompatible({
+				name: "tiptap-editor",
+				baseURL: ref.endpoint,
+				apiKey: ref.apiKey
+			}).chatModel(ref.model);
+			const preset = config.presets[ref.preset];
+			if (!preset) throw new HttpError(400, "Unbekanntes Modell-Preset");
+			const apiKey = preset.apiKey || config.apiKey;
+			if (!apiKey) throw new HttpError(500, `API-Key für Preset „${ref.preset}“ fehlt${config.missingKeyHint?.(ref.preset) ?? ""}`);
+			return createOpenAICompatible({
+				name: "tiptap-editor",
+				baseURL: preset.endpoint,
+				apiKey
+			}).chatModel(preset.model);
+		},
+		async listModels(user) {
+			const listed = await config.listModels?.(user);
+			if (listed) return listed;
+			return Object.entries(config.presets).map(([id, { label, endpoint, model }]) => ({
+				id,
+				label,
+				endpoint,
+				model,
+				source: "preset"
+			}));
+		},
+		slots: config.slots,
+		transcription: config.transcription,
+		streamChat,
+		streamChatTurn
+	};
+}
+function upstreamError(error) {
+	let detail;
+	if (APICallError.isInstance(error)) detail = [error.statusCode, error.responseBody || error.message].filter(Boolean).join(" ");
+	else if (error instanceof Error) detail = error.message;
+	else detail = error?.message ?? JSON.stringify(error);
+	return new HttpError(502, `KI-Endpunkt: ${detail}`.slice(0, 500));
+}
+/**
+* Streams the text deltas of a chat completion (AI SDK `streamText`) on the resolved language model `model` (see
+* `resolveModel`). System messages may appear in `messages`; a trailing assistant message is a prefill the model
+* continues. Upstream failures throw a 502 `HttpError`; aborting `signal` cancels the upstream request and makes the
+* generator throw.
+*/
+async function* streamChat(opts) {
+	for await (const part of streamChatTurn(opts)) if (part.type === "text") yield part.text;
+}
+/**
+* Like `streamChat`, with `tools` the model may call (tools without `execute`: the turn ends with the calls, which are
+* yielded for the caller to handle) and structured `messages` (tool calls and results in the history).
+*/
+async function* streamChatTurn(opts) {
+	const { model } = opts;
+	const upstream = new AbortController();
+	const onAbort = () => upstream.abort(opts.signal.reason);
+	if (opts.signal.aborted) onAbort();
+	else opts.signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		const result = streamText({
+			model,
+			messages: opts.messages,
+			tools: opts.tools,
+			toolChoice: opts.toolChoice,
+			allowSystemInMessages: true,
+			abortSignal: upstream.signal,
+			maxRetries: 0,
+			onError: () => {}
+		});
+		for await (const part of result.stream) if (part.type === "text-delta") {
+			if (part.text) yield {
+				type: "text",
+				text: part.text
+			};
+		} else if (part.type === "tool-call") yield {
+			type: "tool-call",
+			toolCallId: part.toolCallId,
+			toolName: part.toolName,
+			input: part.input,
+			invalid: part.invalid === true
+		};
+		else if (part.type === "error") {
+			if (opts.signal.aborted) break;
+			throw upstreamError(part.error);
+		} else if (part.type === "abort") break;
+		opts.signal.throwIfAborted();
+	} finally {
+		opts.signal.removeEventListener("abort", onAbort);
+		upstream.abort();
+	}
+}
+//#endregion
+export { createAiModels, streamChat, streamChatTurn, upstreamError };
+
+//# sourceMappingURL=ai.js.map

package/dist/server/ai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.js","names":[],"sources":["../../src/server/ai.ts"],"sourcesContent":["import { createOpenAICompatible } from '@ai-sdk/openai-compatible'\nimport { APICallError, type LanguageModel, type ModelMessage, streamText, type ToolChoice, type ToolSet } from 'ai'\nimport type { ModelProfile, ModelRef } from '../features/ai/protocol'\nimport type { ModelSlot } from '../settings'\nimport { HttpError } from './errors'\n\nexport interface ChatMessage { role: 'system' | 'user' | 'assistant', content: string }\n\n/** A streamed text delta, or a finished tool call (`invalid`: unparsable input or unknown tool). */\nexport type ChatTurnPart =\n  | { type: 'text', text: string }\n  | { type: 'tool-call', toolCallId: string, toolName: string, input: unknown, invalid: boolean }\n\n/** Server-defined model preset (any OpenAI-compatible chat completions endpoint); its key falls back to the shared `apiKey`. */\nexport interface PresetConfig { label: string, endpoint: string, model: string, apiKey?: string }\n\n/** Speech-to-text endpoint: any OpenAI-compatible `<endpoint>/audio/transcriptions`. */\nexport interface TranscriptionConfig { endpoint: string, model: string, apiKey?: string }\n\n/** Everything the AI endpoints need, passed explicitly: no runtime config, no globals. */\nexport interface AiModelsConfig {\n  /** Server-defined model presets, keyed by preset id. */\n  presets: Record<string, PresetConfig>\n  /** Shared key of presets without their own. */\n  apiKey?: string\n  /** Default preset per model slot, answered by `GET /api/ai/models`. */\n  slots?: Record<ModelSlot, string>\n  /** Speech-to-text for audio/video composites; absent = the transcription endpoint answers 501. */\n  transcription?: TranscriptionConfig\n  /**\n   * The host's own language model for `ref` (`EditorAdapter.languageModel`), consulted before the presets for every\n   * model reference; `user` is what `authenticate` returned. `null` or nothing falls through to the presets.\n   */\n  languageModel?: (ref: ModelRef, user: object | null) => Promise<LanguageModel | null | undefined>\n  /** The models listed for `user` instead of the presets (`EditorAdapter.listModels`); `null` or nothing lists the presets. */\n  listModels?: (user: object | null) => Promise<ModelProfile[] | null | undefined>\n  /** Appended to the error of a preset without key, e.g. the environment variable names that set it. */\n  missingKeyHint?: (presetId: string) => string\n}\n\nexport interface AiModels {\n  /**\n   * AI SDK language model for `ref` (an OpenAI-compatible chat completions endpoint), for direct `ai` calls. The\n   * host's `languageModel(ref, user)` is asked first (`user`: what `authenticate` returned); a model it returns is\n   * used as is, `null` (or no such hook) falls through to the configured presets. A preset uses its own key or the\n   * shared `apiKey`; a user ref brings its own. Throws `HttpError` 400 for an unknown preset and 500 for a preset\n   * without key, so routes can call it before streaming starts.\n   */\n  resolveModel(ref: ModelRef, user: object | null): Promise<LanguageModel>\n  /**\n   * The configured presets as the client may see them: without their keys. `user` is what the host's `authenticate`\n   * returned; the `listModels` hook supplies the list when it returns one (replacing the presets).\n   */\n  listModels(user: object | null): Promise<ModelProfile[]>\n  readonly slots: Record<ModelSlot, string> | undefined\n  readonly transcription: TranscriptionConfig | undefined\n  streamChat: typeof streamChat\n  streamChatTurn: typeof streamChatTurn\n}\n\n/** The AI model utilities over an explicit configuration. */\nexport function createAiModels(config: AiModelsConfig): AiModels {\n  return {\n    async resolveModel(ref, user) {\n      const hosted = await config.languageModel?.(ref, user)\n      if (hosted) return hosted\n      if (!('preset' in ref)) return createOpenAICompatible({ name: 'tiptap-editor', baseURL: ref.endpoint, apiKey: ref.apiKey }).chatModel(ref.model)\n      const preset = config.presets[ref.preset]\n      if (!preset) throw new HttpError(400, 'Unbekanntes Modell-Preset')\n      const apiKey = preset.apiKey || config.apiKey\n      if (!apiKey) throw new HttpError(500, `API-Key für Preset „${ref.preset}“ fehlt${config.missingKeyHint?.(ref.preset) ?? ''}`)\n      return createOpenAICompatible({ name: 'tiptap-editor', baseURL: preset.endpoint, apiKey }).chatModel(preset.model)\n    },\n    async listModels(user) {\n      const listed = await config.listModels?.(user)\n      if (listed) return listed\n      return Object.entries(config.presets).map(([id, { label, endpoint, model }]) => ({ id, label, endpoint, model, source: 'preset' }))\n    },\n    slots: config.slots,\n    transcription: config.transcription,\n    streamChat,\n    streamChatTurn,\n  }\n}\n\nexport function upstreamError(error: unknown) {\n  let detail: string\n  if (APICallError.isInstance(error)) detail = [error.statusCode, error.responseBody || error.message].filter(Boolean).join(' ')\n  else if (error instanceof Error) detail = error.message\n  else detail = (error as { message?: string } | null)?.message ?? JSON.stringify(error)\n  return new HttpError(502, `KI-Endpunkt: ${detail}`.slice(0, 500))\n}\n\n/**\n * Streams the text deltas of a chat completion (AI SDK `streamText`) on the resolved language model `model` (see\n * `resolveModel`). System messages may appear in `messages`; a trailing assistant message is a prefill the model\n * continues. Upstream failures throw a 502 `HttpError`; aborting `signal` cancels the upstream request and makes the\n * generator throw.\n */\nexport async function* streamChat(opts: { model: LanguageModel, messages: ChatMessage[], signal: AbortSignal }): AsyncGenerator<string> {\n  for await (const part of streamChatTurn(opts)) {\n    if (part.type === 'text') yield part.text\n  }\n}\n\n/**\n * Like `streamChat`, with `tools` the model may call (tools without `execute`: the turn ends with the calls, which are\n * yielded for the caller to handle) and structured `messages` (tool calls and results in the history).\n */\nexport async function* streamChatTurn(opts: {\n  model: LanguageModel\n  messages: ModelMessage[]\n  signal: AbortSignal\n  tools?: ToolSet\n  toolChoice?: ToolChoice<ToolSet>\n}): AsyncGenerator<ChatTurnPart> {\n  const { model } = opts\n  // Also cancels the upstream request when the consumer stops iterating early (break / return).\n  const upstream = new AbortController()\n  const onAbort = () => upstream.abort(opts.signal.reason)\n  if (opts.signal.aborted) onAbort()\n  else opts.signal.addEventListener('abort', onAbort, { once: true })\n  try {\n    const result = streamText({\n      model,\n      messages: opts.messages,\n      tools: opts.tools,\n      toolChoice: opts.toolChoice,\n      allowSystemInMessages: true,\n      abortSignal: upstream.signal,\n      maxRetries: 0,\n      // Errors surface as `error` parts below and are rethrown; the default handler would only log them.\n      onError: () => {},\n    })\n    for await (const part of result.stream) {\n      if (part.type === 'text-delta') {\n        if (part.text) yield { type: 'text', text: part.text }\n      }\n      else if (part.type === 'tool-call') {\n        yield { type: 'tool-call', toolCallId: part.toolCallId, toolName: part.toolName, input: part.input, invalid: part.invalid === true }\n      }\n      else if (part.type === 'error') {\n        if (opts.signal.aborted) break\n        throw upstreamError(part.error)\n      }\n      else if (part.type === 'abort') {\n        break\n      }\n    }\n    opts.signal.throwIfAborted()\n  }\n  finally {\n    opts.signal.removeEventListener('abort', onAbort)\n    upstream.abort()\n  }\n}\n"],"mappings":";;;;;AA6DA,SAAgB,eAAe,QAAkC;CAC/D,OAAO;EACL,MAAM,aAAa,KAAK,MAAM;GAC5B,MAAM,SAAS,MAAM,OAAO,gBAAgB,KAAK,IAAI;GACrD,IAAI,QAAQ,OAAO;GACnB,IAAI,EAAE,YAAY,MAAM,OAAO,uBAAuB;IAAE,MAAM;IAAiB,SAAS,IAAI;IAAU,QAAQ,IAAI;GAAO,CAAC,CAAC,CAAC,UAAU,IAAI,KAAK;GAC/I,MAAM,SAAS,OAAO,QAAQ,IAAI;GAClC,IAAI,CAAC,QAAQ,MAAM,IAAI,UAAU,KAAK,2BAA2B;GACjE,MAAM,SAAS,OAAO,UAAU,OAAO;GACvC,IAAI,CAAC,QAAQ,MAAM,IAAI,UAAU,KAAK,uBAAuB,IAAI,OAAO,SAAS,OAAO,iBAAiB,IAAI,MAAM,KAAK,IAAI;GAC5H,OAAO,uBAAuB;IAAE,MAAM;IAAiB,SAAS,OAAO;IAAU;GAAO,CAAC,CAAC,CAAC,UAAU,OAAO,KAAK;EACnH;EACA,MAAM,WAAW,MAAM;GACrB,MAAM,SAAS,MAAM,OAAO,aAAa,IAAI;GAC7C,IAAI,QAAQ,OAAO;GACnB,OAAO,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,UAAU,cAAc;IAAE;IAAI;IAAO;IAAU;IAAO,QAAQ;GAAS,EAAE;EACpI;EACA,OAAO,OAAO;EACd,eAAe,OAAO;EACtB;EACA;CACF;AACF;AAEA,SAAgB,cAAc,OAAgB;CAC5C,IAAI;CACJ,IAAI,aAAa,WAAW,KAAK,GAAG,SAAS,CAAC,MAAM,YAAY,MAAM,gBAAgB,MAAM,OAAO,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG;MACxH,IAAI,iBAAiB,OAAO,SAAS,MAAM;MAC3C,SAAU,OAAuC,WAAW,KAAK,UAAU,KAAK;CACrF,OAAO,IAAI,UAAU,KAAK,gBAAgB,SAAS,MAAM,GAAG,GAAG,CAAC;AAClE;;;;;;;AAQA,gBAAuB,WAAW,MAAsG;CACtI,WAAW,MAAM,QAAQ,eAAe,IAAI,GAC1C,IAAI,KAAK,SAAS,QAAQ,MAAM,KAAK;AAEzC;;;;;AAMA,gBAAuB,eAAe,MAML;CAC/B,MAAM,EAAE,UAAU;CAElB,MAAM,WAAW,IAAI,gBAAgB;CACrC,MAAM,gBAAgB,SAAS,MAAM,KAAK,OAAO,MAAM;CACvD,IAAI,KAAK,OAAO,SAAS,QAAQ;MAC5B,KAAK,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAClE,IAAI;EACF,MAAM,SAAS,WAAW;GACxB;GACA,UAAU,KAAK;GACf,OAAO,KAAK;GACZ,YAAY,KAAK;GACjB,uBAAuB;GACvB,aAAa,SAAS;GACtB,YAAY;GAEZ,eAAe,CAAC;EAClB,CAAC;EACD,WAAW,MAAM,QAAQ,OAAO,QAC9B,IAAI,KAAK,SAAS,cACZ;OAAA,KAAK,MAAM,MAAM;IAAE,MAAM;IAAQ,MAAM,KAAK;GAAK;EAAA,OAElD,IAAI,KAAK,SAAS,aACrB,MAAM;GAAE,MAAM;GAAa,YAAY,KAAK;GAAY,UAAU,KAAK;GAAU,OAAO,KAAK;GAAO,SAAS,KAAK,YAAY;EAAK;OAEhI,IAAI,KAAK,SAAS,SAAS;GAC9B,IAAI,KAAK,OAAO,SAAS;GACzB,MAAM,cAAc,KAAK,KAAK;EAChC,OACK,IAAI,KAAK,SAAS,SACrB;EAGJ,KAAK,OAAO,eAAe;CAC7B,UACQ;EACN,KAAK,OAAO,oBAAoB,SAAS,OAAO;EAChD,SAAS,MAAM;CACjB;AACF"}

package/dist/server/collab-state.d.ts

@@ -0,0 +1,16 @@
+//#region src/server/collab-state.d.ts
+export interface CollabState {
+  /** `EditorAdapter.contentVersion` of the content the update was stored with; `null` = none known (also: legacy payload). */
+  version: string | null;
+  update: Uint8Array;
+}
+export declare function encodeCollabState({ version, update }: CollabState): Uint8Array;
+export declare function decodeCollabState(payload: Uint8Array): CollabState;
+/**
+ * Whether stored collaborative state is stale against the content behind it. Only hosts that implement
+ * `contentVersion` opt in (`live === undefined`: the adapter has no such method, state is never discarded). A legacy
+ * payload (`stored: null`) against a known live version counts as stale: it cannot prove it matches the content.
+ */
+export declare function isStateStale(stored: string | null, live: string | null | undefined): boolean;
+//#endregion
+//# sourceMappingURL=collab-state.d.ts.map