You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maka.apache.org by wy...@apache.org on 2026/09/01 15:10:06 UTC

(maka) branch feat/maka-browser-recovery-dialogs updated: fix(desktop): keep recovery decisions conservative

This is an automated email from the ASF dual-hosted git repository.

M4n5ter pushed a commit to branch feat/maka-browser-recovery-dialogs
in repository https://gitbox.apache.org/repos/asf/maka.git


The following commit(s) were added to refs/heads/feat/maka-browser-recovery-dialogs by this push:
     new 3258a39fdb fix(desktop): keep recovery decisions conservative
3258a39fdb is described below

commit 3258a39fdbe101a57d492bc467f167c4b3ca5504
Author: Wang <m4...@gmail.com>
AuthorDate: Tue Sep 1 23:09:53 2026 +0800

    fix(desktop): keep recovery decisions conservative
    
    Generated-by: OpenAI Codex
---
 .../src/main/__tests__/browser-message-box.test.ts | 227 ++++++++++++++++++---
 .../__tests__/main-renderer-process-gone.test.ts   |  11 +-
 .../main/__tests__/main-startup-lifetime.test.ts   |  22 ++
 .../__tests__/runtime-host-desktop-manager.test.ts |  48 ++++-
 apps/desktop/src/main/browser-message-box.ts       |  47 +++--
 .../desktop/src/main/main-renderer-process-gone.ts |  23 +--
 apps/desktop/src/main/runtime-host-boot.ts         |   4 +-
 .../src/main/runtime-host-desktop-manager.ts       |  22 +-
 packages/runtime-host/src/client/connection.ts     |   5 +-
 packages/runtime-host/src/protocol/host-status.ts  |   8 +
 packages/runtime-host/src/protocol/operations.ts   |   1 +
 11 files changed, 316 insertions(+), 102 deletions(-)

diff --git a/apps/desktop/src/main/__tests__/browser-message-box.test.ts b/apps/desktop/src/main/__tests__/browser-message-box.test.ts
index facf758b0c..1cd801818c 100644
--- a/apps/desktop/src/main/__tests__/browser-message-box.test.ts
+++ b/apps/desktop/src/main/__tests__/browser-message-box.test.ts
@@ -18,9 +18,15 @@
  */
 
 import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
 import { test } from 'node:test';
-import type { BrowserWindow, MessageBoxReturnValue } from 'electron';
+import type {
+  BrowserWindow,
+  BrowserWindowConstructorOptions,
+  MessageBoxReturnValue,
+} from 'electron';
 import {
+  type BrowserMessageBoxRuntime,
   buildBrowserMessageBoxHtml,
   centeredBounds,
   isBrowserMessageBoxPresentationActive,
@@ -36,38 +42,46 @@ test('falls back natively and never attaches to an inaccessible parent', async (
     isVisible: () => parentState.visible,
     isMinimized: () => parentState.minimized,
     isDestroyed: () => parentState.destroyed,
+    getBounds: () => ({ x: 100, y: 100, width: 900, height: 700 }),
   } as BrowserWindow;
   const nativeParents: Array<BrowserWindow | undefined> = [];
-  const showNative = async (
-    _options: typeof options,
-    actualParent: BrowserWindow | undefined,
-  ): Promise<MessageBoxReturnValue> => {
-    nativeParents.push(actualParent);
-    return nativeResult;
+  const runtimeBase = {
+    shouldUseDarkColors: false,
+    resolveWorkArea: () => ({ x: 0, y: 0, width: 1_200, height: 800 }),
+    showNative: async (
+      _options: typeof options,
+      actualParent: BrowserWindow | undefined,
+    ): Promise<MessageBoxReturnValue> => {
+      nativeParents.push(actualParent);
+      return nativeResult;
+    },
+    onBrowserError: () => assert.fail('native presentation must not report a browser error'),
   };
 
   assert.equal(
-    await showBrowserMessageBoxWithRuntime(options, parent, {
+    await showBrowserMessageBoxWithRuntime(options, parent, { locale: 'en' }, {
+      ...runtimeBase,
       ready: false,
-      showBrowser: async () => assert.fail('pre-ready presentation must stay native'),
-      showNative,
-      onBrowserError: () => assert.fail('native presentation must not report a browser error'),
+      createWindow: () => assert.fail('pre-ready presentation must stay native'),
     }),
     nativeResult,
   );
 
   parentState.visible = true;
   const failure = new Error('renderer failed');
+  const failedWindow = fakeBrowserWindow({ loadError: failure });
   let reported: unknown;
   assert.equal(
-    await showBrowserMessageBoxWithRuntime(options, parent, {
+    await showBrowserMessageBoxWithRuntime(options, parent, { locale: 'en' }, {
+      ...runtimeBase,
       ready: true,
-      showBrowser: async (_nextOptions, actualParent) => {
-        assert.equal(actualParent, parent);
+      createWindow: (windowOptions) => {
+        assert.equal(windowOptions.parent, parent);
+        assert.equal(windowOptions.modal, true);
         parentState.minimized = true;
-        throw failure;
+        failedWindow.options = windowOptions;
+        return failedWindow.window;
       },
-      showNative,
       onBrowserError: (error) => {
         reported = error;
       },
@@ -76,35 +90,101 @@ test('falls back natively and never attaches to an inaccessible parent', async (
   );
   assert.equal(reported, failure);
   assert.deepEqual(nativeParents, [undefined, undefined]);
+  assert.equal(failedWindow.destroyed(), true);
 });
 
-test('presents a ready dialog without an inaccessible modal parent', async () => {
-  const result = { response: 0, checkboxChecked: false };
+test('drives the BrowserWindow lifecycle through a safe response URL', async () => {
   const parent = {
     isVisible: () => true,
     isMinimized: () => true,
     isDestroyed: () => false,
   } as BrowserWindow;
+  const presented = fakeBrowserWindow();
+  let createdOptions: BrowserWindowConstructorOptions | undefined;
 
-  let finishPresentation!: (value: MessageBoxReturnValue) => void;
-  const presentation = showBrowserMessageBoxWithRuntime({ message: 'Recover Maka' }, parent, {
+  const presentation = showBrowserMessageBoxWithRuntime(
+    { message: 'Recover Maka', buttons: ['Recover', 'Cancel'], cancelId: 1 },
+    parent,
+    { locale: 'en', dark: true },
+    {
       ready: true,
-      showBrowser: async (_options, actualParent) => {
+      shouldUseDarkColors: false,
+      createWindow: (options) => {
+        createdOptions = options;
+        return presented.window;
+      },
+      resolveWorkArea: (actualParent) => {
         assert.equal(actualParent, undefined);
-        return new Promise<MessageBoxReturnValue>((resolve) => {
-          finishPresentation = resolve;
-        });
+        return { x: 0, y: 0, width: 1_200, height: 800 };
       },
       showNative: async () => assert.fail('successful browser presentation must not fall back'),
       onBrowserError: () => assert.fail('successful browser presentation must not report error'),
-    });
-  await Promise.resolve();
+    },
+  );
+  await new Promise<void>((resolve) => setImmediate(resolve));
+
   assert.equal(isBrowserMessageBoxPresentationActive(), true);
-  finishPresentation(result);
-  assert.equal(await presentation, result);
+  assert.equal(createdOptions?.parent, undefined);
+  assert.equal(createdOptions?.modal, undefined);
+  assert.equal(presented.shown(), true);
+  assert.equal(presented.focused(), true);
+  assert.match(presented.loadedUrl(), /^data:text\/html/u);
+  assert.equal(presented.deniesWindowOpen(), true);
+
+  let prevented = false;
+  presented.webContents.emit(
+    'will-navigate',
+    {
+      preventDefault: () => {
+        prevented = true;
+      },
+    },
+    'maka-dialog://response/0',
+  );
+  assert.deepEqual(await presentation, { response: 0, checkboxChecked: false });
+  assert.equal(prevented, true);
+  assert.equal(presented.destroyed(), true);
   assert.equal(isBrowserMessageBoxPresentationActive(), false);
 });
 
+test('maps close to cancel and falls back after each BrowserWindow presentation failure', async () => {
+  const closed = fakeBrowserWindow();
+  const closeResult = showBrowserMessageBoxWithRuntime(
+    { message: 'Recover Maka', buttons: ['Recover', 'Cancel'], cancelId: 1 },
+    undefined,
+    { locale: 'en' },
+    runtimeForWindow(closed),
+  );
+  closed.window.emit('closed');
+  assert.deepEqual(await closeResult, { response: 1, checkboxChecked: false });
+  assert.equal(closed.destroyed(), true);
+
+  for (const scenario of ['unresponsive', 'renderer-gone', 'timeout'] as const) {
+    const presented = fakeBrowserWindow({ pendingLoad: scenario === 'timeout' });
+    const errors: unknown[] = [];
+    const nativeResult = { response: 0, checkboxChecked: false };
+    const result = showBrowserMessageBoxWithRuntime(
+      { message: 'Recover Maka' },
+      undefined,
+      { locale: 'en' },
+      runtimeForWindow(presented, {
+        presentationTimeoutMs: scenario === 'timeout' ? 1 : undefined,
+        onBrowserError: (error) => errors.push(error),
+        nativeResult,
+      }),
+    );
+    if (scenario === 'unresponsive') presented.window.emit('unresponsive');
+    if (scenario === 'renderer-gone') {
+      presented.webContents.emit('render-process-gone', {}, { reason: 'crashed' });
+    }
+
+    assert.equal(await result, nativeResult);
+    assert.equal(errors.length, 1, scenario);
+    assert.equal(presented.destroyed(), true, scenario);
+    assert.equal(isBrowserMessageBoxPresentationActive(), false, scenario);
+  }
+});
+
 test('accepts only an in-range response URL produced by the dialog', () => {
   assert.equal(parseBrowserMessageBoxResponse('maka-dialog://response/1', 3), 1);
   for (const value of [
@@ -155,7 +235,9 @@ test('renders escaped content with Maka dialog tokens and safe action ordering',
 
   assert.match(html, /data-theme="dark"/u);
   assert.match(html, /data-maka-theme="nord"/u);
-  assert.match(html, /--shadow-med:/u);
+  assert.match(html, /--surface-overlay:/u);
+  assert.match(html, /--accent-solid:/u);
+  assert.match(html, /--space-4:/u);
   assert.match(html, /color: var\(--maka-brand\)/u);
   assert.doesNotMatch(html, /--control-overlay-hover:/u);
   assert.match(html, /&lt;img src=x onerror=alert\(1\)&gt;/u);
@@ -213,3 +295,90 @@ test('uses the resolved locale instead of guessing from user-controlled text', (
   assert.doesNotMatch(html, /globalThis\.pwned/u);
   assert.match(html, /data-response="0" autofocus/u);
 });
+
+interface FakeBrowserWindow {
+  readonly window: BrowserWindow;
+  readonly webContents: EventEmitter;
+  options?: BrowserWindowConstructorOptions;
+  loadedUrl(): string;
+  shown(): boolean;
+  focused(): boolean;
+  destroyed(): boolean;
+  deniesWindowOpen(): boolean;
+}
+
+function fakeBrowserWindow(input: {
+  readonly loadError?: Error;
+  readonly pendingLoad?: boolean;
+} = {}): FakeBrowserWindow {
+  let loadedUrl = '';
+  let shown = false;
+  let focused = false;
+  let destroyed = false;
+  let deniesWindowOpen = false;
+  const webContents = Object.assign(new EventEmitter(), {
+    setWindowOpenHandler(handler: () => { action: string }) {
+      deniesWindowOpen = handler().action === 'deny';
+    },
+    async executeJavaScript(script: string): Promise<number | undefined> {
+      return script.includes('scrollHeight') ? 340 : undefined;
+    },
+  });
+  const window = Object.assign(new EventEmitter(), {
+    webContents,
+    setMenuBarVisibility() {},
+    loadURL(url: string): Promise<void> {
+      loadedUrl = url;
+      if (input.loadError) return Promise.reject(input.loadError);
+      if (input.pendingLoad) return new Promise<void>(() => undefined);
+      return Promise.resolve();
+    },
+    isDestroyed: () => destroyed,
+    destroy: () => {
+      destroyed = true;
+    },
+    setBounds() {},
+    show: () => {
+      shown = true;
+    },
+    focus: () => {
+      focused = true;
+    },
+  }) as unknown as BrowserWindow;
+  return {
+    window,
+    webContents,
+    loadedUrl: () => loadedUrl,
+    shown: () => shown,
+    focused: () => focused,
+    destroyed: () => destroyed,
+    deniesWindowOpen: () => deniesWindowOpen,
+  };
+}
+
+function runtimeForWindow(
+  presented: FakeBrowserWindow,
+  options: {
+    readonly presentationTimeoutMs?: number;
+    readonly onBrowserError?: (error: unknown) => void;
+    readonly nativeResult?: MessageBoxReturnValue;
+  } = {},
+): BrowserMessageBoxRuntime {
+  return {
+    ready: true,
+    shouldUseDarkColors: false,
+    createWindow: (windowOptions) => {
+      presented.options = windowOptions;
+      return presented.window;
+    },
+    resolveWorkArea: () => ({ x: 0, y: 0, width: 1_200, height: 800 }),
+    showNative: async () =>
+      options.nativeResult ?? assert.fail('successful browser presentation must not fall back'),
+    onBrowserError:
+      options.onBrowserError ??
+      (() => assert.fail('successful browser presentation must not report an error')),
+    ...(options.presentationTimeoutMs === undefined
+      ? {}
+      : { presentationTimeoutMs: options.presentationTimeoutMs }),
+  };
+}
diff --git a/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts b/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts
index 07b988cb97..b576edf72d 100644
--- a/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts
+++ b/apps/desktop/src/main/__tests__/main-renderer-process-gone.test.ts
@@ -63,11 +63,10 @@ test('ignores clean exits and app shutdown', () => {
   }
 });
 
-test('reports reload success only after the main document loads and the Renderer paints', async () => {
+test('reports reload success only after the Renderer commits its first paint', async () => {
   const source = reloadSource();
   const readiness = rendererReadiness();
   let observed = false;
-  let settled = false;
   const result = reloadMainRendererProcess({
     source,
     shutdownSignal: new AbortController().signal,
@@ -76,15 +75,9 @@ test('reports reload success only after the main document loads and the Renderer
       observed = true;
     },
   });
-  void result.then(() => {
-    settled = true;
-  });
 
   assert.equal(source.reloadCalls, 1);
   source.emit('did-fail-load', {}, -3, 'subframe failed', 'https://example.test/frame', false, 1, 2);
-  source.emit('did-finish-load');
-  await Promise.resolve();
-  assert.equal(settled, false);
   readiness.notify();
   assert.equal(await result, true);
   assert.equal(observed, true);
@@ -116,7 +109,6 @@ test('keeps recovery active when a Renderer reload fails, exits, or stops respon
     fail(source);
     assert.equal(await result, false);
     assert.equal(observed, false);
-    assert.equal(source.listenerCount('did-finish-load'), 0);
     assert.equal(source.listenerCount('unresponsive'), 0);
     assert.equal(readiness.subscribed(), false);
   }
@@ -134,7 +126,6 @@ test('bounds a Renderer reload that emits no terminal event', async () => {
   });
 
   assert.equal(await result, false);
-  assert.equal(source.listenerCount('did-finish-load'), 0);
   assert.equal(source.listenerCount('did-fail-load'), 0);
   assert.equal(source.listenerCount('unresponsive'), 0);
   assert.equal(source.listenerCount('render-process-gone'), 0);
diff --git a/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts b/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
index 0a26fff7d8..67f57f4b6d 100644
--- a/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
+++ b/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
@@ -26,6 +26,10 @@ const mainSource = readFileSync(
   fileURLToPath(new URL('../../../src/main/main.ts', import.meta.url)),
   'utf8',
 );
+const bootSource = readFileSync(
+  fileURLToPath(new URL('../../../src/main/runtime-host-boot.ts', import.meta.url)),
+  'utf8',
+);
 
 test('retains process lifetime before a standalone startup dialog can close', () => {
   const retentionPolicy = mainSource.search(
@@ -37,3 +41,21 @@ test('retains process lifetime before a standalone startup dialog can close', ()
   assert.notEqual(singleInstanceDecision, -1);
   assert.ok(retentionPolicy < singleInstanceDecision);
 });
+
+test('resolves persisted locale before first post-settings recovery prompt', () => {
+  const rendererRecoveryStart = bootSource.indexOf('onRendererProcessGone: async');
+  const rendererRecovery = bootSource.slice(
+    rendererRecoveryStart,
+    bootSource.indexOf('resolveBrowserDialogParent =', rendererRecoveryStart),
+  );
+  const hostRecoveryStart = bootSource.indexOf('prompt: async (input)');
+  const hostRecovery = bootSource.slice(
+    hostRecoveryStart,
+    bootSource.indexOf('}).catch((error: unknown)', hostRecoveryStart),
+  );
+
+  assert.match(rendererRecovery, /const locale = await desktopLocale\.resolve\(\)/u);
+  assert.match(hostRecovery, /const locale = await desktopLocale\.resolve\(\)/u);
+  assert.doesNotMatch(rendererRecovery, /desktopLocale\.current\(\)/u);
+  assert.doesNotMatch(hostRecovery, /desktopLocale\.current\(\)/u);
+});
diff --git a/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts b/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
index 3e8583bb26..67930fa9ea 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
@@ -1273,9 +1273,10 @@ test('waits passively for a Host that cannot be taken over', async () => {
 });
 
 test('silently replaces an idle non-restartable Local Host and retries', async () => {
-  const observed = upgradeRequired(false);
+  const observed = upgradeRequired(true);
   const conflict = {
     ...observed,
+    restartable: false as const,
     registration: { ...observed.registration, lifecycleMode: 'service' as const },
   };
   const replacement = candidateHarness();
@@ -1349,7 +1350,7 @@ test('prompts before replacing a non-restartable Local Host with observed connec
   await owner.close();
 });
 
-test('prompts only after a non-restartable Local Host reports active tasks', async () => {
+test('prompts if a non-restartable Local Host omits its activity snapshot', async () => {
   const observed = upgradeRequired(false);
   const conflict = {
     ...observed,
@@ -1359,6 +1360,47 @@ test('prompts only after a non-restartable Local Host reports active tasks', asy
   const policies: string[] = [];
   let starts = 0;
   let prompts = 0;
+  const owner = await startRuntimeHostDesktopManager(
+    {} as DesktopRuntimeHostCandidateStartInput,
+    {
+      startCandidate: async () => {
+        starts += 1;
+        return starts === 1 ? conflict : ready(replacement.candidate);
+      },
+      upgradePrompts: {
+        restartable: async () => assert.fail('non-restartable conflict used restart prompt'),
+        nonRestartable: async (_conflict, action) => {
+          prompts += 1;
+          assert.equal(action, 'replace_may_interrupt_work');
+          return 'replace';
+        },
+      },
+      resolveLocalHostReplacement: async () => ({
+        replace: async (policy) => {
+          policies.push(policy);
+          return 'replaced';
+        },
+      }),
+    },
+  );
+
+  assert.equal(prompts, 1);
+  assert.equal(starts, 2);
+  assert.deepEqual(policies, ['interrupt_active_work']);
+  await owner.close();
+});
+
+test('prompts if an observed-idle Host becomes active before replacement', async () => {
+  const observed = upgradeRequired(true);
+  const conflict = {
+    ...observed,
+    restartable: false as const,
+    registration: { ...observed.registration, lifecycleMode: 'service' as const },
+  };
+  const replacement = candidateHarness();
+  const policies: string[] = [];
+  let starts = 0;
+  let prompts = 0;
   const owner = await startRuntimeHostDesktopManager(
     {} as DesktopRuntimeHostCandidateStartInput,
     {
@@ -1414,7 +1456,7 @@ test('does not authorize active-work interruption when replacement is cancelled'
     }),
     RuntimeHostUpgradeCancelledError,
   );
-  assert.deepEqual(policies, ['refuse_active_work']);
+  assert.deepEqual(policies, []);
 });
 
 test('lets the user cancel startup when an incompatible Host owns the root', async () => {
diff --git a/apps/desktop/src/main/browser-message-box.ts b/apps/desktop/src/main/browser-message-box.ts
index 486d2514f0..10391a3ac8 100644
--- a/apps/desktop/src/main/browser-message-box.ts
+++ b/apps/desktop/src/main/browser-message-box.ts
@@ -25,6 +25,7 @@ import { isThemePalette, type ThemePalette } from '@maka/core/settings';
 import type { UiLocale } from '@maka/core/ui-locale';
 import type {
   BrowserWindow,
+  BrowserWindowConstructorOptions,
   MessageBoxOptions,
   MessageBoxReturnValue,
   Rectangle,
@@ -47,6 +48,19 @@ export interface BrowserMessageBoxAppearance {
   readonly dark?: boolean;
 }
 
+export interface BrowserMessageBoxRuntime {
+  readonly ready: boolean;
+  readonly shouldUseDarkColors: boolean;
+  readonly createWindow: (options: BrowserWindowConstructorOptions) => BrowserWindow;
+  readonly resolveWorkArea: (parent: BrowserWindow | undefined) => Rectangle;
+  readonly showNative: (
+    options: MessageBoxOptions,
+    parent: BrowserWindow | undefined,
+  ) => Promise<MessageBoxReturnValue>;
+  readonly onBrowserError: (error: unknown) => void;
+  readonly presentationTimeoutMs?: number;
+}
+
 /** Whether closing a temporary dialog must not be interpreted as app shutdown. */
 export function isBrowserMessageBoxPresentationActive(): boolean {
   return activeBrowserMessageBoxPresentations > 0;
@@ -68,10 +82,11 @@ export async function showBrowserMessageBox(
   // Keep the presentation helpers importable under plain `node --test`.
   // Electron itself is only required when a dialog is actually presented.
   const electron = await import('electron');
-  return showBrowserMessageBoxWithRuntime(options, parent, {
+  return showBrowserMessageBoxWithRuntime(options, parent, appearance, {
     ready: electron.app.isReady(),
-    showBrowser: (nextOptions, nextParent) =>
-      presentBrowserMessageBox(electron, nextOptions, nextParent, appearance),
+    shouldUseDarkColors: electron.nativeTheme.shouldUseDarkColors,
+    createWindow: (windowOptions) => new electron.BrowserWindow(windowOptions),
+    resolveWorkArea: (nextParent) => resolveWorkArea(electron, nextParent),
     showNative: (nextOptions, nextParent) =>
       showNativeMessageBox(electron, nextOptions, nextParent),
     onBrowserError: (error) => {
@@ -83,18 +98,8 @@ export async function showBrowserMessageBox(
 export async function showBrowserMessageBoxWithRuntime(
   options: MessageBoxOptions,
   parent: BrowserWindow | undefined,
-  runtime: {
-    readonly ready: boolean;
-    readonly showBrowser: (
-      options: MessageBoxOptions,
-      parent: BrowserWindow | undefined,
-    ) => Promise<MessageBoxReturnValue>;
-    readonly showNative: (
-      options: MessageBoxOptions,
-      parent: BrowserWindow | undefined,
-    ) => Promise<MessageBoxReturnValue>;
-    readonly onBrowserError: (error: unknown) => void;
-  },
+  appearance: BrowserMessageBoxAppearance,
+  runtime: BrowserMessageBoxRuntime,
 ): Promise<MessageBoxReturnValue> {
   activeBrowserMessageBoxPresentations += 1;
   try {
@@ -104,7 +109,7 @@ export async function showBrowserMessageBoxWithRuntime(
         : undefined;
     if (!runtime.ready) return await runtime.showNative(options, visibleParent());
     try {
-      return await runtime.showBrowser(options, visibleParent());
+      return await presentBrowserMessageBox(runtime, options, visibleParent(), appearance);
     } catch (error) {
       runtime.onBrowserError(error);
       return await runtime.showNative(options, visibleParent());
@@ -125,23 +130,23 @@ async function showNativeMessageBox(
 }
 
 async function presentBrowserMessageBox(
-  electron: typeof import('electron'),
+  runtime: BrowserMessageBoxRuntime,
   options: MessageBoxOptions,
   parent: BrowserWindow | undefined,
   appearance: BrowserMessageBoxAppearance,
 ): Promise<MessageBoxReturnValue> {
   const presentation = normalizeBrowserMessageBoxPresentation(options, {
     ...appearance,
-    dark: appearance.dark ?? electron.nativeTheme.shouldUseDarkColors,
+    dark: appearance.dark ?? runtime.shouldUseDarkColors,
   });
-  const workArea = resolveWorkArea(electron, parent);
+  const workArea = runtime.resolveWorkArea(parent);
   const width = Math.max(320, Math.min(DIALOG_WIDTH, workArea.width - WORK_AREA_MARGIN * 2));
   const initialHeight = Math.max(
     MIN_HEIGHT,
     Math.min(INITIAL_HEIGHT, workArea.height - WORK_AREA_MARGIN * 2),
   );
   const initialBounds = centeredBounds(parent?.getBounds(), workArea, width, initialHeight);
-  const win = new electron.BrowserWindow({
+  const win = runtime.createWindow({
     ...initialBounds,
     title: presentation.title,
     show: false,
@@ -190,7 +195,7 @@ async function presentBrowserMessageBox(
       };
       presentationTimeout = setTimeout(
         () => fail(new Error('Dialog renderer did not become interactive in time')),
-        DIALOG_PRESENTATION_TIMEOUT_MS,
+        runtime.presentationTimeoutMs ?? DIALOG_PRESENTATION_TIMEOUT_MS,
       );
 
       win.on('closed', () => finish(presentation.cancelId));
diff --git a/apps/desktop/src/main/main-renderer-process-gone.ts b/apps/desktop/src/main/main-renderer-process-gone.ts
index c42ca2326e..ae84ae216d 100644
--- a/apps/desktop/src/main/main-renderer-process-gone.ts
+++ b/apps/desktop/src/main/main-renderer-process-gone.ts
@@ -27,7 +27,6 @@ interface RenderProcessGoneSource {
 }
 
 interface MainRendererReloadSource {
-  once(event: 'did-finish-load', listener: () => void): void;
   once(event: 'unresponsive', listener: () => void): void;
   once(
     event: 'render-process-gone',
@@ -46,7 +45,6 @@ interface MainRendererReloadSource {
       frameRoutingId: number,
     ) => void,
   ): void;
-  off(event: 'did-finish-load', listener: () => void): void;
   off(event: 'unresponsive', listener: () => void): void;
   off(
     event: 'render-process-gone',
@@ -81,9 +79,9 @@ export function observeMainRendererProcessGone(deps: {
 }
 
 /**
- * Waits for a crashed main Renderer to finish loading before recovery is
- * reported as successful. The ordinary one-shot crash observer is re-armed
- * synchronously by `onLoaded`, leaving no successful-load gap unobserved.
+ * Waits for a crashed main Renderer to report its first committed paint before
+ * recovery is successful. The ordinary one-shot crash observer is re-armed
+ * synchronously by `onReady`, leaving no successful-recovery gap unobserved.
  */
 export function reloadMainRendererProcess(deps: {
   readonly source: MainRendererReloadSource;
@@ -97,14 +95,11 @@ export function reloadMainRendererProcess(deps: {
   }
   return new Promise<boolean>((resolve) => {
     let settled = false;
-    let documentLoaded = false;
-    let rendererReady = false;
     let timeout: ReturnType<typeof setTimeout> | undefined;
     let unsubscribeRendererReady = (): void => {};
     const cleanup = (): void => {
       if (timeout) clearTimeout(timeout);
       unsubscribeRendererReady();
-      deps.source.off('did-finish-load', onDocumentLoaded);
       deps.source.off('did-fail-load', onFailed);
       deps.source.off('unresponsive', onUnresponsive);
       deps.source.off('render-process-gone', onGone);
@@ -117,8 +112,7 @@ export function reloadMainRendererProcess(deps: {
       cleanup();
       resolve(loaded);
     };
-    const finishWhenReady = (): void => {
-      if (!documentLoaded || !rendererReady) return;
+    const onRendererReady = (): void => {
       try {
         deps.onReady();
         settle(true);
@@ -126,14 +120,6 @@ export function reloadMainRendererProcess(deps: {
         settle(false);
       }
     };
-    const onDocumentLoaded = (): void => {
-      documentLoaded = true;
-      finishWhenReady();
-    };
-    const onRendererReady = (): void => {
-      rendererReady = true;
-      finishWhenReady();
-    };
     const onFailed = (
       _event: Event,
       _errorCode: number,
@@ -149,7 +135,6 @@ export function reloadMainRendererProcess(deps: {
     const onAborted = (): void => settle(false);
 
     unsubscribeRendererReady = deps.subscribeRendererReady(onRendererReady);
-    deps.source.once('did-finish-load', onDocumentLoaded);
     deps.source.on('did-fail-load', onFailed);
     deps.source.once('unresponsive', onUnresponsive);
     deps.source.once('render-process-gone', onGone);
diff --git a/apps/desktop/src/main/runtime-host-boot.ts b/apps/desktop/src/main/runtime-host-boot.ts
index 405fbc092e..ccc3935200 100644
--- a/apps/desktop/src/main/runtime-host-boot.ts
+++ b/apps/desktop/src/main/runtime-host-boot.ts
@@ -464,7 +464,7 @@ const mainWindowController = createMainWindowController({
       details: `Exit code: ${details.exitCode}`,
     });
     for (;;) {
-      const locale = desktopLocale.current();
+      const locale = await desktopLocale.resolve();
       const decision = await showMainRendererProcessGoneDialog({
         locale,
         copyDiagnostics: () =>
@@ -1171,7 +1171,7 @@ runtimeHostManager = await startDesktopRuntimeHostWithRecovery({
       repairError: input.repairError,
       activeTasks: input.activeTasks,
     });
-    const locale = desktopLocale.current();
+    const locale = await desktopLocale.resolve();
     return showRuntimeHostStartupRecoveryDialog(input, {
       locale,
       showMessageBox: (options) => showDesktopMessageBox(options, { locale }),
diff --git a/apps/desktop/src/main/runtime-host-desktop-manager.ts b/apps/desktop/src/main/runtime-host-desktop-manager.ts
index 69f0a22ba1..25b517e1dc 100644
--- a/apps/desktop/src/main/runtime-host-desktop-manager.ts
+++ b/apps/desktop/src/main/runtime-host-desktop-manager.ts
@@ -36,7 +36,7 @@ import {
   type RuntimeHostRetirementMode,
   type RuntimeHostSshInteraction,
 } from '@maka/runtime-host/client';
-import type { HostActivitySnapshot, HostRegistration } from '@maka/runtime-host/protocol';
+import { isHostActivityIdle, type HostRegistration } from '@maka/runtime-host/protocol';
 import type { DesktopTargetSessionRef } from '../shared/runtime-host-identity.js';
 import {
   startDesktopRuntimeHostCandidate,
@@ -151,14 +151,6 @@ export type RuntimeHostNonRestartableAction =
   | 'wait'
   | 'cancel_only';
 
-function isObservedRuntimeHostIdle(activity: HostActivitySnapshot): boolean {
-  return (
-    activity.connections === 0 &&
-    activity.activeOperations === 0 &&
-    activity.residencies.length === 0
-  );
-}
-
 export interface RuntimeHostLocalReplacement {
   replace(activeWorkPolicy: RuntimeHostRetirementMode): Promise<'replaced' | 'active_tasks'>;
 }
@@ -925,7 +917,7 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
       if (result.kind === 'upgrade_required' && result.restartable) {
         const activity = result.handshake?.activity;
         const decision =
-          activity && isObservedRuntimeHostIdle(activity)
+          activity && isHostActivityIdle(activity)
             ? 'restart'
             : await this.#resolveRestartable(result);
         if (decision === 'cancel') {
@@ -947,11 +939,11 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
           ? undefined
           : await this.resolveLocalHostReplacement?.(result.registration, signal);
         const activity = result.handshake?.activity;
-        if (replacement && (!activity || isObservedRuntimeHostIdle(activity))) {
-          // The managed-service operator can check active work even when an
-          // older Host cannot include an activity snapshot in its handshake.
-          // A present snapshot remains authoritative for connections as well
-          // as operations/residencies; interruption still requires consent.
+        if (replacement && activity && isHostActivityIdle(activity)) {
+          // Only a complete, observed snapshot can authorize silent
+          // replacement. The replacement transaction closes races with new
+          // operations; an absent snapshot requires explicit consent because
+          // it cannot prove that other clients are disconnected.
           const attempt = await replacement.replace('refuse_active_work');
           if (attempt === 'replaced') {
             takeoverHostEpoch = undefined;
diff --git a/packages/runtime-host/src/client/connection.ts b/packages/runtime-host/src/client/connection.ts
index 109cb47b99..3183d11c4b 100644
--- a/packages/runtime-host/src/client/connection.ts
+++ b/packages/runtime-host/src/client/connection.ts
@@ -42,6 +42,7 @@ import {
   type ConfigurationChangedFrame,
   type HostOperationErrorCode,
   type HostIncompatible,
+  isHostActivityIdle,
   type HostRegistration,
   type HostStatusResult,
   HOST_OPERATION_SPECS,
@@ -1281,9 +1282,7 @@ export async function connectResolvedRuntimeHost(
       return registration.lifecycleMode === 'ephemeral' &&
         result.handshake.state === 'ready' &&
         result.handshake.activity !== undefined &&
-        result.handshake.activity.connections === 0 &&
-        result.handshake.activity.activeOperations === 0 &&
-        result.handshake.activity.residencies.length === 0
+        isHostActivityIdle(result.handshake.activity)
         ? {
             kind: 'upgrade_required',
             registration,
diff --git a/packages/runtime-host/src/protocol/host-status.ts b/packages/runtime-host/src/protocol/host-status.ts
index 4aac3a9603..75f22c3679 100644
--- a/packages/runtime-host/src/protocol/host-status.ts
+++ b/packages/runtime-host/src/protocol/host-status.ts
@@ -39,6 +39,14 @@ export interface HostActivitySnapshot {
   readonly residencies: readonly { readonly label: string; readonly count: number }[];
 }
 
+export function isHostActivityIdle(activity: HostActivitySnapshot): boolean {
+  return (
+    activity.connections === 0 &&
+    activity.activeOperations === 0 &&
+    activity.residencies.length === 0
+  );
+}
+
 export interface HostUpgradePrepareInput {
   readonly expectedHostEpoch: string;
   readonly allowInterruptActiveTasks: boolean;
diff --git a/packages/runtime-host/src/protocol/operations.ts b/packages/runtime-host/src/protocol/operations.ts
index 1f6f900805..0ef2056877 100644
--- a/packages/runtime-host/src/protocol/operations.ts
+++ b/packages/runtime-host/src/protocol/operations.ts
@@ -76,6 +76,7 @@ export type {
   HostUpgradePrepareInput,
   HostUpgradePrepareResult,
 } from './host-status.js';
+export { isHostActivityIdle } from './host-status.js';
 export type {
   HostOperationError,
   HostOperationErrorCode,


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@maka.apache.org
For additional commands, e-mail: commits-help@maka.apache.org