@workbench-kit/electron-shell 0.0.2-prototype.0.2.32 → 0.0.2-prototype.0.2.33

package/README.md

@@ -71,16 +71,22 @@ electronApp.on('before-quit', (event) => {
 ```
 
 Repeated quit events are coalesced into the active request. After save or discard,
-the guard rechecks dirty state and resumes only when clean. Errors, timeout, and a
-still-dirty recheck fail closed. `cancelPending()` aborts an obsolete request and
-invalidates any late guard completion; call it when the owning lifecycle is
-replaced. A callback that has already started must honor its `AbortSignal` to stop
-its own side effects.
+the guard rechecks dirty state and resumes only when clean. It invokes `resumeQuit`
+on the next event-loop task so Electron can finish dispatching the original
+`before-quit` event first. Errors, timeout, and a still-dirty recheck fail closed.
+`cancelPending()` aborts an obsolete request and invalidates any late guard
+completion; call it when the owning lifecycle is replaced. A callback that has
+already started must honor its `AbortSignal` to stop its own side effects.
 The injected `resumeQuit` port must re-enter the registered guard synchronously;
 an asynchronous wrapper is treated as a fresh request. OS shutdown paths that do
 not emit `before-quit`, and updater flows that emit it after windows close, remain
 host-owned lifecycle concerns outside this guard.
 
+The repository also runs `pnpm test:electron-quit-guard` against Electron 41.5
+with a live `BrowserWindow`. It verifies the deferred save path, a coalesced quit
+attempt before the scheduled resume, and the normal window-close / application-quit
+lifecycle after the permitted re-entry.
+
 For external links, keep the product allowlist outside the Kit and pass only an
 opaque link id into the generic helper:
 

package/dist/lifecycle/application-quit-guard.js

@@ -38,6 +38,11 @@ function raceWithAbort(operation, signal, readAbortKind) {
         });
     });
 }
+function waitForNextTask() {
+    return new Promise((resolve) => {
+        setTimeout(resolve, 0);
+    });
+}
 /**
  * Coordinate an Electron-style before-quit boundary without importing Electron.
  * The host owns event registration, dirty state, prompts, persistence, and quit invocation.
@@ -76,7 +81,10 @@ function createApplicationQuitGuard(options) {
             }
             return resume(reason);
         };
-        const resume = (reason) => {
+        const resume = async (reason) => {
+            // A Promise continuation can still run before Electron finishes dispatching the original
+            // before-quit event. Cross a task boundary before re-entering app.quit().
+            await run(waitForNextTask);
             // The decision is now irreversible. `cancelPending` must not report a cancellable request
             // while the host is synchronously re-entering before-quit.
             if (isCurrent()) {
@@ -99,7 +107,7 @@ function createApplicationQuitGuard(options) {
                     throw new TypeError('Application quit guard isDirty must return a boolean.');
                 }
                 if (!dirty) {
-                    return resume('clean');
+                    return await resume('clean');
                 }
                 const decision = await run(() => options.requestDecision(controller.signal));
                 if (decision === 'cancel') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-kit/electron-shell",
-  "version": "0.0.2-prototype.0.2.32",
+  "version": "0.0.2-prototype.0.2.33",
   "private": false,
   "type": "module",
   "types": "./src/index.ts",

package/src/lifecycle/application-quit-guard.ts

@@ -109,6 +109,12 @@ function raceWithAbort<Value>(
   });
 }
 
+function waitForNextTask(): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+
 /**
  * Coordinate an Electron-style before-quit boundary without importing Electron.
  * The host owns event registration, dirty state, prompts, persistence, and quit invocation.
@@ -158,7 +164,13 @@ export function createApplicationQuitGuard(
       return resume(reason);
     };
 
-    const resume = (reason: ApplicationQuitProceedReason): ApplicationQuitGuardResult => {
+    const resume = async (
+      reason: ApplicationQuitProceedReason,
+    ): Promise<ApplicationQuitGuardResult> => {
+      // A Promise continuation can still run before Electron finishes dispatching the original
+      // before-quit event. Cross a task boundary before re-entering app.quit().
+      await run(waitForNextTask);
+
       // The decision is now irreversible. `cancelPending` must not report a cancellable request
       // while the host is synchronously re-entering before-quit.
       if (isCurrent()) {
@@ -181,7 +193,7 @@ export function createApplicationQuitGuard(
           throw new TypeError('Application quit guard isDirty must return a boolean.');
         }
         if (!dirty) {
-          return resume('clean');
+          return await resume('clean');
         }
 
         const decision = await run(() => options.requestDecision(controller.signal));