@@ -1037,17 +1037,17 @@ const reportPage = (
   },
 ) => {
   const { zoom = 1, ...reported } = page;
-  const evaluate = context.page.evaluate.getMockImplementation()!;
-  context.page.evaluate.mockImplementation(((script?: unknown) =>
-    typeof script === "string" && script.includes("devicePixelRatio")
-      ? Promise.resolve(reported)
-      : evaluate()) as typeof evaluate);
+  const replies: Record<string, Record<string, unknown>> = {
+    "Page.getFrameTree": { frameTree: { frame: { id: "main" } } },
+    "Page.createIsolatedWorld": { executionContextId: 7 },
+    "Page.getLayoutMetrics": { cssVisualViewport: { pageX: 0, pageY: 0, zoom } },
+  };
   for (const session of context.sessions) {
     const send = session.send.getMockImplementation()!;
     session.send.mockImplementation(async (method, input) =>
-      method === "Page.getLayoutMetrics"
-        ? { cssVisualViewport: { pageX: 0, pageY: 0, zoom } }
-        : send(method, input),
+      method === "Runtime.evaluate" && (input as { contextId?: number })?.contextId === 7
+        ? { result: { value: reported } }
+        : (replies[method] ?? send(method, input)),
     );
   }
 };
@@ -1178,9 +1178,11 @@ it.live("keeps a headless tab's snapshot at its own render scale", () =>
         input: {},
       });
       expect(captureClips(contexts[0]!)).toEqual([{ width: 1280, height: 800, scale: 0.5 }]);
-      expect(contexts[0]!.page.evaluate).not.toHaveBeenCalledWith(
-        expect.stringContaining("devicePixelRatio"),
-      );
+      expect(
+        contexts[0]!.sessions.flatMap((session) =>
+          session.send.mock.calls.map(([method]) => method),
+        ),
+      ).not.toContain("Page.createIsolatedWorld");
       expect(snapshot.screenshot).toMatchObject({ width: 1280, height: 800 });
     }),
   ).pipe(Effect.provide(layer)),
 
@@ -1279,16 +1279,12 @@ const make = Effect.gen(function* () {
    */
   const snapshotRendering = async (tab: ServerTab) => {
     if (!tab.desktop) return { renderScale: RENDER_SCALE };
-    const page = (await tab.page.evaluate(
-      "({ ratio: devicePixelRatio, width: innerWidth, height: innerHeight })",
-    )) as { readonly ratio: number; readonly width: number; readonly height: number };
-    const { cssVisualViewport } = await tab.cdp.send("Page.getLayoutMetrics");
-    const zoom = cssVisualViewport.zoom ?? 1;
+    const page = await ServerBrowserPage.readPageMetrics(tab.cdp);
     return {
-      renderScale: page.ratio / zoom,
+      renderScale: page.ratio / page.zoom,
       viewport: {
-        width: Math.round(page.width * zoom),
-        height: Math.round(page.height * zoom),
+        width: Math.round(page.width * page.zoom),
+        height: Math.round(page.height * page.zoom),
       },
     };
   };
 
@@ -291,6 +291,32 @@ describe("server browser snapshot size", () => {
     },
   );
 
+  it("reads the page's own ratio and viewport after page script reassigns them", async () => {
+    const browser = await chromium.launch({ headless: true });
+    try {
+      const context = await browser.newContext({
+        viewport: { width: 1280, height: 800 },
+        deviceScaleFactor: 1.5,
+      });
+      const page = await context.newPage();
+      const cdp = await context.newCDPSession(page);
+      await page.setContent(
+        "<script>devicePixelRatio = -1.5; innerHeight = 1e7; innerWidth = 99999;</script>",
+      );
+      expect(await page.evaluate("[devicePixelRatio, innerWidth, innerHeight]")).toEqual([
+        -1.5, 99999, 1e7,
+      ]);
+      expect(await ServerBrowserPage.readPageMetrics(cdp)).toEqual({
+        ratio: 1.5,
+        width: 1280,
+        height: 800,
+        zoom: 1,
+      });
+    } finally {
+      await browser.close();
+    }
+  });
+
   it("reports the captured image's size when the given viewport is a pixel off", async () => {
     const browser = await chromium.launch({
       headless: true,
 
@@ -164,6 +164,34 @@ const pngSize = (base64: string) => {
 /** A page's viewport in device-independent pixels, the units a capture clip is given in. */
 type Viewport = { readonly width: number; readonly height: number };
 
+/**
+ * A page's display ratio and CSS viewport, and its zoom. The ratio and viewport are read in an
+ * isolated world, since page script can reassign `devicePixelRatio`, `innerWidth`, and
+ * `innerHeight` in its own.
+ */
+export const readPageMetrics = async (cdp: CDPSession) => {
+  const { frameTree } = await cdp.send("Page.getFrameTree");
+  const { executionContextId } = await cdp.send("Page.createIsolatedWorld", {
+    frameId: frameTree.frame.id,
+    // Chromium reuses a named world; an unnamed one is created again on each call.
+    worldName: "t3-preview-metrics",
+  });
+  const { result } = await cdp.send("Runtime.evaluate", {
+    expression: "({ ratio: devicePixelRatio, width: innerWidth, height: innerHeight })",
+    contextId: executionContextId,
+    returnByValue: true,
+  });
+  const { cssVisualViewport } = await cdp.send("Page.getLayoutMetrics");
+  return {
+    ...(result.value as {
+      readonly ratio: number;
+      readonly width: number;
+      readonly height: number;
+    }),
+    zoom: cssVisualViewport.zoom ?? 1,
+  };
+};
+
 // Scaled captures repaint live screencasts, so callers pause them. Clips use document offsets.
 export const captureViewport = async (
   page: Page,