@bismawy/pi-arnative 0.3.4 → 0.3.6

package/extensions/ui-render-tweaks.ts

@@ -21,7 +21,6 @@ import {
 	getMarkdownTheme,
 	initTheme,
 	InteractiveMode,
-	keyText,
 	Theme,
 	UserMessageComponent,
 	type ExtensionAPI,
@@ -40,18 +39,26 @@ import {
 } from "@earendil-works/pi-tui";
 import { readdirSync, readFileSync } from "node:fs";
 import { renderBoxLines } from "../lib/box.ts";
-import { ansiBgOpen, stripAnsi, themeOf, accentSoftOf } from "../lib/ansi.ts";
+import { ansiBgOpen, getActiveTheme, setActiveTheme, stripAnsi, themeOf, accentSoftOf } from "../lib/ansi.ts";
 import { assert, isMain } from "../lib/check.ts";
 import { contrast, parseOklch, toHex } from "../lib/color.ts";
 import { expandKeyName } from "../lib/format.ts";
 
-let activeThemeProxy: { fg(color: string, text: string): string; bg?(color: string, text: string): string } | null = null;
+type ActiveTheme = { fg(color: string, text: string): string; bg?(color: string, text: string): string } | null;
+const activeTheme = () => getActiveTheme<Exclude<ActiveTheme, null>>();
 
 // Hide pi's built-in "Reloading keybindings, extensions, skills..." box
 // (hardcoded in handleReloadCommand, no auto-hide). Patches Container.render
 // through the prototype chain (Container is not exported) and drops the whole box on match.
+const RELOAD_TEXT = "Reloading keybindings, extensions, skills, prompts, themes, and context files...";
+/**
+ * True only for the box itself: border rows, blank spacers and (possibly wrapped) copy of the
+ * message. The patch sits on every plain Container, so a bare substring test would blank a
+ * whole chat the moment a transcript line mentioned the phrase.
+ */
 export function shouldHideReloadBox(lines: readonly string[]): boolean {
-	return lines.some((l) => l.includes("Reloading keybindings"));
+	const rows = lines.map((l) => stripAnsi(l).trim());
+	return rows.some((r) => r.includes("Reloading keybindings")) && rows.every((r) => r === "" || /^[─-]+$/.test(r) || RELOAD_TEXT.includes(r));
 }
 const RELOAD_BOX_KEY = Symbol.for("pi-arnative.reloadBoxHidden");
 if (UserMessageComponent?.prototype && !(globalThis as Record<symbol, boolean>)[RELOAD_BOX_KEY]) {
@@ -134,8 +141,8 @@ if (TuiAltScreen?.prototype && !(globalThis as Record<symbol, boolean>)[SELECTIO
 	if (typeof origHighlight === "function") {
 		TuiAltScreen.prototype.applySelectionHighlight = function (text: string): string {
 			const highlighted = origHighlight.call(this, text);
-			const fgOpen = ansiFgOpen(activeThemeProxy);
-			const bgOpen = ansiBgOpen(activeThemeProxy, "selectedBg");
+			const fgOpen = ansiFgOpen(activeTheme());
+			const bgOpen = ansiBgOpen(activeTheme(), "selectedBg");
 			return fgOpen && bgOpen ? recolorSelection(highlighted, fgOpen, bgOpen) : highlighted;
 		};
 	}
@@ -154,7 +161,7 @@ if (TuiAltScreen?.prototype && !(globalThis as Record<symbol, boolean>)[PILL_KEY
 			layout: unknown,
 			width: number,
 		) {
-			return withAccentPill(this, () => origComposite.call(this, screen, layout, width), activeThemeProxy);
+			return withAccentPill(this, () => origComposite.call(this, screen, layout, width), activeTheme());
 		};
 	}
 }
@@ -183,7 +190,7 @@ if (ExtensionSelectorComponent?.prototype && !(globalThis as Record<symbol, bool
 	};
 	const origUpdateList = proto.updateList;
 	proto.updateList = function (this: typeof proto) {
-		const th = activeThemeProxy;
+		const th = activeTheme();
 		if (!th) return origUpdateList.call(this); // no theme yet -> pi's default
 		this.listContainer.clear();
 		for (let i = 0; i < this.options.length; i++) {
@@ -199,7 +206,8 @@ if (ExtensionSelectorComponent?.prototype && !(globalThis as Record<symbol, bool
 export default function uiRenderTweaks(pi: ExtensionAPI) {
 	// The active theme is re-read per session (ctx.ui.theme); render reads it lazily.
 	pi.on("session_start", async (_event, ctx) => {
-		activeThemeProxy = themeOf<typeof activeThemeProxy>(ctx) ?? activeThemeProxy;
+		const th = themeOf<Exclude<ActiveTheme, null>>(ctx);
+		if (th) setActiveTheme(th);
 	});
 
 	// 4. `pi-jev-eye-review` contract message: use our own border box.
@@ -217,9 +225,9 @@ export default function uiRenderTweaks(pi: ExtensionAPI) {
 // body text is unchanged.
 export class PackageUpdateBoxComponent implements Component {
 	private packages: string[];
-	private th: { fg(c: string, t: string): string };
+	private th: { fg(c: string, t: string): string } | null;
 
-	constructor(packages: string[], th: { fg(c: string, t: string): string }) {
+	constructor(packages: string[], th: { fg(c: string, t: string): string } | null) {
 		this.packages = packages;
 		this.th = th;
 	}
@@ -228,10 +236,11 @@ export class PackageUpdateBoxComponent implements Component {
 
 	render(width: number): string[] {
 		const th = this.th;
+		const fg = (color: string, text: string) => (th ? th.fg(color, text) : text);
 		const rows = [
-			th.fg("warning", "\x1b[1m\uf449  Package Updates Available\x1b[22m"),
-			`${th.fg("muted", "Package updates are available. Run ")}${th.fg("accent", "pi update --extensions")}`,
-			th.fg("muted", "Packages:"),
+			fg("warning", "\x1b[1m\uf449  Package Updates Available\x1b[22m"),
+			`${fg("muted", "Package updates are available. Run ")}${fg("accent", "pi update --extensions")}`,
+			fg("muted", "Packages:"),
 			...this.packages.map((pkg) => `- ${pkg}`),
 		];
 		return renderBoxLines(th, width, rows, undefined, "warning");
@@ -250,7 +259,7 @@ if (InteractiveMode?.prototype && !(globalThis as Record<symbol, boolean>)[PACKA
 			ui: { requestRender(): void };
 		};
 		self.chatContainer.addChild(new Spacer(1));
-		self.chatContainer.addChild(new PackageUpdateBoxComponent(packages, activeThemeProxy ?? Theme));
+		self.chatContainer.addChild(new PackageUpdateBoxComponent(packages, activeTheme()));
 		self.ui.requestRender();
 	};
 }
@@ -326,7 +335,7 @@ if (CompactionSummaryMessageComponent?.prototype && !(globalThis as Record<symbo
 	const proto = CompactionSummaryMessageComponent.prototype as any;
 	const origUpdateDisplay = proto.updateDisplay;
 	proto.updateDisplay = function (): void {
-		const th = activeThemeProxy;
+		const th = activeTheme();
 		if (!th) return origUpdateDisplay.call(this);
 		const message = this.message as { tokensBefore?: number; summary?: string } | undefined;
 		const tokenStr = Number(message?.tokensBefore ?? 0).toLocaleString();
@@ -360,7 +369,9 @@ if (CompactionSummaryMessageComponent?.prototype && !(globalThis as Record<symbo
 // Self-check: `node extensions/ui-render-tweaks.ts`
 if (isMain(import.meta.url)) {
 	// reload box fully hidden (not line by line)
-	assert(shouldHideReloadBox(["╭──╮", "│ Reloading keybindings, extensions, skills... │"]) === true, "reload box detected");
+	assert(shouldHideReloadBox(["────", "", " Reloading keybindings, extensions, skills, prompts, themes, and context files... ", "", "────"]) === true, "reload box detected");
+	assert(shouldHideReloadBox(["────", "", " Reloading keybindings, extensions,", " skills, prompts, themes, and context files...", "", "────"]) === true, "wrapped reload box detected");
+	assert(shouldHideReloadBox(["hello", "the log says Reloading keybindings", "world"]) === false, "chat lines that mention the phrase stay visible");
 	assert(shouldHideReloadBox(["hello", "world"]) === false, "normal lines pass through");
 
 	// selection: reverse video replaced with explicit colors (bg selectedBg + fg text)

package/extensions/usage.ts

@@ -4,8 +4,8 @@
  * shared with the Model tab.
  */
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { existsSync, readFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { matchesKey, truncateToWidth, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
 import { boxEdge, boxRow } from "../lib/box.ts";
@@ -285,25 +285,67 @@ if (isMain(import.meta.url)) {
 	assert(formatTokens(9_999) === "10k", "formatTokens strips a .0 k tail");
 	assert(formatCost(999.996) === "$1.0k", "formatCost rolls over at $1000");
 
-	const summary = collectUsageSummary();
-	assert(summary.providers.length > 0, "collectUsageSummary detects providers");
-	assert(summary.totals.sessions > 0, "collectUsageSummary detects total sessions");
-	assert(summary.totals.msgs > 0, "collectUsageSummary detects total msgs");
-	assert(summary.totals.cost >= 0, "collectUsageSummary counts cost");
+	// Fixture agent dir: the real history (and cache) must not decide pass/fail.
+	const fixture = mkdtempSync(join(tmpdir(), "arnative-usage-"));
+	process.env.PI_CODING_AGENT_DIR = fixture;
+	mkdirSync(join(fixture, "sessions", "proj"), { recursive: true });
+	const asst = (model: string, input: number) => JSON.stringify({ message: { role: "assistant", provider: "google", model, usage: { input, output: 5, cacheRead: 1, cost: { total: 0.02 } } } });
+	writeFileSync(
+		join(fixture, "sessions", "proj", "a.jsonl"),
+		[JSON.stringify({ message: { role: "user", content: "hi" } }), asst("gemini-3.8-flash", 100), asst("gemini-3.8-flash", 50), asst("other-model", 7)].join(String.fromCharCode(10)),
+	);
+
+	const summary = collectUsageSummary(true);
+	assert(summary.providers.length === 1, "collectUsageSummary detects providers");
+	assert(summary.totals.sessions === 1, "collectUsageSummary detects total sessions");
+	assert(summary.totals.msgs === 3, "collectUsageSummary counts assistant messages only");
+	assert(Math.abs(summary.totals.cost - 0.06) < 1e-9, "collectUsageSummary counts cost");
 
 	const modelUsage = getModelAllTimeUsage("gemini-3.8-flash");
-	assert(modelUsage.input > 0, "getModelAllTimeUsage reads input tokens for gemini-3.8-flash");
+	assert(modelUsage.input === 150 && modelUsage.output === 10 && modelUsage.cacheRead === 2, "getModelAllTimeUsage sums one model across messages");
 	assert(
 		getModelAllTimeUsage(undefined).input === 0 && getModelAllTimeUsage(undefined).output === 0,
 		"getModelAllTimeUsage without a model id matches nothing (no grand total)",
 	);
 
+	// A session file that grows is parsed from the tail only (byte offset in the cache), not re-read.
+	const file = join(fixture, "sessions", "proj", "a.jsonl");
+	const cachedBefore = JSON.parse(readFileSync(join(fixture, "arnative-usage-cache.json"), "utf8")) as Record<string, { consumed: number; size: number }>;
+	assert(cachedBefore[file]!.consumed === cachedBefore[file]!.size, "cache records the full parsed offset");
+	writeFileSync(file, asst("gemini-3.8-flash", 1000) + String.fromCharCode(10), { flag: "a" });
+	const grown = collectUsageSummary(true);
+	assert(grown.totals.msgs === 4, "an appended record is picked up from the tail");
+	assert(
+		getModelAllTimeUsage("gemini-3.8-flash").input === 1150,
+		"the appended record adds to the existing totals (no duplicate, no drop)",
+	);
+
+	// The per-file rollup is what makes a refresh cheap: folding a tail must reproduce the same
+	// totals as parsing the whole file from scratch. Compare the incremental answer to a cold one.
+	const incremental = JSON.stringify(getModelAllTimeUsage("gemini-3.8-flash"));
+	const cacheRaw = JSON.parse(readFileSync(join(fixture, "arnative-usage-cache.json"), "utf8")) as Record<string, unknown>;
+	// Drop the cache (as a fresh machine, or a version bump, would) and rescan the whole file.
+	writeFileSync(join(fixture, "arnative-usage-cache.json"), "{}", "utf8");
+	collectUsageSummary(true);
+	assert(
+		JSON.stringify(getModelAllTimeUsage("gemini-3.8-flash")) === incremental,
+		"an incremental tail fold equals a full cold parse of the same file",
+	);
+	assert(Object.keys(cacheRaw).length === 1, "one session file produces exactly one cache entry");
+
+	// A half-written trailing record must not be counted, then must appear once completed in place.
+	const pending = asst("other-model", 5);
+	writeFileSync(file, pending.slice(0, 40), { flag: "a" });
+	assert(collectUsageSummary(true).totals.msgs === 4, "a half-written trailing record is not counted");
+	writeFileSync(file, pending.slice(40) + String.fromCharCode(10), { flag: "a" });
+	assert(collectUsageSummary(true).totals.msgs === 5, "the record is counted once the write completes");
+
 	// Disk cache pruning: no cache key may point at a session file that is gone.
-	const cacheFile = join(getAgentDir(), "arnative-usage-cache.json");
-	if (existsSync(cacheFile)) {
-		const raw = JSON.parse(readFileSync(cacheFile, "utf8")) as Record<string, unknown>;
-		assert(Object.keys(raw).every((k) => existsSync(k)), "usage disk cache prunes deleted session files");
-	}
+	rmSync(join(fixture, "sessions", "proj", "a.jsonl"));
+	collectUsageSummary(true);
+	const raw = JSON.parse(readFileSync(join(fixture, "arnative-usage-cache.json"), "utf8")) as Record<string, unknown>;
+	assert(Object.keys(raw).length === 0, "usage disk cache prunes deleted session files");
+	rmSync(fixture, { recursive: true, force: true });
 
 	const fakeTheme = {
 		fg: (_c: string, t: string) => `\x1b[38;2;100;100;100m${t}\x1b[39m`,

package/lib/ansi.ts

@@ -25,6 +25,19 @@ export function themeOf<T>(ctx: unknown): T | null {
 	return (ctx as { ui?: { theme?: T } } | null | undefined)?.ui?.theme ?? null;
 }
 
+// Shared active-theme slot. `/reload` re-imports an extension's modules, so two copies
+// can coexist: one carries the session_start handler, the other owns a stacked UI patch.
+// globalThis gives both the same theme, so the patched copy paints instead of drawing
+// uncolored (or, before the null-guard fix, crashing). Set from `session_start`.
+const THEME_PROXY_KEY = Symbol.for("pi-arnative.activeThemeProxy");
+export function getActiveTheme<T>(): T | null {
+	return (globalThis as Record<symbol, T>)[THEME_PROXY_KEY] ?? null;
+}
+export function setActiveTheme<T>(th: T | null): void {
+	if (th) (globalThis as Record<symbol, T>)[THEME_PROXY_KEY] = th;
+	else delete (globalThis as Record<symbol, T>)[THEME_PROXY_KEY];
+}
+
 /** Painter for the `accentSoft` token, which only arnative themes define; other themes fall back to accent (probed once). */
 export function accentSoftOf(th: { fg?(c: string, t: string): string } | null): (s: string) => string {
 	const fg = th?.fg?.bind(th);
@@ -46,6 +59,11 @@ if (isMain(import.meta.url)) {
 	assert(themeOf({ ui: { theme: "T" } }) === "T", "themeOf reads ctx.ui.theme");
 	assert(themeOf(null) === null, "themeOf tolerates a missing ctx");
 
+	setActiveTheme({ fg: (c, t) => `<${c}>${t}</${c}>` });
+	assert(getActiveTheme<object>() !== null, "active theme round-trips through globalThis");
+	setActiveTheme(null);
+	assert(getActiveTheme<object>() === null, "clearing the active theme leaves no stale slot");
+
 	const tag = { fg: (c: string, t: string) => `<${c}>${t}</${c}>` };
 	assert(accentSoftOf(tag)("x") === "<accentSoft>x</accentSoft>", "accentSoftOf uses accentSoft when the theme defines it");
 	const noSoft = {

package/lib/box.ts

@@ -7,7 +7,7 @@ import { visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { assert, isMain } from "./check.ts";
 
 export type BoxTheme = { fg(color: string, text: string): string; bg?(color: string, text: string): string };
-export type Dim = (s: string) => string;
+type Dim = (s: string) => string;
 
 export const boxEdge = (l: string, r: string, width: number, dim: Dim): string =>
 	dim(`${l}${"─".repeat(Math.max(0, width - 2))}${r}`);
@@ -23,18 +23,21 @@ const applyBg = (line: string, width: number, bgFn: (text: string) => string): s
 	return bgFn(line + " ".repeat(pad));
 };
 
-/** Wrap `rows` (plain or ANSI-colored) into a box. `bgType` = theme bg name (no-op when the theme has no `bg`); `borderColor` = border color. */
-export function renderBoxLines(theme: BoxTheme, width: number, rows: string[], bgType?: string, borderColor = "dim"): string[] {
-	const dim = (s: string) => theme.fg(borderColor, s);
+/** Wrap `rows` (plain or ANSI-colored) into a box. `bgType` = theme bg name (no-op when the theme has no `bg`); `borderColor` = border color.
+ *  `theme` may be null: a box is patched in at module load, before `session_start`
+ *  delivers the active theme. An uncolored box for that first frame beats a null
+ *  deref that kills the process. */
+export function renderBoxLines(theme: BoxTheme | null, width: number, rows: string[], bgType?: string, borderColor = "dim"): string[] {
+	const dim = (s: string) => (theme ? theme.fg(borderColor, s) : s);
 	const inner = Math.max(8, width - 4);
 	const lines = [boxEdge("╭", "╮", width, dim)];
 	for (const row of rows) {
 		for (const line of wrapTextWithAnsi(row, inner)) lines.push(boxRow(line, width, dim));
 	}
 	lines.push(boxEdge("╰", "╯", width, dim));
-	if (bgType && theme.bg) {
+	if (bgType && theme?.bg) {
 		try {
-			return lines.map((l) => applyBg(l, width, (s) => theme.bg!(bgType, s)));
+			return lines.map((l) => applyBg(l, width, (s) => theme!.bg!(bgType, s)));
 		} catch {
 			return lines;
 		}
@@ -50,5 +53,8 @@ if (isMain(import.meta.url)) {
 	assert(plain[1] === "│ hello                │", "content line padded flush");
 	assert(renderBoxLines(th, 24, ["x".repeat(40)]).length === 4, "long line wrapped");
 	assert(renderBoxLines(th, 20, ["hi"], "customMessageBg").length === 3, "bg ignored when the theme has no bg");
+	const nullTheme = renderBoxLines(null, 24, ["hello"], "customMessageBg");
+	assert(nullTheme.every((l) => visibleWidth(l) === 24), "null theme renders an uncolored box instead of throwing");
+	assert(nullTheme[0]!.startsWith("╭") && nullTheme[1] === "│ hello                │", "null-theme frame and padding intact");
 	console.log("lib/box.ts OK");
 }

package/lib/check.ts

@@ -1,5 +1,6 @@
 // Self-check helpers shared by every module's `node <file>` block.
 // Lives outside `extensions/*.ts` so pi never loads it as an extension.
+import { pathToFileURL } from "node:url";
 export function assert(cond: boolean, msg: string): asserts cond {
 	if (!cond) {
 		console.error(`FAIL: ${msg}`);
@@ -8,5 +9,13 @@ export function assert(cond: boolean, msg: string): asserts cond {
 }
 
 export function isMain(url: string): boolean {
-	return Boolean(process.argv[1] && url.endsWith(process.argv[1].split("\\").join("/")));
+	const argv = process.argv[1];
+	if (!argv) return false;
+	// Compare canonical file URLs: string `endsWith` broke on paths with spaces or
+	// other characters that `import.meta.url` percent-encodes, silently skipping the check.
+	try {
+		return pathToFileURL(argv).href === url;
+	} catch {
+		return url.endsWith(argv.split("\\").join("/"));
+	}
 }

package/lib/preset-store.ts

@@ -0,0 +1,92 @@
+/**
+ * Persist the small UI choices made through `/arnative` (header and footer preset).
+ *
+ * Why a sidecar and not `settings.json`: pi owns that file through its live `SettingsManager`
+ * (queued writes, atomic replace, field-level merge) and exposes no write API to extensions, so
+ * editing it directly would race the manager and could drop concurrent changes. The choices here
+ * belong to this package, not to pi.
+ *
+ * The file is read once per process and merged on write, so two extensions writing different
+ * keys cannot clobber each other.
+ */
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { assert, isMain } from "./check.ts";
+
+export const HEADER_PRESET_KEY = "headerPreset";
+export const FOOTER_PRESET_KEY = "footerPreset";
+
+// Resolved per call, not at import: the self-check points getAgentDir() at a fixture dir.
+const configPath = (): string => join(getAgentDir(), "arnative-config.json");
+
+let memo: Record<string, unknown> | null = null;
+
+function readConfig(): Record<string, unknown> {
+	if (memo) return memo;
+	memo = {};
+	try {
+		if (existsSync(configPath())) {
+			const raw = JSON.parse(readFileSync(configPath(), "utf8")) as unknown;
+			if (raw && typeof raw === "object" && !Array.isArray(raw)) memo = raw as Record<string, unknown>;
+		}
+	} catch {
+		// unreadable/corrupt: fall back to defaults rather than crash the header
+	}
+	return memo;
+}
+
+/** The stored value for `key`, or undefined when absent or not one of `allowed`. */
+export function loadChoice<T extends string>(key: string, allowed: readonly T[]): T | undefined {
+	const value = readConfig()[key];
+	return typeof value === "string" && (allowed as readonly string[]).includes(value) ? (value as T) : undefined;
+}
+
+/** Store a choice. Best effort: an unwritable agent dir must not break the TUI. */
+export function saveChoice(key: string, value: string): void {
+	const current = readConfig();
+	if (current[key] === value) return;
+	current[key] = value;
+	try {
+		const dir = dirname(configPath());
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileSync(configPath(), `${JSON.stringify(current, null, 2)}\n`, "utf8");
+	} catch {
+		// ignore: the choice still applies for this session
+	}
+}
+
+/** Drop the in-memory copy so the next read hits disk (a restart, in a test). */
+export function resetPresetCache(): void {
+	memo = null;
+}
+
+// Self-check: `node lib/preset-store.ts`
+if (isMain(import.meta.url)) {
+	// The real agent dir must not decide pass/fail, and the test must not touch it.
+	const fixture = mkdtempSync(join(tmpdir(), "arnative-preset-"));
+	process.env.PI_CODING_AGENT_DIR = fixture;
+
+	assert(loadChoice(HEADER_PRESET_KEY, ["a", "b"] as const) === undefined, "absent key reads as undefined");
+	saveChoice(HEADER_PRESET_KEY, "b");
+	saveChoice(FOOTER_PRESET_KEY, "a");
+	assert(loadChoice(HEADER_PRESET_KEY, ["a", "b"] as const) === "b", "a saved choice reads back");
+	assert(loadChoice(FOOTER_PRESET_KEY, ["a", "b"] as const) === "a", "a second key is stored without clobbering the first");
+
+	// The point of the file: the choice outlives the process (drop the in-memory copy).
+	resetPresetCache();
+	assert(loadChoice(HEADER_PRESET_KEY, ["a", "b"] as const) === "b", "the choice survives a restart (read from disk)");
+
+	// A value no longer in the allowed set (renamed preset) falls back instead of breaking.
+	saveChoice(HEADER_PRESET_KEY, "gone");
+	assert(loadChoice(HEADER_PRESET_KEY, ["a", "b"] as const) === undefined, "an unknown stored value is rejected");
+
+	// A corrupt file must not throw on the header's render path.
+	writeFileSync(join(fixture, "arnative-config.json"), "{not json", "utf8");
+	resetPresetCache();
+	assert(loadChoice(HEADER_PRESET_KEY, ["a", "b"] as const) === undefined, "a corrupt config file reads as empty");
+
+	rmSync(fixture, { recursive: true, force: true });
+	console.log("preset-store.ts self-check OK");
+}