@noego/wood 0.4.5 → 0.4.7

package/dist/main/index.js

@@ -4,6 +4,7 @@ import {
   BrowserWindow,
   ipcMain,
   MessageChannelMain,
+  Menu,
   protocol,
   net,
   shell,
@@ -20,6 +21,40 @@ import {
 } from "../runtime/renderer_log_dispatcher.js";
 import { Ipc, getIpc } from "../ipc/index.js";
 import { setIpcPushSender, clearIpcPushSender } from "../ipc/shared.js";
+import {
+  drainRendererTracesBeforeQuit,
+  RendererTraceDrainCoordinator
+} from "./renderer_trace_drain_coordinator.js";
+class BootstrapActivationGate {
+  constructor(hasWindow, createMainWindow) {
+    this.hasWindow = hasWindow;
+    this.createMainWindow = createMainWindow;
+    this.currentState = "pending";
+  }
+  get state() {
+    return this.currentState;
+  }
+  activate() {
+    if (this.currentState === "ready" && !this.hasWindow()) {
+      this.createMainWindow();
+    }
+  }
+  ready() {
+    if (this.currentState !== "pending") {
+      return;
+    }
+    this.createMainWindow();
+    this.currentState = "ready";
+  }
+  failed() {
+    if (this.currentState === "pending") {
+      this.currentState = "failed";
+    }
+  }
+}
+function shouldDeferLastWindowCloseForCleanup(trackedWindowCount, cleanupComplete) {
+  return trackedWindowCount === 1 && !cleanupComplete;
+}
 const DEFAULT_WOOD_REMOTE_DEBUGGING_PORT = 9333;
 function resolveWoodDebugMetadataConfiguration(env = process.env) {
   const isDevelopment = env.WOOD_MODE === "development";
@@ -60,11 +95,15 @@ function startWoodMain(options) {
   const debugConfig = resolveWoodDebugMetadataConfiguration();
   const windowState = new WindowStateStore();
   const windows = /* @__PURE__ */ new Map();
+  const rendererHealth = /* @__PURE__ */ new Map();
   let mainWindow = null;
   let beforeQuitCleanupComplete = false;
   let beforeQuitCleanupPromise = null;
   let runtimeContext = null;
   let mainBootCleanup;
+  let nativeQuitFallbackInstalled = false;
+  const rendererTraceDrain = new RendererTraceDrainCoordinator(ipcMain);
+  rendererTraceDrain.start();
   for (const stream of [process.stdout, process.stderr]) {
     stream.on("error", (error) => {
       if (error.code === "EPIPE") {
@@ -89,11 +128,12 @@ function startWoodMain(options) {
       protocol,
       net,
       shell,
-      screen
+      screen,
+      Menu
     },
     logger
   };
-  void (async () => {
+  const initializeRuntime = async () => {
     const appBootResult = options.appBoot ? await options.appBoot(bootContext) : void 0;
     const bootOverrides = appBootResult ?? {};
     const scope = bootOverrides.scope ?? options.scope ?? process.cwd();
@@ -140,6 +180,129 @@ function startWoodMain(options) {
       }
       return null;
     };
+    const getRendererHealthState = (windowId) => {
+      return rendererHealth.get(windowId) ?? null;
+    };
+    const notifyRendererHealthChanged = (event) => {
+      if (!options.onRendererHealthChanged) {
+        return;
+      }
+      if (!runtimeContext) {
+        runtimeLogger.warn("renderer health hook skipped before runtime context", {
+          windowId: event.windowId,
+          state: event.state
+        });
+        return;
+      }
+      Promise.resolve(options.onRendererHealthChanged(event, runtimeContext)).catch((error) => {
+        runtimeLogger.warn("renderer health hook failed", {
+          windowId: event.windowId,
+          state: event.state,
+          error: toErrorMessage(error)
+        });
+      });
+    };
+    const setRendererHealth = (windowId, state, details = {}) => {
+      const previousState = rendererHealth.get(windowId) ?? null;
+      rendererHealth.set(windowId, state);
+      notifyRendererHealthChanged({
+        windowId,
+        state,
+        previousState,
+        ...details
+      });
+    };
+    const attachRendererHealth = (windowId, win) => {
+      const healthLogger = getLogger("wood:main").named(`renderer-health:${windowId}`);
+      const webContentsId = win.webContents.id;
+      setRendererHealth(windowId, "loading", { webContentsId });
+      win.webContents.on("did-start-loading", () => {
+        setRendererHealth(windowId, "loading", { webContentsId });
+        healthLogger.info("renderer loading", { windowId, webContentsId });
+      });
+      win.webContents.on("did-finish-load", () => {
+        setRendererHealth(windowId, "ready", { webContentsId });
+        healthLogger.info("renderer ready", { windowId, webContentsId });
+      });
+      win.webContents.on("unresponsive", () => {
+        setRendererHealth(windowId, "unresponsive", { webContentsId });
+        healthLogger.error("renderer unresponsive", { windowId, webContentsId });
+      });
+      win.webContents.on("responsive", () => {
+        setRendererHealth(windowId, "ready", { webContentsId });
+        healthLogger.info("renderer responsive", { windowId, webContentsId });
+      });
+      win.webContents.on("render-process-gone", (_event, details) => {
+        setRendererHealth(windowId, "gone", {
+          webContentsId,
+          reason: details.reason,
+          exitCode: details.exitCode
+        });
+        healthLogger.error("renderer process gone", {
+          windowId,
+          webContentsId,
+          reason: details.reason,
+          exitCode: details.exitCode
+        });
+      });
+      win.webContents.on("destroyed", () => {
+        setRendererHealth(windowId, "destroyed");
+        healthLogger.warn("renderer destroyed", { windowId, webContentsId });
+      });
+      win.on("closed", () => {
+        setRendererHealth(windowId, "destroyed");
+        rendererHealth.delete(windowId);
+      });
+    };
+    const canSendToWindow = (win) => {
+      if (win.isDestroyed()) {
+        return false;
+      }
+      if (win.webContents.isDestroyed()) {
+        return false;
+      }
+      if (typeof win.webContents.isCrashed === "function" && win.webContents.isCrashed()) {
+        return false;
+      }
+      return true;
+    };
+    const safeSend = (windowId, win, channel, data) => {
+      if (!canSendToWindow(win)) {
+        runtimeLogger.warn("skipping send to unhealthy renderer", {
+          windowId,
+          channel,
+          rendererHealth: getRendererHealthState(windowId)
+        });
+        return false;
+      }
+      try {
+        win.webContents.send(channel, data);
+        return true;
+      } catch (error) {
+        runtimeLogger.warn("send to renderer failed", {
+          windowId,
+          channel,
+          rendererHealth: getRendererHealthState(windowId),
+          error: toErrorMessage(error)
+        });
+        return false;
+      }
+    };
+    const installNativeQuitFallback = () => {
+      if (nativeQuitFallbackInstalled) {
+        return;
+      }
+      Menu.setApplicationMenu(Menu.buildFromTemplate([
+        {
+          label: electronApp.name,
+          submenu: [
+            { role: "quit" }
+          ]
+        }
+      ]));
+      nativeQuitFallbackInstalled = true;
+      logger.info("native quit fallback installed");
+    };
     const waitForWindowReady = async (win) => {
       const webContents = win.webContents;
       const isLoading = typeof webContents.isLoadingMainFrame === "function" ? webContents.isLoadingMainFrame() : webContents.isLoading();
@@ -162,7 +325,8 @@ function startWoodMain(options) {
           title: win.getTitle(),
           webContentsId: win.webContents.id,
           url: win.webContents.getURL(),
-          focused: win.isFocused()
+          focused: win.isFocused(),
+          rendererHealth: getRendererHealthState(windowId) ?? void 0
         });
       }
       return {
@@ -183,6 +347,9 @@ function startWoodMain(options) {
       const windowDef = resolveWindowDef(options.windowDefs, windowId);
       const defaultShow = windowDef.show ?? true;
       const parentWindow = windowDef.parent ? getWindow(windowDef.parent) : null;
+      if (windowDef.nativeQuitFallback === true) {
+        installNativeQuitFallback();
+      }
       windowState.setScreen(screen);
       const savedBounds = windowDef.rememberBounds ? windowState.getBounds(windowId) : null;
       const windowOptions = {
@@ -209,6 +376,12 @@ function startWoodMain(options) {
           backgroundMaterial: windowDef.backgroundMaterial
         } : {},
         ...typeof windowDef.acceptFirstMouse === "boolean" ? { acceptFirstMouse: windowDef.acceptFirstMouse } : {},
+        // Hidden title bar with native window controls: macOS draws the
+        // traffic lights (positionable), Windows draws min/max/close via the
+        // Window Controls Overlay (always top-right; styled via titleBarOverlay).
+        ...typeof windowDef.titleBarStyle === "string" ? { titleBarStyle: windowDef.titleBarStyle } : {},
+        ...process.platform === "darwin" && windowDef.trafficLightPosition ? { trafficLightPosition: windowDef.trafficLightPosition } : {},
+        ...process.platform === "win32" && windowDef.titleBarOverlay != null ? { titleBarOverlay: windowDef.titleBarOverlay } : {},
         show: savedBounds ? false : defaultShow,
         webPreferences: {
           preload: preloadPath,
@@ -218,6 +391,7 @@ function startWoodMain(options) {
       };
       const win = new BrowserWindow(windowOptions);
       windows.set(windowId, win);
+      attachRendererHealth(windowId, win);
       if (windowId === "main") {
         mainWindow = win;
       }
@@ -305,6 +479,7 @@ function startWoodMain(options) {
       }
       win.on("closed", () => {
         windows.delete(windowId);
+        rendererHealth.delete(windowId);
         if (windowId === "main") {
           mainWindow = null;
         }
@@ -312,13 +487,27 @@ function startWoodMain(options) {
           electronApp.quit();
         }
       });
+      if (options.onWindowCreated) {
+        Promise.resolve(options.onWindowCreated(windowId, win, runtimeContext)).catch((error) => {
+          runtimeLogger.warn("window created hook failed", {
+            windowId,
+            error: toErrorMessage(error)
+          });
+        });
+      }
       logger.info("window created", { windowId });
       return win;
     };
+    const bootstrapActivationGate = new BootstrapActivationGate(
+      () => BrowserWindow.getAllWindows().length > 0,
+      () => {
+        createWindow("main");
+      }
+    );
     const navigateWindow = async (windowId, route) => {
       const win = createWindow(windowId);
       await waitForWindowReady(win);
-      win.webContents.send("__event:__navigate", { route });
+      safeSend(windowId, win, "__event:__navigate", { route });
       win.show();
       win.focus();
     };
@@ -326,8 +515,8 @@ function startWoodMain(options) {
       const eventChannel = channel.startsWith("__event:") ? channel : `__event:${channel}`;
       if (options2?.windowId) {
         const target = getWindow(options2.windowId);
-        if (target && !target.isDestroyed()) {
-          target.webContents.send(eventChannel, data);
+        if (target) {
+          safeSend(options2.windowId, target, eventChannel, data);
         }
         return;
       }
@@ -336,7 +525,7 @@ function startWoodMain(options) {
           windows.delete(windowId);
           continue;
         }
-        win.webContents.send(eventChannel, data);
+        safeSend(windowId, win, eventChannel, data);
       }
     };
     setIpcPushSender(dispatchPushEvent);
@@ -346,7 +535,7 @@ function startWoodMain(options) {
           windows.delete(windowId);
           continue;
         }
-        win.webContents.send(channel, data);
+        safeSend(windowId, win, channel, data);
       }
     };
     runtimeContext = {
@@ -357,11 +546,16 @@ function startWoodMain(options) {
       createWindow,
       navigateWindow,
       broadcast,
+      getRendererHealthState,
       setRendererLogCallback: (callback) => {
         getRendererLogDispatcher().setCallback(callback);
       },
       getRendererLogCallback: () => getRendererLogDispatcher().getCallback(),
-      getDebugMetadata
+      getDebugMetadata,
+      // Late-bound after bootRuntime constructs the router (see bootstrap).
+      dispatch: async () => {
+        throw new Error("WoodMainRuntimeContext.dispatch called before the runtime router was constructed.");
+      }
     };
     const bootstrap = async () => {
       logger.info("bootstrap starting");
@@ -374,7 +568,7 @@ function startWoodMain(options) {
           mainBootCleanup = bootResult;
         }
       }
-      await bootRuntime({
+      const { router: runtimeRouter } = await bootRuntime({
         container,
         ipcMain,
         registerRuntime: options.registerRuntime,
@@ -470,67 +664,98 @@ function startWoodMain(options) {
           };
         }
       });
-      createWindow("main");
+      runtimeContext.dispatch = (channel, payload) => runtimeRouter.dispatch(channel, payload ?? {});
+      bootstrapActivationGate.ready();
       logger.info("bootstrap complete");
     };
-    void electronApp.whenReady().then(bootstrap).catch((error) => {
+    const handleBootstrapFailure = (error) => {
+      bootstrapActivationGate.failed();
       logger.error("bootstrap failed", {
         message: toErrorMessage(error),
         stack: error instanceof Error ? error.stack : void 0
       });
-    });
-    const destroyWindowsForQuit = () => {
-      for (const [id, win] of windows) {
-        if (!win.isDestroyed()) {
-          win.destroy();
-          logger.debug("destroyed window on quit", { windowId: id });
-        }
-      }
-      windows.clear();
     };
-    const runBeforeQuitCleanup = async () => {
-      clearIpcPushSender();
-      if (mainBootCleanup) {
-        await mainBootCleanup();
-      }
-      if (options.onBeforeQuit) {
-        await options.onBeforeQuit(runtimeContext);
-      }
-    };
-    electronApp.on("before-quit", (event) => {
-      if (!runtimeContext) {
-        return;
-      }
-      if (beforeQuitCleanupComplete) {
-        destroyWindowsForQuit();
-        return;
-      }
-      event.preventDefault();
-      if (beforeQuitCleanupPromise) {
-        return;
-      }
-      beforeQuitCleanupPromise = (async () => {
-        try {
-          await runBeforeQuitCleanup();
-        } catch (error) {
-          logger.warn("before-quit handler failed", { error: toErrorMessage(error) });
-        } finally {
-          beforeQuitCleanupComplete = true;
-          beforeQuitCleanupPromise = null;
+    void electronApp.whenReady().then(bootstrap).catch(handleBootstrapFailure);
+    const registerApplicationLifecycle = () => {
+      electronApp.on(
+        "browser-window-created",
+        (_event, window) => {
+          window.on("close", (event) => {
+            const isTrackedWindow = [...windows.values()].includes(window);
+            if (!isTrackedWindow || !shouldDeferLastWindowCloseForCleanup(
+              windows.size,
+              beforeQuitCleanupComplete
+            )) {
+              return;
+            }
+            event.preventDefault();
+            if (!beforeQuitCleanupPromise) {
+              logger.debug("deferring last window close for renderer trace drain");
+              electronApp.quit();
+            }
+          });
         }
-        destroyWindowsForQuit();
+      );
+      const destroyWindowsForQuit = () => {
+        for (const [id, win] of windows) {
+          if (!win.isDestroyed()) {
+            win.destroy();
+            logger.debug("destroyed window on quit", { windowId: id });
+          }
+        }
+        windows.clear();
+      };
+      const runBeforeQuitCleanup = async () => {
+        await drainRendererTracesBeforeQuit(
+          rendererTraceDrain,
+          windows.values(),
+          logger,
+          Date.now() + 1e3
+        );
+        clearIpcPushSender();
+        if (mainBootCleanup) {
+          await mainBootCleanup();
+        }
+        if (options.onBeforeQuit) {
+          await options.onBeforeQuit(runtimeContext);
+        }
+      };
+      electronApp.on("before-quit", (event) => {
+        if (!runtimeContext) {
+          return;
+        }
+        if (beforeQuitCleanupComplete) {
+          destroyWindowsForQuit();
+          return;
+        }
+        event.preventDefault();
+        if (beforeQuitCleanupPromise) {
+          return;
+        }
+        beforeQuitCleanupPromise = (async () => {
+          try {
+            await runBeforeQuitCleanup();
+          } catch (error) {
+            logger.warn("before-quit handler failed", { error: toErrorMessage(error) });
+          } finally {
+            beforeQuitCleanupComplete = true;
+            beforeQuitCleanupPromise = null;
+          }
+          destroyWindowsForQuit();
+          electronApp.quit();
+        })();
+      });
+      electronApp.on("window-all-closed", () => {
         electronApp.quit();
-      })();
-    });
-    electronApp.on("window-all-closed", () => {
-      electronApp.quit();
-    });
-    electronApp.on("activate", () => {
-      if (BrowserWindow.getAllWindows().length === 0) {
-        createWindow("main");
-      }
-    });
-  })().catch((error) => {
+      });
+      electronApp.on("activate", () => {
+        bootstrapActivationGate.activate();
+      });
+    };
+    registerApplicationLifecycle();
+  };
+  void initializeRuntime().catch((error) => {
+    rendererTraceDrain.stop();
     logger.error("startup failed before ready", {
       message: toErrorMessage(error),
       stack: error instanceof Error ? error.stack : void 0
@@ -538,7 +763,9 @@ function startWoodMain(options) {
   });
 }
 export {
+  BootstrapActivationGate,
   resolveWoodDebugMetadataConfiguration,
+  shouldDeferLastWindowCloseForCleanup,
   startWoodMain
 };
 //# sourceMappingURL=index.js.map