collabmd 0.1.30 → 0.1.31

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

@@ -1,9 +1,10 @@
 import {
+  isBaseFilePath,
   isDrawioFilePath,
   isExcalidrawFilePath,
+  isMarkdownFilePath,
   isMermaidFilePath,
   isPlantUmlFilePath,
-  supportsBacklinksForFilePath,
 } from '../../../domain/file-kind.js';
 
 function assertWriteSucceeded(result, operation, filePath) {
@@ -54,6 +55,10 @@ export class CollaborationDocumentStore {
       return this.vaultFileStore.readExcalidrawFile(this.name);
     }
 
+    if (isBaseFilePath(this.name) && typeof this.vaultFileStore.readBaseFile === 'function') {
+      return this.vaultFileStore.readBaseFile(this.name);
+    }
+
     if (isDrawioFilePath(this.name) && typeof this.vaultFileStore.readDrawioFile === 'function') {
       return this.vaultFileStore.readDrawioFile(this.name);
     }
@@ -99,7 +104,7 @@ export class CollaborationDocumentStore {
       await this.writeSnapshot(snapshot);
     }
 
-    if (this.backlinkIndex && supportsBacklinksForFilePath(this.name)) {
+    if (this.backlinkIndex && isMarkdownFilePath(this.name)) {
       this.backlinkIndex.updateFile(this.name, content);
     }
   }
@@ -122,6 +127,12 @@ export class CollaborationDocumentStore {
       return;
     }
 
+    if (isBaseFilePath(this.name) && typeof this.vaultFileStore.writeBaseFile === 'function') {
+      const result = await this.vaultFileStore.writeBaseFile(this.name, content, options);
+      assertWriteSucceeded(result, 'write content', this.name);
+      return;
+    }
+
     if (isMermaidFilePath(this.name) && typeof this.vaultFileStore.writeMermaidFile === 'function') {
       const result = await this.vaultFileStore.writeMermaidFile(this.name, content, options);
       assertWriteSucceeded(result, 'write content', this.name);

package/src/server/domain/workspace-state.js

@@ -0,0 +1,52 @@
+import { isMarkdownFilePath, isVaultFilePath } from '../../domain/file-kind.js';
+
+function compareWorkspacePaths(left = '', right = '') {
+  return String(left).localeCompare(String(right), undefined, { sensitivity: 'base' });
+}
+
+export function collectWorkspaceStateStats(entries = new Map(), metadata = new Map()) {
+  const filePaths = [];
+  const markdownPaths = [];
+  let vaultFileCount = 0;
+
+  entries.forEach((entry, pathValue) => {
+    const entryType = entry?.type ?? entry?.nodeType ?? metadata.get(pathValue)?.type ?? '';
+    if (entryType === 'directory') {
+      return;
+    }
+
+    vaultFileCount += 1;
+    if (isVaultFilePath(pathValue)) {
+      filePaths.push(pathValue);
+    }
+    if (isMarkdownFilePath(pathValue)) {
+      markdownPaths.push(pathValue);
+    }
+  });
+
+  filePaths.sort(compareWorkspacePaths);
+  markdownPaths.sort(compareWorkspacePaths);
+
+  return {
+    filePaths,
+    markdownPaths,
+    vaultFileCount,
+  };
+}
+
+export function createWorkspaceStateSnapshot(entries = new Map(), metadata = new Map(), {
+  scannedAt = Date.now(),
+} = {}) {
+  const normalizedEntries = entries instanceof Map ? entries : new Map(entries ?? []);
+  const normalizedMetadata = metadata instanceof Map ? metadata : new Map(metadata ?? []);
+  const stats = collectWorkspaceStateStats(normalizedEntries, normalizedMetadata);
+
+  return {
+    entries: normalizedEntries,
+    filePaths: stats.filePaths,
+    markdownPaths: stats.markdownPaths,
+    metadata: normalizedMetadata,
+    scannedAt,
+    vaultFileCount: stats.vaultFileCount,
+  };
+}

package/src/server/infrastructure/http/create-request-handler.js

@@ -40,6 +40,7 @@ export function createRequestHandler(
   authService,
   vaultFileStore,
   backlinkIndex,
+  baseQueryService = null,
   docxExporter = null,
   roomRegistry = null,
   plantUmlRenderer = null,
@@ -60,6 +61,7 @@ export function createRequestHandler(
     workspaceMutationCoordinator,
   });
   const handleVaultApi = createVaultApiHandler({
+    baseQueryService,
     backlinkIndex,
     docxExporter,
     plantUmlRenderer,

package/src/server/infrastructure/http/create-vault-api-command-handler.js

@@ -1,4 +1,5 @@
 import {
+  isBaseFilePath,
   isDrawioFilePath,
   isExcalidrawFilePath,
   isMermaidFilePath,
@@ -55,6 +56,10 @@ function selectWriteOperation(vaultFileStore, filePath, content) {
     return vaultFileStore.writeExcalidrawFile(filePath, content);
   }
 
+  if (isBaseFilePath(filePath)) {
+    return vaultFileStore.writeBaseFile(filePath, content);
+  }
+
   if (isDrawioFilePath(filePath)) {
     return vaultFileStore.writeDrawioFile(filePath, content);
   }

package/src/server/infrastructure/http/create-vault-api-handler.js

@@ -3,6 +3,7 @@ import { createVaultApiCommandHandler } from './create-vault-api-command-handler
 import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js';
 
 export function createVaultApiHandler({
+  baseQueryService = null,
   backlinkIndex,
   docxExporter = null,
   plantUmlRenderer = null,
@@ -11,6 +12,7 @@ export function createVaultApiHandler({
   workspaceMutationCoordinator = null,
 }) {
   const handleVaultApiQuery = createVaultApiQueryHandler({
+    baseQueryService,
     backlinkIndex,
     vaultFileStore,
     workspaceMutationCoordinator,

package/src/server/infrastructure/http/create-vault-api-query-handler.js

@@ -1,12 +1,14 @@
 import { basename } from 'node:path';
 
 import {
+  isBaseFilePath,
   isDrawioFilePath,
   isExcalidrawFilePath,
   isImageAttachmentFilePath,
   isMermaidFilePath,
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
+import { parseJsonBody } from './request-body.js';
 import { jsonResponse, sendResponse } from './http-response.js';
 
 const SVG_MIME_TYPE = 'image/svg+xml';
@@ -46,6 +48,10 @@ function selectReadOperation(vaultFileStore, filePath) {
     return vaultFileStore.readExcalidrawFile(filePath);
   }
 
+  if (isBaseFilePath(filePath)) {
+    return vaultFileStore.readBaseFile(filePath);
+  }
+
   if (isDrawioFilePath(filePath)) {
     return vaultFileStore.readDrawioFile(filePath);
   }
@@ -62,11 +68,71 @@ function selectReadOperation(vaultFileStore, filePath) {
 }
 
 export function createVaultApiQueryHandler({
+  baseQueryService = null,
   backlinkIndex,
   vaultFileStore,
   workspaceMutationCoordinator = null,
 }) {
   return async function handleVaultApiQuery(req, res, requestUrl) {
+    if (requestUrl.pathname === '/api/base/query' && req.method === 'POST') {
+      try {
+        if (!baseQueryService?.query) {
+          jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
+          return true;
+        }
+
+        const body = await parseJsonBody(req);
+        const result = await baseQueryService.query({
+          activeFilePath: body?.activeFilePath ?? '',
+          basePath: body?.path ?? '',
+          search: body?.search ?? '',
+          source: typeof body?.source === 'string' ? body.source : null,
+          sourcePath: body?.sourcePath ?? '',
+          view: body?.view ?? '',
+        });
+
+        jsonResponse(req, res, 200, { ok: true, result });
+      } catch (error) {
+        console.error('[api] Failed to query base:', error.message);
+        jsonResponse(req, res, 400, { error: error.message || 'Failed to query base' });
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/base/export' && req.method === 'POST') {
+      try {
+        if (!baseQueryService?.query) {
+          jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
+          return true;
+        }
+
+        const body = await parseJsonBody(req);
+        const result = await baseQueryService.query({
+          activeFilePath: body?.activeFilePath ?? '',
+          basePath: body?.path ?? '',
+          search: body?.search ?? '',
+          source: typeof body?.source === 'string' ? body.source : null,
+          sourcePath: body?.sourcePath ?? '',
+          view: body?.view ?? '',
+        });
+        const fileName = basename(String(body?.path || body?.sourcePath || 'base')).replace(/\.[^.]+$/u, '') || 'base';
+        sendResponse(req, res, {
+          body: result.csv,
+          headers: {
+            'Cache-Control': 'no-store',
+            'Content-Disposition': `attachment; filename="${createSafeAsciiFilename(`${fileName}.csv`)}"; filename*=UTF-8''${encodeContentDispositionFilename(`${fileName}.csv`)}`,
+            'Content-Type': 'text/csv; charset=utf-8',
+            'X-Content-Type-Options': 'nosniff',
+          },
+          statusCode: 200,
+        });
+      } catch (error) {
+        console.error('[api] Failed to export base CSV:', error.message);
+        jsonResponse(req, res, 400, { error: error.message || 'Failed to export base CSV' });
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/files' && req.method === 'GET') {
       try {
         const tree = workspaceMutationCoordinator?.getWorkspaceTree?.() ?? await vaultFileStore.tree();

package/src/server/infrastructure/persistence/path-utils.js

@@ -3,7 +3,7 @@ import { isAbsolute, normalize, relative, resolve } from 'path';
 import { isVaultFilePath } from '../../../domain/file-kind.js';
 
 export const IGNORED_DIRECTORIES = new Set(['.git', '.obsidian', '.trash', 'node_modules', '.DS_Store']);
-export const VAULT_FILE_PATH_REQUIREMENT = '.md, .excalidraw, .drawio, .mmd, .mermaid, .puml, .plantuml, .png, .jpg, .jpeg, .webp, .gif, or .svg';
+export const VAULT_FILE_PATH_REQUIREMENT = '.md, .base, .excalidraw, .drawio, .mmd, .mermaid, .puml, .plantuml, .png, .jpg, .jpeg, .webp, .gif, or .svg';
 export const INVALID_VAULT_FILE_PATH_ERROR = `Invalid file path — must end in ${VAULT_FILE_PATH_REQUIREMENT}`;
 export const INVALID_DIRECTORY_PATH_ERROR = 'Invalid directory path';
 

package/src/server/infrastructure/persistence/vault-content-adapter.js

@@ -1,4 +1,5 @@
 import {
+  isBaseFilePath,
   isDrawioFilePath,
   isExcalidrawFilePath,
   isMarkdownFilePath,
@@ -28,6 +29,11 @@ const adapters = [
     kind: 'markdown',
     matches: isMarkdownFilePath,
   }),
+  new VaultContentAdapter({
+    invalidPathError: 'Invalid file path — must end in .base',
+    kind: 'base',
+    matches: isBaseFilePath,
+  }),
   new VaultContentAdapter({
     invalidPathError: 'Invalid file path — must end in .excalidraw',
     kind: 'excalidraw',

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -78,6 +78,7 @@ function createWorkspaceEntry(relativePath, type) {
 
 function createWorkspaceMetadata(pathValue, type, info) {
   return {
+    ctimeMs: Number(info.ctimeMs || 0),
     inode: Number(info.ino || 0),
     mtimeMs: Number(info.mtimeMs || 0),
     path: pathValue,
@@ -335,6 +336,10 @@ export class VaultFileStore {
     return this.readContentFile(filePath, 'markdown');
   }
 
+  async readBaseFile(filePath) {
+    return this.readContentFile(filePath, 'base');
+  }
+
   async readExcalidrawFile(filePath) {
     return this.readContentFile(filePath, 'excalidraw');
   }
@@ -377,6 +382,10 @@ export class VaultFileStore {
     return this.writeContentFile(filePath, content, 'markdown', options);
   }
 
+  async writeBaseFile(filePath, content, options = {}) {
+    return this.writeContentFile(filePath, content, 'base', options);
+  }
+
   async writeExcalidrawFile(filePath, content, options = {}) {
     return this.writeContentFile(filePath, content, 'excalidraw', options);
   }
@@ -858,6 +867,7 @@ export class VaultFileStore {
 
   async scanWorkspaceState() {
     const entries = new Map();
+    const filePaths = [];
     const metadata = new Map();
     const markdownPaths = [];
     let vaultFileCount = 0;
@@ -901,6 +911,7 @@ export class VaultFileStore {
           }
 
           entries.set(relativePath, createWorkspaceEntry(relativePath, 'file'));
+          filePaths.push(relativePath);
           vaultFileCount += 1;
           if (isMarkdownFilePath(relativePath)) {
             markdownPaths.push(relativePath);
@@ -929,6 +940,7 @@ export class VaultFileStore {
 
           entries.set(relativePath, createWorkspaceEntry(relativePath, 'file'));
           metadata.set(relativePath, createWorkspaceMetadata(relativePath, 'file', info));
+          filePaths.push(relativePath);
           vaultFileCount += 1;
           if (isMarkdownFilePath(relativePath)) {
             markdownPaths.push(relativePath);
@@ -940,10 +952,12 @@ export class VaultFileStore {
     };
 
     await visitDirectory(this.vaultDir);
+    filePaths.sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
     markdownPaths.sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
 
     return {
       entries,
+      filePaths,
       metadata,
       markdownPaths,
       scannedAt: Date.now(),

package/src/server/infrastructure/workspace/file-system-sync-service.js

@@ -5,6 +5,7 @@ import { basename, dirname, join } from 'path';
 import { createWorkspaceChange } from '../../../domain/workspace-change.js';
 import { getVaultTreeNodeType, isVaultFilePath } from '../../../domain/file-kind.js';
 import { logPerfEvent } from '../../config/perf-logging.js';
+import { createWorkspaceStateSnapshot } from '../../domain/workspace-state.js';
 import {
   isIgnoredVaultEntry,
   sanitizeVaultPath,
@@ -88,6 +89,67 @@ function isPathWithinPrefix(pathValue, prefix) {
   return pathValue === prefix || pathValue.startsWith(`${prefix}/`);
 }
 
+function collectAncestorPaths(pathValue = '') {
+  const normalizedPath = normalizeWorkspacePath(pathValue);
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments = normalizedPath.split('/').filter(Boolean);
+  const ancestors = [];
+  let currentPath = '';
+  for (let index = 0; index < Math.max(segments.length - 1, 0); index += 1) {
+    currentPath = currentPath ? `${currentPath}/${segments[index]}` : segments[index];
+    ancestors.push(currentPath);
+  }
+
+  return ancestors;
+}
+
+function collapsePendingPaths(paths = []) {
+  const collapsed = [];
+  for (const pathValue of sortByPath(paths.filter(Boolean))) {
+    if (collapsed.some((existingPath) => isPathWithinPrefix(pathValue, existingPath))) {
+      continue;
+    }
+
+    collapsed.push(pathValue);
+  }
+
+  return collapsed;
+}
+
+function collectPathsWithinPrefixes(paths = [], prefixes = []) {
+  const collected = new Set();
+  for (const pathValue of paths) {
+    if (prefixes.some((prefix) => isPathWithinPrefix(pathValue, prefix))) {
+      collected.add(pathValue);
+    }
+  }
+  return collected;
+}
+
+function createScopedWorkspaceState(sourceState, scopedPaths = new Set()) {
+  const entries = new Map();
+  const metadata = new Map();
+
+  scopedPaths.forEach((pathValue) => {
+    const entry = sourceState?.entries?.get(pathValue);
+    const entryMetadata = sourceState?.metadata?.get(pathValue);
+    if (entry) {
+      entries.set(pathValue, entry);
+    }
+    if (entryMetadata) {
+      metadata.set(pathValue, entryMetadata);
+    }
+  });
+
+  return {
+    entries,
+    metadata,
+  };
+}
+
 function buildPrefixRenameEntries(previousState, nextState, oldPrefix, newPrefix) {
   const renames = [];
   previousState.metadata.forEach((entry, pathValue) => {
@@ -274,6 +336,25 @@ export class FileSystemSyncService {
     this.lastState = snapshot ?? this.mutationCoordinator.workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
   }
 
+  async flushPendingChanges() {
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = null;
+
+    if (this.runningFlush) {
+      await this.runningFlush;
+      return;
+    }
+
+    if (this.pendingEventTypesByPath.size === 0 && !this.forceFullScan) {
+      return;
+    }
+
+    this.runningFlush = this.flush().finally(() => {
+      this.runningFlush = null;
+    });
+    await this.runningFlush;
+  }
+
   async readWorkspacePathSnapshot(pathValue) {
     const normalizedPath = normalizeWorkspacePath(pathValue);
     if (!normalizedPath) {
@@ -397,9 +478,7 @@ export class FileSystemSyncService {
       return { fallbackReason: 'missing-last-state', incrementalResult: null };
     }
 
-    const pendingPaths = Array.from(this.pendingEventTypesByPath.keys())
-      .filter(Boolean)
-      .sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
+    const pendingPaths = collapsePendingPaths(Array.from(this.pendingEventTypesByPath.keys()));
     if (pendingPaths.length === 0 || pendingPaths.length > MAX_INCREMENTAL_PENDING_PATHS) {
       return { fallbackReason: 'too-many-pending-paths', incrementalResult: null };
     }
@@ -407,19 +486,23 @@ export class FileSystemSyncService {
     const nextEntries = new Map(this.lastState.entries);
     const nextMetadata = new Map(this.lastState.metadata);
     const previousState = this.lastState;
+    const previousTouchedPaths = collectPathsWithinPrefixes(previousState.entries.keys(), pendingPaths);
+    const nextTouchedPaths = new Set();
 
-    for (const pathValue of pendingPaths) {
-      Array.from(previousState.entries.keys())
-        .filter((candidatePath) => isPathWithinPrefix(candidatePath, pathValue))
-        .forEach((candidatePath) => {
-          nextEntries.delete(candidatePath);
-        });
-      Array.from(previousState.metadata.keys())
-        .filter((candidatePath) => isPathWithinPrefix(candidatePath, pathValue))
-        .forEach((candidatePath) => {
-          nextMetadata.delete(candidatePath);
-        });
+    pendingPaths.forEach((pathValue) => {
+      collectAncestorPaths(pathValue).forEach((ancestorPath) => {
+        if (previousState.entries.has(ancestorPath)) {
+          previousTouchedPaths.add(ancestorPath);
+        }
+      });
+    });
+
+    previousTouchedPaths.forEach((pathValue) => {
+      nextEntries.delete(pathValue);
+      nextMetadata.delete(pathValue);
+    });
 
+    for (const pathValue of pendingPaths) {
       const snapshot = await this.readWorkspacePathSnapshot(pathValue);
       if (!snapshot) {
         return { fallbackReason: 'snapshot-unavailable', incrementalResult: null };
@@ -429,22 +512,30 @@ export class FileSystemSyncService {
         if (!(await this.ensureAncestorDirectories(nextEntries, nextMetadata, pathValue))) {
           return { fallbackReason: 'ancestor-missing', incrementalResult: null };
         }
+
+        collectAncestorPaths(pathValue).forEach((ancestorPath) => {
+          if (nextEntries.has(ancestorPath)) {
+            nextTouchedPaths.add(ancestorPath);
+          }
+        });
       }
 
       snapshot.entries.forEach((entry, entryPath) => {
         nextEntries.set(entryPath, entry);
+        nextTouchedPaths.add(entryPath);
       });
       snapshot.metadata.forEach((metadata, metadataPath) => {
         nextMetadata.set(metadataPath, metadata);
       });
     }
 
-    const nextState = {
-      entries: nextEntries,
-      metadata: nextMetadata,
+    const nextState = createWorkspaceStateSnapshot(nextEntries, nextMetadata, {
       scannedAt: Date.now(),
-    };
-    const workspaceChange = detectWorkspaceChange(this.lastState, nextState);
+    });
+    const workspaceChange = detectWorkspaceChange(
+      createScopedWorkspaceState(previousState, previousTouchedPaths),
+      createScopedWorkspaceState(nextState, nextTouchedPaths),
+    );
 
     return {
       fallbackReason: '',

package/src/server/infrastructure/workspace/workspace-mutation-coordinator.js

@@ -8,6 +8,7 @@ import {
   normalizeWorkspaceEvent,
 } from '../../../domain/workspace-change.js';
 import { WORKSPACE_ROOM_NAME } from '../../../domain/workspace-room.js';
+import { createWorkspaceStateSnapshot } from '../../domain/workspace-state.js';
 import { sanitizeVaultPath } from '../persistence/path-utils.js';
 
 function createEventId() {
@@ -193,11 +194,13 @@ function diffWorkspaceEntries(previousEntries = new Map(), nextEntries = new Map
 export class WorkspaceMutationCoordinator {
   constructor({
     backlinkIndex,
+    baseQueryService = null,
     roomRegistry,
     vaultFileStore,
     managedWriteWindowMs = 1200,
   }) {
     this.backlinkIndex = backlinkIndex ?? null;
+    this.baseQueryService = baseQueryService ?? null;
     this.roomRegistry = roomRegistry;
     this.vaultFileStore = vaultFileStore;
     this.managedWriteWindowMs = managedWriteWindowMs;
@@ -383,11 +386,9 @@ export class WorkspaceMutationCoordinator {
       nextMetadata.set(pathValue, nextPathState.metadata);
     }
 
-    return {
-      entries: nextEntries,
-      metadata: nextMetadata,
+    return createWorkspaceStateSnapshot(nextEntries, nextMetadata, {
       scannedAt: Date.now(),
-    };
+    });
   }
 
   getWorkspaceRoom() {
@@ -414,6 +415,7 @@ export class WorkspaceMutationCoordinator {
   async initialize({ snapshot = null } = {}) {
     const effectiveSnapshot = snapshot ?? await this.vaultFileStore.scanWorkspaceState();
     this.replaceWorkspaceState(effectiveSnapshot);
+    await this.baseQueryService?.initializeFromWorkspaceState?.(effectiveSnapshot);
     this.getWorkspaceRoom()?.replaceWorkspaceEntries(effectiveSnapshot.entries, {
       generatedAt: effectiveSnapshot.scannedAt,
     });
@@ -554,52 +556,17 @@ export class WorkspaceMutationCoordinator {
       return;
     }
 
-    const previousEntries = this.workspaceState?.entries ?? new Map();
     if (
       forceRebuild
       || countBacklinkAffectedPaths(workspaceChange) > 25
     ) {
-      this.backlinkIndex.scheduleBuild?.();
+      this.backlinkIndex.scheduleBuild?.({ workspaceState: nextState });
       return;
     }
-
-    for (const pathValue of workspaceChange.deletedPaths ?? []) {
-      if (supportsBacklinksForFilePath(pathValue)) {
-        this.backlinkIndex.onFileDeleted(pathValue);
-      }
-    }
-
-    for (const entry of workspaceChange.renamedPaths ?? []) {
-      if (supportsBacklinksForFilePath(entry.oldPath) || supportsBacklinksForFilePath(entry.newPath)) {
-        this.backlinkIndex.onFileRenamed(entry.oldPath, entry.newPath);
-      }
-    }
-
-    for (const pathValue of workspaceChange.changedPaths ?? []) {
-      if (!supportsBacklinksForFilePath(pathValue)) {
-        continue;
-      }
-
-      const existsNow = nextState.entries.has(pathValue);
-      const existedBefore = previousEntries.has(pathValue);
-      if (!existsNow) {
-        if (existedBefore) {
-          this.backlinkIndex.onFileDeleted(pathValue);
-        }
-        continue;
-      }
-
-      const content = await this.vaultFileStore.readMarkdownFile(pathValue);
-      if (content === null) {
-        continue;
-      }
-
-      if (existedBefore) {
-        this.backlinkIndex.updateFile(pathValue, content);
-      } else {
-        this.backlinkIndex.onFileCreated(pathValue, content);
-      }
-    }
+    await this.backlinkIndex.applyWorkspaceChange?.(workspaceChange, {
+      nextState,
+      previousState: this.workspaceState,
+    });
   }
 
   async apply({
@@ -624,6 +591,10 @@ export class WorkspaceMutationCoordinator {
     await this.reconcileBacklinks(normalizedChange, resolvedState, {
       forceRebuild: forceBacklinkRebuild,
     });
+    await this.baseQueryService?.applyWorkspaceChange?.(normalizedChange, {
+      nextState: resolvedState,
+      previousState,
+    });
 
     const roomEffects = await this.roomRegistry?.reconcileWorkspaceChange?.(normalizedChange) ?? {};
     const highlightRanges = normalizePaths(

package/dist/client/assets/architecture-PBZL5I3N-iRyVT2GQ.js

@@ -1 +0,0 @@
-import"./chunk-XZSTWKYB-DDkpyNVE.js";import{n as e}from"./chunk-R5LLSJPH-BjSMFnTi.js";export{e as createArchitectureServices};

package/dist/client/assets/channel-s0w88EQN.js

@@ -1 +0,0 @@
-import{it as e,rt as t}from"./chunk-7R4GIKGN-BMrp52Pk.js";var n=(n,r)=>e.lang.round(t.parse(n)[r]);export{n as t};

package/dist/client/assets/chunk-GLR3WWYH-CQ1LryrI.js

@@ -1,2 +0,0 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./dagre-KLK3FWXG-CAG8WeES.js","./chunk-PU5JKC2W-t0zUh6E3.js","./src-E3c2cohN.js","./chunk-DpHwWhuW.js","./chunk-GEFDOKGD-DYHmaq-c.js","./dist-CsYRf4AV.js","./math-BaavbII8.js","./chunk-7R4GIKGN-BMrp52Pk.js","./preload-helper-Bo9GmnuQ.js","./isArrayLikeObject-Cmt1CYnI.js","./dagre-fvYjRtTE.js","./graphlib-DSzYgMXB.js","./isEmpty-C7iPDOO3.js","./_baseUniq-Bbn0_sHS.js","./_basePickBy-B6kIfhzj.js","./clone-C-n46MFF.js","./chunk-KYZI473N-D4r5eMJZ.js","./chunk-PQ6SQG4A-BY9_Srs_.js","./chunk-YBOYWFTD-CzyyfGQX.js","./rough.esm-jZQkcmER.js","./chunk-MX3YWQON-DqN0TF5Q.js","./chunk-O4XLMI2P-DaS3COAu.js","./line-D57TbKb7.js","./path-BUmMWM1-.js","./array-DwdVlTkF.js","./cose-bilkent-S5V4N54A-jZzFUguD.js","./cytoscape.esm-DBDRhUia.js"])))=>i.map(i=>d[i]);
-import{t as e}from"./preload-helper-Bo9GmnuQ.js";import{u as t}from"./chunk-GEFDOKGD-DYHmaq-c.js";import{g as n,h as r}from"./src-E3c2cohN.js";import{s as i,y as a}from"./chunk-7R4GIKGN-BMrp52Pk.js";import{a as o,i as s,s as c}from"./chunk-KYZI473N-D4r5eMJZ.js";import{a as l,i as u,n as d,r as f}from"./chunk-O4XLMI2P-DaS3COAu.js";var p={common:i,getConfig:a,insertCluster:s,insertEdge:d,insertEdgeLabel:f,insertMarkers:u,insertNode:o,interpolateToCurve:t,labelHelper:c,log:n,positionEdgeLabel:l},m={},h=r(e=>{for(let t of e)m[t.name]=t},`registerLayoutLoaders`);r(()=>{h([{name:`dagre`,loader:r(async()=>await e(()=>import(`./dagre-KLK3FWXG-CAG8WeES.js`),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]),import.meta.url),`loader`)},...[{name:`cose-bilkent`,loader:r(async()=>await e(()=>import(`./cose-bilkent-S5V4N54A-jZzFUguD.js`),__vite__mapDeps([25,3,26,2]),import.meta.url),`loader`)}]])},`registerDefaultLayoutLoaders`)();var g=r(async(e,t)=>{if(!(e.layoutAlgorithm in m))throw Error(`Unknown layout algorithm: ${e.layoutAlgorithm}`);let n=m[e.layoutAlgorithm];return(await n.loader()).render(e,t,p,{algorithm:n.algorithm})},`render`),_=r((e=``,{fallback:t=`dagre`}={})=>{if(e in m)return e;if(t in m)return n.warn(`Layout algorithm ${e} is not registered. Using ${t} as fallback.`),t;throw Error(`Both layout algorithms ${e} and ${t} are not registered.`)},`getRegisteredLayoutAlgorithm`);export{h as n,g as r,_ as t};

package/dist/client/assets/chunk-HHEYEP7N-DOQ0PCdH.js

@@ -1 +0,0 @@
-import{h as e,p as t}from"./src-E3c2cohN.js";import{b as n}from"./chunk-7R4GIKGN-BMrp52Pk.js";var r=e(e=>{let{securityLevel:r}=n(),i=t(`body`);return r===`sandbox`&&(i=t((t(`#i${e}`).node()?.contentDocument??document).body)),i.select(`#${e}`)},`selectSvgElement`);export{r as t};

package/dist/client/assets/chunk-QZHKN3VN-B0v4d-CS.js

@@ -1 +0,0 @@
-import{h as e}from"./src-E3c2cohN.js";var t=class{constructor(e){this.init=e,this.records=this.init()}static{e(this,`ImperativeState`)}reset(){this.records=this.init()}};export{t};

package/dist/client/assets/classDiagram-VBA2DB6C-BQqG4q1b.js

@@ -1 +0,0 @@
-import"./chunk-GEFDOKGD-DYHmaq-c.js";import{h as e}from"./src-E3c2cohN.js";import"./chunk-7R4GIKGN-BMrp52Pk.js";import"./chunk-PU5JKC2W-t0zUh6E3.js";import"./chunk-FMBD7UC4-EWK5Pt4D.js";import"./chunk-MX3YWQON-DqN0TF5Q.js";import"./chunk-YBOYWFTD-CzyyfGQX.js";import"./chunk-JSJVCQXG-B69YGtcQ.js";import"./chunk-55IACEB6-039iVf6v.js";import"./chunk-KX2RTZJC-tuEC7hg1.js";import"./chunk-PQ6SQG4A-BY9_Srs_.js";import"./chunk-KYZI473N-D4r5eMJZ.js";import"./chunk-O4XLMI2P-DaS3COAu.js";import"./chunk-GLR3WWYH-CQ1LryrI.js";import{i as t,n,r,t as i}from"./chunk-WL4C6EOR-zSV-8h7F.js";var a={parser:n,get db(){return new i},renderer:r,styles:t,init:e(e=>{e.class||={},e.class.arrowMarkerAbsolute=e.arrowMarkerAbsolute},`init`)};export{a as diagram};

package/dist/client/assets/classDiagram-v2-RAHNMMFH-BUKbprX1.js

@@ -1 +0,0 @@
-import"./chunk-GEFDOKGD-DYHmaq-c.js";import{h as e}from"./src-E3c2cohN.js";import"./chunk-7R4GIKGN-BMrp52Pk.js";import"./chunk-PU5JKC2W-t0zUh6E3.js";import"./chunk-FMBD7UC4-EWK5Pt4D.js";import"./chunk-MX3YWQON-DqN0TF5Q.js";import"./chunk-YBOYWFTD-CzyyfGQX.js";import"./chunk-JSJVCQXG-B69YGtcQ.js";import"./chunk-55IACEB6-039iVf6v.js";import"./chunk-KX2RTZJC-tuEC7hg1.js";import"./chunk-PQ6SQG4A-BY9_Srs_.js";import"./chunk-KYZI473N-D4r5eMJZ.js";import"./chunk-O4XLMI2P-DaS3COAu.js";import"./chunk-GLR3WWYH-CQ1LryrI.js";import{i as t,n,r,t as i}from"./chunk-WL4C6EOR-zSV-8h7F.js";var a={parser:n,get db(){return new i},renderer:r,styles:t,init:e(e=>{e.class||={},e.class.arrowMarkerAbsolute=e.arrowMarkerAbsolute},`init`)};export{a as diagram};

package/dist/client/assets/clone-C-n46MFF.js

@@ -1 +0,0 @@
-import{y as e}from"./_baseUniq-Bbn0_sHS.js";var t=4;function n(n){return e(n,t)}export{n as t};