@mindexec/cli 0.2.465 → 0.2.466

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.465",
+  "version": "0.2.466",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
   "files": [
     "start-bridge.bat",
     "start-bridge.sh",
-    "launch-bridge.cjs",
-    "desktop-workspace-state.cjs",
-    "server.js",
+    "launch-bridge.cjs",
+    "desktop-workspace-state.cjs",
+    "server.js",
     "remote-hub.js",
     "lzo1x.js",
     "mode4-atlas.js",
@@ -27,17 +27,19 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "desktop:start": "electron electron/main.cjs",
-    "desktop:build:win": "electron-builder --win --x64 --publish never",
-    "desktop:inspect:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned",
-    "desktop:publish:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned --publish",
-    "desktop:deploy:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
-    "desktop:check:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --dry-run --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
-    "test:desktop:update": "node --test electron/update-manager-smoke.mjs electron/recurring-update-owner-smoke.mjs scripts/desktop-update-worker-smoke.mjs scripts/desktop-update-publisher-smoke.mjs",
-    "test:desktop": "node electron/source-smoke.mjs && node scripts/desktop-workspace-state-smoke.mjs && npm run test:desktop:update",
+    "desktop:start": "electron electron/main.cjs",
+    "desktop:build:win": "electron-builder --win --x64 --publish never",
+    "desktop:inspect:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned",
+    "desktop:publish:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned --publish",
+    "desktop:deploy:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
+    "desktop:check:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --dry-run --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
+    "test:desktop:update": "node --test electron/update-manager-smoke.mjs electron/recurring-update-owner-smoke.mjs scripts/desktop-update-worker-smoke.mjs scripts/desktop-update-publisher-smoke.mjs",
+    "test:desktop": "node electron/source-smoke.mjs && node scripts/desktop-workspace-state-smoke.mjs && npm run test:desktop:update",
     "test:desktop:win": "node electron/windows-package-smoke.mjs",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check lzo1x.js && node --check mode4-atlas.js && node --check mode4-atlas-worker.js && node --check codex-runtime.js && node --check codex-model-catalog.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check desktop-workspace-state.cjs && node --check electron/main.cjs && node --check electron/preload.cjs && node --check electron/update-manager.cjs && node --check electron/update-feed-resolver.cjs && node --check electron/recurring-update-owner.cjs && node --check electron/source-smoke.mjs && node --check electron/windows-package-smoke.mjs && node --check electron/update-manager-smoke.mjs && node --check electron/recurring-update-owner-smoke.mjs && node --check scripts/desktop-workspace-state-smoke.mjs && node --check scripts/desktop-update-worker-smoke.mjs && node --check scripts/desktop-update-publisher-smoke.mjs && node --check scripts/publish-mindexec-desktop-updates.mjs && node --check ../workers/mindexec-desktop-updates/src/index.mjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/codex-model-catalog-smoke.mjs && node --check scripts/codex-sdk-runtime-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check lzo1x.js && node --check mode4-atlas.js && node --check mode4-atlas-worker.js && node --check codex-runtime.js && node --check codex-model-catalog.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check desktop-workspace-state.cjs && node --check electron/main.cjs && node --check electron/preload.cjs && node --check electron/update-manager.cjs && node --check electron/update-feed-resolver.cjs && node --check electron/recurring-update-owner.cjs && node --check electron/source-smoke.mjs && node --check electron/windows-package-smoke.mjs && node --check electron/update-manager-smoke.mjs && node --check electron/recurring-update-owner-smoke.mjs && node --check scripts/desktop-workspace-state-smoke.mjs && node --check scripts/desktop-update-worker-smoke.mjs && node --check scripts/desktop-update-publisher-smoke.mjs && node --check scripts/board-render-ownership-smoke.mjs && node --check ../workers/mindexec-desktop-updates/src/index.mjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/codex-model-catalog-smoke.mjs && node --check scripts/codex-sdk-runtime-smoke.mjs && node --check scripts/codex-sdk-image-runtime-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:canvas:board-owner": "node scripts/board-render-ownership-smoke.mjs",
     "test:codex-sdk": "node scripts/codex-sdk-runtime-smoke.mjs",
+    "test:codex-sdk:image": "node scripts/codex-sdk-image-runtime-smoke.mjs",
     "test:codex-sdk:live": "node scripts/codex-sdk-runtime-smoke.mjs --live",
     "test:codex-sdk:live-tools": "node scripts/codex-sdk-runtime-smoke.mjs --live-tools",
     "test:codex-model-catalog": "node scripts/codex-model-catalog-smoke.mjs",
@@ -83,17 +85,17 @@
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "ffmpeg-static": "^5.3.0",
-    "multer": "^2.2.0",
-    "electron-updater": "^6.8.9",
-    "playwright-core": "^1.53.0",
+    "multer": "^2.2.0",
+    "electron-updater": "^6.8.9",
+    "playwright-core": "^1.53.0",
     "sharp": "^0.35.3",
     "web-tree-sitter": "^0.22.6",
     "ws": "^8.16.0"
   },
-  "overrides": {
-    "body-parser": "1.20.6",
-    "js-yaml": "4.3.1"
-  },
+  "overrides": {
+    "body-parser": "1.20.6",
+    "js-yaml": "4.3.1"
+  },
   "bin": {
     "mindexec": "launch-bridge.cjs",
     "mind-bridge": "launch-bridge.cjs"
@@ -108,9 +110,9 @@
     "productName": "MindExec",
     "copyright": "Copyright © 2026 lovecrdm77",
     "asar": false,
-    "extraMetadata": {
-      "main": "electron/main.cjs",
-      "desktopUpdateChannel": "dev"
+    "extraMetadata": {
+      "main": "electron/main.cjs",
+      "desktopUpdateChannel": "dev"
     },
     "directories": {
       "output": "../artifacts/electron"
@@ -119,7 +121,7 @@
       "*.js",
       "*.cjs",
       "*.json",
-      "electron/**/*",
+      "electron/**/*",
       "remote-fast/**/*",
       "scripts/**/*",
       "tree-sitter-grammars/**/*",
@@ -144,8 +146,8 @@
         }
       ]
     },
-    "nsis": {
-      "artifactName": "MindExec-${version}-dev-${arch}.${ext}",
+    "nsis": {
+      "artifactName": "MindExec-${version}-dev-${arch}.${ext}",
       "oneClick": false,
       "perMachine": false,
       "allowToChangeInstallationDirectory": true,
@@ -153,12 +155,12 @@
       "createStartMenuShortcut": true,
       "shortcutName": "MindExec"
     },
-    "portable": {
-      "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
-    },
-    "publish": {
-      "provider": "generic",
-      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64"
-    }
+    "portable": {
+      "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
+    },
+    "publish": {
+      "provider": "generic",
+      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64"
+    }
   }
 }

package/scripts/board-render-ownership-smoke.mjs

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const sourcePath = path.resolve(
+    scriptDir,
+    '..',
+    '..',
+    'MindExecution.Shared',
+    'wwwroot',
+    'js',
+    'mind-map-board-render-ownership.js');
+const source = fs.readFileSync(sourcePath, 'utf8');
+const traces = [];
+const window = {
+    MindCanvasTrace: { emit: (type, data) => traces.push({ type, data }) },
+    MindCanvasBuildInfo: { registerPart: () => { } }
+};
+
+vm.runInNewContext(source, { window, Map, Object, Number, String, Math });
+
+const makeMesh = (count = 8) => ({
+    visible: true,
+    geometry: {
+        instanceCount: count,
+        drawRange: { start: 0, count: count },
+        setDrawRange(start, nextCount) {
+            this.drawRange = { start, count: nextCount };
+        }
+    }
+});
+const renderer = {
+    resetCalls: 0,
+    resetState() { this.resetCalls++; },
+    pendingNodes: new Map([['stale-node', {}]]),
+    instancedHaloMesh: makeMesh(),
+    instancedMesh: makeMesh(),
+    instancedLineMesh: makeMesh(),
+    instancedBorderLineMesh: makeMesh(),
+    instancedConsoleMesh: makeMesh(),
+    instancedImageMesh: makeMesh(),
+    requestResidentPatch(reason) { this.patchReason = reason; }
+};
+const module = { _forceUpdateFrames: 0 };
+
+assert.equal(window.MindMapBoardRenderOwnership.retireResidentBoard(renderer, module, {
+    fromBoardId: 'BOARD-B',
+    toBoardId: 'BOARD-A'
+}), true);
+assert.equal(renderer.resetCalls, 1);
+assert.equal(renderer.pendingNodes.size, 0);
+assert.equal(renderer._activeBoardRenderId, 'board-a');
+assert.equal(renderer._residentBuilt, false);
+assert.equal(renderer._residentBuildPhase, 'board-switch');
+for (const mesh of [
+    renderer.instancedHaloMesh,
+    renderer.instancedMesh,
+    renderer.instancedLineMesh,
+    renderer.instancedBorderLineMesh,
+    renderer.instancedConsoleMesh,
+    renderer.instancedImageMesh
+]) {
+    assert.equal(mesh.visible, false);
+    assert.equal(mesh.geometry.instanceCount, 0);
+}
+assert.equal(renderer.instancedBorderLineMesh.geometry.drawRange.count, 0);
+assert.equal(traces.at(-1)?.type, 'board.resident.retired');
+
+const lineDataCache = new Map([['node-a', [1, 2, 3]]]);
+assert.equal(window.MindMapBoardRenderOwnership.prepareCachedBoard(renderer, module, {
+    boardId: 'BOARD-A',
+    lineDataCache
+}), true);
+assert.equal(renderer.lineDataCache, lineDataCache);
+assert.equal(renderer.patchReason, 'board-reload');
+
+console.log(JSON.stringify({
+    ok: true,
+    retiredResidentCount: 0,
+    activeBoardRenderId: renderer._activeBoardRenderId,
+    patchReason: renderer.patchReason
+}));

package/scripts/codex-sdk-image-runtime-smoke.mjs

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCodexRuntime } from '../codex-runtime.js';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, '..');
+const workspaceRoot = path.resolve(packageRoot, '..');
+const runtimeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-sdk-image-'));
+const tinyPngBase64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jX8kAAAAASUVORK5CYII=';
+
+function imageEvents() {
+    return (async function* generateEvents() {
+        yield { type: 'thread.started', thread_id: 'thread-image-smoke' };
+        yield {
+            type: 'event_msg',
+            payload: {
+                type: 'image_generation_end',
+                result: `data:image/png;base64,${tinyPngBase64}`
+            }
+        };
+        yield { type: 'turn.completed' };
+    })();
+}
+
+function createFakeSdk(runStreamed, captures) {
+    return {
+        Codex: class FakeCodex {
+            constructor(options) {
+                captures.codexOptions.push(options);
+            }
+
+            startThread(options) {
+                captures.threadOptions.push(options);
+                return {
+                    runStreamed: async input => {
+                        captures.inputs.push(input);
+                        return { events: runStreamed() };
+                    }
+                };
+            }
+        }
+    };
+}
+
+function createRuntime(fakeSdk, loginCodex) {
+    return createCodexRuntime({
+        packageRoot,
+        resolveWorkingDirectory: async () => workspaceRoot,
+        getCurrentRuntime: () => ({}),
+        getModelCatalog: async () => ({ models: [], source: 'smoke', updatedAt: new Date().toISOString() }),
+        loadCodexSdk: async () => fakeSdk,
+        ensureCodexRuntimeHome: async () => {
+            await fs.mkdir(path.join(runtimeHome, 'generated_images'), { recursive: true });
+            return runtimeHome;
+        },
+        buildCodexChildEnv: () => ({ CODEX_HOME: runtimeHome }),
+        loginCodex,
+        log: () => {}
+    });
+}
+
+try {
+    const captures = { codexOptions: [], threadOptions: [], inputs: [] };
+    const runtime = createRuntime(createFakeSdk(imageEvents, captures), async () => {
+        throw new Error('Login must not run for an authenticated image request.');
+    });
+    const generated = await runtime.runImage({
+        prompt: 'Create a blue product icon.',
+        model: 'gpt-5.5',
+        size: '1024x1024',
+        quality: 'high',
+        referenceImages: [{ base64: tinyPngBase64, mimeType: 'image/png', fileName: 'source.png' }]
+    });
+
+    assert.equal(generated.success, true, generated.error);
+    assert.equal(generated.providerKind, 'TypeScriptSdk');
+    assert.equal(generated.imageBase64, tinyPngBase64);
+    assert.equal(generated.mimeType, 'image/png');
+    assert.equal(captures.codexOptions[0].config.features.image_generation, true);
+    assert.equal(captures.threadOptions[0].sandboxMode, 'read-only');
+    assert.equal(captures.inputs[0][0].type, 'text');
+    assert.equal(captures.inputs[0][1].type, 'local_image');
+    assert.equal(await fs.stat(captures.inputs[0][1].path).then(() => true).catch(() => false), false);
+
+    let attempts = 0;
+    let loginCount = 0;
+    const authCaptures = { codexOptions: [], threadOptions: [], inputs: [] };
+    const authSdk = createFakeSdk(() => {
+        attempts += 1;
+        if (attempts === 1) {
+            return (async function* invalidAuth() {
+                throw new Error('401 Unauthorized: invalid_refresh_token. Please log out and sign in again.');
+            })();
+        }
+        return imageEvents();
+    }, authCaptures);
+    const authRuntime = createRuntime(authSdk, async () => {
+        loginCount += 1;
+        return { success: true, exitCode: 0 };
+    });
+    const retried = await authRuntime.runImage({ prompt: 'Create one test image.' });
+
+    assert.equal(loginCount, 1);
+    assert.equal(attempts, 2);
+    assert.equal(retried.success, true, retried.error);
+    assert.equal(retried.loginOpened, true);
+    assert.equal(retried.authenticationRequired, false);
+    assert.equal(retried.providerKind, 'TypeScriptSdk');
+
+    console.log(JSON.stringify({
+        ok: true,
+        providerKind: generated.providerKind,
+        referenceAttachment: true,
+        browserLoginRetry: true
+    }));
+} finally {
+    await fs.rm(runtimeHome, { recursive: true, force: true });
+}

package/server.js

@@ -13022,6 +13022,23 @@ app.post('/api/codex/thread/run', async (req, res) => {
     }
 });
 
+app.post('/api/codex/image/run', async (req, res) => {
+    try {
+        res.json(await getCodexRuntime().runImage(req.body || {}));
+    } catch (err) {
+        console.error('[Codex/ImageRun] Error:', err);
+        res.status(err.statusCode || 500).json({
+            success: false,
+            providerKind: 'Unavailable',
+            imageBase64: '',
+            mimeType: '',
+            error: err?.message || String(err),
+            authenticationRequired: false,
+            loginOpened: false
+        });
+    }
+});
+
 app.post('/api/codex/thread/resume', async (req, res) => {
     try {
         res.json(await getCodexRuntime().resumeThread(req.body || {}));

package/wwwroot/_content/MindExecution.Shared/js/mind-map-board-render-ownership.js

@@ -0,0 +1,81 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260819-board-render-owner-v1';
+
+    function normalizeBoardId(value) {
+        return String(value || '').trim().toLowerCase();
+    }
+
+    function clearResidentGeometry(mesh, useDrawRange = false) {
+        if (!mesh) return;
+
+        mesh.visible = false;
+        const geometry = mesh.geometry;
+        if (!geometry) return;
+
+        if ('instanceCount' in geometry) {
+            geometry.instanceCount = 0;
+        }
+        if (useDrawRange && typeof geometry.setDrawRange === 'function') {
+            geometry.setDrawRange(0, 0);
+        }
+    }
+
+    function retireResidentBoard(renderer, module, details = {}) {
+        if (!renderer) return false;
+
+        renderer.resetState?.();
+        renderer.pendingNodes?.clear?.();
+
+        clearResidentGeometry(renderer.instancedHaloMesh);
+        clearResidentGeometry(renderer.instancedMesh);
+        clearResidentGeometry(renderer.instancedLineMesh);
+        clearResidentGeometry(renderer.instancedBorderLineMesh, true);
+        clearResidentGeometry(renderer.instancedConsoleMesh);
+        clearResidentGeometry(renderer.instancedImageMesh);
+
+        renderer._activeBoardRenderId = normalizeBoardId(details.toBoardId);
+        renderer._boardRenderEpoch = Math.max(0, Number(renderer._boardRenderEpoch || 0)) + 1;
+        renderer._residentBuilt = false;
+        renderer._residentBuildPhase = 'board-switch';
+
+        if (module) {
+            module._forceUpdateFrames = Math.max(Number(module._forceUpdateFrames || 0), 2);
+        }
+
+        window.MindCanvasTrace?.emit?.('board.resident.retired', {
+            fromBoardId: details.fromBoardId || null,
+            toBoardId: details.toBoardId || null,
+            reason: details.reason || 'board-switch',
+            epoch: renderer._boardRenderEpoch
+        });
+        return true;
+    }
+
+    function prepareCachedBoard(renderer, module, details = {}) {
+        if (!renderer) return false;
+
+        const boardId = normalizeBoardId(details.boardId);
+        renderer._activeBoardRenderId = boardId;
+        if (details.lineDataCache instanceof Map) {
+            renderer.lineDataCache = details.lineDataCache;
+        }
+        renderer.requestResidentPatch?.('board-reload');
+
+        if (module) {
+            module._forceUpdateFrames = Math.max(Number(module._forceUpdateFrames || 0), 2);
+        }
+        return true;
+    }
+
+    window.MindMapBoardRenderOwnership = Object.freeze({
+        BUILD_ID,
+        normalizeBoardId,
+        retireResidentBoard,
+        prepareCachedBoard
+    });
+    window.MindCanvasBuildInfo?.registerPart?.('boardRenderOwnership', BUILD_ID, {
+        file: 'mind-map-board-render-ownership.js'
+    });
+})();

package/wwwroot/_content/MindExecution.Shared/js/mind-map-core.js

@@ -2837,7 +2837,7 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
     /**
      * Detach the current board's scene objects (without destroying them) and store in cache.
      */
-    function _detachCurrentBoard(boardId) {
+    function _detachCurrentBoard(boardId, nextBoardId = null) {
         if (!moduleInstance || !boardId) return;
         const t0 = performance.now();
 
@@ -2892,6 +2892,16 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             window.MindMapCss3DManager.clearTextOverlays(moduleInstance);
         }
 
+        window.MindMapBoardRenderOwnership?.retireResidentBoard?.(
+            moduleInstance.lodRenderer,
+            moduleInstance,
+            {
+                fromBoardId: boardId,
+                toBoardId: nextBoardId,
+                reason: 'board-cache-detach'
+            }
+        );
+
         _touchBoardCache(boardId, snapshot);
         _enforceBoardCacheLimit();
 
@@ -2911,15 +2921,6 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             totalTextureMemoryBytes: 0
         });
 
-        // Reset LOD renderer state
-        if (moduleInstance.lodRenderer) {
-            moduleInstance.lodRenderer._instancesDirty = true;
-            moduleInstance.lodRenderer._isNodeArrayDirty = true;
-            moduleInstance.lodRenderer._nodeIdToIndex.clear();
-            moduleInstance.lodRenderer.lineDataCache = new Map();
-            moduleInstance.lodRenderer._cachedNodeArray = [];
-        }
-
         console.log(`[BoardCache] ??Detached board ${boardId} (${snapshot.nodeObjectsById.size} nodes) in ${(performance.now() - t0).toFixed(1)}ms`);
     }
 
@@ -2939,16 +2940,17 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
         snapshot.nodeObjectsById.forEach((entry, nodeId) => {
             try {
                 if (entry.glObject && moduleInstance.scene) {
+                    entry.glObject.visible = false;
                     moduleInstance.scene.add(entry.glObject);
                 }
                 if (entry.cssObject) {
                     const cssScene = moduleInstance.cssScene || moduleInstance.scene;
                     if (cssScene) cssScene.add(entry.cssObject);
-                    // Re-show CSS element
+                    entry.cssObject.visible = false;
+                    // Keep the cached surface neutral until the target board's
+                    // camera band becomes the active renderer owner.
                     if (entry.cssObject.element) {
-                        entry.cssObject.element.style.display = '';
-                        entry.cssObject.element.style.visibility = '';
-                        entry.cssObject.element.style.opacity = '';
+                        entry.cssObject.element.style.setProperty('display', 'none', 'important');
                     }
                 }
             } catch (e) {
@@ -2974,10 +2976,14 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
         });
 
         // Restore LOD renderer
-        if (moduleInstance.lodRenderer) {
-            moduleInstance.lodRenderer.lineDataCache = snapshot.lodLineDataCache;
-            moduleInstance.lodRenderer.requestResidentPatch?.('board-reload');
-        }
+        window.MindMapBoardRenderOwnership?.prepareCachedBoard?.(
+            moduleInstance.lodRenderer,
+            moduleInstance,
+            {
+                boardId,
+                lineDataCache: snapshot.lodLineDataCache
+            }
+        );
         moduleInstance.logicWorkerBridge?.resetBoard?.(boardId, 'cache-attach');
         moduleInstance.logicWorkerBridge?.rebuildNodeTables?.(moduleInstance, {
             boardId,
@@ -3859,6 +3865,53 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             return true;
         }
 
+        _applyLocalSnapGridMotionStyle(layer, smallStepPx, majorStepPx, opacity) {
+            if (!layer) return false;
+
+            const safeSmallStep = Math.max(
+                LOCAL_SNAP_GRID_RASTER_MIN_STEP_PX,
+                Number(smallStepPx) || LOCAL_SNAP_GRID_DEFAULT_STEP_PX
+            );
+            const safeMajorStep = Math.max(
+                safeSmallStep,
+                Math.min(
+                    LOCAL_SNAP_GRID_RASTER_MAX_PERIOD_PX,
+                    Number(majorStepPx) || LOCAL_SNAP_GRID_DEFAULT_MAJOR_STEP_PX
+                )
+            );
+            const safeOpacity = Math.max(0, Math.min(0.68, Number(opacity) || 0));
+            const smallStepValue = safeSmallStep.toFixed(3);
+            const majorStepValue = safeMajorStep.toFixed(3);
+            const backgroundSizeValue = [
+                `${smallStepValue}px ${smallStepValue}px`,
+                `${smallStepValue}px ${smallStepValue}px`,
+                `${majorStepValue}px ${majorStepValue}px`,
+                `${majorStepValue}px ${majorStepValue}px`
+            ].join(', ');
+            const backgroundImage = [
+                'linear-gradient(to right, rgba(51, 65, 85, 0.24) 0 1px, transparent 1px)',
+                'linear-gradient(to bottom, rgba(51, 65, 85, 0.24) 0 1px, transparent 1px)',
+                'linear-gradient(to right, rgba(15, 23, 42, 0.42) 0 1px, transparent 1px)',
+                'linear-gradient(to bottom, rgba(15, 23, 42, 0.42) 0 1px, transparent 1px)'
+            ].join(', ');
+            const motionKey = `motion-line|${smallStepValue}|${majorStepValue}|${safeOpacity.toFixed(3)}`;
+
+            if (motionKey === this._lastLocalSnapGridKey) return false;
+
+            this._lastLocalSnapGridKey = motionKey;
+            this._lastLocalSnapGridPatternPeriodPx = safeMajorStep;
+            this._localSnapGridRasterPeriodPx = safeMajorStep;
+            this._lastLocalSnapGridBackgroundSizeKey = backgroundSizeValue;
+            this._lastLocalSnapGridOpacity = safeOpacity.toFixed(3);
+            this._lastLocalSnapGridTransformKey = '';
+            if (layer.style.backgroundImage !== backgroundImage) layer.style.backgroundImage = backgroundImage;
+            if (layer.style.backgroundSize !== backgroundSizeValue) layer.style.backgroundSize = backgroundSizeValue;
+            if (layer.style.opacity !== this._lastLocalSnapGridOpacity) {
+                layer.style.opacity = this._lastLocalSnapGridOpacity;
+            }
+            return true;
+        }
+
         _ensureLocalSnapGridBaseStyle(layer = null) {
             const targetLayer = layer || this._ensureLocalSnapGridLayer();
             if (!targetLayer) {
@@ -3973,16 +4026,6 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                 return false;
             }
 
-            if (this.isZooming === true &&
-                !!this._lastLocalSnapGridKey &&
-                this._getLocalSnapGridStyleKind() !== 'dot') {
-                this._syncLocalSnapGridSpotlightPosition(width, height, left, top);
-                this._lastLocalSnapGridPositionRevision = pointerRevision;
-                this._localSnapGridStyleDeferredForZoom = true;
-                this._setLocalSnapGridVisible(true, opacity.toFixed(3));
-                return true;
-            }
-
             const vfov = (Number(camera.fov || 45) * Math.PI) / 180;
             const viewHeight = 2 * Math.tan(vfov / 2) * cameraZ;
             const pxPerWorld = height / Math.max(1, viewHeight);
@@ -4007,6 +4050,12 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                     opacity
                 );
             } else if (shouldDeferLocalGridStyleForZoom === true) {
+                this._applyLocalSnapGridMotionStyle(
+                    layer,
+                    smallStepPx,
+                    majorStepPx,
+                    opacity
+                );
                 this._localSnapGridStyleDeferredForZoom = true;
             }
 
@@ -4062,13 +4111,17 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                 this._applyLocalSnapGridStyle(
                     layer, styleKind, projection.smallStepPx, projection.majorStepPx, opacity);
                 this._localSnapGridStyleDeferredForZoom = false;
+            } else if (this.isZooming === true) {
+                const vfov = (Number(this.camera?.fov || 45) * Math.PI) / 180;
+                const pxPerWorld = height / Math.max(1, 2 * Math.tan(vfov / 2) * cameraZ);
+                const projection = this._resolveLocalSnapGridWorldStep(pxPerWorld);
+                this._applyLocalSnapGridMotionStyle(
+                    layer, projection.smallStepPx, projection.majorStepPx, opacity);
+                this._localSnapGridStyleDeferredForZoom = true;
             }
             this._syncLocalSnapGridSpotlightPosition(width, height, left, top);
             this._lastLocalSnapGridPositionRevision = pointerRevision;
 
-            if (this.isZooming === true && styleKind !== 'dot') {
-                this._localSnapGridStyleDeferredForZoom = true;
-            }
             this._setLocalSnapGridVisible(true, opacity.toFixed(3));
             return true;
         }
@@ -9905,7 +9958,7 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
 
             // Detach current board (save to JS cache)
             if (boardToDetach) {
-                _detachCurrentBoard(boardToDetach);
+                _detachCurrentBoard(boardToDetach, targetBoardId);
             }
             moduleInstance.setCanvasPhase?.(CanvasPhase.BoardSwitching, 'swapBoard', {
                 fromBoardId: boardToDetach || null,