@mindexec/cli 0.2.494 → 0.2.496

package/electron/preload.cjs

@@ -191,5 +191,17 @@ contextBridge.exposeInMainWorld('mindExecDesktop', {
       ipcRenderer.on('updates:status', listener);
       return () => ipcRenderer.removeListener('updates:status', listener);
     }
+  },
+  nativeRender: {
+    getStatus: () => ipcRenderer.invoke('native-renderer:get-status'),
+    sendSnapshot: scene => ipcRenderer.invoke('native-renderer:snapshot', scene),
+    sendCamera: frame => ipcRenderer.invoke('native-renderer:camera', frame),
+    detach: owner => ipcRenderer.invoke('native-renderer:detach', owner),
+    onStatus: callback => {
+      if (typeof callback !== 'function') return () => undefined;
+      const listener = (_event, payload) => callback(payload);
+      ipcRenderer.on('native-renderer:status', listener);
+      return () => ipcRenderer.removeListener('native-renderer:status', listener);
+    }
   }
 });

package/electron/source-smoke.mjs

@@ -6,12 +6,22 @@ import sharp from 'sharp';
 
 const electronDirectory = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(electronDirectory, '..');
+const repositoryRoot = path.resolve(packageRoot, '..');
 const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
 const mainSource = fs.readFileSync(path.join(electronDirectory, 'main.cjs'), 'utf8');
 const preloadSource = fs.readFileSync(path.join(electronDirectory, 'preload.cjs'), 'utf8');
+const nativeRendererOwnerSource = fs.readFileSync(path.join(electronDirectory, 'native-renderer-owner.cjs'), 'utf8');
+const nativeRendererOwnerSmokeSource = fs.readFileSync(
+  path.join(electronDirectory, 'native-renderer-owner-smoke.mjs'),
+  'utf8'
+);
 const updateManagerSource = fs.readFileSync(path.join(electronDirectory, 'update-manager.cjs'), 'utf8');
 const updateFeed = JSON.parse(fs.readFileSync(path.join(electronDirectory, 'update-feed.json'), 'utf8'));
 const serverSource = fs.readFileSync(path.join(packageRoot, 'server.js'), 'utf8');
+const nativeRendererStageSource = fs.readFileSync(
+  path.join(repositoryRoot, 'scripts', 'prepare-desktop-native-renderer.ps1'),
+  'utf8'
+);
 
 assert.equal(packageJson.build?.appId, 'com.mindexec.desktop', 'Stable desktop appId is required.');
 assert.equal(packageJson.build?.productName, 'MindExec', 'Desktop product name changed unexpectedly.');
@@ -35,7 +45,28 @@ assert.equal(packageJson.dependencies?.['electron-updater'], '^6.8.9', 'The pack
 assert.equal(packageJson.build?.extraMetadata?.desktopUpdateChannel, 'dev', 'Development installers must stay on the dev feed.');
 assert.equal(packageJson.build?.extraMetadata?.nativeCoreMode, 'native',
   'Packaged development builds must use the validated native-primary core with bounded JS fallback.');
+assert.equal(packageJson.build?.extraMetadata?.nativeRenderMode, 'mirror',
+  'Packaged Windows builds must start the native renderer in fail-open mirror mode.');
+assert.match(mainSource, /app\.isPackaged[\s\S]*path\.resolve\(__dirname, '\.\.', 'package\.json'\)/,
+  'Source Electron must resolve nativeRenderMode from the LocalBridge package instead of the electron entry directory.');
+assert.match(packageJson.scripts?.['desktop:build:win'] || '', /prepare-desktop-native-renderer\.ps1[\s\S]*electron-builder/,
+  'The Windows package build must stage the exact native renderer before Electron packaging.');
+const nativeRendererResource = packageJson.build?.extraResources?.find(
+  resource => resource.to === 'native-renderer/windows-x64'
+);
+assert.equal(nativeRendererResource?.from, '../artifacts/desktop-native/windows-x64',
+  'Electron must package only the validated native renderer staging directory.');
+assert.match(nativeRendererStageSource, /mindexec_windows_host\.exe/,
+  'The native renderer staging manifest must include the Windows host.');
+assert.match(nativeRendererStageSource, /shaders\\dxbc\\vs_canvas_shape\.sc\.bin/,
+  'The native renderer staging manifest must include the Direct3D vertex shader.');
+assert.match(nativeRendererStageSource, /shaders\\dxbc\\fs_canvas_shape\.sc\.bin/,
+  'The native renderer staging manifest must include the Direct3D fragment shader.');
+assert.match(nativeRendererStageSource, /native-renderer-manifest\.json/,
+  'The staged native renderer must carry a reproducible manifest.');
 assert.match(mainSource, /waitForNativeCoreSmoke/, 'Packaged smoke must verify the native Wasm runtime, not only its URL mode.');
+assert.match(mainSource, /waitForNativeRendererSmoke[\s\S]*acceptedFrames/,
+  'Packaged smoke must wait for one real board snapshot accepted by the native renderer.');
 assert.equal(packageJson.build?.publish?.provider, 'generic', 'Desktop updates must use the generic R2-backed provider.');
 assert.equal(packageJson.build?.publish?.useMultipleRangeRequest, false,
   'Packaged differential downloads must use one byte range per request.');
@@ -96,6 +127,13 @@ assert.match(mainSource, /createProductUpdateManager/, 'The Electron update mana
 assert.match(mainSource, /updates:get-status/, 'The updater status IPC contract is missing.');
 assert.match(mainSource, /updates:check/, 'The manual updater check IPC contract is missing.');
 assert.match(mainSource, /updates:install/, 'The updater install IPC contract is missing.');
+assert.match(mainSource, /createNativeRendererOwner/, 'The Electron shell must own the exact native renderer child.');
+assert.match(mainSource, /native-renderer:get-status/, 'The native renderer status IPC contract is missing.');
+assert.match(mainSource, /native-renderer:snapshot/, 'The native renderer snapshot IPC contract is missing.');
+assert.match(mainSource, /native-renderer:camera/, 'The native renderer camera IPC contract is missing.');
+assert.match(mainSource, /native-renderer:detach/, 'The native renderer detach IPC contract is missing.');
+assert.match(mainSource, /await nativeRenderer\?\.stop\(\)[\s\S]{0,180}await stopBundledBridge\(\)/,
+  'The native renderer child must stop before an update installer starts.');
 assert.match(mainSource, /await stopBundledBridge\(\)[\s\S]{0,180}await waitForBundledRuntimePortsReleased\(\)/,
   'The Bridge and RemoteHub ports must reach zero before the installer starts.');
 assert.doesNotMatch(mainSource, /Restart and update|promptForDownloadedUpdate|showMessageBox\(mainWindow/, 'Update availability must not open a restart modal.');
@@ -111,6 +149,25 @@ assert.match(preloadSource, /border:\s*0[\s\S]{0,80}border-radius:\s*50%[\s\S]{0
 assert.match(preloadSource, /ipcRenderer\.invoke\('updates:install'\)/, 'Clicking the update indicator must use the owned install IPC path.');
 assert.match(preloadSource, /mindExecDesktop/, 'The updater preload namespace changed unexpectedly.');
 assert.match(preloadSource, /updates:\s*\{/, 'The updater preload API is missing.');
+assert.match(preloadSource, /nativeRender:\s*\{/, 'The isolated native renderer preload API is missing.');
+assert.match(preloadSource, /sendSnapshot:[\s\S]{0,100}native-renderer:snapshot/,
+  'The native renderer snapshot must cross the typed preload IPC boundary.');
+assert.match(preloadSource, /sendCamera:[\s\S]{0,100}native-renderer:camera/,
+  'The native renderer camera must cross the typed preload IPC boundary.');
+assert.match(nativeRendererOwnerSource, /MAX_PAYLOAD_BYTES\s*=\s*32\s*\*\s*1024\s*\*\s*1024/,
+  'The native renderer IPC payload must remain bounded to 32 MiB.');
+assert.match(nativeRendererOwnerSource, /engine-generation-mismatch/,
+  'Electron must reject page messages from a stale native renderer generation.');
+assert.match(nativeRendererOwnerSource, /LIFECYCLE_STATE\.stopping[\s\S]{0,180}native-renderer-stopping/,
+  'The native renderer owner must reject new work while its child is stopping.');
+assert.match(nativeRendererOwnerSource, /native-renderer-force-exit-timeout/,
+  'A missing child exit confirmation must block native renderer shutdown completion.');
+assert.match(nativeRendererOwnerSmokeSource, /sendOwned spawned a replacement native renderer/,
+  'The desktop suite must cover send-versus-stop lifecycle races.');
+assert.match(nativeRendererOwnerSmokeSource, /stop promise settled when SIGKILL was sent/,
+  'The desktop suite must require a real child exit after force-kill.');
+assert.match(nativeRendererOwnerSmokeSource, /force-exit timeout discarded the still-running child reference/,
+  'The desktop suite must retain ownership when a force-killed child never confirms exit.');
 assert.match(updateManagerSource, /autoDownload\s*=\s*false/, 'Updates must not download through an unowned implicit path.');
 assert.match(updateManagerSource, /autoInstallOnAppQuit\s*=\s*false/, 'Updates must not restart without the explicit prompt path.');
 assert.match(updateManagerSource, /useMultipleRangeRequest:\s*false/,

package/electron/windows-package-smoke.mjs

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import { spawn } from 'node:child_process';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import net from 'node:net';
 import os from 'node:os';
@@ -17,9 +18,68 @@ const outputDirectory = process.env.MINDEXEC_ELECTRON_OUTPUT
   ? path.resolve(process.env.MINDEXEC_ELECTRON_OUTPUT)
   : path.join(repositoryRoot, 'artifacts', 'electron');
 const executablePath = path.join(outputDirectory, 'win-unpacked', 'MindExec.exe');
+const nativeRendererDirectory = path.join(
+  outputDirectory,
+  'win-unpacked',
+  'resources',
+  'native-renderer',
+  'windows-x64'
+);
+const nativeRendererExecutablePath = path.join(nativeRendererDirectory, 'mindexec_windows_host.exe');
+const nativeRendererManifestPath = path.join(nativeRendererDirectory, 'native-renderer-manifest.json');
+const nativeRendererVertexShaderPath = path.join(
+  nativeRendererDirectory,
+  'shaders',
+  'dxbc',
+  'vs_canvas_shape.sc.bin'
+);
+const nativeRendererFragmentShaderPath = path.join(
+  nativeRendererDirectory,
+  'shaders',
+  'dxbc',
+  'fs_canvas_shape.sc.bin'
+);
 
 assert.equal(process.platform, 'win32', 'The packaged Electron smoke test requires Windows.');
 assert.ok(fs.existsSync(executablePath), `Packaged Electron executable is missing: ${executablePath}`);
+assert.ok(fs.statSync(nativeRendererExecutablePath).size > 100_000,
+  `Packaged native renderer executable is missing or truncated: ${nativeRendererExecutablePath}`);
+assert.ok(fs.statSync(nativeRendererVertexShaderPath).size > 100,
+  `Packaged native vertex shader is missing or truncated: ${nativeRendererVertexShaderPath}`);
+assert.ok(fs.statSync(nativeRendererFragmentShaderPath).size > 100,
+  `Packaged native fragment shader is missing or truncated: ${nativeRendererFragmentShaderPath}`);
+const nativeRendererManifest = JSON.parse(fs.readFileSync(nativeRendererManifestPath, 'utf8'));
+assert.equal(nativeRendererManifest.schema, 'mindexec-native-renderer-package/v1',
+  'Packaged native renderer manifest schema drifted.');
+assert.equal(nativeRendererManifest.msvcRuntime, 'static',
+  'Packaged native renderer must use the static Visual C++ runtime.');
+assert.equal(nativeRendererManifest.requiresVisualCppRedistributable, false,
+  'Packaged native renderer must not require a separately installed Visual C++ Redistributable.');
+assert.equal(nativeRendererManifest.nativeDesktopStage, 'composition-smoke',
+  'Packaged native renderer must identify the WebView2 composition-smoke stage.');
+assert.equal(nativeRendererManifest.webView2Sdk, '1.0.3179.45',
+  'Packaged native renderer WebView2 SDK version drifted.');
+assert.equal(nativeRendererManifest.webView2Loader, 'static',
+  'Packaged native renderer must statically link the WebView2 loader.');
+assert.equal(nativeRendererManifest.requiresWebView2EvergreenRuntime, true,
+  'Packaged native renderer must declare the Evergreen WebView2 Runtime requirement.');
+assert.deepEqual(
+  nativeRendererManifest.files.map(entry => entry.path).sort(),
+  [
+    'mindexec_windows_host.exe',
+    'shaders/dxbc/fs_canvas_shape.sc.bin',
+    'shaders/dxbc/vs_canvas_shape.sc.bin'
+  ],
+  'Packaged native renderer manifest must name exactly the host and two Direct3D shaders.'
+);
+for (const entry of nativeRendererManifest.files) {
+  const packagedPath = path.join(nativeRendererDirectory, ...String(entry.path).split('/'));
+  const packagedBytes = fs.readFileSync(packagedPath);
+  assert.equal(packagedBytes.length, Number(entry.bytes),
+    `Packaged native renderer byte count drifted for ${entry.path}.`);
+  assert.equal(crypto.createHash('sha256').update(packagedBytes).digest('hex'), String(entry.sha256),
+    `Packaged native renderer SHA-256 drifted for ${entry.path}.`);
+}
 
 function reservePort() {
   return new Promise((resolve, reject) => {
@@ -85,6 +145,25 @@ function canBind(port) {
   });
 }
 
+function processExists(processId) {
+  if (!Number.isInteger(processId) || processId <= 0) return false;
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForProcessExit(processId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!processExists(processId)) return true;
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  return !processExists(processId);
+}
+
 const bridgePort = await reservePort();
 const remoteHubPort = await reservePort();
 const smokeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindexec-electron-smoke-'));
@@ -142,6 +221,22 @@ try {
   assert.match(result.nativeCore?.lastPrimaryResultType || '', /^(?:VISIBILITY|HIT_TEST|SELECTION_QUERY)_RESULT$/,
     'Packaged Electron did not report the accepted native-core result type.');
   assert.equal(result.nativeCore?.lastError, '', 'Packaged Electron native core reported an initialization error.');
+  assert.equal(result.nativeRenderer?.mode, 'mirror',
+    'Packaged Electron did not enable the native renderer mirror.');
+  assert.equal(result.nativeRenderer?.ready, true,
+    `Packaged native renderer did not become ready: ${result.nativeRenderer?.lastError || 'unknown error'}`);
+  assert.ok(String(result.nativeRenderer?.backend || '').length > 0,
+    'Packaged native renderer did not report its bgfx backend.');
+  assert.ok(Number(result.nativeRenderer?.acceptedFrames || 0) > 0,
+    'Packaged native renderer became ready but did not accept a real board frame.');
+  assert.equal(Number(result.nativeRenderer?.rejectedFrames || 0), 0,
+    'Packaged native renderer rejected a frame during its initial board mirror smoke.');
+  assert.ok(Number(result.nativeRenderer?.engineGeneration || 0) > 0,
+    'Packaged native renderer did not report an owned engine generation.');
+  assert.ok(Number(result.nativeRenderer?.processId || 0) > 0,
+    'Packaged native renderer process id is missing.');
+  assert.equal(result.nativeRenderer?.lastError, '',
+    'Packaged native renderer reported an initialization error.');
   assert.equal(result.windowTitle, `MindExec ${packageJson.version}`,
     'Packaged Electron did not keep the version visible in the title bar.');
   assert.equal(result.bridgePort, bridgePort, 'Packaged shell did not use the requested Bridge port.');
@@ -154,6 +249,8 @@ try {
   assert.equal(exitCode, 0, `Packaged Electron smoke exited with code ${exitCode}.`);
 
   await new Promise((resolve) => setTimeout(resolve, 500));
+  assert.equal(await waitForProcessExit(Number(result.nativeRenderer.processId), 5_000), true,
+    `Native renderer process ${result.nativeRenderer.processId} survived Electron exit.`);
   assert.equal(await canBind(bridgePort), true, 'Bridge port was not released after Electron exit.');
   assert.equal(await canBind(remoteHubPort), true, 'RemoteHub port was not released after Electron exit.');
 
@@ -162,6 +259,9 @@ try {
     executablePath,
     version: result.appVersion,
     runtimeMode: result.runtimeMode,
+    nativeRendererBackend: result.nativeRenderer.backend,
+    nativeRendererAcceptedFrames: result.nativeRenderer.acceptedFrames,
+    nativeRendererProcessReleased: true,
     desktopUpdateKind: result.desktopUpdate.installKind,
     bridgePortReleased: true,
     remoteHubPortReleased: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.494",
+  "version": "0.2.496",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -28,15 +28,15 @@
     "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:build:win": "powershell.exe -NoProfile -ExecutionPolicy Bypass -File ../scripts/prepare-desktop-native-renderer.ps1 && 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": "node electron/source-smoke.mjs && node electron/native-renderer-owner-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/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/codex-sdk-image-live-smoke.mjs && node --check scripts/codex-runtime-home-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/native-renderer-owner.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/native-renderer-owner-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/codex-sdk-image-live-smoke.mjs && node --check scripts/codex-runtime-home-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",
@@ -115,12 +115,13 @@
     "extraMetadata": {
       "main": "electron/main.cjs",
       "desktopUpdateChannel": "dev",
-      "nativeCoreMode": "native"
+      "nativeCoreMode": "native",
+      "nativeRenderMode": "mirror"
     },
     "directories": {
       "output": "../artifacts/electron"
     },
-    "files": [
+    "files": [
       "*.js",
       "*.cjs",
       "*.json",
@@ -129,8 +130,17 @@
       "scripts/**/*",
       "tree-sitter-grammars/**/*",
       "wwwroot/**/*",
-      "node_modules/**/*"
-    ],
+      "node_modules/**/*"
+    ],
+    "extraResources": [
+      {
+        "from": "../artifacts/desktop-native/windows-x64",
+        "to": "native-renderer/windows-x64",
+        "filter": [
+          "**/*"
+        ]
+      }
+    ],
     "win": {
       "icon": "../MindExecution.Web/wwwroot/app-icon-1024.png",
       "executableName": "MindExec",

package/scripts/desktop-update-publisher-smoke.mjs

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { createRequire } from 'node:module';
 import test from 'node:test';
 import {
   createWranglerPutCommand,
@@ -10,6 +11,9 @@ import {
   readReleasePlan
 } from './publish-mindexec-desktop-updates.mjs';
 
+const require = createRequire(import.meta.url);
+const { buildBlockMap } = require('app-builder-lib/out/targets/blockmap/blockmap.js');
+
 test('publisher launches Wrangler directly and targets the private update bucket', () => {
   const command = createWranglerPutCommand({
     key: 'dev/windows/x64/MindExec-0.2.461-dev-x64.exe',
@@ -45,7 +49,7 @@ test('publisher validates version, size, and SHA-512 before upload', async () =>
     const parsed = parseUpdateManifest(await (await import('node:fs/promises')).readFile(join(directory, 'latest.yml'), 'utf8'));
     assert.equal(parsed.version, '1.2.3');
     assert.equal(parsed.files[0].name, artifact);
-    assert.throws(
+    await assert.rejects(
       () => readReleasePlan({
         platform: 'windows-x64',
         directory,
@@ -54,7 +58,7 @@ test('publisher validates version, size, and SHA-512 before upload', async () =>
       }),
       /desktop-update-dev-unsigned-ack-required/
     );
-    assert.throws(
+    await assert.rejects(
       () => readReleasePlan({
         platform: 'windows-x64',
         directory,
@@ -65,7 +69,31 @@ test('publisher validates version, size, and SHA-512 before upload', async () =>
       /desktop-update-blockmap-missing/
     );
     await writeFile(join(directory, `${artifact}.blockmap`), Buffer.from('blockmap'));
-    const plan = readReleasePlan({
+    await assert.rejects(
+      () => readReleasePlan({
+        platform: 'windows-x64',
+        directory,
+        packageVersion: '1.2.3',
+        channel: 'dev',
+        allowUnsigned: true
+      }),
+      /desktop-update-blockmap-artifact-mismatch/
+    );
+    const differentArtifactPath = join(directory, 'different-installer.exe');
+    await writeFile(differentArtifactPath, Buffer.from('different-installer-bytes'));
+    await buildBlockMap(differentArtifactPath, 'gzip', join(directory, `${artifact}.blockmap`));
+    await assert.rejects(
+      () => readReleasePlan({
+        platform: 'windows-x64',
+        directory,
+        packageVersion: '1.2.3',
+        channel: 'dev',
+        allowUnsigned: true
+      }),
+      /desktop-update-blockmap-artifact-mismatch/
+    );
+    await buildBlockMap(join(directory, artifact), 'gzip', join(directory, `${artifact}.blockmap`));
+    const plan = await readReleasePlan({
       platform: 'windows-x64',
       directory,
       packageVersion: '1.2.3',
@@ -74,7 +102,7 @@ test('publisher validates version, size, and SHA-512 before upload', async () =>
     });
     assert.equal(plan.prefix, 'dev/windows/x64');
     assert.deepEqual(plan.artifacts.map(item => item.fileName), [artifact, `${artifact}.blockmap`]);
-    assert.throws(
+    await assert.rejects(
       () => readReleasePlan({
         platform: 'windows-x64',
         directory,
@@ -84,7 +112,7 @@ test('publisher validates version, size, and SHA-512 before upload', async () =>
       }),
       /desktop-update-version-mismatch/
     );
-    assert.throws(
+    await assert.rejects(
       () => readReleasePlan({
         platform: 'windows-x64',
         directory,

package/scripts/publish-mindexec-desktop-updates.mjs

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { basename, isAbsolute, join, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { spawnSync } from 'node:child_process';
@@ -14,6 +15,7 @@ const PLATFORM_CONFIG = {
 const packageRoot = resolve(import.meta.dirname, '..');
 const repositoryRoot = resolve(packageRoot, '..');
 const require = createRequire(import.meta.url);
+const { buildBlockMap } = require('app-builder-lib/out/targets/blockmap/blockmap.js');
 
 function resolveWranglerEntry() {
   const explicit = String(process.env.MINDEXEC_WRANGLER_ENTRY || '').trim();
@@ -51,9 +53,25 @@ function sha512Base64(filePath) {
 function contentType(fileName) {
   if (/\.ya?ml$/i.test(fileName)) return 'text/yaml; charset=utf-8';
   if (/\.json$/i.test(fileName)) return 'application/json; charset=utf-8';
+  if (/\.blockmap$/i.test(fileName)) return 'application/gzip';
   return 'application/octet-stream';
 }
 
+async function assertBlockmapMatchesArtifact(artifactPath, blockmapPath) {
+  const scratchDirectory = mkdtempSync(join(tmpdir(), 'mindexec-blockmap-verify-'));
+  const expectedBlockmapPath = join(scratchDirectory, 'expected.blockmap');
+  try {
+    await buildBlockMap(artifactPath, 'gzip', expectedBlockmapPath);
+    const expected = readFileSync(expectedBlockmapPath);
+    const actual = readFileSync(blockmapPath);
+    if (!actual.equals(expected)) {
+      throw new Error(`desktop-update-blockmap-artifact-mismatch:${basename(blockmapPath)}`);
+    }
+  } finally {
+    rmSync(scratchDirectory, { recursive: true, force: true });
+  }
+}
+
 function isReleaseArtifact(fileName, version, channel) {
   const prefix = channel === 'dev'
     ? `MindExec-${version}-dev-`
@@ -61,7 +79,7 @@ function isReleaseArtifact(fileName, version, channel) {
   return fileName.startsWith(prefix) && /(?:\.exe|\.exe\.blockmap)$/i.test(fileName);
 }
 
-export function readReleasePlan({
+export async function readReleasePlan({
   platform,
   directory,
   packageVersion,
@@ -102,9 +120,11 @@ export function readReleasePlan({
     }
     if (/\.exe$/i.test(item.name)) {
       const blockmapName = `${item.name}.blockmap`;
-      if (!existsSync(resolve(releaseDir, blockmapName))) {
+      const blockmapPath = resolve(releaseDir, blockmapName);
+      if (!existsSync(blockmapPath)) {
         throw new Error(`desktop-update-blockmap-missing:${blockmapName}`);
       }
+      await assertBlockmapMatchesArtifact(filePath, blockmapPath);
     }
   }
 
@@ -171,8 +191,9 @@ async function verifyPublished(plan) {
   }
 
   for (const artifact of plan.artifacts) {
+    const verifyBody = /\.blockmap$/i.test(artifact.fileName);
     const artifactResponse = await fetch(`${PUBLIC_BASE_URL}/${plan.prefix}/${encodeURIComponent(artifact.fileName)}`, {
-      method: 'HEAD',
+      method: verifyBody ? 'GET' : 'HEAD',
       cache: 'no-store'
     });
     if (!artifactResponse.ok) {
@@ -182,6 +203,14 @@ async function verifyPublished(plan) {
     if (Number(artifactResponse.headers.get('content-length') || 0) !== expectedSize) {
       throw new Error(`desktop-update-public-artifact-size-mismatch:${artifact.fileName}`);
     }
+    if (verifyBody) {
+      const publishedHash = createHash('sha512')
+        .update(Buffer.from(await artifactResponse.arrayBuffer()))
+        .digest('base64');
+      if (publishedHash !== sha512Base64(artifact.filePath)) {
+        throw new Error(`desktop-update-public-artifact-hash-mismatch:${artifact.fileName}`);
+      }
+    }
   }
 }
 
@@ -199,7 +228,7 @@ async function main() {
   }
 
   const packageInfo = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
-  const plan = readReleasePlan({ platform, directory, packageVersion: packageInfo.version, channel, allowUnsigned });
+  const plan = await readReleasePlan({ platform, directory, packageVersion: packageInfo.version, channel, allowUnsigned });
   const publish = hasFlag('--publish');
   console.log(JSON.stringify({
     platform: plan.platform,

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

@@ -2997,6 +2997,9 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             boardId,
             reason: 'cache-attach'
         });
+        // A JS cache hit skips the C# OnBoardLoaded path, so its normal
+        // completion callback cannot restore this active-board marker.
+        markBoardLoadComplete(boardId, 'cache-attach');
 
         // Force a few render frames
         moduleInstance._forceUpdateFrames = Math.max(moduleInstance._forceUpdateFrames || 0, 6);

package/wwwroot/_content/MindExecution.Shared/js/mind-map-logic-workers.js

@@ -1,7 +1,7 @@
 (function () {
     'use strict';
 
-    const LOGIC_WORKER_BRIDGE_BUILD_ID = '20260830-native-primary-v013';
+    const LOGIC_WORKER_BRIDGE_BUILD_ID = '20260830-native-render-mirror-v014';
     const LEGACY_VISIBILITY_WORKER_URL = `_content/MindExecution.Shared/js/mind-map-visibility-worker.js?v=${LOGIC_WORKER_BRIDGE_BUILD_ID}`;
     const NATIVE_CORE_MODE = String(window.MindMapNativeCoreBridge?.getMode?.() || 'off');
     const NATIVE_PRIMARY_ENABLED = NATIVE_CORE_MODE === 'native';
@@ -245,6 +245,7 @@
             this._pendingSelectionResolvers = new Map();
             this._pendingSearchResolvers = new Map();
             this._nativeCoreShadow = window.MindMapNativeCoreBridge?.createShadow?.() || null;
+            this._nativeRenderMirror = window.MindMapNativeRenderMirror?.createController?.(this.module) || null;
 
             this._createWorkers();
         }
@@ -1151,6 +1152,8 @@
 
         dispose() {
             this._disposed = true;
+            this._nativeRenderMirror?.dispose?.();
+            this._nativeRenderMirror = null;
             this._clearVisibilityReadyTimer();
             this._resetPendingVisibilityQueries();
             try {
@@ -1200,6 +1203,7 @@
                 reason,
                 cellSize: Math.max(1, Number(this.module?.GRID_CELL_SIZE || 500))
             };
+            this._nativeRenderMirror?.resetBoard?.(normalizedBoardId, reason);
             this._postVisibility(payload);
             this._post(this._lodPlanWorker, payload);
             this._postSearch(payload);
@@ -1237,6 +1241,11 @@
                 cellSize: Math.max(1, Number(activeModule.GRID_CELL_SIZE || 500)),
                 nodes
             };
+            this._nativeRenderMirror?.geometryChanged?.(
+                activeModule,
+                boardId,
+                String(options.reason || 'rebuild-node-tables')
+            );
 
             const postedVisibility = this._postVisibility(payload);
             const postedLodPlan = this._post(this._lodPlanWorker, payload);
@@ -1278,6 +1287,11 @@
                 this._boardRevision++;
                 this._visibilityNodeIds.add(snapshot.id);
                 this._visibilityNodeSnapshots.set(snapshot.id, snapshot);
+                this._nativeRenderMirror?.geometryChanged?.(
+                    activeModule,
+                    boardId,
+                    String(options.reason || 'upsert-node')
+                );
             }
             if (searchSnapshot) {
                 this._searchRevision++;
@@ -1318,6 +1332,11 @@
             this._searchRevision++;
             this._visibilityNodeIds.delete(normalizedNodeId);
             this._visibilityNodeSnapshots.delete(normalizedNodeId);
+            this._nativeRenderMirror?.geometryChanged?.(
+                module || this.module,
+                boardId,
+                String(options.reason || 'remove-node')
+            );
 
             const payload = {
                 type: 'REMOVE_NODE',
@@ -1364,6 +1383,7 @@
         }
 
         requestVisibility(module = this.module, camera) {
+            this._nativeRenderMirror?.cameraChanged?.(module || this.module, camera);
             if (this._visibilityDisabled || !this._visibilityReady) {
                 return false;
             }