single-file-cli 2.0.83 → 2.1.1

package/lib/browser.js

@@ -21,18 +21,20 @@
  *   Source.
  */
 
-/* global fetch */
+/* global fetch, setTimeout */
 
 import { BROWSER_PATHS, BROWSER_ARGS } from "./constants.js";
 import { Deno } from "./deno-polyfill.js";
 
-const PIPED_STD_CONFIG = "piped";
+const NULL_STD_CONFIG = "null";
 const DEBUG_PORT_MIN = 9222;
 const DEBUG_PORT_RANGE = 256;
+const READY_TIMEOUT = 30000;
+const READY_RETRY_DELAY = 250;
 
 const { build, makeTempDir, Command, errors, remove } = Deno;
-let child, profilePath;
-export { launchBrowser, closeBrowser };
+let child, profilePath, childExited;
+export { launchBrowser, closeBrowser, browserExited };
 
 async function launchBrowser(options = {}, indexPath = 0) {
 	const executablePath = options.executablePath || BROWSER_PATHS[build.os][indexPath];
@@ -58,7 +60,9 @@ async function launchBrowser(options = {}, indexPath = 0) {
 		args.push("--proxy-server=" + options.httpProxyServer);
 	}
 	args.push("--user-data-dir=" + profilePath);
-	args.push("--single-process");
+	if (options.singleProcess) {
+		args.push("--single-process");
+	}
 	if (options.args) {
 		const argNames = options.args.map(arg => arg.split("=")[0]);
 		args = args.filter(arg => !argNames.includes(arg.split("=")[0]));
@@ -70,24 +74,59 @@ async function launchBrowser(options = {}, indexPath = 0) {
 		!args.includes("--headless")) {
 		args.push("--disable-site-isolation-trials");
 	}
-	const command = new Command(executablePath, { args, stdout: PIPED_STD_CONFIG, stderr: PIPED_STD_CONFIG });
+	const command = new Command(executablePath, { args, stdout: NULL_STD_CONFIG, stderr: NULL_STD_CONFIG });
 	try {
 		child = await command.spawn();
 	} catch (error) {
-		if (error instanceof errors.NotFound) {
-			if (indexPath + 1 < BROWSER_PATHS[build.os].length) {
-				return launchBrowser(options, indexPath + 1);
-			} else {
-				throw error;
-			}
-		} else {
-			throw error;
+		await remove(profilePath, { recursive: true }).catch(() => { });
+		profilePath = undefined;
+		if (error instanceof errors.NotFound && indexPath + 1 < BROWSER_PATHS[build.os].length) {
+			return launchBrowser(options, indexPath + 1);
 		}
+		throw error;
 	}
 	child.ref();
+	childExited = false;
+	child.status.then(() => childExited = true);
+	try {
+		await waitUntilReady(debugPort);
+	} catch (error) {
+		await closeBrowser();
+		if (options.singleProcess) {
+			console.warn("Warning: the browser exited when using --browser-single-process, retrying without it"); // eslint-disable-line no-console
+			return launchBrowser(Object.assign({}, options, { singleProcess: false }), indexPath);
+		}
+		throw error;
+	}
 	return debugPort;
 }
 
+async function waitUntilReady(debugPort) {
+	const timeoutTime = Date.now() + READY_TIMEOUT;
+	while (!childExited && Date.now() < timeoutTime) {
+		try {
+			await fetch("http://localhost:" + debugPort + "/json/version");
+			return;
+		} catch {
+			await new Promise(resolve => setTimeout(resolve, READY_RETRY_DELAY));
+		}
+	}
+	throw new Error(childExited ? "The browser exited unexpectedly" : "The browser is not responding");
+}
+
+async function browserExited(maxDelay = 0) {
+	if (child === undefined) {
+		return false;
+	}
+	if (childExited || !maxDelay) {
+		return childExited;
+	}
+	return Promise.race([
+		child.status.then(() => true),
+		new Promise(resolve => setTimeout(() => resolve(childExited), maxDelay))
+	]);
+}
+
 async function getDebugPort(port = getRandomDebugPort(), usedPorts = []) {
 	try {
 		await fetch("http://localhost:" + port + "/json/version");
@@ -112,7 +151,11 @@ function getRandomDebugPort() {
 
 async function closeBrowser() {
 	if (child !== undefined) {
-		child.kill();
+		try {
+			child.kill();
+		} catch {
+			// ignored
+		}
 		await child.status;
 		child = undefined;
 	}

package/lib/cdp-client-util.js

@@ -21,9 +21,10 @@
  *   Source.
  */
 
-/* global setTimeout, clearTimeout, fetch, URL, Headers, btoa */
+/* global setTimeout, clearTimeout, fetch, URL, Headers */
 
-import { Deno, isDeno } from "./deno-polyfill.js";
+import { Buffer } from "node:buffer";
+import { Deno, isDeno, path } from "./deno-polyfill.js";
 
 const ABORT_EVENT = "abort";
 
@@ -42,10 +43,9 @@ async function fetchWithFileSupport(url, fetchOptions = {}) {
 	if (isDeno) {
 		return await fetch(url, fetchOptions);
 	}
-	const filePath = decodeURIComponent(url.replace(/^file:\/\//, ""));
 	const { readFile } = Deno;
 	try {
-		const fileData = await readFile(filePath);
+		const fileData = await readFile(await path.fromFileUrl(url));
 		return createFileResponse(fileData, 200);
 	} catch {
 		return createFileResponse(new ArrayBuffer(0), 404);
@@ -59,7 +59,7 @@ async function fetchWithFileSupport(url, fetchOptions = {}) {
 				"content-type": isError ? "text/plain" : "application/octet-stream",
 				"content-length": data.length ? data.length.toString() : "0"
 			}),
-			arrayBuffer: async () => data.buffer || data
+			arrayBuffer: () => data.buffer || data
 		};
 	}
 }
@@ -83,7 +83,7 @@ function waitForTimeout(abortSignal, maxDelay, errorMessage, errorCode) {
 }
 
 function arrayBufferToBase64(arrayBuffer) {
-	return btoa(String.fromCharCode.apply(null, new Uint8Array(arrayBuffer)));
+	return Buffer.from(arrayBuffer).toString("base64");
 }
 
 function getAlternativeUrl(url) {

package/lib/cdp-client.js

@@ -25,7 +25,8 @@
 
 import {
 	launchBrowser,
-	closeBrowser
+	closeBrowser,
+	browserExited
 } from "./browser.js";
 import {
 	CDP,
@@ -57,6 +58,10 @@ const SET_SCREENSHOT_FUNCTION_NAME = "setScreenshot";
 const SET_PDF_FUNCTION_NAME = "setPDF";
 const SET_PAGE_DATA_FUNCTION_NAME = "setPageData";
 const BINDING_CALLED_EVENT_TYPE = "bindingCalled";
+const LOCALHOST = "http://localhost:";
+const BROWSER_EXITED_MAX_DELAY = 2000;
+
+let browserOptions, relaunchBrowserPromise;
 
 export {
 	initialize,
@@ -68,12 +73,12 @@ async function initialize(singleFileOptions) {
 	if (singleFileOptions.browserServer) {
 		options.apiUrl = singleFileOptions.browserServer;
 	} else {
-		const LOCALHOST = "http://localhost:";
-		const browserOptions = {};
+		browserOptions = {};
 		browserOptions.args = singleFileOptions.browserArgs;
 		browserOptions.headless = singleFileOptions.browserHeadless;
 		browserOptions.executablePath = singleFileOptions.browserExecutablePath;
 		browserOptions.debug = singleFileOptions.browserDebug;
+		browserOptions.singleProcess = singleFileOptions.browserSingleProcess;
 		browserOptions.disableWebSecurity = singleFileOptions.browserDisableWebSecurity;
 		browserOptions.width = singleFileOptions.browserWidth;
 		browserOptions.height = singleFileOptions.browserHeight;
@@ -83,14 +88,26 @@ async function initialize(singleFileOptions) {
 	}
 }
 
+function relaunchBrowser() {
+	if (!relaunchBrowserPromise) {
+		console.warn("Warning: the browser exited when using --browser-single-process, retrying without it"); // eslint-disable-line no-console
+		relaunchBrowserPromise = (async () => {
+			await closeBrowser();
+			browserOptions.singleProcess = false;
+			options.apiUrl = LOCALHOST + (await launchBrowser(browserOptions));
+		})();
+	}
+	return relaunchBrowserPromise;
+}
+
 async function getPageData(options) {
 	const EMPTY_PAGE_URL = "about:blank";
 	const pageContext = { options, consoleMessages: [], debugMessages: [], httpInfo: {} };
-	let targetInfo;
+	let targetInfo, cdp;
 	try {
 		logData(["Loading page", EMPTY_PAGE_URL], pageContext);
 		targetInfo = await CDP.createTarget(EMPTY_PAGE_URL);
-		const cdp = new CDP(targetInfo);
+		cdp = new CDP(targetInfo);
 		await setupConsoleLogging(cdp, pageContext);
 		await setupBrowserWindow(cdp, targetInfo.id, pageContext);
 		await setupSecurity(cdp, pageContext);
@@ -107,6 +124,9 @@ async function getPageData(options) {
 		if (shouldRetryWithFallback(error)) {
 			return await retryWithFallback();
 		}
+		if (await shouldRelaunchBrowser()) {
+			return await relaunchBrowserAndRetry();
+		}
 		attachDebugInfo(error, pageContext);
 		throw error;
 	} finally {
@@ -130,11 +150,36 @@ async function getPageData(options) {
 		return await getPageData(options);
 	}
 
+	async function shouldRelaunchBrowser() {
+		return Boolean(browserOptions && browserOptions.singleProcess) && await browserExited(BROWSER_EXITED_MAX_DELAY);
+	}
+
+	async function relaunchBrowserAndRetry() {
+		logData(["Relaunching the browser"], pageContext);
+		targetInfo = null;
+		if (cdp) {
+			cdp.reset();
+			cdp = null;
+		}
+		await relaunchBrowser();
+		return await getPageData(options);
+	}
+
 	async function closeTarget() {
 		if (targetInfo && !options.browserDebug) {
-			await CDP.closeTarget(targetInfo.id);
+			try {
+				await CDP.closeTarget(targetInfo.id);
+			} catch {
+				// ignored
+			}
 			targetInfo = null;
 		}
+		// the connection is closed even when the target is left open for
+		// debugging, otherwise it stays open until the process exits
+		if (cdp) {
+			cdp.reset();
+			cdp = null;
+		}
 	}
 }
 
@@ -243,7 +288,7 @@ async function setupNetworkInterception({ Browser, Emulation, Fetch, Network },
 function setupProxyAuth({ Fetch }, { options, debugMessages }) {
 	const AUTH_REQUIRED_EVENT_TYPE = "authRequired";
 	const PROVIDE_CREDENTIALS_RESPONSE = "ProvideCredentials";
-	Fetch.addEventListener(AUTH_REQUIRED_EVENT_TYPE, async ({ params }) => {
+	Fetch.addEventListener(AUTH_REQUIRED_EVENT_TYPE, ignoringErrors(async ({ params }) => {
 		logData(["Authenticating"], { options, debugMessages });
 		await Fetch.continueWithAuth({
 			requestId: params.requestId,
@@ -253,17 +298,28 @@ function setupProxyAuth({ Fetch }, { options, debugMessages }) {
 				password: options.httpProxyPassword
 			}
 		});
-	});
+	}, { options, debugMessages }));
 }
 
 function setupRequestInterception({ Fetch }, { options, debugMessages, httpInfo }) {
 	const REQUEST_PAUSED_EVENT_TYPE = "requestPaused";
 	const ABORTED_ERROR_REASON = "Aborted";
 	const urlState = { url: options.url, alternativeUrl: getAlternativeUrl(options.url) };
-	Fetch.addEventListener(REQUEST_PAUSED_EVENT_TYPE, async ({ params }) => {
+	// compiled here so that an invalid pattern is reported before the page is
+	// loaded, instead of throwing for every request that is intercepted
+	const blockedURLPatterns = (options.blockedURLPatterns || []).map(pattern => new RegExp(pattern));
+	Fetch.addEventListener(REQUEST_PAUSED_EVENT_TYPE, ignoringErrors(async ({ params }) => {
 		const { requestId, request } = params;
-		captureHttpInfo(params, urlState, { options, debugMessages, httpInfo });
-		if (shouldBlockRequest(request.url)) {
+		// the request is always resumed below, otherwise the page waits for it
+		// until the load timeout expires
+		let blocked = false;
+		try {
+			captureHttpInfo(params, urlState, { options, debugMessages, httpInfo });
+			blocked = shouldBlockRequest(request.url);
+		} catch (error) {
+			logData(["Ignoring request interception error", error.message], { options, debugMessages });
+		}
+		if (blocked) {
 			try {
 				await Fetch.failRequest({ requestId, errorReason: ABORTED_ERROR_REASON });
 				return;
@@ -276,15 +332,10 @@ function setupRequestInterception({ Fetch }, { options, debugMessages, httpInfo
 		} catch {
 			// ignored
 		}
-	});
+	}, { options, debugMessages }));
 
 	function shouldBlockRequest(requestUrl) {
-		if (!options.blockedURLPatterns || !options.blockedURLPatterns.length) {
-			return false;
-		}
-		const blockedURL = options.blockedURLPatterns.find(pattern =>
-			new RegExp(pattern).test(requestUrl)
-		);
+		const blockedURL = blockedURLPatterns.some(pattern => pattern.test(requestUrl));
 		if (blockedURL) {
 			logData(["Blocking request", requestUrl], { options, debugMessages });
 			return true;
@@ -336,13 +387,14 @@ async function setupHttpHeaders({ Network }, { options, debugMessages }) {
 }
 
 async function setupMediaFeatures({ Emulation }, { options, debugMessages }) {
+	const features = [];
 	for (const mediaFeature of options.emulateMediaFeatures) {
 		logData(["Emulating media feature", mediaFeature.name, mediaFeature.value], { options, debugMessages });
-		await Emulation.setEmulatedMedia({
-			media: mediaFeature.name,
-			features: mediaFeature.value.split(",").map(feature => feature.trim())
-		});
+		for (const value of mediaFeature.value.split(",")) {
+			features.push({ name: mediaFeature.name, value: value.trim() });
+		}
 	}
+	await Emulation.setEmulatedMedia({ features });
 }
 
 async function setupCookies({ Network }, { options, debugMessages }) {
@@ -387,12 +439,19 @@ async function loadPage({ Page, Runtime }, { options, debugMessages }) {
 	const LOAD_TIMEOUT_ERROR_MESSAGE = "Load timeout";
 	await Runtime.enable();
 	await Page.enable();
+	await Page.setLifecycleEventsEnabled({ enabled: true });
+	// the ID of the top frame is stable, and it is read before the navigation is
+	// triggered so that no event is missed while the browser answers
+	const { frameTree } = await Page.getFrameTree();
 	const loadTimeoutAbortController = new AbortController();
 	const loadTimeoutAbortSignal = loadTimeoutAbortController.signal;
 	try {
 		logData(["Loading page", options.url], { options, debugMessages });
 		const [contextId] = await Promise.race([
-			Promise.all([getTopFrameContextId({ Page, Runtime }, { options, debugMessages }), Page.navigate({ url: options.url })]),
+			Promise.all([
+				getTopFrameContextId({ Page, Runtime }, frameTree.frame.id, { options, debugMessages }),
+				Page.navigate({ url: options.url })
+			]),
 			waitForTimeout(loadTimeoutAbortSignal, options.browserLoadMaxTime, LOAD_TIMEOUT_ERROR_MESSAGE, LOAD_TIMEOUT_ERROR)
 		]);
 		return contextId;
@@ -400,35 +459,17 @@ async function loadPage({ Page, Runtime }, { options, debugMessages }) {
 		if (!loadTimeoutAbortSignal.aborted) {
 			loadTimeoutAbortController.abort();
 		}
+		await Page.setLifecycleEventsEnabled({ enabled: false });
 		await Runtime.disable();
 		await Page.disable();
 	}
 }
 
-async function getTopFrameContextId({ Page, Runtime }, { options, debugMessages }) {
-	await Page.setLifecycleEventsEnabled({ enabled: true });
-	const state = { topFrameId: undefined, contextIds: [] };
-	const removeContextListener = setupContextCreatedListener({ Runtime }, state);
-	try {
-		await waitForPageReadyState({ Page }, state, { options, debugMessages });
-		const contextId = await findValidSingleFileContext({ Runtime }, state.contextIds, { options, debugMessages });
-		return contextId;
-	} finally {
-		removeContextListener();
-		await Page.setLifecycleEventsEnabled({ enabled: false });
-	}
-}
-
-function setupContextCreatedListener({ Runtime }, state) {
-	const EXECUTION_CONTEXT_CREATED_EVENT_TYPE = "executionContextCreated";
-	const onContextCreated = ({ params }) => {
-		const { context } = params;
-		if (context.name === SINGLE_FILE_WORLD_NAME && context.auxData?.frameId === state.topFrameId) {
-			state.contextIds.push(context.id);
-		}
-	};
-	Runtime.addEventListener(EXECUTION_CONTEXT_CREATED_EVENT_TYPE, onContextCreated);
-	return () => Runtime.removeEventListener(EXECUTION_CONTEXT_CREATED_EVENT_TYPE, onContextCreated);
+// the listeners are registered synchronously, before the navigation triggered
+// in parallel by the caller can produce any event
+async function getTopFrameContextId({ Page, Runtime }, topFrameId, { options, debugMessages }) {
+	await waitForPageReadyState({ Page }, { topFrameId }, { options, debugMessages });
+	return await getSingleFileContext({ Page, Runtime }, topFrameId, { options, debugMessages });
 }
 
 async function waitForPageReadyState({ Page }, state, { options, debugMessages }) {
@@ -441,7 +482,7 @@ async function waitForPageReadyState({ Page }, state, { options, debugMessages }
 			Page.removeEventListener(FRAME_NAVIGATED_EVENT_TYPE, onFrameNavigated);
 		};
 		const onLifecycleEvent = createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { options, debugMessages });
-		const onFrameNavigated = createFrameNavigatedHandler(state, timeoutState, reject, cleanup, { options, debugMessages });
+		const onFrameNavigated = createFrameNavigatedHandler(timeoutState, reject, cleanup, { options, debugMessages });
 		Page.addEventListener(LIFE_CYCLE_EVENT_TYPE, onLifecycleEvent);
 		Page.addEventListener(FRAME_NAVIGATED_EVENT_TYPE, onFrameNavigated);
 	});
@@ -453,12 +494,15 @@ function createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { op
 		if (frameId === state.topFrameId) {
 			logData(["Detecting lifecycle event", name], { options, debugMessages });
 		}
-		const shouldResolve = name === options.browserWaitUntil ||
-			(timeoutState.timeoutId && NETWORK_STATES.indexOf(name) < NETWORK_STATES.indexOf(options.browserWaitUntil));
+		const shouldResolve = frameId === state.topFrameId &&
+			(name === options.browserWaitUntil ||
+				(timeoutState.timeoutId && NETWORK_STATES.indexOf(name) < NETWORK_STATES.indexOf(options.browserWaitUntil)));
 		if (shouldResolve) {
+			// the delay is restarted when the page reaches a further state, so
+			// that it is captured once it stopped settling
 			clearTimeout(timeoutState.timeoutId);
 			logData([`Waiting ${options.browserWaitUntilDelay} ms`], { options, debugMessages });
-			setTimeout(() => {
+			timeoutState.timeoutId = setTimeout(() => {
 				logData(["Detecting page ready"], { options, debugMessages });
 				cleanup();
 				resolve();
@@ -467,49 +511,43 @@ function createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { op
 	};
 };
 
-function createFrameNavigatedHandler(state, timeoutState, reject, cleanup, { options, debugMessages }) {
+function createFrameNavigatedHandler(timeoutState, reject, cleanup, { options, debugMessages }) {
 	const UNREACHABLE_URL_ERROR_MESSAGE = "Unreachable URL";
 	return ({ params }) => {
 		const { frame } = params;
-		if (!frame.parentId) {
-			if (frame.unreachableUrl) {
-				clearTimeout(timeoutState.timeoutId);
-				cleanup();
-				reject(new Error(UNREACHABLE_URL_ERROR_MESSAGE + ": " + frame.unreachableUrl));
-			} else {
-				logData(["Detecting top frame ID"], { options, debugMessages });
-				state.topFrameId = frame.id;
-			}
+		if (!frame.parentId && frame.unreachableUrl) {
+			logData(["Detecting unreachable URL", frame.unreachableUrl], { options, debugMessages });
+			clearTimeout(timeoutState.timeoutId);
+			cleanup();
+			reject(new Error(UNREACHABLE_URL_ERROR_MESSAGE + ": " + frame.unreachableUrl));
 		}
 	};
 }
 
-async function findValidSingleFileContext({ Runtime }, contextIds, { options, debugMessages }) {
-	const CONTEXT_NOT_FOUND_ERROR_MESSAGE = "Execution context not found for SingleFile world";
+async function getSingleFileContext({ Page, Runtime }, topFrameId, { options, debugMessages }) {
 	const SINGLE_FILE_DETECTION_TEST = "typeof singlefile !== 'undefined'";
 	const NO_VALID_CONTEXT_ERROR_MESSAGE = "No valid SingleFile execution context found";
 	logData(["Getting execution context"], { options, debugMessages });
-	if (!contextIds.length) {
-		throw new Error(CONTEXT_NOT_FOUND_ERROR_MESSAGE);
-	}
-	for (const contextId of contextIds) {
-		try {
-			const { result } = await Runtime.evaluate({
-				expression: SINGLE_FILE_DETECTION_TEST,
-				contextId
-			});
-			if (result.value === true) {
-				return contextId;
-			}
-		} catch {
-			// ignored
-		}
+	// the world already exists, so asking for it by name returns the context the
+	// injected script ran in instead of creating another one
+	const { executionContextId } = await Page.createIsolatedWorld({
+		frameId: topFrameId,
+		worldName: SINGLE_FILE_WORLD_NAME
+	});
+	// an empty world is returned when the script could not be injected, so the
+	// context is checked before it is used to capture the page
+	const { result } = await Runtime.evaluate({
+		expression: SINGLE_FILE_DETECTION_TEST,
+		contextId: executionContextId
+	});
+	if (result.value !== true) {
+		throw new Error(NO_VALID_CONTEXT_ERROR_MESSAGE);
 	}
-	throw new Error(NO_VALID_CONTEXT_ERROR_MESSAGE);
+	return executionContextId;
 }
 
-function setupPageDataCapture({ Runtime }, contextId, { options, debugMessages }) {
-	return new Promise(resolve => {
+function setupPageDataCapture({ Runtime }, _contextId, { options, debugMessages }) {
+	return new Promise((resolve, reject) => {
 		let pageDataResponse = "";
 		Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, ({ params }) => {
 			if (params.name === SET_PAGE_DATA_FUNCTION_NAME) {
@@ -518,11 +556,15 @@ function setupPageDataCapture({ Runtime }, contextId, { options, debugMessages }
 					pageDataResponse += payload;
 				} else {
 					logData(["Setting page data"], { options, debugMessages });
-					const result = JSON.parse(pageDataResponse);
-					if (result.content instanceof Array) {
-						result.content = new Uint8Array(result.content);
+					try {
+						const result = JSON.parse(pageDataResponse);
+						if (result.content instanceof Array) {
+							result.content = new Uint8Array(result.content);
+						}
+						resolve(result);
+					} catch (error) {
+						reject(error);
 					}
-					resolve(result);
 				}
 			}
 		});
@@ -534,20 +576,20 @@ async function setupBindings({ Page, Runtime }, contextId, { options, debugMessa
 	if (options.embedScreenshot && options.compressContent) {
 		await setupScreenshotCapture({ Page, Runtime }, contextId, { options, debugMessages });
 	}
-	if (options.embedPdf) {
+	if (options.embedPdf && options.compressContent) {
 		await setupPdfCapture({ Page, Runtime }, contextId, { options, debugMessages });
 	}
 	await Runtime.addBinding({ name: FETCH_FUNCTION_NAME, executionContextId: contextId });
-	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, async ({ params }) => {
+	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, ignoringErrors(async ({ params }) => {
 		if (params.name === FETCH_FUNCTION_NAME) {
 			await handleFetchRequest({ Runtime }, params, contextId, { options, debugMessages });
 		}
-	});
+	}, { options, debugMessages }));
 }
 
 async function setupScreenshotCapture({ Page, Runtime }, contextId, { options, debugMessages }) {
 	await Runtime.addBinding({ name: CAPTURE_SCREENSHOT_FUNCTION_NAME, executionContextId: contextId });
-	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, async ({ params }) => {
+	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, ignoringErrors(async ({ params }) => {
 		if (params.name === CAPTURE_SCREENSHOT_FUNCTION_NAME) {
 			logData(["Capturing screenshot"], { options, debugMessages });
 			try {
@@ -558,7 +600,7 @@ async function setupScreenshotCapture({ Page, Runtime }, contextId, { options, d
 				await callBrowserFunction({ Runtime }, contextId, SET_SCREENSHOT_FUNCTION_NAME, [""]);
 			}
 		}
-	});
+	}, { options, debugMessages }));
 
 	function parseScreenshotOptions(optionsString) {
 		const PNG_FORMAT = "png";
@@ -577,8 +619,8 @@ async function setupScreenshotCapture({ Page, Runtime }, contextId, { options, d
 
 async function setupPdfCapture({ Page, Runtime }, contextId, { options, debugMessages }) {
 	await Runtime.addBinding({ name: PRINT_TO_PDF_FUNCTION_NAME, executionContextId: contextId });
-	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, async ({ params }) => {
-		if (params.name !== PRINT_TO_PDF_FUNCTION_NAME) {
+	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, ignoringErrors(async ({ params }) => {
+		if (params.name === PRINT_TO_PDF_FUNCTION_NAME) {
 			logData(["Printing to PDF", options.embedPdfOptions || ""], { options, debugMessages });
 			const pdfOptions = parsePdfOptions(options.embedPdfOptions);
 			try {
@@ -588,7 +630,7 @@ async function setupPdfCapture({ Page, Runtime }, contextId, { options, debugMes
 				await callBrowserFunction({ Runtime }, contextId, SET_PDF_FUNCTION_NAME, [""]);
 			}
 		}
-	});
+	}, { options, debugMessages }));
 
 	function parsePdfOptions(optionsString) {
 		let pdfOptions = {};
@@ -671,7 +713,10 @@ async function capturePageData({ Runtime }, contextId, { options, debugMessages
 	}
 }
 
-async function disableCdpDomains({ Console, Network, Page, Runtime }, { options }) {
+async function disableCdpDomains({ Console, Fetch, Network, Page, Runtime }, { options }) {
+	// disabled first, so that the requests left paused are resumed by the
+	// browser instead of being held until the target is closed
+	await Fetch.disable();
 	await Runtime.disable();
 	await Page.disable();
 	if (options.httpHeaders) {
@@ -708,6 +753,18 @@ function attachDebugInfo(error, { options, consoleMessages, debugMessages }) {
 	}
 }
 
+function ignoringErrors(listener, pageContext) {
+	return async event => {
+		try {
+			await listener(event);
+		} catch (error) {
+			// the commands sent while the target is closing are rejected, and an
+			// error thrown here would be reported as an unhandled rejection
+			logData(["Ignoring event listener error", error.message], pageContext);
+		}
+	};
+}
+
 function logData(data, { options, debugMessages }) {
 	if (options.debugMessagesFile) {
 		debugMessages.push([Date.now(), data]);