fix(engine): reopen a render page whose tab Chrome closed while opening, or say why it can't (#8188)

* test(engine): a capture page whose tab Chrome closed while opening it is replaced once or named

* fix(engine): reopen a render page whose tab Chrome closed while opening, or say why it can't

* style(engine): keep openPage's comment to two lines
This commit is contained in:
Miguel Ángel
2026-11-18 20:14:26 +00:00
committed by GitHub
parent f149d76ed6
commit d205e59487
15 changed files with 284 additions and 12 deletions
@@ -31,6 +31,7 @@ import { enabledAudioFxNodes, type HfAudioFxChain } from "@hyperframes/core/audi
import { serializeAutomation, type HfAutomation } from "@hyperframes/core/audio-automation";
import { removeScratch } from "@hyperframes/core/remove-scratch";
import { acquireBrowser, buildChromeArgs } from "./browserManager.js";
import { openPage } from "./openPage.js";
import { createEnvelopeWalker } from "./audioVolumeEnvelope.js";
import { riffChunks, wavFormatTag } from "./wavChunks.js";
import { windowPrerollSeconds } from "./audioFxWarmup.js";
@@ -653,7 +654,7 @@ async function openFxPage(
browser: Awaited<ReturnType<typeof acquireBrowser>>["browser"],
hostDir: string,
): Promise<FxPage> {
const page = await browser.newPage();
const page = await openPage(browser);
try {
// AudioWorklet is only exposed in a secure context, and about:blank is
// not one — the module would fail with an opaque error. A file:// page
@@ -10,7 +10,9 @@ import {
resolveBrowserGpuMode,
} from "./browserManager.js";
function fakeChrome(newPage = vi.fn().mockResolvedValue({ evaluate: vi.fn() })) {
function fakeChrome(
newPage = vi.fn().mockResolvedValue({ mainFrame: () => ({}), evaluate: vi.fn() }),
) {
const launch = vi.fn(async (_options: LaunchOptions) => ({
connected: true,
newPage,
@@ -15,7 +15,7 @@ vi.mock("./chromeStartup.js", async (importActual) => ({
const chrome = () => ({
connected: true,
newPage: vi.fn().mockResolvedValue({ evaluate: vi.fn() }),
newPage: vi.fn().mockResolvedValue({ mainFrame: () => ({}), evaluate: vi.fn() }),
version: vi.fn().mockResolvedValue("HeadlessChrome/152.0.7977.30"),
close: vi.fn().mockResolvedValue(undefined),
disconnect: vi.fn(),
@@ -28,6 +28,7 @@ function fakeChrome(reachesGpu: (env: NodeJS.ProcessEnv | undefined) => boolean)
const launch = vi.fn(async (options: LaunchOptions) => ({
connected: true,
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
evaluate: vi.fn().mockResolvedValue(reachesGpu(options.env) ? D3D12 : NO_WEBGL),
}),
version: vi.fn().mockResolvedValue("HeadlessChrome/152.0.7977.30"),
@@ -53,6 +53,7 @@ describe("BeginFrame capability probe", () => {
const close = vi.fn().mockResolvedValue(undefined);
const browser = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto,
createCDPSession: vi.fn().mockResolvedValue({ send, detach }),
close,
@@ -79,6 +80,7 @@ describe("BeginFrame capability probe", () => {
const send = vi.fn().mockResolvedValue({ hasDamage: false });
const browser = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto: vi.fn().mockResolvedValue(null),
createCDPSession: vi.fn().mockResolvedValue({
send,
@@ -107,6 +109,7 @@ describe("BeginFrame capability probe", () => {
const send = vi.fn().mockResolvedValue({ screenshotData: jpeg.toString("base64") });
const browser = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto: vi.fn().mockResolvedValue(null),
createCDPSession: vi.fn().mockResolvedValue({
send,
@@ -143,6 +146,7 @@ describe("BeginFrame capability probe", () => {
});
const browser = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto: vi.fn().mockResolvedValue(null),
createCDPSession: vi.fn().mockResolvedValue({
send,
@@ -168,6 +172,7 @@ describe("BeginFrame capability probe", () => {
const close = vi.fn().mockResolvedValue(undefined);
const browser = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto: vi.fn().mockResolvedValue(null),
createCDPSession: vi.fn().mockResolvedValue({
send,
@@ -193,6 +198,7 @@ describe("BeginFrame capability probe", () => {
.mockResolvedValueOnce({ hasDamage: true, screenshotData: png.toString("base64") });
const browser = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto: vi.fn().mockResolvedValue(null),
createCDPSession: vi.fn().mockResolvedValue({
send,
@@ -211,12 +217,14 @@ describe("BeginFrame capability probe", () => {
it("marks a probe that ran out of time as timed out, and a rejection as not", async () => {
const stuck = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto: vi.fn().mockReturnValue(new Promise<never>(() => {})),
close: vi.fn().mockResolvedValue(undefined),
}),
} as unknown as Browser;
const rejecting = {
newPage: vi.fn().mockResolvedValue({
mainFrame: () => ({}),
goto: vi.fn().mockResolvedValue(null),
createCDPSession: vi.fn().mockResolvedValue({
send: vi.fn().mockRejectedValue(new Error("'HeadlessExperimental.enable' wasn't found")),
@@ -716,7 +724,7 @@ describe("resolveBrowserGpuMode", () => {
const close = vi.fn().mockResolvedValue(undefined);
const evaluate = vi.fn().mockResolvedValue(info);
const launch = vi.fn().mockResolvedValue({
newPage: vi.fn().mockResolvedValue({ evaluate }),
newPage: vi.fn().mockResolvedValue({ mainFrame: () => ({}), evaluate }),
close,
});
_setPuppeteerForTests({ launch } as unknown as PuppeteerNode);
@@ -911,7 +919,9 @@ describe("resolveBrowserGpuMode", () => {
spy.mock.calls.map((call) => String(call[0])).join("\n");
const neverAnsweringProbe = () => {
const launch = vi.fn().mockResolvedValue({
newPage: vi.fn().mockResolvedValue({ evaluate: () => new Promise(() => {}) }),
newPage: vi
.fn()
.mockResolvedValue({ mainFrame: () => ({}), evaluate: () => new Promise(() => {}) }),
close: () => new Promise(() => {}),
process: () => ({ kill: vi.fn() }),
disconnect: vi.fn().mockResolvedValue(undefined),
@@ -1069,7 +1079,9 @@ describe("resolveBrowserGpuMode", () => {
try {
const kill = vi.fn();
const launch = vi.fn().mockResolvedValue({
newPage: vi.fn().mockResolvedValue({ evaluate: () => new Promise(() => {}) }),
newPage: vi
.fn()
.mockResolvedValue({ mainFrame: () => ({}), evaluate: () => new Promise(() => {}) }),
close: () => new Promise(() => {}),
process: () => ({ kill }),
disconnect: vi.fn().mockResolvedValue(undefined),
@@ -1986,6 +1998,7 @@ describe.runIf(process.platform === "linux")("BeginFrame launch on a slow first
process: () => ({ kill: vi.fn(), killed: false }),
};
const healthyPage = () => ({
mainFrame: () => ({}),
goto: vi.fn().mockResolvedValue(null),
createCDPSession: vi.fn().mockResolvedValue({
send: vi
@@ -1998,6 +2011,7 @@ describe.runIf(process.platform === "linux")("BeginFrame launch on a slow first
close: vi.fn().mockResolvedValue(undefined),
});
const slowPage = () => ({
mainFrame: () => ({}),
goto: vi.fn().mockReturnValue(new Promise<never>(() => {})),
close: vi.fn().mockResolvedValue(undefined),
});
@@ -18,6 +18,7 @@ import {
} from "./sandboxLaunch.js";
import { scanHtmlOpeningTags } from "@hyperframes/parsers/html-attribute-spans";
import type { Browser, LaunchOptions, Page, PuppeteerNode } from "puppeteer-core";
import { openPage } from "./openPage.js";
import { execFileSync } from "child_process";
import { existsSync, readdirSync } from "fs";
import { join } from "path";
@@ -159,7 +160,7 @@ async function probeHardwareWebGlInfo(
}
async function readWebGlInfo(browser: Browser): Promise<WebGlProbeInfo> {
const page = await browser.newPage();
const page = await openPage(browser);
return await page.evaluate(() => {
const unavailable = { hasWebGL: false, vendor: "", renderer: "" };
const c = document.createElement("canvas");
@@ -429,7 +430,7 @@ async function probeBeginFrameSupport(
let page;
let result: BeginFrameProbeResult;
try {
page = await awaitBeforeDeadline(browser.newPage(), deadline, "newPage");
page = await awaitBeforeDeadline(openPage(browser), deadline, "newPage");
// `browser.newPage()` resolves before a cold renderer has necessarily
// submitted its first surface. Cloud Run exposed this as a false
// "unsupported Chromium" result: probing the untouched about:blank
@@ -0,0 +1,96 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createCaptureSession } from "./frameCapture.js";
const chrome = vi.hoisted(() => ({ connected: true, tabsLost: 0, opened: [] as object[] }));
/** A page whose tab Chrome closed during setup: puppeteer resolves it, then every call throws. */
const lostTab = () => ({
mainFrame: () => {
throw new Error("Requesting main frame too early!");
},
close: vi.fn(async () => {}),
});
const liveTab = () => ({
mainFrame: () => ({}),
close: vi.fn(async () => {}),
on: () => {},
goto: async () => null,
createCDPSession: async () => ({ on: () => {}, send: async () => ({}) }),
evaluateOnNewDocument: async () => {},
setViewport: async () => {},
evaluate: async () => undefined,
});
vi.mock("./browserManager.js", async (importOriginal) => ({
...(await importOriginal<typeof import("./browserManager.js")>()),
resolveBrowserGpuMode: async () => "hardware",
acquireBrowser: async () => ({
captureMode: "screenshot",
release: async () => {},
forceRelease: () => {},
browser: {
get connected() {
return chrome.connected;
},
process: () => ({ exitCode: chrome.connected ? null : 9, signalCode: null }),
version: async () => "Chrome/150.0.0.0",
newPage: async () => {
const page = chrome.opened.length < chrome.tabsLost ? lostTab() : liveTab();
chrome.opened.push(page);
return page;
},
},
}),
}));
const dirs: string[] = [];
afterEach(() => {
Object.assign(chrome, { connected: true, tabsLost: 0, opened: [] });
for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
});
function session() {
const dir = mkdtempSync(join(tmpdir(), "hf-tab-lost-"));
dirs.push(dir);
return createCaptureSession(
"http://localhost:0",
dir,
{ width: 640, height: 360, fps: { num: 30, den: 1 }, format: "jpeg" },
null,
{ forceScreenshot: true },
);
}
describe("a capture page whose tab Chrome closed while opening it", () => {
// fails without the fix: the session used the dead page and threw "Requesting main frame too early!".
it("captures on one more page while the browser still runs", async () => {
chrome.tabsLost = 1;
const created = await session();
expect(created.page).toBe(chrome.opened[1]);
expect(vi.mocked((chrome.opened[0] as { close(): Promise<void> }).close)).toHaveBeenCalled();
});
it("says the browser is still running when the second tab is lost too", async () => {
chrome.tabsLost = 2;
await expect(session()).rejects.toThrow(
"Chrome closed the render page's tab while opening it, twice; the browser is still running",
);
expect(chrome.opened).toHaveLength(2);
});
it("says Chrome exited, with its exit code, and opens nothing more", async () => {
chrome.tabsLost = 1;
chrome.connected = false;
await expect(session()).rejects.toThrow(
"Chrome exited while opening a render page (exit code 9, signal none)",
);
expect(chrome.opened).toHaveLength(1);
});
});
@@ -4,6 +4,7 @@ import { createStaticVerificationPage, type CaptureSession } from "./frameCaptur
describe("createStaticVerificationPage", () => {
it("uses a fresh, ready page so verification seeks cannot affect capture", async () => {
const verificationPage = {
mainFrame: () => ({}),
evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
setViewport: vi.fn().mockResolvedValue(undefined),
goto: vi.fn().mockResolvedValue(undefined),
@@ -37,6 +38,7 @@ describe("createStaticVerificationPage", () => {
it("closes a failed verification page before static dedup fails closed", async () => {
const verificationPage = {
mainFrame: () => ({}),
evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
setViewport: vi.fn().mockRejectedValue(new Error("viewport failed")),
close: vi.fn().mockResolvedValue(undefined),
@@ -62,6 +64,7 @@ describe("createStaticVerificationPage", () => {
const document = { querySelectorAll: () => [host("main"), host("badge")] };
const window = { __timelines: { main: {} } };
const verificationPage = {
mainFrame: () => ({}),
evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
setViewport: vi.fn().mockResolvedValue(undefined),
goto: vi.fn().mockResolvedValue(undefined),
@@ -5,6 +5,7 @@ describe("createStaticVerificationPage background", () => {
function makeSession(options: Record<string, unknown>) {
const send = vi.fn().mockResolvedValue(undefined);
const verificationPage = {
mainFrame: () => ({}),
evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
setViewport: vi.fn().mockResolvedValue(undefined),
goto: vi.fn().mockResolvedValue(undefined),
@@ -10,6 +10,7 @@ type Registered = { fn: (...args: unknown[]) => void; args: unknown[] };
function recordingSession(skipReadinessVideoIds: string[]) {
const registered: Registered[] = [];
const page = {
mainFrame: () => ({}),
evaluateOnNewDocument: async (fn: Registered["fn"], ...args: unknown[]) => {
registered.push({ fn, args });
},
+3 -2
View File
@@ -73,6 +73,7 @@ import {
type BrowserLease,
type CaptureMode,
} from "./browserManager.js";
import { openPage } from "./openPage.js";
import {
beginFrameCapture,
forgetBeginFrameCapture,
@@ -1684,7 +1685,7 @@ async function constructCaptureSession(
} = input;
const { browser, captureMode } = browserLease;
const page = await browser.newPage();
const page = await openPage(browser);
onPageCreated(page);
// Cap the existing session's inspection buffer; new sessions have separate buffers.
const frame = page.mainFrame();
@@ -4239,7 +4240,7 @@ interface StaticVerificationDependencies {
* are contained to this disposable page and cannot corrupt sequential capture.
*/
export async function createStaticVerificationPage(session: CaptureSession): Promise<Page> {
const page = await session.browser.newPage();
const page = await openPage(session.browser);
const pageNavigationTimeout =
session.config?.pageNavigationTimeout ?? DEFAULT_CONFIG.pageNavigationTimeout;
const pageReadyTimeout = session.config?.playerReadyTimeout ?? DEFAULT_CONFIG.playerReadyTimeout;
@@ -4,7 +4,7 @@ import { expect, it, vi } from "vitest";
const launch = vi.hoisted(() =>
vi.fn(async (_options: LaunchOptions) => ({
newPage: async () => ({ setViewport: async () => undefined }),
newPage: async () => ({ mainFrame: () => ({}), setViewport: async () => undefined }),
})),
);
vi.mock("puppeteer", () => ({ default: { launch } }));
+2 -1
View File
@@ -23,6 +23,7 @@ import { withHyperframesBrowserMarker } from "@hyperframes/core/browser-marker";
import { buildChromeLaunchEnv } from "@hyperframes/core/chrome-env";
import type { Page, Browser, PuppeteerNode } from "puppeteer-core";
import { resolveFullChromePath, ownedLaunchOptions } from "./browserManager.js";
import { openPage } from "./openPage.js";
import {
chromeSandboxArgs,
chromeSandboxEnabled,
@@ -263,7 +264,7 @@ export async function launchHdrBrowser(
}),
);
const page = await browser.newPage();
const page = await openPage(browser);
await page.setViewport({ width, height });
return { browser, page };
@@ -0,0 +1,113 @@
import { EventEmitter } from "node:events";
import { describe, expect, it, vi } from "vitest";
import type { Browser, Page } from "puppeteer-core";
import { CdpPage } from "puppeteer-core/internal/cdp/Page.js";
import { TargetCloseError } from "puppeteer-core/internal/common/Errors.js";
import { openPage, PageTabLostError } from "./openPage.js";
/** A CDP session for a new tab; `closedDuringSetup` makes Page.getFrameTree fail as Chrome does when the tab closes. */
function tabSession(closedDuringSetup: boolean) {
const target = {
_targetId: "T",
_targetManager: () => Object.assign(new EventEmitter(), { getChildTargets: () => [] }),
_getTargetInfo: () => ({ targetId: "T", type: "page", url: "about:blank" }),
_isClosedDeferred: { valueOrThrow: () => new Promise(() => {}) },
browser: () => browserStub,
};
const session = Object.assign(new EventEmitter(), {
id: () => "S",
target: () => target,
connection: () => ({ on() {}, off() {} }),
parentSession: () =>
Object.assign(new EventEmitter(), { target: () => target, send: async () => ({}) }),
send: async (method: string) => {
if (method !== "Page.getFrameTree") return {};
if (closedDuringSetup)
throw new TargetCloseError("Protocol error (Page.getFrameTree): Target closed");
return {
frameTree: { frame: { id: "T", loaderId: "L", url: "about:blank" }, childFrames: [] },
};
},
});
return { session, target };
}
const browserStub = { isNetworkEnabled: () => true, isIssuesEnabled: () => false };
/** A real puppeteer page for a tab that either closes during setup or comes up normally. */
async function cdpPage(closedDuringSetup: boolean): Promise<Page> {
const { session, target } = tabSession(closedDuringSetup);
return (await CdpPage._create(session as never, target as never, null, () => undefined)) as Page;
}
function browserWith(
pages: Array<() => Promise<Page>>,
state: { connected: boolean; exitCode?: number },
) {
const opened: Page[] = [];
const browser = {
get connected() {
return state.connected;
},
process: () => ({ exitCode: state.exitCode ?? null, signalCode: null, pid: 1 }),
newPage: vi.fn(async () => {
const page = await pages[opened.length]!();
vi.spyOn(page, "close").mockResolvedValue();
opened.push(page);
return page;
}),
};
return { browser: browser as unknown as Browser, opened };
}
describe("openPage", () => {
it("puppeteer resolves a tab that closed during setup with no main frame", async () => {
const page = await cdpPage(true);
expect(() => page.mainFrame()).toThrow("Requesting main frame too early!");
});
it("opens one more page when the first tab closed during setup and the browser still runs", async () => {
const { browser, opened } = browserWith([() => cdpPage(true), () => cdpPage(false)], {
connected: true,
});
const page = await openPage(browser);
expect(page).toBe(opened[1]);
expect(page.mainFrame().url()).toBe("about:blank");
expect(opened[0]!.close).toHaveBeenCalled();
});
it("names a tab that closed twice while the browser still runs", async () => {
const { browser, opened } = browserWith([() => cdpPage(true), () => cdpPage(true)], {
connected: true,
});
const error = await openPage(browser).catch((e: unknown) => e);
expect(error).toBeInstanceOf(PageTabLostError);
expect((error as PageTabLostError).browserRunning).toBe(true);
expect((error as Error).message).toContain("the browser is still running");
expect(opened.every((page) => vi.mocked(page.close).mock.calls.length === 1)).toBe(true);
});
it("never opens another page in a browser that exited, and names its exit code", async () => {
const state = { connected: true, exitCode: undefined as number | undefined };
const { browser } = browserWith(
[
async () => {
Object.assign(state, { connected: false, exitCode: 137 });
return cdpPage(true);
},
],
state,
);
const error = await openPage(browser).catch((e: unknown) => e);
expect((error as Error).message).toBe(
"Chrome exited while opening a render page (exit code 137, signal none)",
);
expect((error as PageTabLostError).browserRunning).toBe(false);
expect(browser.newPage).toHaveBeenCalledTimes(1);
});
});
+37
View File
@@ -0,0 +1,37 @@
import type { Browser, Page } from "puppeteer-core";
/** Chrome lost a render page's tab while opening it, so the page has no main frame to use. */
export class PageTabLostError extends Error {
readonly browserRunning: boolean;
constructor(browser: Browser) {
const child = browser.process();
super(
browser.connected
? "Chrome closed the render page's tab while opening it, twice; the browser is still running"
: `Chrome exited while opening a render page (exit code ${child?.exitCode ?? "unknown"}, signal ${child?.signalCode ?? "none"})`,
);
this.name = "PageTabLostError";
this.browserRunning = browser.connected;
}
}
async function newLivePage(browser: Browser): Promise<Page | undefined> {
const page = await browser.newPage();
try {
page.mainFrame();
return page;
} catch {
await page.close().catch(() => {});
return undefined;
}
}
// `browser.newPage()`, minus the page puppeteer resolves when its tab closed during setup (no main frame).
// One more page only while the browser runs; a browser that is gone is reported, never retried.
export async function openPage(browser: Browser): Promise<Page> {
const page =
(await newLivePage(browser)) ?? (browser.connected ? await newLivePage(browser) : undefined);
if (page) return page;
throw new PageTabLostError(browser);
}