@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-zentui/extensions/zentui/thinking-status.ts

@@ -0,0 +1,69 @@
+import type { ThinkingStepsComponentConfig, ThinkingStepsMode } from "./config";
+
+export type ThinkingStatusState = Readonly<{
+	active: boolean;
+	activeMode?: ThinkingStepsMode;
+	restartRequired: boolean;
+	/** Whole private renderer capability, independent of mode-specific resources. */
+	rendererAvailable?: boolean;
+	/** Streaming input/timer capability for this session. */
+	streamingAvailable?: boolean;
+	/** Irreversible session-local acquisition/callback poison. */
+	streamingPoisoned?: boolean;
+	/** Legacy whole-renderer capability accepted by settings adapters. */
+	available?: boolean;
+	reason?: string;
+}>;
+
+export type ThinkingStatusLabels = Readonly<{
+	saved: ThinkingStepsMode | "disabled";
+	active: ThinkingStepsMode | "native";
+	rendererUnavailable: boolean;
+	streamingUnavailable: boolean;
+	streamingPoisoned: boolean;
+	restartRequired: boolean;
+	reason?: string;
+}>;
+
+function cleanReason(value: string | undefined): string | undefined {
+	const reason = value
+		?.replace(/(?:[;,·]\s*)?restart required\b[.!]?/gi, "")
+		.replace(/^restart pi to apply(?: saved thinking changes)?[.!]?$/i, "")
+		.replace(/^[\s;,.·]+|[\s;,.·]+$/g, "")
+		.trim();
+	if (!reason || /^(?:renderer|streaming) unavailable$/i.test(reason)) return undefined;
+	return reason;
+}
+
+/** Builds independent status facts once so every consumer reports the same state. */
+export function thinkingStatusLabels(
+	config: ThinkingStepsComponentConfig,
+	state: ThinkingStatusState,
+): ThinkingStatusLabels {
+	const rendererAvailable = state.rendererAvailable ?? state.available ?? true;
+	const reason = cleanReason(state.reason);
+	return {
+		saved: config.enabled ? config.mode : "disabled",
+		active: state.active && state.activeMode ? state.activeMode : "native",
+		rendererUnavailable: !rendererAvailable,
+		streamingUnavailable: state.streamingAvailable === false || state.streamingPoisoned === true,
+		streamingPoisoned: state.streamingPoisoned === true,
+		restartRequired: state.restartRequired,
+		...(reason ? { reason } : {}),
+	};
+}
+
+const modeLabel = (mode: ThinkingStepsMode | "disabled" | "native"): string =>
+	`${mode.charAt(0).toUpperCase()}${mode.slice(1)}`;
+
+/** Formats the canonical complete status line used by settings, previews, and apply failures. */
+export function formatThinkingStatus(facts: ThinkingStatusLabels): string {
+	return [
+		`Saved: ${modeLabel(facts.saved)}`,
+		`Active: ${modeLabel(facts.active)}`,
+		...(facts.rendererUnavailable ? ["Renderer unavailable"] : []),
+		...(facts.streamingUnavailable ? ["Streaming unavailable"] : []),
+		...(facts.restartRequired ? ["restart required"] : []),
+		...(facts.reason ? [facts.reason] : []),
+	].join(" · ");
+}

package/dist/extensions/pi-zentui/extensions/zentui/thinking-steps.ts

@@ -0,0 +1,155 @@
+import { sanitizeSgrOnlySourceText } from "./user-message-osc";
+
+/** Hard limits keep private transcript parsing synchronous and bounded. Limits are inclusive. */
+export const THINKING_STEPS_MAX_INPUT_LENGTH = 65_536;
+export const THINKING_STEPS_MAX_STEPS = 128;
+export const THINKING_STEPS_MAX_LABEL_LENGTH = 512;
+
+export type ThinkingStep = Readonly<{
+	number: number;
+	label: string;
+	body: string;
+}>;
+
+type MutableStep = {
+	number: number;
+	label: string;
+	bodyLines: string[];
+};
+
+type StructuralLabel = { label: string };
+type OpaqueBlock = { end: number; malformed: boolean };
+
+const meaningfulLabelPattern = /[\p{L}\p{N}\p{Extended_Pictographic}]/u;
+
+function headingLabel(line: string): StructuralLabel | undefined {
+	const match = /^(#{1,6})[\t ]+(.+?)\s*$/.exec(line);
+	if (!match) return undefined;
+	const label = (match[2] ?? "").replace(/[\t ]+#+[\t ]*$/, "").trim();
+	return label ? { label } : undefined;
+}
+
+function listLabel(line: string): StructuralLabel | undefined {
+	const match = /^(?:[-+*]|\d{1,9}[.)])[\t ]+(.+?)\s*$/.exec(line);
+	const label = match?.[1]?.trim() ?? "";
+	return label ? { label } : undefined;
+}
+
+function structuralLabel(line: string): StructuralLabel | undefined {
+	return headingLabel(line) ?? listLabel(line);
+}
+
+function fenceBlock(lines: readonly string[], start: number): OpaqueBlock | undefined {
+	const opening = /^ {0,3}(`{3,}|~{3,})([^\r\n]*)$/.exec(lines[start] ?? "");
+	if (!opening) return undefined;
+	const marker = opening[1] ?? "";
+	const info = opening[2] ?? "";
+	if (marker[0] === "`" && info.includes("`")) return { end: start, malformed: true };
+	const closing = new RegExp(`^ {0,3}${marker[0]}{${marker.length},}[\\t ]*$`);
+	for (let index = start + 1; index < lines.length; index += 1) {
+		if (closing.test(lines[index] ?? "")) return { end: index, malformed: false };
+	}
+	return { end: lines.length - 1, malformed: true };
+}
+
+function mathBlock(lines: readonly string[], start: number): OpaqueBlock | undefined {
+	const line = lines[start] ?? "";
+	if (/^ {0,3}\$\$.+\$\$[\t ]*$/.test(line)) return { end: start, malformed: false };
+	const close = /^ {0,3}\$\$[\t ]*$/.test(line)
+		? /^(?: {0,3})\$\$[\t ]*$/
+		: /^ {0,3}\\\[[\t ]*$/.test(line)
+			? /^(?: {0,3})\\\][\t ]*$/
+			: undefined;
+	if (!close) return undefined;
+	for (let index = start + 1; index < lines.length; index += 1) {
+		if (close.test(lines[index] ?? "")) return { end: index, malformed: false };
+	}
+	return { end: lines.length - 1, malformed: true };
+}
+
+function isTopLevelProse(line: string): boolean {
+	if (!line.trim() || /^[\t ]/.test(line)) return false;
+	if (/^(?: {0,3})(?:`{3,}|~{3,}|\$\$|\\\[|>)/.test(line)) return false;
+	return !/^(?:#{1,6}(?:[\t ]|$)|[-+*](?:[\t ]|$)|\d{1,9}[.)](?:[\t ]|$))/.test(line);
+}
+
+function safeLabel(label: string): string | undefined {
+	const trimmed = label.trim();
+	if (
+		!trimmed ||
+		trimmed.length > THINKING_STEPS_MAX_LABEL_LENGTH ||
+		!meaningfulLabelPattern.test(trimmed) ||
+		trimmed.includes("\t")
+	) {
+		return undefined;
+	}
+	return trimmed;
+}
+
+function finishSteps(steps: MutableStep[]): ThinkingStep[] | undefined {
+	const finished: ThinkingStep[] = [];
+	for (const step of steps) {
+		const label = safeLabel(step.label);
+		if (!label) return undefined;
+		let first = 0;
+		let last = step.bodyLines.length;
+		while (first < last && !(step.bodyLines[first] ?? "").trim()) first += 1;
+		while (last > first && !(step.bodyLines[last - 1] ?? "").trim()) last -= 1;
+		finished.push(
+			Object.freeze({
+				number: step.number,
+				label,
+				body: step.bodyLines.slice(first, last).join("\n"),
+			}),
+		);
+	}
+	return finished;
+}
+
+/** Parse source-level structure; fenced and display-math blocks remain opaque bodies. */
+export function parseThinkingSteps(markdown: string): readonly ThinkingStep[] | undefined {
+	if (!markdown || markdown.length > THINKING_STEPS_MAX_INPUT_LENGTH) return undefined;
+	const source = sanitizeSgrOnlySourceText(markdown.replace(/\r\n/g, "\n"));
+	if (source === undefined || !source.trim()) return undefined;
+
+	const lines = source.split("\n");
+	const steps: MutableStep[] = [];
+	let current: MutableStep | undefined;
+	let paragraphBoundary = true;
+	const startStep = (label: string) => {
+		if (steps.length >= THINKING_STEPS_MAX_STEPS) return false;
+		current = { number: steps.length + 1, label, bodyLines: [] };
+		steps.push(current);
+		paragraphBoundary = false;
+		return true;
+	};
+
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		if (!line.trim()) {
+			if (current) current.bodyLines.push(line);
+			paragraphBoundary = true;
+			continue;
+		}
+		const opaque = fenceBlock(lines, index) ?? mathBlock(lines, index);
+		if (opaque) {
+			if (opaque.malformed || !current) return undefined;
+			current.bodyLines.push(...lines.slice(index, opaque.end + 1));
+			index = opaque.end;
+			continue;
+		}
+		const structural = structuralLabel(line);
+		if (structural) {
+			if (!startStep(structural.label)) return undefined;
+			continue;
+		}
+		if (isTopLevelProse(line) && (!current || paragraphBoundary)) {
+			if (!startStep(line.trim())) return undefined;
+			continue;
+		}
+		if (!current) return undefined;
+		current.bodyLines.push(line);
+	}
+	if (steps.length === 0) return undefined;
+	return finishSteps(steps);
+}

package/dist/extensions/pi-zentui/extensions/zentui/ui.ts

@@ -602,7 +602,7 @@ function renderAccentRailFrameFromBase({
 		above: parsedTop?.count,
 		below: parsedBottom?.count,
 	};
-	const lines = renderAccentRailEditorFrame({
+	const renderedLines = renderAccentRailEditorFrame({
 		width,
 		editorLines,
 		autocompleteLines,
@@ -610,6 +610,7 @@ function renderAccentRailFrameFromBase({
 		uiTheme,
 		config,
 	});
+	const lines = renderedLines.length === 1 ? ["", ...renderedLines, ""] : renderedLines;
 	POLISHED_FRAME_SPLITS.set(lines, {
 		rows: Object.freeze([...lines]),
 		split: { editorLines, trailingLines: autocompleteLines, viewport },

package/dist/extensions/pi-zentui/extensions/zentui/user-message-osc.ts

@@ -221,15 +221,29 @@ function filterBalancedUserMessageTerminalText(text: string, options: FilterOpti
 	return filterUserMessageTerminalText(text, { ...options, preserveValidOsc8: false }).text;
 }
 
+const sourceFilterOptions = {
+	preserveValidOsc8: false,
+	preserveSourceWhitespace: true,
+} as const;
+
 /** Strip every terminal control from untrusted source text before Markdown rendering. */
 export function sanitizeUserMessageSourceText(text: string): string {
 	return filterBalancedUserMessageTerminalText(text, {
-		preserveValidOsc8: false,
-		preserveSourceWhitespace: true,
+		...sourceFilterOptions,
 		preserveSgr: false,
 	});
 }
 
+/** Strip strict 7-bit CSI SGR, rejecting source that contains any other terminal control. */
+export function sanitizeSgrOnlySourceText(text: string): string | undefined {
+	const sgrPreserved = filterBalancedUserMessageTerminalText(text, {
+		...sourceFilterOptions,
+		preserveSgr: true,
+	});
+	if (sgrPreserved !== text) return undefined;
+	return sanitizeUserMessageSourceText(text);
+}
+
 /**
  * Sanitize a predecessor-rendered row. Pi formatting needs only SGR and
  * structurally valid 7-bit OSC 8; every other terminal control is removed.

package/dist/extensions/pi-zentui/extensions/zentui/user-message-styles.ts

@@ -24,7 +24,7 @@ function themeFg(theme: Theme | undefined, color: ThemeColor, text: string): str
 	return theme ? theme.fg(color, text) : text;
 }
 
-function makeMarkdownTheme(theme: Theme | undefined): MarkdownTheme {
+export function makeMarkdownTheme(theme: Theme | undefined): MarkdownTheme {
 	return {
 		heading: (text) => themeFg(theme, "mdHeading", text),
 		link: (text) => themeFg(theme, "mdLink", text),

package/dist/extensions/pi-zentui/test/config-load-lifecycle.test.ts

@@ -0,0 +1,124 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { AssistantMessageComponent, initTheme } from "@earendil-works/pi-coding-agent";
+import { describe, expect, it, vi } from "vitest";
+import type { PolishedTuiConfig } from "../extensions/zentui/config";
+
+const mocks = vi.hoisted(() => ({
+	config: undefined as unknown as PolishedTuiConfig,
+	loadConfig: vi.fn(() => mocks.config),
+}));
+
+vi.mock("../extensions/zentui/config", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
+	return { ...actual, loadConfig: mocks.loadConfig };
+});
+
+import { defaultConfig } from "../extensions/zentui/config";
+import zentui from "../extensions/zentui/index";
+
+initTheme("dark", false);
+
+type Handler = (event: unknown, ctx: unknown) => unknown | Promise<unknown>;
+type Command = { handler(args: string, ctx: unknown): Promise<void> };
+type SettingsComponent = { render(width: number): string[]; handleInput(data: string): void };
+
+function config(enabled: boolean): PolishedTuiConfig {
+	const value = structuredClone(defaultConfig);
+	value.projectRefreshIntervalMs = 0;
+	value.components.editor.enabled = false;
+	value.components.userMessages.enabled = false;
+	value.components.selectorBorders.enabled = false;
+	value.components.footer.style = "native";
+	value.components.workingLine.enabled = false;
+	value.components.thinkingSteps = { enabled, mode: "rail" };
+	return value;
+}
+
+function theme(): Theme {
+	return {
+		fg: (_color: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		underline: (text: string) => text,
+		strikethrough: (text: string) => text,
+		getThinkingBorderColor: () => (text: string) => text,
+	} as unknown as Theme;
+}
+
+function context() {
+	let editor: unknown;
+	let settings: SettingsComponent | undefined;
+	const ctx = {
+		mode: "tui",
+		hasUI: true,
+		cwd: process.cwd(),
+		ui: {
+			theme: theme(),
+			setFooter() {},
+			setEditorComponent(value: unknown) {
+				editor = value;
+			},
+			getEditorComponent: () => editor,
+			getEditorText: () => "",
+			setEditorText() {},
+			onTerminalInput: () => () => {},
+			notify() {},
+			async custom(factory: (...args: unknown[]) => unknown) {
+				settings = factory({ requestRender() {} }, theme(), {}, () => {}) as SettingsComponent;
+			},
+		},
+		sessionManager: {
+			getBranch: () => [],
+			getEntries: () => [],
+			getSessionName: () => undefined,
+		},
+		getContextUsage: () => undefined,
+	};
+	return { ctx, settings: () => settings };
+}
+
+async function emit(handlers: Map<string, Handler[]>, event: string, ctx: unknown) {
+	for (const handler of handlers.get(event) ?? []) await handler({}, ctx);
+}
+
+describe("session config loading", () => {
+	it("does not read at registration, loads exactly once per start, and observes external changes", async () => {
+		mocks.loadConfig.mockClear();
+		mocks.config = config(false);
+		const handlers = new Map<string, Handler[]>();
+		let command: Command | undefined;
+		zentui({
+			on(event: string, handler: Handler) {
+				handlers.set(event, [...(handlers.get(event) ?? []), handler]);
+			},
+			registerCommand(name: string, value: Command) {
+				if (name === "zentui") command = value;
+			},
+			registerEntryRenderer() {},
+			getThinkingLevel: () => "off",
+		} as never);
+		expect(mocks.loadConfig).not.toHaveBeenCalled();
+
+		const harness = context();
+		const native = AssistantMessageComponent.prototype.updateContent;
+		await emit(handlers, "session_start", harness.ctx);
+		expect(mocks.loadConfig).toHaveBeenCalledTimes(1);
+		expect(AssistantMessageComponent.prototype.updateContent).toBe(native);
+		await emit(handlers, "session_shutdown", harness.ctx);
+
+		mocks.config = config(true);
+		await emit(handlers, "session_start", harness.ctx);
+		expect(mocks.loadConfig).toHaveBeenCalledTimes(2);
+		expect(AssistantMessageComponent.prototype.updateContent).not.toBe(native);
+		expect(command).toBeDefined();
+		await command?.handler("", harness.ctx);
+		const settingsComponent = harness.settings();
+		for (let index = 0; index < 3; index += 1) settingsComponent?.handleInput("\t");
+		const settings = settingsComponent?.render(160).join("\n") ?? "";
+		expect(settings).toContain("Thinking (Experimental)");
+		expect(settings).toMatch(/Enabled.*enabled/);
+		expect(settings).toMatch(/Mode.*Rail/);
+		await emit(handlers, "session_shutdown", harness.ctx);
+		expect(AssistantMessageComponent.prototype.updateContent).toBe(native);
+	});
+});

package/dist/extensions/pi-zentui/test/config.test.ts

@@ -52,6 +52,7 @@ import {
 	saveSelectorBordersComponentPatch,
 	saveSeparatorPatch,
 	saveStarshipFooterStylePatch,
+	saveThinkingStepsComponentPatch,
 	saveUiFeaturesPatch,
 	saveUserMessagesComponentPatch,
 	saveWorkingLineComponentPatch,
@@ -132,6 +133,7 @@ describe("canonical config resolution", () => {
 				colorSource: "theme",
 				styles: { framed: {}, "framed-copy-friendly": {}, compact: {}, labeled: {} },
 			},
+			thinkingSteps: { enabled: false, mode: "tree" },
 			workingLine: {
 				enabled: true,
 				turnSummary: true,
@@ -569,6 +571,84 @@ describe("canonical config resolution", () => {
 	});
 });
 
+describe("thinking-steps config", () => {
+	it("defaults independently and normalizes invalid canonical leaves", () => {
+		const first = mergeConfig({});
+		const second = mergeConfig({});
+		expect(first.components.thinkingSteps).toEqual({ enabled: false, mode: "tree" });
+		expect(first.components.thinkingSteps).not.toBe(second.components.thinkingSteps);
+		expect(
+			mergeConfig({ components: { thinkingSteps: { enabled: true, mode: "rail" } } }).components
+				.thinkingSteps,
+		).toEqual({ enabled: true, mode: "rail" });
+		expect(
+			mergeConfig({
+				components: {
+					thinkingSteps: { enabled: true, mode: "streaming" },
+				},
+			}).components.thinkingSteps,
+		).toEqual({ enabled: true, mode: "streaming" });
+		expect(
+			mergeConfig({
+				components: {
+					thinkingSteps: { enabled: true, mode: "streaming-experimental" },
+				},
+			}).components.thinkingSteps,
+		).toEqual({ enabled: true, mode: "streaming" });
+		for (const mode of [undefined, "native", "Rail"]) {
+			expect(
+				mergeConfig({ components: { thinkingSteps: { enabled: "yes", mode } } }).components
+					.thinkingSteps,
+			).toEqual({ enabled: false, mode: "tree" });
+		}
+	});
+
+	it("persists atomic component patches and preserves unknown keys", () => {
+		withConfig(
+			{
+				futureTop: { keep: true },
+				components: { thinkingSteps: { future: { keep: true } } },
+			},
+			(path) => {
+				const saved = saveThinkingStepsComponentPatch({ enabled: true, mode: "rail" }, path);
+				const raw = readRaw(path);
+				expect(saved.components.thinkingSteps).toEqual({ enabled: true, mode: "rail" });
+				expect(raw.components.thinkingSteps).toMatchObject({
+					enabled: true,
+					mode: "rail",
+					future: { keep: true },
+				});
+				expect(raw.futureTop).toEqual({ keep: true });
+				expect(configTempFiles(join(path, ".."))).toEqual([]);
+			},
+		);
+	});
+
+	it("normalizes the one-window Streaming migration alias on the next save", () => {
+		withConfig(
+			{ components: { thinkingSteps: { enabled: false, mode: "streaming-experimental" } } },
+			(path) => {
+				const saved = saveThinkingStepsComponentPatch({ enabled: true }, path);
+				expect(saved.components.thinkingSteps).toEqual({ enabled: true, mode: "streaming" });
+				expect(readRaw(path).components.thinkingSteps).toMatchObject({
+					enabled: true,
+					mode: "streaming",
+				});
+			},
+		);
+	});
+
+	it("refuses to overwrite corrupt files", () => {
+		withConfig(undefined, (path) => {
+			writeFileSync(path, "{broken");
+			expect(() => saveThinkingStepsComponentPatch({ enabled: true }, path)).toThrow(
+				/Refusing to save Zentui config/,
+			);
+			expect(readFileSync(path, "utf8")).toBe("{broken");
+		});
+	});
+});
+
 describe("working-line config", () => {
 	it("defaults to cloned custom presets and migrates legacy modes without losing values", () => {
 		const first = mergeConfig({}).components.workingLine.messages;
@@ -1387,6 +1467,7 @@ describe("compatibility saver recipes", () => {
 				"editor",
 				"footer",
 				"selectorBorders",
+				"thinkingSteps",
 				"userMessages",
 				"workingLine",
 			]);
@@ -1758,8 +1839,7 @@ describe("mergeConfig", () => {
 			mergeConfig({
 				components: { footer: { styles: { starship: { pathDisplay: { mode: "repository" } } } } },
 			}).components.footer.styles.starship.pathDisplay,
-		).toEqual({ mode: "repository", depth: 2 });
-		expect(mergeConfig({ pathDisplay: { mode: "fish", depth: -3 } }).pathDisplay).toEqual({
+		).toEqual({ mode: "repository", depth: 2 });		expect(mergeConfig({ pathDisplay: { mode: "fish", depth: -3 } }).pathDisplay).toEqual({
 			mode: "basename",
 			depth: 2,
 		});

package/dist/extensions/pi-zentui/test/editor-viewport-indicators.test.ts

@@ -976,7 +976,7 @@ describe("same-render autocomplete capture", () => {
 });
 
 describe("accent rail editor integration", () => {
-	it("decorates trusted wrapped input and autocomplete rows", () => {
+	it("decorates trusted wrapped input and preserves multi-row autocomplete output", () => {
 		const editor = wrapped(baseEditor({ autocomplete: ["one", "two"] }), {
 			style: "accent-rail",
 		});
@@ -987,6 +987,17 @@ describe("accent rail editor integration", () => {
 		expect(lines.slice(1).map((line) => line.trimEnd())).toEqual(["one", "two"]);
 	});
 
+	it("places one reserved row on each side of a one-row rail", () => {
+		const editor = wrapped(baseEditor({}), { style: "accent-rail" });
+		const lines = editor.render(24);
+
+		expect(lines).toHaveLength(3);
+		expect(lines[0]).toBe("");
+		expect(lines[1]).toMatch(/^▎ typed text/);
+		expect(lines[2]).toBe("");
+		expect([...lines, "footer"].slice(-3)).toEqual([lines[1], "", "footer"]);
+	});
+
 	it("fails open from the reduced same-render rows for untrusted third-party output", () => {
 		const base = baseEditor({ malformedTop: "third-party header" });
 		const editor = wrapped(base, { style: "accent-rail" });
@@ -995,9 +1006,11 @@ describe("accent rail editor integration", () => {
 		expect(lines.join("\n")).not.toContain("▎");
 	});
 
-	it("renders the standalone editor with the same accent rail", () => {
+	it("renders the standalone editor with the same reserved rows and accent rail", () => {
 		const lines = standalone("accent-rail").render(24);
-		expect(lines.some((line) => line.startsWith("▎ "))).toBe(true);
+		expect(lines[0]).toBe("");
+		expect(lines[1]).toMatch(/^▎ /);
+		expect(lines[2]).toBe("");
 		expect(lines.every((line) => visibleWidth(line) <= 24)).toBe(true);
 	});
 });
@@ -1063,7 +1076,9 @@ describe("minimalist editor integration", () => {
 		expect(rawWidths).toEqual([36, 38, 36, 34, 36]);
 		expect(polished.join("\n").match(/provider/g)).toHaveLength(1);
 		expect(lowRail.join("\n").match(/provider/g)).toHaveLength(1);
-		expect(accentRail[0]).toMatch(/^▎ typed text/);
+		expect(accentRail[0]).toBe("");
+		expect(accentRail[1]).toMatch(/^▎ typed text/);
+		expect(accentRail[2]).toBe("");
 		expect(accentRail.join("\n")).not.toContain("provider");
 		expect(minimalist[0]).toMatch(/^╭.*╮$/);
 		expect(minimalist.at(-1)).toMatch(/^╰.*╯$/);