collabmd 0.1.52 → 0.1.55

package/src/domain/comment-threads.js

@@ -6,6 +6,7 @@ export const COMMENT_ANCHOR_QUOTE_MAX_LENGTH = 280;
 export const COMMENT_REACTION_EMOJI_MAX_LENGTH = 16;
 
 const COMMENT_ANCHOR_KINDS = new Set(['diagram-element', 'line', 'text']);
+const REACTION_KEY_PREFIX = 'reaction:';
 
 function asFiniteNumber(value) {
   return Number.isFinite(value) ? value : null;
@@ -125,12 +126,16 @@ export function summarizeCommentExcerpt(value, maxLength = COMMENT_EXCERPT_MAX_L
   return `${normalized.slice(0, Math.max(maxLength - 1, 1)).trimEnd()}…`;
 }
 
-function normalizeReactionEmoji(value) {
+export function normalizeCommentReactionEmoji(value) {
   return Array.from(String(value ?? '').trim())
     .slice(0, COMMENT_REACTION_EMOJI_MAX_LENGTH)
     .join('');
 }
 
+export function createCommentReactionKey(messageId, emoji, userId) {
+  return `${REACTION_KEY_PREFIX}${JSON.stringify([messageId, emoji, userId])}`;
+}
+
 function createReactionUserRecord(user) {
   const userId = asString(readRecordValue(user, 'userId')).trim();
   if (!userId) {
@@ -146,7 +151,7 @@ function createReactionUserRecord(user) {
 }
 
 function createReactionGroupRecord(group) {
-  const emoji = normalizeReactionEmoji(readRecordValue(group, 'emoji'));
+  const emoji = normalizeCommentReactionEmoji(readRecordValue(group, 'emoji'));
   if (!emoji) {
     return null;
   }
@@ -212,10 +217,49 @@ function createMessageRecord(message) {
   };
 }
 
-function serializeMessages(messages) {
-  return asArray(messages)
+function serializeMessages(messages, thread) {
+  const records = asArray(messages)
     .map((message) => createMessageRecord(message))
     .filter(Boolean);
+  if (!(thread instanceof Y.Map)) {
+    return records;
+  }
+
+  const byId = new Map(records.map((message) => [message.id, message]));
+  const overrides = [...thread.entries()]
+    .filter(([key]) => key.startsWith(REACTION_KEY_PREFIX))
+    .sort(([left], [right]) => left.localeCompare(right));
+  for (const [key, value] of overrides) {
+    let identity;
+    try {
+      identity = JSON.parse(key.slice(REACTION_KEY_PREFIX.length));
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(identity) || identity.length !== 3 || !identity.every((part) => typeof part === 'string')) {
+      continue;
+    }
+    const [messageId, rawEmoji, userId] = identity;
+    const emoji = normalizeCommentReactionEmoji(rawEmoji);
+    const message = byId.get(messageId);
+    const user = value === null ? null : createReactionUserRecord(value);
+    if (!message || !emoji || !userId || (value !== null && user?.userId !== userId)) {
+      continue;
+    }
+
+    const groupIndex = message.reactions.findIndex((group) => group.emoji === emoji);
+    const users = new Map((message.reactions[groupIndex]?.users ?? []).map((entry) => [entry.userId, entry]));
+    if (user) users.set(userId, user);
+    else users.delete(userId);
+    if (users.size > 0) {
+      const group = { emoji, users: [...users.values()] };
+      if (groupIndex < 0) message.reactions.push(group);
+      else message.reactions[groupIndex] = group;
+    } else if (groupIndex >= 0) {
+      message.reactions.splice(groupIndex, 1);
+    }
+  }
+  return records;
 }
 
 export function createCommentId(prefix = 'comment') {
@@ -323,7 +367,7 @@ export function serializeCommentThread(thread) {
     anchorSnapshot: readThreadValue(thread, 'anchorSnapshot'),
     elementId: readThreadValue(thread, 'elementId'),
   });
-  const messages = serializeMessages(readThreadValue(thread, 'messages'));
+  const messages = serializeMessages(readThreadValue(thread, 'messages'), thread);
 
   if (!anchor || messages.length === 0) {
     return null;

package/src/domain/excalidraw-room-codec.js

@@ -1,8 +1,8 @@
 import * as Y from 'yjs';
 
-const EXCALIDRAW_TYPE = 'excalidraw';
-const EXCALIDRAW_VERSION = 2;
-const EXCALIDRAW_SOURCE = 'collabmd';
+import { createEmptyScene, normalizeScene, tryParseSceneJson } from './excalidraw-scene.js';
+
+export { tryParseSceneJson as tryParseExcalidrawSceneJson } from './excalidraw-scene.js';
 
 export const EXCALIDRAW_APP_STATE_KEY = 'excalidraw-app-state';
 export const EXCALIDRAW_ELEMENTS_KEY = 'excalidraw-elements';
@@ -13,65 +13,10 @@ export const EXCALIDRAW_ROOM_TEXT_KEY = 'codemirror';
 export const EXCALIDRAW_SCHEMA_VERSION_KEY = 'schemaVersion';
 export const EXCALIDRAW_REPLACE_GENERATION_KEY = 'replaceGeneration';
 
-function createEmptyScene() {
-  return {
-    type: EXCALIDRAW_TYPE,
-    version: EXCALIDRAW_VERSION,
-    source: EXCALIDRAW_SOURCE,
-    elements: [],
-    appState: {
-      gridSize: null,
-      viewBackgroundColor: '#ffffff',
-    },
-    files: {},
-  };
-}
-
-function normalizeAppState(appState = {}) {
-  return {
-    gridSize: appState?.gridSize ?? null,
-    viewBackgroundColor: appState?.viewBackgroundColor ?? '#ffffff',
-  };
-}
-
-function normalizeScene(raw) {
-  if (!raw || typeof raw !== 'object') {
-    return createEmptyScene();
-  }
-
-  return {
-    type: EXCALIDRAW_TYPE,
-    version: EXCALIDRAW_VERSION,
-    source: EXCALIDRAW_SOURCE,
-    elements: Array.isArray(raw.elements) ? raw.elements : [],
-    appState: normalizeAppState(raw.appState),
-    files: raw.files && typeof raw.files === 'object' ? raw.files : {},
-  };
-}
-
-function parseSceneJson(rawJson, { fallbackToEmpty = true } = {}) {
-  if (!rawJson) {
-    return fallbackToEmpty ? createEmptyScene() : null;
-  }
-
-  try {
-    return normalizeScene(JSON.parse(rawJson));
-  } catch {
-    return fallbackToEmpty ? createEmptyScene() : null;
-  }
-}
-
 function cloneJsonValue(value) {
   return structuredClone(value);
 }
 
-function getRevisionKey(element) {
-  const version = Number.isFinite(Number(element?.version)) ? Number(element.version) : 0;
-  const versionNonce = Number.isFinite(Number(element?.versionNonce)) ? Number(element.versionNonce) : 0;
-  const updated = Number.isFinite(Number(element?.updated)) ? Number(element.updated) : 0;
-  return `${version}:${versionNonce}:${updated}`;
-}
-
 function compareElementVersions(left, right) {
   const leftVersion = Number(left?.version) || 0;
   const rightVersion = Number(right?.version) || 0;
@@ -143,14 +88,18 @@ function selectWinningElementFromSlot(slot) {
   }
 
   let winningElement = null;
-  slot.forEach((value) => {
+  let winningKey = '';
+  slot.forEach((value, key) => {
     const candidate = readRevisionEntry(value);
     if (!candidate || !candidate.id) {
       return;
     }
 
-    if (!winningElement || compareElementVersions(candidate, winningElement) > 0) {
+    // Y.Map iteration order can differ across replicas; equal revisions need a stable tie-break.
+    const comparison = winningElement ? compareElementVersions(candidate, winningElement) : 1;
+    if (comparison > 0 || (comparison === 0 && key > winningKey)) {
       winningElement = candidate;
+      winningKey = key;
     }
   });
 
@@ -160,12 +109,16 @@ function selectWinningElementFromSlot(slot) {
 function writeElementSlot(slot, element, {
   maxRevisions = 2,
 } = {}) {
-  const revisionKey = getRevisionKey(element);
+  // Each writer keeps its own candidate so concurrent version/nonce winners survive.
+  // ponytail: metadata grows with writers, not edits; authoritative replace compacts
+  // legacy keys. Never replace a live slot while reconnecting peers can edit it.
+  const revisionKey = `writer:${slot.doc.clientID}`;
+  const previous = readRevisionEntry(slot.get(revisionKey));
+  if (previous && compareElementVersions(element, previous) < 0) {
+    return false;
+  }
   const serialized = cloneJsonValue(element);
-  const previous = slot.get(revisionKey);
-  const previousSerialized = previous && typeof previous === 'object'
-    ? JSON.stringify(previous)
-    : '';
+  const previousSerialized = previous ? JSON.stringify(previous) : '';
   const nextSerialized = JSON.stringify(serialized);
   if (previousSerialized === nextSerialized) {
     return false;
@@ -199,7 +152,8 @@ function pruneElementSlot(slot, maxRevisions = 2) {
     if (!right.element) {
       return 1;
     }
-    return compareElementVersions(left.element, right.element);
+    return compareElementVersions(left.element, right.element)
+      || (left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
   });
 
   while (revisions.length > maxRevisions) {
@@ -328,7 +282,7 @@ export function replaceExcalidrawRoomScene(ydoc, rawScene, {
     filesMap.set(key, cloneJsonValue(value));
   });
 
-  const nextAppState = normalizeAppState(scene.appState);
+  const nextAppState = scene.appState;
   appStateMap.set('gridSize', nextAppState.gridSize);
   appStateMap.set('viewBackgroundColor', nextAppState.viewBackgroundColor);
   meta.set(EXCALIDRAW_REPLACE_GENERATION_KEY, readExcalidrawReplaceGeneration(ydoc) + 1);
@@ -372,7 +326,7 @@ export function applySceneDiffToExcalidrawRoom(ydoc, rawScene, {
     changed = true;
   });
 
-  const nextAppState = normalizeAppState(scene.appState);
+  const nextAppState = scene.appState;
   Object.entries(nextAppState).forEach(([key, value]) => {
     if (appStateMap.get(key) === value) {
       return;
@@ -398,7 +352,7 @@ export function readLegacyExcalidrawRoomScene(ydoc) {
   }
 
   const rawJson = ydoc.getText(EXCALIDRAW_ROOM_TEXT_KEY).toString();
-  return parseSceneJson(rawJson, { fallbackToEmpty: false });
+  return tryParseSceneJson(rawJson);
 }
 
 export function migrateLegacyExcalidrawRoomData(ydoc, rawScene, options = {}) {
@@ -406,7 +360,3 @@ export function migrateLegacyExcalidrawRoomData(ydoc, rawScene, options = {}) {
   replaceExcalidrawRoomScene(ydoc, scene, options);
   return scene;
 }
-
-export function tryParseExcalidrawSceneJson(rawJson) {
-  return parseSceneJson(rawJson, { fallbackToEmpty: false });
-}

package/src/domain/excalidraw-scene.js

@@ -0,0 +1,48 @@
+export function createEmptyScene() {
+  return {
+    type: 'excalidraw',
+    version: 2,
+    source: 'collabmd',
+    elements: [],
+    appState: {
+      gridSize: null,
+      viewBackgroundColor: '#ffffff',
+    },
+    files: {},
+  };
+}
+
+export function normalizeScene(raw) {
+  if (!raw || typeof raw !== 'object') {
+    return createEmptyScene();
+  }
+
+  return {
+    type: 'excalidraw',
+    version: 2,
+    source: 'collabmd',
+    elements: Array.isArray(raw.elements) ? raw.elements : [],
+    appState: {
+      gridSize: raw.appState?.gridSize ?? null,
+      viewBackgroundColor: raw.appState?.viewBackgroundColor ?? '#ffffff',
+    },
+    files: raw.files && typeof raw.files === 'object' ? raw.files : {},
+  };
+}
+
+export function parseSceneJson(rawJson) {
+  const parsed = tryParseSceneJson(rawJson);
+  return parsed || createEmptyScene();
+}
+
+export function tryParseSceneJson(rawJson) {
+  if (!rawJson) {
+    return null;
+  }
+
+  try {
+    return normalizeScene(JSON.parse(rawJson));
+  } catch {
+    return null;
+  }
+}

package/src/domain/file-kind.js

@@ -1,6 +1,7 @@
 const MARKDOWN_FILE_EXTENSIONS = Object.freeze(['.md', '.markdown', '.mdx']);
 const HTML_FILE_EXTENSIONS = Object.freeze(['.html', '.htm']);
 const BASE_FILE_EXTENSION = '.base';
+const CANVAS_FILE_EXTENSION = '.canvas';
 const EXCALIDRAW_FILE_EXTENSION = '.excalidraw';
 const DRAWIO_FILE_EXTENSION = '.drawio';
 const MERMAID_FILE_EXTENSIONS = Object.freeze(['.mmd', '.mermaid']);
@@ -10,6 +11,7 @@ const STRUCTURIZR_FILE_EXTENSIONS = Object.freeze([STRUCTURIZR_FILE_EXTENSION]);
 const PDF_FILE_EXTENSION = '.pdf';
 const IMAGE_ATTACHMENT_EXTENSIONS = Object.freeze(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg']);
 const DIAGRAM_FILE_EXTENSIONS = Object.freeze([
+  CANVAS_FILE_EXTENSION,
   EXCALIDRAW_FILE_EXTENSION,
   DRAWIO_FILE_EXTENSION,
   ...MERMAID_FILE_EXTENSIONS,
@@ -24,7 +26,7 @@ const VAULT_FILE_EXTENSIONS = Object.freeze([
   PDF_FILE_EXTENSION,
   ...IMAGE_ATTACHMENT_EXTENSIONS,
 ]);
-const STRIP_VAULT_EXTENSION_PATTERN = /\.(?:md|markdown|mdx|html?|base|excalidraw|drawio|mmd|mermaid|puml|plantuml|dsl|pdf|png|jpe?g|webp|gif|svg)$/i;
+const STRIP_VAULT_EXTENSION_PATTERN = /\.(?:md|markdown|mdx|html?|base|canvas|excalidraw|drawio|mmd|mermaid|puml|plantuml|dsl|pdf|png|jpe?g|webp|gif|svg)$/i;
 
 function normalizeFilePath(filePath) {
   return String(filePath ?? '').trim().toLowerCase();
@@ -37,6 +39,7 @@ function hasFileExtension(filePath, extensions) {
 
 export {
   BASE_FILE_EXTENSION,
+  CANVAS_FILE_EXTENSION,
   DIAGRAM_FILE_EXTENSIONS,
   DRAWIO_FILE_EXTENSION,
   EXCALIDRAW_FILE_EXTENSION,
@@ -64,6 +67,10 @@ export function getVaultFileKind(filePath) {
     return 'base';
   }
 
+  if (hasFileExtension(filePath, [CANVAS_FILE_EXTENSION])) {
+    return 'canvas';
+  }
+
   if (hasFileExtension(filePath, [EXCALIDRAW_FILE_EXTENSION])) {
     return 'excalidraw';
   }
@@ -129,6 +136,10 @@ export function isExcalidrawFilePath(filePath) {
   return getVaultFileKind(filePath) === 'excalidraw';
 }
 
+export function isCanvasFilePath(filePath) {
+  return getVaultFileKind(filePath) === 'canvas';
+}
+
 export function isBaseFilePath(filePath) {
   return getVaultFileKind(filePath) === 'base';
 }
@@ -160,6 +171,7 @@ export function isImageAttachmentFilePath(filePath) {
 export function isDiagramFilePath(filePath) {
   const kind = getVaultFileKind(filePath);
   return kind === 'excalidraw'
+    || kind === 'canvas'
     || kind === 'drawio'
     || kind === 'mermaid'
     || kind === 'plantuml'

package/src/server/application/workspace-reconciliation.js

@@ -11,8 +11,6 @@ import {
   createWorkspaceTree,
   deriveNextWorkspaceStateForApiMutation as deriveNextWorkspaceStateFromApiMutation,
   diffWorkspaceEntries,
-  isIncrementalWorkspaceMutationAction,
-  readWorkspacePathState as readWorkspacePathStateFromAdapter,
 } from '../domain/workspace-state.js';
 
 function createEventId() {
@@ -87,18 +85,6 @@ export class WorkspaceReconciliation {
     return this.workspaceTree;
   }
 
-  isIncrementalApiAction(action) {
-    return isIncrementalWorkspaceMutationAction(action);
-  }
-
-  async readWorkspacePathState(pathValue, {
-    expectDirectory = null,
-  } = {}) {
-    return readWorkspacePathStateFromAdapter(this.workspaceStateAdapter, pathValue, {
-      expectDirectory,
-    });
-  }
-
   async deriveNextWorkspaceStateForApiMutation(action, workspaceChange = {}) {
     return deriveNextWorkspaceStateFromApiMutation(this.workspaceStateAdapter, {
       action,

package/src/server/config/env.js

@@ -1,5 +1,5 @@
 import { basename, isAbsolute, relative, resolve } from 'path';
-import { readFileSync } from 'node:fs';
+import { lstatSync, readdirSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'url';
 
 import {
@@ -222,11 +222,11 @@ export function parseVaultList(rawValue) {
 
 export function resolveConfiguredVaults(overrides = {}, env = process.env) {
   if (Array.isArray(overrides.vaults)) {
-    return overrides.vaults.map(({ id, dir, repoUrl }) => {
+    return overrides.vaults.map(({ id, dir, name, repoUrl }) => {
       if (!VAULT_ID_PATTERN.test(String(id ?? ''))) {
         throw new Error(`Invalid vault id "${id}". ${VAULT_ID_HINT}`);
       }
-      return { id, dir: resolve(dir), repoUrl: normalizeOptionalString(repoUrl) };
+      return { id, dir: resolve(dir), ...(name ? { name: normalizeOptionalString(name) } : {}), repoUrl: normalizeOptionalString(repoUrl) };
     });
   }
   // ponytail: explicit directory (CLI positional) wins over the operator list
@@ -235,13 +235,34 @@ export function resolveConfiguredVaults(overrides = {}, env = process.env) {
     return [{ id: basename(dir), dir }];
   }
   const rawList = normalizeOptionalString(env.COLLABMD_VAULTS);
-  if (!rawList) {
+  const discovery = normalizeOptionalString(env.COLLABMD_VAULT_DISCOVERY);
+  if (!rawList && !discovery) {
     const dir = resolveConfiguredVaultDir(overrides, env);
     return [{ id: basename(dir), dir }];
   }
-  const vaults = parseVaultList(rawList);
+  let vaults;
+  if (rawList) {
+    vaults = parseVaultList(rawList);
+  } else {
+    if (!['all', 'marked'].includes(discovery)) {
+      throw new Error('COLLABMD_VAULT_DISCOVERY must be "all" or "marked".');
+    }
+    const root = resolve(env.COLLABMD_VAULT_DIR || '.');
+    // ponytail: discover immediate real directories at startup; restart to pick up additions.
+    vaults = readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.')
+        && (discovery === 'all' || lstatSync(resolve(root, entry.name, '.collabmd'), { throwIfNoEntry: false })?.isDirectory()))
+      .sort((a, b) => a.name.localeCompare(b.name, 'en'))
+      .map((entry) => ({ id: entry.name, dir: resolve(root, entry.name) }));
+    if (vaults.length === 0) {
+      throw new Error('No vaults found. Check COLLABMD_VAULT_DIR and COLLABMD_VAULT_DISCOVERY.');
+    }
+  }
   const seenIds = new Set();
   for (const vault of vaults) {
+    if (!VAULT_ID_PATTERN.test(vault.id)) {
+      throw new Error(`Invalid vault id "${vault.id}". ${VAULT_ID_HINT}`);
+    }
     if (seenIds.has(vault.id)) {
       throw new Error(`Duplicate vault id "${vault.id}" in COLLABMD_VAULTS.`);
     }
@@ -262,6 +283,17 @@ export function mangleVaultIdForEnv(vaultId) {
   return String(vaultId ?? '').toUpperCase().replace(/[^A-Z0-9]/g, '_');
 }
 
+export function resolveVaultNames(vaults, env = process.env) {
+  return vaults.map((vault) => {
+    const suffix = mangleVaultIdForEnv(vault.id);
+    const name = normalizeOptionalString(env[`COLLABMD_VAULT_NAME_${suffix}`]);
+    if (name && vaults.filter((entry) => mangleVaultIdForEnv(entry.id) === suffix).length > 1) {
+      throw new Error(`Ambiguous vault name: multiple vaults share COLLABMD_VAULT_NAME_${suffix}.`);
+    }
+    return { ...vault, name: vault.name || name || vault.id };
+  });
+}
+
 // ponytail: explicit repoUrl wins, then COLLABMD_GIT_REPO_URL_<ID>, then the shared URL for the primary
 export function resolveVaultRepoUrls(vaultDefs = [], overrides = {}, env = process.env) {
   const globalRepoUrl = normalizeOptionalString(overrides.remote?.repoUrl ?? overrides.git?.remote?.repoUrl ?? env.COLLABMD_GIT_REPO_URL);
@@ -540,7 +572,7 @@ function resolvePublicDir(nodeEnv) {
 
 export function loadConfig(overrides = {}) {
   const nodeEnv = process.env.NODE_ENV || 'development';
-  const vaults = resolveVaultRepoUrls(resolveConfiguredVaults(overrides), overrides);
+  const vaults = resolveVaultNames(resolveVaultRepoUrls(resolveConfiguredVaults(overrides), overrides));
   // ponytail: vaultDir stays the primary vault; other vaults resolve through the registry
   const vaultDir = overrides.vaultDir || vaults[0].dir;
   const basePath = normalizeAppBasePath(process.env.BASE_PATH || '');
@@ -622,6 +654,7 @@ export function loadConfig(overrides = {}) {
     publicDir,
     vaultDir,
     vaults,
+    vaultDashboard: overrides.vaultDashboard ?? parseBooleanFlag(process.env.COLLABMD_VAULT_DASHBOARD),
     publicWsBaseUrl: process.env.PUBLIC_WS_BASE_URL || '',
     testWsRoomHydrateDelayMs: parsePositiveInt(process.env.TEST_WS_ROOM_HYDRATE_DELAY_MS, 0),
     wikiLinkAutoCreate: process.env.COLLABMD_WIKI_LINK_AUTO_CREATE !== 'false',

package/src/server/domain/backlink-index.js

@@ -49,7 +49,6 @@ export class BacklinkIndex {
     /** @type {Set<string>} file path membership set */
     this._fileSet = new Set();
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
-    this._built = false;
     this._requestedBuildVersion = 0;
     this._completedBuildVersion = 0;
     this._buildPromise = null;
@@ -141,7 +140,7 @@ export class BacklinkIndex {
     this.rawTargetKeysBySource.clear();
     this.rawTargetSources.clear();
 
-    const snapshot = workspaceState ?? await this._resolveWorkspaceState();
+    const snapshot = workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
     this._fileList = Array.from(snapshot?.filePaths ?? snapshot?.markdownPaths ?? []);
     this._fileSet = new Set(this._fileList);
     this._sourceFileList = Array.from(
@@ -165,23 +164,9 @@ export class BacklinkIndex {
       }
     }
 
-    this._built = true;
     console.log(`[backlinks] Index built: ${this._sourceFileList.length} markdown sources, ${this._fileList.length} targets, ${this.reverse.size} targets with backlinks`);
   }
 
-  async _resolveWorkspaceState() {
-    if (typeof this.vaultFileStore.scanWorkspaceState === 'function') {
-      return this.vaultFileStore.scanWorkspaceState();
-    }
-
-    const tree = await this.vaultFileStore.tree();
-    const filePaths = flattenTree(tree);
-    return {
-      filePaths,
-      markdownPaths: filePaths.filter((filePath) => isMarkdownFilePath(filePath)),
-    };
-  }
-
   /**
    * Incrementally update the index when a file's content changes.
    * Call this after every persist / write.
@@ -469,13 +454,6 @@ export class BacklinkIndex {
     return results;
   }
 
-  /**
-   * Get the count of backlinks for a file (cheap — no I/O).
-   */
-  getBacklinkCount(filePath) {
-    return this.reverse.get(filePath)?.size ?? 0;
-  }
-
   // --- Private methods ---
 
   _indexFile(filePath, content, { targetPathAliases = new Map() } = {}) {
@@ -621,16 +599,3 @@ export class BacklinkIndex {
     }
   }
 }
-
-/** Flatten a vault tree into an array of file paths. */
-function flattenTree(nodes) {
-  const files = [];
-  for (const node of nodes) {
-    if (node.type && node.type !== 'directory') {
-      files.push(node.path);
-    } else if (node.children) {
-      files.push(...flattenTree(node.children));
-    }
-  }
-  return files;
-}

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

@@ -26,17 +26,11 @@ function cloneSnapshotRowRecord(rowRecord) {
   };
 }
 
-function createWorkspaceFileSetSignature(fileEntries = []) {
-  return fileEntries.join('\n');
-}
-
-function createRowCacheKey(filePath, workspaceState, fileSetSignature) {
+function createRowMetadataSignature(filePath, workspaceState) {
   const metadata = workspaceState?.metadata?.get(filePath) ?? null;
   return [
-    filePath,
     Number.isFinite(metadata?.mtimeMs) ? metadata.mtimeMs : '',
     Number.isFinite(metadata?.size) ? metadata.size : '',
-    fileSetSignature,
   ].join('\0');
 }
 
@@ -139,6 +133,8 @@ export class BaseIndexSnapshotStore {
     this.indexSnapshot = null;
     this.lastWorkspaceState = null;
     this.rowRecordCache = new Map();
+    this.rowRecordCacheFileSetSignature = '';
+    this.rowRecordCacheGeneration = 0;
   }
 
   async getWorkspaceState() {
@@ -305,13 +301,16 @@ export class BaseIndexSnapshotStore {
   async buildIndexSnapshot(workspaceState = null) {
     const resolvedWorkspaceState = workspaceState ?? await this.getWorkspaceState();
     const fileEntries = listWorkspaceFilePaths(resolvedWorkspaceState);
-    const fileSetSignature = createWorkspaceFileSetSignature(fileEntries);
+    const cacheGeneration = this.prepareRowRecordCache(fileEntries);
     const wikiTargetIndex = createWikiTargetIndex(fileEntries);
     const markdownContents = new Map();
+    // Keep reused rows available if another build replaces the shared cache during I/O.
+    const cachedRowRecords = new Map(fileEntries.map((filePath) => [
+      filePath, this.getCachedRowRecord(filePath, resolvedWorkspaceState, cacheGeneration),
+    ]));
 
     await mapWithConcurrency(resolvedWorkspaceState.markdownPaths ?? [], INDEX_READ_CONCURRENCY, async (filePath) => {
-      const cacheKey = createRowCacheKey(filePath, resolvedWorkspaceState, fileSetSignature);
-      if (!this.rowRecordCache.has(cacheKey)) {
+      if (!cachedRowRecords.get(filePath)) {
         markdownContents.set(filePath, await this.vaultFileStore.readMarkdownFile(filePath));
       }
     });
@@ -322,13 +321,16 @@ export class BaseIndexSnapshotStore {
     const rawTargetSourcesByKey = new Map();
     const nextRowRecordCache = new Map();
     fileEntries.forEach((filePath) => {
-      const cacheKey = createRowCacheKey(filePath, resolvedWorkspaceState, fileSetSignature);
-      const cachedRowRecord = this.rowRecordCache.get(cacheKey);
+      const cachedRowRecord = cachedRowRecords.get(filePath);
       const markdownContent = markdownContents.get(filePath) ?? null;
       const rowRecord = cachedRowRecord
         ? cloneSnapshotRowRecord(cachedRowRecord)
         : this.createSnapshotRow(filePath, resolvedWorkspaceState, wikiTargetIndex, markdownContent);
-      nextRowRecordCache.set(cacheKey, cloneSnapshotRowRecord(rowRecord));
+      nextRowRecordCache.set(filePath, {
+        generation: cacheGeneration,
+        metadataSignature: createRowMetadataSignature(filePath, resolvedWorkspaceState),
+        rowRecord: cloneSnapshotRowRecord(rowRecord),
+      });
       rowsByPath.set(filePath, rowRecord.row);
       forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
       rawTargetKeysBySourcePath.set(filePath, rowRecord.rawTargetKeys);
@@ -411,7 +413,7 @@ export class BaseIndexSnapshotStore {
         return pathValue && isWorkspaceFileEntry(entry);
       });
 
-    const fileSetSignature = createWorkspaceFileSetSignature(snapshot.filePaths);
+    const cacheGeneration = this.prepareRowRecordCache(snapshot.filePaths);
     await mapWithConcurrency(filePathsToRefresh, INDEX_READ_CONCURRENCY, async (filePath) => {
       const markdownContent = isMarkdownFilePath(filePath)
         ? await this.vaultFileStore.readMarkdownFile(filePath)
@@ -419,11 +421,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.rowRecordCache.set(filePath, {
+        generation: cacheGeneration,
+        metadataSignature: createRowMetadataSignature(filePath, workspaceState),
+        rowRecord: cloneSnapshotRowRecord(rowRecord),
+      });
       this.removeRawTargetSourceContributions(snapshot, filePath);
       snapshot.rowsByPath.set(filePath, rowRecord.row);
       snapshot.forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
@@ -431,12 +433,27 @@ export class BaseIndexSnapshotStore {
     });
   }
 
+  prepareRowRecordCache(filePaths) {
+    const signature = JSON.stringify(filePaths);
+    if (signature !== this.rowRecordCacheFileSetSignature) {
+      // Link resolution depends on every target path, including previously missing files.
+      this.rowRecordCache.clear();
+      this.rowRecordCacheFileSetSignature = signature;
+      this.rowRecordCacheGeneration += 1;
+    }
+    return this.rowRecordCacheGeneration;
+  }
+
+  getCachedRowRecord(filePath, workspaceState, generation) {
+    const cached = this.rowRecordCache.get(filePath);
+    return cached?.generation === generation
+      && cached.metadataSignature === createRowMetadataSignature(filePath, workspaceState)
+      ? cached.rowRecord
+      : null;
+  }
+
   invalidateRowRecordCachePath(filePath) {
-    Array.from(this.rowRecordCache.keys()).forEach((cacheKey) => {
-      if (cacheKey === filePath || cacheKey.startsWith(`${filePath}\0`)) {
-        this.rowRecordCache.delete(cacheKey);
-      }
-    });
+    this.rowRecordCache.delete(filePath);
   }
 
   async ensureIndexSnapshot({ basePath = '', sourcePath = '' } = {}) {