diff --git a/packages/engine/src/services/audioFxRender.ts b/packages/engine/src/services/audioFxRender.ts index 7fe41c35df..e830845d41 100644 --- a/packages/engine/src/services/audioFxRender.ts +++ b/packages/engine/src/services/audioFxRender.ts @@ -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>["browser"], hostDir: string, ): Promise { - 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 diff --git a/packages/engine/src/services/browserManager-ownerMarker.test.ts b/packages/engine/src/services/browserManager-ownerMarker.test.ts index e8732c2ce8..68a6c577c0 100644 --- a/packages/engine/src/services/browserManager-ownerMarker.test.ts +++ b/packages/engine/src/services/browserManager-ownerMarker.test.ts @@ -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, diff --git a/packages/engine/src/services/browserManager-seatbelt.test.ts b/packages/engine/src/services/browserManager-seatbelt.test.ts index 1ebb8f4c23..ba60a596d9 100644 --- a/packages/engine/src/services/browserManager-seatbelt.test.ts +++ b/packages/engine/src/services/browserManager-seatbelt.test.ts @@ -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(), diff --git a/packages/engine/src/services/browserManager-wslEnv.test.ts b/packages/engine/src/services/browserManager-wslEnv.test.ts index 2873d727fe..cf95fffaf4 100644 --- a/packages/engine/src/services/browserManager-wslEnv.test.ts +++ b/packages/engine/src/services/browserManager-wslEnv.test.ts @@ -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"), diff --git a/packages/engine/src/services/browserManager.test.ts b/packages/engine/src/services/browserManager.test.ts index 3500c07049..500b0b683d 100644 --- a/packages/engine/src/services/browserManager.test.ts +++ b/packages/engine/src/services/browserManager.test.ts @@ -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(() => {})), 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(() => {})), close: vi.fn().mockResolvedValue(undefined), }); diff --git a/packages/engine/src/services/browserManager.ts b/packages/engine/src/services/browserManager.ts index 3689c93720..9d986963f3 100644 --- a/packages/engine/src/services/browserManager.ts +++ b/packages/engine/src/services/browserManager.ts @@ -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 { - 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 diff --git a/packages/engine/src/services/frameCapture-pageTabLost.test.ts b/packages/engine/src/services/frameCapture-pageTabLost.test.ts new file mode 100644 index 0000000000..0e825ddf4b --- /dev/null +++ b/packages/engine/src/services/frameCapture-pageTabLost.test.ts @@ -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()), + 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 }).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); + }); +}); diff --git a/packages/engine/src/services/frameCapture-staticDedupVerificationPage.test.ts b/packages/engine/src/services/frameCapture-staticDedupVerificationPage.test.ts index be87ce55d4..0be6593b21 100644 --- a/packages/engine/src/services/frameCapture-staticDedupVerificationPage.test.ts +++ b/packages/engine/src/services/frameCapture-staticDedupVerificationPage.test.ts @@ -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), diff --git a/packages/engine/src/services/frameCapture-verificationBackground.test.ts b/packages/engine/src/services/frameCapture-verificationBackground.test.ts index e6f98d6db3..3aac124b3a 100644 --- a/packages/engine/src/services/frameCapture-verificationBackground.test.ts +++ b/packages/engine/src/services/frameCapture-verificationBackground.test.ts @@ -5,6 +5,7 @@ describe("createStaticVerificationPage background", () => { function makeSession(options: Record) { const send = vi.fn().mockResolvedValue(undefined); const verificationPage = { + mainFrame: () => ({}), evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined), setViewport: vi.fn().mockResolvedValue(undefined), goto: vi.fn().mockResolvedValue(undefined), diff --git a/packages/engine/src/services/frameCapture-verificationPage.test.ts b/packages/engine/src/services/frameCapture-verificationPage.test.ts index 316d8047a1..c12f7d52ab 100644 --- a/packages/engine/src/services/frameCapture-verificationPage.test.ts +++ b/packages/engine/src/services/frameCapture-verificationPage.test.ts @@ -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 }); }, diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts index d792d14475..742ec7d8cb 100644 --- a/packages/engine/src/services/frameCapture.ts +++ b/packages/engine/src/services/frameCapture.ts @@ -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 { - 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; diff --git a/packages/engine/src/services/hdrCapture-ownerMarker.test.ts b/packages/engine/src/services/hdrCapture-ownerMarker.test.ts index 1ecd70c311..659f921754 100644 --- a/packages/engine/src/services/hdrCapture-ownerMarker.test.ts +++ b/packages/engine/src/services/hdrCapture-ownerMarker.test.ts @@ -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 } })); diff --git a/packages/engine/src/services/hdrCapture.ts b/packages/engine/src/services/hdrCapture.ts index ea6597b360..7daca4f4c5 100644 --- a/packages/engine/src/services/hdrCapture.ts +++ b/packages/engine/src/services/hdrCapture.ts @@ -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 }; diff --git a/packages/engine/src/services/openPage.test.ts b/packages/engine/src/services/openPage.test.ts new file mode 100644 index 0000000000..d721d10f70 --- /dev/null +++ b/packages/engine/src/services/openPage.test.ts @@ -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 { + const { session, target } = tabSession(closedDuringSetup); + return (await CdpPage._create(session as never, target as never, null, () => undefined)) as Page; +} + +function browserWith( + pages: Array<() => Promise>, + 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); + }); +}); diff --git a/packages/engine/src/services/openPage.ts b/packages/engine/src/services/openPage.ts new file mode 100644 index 0000000000..6cc23d51d7 --- /dev/null +++ b/packages/engine/src/services/openPage.ts @@ -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 { + 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 { + const page = + (await newLivePage(browser)) ?? (browser.connected ? await newLivePage(browser) : undefined); + if (page) return page; + throw new PageTabLostError(browser); +}