@ecsplico/editor 2.0.0 → 2.1.1

package/dist/adapters/forge.d.ts

@@ -0,0 +1,58 @@
+import { EditorAdapter } from "../server/adapter.js";
+import "../server/index.js";
+import { AdapterHooks } from "./shared.js";
+import { MarkdownDiagnostic, MarkdownPolicy } from "../markdown/policy.js";
+import "../markdown/index.js";
+import { AnyExtension } from "@tiptap/core";
+//#region src/adapters/forge.d.ts
+/** A Markdown file of the host, as the host stores it: the whole text with its frontmatter, and an opaque version of that file. */
+export interface ForgeFile {
+  markdown: string;
+  /** Changes whenever the file's content changes (mtime and size, a hash, a revision); no NUL character. Becomes `contentVersion`. */
+  version: string;
+}
+/** Where the host keeps its Markdown documents. The adapter never touches a file system itself. */
+export interface ForgeContent {
+  /** The file behind a document id, `null` = it does not exist. */
+  read(id: string): Promise<ForgeFile | null>;
+  /** Writes the file (frontmatter included). Only called for documents that exist. */
+  write(id: string, markdown: string): Promise<void>;
+  /** Called after every `write` the adapter made (change notifications, indexes). */
+  onWritten?(id: string): void | Promise<void>;
+  /** Ids of all documents, for `listContents` (the tag index). Omitted: `listContents` is empty. */
+  list?(): Promise<string[]>;
+}
+/** What the adapter delegates to a storage adapter that has no use for Markdown: Yjs state, assets, settings, themes (`createJsonAdapter` or `createDrizzleAdapter` fit). */
+export type ForgeState = Pick<EditorAdapter, 'loadState' | 'storeState' | 'removeState' | 'storeAsset' | 'loadAsset'> & Partial<Pick<EditorAdapter, 'loadSettings' | 'storeSettings' | 'listThemes' | 'loadTheme' | 'storeTheme' | 'removeTheme'>>;
+export interface ForgeAdapterOptions extends Omit<AdapterHooks, 'authenticate'> {
+  content: ForgeContent;
+  state: ForgeState;
+  /**
+   * The complete TipTap extension list of the Markdown conversion, e.g. `[...advancedSchemaExtensions(), MermaidBlock]`:
+   * nodes and marks with their Markdown handlers. Host nodes also go to the collaboration schema through `schemaExtensions`
+   * (which lists only the additions to `advancedSchemaExtensions()`).
+   */
+  schema: AnyExtension[];
+  /** The host's session check; there is no default for a host that owns its Markdown files. */
+  authenticate: EditorAdapter['authenticate'];
+  /** Markdown policy of the conversion (raw HTML, data URLs); the default drops both. */
+  policy?: MarkdownPolicy;
+  /** Called with the diagnostics of every load that produced some (dropped HTML or URLs, unknown fences kept verbatim). */
+  onDiagnostics?(id: string, diagnostics: MarkdownDiagnostic[]): void;
+}
+/**
+ * The editor's adapter over the host's Markdown files (concept documents, vault pages). The host keeps owning the
+ * files, their locations, change notifications and access rules and passes them in as functions; this adapter does the
+ * Markdown ↔ TipTap JSON conversion and the contract:
+ *
+ * - `loadContent` splits off the frontmatter and parses the body (`markdownToContent`); a body the conversion could not
+ *   keep intact (unclosed fence, malformed fence metadata) is refused with an error instead of loaded lossy.
+ * - `storeContent` re-reads the file, keeps its current frontmatter verbatim, writes the serialized body and calls
+ *   `onWritten`. A file that is gone is not recreated, and an unchanged result is not rewritten.
+ * - `contentVersion` is the file's own version, read after the write so it reflects what the editor stored.
+ *
+ * Yjs state, assets and settings are `state`'s. The converter is one headless editor per adapter, built on first use.
+ */
+export declare function createForgeAdapter(options: ForgeAdapterOptions): EditorAdapter;
+//#endregion
+//# sourceMappingURL=forge.d.ts.map

package/dist/adapters/forge.js

@@ -0,0 +1,91 @@
+import { DocumentMarkdown } from "../core/document-markdown.js";
+import { hasFatalDiagnostics } from "../markdown/policy.js";
+import { contentToMarkdown, markdownToContent } from "../markdown/document.js";
+import { joinFrontmatter, splitFrontmatter } from "../markdown/frontmatter.js";
+import { Editor } from "@tiptap/core";
+//#region src/adapters/forge.ts
+const OPTIONAL_STATE = [
+	"loadSettings",
+	"storeSettings",
+	"listThemes",
+	"loadTheme",
+	"storeTheme",
+	"removeTheme"
+];
+/**
+* The editor's adapter over the host's Markdown files (concept documents, vault pages). The host keeps owning the
+* files, their locations, change notifications and access rules and passes them in as functions; this adapter does the
+* Markdown ↔ TipTap JSON conversion and the contract:
+*
+* - `loadContent` splits off the frontmatter and parses the body (`markdownToContent`); a body the conversion could not
+*   keep intact (unclosed fence, malformed fence metadata) is refused with an error instead of loaded lossy.
+* - `storeContent` re-reads the file, keeps its current frontmatter verbatim, writes the serialized body and calls
+*   `onWritten`. A file that is gone is not recreated, and an unchanged result is not rewritten.
+* - `contentVersion` is the file's own version, read after the write so it reflects what the editor stored.
+*
+* Yjs state, assets and settings are `state`'s. The converter is one headless editor per adapter, built on first use.
+*/
+function createForgeAdapter(options) {
+	const { content, state, schema, policy, onDiagnostics, authenticate, authorize, schemaExtensions, users } = options;
+	let converter;
+	const editor = () => converter ??= new Editor({
+		content: {
+			type: "doc",
+			content: [{ type: "paragraph" }]
+		},
+		extensions: [DocumentMarkdown, ...schema]
+	});
+	const optionalState = Object.fromEntries(OPTIONAL_STATE.filter((method) => state[method]).map((method) => [method, (...args) => state[method].apply(state, args)]));
+	function parse(id, file) {
+		const { content: json, diagnostics } = markdownToContent(editor(), splitFrontmatter(file.markdown).body, policy ? { policy } : {});
+		if (diagnostics.length) onDiagnostics?.(id, diagnostics);
+		if (hasFatalDiagnostics(diagnostics)) {
+			const problems = diagnostics.filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.message);
+			throw new Error(`@ecsplico/editor: document "${id}" cannot be converted without losing content: ${problems.join(" ")}`);
+		}
+		return json;
+	}
+	return {
+		authenticate: (request) => authenticate(request),
+		listUsers: async () => await users?.() ?? [],
+		...authorize && { authorize: (user, id) => authorize(user, id) },
+		...schemaExtensions && { schemaExtensions: () => schemaExtensions() },
+		async loadContent(id) {
+			const file = await content.read(id);
+			return file && parse(id, file);
+		},
+		async storeContent(id, json) {
+			const current = await content.read(id);
+			if (!current) return;
+			const instance = editor();
+			instance.commands.setContent(json, { emitUpdate: false });
+			const body = contentToMarkdown(instance);
+			const markdown = joinFrontmatter(splitFrontmatter(current.markdown).frontmatter, body && `${body}\n`);
+			if (markdown === current.markdown) return;
+			await content.write(id, markdown);
+			await content.onWritten?.(id);
+		},
+		async contentVersion(id) {
+			return (await content.read(id))?.version ?? null;
+		},
+		async listContents() {
+			return (await Promise.all((await content.list?.() ?? []).map(async (id) => {
+				const file = await content.read(id);
+				return file && {
+					id,
+					content: parse(id, file)
+				};
+			}))).filter((entry) => entry !== null);
+		},
+		loadState: (id) => state.loadState(id),
+		storeState: (id, bytes) => state.storeState(id, bytes),
+		removeState: (id) => state.removeState(id),
+		storeAsset: (id, asset) => state.storeAsset(id, asset),
+		loadAsset: (id, name) => state.loadAsset(id, name),
+		...optionalState
+	};
+}
+//#endregion
+export { createForgeAdapter };
+
+//# sourceMappingURL=forge.js.map

package/dist/adapters/forge.js.map

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

package/dist/adapters/index.d.ts

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

package/dist/adapters/json.d.ts

@@ -0,0 +1,24 @@
+import { AdapterHooks, StoredEditorAdapter } from "./shared.js";
+//#region src/adapters/json.d.ts
+export interface JsonAdapterOptions extends AdapterHooks {
+  /** Directory the adapter owns; created on demand. Single node only: the files are not coordinated across processes. */
+  dir: string;
+}
+/**
+ * The editor's adapter on plain files under `dir`:
+ *
+ *     <dir>/<id>.json                         TipTap JSON of a document
+ *     <dir>/<id>.ystate                       the collab server's state bytes
+ *     <dir>/settings/<user>.json              per-user editor settings
+ *     <dir>/assets/<id>/<name>                an uploaded file
+ *     <dir>/assets/<id>/.records/<name>.json  its `AssetRecord`
+ *
+ * Ids, user keys and asset names are percent-encoded into file names (`a/b` → `a%2Fb.json`), so no input leaves `dir`.
+ * A missing file reads as `null`; every write goes through a temp file and a rename. `contentVersion` is the content
+ * file's modification time (nanoseconds) and size, read after every write the editor makes, so a document edited by
+ * hand or by another tool invalidates the stored Yjs state. `storeContent` only updates existing documents: create
+ * them with `putDocument`. The adapter has no theme library (the themes routes answer 501).
+ */
+export declare function createJsonAdapter(options: JsonAdapterOptions): StoredEditorAdapter;
+//#endregion
+//# sourceMappingURL=json.d.ts.map

package/dist/adapters/json.js

@@ -0,0 +1,128 @@
+import { bytesOf, identityPart, settingsKey } from "./shared.js";
+import { isMissing, readOrNull, writeAtomic } from "./files.js";
+import { promises } from "node:fs";
+import path from "node:path";
+//#region src/adapters/json.ts
+const CONTENT_EXT = ".json";
+const STATE_EXT = ".ystate";
+const SETTINGS_DIR = "settings";
+const ASSETS_DIR = "assets";
+const RECORDS_DIR = ".records";
+/**
+* A file name for `value`: percent-encoded (reversible, no separators, no `.`/`..`), and a leading dot escaped so no
+* key ever collides with the dot-named temp files and the `.records` directory.
+*/
+function fileKey(value) {
+	if (value === "") throw new TypeError("@ecsplico/editor: empty id");
+	const encoded = encodeURIComponent(value);
+	return encoded.startsWith(".") ? `%2E${encoded.slice(1)}` : encoded;
+}
+async function readJson(file) {
+	const data = await readOrNull(file);
+	return data === null ? null : JSON.parse(data.toString("utf8"));
+}
+/** Runs the actions of one key one after another, so a delete cannot interleave with an update of the same document. */
+function keyedLock() {
+	const tails = /* @__PURE__ */ new Map();
+	return (key, action) => {
+		const run = (tails.get(key) ?? Promise.resolve()).then(action, action);
+		const tail = run.catch(() => {});
+		tails.set(key, tail);
+		tail.then(() => {
+			if (tails.get(key) === tail) tails.delete(key);
+		});
+		return run;
+	};
+}
+/**
+* The editor's adapter on plain files under `dir`:
+*
+*     <dir>/<id>.json                         TipTap JSON of a document
+*     <dir>/<id>.ystate                       the collab server's state bytes
+*     <dir>/settings/<user>.json              per-user editor settings
+*     <dir>/assets/<id>/<name>                an uploaded file
+*     <dir>/assets/<id>/.records/<name>.json  its `AssetRecord`
+*
+* Ids, user keys and asset names are percent-encoded into file names (`a/b` → `a%2Fb.json`), so no input leaves `dir`.
+* A missing file reads as `null`; every write goes through a temp file and a rename. `contentVersion` is the content
+* file's modification time (nanoseconds) and size, read after every write the editor makes, so a document edited by
+* hand or by another tool invalidates the stored Yjs state. `storeContent` only updates existing documents: create
+* them with `putDocument`. The adapter has no theme library (the themes routes answer 501).
+*/
+function createJsonAdapter(options) {
+	const root = path.resolve(options.dir);
+	const contentFile = (id) => path.join(root, `${fileKey(id)}${CONTENT_EXT}`);
+	const stateFile = (id) => path.join(root, `${fileKey(id)}${STATE_EXT}`);
+	const settingsFile = (user) => path.join(root, SETTINGS_DIR, `${fileKey(settingsKey(user))}${CONTENT_EXT}`);
+	const assetDir = (id) => path.join(root, ASSETS_DIR, fileKey(id));
+	const assetFile = (id, name) => path.join(assetDir(id), fileKey(name));
+	const recordFile = (id, name) => path.join(assetDir(id), RECORDS_DIR, `${fileKey(name)}${CONTENT_EXT}`);
+	const locked = keyedLock();
+	async function listDocumentIds() {
+		let entries;
+		try {
+			entries = await promises.readdir(root, { withFileTypes: true });
+		} catch (error) {
+			if (isMissing(error)) return [];
+			throw error;
+		}
+		return entries.filter((entry) => entry.isFile() && !entry.name.startsWith(".") && entry.name.endsWith(CONTENT_EXT)).map((entry) => decodeURIComponent(entry.name.slice(0, -5))).sort();
+	}
+	const loadContent = async (id) => readJson(contentFile(id));
+	return {
+		...identityPart(options),
+		loadContent,
+		storeContent: (id, content) => locked(id, async () => {
+			if (!await promises.stat(contentFile(id)).then(() => true, () => false)) return;
+			await writeAtomic(contentFile(id), JSON.stringify(content));
+		}),
+		async contentVersion(id) {
+			try {
+				const { mtimeNs, size } = await promises.stat(contentFile(id), { bigint: true });
+				return `${mtimeNs}:${size}`;
+			} catch (error) {
+				if (isMissing(error)) return null;
+				throw error;
+			}
+		},
+		async listContents() {
+			return (await Promise.all((await listDocumentIds()).map(async (id) => ({
+				id,
+				content: await loadContent(id)
+			})))).filter((entry) => entry.content !== null);
+		},
+		async loadState(id) {
+			const data = await readOrNull(stateFile(id));
+			return data && bytesOf(data);
+		},
+		storeState: async (id, state) => writeAtomic(stateFile(id), state),
+		removeState: async (id) => promises.rm(stateFile(id), { force: true }),
+		async storeAsset(id, { data, ...record }) {
+			await writeAtomic(assetFile(id, record.name), data);
+			await writeAtomic(recordFile(id, record.name), JSON.stringify(record));
+		},
+		async loadAsset(id, name) {
+			const [record, data] = await Promise.all([readJson(recordFile(id, name)), readOrNull(assetFile(id, name))]);
+			return record && data ? {
+				record,
+				data
+			} : null;
+		},
+		loadSettings: async (user) => readJson(settingsFile(user)),
+		storeSettings: async (user, settings) => writeAtomic(settingsFile(user), JSON.stringify(settings)),
+		putDocument: (id, content) => locked(id, () => writeAtomic(contentFile(id), JSON.stringify(content))),
+		deleteDocument: (id) => locked(id, async () => {
+			await promises.rm(contentFile(id), { force: true });
+			await promises.rm(stateFile(id), { force: true });
+			await promises.rm(assetDir(id), {
+				recursive: true,
+				force: true
+			});
+		}),
+		listDocumentIds
+	};
+}
+//#endregion
+export { createJsonAdapter };
+
+//# sourceMappingURL=json.js.map

package/dist/adapters/json.js.map

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

package/dist/adapters/nitro.d.ts

@@ -0,0 +1,61 @@
+import { EditorAdapter } from "../server/adapter.js";
+import { AiModels, AiModelsConfig } from "../server/ai.js";
+import { CollabServer, CollabServerOptions } from "../server/collab.js";
+import { RateLimiterOptions } from "../server/rate-limit.js";
+import "../server/index.js";
+import { DocumentAdmin } from "./shared.js";
+import { CommentStore } from "./comments/types.js";
+import { Router } from "h3";
+//#region src/adapters/nitro.d.ts
+/** The part of a Nitro app this entry uses; `nitroApp` of a Nitro plugin fits. */
+export interface NitroHost {
+  router: Pick<Router, 'add' | 'use'>;
+  hooks: {
+    hook(name: 'close', listener: () => void | Promise<void>): unknown;
+  };
+}
+export interface EditorServerOptions {
+  /** Storage and identity. An adapter that also manages documents (`json`, `drizzle`) lets `PUT /api/editor/documents/:id` create them. */
+  adapter: EditorAdapter & Partial<DocumentAdmin>;
+  /**
+   * The collaboration websocket (`/collab/:id`). Extensions, hooks and Hocuspocus configuration of `createCollabServer`;
+   * `{}` takes everything from the adapter. `false` mounts no websocket (documents then only load and save over HTTP).
+   * Needs `experimental: { websocket: true }` in the Nitro config.
+   */
+  collab: Omit<CollabServerOptions, 'adapter'> | false;
+  /**
+   * Mounts the AI endpoints (`/api/ai/*`): presets, shared key, transcription, slots of `createAiModels`; `languageModel`
+   * and `listModels` default to the adapter's. Omitted: no AI routes.
+   */
+  ai?: Partial<AiModelsConfig>;
+  /** Per-user limit of the AI endpoints; default 30 requests per minute. */
+  rateLimit?: RateLimiterOptions;
+  /** Mounts the comments endpoint (`/api/editor/comments/:id`) over this store; omitted: no comments routes. */
+  comments?: {
+    store: CommentStore;
+  };
+}
+export interface EditorServer {
+  adapter: EditorServerOptions['adapter'];
+  /** The collaboration server, `undefined` with `collab: false`. */
+  collab: CollabServer | undefined;
+  /** The AI models, `undefined` without `ai`. */
+  models: AiModels | undefined;
+  /** Writes pending collaboration stores and disconnects every client. Nitro's `close` hook calls it. */
+  close(): Promise<void>;
+}
+/**
+ * Wires the editor backend into `nitroApp` (call it from a Nitro plugin):
+ *
+ *     /api/editor/{settings,users,tags,assets/…,themes/…}   the editor's own endpoints
+ *     /api/editor/documents/:id                              GET/PUT a document's TipTap JSON (what `useEditorDocument` uses)
+ *     /api/editor/comments/:id                               GET/POST comments, with `comments`
+ *     /api/ai/{models,chat,complete,generate,transcribe,transcript-cleanup}   with `ai`
+ *     /collab/:id                                            the collaboration websocket, unless `collab: false`
+ *
+ * Every route authenticates through `adapter.authenticate`. The collaboration server is closed with Nitro's `close`
+ * hook. The paths are the ones `@ecsplico/editor/nuxt` serves, so the editor's client works unchanged.
+ */
+export declare function installEditorServer(nitroApp: NitroHost, options: EditorServerOptions): EditorServer;
+//#endregion
+//# sourceMappingURL=nitro.d.ts.map

package/dist/adapters/nitro.js

@@ -0,0 +1,212 @@
+import { HttpError } from "../server/errors.js";
+import { createAiModels } from "../server/ai.js";
+import { createCollabServer } from "../server/collab.js";
+import { createRateLimiter } from "../server/rate-limit.js";
+import { chatPost, completePost, generatePost, modelsGet, transcribePost, transcriptCleanupPost } from "../server/handlers/ai.js";
+import { assetGet, assetPost, settingsGet, settingsPut, tagsGet, themeDelete, themeGet, themePost, themesGet, usersGet } from "../server/handlers/editor.js";
+import { AI_API, COLLAB_PATH, COMMENTS_ROUTE, DOCUMENT_ROUTE, EDITOR_API } from "./routes.js";
+import { commentsGet, commentsPost, documentGet, documentPut } from "./documents.js";
+import { createError, defineEventHandler, defineWebSocketHandler, getQuery, getRouterParams, readBody, readFormData, setResponseHeaders, setResponseStatus } from "h3";
+//#region src/adapters/nitro.ts
+const API = EDITOR_API;
+/** The `HandlerRequest` of a Nitro event. `signal` aborts when the client goes away. */
+function requestOf(event) {
+	const abort = new AbortController();
+	event.node.res.once("close", () => abort.abort());
+	return {
+		headers: event.headers,
+		params: getRouterParams(event, { decode: true }),
+		query: Object.fromEntries(Object.entries(getQuery(event)).map(([key, value]) => [key, value === void 0 ? void 0 : String(value)])),
+		readJson: () => readBody(event),
+		readForm: () => readFormData(event),
+		signal: abort.signal
+	};
+}
+/** An event handler that runs `handler` with `ctx` and sends its `HandlerResponse`; an `HttpError` becomes Nitro's error response. */
+function routeOf(ctx, handler) {
+	return defineEventHandler(async (event) => {
+		let response;
+		try {
+			response = await handler(ctx, requestOf(event));
+		} catch (error) {
+			if (!(error instanceof HttpError)) throw error;
+			setResponseHeaders(event, error.headers);
+			throw createError({
+				statusCode: error.statusCode,
+				statusMessage: error.statusMessage,
+				message: error.statusMessage,
+				data: error.data
+			});
+		}
+		setResponseStatus(event, response.status);
+		setResponseHeaders(event, response.headers);
+		return response.body;
+	});
+}
+const editorRoutes = [
+	[
+		"get",
+		`${API}/settings`,
+		settingsGet
+	],
+	[
+		"put",
+		`${API}/settings`,
+		settingsPut
+	],
+	[
+		"get",
+		`${API}/users`,
+		usersGet
+	],
+	[
+		"get",
+		`${API}/tags`,
+		tagsGet
+	],
+	[
+		"post",
+		`${API}/assets/:id`,
+		assetPost
+	],
+	[
+		"get",
+		`${API}/assets/:id/:name`,
+		assetGet
+	],
+	[
+		"get",
+		`${API}/themes`,
+		themesGet
+	],
+	[
+		"post",
+		`${API}/themes`,
+		themePost
+	],
+	[
+		"get",
+		`${API}/themes/:id`,
+		themeGet
+	],
+	[
+		"delete",
+		`${API}/themes/:id`,
+		themeDelete
+	]
+];
+const aiRoutes = [
+	[
+		"get",
+		`${AI_API}/models`,
+		modelsGet
+	],
+	[
+		"post",
+		`${AI_API}/chat`,
+		chatPost
+	],
+	[
+		"post",
+		`${AI_API}/complete`,
+		completePost
+	],
+	[
+		"post",
+		`${AI_API}/generate`,
+		generatePost
+	],
+	[
+		"post",
+		`${AI_API}/transcribe`,
+		transcribePost
+	],
+	[
+		"post",
+		`${AI_API}/transcript-cleanup`,
+		transcriptCleanupPost
+	]
+];
+const collabRoute = (collab) => defineWebSocketHandler({
+	open(peer) {
+		peer._hocuspocus = collab.handleConnection(peer.websocket, peer.request);
+	},
+	message(peer, message) {
+		peer._hocuspocus?.handleMessage(message.uint8Array());
+	},
+	close(peer, details) {
+		peer._hocuspocus?.handleClose({
+			code: details.code ?? 1e3,
+			reason: details.reason ?? ""
+		});
+	},
+	error(peer, error) {
+		console.error("[collab]", peer.id, error);
+	}
+});
+/**
+* Wires the editor backend into `nitroApp` (call it from a Nitro plugin):
+*
+*     /api/editor/{settings,users,tags,assets/…,themes/…}   the editor's own endpoints
+*     /api/editor/documents/:id                              GET/PUT a document's TipTap JSON (what `useEditorDocument` uses)
+*     /api/editor/comments/:id                               GET/POST comments, with `comments`
+*     /api/ai/{models,chat,complete,generate,transcribe,transcript-cleanup}   with `ai`
+*     /collab/:id                                            the collaboration websocket, unless `collab: false`
+*
+* Every route authenticates through `adapter.authenticate`. The collaboration server is closed with Nitro's `close`
+* hook. The paths are the ones `@ecsplico/editor/nuxt` serves, so the editor's client works unchanged.
+*/
+function installEditorServer(nitroApp, options) {
+	const { adapter } = options;
+	const collab = options.collab === false ? void 0 : createCollabServer({
+		adapter,
+		...options.collab
+	});
+	const models = options.ai && createAiModels({
+		presets: {},
+		languageModel: adapter.languageModel && ((ref, user) => adapter.languageModel(ref, user)),
+		listModels: adapter.listModels && ((user) => adapter.listModels(user)),
+		...options.ai
+	});
+	const context = {
+		adapter,
+		...collab && { collab }
+	};
+	for (const [method, path, handler] of editorRoutes) nitroApp.router.add(path, routeOf(context, handler), method);
+	nitroApp.router.add(DOCUMENT_ROUTE, routeOf(context, documentGet), "get");
+	nitroApp.router.add(DOCUMENT_ROUTE, routeOf(context, documentPut), "put");
+	if (options.comments) {
+		const comments = {
+			...context,
+			store: options.comments.store
+		};
+		nitroApp.router.add(COMMENTS_ROUTE, routeOf(comments, commentsGet), "get");
+		nitroApp.router.add(COMMENTS_ROUTE, routeOf(comments, commentsPost), "post");
+	}
+	if (models) {
+		const ai = {
+			...context,
+			ai: models,
+			limiter: createRateLimiter(options.rateLimit ?? {
+				max: 30,
+				windowMs: 6e4
+			})
+		};
+		for (const [method, path, handler] of aiRoutes) nitroApp.router.add(path, routeOf(ai, handler), method);
+	}
+	if (collab) nitroApp.router.use(`${COLLAB_PATH}/:id`, collabRoute(collab));
+	const server = {
+		adapter,
+		collab,
+		models,
+		close: async () => {
+			await collab?.close();
+		}
+	};
+	nitroApp.hooks.hook("close", () => server.close());
+	return server;
+}
+//#endregion
+export { installEditorServer };
+
+//# sourceMappingURL=nitro.js.map