single-file-core 1.5.119 → 1.5.121

package/processors/hooks/content/content-hooks-frames-web.js

@@ -322,7 +322,7 @@
 							const rootBounds = getBoundingClientRectDefined ? rootBoundingRect : docBoundingRect;
 							const time = 0;
 							return { target, intersectionRatio, boundingClientRect, intersectionRect: boundingClientRect, isIntersecting, rootBounds, time };
-						}).filter(params => params.boundingClientRect.width && params.boundingClientRect.height);
+						}).filter(params => params.boundingClientRect.width && params.boundingClientRect.height > 1);
 						if (params.length) {
 							observer.callback.call(intersectionObserver, params, intersectionObserver);
 						}
@@ -349,6 +349,7 @@
 			delete globalThis._singleFileImage;
 		}
 		if (!keepZoomLevel) {
+			resetScreenSize();
 			dispatchResizeEvent();
 		}
 	}

package/processors/lazy/content/content-lazy-loader.js

@@ -33,6 +33,8 @@ const helper = {
 
 const MAX_IDLE_TIMEOUT_CALLS = 10;
 const ATTRIBUTES_MUTATION_TYPE = "attributes";
+const CHILD_LIST_MUTATION_TYPE = "childList";
+const STYLESHEET_TAG_NAMES = ["STYLE", "LINK"];
 
 const browser = globalThis.browser;
 const document = globalThis.document;
@@ -88,24 +90,25 @@ function triggerLazyLoading(options) {
 		let loadingImages;
 		const pendingImages = new Set();
 		const observer = new MutationObserver(async mutations => {
-			mutations = mutations.filter(mutation => mutation.type == ATTRIBUTES_MUTATION_TYPE);
-			if (mutations.length) {
-				const updated = mutations.filter(mutation => {
-					if (mutation.attributeName == "src") {
-						mutation.target.setAttribute(helper.LAZY_SRC_ATTRIBUTE_NAME, mutation.target.src);
-						mutation.target.addEventListener("load", onResourceLoad);
-					}
-					if (mutation.attributeName == "src" || mutation.attributeName == "srcset" ||
-						(mutation.target.tagName && mutation.target.tagName.toUpperCase() == "SOURCE")) {
-						return !mutation.target.classList || !mutation.target.classList.contains(helper.SINGLE_FILE_UI_ELEMENT_CLASS);
-					}
-				});
-				if (updated.length) {
-					loadingImages = true;
-					await deferForceLazyLoadEnd(observer, options, cleanupAndResolve);
-					if (!pendingImages.size) {
-						await deferLazyLoadEnd(observer, options, cleanupAndResolve);
-					}
+			const attributeMutations = mutations.filter(mutation => mutation.type == ATTRIBUTES_MUTATION_TYPE);
+			const insertedStylesheets = mutations.filter(mutation => mutation.type == CHILD_LIST_MUTATION_TYPE &&
+				Array.from(mutation.addedNodes).some(node => node.tagName && STYLESHEET_TAG_NAMES.includes(node.tagName.toUpperCase()) &&
+					(!node.classList || !node.classList.contains(helper.SINGLE_FILE_UI_ELEMENT_CLASS))));
+			const updated = attributeMutations.filter(mutation => {
+				if (mutation.attributeName == "src") {
+					mutation.target.setAttribute(helper.LAZY_SRC_ATTRIBUTE_NAME, mutation.target.src);
+					mutation.target.addEventListener("load", onResourceLoad);
+				}
+				if (mutation.attributeName == "src" || mutation.attributeName == "srcset" ||
+					(mutation.target.tagName && mutation.target.tagName.toUpperCase() == "SOURCE")) {
+					return !mutation.target.classList || !mutation.target.classList.contains(helper.SINGLE_FILE_UI_ELEMENT_CLASS);
+				}
+			});
+			if (updated.length || insertedStylesheets.length) {
+				loadingImages = true;
+				await deferForceLazyLoadEnd(observer, options, cleanupAndResolve);
+				if (!pendingImages.size) {
+					await deferLazyLoadEnd(observer, options, cleanupAndResolve);
 				}
 			}
 		});

package/test/sfz-harness/README.md

@@ -1,9 +1,13 @@
 # SFZ format harness
 
-Tests for the SingleFile archive writer in `processors/compression/`. They drive
+Tests for the SingleFile archive writer in `processors/compression/`, which drive
 `process()` directly with synthetic page data, so they need no browser and no network.
 The format itself is specified in [`doc/singlefile-archive.md`](../../doc/singlefile-archive.md).
 
+The directory has since taken in suites for code the archive writer does not own — the
+CSS processors, the download filename helpers — because they need the same Deno-with-a-
+DOM-stub setup and there was nowhere else to put them. The table says which is which.
+
 Run them with Deno, from the repository root:
 
 ```
@@ -31,6 +35,11 @@ any check failed.
 | `adopted-stylesheets-hook.js` | That the page-world hook answers the adopted-stylesheets request for a CLOSED shadow root, which its host does not expose. |
 | `inlined-functions.js` | That a function serialized into a self-extracting archive names nothing outside itself. An import survives bundling and still reads correctly, and the archive then throws a bare `ReferenceError` and renders nothing. |
 | `pages-archive.js` | That `createPagesArchive` packs several pages into one archive correctly: the first page at the root and the others in folders, the manifest, the symlink a deduplicated entry leaves behind, and the escaping of crawled titles in both tables of contents. |
+| `entry-compression.js` | That an entry is deflated or stored on the content type the server sent, not on the extension alone — a module served as `text/javascript` from a `.ts` URL used to go in uncompressed — and that an unrecognized `application/octet-stream` still stays stored. |
+| `filename-max-length.js` | That `formatFilename` counts the ellipsis as well as the extension in the budget it truncates to, so a filename at `filenameMaxLength` stays at it, and that a limit shorter than the extension does not reach `Blob.slice` with a negative start. |
+| `filename-characters.js` | That `getValidFilename` maps a full-width lookalike one character at a time — `C++` used to be saved as `C＋` — while a run of characters with no lookalike still collapses to a single replacement. |
+| `zip64.js` | That the `page.pdf` record injection accounts for the zip64 end of central directory record (§5.7): all four EOCD fields left at their sentinels, the entry counts and directory size carried in the zip64 record, the directory offset pointing at the injected record, and the archive still readable. The branch runs only past 4 GiB or 65535 entries, so nothing reached it before; the suite forces zip64 through `zipWriter.options` from inside the `writeEntries` callback, with no production lever. |
+| `byte-map.js` | That the byte offsets §8.2 of the specification prints still describe what the writer emits: the prologue order, the doctype and root tag with nothing between them, the identifier's length ahead of the region, absolute EOCD offsets, and the entry order. The specimen §8.2 documents is saved from a live URL and has never been in this repository, so none of its numbers could be checked; three of them were wrong. This builds an equivalent with no network. |
 | `css-fonts-minifier.js` | That `removeUnusedFonts` reads the font families it prunes on correctly: a `var()` family resolved from the values the document declares and not only from the ones the body inherits, every font kept when the value is genuinely undetermined, and a multi-word family name that does not also claim a font named after its own tail. |
 
 ## The tools

package/test/sfz-harness/byte-map.js

@@ -0,0 +1,137 @@
+// §8.2 of doc/singlefile-archive.md is a table of byte offsets. Nothing could check it: the
+// specimen it describes is saved from a live URL through the CLI, so it needs a network and a
+// browser and has never existed in this repository. Three of its rows were wrong for an unknown
+// length of time — the doctype is 15 bytes and nothing separates it from the root element start
+// tag, so the first three offsets were each one too high — and §4.2's derived figure is stale by
+// about 20 KB. This builds an equivalent specimen from the harness, deterministically and with no
+// network, and asserts both the offsets the document prints and the structural relations they
+// stand for. A writer change that moves the layout fails here instead of rotting in the prose.
+import "./dom-stub.js";
+import { makeOptions, runProcess, freezeDate } from "./common.js";
+
+const zipScript = await Deno.readTextFile(new URL("../../vendor/zip/zip.min.js", import.meta.url));
+
+let failed = false;
+
+function check(label, actual, expected) {
+	const ok = actual === expected;
+	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
+	failed ||= !ok;
+}
+
+// a two-entry archive, matching the shape §8.2 documents: index.html and manifest.json only
+function makeSpecimenPageData() {
+	return {
+		title: "Example Domain",
+		doctype: "<!DOCTYPE html>",
+		content: "<html><body><h1>Example Domain</h1><p>" + "specimen ".repeat(64) + "</p></body></html>",
+		comment: "\n url: https://example.com/ \n saved date: Wed Aug 13 2025 \n",
+		resources: { stylesheets: [], images: [] }
+	};
+}
+
+const restoreDate = freezeDate();
+const { bytes } = await runProcess(makeSpecimenPageData(), makeOptions({
+	zipScript,
+	url: "https://example.com/",
+	insertCanonicalLink: false
+}));
+restoreDate();
+
+const text = new TextDecoder("windows-1252").decode(bytes);
+const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+const at = needle => text.indexOf(needle);
+
+const doctype = at("<!DOCTYPE html>");
+const root = at("<html data-sfz>");
+const charset = at("<meta charset=");
+const charsetEnd = charset + text.substring(charset).indexOf(">") + 1;
+const comment = at("<!--\n url:");
+const title = at("<title>");
+const style = at("<style>");
+const body = at("<body hidden>");
+const script = at("<script>");
+const wrapperStart = at("<!--sfz-data");
+const region = at("PK\x03\x04");
+const central = text.indexOf("PK\x01\x02", region);
+const eocd = text.indexOf("PK\x05\x06", central);
+const payload = at("<sfz-extra-data>");
+const endTags = at("</body></html>");
+
+console.log(`specimen: ${bytes.length} bytes`);
+console.log([
+	["html-prologue begins", doctype], ["root element start tag", root],
+	["charset declaration", charset], ["implementation comment", comment],
+	["title", title], ["stylesheet", style], ["body hidden", body],
+	["bootstrap script", script], ["wrapper start tag", wrapperStart],
+	["ZIP region begins", region], ["central directory", central],
+	["EOCD", eocd], ["recovery payload", payload], ["end tags", endTags]
+].map(([label, offset]) => `  ${String(offset).padStart(7)}  ${label}`).join("\n"));
+
+// the prologue order, which §3.1 and §6.1 both got backwards until 2026-09-01: the charset
+// declaration precedes the comment, because the comment carries an unbounded URL
+check("doctype opens the file", doctype, 0);
+check("root element start tag follows the doctype with nothing between", root, doctype + "<!DOCTYPE html>".length);
+check("charset declaration follows the root element start tag", charset, root + "<html data-sfz>".length);
+check("the comment begins where the charset declaration ends", comment, charsetEnd);
+check("the charset declaration is inside the prescan window", charsetEnd <= 1024, true);
+
+// the ordering the byte map asserts, region by region
+check("prologue order holds end to end",
+	[doctype, root, charset, comment, title, style, body, script, wrapperStart, region, central, eocd, payload, endTags]
+		.every((offset, index, all) => offset >= 0 && (index === 0 || offset > all[index - 1])), true);
+
+// the identifier sits inside the wrapper, so the region starts 12 bytes after the tag (§1.3)
+check("the identifier precedes the region by the length of the start tag", region - wrapperStart, "<!--sfz-data".length);
+
+// offsets are absolute file positions, not region-relative (§5.3)
+check("the EOCD directory offset is an absolute file position", view.getUint32(eocd + 16, true), central);
+check("the EOCD counts both entries", view.getUint16(eocd + 10, true), 2);
+check("the EOCD declares no archive comment", view.getUint16(eocd + 20, true), 0);
+
+// the region ends at the wrapper close tag, and the payload describes it minus the two
+// comment-length bytes (§4.5)
+const wrapperEnd = text.indexOf("-->", eocd);
+check("the wrapper closes after the EOCD", wrapperEnd > eocd, true);
+check("the appended run fits the budget", bytes.length - wrapperEnd <= 65535, true);
+
+// the entries the document names, in the order it names them (§4.2)
+let records = 0;
+for (let index = text.indexOf("PK\x01\x02"); index != -1; index = text.indexOf("PK\x01\x02", index + 1)) {
+	records++;
+}
+check("the central directory holds two records", records, 2);
+check("index.html is listed first", text.indexOf("index.html", central) < text.indexOf("manifest.json", central), true);
+
+// §4.2: page.pdf's local header lies before the ZIP region, so the prepended-data compensation
+// a reader of the recovered region applies takes its offset negative. The magnitude is the
+// region's start and moves with the size of the inlined library, so only the relation is checked
+{
+	const pdf = new TextEncoder().encode("%PDF-1.4\n1 0 obj\n<< /X (specimen) >>\nendobj\ntrailer\n<<>>\n%%EOF\n");
+	const restore = freezeDate();
+	const { bytes: pdfBytes } = await runProcess(makeSpecimenPageData(), makeOptions({
+		zipScript,
+		url: "https://example.com/",
+		insertCanonicalLink: false,
+		embeddedPdf: pdf
+	}));
+	restore();
+	const pdfText = new TextDecoder("windows-1252").decode(pdfBytes);
+	const pdfView = new DataView(pdfBytes.buffer, pdfBytes.byteOffset, pdfBytes.byteLength);
+	const pdfRegion = pdfText.indexOf("PK\x03\x04", pdfText.indexOf("<!--sfz-data"));
+	let record = pdfText.indexOf("PK\x01\x02", pdfRegion);
+	let stored;
+	while (record != -1 && stored === undefined) {
+		if (pdfText.substr(record + 46, pdfView.getUint16(record + 28, true)) == "page.pdf") {
+			stored = pdfView.getUint32(record + 42, true);
+		}
+		record = pdfText.indexOf("PK\x01\x02", record + 1);
+	}
+	check("page.pdf is listed in the central directory", stored !== undefined, true);
+	check("its local header sits where the central record says", pdfText.indexOf("PK\x03\x04"), stored);
+	check("its header is inside the PDF scan window", stored < 1024, true);
+	check("its header lies before the ZIP region", stored < pdfRegion, true);
+	check("so the compensated offset is negative", stored - pdfRegion < 0, true);
+}
+
+Deno.exit(failed ? 1 : 0);

package/test/sfz-harness/format-rules.js

@@ -1,6 +1,6 @@
 import "./dom-stub.js";
 import { makePageData, makeOptions, runProcess, mulberry32 } from "./common.js";
-import { ZipReader, BlobReader } from "../../vendor/zip/zip.js";
+import { ZipReader, ZipWriter, BlobReader } from "../../vendor/zip/zip.js";
 
 // the quote is there because the escaper the title shares with the table of contents encodes
 // it for an attribute value, where it matters, and a title has to round-trip through that too
@@ -121,7 +121,22 @@ function imageResource(url) {
 	const pageData = makePageData(6, 4 * 1024);
 	pageData.doctype = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"" + "x".repeat(2000) + ".dtd\">";
 	const { bytes } = await runProcess(pageData, options);
-	check("oversized doctype is kept without the pdf face", decodeText(bytes).startsWith(pageData.doctype), true);
+	const text = decodeText(bytes);
+	check("oversized doctype is replaced without the pdf face", text.startsWith("<!DOCTYPE html><html data-sfz>"), true);
+	check("charset declaration stays inside the scan window", charsetDeclarationEnd(text) <= 1024, true);
+}
+
+{
+	const options = makeOptions();
+	const pageData = makePageData(6, 4 * 1024);
+	pageData.doctype = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
+	const { bytes } = await runProcess(pageData, options);
+	check("ordinary doctype is kept verbatim", decodeText(bytes).startsWith(pageData.doctype), true);
+}
+
+function charsetDeclarationEnd(text) {
+	const index = text.indexOf("<meta charset=");
+	return index == -1 ? -1 : index + text.substring(index).indexOf(">") + 1;
 }
 
 function triggerResource(literals) {
@@ -163,6 +178,67 @@ function countIdentifiers(text) {
 	check("relocated payload needs no separator node", /<\/sfz-extra-data> +<!--sfz-dataPK/.test(text), true);
 }
 
+// relocating the payload shifts the central directory offsets, which moves the payload length by
+// a few base64 quanta; a reservation margin below that shift costs a third layout in about one
+// build out of four, so a dozen relocations must all settle in two. The image bytes never contain
+// a hyphen, so a wrapper collision cannot add a layout of its own
+{
+	const { appendZip } = ZipWriter.prototype;
+	let layouts = 0;
+	ZipWriter.prototype.appendZip = function (reader) {
+		layouts++;
+		return appendZip.call(this, reader);
+	};
+	let retried = 0;
+	for (let seed = 30; seed < 42; seed++) {
+		const options = makeOptions({ preventAppendedData: true });
+		const pageData = makePageData(seed, 64 * 1024);
+		const rand = mulberry32(seed);
+		for (let index = 0; index < 40; index++) {
+			const content = new Uint8Array(8 * 1024).map(() => {
+				const byte = (rand() * 255) | 0;
+				return byte < 0x2D ? byte : byte + 1;
+			});
+			pageData.resources.images.push({ name: "images/" + index + ".jpg", extension: ".jpg", content, url: "https://example.com/" + index + ".jpg" });
+		}
+		layouts = 0;
+		await runProcess(pageData, options);
+		if (layouts > 2) {
+			retried++;
+		}
+	}
+	ZipWriter.prototype.appendZip = appendZip;
+	check("the reservation margin absorbs the offset shift", retried, 0);
+}
+
+// a payload too large for the appended budget is relocated, and relocation is final: the writer
+// then emits no appended run at all, so the file ends at the EOCD like a plain zip. A stored
+// resource made of random newline bytes gives a payload past the budget from a few hundred KB
+{
+	const { appendZip } = ZipWriter.prototype;
+	let layouts = 0;
+	ZipWriter.prototype.appendZip = function (reader) {
+		layouts++;
+		return appendZip.call(this, reader);
+	};
+	const options = makeOptions({ disableCompression: true });
+	const pageData = makePageData(42, 4 * 1024);
+	const rand = mulberry32(42);
+	const newlines = ["\n", "\r", "\r\n"];
+	let content = "";
+	while (content.length < 512 * 1024) {
+		content += newlines[(rand() * 3) | 0];
+	}
+	pageData.resources.stylesheets.push({ name: "newlines.txt", extension: ".txt", content, url: "https://example.com/newlines.txt" });
+	const { bytes } = await runProcess(pageData, options);
+	ZipWriter.prototype.appendZip = appendZip;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	check("an oversized payload is relocated", options.extraDataSize > 0, true);
+	check("relocation needs a single extra layout", layouts, 2);
+	check("a relocated archive ends at the EOCD", view.getUint32(bytes.length - 22, true), 0x06054b50);
+	check("a relocated archive declares no comment", view.getUint16(bytes.length - 2, true), 0);
+}
+
 {
 	const options = makeOptions({ embeddedPdf: PDF });
 	const pageData = makePageData(15, 4 * 1024);
@@ -297,6 +373,24 @@ const ALL_FACE_RUNGS = "<!--sfz-data<script<style<noframes<noembed<iframe<xmp<![
 	check("no page.pdf entry is left behind", entries.some(entry => entry.filename.endsWith("page.pdf")), false);
 }
 
+// page.pdf is the only record the writer builds by hand, so it is the only place the
+// language encoding flag can go missing: without it a reader decodes that one name
+// through CP437 while reading every other name in the same archive as UTF-8
+{
+	const options = makeOptions({ embeddedPdf: PDF });
+	const pageData = makePageData(23, 4 * 1024);
+	pageData.resources.images.push(imageResource("https://example.com/image.png"));
+	const { bytes } = await runProcess(pageData, options);
+	const zipReader = new ZipReader(new BlobReader(new Blob([bytes])));
+	const entries = await zipReader.getEntries();
+	await zipReader.close();
+	check("the pdf entry is listed", entries.some(entry => entry.filename == "page.pdf"), true);
+	check("every central record declares utf-8 names", entries.every(entry => entry.filenameUTF8), true);
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const localFlags = entries.map(entry => view.getUint16(entry.offset + 6, true));
+	check("every local header declares utf-8 names", localFlags.every(flags => Boolean(flags & 0x0800)), true);
+}
+
 {
 	const embeddedImage = new Uint8Array(8 + 25 + 512 + 12);
 	embeddedImage.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
@@ -414,6 +508,42 @@ function readAppendedData(bytes) {
 	check("no trailing bytes when appended data is prevented", trailing, 0);
 }
 
+// a comment cannot escape its own delimiters, so text reaching it from the captured page —
+// the infobar template resolves {page-title} and its kind against the document — would close
+// it early and turn the rest into markup. The page the archive restores carries no scripts by
+// default, and this was the one way to put one back
+{
+	for (const [label, comment] of [
+		["-->", "\n info: --><script>INJECTED</script><!-- \n"],
+		["--!>", "\n info: --!><script>INJECTED</script><!-- \n"],
+		["--->", "\n info: ---><script>INJECTED</script><!-- \n"]
+	]) {
+		const pageData = makePageData(12, 1024);
+		pageData.comment = comment;
+		const { bytes } = await runProcess(pageData, makeOptions());
+		const text = decodeText(bytes);
+		const start = text.indexOf("<!--\n info:");
+		check(`the comment survives ${label} in its content`, start != -1, true);
+		// "--!>" closes a comment too, so the end is the first of either form, not the first "-->"
+		const end = start + text.substring(start).search(/--!?>/);
+		check(`${label} in the comment does not close it early`,
+			text.indexOf("INJECTED") < end, true);
+	}
+	const pageData = makePageData(12, 1024);
+	pageData.comment = "\n info: a-->b \n";
+	const { bytes } = await runProcess(pageData, makeOptions());
+	check("the characters either side of the run are kept",
+		decodeText(bytes).includes("info: a-- >b"), true);
+}
+
+// neither directive falls back to default-src, so each has to be named to have any effect
+{
+	const { bytes } = await runProcess(makePageData(13, 1024), makeOptions({ insertMetaCSP: true }));
+	const policy = decodeText(bytes).match(/content-security-policy content="([^"]*)"/)[1];
+	check("the policy forbids form submission", policy.includes("form-action 'none'"), true);
+	check("the policy forbids a base element", policy.includes("base-uri 'none'"), true);
+}
+
 if (failed) {
 	console.log("FAILED");
 	Deno.exit(1);

package/test/sfz-harness/option-wiring.js

@@ -11,13 +11,10 @@ import { PROCESS_OPTION_NAMES } from "../../processors/compression/compression.j
 // one thing or the other before the suite goes green again
 const INTERNAL_OPTION_NAMES = [
 	// state the module sets on itself between build passes
-	"extraData",
 	"extraDataSize",
-	"extraDataSizeDropped",
 	"extractDataFromPageTags",
 	"preventEmbeddedPdfEntry",
 	// supplied by compression-packager.js, which calls createArchive directly
-	"embeddedScreenshotImage",
 	"multiPageArchive",
 	// read for the root directory name, but no caller has ever passed it
 	"tabId",

package/test/sfz-harness/zip64.js

@@ -0,0 +1,77 @@
+// §5.7 states that the page.pdf central-record injection applies its accounting to the zip64
+// end of central directory record when one is present, and claimed the combination "has been
+// verified on a forced-zip64 build". No such build existed here: the writer has no zip64 lever
+// and §8.3 described the specimen only in prose, so nothing checked the branch. It runs only past
+// 4 GiB or 65535 entries, which a saved page never reaches, so a defect in it would be invisible.
+//
+// zipWriter.options is a live reference to the object the ZipWriter was constructed with, so the
+// writeEntries callback can force zip64 on without any production change.
+import "./dom-stub.js";
+import { createArchive } from "../../processors/compression/compression.js";
+import { TextReader, ZipReader, BlobReader } from "../../vendor/zip/zip.js";
+import { FIXED_DATE, blobBytes } from "./common.js";
+
+const ZIP64_EOCD_SIGNATURE = 0x06064b50;
+const ZIP64_LOCATOR_SIGNATURE = 0x07064b50;
+const EOCD_SIGNATURE = 0x06054b50;
+
+let failed = false;
+
+function check(label, actual, expected) {
+	const ok = actual === expected;
+	console.log(`${ok ? "PASS" : "FAIL"} ${label}: ${actual}${ok ? "" : " (expected " + expected + ")"}`);
+	failed ||= !ok;
+}
+
+const PDF = new TextEncoder().encode("%PDF-1.4\n1 0 obj\n<< /X (zip64) >>\nendobj\ntrailer\n<<>>\n%%EOF\n");
+const pageData = { doctype: "<!DOCTYPE html>", content: "<html><body>zip64</body></html>", title: "zip64" };
+const archiveOptions = { url: "https://example.com/", selfExtractingArchive: true, embeddedPdf: PDF };
+
+const blob = await createArchive(pageData, archiveOptions, "/* zip script stub */", async zipWriter => {
+	zipWriter.options.zip64 = true;
+	await zipWriter.add("index.html", new TextReader("<html><body>zip64</body></html>"));
+	await zipWriter.add("manifest.json", new TextReader("{}"));
+}, FIXED_DATE);
+const bytes = await blobBytes(blob);
+const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+// locate the three records from the end, the way a reader does
+let eocd = -1;
+for (let index = bytes.length - 22; index >= 0 && eocd == -1; index--) {
+	if (view.getUint32(index, true) == EOCD_SIGNATURE) {
+		eocd = index;
+	}
+}
+check("the archive ends with an EOCD record", eocd != -1, true);
+const locator = eocd - 20;
+check("a zip64 locator precedes the EOCD", view.getUint32(locator, true), ZIP64_LOCATOR_SIGNATURE);
+const zip64 = Number(view.getBigUint64(locator + 8, true));
+check("the locator points at the zip64 record", view.getUint32(zip64, true), ZIP64_EOCD_SIGNATURE);
+
+// §5.7: the EOCD's saturated fields stay at their sentinels, and the writer saturates all of
+// them once zip64 is emitted rather than only the one that overflowed
+check("the EOCD entry count is a sentinel", view.getUint16(eocd + 8, true), 0xFFFF);
+check("the EOCD total count is a sentinel", view.getUint16(eocd + 10, true), 0xFFFF);
+check("the EOCD directory size is a sentinel", view.getUint32(eocd + 12, true), 0xFFFFFFFF);
+check("the EOCD directory offset is a sentinel", view.getUint32(eocd + 16, true), 0xFFFFFFFF);
+
+// the injection's accounting lands in the zip64 record: three entries, not the writer's two
+check("the zip64 record counts the injected record on this disk", Number(view.getBigUint64(zip64 + 24, true)), 3);
+check("the zip64 record counts it in the total", Number(view.getBigUint64(zip64 + 32, true)), 3);
+
+// the directory begins at the injected record, which sits ahead of the writer's own directory
+const directoryOffset = Number(view.getBigUint64(zip64 + 48, true));
+const directorySize = Number(view.getBigUint64(zip64 + 40, true));
+check("the zip64 directory offset points at the injected record",
+	view.getUint32(directoryOffset, true), 0x02014b50);
+check("the first record in the directory is page.pdf",
+	new TextDecoder().decode(bytes.subarray(directoryOffset + 46, directoryOffset + 54)), "page.pdf");
+check("the directory size covers every record", directoryOffset + directorySize, zip64);
+
+// and the result is still an archive every reader can read
+const reader = new ZipReader(new BlobReader(new Blob([bytes])));
+const entries = await reader.getEntries();
+await reader.close();
+check("a reader lists all three entries", entries.map(entry => entry.filename).join(","), "page.pdf,index.html,manifest.json");
+
+Deno.exit(failed ? 1 : 0);