claudeup 6.2.0 → 6.3.0

package/src/__tests__/useGitignoreModal.test.ts

@@ -1,71 +1,79 @@
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import { buildGitignoreModal } from "../ui/hooks/useGitignoreModal";
 
 describe("buildGitignoreModal", () => {
-  it("builds a select modal with three options", () => {
-    let dismissed = false;
-    let fixed = false;
-    let opened = false;
-    const modal = buildGitignoreModal({
-      violationCount: 5,
-      safeCount: 3,
-      onFixSafe: () => { fixed = true; },
-      onOpenTab: () => { opened = true; },
-      onDismiss: () => { dismissed = true; },
-    });
-    expect(modal.type).toBe("select");
-    if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.options.length).toBe(3);
-    expect(modal.options[0].value).toBe("fix-safe");
-    expect(modal.options[1].value).toBe("open-tab");
-    expect(modal.options[2].value).toBe("dismiss");
-    expect(modal.options[0].label).toContain("3");
+	it("builds a select modal with three options", () => {
+		let dismissed = false;
+		let fixed = false;
+		let opened = false;
+		const modal = buildGitignoreModal({
+			violationCount: 5,
+			safeCount: 3,
+			onFixSafe: () => {
+				fixed = true;
+			},
+			onOpenTab: () => {
+				opened = true;
+			},
+			onDismiss: () => {
+				dismissed = true;
+			},
+		});
+		expect(modal.type).toBe("select");
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options.length).toBe(3);
+		expect(modal.options[0].value).toBe("fix-safe");
+		expect(modal.options[1].value).toBe("open-tab");
+		expect(modal.options[2].value).toBe("dismiss");
+		expect(modal.options[0].label).toContain("3");
 
-    modal.onSelect("fix-safe");
-    expect(fixed).toBe(true);
+		modal.onSelect("fix-safe");
+		expect(fixed).toBe(true);
 
-    modal.onSelect("open-tab");
-    expect(opened).toBe(true);
+		modal.onSelect("open-tab");
+		expect(opened).toBe(true);
 
-    modal.onSelect("dismiss");
-    expect(dismissed).toBe(true);
-  });
+		modal.onSelect("dismiss");
+		expect(dismissed).toBe(true);
+	});
 
-  it("shows no missing entries label when safeCount is 0", () => {
-    const modal = buildGitignoreModal({
-      violationCount: 2,
-      safeCount: 0,
-      onFixSafe: () => {},
-      onOpenTab: () => {},
-      onDismiss: () => {},
-    });
-    if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.options[0].label).toContain("no missing .gitignore");
-  });
+	it("shows no missing entries label when safeCount is 0", () => {
+		const modal = buildGitignoreModal({
+			violationCount: 2,
+			safeCount: 0,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options[0].label).toContain("no missing .gitignore");
+	});
 
-  it("includes violation count in the message", () => {
-    const modal = buildGitignoreModal({
-      violationCount: 7,
-      safeCount: 2,
-      onFixSafe: () => {},
-      onOpenTab: () => {},
-      onDismiss: () => {},
-    });
-    if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.message).toContain("7");
-  });
+	it("includes violation count in the message", () => {
+		const modal = buildGitignoreModal({
+			violationCount: 7,
+			safeCount: 2,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.message).toContain("7");
+	});
 
-  it("calls onCancel as dismiss", () => {
-    let dismissed = false;
-    const modal = buildGitignoreModal({
-      violationCount: 1,
-      safeCount: 0,
-      onFixSafe: () => {},
-      onOpenTab: () => {},
-      onDismiss: () => { dismissed = true; },
-    });
-    if (modal.type !== "select") throw new Error("type guard");
-    modal.onCancel();
-    expect(dismissed).toBe(true);
-  });
+	it("calls onCancel as dismiss", () => {
+		let dismissed = false;
+		const modal = buildGitignoreModal({
+			violationCount: 1,
+			safeCount: 0,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {
+				dismissed = true;
+			},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		modal.onCancel();
+		expect(dismissed).toBe(true);
+	});
 });

package/src/__tests__/version-snapshot.test.ts

@@ -3,11 +3,11 @@ import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import {
-  diffVersions,
-  isKnownVersion,
-  loadSeenVersions,
-  saveSeenVersions,
-  UNKNOWN_VERSION,
+	UNKNOWN_VERSION,
+	diffVersions,
+	isKnownVersion,
+	loadSeenVersions,
+	saveSeenVersions,
 } from "../services/version-snapshot.js";
 
 /**
@@ -18,179 +18,197 @@ import {
  */
 
 describe("isKnownVersion", () => {
-  test('"0.0.0" is not a usable version', () => {
-    // Claude Code records this for a plugin whose version it cannot determine.
-    expect(isKnownVersion(UNKNOWN_VERSION)).toBe(false);
-    expect(isKnownVersion(undefined)).toBe(false);
-    expect(isKnownVersion("")).toBe(false);
-    expect(isKnownVersion("1.0.0")).toBe(true);
-  });
+	test('"0.0.0" is not a usable version', () => {
+		// Claude Code records this for a plugin whose version it cannot determine.
+		expect(isKnownVersion(UNKNOWN_VERSION)).toBe(false);
+		expect(isKnownVersion(undefined)).toBe(false);
+		expect(isKnownVersion("")).toBe(false);
+		expect(isKnownVersion("1.0.0")).toBe(true);
+	});
 });
 
 describe("diffVersions — first run", () => {
-  test("no baseline reports nothing at all", () => {
-    // Without this, the first launch would flag every installed plugin as new,
-    // which is both wrong and the fastest way to train someone to ignore badges.
-    expect(
-      diffVersions(null, { "dev@magus": "2.12.1", "a@mp": UNKNOWN_VERSION }),
-    ).toEqual([]);
-  });
-
-  test("an empty baseline is NOT the same as no baseline", () => {
-    // A real snapshot that happens to be empty means we have looked before and
-    // saw nothing, so anything present now is genuinely new.
-    const changes = diffVersions({}, { "dev@magus": "2.12.1" });
-    expect(changes).toEqual([
-      { pluginId: "dev@magus", kind: "installed", to: "2.12.1" },
-    ]);
-  });
+	test("no baseline reports nothing at all", () => {
+		// Without this, the first launch would flag every installed plugin as new,
+		// which is both wrong and the fastest way to train someone to ignore badges.
+		expect(
+			diffVersions(null, { "dev@magus": "2.12.1", "a@mp": UNKNOWN_VERSION }),
+		).toEqual([]);
+	});
+
+	test("an empty baseline is NOT the same as no baseline", () => {
+		// A real snapshot that happens to be empty means we have looked before and
+		// saw nothing, so anything present now is genuinely new.
+		const changes = diffVersions({}, { "dev@magus": "2.12.1" });
+		expect(changes).toEqual([
+			{ pluginId: "dev@magus", kind: "installed", to: "2.12.1" },
+		]);
+	});
 });
 
 describe("diffVersions — installs", () => {
-  test("a plugin absent from the baseline is reported as installed, not updated", () => {
-    const changes = diffVersions({ "other@mp": "1.0.0" }, { "new@mp": "3.1.0" });
-    expect(changes).toEqual([
-      { pluginId: "new@mp", kind: "installed", to: "3.1.0" },
-    ]);
-  });
-
-  test("an install with an unknown version is still reported", () => {
-    // The version is unusable but the install is real — the UI shows "new"
-    // with no version rather than suppressing the plugin entirely.
-    const changes = diffVersions({}, { "a@mp": UNKNOWN_VERSION });
-    expect(changes).toEqual([
-      { pluginId: "a@mp", kind: "installed", to: UNKNOWN_VERSION },
-    ]);
-  });
+	test("a plugin absent from the baseline is reported as installed, not updated", () => {
+		const changes = diffVersions(
+			{ "other@mp": "1.0.0" },
+			{ "new@mp": "3.1.0" },
+		);
+		expect(changes).toEqual([
+			{ pluginId: "new@mp", kind: "installed", to: "3.1.0" },
+		]);
+	});
+
+	test("an install with an unknown version is still reported", () => {
+		// The version is unusable but the install is real — the UI shows "new"
+		// with no version rather than suppressing the plugin entirely.
+		const changes = diffVersions({}, { "a@mp": UNKNOWN_VERSION });
+		expect(changes).toEqual([
+			{ pluginId: "a@mp", kind: "installed", to: UNKNOWN_VERSION },
+		]);
+	});
 });
 
 describe("diffVersions — updates", () => {
-  test("reports a genuine version transition", () => {
-    expect(
-      diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
-    ).toEqual([
-      { pluginId: "dev@magus", kind: "updated", from: "2.12.0", to: "2.12.1" },
-    ]);
-  });
-
-  test("unchanged versions report nothing", () => {
-    expect(
-      diffVersions({ "dev@magus": "2.12.1" }, { "dev@magus": "2.12.1" }),
-    ).toEqual([]);
-  });
-
-  test("learning a previously unknown version is not an update", () => {
-    // This is exactly what v4.22.0's registry overlay caused: versions that
-    // could not be resolved suddenly could be. Reporting it would announce
-    // claudeup's own bugfix as if the user's plugins had changed.
-    expect(diffVersions({ "a@mp": UNKNOWN_VERSION }, { "a@mp": "5.3.0" })).toEqual([]);
-  });
-
-  test("losing a known version is not an update either", () => {
-    expect(diffVersions({ "a@mp": "5.3.0" }, { "a@mp": UNKNOWN_VERSION })).toEqual([]);
-  });
-
-  test("a downgrade IS reported", () => {
-    // Rolling back is a real change, arguably the most important to surface.
-    expect(diffVersions({ "a@mp": "2.0.0" }, { "a@mp": "1.0.0" })).toEqual([
-      { pluginId: "a@mp", kind: "updated", from: "2.0.0", to: "1.0.0" },
-    ]);
-  });
+	test("reports a genuine version transition", () => {
+		expect(
+			diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
+		).toEqual([
+			{ pluginId: "dev@magus", kind: "updated", from: "2.12.0", to: "2.12.1" },
+		]);
+	});
+
+	test("unchanged versions report nothing", () => {
+		expect(
+			diffVersions({ "dev@magus": "2.12.1" }, { "dev@magus": "2.12.1" }),
+		).toEqual([]);
+	});
+
+	test("learning a previously unknown version is not an update", () => {
+		// This is exactly what v4.22.0's registry overlay caused: versions that
+		// could not be resolved suddenly could be. Reporting it would announce
+		// claudeup's own bugfix as if the user's plugins had changed.
+		expect(
+			diffVersions({ "a@mp": UNKNOWN_VERSION }, { "a@mp": "5.3.0" }),
+		).toEqual([]);
+	});
+
+	test("losing a known version is not an update either", () => {
+		expect(
+			diffVersions({ "a@mp": "5.3.0" }, { "a@mp": UNKNOWN_VERSION }),
+		).toEqual([]);
+	});
+
+	test("a downgrade IS reported", () => {
+		// Rolling back is a real change, arguably the most important to surface.
+		expect(diffVersions({ "a@mp": "2.0.0" }, { "a@mp": "1.0.0" })).toEqual([
+			{ pluginId: "a@mp", kind: "updated", from: "2.0.0", to: "1.0.0" },
+		]);
+	});
 });
 
 describe("diffVersions — removals and mixed sets", () => {
-  test("a removed plugin is not reported", () => {
-    expect(diffVersions({ "gone@mp": "1.0.0" }, {})).toEqual([]);
-  });
-
-  test("classifies each plugin independently in one pass", () => {
-    const changes = diffVersions(
-      { same: "1.0.0", moved: "2.0.0", learned: UNKNOWN_VERSION },
-      { same: "1.0.0", moved: "2.1.0", learned: "9.0.0", fresh: "0.1.0" },
-    );
-    expect(changes).toEqual([
-      { pluginId: "moved", kind: "updated", from: "2.0.0", to: "2.1.0" },
-      { pluginId: "fresh", kind: "installed", to: "0.1.0" },
-    ]);
-  });
+	test("a removed plugin is not reported", () => {
+		expect(diffVersions({ "gone@mp": "1.0.0" }, {})).toEqual([]);
+	});
+
+	test("classifies each plugin independently in one pass", () => {
+		const changes = diffVersions(
+			{ same: "1.0.0", moved: "2.0.0", learned: UNKNOWN_VERSION },
+			{ same: "1.0.0", moved: "2.1.0", learned: "9.0.0", fresh: "0.1.0" },
+		);
+		expect(changes).toEqual([
+			{ pluginId: "moved", kind: "updated", from: "2.0.0", to: "2.1.0" },
+			{ pluginId: "fresh", kind: "installed", to: "0.1.0" },
+		]);
+	});
 });
 
 describe("per-project baselines", () => {
-  /**
-   * The baseline used to be one flat map for the whole machine, but the
-   * versions written into it are resolved per project. Two projects
-   * legitimately on different versions overwrote each other's baseline, so
-   * every differing plugin was reported as "updated" on the next render — a
-   * change that never happened.
-   *
-   * CLAUDE_CONFIG_DIR, not HOME: os.homedir() reads the passwd database on
-   * macOS and ignores $HOME, so a HOME-only override writes to the operator's
-   * real ~/.claude. That is not hypothetical — it happened while writing these.
-   */
-  const withSandbox = async (fn: () => Promise<void>): Promise<void> => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "vsnap-"));
-    const prev = process.env.CLAUDE_CONFIG_DIR;
-    process.env.CLAUDE_CONFIG_DIR = dir;
-    try {
-      await fn();
-    } finally {
-      if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
-      else process.env.CLAUDE_CONFIG_DIR = prev;
-      await fs.rm(dir, { recursive: true, force: true });
-    }
-  };
-
-  test("a project with no baseline of its own reports nothing", async () => {
-    await withSandbox(async () => {
-      await saveSeenVersions("/proj/a", { "statusline@magus": "2.2.0" });
-      const baseline = await loadSeenVersions("/proj/b");
-      expect(baseline).toBeNull();
-      expect(diffVersions(baseline, { "statusline@magus": "2.5.0" })).toEqual([]);
-    });
-  });
-
-  test("saving one project preserves the others", async () => {
-    await withSandbox(async () => {
-      await saveSeenVersions("/proj/a", { "gtd@magus": "2.0.0" });
-      await saveSeenVersions("/proj/b", { "gtd@magus": "2.0.1" });
-      expect(await loadSeenVersions("/proj/a")).toEqual({ "gtd@magus": "2.0.0" });
-      expect(await loadSeenVersions("/proj/b")).toEqual({ "gtd@magus": "2.0.1" });
-    });
-  });
-
-  test("a real update inside one project is still reported", async () => {
-    await withSandbox(async () => {
-      await saveSeenVersions("/proj/a", { "dev@magus": "3.0.0" });
-      const previous = await loadSeenVersions("/proj/a");
-      expect(diffVersions(previous, { "dev@magus": "3.0.1" })).toEqual([
-        { pluginId: "dev@magus", kind: "updated", from: "3.0.0", to: "3.0.1" },
-      ]);
-    });
-  });
-
-  test("a pre-migration flat baseline is adopted once, then replaced", async () => {
-    await withSandbox(async () => {
-      const file = path.join(
-        process.env.CLAUDE_CONFIG_DIR as string,
-        "claudeup-version-snapshot.json",
-      );
-      await fs.writeFile(
-        file,
-        JSON.stringify({
-          seen: { "dev@magus": "3.0.0" },
-          seededAt: "2026-07-29T00:00:00.000Z",
-          updatedAt: "2026-07-29T00:00:00.000Z",
-        }),
-      );
-
-      // Legacy shape carries no project, so it stands in for whoever asks first
-      // rather than being thrown away.
-      expect(await loadSeenVersions("/proj/a")).toEqual({ "dev@magus": "3.0.0" });
-
-      await saveSeenVersions("/proj/a", { "dev@magus": "3.0.1" });
-      // Once per-project entries exist, the flat map is no longer consulted.
-      expect(await loadSeenVersions("/proj/b")).toBeNull();
-      expect(await loadSeenVersions("/proj/a")).toEqual({ "dev@magus": "3.0.1" });
-    });
-  });
+	/**
+	 * The baseline used to be one flat map for the whole machine, but the
+	 * versions written into it are resolved per project. Two projects
+	 * legitimately on different versions overwrote each other's baseline, so
+	 * every differing plugin was reported as "updated" on the next render — a
+	 * change that never happened.
+	 *
+	 * CLAUDE_CONFIG_DIR, not HOME: os.homedir() reads the passwd database on
+	 * macOS and ignores $HOME, so a HOME-only override writes to the operator's
+	 * real ~/.claude. That is not hypothetical — it happened while writing these.
+	 */
+	const withSandbox = async (fn: () => Promise<void>): Promise<void> => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "vsnap-"));
+		const prev = process.env.CLAUDE_CONFIG_DIR;
+		process.env.CLAUDE_CONFIG_DIR = dir;
+		try {
+			await fn();
+		} finally {
+			// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"; only delete unsets the variable
+			if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+			else process.env.CLAUDE_CONFIG_DIR = prev;
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	};
+
+	test("a project with no baseline of its own reports nothing", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "statusline@magus": "2.2.0" });
+			const baseline = await loadSeenVersions("/proj/b");
+			expect(baseline).toBeNull();
+			expect(diffVersions(baseline, { "statusline@magus": "2.5.0" })).toEqual(
+				[],
+			);
+		});
+	});
+
+	test("saving one project preserves the others", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "gtd@magus": "2.0.0" });
+			await saveSeenVersions("/proj/b", { "gtd@magus": "2.0.1" });
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"gtd@magus": "2.0.0",
+			});
+			expect(await loadSeenVersions("/proj/b")).toEqual({
+				"gtd@magus": "2.0.1",
+			});
+		});
+	});
+
+	test("a real update inside one project is still reported", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "dev@magus": "3.0.0" });
+			const previous = await loadSeenVersions("/proj/a");
+			expect(diffVersions(previous, { "dev@magus": "3.0.1" })).toEqual([
+				{ pluginId: "dev@magus", kind: "updated", from: "3.0.0", to: "3.0.1" },
+			]);
+		});
+	});
+
+	test("a pre-migration flat baseline is adopted once, then replaced", async () => {
+		await withSandbox(async () => {
+			const file = path.join(
+				process.env.CLAUDE_CONFIG_DIR as string,
+				"claudeup-version-snapshot.json",
+			);
+			await fs.writeFile(
+				file,
+				JSON.stringify({
+					seen: { "dev@magus": "3.0.0" },
+					seededAt: "2026-07-29T00:00:00.000Z",
+					updatedAt: "2026-07-29T00:00:00.000Z",
+				}),
+			);
+
+			// Legacy shape carries no project, so it stands in for whoever asks first
+			// rather than being thrown away.
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"dev@magus": "3.0.0",
+			});
+
+			await saveSeenVersions("/proj/a", { "dev@magus": "3.0.1" });
+			// Once per-project entries exist, the flat map is no longer consulted.
+			expect(await loadSeenVersions("/proj/b")).toBeNull();
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"dev@magus": "3.0.1",
+			});
+		});
+	});
 });

package/src/cli/ansi.ts

@@ -59,7 +59,7 @@ const clamp01 = (n: number): number =>
 /** `#rgb` and `#rrggbb`, hash optional. Anything else resolves to black. */
 function parseHex(hex: string): [number, number, number] {
 	let h = hex.trim().replace(/^#/, "");
-	if (h.length === 3) h = h[0]! + h[0]! + h[1]! + h[1]! + h[2]! + h[2]!;
+	if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
 	if (!/^[0-9a-fA-F]{6}$/.test(h)) return [0, 0, 0];
 	return [
 		Number.parseInt(h.slice(0, 2), 16),
@@ -110,19 +110,22 @@ export function mix(from: string, to: string, t: number): string {
 export function blend1D(steps: number, from: string, to: string): string[] {
 	if (!Number.isInteger(steps) || steps <= 0) return [];
 	if (steps === 1) return [toHex(parseHex(from))];
-	return Array.from({ length: steps }, (_, i) => mix(from, to, i / (steps - 1)));
+	return Array.from({ length: steps }, (_, i) =>
+		mix(from, to, i / (steps - 1)),
+	);
 }
 
 /** Multi-stop ramp: `steps` colours spread evenly across every stop, in order. */
 export function blendStops(steps: number, ...stops: string[]): string[] {
 	if (!Number.isInteger(steps) || steps <= 0 || stops.length === 0) return [];
-	if (stops.length === 1 || steps === 1)
-		return blend1D(steps, stops[0]!, stops.at(-1)!);
+	const first = stops[0];
+	const last = stops[stops.length - 1];
+	if (stops.length === 1 || steps === 1) return blend1D(steps, first, last);
 	const segs = stops.length - 1;
 	return Array.from({ length: steps }, (_, i) => {
 		const p = (i / (steps - 1)) * segs;
 		const s = Math.min(segs - 1, Math.floor(p));
-		return mix(stops[s]!, stops[s + 1]!, p - s);
+		return mix(stops[s], stops[s + 1], p - s);
 	});
 }
 
@@ -283,7 +286,7 @@ function charWidth(cp: number): number {
 /** Visible cell width, ignoring escape sequences. */
 export function width(text: string): number {
 	let w = 0;
-	for (const ch of stripAnsi(text)) w += charWidth(ch.codePointAt(0)!);
+	for (const ch of stripAnsi(text)) w += charWidth(ch.codePointAt(0) ?? 0);
 	return w;
 }
 
@@ -321,8 +324,10 @@ export function truncate(text: string, n: number): string {
 			i += m[0].length;
 			continue;
 		}
-		const ch = String.fromCodePoint(text.codePointAt(i)!);
-		const cw = charWidth(ch.codePointAt(0)!);
+		const cp = text.codePointAt(i);
+		if (cp === undefined) break;
+		const ch = String.fromCodePoint(cp);
+		const cw = charWidth(cp);
 		if (w + cw > n) break;
 		out += ch;
 		w += cw;
@@ -391,10 +396,13 @@ export function meter(
 	if (cells <= 0) return "";
 	const p = clamp01((Number.isFinite(pct) ? pct : 0) / 100);
 	const filled = Math.round(p * cells);
-	const cols = blendStops(cells, ...(stops.length > 0 ? stops : ramps.progress));
+	const cols = blendStops(
+		cells,
+		...(stops.length > 0 ? stops : ramps.progress),
+	);
 	let out = "";
 	for (let i = 0; i < cells; i++) {
-		out += i < filled ? fg(cols[i]!, FILL) : fg(TRACK_COLOR, TRACK);
+		out += i < filled ? fg(cols[i], FILL) : fg(TRACK_COLOR, TRACK);
 	}
 	return out;
 }
@@ -446,14 +454,14 @@ export function stackedBar(cells: number, segments: BarSegment[]): string {
 	while (drift !== 0) {
 		const i = widths.indexOf(Math.max(...widths));
 		if (drift > 0) {
-			widths[i]!++;
+			widths[i]++;
 			drift--;
-		} else if (widths[i]! > 1) {
-			widths[i]!--;
+		} else if (widths[i] > 1) {
+			widths[i]--;
 			drift++;
 		} else break;
 	}
-	return live.map((s, i) => fg(s.color, FILL.repeat(widths[i]!))).join("");
+	return live.map((s, i) => fg(s.color, FILL.repeat(widths[i]))).join("");
 }
 
 /**
@@ -498,7 +506,7 @@ export function badge(label: string, hex: string): string {
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
 
 export function spinner(tick: number): string {
-	return SPINNER[Math.abs(Math.trunc(tick)) % SPINNER.length]!;
+	return SPINNER[Math.abs(Math.trunc(tick)) % SPINNER.length];
 }
 
 /** Elapsed time sized to its magnitude: `340ms`, `1.4s`, `2m04s`. */