@nmzpy/pi-ember-stack 0.1.5 → 0.2.1

package/plugins/pi-ember-fff/query.ts

@@ -0,0 +1,87 @@
+import path from "node:path";
+
+export function normalizePathConstraint(
+  pathConstraint: string,
+  cwd = process.cwd(),
+): string | null {
+  let trimmed = pathConstraint.trim();
+  if (!trimmed) return trimmed;
+
+  if (path.isAbsolute(trimmed)) {
+    const relative = path.relative(cwd, trimmed).replaceAll(path.sep, "/");
+    if (relative === "") return null;
+    if (relative.startsWith("../") || relative === ".." || path.isAbsolute(relative)) {
+      throw new Error(
+        `Path constraint must be relative to the workspace: ${pathConstraint}`,
+      );
+    }
+    trimmed = relative;
+  }
+
+  if (trimmed === "." || trimmed === "./") return null;
+  // Strip a leading `./` so `./**/*.rs` and `**/*.rs` behave identically.
+  if (trimmed.startsWith("./")) trimmed = trimmed.slice(2);
+
+  // FFF's glob matcher can treat a hidden directory root glob such as
+  // `.agents/**` as empty, while the tool contract says this means "inside
+  // this directory". Collapse simple trailing recursive directory globs to the
+  // directory-prefix constraint understood by the parser. Keep real file globs
+  // such as `src/**/*.ts` unchanged.
+  const recursiveDir = trimmed.match(/^(.*)\/\*\*(?:\/\*)?$/);
+  if (recursiveDir) {
+    const dir = recursiveDir[1];
+    if (dir && !/[*?[{]/.test(dir)) return `${dir}/`;
+  }
+
+  // Already signals path-constraint syntax to the parser.
+  if (trimmed.startsWith("/") || trimmed.endsWith("/")) return trimmed;
+  // Globs (`*.ts`, `src/**/*.cc`, `{src,lib}`) are handled by the parser.
+  if (/[*?[{]/.test(trimmed)) return trimmed;
+  // Filename with extension (`main.rs`, `config.json`) → FilePath constraint.
+  const lastSegment = trimmed.split("/").pop() ?? "";
+  if (/\.[a-zA-Z][a-zA-Z0-9]{0,9}$/.test(lastSegment)) return trimmed;
+  // Bare directory prefix → append `/` so the parser sees a PathSegment.
+  return `${trimmed}/`;
+}
+
+// Exclusions are emitted as `!<constraint>` tokens, which the Rust parser
+// understands (crates/fff-query-parser/src/parser.rs). We normalize each one
+// the same way as the include path so bare dirs become PathSegment excludes.
+// Tolerate callers passing already-negated forms like `!src/` by stripping
+// the leading `!` before normalizing so we never double-negate (`!!src/`).
+export function normalizeExcludes(
+  exclude: string | string[] | undefined,
+  cwd = process.cwd(),
+): string[] {
+  if (!exclude) return [];
+  const list = Array.isArray(exclude) ? exclude : [exclude];
+  const out: string[] = [];
+  for (const raw of list) {
+    const parts = raw
+      .split(/[,\s]+/)
+      .map((s) => s.trim())
+      .filter(Boolean);
+    for (const p of parts) {
+      const stripped = p.startsWith("!") ? p.slice(1) : p;
+      const normalized = normalizePathConstraint(stripped, cwd);
+      if (normalized) out.push(`!${normalized}`);
+    }
+  }
+  return out;
+}
+
+export function buildQuery(
+  path: string | undefined,
+  pattern: string,
+  exclude?: string | string[],
+  cwd = process.cwd(),
+): string {
+  const parts: string[] = [];
+  if (path) {
+    const pathConstraint = normalizePathConstraint(path, cwd);
+    if (pathConstraint) parts.push(pathConstraint);
+  }
+  parts.push(...normalizeExcludes(exclude, cwd));
+  parts.push(pattern);
+  return parts.join(" ");
+}

package/plugins/pi-ember-fff/test/query.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from "bun:test";
+import { normalizePathConstraint, normalizeExcludes, buildQuery } from "../query.ts";
+
+describe("normalizePathConstraint", () => {
+	test("empty string returns empty", () => {
+		expect(normalizePathConstraint("")).toBe("");
+	});
+
+	test("dot returns null", () => {
+		expect(normalizePathConstraint(".")).toBeNull();
+		expect(normalizePathConstraint("./")).toBeNull();
+	});
+
+	test("bare directory gets trailing slash", () => {
+		expect(normalizePathConstraint("src")).toBe("src/");
+	});
+
+	test("glob is preserved", () => {
+		expect(normalizePathConstraint("*.ts")).toBe("*.ts");
+		expect(normalizePathConstraint("src/**/*.cc")).toBe("src/**/*.cc");
+	});
+
+	test("filename with extension is preserved", () => {
+		expect(normalizePathConstraint("main.rs")).toBe("main.rs");
+	});
+
+	test("recursive dir glob collapses to prefix", () => {
+		expect(normalizePathConstraint("src/**")).toBe("src/");
+		expect(normalizePathConstraint("src/**/*")).toBe("src/");
+	});
+
+	test("leading ./ is stripped", () => {
+		expect(normalizePathConstraint("./src")).toBe("src/");
+	});
+});
+
+describe("normalizeExcludes", () => {
+	test("undefined returns empty array", () => {
+		expect(normalizeExcludes(undefined)).toEqual([]);
+	});
+
+	test("comma-separated string is split", () => {
+		expect(normalizeExcludes("test/, *.min.js")).toEqual(["!test/", "!*.min.js"]);
+	});
+
+	test("leading ! is tolerated", () => {
+		expect(normalizeExcludes("!src/")).toEqual(["!src/"]);
+	});
+
+	test("array input works", () => {
+		expect(normalizeExcludes(["test/", "vendor/"])).toEqual(["!test/", "!vendor/"]);
+	});
+});
+
+describe("buildQuery", () => {
+	test("assembles path + excludes + pattern", () => {
+		const q = buildQuery("src/", "MyClass", "test/");
+		expect(q).toContain("src/");
+		expect(q).toContain("!test/");
+		expect(q).toContain("MyClass");
+	});
+
+	test("no path or excludes yields just pattern", () => {
+		expect(buildQuery(undefined, "foo")).toBe("foo");
+	});
+});

package/plugins/pi-ember-fff/test/renderer.test.ts

@@ -0,0 +1,376 @@
+import { describe, expect, mock, test } from "bun:test";
+import { CompactRenderer, formatCallBody, DISCOVERY_TOOLS } from "../../pi-compact-tools/renderer.ts";
+
+function makeTheme() {
+	const fg = mock((tag: string, text: string) => `[${tag}:${text}]`);
+	return {
+		fg,
+		bold: mock((s: string) => `*${s}*`),
+	};
+}
+
+function makeContext(id: string, state: Record<string, any> = {}) {
+	return {
+		args: {},
+		toolCallId: id,
+		invalidate: mock(() => {}),
+		state,
+	};
+}
+
+describe("CompactRenderer", () => {
+	test("beginTurn does not reset grouping for same-key calls", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const ctx1 = makeContext("a");
+		r.renderCall("read", { file_path: "foo.ts" }, theme, ctx1 as any);
+		r.beginTurn();
+		const ctx2 = makeContext("b");
+		r.renderCall("read", { file_path: "bar.ts" }, theme, ctx2 as any);
+		// Same group key (__discovery__) should still group across turns
+		const record = (r as any).calls.get("b");
+		expect(record.group).toBeDefined();
+	});
+
+	test("consecutive discovery tools group together", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const ctx1 = makeContext("a");
+		const ctx2 = makeContext("b");
+		r.renderCall("read", { file_path: "a.ts" }, theme, ctx1 as any);
+		r.renderCall("grep", { pattern: "foo" }, theme, ctx2 as any);
+		const recA = (r as any).calls.get("a");
+		const recB = (r as any).calls.get("b");
+		expect(recA.group).toBeDefined();
+		expect(recB.group).toBe(recA.group);
+		expect(recA.group.records.length).toBe(2);
+	});
+
+	test("non-discovery tools do not group", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("bash", { command: "ls" }, theme, makeContext("a") as any);
+		r.renderCall("edit", { file_path: "x.ts" }, theme, makeContext("b") as any);
+		const recA = (r as any).calls.get("a");
+		const recB = (r as any).calls.get("b");
+		expect(recA.group).toBeUndefined();
+		expect(recB.group).toBeUndefined();
+	});
+
+	test("renderResult returns empty for bash on success", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("bash", { command: "echo hi" }, theme, makeContext("a") as any);
+		const comp = r.renderResult(
+			"bash",
+			{ command: "echo hi" },
+			{ content: [{ type: "text", text: "hi" }] },
+			{ isPartial: false },
+			theme,
+			{ ...makeContext("a"), isError: false } as any,
+		);
+		// Compact: the result component itself is empty, but the call row is updated.
+		expect((comp as any).text).toBe("");
+	});
+
+	test("bash success renders last output line on the call row", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		const call = r.renderCall("bash", { command: "echo hi" }, theme, makeContext("a", state) as any);
+		r.renderResult(
+			"bash",
+			{ command: "echo hi" },
+			{ content: [{ type: "text", text: "first\nsecond\nOK" }] },
+			{ isPartial: false },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((call as any).text).toContain("Run");
+		expect((call as any).text).toContain("OK");
+		expect((call as any).text).not.toContain("first");
+		expect((call as any).text).not.toContain("second");
+	});
+
+	test("bash output skips trailing blank lines", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		const call = r.renderCall("bash", { command: "echo hi" }, theme, makeContext("a", state) as any);
+		r.renderResult(
+			"bash",
+			{ command: "echo hi" },
+			{ content: [{ type: "text", text: "OK\n\n\n" }] },
+			{ isPartial: false },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((call as any).text).toContain("OK");
+		expect((call as any).text).not.toContain("\n\n");
+	});
+
+	test("bash empty output does not add a result line", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		const call = r.renderCall("bash", { command: ":" }, theme, makeContext("a", state) as any);
+		r.renderResult(
+			"bash",
+			{ command: ":" },
+			{ content: [{ type: "text", text: "" }] },
+			{ isPartial: false },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((call as any).text).toContain("Run");
+		expect((call as any).text).not.toContain("  ");
+	});
+
+	test("bash partial result does not render output yet", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		const call = r.renderCall("bash", { command: "sleep 1" }, theme, makeContext("a", state) as any);
+		r.renderResult(
+			"bash",
+			{ command: "sleep 1" },
+			{ content: [{ type: "text", text: "intermediate" }] },
+			{ isPartial: true },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((call as any).text).toContain("Run");
+		expect((call as any).text).not.toContain("intermediate");
+	});
+
+	test("renderResult shows error text on failure", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("read", { file_path: "bad.ts" }, theme, makeContext("a") as any);
+		const comp = r.renderResult(
+			"read",
+			{ file_path: "bad.ts" },
+			{ content: [{ type: "text", text: "Error: not found" }] },
+			{ isPartial: false },
+			theme,
+			{ ...makeContext("a"), isError: true } as any,
+		);
+		expect((comp as any).text).toContain("Error: not found");
+	});
+
+	test("read never dumps file content on success", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("read", { file_path: "big.ts" }, theme, makeContext("a") as any);
+		const fileContent = "line1\nline2\nline3\n".repeat(100);
+		const comp = r.renderResult(
+			"read",
+			{ file_path: "big.ts" },
+			{ content: [{ type: "text", text: fileContent }] },
+			{ isPartial: false },
+			theme,
+			{ ...makeContext("a"), isError: false } as any,
+		);
+		// Result must be empty — the call row shows the compact summary.
+		expect((comp as any).text).toBe("");
+		expect((comp as any).text).not.toContain("line1");
+	});
+
+	test("bash calls with same cd dir group across turns", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("bash", { command: "cd src && ls" }, theme, makeContext("a") as any);
+		r.beginTurn();
+		r.renderCall("bash", { command: "cd src && pwd" }, theme, makeContext("b") as any);
+		const recA = (r as any).calls.get("a");
+		const recB = (r as any).calls.get("b");
+		expect(recA.group).toBeDefined();
+		expect(recB.group).toBe(recA.group);
+	});
+
+	test("DISCOVERY_TOOLS includes grep and find", () => {
+		expect(DISCOVERY_TOOLS.has("grep")).toBe(true);
+		expect(DISCOVERY_TOOLS.has("find")).toBe(true);
+		expect(DISCOVERY_TOOLS.has("read")).toBe(true);
+		expect(DISCOVERY_TOOLS.has("ls")).toBe(true);
+	});
+
+	test("formatCallBody handles grep", () => {
+		const theme = makeTheme() as any;
+		const result = formatCallBody("grep", { pattern: "MyClass", path: "src/" }, theme);
+		expect(result).toContain("Search");
+		expect(result).toContain("MyClass");
+		expect(result).toContain("src/");
+	});
+
+	test("formatCallBody handles find", () => {
+		const theme = makeTheme() as any;
+		const result = formatCallBody("find", { pattern: "main", path: "." }, theme);
+		expect(result).toContain("Find");
+		expect(result).toContain("main");
+	});
+
+	test("renderOwner moves group to latest call", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const ctx1 = makeContext("a");
+		const ctx2 = makeContext("b");
+		r.renderCall("read", { file_path: "a.ts" }, theme, ctx1 as any);
+		r.renderCall("read", { file_path: "b.ts" }, theme, ctx2 as any);
+		const recA = (r as any).calls.get("a");
+		const recB = (r as any).calls.get("b");
+		// After B joins, B should be the renderOwner
+		expect(recA.group.renderOwner).toBe(recB);
+		expect(recA.group.renderOwner).not.toBe(recA);
+	});
+
+	test("non-owner grouped call renders empty", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const ctx1 = makeContext("a");
+		const ctx2 = makeContext("b");
+		r.renderCall("read", { file_path: "a.ts" }, theme, ctx1 as any);
+		r.renderCall("read", { file_path: "b.ts" }, theme, ctx2 as any);
+		// After B joins and becomes owner, re-rendering A should return empty
+		const compA2 = r.renderCall("read", { file_path: "a.ts" }, theme, ctx1 as any);
+		expect((compA2 as any).text).toBe("");
+	});
+
+	test("expanded bash shows full output", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		r.renderCall("bash", { command: "echo hi" }, theme, makeContext("a", state) as any);
+		const comp = r.renderResult(
+			"bash",
+			{ command: "echo hi" },
+			{ content: [{ type: "text", text: "line1\nline2\nline3" }] },
+			{ isPartial: false, expanded: true },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((comp as any).text).toContain("line1");
+		expect((comp as any).text).toContain("line2");
+		expect((comp as any).text).toContain("line3");
+	});
+
+	test("collapsed bash shows only last line", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		const call = r.renderCall("bash", { command: "echo hi" }, theme, makeContext("a", state) as any);
+		r.renderResult(
+			"bash",
+			{ command: "echo hi" },
+			{ content: [{ type: "text", text: "line1\nline2\nline3" }] },
+			{ isPartial: false, expanded: false },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((call as any).text).toContain("line3");
+		expect((call as any).text).not.toContain("line1");
+		expect((call as any).text).not.toContain("line2");
+	});
+
+	test("expanded read shows full file content", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("read", { file_path: "big.ts" }, theme, makeContext("a") as any);
+		const fileContent = "line1\nline2\nline3\nline4\nline5";
+		const comp = r.renderResult(
+			"read",
+			{ file_path: "big.ts" },
+			{ content: [{ type: "text", text: fileContent }] },
+			{ isPartial: false, expanded: true },
+			theme,
+			{ ...makeContext("a"), isError: false } as any,
+		);
+		expect((comp as any).text).toContain("line1");
+		expect((comp as any).text).toContain("line2");
+		expect((comp as any).text).toContain("line5");
+	});
+
+	test("collapsed read hides file content", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("read", { file_path: "big.ts" }, theme, makeContext("a") as any);
+		const fileContent = "line1\nline2\nline3\nline4\nline5";
+		const comp = r.renderResult(
+			"read",
+			{ file_path: "big.ts" },
+			{ content: [{ type: "text", text: fileContent }] },
+			{ isPartial: false, expanded: false },
+			theme,
+			{ ...makeContext("a"), isError: false } as any,
+		);
+		expect((comp as any).text).toBe("");
+	});
+
+	test("expanded grep shows all match lines", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		r.renderCall("grep", { pattern: "foo" }, theme, makeContext("a", state) as any);
+		const comp = r.renderResult(
+			"grep",
+			{ pattern: "foo" },
+			{ content: [{ type: "text", text: "a.ts:1:foo\nb.ts:2:foo\nc.ts:3:foo" }], details: { totalMatched: 3 } },
+			{ isPartial: false, expanded: true },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((comp as any).text).toContain("a.ts:1:foo");
+		expect((comp as any).text).toContain("b.ts:2:foo");
+		expect((comp as any).text).toContain("c.ts:3:foo");
+	});
+
+	test("expanded grouped call shows full output for owner", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const stateA: Record<string, any> = {};
+		const stateB: Record<string, any> = {};
+		r.renderCall("read", { file_path: "a.ts" }, theme, makeContext("a", stateA) as any);
+		r.renderCall("read", { file_path: "b.ts" }, theme, makeContext("b", stateB) as any);
+		const comp = r.renderResult(
+			"read",
+			{ file_path: "b.ts" },
+			{ content: [{ type: "text", text: "contentB_line1\ncontentB_line2" }] },
+			{ isPartial: false, expanded: true },
+			theme,
+			{ ...makeContext("b", stateB), isError: false } as any,
+		);
+		expect((comp as any).text).toContain("contentB_line1");
+		expect((comp as any).text).toContain("contentB_line2");
+	});
+
+	test("expanded partial result does not show output", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		const state: Record<string, any> = {};
+		r.renderCall("bash", { command: "sleep 1" }, theme, makeContext("a", state) as any);
+		const comp = r.renderResult(
+			"bash",
+			{ command: "sleep 1" },
+			{ content: [{ type: "text", text: "intermediate" }] },
+			{ isPartial: true, expanded: true },
+			theme,
+			{ ...makeContext("a", state), isError: false } as any,
+		);
+		expect((comp as any).text).toBe("");
+	});
+
+	test("expanded error still shows error text", () => {
+		const r = new CompactRenderer();
+		const theme = makeTheme() as any;
+		r.renderCall("read", { file_path: "bad.ts" }, theme, makeContext("a") as any);
+		const comp = r.renderResult(
+			"read",
+			{ file_path: "bad.ts" },
+			{ content: [{ type: "text", text: "Error: not found" }] },
+			{ isPartial: false, expanded: true },
+			theme,
+			{ ...makeContext("a"), isError: true } as any,
+		);
+		expect((comp as any).text).toContain("Error: not found");
+	});
+});

package/plugins/pi-ember-tps/index.ts

@@ -0,0 +1,122 @@
+/**
+ * Ember TPS Meter — minimal tokens-per-second tracker
+ *
+ * Tracks output token rate during streaming and exposes the live value
+ * via getLiveTps() for the custom footer to render.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const STREAM_INTERVAL_MS = 500;
+
+let streamStartMs = 0;
+let firstTokenMs = 0;
+let streamChars = 0;
+let streamTokens = 0;
+let tickTimer: ReturnType<typeof setInterval> | null = null;
+let streaming = false;
+let liveTps = 0;
+let renderTrigger: (() => void) | undefined;
+
+function now(): number {
+	return performance.now();
+}
+
+function tokEst(ch: number): number {
+	return (ch >>> 2) + ((ch & 3) > 0 ? 1 : 0);
+}
+
+function computeTps(): number {
+	const ref = firstTokenMs > 0 ? firstTokenMs : streamStartMs;
+	const elapsed = (now() - ref) / 1000;
+	return elapsed > 0.3 ? streamTokens / elapsed : 0;
+}
+
+function startTick(): void {
+	if (tickTimer) return;
+	tickTimer = setInterval(() => {
+		if (!streaming) {
+			stopTick();
+			return;
+		}
+		liveTps = computeTps();
+		renderTrigger?.();
+	}, STREAM_INTERVAL_MS);
+}
+
+function stopTick(): void {
+	if (tickTimer) {
+		clearInterval(tickTimer);
+		tickTimer = null;
+	}
+}
+
+export function getLiveTps(): number {
+	return liveTps;
+}
+
+export default function piEmberTps(pi: ExtensionAPI): void {
+	pi.on("message_start", async (event, ctx) => {
+		if (event.message.role !== "assistant") return;
+		streamStartMs = now();
+		firstTokenMs = 0;
+		streamChars = 0;
+		streamTokens = 0;
+		liveTps = 0;
+		streaming = true;
+		if (ctx.mode === "tui") {
+			renderTrigger = () => ctx.ui.setStatus("tps", undefined);
+		}
+		startTick();
+	});
+
+	pi.on("message_update", async (event) => {
+		if (event.message.role !== "assistant") return;
+		if (!event.assistantMessageEvent) return;
+		const evt = event.assistantMessageEvent;
+		if (evt.type === "text_delta" || evt.type === "thinking_delta") {
+			const d = evt.delta as string;
+			if (!d) return;
+			if (firstTokenMs === 0) firstTokenMs = now();
+			streamChars += d.length;
+			streamTokens = tokEst(streamChars);
+		}
+	});
+
+	pi.on("message_end", async (event) => {
+		if (event.message.role !== "assistant") return;
+		streaming = false;
+		stopTick();
+
+		const realOut = event.message?.usage?.output;
+		const tokens =
+			typeof realOut === "number" && realOut > 0 ? realOut : streamTokens;
+
+		const ref = firstTokenMs > 0 ? firstTokenMs : streamStartMs;
+		const elapsed = (now() - ref) / 1000;
+		if (elapsed < 0.1 || tokens === 0) {
+			liveTps = 0;
+			return;
+		}
+
+		liveTps = tokens / elapsed;
+		renderTrigger?.();
+	});
+
+	pi.on("agent_end", async () => {
+		streaming = false;
+		stopTick();
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		streaming = false;
+		stopTick();
+		streamStartMs = 0;
+		firstTokenMs = 0;
+		streamChars = 0;
+		streamTokens = 0;
+		liveTps = 0;
+		renderTrigger = undefined;
+		ctx.ui.setStatus("tps", undefined);
+	});
+}