single-file-core 1.5.128 → 1.5.130

package/core/index.js

@@ -31,6 +31,7 @@ const DEBUG = false;
 const Set = globalThis.Set;
 const Map = globalThis.Map;
 const JSON = globalThis.JSON;
+const URL = globalThis.URL;
 
 let util;
 
@@ -160,7 +161,7 @@ const STAGES = [{
 		{ action: "cleanupPage" }
 	],
 	parallel: [
-		{ option: "enableMaff", action: "insertMAFFMetaData" },
+		{ option: "readMaffMetadata", action: "readMAFFMetaData" },
 		{ action: "setDocInfo" }
 	]
 }, {
@@ -421,6 +422,9 @@ const SHADOWROOT_DELEGATES_FOCUS = "shadowrootdelegatesfocus";
 const SHADOWROOT_CLONABLE = "shadowrootclonable";
 const SHADOWROOT_SERIALIZABLE = "shadowrootserializable";
 const SCRIPT_OPTIONS = "data-single-file-options";
+const JAVASCRIPT_URI_PROTOCOL = "javascript:";
+const DISABLED_SCRIPT_URI = "javascript:void(0)";
+const SCRIPT_URI_ATTRIBUTE_NAMES = ["href", "src", "action", "formaction", "data"];
 const UTF8_CHARSET = "utf-8";
 const TAINTED_CANVAS_WARNING_MESSAGE = "SingleFile: canvas elements tainted by a cross-origin resource, dropped from the page:";
 
@@ -448,7 +452,7 @@ class Processor {
 	initialize() {
 		this.options.saveDate = new Date();
 		this.options.saveUrl = this.options.url;
-		if (this.options.enableMaff) {
+		if (this.options.readMaffMetadata) {
 			this.maffMetaDataPromise = this.batchRequest.addURL(util.resolveURL("index.rdf", this.options.baseURI || this.options.url), { expectedType: "document" });
 		}
 		this.maxResources = this.batchRequest.getMaxResources();
@@ -464,7 +468,7 @@ class Processor {
 			content = await util.getContent(this.baseURI, {
 				inline: !this.options.compressContent,
 				maxResourceSize: this.options.maxResourceSize,
-				maxResourceSizeEnabled: this.options.maxResourceSizeEnabled,
+				maxResourceSizeEnabled: this.options.maxResourceSizeEnabled && !this.options.rootDocument,
 				charset,
 				frameId: this.options.windowId,
 				resourceReferrer: this.options.resourceReferrer,
@@ -497,7 +501,7 @@ class Processor {
 		}
 		this.workStyleElement = this.doc.createElement("style");
 		this.doc.body.appendChild(this.workStyleElement);
-		this.onEventAttributeNames = getOnEventAttributeNames(this.doc);
+		this.onEventAttributeNames = new Set(getOnEventAttributeNames(this.doc));
 	}
 
 	finalize() {
@@ -676,7 +680,7 @@ class Processor {
 			optionsElement.type = "application/json";
 			optionsElement.setAttribute(SCRIPT_OPTIONS, "");
 			optionsElement.textContent = JSON.stringify({
-				saveUrl: this.options.url,
+				saveUrl: this.options.saveUrl,
 				saveDate: this.options.saveDate.getTime(),
 				visitDate: (this.options.visitDate || this.options.saveDate).getTime(),
 				filenameTemplate: this.options.filenameTemplate,
@@ -852,18 +856,16 @@ class Processor {
 	}
 
 	removeEmbedScripts() {
-		const JAVASCRIPT_URI_PREFIX = "javascript:";
-		const DISABLED_SCRIPT = "javascript:void(0)";
-		this.onEventAttributeNames.forEach(attributeName => this.doc.querySelectorAll("[" + attributeName + "]").forEach(element => element.removeAttribute(attributeName)));
-		this.doc.querySelectorAll("[href]").forEach(element => {
-			if (element.href && element.href.match && element.href.trim().startsWith(JAVASCRIPT_URI_PREFIX)) {
-				element.setAttribute("href", DISABLED_SCRIPT);
-			}
-		});
-		this.doc.querySelectorAll("[src]").forEach(element => {
-			if (element.src && element.src.trim().startsWith(JAVASCRIPT_URI_PREFIX)) {
-				element.setAttribute("src", DISABLED_SCRIPT);
-			}
+		this.doc.querySelectorAll("*").forEach(element => {
+			Array.from(element.attributes).forEach(attribute => {
+				const localName = attribute.localName || attribute.name;
+				const attributeName = localName.toLowerCase();
+				if (this.onEventAttributeNames.has(attributeName)) {
+					element.removeAttributeNS(attribute.namespaceURI, localName);
+				} else if (SCRIPT_URI_ATTRIBUTE_NAMES.includes(attributeName) && isScriptURI(attribute.value)) {
+					element.setAttributeNS(attribute.namespaceURI, attribute.name, DISABLED_SCRIPT_URI);
+				}
+			});
 		});
 		const scriptElements = this.doc.querySelectorAll("script:not([type=\"application/ld+json\"]):not([" + SCRIPT_OPTIONS + "])");
 		this.stats.set("discarded", "scripts", scriptElements.length);
@@ -1647,7 +1649,7 @@ class Processor {
 		this.doc.documentElement.style.removeProperty("-sf-min-height");
 	}
 
-	async insertMAFFMetaData() {
+	async readMAFFMetaData() {
 		const maffMetaData = await this.maffMetaDataPromise;
 		if (maffMetaData && maffMetaData.content) {
 			const NAMESPACE_RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
@@ -1655,7 +1657,10 @@ class Processor {
 			const originalURLElement = maffDoc.querySelector("RDF > Description > originalurl");
 			const archiveTimeElement = maffDoc.querySelector("RDF > Description > archivetime");
 			if (originalURLElement) {
-				this.options.saveUrl = originalURLElement.getAttributeNS(NAMESPACE_RDF, "resource");
+				const value = originalURLElement.getAttributeNS(NAMESPACE_RDF, "resource");
+				if (value) {
+					this.options.saveUrl = value;
+				}
 			}
 			if (archiveTimeElement) {
 				const value = archiveTimeElement.getAttributeNS(NAMESPACE_RDF, "resource");
@@ -1709,6 +1714,14 @@ function normalizeURL(url) {
 	}
 }
 
+function isScriptURI(value) {
+	try {
+		return new URL(value).protocol == JAVASCRIPT_URI_PROTOCOL;
+	} catch {
+		return false;
+	}
+}
+
 function getOnEventAttributeNames(doc) {
 	const element = doc.body || doc.createElement("div");
 	const attributeNames = [];

package/core/infobar.js

@@ -75,6 +75,21 @@ const INFOBAR_STYLES = `
   animation-iteration-count: 2;
 }
 
+.infobar:not(:focus-within):not(.infobar-focus)::after {
+  content: "";
+  position: absolute;
+  inset: -2px;
+  border: 2px solid #dd6a00;
+  border-radius: inherit;
+  opacity: 0;
+  pointer-events: none;
+  animation-name: ripple;
+  animation-duration: 3s;
+  animation-timing-function: ease-out;
+  animation-delay: 2s;
+  animation-iteration-count: 3;
+}
+
 .infobar:valid, .infobar:not(:focus-within):not(.infobar-focus) .infobar-content {
   display: none;
 }
@@ -126,10 +141,28 @@ const INFOBAR_STYLES = `
 
 @keyframes flash {
   0%, 100% {
-	background-color: #737373;
+    background-color: #737373;
   }
   50% {
-	background-color: #dd6a00;
+    background-color: #dd6a00;
+  }
+}
+
+@keyframes ripple {
+  0% {
+    transform: scale(1);
+    opacity: 1;
+  }
+  45%, 100% {
+    transform: scale(2);
+    opacity: 0;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .infobar,
+  .infobar:not(:focus-within):not(.infobar-focus)::after {
+    animation-name: none;
   }
 }
 

package/core/lib/processor-helper-inline.js

@@ -562,7 +562,7 @@ function getProcessorHelperClass(utilInstance) {
 		}
 
 		setMetaCSP(metaElement) {
-			metaElement.content = "default-src 'none'; font-src 'self' data:; img-src 'self' data:; style-src 'unsafe-inline'; media-src 'self' data:; script-src 'unsafe-inline' data:; object-src 'self' data:; frame-src 'self' data:;";
+			metaElement.content = "default-src 'none'; font-src 'self' data:; img-src 'self' data:; style-src 'unsafe-inline'; media-src 'self' data:; script-src 'unsafe-inline' data:; object-src 'self' data:; frame-src 'self' data:; form-action 'none'; base-uri 'none';";
 		}
 
 		removeUnusedStylesheets(doc) {

package/core/lib/processor-helper.js

@@ -488,7 +488,7 @@ function getProcessorHelperClass(utilInstance) {
 		}
 
 		setMetaCSP(metaElement) {
-			metaElement.content = "default-src 'none'; connect-src 'self' data: blob:; font-src 'self' data: blob:; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline' data: blob:; frame-src 'self' data: blob:; media-src 'self' data: blob:; script-src 'self' 'unsafe-inline' data: blob:; object-src 'self' data: blob:;";
+			metaElement.content = "default-src 'none'; connect-src 'self' data: blob:; font-src 'self' data: blob:; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline' data: blob:; frame-src 'self' data: blob:; media-src 'self' data: blob:; script-src 'self' 'unsafe-inline' data: blob:; object-src 'self' data: blob:; form-action 'none'; base-uri 'none';";
 		}
 
 		removeUnusedStylesheets() {

package/deno.lock

@@ -0,0 +1,19 @@
+{
+  "version": "5",
+  "specifiers": {
+    "jsr:@b-fuze/deno-dom@0.1.56": "0.1.56"
+  },
+  "jsr": {
+    "@b-fuze/deno-dom@0.1.56": {
+      "integrity": "8030e2dc1d8750f1682b53462ab893d9c3470f2287feecbe22f44a88c54ab148"
+    }
+  },
+  "workspace": {
+    "packageJson": {
+      "dependencies": [
+        "npm:@eslint/js@^9.39.5",
+        "npm:eslint@^10.9.1"
+      ]
+    }
+  }
+}

package/doc/singlefile-archive.md

@@ -1079,13 +1079,31 @@ trailing bytes open it (§8.1). The parser closes the open
 comment or element at end of file, and `</body></html>` are implied, so the page
 renders the same.
 
-Relocation is not a move at constant size, and it can end either way. Two effects pull
-against each other: the room the writer sets aside, which in the reference writer is
-`Math.ceil(length * 1.01) + 32` bytes — a percentage of the payload plus a constant, so
-the constant dominates a small payload and the percentage a large one — and the 17 bytes
-of wrapper terminator and end tags it stops emitting. Measured on three files the net ran
-from 9 bytes saved to 190 bytes spent, so a writer sizing a file should quote that range
-rather than a single figure.
+Relocation moves the element rather than copying it, but it is not a move at constant
+size, and wherever there is an element to move it costs bytes. The appended placement
+emits the wrapper terminator, the element and the end tags, the element plus 17; the
+relocated placement emits none of those and reserves room ahead of the archive instead,
+`Math.ceil(length * 1.01) + 32` bytes in the reference writer, where *length* is the
+element with its tags. The net is that reservation less the element and less the 17
+bytes, so about one percent of the element plus fifteen: what relocation costs is the
+margin, not a second copy. Measured on elements from 61 to 17577 bytes the formula holds
+to within a few bytes, the residual being the element itself changing length between the
+two passes, since the reservation lengthens the prologue and moves every
+central-directory offset with it. The wrapper rung sets the constant: fifteen bytes
+behind a comment, nine behind `</script>` or `]]></svg>`, six behind `</plaintext>`.
+With extraction disabled there is no element and nothing is reserved, so suppressing the
+appended run drops those 17 bytes and nothing else.
+
+The two cases a writer meets differ by an order of magnitude, and the budget is what
+separates them. A relocation forced by `preventAppendedData` acts on whatever element
+exists, which on a small archive is small: 16 bytes on a 2848-byte ZIP region, 35 bytes
+on a 1.3 MB one. A relocation the budget triggers cannot be cheap, because it happens
+only once the element no longer fits: at the default 16361 that means an element past
+16344 bytes, and 185 bytes measured on a 12.7 MB region is near the least it can cost.
+It keeps rising from there, since a relocated element sits in the prologue and no comment
+ceiling bounds it — at the ratio above, a 40 MB archive carries roughly 57 KB of element
+and costs roughly 590 bytes. A writer sizing a file should compute the cost from the
+element it produced rather than quote any of these figures.
 
 ### 5.3 Offset bookkeeping
 

package/eslint.config.mjs

@@ -56,5 +56,19 @@ export default [
 		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/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "single-file-core",
-	"version": "1.5.128",
+	"version": "1.5.130",
 	"description": "SingleFile Core",
 	"author": "Gildas Lormeau",
 	"license": "AGPL-3.0-or-later",
 	"scripts": {
-		"test": "deno run --allow-read test/sfz-harness/format-rules.js && deno run --allow-read test/sfz-harness/stored-trigger.js && deno run --allow-read test/sfz-harness/check-determinism.js && deno run --allow-read test/sfz-harness/option-wiring.js && deno run --allow-read test/sfz-harness/css-property-filter.js && deno run --allow-read test/sfz-harness/adopted-stylesheets-hook.js && deno run --allow-read test/sfz-harness/css-fonts-minifier.js && deno run --allow-read test/sfz-harness/font-face-composite.js && deno run --allow-read test/sfz-harness/inlined-functions.js && deno run --allow-read test/sfz-harness/pages-archive.js && deno run --allow-read test/sfz-harness/pages-router.js && deno run --allow-read test/sfz-harness/filename-max-length.js && deno run --allow-read test/sfz-harness/content-type-sniffing.js && deno run --allow-read test/sfz-harness/entry-compression.js && deno run --allow-read test/sfz-harness/filename-characters.js && deno run --allow-read test/sfz-harness/byte-map.js && deno run --allow-read test/sfz-harness/zip64.js && deno run --allow-read test/sfz-harness/charset-round-trip.js",
+		"test": "deno run --allow-read --allow-run test/run.js",
 		"bump-patch": "npm version patch --no-git-tag-version && npm run bump-commit",
 		"bump-minor": "npm version minor --no-git-tag-version && npm run bump-commit",
 		"bump-major": "npm version major --no-git-tag-version && npm run bump-commit",

package/processors/compression/compression-packager.js

@@ -67,7 +67,7 @@ async function createPagesArchive(pages, options) {
 	}
 	const manifest = {
 		pages: pages.map((page, pageIndex) => ({
-			path: getPagePath(pageIndex),
+			path: getPagePath(pageIndex, options.createRootDirectory),
 			url: page.url,
 			originalUrls: page.originalUrls,
 			title: page.title
@@ -97,7 +97,7 @@ async function createPagesArchive(pages, options) {
 	const aliases = {};
 	const blob = await createArchive(pageData, archiveOptions, options.zipScript, async zipWriter => {
 		for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
-			const pagePath = getPagePath(pageIndex);
+			const pagePath = getPagePath(pageIndex, options.createRootDirectory);
 			const zipReader = new ZipReader(new Uint8ArrayReader(await pages[pageIndex].getData()));
 			for (const entry of await zipReader.getEntries()) {
 				const filename = pagePath + entry.filename;
@@ -163,8 +163,8 @@ function getRelativePath(filename, targetFilename) {
 	return "../".repeat(baseSegments.length) + targetSegments.join("/");
 }
 
-function getPagePath(pageIndex) {
-	return pageIndex == 0 ? "" : PAGES_PREFIX + (pageIndex + 1) + "/";
+function getPagePath(pageIndex, createRootDirectory) {
+	return pageIndex == 0 && !createRootDirectory ? "" : PAGES_PREFIX + (pageIndex + 1) + "/";
 }
 
 function getComment(url, options) {

package/processors/compression/compression.js

@@ -132,7 +132,8 @@ export {
 	process,
 	createArchive,
 	escapeHTML,
-	PROCESS_OPTION_NAMES
+	PROCESS_OPTION_NAMES,
+	DEFAULT_MAX_APPENDED_DATA_LENGTH
 };
 
 async function process(pageData, options, lastModDate = new Date()) {

package/single-file.js

@@ -91,7 +91,7 @@ async function getPageData(options = {}, initOptions, doc, win) {
 	}
 	options.doc = doc;
 	options.win = win;
-	options.insertCanonicalLink = true;
+	options.insertCanonicalLink = options.insertCanonicalLink === undefined ? true : options.insertCanonicalLink;
 
 	const externalOnProgress = options.onprogress;
 	options.onprogress = async event => {

package/test/capture/README.md

@@ -0,0 +1,74 @@
+# 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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,72 @@
+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,
+	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/dom.js

@@ -0,0 +1,26 @@
+// 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);
+};