single-file-cli 2.6.1 → 2.6.3

package/lib/version.js

@@ -1 +1 @@
-export const version = "2.6.1";
+export const version = "2.6.3";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "single-file-cli",
-	"version": "2.6.1",
+	"version": "2.6.3",
 	"description": "SingleFile CLI",
 	"author": "Gildas Lormeau",
 	"license": "AGPL-3.0-or-later",
@@ -16,6 +16,7 @@
 	"type": "module",
 	"scripts": {
 		"test": "node --test --test-concurrency=2 \"test/**/*.test.js\"",
+		"test:dev": "SINGLE_FILE_TARGET=dev node --test --test-concurrency=2 \"test/**/*.test.js\"",
 		"lint": "eslint ."
 	},
 	"bin": {

package/test/e2e/automation-detection.test.js

@@ -5,12 +5,11 @@ 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 { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("pages are not captured as controlled by automation", { timeout: 120000 }, async () => {
 	const server = createServer((_, response) => response

package/test/e2e/backend-fetch.test.js

@@ -7,12 +7,11 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("the backend fetch presents the same user agent as the browser", { timeout: 120000 }, async () => {
 	const requests = [];

package/test/e2e/blocked-url-pattern.test.js

@@ -7,12 +7,11 @@ 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 { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("a blocked URL is never requested", { timeout: 120000 }, async () => {
 	const BLOCKED_STYLE = "rgb(123,45,67)";

package/test/e2e/browser-profile.test.js

@@ -5,12 +5,11 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { mkdtemp, mkdir, readdir, readFile, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("a browser profile is copied and left unmodified by a capture", { timeout: 120000 }, async () => {
 	const server = createServer((_, response) => response

package/test/e2e/compress-content.test.js

@@ -7,13 +7,12 @@ 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 { join } from "node:path";
 import process from "node:process";
-import { configure, ZipReader, Uint8ArrayReader } from "../../lib/single-file-archive.js";
+const { configure, ZipReader, Uint8ArrayReader } = await importLibModule("single-file-archive.js");
+import { cliDirectory, importLibModule } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const TEST_TIMEOUT = 120000;
 const END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
 const END_OF_CENTRAL_DIRECTORY_LENGTH = 22;

package/test/e2e/crawl-save-archive.test.js

@@ -7,13 +7,12 @@ 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 { join } from "node:path";
 import process from "node:process";
-import { configure, ZipReader, Uint8ArrayReader, TextWriter } from "../../lib/single-file-archive.js";
+const { configure, ZipReader, Uint8ArrayReader, TextWriter } = await importLibModule("single-file-archive.js");
+import { cliDirectory, importLibModule } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const TEST_TIMEOUT = 120000;
 
 const crawlPromises = new Map();

package/test/e2e/crawl.test.js

@@ -7,12 +7,11 @@ 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 { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const TEST_TIMEOUT = 120000;
 
 let crawlPromise;

package/test/e2e/errors-file.test.js

@@ -4,12 +4,11 @@ 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 { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("errors file lines include the error message and the exit code is nonzero", { timeout: 120000 }, async () => {
 	const directory = await mkdtemp(join(tmpdir(), "single-file-test-"));

package/test/e2e/fidelity.test.js

@@ -0,0 +1,214 @@
+/* global TextDecoder */
+
+// Every other e2e test reads a save as text or as bytes: a marker is present, an entry is named
+// what it should be, the console is clean. None of them looks at the page. A save can pass all of
+// them and still come back with its type in a fallback family, its grid collapsed, or a frame
+// rendered blank — the markup is there, it just does not draw the same picture.
+//
+// So this suite renders the source page and the saved page and compares the pixels. What it can
+// assert is bounded by one thing: a page that does not render identically to ITSELF cannot be held
+// to rendering identically to its save. Every check therefore measures that first — the same source
+// captured twice — and uses it as the floor. On these fixtures the floor is zero, which is why they
+// are hand-built and static rather than mirrored from the web; the real-page matrix is a different
+// tool, and it reports rather than asserts.
+//
+// The fixtures are not decorative. Each one is a defect that shipped, kept in the shape that made
+// it visible, with a comment in the page saying which.
+
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+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 { pathToFileURL, fileURLToPath } from "node:url";
+import process from "node:process";
+import { cliDirectory, importLibModule, useDevBuild } from "../target.js";
+import { openBrowser } from "../fidelity/browser.js";
+import { startServer } from "../fidelity/server.js";
+const { configure, ZipReader, Uint8ArrayReader, TextWriter } = await importLibModule("single-file-archive.js");
+
+const execFileAsync = promisify(execFile);
+const TEST_TIMEOUT = 120000;
+const SAVE_TIMEOUT = 90000;
+const PAGES_DIRECTORY = join(dirname(fileURLToPath(import.meta.url)), "..", "fidelity", "pages");
+
+// These checks are the ones that need a browser of their own, driven directly, and they have not
+// been shown to be reliable on a CI runner yet: the first run there wedged on a CDP command that
+// never answered and the job had to be cancelled. So they run where they were built to be used —
+// against a dev build of single-file-core, which is when the code they cover is being changed — and
+// on demand with SINGLE_FILE_FIDELITY=1. Running them against the default target says little
+// anyway: that target is the *published* core, so a check for a fix lands red until it ships.
+//
+// This is a hold, not a decision. They belong in CI, on a job that builds core from source; the
+// command limit added since would now name what did not answer rather than hanging.
+const enabled = useDevBuild || process.env.SINGLE_FILE_FIDELITY === "1";
+const skip = enabled ? false : "set SINGLE_FILE_FIDELITY=1, or use SINGLE_FILE_TARGET=dev, to run the fidelity checks";
+const options = { timeout: TEST_TIMEOUT, skip };
+
+let browser;
+
+before(async () => enabled && (browser = await openBrowser()), { timeout: TEST_TIMEOUT });
+after(async () => browser && await browser.close(), { timeout: TEST_TIMEOUT });
+
+test("an archived page renders exactly like its source", options, async () => {
+	const { comparison, noise } = await compareSaveWithSource("duplicate-stylesheet", ["--compress-content"]);
+	assertNoWorseThanNoise(comparison, noise);
+});
+
+test("a plain saved page renders exactly like its source", options, async () => {
+	const { comparison, noise } = await compareSaveWithSource("duplicate-stylesheet", []);
+	assertNoWorseThanNoise(comparison, noise);
+});
+
+// The pixels say the page still draws the same picture; they cannot say the element that draws it
+// is still the element the page named. An id a script looks up and a class a selector matches are
+// invisible until something goes looking for them, so they are read out of the save directly.
+test("the archived page keeps the attributes of the stylesheets it rewrites", options, async () => {
+	const { saved } = await compareSaveWithSource("duplicate-stylesheet", ["--compress-content"]);
+	const page = await readArchiveEntry(saved, "index.html");
+	assert.match(page, /id=palette/, "the id of the folded stylesheet was dropped");
+	assert.match(page, /class=theme/, "the class of the folded stylesheet was dropped");
+	assert.match(page, /data-role=tokens/, "the data attribute of the folded stylesheet was dropped");
+	// the point of folding them is that the content is stored once. A page that still carries the
+	// declarations inline as well is the bug this fixture was built for, and it passes every
+	// assertion above
+	assert.doesNotMatch(page, /--accent:/, "the folded stylesheet is still stored inline in the page");
+});
+
+// the saved file is a self-extracting archive: what a reader sees as the page is an entry inside
+// the zip, and the wrapper around it holds none of the markup being asserted on
+async function readArchiveEntry(data, filename) {
+	configure({ useWebWorkers: false });
+	const entries = await new ZipReader(new Uint8ArrayReader(data)).getEntries();
+	const entry = entries.find(entry => entry.filename == filename);
+	assert.ok(entry, "the archive holds no entry named " + filename);
+	return entry.getData(new TextWriter());
+}
+
+// The mirror of the check above, on the other path. A plain save has nowhere to put an external
+// stylesheet, so the link becomes a style element built from the media and the text — and the id a
+// script looks up, the class a selector matches and the data attribute it reads were all left
+// behind, on every plain save of every page with an external stylesheet.
+test("a plain saved page keeps the attributes of the stylesheet it inlines", options, async () => {
+	const { comparison, noise, saved } = await compareSaveWithSource("linked-stylesheet", []);
+	assertNoWorseThanNoise(comparison, noise);
+	const [openingTag] = new TextDecoder().decode(saved).match(/<style[^>]*>/) || [];
+	assert.ok(openingTag, "the saved page holds no style element");
+	["id=theme", "class=site-theme", "data-role=tokens", "title=\"Site theme\""].forEach(attribute =>
+		assert.ok(openingTag.includes(attribute), "the style element lost " + attribute + ": " + openingTag));
+	// what the link used to fetch its stylesheet means nothing on the element now holding it
+	assert.doesNotMatch(openingTag, /\brel=|\bhref=/, "the style element kept an attribute of the link: " + openingTag);
+});
+
+test("an archived page with an external stylesheet renders exactly like its source", options, async () => {
+	const { comparison, noise } = await compareSaveWithSource("linked-stylesheet", ["--compress-content"]);
+	assertNoWorseThanNoise(comparison, noise);
+});
+
+// The font minifier keeps a declared face when something on the page draws with it, and the three
+// samples name their family in the three ways it has to read. It has given up on all three at some
+// point: a property declared on a descendant resolved to nothing, the shorthand was unreadable, and
+// a name that could not be resolved switched pruning off for the whole document.
+test("a saved page still draws with the fonts it used", options, async () => {
+	const { comparison, noise } = await compareSaveWithSource("used-fonts", []);
+	assertNoWorseThanNoise(comparison, noise);
+});
+
+// keeping every face renders identically to keeping the right ones, so the half of the contract the
+// pixels cannot see is read out of the save: the faces nothing draws with are gone, and the three
+// the page draws with are still declared
+test("a saved page drops the fonts it did not use", options, async () => {
+	const { saved } = await compareSaveWithSource("used-fonts", []);
+	assert.deepEqual(getDeclaredFontFamilies(saved).sort(), ["Fidelity Band", "Fidelity Bar", "Fidelity Block"]);
+});
+
+// the faces are read out of the @font-face rules rather than looked for anywhere in the page: a
+// family name also appears in the declarations that USE it, and a check that searched the whole
+// text called a pruned face present because the custom property naming it was still there
+function getDeclaredFontFamilies(saved) {
+	return new TextDecoder().decode(saved).split("@font-face").slice(1).map(rule => {
+		const [, quoted, single, plain] = rule.match(/font-family:\s*(?:"([^"]*)"|'([^']*)'|([^;}]*))/) || [];
+		return (quoted || single || plain || "").trim();
+	});
+}
+
+test("a saved page keeps the fonts declared inside a frame it cannot read", options, async () => {
+	const { comparison, noise } = await compareSaveWithSource("frame-fonts", []);
+	assertNoWorseThanNoise(comparison, noise);
+});
+
+// A family drawn in a style it declares no face for is drawn by the browser slanting or thickening
+// the face it has. It is still the family being used, and narrowing the used list to the faces that
+// match the computed style dropped it from the page that draws it — while the upright sample kept
+// the list non-empty, so nothing else noticed.
+test("a saved page keeps a font drawn in a style it declares no face for", options, async () => {
+	const { comparison, noise, saved } = await compareSaveWithSource("synthetic-italic", []);
+	assertNoWorseThanNoise(comparison, noise);
+	assert.deepEqual(getDeclaredFontFamilies(saved).sort(), ["Fidelity Bar", "Fidelity Block"]);
+});
+
+// The two halves of what happens when a family cannot be resolved from the stylesheets. The face
+// the browser drew with has to survive — the rendered list is the only thing left that names it —
+// and the faces nothing drew have to go, which is the half that says the document was pruned at all
+// rather than given up on. Both are needed: keeping everything passes the first check alone.
+test("a saved page keeps a font named through a value it cannot resolve", options, async () => {
+	const { comparison, noise } = await compareSaveWithSource("unresolved-font-property", []);
+	assertNoWorseThanNoise(comparison, noise);
+});
+
+test("a value it cannot resolve does not stop the rest of the page being pruned", options, async () => {
+	const { saved } = await compareSaveWithSource("unresolved-font-property", []);
+	assert.deepEqual(getDeclaredFontFamilies(saved), ["Fidelity Block"],
+		"one unreadable value decided what happens to every face the page declares");
+});
+
+function assertNoWorseThanNoise(comparison, noise) {
+	assert.ok(comparison.differing <= noise.differing, describe(comparison, noise));
+}
+
+// a failure that says "1382914 pixels differ" is a failure nobody can act on: the report names the
+// bands, so the first thing read is where on the page the two renderings parted company
+function describe(comparison, noise) {
+	const worst = comparison.bands
+		.filter(band => band.differing > 0)
+		.sort((first, second) => second.differing - first.differing)
+		.slice(0, 3)
+		.map(band => `\trows ${band.top}-${band.bottom}: ${band.differing} of ${band.total} pixels`);
+	return [
+		`the saved page does not render like its source: ${comparison.differing} of ${comparison.total} pixels differ`,
+		`\tnoise floor (the same source captured twice): ${noise.differing} pixels`,
+		comparison.sizeMatches ? "\tboth renderings are the same size" : `\tthe renderings are NOT the same size (union ${comparison.width}x${comparison.height})`,
+		...worst
+	].join("\n");
+}
+
+async function compareSaveWithSource(fixtureName, saveOptions) {
+	// the whole pages directory is served, not one fixture: the fonts sit beside the fixtures and
+	// are shared, so that regenerating them cannot leave one copy behind and one up to date
+	const server = await startServer(PAGES_DIRECTORY);
+	const url = server.url + fixtureName + "/";
+	const directory = await mkdtemp(join(tmpdir(), "single-file-fidelity-"));
+	try {
+		// the control is captured first and last is never assumed: the source is rendered twice
+		// before anything is saved, and the two shots set the floor the save is measured against
+		const source = await browser.capture(url);
+		const noise = await browser.compare(source, await browser.capture(url));
+		const savedPath = join(directory, "saved.html");
+		// the default conflict action is to uniquify, which writes "saved (2).html" and leaves the
+		// stale file exactly where the test looks for it
+		await rm(savedPath, { force: true });
+		// the save gets its own limit: a browser that never answers would otherwise be reported
+		// as the check timing out, which says nothing about where it stopped
+		await execFileAsync(process.execPath, ["single-file-node.js", url, savedPath, ...saveOptions], { cwd: cliDirectory, timeout: SAVE_TIMEOUT });
+		const comparison = await browser.compare(source, await browser.capture(pathToFileURL(savedPath).href));
+		// asserted rather than returned: a fixture that asks for something the server does not have
+		// is not a result to interpret, it is a fixture to fix
+		assert.deepEqual(server.misses, [], "the fixture asked for files the server does not have");
+		return { comparison, noise, saved: new Uint8Array(await readFile(savedPath)) };
+	} finally {
+		await rm(directory, { recursive: true, force: true });
+		await server.close();
+	}
+}

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

@@ -7,13 +7,12 @@ 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 { join } from "node:path";
 import { Buffer } from "node:buffer";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 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 = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==", "base64");

package/test/e2e/http-header.test.js

@@ -7,12 +7,11 @@ 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 { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("extra HTTP headers do not make cross-origin resources send a preflight", { timeout: 120000 }, async () => {
 	const STYLE = "rgb(11,22,33)";

package/test/e2e/oopif.test.js

@@ -7,12 +7,11 @@ 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 { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const FRAME_MARKER = "OUT_OF_PROCESS_FRAME_CONTENT";
 
 test("blocked URL patterns and extra HTTP headers apply in cross-origin frames", { timeout: 120000 }, async () => {

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

@@ -5,13 +5,12 @@ 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 { join } from "node:path";
 import { Buffer } from "node:buffer";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 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: 120000 }, async () => {

package/test/e2e/saved-page-opens.test.js

@@ -0,0 +1,79 @@
+/* global URL */
+
+// Every other test in this suite reads a capture as bytes: zip fields, entry names, JSON shape.
+// None of them opened one. That is how single-file-cli 2.6.0 and 2.6.1 shipped producing
+// self-extracting archives that rendered a blank page — the zip was valid, `index.html` was
+// correct, every assertion those tests make stayed true, and the script that unpacks the archive
+// in the browser threw `ReferenceError` before writing anything.
+//
+// So this file asserts the only thing a user actually cares about: the saved file opens, its
+// console is clean, and the page that appears is the page that was saved. It captures a marker,
+// then re-captures the saved file from a file:// URL and looks for that marker in the result —
+// a capture of a blank page cannot contain it.
+
+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 } from "node:path";
+import { pathToFileURL } from "node:url";
+import process from "node:process";
+import { cliDirectory } from "../target.js";
+
+const execFileAsync = promisify(execFile);
+const TEST_TIMEOUT = 180000;
+const MARKER = "single-file-render-marker-9f2c";
+const PAGE = "<html><head><title>Saved Page</title></head><body><p id=\"marker\">" + MARKER + "</p></body></html>";
+
+test("a self-extracting archive opens with no console error and shows the saved page", { timeout: TEST_TIMEOUT }, async () => {
+	const { consoleMessages, reopened } = await captureAndReopen(["--compress-content"]);
+	assertNoConsoleError(consoleMessages);
+	assert.ok(reopened.includes(MARKER), "the reopened archive does not contain the saved content");
+});
+
+test("a plain saved page opens with no console error and shows the saved page", { timeout: TEST_TIMEOUT }, async () => {
+	const { consoleMessages, reopened } = await captureAndReopen([]);
+	assertNoConsoleError(consoleMessages);
+	assert.ok(reopened.includes(MARKER), "the reopened page does not contain the saved content");
+});
+
+function assertNoConsoleError(consoleMessages) {
+	const errors = consoleMessages.filter(message => message.level === "error");
+	assert.deepEqual(errors.map(message => message.text), [], "the saved page logged errors when opened");
+}
+
+async function captureAndReopen(options) {
+	const server = createServer((request, response) => {
+		const { pathname } = new URL(request.url, "http://localhost");
+		if (pathname === "/") {
+			response.writeHead(200, { "content-type": "text/html" }).end(PAGE);
+		} 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 savedPath = join(directory, "saved.html");
+		await runCli(["http://localhost:" + server.address().port + "/", savedPath, ...options]);
+		// re-capturing the saved file runs it in the browser: whatever the page ends up displaying
+		// is what gets written out, so a page that failed to render comes back without the marker
+		const reopenedPath = join(directory, "reopened.html");
+		const consolePath = join(directory, "console.json");
+		await runCli([pathToFileURL(savedPath).href, reopenedPath, "--console-messages-file", consolePath]);
+		return {
+			consoleMessages: JSON.parse(await readFile(consolePath, "utf-8")),
+			reopened: await readFile(reopenedPath, "utf-8")
+		};
+	} finally {
+		await rm(directory, { recursive: true });
+		server.close();
+	}
+}
+
+function runCli(args) {
+	return execFileAsync(process.execPath, ["single-file-node.js", ...args], { cwd: cliDirectory });
+}

package/test/e2e/service-worker.test.js

@@ -7,12 +7,11 @@ 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 { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 // the worker fetches a marked URL instead of passing the request through, so a
 // request reaching the server proves the service worker is the one that made it

package/test/e2e/timeouts.test.js

@@ -8,12 +8,11 @@ import { promisify } from "node:util";
 import { mkdtemp, rm } from "node:fs/promises";
 import { Buffer } from "node:buffer";
 import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("load timeout is reported when the page never loads", { timeout: 120000 }, async () => {
 	const server = createServer(() => { });

package/test/e2e/urls-file.test.js

@@ -5,12 +5,11 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import process from "node:process";
+import { cliDirectory } from "../target.js";
 
 const execFileAsync = promisify(execFile);
-const cliDirectory = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 test("duplicate urls in a urls file are captured once", { timeout: 120000 }, async () => {
 	const server = createServer((_, response) => response