@coywolf/emdash 0.35.13 → 0.35.14

package/src/files/format.test.ts

@@ -1,93 +0,0 @@
-/**
- * Run: node --test src/files/*.test.ts
- */
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-// @ts-expect-error -- Node's type stripping needs the real .ts extension.
-import * as f from "./format.ts";
-// @ts-expect-error -- Node's type stripping needs the real .ts extension.
-import { entryTitle, fileIdsIn, findFileBlocks } from "./walker.ts";
-
-test("Content-Disposition: plain ASCII names", () => {
-	assert.equal(f.contentDisposition("report.pdf"), 'attachment; filename="report.pdf"');
-	assert.equal(f.contentDisposition("Q3 report (final).pdf"), 'attachment; filename="Q3 report (final).pdf"');
-});
-
-test("Content-Disposition: RFC 5987 for non-ASCII and unsafe characters", () => {
-	assert.equal(f.contentDisposition("résumé.pdf"), `attachment; filename="resume.pdf"; filename*=UTF-8''r%C3%A9sum%C3%A9.pdf`);
-	assert.equal(f.contentDisposition("日本語.txt"), `attachment; filename="___.txt"; filename*=UTF-8''%E6%97%A5%E6%9C%AC%E8%AA%9E.txt`);
-	assert.equal(f.contentDisposition('say "hi".txt'), `attachment; filename="say _hi_.txt"; filename*=UTF-8''say%20%22hi%22.txt`);
-	assert.equal(f.contentDisposition("it's (1)*.txt"), `attachment; filename="it's (1)*.txt"`);
-	assert.equal(f.contentDisposition("50%.txt"), `attachment; filename="50_.txt"; filename*=UTF-8''50%25.txt`);
-	assert.equal(f.contentDisposition("a'bé.txt"), `attachment; filename="a'be.txt"; filename*=UTF-8''a%27b%C3%A9.txt`);
-});
-
-test("Content-Disposition: header injection and paths", () => {
-	assert.equal(f.contentDisposition("evil\r\nSet-Cookie: x.pdf"), `attachment; filename="evil  Set-Cookie: x.pdf"`);
-	assert.equal(f.contentDisposition("../../etc/passwd"), `attachment; filename="passwd"`);
-	assert.equal(f.contentDisposition(""), `attachment; filename="download"`);
-});
-
-test("safe file names and download paths", () => {
-	assert.equal(f.safeFilename("My Résumé (2026).PDF"), "My-Resume-2026.PDF");
-	assert.equal(f.safeFilename("../x/y z.tar.gz"), "y-z.tar.gz");
-	assert.equal(f.safeFilename("???"), "file");
-	assert.equal(f.downloadPath("download", "fabcdefghijklmno", "a b.pdf"), "/download/fabcdefghijklmno/a-b.pdf");
-	assert.equal(f.normalizeBase("/Files/"), "files");
-	assert.equal(f.normalizeBase("_emdash"), "download");
-	assert.equal(f.normalizeBase("a/b"), "download");
-});
-
-test("type badge mapping", () => {
-	assert.deepEqual(f.iconFor("pdf"), { color: "#B42318", label: "PDF" });
-	assert.deepEqual(f.iconFor("DOCX"), { color: "#155EEF", label: "DOCX" });
-	assert.deepEqual(f.iconFor("xlsx"), { color: "#067647", label: "XLSX" });
-	assert.deepEqual(f.iconFor("jpeg"), { color: "#C11574", label: "JPEG" });
-	assert.deepEqual(f.iconFor("7z"), { color: "#6941E0", label: "7Z" });
-	assert.deepEqual(f.iconFor("numbers"), { color: "#067647", label: "NUMB" });
-	assert.deepEqual(f.iconFor("weird"), { color: f.DEFAULT_ICON_COLOR, label: "WEIR" });
-	assert.deepEqual(f.iconFor(""), { color: f.DEFAULT_ICON_COLOR, label: "FILE" });
-	assert.equal(f.extensionOf("archive.TAR.GZ"), "gz");
-	assert.equal(f.extensionOf("README"), "");
-});
-
-test("sizes, colors and ids", () => {
-	assert.equal(f.formatSize(0), "0 B");
-	assert.equal(f.formatSize(1023), "1023 B");
-	assert.equal(f.formatSize(1536), "1.5 KB");
-	assert.equal(f.formatSize(5 * 1024 ** 3), "5.0 GB");
-	assert.equal(f.safeColor("#0a7"), "#0a7");
-	assert.equal(f.safeColor("red;}body{"), "");
-	const id = f.newUploadId();
-	assert.match(id, f.UPLOAD_ID);
-	assert.ok(f.isFileId("01J9ZQ3W4X5Y6Z7A8B9C0D1E2F"));
-	assert.ok(!f.isFileId("../etc"));
-});
-
-test("Portable Text walker finds nested coywolf-file blocks", () => {
-	const content = {
-		id: "c1",
-		slug: "hello",
-		data: {
-			title: "Hello",
-			body: [
-				{ _type: "block", children: [{ _type: "span", text: "x" }] },
-				{ _type: "coywolf-file", _key: "a", id: "fabcdefghijklmno", title: "Brochure" },
-				{ _type: "columns", columns: [{ content: [{ _type: "coywolf-file", id: "01J9ZQ3W4X5Y6Z7A8B9C0D1E2F" }] }] },
-				{ _type: "coywolf-file", id: "" },
-				{ _type: "image", id: "01J9ZQ3W4X5Y6Z7A8B9C0D1E2G" },
-			],
-			sidebar: [{ _type: "coywolf-file", id: "fabcdefghijklmno" }],
-		},
-	};
-	assert.deepEqual(findFileBlocks(content), [
-		{ id: "fabcdefghijklmno", field: "body" },
-		{ id: "01J9ZQ3W4X5Y6Z7A8B9C0D1E2F", field: "body" },
-		{ id: "fabcdefghijklmno", field: "sidebar" },
-	]);
-	assert.deepEqual(fileIdsIn(content), ["fabcdefghijklmno", "01J9ZQ3W4X5Y6Z7A8B9C0D1E2F"]);
-	assert.equal(entryTitle(content), "Hello");
-	assert.equal(entryTitle({ id: "x", slug: "s", data: {} }), "s");
-	assert.deepEqual(fileIdsIn(null), []);
-});

package/src/files/r2-rules.test.ts

@@ -1,30 +0,0 @@
-/**
- * Run: node --test src/files/*.test.ts
- */
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-// @ts-expect-error -- Node's type stripping needs the real .ts extension.
-import { parseDownloadPath } from "./format.ts";
-// @ts-expect-error -- Node's type stripping needs the real .ts extension.
-import { MAX_THROUGH_SITE, PART_SIZE, partSizeFor } from "./r2-rules.ts";
-
-const MiB = 1024 * 1024;
-
-test("parts are 6 MiB: above R2's 5 MiB minimum, under EmDash's 8 MiB route body cap", () => {
-	assert.equal(PART_SIZE, 6 * MiB);
-	assert.equal(partSizeFor(1), PART_SIZE);
-	assert.equal(partSizeFor(40 * 1024 * MiB), PART_SIZE);
-	assert.equal(MAX_THROUGH_SITE, 10_000 * PART_SIZE);
-	assert.ok(MAX_THROUGH_SITE >= 50 * 1024 ** 3, "the 50 GB setting fits");
-});
-
-test("download paths", () => {
-	assert.deepEqual(parseDownloadPath("/download/fabcdefghijklmno/report.pdf", "download"), { id: "fabcdefghijklmno", filename: "report.pdf" });
-	assert.deepEqual(parseDownloadPath("/download/01J9ZQ3W4X5Y6Z7A8B9C0D1E2F", "download"), { id: "01J9ZQ3W4X5Y6Z7A8B9C0D1E2F", filename: null });
-	assert.equal(parseDownloadPath("/download/", "download"), null);
-	assert.equal(parseDownloadPath("/download/not-an-id/x.pdf", "download"), null);
-	assert.equal(parseDownloadPath("/download/fabcdefghijklmno/a/b", "download"), null);
-	assert.equal(parseDownloadPath("/downloads/fabcdefghijklmno/x", "download"), null);
-	assert.equal(parseDownloadPath("/download/%E0%A4%A/x", "download"), null);
-});

package/src/files/sigv4.test.ts

@@ -1,64 +0,0 @@
-/**
- * SigV4 against the examples AWS publishes in the S3 API reference
- * ("Signature Calculations for the Authorization Header" and "Authenticating
- * Requests: Using Query Parameters").
- * Run: node --test src/files/*.test.ts
- */
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-// @ts-expect-error -- Node's type stripping needs the real .ts extension.
-import { canonicalQuery, presignUrl, sha256Hex, signRequest, uriEncode } from "./sigv4.ts";
-
-const creds = { accessKeyId: "AKIAIOSFODNN7EXAMPLE", secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" };
-const date = new Date("2013-05-24T00:00:00Z");
-const host = "examplebucket.s3.amazonaws.com";
-const base = { host, region: "us-east-1", date };
-
-test("GET object (Range header)", async () => {
-	const { signature, headers } = await signRequest({ ...base, method: "GET", path: "/test.txt", headers: { range: "bytes=0-9" } }, creds);
-	assert.equal(signature, "f0e8bdb87c964420e857bd35b5d6ed310bd44f0170aba48dd91039c6036bdb41");
-	assert.match(headers.authorization, /^AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE\/20130524\/us-east-1\/s3\/aws4_request,SignedHeaders=host;range;x-amz-content-sha256;x-amz-date,Signature=f0e8/);
-});
-
-test("PUT object (encoded key, signed body)", async () => {
-	const body = "Welcome to Amazon S3.";
-	const payload = await sha256Hex(body);
-	assert.equal(payload, "44ce7dd67c959e0d3524ffac1771dfbba87d2b6b4b4e99e42034a8b803f8b072");
-	const { signature } = await signRequest(
-		{
-			...base,
-			method: "PUT",
-			path: "/test$file.text",
-			headers: { date: "Fri, 24 May 2013 00:00:00 GMT", "x-amz-storage-class": "REDUCED_REDUNDANCY" },
-		},
-		creds,
-		payload,
-	);
-	assert.equal(signature, "98ad721746da40c64f1a55b78f14c238d841ea1380cd77a1b5971af0ece108bd");
-});
-
-test("GET bucket lifecycle (valueless query parameter)", async () => {
-	const { signature } = await signRequest({ ...base, method: "GET", path: "/", query: { lifecycle: "" } }, creds);
-	assert.equal(signature, "fea454ca298b7da1c68078a5d1bdbfbbe0d65c699e0f91ac7a200a0136783543");
-});
-
-test("GET bucket list (sorted query)", async () => {
-	const { signature } = await signRequest({ ...base, method: "GET", path: "/", query: { prefix: "J", "max-keys": "2" } }, creds);
-	assert.equal(signature, "34b48302e7b5fa45bde8084f4b7868a86f0a534bc59db6670ed5711ef69dc6f7");
-});
-
-test("presigned GET URL", async () => {
-	const { url, signature } = await presignUrl({ ...base, method: "GET", path: "/test.txt" }, creds, 86400);
-	assert.equal(signature, "aeeed9bbccd4d02ee5c0109b86d86835f995330da4c265957d157751f604d404");
-	assert.equal(
-		url,
-		"https://examplebucket.s3.amazonaws.com/test.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIOSFODNN7EXAMPLE%2F20130524%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20130524T000000Z&X-Amz-Expires=86400&X-Amz-SignedHeaders=host&X-Amz-Signature=aeeed9bbccd4d02ee5c0109b86d86835f995330da4c265957d157751f604d404",
-	);
-});
-
-test("URI encoding and query order", () => {
-	assert.equal(uriEncode("a b/ü~*", false), "a%20b/%C3%BC~%2A");
-	assert.equal(uriEncode("a/b"), "a%2Fb");
-	assert.equal(canonicalQuery({ uploadId: "x y", partNumber: "2" }), "partNumber=2&uploadId=x%20y");
-});

package/src/headings/headings.test.ts

@@ -1,159 +0,0 @@
-// Run: node --import ./src/headings/test-hooks.mjs --test src/headings/headings.test.ts
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-import { blockText, slugify, uniqueSlug, validAnchor } from "./slug.js";
-import { stampContent } from "./stamp.js";
-import { buildTocTree, countToc } from "./toc.js";
-import { normalizeSettings, withLegacyBreadcrumbs } from "./settings.js";
-
-const h = (key: string, style: string, text: string, extra: Record<string, unknown> = {}) => ({
-	_type: "block",
-	_key: key,
-	style,
-	children: [{ _type: "span", _key: `${key}s`, text, marks: [] }],
-	markDefs: [],
-	...extra,
-});
-const p = (key: string, text: string) => h(key, "normal", text);
-const opts = { anchors: true, toc: true, prefix: "jump-" };
-
-test("slugify mirrors sanitize_title", () => {
-	assert.equal(slugify("Hello, World!"), "hello-world");
-	assert.equal(slugify("Don't Panic"), "dont-panic");
-	assert.equal(slugify("  Café   au lait "), "cafe-au-lait");
-	assert.equal(slugify("Price & Plans — 2026"), "price-plans-2026");
-	assert.equal(slugify("snake_case words"), "snake-case-words");
-	assert.equal(slugify("日本語 見出し"), "日本語-見出し");
-	assert.equal(slugify("!!!"), "");
-	assert.ok(slugify("a".repeat(200)).length <= 80);
-});
-
-test("uniqueSlug prefixes and de-duplicates", () => {
-	const taken = new Set<string>();
-	assert.equal(uniqueSlug("Intro", taken), "jump-intro");
-	assert.equal(uniqueSlug("Intro", taken), "jump-intro-2");
-	assert.equal(uniqueSlug("Intro", taken), "jump-intro-3");
-	assert.equal(uniqueSlug("???", taken), "jump-section");
-	assert.equal(uniqueSlug("2026 plans", new Set(), ""), "h-2026-plans");
-	assert.equal(uniqueSlug("Intro", new Set(), "sec-"), "sec-intro");
-});
-
-test("validAnchor rejects unsafe ids", () => {
-	assert.ok(validAnchor("jump-intro"));
-	assert.ok(!validAnchor('x" onclick="y'));
-	assert.ok(!validAnchor("1abc"));
-	assert.ok(!validAnchor(""));
-	assert.ok(!validAnchor(42));
-});
-
-test("blockText reads nested marks trees", () => {
-	const node = { children: [{ _type: "@span", children: [{ _type: "@text", text: "Bold " }] }, { _type: "@text", text: "tail" }] };
-	assert.equal(blockText(node), "Bold tail");
-});
-
-test("stamping adds unique anchors and TOC headings (breadcrumb blocks are left to Breadcrumb Nav)", () => {
-	const content = {
-		title: "My Post",
-		body: [
-			{ _type: "coywolf-toc", _key: "t" },
-			{ _type: "coywolf-breadcrumbs", _key: "b" },
-			h("a", "h2", "Intro"),
-			p("x", "text"),
-			h("b2", "h3", "Intro"),
-			h("c", "h1", "Title"),
-			h("d", "h2", ""),
-		],
-		other: "not portable text",
-	};
-	const out = stampContent(content, opts);
-	assert.ok(out);
-	const body = out.body as Record<string, unknown>[];
-	assert.equal(body[2].anchor, "jump-intro");
-	assert.equal(body[4].anchor, "jump-intro-2");
-	assert.equal(body[5].anchor, undefined, "H1 is not anchored");
-	assert.equal(body[6].anchor, undefined, "empty heading is skipped");
-	assert.deepEqual(body[0]._headings, [
-		{ level: 2, id: "jump-intro", text: "Intro" },
-		{ level: 3, id: "jump-intro-2", text: "Intro" },
-	]);
-	assert.equal(body[1]._title, undefined);
-	assert.equal(out.other, "not portable text");
-	// Input untouched.
-	assert.equal((content.body[2] as Record<string, unknown>).anchor, undefined);
-});
-
-test("stamping is idempotent", () => {
-	const content = { title: "T", body: [{ _type: "coywolf-toc", _key: "t" }, h("a", "h2", "One"), h("b", "h2", "One")] };
-	const once = stampContent(content, opts);
-	assert.ok(once);
-	assert.equal(stampContent(once, opts), null);
-});
-
-test("anchors stay stable when the editor drops them and the heading is reworded", () => {
-	const saved = stampContent({ body: [h("a", "h2", "Pricing"), h("b", "h2", "FAQ")] }, opts);
-	assert.ok(saved);
-	// Editor round trip: anchor field gone, first heading renamed, a new heading inserted before it.
-	const edited = { body: [h("n", "h2", "FAQ"), h("a", "h2", "Plans and pricing"), h("b", "h2", "FAQ")] };
-	const out = stampContent(edited, { ...opts, previous: saved });
-	assert.ok(out);
-	const body = out.body as Record<string, unknown>[];
-	assert.equal(body[1].anchor, "jump-pricing", "kept by _key despite new text");
-	assert.equal(body[2].anchor, "jump-faq", "kept by _key");
-	assert.equal(body[0].anchor, "jump-faq-2", "new heading slugs around existing anchors");
-});
-
-test("anchors fall back to text matching when keys change", () => {
-	const saved = stampContent({ body: [h("a", "h2", "Setup")] }, { ...opts, prefix: "old-" });
-	assert.ok(saved);
-	const out = stampContent({ body: [h("z", "h2", "Setup")] }, { ...opts, previous: saved });
-	assert.equal((out?.body as Record<string, unknown>[])[0].anchor, "old-setup");
-});
-
-test("invalid stored anchors are replaced", () => {
-	const out = stampContent({ body: [h("a", "h2", "Hi", { anchor: '"><script>' })] }, opts);
-	assert.equal((out?.body as Record<string, unknown>[])[0].anchor, "jump-hi");
-});
-
-test("TOC tree nests by level and tolerates skipped levels", () => {
-	const flat = [
-		{ level: 2, id: "a", text: "A" },
-		{ level: 4, id: "a1", text: "A1" },
-		{ level: 3, id: "a2", text: "A2" },
-		{ level: 2, id: "b", text: "B" },
-		{ level: 5, id: "deep", text: "Deep" },
-		{ level: 3, id: "b1", text: "B1" },
-	];
-	const tree = buildTocTree(flat, [2, 3, 4]);
-	assert.deepEqual(
-		tree.map((n) => [n.id, n.children.map((c) => [c.id, c.children.map((g) => g.id)])]),
-		[
-			["a", [["a1", []], ["a2", []]]],
-			["b", [["b1", []]]],
-		],
-	);
-	assert.equal(countToc(tree), 5);
-	assert.deepEqual(
-		buildTocTree(flat, [3]).map((n) => n.id),
-		["a2", "b1"],
-	);
-	assert.deepEqual(
-		buildTocTree([{ level: 3, id: "x", text: "X" }, { level: 2, id: "y", text: "Y" }], [2, 3]).map((n) => n.id),
-		["x", "y"],
-	);
-});
-
-test("TOC title can be hidden; levels can be H2 only", () => {
-	assert.equal(normalizeSettings({}).toc.showTitle, true);
-	assert.equal(normalizeSettings({ toc: { showTitle: false } }).toc.showTitle, false);
-	assert.deepEqual(normalizeSettings({ toc: { levels: [2] } }).toc.levels, [2]);
-	assert.equal("breadcrumbs" in normalizeSettings({ breadcrumbs: { homeLabel: "Start" } }), false);
-});
-
-test("saving Headings settings keeps the legacy breadcrumb sub-object for Breadcrumb Nav", () => {
-	const legacy = { separator: "chevron", homeLabel: "Start" };
-	const next = normalizeSettings({ prefix: "sec-" });
-	assert.deepEqual(withLegacyBreadcrumbs({ prefix: "jump-", breadcrumbs: legacy }, next), { ...next, breadcrumbs: legacy });
-	assert.deepEqual(withLegacyBreadcrumbs({ prefix: "jump-" }, next), next);
-	assert.deepEqual(withLegacyBreadcrumbs(null, next), next);
-});

package/src/pageCache/lib.test.mjs

@@ -1,224 +0,0 @@
-// Unit tests for page cache purge rules.
-// Run: node --test src/pageCache/lib.test.mjs   (Node 22.6+ strips the types from lib.ts)
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-const { purgesAfter, watchInvalidation } = await import("./lib.ts");
-const api = "/_emdash/api/plugins/coywolf-pack/";
-
-test("admin writes to pack routes purge the page cache", () => {
-	for (const route of ["schema/site/save", "redirects/import", "features/save", "robots/save", "videos/webhook", "videos/update", "backups/run"]) {
-		assert.equal(purgesAfter("POST", api + route), true, route);
-	}
-});
-
-test("public pack routes, reads, and other plugins don't", () => {
-	for (const route of ["search/live", "search/index", "discovery/public/llms", "videos/like", "videos/play", "videos/caption", "videos/embed", "videos/sitemap"]) {
-		assert.equal(purgesAfter("POST", api + route), false, route);
-	}
-	assert.equal(purgesAfter("GET", api + "schema/config"), false);
-	assert.equal(purgesAfter("POST", "/_emdash/api/plugins/emdash-forms/submit"), false);
-	assert.equal(purgesAfter("POST", "/_emdash/api/content/posts"), false, "EmDash purges its own content by tag");
-});
-
-const { applyPageLifetime } = await import("./lib.ts");
-
-function routeCache(maxAge) {
-	return {
-		enabled: true,
-		options: maxAge === undefined ? {} : { maxAge },
-		sets: [],
-		set(o) {
-			this.sets.push(o);
-		},
-	};
-}
-
-test("page lifetimes apply only to routes the site made cacheable", () => {
-	const page = routeCache(3600);
-	assert.equal(applyPageLifetime(page, 7, 1), true);
-	assert.deepEqual(page.sets, [{ maxAge: 604800, swr: 86400 }]);
-
-	const uncached = routeCache(undefined);
-	assert.equal(applyPageLifetime(uncached, 7, 1), false, "never turns caching on");
-	assert.deepEqual(uncached.sets, []);
-	assert.equal(applyPageLifetime(undefined, 7, 1), false);
-	assert.equal(applyPageLifetime({ ...routeCache(60), enabled: false }, 7, 1), false);
-});
-
-const { settlePage, STOPGAP_LIFETIME } = await import("./lib.ts");
-
-const html = (body = "<p>hi</p>", init = {}) => new Response(body, { headers: { "content-type": "text/html; charset=utf-8" }, ...init });
-/** settlePage with no failed read: the stopgap checks alone. */
-const shortenStopgapPage = (cache, response, stopgap, markHeader) => settlePage(cache, response, { failed: () => false, stopgap, markHeader });
-
-test("a page rendered with a stopgap poster is cached for minutes, decided after its body has rendered", async () => {
-	const page = routeCache(604800);
-	let rendered = false;
-	// The flag is set while the body streams (a component deep in the page), not before next() returns.
-	const stream = new ReadableStream({
-		async pull(controller) {
-			await new Promise((r) => setTimeout(r, 0));
-			rendered = true;
-			controller.enqueue(new TextEncoder().encode("<video>"));
-			controller.close();
-		},
-	});
-	const out = await shortenStopgapPage(page, html(stream, { headers: { "content-type": "text/html", "x-keep": "1" } }), () => rendered);
-	assert.deepEqual(page.sets, [{ maxAge: STOPGAP_LIFETIME.maxAge, swr: STOPGAP_LIFETIME.swr }]);
-	assert.equal(await out.text(), "<video>");
-	assert.equal(out.headers.get("x-keep"), "1");
-	assert.equal(out.status, 200);
-});
-
-test("pages without a stopgap, uncached routes and non-HTML responses keep their lifetime", async () => {
-	const page = routeCache(604800);
-	assert.equal(await (await shortenStopgapPage(page, html(), () => false)).text(), "<p>hi</p>");
-	assert.deepEqual(page.sets, []);
-
-	const untouched = html();
-	assert.equal(await shortenStopgapPage(routeCache(undefined), untouched, () => assert.fail("asked")), untouched);
-	assert.equal(await shortenStopgapPage(undefined, untouched, () => assert.fail("asked")), untouched);
-
-	const json = new Response("{}", { headers: { "content-type": "application/json" } });
-	assert.equal(await shortenStopgapPage(routeCache(60), json, () => assert.fail("asked")), json);
-	const missing = html("gone", { status: 404 });
-	assert.equal(await shortenStopgapPage(routeCache(60), missing, () => assert.fail("asked")), missing);
-
-	const short = routeCache(120);
-	await shortenStopgapPage(short, html(), () => true);
-	assert.deepEqual(short.sets, [{ maxAge: 120, swr: STOPGAP_LIFETIME.swr }], "never lengthens a shorter lifetime");
-});
-
-test("the cache warmer's stopgap render isn't cached and is marked for a revisit; visitors' renders aren't marked", async () => {
-	const warmer = routeCache(604800);
-	const marked = await shortenStopgapPage(warmer, html("<video>", { headers: { "content-type": "text/html", "x-keep": "1" } }), () => true, "X-Coywolf-Stopgap");
-	assert.deepEqual(warmer.sets, [false], "not cached, so the mark never reaches visitors and the revisit renders afresh");
-	assert.equal(marked.headers.get("x-coywolf-stopgap"), "1");
-	assert.equal(marked.headers.get("x-keep"), "1");
-	assert.equal(await marked.text(), "<video>");
-
-	const visitor = routeCache(604800);
-	const plain = await shortenStopgapPage(visitor, html(), () => true);
-	assert.equal(plain.headers.get("x-coywolf-stopgap"), null);
-	assert.deepEqual(visitor.sets, [{ maxAge: STOPGAP_LIFETIME.maxAge, swr: STOPGAP_LIFETIME.swr }]);
-
-	const fine = routeCache(604800);
-	const clean = await shortenStopgapPage(fine, html(), () => false, "X-Coywolf-Stopgap");
-	assert.equal(clean.headers.get("x-coywolf-stopgap"), null, "the warmer's normal renders aren't marked");
-	assert.deepEqual(fine.sets, []);
-});
-
-test("watchInvalidation notices EmDash clearing pages by tag, and only a successful clear", async () => {
-	const calls = [];
-	const cache = {
-		async invalidate(options) {
-			calls.push(options);
-			if (options.tags.includes("boom")) throw new Error("purge failed");
-		},
-	};
-	const invalidated = watchInvalidation(cache);
-	assert.equal(invalidated(), false, "a draft save that clears nothing");
-	await assert.rejects(cache.invalidate({ tags: ["boom"] }));
-	assert.equal(invalidated(), false);
-	await cache.invalidate({ tags: ["posts", "01ABC"] });
-	assert.equal(invalidated(), true);
-	assert.deepEqual(calls.at(-1), { tags: ["posts", "01ABC"] }, "the route's call still reaches the cache");
-	assert.equal(watchInvalidation(undefined)(), false, "no route cache");
-	assert.equal(watchInvalidation({})(), false);
-});
-
-// ── After a failed read (src/core/read-failures.ts) ─────────────
-
-// Astro's own route cache (what context.cache is in production), so set(false) and a later
-// set() behave as they really do: a later set() turns caching back on.
-const { AstroCache, applyCacheHeaders, isCacheActive } = await import(new URL("../../node_modules/astro/dist/core/cache/runtime/cache.js", import.meta.url).href);
-const PROVIDER = { setHeaders: (options) => new Headers({ "Cloudflare-CDN-Cache-Control": options.maxAge === undefined ? "public" : `public, max-age=${options.maxAge}` }) };
-function astroCache(maxAge = 604800) {
-	const cache = new AstroCache(PROVIDER);
-	cache.set({ maxAge, swr: 86400 });
-	return cache;
-}
-/** The CDN header Astro would send for this cache state. */
-const cdnHeader = (cache) => {
-	const response = new Response(null);
-	applyCacheHeaders(cache, response, new Request("https://example.com/"));
-	return response.headers.get("Cloudflare-CDN-Cache-Control");
-};
-
-test("Astro's cache: a set() after set(false) turns caching back on (why settlePage decides last)", () => {
-	const cache = astroCache();
-	cache.set(false);
-	assert.equal(isCacheActive(cache), false);
-	cache.set({ tags: ["emdash:menu:primary"] });
-	assert.equal(isCacheActive(cache), true);
-	assert.equal(cdnHeader(cache), "public");
-});
-
-test("a page whose render saw a failed read isn't cached, decided after its body (a component's late cache.set can't undo it)", async () => {
-	const cache = astroCache();
-	let failed = false;
-	// The layout renders while the body streams: a settings read fails, then the menu adds its cache tag.
-	const stream = new ReadableStream({
-		async pull(controller) {
-			await new Promise((r) => setTimeout(r, 0));
-			failed = true;
-			cache.set({ tags: ["emdash:menu:primary"] });
-			controller.enqueue(new TextEncoder().encode("<main></main>"));
-			controller.close();
-		},
-	});
-	const out = await settlePage(cache, html(stream, { headers: { "content-type": "text/html", "x-keep": "1" } }), { failed: () => failed, label: "GET /a/" });
-	assert.equal(isCacheActive(cache), false);
-	assert.equal(cdnHeader(cache), null, "no Cloudflare-CDN-Cache-Control: the adapter sends no-store");
-	assert.equal(await out.text(), "<main></main>", "the visitor still gets the page");
-	assert.equal(out.headers.get("x-keep"), "1");
-	assert.equal(out.status, 200);
-});
-
-test("a failed read wins over a stopgap; the cache warmer is told to come back", async () => {
-	const visitor = astroCache();
-	await settlePage(visitor, html(), { failed: () => true, stopgap: () => true });
-	assert.equal(isCacheActive(visitor), false, "not cached for minutes either");
-
-	const warmer = astroCache();
-	const marked = await settlePage(warmer, html(), { failed: () => true, markHeader: "X-Coywolf-Stopgap" });
-	assert.equal(isCacheActive(warmer), false);
-	assert.equal(marked.headers.get("x-coywolf-stopgap"), "1", "visited again later (src/pageCache/warm.ts)");
-});
-
-test("other responses after a failed read: left out of the cache without reading their body", async () => {
-	for (const response of [
-		new Response("User-agent: *\nAllow: /\n", { headers: { "content-type": "text/plain" } }), // EmDash's robots.txt
-		new Response("{}", { headers: { "content-type": "application/json" } }),
-		html("<p>later</p>", { status: 503 }),
-		new Response(null, { status: 200, headers: { "content-type": "text/html" } }), // HEAD
-	]) {
-		const cache = astroCache();
-		const out = await settlePage(cache, response, { failed: () => true });
-		assert.equal(out, response, "returned as is, still streaming");
-		assert.equal(response.bodyUsed, false);
-		assert.equal(isCacheActive(cache), false, response.headers.get("content-type"));
-	}
-	// A route that only had cache tags (no lifetime) is still left out.
-	const tagged = new AstroCache(PROVIDER);
-	tagged.set({ tags: ["posts"] });
-	await settlePage(tagged, html(), { failed: () => true });
-	assert.equal(isCacheActive(tagged), false);
-});
-
-test("no failed read: a cacheable page keeps its lifetime, and an uncached route is never turned on", async () => {
-	const cache = astroCache();
-	const out = await settlePage(cache, html(), { failed: () => false });
-	assert.equal(await out.text(), "<p>hi</p>");
-	assert.equal(cdnHeader(cache), "public, max-age=604800");
-
-	const off = astroCache();
-	off.set(false); // e.g. a 404 the site turned off
-	await settlePage(off, html("gone", { status: 404 }), { failed: () => false });
-	assert.equal(isCacheActive(off), false);
-
-	const untouched = html();
-	assert.equal(await settlePage(undefined, untouched, { failed: () => assert.fail("asked") }), untouched, "no route cache (dev)");
-	assert.equal(await settlePage({ enabled: false, set: () => assert.fail("set") }, untouched, { failed: () => assert.fail("asked") }), untouched);
-});