@quandev104/pi-style 0.2.0 → 0.2.2

package/extension-src/pi-style/app/index.ts

@@ -96,6 +96,7 @@ export interface PiStyleApp {
 	update(
 		values: import("../domain/status.js").StatusSnapshot,
 		kind?: import("./render-scheduler.js").UpdateClass,
+		options?: import("./runtime.js").RuntimeUpdateOptions,
 	): void;
 }
 
@@ -268,10 +269,10 @@ export function createPiStyleApp(
 		sessionShutdown() {
 			runtime.stop();
 		},
-		update(values, kind = "coalesced") {
+		update(values, kind = "coalesced", options) {
 			const active = runtime.current;
 			if (!active) return;
-			active.update(values);
+			if (!active.update(values, options)) return;
 			active.scheduler.schedule(kind);
 		},
 		reload() {

package/extension-src/pi-style/app/runtime.ts

@@ -2,7 +2,7 @@ import type { ExtensionContext, ExtensionUIContext } from "@earendil-works/pi-co
 import { diffConfig } from "../domain/config-diff.js";
 import type { NormalizedPiStyleConfig } from "../domain/config-types.js";
 import type { GitCommandRunner } from "../domain/providers.js";
-import type { StatusSnapshot } from "../domain/status.js";
+import type { ContextSnapshot, StatusSnapshot } from "../domain/status.js";
 import { normalizeThinkingLevel } from "../domain/status.js";
 import { installEditor } from "../features/editor/index.js";
 import {
@@ -18,12 +18,20 @@ import { CachedGitProvider, InMemoryContextProvider, InMemoryUsageProvider } fro
 import { RenderScheduler } from "./render-scheduler.js";
 import { createSnapshot, replaceSnapshot, type UiSnapshot } from "./snapshot.js";
 
+/** Debounce window for coalescing git refresh spawns after invalidateGit(). */
+const GIT_INVALIDATE_DEBOUNCE_MS = 250;
+
 export interface RuntimeInstallationState {
 	readonly status: "installed" | "disabled" | "failed";
 	readonly editor: "installed" | "preserved" | "disabled" | "failed";
 	readonly startup: "installed" | "disabled" | "failed";
 }
 
+export interface RuntimeUpdateOptions {
+	readonly refreshContextUsage?: boolean;
+	readonly refreshExtensionStatuses?: boolean;
+}
+
 export interface PiStyleRuntime {
 	generation: number;
 	readonly providerIdentity: { git: object; context: object; usage: object };
@@ -34,8 +42,8 @@ export interface PiStyleRuntime {
 	snapshot: UiSnapshot;
 	disposables: DisposableStore;
 	scheduler: RenderScheduler;
-	update(values: StatusSnapshot): void;
-	updateStartupResources(resources: StartupResources): void;
+	update(values: StatusSnapshot, options?: RuntimeUpdateOptions): boolean;
+	updateStartupResources(resources: StartupResources): boolean;
 	dismissStartup(): void;
 	invalidateGit(): void;
 	configure(config: NormalizedPiStyleConfig): void;
@@ -64,7 +72,7 @@ export interface RuntimeHost {
 export function createPiStyleRuntime(
 	host: RuntimeHost,
 	generation: number,
-	requestRender: () => void = () => {},
+	requestRender: () => void = host.requestRender ?? (() => {}),
 ): PiStyleRuntime {
 	let disposed = false;
 	const extensionStatuses = (): readonly import("../domain/status.js").ExtensionStatus[] | undefined => {
@@ -76,13 +84,27 @@ export function createPiStyleRuntime(
 			return [];
 		}
 	};
+	const contextSnapshot = (): ContextSnapshot | undefined => {
+		const usage = host.getContextUsage?.();
+		if (!usage) return undefined;
+		return {
+			...(usage.tokens !== null ? { currentTokens: usage.tokens } : {}),
+			windowTokens: usage.contextWindow,
+			...(usage.percent !== null ? { percent: usage.percent } : {}),
+		};
+	};
 	let currentConfig = host.config;
 	const disposables = new DisposableStore();
 	const scheduler = new RenderScheduler({ requestRender }, generation, () => !disposed);
 	const git = new CachedGitProvider(host.gitRunner);
+	// Debounced git refresh (invalidateGit): tool-result bursts fire one
+	// invalidateGit per write/edit/bash, each of which would otherwise spawn a
+	// `git status` process. Only one refresh may be pending at a time; the
+	// handle is unreffed so it can never keep the process alive.
+	let pendingGitRefresh: ReturnType<typeof setTimeout> | undefined;
 	const contextProvider = new InMemoryContextProvider();
 	const usageProvider = new InMemoryUsageProvider();
-	const usage = host.getContextUsage?.();
+	const initialContext = contextSnapshot();
 	const initialStatuses = extensionStatuses();
 	const initialValues = {
 		...(initialStatuses ? { extensionStatuses: initialStatuses } : {}),
@@ -91,15 +113,7 @@ export function createPiStyleRuntime(
 		...(host.model?.reasoning !== undefined ? { reasoning: host.model.reasoning } : {}),
 		...(host.thinkingLevel ? { thinkingLevel: normalizeThinkingLevel(host.thinkingLevel) } : {}),
 		...(host.cwd ? { cwd: host.cwd } : {}),
-		...(usage
-			? {
-					context: {
-						...(usage.tokens !== null ? { currentTokens: usage.tokens } : {}),
-						windowTokens: usage.contextWindow,
-						...(usage.percent !== null ? { percent: usage.percent } : {}),
-					},
-				}
-			: {}),
+		...(initialContext ? { context: initialContext } : {}),
 	};
 	let currentSnapshot = createSnapshot(generation, 0, initialValues);
 	let statusLine: ReturnType<typeof installStatusLine> | undefined;
@@ -110,14 +124,41 @@ export function createPiStyleRuntime(
 		editor: "disabled",
 		startup: "disabled",
 	};
-	const startupSnapshot = (config: NormalizedPiStyleConfig): StartupSnapshot => ({
+	const snapshotValues = (snapshot: UiSnapshot): StatusSnapshot => {
+		const { generation: _generation, revision: _revision, ...values } = snapshot;
+		return values;
+	};
+	const withSnapshotPatch = (
+		patch: Partial<Record<keyof StatusSnapshot, StatusSnapshot[keyof StatusSnapshot] | undefined>>,
+	): StatusSnapshot => {
+		const next = { ...snapshotValues(currentSnapshot) } as Record<string, unknown>;
+		for (const [key, value] of Object.entries(patch)) {
+			if (value === undefined) delete next[key];
+			else next[key] = value;
+		}
+		return next as StatusSnapshot;
+	};
+	const createStartupSnapshot = (
+		config: NormalizedPiStyleConfig,
+		resources: StartupResources | undefined = host.resources,
+	): StartupSnapshot => ({
 		...currentSnapshot,
 		reason: host.startupReason ?? "startup",
 		...(host.provider ? { startupProvider: host.provider } : {}),
 		...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
 		preset: config.preset,
-		...(host.resources ? { resources: host.resources } : {}),
+		...(resources ? { resources } : {}),
 	});
+	const applySnapshot = (nextSnapshot: UiSnapshot): boolean => {
+		if (nextSnapshot === currentSnapshot) return false;
+		currentSnapshot = nextSnapshot;
+		statusLine?.update(currentSnapshot);
+		editor?.update(currentSnapshot);
+		startup?.update(createStartupSnapshot(currentConfig));
+		return true;
+	};
+	const updateSnapshot = (values: StatusSnapshot): boolean =>
+		applySnapshot(replaceSnapshot(currentSnapshot, generation, values));
 	const installStatus = () => {
 		if (!host.hasUI || host.mode !== "tui" || !host.ui || !currentConfig.enabled || !currentConfig.statusLine.enabled) {
 			installationState = { ...installationState, status: "disabled" };
@@ -186,7 +227,7 @@ export function createPiStyleRuntime(
 			startup = installStartup({
 				host: { ...(host.ui as unknown as StartupHost), mode: host.mode, hasUI: host.hasUI },
 				config: currentConfig,
-				snapshot: startupSnapshot(currentConfig),
+				snapshot: createStartupSnapshot(currentConfig),
 				generation,
 				requestRender,
 				timeoutMs: 3000,
@@ -235,27 +276,10 @@ export function createPiStyleRuntime(
 	if (host.cwd && currentConfig.enabled && currentConfig.statusLine.enabled) {
 		void git.get(host.cwd).then((value) => {
 			if (disposed) return;
-			currentSnapshot = replaceSnapshot(currentSnapshot, generation, { ...currentSnapshot, git: value });
-			statusLine?.update(currentSnapshot);
-			editor?.update(currentSnapshot);
-			startup?.update({
-				...currentSnapshot,
-				reason: host.startupReason ?? "startup",
-				...(host.provider ? { startupProvider: host.provider } : {}),
-				...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
-				preset: currentConfig.preset,
-				...(host.resources ? { resources: host.resources } : {}),
-			});
-			requestRender();
-		});
-	}
-	if (usage) {
-		contextProvider.set("active", {
-			...(usage.tokens !== null ? { currentTokens: usage.tokens } : {}),
-			windowTokens: usage.contextWindow,
-			...(usage.percent !== null ? { percent: usage.percent } : {}),
+			if (updateSnapshot(withSnapshotPatch({ git: value }))) requestRender();
 		});
 	}
+	if (initialContext) contextProvider.set("active", initialContext);
 	return {
 		generation,
 		providerIdentity: { git, context: contextProvider, usage: usageProvider },
@@ -264,51 +288,33 @@ export function createPiStyleRuntime(
 		},
 		mode: host.mode,
 		hasUI: host.hasUI,
-		snapshot: currentSnapshot,
+		get snapshot() {
+			return currentSnapshot;
+		},
 		disposables,
 		scheduler,
 		updateStartupResources(resources) {
-			if (disposed) return;
-			startup?.update({
-				...currentSnapshot,
-				reason: host.startupReason ?? "startup",
-				...(host.provider ? { startupProvider: host.provider } : {}),
-				...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
-				preset: currentConfig.preset,
-				resources,
-			});
+			if (disposed || !startup) return false;
+			startup.update(createStartupSnapshot(currentConfig, resources));
 			requestRender();
+			return true;
 		},
 		dismissStartup() {
 			startup?.dismiss();
 		},
-		update(values) {
-			if (disposed) return;
-			const liveUsage = host.getContextUsage?.();
-			const context = liveUsage
-				? {
-						...(liveUsage.tokens !== null ? { currentTokens: liveUsage.tokens } : {}),
-						windowTokens: liveUsage.contextWindow,
-						...(liveUsage.percent !== null ? { percent: liveUsage.percent } : {}),
-					}
-				: undefined;
-			const statuses = extensionStatuses();
-			currentSnapshot = replaceSnapshot(currentSnapshot, generation, {
-				...currentSnapshot,
-				...values,
-				...(context ? { context } : {}),
-				...(statuses ? { extensionStatuses: statuses } : {}),
-			});
-			statusLine?.update(currentSnapshot);
-			editor?.update(currentSnapshot);
-			startup?.update({
-				...currentSnapshot,
-				reason: host.startupReason ?? "startup",
-				...(host.provider ? { startupProvider: host.provider } : {}),
-				...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
-				preset: currentConfig.preset,
-				...(host.resources ? { resources: host.resources } : {}),
-			});
+		update(values, options = {}) {
+			if (disposed) return false;
+			const patch: Partial<Record<keyof StatusSnapshot, StatusSnapshot[keyof StatusSnapshot] | undefined>> = {
+				...(values as Partial<Record<keyof StatusSnapshot, StatusSnapshot[keyof StatusSnapshot] | undefined>>),
+			};
+			if (options.refreshContextUsage) {
+				const context = contextSnapshot();
+				patch.context = context;
+				if (context) contextProvider.set("active", context);
+				else contextProvider.clear();
+			}
+			if (options.refreshExtensionStatuses) patch.extensionStatuses = extensionStatuses();
+			return updateSnapshot(withSnapshotPatch(patch));
 		},
 		configure(nextConfig) {
 			if (disposed) return;
@@ -347,21 +353,24 @@ export function createPiStyleRuntime(
 		},
 		invalidateGit() {
 			if (disposed || !host.cwd || !currentConfig.enabled || !currentConfig.statusLine.enabled) return;
-			git.invalidate(host.cwd);
-			void git.get(host.cwd).then((value) => {
+			const cwd = host.cwd;
+			// Mark the cache stale immediately (cheap, no spawn); the actual
+			// `git status` process spawn is coalesced behind a short debounce so
+			// bursts of tool results trigger ONE refresh, not one per event.
+			// CachedGitProvider serializes concurrent gets via entry.promise and
+			// honors invalidate-during-flight (needsRefresh re-runs the fetch),
+			// so this debounce only reduces spawn count and never loses a signal.
+			git.invalidate(cwd);
+			if (pendingGitRefresh !== undefined) return;
+			pendingGitRefresh = setTimeout(() => {
+				pendingGitRefresh = undefined;
 				if (disposed) return;
-				currentSnapshot = replaceSnapshot(currentSnapshot, generation, { ...currentSnapshot, git: value });
-				statusLine?.update(currentSnapshot);
-				editor?.update(currentSnapshot);
-				startup?.update({
-					...currentSnapshot,
-					reason: host.startupReason ?? "startup",
-					...(host.provider ? { startupProvider: host.provider } : {}),
-					...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
-					preset: currentConfig.preset,
+				void git.get(cwd).then((value) => {
+					if (disposed) return;
+					if (updateSnapshot(withSnapshotPatch({ git: value }))) requestRender();
 				});
-				requestRender();
-			});
+			}, GIT_INVALIDATE_DEBOUNCE_MS);
+			pendingGitRefresh.unref?.();
 		},
 		get disposed() {
 			return disposed;
@@ -369,6 +378,10 @@ export function createPiStyleRuntime(
 		dispose() {
 			if (disposed) return;
 			disposed = true;
+			if (pendingGitRefresh !== undefined) {
+				clearTimeout(pendingGitRefresh);
+				pendingGitRefresh = undefined;
+			}
 			scheduler.cancel();
 			// UI surfaces are restored synchronously so teardown is deterministic;
 			// the store then disposes the (already disposed) feature instances idempotently.

package/extension-src/pi-style/app/snapshot.ts

@@ -6,10 +6,49 @@ export interface UiSnapshot extends StatusSnapshot {
 }
 
 export function createSnapshot(generation: number, revision = 0, values: StatusSnapshot = {}): UiSnapshot {
-	return Object.freeze({ generation, revision, ...values });
+	return Object.freeze({ ...values, generation, revision });
 }
 
 export function replaceSnapshot(current: UiSnapshot, generation: number, values: StatusSnapshot): UiSnapshot {
 	if (current.generation !== generation) return current;
-	return createSnapshot(generation, current.revision + 1, values);
+	return equalStatusSnapshot(current, values) ? current : createSnapshot(generation, current.revision + 1, values);
+}
+
+function equalStatusSnapshot(current: StatusSnapshot, next: StatusSnapshot): boolean {
+	const currentEntries = Object.entries(current).filter(([key]) => key !== "generation" && key !== "revision");
+	const nextEntries = Object.entries(next).filter(([key]) => key !== "generation" && key !== "revision");
+	if (currentEntries.length !== nextEntries.length) return false;
+	for (const [key, value] of nextEntries) {
+		if (!hasOwn(current, key)) return false;
+		if (!equalValue((current as Record<string, unknown>)[key], value)) return false;
+	}
+	return true;
+}
+
+function equalValue(left: unknown, right: unknown): boolean {
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) && Array.isArray(right)) {
+		if (left.length !== right.length) return false;
+		for (let index = 0; index < left.length; index++) {
+			if (!equalValue(left[index], right[index])) return false;
+		}
+		return true;
+	}
+	if (!isPlainRecord(left) || !isPlainRecord(right)) return false;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of rightKeys) {
+		if (!hasOwn(left, key)) return false;
+		if (!equalValue(left[key], right[key])) return false;
+	}
+	return true;
+}
+
+function hasOwn(value: object, key: string): boolean {
+	return Object.hasOwn(value, key);
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/extension-src/pi-style/domain/status-renderer.ts

@@ -25,6 +25,8 @@ interface Candidate {
 	readonly segment: StatusSegment;
 	readonly result: SegmentRenderResult;
 	content: string;
+	/** Visible width of `content`; updated when the compact form is swapped in. */
+	contentWidth: number;
 	compact: boolean;
 	moved: boolean;
 }
@@ -47,10 +49,6 @@ function renderGroup(items: readonly Candidate[], separator: string, padding: st
 		.join(`${padding}${separator}${padding}`);
 }
 
-function widthOf(items: readonly Candidate[], separator: string, padding: string): number {
-	return visibleWidth(renderGroup(items, separator, padding));
-}
-
 export function renderStatus(
 	layout: StatusLayout,
 	snapshot: StatusSnapshot,
@@ -70,7 +68,15 @@ export function renderStatus(
 		try {
 			const result = segment.render(context);
 			if (!result.visible || !result.content) continue;
-			candidates.set(id, { id, segment, result, content: result.content, compact: false, moved: false });
+			candidates.set(id, {
+				id,
+				segment,
+				result,
+				content: result.content,
+				contentWidth: visibleWidth(result.content),
+				compact: false,
+				moved: false,
+			});
 		} catch {
 			// A broken optional segment must not break the status row.
 		}
@@ -88,13 +94,34 @@ export function renderStatus(
 		.filter((candidate): candidate is Candidate => candidate !== undefined);
 	const visible: Candidate[] = [];
 	const overflow: Candidate[] = [];
+	// Incremental fit tracking: the rendered width of a group is the sum of the
+	// member content widths plus one separator gap between consecutive members
+	// (every join boundary is broken by the separator string, so visible widths
+	// add up). This replaces re-joining and re-measuring the whole group after
+	// every push, which made the overflow loop quadratic in segment count.
+	const gapWidth = visibleWidth(`${padding}${separator}${padding}`);
+	let groupWidth = 0;
+	let groupCount = 0;
+	const widthAfter = (baseWidth: number, count: number, candidate: Candidate): number =>
+		count === 0 ? candidate.contentWidth : baseWidth + gapWidth + candidate.contentWidth;
 	for (const candidate of primary) {
 		visible.push(candidate);
-		if (widthOf(visible, separator, padding) <= width) continue;
+		const pushedWidth = widthAfter(groupWidth, groupCount, candidate);
+		if (pushedWidth <= width) {
+			groupWidth = pushedWidth;
+			groupCount++;
+			continue;
+		}
 		if (candidate.result.compactContent && !candidate.compact) {
 			candidate.content = candidate.result.compactContent;
 			candidate.compact = true;
-			if (widthOf(visible, separator, padding) <= width) continue;
+			candidate.contentWidth = visibleWidth(candidate.content);
+			const compactedWidth = widthAfter(groupWidth, groupCount, candidate);
+			if (compactedWidth <= width) {
+				groupWidth = compactedWidth;
+				groupCount++;
+				continue;
+			}
 		}
 		visible.pop();
 		if (candidate.segment.overflow !== "drop" && candidate.segment.overflow !== "primary") {
@@ -127,9 +154,14 @@ export function renderStatus(
 	}
 	if (visibleWidth(primaryText) > width) primaryText = truncateAnsi(primaryText, width);
 	const secondaryVisible: Candidate[] = [];
+	let secondaryWidth = 0;
+	let secondaryCount = 0;
 	for (const candidate of [...secondary].sort((a, b) => b.segment.defaultPriority - a.segment.defaultPriority)) {
+		const pushedWidth = widthAfter(secondaryWidth, secondaryCount, candidate);
+		if (pushedWidth > width) continue;
 		secondaryVisible.push(candidate);
-		if (widthOf(secondaryVisible, separator, padding) > width) secondaryVisible.pop();
+		secondaryWidth = pushedWidth;
+		secondaryCount++;
 	}
 	const secondaryText = renderGroup(secondaryVisible, separator, padding);
 	const lines = secondaryText ? [primaryText, secondaryText] : primaryText ? [primaryText] : [];

package/extension-src/pi-style/domain/status.ts

@@ -308,11 +308,10 @@ export function createBuiltinSegments(): ReadonlyMap<StatusSegmentId, StatusSegm
 					? ""
 					: theme.apply("time", formatElapsed(Date.now() - snapshot.sessionStartedAt)),
 		})),
-		segment("time", 20, ({ theme }) => ({
-			visible: true,
-			content: theme.apply("time", new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })),
-			compactContent: theme.apply("time", new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })),
-		})),
+		segment("time", 20, ({ theme }) => {
+			const text = theme.apply("time", clockTime());
+			return { visible: true, content: text, compactContent: text };
+		}),
 		segment("hostname", 20, ({ snapshot, theme }) => ({
 			visible: Boolean(snapshot.hostname),
 			content: theme.apply("muted", snapshot.hostname ?? ""),
@@ -337,6 +336,17 @@ export function createBuiltinSegments(): ReadonlyMap<StatusSegmentId, StatusSegm
 	return new Map(segments.map((item) => [item.id, item]));
 }
 
+/** Cached clock text: the minute-precision string only changes once per minute. */
+let clockCache: { minuteKey: number; value: string } | undefined;
+function clockTime(): string {
+	const now = new Date();
+	const minuteKey = now.getHours() * 60 + now.getMinutes();
+	if (clockCache?.minuteKey !== minuteKey) {
+		clockCache = { minuteKey, value: now.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) };
+	}
+	return clockCache.value;
+}
+
 const CONTEXT_BAR_WIDTH = 10;
 
 function contextBar(percent: number, width = CONTEXT_BAR_WIDTH): string {

package/extension-src/pi-style/domain/theme.ts

@@ -200,10 +200,32 @@ function colorPrefixFor(
 	return "";
 }
 
+function envKeyFor(env: Record<string, string | undefined>): string {
+	return `${env.PI_STYLE_NERD_FONTS ?? ""}\u0000${env.GHOSTTY_RESOURCES_DIR ? "1" : "0"}\u0000${env.TERM_PROGRAM ?? ""}`;
+}
+
+const glyphModeCache = new WeakMap<object, Map<string, GlyphMode>>();
+
 export function detectGlyphMode(
 	config: NormalizedPiStyleConfig,
 	env: Record<string, string | undefined> = {},
 ): GlyphMode {
+	// Memoized per config object; the env-derived key keeps the result correct
+	// when the same config is resolved against different environments.
+	let byEnv = glyphModeCache.get(config);
+	if (!byEnv) {
+		byEnv = new Map();
+		glyphModeCache.set(config, byEnv);
+	}
+	const envKey = envKeyFor(env);
+	const cached = byEnv.get(envKey);
+	if (cached !== undefined) return cached;
+	const mode = computeGlyphMode(config, env);
+	byEnv.set(envKey, mode);
+	return mode;
+}
+
+function computeGlyphMode(config: NormalizedPiStyleConfig, env: Record<string, string | undefined>): GlyphMode {
 	if (env.PI_STYLE_NERD_FONTS === "1") return "nerd";
 	if (env.PI_STYLE_NERD_FONTS === "0") return "unicode";
 	if (config.theme.nerdFonts === "on") return "nerd";
@@ -224,7 +246,16 @@ export function resolveTheme(
 ): ResolvedTheme {
 	const noColor = Object.hasOwn(env, "NO_COLOR") && env.NO_COLOR !== "" && config.theme.colors.colorOverride !== "on";
 	const mode = config.preset === "ascii" ? "ascii" : detectGlyphMode(config, env);
-	const color = (token: SemanticToken) => colorPrefixFor(active, config, noColor, token);
+	// Lazy per-instance prefix memo: repeated apply(token, ...) calls stop
+	// re-running colorPrefixFor (and Pi's active.fg()) for the same token.
+	const prefixes = new Map<SemanticToken, string>();
+	const color = (token: SemanticToken): string => {
+		const cached = prefixes.get(token);
+		if (cached !== undefined) return cached;
+		const prefix = colorPrefixFor(active, config, noColor, token);
+		prefixes.set(token, prefix);
+		return prefix;
+	};
 	return {
 		mode,
 		noColor,