collabmd 0.1.39 → 0.1.41

package/src/server/domain/bases/base-index-snapshot-store.js

@@ -17,6 +17,28 @@ import { createLinkValue, dedupeLinkValues } from './base-expression-runtime.js'
 const INLINE_TAG_RE = /(^|[\s(])#([A-Za-z0-9/_-]+)/g;
 const INDEX_READ_CONCURRENCY = 8;
 
+function cloneSnapshotRowRecord(rowRecord) {
+  return {
+    forwardLinks: new Set(rowRecord.forwardLinks ?? []),
+    rawTargetKeys: new Set(rowRecord.rawTargetKeys ?? []),
+    row: structuredClone(rowRecord.row),
+  };
+}
+
+function createWorkspaceFileSetSignature(fileEntries = []) {
+  return fileEntries.join('\n');
+}
+
+function createRowCacheKey(filePath, workspaceState, fileSetSignature) {
+  const metadata = workspaceState?.metadata?.get(filePath) ?? null;
+  return [
+    filePath,
+    Number.isFinite(metadata?.mtimeMs) ? metadata.mtimeMs : '',
+    Number.isFinite(metadata?.size) ? metadata.size : '',
+    fileSetSignature,
+  ].join('\0');
+}
+
 function isPlainObject(value) {
   return Object.prototype.toString.call(value) === '[object Object]';
 }
@@ -119,6 +141,7 @@ export class BaseIndexSnapshotStore {
     this.workspaceStateSynchronizer = workspaceStateSynchronizer;
     this.indexSnapshot = null;
     this.lastWorkspaceState = null;
+    this.rowRecordCache = new Map();
   }
 
   async getWorkspaceState() {
@@ -285,20 +308,30 @@ export class BaseIndexSnapshotStore {
   async buildIndexSnapshot(workspaceState = null) {
     const resolvedWorkspaceState = workspaceState ?? await this.getWorkspaceState();
     const fileEntries = listWorkspaceFilePaths(resolvedWorkspaceState);
+    const fileSetSignature = createWorkspaceFileSetSignature(fileEntries);
     const wikiTargetIndex = createWikiTargetIndex(fileEntries);
     const markdownContents = new Map();
 
     await mapWithConcurrency(resolvedWorkspaceState.markdownPaths ?? [], INDEX_READ_CONCURRENCY, async (filePath) => {
-      markdownContents.set(filePath, await this.vaultFileStore.readMarkdownFile(filePath));
+      const cacheKey = createRowCacheKey(filePath, resolvedWorkspaceState, fileSetSignature);
+      if (!this.rowRecordCache.has(cacheKey)) {
+        markdownContents.set(filePath, await this.vaultFileStore.readMarkdownFile(filePath));
+      }
     });
 
     const rowsByPath = new Map();
     const forwardLinksByPath = new Map();
     const rawTargetKeysBySourcePath = new Map();
     const rawTargetSourcesByKey = new Map();
+    const nextRowRecordCache = new Map();
     fileEntries.forEach((filePath) => {
+      const cacheKey = createRowCacheKey(filePath, resolvedWorkspaceState, fileSetSignature);
+      const cachedRowRecord = this.rowRecordCache.get(cacheKey);
       const markdownContent = markdownContents.get(filePath) ?? null;
-      const rowRecord = this.createSnapshotRow(filePath, resolvedWorkspaceState, wikiTargetIndex, markdownContent);
+      const rowRecord = cachedRowRecord
+        ? cloneSnapshotRowRecord(cachedRowRecord)
+        : this.createSnapshotRow(filePath, resolvedWorkspaceState, wikiTargetIndex, markdownContent);
+      nextRowRecordCache.set(cacheKey, cloneSnapshotRowRecord(rowRecord));
       rowsByPath.set(filePath, rowRecord.row);
       forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
       rawTargetKeysBySourcePath.set(filePath, rowRecord.rawTargetKeys);
@@ -324,6 +357,7 @@ export class BaseIndexSnapshotStore {
     this.rebuildBacklinks(snapshot);
     this.indexSnapshot = snapshot;
     this.lastWorkspaceState = resolvedWorkspaceState;
+    this.rowRecordCache = nextRowRecordCache;
     return snapshot;
   }
 
@@ -380,6 +414,7 @@ export class BaseIndexSnapshotStore {
         return pathValue && isWorkspaceFileEntry(entry);
       });
 
+    const fileSetSignature = createWorkspaceFileSetSignature(snapshot.filePaths);
     await mapWithConcurrency(filePathsToRefresh, INDEX_READ_CONCURRENCY, async (filePath) => {
       const markdownContent = isMarkdownFilePath(filePath)
         ? await this.vaultFileStore.readMarkdownFile(filePath)
@@ -387,6 +422,11 @@ export class BaseIndexSnapshotStore {
       const rowRecord = this.createSnapshotRow(filePath, workspaceState, snapshot.wikiTargetIndex, markdownContent, {
         targetPathAliases,
       });
+      this.invalidateRowRecordCachePath(filePath);
+      this.rowRecordCache.set(
+        createRowCacheKey(filePath, workspaceState, fileSetSignature),
+        cloneSnapshotRowRecord(rowRecord),
+      );
       this.removeRawTargetSourceContributions(snapshot, filePath);
       snapshot.rowsByPath.set(filePath, rowRecord.row);
       snapshot.forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
@@ -394,6 +434,14 @@ export class BaseIndexSnapshotStore {
     });
   }
 
+  invalidateRowRecordCachePath(filePath) {
+    Array.from(this.rowRecordCache.keys()).forEach((cacheKey) => {
+      if (cacheKey === filePath || cacheKey.startsWith(`${filePath}\0`)) {
+        this.rowRecordCache.delete(cacheKey);
+      }
+    });
+  }
+
   async ensureIndexSnapshot({ basePath = '', sourcePath = '' } = {}) {
     await this.synchronizeWorkspaceState();
     let workspaceState = await this.getWorkspaceState();
@@ -510,9 +558,12 @@ export class BaseIndexSnapshotStore {
       });
 
       [...deletedFilePaths, ...removedChangedFilePaths].forEach((pathValue) => {
+        this.invalidateRowRecordCachePath(pathValue);
         this.removeSnapshotPath(snapshot, pathValue);
       });
       renamedFileEntries.forEach((entry) => {
+        this.invalidateRowRecordCachePath(entry.oldPath);
+        this.invalidateRowRecordCachePath(entry.newPath);
         this.removeSnapshotPath(snapshot, entry.oldPath);
       });
       [...createdFilePaths, ...renamedFileEntries.map((entry) => entry.newPath)].forEach((pathValue) => {

package/src/server/domain/bases/base-query-service.js

@@ -23,6 +23,14 @@ import { transformBaseSource } from './base-transform.js';
 
 export { serializeBaseDefinition } from './base-definition.js';
 
+const BASE_QUERY_ROW_CHUNK_SIZE = 50;
+
+function yieldToEventLoop() {
+  return new Promise((resolve) => {
+    setImmediate(resolve);
+  });
+}
+
 function buildSortChain(activeView) {
   const entries = [];
   (activeView.sort ?? []).forEach((sortConfig) => {
@@ -296,7 +304,7 @@ export class BaseQueryService {
     };
   }
 
-  collectCandidateRows({
+  async collectCandidateRows({
     activeView,
     astCache = new Map(),
     columns = [],
@@ -318,46 +326,55 @@ export class BaseQueryService {
       && (activeView.summaries?.length ?? 0) === 0;
     const hardLimit = Math.min(effectiveLimit, effectiveMaxRows);
 
-    snapshot.filePaths.forEach((filePath) => {
-      const row = snapshot.rowsByPath.get(filePath);
-      if (!row) {
-        return;
-      }
-
-      const rowContext = this.createRowQueryContext({
-        astCache,
-        definition,
-        row,
-        snapshot,
-        thisFile,
-      });
-      if (!evaluateFilterNode(definition.filters, rowContext) || !evaluateFilterNode(activeView.filters, rowContext)) {
-        return;
-      }
+    const filePaths = snapshot.filePaths ?? [];
+    for (let chunkStart = 0; chunkStart < filePaths.length; chunkStart += BASE_QUERY_ROW_CHUNK_SIZE) {
+      const chunkEnd = Math.min(chunkStart + BASE_QUERY_ROW_CHUNK_SIZE, filePaths.length);
+      for (let index = chunkStart; index < chunkEnd; index += 1) {
+        const filePath = filePaths[index];
+        const row = snapshot.rowsByPath.get(filePath);
+        if (!row) {
+          continue;
+        }
 
-      const rawCells = {};
-      evaluatedPropertyIds.forEach((propertyId) => {
-        rawCells[propertyId] = getPropertyValue(propertyId, row, definition, snapshot, thisFile, rowContext);
-      });
-
-      const candidateRow = {
-        file: row.file,
-        rawCells,
-      };
-      if (!rowMatchesSearch(candidateRow, columns, search)) {
-        return;
-      }
+        const rowContext = this.createRowQueryContext({
+          astCache,
+          definition,
+          row,
+          snapshot,
+          thisFile,
+        });
+        if (!evaluateFilterNode(definition.filters, rowContext) || !evaluateFilterNode(activeView.filters, rowContext)) {
+          continue;
+        }
 
-      if (canBoundDuringCollection) {
-        insertSortedBounded(rows, candidateRow, {
-          limit: hardLimit,
-          sortChain,
+        const rawCells = {};
+        evaluatedPropertyIds.forEach((propertyId) => {
+          rawCells[propertyId] = getPropertyValue(propertyId, row, definition, snapshot, thisFile, rowContext);
         });
-        return;
+
+        const candidateRow = {
+          file: row.file,
+          rawCells,
+        };
+        if (!rowMatchesSearch(candidateRow, columns, search)) {
+          continue;
+        }
+
+        if (canBoundDuringCollection) {
+          insertSortedBounded(rows, candidateRow, {
+            limit: hardLimit,
+            sortChain,
+          });
+          continue;
+        }
+
+        rows.push(candidateRow);
       }
 
-      rows.push(candidateRow);
-    });
+      if (chunkEnd < filePaths.length) {
+        await yieldToEventLoop();
+      }
+    }
 
     return rows;
   }
@@ -455,7 +472,7 @@ export class BaseQueryService {
     const requestedLimit = Number.isInteger(context.activeView.limit) && context.activeView.limit > 0
       ? context.activeView.limit
       : null;
-    let rows = this.collectCandidateRows({
+    let rows = await this.collectCandidateRows({
       ...context,
       astCache,
       limit: requestedLimit,
@@ -538,7 +555,7 @@ export class BaseQueryService {
       },
     };
     const astCache = new Map();
-    const rows = this.collectCandidateRows({
+    const rows = await this.collectCandidateRows({
       ...propertyValueContext,
       astCache,
       evaluatedPropertyIds: [...new Set([

package/src/server/domain/collaboration/collaboration-document-store.js

@@ -85,6 +85,7 @@ export class CollaborationDocumentStore {
   async persistState({
     commentThreads = [],
     content = '',
+    includeContent = true,
     snapshot = null,
   } = {}) {
     if (!this.vaultFileStore) {
@@ -95,16 +96,19 @@ export class CollaborationDocumentStore {
       const result = await this.vaultFileStore.persistCollaborationState(this.name, {
         commentThreads,
         content,
+        includeContent,
         snapshot,
       });
       assertWriteSucceeded(result, 'persist collaboration state', this.name);
     } else {
-      await this.writeContent(content);
+      if (includeContent) {
+        await this.writeContent(content);
+      }
       await this.writeCommentThreads(commentThreads);
       await this.writeSnapshot(snapshot);
     }
 
-    if (this.backlinkIndex && isMarkdownFilePath(this.name)) {
+    if (includeContent && this.backlinkIndex && isMarkdownFilePath(this.name)) {
       this.backlinkIndex.updateFile(this.name, content);
     }
   }

package/src/server/domain/collaboration/collaboration-room.js

@@ -11,6 +11,9 @@ import { RoomPersistenceController } from './room-persistence-controller.js';
 import { logPerfEvent } from '../../config/perf-logging.js';
 import { populateCommentThreads, serializeCommentThreads } from '../../../domain/comment-threads.js';
 import {
+  EXCALIDRAW_APP_STATE_KEY,
+  EXCALIDRAW_ELEMENTS_KEY,
+  EXCALIDRAW_FILES_KEY,
   isExcalidrawRoomDocStructured,
   migrateLegacyExcalidrawRoomData,
   readLegacyExcalidrawRoomScene,
@@ -128,6 +131,16 @@ function isWorkspaceRoom(name) {
   return name === WORKSPACE_ROOM_NAME;
 }
 
+function normalizeEditableText(content) {
+  return String(content ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+function isContentCleanOrigin(origin) {
+  return origin === 'hydrate'
+    || origin === 'workspace-reconcile'
+    || origin === 'excalidraw-history-reset';
+}
+
 function computeTextReplacement(currentContent, nextContent) {
   const currentText = String(currentContent ?? '');
   const nextText = String(nextContent ?? '');
@@ -194,6 +207,8 @@ export class CollaborationRoom {
     this.destroyed = false;
     this.cachedInitialSyncMessage = null;
     this.activePersistPromise = null;
+    this.persistedContentBaseline = null;
+    this.contentDirty = false;
     this.debugMetrics = {
       hydrateCount: 0,
       initialSyncCount: 0,
@@ -212,6 +227,7 @@ export class CollaborationRoom {
 
     this.awareness.setLocalState(null);
     this.registerDocListeners();
+    this.registerContentDirtyListeners();
   }
 
   async hydrate() {
@@ -290,7 +306,7 @@ export class CollaborationRoom {
                     ytext.insert(0, content);
                   }
                 } else if (content !== null) {
-                  ytext.insert(0, content);
+                  ytext.insert(0, normalizeEditableText(content));
                 }
                 populateCommentThreads(comments, commentThreads);
               }, 'hydrate');
@@ -304,6 +320,7 @@ export class CollaborationRoom {
           this.hydrated = true;
         } finally {
           if (this.hydrated) {
+            this.resetContentBaseline();
             this.debugMetrics.hydrateCount += 1;
             this.debugMetrics.lastHydrate = {
               commentThreadCount,
@@ -371,6 +388,44 @@ export class CollaborationRoom {
     });
   }
 
+  registerContentDirtyListeners() {
+    const markFromTransaction = (transaction) => {
+      if (isContentCleanOrigin(transaction?.origin)) {
+        return;
+      }
+
+      this.refreshContentDirty();
+    };
+
+    if (isExcalidrawRoom(this.name)) {
+      this.doc.getMap(EXCALIDRAW_ELEMENTS_KEY).observeDeep((_events, transaction) => {
+        markFromTransaction(transaction);
+      });
+      this.doc.getMap(EXCALIDRAW_FILES_KEY).observe((_event, transaction) => {
+        markFromTransaction(transaction);
+      });
+      this.doc.getMap(EXCALIDRAW_APP_STATE_KEY).observe((_event, transaction) => {
+        markFromTransaction(transaction);
+      });
+      return;
+    }
+
+    this.doc.getText('codemirror').observe((_event, transaction) => {
+      markFromTransaction(transaction);
+    });
+  }
+
+  resetContentBaseline() {
+    this.persistedContentBaseline = this.getPersistedContent();
+    this.contentDirty = false;
+  }
+
+  refreshContentDirty() {
+    const content = this.getPersistedContent();
+    this.contentDirty = content !== null && content !== this.persistedContentBaseline;
+    return this.contentDirty;
+  }
+
   getClientState(ws) {
     return this.clientStates.get(ws);
   }
@@ -433,12 +488,17 @@ export class CollaborationRoom {
         console.warn(`[room:${this.name}] Skipping persist because the Excalidraw scene is invalid`);
         return;
       }
+      const includeContent = this.refreshContentDirty();
       const commentThreads = serializeCommentThreads(this.doc.getArray('comments'));
       await this.documentStore.persistState({
         commentThreads,
         content,
+        includeContent,
         snapshot: Y.encodeStateAsUpdate(this.doc),
       });
+      if (includeContent) {
+        this.resetContentBaseline();
+      }
     })();
 
     const trackedPromise = persistPromise.finally(() => {
@@ -496,12 +556,15 @@ export class CollaborationRoom {
         }
       }, 'workspace-reconcile');
 
+      this.resetContentBaseline();
       return { ok: true, highlightRange: null };
     }
 
     const ytext = this.doc.getText('codemirror');
-    const replacement = computeTextReplacement(ytext.toString(), content);
+    const normalizedContent = normalizeEditableText(content);
+    const replacement = computeTextReplacement(ytext.toString(), normalizedContent);
     if (!replacement && !replaceCommentThreads) {
+      this.resetContentBaseline();
       return { highlightRange: null, ok: true, skipped: true };
     }
 
@@ -520,6 +583,7 @@ export class CollaborationRoom {
       }
     }, 'workspace-reconcile');
 
+    this.resetContentBaseline();
     return {
       highlightRange: replacement
         ? {

package/src/server/domain/comment-overview.js

@@ -0,0 +1,108 @@
+import { summarizeCommentExcerpt } from '../../domain/comment-threads.js';
+
+const COMMENT_OVERVIEW_PREVIEW_MAX_LENGTH = 140;
+
+function asFiniteNumber(value) {
+  return Number.isFinite(value) ? value : null;
+}
+
+function asString(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function getLatestMessage(messages = []) {
+  return messages.reduce((latest, message) => {
+    if (!latest) {
+      return message;
+    }
+
+    return (asFiniteNumber(message?.createdAt) ?? 0) >= (asFiniteNumber(latest?.createdAt) ?? 0)
+      ? message
+      : latest;
+  }, null);
+}
+
+function createThreadSummary(thread) {
+  if (!thread || asFiniteNumber(thread.resolvedAt) !== null) {
+    return null;
+  }
+
+  const id = asString(thread.id);
+  const anchorStartLine = asFiniteNumber(thread.anchorStartLine);
+  const anchorEndLine = asFiniteNumber(thread.anchorEndLine);
+  const messages = asArray(thread.messages);
+  if (!id || anchorStartLine === null || anchorEndLine === null || messages.length === 0) {
+    return null;
+  }
+
+  const latestMessage = getLatestMessage(messages);
+  const latestActivityAt = asFiniteNumber(latestMessage?.createdAt)
+    ?? asFiniteNumber(thread.createdAt)
+    ?? 0;
+
+  return {
+    anchor: {
+      endLine: Math.max(anchorEndLine, anchorStartLine),
+      kind: asString(thread.anchorKind) || 'line',
+      quote: asString(thread.anchorQuote),
+      startLine: Math.max(anchorStartLine, 1),
+    },
+    createdAt: asFiniteNumber(thread.createdAt) ?? latestActivityAt,
+    createdByColor: asString(thread.createdByColor),
+    createdByName: asString(thread.createdByName),
+    id,
+    latestActivityAt,
+    latestMessage: latestMessage
+      ? {
+        bodyPreview: summarizeCommentExcerpt(latestMessage.body, COMMENT_OVERVIEW_PREVIEW_MAX_LENGTH),
+        createdAt: asFiniteNumber(latestMessage.createdAt) ?? latestActivityAt,
+        userColor: asString(latestMessage.userColor),
+        userName: asString(latestMessage.userName) || 'Anonymous',
+      }
+      : null,
+    messageCount: messages.length,
+  };
+}
+
+export function createCommentOverview(entries = [], {
+  generatedAt = Date.now(),
+} = {}) {
+  const files = asArray(entries)
+    .map((entry) => {
+      const filePath = asString(entry?.filePath);
+      const threads = asArray(entry?.threads)
+        .map((thread) => createThreadSummary(thread))
+        .filter(Boolean)
+        .sort((left, right) => (
+          right.latestActivityAt - left.latestActivityAt
+            || left.anchor.startLine - right.anchor.startLine
+            || left.id.localeCompare(right.id)
+        ));
+
+      if (!filePath || threads.length === 0) {
+        return null;
+      }
+
+      return {
+        filePath,
+        latestActivityAt: threads[0].latestActivityAt,
+        threadCount: threads.length,
+        threads,
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) => (
+      right.latestActivityAt - left.latestActivityAt
+        || left.filePath.localeCompare(right.filePath, undefined, { sensitivity: 'base' })
+    ));
+
+  return {
+    files,
+    generatedAt,
+    totalThreadCount: files.reduce((total, file) => total + file.threadCount, 0),
+  };
+}

package/src/server/domain/hosted-workspace-contract.js

@@ -0,0 +1,18 @@
+import { normalizeEmailAddress } from '../auth/auth-common.js';
+
+export const HOSTED_ROLE_ADMIN = 'admin';
+export const HOSTED_ROLE_COLLABORATOR = 'collaborator';
+
+const SUPPORTED_ROLES = new Set([HOSTED_ROLE_ADMIN, HOSTED_ROLE_COLLABORATOR]);
+
+export function normalizeHostedEmail(value) {
+  return normalizeEmailAddress(value);
+}
+
+export function normalizeHostedRole(value) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!SUPPORTED_ROLES.has(normalized)) {
+    return '';
+  }
+  return normalized;
+}