pi-ui-extend 0.1.64 → 0.1.66

package/external/pi-tools-suite/src/telegram-mirror/README.md

@@ -1,203 +0,0 @@
-# telegram-mirror
-
-A pi-tools-suite module that exposes one or more running pi sessions as a
-single Telegram chat. Pi stays as the source of truth; Telegram is a remote
-second screen.
-
-## Opt-in
-
-The module is a no-op until you add a `telegramMirror` block to
-`~/.config/pi/pi-tools-suite.jsonc`:
-
-```jsonc
-{
-  // …other pi-tools-suite settings…
-  "telegramMirror": {
-    "enabled": true,
-    "botToken": "123456789:ABCdef…",   // from @BotFather
-    "chatId": 123456789                // numeric chat id of your private chat
-  }
-}
-```
-
-- `enabled` (boolean, optional): defaults to `true` when the block is
-  present and `botToken` + `chatId` are valid.
-- `botToken` (string, required): Telegram Bot API token from @BotFather.
-  Empty string disables the mirror.
-- `chatId` (number or string, required): numeric private chat id allowed to
-  control the bot. Non-integer disables the mirror.
-
-When the block is present and valid, the module registers the local
-`/telegram-mirror` and `/tg` slash commands. The bot does not connect until
-you run one of those commands in a pi session.
-
-## Activation
-
-Run this inside each pi session you want to expose to Telegram:
-
-```text
-/telegram-mirror
-```
-
-Short alias:
-
-```text
-/tg
-```
-
-Useful local variants:
-
-- `/telegram-mirror` or `/tg`: connect this pi session to Telegram mirror.
-- `/telegram-mirror status`: show local mirror role and session label.
-- `/telegram-mirror stop`: stop the mirror cluster.
-- `/tg-off`: stop the mirror cluster.
-
-After activation, the leader sends a Telegram message with buttons. Use
-`/menu` or `/list` in Telegram any time to reopen the project/session picker.
-
-## How to get your chat id
-
-Open this URL in a browser (replace `<TOKEN>` with your bot token):
-
-```text
-https://api.telegram.org/bot<TOKEN>/getUpdates
-```
-
-Send any message to your bot in Telegram, then refresh the URL. The JSON
-response contains `"chat": { "id": 123456789, … }` — that number is your
-`chatId`.
-
-Alternative: message [@userinfobot](https://t.me/userinfobot).
-
-The bot silently ignores every message from any other chat.
-
-## Multi-instance setup
-
-Telegram allows exactly one concurrent `getUpdates` call per bot token,
-so this module elects a **leader** when N pi processes share one bot:
-
-1. The first pi to start binds the unix socket at
-   `~/.pi/agent/extensions/pi-tools-suite/.run/telegram-mirror.sock`,
-   connects the bot, and starts polling.
-2. Subsequent pi processes connect to that socket as **followers**. They
-   forward their pix events to the leader over IPC and execute commands
-   received from the leader.
-3. If the leader dies (process exit, socket close, or heartbeat timeout),
-   followers race to bind the socket; the first to win becomes the new
-   leader. `activeId` resets on failover — run `/use N` again.
-
-Run `/telegram-mirror` in every `pi` process you want available in the
-Telegram picker. Only one process polls Telegram; the rest register as
-followers over IPC.
-
-When you start a new pi, it logs `[telegram-mirror] registered with
-leader <label>` on stderr. The leader logs `[telegram-mirror] connected
-as @<botname> (leader)`.
-
-### Selecting the followed project/session
-
-In Telegram, use `/menu`, `/list`, or the inline buttons:
-
-```text
-/list
-→
-1. pi-ui-extend (#12345) (leader) [following] — idle
-2. opencode (#67890) — streaming
-3. other-repo (#99999)
-
-Tap a button below, or use /use N.
-```
-
-```text
-/use 2
-→ ✅ Following: opencode (#67890)
-```
-
-`/use` accepts a 1-based index from `/list` or a substring of the id/label.
-Assistant messages are streamed only from the followed session. Status changes
-from other sessions still produce Telegram signals, so you can see when a
-different session starts or finishes work without switching to it.
-
-### Cleanup
-
-Socket file: `~/.pi/agent/extensions/pi-tools-suite/.run/telegram-mirror.sock`.
-
-If a pi crashes hard and leaves a stale socket, the next pi to start will
-unlink it automatically (bind fails → connect fails → unlink → retry).
-
-## Telegram → pix
-
-- Free text: forwarded to the followed pi session as a user message.
-- `/menu`: show inline project/session picker buttons.
-- `/list`: show all known pi sessions and mark followed.
-- `/use N` or `/use X`: follow by index, id, or label substring.
-- `/abort` or `/stop`: cancel current turn on followed session.
-- `/compact`: trigger context compaction on followed session.
-- `/status`: show idle / streaming state of followed session.
-- `/clear`: best-effort delete known bot messages from the chat.
-- `/say <msg>`: explicit send, for `/`-prefixed text.
-- `/disconnect`: stop the bot cluster-wide.
-- `/new`: not supported via extension API; run `/new` in pi.
-- `/help`: show command list.
-
-## Pix → Telegram
-
-The leader subscribes to pix streaming events (its own + followers' via IPC)
-and renders one Telegram message per agent turn — but only assistant-visible
-text from the followed session is streamed:
-
-- `message_update` (`text_delta`) → appended to the active message, edited
-  in place at ~1.2 s throttle (Telegram rate-limit friendly).
-- `agent_end` → final flush + `— done —` trailer.
-- `agent_start` / `agent_end` from any known session → compact status signal
-  such as `🟡 repo (#pid) is streaming` or `🟢 repo (#pid) is idle`.
-
-Tool calls, tool results, and thinking deltas are intentionally not mirrored
-to Telegram.
-
-Telegram does not expose a full private-chat history wipe API to bots. The
-`/clear` command therefore deletes the messages the bot knows about in this
-process, plus the `/clear` command message when Telegram allows it. Older
-messages from previous bot runs may remain.
-
-Messages are paginated at 4096 chars (Telegram's per-message limit).
-Markdown is converted to Telegram HTML with `**bold**`, `*italic*`,
-`` `code` ``, and fenced blocks.
-
-## Disable
-
-Either set `"enabled": false` in the `telegramMirror` block, remove the
-block entirely, or add `telegram-mirror` to the `disabledModules` array
-in the same config file, then `/reload` pi.
-
-## Known limitations
-
-- `/new` cannot start a fresh session from Telegram. The ExtensionAPI
-  exposes `newSession()` only on slash-command handler contexts, not on
-  event-handler contexts. Workaround: type `/new` in the pi TUI.
-- `pi.sendUserMessage` does not expand pi's own slash commands (calls
-  `prompt(..., { expandPromptTemplates: false })` internally), so text
-  starting with `/` is sent verbatim to the LLM. The module's own
-  `/abort`, `/compact`, `/list`, `/use`, etc. are intercepted before
-  `sendUserMessage` is called, so they work.
-- The leader uses long polling (35 s timeout) and keeps one outbound
-  request open. If your network blocks Telegram, you'll see repeating
-  `[telegram-mirror] polling: …` errors in stderr and the bot will back
-  off up to 60 s between retries.
-- On leader failover, the in-flight streaming output for the followed turn
-  is lost (the new leader's renderer starts empty). The followed session also
-  resets to the new leader; run `/use N` to switch back to a follower.
-- The cluster is single-host only (unix socket). To mirror across
-  machines, use separate bot tokens.
-- IPC events between session_start and leader-registration can be lost
-  for a brief window. Mid-stream output may be cut off.
-
-## Files
-
-- `index.ts`: module factory, activation command, role selection, lifecycle.
-- `bot.ts`: Telegram Bot API fetch client and long-poll loop.
-- `ipc.ts`: unix socket JSON-lines IPC and leader election.
-- `multiplexer.ts`: leader-side registry and active-instance routing.
-- `events.ts`: pix event to sink adapters and context capture.
-- `renderer.ts`: per-turn buffer, throttled edit, pagination.
-- `format.ts`: markdown to Telegram HTML and chunking.

package/external/pi-tools-suite/src/telegram-mirror/bot.ts

@@ -1,299 +0,0 @@
-/**
- * Minimal Telegram Bot API client.
- *
- * Uses native fetch (Node 18+ / Bun) and long polling via getUpdates.
- * No dependencies on grammY or node-telegram-bot-api.
- *
- * Provides:
- *   - sendMessage / editMessageText (HTML parse mode)
- *   - getUpdates long-poll loop with backoff
- *   - Auth gate by chat_id (single whitelist)
- *   - Graceful shutdown via AbortController
- */
-
-export interface TelegramUpdate {
-	update_id: number;
-	message?: TelegramIncomingMessage;
-	callback_query?: {
-		id: string;
-		from?: { id: number; first_name?: string; username?: string };
-		message?: TelegramIncomingMessage;
-		data?: string;
-	};
-}
-
-export interface TelegramIncomingMessage {
-	message_id: number;
-	date: number;
-	chat: { id: number; type: string };
-	from?: { id: number; first_name?: string; username?: string };
-	text?: string;
-}
-
-export interface TelegramMessage {
-	message_id: number;
-	chat: { id: number };
-	date: number;
-	text?: string;
-}
-
-export interface BotConfig {
-	token: string;
-	allowedChatId: number;
-	timeoutMs?: number;
-}
-
-export interface TelegramInlineKeyboardButton {
-	text: string;
-	callback_data?: string;
-	url?: string;
-}
-
-export interface TelegramReplyMarkup {
-	inline_keyboard: TelegramInlineKeyboardButton[][];
-}
-
-export interface TelegramBotCommand {
-	command: string;
-	description: string;
-}
-
-interface SendOptions {
-	parseMode?: "HTML" | "MarkdownV2" | "Markdown";
-	disablePreview?: boolean;
-	silent?: boolean;
-	replyToMessageId?: number;
-	replyMarkup?: TelegramReplyMarkup;
-}
-
-interface EditOptions {
-	parseMode?: "HTML" | "MarkdownV2" | "Markdown";
-	disablePreview?: boolean;
-	replyMarkup?: TelegramReplyMarkup;
-}
-
-export class TelegramBot {
-	private readonly baseUrl: string;
-	private readonly allowedChatId: number;
-	private readonly timeoutMs: number;
-	private readonly controller = new AbortController();
-	private readonly sentMessageIds = new Set<number>();
-	private polling = false;
-	private lastUpdateId = 0;
-	private consecutiveErrors = 0;
-
-	constructor(config: BotConfig) {
-		if (!config.token) throw new Error("TelegramBot: token is required");
-		this.baseUrl = `https://api.telegram.org/bot${config.token}`;
-		this.allowedChatId = config.allowedChatId;
-		this.timeoutMs = config.timeoutMs ?? 35_000;
-	}
-
-	get signal(): AbortSignal {
-		return this.controller.signal;
-	}
-
-	get chatId(): number {
-		return this.allowedChatId;
-	}
-
-	get sentIds(): readonly number[] {
-		return [...this.sentMessageIds];
-	}
-
-	forgetSentId(messageId: number): void {
-		this.sentMessageIds.delete(messageId);
-	}
-
-	isAllowedChat(chatId: number): boolean {
-		return chatId === this.allowedChatId;
-	}
-
-	async getMe(): Promise<{ ok: boolean; result?: { username: string; first_name: string } }> {
-		return this.requestJson("GET", "getMe", undefined);
-	}
-
-	async setMyCommands(commands: TelegramBotCommand[]): Promise<void> {
-		await this.requestJson("POST", "setMyCommands", { commands });
-	}
-
-	async sendMessage(text: string, options: SendOptions = {}): Promise<TelegramMessage | undefined> {
-		const payload = await this.requestJson<{ ok: boolean; result?: TelegramMessage }>("POST", "sendMessage", {
-			chat_id: this.allowedChatId,
-			text,
-			parse_mode: options.parseMode ?? "HTML",
-			disable_web_page_preview: options.disablePreview ?? true,
-			disable_notification: options.silent ?? false,
-			reply_markup: options.replyMarkup,
-			...(options.replyToMessageId ? { reply_to_message_id: options.replyToMessageId } : {}),
-		});
-		if (payload.result?.message_id) this.sentMessageIds.add(payload.result.message_id);
-		return payload.result;
-	}
-
-	async editMessageText(messageId: number, text: string, options: EditOptions = {}): Promise<TelegramMessage | undefined> {
-		try {
-			const payload = await this.requestJson<{ ok: boolean; result?: TelegramMessage }>("POST", "editMessageText", {
-				chat_id: this.allowedChatId,
-				message_id: messageId,
-				text,
-				parse_mode: options.parseMode ?? "HTML",
-				disable_web_page_preview: options.disablePreview ?? true,
-				reply_markup: options.replyMarkup,
-			});
-			return payload.result;
-		} catch (error) {
-			// Telegram returns 400 "message is not modified" if content is identical.
-			// Treat that as success; surface everything else.
-			const message = error instanceof Error ? error.message : String(error);
-			if (/not modified/i.test(message)) return undefined;
-			throw error;
-		}
-	}
-
-	async deleteMessage(messageId: number): Promise<void> {
-		try {
-			await this.requestJson("POST", "deleteMessage", {
-				chat_id: this.allowedChatId,
-				message_id: messageId,
-			});
-			this.sentMessageIds.delete(messageId);
-		} catch {
-			// best-effort
-		}
-	}
-
-	async deleteKnownMessages(extraMessageIds: readonly number[] = []): Promise<{ attempted: number; deleted: number }> {
-		const ids = [...new Set([...this.sentMessageIds, ...extraMessageIds])].sort((a, b) => b - a);
-		let deleted = 0;
-		for (const id of ids) {
-			const before = this.sentMessageIds.has(id);
-			await this.deleteMessage(id);
-			if (before && !this.sentMessageIds.has(id)) deleted += 1;
-		}
-		return { attempted: ids.length, deleted };
-	}
-
-	async answerCallbackQuery(callbackQueryId: string, text?: string): Promise<void> {
-		await this.requestJson("POST", "answerCallbackQuery", {
-			callback_query_id: callbackQueryId,
-			text,
-		});
-	}
-
-	/**
-	 * Start long-polling loop. The callback receives every update from the
-	 * allowed chat; updates from other chats are dropped silently.
-	 *
-	 * The loop exits cleanly when abort() is called.
-	 */
-	startPolling(onUpdate: (update: TelegramUpdate) => void | Promise<void>): void {
-		if (this.polling) return;
-		this.polling = true;
-		void this.pollLoop(onUpdate);
-	}
-
-	abort(): void {
-		if (this.controller.signal.aborted) return;
-		this.controller.abort();
-		this.polling = false;
-	}
-
-	private async pollLoop(onUpdate: (update: TelegramUpdate) => void | Promise<void>): Promise<void> {
-		while (this.polling && !this.controller.signal.aborted) {
-			try {
-				const payload = await this.requestJson<{
-					ok: boolean;
-					result?: TelegramUpdate[];
-				}>("POST", "getUpdates", {
-					offset: this.lastUpdateId > 0 ? this.lastUpdateId + 1 : undefined,
-					timeout: Math.floor(this.timeoutMs / 1000),
-					allowed_updates: ["message", "callback_query"],
-				});
-
-				this.consecutiveErrors = 0;
-
-				if (!payload?.ok || !Array.isArray(payload.result)) {
-					continue;
-				}
-
-				for (const update of payload.result) {
-					if (update.update_id > this.lastUpdateId) this.lastUpdateId = update.update_id;
-					const chatId = getUpdateChatId(update);
-					if (chatId === undefined) continue;
-					if (!this.isAllowedChat(chatId)) continue;
-					try {
-						await onUpdate(update);
-					} catch (handlerError) {
-						this.logError("onUpdate handler", handlerError);
-					}
-				}
-			} catch (error) {
-				if (this.controller.signal.aborted) break;
-				this.consecutiveErrors += 1;
-				this.logError("polling", error);
-				// Backoff: 1s → 60s capped
-				const backoff = Math.min(60_000, 1000 * 2 ** Math.min(5, this.consecutiveErrors - 1));
-				await sleep(backoff).catch(() => undefined);
-			}
-		}
-	}
-
-	private async requestJson<T>(method: "GET" | "POST", endpoint: string, body?: Record<string, unknown>): Promise<T> {
-		const url = `${this.baseUrl}/${endpoint}`;
-		const init: RequestInit = {
-			method,
-			signal: this.controller.signal,
-			headers: body ? { "Content-Type": "application/json" } : undefined,
-			body: body ? JSON.stringify(removeUndefined(body)) : undefined,
-		};
-
-		const response = await fetch(url, init);
-		const text = await response.text();
-		let parsed: unknown;
-		try {
-			parsed = text ? JSON.parse(text) : {};
-		} catch {
-			throw new Error(`Telegram API ${endpoint} returned invalid JSON: ${text.slice(0, 200)}`);
-		}
-
-		if (!response.ok || (isRecord(parsed) && parsed.ok === false)) {
-			const desc = isRecord(parsed) && typeof parsed.description === "string" ? parsed.description : text.slice(0, 200);
-			const errorCode = isRecord(parsed) && typeof parsed.error_code === "number" ? parsed.error_code : response.status;
-			throw new Error(`Telegram API ${endpoint} failed (${errorCode}): ${desc}`);
-		}
-
-		return parsed as T;
-	}
-
-	private logError(label: string, error: unknown): void {
-		const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-		// Use stderr so we don't pollute the TUI. Pi redirects stderr to its log.
-		// eslint-disable-next-line no-console
-		console.error(`[telegram-mirror] ${label}: ${message}`);
-	}
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function getUpdateChatId(update: TelegramUpdate): number | undefined {
-	// For callback_query Telegram may omit `message` or return an
-	// inaccessible message for older inline keyboards. In private chats the
-	// callback sender id is the chat id, so use it as a fallback; otherwise the
-	// auth gate silently drops button presses.
-	return update.message?.chat.id ?? update.callback_query?.message?.chat.id ?? update.callback_query?.from?.id;
-}
-
-function removeUndefined(value: Record<string, unknown>): Record<string, unknown> {
-	const out: Record<string, unknown> = {};
-	for (const [k, v] of Object.entries(value)) {
-		if (v !== undefined) out[k] = v;
-	}
-	return out;
-}
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/external/pi-tools-suite/src/telegram-mirror/events.ts

@@ -1,67 +0,0 @@
-/**
- * Pix event → TurnRenderer adapters.
- *
- * Keeps a per-turn renderer (one TG message chain per agent turn) and exposes
- * ExtensionAPI event handlers that append to it.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { RendererEvent, RendererInstance } from "./renderer.js";
-
-/**
- * Minimal sink for rendering events. The leader wires this to a Multiplexer
- * (which routes to a TurnRenderer for the active instance); a follower wires
- * it to an IPC socket so events travel to the leader.
- */
-export interface RendererSink {
-	push(event: RendererEvent): void;
-}
-
-export function registerPixEventHandlers(pi: ExtensionAPI, hooks: PixMirrorHooks): void {
-	let turnActive = false;
-
-	pi.on("agent_start", (_event, ctx) => {
-		if (turnActive) return;
-		turnActive = true;
-		hooks.getRenderer()?.push({ kind: "turn_start", instance: hooks.describeInstance(ctx as ExtensionContext | undefined) });
-	});
-
-	pi.on("message_update", (event) => {
-		const type = event?.assistantMessageEvent?.type;
-		if (type === "text_delta") {
-			const delta = (event.assistantMessageEvent as { delta?: string }).delta ?? "";
-			if (delta) hooks.getRenderer()?.push({ kind: "assistant_text", delta });
-			return;
-		}
-		// Ignore thinking and toolcall events. Telegram mirrors only the
-		// user-visible assistant answer, not internal reasoning/tools.
-	});
-
-	pi.on("agent_settled", () => {
-		if (!turnActive) return;
-		turnActive = false;
-		hooks.getRenderer()?.push({ kind: "turn_end", reason: "end" });
-		hooks.notifyAgentSettled();
-	});
-}
-
-export interface PixMirrorHooks {
-	getRenderer(): RendererSink | undefined;
-	describeInstance(ctx: ExtensionContext | undefined): RendererInstance | undefined;
-	notifyAgentSettled(): void;
-}
-
-export function captureAbortableContext(ctx: ExtensionContext | undefined, hooks: ContextCapture): void {
-	if (!ctx) return;
-	hooks.captureAbort(() => ctx.abort());
-	hooks.captureIdle(() => ctx.isIdle());
-	hooks.capturePending(() => ctx.hasPendingMessages());
-	hooks.captureCompact(() => ctx.compact());
-}
-
-export interface ContextCapture {
-	captureAbort(fn: () => void): void;
-	captureIdle(fn: () => boolean): void;
-	capturePending(fn: () => boolean): void;
-	captureCompact(fn: () => void): void;
-}

package/external/pi-tools-suite/src/telegram-mirror/format.ts

@@ -1,120 +0,0 @@
-/**
- * Minimal markdown → Telegram HTML conversion.
- *
- * Telegram supports a small subset of HTML: <b>, <i>, <code>, <pre>, <a>, <s>, <u>.
- * See https://core.telegram.org/bots/api#html-style
- *
- * We escape < > & first, then re-introduce supported tags from common markdown
- * patterns. This is intentionally lossy — blockquotes, headings, lists render
- * as plain text. The goal is to keep streaming output legible on a phone screen.
- */
-
-const ENTITY_RE = /[<>&]/g;
-
-export function escapeHtml(value: string): string {
-	return value.replace(ENTITY_RE, (ch) => {
-		switch (ch) {
-			case "<":
-				return "&lt;";
-			case ">":
-				return "&gt;";
-			case "&":
-				return "&amp;";
-			default:
-				return ch;
-		}
-	});
-}
-
-/**
- * Convert a chunk of assistant-flavoured markdown to Telegram HTML.
- *
- * Handles:
- *   ```lang\nfenced\n```   → <pre><code class="language-lang">…</code></pre>
- *   `inline code`          → <code>…</code>
- *   **bold**               → <b>…</b>
- *   __bold__ / *italic*    → <b>…</b> / <i>…</i>
- *
- * Everything else is HTML-escaped.
- */
-export function markdownToTelegram(value: string): string {
-	if (!value) return "";
-
-	// Pull out fenced code blocks first so their contents aren't mangled
-	// by inline replacements.
-	const fences: string[] = [];
-	const fenced = value.replace(/```([a-zA-Z0-9_+-]*)\n?([\s\S]*?)```/g, (_m, lang, body) => {
-		const langAttr = typeof lang === "string" && lang.trim() ? ` class="language-${escapeHtml(lang.trim())}"` : "";
-		const rendered = `<pre><code${langAttr}>${escapeHtml(body)}</code></pre>`;
-		fences.push(rendered);
-		return `\u0000FENCE${fences.length - 1}\u0000`;
-	});
-
-	let out = escapeHtml(fenced);
-
-	// Inline code (do before bold/italic so backticks inside ** stay escaped)
-	out = out.replace(/`([^`\n]+?)`/g, (_m, code) => `<code>${code}</code>`);
-
-	// Bold
-	out = out.replace(/\*\*([^*\n]+?)\*\*/g, "<b>$1</b>");
-	out = out.replace(/__([^_\n]+?)__/g, "<b>$1</b>");
-
-	// Italic (single * or _)
-	out = out.replace(/(^|[^*])\*([^*\n]+?)\*(?!\*)/g, "$1<i>$2</i>");
-	out = out.replace(/(^|[^_])_([^_\n]+?)_(?!_)/g, "$1<i>$2</i>");
-
-	// Restore fenced blocks
-	out = out.replace(/\u0000FENCE(\d+)\u0000/g, (_m, idx) => fences[Number(idx)] ?? "");
-
-	return out;
-}
-
-/** Telegram message size limit. */
-export const TELEGRAM_MESSAGE_MAX = 4096;
-
-/**
- * Split a rendered HTML payload into chunks that fit a single Telegram message.
- * Tries to break on blank lines first, then on newlines, then hard-splits.
- *
- * Each chunk is guaranteed to be <= maxChars characters.
- */
-export function chunkForTelegram(html: string, maxChars = TELEGRAM_MESSAGE_MAX): string[] {
-	if (html.length <= maxChars) return [html];
-
-	const chunks: string[] = [];
-	let cursor = 0;
-	while (cursor < html.length) {
-		const remaining = html.length - cursor;
-		if (remaining <= maxChars) {
-			chunks.push(html.slice(cursor));
-			break;
-		}
-
-		const window = html.slice(cursor, cursor + maxChars);
-		let cut = -1;
-
-		// Prefer blank line break
-		const blank = window.lastIndexOf("\n\n");
-		if (blank >= maxChars * 0.5) cut = blank + 1;
-
-		// Then any newline
-		if (cut < 0) {
-			const nl = window.lastIndexOf("\n");
-			if (nl >= maxChars * 0.5) cut = nl + 1;
-		}
-
-		// Then a space
-		if (cut < 0) {
-			const sp = window.lastIndexOf(" ");
-			if (sp >= maxChars * 0.5) cut = sp + 1;
-		}
-
-		// Hard cut
-		if (cut < 0) cut = maxChars;
-
-		chunks.push(html.slice(cursor, cursor + cut));
-		cursor += cut;
-	}
-
-	return chunks.filter((chunk) => chunk.length > 0);
-}