fix(reader,pathmode): harden mermaid render chain and single-window switch

Author: Jacobinwwey

package.json

@@ -1,6 +1,6 @@
 {
   "name": "noteconnection",
-  "version": "1.6.8",
+  "version": "1.6.9",
   "description": "Hierarchical Knowledge Graph Visualization System",
   "main": "dist/src/server.js",
   "bin": {
@@ -55,6 +55,8 @@
     "verify:fixrisk:issues": "node scripts/verify-fixrisk-issues.js",
     "verify:fixrisk:issues:strict": "node scripts/verify-fixrisk-issues.js --strict-pending",
     "verify:fixrisk:issues:strict:evidence": "node scripts/verify-fixrisk-issues.js --strict-pending --require-evidence-root",
+    "verify:markdown:mermaid:fence": "node scripts/verify-markdown-mermaid-fence.js",
+    "fix:markdown:mermaid:fence": "node scripts/verify-markdown-mermaid-fence.js --fix",
     "verify:pathbridge:strict": "node scripts/verify-pathbridge-strict-schema.js",
     "generate:sbom": "node scripts/generate-sbom.js",
     "generate:sbom:attestation": "node scripts/generate-sbom-attestation.js",

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "NoteConnection",
-  "version": "1.6.8",
+  "version": "1.6.9",
   "identifier": "com.jacobinwwey.noteconnection",
   "build": {
     "beforeDevCommand": "",

src/frontend/app.js

@@ -3808,21 +3808,25 @@ if (btnPathMode) {
             // 单窗口切换：隐藏 Tauri，显示 Godot。
             if (window.__TAURI__ && window.__TAURI__.core && typeof window.__TAURI__.core.invoke === 'function') {
                 try {
-                    // 1. Hide the Tauri window via Rust IPC.
-                    await window.__TAURI__.core.invoke('toggle_pathmode_window', { showGodot: true });
-                    // 2. Send setWindowVisible to Godot via PathBridge WebSocket.
+                    let bridgeVisibilityReady = true;
                     if (
                         multiWindowOptions.singleWindowMode &&
                         window.pathApp &&
-                        window.pathApp.ws &&
-                        window.pathApp.ws.readyState === WebSocket.OPEN
+                        typeof window.pathApp.requestBridgeWindowVisibility === 'function'
                     ) {
-                        window.pathApp.ws.send(JSON.stringify({
-                            type: 'setWindowVisible',
-                            payload: { visible: true }
-                        }));
+                        bridgeVisibilityReady = await window.pathApp.requestBridgeWindowVisibility(true, {
+                            waitMs: 2500,
+                            reason: 'enter-pathmode'
+                        });
+                    }
+
+                    if (multiWindowOptions.singleWindowMode && !bridgeVisibilityReady) {
+                        console.warn('[Path Mode] Bridge window visibility message was not delivered in time; skip hiding Tauri to avoid black-screen switch.');
+                    } else {
+                        // Hide the Tauri window via Rust IPC only after window-visibility intent is delivered.
+                        await window.__TAURI__.core.invoke('toggle_pathmode_window', { showGodot: true });
+                        console.log('[Path Mode] Single-window toggle: Tauri hidden, Godot shown.');
                     }
-                    console.log('[Path Mode] Single-window toggle: Tauri hidden, Godot shown.');
                 } catch (err) {
                     console.warn('[Path Mode] toggle_pathmode_window failed:', err);
                 }

src/frontend/path_app.js

@@ -36,6 +36,7 @@ window.pathApp = {
     },
     bridgeLanguageListenerRegistered: false,
     bridgeMermaidRenderQueue: Promise.resolve(),
+    pendingWindowVisibility: null,
     semanticA11yLastSummaryKey: '',
     semanticA11yLastAnnouncementAt: 0,
 
@@ -101,6 +102,7 @@ window.pathApp = {
             this._sendBridgeMessage('identify', this._getBridgeIdentifyPayload('frontend'));
             this._ensureLanguageSyncListener();
             this.syncLanguageWithBridge();
+            this._flushPendingWindowVisibility('socket-open');
         };
         this.ws.onmessage = (e) => {
             try {
@@ -254,6 +256,7 @@ window.pathApp = {
             this._sendBridgeMessage('identify', this._getBridgeIdentifyPayload('frontend'));
             this._ensureLanguageSyncListener();
             this.syncLanguageWithBridge();
+            this._flushPendingWindowVisibility('socket-reuse');
         }
     },
 
@@ -497,6 +500,68 @@ window.pathApp = {
         return true;
     },
 
+    _waitForBridgeSocketOpen: async function(timeoutMs = 2500) {
+        const budget = Math.max(0, Number(timeoutMs) || 0);
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            return true;
+        }
+        if (budget === 0) {
+            return false;
+        }
+        this._connectBridgeSocket();
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < budget) {
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                return true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            this._connectBridgeSocket();
+        }
+        return this.ws && this.ws.readyState === WebSocket.OPEN;
+    },
+
+    _flushPendingWindowVisibility: function(reason = 'flush') {
+        if (typeof this.pendingWindowVisibility !== 'boolean') {
+            return false;
+        }
+        const visible = this.pendingWindowVisibility;
+        const sent = this._sendBridgeMessage('setWindowVisible', { visible });
+        if (sent) {
+            console.log(`[PathApp] Flushed pending setWindowVisible(${visible}) via ${reason}.`);
+            this.pendingWindowVisibility = null;
+            return true;
+        }
+        return false;
+    },
+
+    requestBridgeWindowVisibility: async function(visible, options = {}) {
+        const targetVisible = visible === true;
+        const waitMs = Math.max(0, Number(options.waitMs) || 0);
+        const reason = String(options.reason || 'manual');
+
+        const sentImmediately = this._sendBridgeMessage('setWindowVisible', { visible: targetVisible });
+        if (sentImmediately) {
+            console.log(`[PathApp] Sent setWindowVisible(${targetVisible}) immediately. reason=${reason}`);
+            this.pendingWindowVisibility = null;
+            return true;
+        }
+
+        this.pendingWindowVisibility = targetVisible;
+        this._connectBridgeSocket();
+        if (waitMs === 0) {
+            console.warn(`[PathApp] Deferred setWindowVisible(${targetVisible}) until socket opens. reason=${reason}`);
+            return false;
+        }
+
+        const ready = await this._waitForBridgeSocketOpen(waitMs);
+        if (!ready) {
+            console.warn(`[PathApp] Bridge socket not ready for setWindowVisible(${targetVisible}). reason=${reason}`);
+            return false;
+        }
+        const flushed = this._flushPendingWindowVisibility(`wait-${reason}`);
+        return flushed;
+    },
+
     _getBridgeMermaidConfig: function(theme = 'dark') {
         return {
             startOnLoad: false,
@@ -1656,15 +1721,11 @@ window.pathApp = {
         // 单窗口切换：隐藏 Godot，显示 Tauri。
         if (window.__TAURI__ && window.__TAURI__.core && typeof window.__TAURI__.core.invoke === 'function') {
             // 1. Hide Godot window via PathBridge WebSocket.
-            if (
-                multiWindowOptions.singleWindowMode &&
-                this.ws &&
-                this.ws.readyState === WebSocket.OPEN
-            ) {
-                this.ws.send(JSON.stringify({
-                    type: 'setWindowVisible',
-                    payload: { visible: false }
-                }));
+            if (multiWindowOptions.singleWindowMode) {
+                void this.requestBridgeWindowVisibility(false, {
+                    waitMs: 1200,
+                    reason: 'exit-pathmode'
+                });
             }
             // 2. Restore Tauri window via Rust IPC.
             if (multiWindowOptions.restoreTauriWhenPathmodeExits) {