@vitest-agent/ui 1.0.0

package/render-ink/StreamApp.js

@@ -0,0 +1,453 @@
+import { classifyRunShape } from "../dispatcher/classify.js";
+import { formatDisplayDuration } from "../format-duration.js";
+import { CountColumns } from "./CountColumns.js";
+import { StatusIcon } from "./StatusIcon.js";
+import { formatTagSuffix } from "./tag-suffix.js";
+import { ProjectRow } from "./ProjectRow.js";
+import { spinnerFrame } from "./spinner.js";
+import { TestRow } from "./TestRow.js";
+import { TrendLine } from "./TrendLine.js";
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/render-ink/StreamApp.tsx
+const ANONYMOUS_PROJECT = "default";
+/** Maximum number of running rows displayed in the Live region. Beyond this,
+*  excess running units collapse into a single "… and N more running" line. */
+const MAX_LIVE_RUNNING_ROWS = 4;
+const groupByProject = (state) => {
+	const order = [];
+	const byName = /* @__PURE__ */ new Map();
+	for (const path of state.moduleOrder) {
+		const mod = state.modules[path];
+		if (mod === void 0) continue;
+		const name = mod.projectName ?? ANONYMOUS_PROJECT;
+		const existing = byName.get(name);
+		if (existing === void 0) {
+			byName.set(name, [mod]);
+			order.push(name);
+		} else existing.push(mod);
+	}
+	return order.map((name) => ({
+		name,
+		modules: byName.get(name) ?? []
+	}));
+};
+const moduleRunning = (m) => m.status !== "finished";
+const moduleElapsedMs = (m, nowMs) => {
+	if (m.status === "finished") return m.durationMs;
+	if (m.startedAt === void 0) return 0;
+	const started = Date.parse(m.startedAt);
+	return Number.isNaN(started) ? 0 : Math.max(0, nowMs - started);
+};
+const sumCounts = (modules) => {
+	let passCount = 0;
+	let failCount = 0;
+	let skipCount = 0;
+	let timeoutCount = 0;
+	for (const m of modules) {
+		passCount += m.passCount;
+		failCount += m.failCount;
+		skipCount += m.skipCount;
+		timeoutCount += m.timeoutCount;
+	}
+	return {
+		passCount,
+		failCount,
+		skipCount,
+		timeoutCount
+	};
+};
+const mergeTagCounts = (modules) => {
+	const out = {};
+	for (const m of modules) for (const [tag, count] of Object.entries(m.tagCounts ?? {})) out[tag] = (out[tag] ?? 0) + count;
+	return out;
+};
+const projectElapsedMs = (group, nowMs) => {
+	if (!group.modules.some(moduleRunning)) {
+		let total = 0;
+		for (const m of group.modules) total += m.durationMs;
+		return total;
+	}
+	let earliest = Number.POSITIVE_INFINITY;
+	for (const m of group.modules) {
+		if (m.startedAt === void 0) continue;
+		const started = Date.parse(m.startedAt);
+		if (!Number.isNaN(started) && started < earliest) earliest = started;
+	}
+	return earliest === Number.POSITIVE_INFINITY ? 0 : Math.max(0, nowMs - earliest);
+};
+const moduleIcon = (m) => {
+	if (m.failCount > 0) return "failed";
+	if (m.timeoutCount > 0) return "timed-out";
+	if (m.skipCount > 0 && m.passCount === 0) return "skipped";
+	return "passed";
+};
+/**
+* One `single-project`-shape row: a module with the four count columns.
+*
+* Used in the Live region for both running rows (spinner, `running=true`)
+* and finished rows (resolved glyph, `running=false`).
+*/
+const ModuleStreamRow = ({ module, nowMs, frame, nameWidth, timedOut }) => {
+	const running = moduleRunning(module);
+	const queued = module.status === "queued";
+	let glyph;
+	let notStartedSuffix = null;
+	if (timedOut && running) if (queued) {
+		glyph = /* @__PURE__ */ jsx(StatusIcon, { status: "queued" });
+		notStartedSuffix = /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: " not started — killed before reaching this module"
+		});
+	} else glyph = /* @__PURE__ */ jsx(StatusIcon, { status: "timed-out" });
+	else if (running) glyph = /* @__PURE__ */ jsx(Text, {
+		color: "yellow",
+		children: frame
+	});
+	else glyph = /* @__PURE__ */ jsx(StatusIcon, { status: moduleIcon(module) });
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsx(Text, { children: "  " }),
+		glyph,
+		/* @__PURE__ */ jsxs(Text, { children: [
+			" ",
+			module.modulePath.padEnd(nameWidth),
+			" "
+		] }),
+		/* @__PURE__ */ jsx(CountColumns, {
+			passCount: module.passCount,
+			failCount: module.failCount,
+			skipCount: module.skipCount,
+			timeoutCount: module.timeoutCount
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [" ", formatDisplayDuration(moduleElapsedMs(module, nowMs))]
+		}),
+		formatTagSuffix(module.tagCounts).length > 0 ? /* @__PURE__ */ jsxs(Text, {
+			color: "cyan",
+			children: [" ", formatTagSuffix(module.tagCounts)]
+		}) : null,
+		notStartedSuffix
+	] });
+};
+const INLINE_VALUE_LIMIT = 200;
+/** A failing test's error, expanded inline beneath a leaf row or in a failure block. */
+const InlineError = ({ failure }) => {
+	if (failure.error?.message === void 0) return null;
+	const first = failure.error.message.split("\n", 1)[0] ?? "";
+	const expected = failure.error.expected;
+	const received = failure.error.received;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: ["      ", first]
+			}),
+			expected !== void 0 ? /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					"      ",
+					"expected: ",
+					expected.slice(0, INLINE_VALUE_LIMIT)
+				]
+			}) : null,
+			received !== void 0 ? /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					"      ",
+					"received: ",
+					received.slice(0, INLINE_VALUE_LIMIT)
+				]
+			}) : null
+		]
+	});
+};
+const failureKey = (f) => `failure:${f.modulePath}::${f.suitePath.join("/")}::${f.testName}`;
+const testKey = (modulePath, t) => `test:${modulePath}::${t.suitePath.join("/")}::${t.testName}`;
+const failurePath = (f) => [
+	f.modulePath,
+	...f.suitePath,
+	f.testName
+].join(" › ");
+/** A failure entry rendered in the Live region. */
+const FailureItem = ({ failure }) => /* @__PURE__ */ jsxs(Box, {
+	flexDirection: "column",
+	children: [/* @__PURE__ */ jsxs(Text, { children: [
+		"  ",
+		/* @__PURE__ */ jsx(Text, {
+			color: failure.timedOut === true ? "#e09a4e" : "red",
+			children: failure.timedOut === true ? "⧖" : "✗"
+		}),
+		" ",
+		failurePath(failure),
+		failure.classification !== null ? /* @__PURE__ */ jsxs(Text, {
+			color: "#c98ae0",
+			children: [
+				" [",
+				failure.classification,
+				"]"
+			]
+		}) : null
+	] }), /* @__PURE__ */ jsx(InlineError, { failure })]
+});
+const TotalsLine = ({ totals }) => /* @__PURE__ */ jsxs(Text, { children: [
+	/* @__PURE__ */ jsx(Text, {
+		bold: true,
+		children: "Total:"
+	}),
+	" ",
+	/* @__PURE__ */ jsx(CountColumns, {
+		passCount: totals.passCount,
+		failCount: totals.failCount,
+		skipCount: totals.skipCount,
+		timeoutCount: totals.timeoutCount
+	}),
+	/* @__PURE__ */ jsxs(Text, {
+		dimColor: true,
+		children: [" ", formatDisplayDuration(totals.durationMs)]
+	})
+] });
+const CoverageItem = ({ state }) => {
+	if (state.coverage === null) return null;
+	const clean = state.coverage.violations.length === 0;
+	return /* @__PURE__ */ jsxs(Text, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: "Coverage:"
+		}),
+		" ",
+		/* @__PURE__ */ jsx(Text, {
+			color: clean ? "green" : "yellow",
+			children: clean ? "✓" : "⚠"
+		}),
+		" ",
+		clean ? "all metrics meet thresholds" : `${state.coverage.violations.length} threshold violation(s)`
+	] });
+};
+const samePath = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+};
+/**
+* Compose the Live region content for the given state + shape. Pure;
+* recomputed every render and every clock tick. Renders the ENTIRE
+* run picture — all rows in discovery order, with running rows capped
+* at MAX_LIVE_RUNNING_ROWS and finished rows always shown.
+*/
+const liveRegion = (state, shape, nowMs, frame) => {
+	const groups = groupByProject(state);
+	const timedOut = state.phase === "timed-out";
+	const finished = state.phase === "finished" || state.phase === "timed-out";
+	const ordered = state.moduleOrder.map((p) => state.modules[p]).filter((m) => m !== void 0);
+	if (shape === "single-test") {
+		const sole = ordered[0];
+		if (sole === void 0 || sole.tests.length === 0) return /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "discovering tests…"
+		});
+		const only = sole.tests[0];
+		if (only === void 0) return /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "discovering tests…"
+		});
+		const failure = only.status === "failed" || only.status === "timed-out" ? state.failures.find((f) => f.testName === only.testName && f.modulePath === sole.modulePath && samePath(f.suitePath, only.suitePath)) : void 0;
+		return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(TestRow, {
+			test: only,
+			indent: 0
+		}), failure !== void 0 ? /* @__PURE__ */ jsx(InlineError, { failure }) : null] });
+	}
+	if (groups.length === 0) return /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: "discovering tests…"
+	});
+	const failuresSection = state.failures.length > 0 ? /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		children: state.failures.map((f) => /* @__PURE__ */ jsx(FailureItem, { failure: f }, failureKey(f)))
+	}) : null;
+	const coverageItem = /* @__PURE__ */ jsx(CoverageItem, { state });
+	const trendItem = state.trend !== null ? /* @__PURE__ */ jsx(TrendLine, { trend: state.trend }) : null;
+	const totalsItem = /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [finished && timedOut ? /* @__PURE__ */ jsx(Text, {
+			color: "#e09a4e",
+			bold: true,
+			children: "⧖ Run timed out"
+		}) : null, /* @__PURE__ */ jsx(TotalsLine, { totals: state.totals })]
+	});
+	if (shape === "workspace") {
+		const nameWidth = Math.max(0, ...groups.map((g) => g.name.length));
+		let runningVisible = 0;
+		let runningOverflow = 0;
+		const rows = [];
+		for (const g of groups) if (g.modules.some(moduleRunning)) if (runningVisible < MAX_LIVE_RUNNING_ROWS) {
+			runningVisible++;
+			const counts = sumCounts(g.modules);
+			const summary = {
+				name: g.name,
+				passCount: counts.passCount,
+				failCount: counts.failCount,
+				skipCount: counts.skipCount,
+				durationMs: 0
+			};
+			rows.push(/* @__PURE__ */ jsx(ProjectRow, {
+				project: summary,
+				counts,
+				running: true,
+				timedOut,
+				elapsedMs: projectElapsedMs(g, nowMs),
+				frame,
+				nameWidth,
+				tagCounts: mergeTagCounts(g.modules)
+			}, g.name));
+		} else runningOverflow++;
+		else {
+			const counts = sumCounts(g.modules);
+			const summary = {
+				name: g.name,
+				passCount: counts.passCount,
+				failCount: counts.failCount,
+				skipCount: counts.skipCount,
+				durationMs: 0
+			};
+			rows.push(/* @__PURE__ */ jsx(ProjectRow, {
+				project: summary,
+				counts,
+				running: false,
+				timedOut,
+				elapsedMs: projectElapsedMs(g, nowMs),
+				frame,
+				nameWidth,
+				tagCounts: mergeTagCounts(g.modules)
+			}, g.name));
+		}
+		return /* @__PURE__ */ jsxs(Fragment, { children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				children: [
+					"Projects (",
+					groups.length,
+					"):"
+				]
+			}),
+			rows,
+			runningOverflow > 0 ? /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					" … and ",
+					runningOverflow,
+					" more running"
+				]
+			}) : null,
+			failuresSection,
+			coverageItem,
+			trendItem,
+			totalsItem
+		] });
+	}
+	if (shape === "single-project") {
+		const nameWidth = Math.max(0, ...ordered.map((m) => m.modulePath.length));
+		let runningVisible = 0;
+		let runningOverflow = 0;
+		const rows = [];
+		for (const m of ordered) if (moduleRunning(m)) if (runningVisible < MAX_LIVE_RUNNING_ROWS) {
+			runningVisible++;
+			rows.push(/* @__PURE__ */ jsx(ModuleStreamRow, {
+				module: m,
+				nowMs,
+				frame,
+				nameWidth,
+				timedOut
+			}, m.modulePath));
+		} else runningOverflow++;
+		else rows.push(/* @__PURE__ */ jsx(ModuleStreamRow, {
+			module: m,
+			nowMs,
+			frame,
+			nameWidth,
+			timedOut
+		}, m.modulePath));
+		return /* @__PURE__ */ jsxs(Fragment, { children: [
+			/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				children: [
+					"Modules (",
+					ordered.length,
+					"):"
+				]
+			}),
+			rows,
+			runningOverflow > 0 ? /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					" … and ",
+					runningOverflow,
+					" more running"
+				]
+			}) : null,
+			failuresSection,
+			coverageItem,
+			trendItem,
+			totalsItem
+		] });
+	}
+	const sole = ordered[0];
+	if (sole === void 0) return /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: "discovering tests…"
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: sole.modulePath
+		}), /* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" — ",
+				sole.tests.length,
+				" tests"
+			]
+		})] }),
+		sole.tests.map((t) => {
+			const failure = t.status === "failed" || t.status === "timed-out" ? state.failures.find((f) => f.testName === t.testName && f.modulePath === sole.modulePath && samePath(f.suitePath, t.suitePath)) : void 0;
+			return /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [/* @__PURE__ */ jsx(TestRow, {
+					test: t,
+					indent: 2
+				}), failure !== void 0 ? /* @__PURE__ */ jsx(InlineError, { failure }) : null]
+			}, testKey(sole.modulePath, t));
+		}),
+		coverageItem,
+		trendItem,
+		totalsItem
+	] });
+};
+/**
+* Root Ink component for the `stream` live renderer. Classifies the run
+* shape and renders the appropriate per-shape live region.
+*
+* @public
+*/
+const StreamApp = ({ state, frameIndex, nowMs }) => {
+	const now = nowMs ?? Date.now();
+	const frame = spinnerFrame(frameIndex);
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		children: liveRegion(state, classifyRunShape(state, groupByProject(state).map((g) => {
+			const c = sumCounts(g.modules);
+			return {
+				name: g.name,
+				passCount: c.passCount,
+				failCount: c.failCount,
+				skipCount: c.skipCount,
+				durationMs: 0
+			};
+		})), now, frame)
+	});
+};
+
+//#endregion
+export { StreamApp };

package/render-ink/SuggestedActions.js

@@ -0,0 +1,49 @@
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/render-ink/SuggestedActions.tsx
+const SEVERITY_COLOR = {
+	info: "blue",
+	warn: "yellow",
+	blocker: "red"
+};
+/**
+* Renders the suggested-actions queue as severity-prefixed rows with
+* optional tool hints. Returns `null` when the actions list is empty.
+*
+* @public
+*/
+const SuggestedActions = ({ actions }) => {
+	if (actions.length === 0) return null;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: "Actions"
+		}), actions.map((action, idx) => /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			children: [/* @__PURE__ */ jsxs(Box, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					color: SEVERITY_COLOR[action.severity],
+					bold: true,
+					children: `  ${action.severity}: `
+				}),
+				/* @__PURE__ */ jsx(Text, { children: action.title }),
+				action.targetTool !== void 0 ? /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						" (tool: ",
+						action.targetTool,
+						")"
+					]
+				}) : null
+			] }), /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: `    ${action.detail}`
+			})]
+		}, `${action.severity}-${idx}-${action.title}`))]
+	});
+};
+
+//#endregion
+export { SuggestedActions };

package/render-ink/TestRow.js

@@ -0,0 +1,33 @@
+import { formatDisplayDuration } from "../format-duration.js";
+import { StatusIcon } from "./StatusIcon.js";
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/render-ink/TestRow.tsx
+const testGlyph = (status) => status;
+/**
+* Renders one test row: status glyph, optional suite prefix, test name, and duration.
+*
+* @public
+*/
+const TestRow = ({ test, indent = 2 }) => {
+	const pad = " ".repeat(indent);
+	const suite = test.suitePath.length > 0 ? `${test.suitePath.join(" > ")} > ` : "";
+	const duration = test.durationMs !== null ? ` (${formatDisplayDuration(test.durationMs)})` : "";
+	return /* @__PURE__ */ jsxs(Box, { children: [
+		/* @__PURE__ */ jsx(Text, { children: pad }),
+		/* @__PURE__ */ jsx(StatusIcon, { status: testGlyph(test.status) }),
+		/* @__PURE__ */ jsxs(Text, { children: [
+			" ",
+			suite,
+			test.testName
+		] }),
+		/* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: duration
+		})
+	] });
+};
+
+//#endregion
+export { TestRow };

package/render-ink/TrendLine.js

@@ -0,0 +1,42 @@
+import { Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/render-ink/TrendLine.tsx
+/**
+* The one-line trend signal — `Trend: <direction> (<N> runs)`.
+*/
+const COLOR = {
+	improving: "green",
+	regressing: "red",
+	stable: "gray"
+};
+/**
+* Renders the one-line trend signal: direction (colored) and run count.
+*
+* @public
+*/
+const TrendLine = ({ trend }) => {
+	const runs = trend.runCount === 1 ? "1 run" : `${trend.runCount} runs`;
+	return /* @__PURE__ */ jsxs(Text, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: "Trend:"
+		}),
+		" ",
+		/* @__PURE__ */ jsx(Text, {
+			color: COLOR[trend.direction],
+			children: trend.direction
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" (",
+				runs,
+				")"
+			]
+		})
+	] });
+};
+
+//#endregion
+export { TrendLine };

package/render-ink/index.js

@@ -0,0 +1,14 @@
+import { CountColumns } from "./CountColumns.js";
+import { CoverageBlock } from "./CoverageBlock.js";
+import { FailureSection } from "./FailureSection.js";
+import { FailuresSection } from "./FailuresSection.js";
+import { StatusIcon } from "./StatusIcon.js";
+import { ModuleHeader } from "./ModuleHeader.js";
+import { ProjectRow } from "./ProjectRow.js";
+import { SPINNER_FRAMES, SPINNER_FRAME_MS, spinnerFrame, spinnerFrameForTime } from "./spinner.js";
+import { TestRow } from "./TestRow.js";
+import { TrendLine } from "./TrendLine.js";
+import { StreamApp } from "./StreamApp.js";
+import { SuggestedActions } from "./SuggestedActions.js";
+
+export {  };

package/render-ink/spinner.js

@@ -0,0 +1,62 @@
+//#region src/render-ink/spinner.ts
+/**
+* Hand-rolled Braille spinner for the `stream` live renderer.
+*
+* No `ink-spinner` dependency — that package is a thin wrapper over the
+* same ten Braille characters plus a timer. The `stream` renderer
+* already needs a frame clock for the ticking elapsed column, so the
+* timer is shared and only the frame array lives here.
+*
+* The frame index is presentation state: it is derived from wall-clock
+* time by `createLiveInk` and passed to `StreamApp` as a prop. It never
+* enters the event-sourced `RenderState`.
+*/
+/**
+* The ten Braille spinner frames, in animation order.
+*
+* @public
+*/
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+/**
+* How long each spinner frame is held, in milliseconds.
+*
+* @public
+*/
+const SPINNER_FRAME_MS = 80;
+/**
+* Resolve the spinner glyph for a frame index. The index wraps modulo
+* the frame count and tolerates negative values, so a wall-clock-derived
+* index is always valid.
+*
+* @param index - the frame index (wraps modulo frame count)
+* @returns the Braille glyph for the given frame
+* @public
+*/
+const spinnerFrame = (index) => {
+	const count = SPINNER_FRAMES.length;
+	return SPINNER_FRAMES[(Math.trunc(index) % count + count) % count];
+};
+/**
+* Derive the spinner frame index from a wall-clock timestamp. Using the
+* clock — rather than a monotonic counter — keeps the animation correct
+* across watch-mode remounts with no extra closure state to reset.
+*
+* @param nowMs - current wall-clock time in milliseconds
+* @returns the frame index for the given timestamp
+* @public
+*/
+const spinnerFrameForTime = (nowMs) => Math.floor(nowMs / 80);
+
+//#endregion
+export { SPINNER_FRAMES, SPINNER_FRAME_MS, spinnerFrame, spinnerFrameForTime };

package/render-ink/tag-suffix.js

@@ -0,0 +1,18 @@
+//#region src/render-ink/tag-suffix.ts
+/**
+* Format a per-row tag-count suffix — sorted `tag:count` pairs joined
+* by two spaces. A single tag is suppressed: a project that is all one
+* kind carries no signal worth the column, matching the agent
+* renderer's behaviour.
+*
+* @packageDocumentation
+*/
+const formatTagSuffix = (tagCounts) => {
+	if (tagCounts === void 0) return "";
+	const entries = Object.entries(tagCounts);
+	if (entries.length <= 1) return "";
+	return [...entries].sort(([a], [b]) => a.localeCompare(b)).map(([tag, count]) => `${tag}:${count}`).join("  ");
+};
+
+//#endregion
+export { formatTagSuffix };