@underactive/pi-topping-statusline 0.2.7 → 0.3.0

package/src/tests/settings-menu.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Host-level smoke for /topping-statusline-settings: the command mounts the
+ * shared menu from @underactive/pi-topping-primitives through ctx.ui.custom,
+ * applying persists the draft and cancelling leaves everything alone. The menu's
+ * own behaviour is covered by the package's menu-*.test.ts suites; only the
+ * component's public surface (handleInput, render, snapshot) is used here.
+ */
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { Component, KeybindingsManager, TUI } from "@earendil-works/pi-tui";
+import { MenuComponent } from "@underactive/pi-topping-primitives/menu";
+import { SegmentContextBuilder } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
+import { registerSettingsCommand } from "../settings-menu.ts";
+import { createSettingsState, DEFAULT_FEEDS, settingsPath } from "../settings.ts";
+
+const KEY = { up: "\x1b[A", down: "\x1b[B", right: "\x1b[C", space: " ", enter: "\r", escape: "\x1b" } as const;
+
+const theme = {
+	fg: (_color: string, text: string) => text,
+	bg: (_color: string, text: string) => text,
+	bold: (text: string) => text,
+	getBgAnsi: () => "",
+} as unknown as Theme;
+
+type CommandHandler = (args: string, ctx: ExtensionCommandContext) => Promise<void> | void;
+type OverlayFactory = (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (result: unknown) => void) => Component;
+
+interface Host {
+	handler: CommandHandler;
+	ctx: ExtensionCommandContext;
+	/** The component the command mounted, once it has. */
+	mounted: () => MenuComponent;
+	overlayOptions: () => unknown;
+	notices: string[];
+	changes: () => number;
+	settings: () => ReturnType<typeof createSettingsState>["settings"];
+	dispose: () => void;
+}
+
+/** Register the real command against fakes and expose what the command mounts. */
+function host(): Host {
+	const commands = new Map<string, CommandHandler>();
+	const fakePi = {
+		registerCommand: (name: string, options: { handler: CommandHandler }) => commands.set(name, options.handler),
+		exec: async () => undefined,
+		getThinkingLevel: () => "off",
+	} as unknown as ExtensionAPI;
+	const state = createSettingsState();
+	const builder = new SegmentContextBuilder(fakePi);
+	let changes = 0;
+	registerSettingsCommand(fakePi, state, builder, () => changes++);
+	const handler = commands.get("topping-statusline-settings");
+	assert.ok(handler, "the command must be registered");
+
+	let mounted: Component | undefined;
+	let overlayOptions: unknown;
+	const notices: string[] = [];
+	const tui = { terminal: { rows: 40, columns: 100 }, requestRender: () => {} } as unknown as TUI;
+	const ctx = {
+		mode: "tui",
+		ui: {
+			theme,
+			notify: (message: string) => notices.push(message),
+			custom: (factory: OverlayFactory, options: unknown) =>
+				new Promise(resolve => {
+					overlayOptions = options;
+					mounted = factory(tui, theme, {} as KeybindingsManager, resolve);
+				}),
+		},
+	} as unknown as ExtensionCommandContext;
+
+	return {
+		handler,
+		ctx,
+		mounted: () => {
+			assert.ok(mounted instanceof MenuComponent, "the command must mount the shared MenuComponent");
+			return mounted;
+		},
+		overlayOptions: () => overlayOptions,
+		notices,
+		changes: () => changes,
+		settings: () => state.settings,
+		dispose: () => builder.dispose(),
+	};
+}
+
+function withTempAgentDir<T>(run: (dir: string) => Promise<T>): Promise<T> {
+	const dir = mkdtempSync(join(tmpdir(), "statusline-menu-"));
+	const previous = process.env.PI_CODING_AGENT_DIR;
+	process.env.PI_CODING_AGENT_DIR = dir;
+	return run(dir).finally(() => {
+		if (previous === undefined) delete process.env.PI_CODING_AGENT_DIR;
+		else process.env.PI_CODING_AGENT_DIR = previous;
+		rmSync(dir, { recursive: true, force: true });
+	});
+}
+
+const plain = (menu: MenuComponent, width = 80) => menu.render(width).map(stripAnsi);
+const typeText = (menu: MenuComponent, text: string) => {
+	for (const ch of text) menu.handleInput(ch);
+};
+
+test("the settings command mounts the shared menu; adding a feed and applying saves it", () =>
+	withTempAgentDir(async () => {
+		const h = host();
+		try {
+			const run = h.handler("", h.ctx);
+			const menu = h.mounted();
+			assert.deepEqual(h.overlayOptions(), { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%" } });
+
+			const frame = plain(menu);
+			assert.match(frame[0] ?? "", /Pi Topping Statusline: Settings/);
+			assert.ok(frame.some(line => line.includes("─ Preview ")), "the live preview section is present");
+			assert.ok(frame.some(line => /❯ \[■\] Transparent Segments\s+ON/.test(line)), "the selected row carries the ❯ marker");
+			assert.ok(!frame.some(line => /^║\s+> /.test(line)), "the old > marker is gone");
+			assert.ok(frame.some(line => line.includes("⏎ apply/edit")), "the command's own hints are shown");
+
+			// Up/down stop at the ends, so overshooting lands on the last row: "+ add feed".
+			const rows = menu.snapshot().rowCount;
+			for (let i = 0; i < rows; i++) menu.handleInput(KEY.down);
+			assert.equal(menu.snapshot().cursorId, "feed.add");
+			menu.handleInput(KEY.enter);
+			assert.equal(menu.snapshot().rowCount, rows + 5, "one feed is five rows");
+			assert.equal(menu.snapshot().cursorId, "feed.add", "the cursor keeps its row across the rebuild");
+
+			for (let i = 0; i < 5; i++) menu.handleInput(KEY.up);
+			assert.equal(menu.snapshot().cursorId, "feed.0.customType");
+			menu.handleInput(KEY.enter);
+			typeText(menu, "my-ext/tokens");
+			menu.handleInput(KEY.enter);
+			menu.handleInput(KEY.down);
+			assert.equal(menu.snapshot().cursorId, "feed.0.field");
+			menu.handleInput(KEY.enter);
+			typeText(menu, "count");
+			menu.handleInput(KEY.enter);
+			menu.handleInput(KEY.down);
+			menu.handleInput(KEY.down);
+			assert.equal(menu.snapshot().cursorId, "feed.0.format");
+			menu.handleInput(KEY.right); // currency -> number
+			assert.ok(plain(menu).some(line => line.includes("my-ext/tokens")), "the committed text shows in the row");
+
+			// Enter on a cycle row applies the whole menu (the menu has no buttons).
+			menu.handleInput(KEY.enter);
+			await run;
+
+			const added = { customType: "my-ext/tokens", field: "count", prefix: "", format: "number" };
+			assert.equal(h.changes(), 1);
+			assert.deepEqual(h.settings().feeds, [...DEFAULT_FEEDS, added]);
+			assert.deepEqual(JSON.parse(readFileSync(settingsPath(), "utf8")).feeds, [...DEFAULT_FEEDS, added]);
+			assert.deepEqual(h.notices, []);
+		} finally {
+			h.dispose();
+		}
+	}));
+
+test("escape resolves the command without applying the edited draft", () =>
+	withTempAgentDir(async () => {
+		const h = host();
+		try {
+			const run = h.handler("", h.ctx);
+			const menu = h.mounted();
+			menu.handleInput(KEY.space);
+			assert.equal(menu.snapshot().values.transparent, false, "the draft differs from the saved settings");
+			menu.handleInput(KEY.escape);
+			await run;
+
+			assert.equal(h.changes(), 0);
+			assert.deepEqual(h.settings(), {}, "cancelling leaves the loaded settings untouched");
+			assert.equal(existsSync(settingsPath()), false, "nothing is written on cancel");
+			assert.deepEqual(h.notices, []);
+		} finally {
+			h.dispose();
+		}
+	}));

package/src/tests/settings.test.ts

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { loadSettings, saveSettings, settingsPath } from "../settings.ts";
+
+function withAgentDir(run: (dir: string) => void): void {
+	const dir = mkdtempSync(join(tmpdir(), "statusline-settings-"));
+	const previous = process.env.PI_CODING_AGENT_DIR;
+	process.env.PI_CODING_AGENT_DIR = dir;
+	try {
+		run(dir);
+	} finally {
+		if (previous === undefined) delete process.env.PI_CODING_AGENT_DIR;
+		else process.env.PI_CODING_AGENT_DIR = previous;
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
+test("the settings path follows PI_CODING_AGENT_DIR changes made after import", () => {
+	withAgentDir((first) => {
+		assert.equal(settingsPath(), join(first, "pi-topping-statusline", "settings.json"));
+		withAgentDir((second) => {
+			assert.equal(settingsPath(), join(second, "pi-topping-statusline", "settings.json"));
+			assert.equal(saveSettings({ transparent: true }).ok, true);
+			assert.equal(loadSettings().transparent, true);
+		});
+	});
+});
+
+test("saveSettings writes tab-indented JSON with a trailing newline, mode 0600", () => {
+	withAgentDir(() => {
+		assert.equal(saveSettings({ transparent: true, separator: "pipe" }).ok, true);
+		assert.equal(readFileSync(settingsPath(), "utf8"), '{\n\t"transparent": true,\n\t"separator": "pipe"\n}\n');
+		assert.equal(statSync(settingsPath()).mode & 0o777, 0o600);
+	});
+});
+
+test("saveSettings reports a failure instead of throwing", () => {
+	withAgentDir((dir) => {
+		writeFileSync(join(dir, "pi-topping-statusline"), "a file where the directory belongs");
+		const result = saveSettings({ transparent: true });
+		assert.equal(result.ok, false);
+	});
+});
+
+test("loadSettings ignores a corrupt or non-object file", () => {
+	withAgentDir(() => {
+		mkdirSync(join(settingsPath(), ".."), { recursive: true });
+		writeFileSync(settingsPath(), "[1,2]");
+		assert.deepEqual(loadSettings(), {});
+		writeFileSync(settingsPath(), "{nope");
+		assert.deepEqual(loadSettings(), {});
+	});
+});

package/src/tests/token-rate.test.ts

@@ -27,7 +27,7 @@ builder.attach(fakeCtx);
 const BASE = builder.build(
 	80,
 	resolveEffectiveSettings({}).segmentOptions,
-	{ git: false, pr: false, piStats: false, tokenRate: true, feeds: [] },
+	{ git: false, pr: false, piStats: false, tokenRate: true, cacheHit: false, feeds: [] },
 	undefined,
 );
 

package/src/tests/working-status.test.ts

@@ -1,8 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { WORKING_STATUS_SLIDE_MS } from "@underactive/pi-topping-primitives/contracts";
 import {
 	STATUS_HOLD_MS,
-	STATUS_SLIDE_MS,
 	type StatusIndicatorKind,
 	StatusTransition,
 	WORKING_FADE_MS,
@@ -10,7 +10,7 @@ import {
 
 /** Show a status early enough that its slide-out has finished by `at`. */
 function settle(transition: StatusTransition, status: string, kind: StatusIndicatorKind | undefined, at: number): void {
-	transition.resolve(status, kind, at - STATUS_SLIDE_MS);
+	transition.resolve(status, kind, at - WORKING_STATUS_SLIDE_MS);
 	transition.resolve(status, kind, at);
 }
 
@@ -24,24 +24,24 @@ test("a status appearing over the user's segments slides out, then settles verba
 		pending: true,
 	});
 	// Spinner frames change the text mid-slide without restarting it.
-	const early = transition.resolve("⠹ Working", "working", 1_000 + STATUS_SLIDE_MS / 4).reveal ?? -1;
-	const late = transition.resolve("⠸ Working", "working", 1_000 + (STATUS_SLIDE_MS * 3) / 4).reveal ?? -1;
+	const early = transition.resolve("⠹ Working", "working", 1_000 + WORKING_STATUS_SLIDE_MS / 4).reveal ?? -1;
+	const late = transition.resolve("⠸ Working", "working", 1_000 + (WORKING_STATUS_SLIDE_MS * 3) / 4).reveal ?? -1;
 	assert.ok(0 < early && early < late && late < 1, "reveal grows monotonically");
-	assert.equal(transition.pending(1_000 + STATUS_SLIDE_MS - 1), true);
+	assert.equal(transition.pending(1_000 + WORKING_STATUS_SLIDE_MS - 1), true);
 
-	assert.deepEqual(transition.resolve("⠼ Working", "working", 1_000 + STATUS_SLIDE_MS), {
+	assert.deepEqual(transition.resolve("⠼ Working", "working", 1_000 + WORKING_STATUS_SLIDE_MS), {
 		status: "⠼ Working",
 		kind: "working",
 		pending: false,
 	});
-	assert.equal(transition.pending(1_000 + STATUS_SLIDE_MS), false);
+	assert.equal(transition.pending(1_000 + WORKING_STATUS_SLIDE_MS), false);
 });
 
 test("a status cleared mid-slide keeps sliding through its hold", () => {
 	const transition = new StatusTransition();
 	transition.resolve("⠙ Working", "working", 0);
 
-	const clearedAt = STATUS_SLIDE_MS / 4;
+	const clearedAt = WORKING_STATUS_SLIDE_MS / 4;
 	const cleared = transition.resolve(undefined, undefined, clearedAt);
 	const held = transition.resolve(undefined, undefined, clearedAt + STATUS_HOLD_MS / 2);
 	assert.equal(held.status, "⠙ Working");

package/src/tests/working.test.ts

@@ -14,7 +14,7 @@ import { buildStatusLine } from "../layout.ts";
 import { SEGMENTS } from "../segments.ts";
 import { getSeparator } from "../separators.ts";
 import { resolveEffectiveSettings, topLeftSegments } from "../settings.ts";
-import { easeFade, theme } from "../theme.ts";
+import { theme } from "../theme.ts";
 import type { SegmentContext, StatusLineSegmentId } from "../types.ts";
 
 const noGap = (s: string) => s;
@@ -207,12 +207,6 @@ test("fadeAnsi leaves text untouched at full opacity and sinks colors into the b
 	);
 });
 
-test("easeFade is monotonic and pinned at both ends", () => {
-	assert.equal(easeFade(0), 0);
-	assert.equal(easeFade(1), 1);
-	assert.ok(easeFade(0.25) < easeFade(0.5) && easeFade(0.5) < easeFade(0.75));
-});
-
 test("leftFade recolors the working status but not pi or model details", () => {
 	const status = "\x1b[38;2;10;200;30m⠙ Working\x1b[39m";
 	const ctx = ctxWith(status);

package/src/theme.ts

@@ -8,20 +8,22 @@
  * embedded here. Values are hex strings (truecolor), 256-palette indices
  * (numbers), or "" for the terminal default color.
  */
-import { getTerminalColorMode } from "@earendil-works/pi-tui";
+import { getTerminalColorMode, type TerminalColorMode } from "@earendil-works/pi-tui";
+import { easeFade, FADE_SHADE_COUNT } from "@underactive/pi-topping-primitives/activity";
+import {
+	channelsToFgAnsi,
+	fadeRgbToward,
+	hexToFgAnsi as sharedHexToFgAnsi,
+	parseHex,
+	xterm256ToRgb,
+} from "@underactive/pi-topping-primitives/color";
+import { ASCII_BOX, BOX_STYLES, type BoxGlyphs, type BoxStyle } from "@underactive/pi-topping-primitives/glyphs";
+
+export type { BoxGlyphs };
 
 export type SymbolPreset = "unicode" | "nerd" | "ascii";
 
-export type BorderStyle = "rounded" | "heavy" | "double" | "single";
-
-export interface BoxGlyphs {
-	topLeft: string;
-	topRight: string;
-	bottomLeft: string;
-	bottomRight: string;
-	horizontal: string;
-	vertical: string;
-}
+export type BorderStyle = BoxStyle;
 
 export interface StatusSymbols {
 	sep: {
@@ -161,16 +163,6 @@ const SYMBOL_PRESETS: Record<SymbolPreset, StatusSymbols> = {
 	ascii: ASCII_SYMBOLS,
 };
 
-const ASCII_BOX: BoxGlyphs = { topLeft: "+", topRight: "+", bottomLeft: "+", bottomRight: "+", horizontal: "-", vertical: "|" };
-
-/** Same glyphs as pi-topping's User Prompt border style. */
-const BOX_STYLES: Record<BorderStyle, BoxGlyphs> = {
-	rounded: { topLeft: "╭", topRight: "╮", bottomLeft: "╰", bottomRight: "╯", horizontal: "─", vertical: "│" },
-	heavy: { topLeft: "┏", topRight: "┓", bottomLeft: "┗", bottomRight: "┛", horizontal: "━", vertical: "┃" },
-	double: { topLeft: "╔", topRight: "╗", bottomLeft: "╚", bottomRight: "╝", horizontal: "═", vertical: "║" },
-	single: { topLeft: "┌", topRight: "┐", bottomLeft: "└", bottomRight: "┘", horizontal: "─", vertical: "│" },
-};
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Palette (OMP dark.json)
 // ═══════════════════════════════════════════════════════════════════════════
@@ -191,6 +183,7 @@ export type StatusColor =
 	| "statusLineGitDirty"
 	| "statusLineContext"
 	| "statusLineContextElevated"
+	| "statusLineCacheHit"
 	| "statusLineStaged"
 	| "statusLineDirty"
 	| "statusLineUntracked"
@@ -212,6 +205,7 @@ const FG_COLORS: Record<StatusColor, ColorValue> = {
 	statusLineGitDirty: "#d7af5f",
 	statusLineContext: "#8787af",
 	statusLineContextElevated: "#e07a1f",
+	statusLineCacheHit: "#7fb069",
 	statusLineStaged: 70,
 	statusLineDirty: 178,
 	statusLineUntracked: 39,
@@ -229,88 +223,32 @@ export const MAJOR_COLOR_HEXES = [
 	"#00afaf",
 ];
 
-export type ColorMode = "truecolor" | "256color";
+export type ColorMode = TerminalColorMode;
 
 /** Defer to pi's cached terminal detection, which honors PI_TRUE_COLOR, terminal.trueColor, and capability overrides. */
 export function detectColorMode(): ColorMode {
 	return getTerminalColorMode();
 }
 
-export function parseHex(hex: string): [number, number, number] | undefined {
-	const match = /^#?([0-9a-f]{6})$/i.exec(hex);
-	if (!match) return undefined;
-	const n = Number.parseInt(match[1], 16);
-	return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
-}
-
-/** Number of discrete, eased shades used for the token-rate and feed fades (pi-topping). */
-export const FADE_SHADE_COUNT = 5;
-
-/** Stand-in for the terminal's default foreground when a fade must recolor it. */
-const DEFAULT_FG_RGB: [number, number, number] = [204, 204, 204];
-
-/** Every SGR color the layout or a segment can emit: truecolor, 256-color, or the default-fg reset. */
-const SGR_COLOR_RE = /\x1b\[(38|48);2;(\d+);(\d+);(\d+)m|\x1b\[(38|48);5;(\d+)m|\x1b\[39m/g;
-
-/** Raised-cosine ease shared by the discrete and continuous fades. */
-export function easeFade(progress: number): number {
-	const clamped = Math.max(0, Math.min(1, progress));
-	return 0.5 * (1 - Math.cos(Math.PI * clamped));
-}
-
-/** Resolve an xterm-256 palette index to RGB (16–231 cube, 232–255 grayscale). */
-function xterm256ToRgb(n: number): [number, number, number] {
-	if (n >= 232) {
-		const v = 8 + (n - 232) * 10;
-		return [v, v, v];
-	}
-	const i = Math.max(0, n - 16);
-	const c = (v: number) => (v === 0 ? 0 : 55 + v * 51);
-	return [c(Math.floor(i / 36) % 6), c(Math.floor(i / 6) % 6), c(i % 6)];
-}
+export { easeFade, FADE_SHADE_COUNT } from "@underactive/pi-topping-primitives/activity";
 
 function colorValueToRgb(color: ColorValue): [number, number, number] {
 	if (typeof color === "number") return xterm256ToRgb(color);
 	return parseHex(color) ?? [0, 0, 0];
 }
 
-function rgbTo256(r: number, g: number, b: number): number {
-	if (r === g && g === b) {
-		if (r < 8) return 16;
-		if (r > 248) return 231;
-		return 232 + Math.round(((r - 8) / 247) * 24);
-	}
-	const scale = (v: number) => Math.round((v / 255) * 5);
-	return 16 + 36 * scale(r) + 6 * scale(g) + scale(b);
-}
-
-export function mixRgb(
-	from: readonly [number, number, number],
-	to: readonly [number, number, number],
-	amount: number,
-): [number, number, number] {
-	const clamped = Math.min(1, Math.max(0, amount));
-	return [
-		Math.round(from[0] + (to[0] - from[0]) * clamped),
-		Math.round(from[1] + (to[1] - from[1]) * clamped),
-		Math.round(from[2] + (to[2] - from[2]) * clamped),
-	];
-}
-
-export function rgbToFgAnsi(r: number, g: number, b: number, mode: ColorMode): string {
-	return mode === "truecolor" ? `\x1b[38;2;${r};${g};${b}m` : `\x1b[38;5;${rgbTo256(r, g, b)}m`;
-}
+/** The bar background as a tuple, resolved once at load: `fadeAnsi` sinks colours toward it on every tick. */
+const STATUS_LINE_BG_RGB = colorValueToRgb(STATUS_LINE_BG);
 
+/** `#rrggbb` as a foreground escape, in the terminal's colour depth unless the caller passes one. */
 export function hexToFgAnsi(hex: string, mode: ColorMode = detectColorMode()): string {
-	const rgb = parseHex(hex);
-	if (!rgb) return "";
-	return rgbToFgAnsi(...rgb, mode);
+	return sharedHexToFgAnsi(hex, mode);
 }
 
 function fgAnsi(color: ColorValue, mode: ColorMode): string {
 	if (color === "") return "\x1b[39m";
 	if (typeof color === "number") return `\x1b[38;5;${color}m`;
-	return hexToFgAnsi(color, mode);
+	return sharedHexToFgAnsi(color, mode);
 }
 
 function bgAnsi(color: ColorValue, mode: ColorMode): string {
@@ -402,7 +340,7 @@ class StatusTheme {
 		const r = Math.round(a[0] * (1 - eased) + b[0] * eased);
 		const g = Math.round(a[1] * (1 - eased) + b[1] * eased);
 		const bl = Math.round(a[2] * (1 - eased) + b[2] * eased);
-		const ansi = rgbToFgAnsi(r, g, bl, this.#currentMode());
+		const ansi = channelsToFgAnsi(r, g, bl, this.#currentMode());
 		return `${ansi}${text}\x1b[39m`;
 	}
 
@@ -417,22 +355,7 @@ class StatusTheme {
 	fadeAnsi(text: string, opacity: number): string {
 		const alpha = Math.max(0, Math.min(1, opacity));
 		if (alpha >= 1) return text;
-		const target = colorValueToRgb(STATUS_LINE_BG);
-		const mode = this.#currentMode();
-		return text.replace(SGR_COLOR_RE, (_m, tcPlane, r, g, b, ixPlane, index) => {
-			let plane = "38";
-			let rgb: [number, number, number] = DEFAULT_FG_RGB;
-			if (tcPlane) {
-				plane = tcPlane;
-				rgb = [Number(r), Number(g), Number(b)];
-			} else if (ixPlane) {
-				plane = ixPlane;
-				rgb = xterm256ToRgb(Number(index));
-			}
-			const mix = (i: number) => Math.round(rgb[i] * alpha + target[i] * (1 - alpha));
-			const fg = rgbToFgAnsi(mix(0), mix(1), mix(2), mode);
-			return plane === "38" ? fg : fg.replace("\x1b[38;", "\x1b[48;");
-		});
+		return fadeRgbToward(text, STATUS_LINE_BG_RGB, alpha, this.#currentMode());
 	}
 }