specrails-desktop 2.36.0 → 2.42.2

package/server/dist/blueprint-store.js

@@ -7,7 +7,13 @@ exports.updateBlueprintConversation = updateBlueprintConversation;
 exports.deleteBlueprintConversation = deleteBlueprintConversation;
 exports.addBlueprintMessage = addBlueprintMessage;
 exports.listBlueprintMessages = listBlueprintMessages;
+exports.saveBlueprintSnapshot = saveBlueprintSnapshot;
+exports.saveBlueprintSnapshotIssue = saveBlueprintSnapshotIssue;
+exports.getBlueprintSnapshot = getBlueprintSnapshot;
+exports.markBlueprintCommitted = markBlueprintCommitted;
+exports.listResumableBlueprintConversations = listResumableBlueprintConversations;
 const crypto_1 = require("crypto");
+const blueprint_draft_parser_1 = require("./blueprint-draft-parser");
 function createBlueprintConversation(db, input = {}) {
     const id = (0, crypto_1.randomUUID)();
     db.prepare('INSERT INTO blueprint_conversations (id, provider, model) VALUES (?, ?, ?)').run(id, input.provider ?? 'claude', input.model ?? null);
@@ -38,7 +44,7 @@ function deleteBlueprintConversation(db, id) {
 }
 function addBlueprintMessage(db, input) {
     const id = (0, crypto_1.randomUUID)();
-    db.prepare('INSERT INTO blueprint_messages (id, conversation_id, role, content) VALUES (?, ?, ?, ?)').run(id, input.conversationId, input.role, input.content);
+    db.prepare('INSERT INTO blueprint_messages (id, conversation_id, role, content, raw_content, intent) VALUES (?, ?, ?, ?, ?, ?)').run(id, input.conversationId, input.role, input.content, input.rawContent ?? null, input.intent ?? null);
     db.prepare("UPDATE blueprint_conversations SET updated_at = datetime('now') WHERE id = ?").run(input.conversationId);
     return db.prepare('SELECT * FROM blueprint_messages WHERE id = ?').get(id);
 }
@@ -47,3 +53,88 @@ function listBlueprintMessages(db, conversationId) {
         .prepare('SELECT * FROM blueprint_messages WHERE conversation_id = ? ORDER BY created_at, rowid')
         .all(conversationId);
 }
+function parseJsonColumn(value) {
+    if (!value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+/** Persist the ACCEPTED snapshot pair and clear any pending rejection. */
+function saveBlueprintSnapshot(db, id, snapshot) {
+    db.prepare(`UPDATE blueprint_conversations
+       SET blueprint_json = ?, raw_blueprint_json = ?, snapshot_updated_at = datetime('now'),
+           snapshot_issue_json = NULL, updated_at = datetime('now')
+     WHERE id = ?`).run(JSON.stringify(snapshot.blueprint), JSON.stringify(snapshot.rawBlueprint ?? snapshot.blueprint), id);
+}
+/** Record why the last block was rejected (kept until a snapshot is accepted). */
+function saveBlueprintSnapshotIssue(db, id, issue) {
+    db.prepare("UPDATE blueprint_conversations SET snapshot_issue_json = ?, updated_at = datetime('now') WHERE id = ?").run(issue ? JSON.stringify(issue) : null, id);
+}
+/** Read the persisted snapshot (normalized through `coerceBlueprint` so a
+ *  row written by an older build stays readable; corrupt JSON reads as null). */
+function getBlueprintSnapshot(db, id) {
+    const row = getBlueprintConversation(db, id);
+    if (!row)
+        return { blueprint: null, rawBlueprint: null, snapshotUpdatedAt: null, issue: null };
+    const rawBlueprint = parseJsonColumn(row.raw_blueprint_json);
+    const blueprint = (0, blueprint_draft_parser_1.coerceBlueprint)(parseJsonColumn(row.blueprint_json) ?? rawBlueprint);
+    const issueValue = parseJsonColumn(row.snapshot_issue_json);
+    const issue = issueValue && typeof issueValue.reason === 'string' && typeof issueValue.detail === 'string'
+        ? { reason: issueValue.reason, detail: issueValue.detail, at: typeof issueValue.at === 'string' ? issueValue.at : '' }
+        : null;
+    return { blueprint, rawBlueprint: blueprint ? rawBlueprint ?? blueprint : null, snapshotUpdatedAt: row.snapshot_updated_at, issue };
+}
+function markBlueprintCommitted(db, id, projectId) {
+    db.prepare("UPDATE blueprint_conversations SET committed_project_id = ?, updated_at = datetime('now') WHERE id = ?").run(projectId, id);
+}
+function summarizeBlueprint(bp) {
+    if (!bp)
+        return { productName: null, platform: null, specCount: 0, specsComplete: false, dimensionsFilled: 0 };
+    const dims = [
+        bp.product.name !== '' && bp.product.pitch !== '',
+        bp.coreFlow !== '',
+        bp.platform !== '',
+        bp.stack.language !== '' || bp.stack.framework !== '',
+        bp.milestones.length > 0,
+    ];
+    return {
+        productName: bp.product.name || null,
+        platform: bp.platform || null,
+        specCount: bp.m1Specs.length,
+        specsComplete: bp.specsComplete,
+        dimensionsFilled: dims.filter(Boolean).length,
+    };
+}
+/**
+ * Unfinished Builder conversations worth resuming: not committed and with at
+ * least one assistant reply (an empty bootstrap row is noise). Newest first.
+ */
+function listResumableBlueprintConversations(db, limit = 8) {
+    const rows = db
+        .prepare(`SELECT c.*, (SELECT COUNT(*) FROM blueprint_messages m WHERE m.conversation_id = c.id) AS message_count
+         FROM blueprint_conversations c
+        WHERE c.committed_project_id IS NULL
+          AND EXISTS (SELECT 1 FROM blueprint_messages m WHERE m.conversation_id = c.id AND m.role = 'assistant')
+        ORDER BY c.updated_at DESC, c.rowid DESC
+        LIMIT ?`)
+        .all(limit);
+    return rows.map((row) => {
+        const snapshot = getBlueprintSnapshot(db, row.id);
+        return {
+            id: row.id,
+            title: row.title,
+            provider: row.provider,
+            model: row.model,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            messageCount: row.message_count,
+            ...summarizeBlueprint(snapshot.blueprint),
+            hasSnapshot: snapshot.blueprint !== null,
+            pendingIssue: snapshot.issue?.reason ?? null,
+        };
+    });
+}

package/server/dist/browser-capture-manager.js

@@ -10,6 +10,7 @@ const ids_1 = require("./ids");
 const attachment_manager_1 = require("./attachment-manager");
 const browser_capture_types_1 = require("./browser-capture-types");
 const browser_playwright_1 = require("./browser-playwright");
+const browser_viewport_1 = require("./browser-viewport");
 const WS_OPEN = 1;
 const DEFAULT_VIEWPORT = { width: 1280, height: 800 };
 /** Playwright throws this family when the page/context/browser died underneath an
@@ -187,6 +188,14 @@ class BrowserCaptureManager {
             this._reserved--;
             throw err;
         }
+        if (this.disposed) {
+            this._reserved--;
+            try {
+                await page.close();
+            }
+            catch { /* ignore */ }
+            throw new browser_capture_types_1.BrowserLaunchError('manager disposed');
+        }
         // Re-check AFTER the awaits: another create that started before us may have
         // committed its session in the meantime. If the cap is now exceeded, tear the
         // extra page down and reject rather than silently exceeding the limit.
@@ -296,7 +305,7 @@ class BrowserCaptureManager {
         s.popupView = true;
         // Popups inherit the session viewport so coordinate mapping + screencast
         // dimensions stay identical to the root page.
-        void popup.setViewport(s.viewport.width, s.viewport.height).catch(() => { });
+        void popup.setViewport(s.viewport.width, s.viewport.height, s.viewport.deviceScaleFactor).catch(() => { });
         popup.onClose?.(() => this.dropPopup(s, popup));
         popup.onNavigated?.(() => {
             // Keep the "Login window — <origin>" label fresh while the top popup
@@ -398,27 +407,55 @@ class BrowserCaptureManager {
                 }
                 catch { /* ignore */ }
             }
+            s.lastFrame = null; // never replay a previous popup/root frame under new chrome
             if (desired) {
-                s.screencastPage = desired;
-                await desired.startScreencast((frame) => {
-                    if (s.closed)
+                for (let attempt = 0; attempt < 2; attempt++) {
+                    if (s.closed || !s.screencastDesired || this.activePage(s) !== desired)
+                        return;
+                    try {
+                        await desired.startScreencast((frame) => {
+                            if (s.closed || !s.screencastDesired || this.activePage(s) !== desired)
+                                return;
+                            s.lastFrame = frame.data;
+                            for (const client of s.clients) {
+                                if (client.readyState !== WS_OPEN)
+                                    continue;
+                                // Keep slow clients current instead of queueing stale JPEGs.
+                                if ((client.bufferedAmount ?? 0) > MAX_CLIENT_BUFFERED_BYTES)
+                                    continue;
+                                try {
+                                    client.send(frame.data);
+                                }
+                                catch { /* drop */ }
+                            }
+                        });
+                        s.screencastPage = desired;
                         return;
-                    s.lastFrame = frame.data;
-                    for (const client of s.clients) {
-                        if (client.readyState !== WS_OPEN)
-                            continue;
-                        // Conflate for slow consumers: when the socket's send-buffer is
-                        // already backed up, skip this frame for that client instead of
-                        // queueing ever-staler frames behind the backlog (latency, not
-                        // fps, is what makes a screencast feel sluggish).
-                        if ((client.bufferedAmount ?? 0) > MAX_CLIENT_BUFFERED_BYTES)
-                            continue;
+                    }
+                    catch {
+                        // A rejected CDP start previously left this session permanently
+                        // marked as casting. Release partial resources before one retry.
                         try {
-                            client.send(frame.data);
+                            await desired.stopScreencast();
                         }
-                        catch { /* drop */ }
+                        catch { /* ignore */ }
                     }
-                });
+                }
+                // An OAuth window can self-close during the final failed CDP attach or
+                // its cleanup. The queued transition will resume its opener; a failure
+                // belonging to the old popup must not disconnect the whole session.
+                if (s.closed || !s.screencastDesired || this.activePage(s) !== desired)
+                    return;
+                s.screencastDesired = false;
+                // Persistent failure must surface as a disconnected stream, not a ready
+                // socket that displays a blank canvas forever. A later attach can retry.
+                for (const client of s.clients) {
+                    try {
+                        client.close(1011, 'browser_stream_failed');
+                    }
+                    catch { /* ignore */ }
+                }
+                s.clients.clear();
             }
         }).catch(() => { });
         return s.screencastOp;
@@ -461,16 +498,21 @@ class BrowserCaptureManager {
         if (!s)
             return;
         if (event.type === 'resize') {
+            const normalized = (0, browser_viewport_1.normalizeBrowserViewport)(event.width, event.height, event.deviceScaleFactor ?? s.viewport.deviceScaleFactor);
             s.viewport = {
-                width: Math.max(1, Math.round(event.width)),
-                height: Math.max(1, Math.round(event.height)),
+                width: normalized.width,
+                height: normalized.height,
+                ...(event.deviceScaleFactor !== undefined || s.viewport.deviceScaleFactor !== undefined
+                    ? { deviceScaleFactor: (0, browser_viewport_1.normalizeBrowserDeviceScaleFactor)(event.deviceScaleFactor ?? s.viewport.deviceScaleFactor ?? 1) }
+                    : {}),
             };
             // Keep every page of the session (root + popups) at the same viewport so
             // switching between them never re-maps coordinates or resizes the canvas.
-            await s.page.dispatchInput(event);
+            const resize = { type: 'resize', ...s.viewport };
+            await s.page.dispatchInput(resize);
             for (const popup of s.popups) {
                 try {
-                    await popup.dispatchInput(event);
+                    await popup.dispatchInput(resize);
                 }
                 catch { /* ignore */ }
             }
@@ -486,22 +528,36 @@ class BrowserCaptureManager {
         const s = this.getSessionForActivity(sessionId);
         if (!s)
             return null;
+        // Snapshot before awaiting: an OAuth window can close, or the user can
+        // switch views, while a navigation is in flight. Its result still belongs
+        // to the page the user acted on, never to the newly visible opener.
+        const page = this.activePage(s);
+        const isPopup = page !== s.page;
         this.beginOperation(s);
         try {
             let result;
             if (action === 'goto')
-                result = await s.page.goto(url ?? 'about:blank');
+                result = await page.goto(url ?? 'about:blank');
             else if (action === 'back')
-                result = await s.page.goBack();
+                result = await page.goBack();
             else if (action === 'forward')
-                result = await s.page.goForward();
+                result = await page.goForward();
             else
-                result = await s.page.reload();
-            s.url = result.url;
-            s.title = result.title;
-            if (result.url && result.url !== 'about:blank')
-                this.setLastUrl(result.url);
-            this.broadcastControl(s, { type: 'nav', url: result.url, title: result.title });
+                result = await page.reload();
+            if (isPopup) {
+                if (!s.closed && !this.disposed && this.topPopup(s) === page)
+                    this.broadcastPopupState(s);
+                // Popup redirect/callback URLs must never replace the project page's
+                // remembered URL, title or nav events (nor the client's root state).
+                return { ...result, target: 'popup' };
+            }
+            if (!s.closed && !this.disposed) {
+                s.url = result.url;
+                s.title = result.title;
+                if (result.url && result.url !== 'about:blank')
+                    this.setLastUrl(result.url);
+                this.broadcastControl(s, { type: 'nav', url: result.url, title: result.title });
+            }
             return result;
         }
         finally {

package/server/dist/browser-playwright.js

@@ -8,6 +8,7 @@
 // Screencast uses CDP (`Page.startScreencast`) since Playwright exposes no
 // screencast API; input + screenshot + DOM use Playwright's high-level page API.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightPageHandle = void 0;
 exports.isNavigableUrl = isNavigableUrl;
 exports.screencastParams = screencastParams;
 exports.normalizeUrl = normalizeUrl;
@@ -15,6 +16,7 @@ exports.chromiumLaunchArgs = chromiumLaunchArgs;
 exports.createPlaywrightLauncher = createPlaywrightLauncher;
 const chromium_resolver_1 = require("./chromium-resolver");
 const browser_network_1 = require("./browser-network");
+const browser_viewport_1 = require("./browser-viewport");
 /**
  * Centralized SSRF / scheme guard for EVERY navigation path (WS `navigate`, REST
  * `navigate`, REST create `initialUrl`). Returns true only for an `http`/`https`
@@ -117,7 +119,7 @@ function screencastParams(env = process.env) {
         if (Number.isFinite(n))
             quality = Math.min(100, Math.max(1, Math.round(n)));
     }
-    return { format: 'jpeg', quality, everyNthFrame: 1, maxWidth: 3840, maxHeight: 2400 };
+    return { format: 'jpeg', quality, everyNthFrame: 1, maxWidth: browser_viewport_1.MAX_BROWSER_RASTER.width, maxHeight: browser_viewport_1.MAX_BROWSER_RASTER.height };
 }
 /**
  * Normalize a user-supplied address into a safe, navigable URL. A bare host
@@ -144,6 +146,14 @@ class PlaywrightPageHandle {
     // dependency on playwright's exported types leaking through the abstraction.
     cdp = null;
     screencastHandler = null;
+    screencastStart = null;
+    // Captures can render at display density independently of the interactive
+    // viewport. CDP emulation scale/DPR changes break screencast or wheel semantics.
+    captureCdp = null;
+    viewportOp = null;
+    pendingViewport = null;
+    requestedDeviceScaleFactor = 1;
+    captureDeviceScaleFactor = 1;
     // A dedicated, long-lived CDP session for the Network domain — kept SEPARATE
     // from `cdp` (which is attached/detached around screencast) so request capture
     // survives screencast toggles.
@@ -207,11 +217,33 @@ class PlaywrightPageHandle {
             return '';
         }
     }
-    async setViewport(width, height) {
+    async setViewport(width, height, deviceScaleFactor) {
+        if (deviceScaleFactor !== undefined)
+            this.requestedDeviceScaleFactor = deviceScaleFactor;
+        this.pendingViewport = (0, browser_viewport_1.normalizeBrowserViewport)(width, height, this.requestedDeviceScaleFactor);
+        if (this.viewportOp)
+            return this.viewportOp;
+        const operation = (async () => {
+            while (this.pendingViewport) {
+                const next = this.pendingViewport;
+                this.pendingViewport = null;
+                try {
+                    await this.page.setViewportSize({ width: next.width, height: next.height });
+                    this.captureDeviceScaleFactor = next.deviceScaleFactor;
+                }
+                catch {
+                    this.captureDeviceScaleFactor = 1; // page closed/navigating; input stays best-effort
+                }
+            }
+        })();
+        this.viewportOp = operation;
         try {
-            await this.page.setViewportSize({ width: Math.max(1, Math.round(width)), height: Math.max(1, Math.round(height)) });
+            await operation;
+        }
+        finally {
+            if (this.viewportOp === operation)
+                this.viewportOp = null;
         }
-        catch { /* ignore */ }
     }
     async dispatchInput(event) {
         try {
@@ -257,7 +289,7 @@ class PlaywrightPageHandle {
                 }
             }
             else if (event.type === 'resize') {
-                await this.setViewport(event.width, event.height);
+                await this.setViewport(event.width, event.height, event.deviceScaleFactor);
             }
         }
         catch {
@@ -265,44 +297,81 @@ class PlaywrightPageHandle {
         }
     }
     async startScreencast(onFrame) {
+        if (this.screencastStart)
+            return this.screencastStart;
         if (this.screencastHandler)
             return;
-        this.screencastHandler = onFrame;
-        const ctx = this.page.context();
-        this.cdp = await ctx.newCDPSession(this.page);
-        this.cdp.on('Page.screencastFrame', (evt) => {
-            // Ack FIRST, fire-and-forget: Chromium throttles the screencast on unacked
-            // frames, so acking before the fan-out lets it capture+compress the next
-            // frame while this one is being delivered (pipeline overlap → higher fps,
-            // lower frame age). The frames are independent JPEGs, so there is no
-            // ordering hazard in acking early.
+        const startup = (async () => {
+            let cdp = null;
             try {
-                this.cdp?.send('Page.screencastFrameAck', { sessionId: evt.sessionId })?.catch?.(() => { });
-            }
-            catch { /* ignore */ }
-            try {
-                this.screencastHandler?.({
-                    data: Buffer.from(evt.data, 'base64'),
-                    width: evt.metadata?.deviceWidth ?? 0,
-                    height: evt.metadata?.deviceHeight ?? 0,
+                cdp = await this.page.context().newCDPSession(this.page);
+                this.cdp = cdp;
+                this.screencastHandler = onFrame;
+                cdp.on('Page.screencastFrame', (evt) => {
+                    // Ack on the session that emitted the frame. A late callback from an
+                    // old cast must never ack or render into its replacement.
+                    try {
+                        cdp.send('Page.screencastFrameAck', { sessionId: evt.sessionId })?.catch?.(() => { });
+                    }
+                    catch { /* ignore */ }
+                    if (this.cdp !== cdp)
+                        return;
+                    try {
+                        this.screencastHandler?.({
+                            data: Buffer.from(evt.data, 'base64'),
+                            width: evt.metadata?.deviceWidth ?? 0,
+                            height: evt.metadata?.deviceHeight ?? 0,
+                        });
+                    }
+                    catch { /* never let a handler error kill the CDP session */ }
                 });
+                await cdp.send('Page.startScreencast', screencastParams());
             }
-            catch { /* never let a handler error kill the CDP session */ }
-        });
-        await this.cdp.send('Page.startScreencast', screencastParams());
+            catch (err) {
+                this.screencastHandler = null;
+                if (this.cdp === cdp)
+                    this.cdp = null;
+                if (cdp) {
+                    try {
+                        await cdp.send('Page.stopScreencast');
+                    }
+                    catch { /* ignore */ }
+                    try {
+                        await cdp.detach();
+                    }
+                    catch { /* ignore */ }
+                }
+                throw err;
+            }
+        })();
+        this.screencastStart = startup;
+        try {
+            await startup;
+        }
+        finally {
+            if (this.screencastStart === startup)
+                this.screencastStart = null;
+        }
     }
     async stopScreencast() {
+        // Closing while newCDPSession/start is awaiting must also close the eventual
+        // CDP handle. Otherwise unmount can leave an invisible capture running.
+        try {
+            await this.screencastStart;
+        }
+        catch { /* startup already cleaned up */ }
         this.screencastHandler = null;
-        if (this.cdp) {
+        const cdp = this.cdp;
+        this.cdp = null;
+        if (cdp) {
             try {
-                await this.cdp.send('Page.stopScreencast');
+                await cdp.send('Page.stopScreencast');
             }
             catch { /* ignore */ }
             try {
-                await this.cdp.detach();
+                await cdp.detach();
             }
             catch { /* ignore */ }
-            this.cdp = null;
         }
     }
     async screenshotClip(rect) {
@@ -312,6 +381,29 @@ class PlaywrightPageHandle {
             width: Math.max(1, Math.round(rect.width)),
             height: Math.max(1, Math.round(rect.height)),
         };
+        await this.viewportOp;
+        if (this.captureDeviceScaleFactor > 1) {
+            // Screenshot clip.scale re-rasterizes vector/text detail at display
+            // density without changing page DPR, input units, scroll, or live JPEGs.
+            // CSS layout metrics supply the document offset of the viewport crop.
+            this.captureCdp ??= await this.page.context().newCDPSession(this.page);
+            try {
+                const { cssVisualViewport } = await this.captureCdp.send('Page.getLayoutMetrics');
+                const result = await this.captureCdp.send('Page.captureScreenshot', {
+                    format: 'png', captureBeyondViewport: false,
+                    clip: { ...clip, x: clip.x + (cssVisualViewport?.pageX ?? 0), y: clip.y + (cssVisualViewport?.pageY ?? 0), scale: this.captureDeviceScaleFactor },
+                });
+                return Buffer.from(result.data, 'base64');
+            }
+            catch (error) {
+                try {
+                    await this.captureCdp.detach();
+                }
+                catch { /* ignore */ }
+                this.captureCdp = null;
+                throw error;
+            }
+        }
         return this.page.screenshot({ clip, type: 'png' });
     }
     async extractDom(rect, htmlByteCap) {
@@ -496,17 +588,15 @@ class PlaywrightPageHandle {
         // context — cookies and the window.opener/postMessage relationship are
         // intact, which is exactly what an OAuth redirect/popup flow needs.
         //
-        // HARDENING (Okta-class IdPs): a popup opened from a cross-origin IFRAME
-        // (out-of-process sign-in widgets) is attributed to the iframe's target,
-        // and the page-level 'popup' event can miss it — the login window then
-        // "never appears". So we ALSO watch the shared context for new pages whose
-        // opener chain resolves to this page and adopt those. `seen` dedupes the
-        // two doors; pages from other sessions have a different opener and are
-        // ignored.
+        // Also watch the context for pages whose direct opener is this page. A
+        // chained login can open its next window before its own handle is adopted,
+        // so replay existing pages after subscribing. Deduplication covers both
+        // events and the replay; another session's pages never share this opener.
         try {
             const seen = new WeakSet();
+            let active = !this.page.isClosed?.();
             const adopt = (p) => {
-                if (seen.has(p))
+                if (!active || p === this.page || p.isClosed?.() || seen.has(p))
                     return;
                 seen.add(p);
                 try {
@@ -520,9 +610,11 @@ class PlaywrightPageHandle {
                 const onContextPage = (p) => {
                     void (async () => {
                         try {
-                            if (seen.has(p) || p === this.page)
+                            if (!active || seen.has(p) || p === this.page || p.isClosed?.())
                                 return;
                             const opener = await p.opener?.();
+                            // `opener()` is async; the opener or popup may have closed while
+                            // it was pending. adopt checks that lifetime again.
                             if (opener === this.page)
                                 adopt(p);
                         }
@@ -530,13 +622,20 @@ class PlaywrightPageHandle {
                     })();
                 };
                 ctx.on('page', onContextPage);
-                // The shared context outlives this page — detach on page close so a
-                // long-lived app never accumulates dead listeners.
-                this.page.on('close', () => {
+                for (const p of ctx.pages?.() ?? [])
+                    onContextPage(p);
+                // The shared context outlives this page. Invalidate pending lookups as
+                // well as detaching listeners, or a late result can revive a dead tab.
+                this.onClose(() => {
+                    active = false;
                     try {
                         ctx.off?.('page', onContextPage);
                     }
                     catch { /* ignore */ }
+                    try {
+                        this.page.off?.('popup', adopt);
+                    }
+                    catch { /* ignore */ }
                 });
             }
         }
@@ -544,12 +643,21 @@ class PlaywrightPageHandle {
     }
     onClose(cb) {
         try {
-            this.page.on('close', () => {
+            let delivered = false;
+            const notify = () => {
+                if (delivered)
+                    return;
+                delivered = true;
                 try {
                     cb();
                 }
                 catch { /* ignore */ }
-            });
+            };
+            this.page.on('close', notify);
+            // An immediate OAuth callback can self-close before adoption finishes.
+            // Deliver that state too; waiting only for a future event strands it.
+            if (this.page.isClosed?.())
+                queueMicrotask(notify);
         }
         catch { /* ignore */ }
     }
@@ -587,6 +695,14 @@ class PlaywrightPageHandle {
     }
     async close() {
         await this.stopScreencast();
+        await this.viewportOp;
+        if (this.captureCdp) {
+            try {
+                await this.captureCdp.detach();
+            }
+            catch { /* ignore */ }
+            this.captureCdp = null;
+        }
         if (this.netCdp) {
             try {
                 await this.netCdp.send('Network.disable');
@@ -604,6 +720,7 @@ class PlaywrightPageHandle {
         catch { /* ignore */ }
     }
 }
+exports.PlaywrightPageHandle = PlaywrightPageHandle;
 // Serialised into the page via page.evaluate. Self-contained: no closures over
 // Node scope. Returns the html + nodes; the Node side stamps url/title/time.
 function domExtractScript(arg) {
@@ -1100,8 +1217,12 @@ class PlaywrightContextHandle {
  * sandbox frequently fails to initialise inside a packaged/headless app and would
  * otherwise refuse to launch. We never disable the sandbox where it functions.
  */
-function chromiumLaunchArgs() {
-    const args = ['--disable-dev-shm-usage', '--disable-gpu'];
+function chromiumLaunchArgs(env = process.env) {
+    const args = ['--disable-dev-shm-usage'];
+    // Native acceleration is the browser default. Retain an explicit escape hatch
+    // for machines/drivers that need software rendering, without forcing it on Macs.
+    if (env.SPECRAILS_BROWSER_DISABLE_GPU === 'true')
+        args.push('--disable-gpu');
     if (process.platform === 'linux')
         args.unshift('--no-sandbox');
     return args;
@@ -1123,6 +1244,8 @@ function createPlaywrightLauncher() {
         const context = await chromium.launchPersistentContext(opts.userDataDir, {
             headless: true,
             executablePath,
+            // Playwright defaults this option to false even without --no-sandbox.
+            chromiumSandbox: process.platform !== 'linux',
             viewport: opts.viewport,
             args: chromiumLaunchArgs(),
         });

package/server/dist/browser-viewport.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_BROWSER_RASTER = void 0;
+exports.normalizeBrowserDeviceScaleFactor = normalizeBrowserDeviceScaleFactor;
+exports.normalizeBrowserViewport = normalizeBrowserViewport;
+/** CSS layout stays independent from the bounded physical capture raster. */
+exports.MAX_BROWSER_RASTER = { width: 3840, height: 2400 };
+function normalizeBrowserDeviceScaleFactor(value) {
+    return Number.isFinite(value) ? Math.min(2, Math.max(1, value)) : 1;
+}
+function normalizeBrowserViewport(width, height, deviceScaleFactor = 1) {
+    const dimension = (value, fallback, max) => Number.isFinite(value)
+        ? Math.min(max, Math.max(1, Math.round(value)))
+        : fallback;
+    const cssWidth = dimension(width, 1280, exports.MAX_BROWSER_RASTER.width);
+    const cssHeight = dimension(height, 800, exports.MAX_BROWSER_RASTER.height);
+    const requestedScale = normalizeBrowserDeviceScaleFactor(deviceScaleFactor);
+    const scale = Math.min(requestedScale, exports.MAX_BROWSER_RASTER.width / cssWidth, exports.MAX_BROWSER_RASTER.height / cssHeight);
+    return {
+        width: cssWidth,
+        height: cssHeight,
+        deviceScaleFactor: scale,
+        rasterWidth: Math.round(cssWidth * scale),
+        rasterHeight: Math.round(cssHeight * scale),
+    };
+}