single-file-cli 2.0.83 → 2.1.0

package/lib/browser.js

@@ -26,7 +26,7 @@
 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;
 
@@ -58,7 +58,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,19 +72,16 @@ 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();
 	return debugPort;

package/lib/cdp-client-util.js

@@ -21,9 +21,9 @@
  *   Source.
  */
 
-/* global setTimeout, clearTimeout, fetch, URL, Headers, btoa */
+/* global setTimeout, clearTimeout, fetch, URL, Headers */
 
-import { Deno, isDeno } from "./deno-polyfill.js";
+import { Deno, isDeno, path } from "./deno-polyfill.js";
 
 const ABORT_EVENT = "abort";
 
@@ -42,10 +42,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 +58,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 +82,7 @@ function waitForTimeout(abortSignal, maxDelay, errorMessage, errorCode) {
 }
 
 function arrayBufferToBase64(arrayBuffer) {
-	return btoa(String.fromCharCode.apply(null, new Uint8Array(arrayBuffer)));
+	return new Uint8Array(arrayBuffer).toBase64();
 }
 
 function getAlternativeUrl(url) {

package/lib/cdp-client.js

@@ -74,6 +74,7 @@ async function initialize(singleFileOptions) {
 		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;
@@ -86,11 +87,11 @@ async function initialize(singleFileOptions) {
 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);
@@ -135,6 +136,12 @@ async function getPageData(options) {
 			await CDP.closeTarget(targetInfo.id);
 			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 +250,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 +260,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 +294,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 +349,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 +401,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 +421,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 +444,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 +456,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 +473,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 +518,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 +538,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 +562,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 +581,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 +592,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 +675,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 +715,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]);

package/lib/deno-polyfill.js

@@ -29,11 +29,6 @@ import * as path from "path";
 
 const DENO_RUNTIME_DETECTED = typeof Deno !== "undefined";
 
-const NPM_MODULES = {
-	"ws": "ws",
-	"simple-cdp": "simple-cdp",
-};
-
 const NODE_MODULES = {
 	"fs": "node:fs/promises",
 	"os": "node:os",
@@ -68,7 +63,9 @@ const Command = DENO_RUNTIME_DETECTED ? Deno.Command : class Command {
 	}
 	async spawn() {
 		const childProcess = await import(NODE_MODULES["child_process"]);
-		const child = childProcess.spawn(this.path, this.options.args);
+		const stdio = [this.options.stdin, this.options.stdout, this.options.stderr]
+			.map(config => config == "null" ? "ignore" : config == "piped" ? "pipe" : "inherit");
+		const child = childProcess.spawn(this.path, this.options.args, { stdio });
 
 		await new Promise((resolve, reject) => {
 			child.on("spawn", () => resolve());
@@ -81,14 +78,8 @@ const Command = DENO_RUNTIME_DETECTED ? Deno.Command : class Command {
 			});
 		});
 		return {
-			status: new Promise((resolve, reject) => {
-				child.on("exit", code => {
-					if (code === 0 || code === 143 || code === 130 || code === null) {
-						resolve();
-					} else {
-						reject(new Error(`Process exited with code ${code}`));
-					}
-				});
+			status: new Promise(resolve => {
+				child.on("exit", (code, signal) => resolve({ success: code === 0, code, signal }));
 			}),
 			kill() {
 				child.kill();
@@ -122,22 +113,21 @@ const DenoAPI = {
 const pathAPI = {
 	dirname,
 	toFileUrl,
+	fromFileUrl,
 	SEPARATOR: DENO_RUNTIME_DETECTED ? path.SEPARATOR : path.sep
 };
 
 const isDeno = DENO_RUNTIME_DETECTED;
 
-await initGlobalThisProperties();
+// the connection to the browser relies on the WebSocket of the runtime, which
+// Node.js provides since 22.4.0 and can still be turned off with
+// --no-experimental-websocket
+if (typeof globalThis.WebSocket !== "function") {
+	throw new Error("WebSocket is not available, Node.js 22.4.0 or later is required");
+}
 
 export { DenoAPI as Deno, pathAPI as path, isDeno };
 
-async function initGlobalThisProperties() {
-	if (!DENO_RUNTIME_DETECTED) {
-		const { WebSocket } = await import(getNPMModule("ws"));
-		globalThis.WebSocket = WebSocket;
-	}
-}
-
 async function readFile(path) {
 	if (DENO_RUNTIME_DETECTED) {
 		return Deno.readFile(path);
@@ -219,21 +209,21 @@ async function remove(path, options = {}) {
 }
 
 function exit(code) {
+	if (code == "SIGINT") {
+		code = 130;
+	} else if (code == "SIGTERM") {
+		code = 143;
+	}
 	if (DENO_RUNTIME_DETECTED) {
 		Deno.exit(code);
 	} else {
-		if (code == "SIGINT") {
-			code = 130;
-		} else if (code == "SIGTERM") {
-			code = 143;
-		}
 		process.exit(code);
 	}
 }
 
 function addSignalListener(signal, listener) {
 	if (DENO_RUNTIME_DETECTED) {
-		Deno.addSignalListener(signal, listener);
+		Deno.addSignalListener(signal, () => listener(signal));
 	} else {
 		process.once(signal, listener);
 	}
@@ -261,6 +251,11 @@ async function toFileUrl(filePath) {
 	}
 }
 
-function getNPMModule(module) {
-	return NPM_MODULES[module];
+async function fromFileUrl(fileUrl) {
+	if (DENO_RUNTIME_DETECTED) {
+		return path.fromFileUrl(fileUrl);
+	} else {
+		const url = await import(NODE_MODULES["url"]);
+		return url.fileURLToPath(fileUrl);
+	}
 }