@mindexec/cli 0.2.493 → 0.2.495

package/electron/main.cjs

@@ -7,6 +7,7 @@ const http = require('http');
 const net = require('net');
 const path = require('path');
 const workspaceState = require('../desktop-workspace-state.cjs');
+const { createNativeRendererOwner } = require('./native-renderer-owner.cjs');
 const { createProductUpdateManager } = require('./update-manager.cjs');
 const {
   DEFAULT_UPDATE_INTERVAL_MS,
@@ -33,6 +34,7 @@ let desktopWorkspaceStatePath = '';
 let productUpdates = null;
 let recurringProductUpdates = null;
 let updateInstallSequenceStarted = false;
+let nativeRenderer = null;
 
 function resolveDesktopIconPath() {
   const iconPath = path.resolve(__dirname, '..', 'wwwroot', 'icon-512.png');
@@ -61,6 +63,28 @@ function resolveNativeCoreMode() {
   }
 }
 
+function resolveNativeRendererMode() {
+  const validModes = new Set(['off', 'mirror']);
+  const environmentMode = String(
+    process.env.MINDEXEC_NATIVE_RENDER_MODE || process.env.MINDEXEC_NATIVE_RENDERER_MODE || ''
+  ).trim().toLowerCase();
+  if (validModes.has(environmentMode)) return environmentMode;
+
+  try {
+    const packagePath = app.isPackaged
+      ? path.join(app.getAppPath(), 'package.json')
+      : path.resolve(__dirname, '..', 'package.json');
+    const packageInfo = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const configuredMode = app.isPackaged
+      ? packageInfo.nativeRenderMode
+      : packageInfo.build?.extraMetadata?.nativeRenderMode;
+    const normalizedMode = String(configuredMode || '').trim().toLowerCase();
+    return validModes.has(normalizedMode) ? normalizedMode : 'off';
+  } catch {
+    return 'off';
+  }
+}
+
 function parsePort(value) {
   const parsed = Number.parseInt(String(value ?? ''), 10);
   return Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535 ? parsed : 0;
@@ -236,19 +260,23 @@ async function prepareBundledRuntime() {
   return waitForBundledBridge();
 }
 
-function assertTrustedUpdateIpc(event) {
+function assertTrustedDesktopIpc(event, feature) {
   const senderUrl = event?.senderFrame?.url || event?.sender?.getURL?.() || '';
   let sender;
   try {
     sender = new URL(senderUrl);
   } catch {
-    throw new Error('desktop-update-ipc-sender-invalid');
+    throw new Error(`desktop-${feature}-ipc-sender-invalid`);
   }
   if (sender.protocol !== 'http:' || sender.hostname !== '127.0.0.1' || sender.port !== String(activeBridgePort)) {
-    throw new Error('desktop-update-ipc-sender-untrusted');
+    throw new Error(`desktop-${feature}-ipc-sender-untrusted`);
   }
 }
 
+function assertTrustedUpdateIpc(event) {
+  assertTrustedDesktopIpc(event, 'update');
+}
+
 function registerUpdateIpc() {
   const handle = (channel, callback) => {
     ipcMain.handle(channel, async (event) => {
@@ -261,6 +289,50 @@ function registerUpdateIpc() {
   handle('updates:install', () => productUpdates?.install() || Promise.resolve({ state: 'unavailable' }));
 }
 
+function sendNativeRendererStatus(status) {
+  appendDesktopLog(
+    `[native-renderer] mode=${status.mode} ready=${status.ready} backend=${status.backend || ''} ` +
+    `generation=${status.engineGeneration} accepted=${status.acceptedFrames} rejected=${status.rejectedFrames}` +
+    `${status.lastError ? ` error=${status.lastError}` : ''}`
+  );
+  if (mainWindow && !mainWindow.isDestroyed() && !mainWindow.webContents.isDestroyed()) {
+    mainWindow.webContents.send('native-renderer:status', status);
+  }
+}
+
+function initializeNativeRenderer() {
+  nativeRenderer = createNativeRendererOwner({
+    mode: resolveNativeRendererMode(),
+    appIsPackaged: app.isPackaged,
+    resourcesPath: process.resourcesPath,
+    packageRoot: path.resolve(__dirname, '..'),
+    onStatus: sendNativeRendererStatus,
+    log: appendDesktopLog
+  });
+}
+
+function registerNativeRendererIpc() {
+  const handle = (channel, callback) => {
+    ipcMain.handle(channel, async (event, payload) => {
+      assertTrustedDesktopIpc(event, 'native-renderer');
+      return callback(payload);
+    });
+  };
+  handle('native-renderer:get-status', () => nativeRenderer?.getStatus() || {
+    mode: 'off',
+    ready: false,
+    backend: '',
+    engineGeneration: 0,
+    acceptedFrames: 0,
+    rejectedFrames: 0,
+    lastError: '',
+    processId: 0
+  });
+  handle('native-renderer:snapshot', scene => nativeRenderer?.sendSnapshot(scene));
+  handle('native-renderer:camera', frame => nativeRenderer?.sendCamera(frame));
+  handle('native-renderer:detach', owner => nativeRenderer?.detach(owner));
+}
+
 function sendUpdateStatus(status) {
   appendDesktopLog(
     `[update] state=${status.state} current=${status.currentVersion || ''} ` +
@@ -389,6 +461,23 @@ async function waitForNativeCoreSmoke(browserWindow, expectedMode) {
   throw new Error(`Native core did not become ready in ${expectedMode} mode: ${JSON.stringify(lastSnapshot)}`);
 }
 
+async function waitForNativeRendererSmoke(expectedMode) {
+  if (expectedMode === 'off') return nativeRenderer?.getStatus() || null;
+  const deadline = Date.now() + 30_000;
+  let lastSnapshot = null;
+  while (Date.now() < deadline) {
+    lastSnapshot = nativeRenderer?.getStatus() || null;
+    if (lastSnapshot?.lastError) {
+      throw new Error(`Native renderer smoke failed: ${lastSnapshot.lastError}`);
+    }
+    if (lastSnapshot?.ready === true && Number(lastSnapshot.acceptedFrames || 0) > 0) {
+      return lastSnapshot;
+    }
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error(`Native renderer did not accept a board frame: ${JSON.stringify(lastSnapshot)}`);
+}
+
 async function stopBundledBridge() {
   const child = bridgeChild;
   bridgeChild = null;
@@ -448,9 +537,10 @@ async function prepareRuntimeForUpdateInstall() {
   recurringProductUpdates?.stop();
   isQuitting = true;
   appendDesktopLog('[update] stopping bundled runtime before installer launch');
+  await nativeRenderer?.stop();
   await stopBundledBridge();
   await waitForBundledRuntimePortsReleased();
-  appendDesktopLog('[update] bundled runtime and ports are fully released');
+  appendDesktopLog('[update] native renderer, bundled runtime, and ports are fully released');
 }
 
 async function recoverRuntimeAfterUpdateInstallError(error) {
@@ -460,11 +550,15 @@ async function recoverRuntimeAfterUpdateInstallError(error) {
   if (!bridgeChild || bridgeChild.exitCode !== null) {
     await prepareBundledRuntime();
   }
+  await nativeRenderer?.start();
   recurringProductUpdates?.start();
 }
 
 async function launchDesktop() {
-  const status = await prepareBundledRuntime();
+  const [status] = await Promise.all([
+    prepareBundledRuntime(),
+    nativeRenderer?.start()
+  ]);
   const window = createMainWindow();
   const nativeCoreMode = resolveNativeCoreMode();
   const nativeCoreQuery = nativeCoreMode === 'off'
@@ -475,6 +569,7 @@ async function launchDesktop() {
 
   if (process.env.MINDEXEC_DESKTOP_SMOKE === '1') {
     const nativeCore = await waitForNativeCoreSmoke(window, nativeCoreMode);
+    const nativeRendererStatus = await waitForNativeRendererSmoke(nativeRenderer?.getStatus().mode || 'off');
     writeSmokeResult({
       ok: true,
       appVersion: app.getVersion(),
@@ -486,6 +581,7 @@ async function launchDesktop() {
       workspace: activeWorkspace,
       url: appUrl,
       nativeCore,
+      nativeRenderer: nativeRendererStatus,
       desktopUpdate: productUpdates?.getStatus() || null
     });
     setTimeout(() => app.quit(), 250).unref();
@@ -514,20 +610,25 @@ if (!hasSingleInstanceLock) {
   });
 
   app.on('before-quit', (event) => {
-    if (isQuitting || !bridgeChild || bridgeChild.exitCode !== null) {
+    const bridgeRunning = Boolean(bridgeChild && bridgeChild.exitCode === null);
+    const nativeRendererRunning = nativeRenderer?.isRunning() === true;
+    if (isQuitting || (!bridgeRunning && !nativeRendererRunning)) {
       return;
     }
 
     event.preventDefault();
     recurringProductUpdates?.stop();
     isQuitting = true;
-    stopBundledBridge().finally(() => app.exit(requestedExitCode));
+    Promise.all([nativeRenderer?.stop(), stopBundledBridge()])
+      .finally(() => app.exit(requestedExitCode));
   });
 
   app.whenReady()
     .then(async () => {
       initializeProductUpdates();
+      initializeNativeRenderer();
       registerUpdateIpc();
+      registerNativeRendererIpc();
       void productUpdates.checkAtStartup().catch(error => {
         appendDesktopLog(`[update:startup-error] ${error?.stack || error}`);
       });

package/electron/native-renderer-owner-smoke.mjs

@@ -0,0 +1,387 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
+import protocol from './native-renderer-owner.cjs';
+
+const {
+  HEADER_BYTES,
+  PROTOCOL_MAGIC,
+  PROTOCOL_VERSION,
+  REQUEST_TYPE,
+  RESPONSE_TYPE,
+  createNativeRendererOwner,
+  framePayload
+} = protocol;
+
+function stringU16(value) {
+  const bytes = Buffer.from(value, 'utf8');
+  const output = Buffer.allocUnsafe(2 + bytes.length);
+  output.writeUInt16LE(bytes.length, 0);
+  bytes.copy(output, 2);
+  return output;
+}
+
+function requestOwnerPayload(payload) {
+  const boardIdLength = payload.readUInt16LE(0);
+  return payload.subarray(0, 2 + boardIdLength + 32);
+}
+
+function responseReady(backend) {
+  return framePayload(RESPONSE_TYPE.ready, stringU16(backend));
+}
+
+function responseAccepted(requestType, ownerPayload) {
+  const payload = Buffer.allocUnsafe(2 + ownerPayload.length);
+  payload.writeUInt16LE(requestType, 0);
+  ownerPayload.copy(payload, 2);
+  return framePayload(RESPONSE_TYPE.accepted, payload);
+}
+
+function responseShutdown() {
+  return framePayload(RESPONSE_TYPE.shutdown, Buffer.alloc(0));
+}
+
+class FakeNativeRendererChild extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.pid = options.pid || 4242;
+    this.exitCode = null;
+    this.stdin = new PassThrough();
+    this.stdout = new PassThrough();
+    this.stderr = new PassThrough();
+    this.requests = [];
+    this.input = Buffer.alloc(0);
+    this.holdRequestResponses = false;
+    this.autoExitOnShutdown = options.autoExitOnShutdown !== false;
+    this.autoExitOnKill = options.autoExitOnKill !== false;
+    this.killSignals = [];
+    this.stdin.on('data', chunk => this.handleInput(chunk));
+    setImmediate(() => this.stdout.write(responseReady('fake-d3d11')));
+  }
+
+  handleInput(chunk) {
+    this.input = this.input.length === 0 ? Buffer.from(chunk) : Buffer.concat([this.input, chunk]);
+    while (this.input.length >= HEADER_BYTES) {
+      const payloadLength = this.input.readUInt32LE(8);
+      const frameLength = HEADER_BYTES + payloadLength;
+      if (this.input.length < frameLength) return;
+      const frame = Buffer.from(this.input.subarray(0, frameLength));
+      this.input = this.input.subarray(frameLength);
+      this.requests.push(frame);
+      const requestType = frame.readUInt16LE(6);
+      const payload = frame.subarray(HEADER_BYTES);
+      if (requestType === REQUEST_TYPE.shutdown) {
+        this.stdout.write(responseShutdown());
+        if (this.autoExitOnShutdown) {
+          setImmediate(() => this.exit(0, null));
+        }
+      } else if (!this.holdRequestResponses) {
+        this.stdout.write(responseAccepted(requestType, requestOwnerPayload(payload)));
+      }
+    }
+  }
+
+  kill(signal) {
+    this.killSignals.push(signal);
+    if (this.autoExitOnKill) {
+      setImmediate(() => this.exit(signal === 'SIGKILL' ? 1 : 0, signal));
+    }
+    return true;
+  }
+
+  exit(code, signal) {
+    if (this.exitCode !== null) return;
+    this.exitCode = code;
+    this.emit('exit', code, signal);
+  }
+}
+
+let fakeChild = null;
+function fakeSpawn() {
+  fakeChild = new FakeNativeRendererChild();
+  return fakeChild;
+}
+fakeSpawn.__allowNonWindowsForTest = true;
+
+const statusEvents = [];
+const owner = createNativeRendererOwner({
+  mode: 'mirror',
+  appIsPackaged: false,
+  executablePath: process.execPath,
+  spawnProcess: fakeSpawn,
+  readyTimeoutMs: 1_000,
+  responseTimeoutMs: 100,
+  stopTimeoutMs: 1_000,
+  onStatus: status => statusEvents.push(status)
+});
+
+const readyStatus = await owner.start();
+assert.equal(readyStatus.ready, true, 'The native renderer owner did not accept READY.');
+assert.equal(readyStatus.backend, 'fake-d3d11', 'READY backend parsing drifted.');
+assert.equal(readyStatus.engineGeneration, 1, 'The first owned process must use generation 1.');
+assert.equal(readyStatus.processId, 4242, 'The owner must report the exact child process id.');
+
+const commonOwner = {
+  boardId: 'board-한글',
+  engineGeneration: readyStatus.engineGeneration,
+  boardEpoch: 7,
+  boardRevision: 11,
+  requestSequence: 13
+};
+const camera = {
+  x: 10,
+  y: -20,
+  z: 1_200,
+  near: 1,
+  far: 10_000,
+  fov: 45,
+  viewportW: 1_440,
+  viewportH: 960,
+  zoom: 1.25
+};
+const snapshotResult = await owner.sendSnapshot({
+  owner: commonOwner,
+  camera,
+  nodes: [{
+    handle: 1,
+    x: 100,
+    y: 200,
+    z: 0,
+    width: 320,
+    height: 180,
+    fillRgba: 0x89abcdef
+  }],
+  edges: [{
+    handle: 2,
+    sourceHandle: 1,
+    targetHandle: 1,
+    z: -1,
+    width: 3,
+    colorRgba: 0x102030ff,
+    points: [{ x: 100, y: 200 }, { x: 260, y: 290 }]
+  }]
+});
+assert.equal(snapshotResult.accepted, true, 'A valid snapshot was not acknowledged.');
+assert.equal(snapshotResult.acceptedFrames, 1, 'Accepted snapshot count drifted.');
+
+const snapshotFrame = fakeChild.requests[0];
+assert.equal(snapshotFrame.readUInt32LE(0), PROTOCOL_MAGIC, 'Snapshot magic drifted.');
+assert.equal(snapshotFrame.readUInt16LE(4), PROTOCOL_VERSION, 'Snapshot version drifted.');
+assert.equal(snapshotFrame.readUInt16LE(6), REQUEST_TYPE.snapshot, 'Snapshot request type drifted.');
+assert.equal(snapshotFrame.readUInt32LE(8), snapshotFrame.length - HEADER_BYTES,
+  'Snapshot payload length does not match its frame.');
+let offset = HEADER_BYTES;
+const boardIdLength = snapshotFrame.readUInt16LE(offset);
+offset += 2;
+assert.equal(snapshotFrame.toString('utf8', offset, offset + boardIdLength), commonOwner.boardId,
+  'UTF-8 board id encoding drifted.');
+offset += boardIdLength;
+assert.equal(snapshotFrame.readBigUInt64LE(offset), 1n, 'Engine generation encoding drifted.');
+assert.equal(snapshotFrame.readBigUInt64LE(offset + 8), 7n, 'Board epoch encoding drifted.');
+assert.equal(snapshotFrame.readBigUInt64LE(offset + 16), 11n, 'Board revision encoding drifted.');
+assert.equal(snapshotFrame.readBigUInt64LE(offset + 24), 13n, 'Request sequence encoding drifted.');
+offset += 32;
+assert.equal(snapshotFrame.readDoubleLE(offset), camera.x, 'Camera x encoding drifted.');
+assert.equal(snapshotFrame.readDoubleLE(offset + 56), camera.viewportH, 'Camera viewport height encoding drifted.');
+assert.equal(snapshotFrame.readDoubleLE(offset + 64), camera.zoom, 'Camera zoom encoding drifted.');
+offset += 72;
+assert.equal(snapshotFrame.readUInt32LE(offset), 1, 'Snapshot node count drifted.');
+assert.equal(snapshotFrame.readUInt32LE(offset + 4), 1, 'Snapshot edge count drifted.');
+assert.equal(snapshotFrame.readUInt32LE(offset + 8), 2, 'Snapshot point count drifted.');
+offset += 12;
+assert.equal(snapshotFrame.readUInt32LE(offset), 1, 'Node handle encoding drifted.');
+assert.equal(snapshotFrame.readDoubleLE(offset + 4), 100, 'Node x encoding drifted.');
+assert.equal(snapshotFrame.readUInt32LE(offset + 44), 0x89abcdef, 'Node color encoding drifted.');
+offset += 48;
+assert.equal(snapshotFrame.readUInt32LE(offset), 2, 'Edge handle encoding drifted.');
+assert.equal(snapshotFrame.readUInt32LE(offset + 4), 1, 'Edge source handle encoding drifted.');
+assert.equal(snapshotFrame.readUInt32LE(offset + 8), 1, 'Edge target handle encoding drifted.');
+assert.equal(snapshotFrame.readDoubleLE(offset + 12), -1, 'Edge z encoding drifted.');
+assert.equal(snapshotFrame.readDoubleLE(offset + 20), 3, 'Edge width encoding drifted.');
+assert.equal(snapshotFrame.readUInt32LE(offset + 28), 0x102030ff, 'Edge color encoding drifted.');
+assert.equal(snapshotFrame.readUInt32LE(offset + 32), 2, 'Edge point count encoding drifted.');
+assert.equal(snapshotFrame.readDoubleLE(offset + 36), 100, 'First edge point x encoding drifted.');
+assert.equal(snapshotFrame.readDoubleLE(offset + 60), 290, 'Second edge point y encoding drifted.');
+assert.equal(offset + 68, snapshotFrame.length, 'Snapshot record size drifted.');
+
+const requestCountBeforeStaleFrame = fakeChild.requests.length;
+const staleResult = await owner.sendCamera({
+  owner: { ...commonOwner, engineGeneration: readyStatus.engineGeneration + 1, requestSequence: 14 },
+  camera
+});
+assert.equal(staleResult.accepted, false, 'A stale renderer generation was accepted.');
+assert.equal(staleResult.reason, 'native-renderer-engine-generation-mismatch',
+  'Stale generation rejection reason drifted.');
+assert.equal(fakeChild.requests.length, requestCountBeforeStaleFrame,
+  'A stale renderer generation reached the child process.');
+
+const cameraResult = await owner.sendCamera({
+  owner: { ...commonOwner, requestSequence: 15 },
+  camera: { ...camera, x: 42 }
+});
+assert.equal(cameraResult.accepted, true, 'A valid camera frame was not acknowledged.');
+assert.equal(cameraResult.acceptedFrames, 2, 'Accepted camera count drifted.');
+assert.equal(cameraResult.rejectedFrames, 1, 'Rejected stale frame count drifted.');
+
+const detachResult = await owner.detach({ ...commonOwner, requestSequence: 16 });
+assert.equal(detachResult.accepted, true, 'A valid board detach was not acknowledged.');
+assert.equal(detachResult.acceptedFrames, 2, 'Detach must not count as a rendered frame.');
+
+fakeChild.holdRequestResponses = true;
+const pendingKeepAlive = setInterval(() => undefined, 25);
+const boundedResults = await Promise.all(Array.from({ length: 9 }, (_, index) => owner.sendCamera({
+  owner: { ...commonOwner, requestSequence: 100 + index },
+  camera
+})));
+clearInterval(pendingKeepAlive);
+assert.equal(boundedResults.filter(result => result.reason === 'native-renderer-pending-limit').length, 1,
+  'The owner must reject work beyond its bounded pending request count.');
+assert.equal(boundedResults.filter(result => result.reason === 'native-renderer-response-timeout').length, 8,
+  'The bounded pending requests did not resolve through their timeout path.');
+fakeChild.holdRequestResponses = false;
+
+const stoppedStatus = await owner.stop();
+assert.equal(stoppedStatus.ready, false, 'Stopped renderer still reports ready.');
+assert.equal(stoppedStatus.processId, 0, 'Stopped renderer still reports a child pid.');
+assert.equal(fakeChild.requests.at(-1).readUInt16LE(6), REQUEST_TYPE.shutdown,
+  'Owned shutdown did not use the protocol shutdown frame.');
+
+const missingOwner = createNativeRendererOwner({
+  mode: 'mirror',
+  executablePath: `${process.execPath}.definitely-missing`,
+  spawnProcess: fakeSpawn
+});
+const missingStatus = await missingOwner.start();
+assert.equal(missingStatus.ready, false, 'A missing renderer executable reported ready.');
+assert.match(missingStatus.lastError, /^native-renderer-executable-missing:/,
+  'A missing renderer executable must fail open with a diagnosable status.');
+
+function controlledSpawnFactory(options) {
+  const children = [];
+  const spawnControlled = () => {
+    const child = new FakeNativeRendererChild({
+      ...options,
+      pid: (options.pid || 5000) + children.length
+    });
+    children.push(child);
+    return child;
+  };
+  spawnControlled.__allowNonWindowsForTest = true;
+  return { children, spawnControlled };
+}
+
+const stoppingFactory = controlledSpawnFactory({
+  pid: 5100,
+  autoExitOnShutdown: false,
+  autoExitOnKill: true
+});
+const stoppingOwner = createNativeRendererOwner({
+  mode: 'mirror',
+  executablePath: process.execPath,
+  spawnProcess: stoppingFactory.spawnControlled,
+  readyTimeoutMs: 1_000,
+  responseTimeoutMs: 100,
+  stopTimeoutMs: 1_000,
+  forceExitTimeoutMs: 1_000
+});
+const stoppingReady = await stoppingOwner.start();
+const stoppingChild = stoppingFactory.children[0];
+const stoppingPromise = stoppingOwner.stop();
+await new Promise(resolve => setTimeout(resolve, 10));
+const sendWhileStopping = await stoppingOwner.sendCamera({
+  owner: {
+    ...commonOwner,
+    engineGeneration: stoppingReady.engineGeneration,
+    requestSequence: 201
+  },
+  camera
+});
+assert.equal(sendWhileStopping.accepted, false, 'A frame was accepted while shutdown was in progress.');
+assert.equal(sendWhileStopping.reason, 'native-renderer-stopping',
+  'A frame during shutdown did not report the lifecycle rejection.');
+assert.equal(stoppingFactory.children.length, 1,
+  'sendOwned spawned a replacement native renderer while the owned child was stopping.');
+assert.equal(stoppingOwner.isRunning(), true,
+  'The owner discarded its child before the child confirmed exit.');
+stoppingChild.exit(0, null);
+await stoppingPromise;
+assert.equal(stoppingOwner.isRunning(), false, 'Confirmed child exit did not complete shutdown.');
+
+const delayedKillFactory = controlledSpawnFactory({
+  pid: 5200,
+  autoExitOnShutdown: false,
+  autoExitOnKill: false
+});
+const delayedKillOwner = createNativeRendererOwner({
+  mode: 'mirror',
+  executablePath: process.execPath,
+  spawnProcess: delayedKillFactory.spawnControlled,
+  readyTimeoutMs: 1_000,
+  stopTimeoutMs: 20,
+  forceExitTimeoutMs: 1_000
+});
+await delayedKillOwner.start();
+const delayedKillChild = delayedKillFactory.children[0];
+let delayedStopSettled = false;
+const delayedStopPromise = delayedKillOwner.stop().then(
+  status => {
+    delayedStopSettled = true;
+    return status;
+  },
+  error => {
+    delayedStopSettled = true;
+    throw error;
+  }
+);
+await new Promise(resolve => setTimeout(resolve, 60));
+assert.ok(delayedKillChild.killSignals.includes('SIGKILL'),
+  'The owner did not force-kill a child that ignored graceful shutdown.');
+assert.equal(delayedStopSettled, false,
+  'The stop promise settled when SIGKILL was sent instead of waiting for child exit.');
+assert.equal(delayedKillOwner.getStatus().processId, delayedKillChild.pid,
+  'The owner cleared the child pid before receiving its exit event.');
+delayedKillChild.exit(1, 'SIGKILL');
+await delayedStopPromise;
+assert.equal(delayedKillOwner.getStatus().processId, 0,
+  'The owner retained the child after a confirmed forced exit.');
+
+const stuckFactory = controlledSpawnFactory({
+  pid: 5300,
+  autoExitOnShutdown: false,
+  autoExitOnKill: false
+});
+const stuckOwner = createNativeRendererOwner({
+  mode: 'mirror',
+  executablePath: process.execPath,
+  spawnProcess: stuckFactory.spawnControlled,
+  readyTimeoutMs: 1_000,
+  stopTimeoutMs: 20,
+  forceExitTimeoutMs: 20
+});
+await stuckOwner.start();
+const stuckChild = stuckFactory.children[0];
+await assert.rejects(
+  stuckOwner.stop(),
+  /native-renderer-force-exit-timeout/,
+  'A child with no exit confirmation must block shutdown completion.'
+);
+assert.equal(stuckOwner.getStatus().processId, stuckChild.pid,
+  'A force-exit timeout discarded the still-running child reference.');
+assert.equal(stuckOwner.isRunning(), true,
+  'A force-exit timeout reported a still-running child as stopped.');
+stuckChild.exit(1, 'SIGKILL');
+
+assert.ok(statusEvents.some(status => status.ready && status.backend === 'fake-d3d11'),
+  'READY status was not projected to the Electron owner.');
+
+console.log(JSON.stringify({
+  ok: true,
+  backend: readyStatus.backend,
+  acceptedFrames: cameraResult.acceptedFrames,
+  rejectedFrames: cameraResult.rejectedFrames,
+  requestCount: fakeChild.requests.length,
+  missingHostFailOpen: true,
+  sendDuringStopBlocked: true,
+  forcedExitConfirmed: true,
+  stuckChildRetained: true
+}));