single-file-core 1.6.0 → 1.6.2

package/eslint.config.mjs

@@ -1,74 +0,0 @@
-import js from "@eslint/js";
-
-export default [
-	{
-		ignores: [
-			"vendor/**",
-			"zip-build/lib/**"
-		]
-	},
-	js.configs.recommended,
-	{
-		languageOptions: {
-			ecmaVersion: 2025,
-			sourceType: "module",
-			globals: {
-				console: "readonly",
-			}
-		},
-		rules: {
-			"linebreak-style": [
-				"error",
-				"unix"
-			],
-			"quotes": [
-				"error",
-				"double"
-			],
-			"semi": [
-				"error",
-				"always"
-			],
-			"no-console": [
-				"warn"
-			],
-			"no-empty": [
-				"error",
-				{
-					"allowEmptyCatch": true
-				}
-			]
-		}
-	},
-	{
-		files: ["test/sfz-harness/**"],
-		languageOptions: {
-			globals: {
-				Deno: "readonly",
-				setTimeout: "readonly",
-				Blob: "readonly",
-				TextDecoder: "readonly",
-				TextEncoder: "readonly",
-				URL: "readonly",
-				performance: "readonly"
-			}
-		},
-		rules: {
-			"no-console": "off"
-		}
-	},
-	{
-		files: ["test/capture/**", "test/run.js"],
-		languageOptions: {
-			globals: {
-				Deno: "readonly",
-				Response: "readonly",
-				TextDecoder: "readonly",
-				URL: "readonly"
-			}
-		},
-		rules: {
-			"no-console": "off"
-		}
-	}
-];

package/test/capture/README.md

@@ -1,74 +0,0 @@
-# Capture harness
-
-Tests that drive the real capture pipeline — `getPageData()`, `Processor`, `loadPage`, the batch
-fetch layer — in Deno, with an injected fetch and a parser instead of a browser. Every resource a
-capture asks for is served from a map declared in the suite, so there is no network and no page.
-
-It exists because the [SFZ harness](../sfz-harness/README.md) next door covers the archive writer and
-its neighbours, and nothing covered `core/index.js`. A defect in the capture pipeline could only be
-caught by driving Chrome from `single-file-cli`, in another repository, against a published build.
-
-Run them with Deno, from the repository root:
-
-```
-npm test
-```
-
-or this directory alone, through the same runner:
-
-```
-deno run --allow-read --allow-run test/run.js capture
-```
-
-or one suite at a time, which needs no runner:
-
-```
-deno run --allow-read test/capture/resource-cap.js
-```
-
-`common.js` and `dom.js` are named in the runner's `NOT_SUITES` list because they assert
-nothing. Every other `.js` file here is run.
-
-Unlike the SFZ harness, these download `@b-fuze/deno-dom` from JSR, so a cold cache needs network.
-The version is pinned in `dom.js` and `deno.lock` carries its integrity hash, so a cold run fetches
-that exact build or fails. `test/*` is ignored by `.gitignore` with one exception per directory, so a
-new test directory needs its own `!` line or nothing in it is ever committed.
-
-## The suites
-
-| Script | What it covers |
-|---|---|
-| `resource-cap.js` | That `maxResourceSize` applies to what the capture fetches and never to the page document itself. A page supplied as content is untouched, a page fetched by `saveRawPage` is untouched, an image over the cap is still dropped, frame content supplied as data is untouched, and a frame fetched in raw mode is still dropped. The raw-page case is a regression test: the cap used to empty the document, so a 2.5 MB page was saved as 525 bytes with no body, exit code 0 and no warning. |
-
-## How it works
-
-`dom.js` installs the globals core reads when its modules are evaluated — `DOMParser`, `Document`,
-`window`, `MutationObserver`. Import it before core, which is why `common.js` imports `single-file.js`
-dynamically.
-
-`common.js` exports `capture(resources, options)`, which returns the saved page as a string. Two
-things about it are forced by core rather than chosen. `init()` builds the util instance once per
-process and returns early ever after, so the injected fetch cannot be swapped per capture: one
-dispatcher is installed and `capture()` points it at the map for the run in progress. And a capture
-that passes no document never runs `preProcessDoc`, so the arrays it would have produced have to be
-supplied empty — `processWorklets` and its neighbours read `.length` with no guard.
-
-`frameData(windowId, baseURI, content)` builds the frame data a content script would have captured,
-matched to a frame element carrying the same window id. `html(body, head)` wraps a fixture.
-
-## What it cannot test
-
-Anything that reads a live document: `preProcessDoc`, `removeHiddenElements` and its marked elements,
-and the `getComputedStyle` callers in `core/infobar.js` and `modules/css-fonts-minifier.js`. Leave
-those options off here. The browser rigs in `single-file-cli` and `single-file-tests` cover them.
-
-deno-dom is not a browser parser. It materializes a whole `NodeList` when `children` is read, and
-`buildTrackIdMap` walks the tree child by child, so a fixture with 100k siblings overflows the stack.
-Size a fixture with long text in few elements.
-
-## Adding a case
-
-Same rule as the SFZ harness: add checks to the suite that already covers the area rather than making
-a file per rule, write the comment that says *why* the rule exists, and confirm the check can fail.
-For `resource-cap.js` that was done by reverting the `&& !this.options.rootDocument` conjunct in
-`core/index.js`: exactly one check goes red, which is the check that names it.

package/test/capture/canonical-link.js

@@ -1,50 +0,0 @@
-import { capture, html } from "./common.js";
-
-const PAGE_URL = "https://example.com/page.html";
-const FILE_URL = "file:///tmp/page.html";
-const PAGE = html("<h1>page</h1>");
-
-const resources = {
-	[PAGE_URL]: { body: PAGE },
-	[FILE_URL]: { body: PAGE }
-};
-
-let failed = false;
-
-// insertCanonicalLink was forced to true in single-file.js after the options were merged, so it read
-// as an option in three places and could be set from none: the CLI flag was written, measured doing
-// nothing, and removed again rather than shipped. It now defaults to true instead of being forced,
-// which is what makes the flag and the extension config key mean anything.
-{
-	const content = await capture(resources, { url: PAGE_URL, content: PAGE });
-	check("a canonical link is inserted by default", content.includes("rel=\"canonical\""), true);
-}
-
-{
-	const content = await capture(resources, { url: PAGE_URL, content: PAGE, insertCanonicalLink: false });
-	check("insertCanonicalLink false suppresses it", content.includes("rel=\"canonical\""), false);
-}
-
-{
-	const content = await capture(resources, { url: PAGE_URL, content: PAGE, insertCanonicalLink: true });
-	check("insertCanonicalLink true keeps it", content.includes("rel=\"canonical\""), true);
-}
-
-// The href guard is the reason the option is safe to default on: a page saved from disk has no
-// canonical URL to point at, and the element is skipped rather than written with a file: href.
-{
-	const content = await capture(resources, { url: FILE_URL, content: PAGE });
-	check("a page saved from file: gets no canonical link", content.includes("rel=\"canonical\""), false);
-}
-
-if (failed) {
-	console.log("FAILED");
-	Deno.exit(1);
-}
-console.log("OK");
-
-function check(label, actual, expected) {
-	const ok = actual === expected;
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
-	failed ||= !ok;
-}

package/test/capture/common.js

@@ -1,73 +0,0 @@
-import "./dom.js";
-
-const { init, getPageData, helper } = await import("../../single-file.js");
-
-const WIN_ID_ATTRIBUTE_NAME = helper.WIN_ID_ATTRIBUTE_NAME;
-
-// preProcessDoc fills these from the live document, and it only runs when a doc is passed. A capture
-// driven from here passes none, so the arrays it would have produced have to be supplied empty:
-// processWorklets and its neighbours read .length with no guard.
-const EMPTY_DOC_DATA = {
-	adoptedStyleSheets: [],
-	canvases: [],
-	fonts: [],
-	images: [],
-	posters: [],
-	referrer: "",
-	shadowRoots: [],
-	stylesheets: [],
-	usedFonts: [],
-	videos: [],
-	worklets: []
-};
-
-// init() builds the util instance once per process and returns early ever after, so the fetch cannot
-// be swapped per capture. One dispatcher is installed here and capture() points it at the resources
-// of the run in progress; captures are sequential, so nothing races.
-let resources = new Map();
-
-const initOptions = {
-	fetch: fetchResource,
-	frameFetch: fetchResource
-};
-
-init(initOptions);
-
-export {
-	capture,
-	frameData,
-	html,
-	helper,
-	WIN_ID_ATTRIBUTE_NAME
-};
-
-async function capture(pageResources, options) {
-	resources = pageResources instanceof Map ? pageResources : new Map(Object.entries(pageResources));
-	const pageData = await getPageData({ ...EMPTY_DOC_DATA, ...options }, initOptions, null, null);
-	return pageData.content;
-}
-
-function fetchResource(url) {
-	const resource = resources.get(url);
-	if (!resource) {
-		return Promise.resolve(new Response("", { status: 404 }));
-	}
-	const contentType = resource.contentType || "text/html";
-	return Promise.resolve(new Response(resource.body, {
-		status: resource.status || 200,
-		headers: { "content-type": contentType }
-	}));
-}
-
-// A frame whose content was captured by the content script arrives as frame data keyed by the window
-// id its element carries. Outside raw mode this is the only way a frame is ever filled.
-function frameData(windowId, baseURI, content) {
-	return { ...EMPTY_DOC_DATA, windowId, baseURI, content, scrollPosition: { x: 0, y: 0 } };
-}
-
-// deno-dom materializes a whole NodeList when children is read, and buildTrackIdMap walks the tree
-// child by child, so a fixture with 100k siblings overflows the stack. Size a fixture with long text
-// in few elements, never with many elements.
-function html(body, head = "") {
-	return "<!DOCTYPE html><html><head>" + head + "</head><body>" + body + "</body></html>";
-}

package/test/capture/deferred-content-options.js

@@ -1,71 +0,0 @@
-import { helper } from "./common.js";
-
-// The loadDeferredImages* options were renamed to loadDeferredContent* because they never applied to
-// images only: they govern every kind of deferred content, including frames and whole virtualized
-// message lists. The old names stay accepted because they are public API in two ways core cannot
-// see - a library caller passing them to getPageData, and another extension passing them through the
-// external capture API - so this suite pins the compatibility shim rather than the rename.
-
-const DEPRECATED_NAMES = {
-	loadDeferredImages: "loadDeferredContent",
-	loadDeferredImagesMaxIdleTime: "loadDeferredContentMaxIdleTime",
-	loadDeferredImagesBlockCookies: "loadDeferredContentBlockCookies",
-	loadDeferredImagesBlockStorage: "loadDeferredContentBlockStorage",
-	loadDeferredImagesKeepZoomLevel: "loadDeferredContentKeepZoomLevel",
-	loadDeferredImagesDispatchScrollEvent: "loadDeferredContentDispatchScrollEvent",
-	loadDeferredImagesBeforeFrames: "loadDeferredContentBeforeFrames"
-};
-
-let failed = false;
-
-{
-	for (const deprecatedName of Object.keys(DEPRECATED_NAMES)) {
-		const optionName = DEPRECATED_NAMES[deprecatedName];
-		const value = deprecatedName.endsWith("MaxIdleTime") ? 3000 : true;
-		const normalized = helper.normalizeOptions({ [deprecatedName]: value });
-		check(`${deprecatedName} fills ${optionName}`, normalized[optionName], value);
-	}
-}
-
-// A false or 0 must survive: testing the deprecated value for truthiness instead of for undefined
-// would silently drop every option a user turned off, which is the half that matters most here.
-{
-	const normalized = helper.normalizeOptions({ loadDeferredImages: false, loadDeferredImagesMaxIdleTime: 0 });
-	check("a deprecated false is carried over", normalized.loadDeferredContent, false);
-	check("a deprecated 0 is carried over", normalized.loadDeferredContentMaxIdleTime, 0);
-}
-
-{
-	const normalized = helper.normalizeOptions({ loadDeferredImages: false, loadDeferredContent: true });
-	check("the new name wins when both are set", normalized.loadDeferredContent, true);
-}
-
-// getPageData is handed the caller's own object, so filling the new names in place would edit an
-// object the caller still holds and may reuse for a second capture.
-{
-	const options = { loadDeferredImages: true };
-	const normalized = helper.normalizeOptions(options);
-	check("the caller's object is not mutated", options.loadDeferredContent, undefined);
-	check("a copy is returned instead", normalized.loadDeferredContent, true);
-}
-
-{
-	const options = { removeFrames: true };
-	check("an options object without deprecated names is returned as is", helper.normalizeOptions(options), options);
-}
-
-{
-	check("a missing options object is tolerated", helper.normalizeOptions(undefined), undefined);
-}
-
-if (failed) {
-	console.log("FAILED");
-	Deno.exit(1);
-}
-console.log("OK");
-
-function check(label, actual, expected) {
-	const ok = actual === expected;
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
-	failed ||= !ok;
-}

package/test/capture/dom.js

@@ -1,26 +0,0 @@
-// Three modules read globals when they are evaluated, so every one of them has to exist before core
-// is imported: core/util.js captures DOMParser, and processors/hooks/content/content-hooks-frames.js
-// reads globalThis.window, then calls init() and new MutationObserver(init) at module scope. That
-// hook belongs to the page world and does nothing useful here; it only has to load without throwing.
-// Import this module first and import single-file.js dynamically, the way common.js does.
-import { DOMParser, Document, Element } from "jsr:@b-fuze/deno-dom@0.1.56";
-
-globalThis.DOMParser = DOMParser;
-globalThis.Document = Document;
-globalThis.window = globalThis;
-globalThis.MutationObserver = class {
-	observe() { }
-	disconnect() { }
-};
-
-// deno-dom implements neither of these, so removeEmbedScripts throws here and nowhere else. Mapping
-// them onto the qualified-name methods is faithful for what deno-dom can represent, which is only
-// null-namespace attributes: it drops the prefix of xlink:href and lowercases nothing, so the
-// namespaced and mixed-case cases cannot be written as a fixture at all. Those are covered by the
-// browser suite in single-file-cli, which drives a real DOM.
-Element.prototype.setAttributeNS = function (namespaceURI, qualifiedName, value) {
-	this.setAttribute(qualifiedName, value);
-};
-Element.prototype.removeAttributeNS = function (namespaceURI, localName) {
-	this.removeAttribute(localName);
-};

package/test/capture/maff-metadata.js

@@ -1,205 +0,0 @@
-import "./dom.js";
-
-// core/util.js captures globalThis.DOMParser when it loads, and deno-dom throws on "text/xml", so
-// the MAFF metadata could not be parsed here at all. This substitutes a stub for that one mime type,
-// installed before common.js imports core, the same ordering constraint dom.js itself documents.
-//
-// What the stub stands for and what it does not. The two defects fixed alongside this suite are both
-// about what core does with what the parser HANDS BACK — an attribute that came back null, and which
-// of two almost-identical option fields gets written out — so a stub returning null or a string
-// covers them faithfully. It does NOT cover the parse: that `RDF > Description > originalurl` matches
-// `<RDF:RDF><RDF:Description><MAF:originalurl>` by local name, and that getAttributeNS resolves the
-// RDF prefix, are properties of a real XML DOM that only a browser suite can confirm.
-const XML_DOCUMENTS = new Map();
-const NativeDOMParser = globalThis.DOMParser;
-
-class StubXMLDocument {
-	constructor(values) {
-		this.values = values;
-	}
-	// undefined means the element is absent, null means it is present with no RDF:resource attribute
-	querySelector(selector) {
-		const localName = selector.split(">").pop().trim();
-		const value = this.values[localName];
-		return value === undefined ? null : { getAttributeNS: () => value };
-	}
-}
-
-globalThis.DOMParser = class {
-	parseFromString(content, mimeType) {
-		if (mimeType == "text/xml") {
-			return new StubXMLDocument(XML_DOCUMENTS.get(content) || {});
-		}
-		return new NativeDOMParser().parseFromString(content, mimeType);
-	}
-};
-
-const { capture, frameData, html, WIN_ID_ATTRIBUTE_NAME } = await import("./common.js");
-
-const PAGE_URL = "https://example.com/page.html";
-const RDF_URL = "https://example.com/index.rdf";
-const FRAME_URL = "https://example.com/frame-dir/frame.html";
-const FRAME_RDF_URL = "https://example.com/frame-dir/index.rdf";
-const ORIGINAL_URL = "https://original.example/real.html";
-const ARCHIVE_TIME = "Mon, 01 Jan 2024 10:20:30 GMT";
-const ARCHIVE_TIME_MS = new Date(ARCHIVE_TIME).getTime();
-const COMPLETE = { originalurl: ORIGINAL_URL, archivetime: ARCHIVE_TIME };
-const PAGE = html("<h1>page</h1>");
-const FRAME_PAGE = html("<h1>frame</h1>");
-const HOST_PAGE = html("<h1>host</h1><iframe src=\"" + FRAME_URL + "\" " + WIN_ID_ATTRIBUTE_NAME + "=\"0.1\"></iframe>");
-
-// The canonical link would be the obvious place to read the recovered url, but deno-dom reflects
-// neither the href nor the type property, so core's `element.href = ...` leaves no attribute behind.
-// Two observables survive that: the SingleFile comment, which core builds from options.saveUrl, and
-// the embedded options block, which is where the second defect lives.
-const OPTIONS_BLOCK = /<script data-single-file-options[^>]*>([^<]*)<\/script>/;
-
-let fixtureIndex = 0;
-
-function rdf(values) {
-	const content = "<?xml version=\"1.0\"?><!-- fixture " + (fixtureIndex++) + " -->";
-	XML_DOCUMENTS.set(content, values);
-	return content;
-}
-
-class CountingResources extends Map {
-	constructor(entries) {
-		super(entries);
-		this.counts = new Map();
-	}
-	get(key) {
-		this.counts.set(key, (this.counts.get(key) || 0) + 1);
-		return super.get(key);
-	}
-	countOf(key) {
-		return this.counts.get(key) || 0;
-	}
-}
-
-function resources(rdfContent) {
-	const entries = [
-		[PAGE_URL, { body: PAGE }],
-		[FRAME_URL, { body: FRAME_PAGE }]
-	];
-	if (rdfContent !== undefined) {
-		entries.push([RDF_URL, { body: rdfContent, contentType: "text/xml" }]);
-	}
-	return new CountingResources(entries);
-}
-
-function commentURL(content) {
-	const match = content.match(/ url: ([^\n]*)/);
-	return match && match[1].trim();
-}
-
-function embeddedOptions(content) {
-	const match = content.match(OPTIONS_BLOCK);
-	return match && JSON.parse(match[1]);
-}
-
-let failed = false;
-
-// readMaffMetadata is the new name of enableMaff, which was implemented in core and set by nothing:
-// no CLI flag, no config key, no UI anywhere. That is what made renaming it free, and exposing it is
-// what made the two defects below reachable by a user.
-{
-	const map = resources(rdf(COMPLETE));
-	const content = await capture(map, { url: PAGE_URL, content: PAGE, insertSingleFileComment: true });
-	check("index.rdf is not requested when the option is off", map.countOf(RDF_URL), 0);
-	check("the page url is saved when the option is off", commentURL(content), PAGE_URL);
-}
-
-{
-	const map = resources(rdf(COMPLETE));
-	const content = await capture(map, { url: PAGE_URL, content: PAGE, readMaffMetadata: true, insertSingleFileComment: true });
-	check("index.rdf is requested when the option is on", map.countOf(RDF_URL), 1);
-	check("the original url is recovered", commentURL(content), ORIGINAL_URL);
-}
-
-// THE CRASH. An originalurl with no RDF:resource made getAttributeNS return null, saveUrl became
-// null, and the canonical link then called .match() on it and failed the whole capture with a
-// TypeError. The archivetime branch beside it had always guarded its own value, so the two halves of
-// one method disagreed with each other.
-{
-	let threw = false;
-	let content = "";
-	try {
-		content = await capture(resources(rdf({ originalurl: null, archivetime: ARCHIVE_TIME })), {
-			url: PAGE_URL,
-			content: PAGE,
-			readMaffMetadata: true,
-			insertSingleFileComment: true
-		});
-	} catch {
-		threw = true;
-	}
-	check("an originalurl with no resource attribute does not fail the capture", threw, false);
-	check("and the page url is kept", commentURL(content), PAGE_URL);
-}
-
-{
-	const content = await capture(resources(rdf({ originalurl: ORIGINAL_URL, archivetime: null })), {
-		url: PAGE_URL,
-		content: PAGE,
-		readMaffMetadata: true,
-		insertSingleFileComment: true
-	});
-	check("an archivetime with no resource attribute is tolerated", commentURL(content), ORIGINAL_URL);
-}
-
-{
-	const content = await capture(resources(), { url: PAGE_URL, content: PAGE, readMaffMetadata: true, insertSingleFileComment: true });
-	check("a missing index.rdf leaves the page url in place", commentURL(content), PAGE_URL);
-}
-
-// THE INCONSISTENCY. saveFilenameTemplateData wrote saveUrl from options.url, one line above writing
-// saveDate from the value MAFF had just recovered, so the embedded block paired the archive's date
-// with the extracted copy's path, and a recompute in the editor resolved {url-*} against the wrong
-// one. options.saveUrl and options.url are identical on every other code path, which is what let it
-// sit unnoticed.
-{
-	const content = await capture(resources(rdf(COMPLETE)), {
-		url: PAGE_URL,
-		content: PAGE,
-		readMaffMetadata: true,
-		saveFilenameTemplateData: true
-	});
-	const embedded = embeddedOptions(content);
-	check("the embedded options block exists", Boolean(embedded), true);
-	if (embedded) {
-		check("the embedded saveUrl is the recovered one", embedded.saveUrl, ORIGINAL_URL);
-		check("the embedded saveDate is the recovered one", embedded.saveDate, ARCHIVE_TIME_MS);
-	}
-}
-
-{
-	const content = await capture(resources(rdf(COMPLETE)), { url: PAGE_URL, content: PAGE, saveFilenameTemplateData: true });
-	const embedded = embeddedOptions(content);
-	check("the embedded saveUrl is the page url when the option is off", embedded && embedded.saveUrl, PAGE_URL);
-}
-
-// Only the root document reaches Processor.initialize, because Runner.run guards that call with
-// `if (this.root)`. That guard is the whole reason a page with twenty frames does not make twenty
-// pointless index.rdf requests, and nothing else pins it. Note initializeProcessor resets a list of
-// root-only options for frames and readMaffMetadata is deliberately NOT in it: next to this guard
-// such a reset is dead code, which is exactly what adding one and watching nothing change proved.
-{
-	const map = resources(rdf(COMPLETE));
-	const frames = [frameData("0.1", FRAME_URL, FRAME_PAGE)];
-	const content = await capture(map, { url: PAGE_URL, content: HOST_PAGE, frames, readMaffMetadata: true });
-	check("the root asks for its index.rdf", map.countOf(RDF_URL), 1);
-	check("a frame does not ask for one of its own", map.countOf(FRAME_RDF_URL), 0);
-	check("the frame is still captured", content.includes("frame"), true);
-}
-
-if (failed) {
-	console.log("FAILED");
-	Deno.exit(1);
-}
-console.log("OK");
-
-function check(label, actual, expected) {
-	const ok = actual === expected;
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
-	failed ||= !ok;
-}

package/test/capture/resource-cap.js

@@ -1,79 +0,0 @@
-import { capture, frameData, html, WIN_ID_ATTRIBUTE_NAME } from "./common.js";
-
-const PAGE_URL = "https://example.com/big.html";
-const HOST_URL = "https://example.com/host.html";
-const IMAGE_URL = "https://example.com/big.png";
-const PAGE_MARKER = "BIG PAGE MARKER";
-const HOST_MARKER = "HOST PAGE MARKER";
-
-// One paragraph of 2.1 MB rather than many small ones, for the reason common.js gives.
-const BIG_PAGE = html("<h1>" + PAGE_MARKER + "</h1><p>" + "filler ".repeat(300000) + "</p>");
-const HOST_PAGE = html("<h1>" + HOST_MARKER + "</h1><iframe src=\"" + PAGE_URL + "\" " + WIN_ID_ATTRIBUTE_NAME + "=\"0.1\"></iframe>");
-const IMAGE_PAGE = html("<h1>" + HOST_MARKER + "</h1><img src=\"" + IMAGE_URL + "\">");
-const BIG_IMAGE = new Uint8Array(2 * 1024 * 1024).fill(0x21);
-
-const resources = {
-	[PAGE_URL]: { body: BIG_PAGE },
-	[HOST_URL]: { body: HOST_PAGE },
-	[IMAGE_URL]: { body: BIG_IMAGE, contentType: "image/png" }
-};
-
-// One megabyte, so every fixture above is over it and the default of ten is not in the way.
-const CAP = { maxResourceSizeEnabled: true, maxResourceSize: 1 };
-
-let failed = false;
-
-// The content a browser captured is handed to core as a string and never fetched, so the cap has no
-// point at which it could fire. This is what every extension save and every non-raw CLI capture does.
-{
-	const content = await capture(resources, { url: PAGE_URL, content: BIG_PAGE, ...CAP });
-	check("a page supplied as content is never capped", content.includes(PAGE_MARKER), true);
-}
-
-// The regression test. loadPage fetches the document itself in raw mode, and until rootDocument was
-// excluded the cap emptied it: a 2.5 MB page came out as 525 bytes with no body at all, exit code 0
-// and no warning. The cap is documented to apply to "images, fonts, stylesheets, scripts, frames,
-// videos and audios", never to the page.
-{
-	const content = await capture(resources, { url: PAGE_URL, saveRawPage: true, ...CAP });
-	check("a raw page over the cap keeps its content", content.includes(PAGE_MARKER), true);
-}
-
-// The control for the test above: the same cap, in the same capture, still has to drop a resource.
-// A fix that exempted everything would pass the raw-page check and break the option.
-{
-	const capped = await capture(resources, { url: HOST_URL, content: IMAGE_PAGE, ...CAP });
-	const uncapped = await capture(resources, { url: HOST_URL, content: IMAGE_PAGE });
-	check("an image over the cap is left out", capped.includes("data:image/png;base64"), false);
-	check("the page holding it is kept", capped.includes(HOST_MARKER), true);
-	check("the same image is embedded with the cap off", uncapped.includes("data:image/png;base64"), true);
-}
-
-// Frame content captured by the content script arrives as data, like the top document above, so the
-// cap cannot reach it either.
-{
-	const frames = [frameData("0.1", PAGE_URL, BIG_PAGE)];
-	const content = await capture(resources, { url: HOST_URL, content: HOST_PAGE, frames, ...CAP });
-	check("a frame supplied as data is never capped", content.includes(PAGE_MARKER), true);
-	check("its host is kept", content.includes(HOST_MARKER), true);
-}
-
-// In raw mode there is no frame data: resolveFrameURLs pushes a frame with no content and its runner
-// fetches the frame document, which is the one caller the cap is meant for. Dropping it is correct.
-{
-	const content = await capture(resources, { url: HOST_URL, saveRawPage: true, ...CAP });
-	check("a raw frame over the cap is dropped", content.includes(PAGE_MARKER), false);
-	check("its host is kept", content.includes(HOST_MARKER), true);
-}
-
-if (failed) {
-	console.log("FAILED");
-	Deno.exit(1);
-}
-console.log("OK");
-
-function check(label, actual, expected) {
-	const ok = actual === expected;
-	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
-	failed ||= !ok;
-}