import type { Database } from "bun:sqlite";
import { beforeAll, describe, expect, test } from "bun:test";
import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import type { Hono } from "hono";
import { openBucket } from "../src/bucket/reader.ts";
import { syncAll } from "../src/bucket/sync.ts";
import { fileAt, objectBytes, type Save } from "../src/mirror/queries.ts";
import { openMirror } from "../src/mirror/store.ts";
import { timelineSaves, timelineSvg } from "../src/pages/timeline.ts";
import { createApp } from "../src/server/app.ts";
import { openKeprDb } from "../src/server/db.ts";
import { type Fixture, makeKohBucket } from "./fixture.ts";

let fx: Fixture;
let app: Hono;
let kepr: Database;
let mirrorDir: string;
let tailSaves: string[];
const get = (path: string) => app.request(path);
const body = async (path: string) => (await get(path)).text();
// History's IDs only, not the Atlas picker's, which lists every save.
const historyIds = (page: string) => {
	const list = /data-list="history">(.*?)<\/div>/s.exec(page)?.[1] ?? "";
	return [...list.matchAll(/class="history-id">([0-9a-f]+)</g)].map((m) => m[1]);
};

beforeAll(async () => {
	fx = await makeKohBucket();
	const secretRepo = await makeKohBucket("hidden");
	const large = await makeKohBucket("large");
	// Over 1 MB each: text with a two-byte "é" split by the 1 MB mark, and invalid UTF-8 with no NUL.
	await writeFile(
		join(large.repoDir, "big.txt"),
		`${"a".repeat(1024 * 1024 - 1)}é${"b".repeat(1000)}\n`,
	);
	await writeFile(join(large.repoDir, "big.bin"), new Uint8Array(1024 * 1024 + 500).fill(0xff));
	Bun.spawnSync(["koh", "save", "add large files"], {
		cwd: large.repoDir,
		env: { PATH: process.env.PATH, HOME: join(large.repoDir, "../../home"), NO_COLOR: "1" },
	});
	// A file that gains its final newline, then loses it again.
	const tail = await makeKohBucket("tail");
	const tailEnv = { PATH: process.env.PATH, HOME: join(tail.repoDir, "../../home"), NO_COLOR: "1" };
	for (const [text, message] of [
		["a\nb", "add tail"],
		["a\nb\n", "end tail with a newline"],
		["a\nb", "drop the newline"],
	] as const) {
		await writeFile(join(tail.repoDir, "tail.txt"), text);
		Bun.spawnSync(["koh", "save", message], { cwd: tail.repoDir, env: tailEnv });
	}
	tailSaves = JSON.parse(
		Bun.spawnSync(["koh", "view", "--json"], {
			cwd: tail.repoDir,
			env: tailEnv,
		}).stdout.toString(),
	).saves.map((save: { id: string }) => save.id);
	const dataDir = await mkdtemp(join(tmpdir(), "kepr-pages-"));
	await mkdir(join(dataDir, "assets"));
	await writeFile(join(dataDir, "assets", "plain.txt"), "asset\n");
	kepr = openKeprDb(dataDir);
	mirrorDir = join(dataDir, "mirror");
	for (const bucketDir of [fx.bucketDir, secretRepo.bucketDir, large.bucketDir, tail.bucketDir]) {
		const bucket = openBucket({ kind: "folder", path: bucketDir });
		await syncAll({ bucket, kepr, mirrorDir });
	}
	kepr.run("UPDATE repos SET public = 1, homepage = 'https://demo.example' WHERE name = 'demo'");
	kepr.run("UPDATE repos SET public = 1 WHERE name IN ('large', 'tail')");
	app = createApp(
		{
			domain: "kepr.example",
			dataDir,
			adminPasswordHash: "$argon2id$x",
			bucket: { kind: "folder", path: fx.bucketDir },
		},
		kepr,
	);
});

const [head, , second, first] = [0, 1, 2, 3].map((i) => () => fx.saveIds[i] as string);

describe("the visibility gate", () => {
	test("a private repo and an unknown one are the same 404, everywhere", async () => {
		for (const suffix of ["", "/files/src/main.ts", "/raw/src/main.ts"]) {
			const hidden = await get(`/hidden${suffix}`);
			const missing = await get(`/nowhere${suffix}`);
			expect(hidden.status).toBe(404);
			expect(missing.status).toBe(404);
			expect((await hidden.text()).replaceAll("/hidden", "/nowhere")).toBe(await missing.text());
		}
	});
});

describe("the repo page", () => {
	test("renders header, timeline, history and README at HEAD with a short cache", async () => {
		const response = await get("/demo");
		expect(response.status).toBe(200);
		expect(response.headers.get("cache-control")).toBe("public, max-age=60");
		const page = await response.text();
		expect(page).toContain('<h1 class="repo-name">demo</h1>');
		// The README opens with an HTML comment and a raw <p align>; neither is the intro.
		expect(/<div class="repo-desc"><p>(.*?)<\/p>/.exec(page)?.[1]).toBe(
			"A small repo for <strong>Kepr's</strong> tests.",
		);
		expect(page).toContain(
			'<meta property="og:description" content="A small repo for Kepr&#39;s tests.">',
		);
		expect(page).toContain('href="https://demo.example"');
		expect(page).toContain('<span class="lang-badge">TypeScript</span>');
		expect(page).toContain("3 saves");
		expect(page).not.toContain('class="install-line"');
		expect(page.match(/<circle class="dot d\d"/g)?.length).toBe(3);
		expect(page).not.toContain("density = activity");
		expect(historyIds(page)).toEqual([head(), second(), first()]);
		expect(page).toContain('data-copy="koh steal kepr.example/demo"');
		expect(page).toContain('href="/demo/releases" data-panel="releases">builds</a>');
	});

	test("the issues tab counts only this repo's visible open issues and hides zero", async () => {
		kepr.run("BEGIN");
		try {
			kepr.run(`INSERT INTO issues (repo, number, title, body, type, filed_at, hidden, status) VALUES
('demo', 1, 'one', 'body', 'bug', 1, 0, 'open'),
('demo', 2, 'two', 'body', 'bug', 1, 0, 'open'),
('demo', 3, 'three', 'body', 'bug', 1, 0, 'open'),
('demo', 4, 'hidden', 'body', 'bug', 1, 1, 'open'),
('demo', 5, 'closed', 'body', 'bug', 1, 0, 'closed'),
('large', 1, 'another repo', 'body', 'bug', 1, 0, 'open')`);
			expect(await body("/demo")).toContain(
				'<span class="repo-issue-count" aria-label="3 open issues">3</span>',
			);
			kepr.run("UPDATE issues SET status = 'closed' WHERE repo = 'demo' AND number = 1");
			expect(await body("/demo")).toContain(
				'<span class="repo-issue-count" aria-label="2 open issues">2</span>',
			);
			kepr.run("UPDATE issues SET status = 'closed' WHERE repo = 'demo' AND number = 2");
			expect(await body("/demo")).toContain(
				'<span class="repo-issue-count" aria-label="1 open issue">1</span>',
			);
			kepr.run("UPDATE issues SET status = 'closed' WHERE repo = 'demo'");
			expect(await body("/demo")).not.toContain('class="repo-issue-count"');
		} finally {
			kepr.run("ROLLBACK");
		}
	});

	test("a page past the last, or too large to bind, is page 1", async () => {
		for (const query of ["?page=2", `?page=${"9".repeat(400)}`, "?page=1e999", "?page=x"]) {
			const response = await get(`/demo${query}`);
			expect([query, response.status]).toEqual([query, 200]);
			expect(historyIds(await response.text()).length).toBe(3);
		}
	});

	test("checkpoints never appear", async () => {
		expect(await body("/demo")).not.toContain(fx.saveIds[1] as string);
	});

	test("the README points relative links and images at raw files and drops unsafe links", async () => {
		const page = await body("/demo");
		expect(page).toContain('<a href="/demo/raw/docs/guide.md">the guide</a>');
		expect(page).toContain('<img src="/demo/raw/docs/logo.png" alt="logo">');
		expect(page).toContain('<a href="https://example.com">the site</a>');
		expect(page).not.toContain('href="javascript:');
		expect(page).toContain("&lt;script&gt;alert");
		expect(page).not.toContain("<script>alert");
	});
});

describe("the timeline", () => {
	// A replayed save keeps its original time, so newest-first order is not time order.
	const saves = [300, 100, 500, 200].map(
		(created_at, i): Save => ({
			id: `00000000000${i}`,
			parent: "",
			message: "m",
			created_at: created_at * 86400,
			machine: "m",
			agent: "",
			session: "",
			is_checkpoint: false,
		}),
	);

	test("span from the earliest to the latest save, whatever the line's order", () => {
		const dots = [...timelineSvg("demo", saves).value.matchAll(/cx="([\d.]+)%"/g)].map((m) => m[1]);
		expect(dots).toEqual(["50.000", "1.000", "99.000", "25.500"]);
	});

	test("a dot's neighbours are counted within a fractional reach exactly", () => {
		// A span of 144,001 s makes the reach 3,600.025 s: the save at 3,601 s is not within it.
		const at = (created_at: number) => ({ ...(saves[0] as Save), created_at });
		const svg = timelineSvg("demo", [at(0), at(3601), at(144001)]).value;
		expect(svg.match(/class="dot d(\d)"/g)).toEqual([
			'class="dot d0"',
			'class="dot d0"',
			'class="dot d0"',
		]);
	});

	test("a dot's tooltip keeps a long message's first 120 characters", () => {
		const long = { ...(saves[0] as Save), message: `${"x".repeat(150)}\nsecond line` };
		expect(timelineSaves([long])[0]?.message).toBe(`${"x".repeat(119)}…`);
	});

	test("the page carries plain dots; their words come from /<repo>/timeline", async () => {
		const page = await (await get("/demo")).text();
		expect(page).toContain('data-src="/demo/timeline"');
		expect(/<svg class="timeline"[\s\S]*?<\/svg>/.exec(page)?.[0]).not.toContain("<title>");
		const response = await get("/demo/timeline");
		expect(response.headers.get("cache-control")).toBe("public, max-age=60");
		const saves = (await response.json()) as { id: string; message: string }[];
		expect(saves.map((save) => save.message)).toContain("say hello");
		expect(saves.length).toBe(3);
		expect((await get("/nope/timeline")).status).toBe(404);
	});
});

describe("the file viewer", () => {
	test("shows a file at HEAD and at an old save, with line anchors", async () => {
		const now = await get("/demo/files/src/main.ts");
		expect(now.headers.get("cache-control")).toBe("public, max-age=60");
		const nowPage = await now.text();
		expect(nowPage).toContain("hello");
		expect(nowPage).toContain(
			'<span class="line" id="L2"><a class="ln" href="#L2">2</a><span class="lc">',
		);
		expect(nowPage).toContain('class="tk-');

		const then = await get(`/demo/files/src/main.ts?at=${second().slice(0, 6)}`);
		expect(then.headers.get("cache-control")).toBe("private, max-age=31536000");
		const thenPage = await then.text();
		expect(thenPage).toContain("&#39;hi&#39;");
		expect(thenPage).not.toContain("hello");
		expect(thenPage).toContain(`/demo/raw/src/main.ts?at=${second()}`);
	});

	test("a file absent at that save, a bad save or an unsafe path is a 404", async () => {
		expect((await get(`/demo/files/src/main.ts?at=${first()}`)).status).toBe(404);
		expect((await get("/demo/files/src/main.ts?at=zzzzzz")).status).toBe(404);
		expect((await get("/demo/files/src/main.ts?at=abc")).status).toBe(404);
		expect((await get("/demo/files/src%2F..%2FREADME.md")).status).toBe(404);
		expect((await get("/demo/files/nothing.txt")).status).toBe(404);
	});

	test("Markdown renders, with a source toggle", async () => {
		const rendered = await body("/demo/files/docs/guide.md");
		expect(rendered).toContain("<h1>Guide</h1>");
		const source = await body("/demo/files/docs/guide.md?view=source");
		expect(source).toContain('id="L1"');
		expect(source).not.toContain("<h1>Guide</h1>");
	});

	test("an image displays inline from its raw file", async () => {
		expect(await body("/demo/files/docs/logo.png")).toContain('<img src="/demo/raw/docs/logo.png"');
	});
});

describe("files over 1 MB", () => {
	test("text shows its first 1 MB with a raw link, even with a character cut at the mark", async () => {
		const page = await body("/large/files/big.txt");
		expect(page).toContain("showing the first 1 MB");
		expect(page).toContain('href="/large/raw/big.txt"');
		expect(page).not.toContain("bbb");
		const raw = await get("/large/raw/big.txt");
		expect(raw.headers.get("content-type")).toBe("text/plain; charset=utf-8");
	});

	test("invalid UTF-8 without a NUL is binary, not text", async () => {
		const page = await body("/large/files/big.bin");
		expect(page).toContain("binary file");
		expect(page).not.toContain('class="code"');
		const raw = await get("/large/raw/big.bin");
		expect(raw.headers.get("content-type")).toBe("application/octet-stream");
	});
});

describe("the Atlas", () => {
	// A row's detail panel, fetched on hover or select; a folder's path ends in a slash.
	const panelOf = (path: string, at?: string) =>
		body(`/demo/atlas/panel?${new URLSearchParams(at ? { path, at } : { path })}`);
	const rowOf = (page: string, name: string) =>
		new RegExp(`data-name="${name}"[^>]*>(.*?)</a>`, "s").exec(page)?.[1] ?? "";

	test("sits between the timeline and History", async () => {
		const page = await body("/demo");
		const atlas = page.indexOf('id="atlas"');
		expect(page.indexOf('class="timeline"')).toBeLessThan(atlas);
		expect(atlas).toBeLessThan(page.indexOf('id="history"'));
	});

	test("is a folder tree, folders first, then files, alphabetical", async () => {
		const names = [...(await body("/demo")).matchAll(/class="atlas-name">([^<]*)</g)].map(
			(m) => m[1],
		);
		expect(names).toEqual([
			"docs/",
			"guide.md",
			"logo.png",
			"src/",
			"lib/",
			"deep/",
			"util.ts",
			"main.ts",
			"vendor/",
			"big.c",
			"README.md",
			"secret.txt",
		]);
	});

	test("rows carry the first sentence of the file's own comment, rendered, and link to the file", async () => {
		const page = await body("/demo");
		expect(rowOf(page, "util.ts")).toContain(
			'<span class="atlas-desc">The <em>one</em> helper.</span>',
		);
		expect(rowOf(page, "main.ts")).toContain("Entry point.");
		expect(rowOf(page, "guide.md")).toContain('<span class="atlas-desc">Read me.</span>');
		expect(rowOf(page, "secret.txt")).toContain('<span class="atlas-desc"></span>');
		expect(page).toContain(
			'<a class="atlas-row atlas-file" href="/demo/files/src/main.ts" data-name="main.ts" data-path="src/main.ts">',
		);
		const util = await panelOf("src/lib/deep/util.ts");
		expect(util).toContain("<p>The <em>one</em> helper. Deep down.</p>");
		expect(util).toContain("<dt>exports</dt><dd>one</dd>");
		expect(await panelOf("src/main.ts")).not.toContain("atlas-map");
	});

	test("the panel counts only real saves, crediting a checkpoint's change to the next save", async () => {
		const page = await body("/demo");
		const main = await panelOf("src/main.ts");
		expect(main).toContain("<dt>lines</dt><dd>2</dd>");
		expect(main).toContain("<dt>saves</dt><dd>2</dd>");
		expect(main).toContain(`<dt>first save</dt><dd><a href="/demo/saves/${second()}">`);
		expect(main).toContain(`<dt>last save</dt><dd><a href="/demo/saves/${head()}">`);
		const guide = await panelOf("docs/guide.md");
		expect(guide).toContain("<dt>saves</dt><dd>2</dd>");
		expect(guide).toContain(`<dt>last save</dt><dd><a href="/demo/saves/${head()}">`);
		expect(await panelOf("docs/logo.png")).toContain("<dt>lines</dt><dd>binary</dd>");
		expect(page).not.toContain(fx.saveIds[1] as string);
	});

	test("a folder's panel sums its files and counts the saves that touched anything under it", async () => {
		const docs = await panelOf("docs/");
		expect(docs).toContain('<p class="atlas-info-path mono">docs</p>');
		expect(docs).toContain("<dt>lines</dt><dd>3</dd>");
		expect(docs).toContain("<dt>files</dt><dd>2</dd>");
		expect(docs).toContain("<dt>saves</dt><dd>2</dd>");
		expect(docs).toContain(`<dt>first save</dt><dd><a href="/demo/saves/${first()}">`);
		expect(docs).toContain(`<dt>last save</dt><dd><a href="/demo/saves/${head()}">`);
		const src = await panelOf("src/");
		expect(src).toContain("<dt>saves</dt><dd>3</dd>");
	});

	test("can be viewed at an older save, and an unknown save is a 404", async () => {
		const page = await body(`/demo?at=${second().slice(0, 8)}`);
		expect(page).toContain(`title="explore through time">${second()}</summary>`);
		const picker = await body(`/demo/atlas/saves?at=${second()}`);
		expect(picker).toContain(
			`<a class="atlas-picker-row active" href="/demo?at=${second()}#atlas"`,
		);
		expect(picker).toContain(`<a class="atlas-picker-row" href="/demo?at=${head()}#atlas"`);
		expect(page).toContain('<a class="atlas-head-link mono" href="/demo#atlas">back to HEAD</a>');
		expect(page).toContain(`href="/demo/files/src/main.ts?at=${second()}"`);
		const main = await panelOf("src/main.ts", second().slice(0, 8));
		expect(main).toContain("<dt>saves</dt><dd>1</dd>");
		expect(main).not.toContain(head());
		const oldest = await body(`/demo?at=${first()}`);
		expect(oldest).not.toContain('data-name="main.ts"');
		expect((await get("/demo?at=abcdef")).status).toBe(404);
		expect((await get("/demo?at=../x")).status).toBe(404);
	});

	test("the page carries no panels; each is fetched alone, and anything unknown is a 404", async () => {
		const page = await body("/demo");
		expect(page).not.toContain("<template>");
		expect(page).not.toContain('class="atlas-picker-row" href="/demo?at=');
		expect(page).toContain('data-src="/demo/atlas/saves"');
		expect((await get("/demo/atlas/saves?at=abcdef")).status).toBe(404);
		expect((await get("/nobody/atlas/saves")).status).toBe(404);
		const panel = await get("/demo/atlas/panel?path=src/main.ts");
		expect(panel.status).toBe(200);
		expect(panel.headers.get("content-type")).toContain("text/html");
		for (const query of [
			"path=nope.ts",
			"path=src/main.ts&at=abcdef",
			"path=../secret.txt",
			"path=",
			"",
			"path=nope/",
		]) {
			expect(`${query} ${(await get(`/demo/atlas/panel?${query}`)).status}`).toBe(`${query} 404`);
		}
		expect((await get("/nobody/atlas/panel?path=README.md")).status).toBe(404);
	});
});

describe("the save page", () => {
	test("shows the save's facts and diffs against the previous real save, skipping the checkpoint", async () => {
		const response = await get(`/demo/saves/${head()}`);
		expect(response.status).toBe(200);
		expect(response.headers.get("cache-control")).toBe("public, max-age=60");
		const page = await response.text();
		expect(page).toContain('<h1 class="save-message-head">say hello</h1>');
		expect(page).toContain(
			`<dt>parent</dt><dd><a href="/demo/saves/${second()}">${second()}</a></dd>`,
		);
		expect(page).not.toContain(fx.saveIds[1] as string);
		expect(page).not.toContain("save-flag");
		// The guide's edit was first recorded by the checkpoint; it belongs to this save.
		const rows = [
			...page.matchAll(
				/class="change-row change-(\w+)" href="#diff-\d"><span class="change-path">([^<]+)</g,
			),
		];
		expect(rows.map((m) => [m[1], m[2]])).toEqual([
			["modified", "docs/guide.md"],
			["modified", "src/main.ts"],
		]);
		expect(page).toContain('<span class="diff-add">+1</span> <span class="diff-del">−1</span>');
		expect(page).toContain('<span class="dh">@@ -1,2 +1,2 @@</span>');
		expect(page).toContain(
			'<span class="dl dl-del"><span class="ln">2</span><span class="ln"></span><span class="ds">-</span>',
		);
		expect(page).toContain('class="tk-');
		expect(page).toContain(`href="/demo/archive/${head()}.tar.gz"`);
		expect(page).toContain(`href="/demo?at=${head()}#atlas"`);
	});

	test("the first save diffs against nothing, notes binaries, and shows its flag and agent", async () => {
		const page = await body(`/demo/saves/${first()}`);
		expect(page).toContain('<span class="save-flag-label mono">flagged</span> holds a secret');
		expect(page).toContain("<dt>parent</dt><dd>none, the first save</dd>");
		expect(page).toContain(
			'change-added" href="#diff-2"><span class="change-path">docs/logo.png</span><span class="change-stat mono"><span class="diff-note">binary</span>',
		);
		expect(page).toContain("binary file, not shown");
		expect(page).toContain('<span class="dh">@@ -0,0 +1 @@</span>');
		const second_ = await body(`/demo/saves/${second()}`);
		expect(second_).toContain("<dt>agent</dt><dd>test-agent</dd><dt>session</dt><dd>fixture</dd>");
		expect(second_).not.toContain("save-flag");
	});

	test("a change to the final newline alone is a changed last line, marked as in GNU diff", async () => {
		const marker = '<span class="dh">\\ No newline at end of file</span>';
		const row = (kind: string, a: string, b: string, sign: string) =>
			`<span class="dl dl-${kind}"><span class="ln">${a}</span><span class="ln">${b}</span><span class="ds">${sign}</span><span class="lc">b</span></span>`;
		const gained = await body(`/tail/saves/${tailSaves[1]}`);
		expect(gained).toContain('<span class="diff-add">+1</span> <span class="diff-del">−1</span>');
		expect(gained).toContain(`${row("del", "2", "", "-")}${marker}${row("add", "", "2", "+")}<`);
		const lost = await body(`/tail/saves/${tailSaves[0]}`);
		expect(lost).toContain(`${row("del", "2", "", "-")}${row("add", "", "2", "+")}${marker}`);
	});

	test("a prefix redirects, and a checkpoint, an unknown or a private save is a 404", async () => {
		const short = await get(`/demo/saves/${head().slice(0, 6)}`);
		expect(short.status).toBe(302);
		expect(short.headers.get("location")).toBe(`/demo/saves/${head()}`);
		expect((await get(`/demo/saves/${fx.saveIds[1]}`)).status).toBe(404);
		expect((await get("/demo/saves/abcdef")).status).toBe(404);
		expect((await get("/demo/saves/abc")).status).toBe(404);
		expect((await get(`/hidden/saves/${head()}`)).status).toBe(404);
	});
});

describe("raw files", () => {
	test("are the exact object bytes, text as text/plain", async () => {
		const mirror = openMirror(mirrorDir, "demo");
		for (const [path, type] of [
			["src/main.ts", "text/plain; charset=utf-8"],
			["docs/logo.png", "image/png"],
			["README.md", "text/plain; charset=utf-8"],
		] as const) {
			const response = await get(`/demo/raw/${path}`);
			const file = fileAt(mirror, head(), path);
			expect(response.headers.get("content-type")).toBe(type);
			expect(new Uint8Array(await response.arrayBuffer())).toEqual(
				objectBytes(mirror, file?.hash as string) as Uint8Array<ArrayBuffer>,
			);
		}
		expect(await (await get(`/demo/raw/src/main.ts?at=${second()}`)).text()).toContain("'hi'");
	});
});

test("static assets and raw files carry route-based sandboxing", async () => {
	const css = await get("/static/css/kepr.css");
	expect(css.status).toBe(200);
	expect(css.headers.get("content-type")).toContain("text/css");
	const raw = await get("/demo/raw/README.md");
	expect(raw.headers.get("content-security-policy")).toContain("sandbox");
	const asset = await get("/static/assets/plain.txt");
	expect(asset.headers.get("content-security-policy")).toContain("sandbox");
	const favicon = await get("/favicon.svg");
	expect(favicon.headers.get("content-type")).toBe("image/svg+xml");
	expect(favicon.headers.get("content-security-policy")).not.toContain("sandbox");
	expect((await get("/static/../package.json")).status).toBe(404);
	const csp = (await get("/demo")).headers.get("content-security-policy") ?? "";
	expect(csp).toContain("style-src 'self';");
	expect(csp).toContain("font-src 'self';");
	expect(csp).not.toContain("unsafe-inline");
});

describe("housekeeping routes", () => {
	test("robots.txt points at the sitemap, which lists public repos only", async () => {
		expect(await body("/robots.txt")).toBe(
			"User-agent: *\nAllow: /\n\nSitemap: https://kepr.example/sitemap.xml\n",
		);
		const sitemap = await get("/sitemap.xml");
		expect(sitemap.headers.get("Content-Type")).toBe("application/xml; charset=UTF-8");
		const xml = await sitemap.text();
		expect(xml).toStartWith('<?xml version="1.0" encoding="UTF-8"?>\n<urlset');
		for (const repo of ["demo", "large", "tail"]) {
			expect(xml).toContain(`<loc>https://kepr.example/${repo}</loc>`);
		}
		expect(xml).not.toContain("hidden");
	});

	test("favicon.svg is Kepr 2's mark, and every page links it", async () => {
		const res = await get("/favicon.svg");
		expect(res.headers.get("Content-Type")).toBe("image/svg+xml");
		expect(await res.text()).toContain('<polygon points="16,3 27,23 5,23"');
		expect(await body("/demo")).toContain(
			'<link rel="icon" href="/favicon.svg" type="image/svg+xml">',
		);
	});
});

test("pages are prefetched on hover, never a link whose GET does something", async () => {
	const page = await get("/demo");
	expect(page.headers.get("speculation-rules")).toBe('"/speculation.json"');
	const rules = await get("/speculation.json");
	expect(rules.headers.get("content-type")).toBe("application/speculationrules+json");
	const text = await rules.text();
	for (const pattern of [
		"/*/archive/*",
		"/*/raw/*",
		"/*/releases/*",
		"/*/koh/*",
		"/api/*",
		"/admin/backup*",
		"/admin/notifications/*",
		"/*/issues/*",
		"/sign-in*",
		"/connect*",
	]) {
		expect(text).toContain(JSON.stringify(pattern));
	}
});