collabmd 0.1.27 → 0.1.30

package/src/server/auth/create-auth-service.js

@@ -168,8 +168,7 @@ function readAuthenticatedOidcSession(sessionCookieManager, req) {
     return null;
   }
 
-  const expiresAt = Number(session.expiresAt);
-  if (Number.isFinite(expiresAt) && expiresAt <= Date.now()) {
+  if (hasExpiredSession(session)) {
     return null;
   }
 
@@ -185,6 +184,29 @@ function readAuthenticatedOidcSession(sessionCookieManager, req) {
   };
 }
 
+function hasExpiredSession(session) {
+  const expiresAt = Number(session?.expiresAt);
+  return Number.isFinite(expiresAt) && expiresAt <= Date.now();
+}
+
+function resolveSessionExpiresAt(sessionMaxAgeMs, fallbackExpiresAt = null) {
+  if (Number.isFinite(sessionMaxAgeMs) && sessionMaxAgeMs > 0) {
+    return Date.now() + sessionMaxAgeMs;
+  }
+
+  return Number.isFinite(fallbackExpiresAt) ? fallbackExpiresAt : null;
+}
+
+function createSessionCookieOptions(expiresAt) {
+  if (!Number.isFinite(expiresAt)) {
+    return {};
+  }
+
+  return {
+    expires: new Date(expiresAt),
+  };
+}
+
 function buildClientConfig(authConfig, { basePath = '' } = {}) {
   const loginEndpoint = prependBasePath(basePath, '/api/auth/oidc/login');
   const sessionEndpoint = prependBasePath(basePath, '/api/auth/session');
@@ -232,7 +254,7 @@ function createPasswordStrategy(authConfig, sessionCookieManager, clientConfig)
 
   function hasValidSession(req) {
     const session = sessionCookieManager.readSession(req);
-    return session?.strategy === AUTH_STRATEGY_PASSWORD;
+    return session?.strategy === AUTH_STRATEGY_PASSWORD && !hasExpiredSession(session);
   }
 
   return {
@@ -260,6 +282,8 @@ function createPasswordStrategy(authConfig, sessionCookieManager, clientConfig)
         }, { kind: 'invalid_credentials' });
       }
 
+      const expiresAt = resolveSessionExpiresAt(authConfig.sessionMaxAgeMs);
+
       return createResponse(200, {
         auth: clientConfig,
         authenticated: true,
@@ -269,8 +293,9 @@ function createPasswordStrategy(authConfig, sessionCookieManager, clientConfig)
         kind: 'session_created',
         setCookie: sessionCookieManager.createSessionCookie(req, {
           authenticatedAt: Date.now(),
+          ...(Number.isFinite(expiresAt) ? { expiresAt } : {}),
           strategy: AUTH_STRATEGY_PASSWORD,
-        }),
+        }, createSessionCookieOptions(expiresAt)),
       });
     },
 
@@ -456,9 +481,10 @@ function createOidcStrategy(authConfig, sessionCookieManager, flowCookieManager,
           return createErrorRedirect(req, accessDecision.error, flowPayload);
         }
 
-        const expiresAt = Number.isFinite(claims.exp)
+        const tokenExpiresAt = Number.isFinite(claims.exp)
           ? claims.exp * 1000
           : Date.now() + (Math.max(Number(tokens.expires_in) || 3600, 1) * 1000);
+        const expiresAt = resolveSessionExpiresAt(authConfig.sessionMaxAgeMs, tokenExpiresAt);
         const returnTo = sanitizeReturnTo(flowPayload.returnTo, {
           basePath,
           publicBaseUrl: authConfig.oidc.publicBaseUrl,
@@ -480,7 +506,7 @@ function createOidcStrategy(authConfig, sessionCookieManager, flowCookieManager,
               expiresAt,
               strategy: AUTH_STRATEGY_OIDC,
               user,
-            }),
+            }, createSessionCookieOptions(expiresAt)),
             flowCookieManager.clear(req),
           ],
         });

package/src/server/config/env.js

@@ -10,12 +10,34 @@ import {
   createRandomSessionSecret,
 } from '../auth/create-auth-service.js';
 import { loadBuildInfo } from './build-info.js';
+import { isPerfLoggingEnabled } from './perf-logging.js';
 
 function parsePositiveInt(rawValue, fallbackValue) {
   const parsed = Number.parseInt(rawValue ?? '', 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : fallbackValue;
 }
 
+function parseOptionalPositiveInt(rawValue, {
+  fallbackValue = null,
+  variableName = 'value',
+} = {}) {
+  const normalized = String(rawValue ?? '').trim();
+  if (!normalized) {
+    return fallbackValue;
+  }
+
+  if (!/^[1-9]\d*$/u.test(normalized)) {
+    throw new Error(`${variableName} must be a positive integer.`);
+  }
+
+  const parsed = Number(normalized);
+  if (Number.isSafeInteger(parsed) && parsed > 0) {
+    return parsed;
+  }
+
+  throw new Error(`${variableName} must be a positive integer.`);
+}
+
 function parsePort(rawPort, fallbackPort) {
   return parsePositiveInt(rawPort, fallbackPort);
 }
@@ -284,6 +306,10 @@ export function loadConfig(overrides = {}) {
       password,
       passwordWasGenerated,
       sessionCookieName: authOverrides.sessionCookieName || process.env.AUTH_SESSION_COOKIE_NAME || 'collabmd_auth',
+      sessionMaxAgeMs: parseOptionalPositiveInt(
+        authOverrides.sessionMaxAgeMs ?? process.env.AUTH_SESSION_MAX_AGE_MS,
+        { variableName: 'AUTH_SESSION_MAX_AGE_MS' },
+      ),
       sessionSecret: authOverrides.sessionSecret || process.env.AUTH_SESSION_SECRET || createRandomSessionSecret(),
       strategy: authStrategy,
     },
@@ -296,6 +322,7 @@ export function loadConfig(overrides = {}) {
     httpRequestTimeoutMs: parsePositiveInt(process.env.HTTP_REQUEST_TIMEOUT_MS, 30_000),
     git,
     gitEnabled: git.enabled,
+    perfLoggingEnabled: overrides.perfLoggingEnabled ?? isPerfLoggingEnabled(process.env.COLLABMD_PERF_LOGGING),
     port: parsePort(process.env.PORT, 1234),
     nodeEnv,
     plantumlServerUrl: process.env.PLANTUML_SERVER_URL || 'https://www.plantuml.com/plantuml',

package/src/server/config/perf-logging.js

@@ -0,0 +1,39 @@
+function formatPerfValue(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/\.?0+$/u, '');
+  }
+
+  if (typeof value === 'string') {
+    return /[\s=]/u.test(value) ? JSON.stringify(value) : value;
+  }
+
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
+
+  return JSON.stringify(value);
+}
+
+export function isPerfLoggingEnabled(value = '') {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  const normalized = String(value ?? '').trim().toLowerCase();
+  return normalized === '1'
+    || normalized === 'true'
+    || normalized === 'yes'
+    || normalized === 'on';
+}
+
+export function logPerfEvent(enabled, scope, fields = {}) {
+  if (!enabled) {
+    return;
+  }
+
+  const formattedFields = Object.entries(fields)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${key}=${formatPerfValue(value)}`);
+  const suffix = formattedFields.length > 0 ? ` ${formattedFields.join(' ')}` : '';
+  console.info(`[perf][${scope}]${suffix}`);
+}

package/src/server/create-app-server.js

@@ -2,9 +2,11 @@ import { createServer } from 'http';
 
 import { loadConfig } from './config/env.js';
 import { createAuthService } from './auth/create-auth-service.js';
+import { logPerfEvent } from './config/perf-logging.js';
 import { BacklinkIndex } from './domain/backlink-index.js';
 import { CollaborationDocumentStore } from './domain/collaboration/collaboration-document-store.js';
 import { CollaborationRoom } from './domain/collaboration/collaboration-room.js';
+import { DocxExporter } from './domain/docx-exporter.js';
 import { GitService } from './infrastructure/git/git-service.js';
 import { PlantUmlRenderer } from './infrastructure/plantuml/plantuml-renderer.js';
 import { RoomRegistry } from './domain/collaboration/room-registry.js';
@@ -37,10 +39,41 @@ function closeHttpServer(httpServer) {
   });
 }
 
+function workspaceStateMetadataEqual(left = null, right = null) {
+  const leftMetadata = left?.metadata;
+  const rightMetadata = right?.metadata;
+  if (!(leftMetadata instanceof Map) || !(rightMetadata instanceof Map)) {
+    return false;
+  }
+
+  if (leftMetadata.size !== rightMetadata.size) {
+    return false;
+  }
+
+  for (const [pathValue, leftEntry] of leftMetadata.entries()) {
+    const rightEntry = rightMetadata.get(pathValue);
+    if (!rightEntry) {
+      return false;
+    }
+
+    if (
+      leftEntry.type !== rightEntry.type
+      || leftEntry.size !== rightEntry.size
+      || leftEntry.inode !== rightEntry.inode
+      || leftEntry.mtimeMs !== rightEntry.mtimeMs
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 export function createAppServer(config = loadConfig()) {
   const authService = createAuthService(config);
   const vaultFileStore = new VaultFileStore({ vaultDir: config.vaultDir });
   const backlinkIndex = new BacklinkIndex({ vaultFileStore });
+  const docxExporter = new DocxExporter();
   const plantUmlRenderer = new PlantUmlRenderer({
     serverUrl: config.plantumlServerUrl,
   });
@@ -67,6 +100,7 @@ export function createAppServer(config = loadConfig()) {
         maxBufferedAmountBytes: config.wsMaxBufferedAmountBytes,
         name,
         onEmpty,
+        perfLoggingEnabled: config.perfLoggingEnabled,
       });
 
       if (name === WORKSPACE_ROOM_NAME && workspaceMutationCoordinator?.workspaceState) {
@@ -86,6 +120,7 @@ export function createAppServer(config = loadConfig()) {
   vaultFileStore.setManagedWriteTracker(workspaceMutationCoordinator);
   const fileSystemSyncService = new FileSystemSyncService({
     mutationCoordinator: workspaceMutationCoordinator,
+    perfLoggingEnabled: config.perfLoggingEnabled,
     vaultFileStore,
   });
   const requestHandler = createRequestHandler(
@@ -93,6 +128,7 @@ export function createAppServer(config = loadConfig()) {
     authService,
     vaultFileStore,
     backlinkIndex,
+    docxExporter,
     roomRegistry,
     plantUmlRenderer,
     gitService,
@@ -126,21 +162,84 @@ export function createAppServer(config = loadConfig()) {
   let vaultFileCount = 0;
 
   async function listen() {
-    vaultFileCount = await vaultFileStore.countVaultFiles();
-    await backlinkIndex.build();
-    await workspaceMutationCoordinator.initialize();
-    await fileSystemSyncService.start();
+    const startupStartedAt = Date.now();
+
+    const initialWorkspaceScanStartedAt = Date.now();
+    const initialWorkspaceSnapshot = await vaultFileStore.scanWorkspaceState();
+    vaultFileCount = initialWorkspaceSnapshot.vaultFileCount ?? 0;
+    logPerfEvent(config.perfLoggingEnabled, 'startup', {
+      durationMs: Date.now() - initialWorkspaceScanStartedAt,
+      phase: 'workspace-scan',
+      vaultFileCount,
+    });
+
+    const backlinkBuildStartedAt = Date.now();
+    await backlinkIndex.build({ workspaceState: initialWorkspaceSnapshot });
+    logPerfEvent(config.perfLoggingEnabled, 'startup', {
+      durationMs: Date.now() - backlinkBuildStartedAt,
+      markdownFileCount: initialWorkspaceSnapshot.markdownPaths?.length ?? 0,
+      phase: 'backlink-build',
+    });
+
+    const liveWorkspaceScanStartedAt = Date.now();
+    const liveWorkspaceSnapshot = await vaultFileStore.scanWorkspaceState();
+    const workspaceChangedDuringStartup = !workspaceStateMetadataEqual(initialWorkspaceSnapshot, liveWorkspaceSnapshot);
+    vaultFileCount = liveWorkspaceSnapshot.vaultFileCount ?? vaultFileCount;
+    logPerfEvent(config.perfLoggingEnabled, 'startup', {
+      changedDuringStartup: workspaceChangedDuringStartup,
+      durationMs: Date.now() - liveWorkspaceScanStartedAt,
+      phase: 'workspace-rescan',
+      vaultFileCount,
+    });
+
+    if (workspaceChangedDuringStartup) {
+      const backlinkRebuildStartedAt = Date.now();
+      await backlinkIndex.build({ workspaceState: liveWorkspaceSnapshot });
+      logPerfEvent(config.perfLoggingEnabled, 'startup', {
+        durationMs: Date.now() - backlinkRebuildStartedAt,
+        markdownFileCount: liveWorkspaceSnapshot.markdownPaths?.length ?? 0,
+        phase: 'backlink-rebuild',
+      });
+    }
+
+    const workspaceInitStartedAt = Date.now();
+    await workspaceMutationCoordinator.initialize({ snapshot: liveWorkspaceSnapshot });
+    logPerfEvent(config.perfLoggingEnabled, 'startup', {
+      durationMs: Date.now() - workspaceInitStartedAt,
+      phase: 'workspace-init',
+    });
+
+    const watcherStartStartedAt = Date.now();
+    await fileSystemSyncService.start({ snapshot: liveWorkspaceSnapshot });
+    logPerfEvent(config.perfLoggingEnabled, 'startup', {
+      durationMs: Date.now() - watcherStartStartedAt,
+      phase: 'watcher-start',
+    });
 
     return new Promise((resolve, reject) => {
+      const listenStartedAt = Date.now();
       httpServer.once('error', reject);
       httpServer.listen(config.port, config.host, () => {
         httpServer.off('error', reject);
         const address = httpServer.address();
-        resolve({
+        const result = {
           address,
           host: getDisplayHost(config.host),
           port: typeof address === 'object' && address ? address.port : config.port,
           wsPath: `${config.basePath || ''}${config.wsBasePath}/:file`,
+        };
+        logPerfEvent(config.perfLoggingEnabled, 'startup', {
+          durationMs: Date.now() - listenStartedAt,
+          phase: 'listen',
+          port: result.port,
+        });
+        logPerfEvent(config.perfLoggingEnabled, 'startup-total', {
+          durationMs: Date.now() - startupStartedAt,
+          markdownFileCount: liveWorkspaceSnapshot.markdownPaths?.length ?? 0,
+          vaultFileCount,
+        });
+        resolve({
+          ...result,
         });
       });
     });
@@ -173,6 +272,7 @@ export function createAppServer(config = loadConfig()) {
     roomRegistry,
     workspaceMutationCoordinator,
     authService,
+    backlinkIndex,
     fileSystemSyncService,
     gitService,
     setTestHydrateDelayMs(delayMs = 0) {

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

@@ -11,8 +11,10 @@
  */
 
 import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
+import { mapWithConcurrency } from '../shared/async-utils.js';
 
 const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+const BACKLINK_BUILD_CONCURRENCY = 8;
 
 function createDeferred() {
   let resolve;
@@ -58,13 +60,15 @@ export class BacklinkIndex {
    * Build the full index by scanning every markdown file in the vault.
    * Called once at server startup.
    */
-  async build() {
+  async build({ workspaceState = null } = {}) {
     this._requestedBuildVersion += 1;
+    this._latestRequestedWorkspaceState = workspaceState;
     return this.flushScheduledBuild();
   }
 
   scheduleBuild({ delayMs = this.rebuildDelayMs } = {}) {
     this._requestedBuildVersion += 1;
+    this._latestRequestedWorkspaceState = null;
     if (!this._scheduledBuildDeferred) {
       this._scheduledBuildDeferred = createDeferred();
     }
@@ -116,8 +120,9 @@ export class BacklinkIndex {
     }
 
     const targetVersion = this._requestedBuildVersion;
+    const workspaceState = this._latestRequestedWorkspaceState;
     this._buildPromise = (async () => {
-      await this._performBuild();
+      await this._performBuild(workspaceState);
       this._completedBuildVersion = Math.max(this._completedBuildVersion, targetVersion);
     })().finally(() => {
       this._buildPromise = null;
@@ -126,18 +131,26 @@ export class BacklinkIndex {
     return this._buildPromise;
   }
 
-  async _performBuild() {
+  async _performBuild(workspaceState = null) {
     this.forward.clear();
     this.reverse.clear();
     this.contextsBySource.clear();
 
-    const tree = await this.vaultFileStore.tree();
-    this._fileList = flattenTree(tree);
+    const snapshot = workspaceState ?? await this._resolveWorkspaceState();
+    this._fileList = Array.from(snapshot?.markdownPaths ?? []);
     this._fileSet = new Set(this._fileList);
     this._refreshWikiTargetIndex();
 
-    for (const filePath of this._fileList) {
-      const content = await this.vaultFileStore.readMarkdownFile(filePath);
+    const fileContents = await mapWithConcurrency(
+      this._fileList,
+      BACKLINK_BUILD_CONCURRENCY,
+      async (filePath) => ({
+        content: await this.vaultFileStore.readMarkdownFile(filePath),
+        filePath,
+      }),
+    );
+
+    for (const { content, filePath } of fileContents) {
       if (content !== null) {
         this._indexFile(filePath, content);
       }
@@ -147,6 +160,17 @@ export class BacklinkIndex {
     console.log(`[backlinks] Index built: ${this._fileList.length} files, ${this.reverse.size} targets with backlinks`);
   }
 
+  async _resolveWorkspaceState() {
+    if (typeof this.vaultFileStore.scanWorkspaceState === 'function') {
+      return this.vaultFileStore.scanWorkspaceState();
+    }
+
+    const tree = await this.vaultFileStore.tree();
+    return {
+      markdownPaths: flattenTree(tree),
+    };
+  }
+
   /**
    * Incrementally update the index when a file's content changes.
    * Call this after every persist / write.

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

@@ -8,6 +8,7 @@ import { MSG_AWARENESS, MSG_SYNC } from './protocol.js';
 import { CollaborationDocumentStore } from './collaboration-document-store.js';
 import { RoomClientStateStore } from './room-client-state-store.js';
 import { RoomPersistenceController } from './room-persistence-controller.js';
+import { logPerfEvent } from '../../config/perf-logging.js';
 import { populateCommentThreads, serializeCommentThreads } from '../../../domain/comment-threads.js';
 import {
   isExcalidrawRoomDocStructured,
@@ -131,6 +132,7 @@ export class CollaborationRoom {
     name,
     idleGraceMs = 0,
     maxBufferedAmountBytes,
+    perfLoggingEnabled = false,
     vaultFileStore,
     backlinkIndex,
     onEmpty,
@@ -138,6 +140,7 @@ export class CollaborationRoom {
     this.name = name;
     this.idleGraceMs = idleGraceMs;
     this.maxBufferedAmountBytes = maxBufferedAmountBytes;
+    this.perfLoggingEnabled = perfLoggingEnabled;
     this.documentStore = documentStore ?? new CollaborationDocumentStore({
       backlinkIndex,
       name,
@@ -187,6 +190,8 @@ export class CollaborationRoom {
         let snapshotExists = false;
         let snapshotValid = false;
         let commentThreadCount = 0;
+        let snapshotReadDurationMs = 0;
+        let contentFallbackDurationMs = 0;
         const hydrateDelayMs = Math.max(0, Number(this.getHydrateDelayMs?.() || 0));
 
         try {
@@ -195,7 +200,9 @@ export class CollaborationRoom {
           }
 
           if (this.documentStore?.hasPersistence()) {
+            const snapshotReadStartedAt = Date.now();
             const snapshot = await this.documentStore.readSnapshot();
+            snapshotReadDurationMs = Date.now() - snapshotReadStartedAt;
             if (snapshot) {
               snapshotExists = true;
               try {
@@ -227,10 +234,12 @@ export class CollaborationRoom {
               }
             }
 
+            const fallbackStartedAt = Date.now();
             const [content, commentThreads] = await Promise.all([
               this.documentStore.readContent(),
               this.documentStore.readCommentThreads(),
             ]);
+            contentFallbackDurationMs = Date.now() - fallbackStartedAt;
             commentThreadCount = commentThreads.length;
             if (content !== null || commentThreads.length > 0) {
               hydrateSource = 'content';
@@ -262,14 +271,23 @@ export class CollaborationRoom {
             this.debugMetrics.hydrateCount += 1;
             this.debugMetrics.lastHydrate = {
               commentThreadCount,
+              contentFallbackDurationMs,
               durationMs: Date.now() - startedAt,
+              snapshotReadDurationMs,
               snapshotExists,
               snapshotValid,
               source: hydrateSource,
             };
-            console.info(
-              `[perf][room:${this.name}] hydrate durationMs=${this.debugMetrics.lastHydrate.durationMs} source=${this.debugMetrics.lastHydrate.source} snapshotExists=${this.debugMetrics.lastHydrate.snapshotExists} snapshotValid=${this.debugMetrics.lastHydrate.snapshotValid} commentThreads=${this.debugMetrics.lastHydrate.commentThreadCount}`,
-            );
+            logPerfEvent(this.perfLoggingEnabled, `room:${this.name}`, {
+              commentThreads: this.debugMetrics.lastHydrate.commentThreadCount,
+              contentFallbackDurationMs: this.debugMetrics.lastHydrate.contentFallbackDurationMs,
+              durationMs: this.debugMetrics.lastHydrate.durationMs,
+              event: 'hydrate',
+              snapshotExists: this.debugMetrics.lastHydrate.snapshotExists,
+              snapshotReadDurationMs: this.debugMetrics.lastHydrate.snapshotReadDurationMs,
+              snapshotValid: this.debugMetrics.lastHydrate.snapshotValid,
+              source: this.debugMetrics.lastHydrate.source,
+            });
           }
         }
       })().catch((error) => {
@@ -522,8 +540,13 @@ export class CollaborationRoom {
   sendInitialSync(ws) {
     this.debugMetrics.initialSyncCount += 1;
     this.debugMetrics.lastInitialSyncAt = Date.now();
-    console.info(`[perf][room:${this.name}] send-initial-sync count=${this.debugMetrics.initialSyncCount}`);
-    return sendMessage.call(this, ws, this.getInitialSyncMessage(), this);
+    const initialSyncMessage = this.getInitialSyncMessage();
+    logPerfEvent(this.perfLoggingEnabled, `room:${this.name}`, {
+      bytes: initialSyncMessage.byteLength,
+      count: this.debugMetrics.initialSyncCount,
+      event: 'initial-sync',
+    });
+    return sendMessage.call(this, ws, initialSyncMessage, this);
   }
 
   async addClient(ws, { sendInitialSync: shouldSendInitialSync = true } = {}) {

package/src/server/domain/docx-exporter.js

@@ -0,0 +1,62 @@
+const DOCX_EXPORTER_CREATOR = 'CollabMD';
+
+function normalizeDocxBuffer(result) {
+  if (Buffer.isBuffer(result)) {
+    return result;
+  }
+
+  if (result instanceof ArrayBuffer) {
+    return Buffer.from(result);
+  }
+
+  if (ArrayBuffer.isView(result)) {
+    return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+  }
+
+  throw new Error('DOCX exporter returned an unsupported payload');
+}
+
+export class DocxExporter {
+  constructor({
+    loadConverter = () => import('@turbodocx/html-to-docx'),
+  } = {}) {
+    this.loadConverter = loadConverter;
+    this.converterPromise = null;
+  }
+
+  async ensureConverter() {
+    if (this.converterPromise) {
+      return this.converterPromise;
+    }
+
+    this.converterPromise = this.loadConverter().then((module) => {
+      const converter = module?.default ?? module?.HTMLToDOCX ?? module;
+      if (typeof converter !== 'function') {
+        throw new Error('DOCX converter failed to load');
+      }
+      return converter;
+    });
+    return this.converterPromise;
+  }
+
+  async render({
+    html,
+    title = '',
+  } = {}) {
+    const converter = await this.ensureConverter();
+    const result = await converter(String(html ?? ''), null, {
+      creator: DOCX_EXPORTER_CREATOR,
+      font: 'Arial',
+      footer: false,
+      pageNumber: false,
+      table: {
+        row: {
+          cantSplit: true,
+        },
+      },
+      title: String(title ?? ''),
+    });
+
+    return normalizeDocxBuffer(result);
+  }
+}

package/src/server/infrastructure/git/history-service.js

@@ -430,7 +430,7 @@ export class GitHistoryService {
     }
 
     return this.runRequest(cacheKey, async () => {
-      let content = '';
+      let content;
       try {
         content = await this.commandRunner.execGit(['show', `${normalizedHash}:${normalizedPath}`]);
       } catch {

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

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