@next2d/builder 0.4.5 → 0.4.7

package/dist/electron-config.js

@@ -132,8 +132,7 @@ export const createElectronPackagerOptions = (root, config, os, resources) => {
         ...os === "macos" && (config.macos.localNetworkUsageDescription || config.window.overlay?.enabled) ? {
             "extendInfo": {
                 ...config.macos.localNetworkUsageDescription ? { "NSLocalNetworkUsageDescription": config.macos.localNetworkUsageDescription } : {},
-                // An overlay starts as an agent app (no Dock icon) so that a second launch, which quits at once,
-                // never shows one. The first instance shows its Dock icon itself (templates/electron/index.js).
+                // An overlay is an agent app: no Dock icon, also for a second launch that quits at once.
                 ...config.window.overlay?.enabled ? { "LSUIElement": true } : {}
             },
             ...config.macos.localNetworkUsageDescription ? {

package/docs/steam.md

@@ -105,7 +105,9 @@ await window.next2dWindow.quit();
 const off = window.next2dWindow.onResume(() => { /* 状態の再送など */ });
 ```
 
-重ね表示が有効なときは、アプリは**1つだけ**起動します（2つ目の起動はすぐに終了します。macOSではDockにアイコンも出しません）。開発中に複数起動したいときは `--next2d-allow-multiple` を付けて起動します。
+重ね表示が有効なときは、アプリは**1つだけ**起動します（2つ目の起動はすぐに終了します）。macOSではDockにアイコンを出しません（エージェントアプリ。終了はゲーム内のボタンで行います）。開発中に複数起動したいときは `--next2d-allow-multiple` を付けて起動します。
+
+Windowsでスリープ（ノートPCのふたを閉じる等）から復帰すると、重ね表示の窓がマウスを受け取れなくなることがあるため、窓を作り直します（ゲームは自動保存を前提にしてください）。電源・ディスプレイ・GPUのイベントは `userData/diagnostics.log`（Windowsは `%APPDATA%\<appId>\diagnostics.log`）に記録されます。
 
 Linuxの透明表示はコンポジタが必要です。
 
@@ -325,7 +327,9 @@ await window.next2dWindow.quit();
 const off = window.next2dWindow.onResume(() => { /* resend state, etc. */ });
 ```
 
-With the overlay enabled the app runs **once**: a second launch quits at once (and, on macOS, never shows a Dock icon). Start with `--next2d-allow-multiple` to run several copies while developing.
+With the overlay enabled the app runs **once**: a second launch quits at once. On macOS it is an agent app with no Dock icon (quit from inside the game). Start with `--next2d-allow-multiple` to run several copies while developing.
+
+On Windows, after sleep (e.g. closing a laptop lid) the overlay window can stop receiving the mouse, so a fresh window replaces it; the game should save automatically. Power, display and GPU events are logged to `userData/diagnostics.log` (Windows: `%APPDATA%\<appId>\diagnostics.log`).
 
 Transparency on Linux requires a compositor.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next2d/builder",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Multi-platform builder for Next2d Framework, supporting export to various platforms such as macOS, Windows, iOS, Android and Web(HTML)",
   "author": "Toshiyuki Ienaga <ienaga@next2d.app>",
   "license": "MIT",

package/templates/electron/index.js

@@ -66,6 +66,64 @@ const refreshForwarding = () => {
     mainWindow.setIgnoreMouseEvents(false);
     mainWindow.setIgnoreMouseEvents(true, { forward: true });
 };
+// A small log of power/display/GPU events (userData/diagnostics.log) to find out what happened after sleep.
+const diagnosticsFile = () => path.join(app.getPath("userData"), "diagnostics.log");
+const diag = (message) => {
+    if (!overlay) return;
+    try {
+        const file = diagnosticsFile();
+        if (fs.existsSync(file) && fs.statSync(file).size > 200000) fs.writeFileSync(file, "");
+        fs.appendFileSync(file, `${new Date().toISOString()} ${message}\n`);
+    } catch { /* diagnostics must never break the game */ }
+};
+// Counts of mouse events the page really receives (moves are forwarded while click-through; down/up only arrive
+// while the window accepts clicks). Logged when they change, to tell "clicks never reach the page" from other causes.
+const DIAG_SCRIPT = `(() => {
+    if (window.__n2dDiag) return;
+    const d = window.__n2dDiag = { moves: 0, downs: 0, ups: 0, keys: 0, last: null };
+    const mark = (name) => (event) => { d[name]++; d.last = [event.clientX, event.clientY]; };
+    addEventListener("mousemove", mark("moves"), true);
+    addEventListener("pointerdown", mark("downs"), true);
+    addEventListener("pointerup", mark("ups"), true);
+    addEventListener("keydown", () => { d.keys++; }, true);
+})()`;
+let lastSnapshot = "";
+const snapshotRenderer = async () => {
+    if (!mainWindow || mainWindow.isDestroyed()) return;
+    try {
+        const raw = await mainWindow.webContents.executeJavaScript("JSON.stringify(window.__n2dDiag || null)");
+        if (raw !== lastSnapshot) {
+            lastSnapshot = raw;
+            diag(`renderer ${raw} ignore=${overlayIgnore} onTop=${mainWindow.isAlwaysOnTop()} bounds=${JSON.stringify(mainWindow.getBounds())}`);
+        }
+    } catch (error) {
+        diag(`renderer snapshot failed: ${error?.message ?? error}`);
+    }
+};
+// After sleep (closing a laptop lid) Windows can leave the overlay window itself broken: mouse moves are no longer
+// forwarded to it, or clicks fall through even where the pet is drawn. Reloading the page does not help (the
+// window is the same), so build a new window and close the old one. The game saves automatically, so progress is
+// kept. The new window is created first so the app never has zero windows (which would quit it).
+let recreating = false;
+const recreateWindow = async () => {
+    if (recreating || !mainWindow || mainWindow.isDestroyed()) return;
+    recreating = true;
+    diag("recreate window (resume)");
+    const old = mainWindow;
+    overlayIgnore = Boolean(overlay?.clickThrough);
+    try {
+        await createWindow();
+    } catch (error) {
+        diag(`recreate window failed: ${error?.message ?? error}`);
+    } finally {
+        recreating = false;
+        if (old !== mainWindow && !old.isDestroyed()) {
+            // Closing on purpose: do not treat the old page going away as a crash.
+            old.webContents.removeAllListeners("render-process-gone");
+            old.destroy();
+        }
+    }
+};
 const createWindow = async () => {
     const { width, height } = screen.getPrimaryDisplay().workAreaSize;
     // The preload reads these flags; each API is exposed only when its feature is configured.
@@ -103,8 +161,25 @@ const createWindow = async () => {
         if (overlay.clickThrough) {
             mainWindow.setIgnoreMouseEvents(true, { forward: true });
         }
+        // Errors the game prints (a failed window request, for example) are otherwise invisible in a packaged app.
+        let consoleLogged = 0;
+        mainWindow.webContents.on("console-message", (...args) => {
+            const first = args[0];
+            const detail = first && typeof first === "object" && "message" in first ? first : { level: args[1], message: args[2] };
+            if (!["error", "warning", 2, 3].includes(detail.level) || ++consoleLogged > 200) return;
+            diag(`console ${detail.level}: ${String(detail.message).slice(0, 300)}`);
+        });
+        mainWindow.webContents.on("did-finish-load", () => {
+            diag("renderer loaded");
+            mainWindow.webContents.executeJavaScript(DIAG_SCRIPT).catch(() => {});
+        });
+        const snapshotTimer = setInterval(snapshotRenderer, 5000);
+        snapshotTimer.unref?.();
+        mainWindow.once("closed", () => clearInterval(snapshotTimer));
+        mainWindow.webContents.on("unresponsive", () => diag("renderer unresponsive"));
+        mainWindow.webContents.on("responsive", () => diag("renderer responsive"));
         const events = ["display-metrics-changed", "display-added", "display-removed"];
-        const onDisplayChange = () => { placeOverlay(); keepOnTop(); };
+        const onDisplayChange = () => { diag("display changed"); placeOverlay(); keepOnTop(); };
         for (const name of events) screen.on(name, onDisplayChange);
         mainWindow.once("closed", () => {
             for (const name of events) screen.removeListener(name, onDisplayChange);
@@ -144,9 +219,8 @@ const createWindow = async () => {
 
 app.whenReady().then(async () => {
     if (!hasLock) return;
-    // The overlay app is packaged as an agent app (LSUIElement) so a second launch never shows a Dock icon;
-    // the instance that keeps running shows it.
-    if (process.platform === "darwin" && overlay) app.dock?.show();
+    // The overlay app is packaged as an agent app (LSUIElement): it never shows a Dock icon (a desktop pet stays out
+    // of the Dock and the app switcher; the game offers its own "quit").
     Menu.setApplicationMenu(process.platform === "darwin" ? Menu.buildFromTemplate([
         { role: "appMenu" }, { role: "editMenu" }, { role: "windowMenu" }
     ]) : null);
@@ -187,7 +261,10 @@ app.whenReady().then(async () => {
     }
     if (overlay) {
         const trusted = (event) => {
-            if (!isTrustedSender(event, mainWindow)) throw new Error("Window API access denied");
+            if (!isTrustedSender(event, mainWindow)) {
+                diag(`window API access denied (frame url: ${event?.senderFrame?.url})`);
+                throw new Error("Window API access denied");
+            }
         };
         ipcMain.handle("next2d:window:set-ignore-mouse-events", (event, ignore) => {
             trusted(event);
@@ -210,7 +287,19 @@ app.whenReady().then(async () => {
             mainWindow.setIgnoreMouseEvents(overlayIgnore, overlayIgnore ? { forward: true } : undefined);
             mainWindow.webContents.send("next2d:window:resume");
         };
-        for (const name of ["resume", "unlock-screen"]) powerMonitor.on(name, () => setTimeout(recoverOverlay, 1000));
+        for (const name of ["suspend", "lock-screen"]) powerMonitor.on(name, () => diag(name));
+        for (const name of ["resume", "unlock-screen"]) {
+            powerMonitor.on(name, () => {
+                diag(name);
+                if (name === "resume" && process.platform === "win32") {
+                    // Give the GPU/display time to come back, then start over with a fresh window.
+                    setTimeout(() => { void recreateWindow(); }, 3000);
+                } else {
+                    setTimeout(recoverOverlay, 1000);
+                }
+            });
+        }
+        app.on("child-process-gone", (_event, details) => diag(`child-process-gone ${details.type} ${details.reason}`));
         ipcMain.handle("next2d:window:quit", (event) => {
             trusted(event);
             // Reply before the window is torn down.