collabmd 0.1.20 → 0.1.23

package/src/client/application/workspace-coordinator.js

@@ -1,6 +1,14 @@
 import { FileOpenLifecycle } from './file-open-lifecycle.js';
 import { WorkspaceChromeController } from './workspace-chrome-controller.js';
 
+const BOOTSTRAP_RENDER_DELAY_MS = 150;
+
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
 export class WorkspaceCoordinator {
   constructor({
     attachEditorScroller,
@@ -18,6 +26,7 @@ export class WorkspaceCoordinator {
     isMermaidFile,
     isPlantUmlFile,
     isTabActive,
+    loadBootstrapContent = null,
     loadEditorSessionClass,
     loadBacklinks,
     onBeforeFileOpen,
@@ -30,6 +39,7 @@ export class WorkspaceCoordinator {
     onImagePaste,
     onSelectionChange,
     onSessionAssigned = null,
+    onFileOpenMetric = null,
     onRenderExcalidrawPreview,
     onRenderImagePreview,
     onSyncWrapToggle,
@@ -58,6 +68,7 @@ export class WorkspaceCoordinator {
     this.isMermaidFile = isMermaidFile ?? (() => false);
     this.isPlantUmlFile = isPlantUmlFile ?? (() => false);
     this.isTabActive = isTabActive;
+    this.loadBootstrapContent = loadBootstrapContent;
     this.loadEditorSessionClassPort = loadEditorSessionClass;
     this.loadBacklinks = loadBacklinks;
     this.onBeforeFileOpen = onBeforeFileOpen;
@@ -70,6 +81,7 @@ export class WorkspaceCoordinator {
     this.onImagePaste = onImagePaste;
     this.onSelectionChange = onSelectionChange;
     this.onSessionAssigned = onSessionAssigned;
+    this.onFileOpenMetric = onFileOpenMetric;
     this.onRenderExcalidrawPreview = onRenderExcalidrawPreview;
     this.onSyncWrapToggle = onSyncWrapToggle;
     this.onUpdateActiveFile = onUpdateActiveFile;
@@ -122,6 +134,14 @@ export class WorkspaceCoordinator {
     });
   }
 
+  reportFileOpenMetric(name, loadToken, data = {}) {
+    this.onFileOpenMetric?.(name, {
+      filePath: this.stateStore.get('currentFilePath'),
+      loadToken,
+      ...data,
+    });
+  }
+
   cleanupSession() {
     this.session?.destroy();
     this.session = null;
@@ -146,11 +166,13 @@ export class WorkspaceCoordinator {
     }
 
     const loadToken = this.stateStore.nextSessionLoadToken();
+    const openStartedAt = performance.now();
 
     this.cleanupSession();
     const chromeState = this.chromeController.prepareForFileOpen(filePath, {
       resetConnectionState: !isExcalidraw && !isImage,
     });
+    this.reportFileOpenMetric('open_started', loadToken, { filePath });
 
     if (isExcalidraw || isImage) {
       this.onSessionAssigned?.(null);
@@ -198,37 +220,144 @@ export class WorkspaceCoordinator {
     this.onSessionAssigned?.(session);
 
     try {
-      await session.initialize(filePath);
+      let fileOpenReady = false;
+      let fileOpenFinalized = false;
+      let liveSyncComplete = false;
 
-      if (loadToken !== this.stateStore.get('sessionLoadToken')) {
-        session.destroy();
-        return;
-      }
+      const readySession = async (reason) => {
+        if (fileOpenReady || loadToken !== this.stateStore.get('sessionLoadToken')) {
+          return;
+        }
+
+        fileOpenReady = true;
+        this.lifecycle.attachSessionScroller(session);
+        session.applyTheme(this.getTheme());
+        this.chromeController.markFileOpenReady(session);
+        this.reportFileOpenMetric('editor_ready', loadToken, { reason });
+        session.requestMeasure();
+        await this.waitForNextPaint();
+
+        if (fileOpenFinalized || loadToken !== this.stateStore.get('sessionLoadToken')) {
+          return;
+        }
 
-      this.lifecycle.attachSessionScroller(session);
-      session.applyTheme(this.getTheme());
-      await session.waitForInitialSync();
-      session.ensureInitialContent?.();
+        fileOpenFinalized = true;
+        this.chromeController.finalizeFileOpen({
+          filePath,
+          isExcalidraw,
+          session,
+          supportsBacklinks: chromeState.supportsBacklinks,
+        });
+      };
+
+      const bootstrapPromise = this.loadBootstrapContent
+        ? (async () => {
+          this.reportFileOpenMetric('bootstrap_fetch_started', loadToken);
+          try {
+            const content = await this.loadBootstrapContent(filePath);
+            this.reportFileOpenMetric('bootstrap_fetch_completed', loadToken, {
+              found: content !== null,
+            });
+            return content;
+          } catch (error) {
+            this.reportFileOpenMetric('bootstrap_fetch_completed', loadToken, {
+              error: error.message,
+              found: false,
+            });
+            return null;
+          }
+        })()
+        : Promise.resolve(null);
+
+      const initializePromise = session.initialize(filePath);
+      const liveSyncPromise = (async () => {
+        await initializePromise;
+
+        if (loadToken !== this.stateStore.get('sessionLoadToken')) {
+          return false;
+        }
+
+        await session.waitForInitialSync(null);
+        if (loadToken !== this.stateStore.get('sessionLoadToken')) {
+          return false;
+        }
+
+        liveSyncComplete = true;
+        session.activateCollaborativeView?.();
+        this.lifecycle.attachSessionScroller(session);
+        session.applyTheme(this.getTheme());
+        this.reportFileOpenMetric('initial_sync_complete', loadToken);
+        session.ensureInitialContent?.();
+        if (!fileOpenReady) {
+          await readySession('live-sync');
+        } else {
+          session.requestMeasure();
+        }
+        return true;
+      })();
+
+      const bootstrapVisibilityPromise = (async () => {
+        const bootstrapContent = await bootstrapPromise;
+        if (
+          bootstrapContent === null
+          || liveSyncComplete
+          || fileOpenReady
+          || loadToken !== this.stateStore.get('sessionLoadToken')
+        ) {
+          return false;
+        }
+
+        const elapsedMs = performance.now() - openStartedAt;
+        const remainingDelayMs = Math.max(0, BOOTSTRAP_RENDER_DELAY_MS - elapsedMs);
+        if (remainingDelayMs > 0) {
+          const winner = await Promise.race([
+            liveSyncPromise.then((didSync) => (didSync ? 'live-sync' : 'stale')),
+            delay(remainingDelayMs).then(() => 'timeout'),
+          ]);
+          if (winner === 'live-sync') {
+            return false;
+          }
+        }
+
+        if (
+          liveSyncComplete
+          || fileOpenReady
+          || loadToken !== this.stateStore.get('sessionLoadToken')
+        ) {
+          return false;
+        }
+
+        const didApplyBootstrap = session.showBootstrapContent({
+          content: bootstrapContent,
+          filePath,
+        });
+        if (!didApplyBootstrap && !session.hasBootstrapContent?.()) {
+          return false;
+        }
+
+        this.reportFileOpenMetric('bootstrap_shown', loadToken);
+        await readySession('bootstrap');
+        return true;
+      })();
+
+      await initializePromise;
 
       if (loadToken !== this.stateStore.get('sessionLoadToken')) {
         session.destroy();
         return;
       }
 
-      this.chromeController.markFileOpenReady(session);
-      session.requestMeasure();
-      await this.waitForNextPaint();
+      await Promise.all([liveSyncPromise, bootstrapVisibilityPromise]);
 
       if (loadToken !== this.stateStore.get('sessionLoadToken')) {
         session.destroy();
         return;
       }
-      this.chromeController.finalizeFileOpen({
-        filePath,
-        isExcalidraw,
-        session,
-        supportsBacklinks: chromeState.supportsBacklinks,
-      });
+
+      if (!fileOpenReady) {
+        session.ensureInitialContent?.();
+        await readySession('post-initialize');
+      }
     } catch (error) {
       console.error('[app] Failed to initialize editor:', error);
       session.destroy();

package/src/client/application/workspace-preview-controller.js

@@ -164,6 +164,40 @@ export class WorkspacePreviewController {
     this.schedulePreviewLayoutSyncCallback({ delayMs: 0 });
   }
 
+  renderTextFilePreview({ content = '' } = {}) {
+    const previewElement = this.elements.previewContent;
+    if (!previewElement) {
+      return;
+    }
+
+    this.videoEmbed?.detachForCommit();
+    this.excalidrawEmbed.detachForCommit();
+    this.resetPreviewMode();
+    const renderHost = this.previewRenderer.ensureRenderHost();
+    this.previewRenderer.normalizePreviewChildren(renderHost);
+
+    const shell = document.createElement('div');
+    shell.className = 'preview-shell';
+    const pre = document.createElement('pre');
+    const code = document.createElement('code');
+    code.textContent = String(content ?? '');
+    pre.appendChild(code);
+    shell.appendChild(pre);
+
+    if (renderHost) {
+      renderHost.replaceChildren(shell);
+      renderHost.style.minHeight = '';
+    }
+
+    previewElement.dataset.renderPhase = 'ready';
+    this.outlineController.close();
+    this.backlinksPanel.clear();
+    this.scrollSyncController.setLargeDocumentMode(false);
+    this.scrollSyncController.invalidatePreviewBlocks();
+    this.videoEmbed?.reconcileEmbeds(previewElement);
+    this.schedulePreviewLayoutSyncCallback({ delayMs: 0 });
+  }
+
   createResizeHandler(restoreSidebarState) {
     let resizeTimer = null;
     return () => {

package/src/client/application/workspace-route-controller.js

@@ -2,9 +2,11 @@ export class WorkspaceRouteController {
   constructor({
     backlinksPanel,
     clearInitialFileBootstrap,
+    clearStaticPreviewDocument = null,
     closeSidebarOnMobile,
     elements,
     excalidrawEmbed,
+    fileHistoryView = null,
     fileExplorer,
     getIsTabActive,
     getSessionLoadToken,
@@ -22,7 +24,11 @@ export class WorkspaceRouteController {
     setSessionLoadToken,
     setSidebarTab,
     setCurrentFilePath,
+    showGitCommit,
     showGitDiff,
+    showGitFileHistory,
+    showGitFilePreview,
+    showGitHistory,
     syncMainChrome,
     videoEmbed,
     workspaceCoordinator,
@@ -30,9 +36,11 @@ export class WorkspaceRouteController {
   }) {
     this.backlinksPanel = backlinksPanel;
     this.clearInitialFileBootstrap = clearInitialFileBootstrap;
+    this.clearStaticPreviewDocument = clearStaticPreviewDocument;
     this.closeSidebarOnMobile = closeSidebarOnMobile;
     this.elements = elements;
     this.excalidrawEmbed = excalidrawEmbed;
+    this.fileHistoryView = fileHistoryView;
     this.fileExplorer = fileExplorer;
     this.getIsTabActive = getIsTabActive;
     this.getSessionLoadToken = getSessionLoadToken;
@@ -50,7 +58,11 @@ export class WorkspaceRouteController {
     this.setSessionLoadToken = setSessionLoadToken;
     this.setSidebarTab = setSidebarTab;
     this.setCurrentFilePath = setCurrentFilePath;
+    this.showGitCommit = showGitCommit;
     this.showGitDiff = showGitDiff;
+    this.showGitFileHistory = showGitFileHistory;
+    this.showGitFilePreview = showGitFilePreview;
+    this.showGitHistory = showGitHistory;
     this.syncMainChrome = syncMainChrome;
     this.videoEmbed = videoEmbed;
     this.workspaceCoordinator = workspaceCoordinator;
@@ -76,13 +88,39 @@ export class WorkspaceRouteController {
       return;
     }
 
+    if (route.type === 'git-file-history') {
+      this.setSidebarTab('files');
+      await this.showGitFileHistory(route);
+      return;
+    }
+
+    if (route.type === 'git-file-preview') {
+      this.setSidebarTab('files');
+      await this.showGitFilePreview(route);
+      return;
+    }
+
+    if (route.type === 'git-history') {
+      this.setSidebarTab('git');
+      await this.showGitHistory();
+      return;
+    }
+
+    if (route.type === 'git-commit') {
+      this.setSidebarTab('git');
+      await this.showGitCommit(route);
+      return;
+    }
+
     this.setSidebarTab('files');
     await this.openFile(route.filePath);
   }
 
   showEmptyState() {
     this.gitDiffView.hide();
+    this.fileHistoryView?.hide?.();
     this.workspaceCoordinator.cleanupSession();
+    this.clearStaticPreviewDocument?.();
     this.setSession(null);
     this.setSessionLoadToken(this.getSessionLoadToken() + 1);
     this.clearInitialFileBootstrap();
@@ -113,8 +151,10 @@ export class WorkspaceRouteController {
   }
 
   showDiffState() {
+    this.fileHistoryView?.hide?.();
     this.setSessionLoadToken(this.getSessionLoadToken() + 1);
     this.clearInitialFileBootstrap();
+    this.clearStaticPreviewDocument?.();
     this.workspaceCoordinator.cleanupSession();
     this.setSession(null);
     this.resetPreviewMode();
@@ -141,10 +181,74 @@ export class WorkspaceRouteController {
     this.backlinksPanel.clear();
   }
 
+  showFileHistoryState(filePath) {
+    this.gitDiffView.hide();
+    this.setSessionLoadToken(this.getSessionLoadToken() + 1);
+    this.clearInitialFileBootstrap();
+    this.clearStaticPreviewDocument?.();
+    this.workspaceCoordinator.cleanupSession();
+    this.setSession(null);
+    this.resetPreviewMode();
+    this.layoutController.reset();
+    this.setCurrentFilePath(filePath);
+    this.lobby.setCurrentFile(null);
+    this.fileExplorer.setActiveFile(filePath);
+
+    this.elements.emptyState?.classList.add('hidden');
+    this.elements.editorPage?.classList.add('hidden');
+    this.elements.diffPage?.classList.remove('hidden');
+    if (this.elements.previewContent) {
+      this.elements.previewContent.innerHTML = '';
+      this.elements.previewContent.dataset.renderPhase = 'ready';
+    }
+    this.videoEmbed?.reconcileEmbeds(this.elements.previewContent);
+    this.resetPreviewSurface();
+
+    this.elements.outlineToggle?.classList.add('hidden');
+    this.elements.markdownToolbar?.classList.add('hidden');
+
+    this.renderAvatars();
+    this.renderPresence();
+    this.backlinksPanel.clear();
+  }
+
+  showPreviewOnlyState(filePath) {
+    this.gitDiffView.hide();
+    this.fileHistoryView?.hide?.();
+    this.setSessionLoadToken(this.getSessionLoadToken() + 1);
+    this.clearInitialFileBootstrap();
+    this.clearStaticPreviewDocument?.();
+    this.workspaceCoordinator.cleanupSession();
+    this.setSession(null);
+    this.resetPreviewMode();
+    this.layoutController.reset();
+    this.setCurrentFilePath(filePath);
+    this.lobby.setCurrentFile(null);
+    this.fileExplorer.setActiveFile(filePath);
+
+    this.elements.emptyState?.classList.add('hidden');
+    this.elements.editorPage?.classList.remove('hidden');
+    this.elements.diffPage?.classList.add('hidden');
+    if (this.elements.previewContent) {
+      this.elements.previewContent.innerHTML = '';
+      this.elements.previewContent.dataset.renderPhase = 'ready';
+    }
+    this.videoEmbed?.reconcileEmbeds(this.elements.previewContent);
+    this.resetPreviewSurface();
+
+    this.elements.markdownToolbar?.classList.add('hidden');
+
+    this.renderAvatars();
+    this.renderPresence();
+    this.backlinksPanel.clear();
+  }
+
   async openFile(filePath) {
     this.imageLightbox?.close?.();
     this.gitPanel.setSelection();
     this.gitDiffView.hide();
+    this.fileHistoryView?.hide?.();
+    this.clearStaticPreviewDocument?.();
     this.syncMainChrome({ mode: 'editor' });
     await this.workspaceCoordinator.openFile(filePath);
     this.setSession(this.workspaceCoordinator.getSession());

package/src/client/bootstrap/collabmd-app-shell.js

@@ -18,10 +18,12 @@ import { BrowserPreferencesPort } from '../infrastructure/browser-preferences-po
 import { getRuntimeConfig } from '../infrastructure/runtime-config.js';
 import { TabActivityLock } from '../infrastructure/tab-activity-lock.js';
 import { vaultApiClient } from '../infrastructure/vault-api-client.js';
+import { WorkspaceSyncClient } from '../infrastructure/workspace-sync-client.js';
 import { BacklinksPanel } from '../presentation/backlinks-panel.js';
 import { CommentUiController } from '../presentation/comment-ui-controller.js';
 import { ExcalidrawEmbedController } from '../presentation/excalidraw-embed-controller.js';
 import { FileExplorerController } from '../presentation/file-explorer-controller.js';
+import { FileHistoryViewController } from '../presentation/file-history-view-controller.js';
 import { GitDiffViewController } from '../presentation/git-diff-view-controller.js';
 import { GitPanelController } from '../presentation/git-panel-controller.js';
 import { LayoutController } from '../presentation/layout-controller.js';
@@ -102,6 +104,7 @@ export class CollabMdAppShell {
     this._previewHydrationPaused = false;
     this._previewLayoutResizeObserver = null;
     this._previewLayoutSyncTimer = null;
+    this._staticPreviewDocument = null;
     this.pendingGitResetPath = null;
     this.chatTimeFormatter = new Intl.DateTimeFormat(undefined, { hour: 'numeric', minute: '2-digit' });
     this.chatNotificationsEnabled = this.preferences.getChatNotificationsEnabled();
@@ -111,11 +114,23 @@ export class CollabMdAppShell {
     this.quickSwitcherModulePromise = null;
     this.fileExplorerReadyPromise = Promise.resolve();
     this.mobileBreakpointQuery = window.matchMedia('(max-width: 768px)');
+    this.pendingWorkspaceRequestIds = new Set();
+    this._fileOpenPerf = null;
 
     this.lobby = new LobbyPresence({
       preferredUserName: this.getStoredUserName(),
       onChange: (users) => this.updateGlobalUsers(users),
       onChatChange: (messages, meta) => this.updateChatMessages(messages, meta),
+    });
+    this.workspaceSync = new WorkspaceSyncClient({
+      onTreeChange: (tree, metadata = {}) => {
+        const wasReady = this.fileExplorerReady;
+        this.fileExplorer.setTree(tree, metadata);
+        this.fileExplorerReady = true;
+        if (!wasReady && this.isTabActive) {
+          void this.handleHashChange();
+        }
+      },
       onWorkspaceEvent: (event) => {
         void this.handleIncomingWorkspaceEvent(event);
       },
@@ -136,6 +151,7 @@ export class CollabMdAppShell {
       onPushBranch: () => this.pushGitBranch(),
       onRepoChange: (isGitRepo, status) => this.handleGitRepoChange(isGitRepo, status),
       onResetFile: (filePath, { scope }) => this.openGitResetDialog(filePath, { scope }),
+      onSelectCommit: (hash, { path }) => this.handleGitCommitSelection(hash, { closeSidebarOnMobile: true, path }),
       onSelectDiff: (filePath, { scope }) => this.handleGitDiffSelection(filePath, { closeSidebarOnMobile: true, scope }),
       onStageFile: (filePath, { scope }) => this.stageGitFile(filePath, { scope }),
       onUnstageFile: (filePath, { scope }) => this.unstageGitFile(filePath, { scope }),
@@ -163,6 +179,10 @@ export class CollabMdAppShell {
       getFileList: () => this.fileExplorer.flatDocumentFiles,
       getSourceFilePath: () => this.currentFilePath,
       onAfterRenderCommit: (_previewElement, stats) => {
+        this.recordFileOpenMetric('preview_committed', {
+          chars: stats?.chars ?? 0,
+          renderVersion: stats?.renderVersion ?? 0,
+        });
         this.videoEmbed.reconcileEmbeds(this.elements.previewContent);
         this.videoEmbed.syncLayout();
         this.excalidrawEmbed.reconcileEmbeds(this.elements.previewContent, { isLargeDocument: stats.isLargeDocument });
@@ -254,12 +274,35 @@ export class CollabMdAppShell {
       vaultApiClient: this.vaultApiClient,
     });
     this.gitDiffView = new GitDiffViewController({
+      onBackToHistory: ({ historyFilePath } = {}) => {
+        if (historyFilePath) {
+          this.navigation.navigateToGitFileHistory({ filePath: historyFilePath });
+          return;
+        }
+        this.navigation.navigateToGitHistory();
+      },
       onCommitStaged: () => this.openGitCommitDialog(),
       onOpenFile: (filePath) => filePath && this.navigation.navigateToFile(filePath),
       onStageFile: (filePath, { scope }) => this.stageGitFile(filePath, { scope }),
       onUnstageFile: (filePath, { scope }) => this.unstageGitFile(filePath, { scope }),
       toastController: this.toastController,
     });
+    this.fileHistoryView = new FileHistoryViewController({
+      diffRenderer: this.gitDiffView,
+      onOpenCommitDiff: (hash, { historyFilePath, path }) => this.handleGitCommitSelection(hash, {
+        closeSidebarOnMobile: false,
+        historyFilePath,
+        path,
+      }),
+      onOpenFile: (filePath) => filePath && this.navigation.navigateToFile(filePath),
+      onOpenPreview: ({ hash, path, currentFilePath }) => this.handleGitFilePreviewSelection({
+        hash,
+        path,
+        currentFilePath,
+      }),
+      onOpenWorkspaceDiff: (filePath) => this.handleGitDiffSelection(filePath, { closeSidebarOnMobile: false, scope: 'all' }),
+      toastController: this.toastController,
+    });
     this.tabActivityLock = new TabActivityLock({
       onActivated: ({ takeover }) => this.handleTabActivated({ takeover }),
       onBlocked: () => this.handleTabBlocked({ reason: 'active-elsewhere' }),
@@ -301,6 +344,10 @@ export class CollabMdAppShell {
       isMermaidFile: (filePath) => this.isMermaidFile(filePath),
       isPlantUmlFile: (filePath) => this.isPlantUmlFile(filePath),
       isTabActive: () => this.isTabActive,
+      loadBootstrapContent: async (filePath) => {
+        const response = await this.vaultApiClient.readFile(filePath);
+        return typeof response?.content === 'string' ? response.content : null;
+      },
       loadEditorSessionClass: () => this.loadEditorSessionClass(),
       loadBacklinks: (filePath) => this.backlinksPanel.load(filePath),
       onBeforeFileOpen: () => {
@@ -333,6 +380,7 @@ export class CollabMdAppShell {
       },
       onSelectionChange: (anchor) => this.handleCommentSelectionChange(anchor),
       onImagePaste: (file) => this.handleEditorImageInsert(file),
+      onFileOpenMetric: (name, payload) => this.recordFileOpenMetric(name, payload),
       onSessionAssigned: (session) => {
         this.session = session;
         this.commentUi.attachSession(session);
@@ -348,6 +396,7 @@ export class CollabMdAppShell {
       onUpdateVisibleChrome: (filePath, { displayName }) => {
         this.syncFileChrome(filePath);
         this.syncCommentChrome(filePath);
+        this.syncFileHistoryButton({ filePath, mode: 'editor' });
         if (this.elements.activeFileName) {
           this.elements.activeFileName.textContent = displayName;
         }
@@ -361,9 +410,11 @@ export class CollabMdAppShell {
     this.workspaceRouteController = new WorkspaceRouteController({
       backlinksPanel: this.backlinksPanel,
       clearInitialFileBootstrap: () => this.clearInitialFileBootstrap(),
+      clearStaticPreviewDocument: () => this.clearStaticPreviewDocument(),
       closeSidebarOnMobile: () => this.closeSidebarOnMobile(),
       elements: this.elements,
       excalidrawEmbed: this.excalidrawEmbed,
+      fileHistoryView: this.fileHistoryView,
       fileExplorer: this.fileExplorer,
       getIsTabActive: () => this.isTabActive,
       getSessionLoadToken: () => this.sessionLoadToken,
@@ -394,7 +445,11 @@ export class CollabMdAppShell {
         this.sessionLoadToken = value;
       },
       setSidebarTab: (value) => this.setSidebarTab(value),
+      showGitCommit: (route) => this.showGitCommit(route),
       showGitDiff: (route) => this.showGitDiff(route),
+      showGitFileHistory: (route) => this.showGitFileHistory(route),
+      showGitFilePreview: (route) => this.showGitFilePreview(route),
+      showGitHistory: () => this.showGitHistory(),
       syncMainChrome: (payload) => this.syncMainChrome(payload),
       videoEmbed: this.videoEmbed,
       workspaceCoordinator: this.workspaceCoordinator,
@@ -440,6 +495,58 @@ export class CollabMdAppShell {
   get followedCursorSignature() { return this.stateStore.get('followedCursorSignature'); }
   set followedCursorSignature(value) { this.stateStore.set('followedCursorSignature', value); }
 
+  publishFileOpenPerf() {
+    if (typeof window === 'undefined') {
+      return;
+    }
+
+    window.__COLLABMD_PERF__ ??= {};
+    window.__COLLABMD_PERF__.fileOpen = this._fileOpenPerf
+      ? {
+        ...this._fileOpenPerf,
+        details: { ...this._fileOpenPerf.details },
+        marks: { ...this._fileOpenPerf.marks },
+      }
+      : null;
+  }
+
+  recordFileOpenMetric(name, payload = {}) {
+    if (name === 'open_started') {
+      this._fileOpenPerf = {
+        details: {
+          filePath: payload.filePath || this.currentFilePath || '',
+          loadToken: payload.loadToken ?? 0,
+        },
+        marks: {
+          open_started: performance.now(),
+        },
+      };
+      this.publishFileOpenPerf();
+      return;
+    }
+
+    if (!this._fileOpenPerf) {
+      return;
+    }
+
+    const metricLoadToken = payload.loadToken ?? this._fileOpenPerf.details.loadToken;
+    if (metricLoadToken !== this._fileOpenPerf.details.loadToken) {
+      return;
+    }
+
+    this._fileOpenPerf.marks[name] = performance.now();
+    if (payload.filePath) {
+      this._fileOpenPerf.details.filePath = payload.filePath;
+    }
+    Object.entries(payload).forEach(([key, value]) => {
+      if (key === 'filePath' || key === 'loadToken') {
+        return;
+      }
+      this._fileOpenPerf.details[key] = value;
+    });
+    this.publishFileOpenPerf();
+  }
+
   loadEditorSessionClass() {
     if (!this._editorSessionModulePromise) {
       this._editorSessionModulePromise = import('../infrastructure/editor-session.js')

package/src/client/domain/runtime-paths.js

@@ -63,6 +63,8 @@ export function getClientRuntimeConfig() {
     auth: {
       enabled: false,
       implemented: true,
+      loginEndpoint: '/api/auth/oidc/login',
+      provider: '',
       requiresLogin: false,
       sessionEndpoint: '/api/auth/session',
       statusEndpoint: '/api/auth/status',
@@ -79,6 +81,8 @@ export function getClientRuntimeConfig() {
   const authConfig = {
     enabled: false,
     implemented: true,
+    loginEndpoint: '/api/auth/oidc/login',
+    provider: '',
     requiresLogin: false,
     sessionEndpoint: '/api/auth/session',
     statusEndpoint: '/api/auth/status',
@@ -90,6 +94,7 @@ export function getClientRuntimeConfig() {
     ...rawConfig,
     auth: {
       ...authConfig,
+      loginEndpoint: applyBasePath(basePath, authConfig.loginEndpoint),
       sessionEndpoint: applyBasePath(basePath, authConfig.sessionEndpoint),
       statusEndpoint: applyBasePath(basePath, authConfig.statusEndpoint),
     },

package/src/client/domain/vault-utils.js

@@ -25,8 +25,8 @@ export function escapeHtml(text) {
  *
  * Matching rules (in order):
  *   1. Exact path match (with .md appended if missing)
- *   2. Filename match at any directory depth
- *   3. Path without .md extension matches the target
+ *   2. Exact path without .md extension matches the target
+ *   3. Filename/path suffix match at any directory depth
  *
  * @param {string} target — the raw wiki-link target text
  * @param {string[]} files — list of vault file paths