Pup - the AI's own browser

@@ -12080,9 +12080,20 @@ function attachSessionNotices(obj, verb, argsIn) {     if (obj._viewportOverride === undefined && VIEWPORT_SENSITIVE.has(verb)) {       const ev = sess._emulatedViewport;       if (ev && ev.width) {+        // Both failure directions are real and they look opposite on screen. NARROWER than the+        // window leaves dead space down the side; WIDER crops content off the edge, which is the+        // one that hides information from the user. Name which one this is.+        const outer = Number(sess._lastOuterWidth) || null;+        let shape = '';+        if (outer && ev.width > outer + 4) {+          shape = ` The emulation is WIDER than the OS window (${ev.width} vs ${outer}), so the user is seeing this page CROPPED: roughly ${ev.width - outer}px of it is off the right edge of their window.`;+        } else if (outer && ev.width < outer - 4) {+          shape = ` The emulation is NARROWER than the OS window (${ev.width} vs ${outer}), so the user is seeing dead space beside the page.`;+        }         obj._viewportOverride = `This window has an EMULATED VIEWPORT of ${ev.width}x${ev.height}`           + (ev.deviceScaleFactor ? ` @${ev.deviceScaleFactor}x` : '')-          + `, so it is NOT tracking the real OS window. Anything you measure in the page (innerWidth, clientWidth, a bounding rect) describes the emulation, not what the user sees: a page that fills this viewport can still leave dead space on their screen. Clear it with pup_set_viewport {"reset":true} when you are done emulating.`;+          + `, so it is NOT tracking the real OS window.` + shape+          + ` Anything you measure in the page (innerWidth, clientWidth, a bounding rect) describes the emulation, not what the user sees. Clear it with pup_set_viewport {"reset":true} when you are done emulating.`;       }     }     // #80: the restart notice, delivered to the session it happened to rather than broadcast.@@ -17147,10 +17158,35 @@ const server = http.createServer(async (req, res) => {           const wantsReset = args.reset === true || (args.width === undefined && args.height === undefined);           if (wantsReset) {             try {+              // v2.0.365 (project-a5's report). VERIFY THE CLEAR, do not assume it. They measured a+              // reset that returned ok:true with "innerWidth now 2200" — the OVERRIDE width, not the+              // real one — while the override was still in force through a reload. A reset that+              // reports the number it was supposed to remove is worse than a failure, because the+              // caller then trusts a window that is still cropping content off the user's screen.+              const _prev = session._emulatedViewport ? Number(session._emulatedViewport.width) : null;               await tab.page.setViewport(null);+              // Belt and braces: puppeteer's setViewport(null) does not always reach the metrics+              // override on a page that was emulated earlier in its life, so clear it at the+              // protocol level too. Harmless when there is nothing to clear.+              try { const _cdp = await tab.page.createCDPSession(); await _cdp.send('Emulation.clearDeviceMetricsOverride'); await _cdp.detach().catch(() => {}); } catch (e) {}               session._emulatedViewport = null;-              const dims = await tab.page.evaluate(() => ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, devicePixelRatio: window.devicePixelRatio }));-              sendJSON(res, { success: true, output: JSON.stringify({ ok: true, sessionId: resolvedId, tabId, reset: true, ...dims,+              // Measure AFTER a forced reflow, and measure the OUTER window too: outerWidth is the+              // one number an emulated viewport cannot fake, so innerWidth-vs-outerWidth is how an+              // AI can finally tell an emulated window from a real one (their ask (b)).+              await tab.page.evaluate(() => new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r))));+              const dims = await tab.page.evaluate(() => ({+                innerWidth: window.innerWidth, innerHeight: window.innerHeight,+                outerWidth: window.outerWidth, devicePixelRatio: window.devicePixelRatio,+              }));+              // If it still reads as the width we just removed, the clear did NOT take. Say so.+              if (_prev && Math.abs(dims.innerWidth - _prev) <= 2) {+                sendJSON(res, { success: false, error: `the viewport override did not clear: the page still reports innerWidth ${dims.innerWidth}, which is the override width`,+                  errorCode: 'viewport_reset_failed',+                  output: JSON.stringify({ ok: false, sessionId: resolvedId, tabId, emulated: true, ...dims }),+                  _hint: `pup could not remove the emulation from this window. Close and reopen it (pup_close_window then pup_open_window) — a fresh window reports the real size. Do NOT trust in-page measurements from this window meanwhile: the page believes it is ${dims.innerWidth}px wide while the OS window is ${dims.outerWidth}px, so the user is seeing it cropped.` });+                return;+              }+              sendJSON(res, { success: true, output: JSON.stringify({ ok: true, sessionId: resolvedId, tabId, reset: true, emulated: false, ...dims,                 _hint: `Viewport override CLEARED — this window tracks the real OS window again (innerWidth now ${dims.innerWidth}, dpr ${dims.devicePixelRatio}). Resizing the window will reflow the page normally.` }) });             } catch (e) { sendJSON(res, { success: false, error: `clearing the viewport override failed: ${e.message}` }); }             return;@@ -17162,13 +17198,19 @@ const server = http.createServer(async (req, res) => {           }           const dsf = Number(args.deviceScaleFactor) || 1;           try {+            // Capture the REAL window width BEFORE emulating. outerWidth is the one number the+            // override cannot fake, and it is what lets every later warning say whether the user is+            // seeing dead space or seeing content cropped off their screen.+            let _outerBefore = null;+            try { _outerBefore = await tab.page.evaluate(() => window.outerWidth); } catch (e) {}             await tab.page.setViewport({ width: Math.round(vw), height: Math.round(vh), deviceScaleFactor: dsf });+            if (_outerBefore) session._lastOuterWidth = _outerBefore;             // Fix 2 of 4: RECORD the override so pup_status / pup_list_windows can report it.             session._emulatedViewport = { width: Math.round(vw), height: Math.round(vh), deviceScaleFactor: dsf };-            const dims = await tab.page.evaluate(() => ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, devicePixelRatio: window.devicePixelRatio }));+            const dims = await tab.page.evaluate(() => ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, outerWidth: window.outerWidth, devicePixelRatio: window.devicePixelRatio }));             // Fix 3 of 4: the hint must state the LIFECYCLE, not just the benefit. The old text sold             // the feature and never said the effect is permanent for the life of the window.-            sendJSON(res, { success: true, output: JSON.stringify({ ok: true, sessionId: resolvedId, tabId, applied: { width: Math.round(vw), height: Math.round(vh), deviceScaleFactor: dsf }, ...dims,+            sendJSON(res, { success: true, output: JSON.stringify({ ok: true, sessionId: resolvedId, tabId, emulated: true, realOuterWidth: _outerBefore, applied: { width: Math.round(vw), height: Math.round(vh), deviceScaleFactor: dsf }, ...dims,               _hint: `Viewport PINNED to ${Math.round(vw)}×${Math.round(vh)} (innerWidth now ${dims.innerWidth}). ⚠ THIS PERSISTS: it survives navigation AND hard reload, and while it is set the window NO LONGER TRACKS OS RESIZING — a human resizing this window will see the page not reflow, which reads exactly like an app layout bug. CLEAR IT when you are done: pup_set_viewport {"sessionId":"${resolvedId}","reset":true}. It is reported as emulatedViewport in pup_status / pup_list_windows.` }) });           } catch (e) { sendJSON(res, { success: false, error: `setViewport failed: ${e.message}` }); }           return;