@coywolf/emdash 0.35.13 → 0.35.14

package/src/backups/dump.test.mjs

@@ -1,287 +0,0 @@
-// Unit tests for the D1 dump: rows bigger than D1's statement limit restore intact.
-// Run: node --test src/backups/dump.test.mjs   (Node 22.6+ strips the types from dump.ts)
-import assert from "node:assert/strict";
-import { DatabaseSync } from "node:sqlite";
-import { test } from "node:test";
-
-const { dumpDatabase, splitText, MAX_STATEMENT_BYTES, nextPageSize, PAGE_TARGET_BYTES } = await import("./dump.ts");
-
-/** The slice of the D1 binding that dumpDatabase uses, over node:sqlite. */
-function d1(db) {
-	return {
-		prepare(sql) {
-			let params = [];
-			const stmt = {
-				bind(...args) {
-					params = args;
-					return stmt;
-				},
-				async all() {
-					return { results: db.prepare(sql).all(...params) };
-				},
-			};
-			return stmt;
-		},
-	};
-}
-
-function seed() {
-	const db = new DatabaseSync(":memory:");
-	db.exec(`CREATE TABLE options (name TEXT PRIMARY KEY, value TEXT, revision INTEGER);
-		CREATE TABLE ec_posts (id TEXT PRIMARY KEY, slug TEXT, content TEXT, excerpt TEXT);
-		CREATE TABLE log (line TEXT);`);
-	const insert = (sql, ...v) => db.prepare(sql).run(...v);
-	// 250 KB with quotes, CR/LF, emoji (surrogate pairs) and accents, so pieces split on awkward characters.
-	const big = Array.from({ length: 5000 }, (_, i) => `Line ${i}: it's "quoted" — café 🦊\r\n`).join("");
-	insert("INSERT INTO ec_posts VALUES (?, ?, ?, ?)", "p1", "long", big, big.slice(0, 120_000));
-	insert("INSERT INTO ec_posts VALUES (?, ?, ?, ?)", "p2", "short", "hello\nworld", null);
-	insert("INSERT INTO options VALUES (?, ?, ?)", "site:title", "Coywolf", 1);
-	insert("INSERT INTO options VALUES (?, ?, ?)", "plugin:coywolf-pack:cache:discovery:llms", big, 1);
-	insert("INSERT INTO log VALUES (?)", big);
-	return { db, big };
-}
-
-test("oversized rows are split into statements under the limit and restore intact", async () => {
-	const { db, big } = seed();
-	const { sql } = await dumpDatabase(d1(db));
-	const statements = sql.trim().split("\n");
-	for (const s of statements) assert.ok(new TextEncoder().encode(s).length <= MAX_STATEMENT_BYTES, `statement of ${s.length} chars`);
-	assert.ok(statements.some((s) => s.startsWith('UPDATE "ec_posts"')), "long post written in pieces");
-
-	const restored = new DatabaseSync(":memory:");
-	for (const s of statements) restored.exec(s);
-	const post = restored.prepare("SELECT * FROM ec_posts WHERE id = 'p1'").get();
-	assert.equal(post.content, big);
-	assert.equal(post.excerpt, big.slice(0, 120_000));
-	assert.equal(restored.prepare("SELECT content FROM ec_posts WHERE id = 'p2'").get().content, "hello\nworld");
-	assert.equal(restored.prepare("SELECT line FROM log").get().line, big, "table without a primary key uses rowid");
-});
-
-test("plugin caches are left out; other options are kept", async () => {
-	const { db } = seed();
-	const { sql, rows } = await dumpDatabase(d1(db));
-	assert.ok(!sql.includes("cache:discovery:llms"));
-	assert.ok(sql.includes("site:title"));
-	assert.equal(rows, 4);
-});
-
-test("splitText never cuts a surrogate pair and rejoins exactly", () => {
-	const text = "🦊".repeat(40_000);
-	const pieces = splitText(text);
-	assert.ok(pieces.length > 1);
-	assert.equal(pieces.join(""), text);
-	for (const p of pieces) assert.ok(!/^[\udc00-\udfff]/.test(p));
-});
-
-test("rows are paged by rowid across pages, in rowid order, and restore intact", async () => {
-	const db = new DatabaseSync(":memory:");
-	db.exec(`CREATE TABLE items (id TEXT PRIMARY KEY, n INTEGER);
-		CREATE TABLE plain (line TEXT);
-		CREATE TABLE odd (oid TEXT, v INTEGER);
-		CREATE TABLE kv (k TEXT PRIMARY KEY, v TEXT) WITHOUT ROWID;`);
-	for (let i = 0; i < 1234; i++) {
-		db.prepare("INSERT INTO items VALUES (?, ?)").run(`id-${String(1234 - i).padStart(4, "0")}`, i);
-		db.prepare("INSERT INTO plain VALUES (?)").run(`line ${i}`);
-		db.prepare("INSERT INTO odd VALUES (?, ?)").run(`o${i}`, i);
-		db.prepare("INSERT INTO kv VALUES (?, ?)").run(`k${i}`, `v${i}`);
-	}
-	// Gaps in the rowids, as deletes leave them.
-	db.exec("DELETE FROM items WHERE n % 7 = 0; DELETE FROM plain WHERE rowid BETWEEN 400 AND 650;");
-	const queries = [];
-	const binding = d1(db);
-	const spy = { prepare: (sql) => (queries.push(sql), binding.prepare(sql)) };
-	const { sql, rows } = await dumpDatabase(spy);
-	assert.ok(queries.some((q) => /FROM "items" WHERE rowid > \? ORDER BY rowid LIMIT \?/.test(q)), "paged by rowid");
-	assert.ok(queries.some((q) => /FROM "odd" ORDER BY rowid LIMIT \? OFFSET \?/.test(q)), "a column named oid falls back to OFFSET");
-	assert.ok(queries.some((q) => /FROM "kv" LIMIT \? OFFSET \?/.test(q)), "WITHOUT ROWID uses OFFSET");
-	assert.ok(!sql.includes("__coywolf_rowid"), "the paging cursor is never written");
-
-	const restored = new DatabaseSync(":memory:");
-	for (const s of sql.trim().split("\n")) restored.exec(s);
-	for (const table of ["items", "plain", "odd", "kv"]) {
-		assert.deepEqual(restored.prepare(`SELECT * FROM ${table} ORDER BY 1`).all(), db.prepare(`SELECT * FROM ${table} ORDER BY 1`).all(), table);
-	}
-	// Same order as before (rowid order): the n column of items rises.
-	const ns = [...sql.matchAll(/INSERT INTO "items" \("id","n"\) VALUES\('[^']+',(\d+)\);/g)].map((m) => Number(m[1]));
-	assert.deepEqual(ns, [...ns].sort((a, b) => a - b));
-	assert.equal(rows, db.prepare("SELECT (SELECT count(*) FROM items) + (SELECT count(*) FROM plain) + 1234 + 1234 AS n").get().n);
-});
-
-/** An R2 bucket that keeps what's put and records multipart uploads. */
-function fakeBucket() {
-	const store = new Map();
-	const uploads = [];
-	return {
-		store,
-		uploads,
-		async put(key, body) {
-			store.set(key, Buffer.from(body));
-		},
-		async createMultipartUpload(key) {
-			const parts = [];
-			const upload = { key, parts, completed: false, aborted: false };
-			uploads.push(upload);
-			return {
-				async uploadPart(n, body) {
-					parts.push({ n, size: body.byteLength, body: Buffer.from(body) });
-					return { partNumber: n, etag: `e${n}` };
-				},
-				async complete(list) {
-					upload.completed = true;
-					store.set(key, Buffer.concat(list.map((p) => parts.find((x) => x.n === p.partNumber).body)));
-				},
-				async abort() {
-					upload.aborted = true;
-				},
-			};
-		},
-	};
-}
-
-test("the dump streams into the bucket: multipart parts of one size, same bytes as the whole", async () => {
-	const { writeDumpStream } = await import("./store.ts");
-	const { dumpLines } = await import("./dump.ts");
-	const { gunzipSync } = await import("node:zlib");
-	const { createHash } = await import("node:crypto");
-	const { db } = seed();
-	const lines = [];
-	for await (const line of dumpLines(d1(db))) lines.push(line);
-	async function* replay() {
-		yield* lines;
-	}
-
-	const big = fakeBucket();
-	const result = await writeDumpStream(big, "2026-10-05T1200Z", "site.sql.gz", replay(), 4096);
-	const stored = big.store.get("d1/2026-10-05T1200Z/site.sql.gz");
-	assert.equal(big.uploads.length, 1);
-	const sizes = big.uploads[0].parts.map((p) => p.size);
-	assert.ok(sizes.length > 2, `${sizes.length} parts`);
-	assert.ok(sizes.slice(0, -1).every((s) => s === 4096), "every part but the last is exactly one part size");
-	assert.equal(result.bytes, stored.length);
-	assert.equal(result.sha256, createHash("sha256").update(stored).digest("hex"));
-	assert.equal(gunzipSync(stored).toString("utf8"), `${lines.join("\n")}\n`);
-
-	const small = fakeBucket();
-	await writeDumpStream(small, "2026-10-05T1200Z", "site.sql.gz", replay());
-	assert.equal(small.uploads.length, 0, "under one part: a single put");
-	assert.equal(gunzipSync(small.store.get("d1/2026-10-05T1200Z/site.sql.gz")).toString("utf8"), (await dumpDatabase(d1(db))).sql);
-});
-
-test("a failed dump aborts the upload and reports the dump's error", async () => {
-	const { writeDumpStream } = await import("./store.ts");
-	const bucket = fakeBucket();
-	async function* failing() {
-		for (let i = 0; i < 4000; i++) yield `${Math.random().toString(36)}${Math.random().toString(36)}`;
-		throw new Error("D1 went away");
-	}
-	await assert.rejects(() => writeDumpStream(bucket, "2026-10-05T1200Z", "x.sql.gz", failing(), 1024), /D1 went away/);
-	assert.equal(bucket.uploads.length, 1);
-	assert.equal(bucket.uploads[0].aborted, true);
-	assert.equal(bucket.store.size, 0);
-});
-
-test("a failed upload stops the dump instead of hanging", async () => {
-	const { writeDumpStream } = await import("./store.ts");
-	let aborted = false;
-	const bucket = {
-		async put() {},
-		async createMultipartUpload() {
-			return {
-				uploadPart: async () => {
-					throw new Error("R2 unavailable");
-				},
-				complete: async () => {},
-				abort: async () => {
-					aborted = true;
-				},
-			};
-		},
-	};
-	let produced = 0;
-	async function* endless() {
-		for (;;) {
-			produced++;
-			yield `${Math.random().toString(36)}${Math.random().toString(36)}${Math.random().toString(36)}`;
-		}
-	}
-	await assert.rejects(() => writeDumpStream(bucket, "2026-10-05T1200Z", "x.sql.gz", endless(), 1024), /R2 unavailable/);
-	assert.equal(aborted, true);
-	const stopped = produced;
-	await new Promise((resolve) => setTimeout(resolve, 20));
-	assert.equal(produced, stopped, "the dump stops reading rows");
-});
-
-test("reads are sized by bytes: big rows mean fewer rows per read, never more than 500", () => {
-	assert.equal(nextPageSize(0, 0), 500);
-	assert.equal(nextPageSize(500 * 200, 500), 500, "small rows: the full page");
-	assert.equal(nextPageSize(10 * 1024 * 1024, 10), Math.floor(PAGE_TARGET_BYTES / (1024 * 1024)), "1 MB rows: about 8 a read");
-	assert.equal(nextPageSize(50 * 1024 * 1024, 1), 1, "never below one row");
-});
-
-test("a read D1 refuses as too large is asked again for fewer rows; offset paging skips nothing", async () => {
-	// 600 rows of ~40 KB each in a table paged by OFFSET (a column named rowid shadows the real one),
-	// with a fake D1 that refuses any result over 5 MB, as D1 does over 50 MB.
-	const db = new DatabaseSync(":memory:");
-	db.exec("CREATE TABLE odd (rowid TEXT, body TEXT)");
-	const body = "x".repeat(40_000);
-	for (let i = 0; i < 600; i++) db.prepare("INSERT INTO odd VALUES (?, ?)").run(`r${i}`, `${i}:${body}`);
-	const base = d1(db);
-	let refused = 0;
-	const limited = {
-		prepare(sql) {
-			const stmt = base.prepare(sql);
-			let params = [];
-			return {
-				bind(...args) {
-					params = args;
-					stmt.bind(...args);
-					return this;
-				},
-				async all() {
-					const out = await stmt.all();
-					const size = JSON.stringify(out.results).length;
-					if (/FROM "odd"/.test(sql) && size > 5_000_000) {
-						refused++;
-						throw new Error("D1_ERROR: result too large");
-					}
-					return out;
-				},
-			};
-		},
-	};
-	const { sql, rows } = await dumpDatabase(limited);
-	assert.ok(refused >= 1, "the first 500-row read was refused");
-	assert.equal(rows, 600);
-	const restored = new DatabaseSync(":memory:");
-	for (const s of sql.trim().split("\n")) restored.exec(s);
-	assert.equal(restored.prepare("SELECT count(*) AS n FROM odd").get().n, 600, "every row once");
-	assert.equal(restored.prepare("SELECT count(DISTINCT rowid) AS n FROM odd").get().n, 600, "no row twice");
-});
-
-test("other read errors aren't retried with fewer rows: they fail the backup at once", async () => {
-	const db = new DatabaseSync(":memory:");
-	db.exec("CREATE TABLE t (id TEXT PRIMARY KEY, v TEXT)");
-	db.prepare("INSERT INTO t VALUES ('a', 'b')").run();
-	const base = d1(db);
-	let reads = 0;
-	const failing = {
-		prepare(sql) {
-			const stmt = base.prepare(sql);
-			return {
-				bind(...args) {
-					stmt.bind(...args);
-					return this;
-				},
-				async all() {
-					if (/FROM "t"/.test(sql)) {
-						reads++;
-						throw new Error("D1_ERROR: Network connection lost.");
-					}
-					return stmt.all();
-				},
-			};
-		},
-	};
-	await assert.rejects(dumpDatabase(failing), /Network connection lost/);
-	assert.equal(reads, 1, "asked once, not again with fewer rows");
-});

package/src/backups/restore.test.mjs

@@ -1,103 +0,0 @@
-// Unit tests for restoring missing media in batches.
-// Run: node --test src/backups/restore.test.mjs   (Node 22.6+ strips the types from store.ts)
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-const { restoreMissingMedia, mirrorBucket, pruneBackups } = await import("./store.ts");
-
-/** The slice of an R2 bucket that restoreMissingMedia uses, paging 100 keys at a time like R2's default 1,000. */
-function bucket(entries = {}) {
-	const store = new Map(Object.entries(entries));
-	return {
-		store,
-		async list({ prefix = "", cursor, delimiter } = {}) {
-			const keys = [...store.keys()].filter((k) => k.startsWith(prefix)).sort();
-			if (delimiter) {
-				const dirs = [...new Set(keys.map((k) => k.slice(prefix.length)).filter((k) => k.includes(delimiter)).map((k) => prefix + k.split(delimiter)[0] + delimiter))];
-				return { objects: [], delimitedPrefixes: dirs, truncated: false };
-			}
-			const start = cursor ? Number(cursor) : 0;
-			const page = keys.slice(start, start + 100);
-			const truncated = start + 100 < keys.length;
-			return { objects: page.map((key) => ({ key, etag: `e-${store.get(key)}` })), truncated, cursor: truncated ? String(start + 100) : undefined };
-		},
-		async get(key) {
-			return store.has(key) ? { body: store.get(key), httpMetadata: {} } : null;
-		},
-		async put(key, body) {
-			store.set(key, body);
-		},
-		async delete(keys) {
-			for (const k of [].concat(keys)) store.delete(k);
-		},
-	};
-}
-
-test("restores missing media in batches until nothing is pending, never overwriting", async () => {
-	const mirror = {};
-	for (let i = 0; i < 450; i++) mirror[`media/current/file-${String(i).padStart(3, "0")}.jpg`] = `backup-${i}`;
-	const backups = bucket(mirror);
-	const media = bucket({ "file-000.jpg": "live-0" });
-
-	const runs = [];
-	for (;;) {
-		const result = await restoreMissingMedia(media, backups, 200);
-		runs.push(result);
-		if (!result.pending) break;
-	}
-	assert.deepEqual(runs.map((r) => [r.restored, r.pending]), [[200, 249], [200, 49], [49, 0]]);
-	assert.equal(media.store.size, 450);
-	assert.equal(media.store.get("file-000.jpg"), "live-0", "existing files are left alone");
-	assert.equal(media.store.get("file-449.jpg"), "backup-449");
-	assert.deepEqual(await restoreMissingMedia(media, backups, 200), { restored: 0, checked: 450, pending: 0 });
-});
-
-test("private form uploads mirror to uploads/ and restore from there, separate from media", async () => {
-	const uploads = bucket({ "forms/a.pdf": "A", "forms/b.png": "B" });
-	const backups = bucket({ "media/current/photo.jpg": "P" });
-	const first = await mirrorBucket(uploads, backups, "2020-01-01T0600Z", "uploads");
-	assert.deepEqual(first, { copied: 2, preserved: 0, total: 2, pending: 0 });
-	assert.equal(backups.store.get("uploads/current/forms/a.pdf"), "A");
-
-	// A replaced upload keeps its old copy under uploads/changed/<stamp>/; a deleted one too.
-	uploads.store.set("forms/a.pdf", "A2");
-	uploads.store.delete("forms/b.png");
-	await mirrorBucket(uploads, backups, "2020-01-02T0600Z", "uploads");
-	assert.equal(backups.store.get("uploads/current/forms/a.pdf"), "A2");
-	assert.equal(backups.store.get("uploads/changed/2020-01-02T0600Z/forms/a.pdf"), "A");
-	assert.equal(backups.store.get("uploads/changed/2020-01-02T0600Z/forms/b.png"), "B");
-	assert.ok(!backups.store.has("uploads/current/forms/b.png"));
-	assert.equal(backups.store.get("media/current/photo.jpg"), "P", "media mirror untouched");
-
-	const empty = bucket();
-	const restored = await restoreMissingMedia(empty, backups, 200, "uploads");
-	assert.deepEqual(restored, { restored: 1, checked: 1, pending: 0 });
-	assert.equal(empty.store.get("forms/a.pdf"), "A2");
-	assert.ok(!empty.store.has("photo.jpg"), "media isn't restored into the uploads bucket");
-
-	// Old replaced copies are pruned like media's.
-	assert.equal(await pruneBackups(backups, 1), 0);
-	assert.ok(![...backups.store.keys()].some((k) => k.startsWith("uploads/changed/2020-01-02")), "uploads/changed pruned");
-});
-
-test("the mirror copies a few files at a time, never more than its limit", async () => {
-	const { MIRROR_CONCURRENCY } = await import("./store.ts");
-	const files = {};
-	for (let i = 0; i < 40; i++) files[`f${i}.jpg`] = `v${i}`;
-	const media = bucket(files);
-	const backups = bucket({ "media/current/f0.jpg": "old", "media/current/gone.jpg": "G" });
-	let inFlight = 0;
-	let most = 0;
-	const slowGet = media.get.bind(media);
-	media.get = async (key) => {
-		most = Math.max(most, ++inFlight);
-		await new Promise((resolve) => setTimeout(resolve, 2));
-		inFlight--;
-		return slowGet(key);
-	};
-	const result = await mirrorBucket(media, backups, "2020-01-03T0600Z", "media", 30);
-	assert.equal(most, MIRROR_CONCURRENCY);
-	assert.deepEqual(result, { copied: 30, preserved: 1, total: 40, pending: 11 });
-	assert.equal(backups.store.get("media/changed/2020-01-03T0600Z/f0.jpg"), "old", "a replaced file's old copy is kept before it's overwritten");
-	assert.equal(backups.store.get("media/current/f0.jpg"), "v0");
-});

package/src/codeBlocks/render.test.ts

@@ -1,152 +0,0 @@
-/**
- * Run: node --test src/codeBlocks/render.test.ts   (Node 22.18+ strips types)
- */
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-// A literal ".ts" specifier would trip tsc (no allowImportingTsExtensions); Node needs the real file name.
-const path = "./render" + ".ts";
-const r: typeof import("./render.js") = await import(path);
-
-test("escapes text in highlighted and plain output", () => {
-	const html = r.renderBlock({ code: `<script>alert("x")</script> & </code>`, language: "zig" }, { label: true, copy: false, lineNumbers: false });
-	assert.ok(!html.includes("<script>"));
-	assert.ok(html.includes("&lt;script&gt;alert(&quot;x&quot;)&lt;/script&gt; &amp; &lt;/code&gt;"));
-	const hl = r.highlightLines(`const a = "<b>";`, "javascript").join("\n");
-	assert.ok(hl.includes("&lt;b&gt;"));
-	assert.ok(!hl.includes("<b>"));
-});
-
-test("shows the language, not the file name, and escapes an unknown language label", () => {
-	const html = r.renderBlock({ code: "x", language: `"><img src=x>`, filename: `<i>a.ts</i>` }, { label: true, copy: false, lineNumbers: false });
-	assert.ok(!html.includes("<img"));
-	assert.ok(!html.includes("a.ts"));
-	assert.match(html, /class="language-img-src-x"/);
-	const ts = r.renderBlock({ code: "let a = 1;", language: "typescript", filename: "greet.ts" }, { label: true, copy: true, lineNumbers: false });
-	assert.match(ts, /<div class="cw-code-head"><span class="cw-code-label">TypeScript<\/span><\/div>/);
-	assert.ok(!ts.includes("greet.ts"));
-});
-
-test("only hljs classes survive hast → HTML", () => {
-	const lines = r.hastToLines({
-		type: "root",
-		children: [
-			{
-				type: "element",
-				tagName: "span",
-				properties: { className: ["hljs-title", "function_", "evil\" onclick=\"x", "other"] },
-				children: [{ type: "text", value: "f" }],
-			},
-			{ type: "element", tagName: "img", properties: { src: "x", onerror: "alert(1)" }, children: [{ type: "text", value: "y" }] },
-			{ type: "comment", value: "<!-- no -->" },
-		],
-	});
-	assert.deepEqual(lines, ['<span class="hljs-title function_">f</span>y']);
-});
-
-test("unknown languages fall back to plain text", () => {
-	const lang = r.resolveLanguage("klingon");
-	assert.equal(lang.grammar, null);
-	assert.equal(lang.id, "klingon");
-	const html = r.renderBlock({ code: "if (x) { y }", language: "klingon" }, { label: false, copy: false, lineNumbers: false });
-	assert.ok(!html.includes("hljs-"));
-	assert.ok(html.includes("if (x) { y }"));
-	assert.equal(r.resolveLanguage("").id, null);
-	assert.equal(r.resolveLanguage("plaintext").label, null);
-});
-
-test("aliases and editor ids map to grammars", () => {
-	assert.equal(r.resolveLanguage("ts").grammar, "typescript");
-	assert.equal(r.resolveLanguage("TSX").grammar, "typescript");
-	assert.equal(r.resolveLanguage("html").grammar, "xml");
-	assert.equal(r.resolveLanguage("html").label, "HTML");
-	assert.equal(r.resolveLanguage("dockerfile").grammar, "dockerfile");
-	assert.equal(r.resolveLanguage("zig").grammar, null);
-	assert.equal(r.resolveLanguage("zig").label, "Zig");
-});
-
-test("spans crossing newlines are closed and reopened per line", () => {
-	const lines = r.highlightLines("/* one\n   two */\nx = 1", "javascript");
-	assert.equal(lines.length, 3);
-	assert.equal(lines[0], '<span class="hljs-comment">/* one</span>');
-	assert.equal(lines[1], '<span class="hljs-comment">   two */</span>');
-	for (const line of lines) {
-		assert.equal((line.match(/<span/g) ?? []).length, (line.match(/<\/span>/g) ?? []).length, line);
-	}
-});
-
-test("nested spans split across lines keep their nesting", () => {
-	const lines = r.hastToLines({
-		type: "root",
-		children: [
-			{
-				type: "element",
-				tagName: "span",
-				properties: { className: ["hljs-string"] },
-				children: [
-					{ type: "text", value: "`a\n" },
-					{ type: "element", tagName: "span", properties: { className: ["hljs-subst"] }, children: [{ type: "text", value: "${b\nc}" }] },
-					{ type: "text", value: "`" },
-				],
-			},
-		],
-	});
-	assert.deepEqual(lines, [
-		'<span class="hljs-string">`a</span>',
-		'<span class="hljs-string"><span class="hljs-subst">${b</span></span>',
-		'<span class="hljs-string"><span class="hljs-subst">c}</span>`</span>',
-	]);
-});
-
-test("line numbers wrap each line; trailing newline adds no empty line", () => {
-	const html = r.renderBlock({ code: "a\nb\n", language: "plaintext" }, { label: true, copy: false, lineNumbers: true });
-	assert.equal((html.match(/class="cw-line"/g) ?? []).length, 2);
-	assert.ok(!html.includes("cw-code-head"), "plain text has no label");
-});
-
-test("copy button is accessible and optional", () => {
-	const on = r.renderBlock({ code: "x", language: "js" }, { label: true, copy: true, lineNumbers: false });
-	assert.ok(on.includes('aria-label="Copy code to clipboard"'));
-	assert.ok(on.includes('role="status" aria-live="polite"'));
-	assert.ok(on.includes('<span class="cw-code-label">JavaScript</span>'));
-	const off = r.renderBlock({ code: "x", language: "js" }, { label: false, copy: false, lineNumbers: false });
-	assert.ok(!off.includes("button"));
-	assert.ok(!off.includes("cw-code-label"));
-});
-
-test("very large blocks skip highlighting", () => {
-	const code = "const x = 1;\n".repeat(Math.ceil(r.MAX_HIGHLIGHT_CHARS / 13) + 1);
-	assert.ok(!r.highlightLines(code, "javascript").some((l) => l.includes("<span")));
-});
-
-test("any line over the limit skips highlighting, quickly", () => {
-	const long = `const s = "${"a".repeat(r.MAX_HIGHLIGHT_LINE)}";`;
-	const started = performance.now();
-	const lines = r.highlightLines(`let a = 1;\n${long}\nlet b = 2;`, "javascript");
-	assert.ok(performance.now() - started < 50);
-	assert.equal(lines.length, 3);
-	assert.ok(!lines.some((l) => l.includes("<span")));
-	assert.ok(lines[1]!.includes("&quot;"));
-	const ok = `const s = "${"a".repeat(r.MAX_HIGHLIGHT_LINE - 20)}";`;
-	assert.ok(r.highlightLines(ok, "javascript")[0]!.includes("<span"));
-	const huge = `x = "${"b".repeat(40_000)}"`;
-	const t2 = performance.now();
-	r.highlightLines(huge, "typescript");
-	assert.ok(performance.now() - t2 < 50);
-});
-
-test("rendered blocks are cached and keyed by options and code", () => {
-	const node = { code: "let a = 1;", language: "js" };
-	const a = r.renderBlock(node, { label: true, copy: false, lineNumbers: false });
-	assert.equal(r.renderBlock({ ...node }, { label: true, copy: false, lineNumbers: false }), a);
-	assert.notEqual(r.renderBlock(node, { label: true, copy: false, lineNumbers: true }), a);
-	assert.notEqual(r.renderBlock({ ...node, code: "let a = 2;" }, { label: true, copy: false, lineNumbers: false }), a);
-});
-
-test("unknown language ids are capped at 40 characters", () => {
-	const lang = r.resolveLanguage("x".repeat(100));
-	assert.equal(lang.id!.length, 40);
-	const html = r.renderBlock({ code: "y", language: "z".repeat(100) }, { label: false, copy: false, lineNumbers: false });
-	assert.ok(html.includes(`data-language="${"z".repeat(40)}"`));
-	assert.ok(!html.includes("z".repeat(41)));
-});

package/src/files/counts.test.ts

@@ -1,114 +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 { createDownloadCounter } from "./counts.ts";
-// @ts-expect-error -- Node's type stripping needs the real .ts extension.
-import { ifRangeMatches, parseRange, resolveRange } from "./range.ts";
-
-/** A D1 stand-in that records the (id, n) of each upsert, with a controllable write delay. */
-function stubDb(writeMs = 0) {
-	const writes: Array<Array<[string, number]>> = [];
-	return {
-		writes,
-		prepare: () => ({ bind: (...v: unknown[]) => [v[2] as string, v[3] as number] }),
-		batch: async (statements: unknown[]) => {
-			await new Promise((r) => setTimeout(r, writeMs));
-			writes.push(statements as Array<[string, number]>);
-		},
-	};
-}
-
-const total = (writes: Array<Array<[string, number]>>) => {
-	const out: Record<string, number> = {};
-	for (const batch of writes) for (const [id, n] of batch) out[id] = (out[id] ?? 0) + n;
-	return out;
-};
-
-test("counts in a burst are written in one batch", async () => {
-	const counter = createDownloadCounter("p", "c", 5);
-	const db = stubDb();
-	const waits: Promise<unknown>[] = [];
-	for (let i = 0; i < 3; i++) counter.count(db, "a", (p: Promise<unknown>) => waits.push(p));
-	counter.count(db, "b", (p: Promise<unknown>) => waits.push(p));
-	await Promise.all(waits);
-	assert.equal(db.writes.length, 1);
-	assert.deepEqual(total(db.writes), { a: 3, b: 1 });
-	assert.ok(counter.idle);
-});
-
-test("a count made during a write is not lost", async () => {
-	const counter = createDownloadCounter("p", "c", 5);
-	const db = stubDb(20);
-	const waits: Promise<unknown>[] = [];
-	const waitUntil = (p: Promise<unknown>) => waits.push(p);
-	counter.count(db, "a", waitUntil);
-	await new Promise((r) => setTimeout(r, 12)); // First batch is now being written.
-	counter.count(db, "a", waitUntil);
-	await Promise.all(waits);
-	assert.deepEqual(total(db.writes), { a: 2 });
-	assert.equal(counter.pendingSize, 0);
-	// After the flush finished, a new count starts a new flush.
-	counter.count(db, "z", waitUntil);
-	assert.ok(!counter.idle);
-	await Promise.all(waits);
-	assert.deepEqual(total(db.writes), { a: 2, z: 1 });
-	assert.equal(counter.pendingSize, 0);
-});
-
-test("a failed write doesn't stop later counts", async () => {
-	const counter = createDownloadCounter("p", "c", 1);
-	let fail = true;
-	const db = stubDb();
-	const batch = db.batch;
-	db.batch = async (s: unknown[]) => {
-		if (fail) {
-			fail = false;
-			throw new Error("D1 down");
-		}
-		return batch(s);
-	};
-	const waits: Promise<unknown>[] = [];
-	const orig = console.error;
-	console.error = () => undefined;
-	counter.count(db, "a", (p: Promise<unknown>) => waits.push(p));
-	await Promise.all(waits);
-	console.error = orig;
-	assert.ok(counter.idle);
-	counter.count(db, "b", (p: Promise<unknown>) => waits.push(p));
-	await Promise.all(waits);
-	assert.deepEqual(total(db.writes), { b: 1 });
-});
-
-test("Range parsing: single ranges only", () => {
-	assert.deepEqual(parseRange("bytes=0-99"), { offset: 0, end: 99 });
-	assert.deepEqual(parseRange("bytes=100-"), { offset: 100 });
-	assert.deepEqual(parseRange("bytes=-500"), { suffix: 500 });
-	assert.equal(parseRange("bytes=0-99,200-299"), null); // Multi-range → whole file (200).
-	assert.equal(parseRange("bytes=5-1"), null);
-	assert.equal(parseRange("bytes=-0"), null);
-	assert.equal(parseRange("items=0-1"), null);
-	assert.equal(parseRange(null), null);
-});
-
-test("Range resolution clamps to the file", () => {
-	assert.deepEqual(resolveRange({ suffix: 5000 }, 1000), { offset: 0, length: 1000 });
-	assert.deepEqual(resolveRange({ suffix: 10 }, 1000), { offset: 990, length: 10 });
-	assert.deepEqual(resolveRange({ offset: 900, end: 5000 }, 1000), { offset: 900, length: 100 });
-	assert.deepEqual(resolveRange({ offset: 10 }, 1000), { offset: 10, length: 990 });
-	assert.equal(resolveRange({ offset: 1000 }, 1000), null);
-	assert.equal(resolveRange({ suffix: 1 }, 0), null);
-});
-
-test("If-Range", () => {
-	const modified = new Date("2026-10-01T12:00:00Z");
-	assert.ok(ifRangeMatches(null, '"abc"', modified));
-	assert.ok(ifRangeMatches('"abc"', '"abc"', modified));
-	assert.ok(!ifRangeMatches('"old"', '"abc"', modified));
-	assert.ok(!ifRangeMatches('W/"abc"', '"abc"', modified));
-	assert.ok(ifRangeMatches("Thu, 01 Oct 2026 12:00:00 GMT", '"abc"', modified));
-	assert.ok(!ifRangeMatches("Wed, 30 Sep 2026 12:00:00 GMT", '"abc"', modified));
-});