claudeup 6.2.0 → 6.3.0

package/src/__tests__/theme-env.test.ts

@@ -0,0 +1,281 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadProjectDotenv } from "../services/dotenv.js";
+import { resolveTheme, snapshotThemeEnv } from "../ui/theme-resolve.js";
+
+/**
+ * `TERM_THEME` is read from the process environment and never from a `.env`.
+ *
+ * Nothing at runtime enforces that — `loadProjectDotenv` merges into the same
+ * `process.env` the resolver would otherwise read — so the isolation is the
+ * ORDER of two calls in main.tsx: snapshot first, dotenv second. T-env-1 and
+ * T-env-2 prove the mechanism; T-env-3 pins the order at source level, which is
+ * the only place it can be pinned without spawning the TUI.
+ *
+ * Order alone is not enough on the source path: Bun autoloads the cwd's `.env`
+ * into `process.env` BEFORE any user code runs, so a snapshot taken as the
+ * first statement already holds the file's values. Every source launcher
+ * therefore passes `--no-env-file` (the compiled binary is built with
+ * `--no-compile-autoload-dotenv`). T-env-4 proves that flag live, with a
+ * negative control showing the leak without it.
+ */
+
+const dirs: string[] = [];
+
+const MAIN_TSX = path.join(import.meta.dir, "..", "main.tsx");
+const THEME_RESOLVE = path.join(
+	import.meta.dir,
+	"..",
+	"ui",
+	"theme-resolve.ts",
+);
+
+/**
+ * Spawn bun from `cwd` with the three theme variables removed from the parent
+ * environment, so the only way `TERM_THEME` can reach the child is Bun's own
+ * `.env` autoload. Returns stdout/stderr/status.
+ */
+function spawnBun(
+	cwd: string,
+	args: string[],
+): { status: number | null; stdout: string; stderr: string } {
+	const env: Record<string, string | undefined> = { ...process.env };
+	env.TERM_THEME = undefined;
+	env.CLAUDEUP_THEME = undefined;
+	env.COLORFGBG = undefined;
+	const r = spawnSync("bun", args, {
+		cwd,
+		env: env as NodeJS.ProcessEnv,
+		encoding: "utf-8",
+		input: "",
+	});
+	return { status: r.status, stdout: r.stdout, stderr: r.stderr };
+}
+
+/** A one-file harness that prints `snapshotThemeEnv()` of its own process. */
+function writeSnapshotHarness(cwd: string): string {
+	const file = path.join(cwd, "print-snapshot.ts");
+	writeFileSync(
+		file,
+		[
+			`import { snapshotThemeEnv } from ${JSON.stringify(THEME_RESOLVE)};`,
+			"console.log(JSON.stringify(snapshotThemeEnv()));",
+			"",
+		].join("\n"),
+	);
+	return file;
+}
+
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(): string {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "claudeup-theme-env-"));
+	dirs.push(dir);
+	return dir;
+}
+
+describe("snapshotThemeEnv", () => {
+	test("T-env-1: the snapshot is a copy — later writes to env do not reach it", () => {
+		const env: Record<string, string | undefined> = {
+			TERM_THEME: "light",
+			CLAUDEUP_THEME: "dark",
+			COLORFGBG: "0;15",
+			UNRELATED: "x",
+		};
+
+		const snapshot = snapshotThemeEnv(env);
+		env.TERM_THEME = "dark";
+		env.CLAUDEUP_THEME = undefined;
+		env.COLORFGBG = "15;0";
+
+		expect(snapshot).toEqual({
+			TERM_THEME: "light",
+			CLAUDEUP_THEME: "dark",
+			COLORFGBG: "0;15",
+		});
+	});
+
+	test("T-env-1b: an unset variable is absent from the snapshot, not undefined", () => {
+		expect(snapshotThemeEnv({})).toEqual({});
+		expect(Object.keys(snapshotThemeEnv({ TERM_THEME: "light" }))).toEqual([
+			"TERM_THEME",
+		]);
+	});
+
+	test("T-env-2: a .env TERM_THEME lands in env but never in a snapshot taken first", () => {
+		const cwd = tempDir();
+		writeFileSync(path.join(cwd, ".env"), "TERM_THEME=light\n");
+		const env: Record<string, string | undefined> = {};
+
+		const snapshot = snapshotThemeEnv(env);
+		const outcome = loadProjectDotenv(cwd, env);
+
+		expect(outcome.warnings).toEqual([]);
+		expect(env.TERM_THEME).toBe("light");
+		expect(snapshot.TERM_THEME).toBeUndefined();
+		expect(snapshot).toEqual({});
+	});
+
+	test("T-env-2b: a .env TERM_THEME=light never reaches the resolver — the probe still runs and wins", async () => {
+		// End to end through the resolver: snapshot, then .env, then resolve
+		// with the snapshot. Were the .env value reaching the resolver, step 3
+		// would answer light and the probe would never be called.
+		const cwd = tempDir();
+		writeFileSync(
+			path.join(cwd, ".env"),
+			"TERM_THEME=light\nCLAUDEUP_THEME=light\n",
+		);
+		const env: Record<string, string | undefined> = {};
+		let probeCalls = 0;
+
+		const snapshot = snapshotThemeEnv(env);
+		loadProjectDotenv(cwd, env);
+		const interactive = await resolveTheme({
+			env: snapshot,
+			isInteractive: true,
+			probe: async () => {
+				probeCalls += 1;
+				return "dark";
+			},
+		});
+		const headless = await resolveTheme({
+			env: snapshot,
+			isInteractive: false,
+			probe: async () => "light",
+		});
+
+		expect(env.TERM_THEME).toBe("light");
+		expect(interactive).toEqual({ mode: "dark", source: "osc11" });
+		expect(probeCalls).toBe(1);
+		expect(headless).toEqual({ mode: "dark", source: "default" });
+	});
+
+	test("T-env-2c: .env.local is isolated the same way as .env", async () => {
+		const cwd = tempDir();
+		writeFileSync(path.join(cwd, ".env.local"), "TERM_THEME=light\n");
+		const env: Record<string, string | undefined> = { COLORFGBG: "15;0" };
+
+		const snapshot = snapshotThemeEnv(env);
+		loadProjectDotenv(cwd, env);
+		const r = await resolveTheme({
+			env: snapshot,
+			isInteractive: false,
+			probe: async () => null,
+		});
+
+		expect(env.TERM_THEME).toBe("light");
+		expect(r).toEqual({ mode: "dark", source: "COLORFGBG" });
+	});
+});
+
+describe("Bun .env autoload (live)", () => {
+	test("T-env-4: `bun --no-env-file src/main.tsx --theme bogus` from a cwd with .env exits in the router, not from the file", () => {
+		// --theme bogus exits 1 before the renderer, so no tty is needed. The
+		// point of the run is the exit path: a leaked .env value cannot change
+		// it, and the flag must not break the source launch either.
+		const cwd = tempDir();
+		writeFileSync(
+			path.join(cwd, ".env"),
+			"TERM_THEME=light\nCLAUDEUP_THEME=light\n",
+		);
+
+		const r = spawnBun(cwd, ["--no-env-file", MAIN_TSX, "--theme", "bogus"]);
+
+		expect(r.status).toBe(1);
+		expect(r.stderr).toContain("bogus");
+		expect(r.stderr).toContain("--theme");
+	});
+
+	test("T-env-4b: with --no-env-file the process snapshot holds nothing from the cwd's .env", () => {
+		const cwd = tempDir();
+		writeFileSync(
+			path.join(cwd, ".env"),
+			"TERM_THEME=light\nCLAUDEUP_THEME=light\n",
+		);
+		const harness = writeSnapshotHarness(cwd);
+
+		const r = spawnBun(cwd, ["--no-env-file", harness]);
+
+		expect(r.status).toBe(0);
+		expect(JSON.parse(r.stdout.trim())).toEqual({});
+	});
+
+	test("T-env-4c (negative control): without --no-env-file the same harness sees TERM_THEME=light — the flag is what isolates", () => {
+		const cwd = tempDir();
+		writeFileSync(
+			path.join(cwd, ".env"),
+			"TERM_THEME=light\nCLAUDEUP_THEME=light\n",
+		);
+		const harness = writeSnapshotHarness(cwd);
+
+		const r = spawnBun(cwd, [harness]);
+
+		expect(r.status).toBe(0);
+		expect(JSON.parse(r.stdout.trim())).toEqual({
+			TERM_THEME: "light",
+			CLAUDEUP_THEME: "light",
+		});
+	});
+
+	test("T-env-4d: every source launcher passes --no-env-file", () => {
+		// package.json scripts and the bin fallback are the launch surfaces a
+		// developer actually uses; a `bun src/main.tsx` without the flag is the
+		// bug T-env-4c demonstrates.
+		const root = path.join(import.meta.dir, "..", "..");
+		const pkg = JSON.parse(
+			readFileSync(path.join(root, "package.json"), "utf-8"),
+		) as { scripts: Record<string, string> };
+		const bin = readFileSync(path.join(root, "bin", "claudeup.js"), "utf-8");
+
+		for (const name of ["start", "dev"]) {
+			expect(pkg.scripts[name]).toContain("--no-env-file");
+			expect(pkg.scripts[name]).toContain("src/main.tsx");
+		}
+		expect(bin).toMatch(/spawnSync\(\s*"bun",\s*\[\s*"--no-env-file"/);
+	});
+});
+
+/**
+ * Drop `//` line comments and `/* *\/` blocks so a guard below matches code,
+ * never a comment that happens to name the call. Strings in main.tsx contain
+ * neither `//` nor `/*`, so the crude regex is exact enough for that one file.
+ */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+
+describe("main.tsx order", () => {
+	const code = stripComments(
+		readFileSync(path.join(import.meta.dir, "..", "main.tsx"), "utf-8"),
+	);
+
+	test("T-env-3: the snapshot STATEMENT runs before the loadProjectDotenv() call", () => {
+		// Source-level guard. Honest about what it is: nothing at runtime would
+		// notice a .env winning, and the TUI cannot be spawned in a test. It
+		// anchors on the concrete statement, in comment-stripped source, so the
+		// explanatory comment above the call cannot satisfy it (it once did).
+		const snapshotAt = code.indexOf("const themeEnv = snapshotThemeEnv()");
+		const dotenvAt = code.indexOf("loadProjectDotenv(");
+
+		expect(snapshotAt).toBeGreaterThan(-1);
+		expect(dotenvAt).toBeGreaterThan(-1);
+		expect(snapshotAt).toBeLessThan(dotenvAt);
+	});
+
+	test("T-env-3b: main.tsx reads the three theme variables only through the snapshot", () => {
+		// A later `process.env.TERM_THEME` would see the merged .env and bypass
+		// the snapshot silently; the resolver must be handed `themeEnv` instead.
+		for (const name of ["TERM_THEME", "CLAUDEUP_THEME", "COLORFGBG"]) {
+			expect(code).not.toMatch(
+				new RegExp(`process\\.env(\\.${name}\\b|\\[["'\`]${name}["'\`]\\])`),
+			);
+		}
+		expect(code).toMatch(/env:\s*themeEnv\b/);
+	});
+});

package/src/__tests__/theme-resolve.test.ts

@@ -0,0 +1,380 @@
+import { describe, expect, test } from "bun:test";
+import type { ThemeMode } from "@opentui/core";
+import {
+	type ResolveThemeInput,
+	parseColorFgBg,
+	parseThemeWord,
+	resolveTheme,
+} from "../ui/theme-resolve.js";
+
+/**
+ * The resolver is a six-step, first-answer-wins list. These tests pin every
+ * step, every adjacent precedence pair, and the "no opinion" rule: a word that
+ * is not exactly `light` or `dark` says nothing and the next step runs.
+ *
+ * The probe is a hand-rolled recorder rather than `spyOn` — `spyOn` calls
+ * through to the original by default, and the property under test is whether
+ * the probe was reached at all.
+ */
+
+function probeReturning(value: ThemeMode | null) {
+	let calls = 0;
+	const probe = async () => {
+		calls += 1;
+		return value;
+	};
+	return { probe, calls: () => calls };
+}
+
+function input(overrides: Partial<ResolveThemeInput> = {}): ResolveThemeInput {
+	return {
+		env: {},
+		isInteractive: true,
+		probe: async () => null,
+		...overrides,
+	};
+}
+
+describe("each step answers on its own", () => {
+	test("T-step-1: the flag wins and the probe is never called", async () => {
+		const p = probeReturning("dark");
+
+		const r = await resolveTheme(input({ flag: "light", probe: p.probe }));
+
+		expect(r).toEqual({ mode: "light", source: "flag" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-step-2: CLAUDEUP_THEME answers without the probe", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({ env: { CLAUDEUP_THEME: "dark" }, probe: p.probe }),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "variable" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-step-3: TERM_THEME answers and the probe is skipped entirely", async () => {
+		const p = probeReturning("dark");
+
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "light" }, probe: p.probe }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "TERM_THEME" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-step-4: an interactive tty probes exactly once", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(input({ probe: p.probe }));
+
+		expect(r).toEqual({ mode: "light", source: "osc11" });
+		expect(p.calls()).toBe(1);
+	});
+
+	test("T-step-5: an unanswered probe falls to COLORFGBG", async () => {
+		const r = await resolveTheme(
+			input({ env: { COLORFGBG: "15;7" }, probe: async () => null }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+	});
+
+	test("T-step-6: nothing answers → dark by decision, no throw", async () => {
+		const r = await resolveTheme(input());
+
+		expect(r).toEqual({ mode: "dark", source: "default" });
+	});
+});
+
+describe("precedence between adjacent steps", () => {
+	test("T-prec-flag>var: the flag beats CLAUDEUP_THEME", async () => {
+		const r = await resolveTheme(
+			input({ flag: "light", env: { CLAUDEUP_THEME: "dark" } }),
+		);
+
+		expect(r.mode).toBe("light");
+		expect(r.source).toBe("flag");
+	});
+
+	test("T-prec-var>TERM: CLAUDEUP_THEME beats TERM_THEME", async () => {
+		const r = await resolveTheme(
+			input({ env: { CLAUDEUP_THEME: "light", TERM_THEME: "dark" } }),
+		);
+
+		expect(r.mode).toBe("light");
+		expect(r.source).toBe("variable");
+	});
+
+	test("T-prec-TERM>probe: TERM_THEME beats a probe that would disagree", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "dark" }, probe: p.probe }),
+		);
+
+		expect(r.mode).toBe("dark");
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-prec-probe>CFB: the probe beats COLORFGBG", async () => {
+		const r = await resolveTheme(
+			input({ env: { COLORFGBG: "15;0" }, probe: async () => "light" }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "osc11" });
+	});
+
+	test("T-prec-CFB>default: a dark COLORFGBG is attributed to COLORFGBG, not default", async () => {
+		const r = await resolveTheme(input({ env: { COLORFGBG: "0;0" } }));
+
+		expect(r).toEqual({ mode: "dark", source: "COLORFGBG" });
+	});
+});
+
+describe("precedence across non-adjacent steps", () => {
+	test("T-prec-flag>all: the flag beats every later step, and none of them is consulted", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({
+				flag: "dark",
+				env: {
+					CLAUDEUP_THEME: "light",
+					TERM_THEME: "light",
+					COLORFGBG: "0;15",
+				},
+				probe: p.probe,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "flag" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-prec-var>probe: CLAUDEUP_THEME beats a probe that would disagree, and skips it", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({
+				env: { CLAUDEUP_THEME: "dark", COLORFGBG: "0;15" },
+				probe: p.probe,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "variable" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-prec-TERM>CFB: TERM_THEME beats COLORFGBG when there is no tty to probe", async () => {
+		const r = await resolveTheme(
+			input({
+				env: { TERM_THEME: "light", COLORFGBG: "15;0" },
+				isInteractive: false,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "TERM_THEME" });
+	});
+
+	test("T-step-4b: a probe that answers dark is attributed to osc11, not default", async () => {
+		const r = await resolveTheme(
+			input({ env: { COLORFGBG: "0;15" }, probe: async () => "dark" }),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "osc11" });
+	});
+});
+
+describe("no opinion falls through", () => {
+	test("T-noop-auto: TERM_THEME=auto reaches the probe", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "auto" }, probe: p.probe }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "osc11" });
+		expect(p.calls()).toBe(1);
+	});
+
+	test("T-noop-case: Light and DARK are not the exact words and are ignored", async () => {
+		const r = await resolveTheme(
+			input({
+				env: { TERM_THEME: "Light", CLAUDEUP_THEME: "DARK" },
+				isInteractive: false,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "default" });
+	});
+
+	test("T-noop-empty: an empty TERM_THEME falls through", async () => {
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "", COLORFGBG: "0;15" } }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+	});
+
+	test("T-noop-auto-notty: TERM_THEME=auto never means dark — without a tty it reaches COLORFGBG", async () => {
+		const p = probeReturning("dark");
+
+		const r = await resolveTheme(
+			input({
+				env: { TERM_THEME: "auto", COLORFGBG: "0;15" },
+				isInteractive: false,
+				probe: p.probe,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-noop-auto-default: TERM_THEME=auto with nothing else is the DEFAULT dark, not a TERM_THEME answer", async () => {
+		const r = await resolveTheme(input({ env: { TERM_THEME: "auto" } }));
+
+		expect(r).toEqual({ mode: "dark", source: "default" });
+	});
+
+	test.each(["auto", "purple", "", "Dark"])(
+		"T-noop-var: CLAUDEUP_THEME=%p is no opinion and TERM_THEME answers instead",
+		async (word) => {
+			const p = probeReturning("dark");
+
+			const r = await resolveTheme(
+				input({
+					env: { CLAUDEUP_THEME: word, TERM_THEME: "light" },
+					probe: p.probe,
+				}),
+			);
+
+			expect(r).toEqual({ mode: "light", source: "TERM_THEME" });
+			expect(p.calls()).toBe(0);
+		},
+	);
+});
+
+describe("R8: resolving is silent", () => {
+	// The dark fallback is a decision, not a failure: no step, including step 6
+	// and a probe that fails, may print a "could not detect" line.
+	test("T-quiet: neither the default path nor a failing probe writes to the console", async () => {
+		const written: string[] = [];
+		const record = (...a: unknown[]) => {
+			written.push(a.join(" "));
+		};
+		const original = {
+			log: console.log,
+			warn: console.warn,
+			error: console.error,
+		};
+		console.log = record;
+		console.warn = record;
+		console.error = record;
+		try {
+			await resolveTheme(input());
+			await resolveTheme(
+				input({
+					probe: async () => {
+						throw new Error("no reply");
+					},
+				}),
+			);
+			await resolveTheme(
+				input({ env: { TERM_THEME: "auto" }, isInteractive: false }),
+			);
+		} finally {
+			console.log = original.log;
+			console.warn = original.warn;
+			console.error = original.error;
+		}
+
+		expect(written).toEqual([]);
+	});
+});
+
+describe("the probe is guarded", () => {
+	test("T-tty: a non-interactive process never probes", async () => {
+		const p = probeReturning("light");
+
+		const fromEnv = await resolveTheme(
+			input({
+				isInteractive: false,
+				env: { COLORFGBG: "0;15" },
+				probe: p.probe,
+			}),
+		);
+		const fromDefault = await resolveTheme(
+			input({ isInteractive: false, probe: p.probe }),
+		);
+
+		expect(fromEnv).toEqual({ mode: "light", source: "COLORFGBG" });
+		expect(fromDefault).toEqual({ mode: "dark", source: "default" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-probe-throws: a rejecting probe is treated as null", async () => {
+		const r = await resolveTheme(
+			input({
+				env: { COLORFGBG: "0;7" },
+				probe: async () => {
+					throw new Error("terminal hung up");
+				},
+			}),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+	});
+});
+
+describe("T-cfb-parse: parseColorFgBg reads the LAST field as the background", () => {
+	test.each<[string | undefined, ThemeMode | null]>([
+		["15;0", "dark"],
+		["0;15", "light"],
+		["0;7", "light"],
+		["12;3;7", "light"],
+		["0;default;15", "light"],
+		["default;default", null],
+		["7", null],
+		["15", null],
+		["x;16", null],
+		["0;255", null],
+		// Zero-padded fields are outside the statusline's literal `case` set, so
+		// they are no opinion here too — Number("07") would have said light.
+		["0;07", null],
+		["0;015", null],
+		["0;00", null],
+		["0;", null],
+		["", null],
+		[undefined, null],
+	])("%p → %p", (value, expected) => {
+		expect(parseColorFgBg(value)).toBe(expected);
+	});
+
+	test("every background 0-14 except 7 is dark", () => {
+		for (let bg = 0; bg <= 14; bg += 1) {
+			expect(parseColorFgBg(`0;${bg}`)).toBe(bg === 7 ? "light" : "dark");
+		}
+	});
+});
+
+describe("T-word-parse: parseThemeWord is exact, lowercase, untrimmed", () => {
+	test.each<[string | undefined, ThemeMode | null]>([
+		["light", "light"],
+		["dark", "dark"],
+		["auto", null],
+		["Light", null],
+		["DARK", null],
+		[" dark", null],
+		["dark ", null],
+		["", null],
+		[undefined, null],
+	])("%p → %p", (value, expected) => {
+		expect(parseThemeWord(value)).toBe(expected);
+	});
+});

package/src/__tests__/update-apply.test.ts

@@ -7,13 +7,13 @@
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { PluginScope } from "../services/claude-cli.js";
 import {
 	type PluginApplyDeps,
 	applyPlugins,
 	installPluginInScope,
 	updatePluginInScope,
 } from "../services/update-engine.js";
-import type { PluginScope } from "../services/claude-cli.js";
 import type { PluginUpdateItem } from "../services/update-plan.js";
 
 const PROJECT = "/tmp/project";
@@ -67,9 +67,7 @@ function item(over: Partial<PluginUpdateItem>): PluginUpdateItem {
 let logs: string[];
 beforeEach(() => {
 	logs = [];
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.log = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.warn = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
 });