sliccy 6.164.0 → 6.164.1

package/dist/node-server/electron-main.js

@@ -5,7 +5,7 @@ import { resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { mintBridgeToken } from './bridge-security.js';
 import { BRIDGE_ROLE_LEADER, buildThinOverlayAppUrl, resolveHostedLeaderOrigin, } from './electron-controller.js';
-import { buildElectronOverlayInjectionCall, buildElectronServerSpawnConfig, getElectronOverlayEntryDistPath, getElectronServeOrigin, parseElectronFloatFlags, } from './electron-runtime.js';
+import { buildElectronChildWindowOptions, buildElectronOverlayInjectionCall, buildElectronServerSpawnConfig, ELECTRON_FLOAT_WINDOW_BOX, getElectronOverlayEntryDistPath, getElectronServeOrigin, parseElectronFloatFlags, } from './electron-runtime.js';
 const Dirname = fileURLToPath(new URL('.', import.meta.url));
 const PROJECT_ROOT = resolve(Dirname, '..', '..');
 const FLAGS = parseElectronFloatFlags(process.argv.slice(2));
@@ -92,27 +92,47 @@ function configureElectronSession() {
         callback({ responseHeaders });
     });
 }
+const FLOAT_WEB_PREFERENCES = {
+    partition: ELECTRON_PARTITION,
+    contextIsolation: true,
+    nodeIntegration: false,
+    sandbox: true,
+    allowRunningInsecureContent: true,
+};
+/**
+ * Overlay reinjection plus renderer-opened child windows, applied to every
+ * float window and, recursively, to every window it opens.
+ *
+ * Child windows are ALLOWED, not denied-and-replaced: a `{ action: 'deny' }`
+ * handler makes `window.open()` return `null` in the renderer even when the
+ * main process spawns a lookalike, so a full-document sprinkle could never get
+ * a handle or a sized window (Codex P1 on #3250). With `allow`, Electron
+ * creates the child from the parsed `features` string (width/height) and the
+ * renderer gets the real `Window` back. The override only adds the float's
+ * web preferences and, for featureless `target="_blank"` links, the default
+ * float box.
+ */
+function wireFloatWindow(window) {
+    wireOverlayReinjection(window);
+    window.webContents.setWindowOpenHandler(({ features }) => ({
+        action: 'allow',
+        overrideBrowserWindowOptions: {
+            ...buildElectronChildWindowOptions(features),
+            webPreferences: FLOAT_WEB_PREFERENCES,
+        },
+    }));
+    window.webContents.on('did-create-window', (child) => {
+        wireFloatWindow(child);
+    });
+}
 async function createFloatWindow(targetUrl) {
     const window = new BrowserWindow({
-        width: 1440,
-        height: 960,
-        minWidth: 1024,
-        minHeight: 720,
+        ...ELECTRON_FLOAT_WINDOW_BOX,
         autoHideMenuBar: true,
         title: 'slicc electron float',
-        webPreferences: {
-            partition: ELECTRON_PARTITION,
-            contextIsolation: true,
-            nodeIntegration: false,
-            sandbox: true,
-            allowRunningInsecureContent: true,
-        },
-    });
-    wireOverlayReinjection(window);
-    window.webContents.setWindowOpenHandler(({ url }) => {
-        void createFloatWindow(url);
-        return { action: 'deny' };
+        webPreferences: FLOAT_WEB_PREFERENCES,
     });
+    wireFloatWindow(window);
     try {
         await window.loadURL(targetUrl);
     }

package/dist/node-server/electron-runtime.d.ts

@@ -71,6 +71,36 @@ export declare function buildElectronServerSpawnConfig(projectRoot: string, opti
     cdpPort: number;
     nodePath?: string;
 }): ElectronServerSpawnConfig;
+/** Default float window box; also applied to child windows opened without a size. */
+export declare const ELECTRON_FLOAT_WINDOW_BOX: {
+    readonly width: 1440;
+    readonly height: 960;
+    readonly minWidth: 1024;
+    readonly minHeight: 720;
+};
+export interface ElectronChildWindowOptions {
+    autoHideMenuBar: true;
+    width?: number;
+    height?: number;
+    minWidth?: number;
+    minHeight?: number;
+}
+/**
+ * Does a `window.open()` features string ask for a window size? Electron parses
+ * `width`/`height` (and the `innerWidth`/`innerHeight` aliases) from the
+ * comma-separated `key=value` list into `BrowserWindowConstructorOptions`.
+ */
+export declare function windowOpenFeaturesRequestSize(features: string): boolean;
+/**
+ * Options the Electron float's `setWindowOpenHandler` layers over a
+ * renderer-opened child window. Handler options OUTRANK the parsed features
+ * string, so this must not name a size when the opener asked for one:
+ * `window.open(url, name, 'popup=yes,width=1280,height=800')` (a sprinkle
+ * opening a fixed-size capture window) has to come out exactly 1280×800 with
+ * no min-size clamp. A featureless `target="_blank"` link keeps the full float
+ * box it always had.
+ */
+export declare function buildElectronChildWindowOptions(features: string): ElectronChildWindowOptions;
 export declare function getElectronServeOrigin(servePort: number): string;
 export declare function getElectronOverlayEntryDistPath(projectRoot: string): string;
 /** Payload passed to `window.__SLICC_ELECTRON_OVERLAY__.inject()` — mirrors spoon's `InjectSliccLauncherOptions`. */

package/dist/node-server/electron-runtime.js

@@ -227,6 +227,41 @@ export function buildElectronServerSpawnConfig(projectRoot, options) {
         ],
     };
 }
+/** Default float window box; also applied to child windows opened without a size. */
+export const ELECTRON_FLOAT_WINDOW_BOX = {
+    width: 1440,
+    height: 960,
+    minWidth: 1024,
+    minHeight: 720,
+};
+const WINDOW_OPEN_SIZE_FEATURES = new Set(['width', 'height', 'innerwidth', 'innerheight']);
+/**
+ * Does a `window.open()` features string ask for a window size? Electron parses
+ * `width`/`height` (and the `innerWidth`/`innerHeight` aliases) from the
+ * comma-separated `key=value` list into `BrowserWindowConstructorOptions`.
+ */
+export function windowOpenFeaturesRequestSize(features) {
+    for (const entry of features.split(',')) {
+        const key = entry.split('=')[0]?.trim().toLowerCase();
+        if (key && WINDOW_OPEN_SIZE_FEATURES.has(key))
+            return true;
+    }
+    return false;
+}
+/**
+ * Options the Electron float's `setWindowOpenHandler` layers over a
+ * renderer-opened child window. Handler options OUTRANK the parsed features
+ * string, so this must not name a size when the opener asked for one:
+ * `window.open(url, name, 'popup=yes,width=1280,height=800')` (a sprinkle
+ * opening a fixed-size capture window) has to come out exactly 1280×800 with
+ * no min-size clamp. A featureless `target="_blank"` link keeps the full float
+ * box it always had.
+ */
+export function buildElectronChildWindowOptions(features) {
+    if (windowOpenFeaturesRequestSize(features))
+        return { autoHideMenuBar: true };
+    return { autoHideMenuBar: true, ...ELECTRON_FLOAT_WINDOW_BOX };
+}
 export function getElectronServeOrigin(servePort) {
     return `http://${DEFAULT_ELECTRON_SERVE_HOST}:${servePort}`;
 }