single-file-cli 2.0.82 → 2.1.0

package/lib/single-file-script.js

@@ -68,7 +68,9 @@ function initSingleFile(constants) {
 		const pendingRequest = pendingRequests.get(requestId);
 		if (pendingRequest) {
 			pendingRequests.delete(requestId);
-			pendingRequest.reject(new Error(error.error));
+			const fetchError = new Error(error.error);
+			fetchError.code = error.code;
+			pendingRequest.reject(fetchError);
 		}
 	};
 

package/lib/version.js

@@ -1 +1 @@
-export const version = "2.0.82";
+export const version = "2.1.0";

package/options.js

@@ -59,6 +59,7 @@ const OPTIONS_INFO = [{
 	"browser-debug": { description: "Enable debug mode", type: "boolean" },
 	"browser-arg": { description: "Argument passed to the browser", type: "string[]", alias: "browser-argument" },
 	"browser-args": { description: "Arguments provided as a JSON array and passed to the browser", type: "string" },
+	"browser-single-process": { description: "Run the browser as a single process", type: "boolean", defaultValue: true },
 	"browser-start-minimized": { description: "Minimize the browser", type: "boolean" },
 	"browser-ignore-insecure-certs": { description: "Ignore HTTPs errors", type: "boolean" },
 	"browser-remote-debugging-URL": { description: "Remote debugging URL", type: "string" }
@@ -112,6 +113,7 @@ const OPTIONS_INFO = [{
 	"compress-HTML": { description: "Compress HTML content", type: "boolean", defaultValue: true },
 	"remove-frames": { description: "Remove frames", type: "boolean" },
 	"remove-hidden-elements": { description: "Remove HTML elements which are not displayed", type: "boolean", defaultValue: true },
+	"removed-elements-selector": { description: "Remove specific HTML elements matching the given CSS selectors (comma separated)", type: "string" },
 	"remove-unused-styles": { description: "Remove unused CSS rules and unneeded declarations", type: "boolean", defaultValue: true },
 	"remove-unused-fonts": { description: "Remove unused CSS font rules", type: "boolean", defaultValue: true },
 	"remove-alternative-fonts": { description: "Remove alternative fonts to the ones displayed", type: "boolean", defaultValue: true },
@@ -137,7 +139,7 @@ const OPTIONS_INFO = [{
 	"embed-pdf-options": { description: "Options passed to the CDP method `Page.printToPDF()` given as a JSON string (e.g. { \"pageRanges\": \"1-1\", \"paperWidth\": 11, \"paperHeight\": 8.5 })", type: "string" },
 	"embedded-pdf": { description: "Path to a PDF file to embed in the compressed file.", type: "string" }
 }, {
-	"filename-template": { description: "Template used to generate the output filename (see help page of the extension for more info)", type: "string", defaultValue: "%if-empty<{page-title}|No title> ({date-locale} {time-locale}).{filename-extension}" },
+	"filename-template": { description: "Template used to generate the output filename (see https://github.com/gildas-lormeau/SingleFile/wiki/Template-variables-and-functions)", type: "string", defaultValue: "%if-empty<{page-title}|No title> ({date-locale} {time-locale}).{filename-extension}" },
 	"filename-conflict-action": { description: "Action when the filename is conflicting with existing one on the filesystem. The possible values are \"uniquify\" (default), \"overwrite\" and \"skip\"", type: "string", defaultValue: "uniquify" },
 	"filename-replacement-character": { description: "The character used for replacing invalid characters in filenames", type: "string", defaultValue: "_" },
 	"filename-replaced-character": { description: "The replaced character and the character(s) used for replacing the replacement character in filenames separated by a space, e.g. --filename-replaced-character \">\" _GT_ to replace \">\" with _GT_", type: "string[]", defaultValue: ["~ ～", "+ ＋", "? ？", "% ％", "* ＊", ": ：", "| ｜", "\" ＂", "< ＜", "> ＞", "\\\\ ＼", "\\x00-\\x1f _", "\x7F _"] },

package/package.json

@@ -1,22 +1,27 @@
 {
 	"name": "single-file-cli",
-	"version": "2.0.82",
+	"version": "2.1.0",
 	"description": "SingleFile CLI",
 	"author": "Gildas Lormeau",
 	"engines": {
-		"deno": ">=1.4",
-		"bun": ">=1.0",
-		"node": ">=20"
+		"deno": ">=2.2",
+		"bun": ">=1.2",
+		"node": ">=24.0.0"
 	},
 	"type": "module",
+	"scripts": {
+		"test": "node --test \"test/**/*.test.js\"",
+		"lint": "eslint ."
+	},
 	"bin": {
 		"single-file": "single-file-node.js"
 	},
 	"dependencies": {
-		"simple-cdp": "^1.8.6",
-		"ws": "^8.18.3"
+		"simple-cdp": "^1.10.0"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.39.1"
+		"@eslint/js": "^9.39.1",
+		"esbuild": "^0.27.4",
+		"eslint": "^10.8.1"
 	}
-}
+}

package/single-file-cli-api.js

@@ -21,7 +21,7 @@
  *   Source.
  */
 
-/* global URL, Blob, FileReader */
+/* global URL */
 
 import * as backend from "./lib/cdp-client.js";
 import { getZipScriptSource } from "./lib/single-file-script.js";
@@ -65,6 +65,9 @@ export { initialize };
 
 async function initialize(options) {
 	options = Object.assign({}, DEFAULT_OPTIONS, options);
+	if ((options.embedPdf || options.embeddedPdf || options.embedScreenshot || options.embeddedImage) && !options.compressContent) {
+		throw new Error("--embed-pdf, --embedded-pdf, --embed-screenshot and --embedded-image require --compress-content");
+	}
 	maxParallelWorkers = options.maxParallelWorkers || 8;
 	try {
 		await backend.initialize(options);
@@ -83,7 +86,8 @@ async function initialize(options) {
 	}
 	if (options.crawlSyncSession || options.crawlLoadSession) {
 		try {
-			tasks = JSON.parse(await readTextFile(options.crawlSyncSession || options.crawlLoadSession));
+			tasks = JSON.parse(await readTextFile(options.crawlSyncSession || options.crawlLoadSession))
+				.map(task => Object.assign({ originalUrls: [task.url] }, task));
 		} catch (error) {
 			if (options.crawlLoadSession) {
 				throw error;
@@ -127,17 +131,20 @@ async function finish(options) {
 	if (options.crawlReplaceURLs && !options.compressContent) {
 		for (const task of tasks) {
 			try {
-				let pageContent = await readTextFile(task.filename);
+				const outputFilename = getOutputDirectory(options) + task.filename;
+				let pageContent = await readTextFile(outputFilename);
 				tasks.forEach(otherTask => {
 					if (otherTask.filename) {
-						pageContent = pageContent.replace(new RegExp(escapeRegExp("\"" + otherTask.originalUrl + "\""), "gi"), "\"" + otherTask.filename + "\"");
-						pageContent = pageContent.replace(new RegExp(escapeRegExp("'" + otherTask.originalUrl + "'"), "gi"), "'" + otherTask.filename + "'");
-						const filename = otherTask.filename.replace(/ /g, "%20");
-						pageContent = pageContent.replace(new RegExp(escapeRegExp("=" + otherTask.originalUrl + " "), "gi"), "=" + filename + " ");
-						pageContent = pageContent.replace(new RegExp(escapeRegExp("=" + otherTask.originalUrl + ">"), "gi"), "=" + filename + ">");
+						otherTask.originalUrls.forEach(originalUrl => {
+							pageContent = pageContent.replace(new RegExp(escapeRegExp("\"" + originalUrl + "\""), "gi"), "\"" + otherTask.filename + "\"");
+							pageContent = pageContent.replace(new RegExp(escapeRegExp("'" + originalUrl + "'"), "gi"), "'" + otherTask.filename + "'");
+							const filename = otherTask.filename.replace(/ /g, "%20");
+							pageContent = pageContent.replace(new RegExp(escapeRegExp("=" + originalUrl + " "), "gi"), "=" + filename + " ");
+							pageContent = pageContent.replace(new RegExp(escapeRegExp("=" + originalUrl + ">"), "gi"), "=" + filename + ">");
+						});
 					}
 				});
-				await writeTextFile(task.filename, pageContent);
+				await writeTextFile(outputFilename, pageContent);
 			} catch {
 				// ignored
 			}
@@ -174,12 +181,11 @@ async function runNextTask() {
 			if (options.crawlLinks && testMaxDepth(task)) {
 				const urls = pageData.links;
 				let newTasks = await Promise.all(urls.map(url => createTask(url, options, task, task.rootTaskURL || task.url)));
-				newTasks = newTasks.filter(task => task &&
+				newTasks = newTasks.filter((task, taskIndex) => task &&
 					testMaxDepth(task) &&
-					!tasks.find(otherTask => otherTask.url == task.url) &&
-					!newTasks.find(otherTask => otherTask != task && otherTask.url == task.url) &&
 					(!options.crawlInnerLinksOnly || task.isInnerLink) &&
-					(!options.crawlNoParent || (task.isChild || !task.isInnerLink)));
+					(!options.crawlNoParent || (task.isChild || !task.isInnerLink)) &&
+					!mergeDuplicateTask(task, tasks.concat(newTasks.slice(0, taskIndex))));
 				tasks.splice(tasks.length, 0, ...newTasks);
 			}
 		}
@@ -188,6 +194,18 @@ async function runNextTask() {
 	}
 }
 
+function mergeDuplicateTask(task, otherTasks) {
+	const duplicateTask = otherTasks.find(otherTask => otherTask && otherTask.url == task.url);
+	if (duplicateTask) {
+		task.originalUrls.forEach(url => {
+			if (!duplicateTask.originalUrls.includes(url)) {
+				duplicateTask.originalUrls.push(url);
+			}
+		});
+		return true;
+	}
+}
+
 function testMaxDepth(task) {
 	const options = task.options;
 	return (options.crawlMaxDepth == 0 || task.depth <= options.crawlMaxDepth) &&
@@ -195,10 +213,13 @@ function testMaxDepth(task) {
 }
 
 async function createTask(url, options, parentTask, rootTaskURL) {
-	options.originalUrl = url;
+	const originalUrl = url;
 	url = parentTask ? rewriteURL(url, options.crawlRemoveURLFragment, options.crawlRewriteRules) : url;
 	if (url) {
 		if (!VALID_URL_TEST.test(url)) {
+			if (parentTask) {
+				return;
+			}
 			try {
 				url = url.replace(/\\/g, "/");
 				url = url.replace(/#/g, "%23");
@@ -215,7 +236,7 @@ async function createTask(url, options, parentTask, rootTaskURL) {
 			url,
 			isInnerLink,
 			isChild,
-			originalUrl: url,
+			originalUrls: [originalUrl],
 			rootTaskURL,
 			depth: parentTask ? parentTask.depth + 1 : 0,
 			externalLinkDepth: isInnerLink ? -1 : parentTask ? parentTask.externalLinkDepth + 1 : -1,
@@ -252,7 +273,7 @@ function rewriteURL(url, crawlRemoveURLFragment, crawlRewriteRules = []) {
 
 function getHostURL(url) {
 	url = new URL(url);
-	return url.protocol + "//" + (url.username ? url.username + (url.password || "") + "@" : "") + url.hostname;
+	return url.protocol + "//" + (url.username ? url.username + (url.password ? ":" + url.password : "") + "@" : "") + url.host + "/";
 }
 
 async function capturePage(options) {
@@ -270,14 +291,8 @@ async function capturePage(options) {
 		}
 		if (options.outputJson) {
 			if (content instanceof Uint8Array) {
-				const fileReader = new FileReader();
-				fileReader.readAsDataURL(new Blob([content]));
-				content = await new Promise(resolve => {
-					fileReader.onload = () => resolve(fileReader.result);
-				});
-				content = content.replace(/^data:.*?;base64,/, "");
 				pageData.content = undefined;
-				pageData.binaryContent = content;
+				pageData.binaryContent = content.toBase64();
 			}
 			pageData.doctype = undefined;
 			pageData.viewport = undefined;
@@ -308,6 +323,8 @@ async function capturePage(options) {
 			} else {
 				await writeTextFile(filename, content);
 			}
+			const outputDirectory = getOutputDirectory(options);
+			pageData.filename = filename.startsWith(outputDirectory) ? filename.substring(outputDirectory.length) : filename;
 		}
 		return pageData;
 	} catch (error) {
@@ -332,7 +349,7 @@ async function capturePage(options) {
 	}
 }
 
-async function getFilename(filename, options, index = 1) {
+function getOutputDirectory(options) {
 	if (Array.isArray(options.outputDirectory)) {
 		const outputDirectory = options.outputDirectory.pop();
 		if (outputDirectory.startsWith("/")) {
@@ -345,9 +362,13 @@ async function getFilename(filename, options, index = 1) {
 	if (outputDirectory && !outputDirectory.endsWith("/")) {
 		outputDirectory += "/";
 	}
-	let newFilename = outputDirectory + filename;
+	return outputDirectory;
+}
+
+async function getFilename(filename, options, index = 1) {
+	let newFilename = getOutputDirectory(options) + filename;
 	if (options.filenameConflictAction == "overwrite") {
-		return filename;
+		return newFilename;
 	} else if (options.filenameConflictAction == "uniquify" && index > 1) {
 		const regExpMatchExtension = /(\.[^.]+)$/;
 		const matchExtension = newFilename.match(regExpMatchExtension);

package/single-file-launcher.js

@@ -30,12 +30,12 @@ const { readTextFile, readFile, exit, addSignalListener } = Deno;
 
 try {
 	addSignalListener("SIGTERM", closeBrowserAndExit);
-} catch (_error) {
+} catch {
 	// ignored
 }
 try {
 	addSignalListener("SIGINT", closeBrowserAndExit);
-} catch (_error) {
+} catch {
 	// ignored
 }
 
@@ -84,6 +84,15 @@ async function run() {
 				options.browserCookies = parseCookies(cookiesContent);
 			}
 		}
+		if (options.emulateMediaFeatures) {
+			options.emulateMediaFeatures = options.emulateMediaFeatures.map(feature => {
+				const colonIndex = feature.indexOf(":");
+				return {
+					name: feature.substring(0, colonIndex),
+					value: feature.substring(colonIndex + 1)
+				};
+			});
+		}
 		if (options.httpHeaders) {
 			const headers = {};
 			for (const header of options.httpHeaders) {

package/test/e2e/crawl.test.js

@@ -0,0 +1,142 @@
+/* global URL */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const TEST_TIMEOUT = 120000;
+
+let crawlPromise;
+
+test("a page linked with and without fragment is captured once", { timeout: TEST_TIMEOUT }, async () => {
+	const { filenames } = await getCrawlResult();
+	assert.ok(filenames.includes("Top Page.html"));
+	assert.equal(filenames.filter(filename => filename.startsWith("Linked Page")).length, 1);
+});
+
+test("links to pages with the same title are rewritten to distinct filenames", { timeout: TEST_TIMEOUT }, async () => {
+	const { filenames, pages } = await getCrawlResult();
+	assert.ok(filenames.includes("Same Title.html"));
+	assert.ok(filenames.includes("Same Title (2).html"));
+	assert.ok(pages["Top Page.html"].includes("=Same%20Title.html>"));
+	assert.ok(pages["Top Page.html"].includes("=Same%20Title%20(2).html>"));
+});
+
+test("links to another port are not crawled as inner links", { timeout: TEST_TIMEOUT }, async () => {
+	const { filenames, otherServerRequests } = await getCrawlResult();
+	assert.ok(!filenames.includes("Other Server.html"));
+	assert.equal(otherServerRequests.length, 0);
+});
+
+test("fragment links are rewritten to the captured filename", { timeout: TEST_TIMEOUT }, async () => {
+	const { pages } = await getCrawlResult();
+	assert.ok(pages["Top Page.html"].includes("=Fragment%20Page.html>"));
+});
+
+test("all link variants of a deduplicated page are rewritten", { timeout: TEST_TIMEOUT }, async () => {
+	const { pages } = await getCrawlResult();
+	assert.ok(!pages["Top Page.html"].includes("page.html#section"));
+	assert.equal((pages["Top Page.html"].match(/=Linked%20Page\.html>/g) || []).length, 2);
+});
+
+test("mail and script links are not crawled as external links", { timeout: TEST_TIMEOUT }, async () => {
+	const server = createServer((_, response) => servePage(response, "Mail Top", `
+		<a href="mailto:contact@example.net">mail</a>
+		<a href="javascript:void(0)">script</a>
+		<a href="tel:+15550100">phone</a>`));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const url = "http://localhost:" + server.address().port + "/";
+		await execFileAsync(process.execPath, [
+			"single-file-node.js", url,
+			"--crawl-links",
+			"--crawl-inner-links-only=false",
+			"--output-directory", directory,
+			"--filename-template", "{page-title}.html",
+			"--errors-file", join(directory, "errors.txt"),
+			"--max-parallel-workers", "1"
+		], { cwd: cliDirectory });
+		assert.deepEqual(await readdir(directory), ["Mail Top.html"]);
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});
+
+function getCrawlResult() {
+	if (!crawlPromise) {
+		crawlPromise = runCrawl();
+	}
+	return crawlPromise;
+}
+
+async function runCrawl() {
+	const otherServerRequests = [];
+	const otherServer = createServer((request, response) => {
+		otherServerRequests.push(request.url);
+		servePage(response, "Other Server");
+	});
+	await new Promise(resolve => otherServer.listen(0, "localhost", resolve));
+	const otherServerOrigin = "http://localhost:" + otherServer.address().port;
+	const server = createServer((request, response) => {
+		const { pathname } = new URL(request.url, "http://localhost");
+		if (pathname === "/") {
+			servePage(response, "Top Page", `
+				<a href="/page.html">page</a>
+				<a href="/page.html#section">section</a>
+				<a href="/fragment.html#top">fragment</a>
+				<a href="/same-title-1.html">first</a>
+				<a href="/same-title-2.html">second</a>
+				<a href="${otherServerOrigin}/other.html">other</a>
+				<a href="mailto:contact@example.net">mail</a>`);
+		} else if (pathname === "/page.html") {
+			servePage(response, "Linked Page");
+		} else if (pathname === "/fragment.html") {
+			servePage(response, "Fragment Page");
+		} else if (pathname === "/same-title-1.html") {
+			servePage(response, "Same Title", "first");
+		} else if (pathname === "/same-title-2.html") {
+			servePage(response, "Same Title", "second");
+		} else {
+			response.writeHead(404).end();
+		}
+	});
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const url = "http://localhost:" + server.address().port + "/";
+		await execFileAsync(process.execPath, [
+			"single-file-node.js", url,
+			"--crawl-links",
+			"--crawl-replace-URLs",
+			"--output-directory", directory,
+			"--filename-template", "{page-title}.html",
+			"--max-parallel-workers", "1"
+		], { cwd: cliDirectory });
+		const filenames = await readdir(directory);
+		const pages = {};
+		for (const filename of filenames) {
+			pages[filename] = await readFile(join(directory, filename), "utf8");
+		}
+		return { filenames, pages, otherServerRequests };
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+		otherServer.close();
+	}
+}
+
+function servePage(response, title, body = "") {
+	response.writeHead(200, { "content-type": "text/html" })
+		.end(`<html><head><title>${title}</title></head><body>${body}</body></html>`);
+}

package/test/e2e/frame-gate.test.js

@@ -0,0 +1,61 @@
+/* global setTimeout, URL */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const LOAD_MARKER = "MARKER_ADDED_AFTER_LOAD_EVENT";
+const SLOW_RESOURCE_DELAY = 3500;
+const PIXEL_PNG = Uint8Array.fromBase64("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==");
+
+const TOP_PAGE = `<html><head><title>top</title></head><body>
+<img src="/slow.png">
+<iframe src="/frame.html"></iframe>
+<script>
+addEventListener("load", () => {
+	const marker = document.createElement("div");
+	marker.textContent = "${LOAD_MARKER}";
+	document.body.appendChild(marker);
+});
+</script>
+</body></html>`;
+
+test("capture waits for the top frame, not a fast iframe", { timeout: 60000 }, async () => {
+	const server = createServer((request, response) => {
+		const { pathname } = new URL(request.url, "http://localhost");
+		if (pathname === "/top.html") {
+			response.writeHead(200, { "content-type": "text/html" }).end(TOP_PAGE);
+		} else if (pathname === "/frame.html") {
+			response.writeHead(200, { "content-type": "text/html" }).end("<html><body>frame</body></html>");
+		} else if (pathname === "/slow.png") {
+			setTimeout(() => response.writeHead(200, { "content-type": "image/png" }).end(PIXEL_PNG), SLOW_RESOURCE_DELAY);
+		} else {
+			response.writeHead(404).end();
+		}
+	});
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const outputPath = join(directory, "out.html");
+		const url = "http://localhost:" + server.address().port + "/top.html";
+		await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath,
+			"--browser-wait-until", "networkIdle",
+			"--browser-wait-until-delay", "1000"
+		], { cwd: cliDirectory });
+		const content = await readFile(outputPath, "utf8");
+		assert.ok(content.includes(LOAD_MARKER), "page was captured before the top frame finished loading");
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});

package/test/e2e/output-json.test.js

@@ -0,0 +1,40 @@
+/* global TextDecoder */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const ZIP_SIGNATURE = "PK\u0003\u0004";
+
+test("output-json embeds compressed content as base64", { timeout: 60000 }, async () => {
+	const server = createServer((_, response) => response
+		.writeHead(200, { "content-type": "text/html" })
+		.end("<html><head><title>JSON Output</title></head><body>content</body></html>"));
+	await new Promise(resolve => server.listen(0, "localhost", resolve));
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const outputPath = join(directory, "page.json");
+		const url = "http://localhost:" + server.address().port + "/";
+		await execFileAsync(process.execPath, [
+			"single-file-node.js", url, outputPath,
+			"--compress-content",
+			"--output-json"
+		], { cwd: cliDirectory });
+		const pageData = JSON.parse(await readFile(outputPath, "utf8"));
+		assert.ok(pageData.binaryContent);
+		const content = new TextDecoder("latin1").decode(Uint8Array.fromBase64(pageData.binaryContent));
+		assert.ok(content.includes(ZIP_SIGNATURE));
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+});

package/test/unit/command.test.js

@@ -0,0 +1,41 @@
+/* global setTimeout, clearTimeout */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import process from "node:process";
+import { Deno } from "../../lib/deno-polyfill.js";
+
+const { Command } = Deno;
+
+test("status resolves when the process exits with a nonzero code", async () => {
+	const command = new Command(process.execPath, { args: ["-e", "process.exit(7)"] });
+	const child = await command.spawn();
+	const status = await child.status;
+	assert.equal(status.code, 7);
+});
+
+test("status resolves when the process is killed", async () => {
+	const command = new Command(process.execPath, { args: ["-e", "setTimeout(() => {}, 60000)"] });
+	const child = await command.spawn();
+	child.kill();
+	const status = await child.status;
+	assert.equal(status.code, null);
+});
+
+test("a process writing large output with discarded stdio exits", async () => {
+	const script = "const chunk = \"x\".repeat(65536); for (let i = 0; i < 64; i++) { process.stdout.write(chunk); process.stderr.write(chunk); }";
+	const command = new Command(process.execPath, { args: ["-e", script], stdout: "null", stderr: "null" });
+	const child = await command.spawn();
+	let timeoutId;
+	const result = await Promise.race([
+		child.status,
+		new Promise(resolve => timeoutId = setTimeout(() => resolve("timeout"), 5000))
+	]);
+	clearTimeout(timeoutId);
+	if (result === "timeout") {
+		child.kill();
+		await child.status.catch(() => { });
+		assert.fail("process blocked on unread output");
+	}
+	assert.equal(result.code, 0);
+});

package/test/unit/file-url.test.js

@@ -0,0 +1,37 @@
+/* global TextDecoder */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { path } from "../../lib/deno-polyfill.js";
+import { fetch as fetchWithFileSupport } from "../../lib/cdp-client-util.js";
+
+test("fromFileUrl decodes percent-encoded characters", async () => {
+	assert.equal(await path.fromFileUrl("file:///tmp/some%20dir/page.html"), "/tmp/some dir/page.html");
+});
+
+test("fromFileUrl ignores query and fragment", async () => {
+	assert.equal(await path.fromFileUrl("file:///tmp/page.html?query=1#fragment"), "/tmp/page.html");
+});
+
+test("fetch reads a file URL with a query", async () => {
+	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));
+	try {
+		const filePath = join(directory, "resource dir");
+		await writeFile(filePath, "file content");
+		const fileUrl = await path.toFileUrl(filePath);
+		const response = await fetchWithFileSupport(fileUrl + "?query=1");
+		assert.equal(response.status, 200);
+		const content = new TextDecoder().decode(await response.arrayBuffer());
+		assert.equal(content, "file content");
+	} finally {
+		await rm(directory, { recursive: true });
+	}
+});
+
+test("fetch returns 404 for a missing file URL", async () => {
+	const response = await fetchWithFileSupport("file:///nonexistent/path/resource");
+	assert.equal(response.status, 404);
+});