Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/autopsy/__tests__/browser.test.ts

Raw
import { cp, mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { initTheme } from "@earendil-works/pi-coding-agent";
import { expect as browserExpect, chromium } from "@playwright/test";
import { expect, it } from "vitest";
import {
	createPiSession,
	type PiSession,
} from "../../../test/fixture/create-pi-session.ts";

it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
	"renders a relocated package's real Pi capture, filters, usage, refresh and failure states",
	async () => {
		const root = await mkdtemp(join(tmpdir(), "pi-autopsy-browser-"));
		const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
		const browser = await chromium.launch();
		let pi: PiSession | undefined;
		try {
			const packageDir = join(root, "package");
			await cp(
				fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
				packageDir,
				{ recursive: true },
			);
			const page = await browser.newPage({
				viewport: { width: 1100, height: 900 },
				colorScheme: "dark",
			});
			const imageData = await page.evaluate(() => {
				const canvas = document.createElement("canvas");
				canvas.width = 1000;
				canvas.height = 600;
				const ctx = canvas.getContext("2d")!;
				ctx.fillStyle = "#1556a0";
				ctx.fillRect(0, 0, 1000, 600);
				ctx.fillStyle = "#f8c080";
				ctx.fillRect(50, 50, 900, 500);
				ctx.fillStyle = "#20252c";
				ctx.font = "48px sans-serif";
				ctx.fillText("Local session image", 100, 310);
				return canvas.toDataURL("image/png").split(",")[1]!;
			});
			const extraImages = await page.evaluate(() => {
				const canvas = document.createElement("canvas");
				canvas.width = 40;
				canvas.height = 30;
				canvas.getContext("2d")!.fillRect(0, 0, 40, 30);
				return {
					jpeg: canvas.toDataURL("image/jpeg").split(",")[1]!,
					webp: canvas.toDataURL("image/webp").split(",")[1]!,
				};
			});
			const expected =
				"  Captured identity\n\n<rules>\nStay literal: <script>window.injection = true</script>\n</rules>\n  ";
			pi = await createPiSession({
				extensionPaths: [join(packageDir, "index.ts")],
				extensionFactories: [
					(api) => {
						api.on("before_agent_start", () => ({ systemPrompt: expected }));
					},
				],
				env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
			});
			const manager = pi.session.sessionManager;
			const first = manager.appendMessage({
				role: "user",
				content: "old branch needle",
				timestamp: 1,
			});
			manager.appendCustomEntry("other-branch", { value: "off-branch-only" });
			manager.branch(first);
			manager.appendUsage("test", "faux", "faux-model", {
				input: 17,
				output: 5,
				cacheRead: 3,
				cacheWrite: 0,
				totalTokens: 25,
				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.25 },
			});
			await pi.session.prompt(
				"browser journey <img src=x onerror='window.injection=true'>",
			);
			const oversizedImage = Buffer.from(imageData, "base64");
			oversizedImage.writeUInt32BE(10_000, 16);
			oversizedImage.writeUInt32BE(10_000, 20);
			manager.appendMessage({
				role: "user",
				timestamp: Date.now(),
				content: [
					{ type: "text", text: "image journey" },
					{ type: "image", mimeType: "image/png", data: imageData },
					{
						type: "image",
						mimeType: "image/png",
						data: oversizedImage.toString("base64"),
					},
					{ type: "image", mimeType: "image/jpeg", data: extraImages.jpeg },
					{ type: "image", mimeType: "image/webp", data: extraImages.webp },
					{
						type: "image",
						mimeType: "image/gif",
						data: "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
					},
				],
			});
			const assistantEntry = manager
				.getEntries()
				.findLast(
					(entry) =>
						entry.type === "message" && entry.message.role === "assistant",
				);
			if (
				assistantEntry?.type !== "message" ||
				assistantEntry.message.role !== "assistant"
			)
				throw new Error("missing scripted assistant");
			const signature =
				"opaque signature <script>window.injection = true</script>";
			manager.appendMessage({
				...assistantEntry.message,
				timestamp: Date.now(),
				content: [
					{ type: "text", text: "signature journey", textSignature: signature },
				],
			});
			const quotedKey = 'escaped"key\\';
			const jsonEntryId = manager.appendCustomEntry("json-highlighting", {
				[quotedKey]:
					'quote: " slash: \\ <img src=x onerror="window.injection=true">',
				flags: [true, false, null],
				number: -1.25e-8,
			});
			initTheme(undefined, false);
			const ctx = pi.session.extensionRunner.createCommandContext();
			let url = "";
			ctx.ui.notify = (message) => {
				url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
			};
			await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
			expect(url).toMatch(/^http:/u);
			const errors: string[] = [];
			const imageRequests: string[] = [];
			page.on("request", (request) => {
				if (request.url().includes("/image/"))
					imageRequests.push(request.url());
			});
			page.on("pageerror", (error) => errors.push(error.message));
			await page.goto(url);
			await browserExpect(page).toHaveTitle("Session · Autopsy");
			const initialStatus = {
				text: await page.locator("#status").textContent(),
				hidden: await page.locator("#status").isHidden(),
			};
			await page.getByRole("button", { name: "Insights", exact: true }).click();
			await browserExpect(page.locator("#usage-chart")).toContainText("25");
			await browserExpect(
				page.locator("#usage-chart .bar").first(),
			).toHaveJSProperty(
				"offsetWidth",
				await page
					.locator("#usage-chart .bar")
					.first()
					.evaluate((node) => node.parentElement!.clientWidth),
			);
			await page
				.getByRole("dialog", { name: "Insights", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			await page.locator("#search").fill("off-branch-only");
			await browserExpect(page.locator("#entry-count")).toHaveText("0 entries");
			await browserExpect(page.locator("#status")).toBeHidden();
			await page.getByRole("button", { name: "Filters", exact: true }).click();
			await page.locator("#branch").selectOption("all");
			await page
				.getByRole("dialog", { name: "Filters", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			await browserExpect(page.locator("#entry-count")).toHaveText("1 entry");
			await page.locator("#search").fill("browser journey");
			await page.getByRole("button", { name: "Filters", exact: true }).click();
			await page.locator("#role").selectOption("user");
			await page
				.getByRole("dialog", { name: "Filters", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			await browserExpect(page.locator("#entry-count")).toHaveText("1 entry");
			await page.locator(".entry > summary").click();
			await browserExpect(
				page.locator(".entry-body pre").first(),
			).toContainText("<img");
			expect(
				await page.locator(".entry-body img, .entry-body script").count(),
			).toBe(0);
			expect(await page.evaluate(() => "injection" in window)).toBe(false);
			expect(imageRequests).toEqual([]);
			await page.locator("#search").fill("signature journey");
			await page.getByRole("button", { name: "Filters", exact: true }).click();
			await page.locator("#role").selectOption("assistant");
			await page
				.getByRole("dialog", { name: "Filters", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			await page.locator(".entry > summary").click();
			await browserExpect(page.locator(".entry-json")).not.toHaveAttribute(
				"open",
			);
			expect(await page.locator(".entry-body").textContent()).not.toContain(
				signature,
			);
			await page.locator(".entry-json > summary").click();
			await browserExpect(page.locator(".entry-json pre")).toContainText(
				signature,
			);
			expect(await page.evaluate(() => "injection" in window)).toBe(false);
			await page.locator(".entry-json > summary").click();
			await browserExpect(page.locator(".entry-json pre")).toBeHidden();
			await page.getByRole("button", { name: "Filters", exact: true }).click();
			await page.locator("#role").selectOption("");
			await page
				.getByRole("dialog", { name: "Filters", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			await page.locator("#search").fill("json-highlighting");
			await browserExpect(
				page.locator(`.entry[data-entry-id="${jsonEntryId}"]`),
			).toBeVisible();
			await page
				.locator(`.entry[data-entry-id="${jsonEntryId}"] > summary`)
				.click();
			await page.locator(".entry-json > summary").click();
			const json = page.locator(".entry-json .json-code");
			await browserExpect(
				page.locator(".entry-json > .entry-load-status"),
			).toHaveText("");
			const inspectorData = await (
				await fetch(`${url}data?branch=all&q=json-highlighting`)
			).json();
			expect(
				inspectorData.entries.map((entry: { id: string }) => entry.id),
			).toContain(jsonEntryId);
			expect(await json.textContent()).toBe(
				JSON.stringify(manager.getEntry(jsonEntryId), null, 2),
			);
			expect(await json.locator(".json-key").allTextContents()).toContain(
				JSON.stringify(quotedKey),
			);
			await browserExpect(json.locator(".json-number")).toHaveText("-1.25e-8");
			await browserExpect(json.locator(".json-literal")).toHaveText([
				"true",
				"false",
				"null",
			]);
			expect(await json.locator(".json-string").count()).toBeGreaterThan(0);
			expect(await json.locator("img, script").count()).toBe(0);
			expect(await page.evaluate(() => "injection" in window)).toBe(false);
			await page
				.locator(".entry")
				.screenshot({ path: join(root, "json-dark.png") });
			await page.emulateMedia({ colorScheme: "light" });
			await page.setViewportSize({ width: 390, height: 844 });
			expect(
				await page.evaluate(
					() => document.documentElement.scrollWidth <= window.innerWidth,
				),
			).toBe(true);
			await page
				.locator(".entry")
				.screenshot({ path: join(root, "json-light-mobile.png") });
			await page.emulateMedia({ colorScheme: "dark" });
			await page.setViewportSize({ width: 1100, height: 900 });
			await page.getByRole("button", { name: "Filters", exact: true }).click();
			await page.locator("#role").selectOption("user");
			await page
				.getByRole("dialog", { name: "Filters", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			await page.locator("#search").fill("image journey");
			await page.locator(".entry > summary").click();
			expect(imageRequests).toEqual([]);
			const imageViewer = page.locator(".image-viewer").first();
			await browserExpect(imageViewer.locator("summary")).toHaveText(
				/^Image 1 · image\/png · [\d,.]+ B · 1000 × 600 px$/u,
			);
			await browserExpect(
				page.locator(".image-viewer").nth(1).locator("summary"),
			).toHaveText(/^Image 2 · image\/png · [\d,.]+ B · 10000 × 10000 px$/u);
			await imageViewer.locator("summary").click();
			await browserExpect(imageViewer.locator("img")).toHaveJSProperty(
				"naturalWidth",
				1000,
			);
			await browserExpect(imageViewer.locator("img")).toHaveJSProperty(
				"naturalHeight",
				600,
			);
			expect(imageRequests).toHaveLength(1);
			expect(imageRequests[0]).toMatch(/\/1$/u);
			expect(
				(await imageViewer.locator("img").boundingBox())!.width,
			).toBeLessThan(1000);
			await imageViewer
				.getByRole("button", { name: "Show original size" })
				.click();
			await browserExpect(imageViewer.locator(".image-viewport")).toHaveClass(
				/image-original/u,
			);
			expect((await imageViewer.locator("img").boundingBox())!.width).toBe(
				1000,
			);
			await imageViewer
				.getByRole("button", { name: "Show preview size" })
				.click();
			for (const [index, width] of [
				[2, 40],
				[3, 40],
				[4, 1],
			] as const) {
				const preview = page.locator(".image-viewer").nth(index);
				await preview.locator("summary").click();
				await browserExpect(preview.locator("img")).toHaveJSProperty(
					"naturalWidth",
					width,
				);
				await preview.locator("summary").click();
				await browserExpect(preview.locator("img")).toHaveCount(0);
			}
			await page.screenshot({
				path: join(root, "image-dark.png"),
				fullPage: true,
			});
			await page.emulateMedia({ colorScheme: "light" });
			await page.setViewportSize({ width: 390, height: 844 });
			expect(
				await page.evaluate(
					() => document.documentElement.scrollWidth <= window.innerWidth,
				),
			).toBe(true);
			await page.screenshot({
				path: join(root, "image-light-mobile.png"),
				fullPage: true,
			});
			await page.emulateMedia({ colorScheme: "dark" });
			await page.setViewportSize({ width: 1100, height: 900 });
			await imageViewer.locator("summary").click();
			await browserExpect(imageViewer.locator("img")).toHaveCount(0);
			const rejectedImage = page.locator(".image-viewer").nth(1);
			await rejectedImage.locator("summary").click();
			await browserExpect(rejectedImage.locator(".image-status")).toContainText(
				"Image unavailable",
			);
			expect(imageRequests.at(-1)).toMatch(/\/2$/u);
			await page.locator(".entry > summary").click();
			await browserExpect(rejectedImage.locator("img")).toHaveCount(0);
			await page.getByRole("button", { name: "Session", exact: true }).click();
			await browserExpect(page.locator("#metadata")).toContainText(
				"Snapshot generated",
			);
			await page.locator("#captures > summary").click();
			await browserExpect(page.locator("#prompt-raw")).toHaveText(expected);
			expect(await page.locator("#prompt-raw").textContent()).toBe(expected);
			await browserExpect(page.locator("#prompt-grouped")).toContainText(
				"[RULES]",
			);
			await page.screenshot({
				path: join(root, "prompt-dark.png"),
				fullPage: true,
			});
			await page
				.getByRole("dialog", { name: "Session", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			await page.locator("#search").fill("");
			await page.getByRole("button", { name: "Filters", exact: true }).click();
			await page.locator("#role").selectOption("");
			await page
				.getByRole("dialog", { name: "Filters", exact: true })
				.getByRole("button", { name: "Close", exact: true })
				.click();
			manager.appendCustomEntry("refresh-test", { text: "fresh entry" });
			await page.locator("#refresh").click();
			await page.locator("#search").fill("fresh entry");
			await browserExpect(page.locator("#entry-count")).toHaveText("1 entry");
			const resetScope = page.waitForResponse((response) => {
				const request = new URL(response.url());
				return (
					request.pathname.endsWith("/data") && !request.searchParams.has("q")
				);
			});
			await page.locator("#search").fill("");
			await resetScope;
			await browserExpect(page.locator("#entry-count")).not.toHaveText(
				"1 entry",
			);
			await page.emulateMedia({ colorScheme: "light" });
			await page.setViewportSize({ width: 390, height: 844 });
			expect(
				await page.evaluate(
					() => document.documentElement.scrollWidth <= window.innerWidth,
				),
			).toBe(true);
			await page.screenshot({
				path: join(root, "session-light-mobile.png"),
				fullPage: true,
			});
			const visibleEntries = await page.locator("#entries").textContent();
			expect(await page.locator(".entry").count()).toBeGreaterThan(0);
			await pi.dispose();
			pi = undefined;
			await page.locator("#refresh").click();
			await browserExpect(page.locator("#status")).toContainText(
				"History load failed:",
			);
			await browserExpect(page.locator("#entries")).toHaveText(visibleEntries!);
			expect(initialStatus).toEqual({ text: "", hidden: true });
			expect(errors).toEqual([]);
		} finally {
			await browser.close();
			await pi?.dispose();
			if (keepScreenshots) {
				await rm(join(root, "package"), { recursive: true, force: true });
				console.log(`Browser screenshots: ${root}`);
			} else await rm(root, { recursive: true, force: true });
		}
	},
	30_000,
);

it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
	"shows source-aware dashboard metrics, shared filters, time graphs and transcript drill-down",
	async () => {
		const root = await mkdtemp(join(tmpdir(), "pi-autopsy-dashboard-"));
		const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
		const browser = await chromium.launch();
		let pi: PiSession | undefined;
		try {
			const packageDir = join(root, "package");
			await cp(
				fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
				packageDir,
				{ recursive: true },
			);
			const provider = "autopsy-metrics-test";
			const model = "priced";
			pi = await createPiSession({
				extensionPaths: [join(packageDir, "index.ts")],
				extensionFactories: [
					(api) => {
						api.registerProvider(provider, {
							api: "openai",
							apiKey: "test-key",
							baseUrl: "https://unused.invalid",
							models: [
								{
									id: model,
									name: "Priced test model",
									reasoning: false,
									input: ["text"],
									contextWindow: 10000,
									maxTokens: 512,
									cost: { input: 2, output: 4, cacheRead: 1, cacheWrite: 3 },
								},
							],
						});
					},
				],
				env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
			});
			await pi.session.prompt("real Pi dashboard setup");
			const manager = pi.session.sessionManager;
			const completeUsage = {
				input: 1_000_000,
				output: 500_000,
				cacheRead: 100_000,
				cacheWrite: 0,
				totalTokens: 1_600_000,
				cost: {
					input: 3,
					output: 3,
					cacheRead: 1,
					cacheWrite: 0,
					total: 7,
					totalFromProvider: true,
				},
			};
			const missingUsage = {
				input: Number.NaN,
				output: 0,
				cacheRead: 0,
				cacheWrite: 0,
				totalTokens: 0,
				cost: {
					input: 0,
					output: 0,
					cacheRead: 0,
					cacheWrite: 0,
					total: Number.NaN,
				},
			};
			const start = Date.parse("2026-01-01T00:00:10.000Z");
			const firstId = manager.appendMessage({
				role: "assistant",
				api: "openai",
				provider,
				model,
				timestamp: start,
				durationMs: 2500,
				content: [{ type: "text", text: "dashboard priced response" }],
				usage: completeUsage,
				stopReason: "stop",
			});
			const secondId = manager.appendMessage({
				role: "assistant",
				api: "openai",
				provider,
				model,
				timestamp: start + 10000,
				durationMs: 0,
				content: [{ type: "text", text: "dashboard missing usage" }],
				usage: missingUsage,
				stopReason: "stop",
			});
			const first = manager.getEntry(firstId)!;
			const second = manager.getEntry(secondId)!;
			// Deterministic recorded-entry timestamps, distinct from request starts.
			first.timestamp = "2026-01-01T00:00:12.500Z";
			second.timestamp = "2026-01-01T00:00:20.000Z";
			const toolId = manager.appendMessage({
				role: "toolResult",
				toolCallId: "dashboard-tool",
				toolName: "measure",
				timestamp: start + 3000,
				durationMs: 1500,
				content: [],
				isError: false,
			});
			manager.getEntry(toolId)!.timestamp = "2026-01-01T00:00:13.000Z";
			initTheme(undefined, false);
			const ctx = pi.session.extensionRunner.createCommandContext();
			let url = "";
			ctx.ui.notify = (message) => {
				url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
			};
			await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
			expect(url).toMatch(/^http:/u);
			const page = await browser.newPage({
				viewport: { width: 1100, height: 900 },
				colorScheme: "dark",
				locale: "en-US",
				timezoneId: "UTC",
			});
			const errors: string[] = [];
			page.on("pageerror", (error) => errors.push(error.message));
			await page.goto(url);
			await browserExpect(
				page.locator("#entries > .entry").first(),
			).toBeVisible();
			await page.locator("#filters-button").click();
			await browserExpect(page.locator("#filters-panel")).toBeVisible();
			await page.locator("#provider").selectOption({ label: provider });
			await page.locator("#model").selectOption({ label: model });
			await page.locator("#filters-panel [data-close]").click();
			await browserExpect(page.locator("#entry-count")).toContainText(
				"2 entries",
			);
			await page.locator("#insights-button").click();
			await browserExpect(page.locator("#insights-panel")).toBeVisible();
			const card = (metric: string) =>
				page.locator(`[data-metric="${metric}"]`);
			await browserExpect(
				card("stored-cost").locator(".card-value"),
			).toHaveText("$7");
			await browserExpect(
				card("catalog-cost").locator(".card-value"),
			).toHaveText("$4.1");
			await browserExpect(
				card("stored-cost").locator(".card-coverage"),
			).toHaveText("1/2 entries known");
			await browserExpect(
				card("catalog-cost").locator(".card-coverage"),
			).toHaveText("1/2 entries known");
			await browserExpect(card("tokens").locator(".card-value")).toHaveText(
				"1,600,000",
			);
			await browserExpect(card("duration").locator(".card-value")).toHaveText(
				"2.5 s",
			);
			await browserExpect(card("size").locator(".card-value")).toHaveText(
				"48 B",
			);
			await browserExpect(page.locator("#dashboard-timing")).toContainText(
				"7.5 s",
			);
			await browserExpect(
				page.locator("#dashboard-timelines .timeline-point"),
			).toHaveCount(2);
			await browserExpect(
				page.locator(`#dashboard-timelines [data-entry-id="${secondId}"]`),
			).toHaveCount(0);
			await page.locator("#timeline-view").selectOption("tokens");
			await browserExpect(
				page.locator(
					`.timeline-point[data-entry-id="${secondId}"][aria-label^="Input:"]`,
				),
			).toHaveCount(0);
			await browserExpect(
				page.locator(
					`.timeline-point[data-entry-id="${secondId}"][aria-label^="Output:"]`,
				),
			).toHaveAttribute("aria-label", /Output: 0/u);
			await page.locator("#timeline-view").selectOption("duration");
			await browserExpect(
				page.locator(`.timeline-point[data-entry-id="${secondId}"]`),
			).toHaveAttribute("aria-label", /Model response: 0 s/u);
			await page.locator("#timeline-view").selectOption("size");
			await browserExpect(
				page.locator("#dashboard-timelines svg"),
			).toHaveAttribute("aria-label", /content size/u);
			await page.locator("#timeline-view").selectOption("cumulative");
			await browserExpect(
				page.locator("#dashboard-timelines h4"),
			).toContainText("Cumulative known cost");
			await page.locator("#insights-panel [data-close]").click();
			await page.locator("#filters-button").click();
			await page.locator("#from").fill("2026-01-01T00:00:12.5");
			await page.locator("#from").dispatchEvent("change");
			await page.locator("#to").fill("2026-01-01T00:00:12.5");
			await page.locator("#to").dispatchEvent("change");
			await browserExpect(page.locator("#entry-count")).toContainText(
				"1 entry",
			);
			await page.locator("#filters-panel [data-close]").click();
			await page.locator("#insights-button").click();
			await browserExpect(
				card("stored-cost").locator(".card-coverage"),
			).toHaveText("1/1 entries known");
			await page.locator("#insights-panel [data-close]").click();
			await page.locator("#filters-button").click();
			await page.locator("#from").fill("2026-01-01T00:00:20");
			await page.locator("#from").dispatchEvent("change");
			await browserExpect(page.locator("#to")).toHaveJSProperty(
				"validationMessage",
				"To must be on or after From.",
			);
			await browserExpect(page.locator("#entry-count")).toContainText(
				"1 entry",
			);
			await page.locator("#filters-panel [data-close]").click();
			await page.locator("#insights-button").click();
			await browserExpect(
				card("stored-cost").locator(".card-value"),
			).toHaveText("$7");
			await page.locator("#insights-panel [data-close]").click();
			await page.locator("#filters-button").click();
			await page.locator("#reset-filters").click();
			await page.locator("#role").selectOption("toolResult");
			await page.locator("#filters-panel [data-close]").click();
			await page.locator("#insights-button").click();
			await page.locator("#timeline-view").selectOption("duration");
			await browserExpect(
				page.locator(`.timeline-point[data-entry-id="${toolId}"]`),
			).toHaveAttribute("aria-label", /Tool execution: 1.5 s/u);
			await page.locator("#insights-panel [data-close]").click();
			await page.locator("#filters-button").click();
			await page.locator("#reset-filters").click();
			await page.locator("#filters-panel [data-close]").click();
			const zeroUsage = {
				input: 0,
				output: 0,
				cacheRead: 0,
				cacheWrite: 0,
				totalTokens: 0,
				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
			};
			for (let i = 0; i < 54; i++) {
				const entry = manager.appendUsage(
					"dashboard-pagination",
					provider,
					model,
					zeroUsage,
				);
				entry.timestamp = new Date(
					Date.parse("2025-12-31T23:59:00.000Z") + i * 1000,
				).toISOString();
			}
			await page.locator("#refresh").click();
			await page.locator("#filters-button").click();
			await page.locator("#provider").selectOption({ label: provider });
			await page.locator("#model").selectOption({ label: model });
			await page.locator("#order").selectOption("newest");
			await page.locator("#filters-panel [data-close]").click();
			await page.locator("#insights-button").click();
			await page.locator("#timeline-view").selectOption("cost");
			await browserExpect(page.locator("#entry-count")).toContainText(
				"56 entries",
			);
			const point = page
				.locator(`.timeline-point[data-entry-id="${firstId}"]`)
				.first();
			await browserExpect(
				page.locator(`.entry[data-entry-id="${firstId}"]`),
			).toHaveCount(0);
			const around = page.waitForRequest(
				(request) =>
					new URL(request.url()).searchParams.get("around") === firstId,
			);
			await point.focus();
			await point.press("Enter");
			await around;
			await browserExpect(page.locator("#insights-panel")).not.toBeVisible();
			await browserExpect(
				page.locator(`.entry[data-entry-id="${firstId}"]`),
			).toHaveAttribute("open");
			await browserExpect(
				page.locator(`.entry[data-entry-id="${firstId}"] > summary`),
			).toBeFocused();
			await page.locator("#insights-button").click();
			await page
				.locator("#insights-panel")
				.screenshot({ path: join(root, "dashboard-dark.png") });
			await page.locator("#dashboard-totals > details > summary").click();
			await page
				.locator("#dashboard-totals > details")
				.screenshot({ path: join(root, "dashboard-details-dark.png") });
			await page.locator("#dashboard-totals > details > summary").click();
			await page.emulateMedia({ colorScheme: "light" });
			await page.setViewportSize({ width: 390, height: 844 });
			expect(
				await page.evaluate(
					() => document.documentElement.scrollWidth <= window.innerWidth,
				),
			).toBe(true);
			await page
				.locator("#insights-panel")
				.screenshot({ path: join(root, "dashboard-light-mobile.png") });
			await page.locator("#dashboard-totals > details > summary").click();
			expect(
				await page.evaluate(
					() => document.documentElement.scrollWidth <= window.innerWidth,
				),
			).toBe(true);
			await page
				.locator("#dashboard-totals > details")
				.screenshot({ path: join(root, "dashboard-details-light-mobile.png") });
			expect(errors).toEqual([]);
		} finally {
			await browser.close();
			await pi?.dispose();
			if (keepScreenshots) {
				await rm(join(root, "package"), { recursive: true, force: true });
				console.log(`Dashboard screenshots: ${root}`);
			} else await rm(root, { recursive: true, force: true });
		}
	},
	30_000,
);

it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
	"streams complete content on click, preserves unchanged rows and recovers from interrupted details",
	async () => {
		const root = await mkdtemp(join(tmpdir(), "pi-autopsy-previews-"));
		const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
		const browser = await chromium.launch();
		let pi: PiSession | undefined;
		try {
			const packageDir = join(root, "package");
			await cp(
				fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
				packageDir,
				{ recursive: true },
			);
			pi = await createPiSession({
				extensionPaths: [join(packageDir, "index.ts")],
				env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
			});
			await pi.session.prompt("preview setup");
			const manager = pi.session.sessionManager;
			const marker = "preview-stream-fixture";
			const sentinel = "COMPLETE-TEXT-SENTINEL";
			const body = `${marker}\n${"long line 🦊 [truncated] <img src=x>\n".repeat(12_000)}${sentinel}`;
			const signature = `${"opaque-signature".repeat(20_000)}SIGNATURE-END`;
			const usage = {
				input: 0,
				output: 0,
				cacheRead: 0,
				cacheWrite: 0,
				totalTokens: 0,
				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
			};
			const id = manager.appendMessage({
				role: "assistant",
				api: "openai",
				provider: "faux",
				model: "faux-model",
				timestamp: Date.now(),
				content: [{ type: "text", text: body, textSignature: signature }],
				usage,
				stopReason: "stop",
			});
			manager.appendMessage({
				role: "user",
				timestamp: Date.now(),
				content: "literal-marker-fixture [truncated] is original text",
			});
			const cancelMarker = "preview-cancel-fixture";
			const cancelSentinel = "CANCEL-REOPEN-SENTINEL";
			const cancelBody = `${cancelMarker}\n${"cancel segment\n".repeat(100_000)}${cancelSentinel}`;
			const disposedId = manager.appendMessage({
				role: "user",
				timestamp: Date.now(),
				content: "preview-disposed-fixture",
			});
			const cancelId = manager.appendMessage({
				role: "user",
				timestamp: Date.now(),
				content: cancelBody,
			});
			initTheme(undefined, false);
			const ctx = pi.session.extensionRunner.createCommandContext();
			let url = "";
			ctx.ui.notify = (message) => {
				url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
			};
			await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
			expect(url).toMatch(/^http:/u);
			const page = await browser.newPage({
				viewport: { width: 1100, height: 900 },
				colorScheme: "dark",
			});
			const requests: string[] = [];
			const errors: string[] = [];
			page.on("request", (request) => {
				if (request.url().includes("/entry/")) requests.push(request.url());
			});
			page.on("pageerror", (error) => errors.push(error.message));
			await page.goto(url);
			await browserExpect(
				page.locator("#entries > .entry").first(),
			).toBeVisible();
			await browserExpect(page.locator("#history")).toHaveAttribute(
				"aria-busy",
				"false",
			);
			const initialStatus = {
				text: await page.locator("#status").textContent(),
				hidden: await page.locator("#status").isHidden(),
			};
			expect(requests).toEqual([]);
			await page.locator("#filters-button").click();
			await browserExpect(page.locator("#filters-panel")).toBeVisible();
			await browserExpect(page.locator("#branch")).toHaveValue("current");
			await page.locator("#filters-panel [data-close]").click();
			await page.locator("#session-button").click();
			await browserExpect(page.locator("#session-panel")).toBeVisible();
			await browserExpect(page.locator("#warnings")).not.toContainText(
				"truncated for viewer",
			);
			await browserExpect(page.locator("#warnings")).not.toContainText(
				"Session history",
			);
			await browserExpect(page.locator(".session-note")).toContainText(
				"Session history",
			);
			await page.locator("#session-panel [data-close]").click();
			await page.locator("#search").fill("literal-marker-fixture");
			await browserExpect(page.locator(".preview-limited")).toHaveCount(0);
			const markerScope = page.waitForResponse((response) => {
				const request = new URL(response.url());
				return (
					request.pathname.endsWith("/data") &&
					request.searchParams.get("q") === marker
				);
			});
			await page.locator("#search").fill(marker);
			await markerScope;
			const row = page.locator(`.entry[data-entry-id="${id}"]`);
			await browserExpect(row.locator(".preview-limited")).toHaveCount(0);
			expect(
				(await row.locator(".entry-preview").textContent())!.length,
			).toBeLessThanOrEqual(600);
			expect(await row.locator(".entry-preview").textContent()).not.toContain(
				sentinel,
			);
			await row.screenshot({ path: join(root, "preview-dark.png") });
			await row.locator(":scope > summary").click();
			await browserExpect(row.locator(".entry-full-text pre")).toContainText(
				sentinel,
				{ timeout: 15000 },
			);
			await browserExpect(
				row.locator(".entry-body > .entry-load-status"),
			).toHaveText("");
			const text = row.locator(".entry-full-text pre");
			expect(
				await text.evaluate(
					(node, expected) => node.textContent === expected,
					body,
				),
			).toBe(true);
			expect(await text.locator("img, script").count()).toBe(0);
			expect(
				requests.filter((request) => request.endsWith(`/entry/${id}/text`)),
			).toHaveLength(1);
			expect(
				requests.filter((request) => request.endsWith(`/entry/${id}/json`)),
			).toHaveLength(0);
			const originalRow = await row.elementHandle();
			const selected = await text.evaluate((node) => {
				const range = document.createRange();
				range.setStart(node.firstChild!, 0);
				range.setEnd(node.firstChild!, 7);
				window.getSelection()!.removeAllRanges();
				window.getSelection()!.addRange(range);
				return window.getSelection()!.toString();
			});
			const history = page.locator("#history");
			await history.evaluate((node) => {
				node.scrollTop = 100;
			});
			expect(await history.evaluate((node) => node.scrollTop)).toBe(100);
			const anchorTop = await text.evaluate(
				(node) => node.getBoundingClientRect().top,
			);
			const refreshed = page.waitForResponse(
				(response) =>
					new URL(response.url()).pathname === new URL("data", url).pathname,
			);
			await page
				.locator("#refresh")
				.evaluate((node: HTMLButtonElement) => node.click());
			const dataUrl = (await refreshed).url();
			await browserExpect(page.locator("#refresh")).toBeEnabled();
			expect(await originalRow!.evaluate((node) => node.isConnected)).toBe(
				true,
			);
			await browserExpect(row).toHaveAttribute("open");
			expect(await page.evaluate(() => window.getSelection()!.toString())).toBe(
				selected,
			);
			expect(
				await text.evaluate((node) => node.getBoundingClientRect().top),
			).toBeCloseTo(anchorTop, 0);
			expect(
				requests.filter((request) => request.endsWith(`/entry/${id}/text`)),
			).toHaveLength(1);
			const changed = await (await fetch(dataUrl)).json();
			const changedEntry = changed.entries.find(
				(entry: { id: string }) => entry.id === id,
			);
			changedEntry.metrics.durationMs = 1234;
			changedEntry.metrics.textBytes = null;
			changedEntry.metrics.totalBytes = null;
			changedEntry.usage.catalogCost = {
				input: 1,
				output: 2,
				cacheRead: 0,
				cacheWrite: 0,
				total: 3,
			};
			await page.route(`${url}data?**`, (route) =>
				route.fulfill({
					contentType: "application/json",
					body: JSON.stringify(changed),
				}),
			);
			const changedResponse = page.waitForResponse(
				(response) => response.url() === dataUrl,
			);
			await page
				.locator("#refresh")
				.evaluate((node: HTMLButtonElement) => node.click());
			await changedResponse;
			await browserExpect(page.locator("#refresh")).toBeEnabled();
			await page.unroute(`${url}data?**`);
			expect(await originalRow!.evaluate((node) => node.isConnected)).toBe(
				true,
			);
			expect(await page.evaluate(() => window.getSelection()!.toString())).toBe(
				selected,
			);
			expect(
				await text.evaluate((node) => node.getBoundingClientRect().top),
			).toBeCloseTo(anchorTop, 0);
			await browserExpect(row.locator(".entry-metadata")).not.toHaveAttribute(
				"open",
			);
			await row.locator(".entry-metadata > summary").click();
			await browserExpect(row.locator(".entry-meta")).toContainText("1.234 s");
			await row
				.getByText("Usage and size measurements", { exact: true })
				.click();
			await browserExpect(
				row.getByRole("row", {
					name: "Current catalog estimate (USD) $3",
					exact: true,
				}),
			).toBeVisible();
			await browserExpect(
				row.getByRole("row", { name: "Text bytes Unknown", exact: true }),
			).toBeVisible();
			await row
				.getByText("Usage and size measurements", { exact: true })
				.click();
			await row.locator(".entry-metadata > summary").click();
			expect(
				requests.filter((request) => request.endsWith(`/entry/${id}/text`)),
			).toHaveLength(1);
			await page.route(`**/entry/${id}/json`, (route) =>
				route.fulfill({
					status: 200,
					contentType: "application/x-ndjson",
					body: `${JSON.stringify({ type: "text", text: '{"partial":true' })}\n`,
				}),
			);
			await row.locator(".entry-json > summary").click();
			await browserExpect(
				row.locator(".entry-json > .entry-load-status"),
			).toContainText("Load failed");
			await browserExpect(row.locator(".entry-preview")).toContainText(marker);
			await page.unroute(`**/entry/${id}/json`);
			await row
				.getByRole("button", { name: "Retry JSON", exact: true })
				.click();
			await browserExpect(
				row.locator(".entry-json > .entry-load-status"),
			).toHaveText("");
			const completeJson = JSON.parse(
				(await row.locator(".entry-json .json-code").textContent())!,
			);
			expect(completeJson.message.content[0].text === body).toBe(true);
			expect(completeJson.message.content[0].textSignature === signature).toBe(
				true,
			);
			await row.locator(".entry-json > summary").click();
			await text.evaluate((node) => {
				node.scrollTop = node.scrollHeight;
			});
			await row.screenshot({ path: join(root, "complete-dark.png") });
			await page.locator("#search").fill(cancelMarker);
			const cancelRow = page.locator(`.entry[data-entry-id="${cancelId}"]`);
			const cdp = await page.context().newCDPSession(page);
			await cdp.send("Network.enable");
			await cdp.send("Network.emulateNetworkConditions", {
				offline: false,
				latency: 0,
				downloadThroughput: 64 * 1024,
				uploadThroughput: -1,
			});
			const aborted = page.waitForEvent("requestfailed", {
				predicate: (request) =>
					request.url() === `${url}entry/${cancelId}/text`,
				timeout: 5000,
			});
			await cancelRow.locator(":scope > summary").click();
			await browserExpect(
				cancelRow.locator(".entry-full-text pre"),
			).toContainText(cancelMarker);
			await cancelRow.locator(":scope > summary").click();
			await aborted;
			await cdp.send("Network.emulateNetworkConditions", {
				offline: false,
				latency: 0,
				downloadThroughput: -1,
				uploadThroughput: -1,
			});
			await cancelRow.locator(":scope > summary").click();
			await browserExpect(
				cancelRow.locator(".entry-body > .entry-load-status"),
			).toHaveText("");
			expect(
				await cancelRow
					.locator(".entry-full-text pre")
					.evaluate(
						(node, expected) => node.textContent === expected,
						cancelBody,
					),
			).toBe(true);
			expect(
				requests.filter((request) =>
					request.endsWith(`/entry/${cancelId}/text`),
				),
			).toHaveLength(2);
			await page.emulateMedia({ colorScheme: "light" });
			await page.setViewportSize({ width: 390, height: 844 });
			await cancelRow.locator(".entry-full-text pre").evaluate((node) => {
				node.scrollTop = node.scrollHeight;
			});
			expect(
				await page.evaluate(
					() => document.documentElement.scrollWidth <= window.innerWidth,
				),
			).toBe(true);
			await page.screenshot({
				path: join(root, "complete-light-mobile.png"),
			});
			await cancelRow.locator(":scope > summary").click();
			await cancelRow.screenshot({
				path: join(root, "preview-light-mobile.png"),
			});
			await page.locator("#search").fill("preview-disposed-fixture");
			const disposedRow = page.locator(`.entry[data-entry-id="${disposedId}"]`);
			await browserExpect(disposedRow).toBeVisible();
			const disposedRoot = await disposedRow.elementHandle();
			await page.locator("#search").fill("no-matching-entry");
			await browserExpect(page.locator(".entry")).toHaveCount(0);
			await disposedRoot!.evaluate(async (node) => {
				const row = node as HTMLDetailsElement;
				const raw = row.querySelector<HTMLDetailsElement>(".entry-json")!;
				const toggled = Promise.all([
					new Promise<void>((resolve) =>
						row.addEventListener("toggle", () => resolve(), { once: true }),
					),
					new Promise<void>((resolve) =>
						raw.addEventListener("toggle", () => resolve(), { once: true }),
					),
				]);
				row.open = true;
				raw.open = true;
				await toggled;
			});
			await browserExpect(page.locator(".entry")).toHaveCount(0);
			expect(
				requests.some((request) => request.includes(`/entry/${disposedId}/`)),
			).toBe(false);
			expect(initialStatus).toEqual({ text: "", hidden: true });
			expect(errors).toEqual([]);
		} finally {
			await browser.close();
			await pi?.dispose();
			if (keepScreenshots) {
				await rm(join(root, "package"), { recursive: true, force: true });
				console.log(`Preview screenshots: ${root}`);
			} else await rm(root, { recursive: true, force: true });
		}
	},
	45_000,
);

it.runIf(process.env["PI_AUTOPSY_BROWSER_TESTS"] === "1")(
	"lazily scrolls relocated real history without losing scope totals or open readers",
	async () => {
		type InspectorData = import("../src/types.ts").InspectorData;
		const root = await mkdtemp(join(tmpdir(), "pi-autopsy-history-"));
		const keepScreenshots = process.env["PI_AUTOPSY_KEEP_SCREENSHOTS"] === "1";
		const browser = await chromium.launch();
		let pi: PiSession | undefined;
		let releaseCursor = () => {};
		try {
			const packageDir = join(root, "package");
			await cp(
				fileURLToPath(new URL("../../../dist/autopsy", import.meta.url)),
				packageDir,
				{ recursive: true },
			);
			pi = await createPiSession({
				extensionPaths: [join(packageDir, "index.ts")],
				env: { PATH: "/no-browser-openers", TERMUX_VERSION: "fixture" },
			});
			const manager = pi.session.sessionManager;
			manager.appendUsage("test", "faux", "faux-model", {
				input: 17,
				output: 5,
				cacheRead: 3,
				cacheWrite: 0,
				totalTokens: 25,
				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.25 },
			});
			const bodies = new Map<string, string>();
			for (let index = 0; index < 300; index++) {
				const body =
					`History ${index}: investigating a real captured session.\n` +
					"Substantial recorded content, available completely on demand. ".repeat(
						420,
					) +
					`\nCOMPLETE-HISTORY-TAIL-${index}`;
				const id = manager.appendMessage({
					role: "user",
					timestamp: Date.UTC(2026, 0, 1) + index * 1000,
					content: body,
				});
				bodies.set(id, body);
			}
			expect(
				[...bodies.values()].reduce((sum, body) => sum + body.length, 0),
			).toBeGreaterThan(4 * 1024 * 1024);
			const newestId = [...bodies.keys()].at(-1)!;
			const oldestId = manager.getBranch()[0]!.id;
			initTheme(undefined, false);
			const ctx = pi.session.extensionRunner.createCommandContext();
			let url = "";
			ctx.ui.notify = (message) => {
				url = message.match(/http:\/\/127\.0\.0\.1:\d+\/\w+\//u)?.[0] ?? "";
			};
			await pi.extensions[0]!.commands.get("autopsy")!.handler("", ctx);
			expect(url).toMatch(/^http:/u);
			const page = await browser.newPage({
				viewport: { width: 1100, height: 10000 },
				colorScheme: "dark",
			});
			const requests: URL[] = [];
			const errors: string[] = [];
			const pages: InspectorData[] = [];
			page.on("request", (request) => requests.push(new URL(request.url())));
			page.on("pageerror", (error) => errors.push(error.message));
			const cursorGate = new Promise<void>((resolve) => {
				releaseCursor = resolve;
			});
			// Hold real cursor responses to measure page 1, without synthetic data or DOM.
			await page.route("**/data?**", async (route) => {
				if (new URL(route.request().url()).searchParams.has("after"))
					await cursorGate;
				await route.continue();
			});
			const initialResponse = page.waitForResponse((response) =>
				new URL(response.url()).pathname.endsWith("/data"),
			);
			const initialCursor = page.waitForRequest((request) =>
				new URL(request.url()).searchParams.has("after"),
			);
			await page.goto(url);
			const firstPage: InspectorData = await (await initialResponse).json();
			pages.push(firstPage);
			await initialCursor;
			await browserExpect(page.locator(".entry")).toHaveCount(50);
			expect(
				await page
					.locator("#history")
					.evaluate((node) => node.scrollHeight <= node.clientHeight),
			).toBe(true);
			expect(
				await page.locator("#history").evaluate((node) => node.scrollTop),
			).toBe(0);
			const furtherPages: InspectorData[] = [];
			page.on("response", async (response) => {
				if (
					new URL(response.url()).pathname.endsWith("/data") &&
					response.ok()
				) {
					const snapshot: InspectorData = await response.json();
					furtherPages.push(snapshot);
				}
			});
			releaseCursor();
			await browserExpect
				.poll(() => furtherPages.length)
				.toBeGreaterThanOrEqual(2);
			await browserExpect(page.locator("#history")).toHaveAttribute(
				"aria-busy",
				"false",
			);
			expect(
				requests.filter((request) => request.searchParams.has("after")).length,
			).toBeGreaterThanOrEqual(2);
			const detailRequests = () =>
				requests.filter((request) => request.pathname.includes("/entry/"));
			expect(detailRequests()).toEqual([]);
			expect(
				requests.some((request) =>
					/\/(?:metrics|prompts)$/u.test(request.pathname),
				),
			).toBe(false);
			const realSummary: InspectorData = await (
				await fetch(`${url}data?branch=current&order=newest&limit=50`)
			).json();
			expect(firstPage.summary).toEqual(realSummary.summary);
			expect(firstPage.summary.entries).toBe(manager.getBranch().length);
			expect(firstPage.summary.tokens).toBe(25);
			expect(firstPage.summary.storedCost).toBe(0.25);
			expect(firstPage.entries[0]!.id).toBe(newestId);
			const header = await page.locator(".metrics-strip").textContent();
			const assertScope = async () => {
				expect(await page.locator(".metrics-strip").textContent()).toBe(header);
				for (const snapshot of [...pages, ...furtherPages])
					expect(snapshot.summary).toEqual(firstPage.summary);
				const ids = await page
					.locator(".entry")
					.evaluateAll((rows) =>
						rows.map((row) => (row as HTMLElement).dataset["entryId"]),
					);
				expect(new Set(ids).size).toBe(ids.length);
			};
			await page.setViewportSize({ width: 1100, height: 900 });
			// Transcript-first screenshots: no dialog or expanded reader obscures the screen.
			for (const colorScheme of ["dark", "light"] as const) {
				await page.emulateMedia({ colorScheme });
				for (const [size, viewport] of [
					["desktop", { width: 1100, height: 900 }],
					["mobile", { width: 390, height: 844 }],
				] as const) {
					await page.setViewportSize(viewport);
					expect(
						await page.evaluate(
							() => document.documentElement.scrollWidth <= innerWidth,
						),
					).toBe(true);
					await browserExpect(page.locator("dialog[open]")).toHaveCount(0);
					await browserExpect(page.locator(".entry[open]")).toHaveCount(0);
					await page.screenshot({
						path: join(root, `transcript-${colorScheme}-${size}.png`),
					});
				}
			}
			await page.emulateMedia({ colorScheme: "dark" });
			await page.setViewportSize({ width: 1100, height: 900 });
			const row = page.locator(`.entry[data-entry-id="${newestId}"]`);
			const preview = firstPage.entries[0]!.text;
			expect(preview).not.toContain("COMPLETE-HISTORY-TAIL-299");
			await row.locator(":scope > summary").click();
			await browserExpect(
				row.locator(".entry-body > .entry-load-status"),
			).toHaveText("");
			const text = row.locator(".entry-full-text pre");
			expect(await text.textContent()).toBe(bodies.get(newestId));
			expect((await text.textContent())!.length).toBeGreaterThan(
				preview.length,
			);
			expect(detailRequests().map((request) => request.pathname)).toEqual([
				new URL(`entry/${newestId}/text`, url).pathname,
			]);
			const originalRoot = await text.elementHandle();
			const selected = await text.evaluate((node) => {
				const range = document.createRange();
				range.setStart(node.firstChild!, 0);
				range.setEnd(node.firstChild!, 10);
				const selection = window.getSelection()!;
				selection.removeAllRanges();
				selection.addRange(range);
				return selection.toString();
			});
			const originalRange = await page.evaluateHandle(() =>
				window.getSelection()!.getRangeAt(0),
			);
			const scrollPage = async (direction: "after" | "before") => {
				const response = page.waitForResponse(
					(response) =>
						new URL(response.url()).pathname.endsWith("/data") &&
						new URL(response.url()).searchParams.has(direction),
				);
				await page.locator("#history").evaluate((node, side) => {
					node.scrollTop = side === "after" ? node.scrollHeight : 0;
				}, direction);
				pages.push(await (await response).json());
				await browserExpect(page.locator("#history")).toHaveAttribute(
					"aria-busy",
					"false",
				);
				await assertScope();
				expect(
					await page.locator(".entry:not([open])").count(),
				).toBeLessThanOrEqual(150);
			};
			for (let step = 0; step < 12; step++) {
				if (
					(await page.locator("#end-status").textContent()) ===
					"End of history."
				)
					break;
				await scrollPage("after");
				expect(
					await originalRoot!.evaluate(
						(node, id) =>
							node ===
							document.querySelector(
								`.entry[data-entry-id="${id}"] .entry-full-text pre`,
							),
						newestId,
					),
				).toBe(true);
				expect(
					await page.evaluate(() => window.getSelection()!.toString()),
				).toBe(selected);
				expect(
					await originalRange.evaluate(
						(range) => window.getSelection()!.getRangeAt(0) === range,
					),
				).toBe(true);
			}
			await browserExpect(page.locator("#end-status")).toHaveText(
				"End of history.",
			);
			await browserExpect(
				page.locator(`.entry[data-entry-id="${oldestId}"]`),
			).toHaveCount(1);
			expect(
				requests.filter((request) => request.searchParams.has("after")).length,
			).toBeGreaterThanOrEqual(3);
			expect(
				await page.locator(".entry:not([open])").count(),
			).toBeLessThanOrEqual(150);
			expect(detailRequests()).toHaveLength(1);
			// Trigger native disclosure without scrolling the pinned reader back into view.
			await row
				.locator(".entry-json > summary")
				.evaluate((node) => (node as HTMLElement).click());
			await browserExpect(
				row.locator(".entry-json > .entry-load-status"),
			).toHaveText("");
			expect(detailRequests().map((request) => request.pathname)).toEqual([
				new URL(`entry/${newestId}/text`, url).pathname,
				new URL(`entry/${newestId}/json`, url).pathname,
			]);
			expect(
				await row.locator(".entry-json .json-code").textContent(),
			).toContain("COMPLETE-HISTORY-TAIL-299");
			await row
				.locator(":scope > summary")
				.evaluate((node) => (node as HTMLElement).click());
			await page.evaluate(() => {
				window.getSelection()!.removeAllRanges();
				(document.activeElement as HTMLElement | null)?.blur();
			});
			// Release the pinned reader before recovering the newest page via before cursors.
			for (let step = 0; step < 12; step++) {
				if (pages.at(-1)!.page.start === 0) break;
				await scrollPage("before");
			}
			await browserExpect(page.locator(".entry").first()).toHaveAttribute(
				"data-entry-id",
				newestId,
			);
			expect(
				requests.filter((request) => request.searchParams.has("before")).length,
			).toBeGreaterThanOrEqual(3);
			await assertScope();
			expect(
				requests.some((request) =>
					/\/(?:metrics|prompts)$/u.test(request.pathname),
				),
			).toBe(false);
			await page.locator("#insights-button").click();
			await browserExpect(page.locator("#metrics-status")).toContainText(
				"complete scope",
			);
			expect(
				requests.filter((request) => request.pathname.endsWith("/metrics")),
			).toHaveLength(1);
			expect(
				requests.some((request) => request.pathname.endsWith("/prompts")),
			).toBe(false);
			await page.locator("#insights-panel [data-close]").click();
			await page.locator("#session-button").click();
			expect(
				requests.some((request) => request.pathname.endsWith("/prompts")),
			).toBe(false);
			await page.locator("#captures > summary").click();
			await browserExpect(page.locator("#prompt-empty")).toBeVisible();
			expect(
				requests.filter((request) => request.pathname.endsWith("/prompts")),
			).toHaveLength(1);
			expect(
				pages.every(
					(snapshot) => snapshot.summary.entries === firstPage.summary.entries,
				),
			).toBe(true);
			expect(errors).toEqual([]);
		} finally {
			releaseCursor();
			await browser.close();
			await pi?.dispose();
			if (keepScreenshots) {
				await rm(join(root, "package"), { recursive: true, force: true });
				console.log(`History screenshots: ${root}`);
			} else await rm(root, { recursive: true, force: true });
		}
	},
	60_000,
);