@mdfn/server 0.1.0

package/dist/index.cjs

@@ -0,0 +1,737 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MDFN_SERVER_SCHEMA_VERSION: () => MDFN_SERVER_SCHEMA_VERSION,
+  MDFN_SERVER_VERSION: () => MDFN_SERVER_VERSION,
+  MdfnServerError: () => MdfnServerError,
+  createMdfnRouter: () => createMdfnRouter,
+  createMdfnServer: () => createMdfnServer,
+  createMdfnService: () => createMdfnService,
+  getSchema: () => getSchema
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@mdfn/core");
+var import_markdown = require("@mdfn/markdown");
+var import_db = require("@superfunctions/db");
+var import_http = require("@superfunctions/http");
+var DOCUMENTS = "mdfnDocuments";
+var VERSIONS = "mdfnVersions";
+var RECEIPTS = "mdfnReceipts";
+var COLLAB_UPDATES = "mdfnCollaborationUpdates";
+var MDFN_SERVER_SCHEMA_VERSION = 2;
+var MdfnServerError = class extends Error {
+  constructor(code, status, message = code) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "MdfnServerError";
+  }
+  code;
+  status;
+};
+function configuredDocumentBytes(config) {
+  return config.markdown?.maxBytes ?? 2 * 1024 * 1024;
+}
+function configuredCollaborationUpdateBytes(config) {
+  if (config.maxCollaborationUpdateBytes !== void 0) return config.maxCollaborationUpdateBytes;
+  const documentBytes = configuredDocumentBytes(config);
+  const yjsOverhead = Math.max(64 * 1024, Math.ceil(documentBytes / 16));
+  return 4 * Math.ceil((documentBytes + yjsOverhead) / 3);
+}
+function collaborationCursorKey(previousKey) {
+  const match = previousKey?.match(/^v2:(\d{20})$/);
+  if (previousKey?.startsWith("v2:") && !match) throw new MdfnServerError("MDFN_COLLAB_CURSOR_INVALID", 500);
+  const sequence = (match ? BigInt(match[1]) : 0n) + 1n;
+  const encoded = sequence.toString().padStart(20, "0");
+  if (encoded.length > 20) throw new MdfnServerError("MDFN_COLLAB_CURSOR_EXHAUSTED", 500);
+  return `v2:${encoded}`;
+}
+function isUniqueConflict(error) {
+  const value = error;
+  const cause = value?.cause;
+  return /(?:unique|duplicate|23505|p2002)/i.test([value?.code, value?.message, cause?.code, cause?.message].filter(Boolean).join(" "));
+}
+function encodeCollaborationCursor(documentId, key) {
+  return encodeURIComponent(JSON.stringify({ documentId, key }));
+}
+function decodeCollaborationCursor(cursor, documentId) {
+  try {
+    const parsed = JSON.parse(decodeURIComponent(cursor));
+    if (parsed.documentId !== documentId || typeof parsed.key !== "string" || !parsed.key) {
+      throw new Error("invalid cursor");
+    }
+    return parsed.key;
+  } catch {
+    throw new MdfnServerError("MDFN_COLLAB_CURSOR_INVALID", 422);
+  }
+}
+function getSchema() {
+  const date = { type: "date", required: true, dateValueType: "date" };
+  return { version: MDFN_SERVER_SCHEMA_VERSION, schemas: [
+    { modelName: DOCUMENTS, fields: { id: { type: "string", required: true }, collaborationGeneration: { type: "string", required: true }, ownerId: { type: "string", required: true }, tenantId: { type: "string" }, title: { type: "string" }, markdown: { type: "string", required: true }, sourceHash: { type: "string", required: true }, schemaHash: { type: "string", required: true }, sidecar: { type: "json" }, version: { type: "number", required: true }, createdAt: date, updatedAt: date }, indexes: [{ name: "idx_mdfn_documents_owner", fields: ["ownerId"] }, { name: "idx_mdfn_documents_tenant", fields: ["tenantId"] }] },
+    { modelName: VERSIONS, fields: { id: { type: "string", required: true }, documentId: { type: "string", required: true }, collaborationGeneration: { type: "string", required: true }, ownerId: { type: "string", required: true }, tenantId: { type: "string" }, title: { type: "string" }, markdown: { type: "string", required: true }, sourceHash: { type: "string", required: true }, schemaHash: { type: "string", required: true }, sidecar: { type: "json" }, version: { type: "number", required: true }, authorId: { type: "string", required: true }, changeSource: { type: "string", required: true }, createdAt: date, updatedAt: date }, indexes: [{ name: "idx_mdfn_versions_document_version", fields: ["documentId", "version"], unique: true }] },
+    { modelName: RECEIPTS, fields: { id: { type: "string", required: true }, documentId: { type: "string", required: true }, idempotencyKey: { type: "string", required: true }, operation: { type: "string", required: true }, payloadHash: { type: "string", required: true }, result: { type: "json", required: true }, createdAt: date }, indexes: [{ name: "idx_mdfn_receipts_key", fields: ["documentId", "idempotencyKey"], unique: true }] },
+    { modelName: COLLAB_UPDATES, fields: { id: { type: "string", required: true }, documentId: { type: "string", required: true, references: { model: DOCUMENTS, field: "id", onDelete: "cascade" } }, documentGeneration: { type: "string", required: true }, authorId: { type: "string", required: true }, update: { type: "string", required: true }, cursorKey: { type: "string", required: true }, createdAt: date }, indexes: [{ name: "idx_mdfn_collab_generation_cursor", fields: ["documentId", "documentGeneration", "cursorKey"], unique: true }] }
+  ] };
+}
+async function allowed(config, action, principal, document) {
+  if (!await config.authorize(action, principal, document)) throw new MdfnServerError("MDFN_FORBIDDEN", 403);
+}
+function whereId(id) {
+  return [{ field: "id", operator: "eq", value: id }];
+}
+function createMdfnService(config) {
+  const database = (0, import_db.wrapWithSchema)(config.database, getSchema());
+  if ((config.durability ?? "required") === "required") {
+    if (!database.capabilities.transactions.supported) {
+      throw new MdfnServerError("MDFN_TRANSACTIONAL_DATABASE_REQUIRED", 500);
+    }
+    if (!database.capabilities.schema.constraints) {
+      throw new MdfnServerError("MDFN_RELATIONAL_CONSTRAINTS_REQUIRED", 500);
+    }
+  }
+  const registry = (0, import_core.resolveExtensions)(config.extensions ?? []);
+  const markdownOptions = { ...config.markdown, extensions: registry };
+  const createId = config.createId ?? (() => crypto.randomUUID());
+  const createCollaborationGeneration = config.createCollaborationGeneration ?? (() => crypto.randomUUID());
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  const collaborationUpdateBytes = configuredCollaborationUpdateBytes(config);
+  const collaborationBatchBytes = Math.max(
+    collaborationUpdateBytes,
+    config.maxCollaborationBatchBytes ?? collaborationUpdateBytes * 4
+  );
+  const collaborationBatchUpdates = Math.min(1e3, Math.max(1, config.maxCollaborationBatchUpdates ?? 100));
+  const parse = (source, sidecar) => {
+    try {
+      (0, import_markdown.parseMarkdown)(source, markdownOptions);
+      (0, import_core.validateMdfnSidecar)(sidecar, { markdownLength: source.length });
+    } catch {
+      throw new MdfnServerError("MDFN_DOCUMENT_INVALID", 422);
+    }
+  };
+  const loadFrom = async (storage, id) => {
+    const result = await storage.findOne({ model: DOCUMENTS, where: whereId(id) });
+    if (!result) throw new MdfnServerError("MDFN_DOCUMENT_NOT_FOUND", 404);
+    return result;
+  };
+  const load = (id) => loadFrom(database, id);
+  const loadScopedFrom = async (storage, principal, id) => {
+    const document = await loadFrom(storage, id);
+    const inScope = principal.tenantId ? document.tenantId === principal.tenantId : document.tenantId === void 0 && document.ownerId === principal.id;
+    if (!inScope) throw new MdfnServerError("MDFN_DOCUMENT_NOT_FOUND", 404);
+    return document;
+  };
+  const loadScoped = (principal, id) => loadScopedFrom(database, principal, id);
+  const revision = (document, authorId, changeSource) => ({ ...document, id: `${document.id}:${document.version}`, documentId: document.id, authorId, changeSource });
+  const withStorage = (callback) => database.capabilities.transactions.supported ? database.transaction((transaction) => callback(transaction)) : callback(database);
+  const collaborationWriteTails = /* @__PURE__ */ new Map();
+  const serializeCollaborationWrite = async (documentId, callback) => {
+    const previous = collaborationWriteTails.get(documentId) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+      release = resolve;
+    });
+    const tail = previous.then(() => gate);
+    collaborationWriteTails.set(documentId, tail);
+    await previous;
+    try {
+      return await callback();
+    } finally {
+      release();
+      if (collaborationWriteTails.get(documentId) === tail) collaborationWriteTails.delete(documentId);
+    }
+  };
+  const withCollaborationWrite = (principal, documentId, action, callback) => serializeCollaborationWrite(documentId, async () => {
+    const authorizedDocument = await loadScoped(principal, documentId);
+    await allowed(config, action, principal, authorizedDocument);
+    const documentGeneration = authorizedDocument.collaborationGeneration;
+    let lastConflict;
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      try {
+        const result = await withStorage(async (storage) => {
+          const storedDocument = await loadScopedFrom(storage, principal, documentId);
+          if (storedDocument.collaborationGeneration !== documentGeneration) {
+            throw new MdfnServerError("MDFN_DOCUMENT_NOT_FOUND", 404);
+          }
+          const latest = await storage.findMany({
+            model: COLLAB_UPDATES,
+            where: [
+              { field: "documentId", operator: "eq", value: documentId },
+              { field: "documentGeneration", operator: "eq", value: documentGeneration }
+            ],
+            select: ["cursorKey"],
+            orderBy: [{ field: "cursorKey", direction: "desc" }],
+            limit: 1
+          });
+          return callback(storage, collaborationCursorKey(latest[0]?.cursorKey), documentGeneration);
+        });
+        let latestDocument;
+        try {
+          latestDocument = await loadScoped(principal, documentId);
+        } catch (error) {
+          if (!(error instanceof MdfnServerError && error.code === "MDFN_DOCUMENT_NOT_FOUND")) throw error;
+        }
+        if (latestDocument?.collaborationGeneration !== documentGeneration) {
+          await database.deleteMany({
+            model: COLLAB_UPDATES,
+            where: [
+              { field: "documentId", operator: "eq", value: documentId },
+              { field: "documentGeneration", operator: "eq", value: documentGeneration }
+            ]
+          });
+          throw new MdfnServerError("MDFN_DOCUMENT_NOT_FOUND", 404);
+        }
+        return result;
+      } catch (error) {
+        if (!isUniqueConflict(error)) throw error;
+        lastConflict = error;
+      }
+    }
+    throw lastConflict;
+  });
+  let service;
+  const editorialActor = (principal) => ({ id: principal.id, createId, now: () => now().toISOString() });
+  const maxTitleBytes = config.maxTitleBytes ?? 512;
+  if (!Number.isSafeInteger(maxTitleBytes) || maxTitleBytes < 1) {
+    throw new MdfnServerError("MDFN_TITLE_LIMIT_INVALID", 500);
+  }
+  const validateTitle = (title) => {
+    if (title !== void 0 && new TextEncoder().encode(title).byteLength > maxTitleBytes) {
+      throw new MdfnServerError("MDFN_TITLE_TOO_LARGE", 413);
+    }
+  };
+  const canonicalJson = (value) => {
+    if (Array.isArray(value)) return value.map(canonicalJson);
+    if (value === null || typeof value !== "object") return value;
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, canonicalJson(entry)])
+    );
+  };
+  const hashValue = (value) => (0, import_core.hashString)(JSON.stringify(canonicalJson(value)));
+  const protectedSidecar = (value) => JSON.stringify(canonicalJson({
+    comments: value?.comments ?? [],
+    suggestions: value?.suggestions ?? [],
+    reviewState: value?.reviewState ?? "draft",
+    audit: value?.audit ?? []
+  }));
+  const coarseChangedRanges = (before, after, offset) => {
+    const ranges = [];
+    const syncLength = 16;
+    const initialLookahead = 2048;
+    let remainingSearchWork = 65536;
+    let left = 0;
+    let right = 0;
+    let position = offset;
+    while (left < before.length || right < after.length) {
+      while (left < before.length && right < after.length && before.charCodeAt(left) === after.charCodeAt(right)) {
+        left += 1;
+        right += 1;
+        position += 1;
+      }
+      if (left === before.length && right === after.length) break;
+      const from = position;
+      let match;
+      let lookahead = initialLookahead;
+      const beforeAnchors = /* @__PURE__ */ new Map();
+      const afterAnchors = /* @__PURE__ */ new Map();
+      let beforeScannedTo = left - 1;
+      let afterScannedTo = right - 1;
+      while (!match) {
+        const beforeLimit = Math.min(before.length - syncLength, left + lookahead);
+        for (let candidate = beforeScannedTo + 1; candidate <= beforeLimit; candidate += 1) {
+          if (remainingSearchWork === 0) break;
+          remainingSearchWork -= 1;
+          const key = before.slice(candidate, candidate + syncLength);
+          if (!beforeAnchors.has(key)) beforeAnchors.set(key, candidate);
+          const matchingRight = afterAnchors.get(key);
+          if (matchingRight !== void 0) {
+            const cost = candidate - left + matchingRight - right;
+            if (!match || cost < match.cost) match = { left: candidate, right: matchingRight, cost };
+          }
+          beforeScannedTo = candidate;
+        }
+        const afterLimit = Math.min(after.length - syncLength, right + lookahead);
+        for (let candidate = afterScannedTo + 1; candidate <= afterLimit; candidate += 1) {
+          if (remainingSearchWork === 0) break;
+          remainingSearchWork -= 1;
+          const key = after.slice(candidate, candidate + syncLength);
+          if (!afterAnchors.has(key)) afterAnchors.set(key, candidate);
+          const matchingLeft = beforeAnchors.get(key);
+          if (matchingLeft !== void 0) {
+            const cost = matchingLeft - left + candidate - right;
+            if (!match || cost < match.cost) match = { left: matchingLeft, right: candidate, cost };
+          }
+          afterScannedTo = candidate;
+        }
+        const searchedAllBefore = before.length - left < syncLength || beforeScannedTo >= before.length - syncLength;
+        const searchedAllAfter = after.length - right < syncLength || afterScannedTo >= after.length - syncLength;
+        if (match || remainingSearchWork === 0 || searchedAllBefore && searchedAllAfter) break;
+        lookahead = Math.min(
+          Math.max(before.length - left, after.length - right),
+          lookahead * 2
+        );
+      }
+      if (!match || match.cost === 0) {
+        ranges.push({ from, to: from + before.length - left, insertedLength: after.length - right });
+        break;
+      }
+      const removed = match.left - left;
+      const insertedLength = match.right - right;
+      ranges.push({ from, to: from + removed, insertedLength });
+      left = match.left;
+      right = match.right;
+      position += insertedLength;
+    }
+    return ranges;
+  };
+  const changedRanges = (previous, next) => {
+    if (previous === next) return [];
+    let prefix = 0;
+    while (prefix < previous.length && prefix < next.length && previous.charCodeAt(prefix) === next.charCodeAt(prefix)) prefix += 1;
+    let previousEnd = previous.length;
+    let nextEnd = next.length;
+    while (previousEnd > prefix && nextEnd > prefix && previous.charCodeAt(previousEnd - 1) === next.charCodeAt(nextEnd - 1)) {
+      previousEnd -= 1;
+      nextEnd -= 1;
+    }
+    const before = previous.slice(prefix, previousEnd);
+    const after = next.slice(prefix, nextEnd);
+    if (before.length * after.length > 25e4) return coarseChangedRanges(before, after, prefix);
+    const width = after.length + 1;
+    const lcs = new Uint32Array((before.length + 1) * width);
+    for (let left2 = before.length - 1; left2 >= 0; left2 -= 1) {
+      for (let right2 = after.length - 1; right2 >= 0; right2 -= 1) {
+        const index = left2 * width + right2;
+        lcs[index] = before.charCodeAt(left2) === after.charCodeAt(right2) ? lcs[(left2 + 1) * width + right2 + 1] + 1 : Math.max(lcs[(left2 + 1) * width + right2], lcs[index + 1]);
+      }
+    }
+    const ranges = [];
+    let left = 0;
+    let right = 0;
+    let position = prefix;
+    while (left < before.length || right < after.length) {
+      if (left < before.length && right < after.length && before.charCodeAt(left) === after.charCodeAt(right)) {
+        left += 1;
+        right += 1;
+        position += 1;
+        continue;
+      }
+      const from = position;
+      let removed = 0;
+      let insertedLength = 0;
+      while (left < before.length || right < after.length) {
+        if (left < before.length && right < after.length && before.charCodeAt(left) === after.charCodeAt(right)) break;
+        if (right < after.length && (left === before.length || lcs[left * width + right + 1] >= lcs[(left + 1) * width + right])) {
+          right += 1;
+          insertedLength += 1;
+        } else {
+          left += 1;
+          removed += 1;
+        }
+      }
+      ranges.push({ from, to: from + removed, insertedLength });
+      position += insertedLength;
+    }
+    return ranges;
+  };
+  const mapForMarkdownChange = (sidecar, previous, next) => {
+    if (!sidecar || previous === next) return sidecar;
+    return (0, import_core.mapSidecar)(sidecar, changedRanges(previous, next));
+  };
+  const replayReceipt = async (storage, documentId, idempotencyKey, operation, payloadHash) => {
+    const receipt = await storage.findOne({ model: RECEIPTS, where: [{ field: "documentId", operator: "eq", value: documentId }, { field: "idempotencyKey", operator: "eq", value: idempotencyKey }] });
+    if (!receipt) return void 0;
+    if (receipt.operation !== operation || receipt.payloadHash !== payloadHash) throw new MdfnServerError("MDFN_IDEMPOTENCY_KEY_REUSED", 409);
+    return receipt.result;
+  };
+  const writeUpdate = async (principal, id, input, options = {}) => {
+    const current = await loadScoped(principal, id);
+    await allowed(config, options.authorizationAction ?? "update", principal, current);
+    const operation = options.idempotencyOperation ?? "document:update";
+    const payloadHash = hashValue(options.idempotencyPayload ?? {
+      ...input,
+      idempotencyKey: void 0,
+      restoreSnapshot: options.restoreSnapshot
+    });
+    if (input.idempotencyKey) {
+      const replay = await replayReceipt(database, id, input.idempotencyKey, operation, payloadHash);
+      if (replay) return replay;
+    }
+    if (current.version !== input.expectedVersion) throw new MdfnServerError("MDFN_VERSION_CONFLICT", 409);
+    const markdown = options.restoreSnapshot?.markdown ?? input.markdown ?? current.markdown;
+    if (!options.trustedEditorial && input.sidecar && protectedSidecar(input.sidecar) !== protectedSidecar(current.sidecar)) {
+      throw new MdfnServerError("MDFN_EDITORIAL_MUTATION_FORBIDDEN", 403);
+    }
+    const mappedSidecar = mapForMarkdownChange(current.sidecar, current.markdown, markdown);
+    const sidecar = options.restoreSnapshot ? options.restoreSnapshot.sidecar : options.trustedEditorial ? input.sidecar ?? mappedSidecar : input.sidecar ? {
+      ...input.sidecar,
+      comments: mappedSidecar?.comments,
+      suggestions: mappedSidecar?.suggestions,
+      reviewState: mappedSidecar?.reviewState,
+      audit: mappedSidecar?.audit
+    } : mappedSidecar;
+    parse(markdown, sidecar);
+    const title = options.restoreSnapshot ? options.restoreSnapshot.title : input.title ?? current.title;
+    validateTitle(title);
+    const next = { ...current, title, markdown, sourceHash: (0, import_core.hashString)(markdown), schemaHash: registry.schemaHash, sidecar, version: current.version + 1, updatedAt: now() };
+    return withStorage(async (storage) => {
+      if (input.idempotencyKey) {
+        const replay = await replayReceipt(storage, id, input.idempotencyKey, operation, payloadHash);
+        if (replay) return replay;
+      }
+      const latest = await storage.findOne({ model: DOCUMENTS, where: whereId(id) });
+      if (!latest || latest.version !== input.expectedVersion) throw new MdfnServerError("MDFN_VERSION_CONFLICT", 409);
+      const updated = await storage.update({ model: DOCUMENTS, where: [{ field: "id", operator: "eq", value: id }, { field: "version", operator: "eq", value: input.expectedVersion }], data: next });
+      await storage.create({ model: VERSIONS, data: revision(updated, principal.id, input.changeSource ?? "update") });
+      if (input.idempotencyKey) await storage.create({ model: RECEIPTS, data: { id: createId(), documentId: id, idempotencyKey: input.idempotencyKey, operation, payloadHash, result: updated, createdAt: now() } });
+      return updated;
+    });
+  };
+  const mutateEditorial = async (principal, id, expectedVersion, authorizationAction, changeSource, idempotencyKey, idempotencyPayload, mutate) => {
+    const current = await loadScoped(principal, id);
+    await allowed(config, authorizationAction, principal, current);
+    if (idempotencyKey) {
+      const replay = await replayReceipt(database, id, idempotencyKey, changeSource, hashValue(idempotencyPayload));
+      if (replay) return replay;
+    }
+    if (current.version !== expectedVersion) throw new MdfnServerError("MDFN_VERSION_CONFLICT", 409);
+    try {
+      const next = mutate(current);
+      return writeUpdate(principal, id, { expectedVersion, markdown: next.markdown, sidecar: next.sidecar, changeSource, idempotencyKey }, { trustedEditorial: true, authorizationAction, idempotencyOperation: changeSource, idempotencyPayload });
+    } catch (error) {
+      if (error instanceof MdfnServerError) throw error;
+      throw new MdfnServerError("MDFN_EDITORIAL_INVALID", 422);
+    }
+  };
+  service = {
+    async create(principal, input) {
+      await allowed(config, "create", principal);
+      parse(input.markdown, input.sidecar);
+      validateTitle(input.title);
+      if (input.id !== void 0 && (typeof input.id !== "string" || input.id.trim().length === 0)) {
+        throw new MdfnServerError("MDFN_DOCUMENT_ID_INVALID", 422);
+      }
+      if (input.sidecar && protectedSidecar(input.sidecar) !== protectedSidecar(void 0)) {
+        throw new MdfnServerError("MDFN_EDITORIAL_MUTATION_FORBIDDEN", 403);
+      }
+      const createdAt = now();
+      const collaborationGeneration = createCollaborationGeneration();
+      if (typeof collaborationGeneration !== "string" || collaborationGeneration.length === 0) {
+        throw new MdfnServerError("MDFN_COLLAB_GENERATION_INVALID", 500);
+      }
+      const document = { id: input.id ?? createId(), collaborationGeneration, ownerId: principal.id, tenantId: principal.tenantId, title: input.title, markdown: input.markdown, sourceHash: (0, import_core.hashString)(input.markdown), schemaHash: registry.schemaHash, sidecar: input.sidecar, version: 1, createdAt, updatedAt: createdAt };
+      return withStorage(async (storage) => {
+        const created = await storage.create({ model: DOCUMENTS, data: document });
+        await storage.create({ model: VERSIONS, data: revision(created, principal.id, "create") });
+        return created;
+      });
+    },
+    async read(principal, id) {
+      const document = await loadScoped(principal, id);
+      await allowed(config, "read", principal, document);
+      return document;
+    },
+    async list(principal, options = {}) {
+      await allowed(config, "read", principal);
+      const where = principal.tenantId ? [{ field: "tenantId", operator: "eq", value: principal.tenantId }] : [{ field: "ownerId", operator: "eq", value: principal.id }];
+      const offset = Math.max(0, options.offset ?? 0);
+      const limit = Math.min(100, Math.max(1, options.limit ?? 50));
+      const pageSize = Math.max(25, limit);
+      const visible = [];
+      let databaseOffset = 0;
+      let authorizedOffset = 0;
+      while (visible.length < limit) {
+        const candidates = await database.findMany({
+          model: DOCUMENTS,
+          where,
+          orderBy: [{ field: "updatedAt", direction: "desc" }, { field: "id", direction: "desc" }],
+          limit: pageSize,
+          offset: databaseOffset
+        });
+        databaseOffset += candidates.length;
+        for (const document of candidates) {
+          if (!principal.tenantId && document.tenantId !== void 0 && document.tenantId !== null) continue;
+          if (!await config.authorize("read", principal, document)) continue;
+          if (authorizedOffset < offset) {
+            authorizedOffset += 1;
+            continue;
+          }
+          visible.push(document);
+          if (visible.length === limit) break;
+        }
+        if (candidates.length < pageSize) break;
+      }
+      return visible;
+    },
+    async update(principal, id, input) {
+      return writeUpdate(principal, id, input);
+    },
+    async delete(principal, id) {
+      await serializeCollaborationWrite(id, async () => {
+        const current = await loadScoped(principal, id);
+        await allowed(config, "delete", principal, current);
+        await withStorage(async (storage) => {
+          const documentWhere = [{ field: "documentId", operator: "eq", value: id }];
+          await storage.deleteMany({ model: COLLAB_UPDATES, where: documentWhere });
+          await storage.deleteMany({ model: RECEIPTS, where: documentWhere });
+          await storage.deleteMany({ model: VERSIONS, where: documentWhere });
+          await storage.delete({ model: DOCUMENTS, where: whereId(id) });
+        });
+      });
+    },
+    async versions(principal, id, options = {}) {
+      const document = await loadScoped(principal, id);
+      await allowed(config, "history", principal, document);
+      const cursor = options.cursor === void 0 ? void 0 : Number(options.cursor);
+      const requestedLimit = options.limit ?? 50;
+      if (cursor !== void 0 && (!Number.isSafeInteger(cursor) || cursor < 1) || !Number.isSafeInteger(requestedLimit) || requestedLimit < 1) {
+        throw new MdfnServerError("MDFN_VERSION_CURSOR_INVALID", 422);
+      }
+      const limit = Math.min(100, requestedLimit);
+      const where = [
+        { field: "documentId", operator: "eq", value: id },
+        ...cursor === void 0 ? [] : [{ field: "version", operator: "lt", value: cursor }]
+      ];
+      const rows = await database.findMany({
+        model: VERSIONS,
+        where,
+        select: [
+          "id",
+          "documentId",
+          "collaborationGeneration",
+          "ownerId",
+          "tenantId",
+          "title",
+          "sourceHash",
+          "schemaHash",
+          "version",
+          "authorId",
+          "changeSource",
+          "createdAt",
+          "updatedAt"
+        ],
+        orderBy: [{ field: "version", direction: "desc" }],
+        limit: limit + 1
+      });
+      const versions = rows.slice(0, limit);
+      return {
+        versions,
+        ...rows.length > limit ? { nextCursor: String(versions.at(-1).version) } : {}
+      };
+    },
+    async version(principal, id, version) {
+      const document = await loadScoped(principal, id);
+      await allowed(config, "history", principal, document);
+      const result = await database.findOne({ model: VERSIONS, where: [{ field: "documentId", operator: "eq", value: id }, { field: "version", operator: "eq", value: version }] });
+      if (!result) throw new MdfnServerError("MDFN_VERSION_NOT_FOUND", 404);
+      return result;
+    },
+    async restoreVersion(principal, id, input) {
+      const current = await loadScoped(principal, id);
+      await allowed(config, "history:restore", principal, current);
+      const restored = await database.findOne({
+        model: VERSIONS,
+        where: [
+          { field: "documentId", operator: "eq", value: id },
+          { field: "version", operator: "eq", value: input.version }
+        ]
+      });
+      if (!restored) throw new MdfnServerError("MDFN_VERSION_NOT_FOUND", 404);
+      return writeUpdate(
+        principal,
+        id,
+        { expectedVersion: input.expectedVersion, changeSource: `restore:${input.version}`, idempotencyKey: input.idempotencyKey },
+        {
+          trustedEditorial: true,
+          authorizationAction: "history:restore",
+          restoreSnapshot: restored,
+          idempotencyOperation: "document:restore",
+          idempotencyPayload: input
+        }
+      );
+    },
+    async createComment(principal, id, input) {
+      return mutateEditorial(principal, id, input.expectedVersion, "comment:create", "editorial:comment-created", input.idempotencyKey, input, (document) => (0, import_core.createCommentThread)({ sidecar: document.sidecar, anchor: input.anchor, body: input.body, actor: editorialActor(principal), markdownLength: document.markdown.length }));
+    },
+    async replyComment(principal, id, threadId, input) {
+      return mutateEditorial(principal, id, input.expectedVersion, "comment:reply", "editorial:comment-replied", input.idempotencyKey, { threadId, ...input }, (document) => ({ sidecar: (0, import_core.replyToComment)({ sidecar: document.sidecar ?? {}, threadId, body: input.body, actor: editorialActor(principal) }) }));
+    },
+    async resolveComment(principal, id, threadId, input) {
+      return mutateEditorial(principal, id, input.expectedVersion, "comment:resolve", input.resolved ? "editorial:comment-resolved" : "editorial:comment-reopened", input.idempotencyKey, { threadId, ...input }, (document) => ({ sidecar: (0, import_core.setCommentResolved)({ sidecar: document.sidecar ?? {}, threadId, resolved: input.resolved, actor: editorialActor(principal) }) }));
+    },
+    async createSuggestion(principal, id, input) {
+      return mutateEditorial(principal, id, input.expectedVersion, "suggestion:create", "editorial:suggestion-created", input.idempotencyKey, input, (document) => (0, import_core.createSuggestion)({ sidecar: document.sidecar, anchor: input.anchor, replacement: input.replacement, actor: editorialActor(principal), markdownLength: document.markdown.length }));
+    },
+    async decideSuggestion(principal, id, suggestionId, input) {
+      return mutateEditorial(principal, id, input.expectedVersion, "suggestion:decide", `editorial:suggestion-${input.decision}`, input.idempotencyKey, { suggestionId, ...input }, (document) => {
+        const controller = (0, import_core.createEditor)({ markdown: document.markdown, projector: (0, import_markdown.createMarkdownProjector)(markdownOptions), extensions: config.extensions, sidecar: document.sidecar });
+        try {
+          (0, import_core.decideSuggestion)({ controller, suggestionId, decision: input.decision, actor: editorialActor(principal) });
+          const state = controller.getState();
+          return { markdown: state.markdown, sidecar: state.sidecar ?? {} };
+        } finally {
+          controller.destroy();
+        }
+      });
+    },
+    async transitionReview(principal, id, input) {
+      return mutateEditorial(principal, id, input.expectedVersion, "review:transition", "editorial:review-transitioned", input.idempotencyKey, input, (document) => ({ sidecar: (0, import_core.transitionReview)({ sidecar: document.sidecar, to: input.state, actor: editorialActor(principal) }) }));
+    },
+    async appendCollaborationUpdate(principal, id, update) {
+      if (new TextEncoder().encode(update).byteLength > collaborationUpdateBytes) throw new MdfnServerError("MDFN_COLLAB_UPDATE_TOO_LARGE", 413);
+      const updateId = createId();
+      const createdAt = now();
+      await withCollaborationWrite(principal, id, "collaborate", async (storage, cursorKey, documentGeneration) => {
+        await storage.create({
+          model: COLLAB_UPDATES,
+          data: { id: updateId, documentId: id, documentGeneration, authorId: principal.id, update, cursorKey, createdAt }
+        });
+      });
+      return updateId;
+    },
+    async collaborationUpdates(principal, id, options = {}) {
+      const document = await loadScoped(principal, id);
+      await allowed(config, "collaborate", principal, document);
+      const requestedLimit = options.limit ?? collaborationBatchUpdates;
+      if (!Number.isSafeInteger(requestedLimit) || requestedLimit < 1) {
+        throw new MdfnServerError("MDFN_COLLAB_CURSOR_INVALID", 422);
+      }
+      const limit = Math.min(collaborationBatchUpdates, requestedLimit);
+      const cursor = options.cursor === void 0 ? void 0 : decodeCollaborationCursor(options.cursor, id);
+      const rows = await database.findMany({
+        model: COLLAB_UPDATES,
+        where: [
+          { field: "documentId", operator: "eq", value: id },
+          { field: "documentGeneration", operator: "eq", value: document.collaborationGeneration },
+          ...cursor === void 0 ? [] : [{ field: "cursorKey", operator: "gt", value: cursor }]
+        ],
+        orderBy: [{ field: "cursorKey", direction: "asc" }],
+        limit: limit + 1
+      });
+      const included = [];
+      let encodedBytes = 0;
+      for (const row of rows.slice(0, limit)) {
+        const rowBytes = new TextEncoder().encode(row.update).byteLength;
+        if (included.length > 0 && encodedBytes + rowBytes > collaborationBatchBytes) break;
+        included.push(row);
+        encodedBytes += rowBytes;
+      }
+      const hasMore = included.length < rows.length;
+      return {
+        updates: included.map((row) => row.update),
+        includedUpdateIds: included.map((row) => row.id),
+        ...hasMore ? { nextCursor: encodeCollaborationCursor(id, included.at(-1).cursorKey) } : {}
+      };
+    },
+    async compactCollaborationUpdates(principal, id, snapshot, includedUpdateIds) {
+      if (new TextEncoder().encode(snapshot).byteLength > collaborationUpdateBytes) throw new MdfnServerError("MDFN_COLLAB_UPDATE_TOO_LARGE", 413);
+      if (!Array.isArray(includedUpdateIds) || includedUpdateIds.some((updateId2) => typeof updateId2 !== "string" || !updateId2)) {
+        throw new MdfnServerError("MDFN_COLLAB_COMPACTION_INVALID", 422);
+      }
+      const uniqueUpdateIds = [...new Set(includedUpdateIds)];
+      const updateId = createId();
+      const createdAt = now();
+      await withCollaborationWrite(principal, id, "compact-collaboration", async (storage, cursorKey, documentGeneration) => {
+        if (uniqueUpdateIds.length > 0) {
+          await storage.deleteMany({ model: COLLAB_UPDATES, where: [{ field: "documentId", operator: "eq", value: id }, { field: "documentGeneration", operator: "eq", value: documentGeneration }, { field: "id", operator: "in", value: uniqueUpdateIds }] });
+        }
+        await storage.create({ model: COLLAB_UPDATES, data: { id: updateId, documentId: id, documentGeneration, authorId: principal.id, update: snapshot, cursorKey, createdAt } });
+      });
+      return updateId;
+    }
+  };
+  return service;
+}
+function etag(document) {
+  return `"mdfn-${document.version}-${document.sourceHash}"`;
+}
+function response(document, status = 200) {
+  return Response.json(document, { status, headers: { ETag: etag(document), "Cache-Control": "no-store" } });
+}
+function idempotent(request, body) {
+  return { ...body, idempotencyKey: body.idempotencyKey ?? request.headers.get("Idempotency-Key") ?? void 0 };
+}
+function createMdfnRouter(config, service = createMdfnService(config)) {
+  const principal = config.resolvePrincipal ?? (() => {
+    throw new MdfnServerError("MDFN_UNAUTHENTICATED", 401);
+  });
+  const defaultBodyBytes = Math.max(
+    configuredDocumentBytes(config) + 4 * 1024 * 1024,
+    configuredCollaborationUpdateBytes(config) + 64 * 1024
+  );
+  return (0, import_http.createRouter)({
+    basePath: config.basePath ?? "/api/mdfn",
+    maxBodyBytes: config.maxRequestBodyBytes ?? defaultBodyBytes,
+    context: async (request) => ({ principal: await principal(request) }),
+    onError: (error) => error instanceof MdfnServerError ? Response.json({ error: error.code }, { status: error.status }) : error instanceof import_http.RouterError ? error.toResponse() : Response.json({ error: "MDFN_INTERNAL_ERROR" }, { status: 500 }),
+    routes: [
+      { method: "GET", path: "/documents", handler: (_request, context) => service.list(context.principal, { limit: Number(context.query.get("limit") ?? 50), offset: Number(context.query.get("offset") ?? 0) }).then((documents) => Response.json({ documents })) },
+      { method: "POST", path: "/documents", handler: async (_request, context) => response(await service.create(context.principal, await context.json()), 201) },
+      { method: "GET", path: "/documents/:id", handler: async (_request, context) => response(await service.read(context.principal, context.params.id)) },
+      { method: "PATCH", path: "/documents/:id", handler: async (request, context) => response(await service.update(context.principal, context.params.id, idempotent(request, await context.json()))) },
+      { method: "DELETE", path: "/documents/:id", handler: async (_request, context) => {
+        await service.delete(context.principal, context.params.id);
+        return new Response(null, { status: 204 });
+      } },
+      { method: "GET", path: "/documents/:id/versions", handler: async (_request, context) => Response.json(await service.versions(context.principal, context.params.id, { cursor: context.query.get("cursor") ?? void 0, limit: context.query.has("limit") ? Number(context.query.get("limit")) : void 0 })) },
+      { method: "GET", path: "/documents/:id/versions/:version", handler: async (_request, context) => Response.json(await service.version(context.principal, context.params.id, Number(context.params.version))) },
+      { method: "POST", path: "/documents/:id/restore", handler: async (request, context) => response(await service.restoreVersion(context.principal, context.params.id, idempotent(request, await context.json()))) },
+      { method: "GET", path: "/documents/:id/sidecar", handler: async (_request, context) => Response.json((await service.read(context.principal, context.params.id)).sidecar ?? {}) },
+      { method: "PUT", path: "/documents/:id/sidecar", handler: async (request, context) => {
+        const body = idempotent(request, await context.json());
+        return response(await service.update(context.principal, context.params.id, { ...body, changeSource: "sidecar" }));
+      } },
+      { method: "GET", path: "/documents/:id/audit", handler: async (_request, context) => Response.json({ audit: (await service.read(context.principal, context.params.id)).sidecar?.audit ?? [] }) },
+      { method: "POST", path: "/documents/:id/comments", handler: async (request, context) => response(await service.createComment(context.principal, context.params.id, idempotent(request, await context.json()))) },
+      { method: "POST", path: "/documents/:id/comments/:threadId/replies", handler: async (request, context) => response(await service.replyComment(context.principal, context.params.id, context.params.threadId, idempotent(request, await context.json()))) },
+      { method: "PATCH", path: "/documents/:id/comments/:threadId", handler: async (request, context) => response(await service.resolveComment(context.principal, context.params.id, context.params.threadId, idempotent(request, await context.json()))) },
+      { method: "POST", path: "/documents/:id/suggestions", handler: async (request, context) => response(await service.createSuggestion(context.principal, context.params.id, idempotent(request, await context.json()))) },
+      { method: "PATCH", path: "/documents/:id/suggestions/:suggestionId", handler: async (request, context) => response(await service.decideSuggestion(context.principal, context.params.id, context.params.suggestionId, idempotent(request, await context.json()))) },
+      { method: "PUT", path: "/documents/:id/review", handler: async (request, context) => response(await service.transitionReview(context.principal, context.params.id, idempotent(request, await context.json()))) },
+      { method: "GET", path: "/documents/:id/collaboration-updates", handler: async (_request, context) => Response.json(await service.collaborationUpdates(context.principal, context.params.id, { cursor: context.query.get("cursor") ?? void 0, limit: context.query.has("limit") ? Number(context.query.get("limit")) : void 0 })) },
+      { method: "POST", path: "/documents/:id/collaboration-updates", handler: async (_request, context) => {
+        const body = await context.json();
+        return Response.json({ id: await service.appendCollaborationUpdate(context.principal, context.params.id, body.update) }, { status: 201 });
+      } },
+      { method: "PUT", path: "/documents/:id/collaboration-updates/compact", handler: async (_request, context) => {
+        const body = await context.json();
+        return Response.json({ id: await service.compactCollaborationUpdates(context.principal, context.params.id, body.snapshot, body.includedUpdateIds) });
+      } }
+    ]
+  });
+}
+function createMdfnServer(config) {
+  const service = createMdfnService(config);
+  return { service, router: createMdfnRouter(config, service), schema: getSchema() };
+}
+var MDFN_SERVER_VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MDFN_SERVER_SCHEMA_VERSION,
+  MDFN_SERVER_VERSION,
+  MdfnServerError,
+  createMdfnRouter,
+  createMdfnServer,
+  createMdfnService,
+  getSchema
+});
+//# sourceMappingURL=index.cjs.map