gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

package/packages/pi-coding-agent/src/modes/interactive/components/tool-card-cleanup-and-success-runtime.test.ts

@@ -1,212 +0,0 @@
-// Runtime regression tests for the post-compaction tool-card cleanup and the
-// green-bordered success-notification rendering. Replaces the source-grep
-// `src/tests/tui-running-and-success-box.test.ts` that was deleted in #4875
-// (tracked as #4872).
-//
-// The previous tests asserted on identifier presence and method signature
-// shape via regex. A regression that routed `success` notifications through
-// `showStatus` (dim text) by accident would not have failed because the
-// `showSuccess` method would still exist and still match the regex. These
-// tests instead drive the components through the actual scenario and assert
-// on rendered output.
-
-import assert from "node:assert/strict";
-import { describe, it, before } from "node:test";
-
-import { Container, Text } from "@gsd/pi-tui";
-import stripAnsi from "strip-ansi";
-
-import { initTheme, theme } from "../theme/theme.js";
-import { DynamicBorder } from "./dynamic-border.js";
-import { ToolExecutionComponent } from "./tool-execution.js";
-
-// Theme is a globalThis-shared singleton that throws if not initialized.
-// Initialize once before any test that exercises themed rendering.
-before(() => {
-	initTheme("dark");
-});
-
-interface MockTui {
-	renderCount: number;
-	requestRender(): void;
-}
-
-function makeMockTUI(): MockTui {
-	return {
-		renderCount: 0,
-		requestRender() {
-			this.renderCount++;
-		},
-	};
-}
-
-// ─── Bug 1: tool cards stuck in "Running" after compaction ──────────────
-
-describe("ToolExecutionComponent post-compaction cleanup", () => {
-	it("renders 'Running' status while the tool call has no result", () => {
-		// Baseline: a freshly-constructed component (mid-stream) must show
-		// the running badge — this is the state we need to flip OUT of when
-		// compaction removes the result message.
-		const ui = makeMockTUI();
-		const c = new ToolExecutionComponent(
-			"read_file",
-			{ path: "/tmp/x.txt" },
-			{},
-			undefined,
-			ui as never,
-		);
-		const rendered = c.render(60).map(stripAnsi).join("\n");
-		assert.ok(
-			rendered.includes("Running"),
-			"freshly constructed component should render 'Running' badge",
-		);
-	});
-
-	it("markHistoricalNoResult flips a stuck tool card OUT of 'Running'", () => {
-		// Real bug: after session-history replay (post-compaction or session
-		// switch), tool calls without matching tool_result messages stay in
-		// isPartial = true forever. markHistoricalNoResult must produce a
-		// rendered output that no longer reads "Running".
-		const ui = makeMockTUI();
-		const c = new ToolExecutionComponent(
-			"read_file",
-			{ path: "/tmp/x.txt" },
-			{},
-			undefined,
-			ui as never,
-		);
-
-		c.markHistoricalNoResult();
-
-		const rendered = c.render(60).map(stripAnsi).join("\n");
-		assert.ok(
-			!rendered.includes("Running"),
-			"after markHistoricalNoResult, the tool card must NOT render 'Running' — got:\n" +
-				rendered,
-		);
-		assert.ok(
-			rendered.includes("Done"),
-			"flipped card should render 'Done' status (no-result success)",
-		);
-	});
-
-	it("markHistoricalNoResult is idempotent when a real result already exists", () => {
-		// Late-arriving stream events must not clobber legitimate results.
-		// We observe the no-clobber via behaviour: a card that completed
-		// with a real result keeps its "Done" badge and content even if
-		// markHistoricalNoResult fires again afterwards.
-		const ui = makeMockTUI();
-		const c = new ToolExecutionComponent(
-			"read_file",
-			{ path: "/tmp/x.txt" },
-			{},
-			undefined,
-			ui as never,
-		);
-
-		// Use the public completion path the runtime calls.
-		c.updateResult(
-			{
-				content: [{ type: "text", text: "real-result-payload" }],
-				isError: false,
-			},
-			false, // isPartial = false → "Done"
-		);
-
-		const before = c.render(60).map(stripAnsi).join("\n");
-		assert.ok(before.includes("Done"), "after complete(), card shows 'Done'");
-
-		c.markHistoricalNoResult(); // must early-return
-		const after = c.render(60).map(stripAnsi).join("\n");
-		assert.equal(
-			after,
-			before,
-			"markHistoricalNoResult must NOT mutate state when a real result is already present",
-		);
-	});
-});
-
-// ─── Bug 2: success notifications render as a green bordered box ────────
-
-describe("Success-notification rendering — DynamicBorder + success theme", () => {
-	// We drive the same component composition that interactive-mode.showSuccess
-	// builds (DynamicBorder + Text + DynamicBorder, all themed with
-	// theme.fg("success", …)) and assert on the rendered output, rather than
-	// trying to instantiate the full InteractiveMode (which requires a real
-	// session, bridge, and TUI runtime).
-	function buildSuccessNotification(message: string): Container {
-		const c = new Container();
-		const successColor = (text: string) => theme.fg("success", text);
-		c.addChild(new DynamicBorder(successColor));
-		c.addChild(new Text(theme.fg("success", message), 1, 0));
-		c.addChild(new DynamicBorder(successColor));
-		return c;
-	}
-
-	it("renders a top and bottom horizontal border framing the message", () => {
-		const c = buildSuccessNotification("Milestone M042 ready.");
-		const lines = c.render(40);
-
-		// First and last lines should be horizontal-rule borders
-		// (DynamicBorder renders a row of "─" characters).
-		const firstStripped = stripAnsi(lines[0]);
-		const lastStripped = stripAnsi(lines[lines.length - 1]);
-
-		assert.ok(
-			firstStripped.includes("─"),
-			`first line should be a border (got: ${JSON.stringify(firstStripped)})`,
-		);
-		assert.ok(
-			lastStripped.includes("─"),
-			`last line should be a border (got: ${JSON.stringify(lastStripped)})`,
-		);
-		assert.ok(
-			lines.length >= 3,
-			`success notification must have at least 3 lines (top border, message, bottom border) — got ${lines.length}`,
-		);
-	});
-
-	it("the message text appears between the two borders", () => {
-		const c = buildSuccessNotification("Milestone M042 ready.");
-		const lines = c.render(40);
-
-		const messageRow = lines.findIndex((l) => stripAnsi(l).includes("Milestone M042 ready."));
-		assert.ok(messageRow > 0, "message must appear after the top border");
-		assert.ok(
-			messageRow < lines.length - 1,
-			"message must appear before the bottom border",
-		);
-	});
-
-	it("borders carry ANSI styling (not plain dim text like showStatus)", () => {
-		// Goodhart-resistant: if a regression routed success through
-		// showStatus, the borders would be missing AND the rendered text
-		// would be plain (or only dim-styled, not success-colored). We
-		// observe the border lines carry ANSI escape codes — the literal
-		// foreground color depends on the theme (which is system-dependent
-		// in CI), so we don't pin a specific code but DO require styling
-		// to be present.
-		const c = buildSuccessNotification("ok");
-		const lines = c.render(40);
-		const top = lines[0];
-		assert.ok(
-			top !== stripAnsi(top),
-			"top border must contain ANSI styling — a plain unstyled border " +
-				"would indicate the rendering bypassed theme.fg('success', ...)",
-		);
-	});
-
-	it("plain Text status (the showStatus path) does NOT produce a bordered box", () => {
-		// Counter-test: this is what the bug looked like — a single dim Text
-		// with no surrounding border. If anyone ever "fixes" the showSuccess
-		// regression by also adding borders to showStatus, this test will
-		// surface the conflation.
-		const plain = new Text(theme.fg("dim", "Milestone M042 ready."), 1, 0);
-		const lines = plain.render(40);
-		const joined = lines.map(stripAnsi).join("\n");
-		assert.ok(
-			!joined.includes("─"),
-			"plain Text (showStatus path) must NOT contain border characters",
-		);
-	});
-});

package/packages/pi-coding-agent/src/tests/system-prompt-cache-stability.test.ts

@@ -1,102 +0,0 @@
-// @gsd/pi-coding-agent + system-prompt-cache-stability.test — regression
-// coverage for #5019. The system prompt must NOT include a per-call timestamp
-// by default; embedding `Date.toLocaleString()` in the cached prefix
-// invalidates Anthropic prompt-cache hits on every request and incurs the
-// cache-write premium. The opt-in `includeDateTime` flag preserves the prior
-// behavior for callers that explicitly want clock awareness.
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { buildSystemPrompt } from "../core/system-prompt.js";
-
-// ─── Default branch (no customPrompt) ──────────────────────────────────────
-
-test("buildSystemPrompt: default omits 'Current date and time' line", () => {
-	const prompt = buildSystemPrompt({ selectedTools: ["read", "edit"] });
-	assert.ok(
-		!prompt.includes("Current date and time:"),
-		`prompt should not include the dateTime line by default. Got:\n${prompt}`,
-	);
-});
-
-test("buildSystemPrompt: includeDateTime=true emits 'Current date and time' line", () => {
-	const prompt = buildSystemPrompt({
-		selectedTools: ["read", "edit"],
-		includeDateTime: true,
-	});
-	assert.match(
-		prompt,
-		/Current date and time: /,
-		"prompt should include the dateTime line when explicitly opted in",
-	);
-});
-
-test("buildSystemPrompt: includeDateTime=false explicit also omits the line", () => {
-	const prompt = buildSystemPrompt({
-		selectedTools: ["read", "edit"],
-		includeDateTime: false,
-	});
-	assert.ok(!prompt.includes("Current date and time:"));
-});
-
-// ─── Custom-prompt branch ──────────────────────────────────────────────────
-
-test("buildSystemPrompt (customPrompt): default omits 'Current date and time' line", () => {
-	const prompt = buildSystemPrompt({
-		customPrompt: "CUSTOM BASE",
-		selectedTools: ["read"],
-	});
-	assert.ok(!prompt.includes("Current date and time:"));
-});
-
-test("buildSystemPrompt (customPrompt): includeDateTime=true emits the line", () => {
-	const prompt = buildSystemPrompt({
-		customPrompt: "CUSTOM BASE",
-		selectedTools: ["read"],
-		includeDateTime: true,
-	});
-	assert.match(prompt, /Current date and time: /);
-});
-
-// ─── Cache-stability invariant ─────────────────────────────────────────────
-
-test("buildSystemPrompt: two back-to-back default calls produce identical prompts", async () => {
-	// The bug: the previous default-on `dateTime` line included `second: "2-digit"`,
-	// so two calls within the same second could match but any longer gap busted
-	// the cache. Asserting equality across a deliberate sub-second sleep proves
-	// the byte-for-byte stability that Anthropic prompt caching requires.
-	const first = buildSystemPrompt({ selectedTools: ["read", "edit"], cwd: "/tmp/example" });
-	await new Promise((resolve) => setTimeout(resolve, 1100));
-	const second = buildSystemPrompt({ selectedTools: ["read", "edit"], cwd: "/tmp/example" });
-	assert.equal(
-		first,
-		second,
-		"system prompt must be byte-for-byte stable across calls so the prompt cache can hit",
-	);
-});
-
-test("buildSystemPrompt: includeDateTime=true intentionally produces different prompts across the second boundary", async () => {
-	// Inverse of the cache-stability test: when callers opt in, the dateTime
-	// line is expected to vary. This documents the trade-off the flag exists
-	// to surface.
-	const first = buildSystemPrompt({
-		selectedTools: ["read"],
-		cwd: "/tmp/example",
-		includeDateTime: true,
-	});
-	await new Promise((resolve) => setTimeout(resolve, 1100));
-	const second = buildSystemPrompt({
-		selectedTools: ["read"],
-		cwd: "/tmp/example",
-		includeDateTime: true,
-	});
-	assert.notEqual(first, second, "opt-in dateTime is expected to vary across the second boundary");
-});
-
-// ─── Cwd preservation ──────────────────────────────────────────────────────
-
-test("buildSystemPrompt: 'Current working directory' line is preserved (only dateTime is removed)", () => {
-	const prompt = buildSystemPrompt({ selectedTools: ["read"], cwd: "/tmp/example" });
-	assert.match(prompt, /Current working directory: \/tmp\/example/);
-});

package/packages/pi-coding-agent/src/tests/token-telemetry.test.ts

@@ -1,200 +0,0 @@
-// @gsd/pi-coding-agent + token-telemetry.test — coverage for #5023.
-// Verifies the env-gated emitter:
-//   - is silent by default (no behavior change for existing users)
-//   - emits a single valid JSON line when PI_TOKEN_TELEMETRY=1
-//   - record shape captures the cache breakdown the providers already extract
-//   - cacheHitRatio math is correct, including the no-input edge case
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-
-import type { AssistantMessage } from "@gsd/pi-ai";
-
-import { buildTokenTelemetryRecord, emitTokenTelemetry } from "../core/token-telemetry.js";
-
-function makeAssistantMessage(overrides: Partial<AssistantMessage> = {}): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [],
-		api: "anthropic-messages",
-		provider: "anthropic",
-		model: "claude-sonnet-4-6",
-		usage: {
-			input: 100,
-			output: 50,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 150,
-			cost: { input: 0.3, output: 0.75, cacheRead: 0, cacheWrite: 0, total: 1.05 },
-		},
-		stopReason: "stop",
-		timestamp: 1700000000000,
-		...overrides,
-	};
-}
-
-// ─── buildTokenTelemetryRecord ─────────────────────────────────────────────
-
-describe("buildTokenTelemetryRecord", () => {
-	test("captures all fields from a typical message", () => {
-		const msg = makeAssistantMessage();
-		const record = buildTokenTelemetryRecord(msg);
-		assert.deepEqual(record, {
-			ts: 1700000000000,
-			model: "claude-sonnet-4-6",
-			stopReason: "stop",
-			input: 100,
-			output: 50,
-			cacheRead: 0,
-			cacheWrite: 0,
-			costTotal: 1.05,
-			cacheHitRatio: 0,
-		});
-	});
-
-	test("cacheHitRatio = read / (read + input) when both present", () => {
-		const msg = makeAssistantMessage({
-			usage: {
-				input: 200,
-				output: 50,
-				cacheRead: 800,
-				cacheWrite: 0,
-				totalTokens: 1050,
-				cost: { input: 0.6, output: 0.75, cacheRead: 0.24, cacheWrite: 0, total: 1.59 },
-			},
-		});
-		const record = buildTokenTelemetryRecord(msg);
-		assert.equal(record.cacheRead, 800);
-		assert.equal(record.input, 200);
-		assert.equal(record.cacheHitRatio, 0.8);
-	});
-
-	test("cacheHitRatio = 0 when both read and input are 0 (no division-by-zero)", () => {
-		const msg = makeAssistantMessage({
-			usage: {
-				input: 0,
-				output: 50,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 50,
-				cost: { input: 0, output: 0.75, cacheRead: 0, cacheWrite: 0, total: 0.75 },
-			},
-		});
-		const record = buildTokenTelemetryRecord(msg);
-		assert.equal(record.cacheHitRatio, 0);
-	});
-
-	test("cacheHitRatio = 1 when only cacheRead present (full hit)", () => {
-		const msg = makeAssistantMessage({
-			usage: {
-				input: 0,
-				output: 50,
-				cacheRead: 5000,
-				cacheWrite: 0,
-				totalTokens: 5050,
-				cost: { input: 0, output: 0.75, cacheRead: 1.5, cacheWrite: 0, total: 2.25 },
-			},
-		});
-		const record = buildTokenTelemetryRecord(msg);
-		assert.equal(record.cacheHitRatio, 1);
-	});
-
-	test("cacheWrite is captured (the cache-miss-with-cache-control case from #5019)", () => {
-		const msg = makeAssistantMessage({
-			usage: {
-				input: 50,
-				output: 100,
-				cacheRead: 0,
-				cacheWrite: 5000,
-				totalTokens: 5150,
-				cost: { input: 0.15, output: 1.5, cacheRead: 0, cacheWrite: 18.75, total: 20.4 },
-			},
-		});
-		const record = buildTokenTelemetryRecord(msg);
-		assert.equal(record.cacheWrite, 5000);
-		assert.equal(record.cacheHitRatio, 0, "no read = ratio 0 even when write is large");
-	});
-
-	test("error stopReason is captured verbatim", () => {
-		const msg = makeAssistantMessage({ stopReason: "error", errorMessage: "rate_limit" });
-		assert.equal(buildTokenTelemetryRecord(msg).stopReason, "error");
-	});
-});
-
-// ─── emitTokenTelemetry ────────────────────────────────────────────────────
-
-describe("emitTokenTelemetry", () => {
-	let captured: string[];
-	let originalWrite: typeof process.stderr.write;
-	let originalEnv: string | undefined;
-
-	beforeEach(() => {
-		captured = [];
-		originalWrite = process.stderr.write.bind(process.stderr);
-		// Replace stderr.write with a capture; preserve the same return contract.
-		process.stderr.write = ((chunk: string | Uint8Array): boolean => {
-			captured.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
-			return true;
-		}) as typeof process.stderr.write;
-		originalEnv = process.env.PI_TOKEN_TELEMETRY;
-	});
-
-	afterEach(() => {
-		process.stderr.write = originalWrite;
-		if (originalEnv === undefined) {
-			delete process.env.PI_TOKEN_TELEMETRY;
-		} else {
-			process.env.PI_TOKEN_TELEMETRY = originalEnv;
-		}
-	});
-
-	test("silent by default (env var unset)", () => {
-		delete process.env.PI_TOKEN_TELEMETRY;
-		emitTokenTelemetry(makeAssistantMessage());
-		assert.equal(captured.length, 0);
-	});
-
-	test("silent when env var has any non-'1' value", () => {
-		process.env.PI_TOKEN_TELEMETRY = "true"; // not literally "1"
-		emitTokenTelemetry(makeAssistantMessage());
-		assert.equal(captured.length, 0, "only literal '1' should enable telemetry");
-	});
-
-	test("emits a single JSON line when PI_TOKEN_TELEMETRY=1", () => {
-		process.env.PI_TOKEN_TELEMETRY = "1";
-		emitTokenTelemetry(makeAssistantMessage());
-		assert.equal(captured.length, 1);
-		assert.ok(captured[0].endsWith("\n"), "line must terminate with newline");
-		const parsed = JSON.parse(captured[0].trimEnd());
-		assert.equal(parsed.model, "claude-sonnet-4-6");
-		assert.equal(parsed.input, 100);
-		assert.equal(parsed.output, 50);
-	});
-
-	test("emitted JSON has the documented shape", () => {
-		process.env.PI_TOKEN_TELEMETRY = "1";
-		emitTokenTelemetry(makeAssistantMessage());
-		const parsed = JSON.parse(captured[0].trimEnd());
-		const keys = Object.keys(parsed).sort();
-		assert.deepEqual(keys, [
-			"cacheHitRatio",
-			"cacheRead",
-			"cacheWrite",
-			"costTotal",
-			"input",
-			"model",
-			"output",
-			"stopReason",
-			"ts",
-		]);
-	});
-
-	test("never throws — telemetry must not break the agent loop", () => {
-		process.env.PI_TOKEN_TELEMETRY = "1";
-		// Force a write failure to exercise the swallow path.
-		process.stderr.write = (() => {
-			throw new Error("simulated stderr failure");
-		}) as typeof process.stderr.write;
-		assert.doesNotThrow(() => emitTokenTelemetry(makeAssistantMessage()));
-	});
-});

package/packages/pi-tui/dist/components/__tests__/leak-fixes-runtime.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=leak-fixes-runtime.test.d.ts.map

package/packages/pi-tui/dist/components/__tests__/leak-fixes-runtime.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"leak-fixes-runtime.test.d.ts","sourceRoot":"","sources":["../../../src/components/__tests__/leak-fixes-runtime.test.ts"],"names":[],"mappings":""}

package/packages/pi-tui/dist/components/__tests__/leak-fixes-runtime.test.js

@@ -1,161 +0,0 @@
-// Runtime regression tests for the long-running-session leak fixes.
-//
-// Replaces the source-grep file `src/tests/session-memory-leaks.test.ts`
-// (deleted in #4875, tracked as #4873). The previous tests asserted on
-// identifier presence (`_prevRender`, `_lastMessage`, `MAX_CHAT_COMPONENTS`)
-// in source — a regression that set `MAX_CHAT_COMPONENTS = Number.MAX_SAFE_INTEGER`
-// or replaced `setText` with an inline mutation would still pass.
-//
-// Each test below drives the actual component through a long-running scenario
-// and asserts on observable behaviour.
-import { describe, it, mock, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { Container } from "../../tui.js";
-import { Loader } from "../loader.js";
-import { Text } from "../text.js";
-function makeMockTUI() {
-    return { requestRender: mock.fn() };
-}
-// ─── Container render-skip ──────────────────────────────────────────────
-describe("Container.render skips work when output is unchanged", () => {
-    it("returns the SAME array reference across two renders with no changes", () => {
-        // The container caches `_prevRender` so doRender() can short-circuit
-        // the post-processing (image-line scan, applyLineResets, line diffs).
-        // The contract for the optimization is reference equality of the
-        // returned array — that's what the consumer in tui.ts checks.
-        const c = new Container();
-        c.addChild(new Text("hello", 0, 0));
-        const first = c.render(20);
-        const second = c.render(20);
-        assert.strictEqual(second, first, "Container must return the same array reference when content is unchanged " +
-            "(reference equality is the consumer-visible contract for the skip)");
-    });
-    it("returns a DIFFERENT array reference after addChild invalidates the cache", () => {
-        // If a regression caused `_prevRender` to never reset, downstream
-        // rendering would skip post-processing for new components — visible
-        // as missing/stale UI. Behaviourally we observe that adding a child
-        // breaks the reference-equality contract on the next render.
-        const c = new Container();
-        c.addChild(new Text("a", 0, 0));
-        const first = c.render(20);
-        c.addChild(new Text("b", 0, 0));
-        const second = c.render(20);
-        assert.notStrictEqual(second, first, "adding a child must invalidate the cached render reference");
-    });
-    it("returns a different reference after content changes", () => {
-        const t = new Text("hello", 0, 0);
-        const c = new Container();
-        c.addChild(t);
-        const first = c.render(20);
-        t.setText("world");
-        const second = c.render(20);
-        assert.notStrictEqual(second, first, "changing a child's text must produce a fresh array (not the cached one)");
-    });
-});
-// ─── Loader frame isolation ─────────────────────────────────────────────
-describe("Loader does not mutate Text cache on every spinner tick", () => {
-    let tui;
-    let loader;
-    beforeEach(() => {
-        tui = makeMockTUI();
-        mock.timers.enable({ apis: ["setInterval"] });
-    });
-    afterEach(() => {
-        try {
-            loader?.stop();
-        }
-        catch {
-            /* best-effort */
-        }
-        mock.timers.reset();
-    });
-    it("does not invalidate Text's render cache across N spinner ticks", () => {
-        // Loader extends Text. Text caches its rendered lines keyed by
-        // (text, width). The leak was: the old Loader called setText()
-        // on every 80ms tick, which always cleared the cache, forcing a
-        // re-wrap of the message text.
-        // Behavioural test: render the loader, capture the cached array
-        // reference returned by Text.render, advance many ticks, and
-        // assert the underlying Text cache was NOT invalidated (we observe
-        // this via reference equality of the cached lines slice in the
-        // returned array — the second `result[*]` segment from super.render
-        // stays identity-stable when the cache survives).
-        loader = new Loader(tui, (s) => s, (s) => s, "the-message");
-        const before = loader.render(40);
-        // Run 50 frame intervals — the spinner should rotate, but the
-        // underlying message text wrapping must not change.
-        mock.timers.tick(80 * 50);
-        const after = loader.render(40);
-        // The message portion (everything after the first `""` padding line
-        // and after the spinner glyph + space prefix on the first content
-        // line) must be byte-identical across renders.
-        assert.equal(before.length, after.length, "render shape stable across ticks");
-        // Trailing message lines (index 2 onwards) come straight from Text's
-        // cache without any spinner mutation. They must be reference-equal
-        // substrings — same string contents byte-for-byte.
-        for (let i = 2; i < before.length; i++) {
-            assert.equal(after[i], before[i], `message line ${i} must remain byte-identical across spinner ticks ` +
-                `(cache must not be invalidated by frame rotation)`);
-        }
-    });
-    it("setMessage invalidates Text cache and a new message is reflected", () => {
-        // Quiescence is conditional on the message being unchanged — we
-        // must still see updates when it actually changes. This is the
-        // counter-test that prevents a false-positive "cache always stable"
-        // fix that would freeze the loader text.
-        loader = new Loader(tui, (s) => s, (s) => s, "first");
-        const beforeFirstRender = loader.render(40).join("\n");
-        loader.setMessage("second");
-        const afterChange = loader.render(40).join("\n");
-        assert.ok(afterChange.includes("second"), "new message must render");
-        assert.ok(!afterChange.includes("first") || beforeFirstRender !== afterChange, "render output must change when message changes");
-    });
-});
-// ─── Text.setText early-return guard ────────────────────────────────────
-describe("Text.setText returns early when value is unchanged", () => {
-    it("does not invalidate the cached render when setText receives the same value", () => {
-        // The setText early-return is the runtime guard that keeps the
-        // Loader-and-Text cache stable. We observe it via reference equality
-        // of the rendered output across a setText(SAME) call.
-        const t = new Text("identical", 0, 0);
-        const first = t.render(30);
-        t.setText("identical"); // same value — must NOT clear the cache
-        const second = t.render(30);
-        assert.strictEqual(second, first, "setText with an unchanged value must leave the render cache intact");
-    });
-    it("invalidates cache when the value actually changes", () => {
-        const t = new Text("one", 0, 0);
-        const first = t.render(30);
-        t.setText("two");
-        const second = t.render(30);
-        assert.notStrictEqual(second, first, "setText with a new value must produce a fresh render result");
-    });
-});
-// ─── Heap growth bound (gated on --expose-gc) ───────────────────────────
-describe("Long-running render loop does not leak heap (forced-GC bound)", () => {
-    const hasGc = typeof globalThis.gc === "function";
-    it("renders a Container 5000 times with stable heapUsed (within 2x baseline)", { skip: !hasGc ? "requires --expose-gc to drive deterministic GC between snapshots" : false }, () => {
-        // This is the on-the-wire memory-soak test. The naive version
-        // (no forced GC) is flaky because Node's GC is opportunistic;
-        // any background allocation can shift heapUsed past an absolute
-        // bound. We instead force GC between snapshots and assert a
-        // RELATIVE bound: post-iteration heap must be within 2x of the
-        // post-warmup baseline.
-        const gc = globalThis.gc;
-        const c = new Container();
-        const t = new Text("steady-state", 0, 0);
-        c.addChild(t);
-        // Warm up so the JIT and any lazy initial allocations settle.
-        for (let i = 0; i < 200; i++)
-            c.render(40);
-        gc();
-        const baseline = process.memoryUsage().heapUsed;
-        for (let i = 0; i < 5000; i++)
-            c.render(40);
-        gc();
-        const after = process.memoryUsage().heapUsed;
-        assert.ok(after < baseline * 2, `heapUsed must stay within 2x baseline after 5000 renders ` +
-            `(baseline=${baseline}B, after=${after}B, ratio=${(after / baseline).toFixed(2)})`);
-    });
-});
-//# sourceMappingURL=leak-fixes-runtime.test.js.map