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 16:12:26 UTC

(maka) branch feat/maka-browser-recovery-dialogs updated: fix(desktop): bind recovery readiness to reload frame

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 dca3c42d04 fix(desktop): bind recovery readiness to reload frame
dca3c42d04 is described below

commit dca3c42d0457c90d41512e57352e18ae4d70bbe1
Author: Wang <m4...@gmail.com>
AuthorDate: Wed Sep 2 00:11:33 2026 +0800

    fix(desktop): bind recovery readiness to reload frame
---
 .../__tests__/main-renderer-process-gone.test.ts   | 46 ++++++++++++++++++----
 .../main/__tests__/main-startup-lifetime.test.ts   | 13 ++++--
 apps/desktop/src/main/app-ipc-main.ts              |  2 +-
 .../desktop/src/main/main-renderer-process-gone.ts | 36 ++++++++++++++++-
 apps/desktop/src/main/main-window.ts               | 46 +++++++++++++++++-----
 5 files changed, 120 insertions(+), 23 deletions(-)

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 b576edf72d..e7bab8de47 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
@@ -22,6 +22,7 @@ import { EventEmitter } from 'node:events';
 import { test } from 'node:test';
 import type { RenderProcessGoneDetails } from 'electron';
 import {
+  type MainRendererFrameIdentity,
   observeMainRendererProcessGone,
   reloadMainRendererProcess,
 } from '../main-renderer-process-gone.js';
@@ -63,13 +64,16 @@ test('ignores clean exits and app shutdown', () => {
   }
 });
 
-test('reports reload success only after the Renderer commits its first paint', async () => {
+test('accepts first-paint readiness only from the frame committed by this reload', async () => {
   const source = reloadSource();
   const readiness = rendererReadiness();
+  const previousFrame = frameIdentity(1, 10, 'previous');
+  const currentFrame = frameIdentity(2, 20, 'current');
   let observed = false;
   const result = reloadMainRendererProcess({
     source,
     shutdownSignal: new AbortController().signal,
+    subscribeMainFrameCommitted: readiness.subscribeCommit,
     subscribeRendererReady: readiness.subscribe,
     onReady: () => {
       observed = true;
@@ -78,7 +82,11 @@ test('reports reload success only after the Renderer commits its first paint', a
 
   assert.equal(source.reloadCalls, 1);
   source.emit('did-fail-load', {}, -3, 'subframe failed', 'https://example.test/frame', false, 1, 2);
-  readiness.notify();
+  assert.equal(readiness.notify(previousFrame), false);
+  readiness.commit(currentFrame);
+  assert.equal(readiness.notify(previousFrame), false);
+  assert.equal(observed, false);
+  assert.equal(readiness.notify(currentFrame), true);
   assert.equal(await result, true);
   assert.equal(observed, true);
   assert.equal(source.listenerCount('did-fail-load'), 0);
@@ -100,6 +108,7 @@ test('keeps recovery active when a Renderer reload fails, exits, or stops respon
     const result = reloadMainRendererProcess({
       source,
       shutdownSignal: new AbortController().signal,
+      subscribeMainFrameCommitted: readiness.subscribeCommit,
       subscribeRendererReady: readiness.subscribe,
       onReady: () => {
         observed = true;
@@ -120,6 +129,7 @@ test('bounds a Renderer reload that emits no terminal event', async () => {
   const result = reloadMainRendererProcess({
     source,
     shutdownSignal: new AbortController().signal,
+    subscribeMainFrameCommitted: readiness.subscribeCommit,
     subscribeRendererReady: readiness.subscribe,
     onReady: () => assert.fail('timed-out reload must not report success'),
     timeoutMs: 1,
@@ -133,11 +143,14 @@ test('bounds a Renderer reload that emits no terminal event', async () => {
 });
 
 function rendererReadiness(): {
-  subscribe(listener: () => void): () => void;
-  notify(): void;
+  subscribe(listener: (frame: MainRendererFrameIdentity) => boolean): () => void;
+  subscribeCommit(listener: (frame: MainRendererFrameIdentity) => void): () => void;
+  notify(frame: MainRendererFrameIdentity): boolean;
+  commit(frame: MainRendererFrameIdentity): void;
   subscribed(): boolean;
 } {
-  let listener: (() => void) | undefined;
+  let listener: ((frame: MainRendererFrameIdentity) => boolean) | undefined;
+  let commitListener: ((frame: MainRendererFrameIdentity) => void) | undefined;
   return {
     subscribe(next) {
       listener = next;
@@ -145,15 +158,32 @@ function rendererReadiness(): {
         if (listener === next) listener = undefined;
       };
     },
-    notify() {
-      listener?.();
+    subscribeCommit(next) {
+      commitListener = next;
+      return () => {
+        if (commitListener === next) commitListener = undefined;
+      };
+    },
+    notify(frame) {
+      return listener?.(frame) ?? false;
+    },
+    commit(frame) {
+      commitListener?.(frame);
     },
     subscribed() {
-      return listener !== undefined;
+      return listener !== undefined || commitListener !== undefined;
     },
   };
 }
 
+function frameIdentity(
+  processId: number,
+  routingId: number,
+  frameToken: string,
+): MainRendererFrameIdentity {
+  return { processId, routingId, frameToken };
+}
+
 function reloadSource(): EventEmitter & {
   reloadCalls: number;
   reload(): void;
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 5eaf721d28..de1a40689c 100644
--- a/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
+++ b/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
@@ -96,7 +96,9 @@ test('routes the first-paint IPC only to the active Renderer recovery listener',
     ipcHandlerStart,
     appIpcSource.indexOf("targetIpc.handle('window:setThemeSource'", ipcHandlerStart),
   );
-  const readyHandlerStart = mainWindowSource.indexOf('notifyRendererReady(sender)');
+  const readyHandlerStart = mainWindowSource.indexOf(
+    'notifyRendererReady(sender, senderFrame)',
+  );
   const readyHandler = mainWindowSource.slice(
     readyHandlerStart,
     mainWindowSource.indexOf('setTitlebarControlsVisible(sender', readyHandlerStart),
@@ -107,19 +109,24 @@ test('routes the first-paint IPC only to the active Renderer recovery listener',
     mainWindowSource.indexOf('    send: safeSendToRenderer', reloadStart),
   );
 
-  assert.match(ipcHandler, /mainWindowController\.notifyRendererReady\(event\.sender\)/u);
+  assert.match(
+    ipcHandler,
+    /mainWindowController\.notifyRendererReady\(event\.sender, event\.senderFrame\)/u,
+  );
   assert.match(
     reloadHandler,
     /clearShowFallbackTimer\(\);\s*revealGate\.reset\(\);\s*target\.hide\(\);/u,
   );
   assert.match(reloadHandler, /reloadMainRendererProcess\(/u);
+  assert.match(reloadHandler, /subscribeMainFrameCommitted:/u);
+  assert.match(reloadHandler, /webFrameMain\.fromId\(frameProcessId, frameRoutingId\)/u);
   assert.match(
     readyHandler,
     /sender !== mainWindow\.webContents\) return;/u,
   );
   assert.match(
     readyHandler,
-    /if \(recovery\?\.contents === sender\) \{\s*[^}]*if \(!recovery\.listener\) return;\s*recovery\.listener\(\);\s*\}/u,
+    /if \(recovery\?\.contents === sender\) \{\s*[^}]*if \(!senderFrame \|\| !recovery\.listener\?\.\(rendererFrameIdentity\(senderFrame\)\)\) return;\s*\}/u,
   );
   assert.match(
     reloadHandler,
diff --git a/apps/desktop/src/main/app-ipc-main.ts b/apps/desktop/src/main/app-ipc-main.ts
index bd158de339..ceb9ac4dd2 100644
--- a/apps/desktop/src/main/app-ipc-main.ts
+++ b/apps/desktop/src/main/app-ipc-main.ts
@@ -67,7 +67,7 @@ export function registerAppClientIpc(
     mainWindowController.setTitlebarControlsVisible(event.sender, visible);
   });
   targetIpc.handle('window:notifyRendererReady', (event): void => {
-    mainWindowController.notifyRendererReady(event.sender);
+    mainWindowController.notifyRendererReady(event.sender, event.senderFrame);
   });
   targetIpc.handle('window:setThemeSource', (event, themePref: unknown): void => {
     mainWindowController.setThemeSource(event.sender, themePref);
diff --git a/apps/desktop/src/main/main-renderer-process-gone.ts b/apps/desktop/src/main/main-renderer-process-gone.ts
index ae84ae216d..f1390a16d1 100644
--- a/apps/desktop/src/main/main-renderer-process-gone.ts
+++ b/apps/desktop/src/main/main-renderer-process-gone.ts
@@ -67,6 +67,12 @@ interface MainRendererReloadSource {
   reload(): void;
 }
 
+export interface MainRendererFrameIdentity {
+  readonly processId: number;
+  readonly routingId: number;
+  readonly frameToken: string;
+}
+
 export function observeMainRendererProcessGone(deps: {
   readonly source: RenderProcessGoneSource;
   readonly shutdownSignal: AbortSignal;
@@ -86,7 +92,12 @@ export function observeMainRendererProcessGone(deps: {
 export function reloadMainRendererProcess(deps: {
   readonly source: MainRendererReloadSource;
   readonly shutdownSignal: AbortSignal;
-  readonly subscribeRendererReady: (listener: () => void) => () => void;
+  readonly subscribeMainFrameCommitted: (
+    listener: (frame: MainRendererFrameIdentity) => void,
+  ) => () => void;
+  readonly subscribeRendererReady: (
+    listener: (frame: MainRendererFrameIdentity) => boolean,
+  ) => () => void;
   readonly onReady: () => void;
   readonly timeoutMs?: number;
 }): Promise<boolean> {
@@ -96,9 +107,12 @@ export function reloadMainRendererProcess(deps: {
   return new Promise<boolean>((resolve) => {
     let settled = false;
     let timeout: ReturnType<typeof setTimeout> | undefined;
+    let committedFrame: MainRendererFrameIdentity | undefined;
+    let unsubscribeMainFrameCommitted = (): void => {};
     let unsubscribeRendererReady = (): void => {};
     const cleanup = (): void => {
       if (timeout) clearTimeout(timeout);
+      unsubscribeMainFrameCommitted();
       unsubscribeRendererReady();
       deps.source.off('did-fail-load', onFailed);
       deps.source.off('unresponsive', onUnresponsive);
@@ -112,12 +126,15 @@ export function reloadMainRendererProcess(deps: {
       cleanup();
       resolve(loaded);
     };
-    const onRendererReady = (): void => {
+    const onRendererReady = (frame: MainRendererFrameIdentity): boolean => {
+      if (!sameFrame(frame, committedFrame)) return false;
       try {
         deps.onReady();
         settle(true);
+        return true;
       } catch {
         settle(false);
+        return false;
       }
     };
     const onFailed = (
@@ -134,6 +151,9 @@ export function reloadMainRendererProcess(deps: {
     const onDestroyed = (): void => settle(false);
     const onAborted = (): void => settle(false);
 
+    unsubscribeMainFrameCommitted = deps.subscribeMainFrameCommitted((frame) => {
+      committedFrame = frame;
+    });
     unsubscribeRendererReady = deps.subscribeRendererReady(onRendererReady);
     deps.source.on('did-fail-load', onFailed);
     deps.source.once('unresponsive', onUnresponsive);
@@ -148,3 +168,15 @@ export function reloadMainRendererProcess(deps: {
     }
   });
 }
+
+function sameFrame(
+  actual: MainRendererFrameIdentity,
+  expected: MainRendererFrameIdentity | undefined,
+): boolean {
+  if (!expected) return false;
+  return (
+    actual.processId === expected.processId &&
+    actual.routingId === expected.routingId &&
+    actual.frameToken === expected.frameToken
+  );
+}
diff --git a/apps/desktop/src/main/main-window.ts b/apps/desktop/src/main/main-window.ts
index 88ab8c7836..6219b04326 100644
--- a/apps/desktop/src/main/main-window.ts
+++ b/apps/desktop/src/main/main-window.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { app, BrowserWindow, dialog, nativeTheme, screen, shell } from 'electron';
+import { app, BrowserWindow, dialog, nativeTheme, screen, shell, webFrameMain } from 'electron';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { appIconForTheme, type AppSettings } from '@maka/core/settings';
@@ -30,6 +30,7 @@ import type { E2eFixture } from './e2e-fixture.js';
 import { installMainWindowPermissionPolicy } from './main-window-permission-policy.js';
 import { loadMainRenderer, resolveMainRendererEntry } from './main-renderer-loader.js';
 import {
+  type MainRendererFrameIdentity,
   observeMainRendererProcessGone,
   reloadMainRendererProcess,
 } from './main-renderer-process-gone.js';
@@ -54,7 +55,10 @@ export interface MainWindowController {
   send(channel: string, ...args: unknown[]): void;
   // PR-SHOW-AFTER-FIRST-COMMIT: reveal the hidden window after the renderer's
   // first React commit. Idempotent + e2e-fixture-safe (see notifyRendererReady).
-  notifyRendererReady(sender: Electron.WebContents): void;
+  notifyRendererReady(
+    sender: Electron.WebContents,
+    senderFrame: Electron.WebFrameMain | null,
+  ): void;
   setTitlebarControlsVisible(sender: Electron.WebContents, visible: unknown): void;
   setThemeSource(sender: Electron.WebContents, themePref: unknown): void;
   setTitleBarOverlayTheme(sender: Electron.WebContents, theme: unknown): void;
@@ -181,7 +185,7 @@ export function createMainWindowController(deps: MainWindowControllerDeps): Main
   let rendererRecoveryReadiness:
     | {
         readonly contents: Electron.WebContents;
-        listener?: () => void;
+        listener?: (frame: MainRendererFrameIdentity) => boolean;
       }
     | undefined;
   let mainWindowShutdownSignal: AbortSignal | undefined;
@@ -553,7 +557,7 @@ export function createMainWindowController(deps: MainWindowControllerDeps): Main
       const contents = target.webContents;
       const readiness: {
         readonly contents: Electron.WebContents;
-        listener?: () => void;
+        listener?: (frame: MainRendererFrameIdentity) => boolean;
       } = { contents };
       rendererRecoveryReadiness = readiness;
       let loaded = false;
@@ -561,6 +565,23 @@ export function createMainWindowController(deps: MainWindowControllerDeps): Main
         loaded = await reloadMainRendererProcess({
           source: contents,
           shutdownSignal: signal,
+          subscribeMainFrameCommitted: (listener) => {
+            const onFrameNavigated = (
+              _event: Electron.Event,
+              _url: string,
+              _httpResponseCode: number,
+              _httpStatusText: string,
+              isMainFrame: boolean,
+              frameProcessId: number,
+              frameRoutingId: number,
+            ): void => {
+              if (!isMainFrame) return;
+              const frame = webFrameMain.fromId(frameProcessId, frameRoutingId);
+              if (frame) listener(rendererFrameIdentity(frame));
+            };
+            contents.on('did-frame-navigate', onFrameNavigated);
+            return () => contents.off('did-frame-navigate', onFrameNavigated);
+          },
           subscribeRendererReady: (listener) => {
             readiness.listener = listener;
             return () => {
@@ -583,14 +604,13 @@ export function createMainWindowController(deps: MainWindowControllerDeps): Main
       }
     },
     send: safeSendToRenderer,
-    notifyRendererReady(sender) {
+    notifyRendererReady(sender, senderFrame) {
       if (!mainWindow || mainWindow.isDestroyed() || sender !== mainWindow.webContents) return;
       const recovery = rendererRecoveryReadiness;
       if (recovery?.contents === sender) {
-        // A failed attempt stays as a tombstone so a late ready signal cannot
-        // reveal an unobserved Renderer behind the next recovery prompt.
-        if (!recovery.listener) return;
-        recovery.listener();
+        // A failed attempt stays as a tombstone, and a retry accepts ready only
+        // from the main frame committed by that exact reload navigation.
+        if (!senderFrame || !recovery.listener?.(rendererFrameIdentity(senderFrame))) return;
       }
       // PR-SHOW-AFTER-FIRST-COMMIT: the renderer finished its first React
       // commit. Cancel the fallback timer and reveal the window through the
@@ -681,6 +701,14 @@ export function createMainWindowController(deps: MainWindowControllerDeps): Main
   };
 }
 
+function rendererFrameIdentity(frame: Electron.WebFrameMain): MainRendererFrameIdentity {
+  return {
+    processId: frame.processId,
+    routingId: frame.routingId,
+    frameToken: frame.frameToken,
+  };
+}
+
 function isTitleBarOverlayTheme(value: unknown): value is { isDark: boolean; backgroundColor: string } {
   if (!value || typeof value !== 'object') return false;
   const candidate = value as { isDark?: unknown; backgroundColor?: unknown };


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