collabmd 0.1.40 → 0.1.41

package/src/server/domain/bases/base-expression-runtime.js

@@ -472,63 +472,65 @@ function invokeGlobalFunction(name, argNodes, scope, evaluate) {
   }
 }
 
-function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
-  if (target?.__baseType === 'formula-namespace') {
-    if (argNodes.length > 0) {
-      throw new Error(`Formula namespace property "${name}" is not callable`);
-    }
-    return rootContext.resolveFormulaValue(name, target.row, target.evaluationState);
+const METHOD_NOT_HANDLED = Symbol('base-method-not-handled');
+const NULL_FALSE_METHODS = new Set([
+  'contains',
+  'containsAll',
+  'containsAny',
+  'endsWith',
+  'hasLink',
+  'hasProperty',
+  'hasTag',
+  'inFolder',
+  'linksTo',
+  'startsWith',
+]);
+
+function normalizeLinkComparablePath(value) {
+  if (value?.__baseType === 'file') {
+    return value.path;
   }
+  if (value?.__baseType === 'link') {
+    return value.path;
+  }
+  return String(value ?? '');
+}
 
-  if (target == null) {
-    switch (name) {
-      case 'contains':
-      case 'containsAll':
-      case 'containsAny':
-      case 'endsWith':
-      case 'hasLink':
-      case 'hasProperty':
-      case 'hasTag':
-      case 'inFolder':
-      case 'linksTo':
-      case 'startsWith':
-        return false;
-      case 'isEmpty':
-        return true;
-      default:
-        break;
-    }
+function invokeNullMethod(name) {
+  if (NULL_FALSE_METHODS.has(name)) {
+    return false;
+  }
+  if (name === 'isEmpty') {
+    return true;
   }
+  return METHOD_NOT_HANDLED;
+}
 
-  if (Array.isArray(target)) {
-    if (name === 'contains') {
+function invokeArrayMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'contains': {
       const needle = evaluate(argNodes[0], scope);
       return target.some((entry) => valuesEqual(entry, needle));
     }
-    if (name === 'containsAll') {
+    case 'containsAll':
       return argNodes.every((node) => target.some((entry) => valuesEqual(entry, evaluate(node, scope))));
-    }
-    if (name === 'containsAny') {
+    case 'containsAny':
       return argNodes.some((node) => target.some((entry) => valuesEqual(entry, evaluate(node, scope))));
-    }
-    if (name === 'filter') {
+    case 'filter': {
       const predicate = argNodes[0];
       return target.filter((value, index) => Boolean(evaluate(predicate, scope.child({ index, value }))));
     }
-    if (name === 'flat') {
+    case 'flat':
       return target.flat();
-    }
-    if (name === 'isEmpty') {
+    case 'isEmpty':
       return target.length === 0;
-    }
-    if (name === 'join') {
+    case 'join':
       return target.map((entry) => toDisplayText(entry)).join(String(evaluate(argNodes[0], scope) ?? ''));
-    }
-    if (name === 'map') {
+    case 'map': {
       const mapper = argNodes[0];
       return target.map((value, index) => evaluate(mapper, scope.child({ index, value })));
     }
-    if (name === 'reduce') {
+    case 'reduce': {
       const reducer = argNodes[0];
       let accumulator = argNodes.length > 1 ? evaluate(argNodes[1], scope) : null;
       target.forEach((value, index) => {
@@ -536,16 +538,13 @@ function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
       });
       return accumulator;
     }
-    if (name === 'reverse') {
+    case 'reverse':
       return [...target].reverse();
-    }
-    if (name === 'slice') {
+    case 'slice':
       return target.slice(Number(evaluate(argNodes[0], scope) ?? 0), argNodes[1] ? Number(evaluate(argNodes[1], scope)) : undefined);
-    }
-    if (name === 'sort') {
+    case 'sort':
       return [...target].sort(compareValues);
-    }
-    if (name === 'unique') {
+    case 'unique': {
       const uniqueValues = [];
       target.forEach((value) => {
         if (!uniqueValues.some((entry) => valuesEqual(entry, value))) {
@@ -554,123 +553,160 @@ function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
       });
       return uniqueValues;
     }
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (typeof target === 'string') {
-    switch (name) {
-      case 'contains':
-        return target.toLowerCase().includes(String(evaluate(argNodes[0], scope) ?? '').toLowerCase());
-      case 'endsWith':
-        return target.endsWith(String(evaluate(argNodes[0], scope) ?? ''));
-      case 'isEmpty':
-        return target.length === 0;
-      case 'lower':
-        return target.toLowerCase();
-      case 'replace':
-        return target.replaceAll(String(evaluate(argNodes[0], scope) ?? ''), String(evaluate(argNodes[1], scope) ?? ''));
-      case 'split':
-        return target.split(String(evaluate(argNodes[0], scope) ?? ''));
-      case 'startsWith':
-        return target.startsWith(String(evaluate(argNodes[0], scope) ?? ''));
-      case 'title':
-        return target.replace(/\b\p{L}/gu, (match) => match.toUpperCase());
-      case 'trim':
-        return target.trim();
-      case 'upper':
-        return target.toUpperCase();
-      default:
-        break;
-    }
+function invokeStringMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'contains':
+      return target.toLowerCase().includes(String(evaluate(argNodes[0], scope) ?? '').toLowerCase());
+    case 'endsWith':
+      return target.endsWith(String(evaluate(argNodes[0], scope) ?? ''));
+    case 'isEmpty':
+      return target.length === 0;
+    case 'lower':
+      return target.toLowerCase();
+    case 'replace':
+      return target.replaceAll(String(evaluate(argNodes[0], scope) ?? ''), String(evaluate(argNodes[1], scope) ?? ''));
+    case 'split':
+      return target.split(String(evaluate(argNodes[0], scope) ?? ''));
+    case 'startsWith':
+      return target.startsWith(String(evaluate(argNodes[0], scope) ?? ''));
+    case 'title':
+      return target.replace(/\b\p{L}/gu, (match) => match.toUpperCase());
+    case 'trim':
+      return target.trim();
+    case 'upper':
+      return target.toUpperCase();
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (typeof target === 'number') {
-    switch (name) {
-      case 'ceil':
-        return Math.ceil(target);
-      case 'floor':
-        return Math.floor(target);
-      case 'isEmpty':
-        return false;
-      case 'round':
-        return Number.isFinite(evaluate(argNodes[0], scope))
-          ? Number(target.toFixed(Number(evaluate(argNodes[0], scope))))
-          : Math.round(target);
-      case 'toFixed':
-        return target.toFixed(Number(evaluate(argNodes[0], scope) ?? 0));
-      default:
-        break;
+function invokeNumberMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'ceil':
+      return Math.ceil(target);
+    case 'floor':
+      return Math.floor(target);
+    case 'isEmpty':
+      return false;
+    case 'round': {
+      const precision = evaluate(argNodes[0], scope);
+      return Number.isFinite(precision)
+        ? Number(target.toFixed(Number(precision)))
+        : Math.round(target);
     }
+    case 'toFixed':
+      return target.toFixed(Number(evaluate(argNodes[0], scope) ?? 0));
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
+function invokeDateMethod(target, name, argNodes, scope, evaluate) {
   const asDate = parseDateValue(target);
-  if (asDate) {
-    switch (name) {
-      case 'format':
-        return formatDateValue(asDate, String(evaluate(argNodes[0], scope) ?? 'YYYY-MM-DD'));
-      case 'isEmpty':
-        return false;
-      default:
-        break;
-    }
+  if (!asDate) {
+    return METHOD_NOT_HANDLED;
   }
 
-  if (target?.__baseType === 'file') {
-    switch (name) {
-      case 'asLink':
-        return createLinkValue(target.path, {
-          display: typeof evaluate(argNodes[0], scope) === 'string' ? evaluate(argNodes[0], scope) : '',
-          exists: true,
-        });
-      case 'hasLink': {
-        const needle = evaluate(argNodes[0], scope);
-        const needlePath = needle?.__baseType === 'file'
-          ? needle.path
-          : (needle?.__baseType === 'link' ? needle.path : String(needle ?? ''));
-        return target.links.some((link) => link.path === needlePath || link.rawTarget === needlePath);
-      }
-      case 'hasProperty':
-        return Object.hasOwn(target.properties, String(evaluate(argNodes[0], scope) ?? ''));
-      case 'hasTag':
-        return argNodes.some((node) => {
-          const value = String(evaluate(node, scope) ?? '').replace(/^#/u, '');
-          return target.tags.some((tag) => tag === value || tag.startsWith(`${value}/`));
-        });
-      case 'inFolder': {
-        const folder = String(evaluate(argNodes[0], scope) ?? '').replace(/\/+$/u, '');
-        return !folder || target.folder === folder || target.folder.startsWith(`${folder}/`);
-      }
-      default:
-        break;
-    }
+  switch (name) {
+    case 'format':
+      return formatDateValue(asDate, String(evaluate(argNodes[0], scope) ?? 'YYYY-MM-DD'));
+    case 'isEmpty':
+      return false;
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (target?.__baseType === 'link') {
-    switch (name) {
-      case 'asFile':
-        return target.path ? rootContext.snapshot.rowsByPath.get(target.path)?.file ?? null : null;
-      case 'linksTo': {
-        const other = evaluate(argNodes[0], scope);
-        const otherPath = other?.__baseType === 'file'
-          ? other.path
-          : (other?.__baseType === 'link' ? other.path : String(other ?? ''));
-        return target.path === otherPath;
-      }
-      default:
-        break;
+function invokeFileMethod(target, name, argNodes, scope, evaluate) {
+  switch (name) {
+    case 'asLink': {
+      const display = evaluate(argNodes[0], scope);
+      return createLinkValue(target.path, {
+        display: typeof display === 'string' ? display : '',
+        exists: true,
+      });
+    }
+    case 'hasLink': {
+      const needlePath = normalizeLinkComparablePath(evaluate(argNodes[0], scope));
+      return target.links.some((link) => link.path === needlePath || link.rawTarget === needlePath);
     }
+    case 'hasProperty':
+      return Object.hasOwn(target.properties, String(evaluate(argNodes[0], scope) ?? ''));
+    case 'hasTag':
+      return argNodes.some((node) => {
+        const value = String(evaluate(node, scope) ?? '').replace(/^#/u, '');
+        return target.tags.some((tag) => tag === value || tag.startsWith(`${value}/`));
+      });
+    case 'inFolder': {
+      const folder = String(evaluate(argNodes[0], scope) ?? '').replace(/\/+$/u, '');
+      return !folder || target.folder === folder || target.folder.startsWith(`${folder}/`);
+    }
+    default:
+      return METHOD_NOT_HANDLED;
+  }
+}
+
+function invokeLinkMethod(target, name, argNodes, scope, evaluate, rootContext) {
+  switch (name) {
+    case 'asFile':
+      return target.path ? rootContext.snapshot.rowsByPath.get(target.path)?.file ?? null : null;
+    case 'linksTo':
+      return target.path === normalizeLinkComparablePath(evaluate(argNodes[0], scope));
+    default:
+      return METHOD_NOT_HANDLED;
   }
+}
 
-  if (isPlainObject(target)) {
-    switch (name) {
-      case 'isEmpty':
-        return Object.keys(target).length === 0;
-      case 'keys':
-        return Object.keys(target);
-      case 'values':
-        return Object.values(target);
-      default:
-        break;
+function invokeObjectMethod(target, name) {
+  switch (name) {
+    case 'isEmpty':
+      return Object.keys(target).length === 0;
+    case 'keys':
+      return Object.keys(target);
+    case 'values':
+      return Object.values(target);
+    default:
+      return METHOD_NOT_HANDLED;
+  }
+}
+
+function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
+  if (target?.__baseType === 'formula-namespace') {
+    if (argNodes.length > 0) {
+      throw new Error(`Formula namespace property "${name}" is not callable`);
     }
+    return rootContext.resolveFormulaValue(name, target.row, target.evaluationState);
+  }
+
+  let result = METHOD_NOT_HANDLED;
+  if (target == null) {
+    result = invokeNullMethod(name);
+  } else if (Array.isArray(target)) {
+    result = invokeArrayMethod(target, name, argNodes, scope, evaluate);
+  } else if (typeof target === 'string') {
+    result = invokeStringMethod(target, name, argNodes, scope, evaluate);
+  } else if (typeof target === 'number') {
+    result = invokeNumberMethod(target, name, argNodes, scope, evaluate);
+  } else if (target?.__baseType === 'file') {
+    result = invokeFileMethod(target, name, argNodes, scope, evaluate);
+  } else if (target?.__baseType === 'link') {
+    result = invokeLinkMethod(target, name, argNodes, scope, evaluate, rootContext);
+  } else if (isPlainObject(target)) {
+    result = invokeObjectMethod(target, name);
+  }
+
+  if (result !== METHOD_NOT_HANDLED) {
+    return result;
+  }
+
+  result = invokeDateMethod(target, name, argNodes, scope, evaluate);
+  if (result !== METHOD_NOT_HANDLED) {
+    return result;
   }
 
   throw new Error(`Unsupported method "${name}"`);

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);
     }
   }