@fx-/chat-ink 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,3918 @@
+import stringWidth from "string-width";
+import { createCoreHooks } from "@fx-/chat-core/hooks";
+import { approxTokenCount, countActivity, earlierLabel, formatClockTime, formatDuration, formatElapsed, formatTokensPerSecond, getBlockTimelineBehavior, isBlockActive, isCoreBlockType, livePhase, lookupExtension, planFooter, planGroupHeader, planMessage, positiveTimestamp, shouldShowTimer, statusLabel, summarizeBlock, toolDisplayInput, toolHeadline, toolLabel, toolResultText } from "@fx-/chat-core";
+import { layoutJson, looksLikeJson, parseLooseJson } from "@fx-/chat-core/json";
+import { Buffer } from "node:buffer";
+
+//#region src/lines/measure.ts
+const segmenter = new Intl.Segmenter();
+/**
+* `width`'s results (default: `string-width`, which Ink measures with), with
+* each distinct grapheme cluster measured once. The package sums independent
+* per-cluster widths, so caching changes no result; on Bun its emoji check is
+* pathologically slow and the same few clusters are measured over and over.
+* Text with ANSI escapes goes to `width` as it is (stripping spans clusters).
+* The cache is bounded and starts over when full.
+*/
+function cachedMeasure(width$2 = stringWidth, limit = 4096) {
+	const cache = new Map();
+	return (text) => {
+		if (/^[\u0020-\u007E]*$/.test(text)) return text.length;
+		if (text.includes("\x1B") || text.includes("›")) return width$2(text);
+		let total = 0;
+		for (const { segment } of segmenter.segment(text)) {
+			let cluster = cache.get(segment);
+			if (cluster === void 0) {
+				cluster = width$2(segment);
+				if (cache.size >= limit) cache.clear();
+				cache.set(segment, cluster);
+			}
+			total += cluster;
+		}
+		return total;
+	};
+}
+const defaultMeasure = cachedMeasure();
+/** Grapheme clusters of `text` (so a wide or combined character is never split). */
+function graphemes(text) {
+	return Array.from(segmenter.segment(text), (s) => s.segment);
+}
+/** The first grapheme cluster of `text` ('' when empty), segmenting no further. */
+function firstGrapheme(text) {
+	for (const { segment } of segmenter.segment(text)) return segment;
+	return "";
+}
+/** Cut `text` to at most `cells`, ending with `…` when cut. */
+function truncate(text, cells$1, measure = defaultMeasure) {
+	if (measure(text) <= cells$1) return text;
+	if (cells$1 <= 0) return "";
+	let out = "";
+	let width$2 = 0;
+	for (const g of graphemes(text)) {
+		const w = measure(g);
+		if (width$2 + w > cells$1 - 1) break;
+		out += g;
+		width$2 += w;
+	}
+	return `${out}…`;
+}
+/** Split `text` into pieces of at most `cells` each, never inside a grapheme. */
+function hardSplit(text, cells$1, measure = defaultMeasure) {
+	const pieces = [];
+	let current = "";
+	let width$2 = 0;
+	for (const g of graphemes(text)) {
+		const w = measure(g);
+		if (width$2 + w > cells$1 && current) {
+			pieces.push(current);
+			current = "";
+			width$2 = 0;
+		}
+		current += g;
+		width$2 += w;
+	}
+	if (current || pieces.length === 0) pieces.push(current);
+	return pieces;
+}
+/**
+* Wrap one paragraph (no newlines) to `width` cells at spaces. A word longer
+* than the line is split with a `hard` join; other continuation rows are
+* `soft` (a copy rejoins them with a space).
+*/
+function wrapText(text, width$2, measure = defaultMeasure) {
+	const max = Math.max(1, width$2);
+	const words$1 = text.split(" ");
+	const rows = [];
+	let current = "";
+	let currentWidth = 0;
+	let join;
+	const push = (next) => {
+		rows.push(join ? {
+			text: current,
+			wrap: join
+		} : { text: current });
+		current = "";
+		currentWidth = 0;
+		join = next;
+	};
+	for (const word of words$1) {
+		const w = measure(word);
+		const gap = current ? 1 : 0;
+		if (current && currentWidth + gap + w > max) push("soft");
+		if (w > max) {
+			const pieces = hardSplit(word, max, measure);
+			pieces.forEach((piece, i) => {
+				if (i > 0) push("hard");
+				current = piece;
+				currentWidth = measure(piece);
+			});
+			continue;
+		}
+		current = current ? `${current} ${word}` : word;
+		currentWidth += (current === word ? 0 : 1) + w;
+	}
+	push(void 0);
+	return rows;
+}
+/** Wrap text with newlines: each line wrapped on its own (hard line breaks stay). */
+function wrapLines(text, width$2, measure = defaultMeasure) {
+	return text.split("\n").flatMap((line) => wrapText(line, width$2, measure));
+}
+
+//#endregion
+//#region src/editor.ts
+const emptyEditor = {
+	value: "",
+	caret: 0
+};
+const clamp = (n, max) => Math.max(0, Math.min(n, max));
+/** Start and end offsets of the line containing `caret`. */
+function lineBounds(value, caret) {
+	const start = value.lastIndexOf("\n", caret - 1) + 1;
+	const nl = value.indexOf("\n", caret);
+	return [start, nl === -1 ? value.length : nl];
+}
+/**
+* The grapheme boundaries of the line holding `at`, both line ends included.
+* A newline always separates graphemes, so only the one line is segmented.
+*/
+function boundaries(value, at) {
+	const [start, end] = lineBounds(value, at);
+	const out = [start];
+	let offset = start;
+	for (const g of graphemes(value.slice(start, end))) {
+		offset += g.length;
+		out.push(offset);
+	}
+	return out;
+}
+/** `caret` clamped to the value and moved back to the start of the grapheme it is inside. */
+function caretBoundary(value, caret) {
+	const at = clamp(caret, value.length);
+	return lastBelow(boundaries(value, at), at + 1);
+}
+/** The last of ascending `list` (which starts below `limit`) that is below `limit`. */
+function lastBelow(list$1, limit) {
+	let found = list$1[0];
+	for (const b of list$1) if (b < limit) found = b;
+	return found;
+}
+/** The boundary one grapheme before `caret` (a boundary), or 0. */
+function before(value, caret) {
+	if (caret === 0) return 0;
+	if (value[caret - 1] === "\n") return caret - 1;
+	return lastBelow(boundaries(value, caret), caret);
+}
+/** The boundary one grapheme after `caret` (a boundary), or the end. */
+function after(value, caret) {
+	if (caret >= value.length) return value.length;
+	if (value[caret] === "\n") return caret + 1;
+	return boundaries(value, caret).find((b) => b > caret);
+}
+/**
+* Split `text` at a caret for drawing: before it, the grapheme under it ('' at
+* the end) and after it. The grapheme is whole, so the caret cell covers all
+* of it (two cells for a wide one) and no character is split around it.
+*/
+function splitAtCaret(text, caret) {
+	const at = caretBoundary(text, caret);
+	const under = firstGrapheme(text.slice(at));
+	return [
+		text.slice(0, at),
+		under,
+		text.slice(at + under.length)
+	];
+}
+const snapped = (state) => {
+	const caret = caretBoundary(state.value, state.caret);
+	return caret === state.caret ? state : {
+		...state,
+		caret
+	};
+};
+/**
+* Insert at the caret. Text that joins the grapheme after it (a combining
+* mark's base, half a flag) leaves the caret after the joined grapheme.
+*/
+function insert(state, text) {
+	const { caret } = snapped(state);
+	const value = state.value.slice(0, caret) + text + state.value.slice(caret);
+	const end = caret + text.length;
+	const at = caretBoundary(value, end);
+	return {
+		value,
+		caret: at === end ? end : after(value, at)
+	};
+}
+function backspace(state) {
+	const { caret } = snapped(state);
+	if (caret === 0) return {
+		...state,
+		caret
+	};
+	const start = before(state.value, caret);
+	return {
+		value: state.value.slice(0, start) + state.value.slice(caret),
+		caret: start
+	};
+}
+function deleteForward(state) {
+	const { caret } = snapped(state);
+	const end = after(state.value, caret);
+	return {
+		value: state.value.slice(0, caret) + state.value.slice(end),
+		caret
+	};
+}
+/** Move the caret `delta` graphemes (negative: left), stopping at the ends. */
+function moveBy(state, delta) {
+	let { caret } = snapped(state);
+	const step = delta < 0 ? before : after;
+	for (let n = Math.abs(delta); n > 0; n--) {
+		const next = step(state.value, caret);
+		if (next === caret) break;
+		caret = next;
+	}
+	return {
+		...state,
+		caret
+	};
+}
+function lineStart(state) {
+	return {
+		...state,
+		caret: lineBounds(state.value, clamp(state.caret, state.value.length))[0]
+	};
+}
+function lineEnd(state) {
+	return {
+		...state,
+		caret: lineBounds(state.value, clamp(state.caret, state.value.length))[1]
+	};
+}
+/** Delete from the line start to the caret. */
+function killToLineStart(state) {
+	const { caret } = snapped(state);
+	const [start] = lineBounds(state.value, caret);
+	return {
+		value: state.value.slice(0, start) + state.value.slice(caret),
+		caret: start
+	};
+}
+/** Delete from the caret to the line end. */
+function killToLineEnd(state) {
+	const { caret } = snapped(state);
+	const [, end] = lineBounds(state.value, caret);
+	return {
+		value: state.value.slice(0, caret) + state.value.slice(end),
+		caret
+	};
+}
+const blank$2 = (g) => /^\s+$/.test(g);
+/** The start of the whitespace-separated word before `caret` (skipping whitespace first). */
+function wordStart(value, caret) {
+	let i = caret;
+	const skip = (word) => {
+		while (i > 0) {
+			const prev = before(value, i);
+			if (blank$2(value.slice(prev, i)) === word) return;
+			i = prev;
+		}
+	};
+	skip(false);
+	skip(true);
+	return i;
+}
+/** Delete the word before the caret (and the whitespace after it). */
+function deleteWordBack(state) {
+	const { caret } = snapped(state);
+	const i = wordStart(state.value, caret);
+	return {
+		value: state.value.slice(0, i) + state.value.slice(caret),
+		caret: i
+	};
+}
+/**
+* Move the caret one line up (`-1`) or down (`+1`), keeping its cell column
+* where the target line is long enough. Returns `undefined` at the first/last
+* line, so the caller can fall through to history navigation.
+*/
+function moveLine(state, direction, measure = defaultMeasure) {
+	return moveVisual(state, visualRows(state.value), direction, measure);
+}
+/** Split into lines, each with the caret column (an offset into the line) when the caret is on it. */
+function caretLines(state) {
+	const { caret } = snapped(state);
+	const out = [];
+	let offset = 0;
+	for (const text of state.value.split("\n")) {
+		const end = offset + text.length;
+		out.push(caret >= offset && caret <= end ? {
+			text,
+			caret: caret - offset
+		} : { text });
+		offset = end + 1;
+	}
+	return out;
+}
+/** Jump to the start of the previous whitespace-separated word. */
+function wordLeft(state) {
+	return {
+		...state,
+		caret: wordStart(state.value, snapped(state).caret)
+	};
+}
+/** Jump past the end of the next whitespace-separated word. */
+function wordRight(state) {
+	const { value } = state;
+	let i = snapped(state).caret;
+	const skip = (word) => {
+		while (i < value.length) {
+			const next = after(value, i);
+			if (blank$2(value.slice(i, next)) === word) return;
+			i = next;
+		}
+	};
+	skip(false);
+	skip(true);
+	return {
+		...state,
+		caret: i
+	};
+}
+/**
+* Lay the value out in rows: at newlines, and (with a width) wherever the
+* next grapheme would pass `width` cells — never inside a wide character.
+*/
+function visualRows(value, width$2, measure = defaultMeasure) {
+	const rows = [];
+	let offset = 0;
+	for (const line of value.split("\n")) {
+		let start = offset;
+		let cells$1 = 0;
+		if (width$2 !== void 0) {
+			let at = offset;
+			for (const g of graphemes(line)) {
+				const w = measure(g);
+				if (cells$1 + w > Math.max(1, width$2) && at > start) {
+					rows.push({
+						start,
+						end: at,
+						soft: true
+					});
+					start = at;
+					cells$1 = 0;
+				}
+				cells$1 += w;
+				at += g.length;
+			}
+		}
+		rows.push({
+			start,
+			end: offset + line.length,
+			soft: false
+		});
+		offset += line.length + 1;
+	}
+	return rows;
+}
+/** The row holding the caret: a soft row's end belongs to the next row. */
+function caretRow(rows, caret) {
+	const i = rows.findIndex((row) => caret >= row.start && (caret < row.end || caret === row.end && !row.soft));
+	return i === -1 ? rows.length - 1 : i;
+}
+/**
+* Move the caret one visual row up or down, keeping its cell column (landing
+* at the end of a shorter row). Undefined at the first or last row.
+*/
+function moveVisual(state, rows, direction, measure = defaultMeasure) {
+	const at = caretBoundary(state.value, state.caret);
+	const from = caretRow(rows, at);
+	const target = rows[from + direction];
+	if (!target) return void 0;
+	const row = rows[from];
+	const column = measure(state.value.slice(row.start, at));
+	let caret = target.start;
+	let cells$1 = 0;
+	for (const g of graphemes(state.value.slice(target.start, target.end))) {
+		const w = measure(g);
+		if (cells$1 + w > column) break;
+		if (target.soft && caret + g.length === target.end) break;
+		cells$1 += w;
+		caret += g.length;
+	}
+	return {
+		...state,
+		caret
+	};
+}
+const toEntry = (entry) => typeof entry === "string" ? { text: entry } : entry;
+function createHistory(entries = []) {
+	const list$1 = entries.map(toEntry);
+	return {
+		entries: list$1,
+		index: list$1.length,
+		draft: { text: "" }
+	};
+}
+function pushHistory(history, entry) {
+	const next = toEntry(entry);
+	const last = history.entries.at(-1);
+	const attached = Boolean(next.attachments?.length);
+	const repeat = last?.text === next.text && !attached && !last.attachments?.length;
+	const entries = (next.text.trim() || attached) && !repeat ? [...history.entries, next] : history.entries;
+	return {
+		entries,
+		index: entries.length,
+		draft: { text: "" }
+	};
+}
+/**
+* Replace the entries (the host's list changed), keeping the draft and a
+* browse in progress (clamped to the new list).
+*/
+function withEntries(history, entries) {
+	const list$1 = entries.map(toEntry);
+	const browsing = history.index < history.entries.length;
+	return {
+		entries: list$1,
+		index: browsing ? Math.min(history.index, list$1.length) : list$1.length,
+		draft: history.draft
+	};
+}
+/** Step through history; returns the new history and the entry to show, or undefined at an end. */
+function stepHistory(history, direction, current) {
+	const index = history.index + direction;
+	if (index < 0 || index > history.entries.length) return void 0;
+	const draft = history.index === history.entries.length ? toEntry(current) : history.draft;
+	const entry = index === history.entries.length ? draft : history.entries[index];
+	return {
+		history: {
+			...history,
+			index,
+			draft
+		},
+		value: entry.text,
+		...entry.attachments?.length ? { attachments: entry.attachments } : {}
+	};
+}
+
+//#endregion
+//#region src/runtime.ts
+const UNBOUND = "@fx-/chat-ink is not bound to React and Ink yet: call createChatInk({ React, ink }) first.";
+/** A stand-in that names the missing call on any use. */
+function unbound() {
+	return new Proxy({}, { get() {
+		throw new Error(UNBOUND);
+	} });
+}
+let React = unbound();
+let ink = unbound();
+/** The core render hooks, bound to the host's React. */
+let hooks = unbound();
+let bound;
+/** Bind the package to the host's React and Ink. */
+function bindRuntime(deps) {
+	if (bound) {
+		if (bound.React === deps.React && bound.ink === deps.ink) return;
+		throw new Error("@fx-/chat-ink is already bound to other React and Ink instances; one process renders with one.");
+	}
+	bound = deps;
+	React = deps.React;
+	ink = deps.ink;
+	hooks = createCoreHooks(deps.React);
+}
+/** Whether `createChatInk` has run. */
+function isBound() {
+	return bound !== void 0;
+}
+
+//#endregion
+//#region src/sanitize.ts
+/**
+* Content must never drive the terminal. Model output, tool output, titles
+* and other host- or model-provided strings may carry escape sequences (an
+* OSC 52 clipboard write, an OSC 8 link, SGR colours, cursor moves) that Ink
+* would pass straight through. Everything this package draws is cleaned
+* here first; its own styling travels as Ink props, never as escapes in text.
+*
+* Removed: whole ESC/C1 sequences — CSI, OSC, DCS, SOS, PM, APC (a string
+* command up to its terminator: BEL, `ESC \` or ST), and any other ESC
+* sequence — then every remaining C0 control but `\n` and `\t` (so `\r` and
+* BEL go), DEL, and the C1 controls U+0080–U+009F. An unterminated string
+* command loses its introducer only: the rest is plain text once no control
+* can read it, and the scan stays linear.
+*/
+const ESC$2 = "\\u001B";
+const BEL = "\\u0007";
+const ST = "\\u009C";
+const STRING_START = `(?:${ESC$2}[P\\]X^_]|[\\u0090\\u0098\\u009D-\\u009F])`;
+const STRING_BODY = `[^${BEL}${ESC$2}\\u0090\\u0098\\u009C-\\u009F]*`;
+const STRING_END = `(?:${BEL}|${ESC$2}\\\\|${ST})`;
+const CSI = `(?:${ESC$2}\\[|\\u009B)[\\u0030-\\u003F]*[\\u0020-\\u002F]*[\\u0040-\\u007E]`;
+const OTHER_ESC = `${ESC$2}[\\u0020-\\u002F]*[\\u0030-\\u007E]`;
+const CONTROL = "[\\u0000-\\u0008\\u000B-\\u001F\\u007F-\\u009F]";
+const SEQUENCES = new RegExp(`${STRING_START}${STRING_BODY}${STRING_END}|${CSI}|${OTHER_ESC}|${CONTROL}`, "g");
+const HAS_CONTROL = new RegExp(CONTROL);
+/** `text` without terminal control sequences or control characters (bar `\n` and `\t`). */
+function stripControls(text) {
+	return HAS_CONTROL.test(text) ? text.replace(SEQUENCES, "") : text;
+}
+const isPlain = (value) => {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+const CONTROLS = new RegExp(CONTROL, "g");
+/** `key` with each control character spelled as visible `\uXXXX` text. */
+const escapeControls = (key) => key.replace(CONTROLS, (c) => `\\u${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}`);
+/**
+* Clean keys for `keys`, one per key, all distinct. A clean key keeps its
+* name; a dirty one takes its stripped form unless that is taken, then its
+* visibly escaped form, then that with ` (2)`, ` (3)`… — so no value is ever
+* dropped by two keys cleaning to the same name.
+*/
+const cleanKeys = (keys) => {
+	const taken = new Set(keys.filter((key) => stripControls(key) === key));
+	return keys.map((key) => {
+		if (stripControls(key) === key) return key;
+		let name = stripControls(key);
+		if (taken.has(name)) name = escapeControls(key);
+		const base = name;
+		for (let n = 2; taken.has(name); n++) name = `${base} (${n})`;
+		taken.add(name);
+		return name;
+	});
+};
+/**
+* `value` with `stripControls` applied to every string in it (object keys
+* included), through arrays and plain objects; other objects (Map, Set,
+* Date, class instances) pass through as they are. Anything unchanged keeps
+* its identity, so clean content costs a scan and no copies. Keys that clean
+* to the same name all survive (see `cleanKeys`); a `__proto__` key stays an
+* own property, never a prototype; a cycle is left as it is where it closes.
+*/
+function stripControlsDeep(value) {
+	return deep(value, new Set());
+}
+function deep(value, path) {
+	if (typeof value === "string") return stripControls(value);
+	if (value === null || typeof value !== "object" || path.has(value)) return value;
+	if (!Array.isArray(value) && !isPlain(value)) return value;
+	path.add(value);
+	try {
+		if (Array.isArray(value)) {
+			let out;
+			value.forEach((item, i) => {
+				const next = deep(item, path);
+				if (next !== item) {
+					out ??= value.slice();
+					out[i] = next;
+				}
+			});
+			return out ?? value;
+		}
+		const entries = Object.entries(value);
+		const keys = cleanKeys(entries.map(([key]) => key));
+		let changed = false;
+		const values = entries.map(([key, item], i) => {
+			const next = deep(item, path);
+			if (next !== item || keys[i] !== key) changed = true;
+			return next;
+		});
+		if (!changed) return value;
+		return Object.fromEntries(keys.map((key, i) => [key, values[i]]));
+	} finally {
+		path.delete(value);
+	}
+}
+
+//#endregion
+//#region src/text.tsx
+function clean(node) {
+	if (typeof node === "string") return stripControls(node);
+	if (Array.isArray(node)) return node.map(clean);
+	if (React.isValidElement(node) && node.type === React.Fragment) return withChildren(node.props.children, (kids) => React.cloneElement(node, void 0, ...kids));
+	return node;
+}
+/** Rebuild with cleaned children, passed as arguments (as JSX does) so none needs a key. */
+function withChildren(children, build) {
+	return build(Array.isArray(children) ? children.map(clean) : [clean(children)]);
+}
+function Text({ children,...props }) {
+	return withChildren(children, (kids) => React.createElement(ink.Text, props, ...kids));
+}
+
+//#endregion
+//#region src/theme.ts
+/** Greyscale defaults: no hue anywhere. */
+const plainTheme = {
+	content: {},
+	muted: { dim: true },
+	strong: { bold: true },
+	marker: { dim: true },
+	chrome: { dim: true },
+	cursor: { inverse: true },
+	positive: {},
+	caution: {},
+	danger: { bold: true },
+	user: { bold: true },
+	assistant: { dim: true },
+	accent: {},
+	code: {},
+	link: { underline: true },
+	selection: { inverse: true }
+};
+/**
+* The default glyphs: monochrome text, one cell each. No glyph is
+* emoji-capable (Unicode `Emoji=No`), so terminals cannot widen or colour one,
+* and every glyph is one that common monospace fonts carry.
+*/
+const plainGlyphs = {
+	collapsed: "▸",
+	expanded: "▾",
+	brain: "✻",
+	wrench: "ƒ",
+	gear: "§",
+	checklist: "☐",
+	planDone: "✓",
+	planActive: "…",
+	planPending: "·",
+	success: "✓",
+	error: "✗",
+	user: "›",
+	assistant: "•",
+	prompt: "›",
+	spinner: [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	],
+	separator: " · ",
+	tool: "ƒ",
+	earlier: "⋮",
+	toolSuccess: "✓",
+	toolError: "✗",
+	toolRunning: "…",
+	toolIdle: "·",
+	boxTopLeft: "╭",
+	boxTopRight: "╮",
+	boxBottomLeft: "╰",
+	boxBottomRight: "╯",
+	boxJunction: "├",
+	boxHorizontal: "─",
+	boxVertical: "│",
+	footer: "╰",
+	outputBar: "┊",
+	attachment: "⊕",
+	image: "▣",
+	pending: "‖",
+	pulse: [
+		"●··",
+		"·●·",
+		"··●"
+	],
+	bullet: "•",
+	taskOpen: "☐",
+	taskDone: "☒",
+	rule: "─",
+	quoteBar: "│",
+	codeBar: "│",
+	tableColumn: "│",
+	tableCross: "┼"
+};
+/** Glyphs using only ASCII, for terminals without box-drawing or emoji symbols. */
+const asciiGlyphs = {
+	collapsed: ">",
+	expanded: "v",
+	brain: "~",
+	wrench: "*",
+	gear: "#",
+	checklist: "=",
+	planDone: "x",
+	planActive: ">",
+	planPending: "-",
+	success: "+",
+	error: "x",
+	user: ">",
+	assistant: "*",
+	prompt: ">",
+	spinner: [
+		"|",
+		"/",
+		"-",
+		"\\"
+	],
+	separator: " | ",
+	tool: "*",
+	earlier: "^",
+	toolSuccess: "+",
+	toolError: "x",
+	toolRunning: "~",
+	toolIdle: ".",
+	boxTopLeft: "+",
+	boxTopRight: "+",
+	boxBottomLeft: "+",
+	boxBottomRight: "+",
+	boxJunction: "+",
+	boxHorizontal: "-",
+	boxVertical: "|",
+	footer: "+",
+	outputBar: ":",
+	attachment: "@",
+	image: "[img]",
+	pending: "..",
+	pulse: [
+		"o..",
+		".o.",
+		"..o"
+	],
+	bullet: "-",
+	taskOpen: "[ ]",
+	taskDone: "[x]",
+	rule: "-",
+	quoteBar: "|",
+	codeBar: "|",
+	tableColumn: "|",
+	tableCross: "+"
+};
+/**
+* Opt-in colour icons over {@link plainGlyphs}: only code points that are
+* emoji by default (`Emoji_Presentation=Yes`), which terminals and the
+* default measure both treat as two cells. Turn it on with
+* `<InkChatProvider components={{ glyphs: emojiGlyphs }}>`.
+*/
+const emojiGlyphs = {
+	...plainGlyphs,
+	brain: "🧠",
+	wrench: "🔧",
+	tool: "🔧",
+	gear: "📜",
+	checklist: "📋",
+	attachment: "📎",
+	image: "📷",
+	pending: "⏳"
+};
+
+//#endregion
+//#region src/registry.tsx
+/** Prints markdown source as-is. */
+function PlainMarkdown({ content }) {
+	return /* @__PURE__ */ React.createElement(Styled, { tone: "content" }, content);
+}
+const plainComponents = {
+	theme: plainTheme,
+	glyphs: plainGlyphs,
+	Markdown: PlainMarkdown,
+	spinnerIntervalMs: 80,
+	flashComplete: true
+};
+let context;
+const inkContext = () => {
+	context ??= React.createContext(plainComponents);
+	return context;
+};
+/** Merge a partial registry over a base. */
+function mergeInkComponents(base, partial = {}) {
+	return {
+		theme: {
+			...base.theme,
+			...partial.theme
+		},
+		glyphs: {
+			...base.glyphs,
+			...partial.glyphs
+		},
+		Markdown: partial.Markdown ?? base.Markdown,
+		spinnerIntervalMs: partial.spinnerIntervalMs ?? base.spinnerIntervalMs,
+		flashComplete: partial.flashComplete ?? base.flashComplete
+	};
+}
+function InkChatProvider({ components, children }) {
+	const value = React.useMemo(() => mergeInkComponents(plainComponents, components), [components]);
+	const InkContext = inkContext();
+	return /* @__PURE__ */ React.createElement(InkContext.Provider, { value }, children);
+}
+function useInkComponents() {
+	return React.useContext(inkContext());
+}
+/** Ink `<Text>` props for an appearance. */
+function appearanceProps(appearance) {
+	return {
+		...appearance.color ? { color: appearance.color } : {},
+		...appearance.dim ? { dimColor: true } : {},
+		...appearance.bold ? { bold: true } : {},
+		...appearance.italic ? { italic: true } : {},
+		...appearance.inverse ? { inverse: true } : {},
+		...appearance.underline ? { underline: true } : {},
+		...appearance.strikethrough ? { strikethrough: true } : {}
+	};
+}
+/** Text drawn in a theme role (`tone`). */
+function Styled({ tone, wrap, children }) {
+	const { theme } = useInkComponents();
+	return /* @__PURE__ */ React.createElement(Text, {
+		...appearanceProps(theme[tone]),
+		...wrap ? { wrap } : {}
+	}, children);
+}
+
+//#endregion
+//#region src/terminal.ts
+/**
+* Terminal protocol helpers shared by the composer and the viewport.
+*/
+const ESC$1 = String.fromCharCode(27);
+const TERMINAL_REPORT = new RegExp(`^(?:${ESC$1})?\\[(?:<\\d+;\\d+;\\d+[Mm]|\\d+;\\d+;\\d+t|\\?\\d[\\d;]*[a-zA-Z])`);
+/** Mouse reports and terminal replies arrive as input; key handlers ignore them. */
+function isTerminalReport(input) {
+	return TERMINAL_REPORT.test(input);
+}
+/** The longest unfinished report followed across key events; a longer one is noise. */
+const MAX_TAIL = 64;
+const CSI_HEAD = /^\[[\x30-\x3f]*[\x20-\x2f]*/;
+/**
+* Where the CSI sequence opening `text` (ESC stripped) ends: past its final
+* byte, 0 while it is unfinished, or -1 when `text` opens none.
+*/
+function csiEnd(text) {
+	const head = CSI_HEAD.exec(text);
+	if (!head) return -1;
+	const at = head[0].length;
+	if (at === text.length) return 0;
+	const code = text.charCodeAt(at);
+	return code >= 64 && code <= 126 ? at + 1 : -1;
+}
+/**
+* A reader of terminal reports across key events. Ink holds an unfinished
+* escape sequence only briefly, then delivers it with its ESC stripped (so a
+* report split across stdin chunks arrives as `[<0;3` and then `;4M`). Each
+* call classifies one event's input, following such a start into the next
+* event; the start itself cannot be told from typing (a typed `[` looks the
+* same), so it is `partial` and the caller decides what to hold back.
+*/
+function createKeyReportReader() {
+	let tail = "";
+	return (input) => {
+		const held = tail;
+		tail = "";
+		if (isTerminalReport(input)) return {
+			kind: "report",
+			joined: false,
+			rest: ""
+		};
+		const text = input.startsWith(ESC$1) ? input.slice(1) : input;
+		if (held && text) {
+			const joined = held + text;
+			const end = csiEnd(joined);
+			if (end > 0 && isTerminalReport(joined.slice(0, end))) return {
+				kind: "report",
+				joined: true,
+				rest: joined.slice(end)
+			};
+			if (end === 0 && joined.length <= MAX_TAIL) {
+				tail = joined;
+				return {
+					kind: "partial",
+					continued: true
+				};
+			}
+		}
+		if (csiEnd(text) === 0 && text.length <= MAX_TAIL) {
+			tail = text;
+			return {
+				kind: "partial",
+				continued: false
+			};
+		}
+		return { kind: "text" };
+	};
+}
+/** Kitty keyboard protocol: push the disambiguate flag (Shift+Enter is then reported). */
+const KITTY_PUSH = `${ESC$1}[>1u`;
+/** Kitty keyboard protocol: pop the flags pushed last. */
+const KITTY_POP = `${ESC$1}[<u`;
+
+//#endregion
+//#region src/Composer.tsx
+const emptyComposerValue = {
+	text: "",
+	caret: 0,
+	attachments: []
+};
+function findMatch(providers, state) {
+	for (const provider of providers ?? []) {
+		if (!state.value.slice(0, state.caret).includes(provider.trigger)) continue;
+		const match = provider.match(state.value, state.caret);
+		if (match) return {
+			provider,
+			match
+		};
+	}
+	return void 0;
+}
+/** Stable identity of a matched token (provider, start, query). */
+function keyOf(found) {
+	return found ? `${found.provider.id}:${found.match.range[0]}:${found.match.query}` : void 0;
+}
+/** State plus a ref that always holds the latest value, updated synchronously. */
+function useLive(initial) {
+	const [value, setValue] = React.useState(initial);
+	const ref = React.useRef(value);
+	const set = React.useCallback((next) => {
+		ref.current = next;
+		setValue(() => next);
+	}, []);
+	return [
+		value,
+		ref,
+		set
+	];
+}
+const toEditor = (v) => ({
+	value: v.text,
+	caret: v.caret
+});
+const sameEditor = (a, b) => a.value === b.value && a.caret === b.caret;
+/**
+* Cells left for text at `width`: the prompt, the border and padding of the
+* boxed variant, and one cell kept for the caret come off.
+*/
+function composerInnerWidth(width$2, variant = "boxed", promptWidth = 2) {
+	return Math.max(1, width$2 - promptWidth - (variant === "boxed" ? 4 : 0) - 1);
+}
+/**
+* Rows the composer takes at `width` for `value`: its input rows (up to
+* `maxRows`), the attachments row, and the boxed variant's border — not the
+* hint or completion lines under it. Lets a host size the rest of the screen.
+*/
+function composerRows(value, width$2, options = {}) {
+	const { variant = "boxed", maxRows, promptWidth = 2, measure = defaultMeasure } = options;
+	const rows = visualRows(value.text, composerInnerWidth(width$2, variant, promptWidth), measure).length;
+	const shown = maxRows === void 0 ? rows : Math.min(rows, Math.max(1, maxRows));
+	return shown + (value.attachments.length > 0 ? 1 : 0) + (variant === "boxed" ? 2 : 0);
+}
+/** Keep the caret's row inside a window of `max` rows, moving the window as little as possible. */
+function scrollTop(top, row, rows, max) {
+	const last = Math.max(0, rows - max);
+	if (row < top) return row;
+	if (row >= top + max) return Math.min(row - max + 1, last);
+	return Math.min(top, last);
+}
+function Composer({ onSubmit, onEscape, providers, history: initialHistory, placeholder = "Message", disabled = false, hint, maxItems = 6, value: controlled, onChange, variant = "boxed", width: width$2, maxRows, focused = true, attachmentHint, killLine = "line", onKey, onPaste, inputSource = "own", ref, kittyKeyboard = false, measure = defaultMeasure }) {
+	const { glyphs, theme } = useInkComponents();
+	const { stdout } = ink.useStdout();
+	const [own, valueRef, setOwn] = useLive(controlled ?? emptyComposerValue);
+	const seen = React.useRef(controlled);
+	if (controlled && controlled !== seen.current) {
+		seen.current = controlled;
+		valueRef.current = controlled;
+	}
+	const current = controlled ?? own;
+	const [, historyRef, setHistory] = useLive(() => createHistory(initialHistory));
+	const historyLength = initialHistory?.length ?? 0;
+	const seenHistory = React.useRef(initialHistory);
+	React.useEffect(() => {
+		if (seenHistory.current === initialHistory && historyLength === historyRef.current.entries.length) return;
+		seenHistory.current = initialHistory;
+		setHistory(withEntries(historyRef.current, initialHistory ?? []));
+	}, [
+		initialHistory,
+		historyLength,
+		historyRef,
+		setHistory
+	]);
+	const [completion, completionRef, setCompletion] = useLive(void 0);
+	const [dismissed, dismissedRef, setDismissed] = useLive(void 0);
+	const recalled = React.useRef(false);
+	const active = focused && !disabled;
+	const prompt = `${glyphs.prompt} `;
+	const promptWidth = measure(prompt);
+	const inner = width$2 === void 0 ? void 0 : composerInnerWidth(width$2, variant, promptWidth);
+	const rowsOf = (text) => visualRows(text, inner, measure);
+	const found = findMatch(providers, toEditor(current));
+	const tokenKey = keyOf(found);
+	const latest = React.useRef(found);
+	latest.current = found;
+	React.useEffect(() => {
+		const match = latest.current;
+		if (!tokenKey || !match || tokenKey === dismissed) {
+			setCompletion(void 0);
+			return;
+		}
+		const controller = new AbortController();
+		Promise.resolve(match.provider.items(match.match.query, controller.signal)).then((items) => {
+			if (controller.signal.aborted) return;
+			setCompletion(items.length > 0 ? {
+				provider: match.provider,
+				match: match.match,
+				items,
+				active: 0
+			} : void 0);
+		}, () => {
+			if (!controller.signal.aborted) setCompletion(void 0);
+		});
+		return () => controller.abort();
+	}, [tokenKey, dismissed]);
+	React.useEffect(() => {
+		if (!kittyKeyboard || !active) return;
+		stdout.write(KITTY_PUSH);
+		const pop = () => stdout.write(KITTY_POP);
+		process.once("exit", pop);
+		return () => {
+			process.off("exit", pop);
+			pop();
+		};
+	}, [
+		kittyKeyboard,
+		active,
+		stdout
+	]);
+	const commit = (next) => {
+		setOwn(next);
+		onChange?.(next);
+	};
+	const setEditor = (state, attachments$1 = valueRef.current.attachments) => commit({
+		text: state.value,
+		caret: state.caret,
+		attachments: attachments$1
+	});
+	/** A change from the user: an edit ends a recall and reopens completion. */
+	const edit = (next) => {
+		if (dismissedRef.current !== void 0) setDismissed(void 0);
+		if (next.value !== valueRef.current.text) recalled.current = false;
+		setEditor(next);
+	};
+	const apply = (c) => {
+		const item = c.items[c.active];
+		const [start, end] = c.match.range;
+		const text = valueRef.current.text;
+		const result = c.provider.apply(item, text.slice(0, start), text.slice(end));
+		const next = {
+			value: result.value,
+			caret: result.caret
+		};
+		setEditor(next);
+		setCompletion(void 0);
+		setDismissed(keyOf(findMatch(providers, next)));
+	};
+	/** Submit `text` with the current attachments (if either has content); returns whether it was sent. */
+	const send = (text) => {
+		const attachments$1 = valueRef.current.attachments;
+		if (!text.trim() && attachments$1.length === 0) return false;
+		if (attachments$1.length > 0) onSubmit(text, attachments$1);
+		else onSubmit(text);
+		setHistory(pushHistory(historyRef.current, {
+			text,
+			attachments: attachments$1
+		}));
+		setCompletion(void 0);
+		recalled.current = false;
+		return true;
+	};
+	const cleared = {
+		value: "",
+		caret: 0
+	};
+	const submit = () => {
+		if (send(valueRef.current.text)) setEditor(cleared, []);
+	};
+	/**
+	* A chunk of typed characters. Terminals and multiplexers may deliver
+	* several keystrokes at once (e.g. `"hi\r"`), which arrive as text without
+	* the return flag: a `\r` inside the chunk submits what precedes it and a
+	* `\n` inserts a newline, as if each key had arrived alone.
+	*/
+	const typeChunk = (chunk) => {
+		let state = toEditor(valueRef.current);
+		for (const part of chunk.split(/(\r\n?|\n)/)) if (part === "\n") state = insert(state, "\n");
+		else if (part.startsWith("\r")) {
+			if (send(state.value)) {
+				state = cleared;
+				setEditor(state, []);
+			}
+		} else if (part) state = insert(state, stripControls(part));
+		edit(state);
+	};
+	const paste = (text) => {
+		if (onPaste?.(text)) return;
+		edit(insert(toEditor(valueRef.current), stripControls(text.replace(/\r\n?/g, "\n"))));
+	};
+	const stepThroughHistory = (direction) => {
+		const value = valueRef.current;
+		const stepped = stepHistory(historyRef.current, direction, {
+			text: value.text,
+			attachments: value.attachments
+		});
+		if (!stepped) return;
+		setHistory(stepped.history);
+		recalled.current = stepped.history.index < stepped.history.entries.length;
+		setEditor({
+			value: stepped.value,
+			caret: stepped.value.length
+		}, stepped.attachments ?? []);
+	};
+	const [readReport] = React.useState(createKeyReportReader);
+	const held = React.useRef(void 0);
+	const handleKey = (input$1, key) => {
+		const report = readReport(input$1);
+		const start = held.current;
+		held.current = void 0;
+		if (report.kind === "report") {
+			const now = toEditor(valueRef.current);
+			if (report.joined && sameEditor(now, start.after) && !sameEditor(now, start.before)) edit(start.before);
+			if (report.rest) handleKey(report.rest, key);
+			return;
+		}
+		const from = report.kind === "partial" && report.continued ? start.before : toEditor(valueRef.current);
+		if (report.kind === "partial") held.current = {
+			before: from,
+			after: from
+		};
+		handleOwnKey(input$1, key);
+		if (held.current) held.current.after = toEditor(valueRef.current);
+	};
+	const handleOwnKey = (input$1, key) => {
+		if (onKey?.(input$1, key)) return;
+		const completion$1 = completionRef.current;
+		const editor = toEditor(valueRef.current);
+		if (completion$1) {
+			if (key.upArrow || key.downArrow) {
+				const n = completion$1.items.length;
+				setCompletion({
+					...completion$1,
+					active: (completion$1.active + (key.upArrow ? n - 1 : 1)) % n,
+					navigated: true
+				});
+				return;
+			}
+			if (key.tab || key.return && completion$1.navigated) {
+				apply(completion$1);
+				return;
+			}
+			if (key.escape) {
+				setDismissed(keyOf(findMatch(providers, editor)));
+				setCompletion(void 0);
+				return;
+			}
+		}
+		if (key.escape) {
+			onEscape?.();
+			return;
+		}
+		if (key.return) {
+			if (key.meta || key.shift) edit(insert(editor, "\n"));
+			else if (editor.value.slice(0, editor.caret).endsWith("\\")) edit(insert(backspace(editor), "\n"));
+			else submit();
+			return;
+		}
+		if (key.backspace) return edit(backspace(editor));
+		if (key.delete) return edit(deleteForward(editor));
+		if ((key.ctrl || key.meta) && key.leftArrow) return edit(wordLeft(editor));
+		if ((key.ctrl || key.meta) && key.rightArrow) return edit(wordRight(editor));
+		if (key.meta && input$1 === "b") return edit(wordLeft(editor));
+		if (key.meta && input$1 === "f") return edit(wordRight(editor));
+		if (key.leftArrow) return edit(moveBy(editor, -1));
+		if (key.rightArrow) return edit(moveBy(editor, 1));
+		if (key.home || key.ctrl && input$1 === "a") return edit(lineStart(editor));
+		if (key.end || key.ctrl && input$1 === "e") return edit(lineEnd(editor));
+		if (key.ctrl && input$1 === "u") return edit(killLine === "input" ? cleared : killToLineStart(editor));
+		if (key.ctrl && input$1 === "k") return edit(killToLineEnd(editor));
+		if (key.ctrl && input$1 === "w") return edit(deleteWordBack(editor));
+		if (key.upArrow || key.downArrow) {
+			const direction = key.upArrow ? -1 : 1;
+			const moved = recalled.current ? void 0 : moveVisual(editor, rowsOf(editor.value), direction, measure);
+			if (moved) return edit(moved);
+			stepThroughHistory(direction);
+			return;
+		}
+		if (key.ctrl || key.meta || key.tab || !input$1) return;
+		typeChunk(input$1);
+	};
+	React.useImperativeHandle(ref, () => ({
+		key: handleKey,
+		paste
+	}));
+	const listening = active && inputSource === "own";
+	ink.usePaste(paste, { isActive: listening });
+	ink.useInput(handleKey, { isActive: listening });
+	const rows = rowsOf(current.text);
+	const at = caretBoundary(current.text, current.caret);
+	const row = caretRow(rows, at);
+	const top = React.useRef(0);
+	top.current = maxRows === void 0 ? 0 : scrollTop(top.current, row, rows.length, Math.max(1, maxRows));
+	const shown = rows.slice(top.current, maxRows === void 0 ? void 0 : top.current + maxRows);
+	const empty = current.text === "" && current.attachments.length === 0;
+	const input = empty ? /* @__PURE__ */ React.createElement(Text, null, focused ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, appearanceProps(theme.cursor), placeholder.slice(0, 1) || " "), /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, placeholder.slice(1))) : /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, placeholder)) : shown.map((r, i) => {
+		const text = current.text.slice(r.start, r.end);
+		const caret = focused && top.current + i === row ? splitAtCaret(text, at - r.start) : void 0;
+		return /* @__PURE__ */ React.createElement(Text, {
+			key: i,
+			wrap: inner === void 0 ? "wrap" : "truncate"
+		}, caret === void 0 ? text || " " : /* @__PURE__ */ React.createElement(React.Fragment, null, caret[0], /* @__PURE__ */ React.createElement(Text, appearanceProps(theme.cursor), caret[1] || " "), caret[2]));
+	});
+	const attachments = current.attachments.length > 0 ? /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Styled, { tone: "link" }, `${glyphs.attachment} `), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, truncate([current.attachments.map((a) => a.description ?? a.name ?? a.mediaType).join(glyphs.separator), attachmentHint].filter(Boolean).join("  "), Math.max(1, (width$2 ?? Number.POSITIVE_INFINITY) - measure(`${glyphs.attachment} `)), measure))) : null;
+	const promptTone = focused ? "marker" : "chrome";
+	const below = completion ? /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		paddingLeft: 2
+	}, completion.items.slice(0, maxItems).map((item, i) => /* @__PURE__ */ React.createElement(Text, { key: item.id }, /* @__PURE__ */ React.createElement(Text, i === completion.active ? appearanceProps(theme.cursor) : {}, item.label), item.description ? /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, " ", item.description) : null))) : hint ? /* @__PURE__ */ React.createElement(ink.Box, { paddingLeft: 2 }, /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, hint)) : null;
+	if (variant === "plain") return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, attachments, /* @__PURE__ */ React.createElement(ink.Box, null, /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		width: promptWidth,
+		flexShrink: 0
+	}, /* @__PURE__ */ React.createElement(Styled, { tone: promptTone }, prompt)), /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		flexGrow: 1
+	}, input)), below);
+	return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, attachments, /* @__PURE__ */ React.createElement(ink.Box, {
+		...width$2 === void 0 ? {} : { width: width$2 },
+		borderStyle: "round",
+		borderColor: theme.chrome.color ?? "gray",
+		borderDimColor: Boolean(theme.chrome.dim),
+		paddingX: 1
+	}, /* @__PURE__ */ React.createElement(ink.Box, { marginRight: 1 }, /* @__PURE__ */ React.createElement(Styled, { tone: promptTone }, glyphs.prompt)), /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		flexGrow: 1
+	}, input)), below);
+}
+
+//#endregion
+//#region src/Spinner.tsx
+/**
+* An animated spinner in the `marker` role, using the injected frames. It
+* steps once per tick of the shared clock when a ClockProvider is in scope,
+* else every `spinnerIntervalMs`.
+*/
+function Spinner() {
+	const { glyphs, spinnerIntervalMs } = useInkComponents();
+	const frame = hooks.useTicks(true, spinnerIntervalMs);
+	const frames = glyphs.spinner;
+	return /* @__PURE__ */ React.createElement(Styled, { tone: "marker" }, frames[frame % frames.length] ?? "");
+}
+
+//#endregion
+//#region src/Row.tsx
+function Row({ label, detail, qualifier, iconName, prefix: prefix$1, isActive = false, startedAt, durationMs, showTimer = false, tokensPerSecond, error = false, expanded = false, children }) {
+	const { glyphs, flashComplete } = useInkComponents();
+	const flash = hooks.useFlashComplete(isActive, 1200, flashComplete);
+	const elapsed = hooks.useElapsedTimer({
+		startedAt,
+		isActive: isActive && showTimer,
+		durationMs
+	});
+	const hasBody = children != null && children !== false;
+	const timer = shouldShowTimer({
+		showTimer,
+		isActive,
+		startedAt,
+		durationMs
+	});
+	const tps = formatTokensPerSecond(tokensPerSecond);
+	let affordance;
+	if (isActive) affordance = /* @__PURE__ */ React.createElement(Spinner, null);
+	else if (flash) affordance = /* @__PURE__ */ React.createElement(Styled, { tone: "positive" }, glyphs.success);
+	else if (hasBody) affordance = /* @__PURE__ */ React.createElement(Styled, { tone: "marker" }, expanded ? glyphs.expanded : glyphs.collapsed);
+	else affordance = /* @__PURE__ */ React.createElement(Text, null, " ");
+	return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(ink.Box, { gap: 1 }, affordance, prefix$1, iconName ? /* @__PURE__ */ React.createElement(Styled, { tone: "marker" }, glyphs[iconName]) : null, /* @__PURE__ */ React.createElement(Styled, {
+		tone: error ? "danger" : "strong",
+		wrap: "truncate-end"
+	}, label), detail ? /* @__PURE__ */ React.createElement(Styled, {
+		tone: "muted",
+		wrap: "truncate-end"
+	}, detail) : null, error ? /* @__PURE__ */ React.createElement(Styled, { tone: "danger" }, glyphs.error, " Error") : null, qualifier ? /* @__PURE__ */ React.createElement(Styled, { tone: "danger" }, "· ", qualifier) : null, timer ? /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, formatDuration(elapsed)) : null, tps ? /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, tps) : null), hasBody && expanded ? /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		paddingLeft: 2
+	}, children) : null);
+}
+/** Clip long text to `maxLines`, noting how many lines were hidden. */
+function clipLines(text, maxLines) {
+	const lines = text.split("\n");
+	if (lines.length <= maxLines) return text;
+	return [...lines.slice(0, maxLines), `… ${lines.length - maxLines} more lines`].join("\n");
+}
+/** Pretty JSON, tolerating values JSON cannot encode. */
+function toJson(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value, null, 2) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+//#region src/MessageView.tsx
+const APPROVAL_TEXT = {
+	denied: "denied",
+	unavailable: "refused",
+	pending: "awaiting approval"
+};
+function BlockRow({ block, ctx }) {
+	const { Markdown } = useInkComponents();
+	const live = isBlockActive(block, ctx);
+	if (!isCoreBlockType(block.type)) {
+		const custom = block;
+		const Renderer = lookupExtension(ctx.extensions?.blockRenderers, custom.type);
+		if (Renderer) return /* @__PURE__ */ React.createElement(Renderer, {
+			block: custom,
+			message: ctx.message,
+			isStreaming: live
+		});
+		return /* @__PURE__ */ React.createElement(Row, { label: summarizeBlock(custom).label });
+	}
+	const core = block;
+	switch (core.type) {
+		case "text": return ctx.message.role === "user" ? /* @__PURE__ */ React.createElement(Styled, { tone: "user" }, core.text) : /* @__PURE__ */ React.createElement(Markdown, {
+			content: core.text,
+			...live ? { streaming: true } : {}
+		});
+		case "reasoning": {
+			const summary = summarizeBlock(core, { isActive: live });
+			return /* @__PURE__ */ React.createElement(Row, {
+				label: summary.label,
+				iconName: "brain",
+				isActive: live,
+				startedAt: positiveTimestamp(core.startedAt) ?? ctx.startedAt,
+				durationMs: core.durationMs,
+				showTimer: summary.showTimer,
+				expanded: ctx.expanded
+			}, core.text ? /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, clipLines(core.text, ctx.bodyLines)) : null);
+		}
+		case "tool_call": {
+			const isError = core.status === "error";
+			const input = toolDisplayInput(core);
+			const approval = core.approval ? APPROVAL_TEXT[core.approval.state] : void 0;
+			return /* @__PURE__ */ React.createElement(Row, {
+				label: toolLabel(core) || "tool",
+				...input ? { detail: input } : {},
+				...approval ? { qualifier: approval } : {},
+				iconName: "wrench",
+				isActive: live,
+				startedAt: core.startedAt,
+				durationMs: core.durationMs,
+				showTimer: true,
+				error: isError,
+				expanded: ctx.expanded
+			}, /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, "input"), /* @__PURE__ */ React.createElement(Styled, { tone: "content" }, clipLines(toJson(core.arguments), ctx.bodyLines)), core.result !== void 0 ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, "output"), /* @__PURE__ */ React.createElement(Styled, { tone: isError ? "danger" : "content" }, clipLines(toolResultText(core.result), ctx.bodyLines))) : null));
+		}
+		case "status": return /* @__PURE__ */ React.createElement(Row, {
+			label: statusLabel(core.phase, live),
+			isActive: live,
+			startedAt: ctx.startedAt,
+			durationMs: ctx.durationMs,
+			showTimer: true,
+			...live ? { tokensPerSecond: ctx.tokensPerSecond } : {}
+		});
+		case "plan": {
+			const summary = summarizeBlock(core);
+			return /* @__PURE__ */ React.createElement(Row, {
+				label: summary.label,
+				iconName: "checklist",
+				expanded: ctx.expanded
+			}, core.entries.length > 0 ? /* @__PURE__ */ React.createElement(PlanEntries, {
+				entries: core.entries,
+				live: ctx.isActive
+			}) : null);
+		}
+		case "system": return /* @__PURE__ */ React.createElement(Row, {
+			label: "System prompt",
+			iconName: "gear",
+			expanded: ctx.expanded
+		}, /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, clipLines(core.text, ctx.bodyLines)));
+	}
+}
+function PlanEntries({ entries, live }) {
+	const { glyphs } = useInkComponents();
+	return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, entries.map((entry, index) => {
+		const marker = entry.status === "completed" ? glyphs.planDone : entry.status === "in_progress" ? glyphs.planActive : glyphs.planPending;
+		const tone = entry.status === "completed" ? "muted" : entry.status === "in_progress" && live ? "caution" : "content";
+		return /* @__PURE__ */ React.createElement(ink.Box, {
+			key: entry.id ?? index,
+			gap: 1
+		}, entry.status === "in_progress" && live ? /* @__PURE__ */ React.createElement(Spinner, null) : /* @__PURE__ */ React.createElement(Styled, { tone: entry.status === "completed" ? "positive" : "marker" }, marker), /* @__PURE__ */ React.createElement(Styled, { tone }, entry.content));
+	}));
+}
+function GroupRow({ blocks, ctx }) {
+	const plan = planGroupHeader(blocks, ctx);
+	const tokensPerSecond = plan.showRate ? ctx.tokensPerSecond : void 0;
+	const only = plan.tools?.only;
+	const approval = only?.approval ? APPROVAL_TEXT[only.approval.state] : void 0;
+	return /* @__PURE__ */ React.createElement(Row, {
+		label: plan.summary.label,
+		...approval ? { qualifier: approval } : {},
+		error: only !== void 0 && plan.tools?.failed === 1,
+		iconName: plan.summary.iconName,
+		prefix: plan.hiddenCount > 0 ? /* @__PURE__ */ React.createElement(Styled, { tone: "marker" }, "(+", plan.hiddenCount, ")") : null,
+		isActive: plan.isActive,
+		startedAt: plan.startedAt,
+		durationMs: plan.durationMs,
+		showTimer: plan.showTimer,
+		tokensPerSecond,
+		expanded: ctx.expanded
+	}, blocks.map((block) => /* @__PURE__ */ React.createElement(BlockRow, {
+		key: block.id,
+		block,
+		ctx
+	})));
+}
+function MessageView({ message: original, isActive = false, expanded = false, minimal = false, showFooter = true, bodyLines = 12, extensions, retryHint, activityPlacement, liveTail, liveFooter = false }) {
+	const { glyphs } = useInkComponents();
+	const message = stripControlsDeep(original);
+	const live = isActive && liveFooter;
+	const now = hooks.useElapsedTimer({
+		startedAt: 0,
+		isActive: live,
+		intervalMs: 1e3
+	});
+	const tokensPerSecond = hooks.useLiveTokensPerSecond({
+		startedAt: message.createdAt,
+		isActive,
+		tokenCount: isActive ? approxTokenCount(message.blocks) : void 0,
+		metrics: message.metrics
+	});
+	const plan = planMessage(message, {
+		isActive,
+		minimal,
+		showFooter,
+		...activityPlacement ? { activityPlacement } : {},
+		...liveTail !== void 0 && !expanded ? { liveTail } : {}
+	});
+	const ctx = {
+		message,
+		isActive,
+		activeBlockId: plan.activeBlockId,
+		startedAt: message.createdAt,
+		durationMs: message.metrics?.durationMs,
+		tokensPerSecond,
+		expanded,
+		bodyLines,
+		extensions,
+		outcome: message.outcome
+	};
+	const showsSomething$1 = message.blocks.length > 0 || message.outcome !== void 0;
+	const footerFacts = plan.showFooter || live && showsSomething$1 ? planFooter(message, {
+		isActive,
+		detail: expanded ? "details" : "collapsed",
+		...live ? { now } : {}
+	}) : void 0;
+	const factGlyph = {
+		reasoning: glyphs.brain,
+		plan: glyphs.checklist,
+		tools: glyphs.wrench
+	};
+	const footer = footerFacts ? [...footerFacts.map((fact) => factGlyph[fact.key] ? `${factGlyph[fact.key]} ${fact.text}` : fact.text), ...message.outcome && retryHint ? [retryHint] : []].join(glyphs.separator) || void 0 : void 0;
+	const isUser = message.role === "user";
+	const attachments = message.attachments ?? [];
+	return /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		marginBottom: 1
+	}, /* @__PURE__ */ React.createElement(ink.Box, { gap: 1 }, /* @__PURE__ */ React.createElement(Styled, { tone: isUser ? "user" : "assistant" }, isUser ? glyphs.user : glyphs.assistant), /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		flexGrow: 1
+	}, plan.rows.map((row) => row.kind === "pending" ? /* @__PURE__ */ React.createElement(BlockRow, {
+		key: row.id,
+		block: {
+			type: "status",
+			id: row.id,
+			phase: "pre-stream"
+		},
+		ctx: {
+			...ctx,
+			activeBlockId: row.id
+		}
+	}) : row.kind === "bare" ? /* @__PURE__ */ React.createElement(BlockRow, {
+		key: row.block.id,
+		block: row.block,
+		ctx
+	}) : row.kind === "earlier" ? /* @__PURE__ */ React.createElement(Styled, {
+		key: row.key,
+		tone: "muted"
+	}, glyphs.earlier ? `${glyphs.earlier} ${earlierLabel(row)}` : earlierLabel(row)) : row.kind === "outcome" ? /* @__PURE__ */ React.createElement(Styled, {
+		key: "outcome",
+		tone: "danger"
+	}, glyphs.error, " ", row.outcome.message) : /* @__PURE__ */ React.createElement(GroupRow, {
+		key: row.key,
+		blocks: row.blocks,
+		ctx
+	})), attachments.map((a, i) => /* @__PURE__ */ React.createElement(Styled, {
+		key: `${a.url}-${i}`,
+		tone: "muted"
+	}, "[", a.kind, "] ", a.name ?? a.mediaType)), footer ? /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, footer) : null)));
+}
+
+//#endregion
+//#region src/Transcript.tsx
+function Transcript({ messages, isStreaming = false, streamingMessageId, expanded = false, expandFinished = false, minimal = false, showFooter = true, bodyLines, extensions, retryHint, activityPlacement, liveTail, liveFooter }) {
+	const liveIndex = isStreaming ? messages.findIndex((message) => message.id === streamingMessageId) : -1;
+	const finished = liveIndex === -1 ? messages : messages.slice(0, liveIndex);
+	const live = liveIndex === -1 ? [] : messages.slice(liveIndex);
+	const common = {
+		minimal,
+		showFooter,
+		...bodyLines !== void 0 ? { bodyLines } : {},
+		...extensions ? { extensions } : {},
+		...retryHint ? { retryHint } : {},
+		...activityPlacement ? { activityPlacement } : {},
+		...liveTail !== void 0 ? { liveTail } : {},
+		...liveFooter !== void 0 ? { liveFooter } : {}
+	};
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Static, { items: finished }, (message) => /* @__PURE__ */ React.createElement(MessageView, {
+		key: message.id,
+		message,
+		expanded: expandFinished,
+		...common
+	})), live.length > 0 ? /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, live.map((message) => /* @__PURE__ */ React.createElement(MessageView, {
+		key: message.id,
+		message,
+		isActive: message.id === streamingMessageId,
+		expanded,
+		...common
+	}))) : null);
+}
+
+//#endregion
+//#region src/lines/Lines.tsx
+/** A span's resolved text props. */
+function spanProps(s, theme, highlight) {
+	const base = {
+		...s.role ? theme[s.role] : {},
+		...s.style,
+		...s.bold !== void 0 ? { bold: s.bold } : {},
+		...s.italic ? { italic: true } : {},
+		...s.dim ? { dim: true } : {},
+		...s.underline ? { underline: true } : {},
+		...s.strike ? { strikethrough: true } : {},
+		...s.inverse ? { inverse: true } : {},
+		...s.color ? { color: s.color } : {},
+		...highlight
+	};
+	return appearanceProps(base);
+}
+const CHUNK = 8;
+/** Split text into runs that keep width measurement cheap. */
+function splitRuns(text) {
+	const runs = [];
+	let ascii = "";
+	const chars = Array.from(text);
+	let i = 0;
+	while (i < chars.length) {
+		const ch = chars[i];
+		if (ch.charCodeAt(0) < 128) {
+			ascii += ch;
+			i++;
+			continue;
+		}
+		if (ascii) {
+			runs.push(ascii);
+			ascii = "";
+		}
+		let j = i;
+		while (j < chars.length && chars[j] === ch) j++;
+		const repeat = j - i;
+		if (repeat > 1) {
+			for (let k = 0; k < repeat; k += CHUNK) runs.push(ch.repeat(Math.min(CHUNK, repeat - k)));
+			i = j;
+			continue;
+		}
+		let stretch = "";
+		while (i < chars.length && chars[i].charCodeAt(0) >= 128 && chars[i] !== chars[i + 1]) {
+			stretch += chars[i];
+			i++;
+		}
+		runs.push(stretch);
+	}
+	if (ascii) runs.push(ascii);
+	return runs;
+}
+const runCache = new WeakMap();
+function lineNode(line, theme) {
+	const cached$1 = runCache.get(line);
+	if (cached$1 && cached$1.theme === theme) return cached$1.node;
+	const node = /* @__PURE__ */ React.createElement(ink.Box, {
+		height: 1,
+		overflow: "hidden",
+		flexShrink: 0
+	}, line.spans.length === 0 ? /* @__PURE__ */ React.createElement(Text, null, " ") : line.spans.flatMap((s, si) => {
+		const props = spanProps(s, theme);
+		return splitRuns(s.text).map((run, ri) => /* @__PURE__ */ React.createElement(Text, {
+			key: `${si}:${ri}`,
+			wrap: "truncate",
+			...props
+		}, run));
+	}));
+	runCache.set(line, {
+		theme,
+		node
+	});
+	return node;
+}
+function Lines({ lines, theme, override }) {
+	return /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		flexShrink: 0
+	}, lines.map((line, i) => /* @__PURE__ */ React.createElement(React.Fragment, { key: i }, override?.(line, i) ?? lineNode(line, theme))));
+}
+
+//#endregion
+//#region src/lines/Status.tsx
+function defaultPhaseLabel(phase, headline) {
+	switch (phase.kind) {
+		case "waiting": return "waiting";
+		case "thinking": return "thinking";
+		case "writing": return "writing";
+		case "tool": return `running ${headline}`;
+		case "approval": return `awaiting approval ${headline}`;
+	}
+}
+function StatusLine({ width: width$2, live, notice, idle, below = 0, extras = [], phaseLabel, slowHint, accent, measure = defaultMeasure }) {
+	const { glyphs, theme } = useInkComponents();
+	const ticks = hooks.useTicks(live !== void 0, 1e3);
+	const now = hooks.useClock(false);
+	const rule = glyphs.boxHorizontal;
+	const phase = live ? livePhase(live.message) : void 0;
+	const call = phase?.kind === "tool" || phase?.kind === "approval" ? phase.call : void 0;
+	const headline = React.useMemo(() => call ? truncate(toolHeadline(call), 32) : void 0, [
+		call,
+		call?.title,
+		call?.name,
+		call?.inputSummary,
+		call?.arguments
+	]);
+	let label = null;
+	let labelText = "";
+	if (live) {
+		const current = phase;
+		const elapsed = now - live.startedAt;
+		const facts = [phaseLabel?.(current) ?? defaultPhaseLabel(current, headline), formatElapsed(elapsed, { live: true })];
+		const tools = countActivity(live.message.blocks).tools.total;
+		if (tools > 0) facts.push(`${tools} tool${tools === 1 ? "" : "s"}`);
+		if (slowHint && elapsed >= slowHint.afterMs && slowHint.phases.includes(current.kind)) facts.push(slowHint.text);
+		facts.push(...extras);
+		const pulse = glyphs.pulse[ticks % glyphs.pulse.length] ?? "";
+		const factText = stripControls(facts.join(glyphs.separator));
+		labelText = ` ${pulse} ${factText} `;
+		label = /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, null, " "), /* @__PURE__ */ React.createElement(Text, appearanceProps(accent ?? theme.accent), pulse), /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, " ", factText, " "));
+	} else if (notice) {
+		const text = ` ${notice.tone === "positive" ? glyphs.success : glyphs.error} ${stripControls(notice.text)} `;
+		labelText = text;
+		label = /* @__PURE__ */ React.createElement(Styled, { tone: notice.tone }, text);
+	} else if (idle || below > 0) {
+		labelText = ` ${[idle && stripControls(idle), below > 0 ? `↓ ${below} more` : void 0].filter(Boolean).join(glyphs.separator)} `;
+		label = /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, labelText);
+	}
+	const lead = rule.repeat(2);
+	const rest = Math.max(0, width$2 - measure(lead) - measure(labelText));
+	if (measure(lead) + measure(labelText) > width$2) return /* @__PURE__ */ React.createElement(ink.Box, {
+		height: 1,
+		overflow: "hidden"
+	}, /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Styled, { tone: "chrome" }, lead), truncate(labelText, Math.max(0, width$2 - measure(lead)), measure)));
+	return /* @__PURE__ */ React.createElement(ink.Box, {
+		height: 1,
+		overflow: "hidden"
+	}, /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Styled, { tone: "chrome" }, lead), label, /* @__PURE__ */ React.createElement(Styled, { tone: "chrome" }, rule.repeat(rest))));
+}
+/** Messages queued while an answer streams (the queue itself is host state). */
+function PendingRows({ items, width: width$2, maxRows = 3, measure = defaultMeasure }) {
+	const { glyphs } = useInkComponents();
+	if (items.length === 0) return null;
+	const shown = items.slice(-maxRows);
+	const hidden = items.length - shown.length;
+	return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, shown.map((item, i) => {
+		const more = i === 0 && hidden > 0 ? `+${hidden} · ` : "";
+		const clip = item.attachments ? `${glyphs.attachment}${item.attachments} ` : "";
+		const text = `${more}${clip}${stripControls(item.text).replace(/\s+/g, " ").trim()}`;
+		return /* @__PURE__ */ React.createElement(ink.Box, {
+			key: i,
+			height: 1,
+			overflow: "hidden"
+		}, /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Styled, { tone: "caution" }, glyphs.pending, " "), /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, truncate(text, Math.max(1, width$2 - measure(glyphs.pending) - 1), measure))));
+	}));
+}
+/** A centred empty state; pass it as the viewport's `empty`. */
+function EmptyState({ title, subtitle, notes = [], accent }) {
+	const { theme } = useInkComponents();
+	return /* @__PURE__ */ React.createElement(ink.Box, {
+		flexDirection: "column",
+		alignItems: "center"
+	}, /* @__PURE__ */ React.createElement(Text, {
+		...appearanceProps(accent ?? theme.accent),
+		bold: true
+	}, title), subtitle ? /* @__PURE__ */ React.createElement(Styled, { tone: "muted" }, subtitle) : null, notes.map((note) => /* @__PURE__ */ React.createElement(Styled, {
+		key: note,
+		tone: "muted"
+	}, note)));
+}
+
+//#endregion
+//#region src/lines/model.ts
+/** A span. */
+function span(text, extra = {}) {
+	return {
+		text,
+		...extra
+	};
+}
+/** Prepend spans, keeping the line's metadata. */
+function prefix(line, spans) {
+	return {
+		...line,
+		spans: [...spans, ...line.spans]
+	};
+}
+/** Append spans, keeping the line's metadata. */
+function suffix(line, spans) {
+	return {
+		...line,
+		spans: [...line.spans, ...spans]
+	};
+}
+/** The line's text as drawn. */
+function lineText(line) {
+	return line.spans.map((s) => s.text).join("");
+}
+
+//#endregion
+//#region src/lines/frames.ts
+const blank$1 = () => ({
+	spans: [],
+	frame: true
+});
+/**
+* Compact: a role glyph before the first row (`›` user, `•` answer), rows
+* indented under it, a dim footer line, a blank line after each message.
+*/
+const compactFrame = {
+	id: "compact",
+	innerWidth: (_message, width$2) => Math.max(1, width$2 - 2),
+	layout({ message, body, footer, ctx, accent }) {
+		const user = message.role === "user";
+		const glyph = user ? ctx.glyphs.user : ctx.glyphs.assistant;
+		const lead = span(`${glyph} `, user ? {
+			role: "user",
+			chrome: true
+		} : {
+			style: accent,
+			chrome: true
+		});
+		const pad$1 = span("  ", { chrome: true });
+		const lines = body.map((line, i) => ({
+			...line,
+			spans: [i === 0 ? lead : pad$1, ...line.spans]
+		}));
+		if (lines.length === 0 && footer) lines.push({
+			spans: [lead],
+			frame: true
+		});
+		if (footer) lines.push({
+			spans: [pad$1, ...footer],
+			frame: true
+		});
+		if (lines.length > 0) lines.push(blank$1());
+		return lines;
+	}
+};
+/**
+* Threaded: the user's message in a round-cornered box with its time set into
+* the top edge; an answer hangs from the box on a gutter in its accent and
+* ends with a footer corner (bare when the answer has no footer facts). A live answer that shows nothing yet draws
+* nothing.
+*/
+const threadedFrame = {
+	id: "threaded",
+	innerWidth: (message, width$2) => Math.max(1, width$2 - (message.role === "user" ? 4 : 2)),
+	layout(input) {
+		return input.message.role === "user" ? userBox(input) : answerGutter(input);
+	}
+};
+function userBox({ message, ctx, nextShows }) {
+	const g = ctx.glyphs;
+	const max = Math.max(1, ctx.width - 4);
+	const text = message.blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+	const rows = wrapLines(text, max, ctx.measure);
+	for (const attachment of message.attachments ?? []) {
+		const label = attachment.description ?? attachment.name ?? attachment.mediaType;
+		rows.push({
+			text: truncate(`${g.attachment} ${label}`, max, ctx.measure),
+			dim: true
+		});
+	}
+	const time = message.createdAt !== void 0 ? formatClockTime(message.createdAt).slice(0, 5) : "";
+	const timeLabel = time ? ` ${time} ` : "";
+	const inner = Math.min(max, Math.max(ctx.measure(timeLabel) + 2, ...rows.map((row) => ctx.measure(row.text))));
+	const edge = (n) => g.boxHorizontal.repeat(Math.max(0, n));
+	const chrome = (text$1) => span(text$1, {
+		role: "chrome",
+		chrome: true
+	});
+	const topFill = inner + 2 - ctx.measure(timeLabel) - 1;
+	const lines = [
+		{
+			spans: [chrome(`${g.boxTopLeft}${edge(topFill)}${timeLabel}${edge(1)}${g.boxTopRight}`)],
+			frame: true
+		},
+		...rows.map((row) => ({
+			spans: [
+				chrome(`${g.boxVertical} `),
+				span(row.text, {
+					role: "user",
+					...row.dim ? {
+						dim: true,
+						bold: false
+					} : {}
+				}),
+				chrome(`${" ".repeat(Math.max(0, inner - ctx.measure(row.text)))} ${g.boxVertical}`)
+			],
+			...row.wrap ? { wrap: row.wrap } : {}
+		})),
+		{
+			spans: [chrome(`${nextShows ? g.boxJunction : g.boxBottomLeft}${edge(inner + 2)}${g.boxBottomRight}`)],
+			frame: true
+		}
+	];
+	if (!nextShows) lines.push(blank$1());
+	return lines;
+}
+function answerGutter({ body, footer, shows, accent, ctx }) {
+	if (!shows) return [];
+	const g = ctx.glyphs;
+	const gutter = span(`${g.boxVertical} `, {
+		style: accent,
+		chrome: true
+	});
+	const bare = {
+		spans: [span(g.boxVertical, {
+			style: accent,
+			chrome: true
+		})],
+		frame: true
+	};
+	const lines = [bare, ...body.map((line) => ({
+		...line,
+		spans: [gutter, ...line.spans]
+	}))];
+	if (footer) lines.push(bare, {
+		spans: [span(`${g.footer} `, {
+			style: accent,
+			chrome: true
+		}), ...footer],
+		frame: true
+	});
+	else lines.push({
+		spans: [span(g.footer, {
+			style: accent,
+			chrome: true
+		})],
+		frame: true
+	});
+	lines.push(blank$1());
+	return lines;
+}
+
+//#endregion
+//#region src/lines/markdown/inline.ts
+const PUNCTUATION = /[!-/:-@[-`{-~]/;
+const WORD = /[\p{L}\p{N}]/u;
+const SPACE = /\s/;
+const ENTITY = /^&(?:#(\d{1,7})|#[xX]([\da-fA-F]{1,6})|(amp|lt|gt|quot|apos|nbsp));/;
+const NAMED = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: "\xA0"
+};
+/**
+* The character reference at the start of `text` and its length, or
+* undefined. A numeric one naming a control character (or no character)
+* stays as written: decoding must not smuggle controls past sanitising.
+*/
+function entity(text) {
+	const match = ENTITY.exec(text);
+	if (!match) return void 0;
+	if (match[3]) return [NAMED[match[3]], match[0].length];
+	const code = match[1] ? Number.parseInt(match[1], 10) : Number.parseInt(match[2], 16);
+	const control = code < 32 || code >= 127 && code < 160;
+	if (control || code > 1114111 || code >= 55296 && code < 57344) return void 0;
+	return [String.fromCodePoint(code), match[0].length];
+}
+/** Show a source the way a reader can use it: a `data:` URL as its type. */
+function describeSource(src) {
+	if (!src.startsWith("data:")) return src;
+	return src.slice(5).split(/[;,]/)[0] || "data";
+}
+/** Merge adjacent spans with identical attributes. */
+function mergeSpans(spans) {
+	const out = [];
+	for (const s of spans) {
+		if (s.text === "") continue;
+		const last = out.at(-1);
+		if (last && sameStyle(last, s)) out[out.length - 1] = {
+			...last,
+			text: last.text + s.text
+		};
+		else out.push(s);
+	}
+	return out;
+}
+function sameStyle(a, b) {
+	return a.role === b.role && a.style === b.style && a.bold === b.bold && a.italic === b.italic && a.dim === b.dim && a.underline === b.underline && a.strike === b.strike && a.inverse === b.inverse && a.color === b.color && a.chrome === b.chrome && a.copyEach === b.copyEach;
+}
+/** End of the code span opening at `i` (index after its closing run), or -1. */
+function codeSpanEnd(text, i) {
+	let run = 0;
+	while (text[i + run] === "`") run++;
+	const fence$1 = "`".repeat(run);
+	let j = text.indexOf(fence$1, i + run);
+	while (j !== -1) {
+		let k = 0;
+		while (text[j + k] === "`") k++;
+		if (k === run) return j + run;
+		j = text.indexOf(fence$1, j + k);
+	}
+	return -1;
+}
+/** Index of the bracket closing the one at `open`, skipping code spans and escapes. */
+function matching(text, open, left, right) {
+	let depth = 0;
+	for (let i = open; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === "\\") i++;
+		else if (ch === "`") {
+			const end = codeSpanEnd(text, i);
+			if (end !== -1) i = end - 1;
+		} else if (ch === left) depth++;
+		else if (ch === right && --depth === 0) return i;
+	}
+	return -1;
+}
+function runLength(text, i) {
+	let n = 0;
+	while (text[i + n] === text[i]) n++;
+	return n;
+}
+const isWordChar = (ch) => ch !== void 0 && WORD.test(ch);
+const isSpace = (ch) => ch === void 0 || SPACE.test(ch);
+/** Where the emphasis run opening at `i` (length `run`) closes, or -1. */
+function closer(text, i, run) {
+	const marker = text[i];
+	for (let j = i + run; j < text.length; j++) {
+		const ch = text[j];
+		if (ch === "\\") {
+			j++;
+			continue;
+		}
+		if (ch === "`") {
+			const end = codeSpanEnd(text, j);
+			if (end !== -1) j = end - 1;
+			continue;
+		}
+		if (ch !== marker) continue;
+		const n = runLength(text, j);
+		if (n === run && !isSpace(text[j - 1]) && !isWordChar(text[j + n]) && j > i + run) return j;
+		j += n - 1;
+	}
+	return -1;
+}
+/** A bare `http(s)://` URL at `i`, trailing punctuation excluded. */
+function bareUrl(text, i) {
+	const match = /^https?:\/\/[^\s<>]+/.exec(text.slice(i));
+	if (!match) return void 0;
+	return match[0].replace(/[.,;:!?'")\]]+$/, "");
+}
+/** Parse inline markdown into spans, every span starting from `base`. */
+function parseInline(text, base, glyphs) {
+	const out = [];
+	let plain = "";
+	const flush = () => {
+		if (plain) out.push({
+			text: plain,
+			...base
+		});
+		plain = "";
+	};
+	const emit = (spans) => {
+		flush();
+		out.push(...spans);
+	};
+	let i = 0;
+	while (i < text.length) {
+		const ch = text[i];
+		const prev = text[i - 1];
+		if (ch === "\\" && i + 1 < text.length && PUNCTUATION.test(text[i + 1])) {
+			plain += text[i + 1];
+			i += 2;
+			continue;
+		}
+		if (ch === "`") {
+			const end = codeSpanEnd(text, i);
+			if (end !== -1) {
+				const run$1 = runLength(text, i);
+				let code = text.slice(i + run$1, end - run$1);
+				if (code.startsWith(" ") && code.endsWith(" ") && code.trim()) code = code.slice(1, -1);
+				emit([{
+					text: code,
+					...base,
+					role: "code"
+				}]);
+				i = end;
+				continue;
+			}
+			const run = runLength(text, i);
+			plain += text.slice(i, i + run);
+			i += run;
+			continue;
+		}
+		if ((ch === "[" || ch === "!" && text[i + 1] === "[") && text.length > i + 1) {
+			const image = ch === "!";
+			const open = image ? i + 1 : i;
+			const close = matching(text, open, "[", "]");
+			if (close !== -1 && text[close + 1] === "(") {
+				const end = matching(text, close + 1, "(", ")");
+				if (end !== -1) {
+					const label = text.slice(open + 1, close);
+					const url = text.slice(close + 2, end).trim().replace(/\s+"[^"]*"$/, "").replace(/^<(.*)>$/, "$1");
+					if (image) emit([
+						{
+							text: `${glyphs.image} `,
+							...base
+						},
+						...label ? [{
+							text: `${label} `,
+							...base
+						}] : [],
+						{
+							text: `(${describeSource(url)})`,
+							...base,
+							role: "muted"
+						}
+					]);
+					else {
+						emit(parseInline(label, {
+							...base,
+							role: "link"
+						}, glyphs));
+						if (url && url !== label) emit([{
+							text: ` (${url})`,
+							...base,
+							role: "muted"
+						}]);
+					}
+					i = end + 1;
+					continue;
+				}
+			}
+		}
+		if (ch === "<") {
+			const match = /^<((?:https?|mailto):[^\s<>]+)>/.exec(text.slice(i));
+			if (match) {
+				emit([{
+					text: match[1],
+					...base,
+					role: "link"
+				}]);
+				i += match[0].length;
+				continue;
+			}
+		}
+		if (ch === "h" && (prev === void 0 || /[\s(]/.test(prev))) {
+			const url = bareUrl(text, i);
+			if (url) {
+				emit([{
+					text: url,
+					...base,
+					role: "link"
+				}]);
+				i += url.length;
+				continue;
+			}
+		}
+		if (ch === "*" || ch === "_" || ch === "~") {
+			const run = runLength(text, i);
+			const valid = ch === "~" ? run === 2 : run <= 3;
+			if (valid && !isWordChar(prev) && !isSpace(text[i + run])) {
+				const end = closer(text, i, run);
+				if (end !== -1) {
+					const style = ch === "~" ? { strike: true } : run === 1 ? { italic: true } : run === 2 ? { bold: true } : {
+						bold: true,
+						italic: true
+					};
+					emit(parseInline(text.slice(i + run, end), {
+						...base,
+						...style
+					}, glyphs));
+					i = end + run;
+					continue;
+				}
+			}
+			plain += text.slice(i, i + run);
+			i += run;
+			continue;
+		}
+		if (ch === "&") {
+			const ref = entity(text.slice(i, i + 12));
+			if (ref) {
+				plain += ref[0];
+				i += ref[1];
+				continue;
+			}
+		}
+		plain += ch;
+		i++;
+	}
+	flush();
+	return mergeSpans(out);
+}
+
+//#endregion
+//#region src/lines/markdown/wrap.ts
+function words(spans, measure) {
+	const out = [{
+		pieces: [],
+		width: 0
+	}];
+	for (const s of spans) s.text.split(" ").forEach((part, i) => {
+		if (i > 0) out.push({
+			pieces: [],
+			width: 0,
+			gap: {
+				...s,
+				text: " "
+			}
+		});
+		const word = out.at(-1);
+		if (part) {
+			word.pieces.push({
+				...s,
+				text: part
+			});
+			word.width += measure(part);
+		}
+	});
+	return out;
+}
+/** Cut a word's pieces into chunks of at most `max` cells, never inside a grapheme. */
+function split(word, max, measure) {
+	const chunks$1 = [{
+		pieces: [],
+		width: 0
+	}];
+	for (const piece of word.pieces) for (const g of graphemes(piece.text)) {
+		const w = measure(g);
+		let chunk = chunks$1.at(-1);
+		if (chunk.width + w > max && chunk.width > 0) {
+			chunk = {
+				pieces: [],
+				width: 0
+			};
+			chunks$1.push(chunk);
+		}
+		chunk.pieces.push({
+			...piece,
+			text: g
+		});
+		chunk.width += w;
+	}
+	return chunks$1;
+}
+function wrapSpans(spans, width$2, measure) {
+	const max = Math.max(1, width$2);
+	const rows = [];
+	let current = [];
+	let currentWidth = 0;
+	let join;
+	let started = false;
+	const push = (next) => {
+		const spans$1 = mergeSpans(current);
+		rows.push(join ? {
+			spans: spans$1,
+			wrap: join
+		} : { spans: spans$1 });
+		current = [];
+		currentWidth = 0;
+		started = false;
+		join = next;
+	};
+	for (const word of words(spans, measure)) {
+		const gap = started && word.gap ? 1 : 0;
+		if (started && currentWidth + gap + word.width > max) push("soft");
+		else if (started && word.gap) {
+			current.push(word.gap);
+			currentWidth += 1;
+		}
+		if (word.width > max) {
+			split(word, max, measure).forEach((chunk, i) => {
+				if (i > 0) push("hard");
+				current.push(...chunk.pieces);
+				currentWidth = chunk.width;
+				started = true;
+			});
+			continue;
+		}
+		current.push(...word.pieces);
+		currentWidth += word.width;
+		started = true;
+	}
+	push(void 0);
+	return rows;
+}
+
+//#endregion
+//#region src/lines/images.ts
+/** The largest thumbnail, in cells. */
+const THUMBNAIL = {
+	columns: 32,
+	rows: 8
+};
+const HINT = {
+	ask: () => "click to show",
+	loading: () => "loading…",
+	failed: (state) => `✗ ${state.error}`,
+	ready: (_, expanded) => expanded ? "click to shrink" : "click to enlarge"
+};
+/** Lay out a block image: its ready rows, then a wrapped caption; every line targets the source. */
+function layoutImage(src, alt, width$2, { provider, expanded, maxHeight, glyphs, measure }) {
+	const box = expanded ? {
+		columns: Math.max(1, width$2),
+		rows: Math.max(1, maxHeight)
+	} : {
+		columns: Math.max(1, Math.min(THUMBNAIL.columns, width$2)),
+		rows: THUMBNAIL.rows
+	};
+	const state = provider?.get(src, box);
+	const target = {
+		kind: "image",
+		src
+	};
+	const image = state?.kind === "ready" ? state.rows.map((row) => ({
+		spans: [span(row, state.color ? { color: state.color } : {})],
+		target
+	})) : [];
+	const caption = [
+		span(`${glyphs.image} `, { role: "muted" }),
+		...alt ? [span(alt, {
+			role: "content",
+			italic: true
+		}), span(" ")] : [],
+		span(describeSource(src), { role: "link" }),
+		...state ? [span(` ${HINT[state.kind](state, expanded)}`, {
+			role: "muted",
+			dim: true
+		})] : []
+	];
+	const clean$1 = caption.map((s) => ({
+		...s,
+		text: stripControls(s.text)
+	}));
+	return [...image, ...wrapSpans(clean$1, width$2, measure).map((row) => ({
+		...row,
+		target
+	}))];
+}
+
+//#endregion
+//#region src/lines/layout.ts
+const NOTHING_OPEN = {
+	version: 0,
+	isOpen: () => false
+};
+/** The path a collapsible row's open state is kept under. */
+const ROW_PATH = "#row";
+/** The default markdown layout: plain text, wrapped, in the `content` role. */
+const plainMarkdownLayout = (source, width$2, { measure }) => wrapLines(source, width$2, measure).map((row) => ({
+	spans: [span(row.text, { role: "content" })],
+	...row.wrap ? { wrap: row.wrap } : {}
+}));
+const width$1 = (spans, measure) => spans.reduce((sum, s) => sum + measure(s.text), 0);
+/** Resolve an accent to an explicit appearance. */
+function resolveAccent(message, ctx) {
+	const accent = ctx.accentFor?.(message) ?? "assistant";
+	return typeof accent === "string" ? ctx.theme[accent] : accent;
+}
+function wrapped(text, w, measure, extra) {
+	return wrapLines(text, w, measure).map((row) => ({
+		spans: [span(row.text, extra)],
+		...row.wrap ? { wrap: row.wrap } : {}
+	}));
+}
+function indent(lines, cells$1) {
+	const pad$1 = span(" ".repeat(cells$1), { chrome: true });
+	return lines.map((line) => ({
+		...line,
+		spans: [pad$1, ...line.spans]
+	}));
+}
+function owned(lines, owner) {
+	return lines.map((line) => line.owner ? line : {
+		...line,
+		owner
+	});
+}
+/**
+* Cells of label (up to its whole width) a header keeps before it gives up its
+* time, then its `after` spans.
+*/
+const LABEL_MIN = 16;
+/**
+* One header row, truncated to `w` (affordance, icon and qualifier exempt). The
+* timer and the `after` spans are exempt too, until the label would be cut
+* below {@link LABEL_MIN} cells: then the timer goes, then the `after` spans.
+*/
+function headerRow(parts, w, ctx) {
+	const fixed = [parts.affordance, span(" ")];
+	if (parts.prefix) fixed.push(parts.prefix, span(" "));
+	if (parts.icon) fixed.push(span(parts.icon, { role: "marker" }), span(" "));
+	const label = parts.label.replace(/\s+/g, " ").trim();
+	const least = Math.min(LABEL_MIN, ctx.measure(label));
+	let trailing = parts.trailing;
+	let after$1 = parts.after ?? [];
+	const tailOf = () => [...parts.qualifier ? [span(" "), parts.qualifier] : [], ...trailing ? [span(` ${trailing}`, { role: "muted" })] : []];
+	const room = () => w - width$1(fixed, ctx.measure) - width$1(after$1, ctx.measure) - width$1(tailOf(), ctx.measure);
+	if (room() < least) trailing = void 0;
+	if (room() < least) after$1 = [];
+	const tail = tailOf();
+	const budget = Math.max(1, room());
+	const detail = parts.detail ? parts.detail.replace(/\s+/g, " ").trim() : void 0;
+	const full = detail ? `${label} ${detail}` : label;
+	const cut = truncate(full, budget, ctx.measure);
+	const labelPart = cut.slice(0, Math.min(label.length, cut.length));
+	const detailPart = cut.slice(labelPart.length);
+	const error = parts.error || parts.errorWithoutAfter && after$1.length === 0;
+	const middle = [span(labelPart, { role: error ? "danger" : "strong" }), ...after$1];
+	if (detailPart) middle.push(span(detailPart, { role: "muted" }));
+	return {
+		spans: [
+			...fixed,
+			...middle,
+			...tail
+		],
+		...parts.target ? { target: parts.target } : {}
+	};
+}
+function spinnerFrame(ctx) {
+	const frames = ctx.glyphs.spinner;
+	return frames[Math.floor(ctx.now / 1e3) % frames.length] ?? "";
+}
+function liveTimer(startedAt, durationMs, live, ctx) {
+	if (durationMs !== void 0) return formatDuration(durationMs);
+	if (live && startedAt !== void 0 && Number.isFinite(startedAt)) return formatElapsed(ctx.now - startedAt, { live: true });
+	return void 0;
+}
+function toolGlyph(tool, live, ctx) {
+	const g = ctx.glyphs;
+	if (tool.status === "success") return span(g.toolSuccess, {
+		role: "positive",
+		dim: true
+	});
+	if (tool.status === "error") return span(g.toolError, { role: "danger" });
+	return live ? span(spinnerFrame(ctx), { role: "marker" }) : span(g.toolIdle, { role: "caution" });
+}
+const APPROVAL = {
+	denied: ["· denied", "danger"],
+	unavailable: ["· refused", "danger"],
+	pending: ["· awaiting approval", "caution"]
+};
+function approvalQualifier(tool) {
+	const approval = tool?.approval ? APPROVAL[tool.approval.state] : void 0;
+	return approval ? span(approval[0], { role: approval[1] }) : void 0;
+}
+function toolOutput(tool, b) {
+	if (tool.result === void 0) return [];
+	const { ctx } = b;
+	const text = toolResultText(tool.result);
+	const bar = span(`  ${ctx.glyphs.outputBar} `, {
+		chrome: true,
+		dim: true
+	});
+	const inner = Math.max(1, b.width - ctx.measure(bar.text));
+	const target = {
+		kind: "tool-output",
+		blockId: tool.id
+	};
+	let rows;
+	if (looksLikeJson(text)) {
+		const parsed = parseLooseJson(text);
+		const full = ctx.detail === "full";
+		const jsonRows = layoutJson(parsed.node, {
+			...full ? {} : { maxString: 80 },
+			collapsed: (path) => !full && !ctx.opened.isOpen(tool.id, path)
+		});
+		rows = jsonRows.flatMap((row) => {
+			const pad$1 = "  ".repeat(row.depth);
+			if (row.toggle) {
+				const marker = row.toggle.open ? ctx.glyphs.expanded : ctx.glyphs.collapsed;
+				const lead = "  ".repeat(row.depth - 1);
+				const markerSpan = span(`${marker} `, {
+					role: "link",
+					chrome: true,
+					copyEach: " "
+				});
+				const size = row.toggle.open ? "" : ` · ${row.toggle.size}`;
+				const available = Math.max(1, inner - ctx.measure(lead) - 2 - ctx.measure(size));
+				return [{
+					spans: [
+						span(lead),
+						markerSpan,
+						span(truncate(row.text, available, ctx.measure), {
+							role: "content",
+							dim: true
+						}),
+						...size ? [span(size, {
+							chrome: true,
+							dim: true
+						})] : []
+					],
+					target: {
+						kind: "json-toggle",
+						blockId: tool.id,
+						path: row.toggle.path,
+						open: row.toggle.open
+					}
+				}];
+			}
+			const pieces = wrapLines(row.text, Math.max(1, inner - ctx.measure(pad$1)), ctx.measure);
+			return pieces.map((piece, i) => ({
+				spans: [span(i === 0 ? pad$1 : `${pad$1}  `), span(piece.text, {
+					role: "content",
+					dim: true
+				})],
+				...piece.wrap ? { wrap: piece.wrap } : {},
+				target
+			}));
+		});
+		if (parsed.rest) rows.push(...wrapped(parsed.rest, inner, ctx.measure, {
+			role: "content",
+			dim: true
+		}).map((r) => ({
+			...r,
+			target
+		})));
+	} else rows = wrapped(text, inner, ctx.measure, {
+		role: "content",
+		dim: true
+	}).map((r) => ({
+		...r,
+		target
+	}));
+	return rows.map((row) => ({
+		...row,
+		spans: [bar, ...row.spans]
+	}));
+}
+function toolRow(tool, b) {
+	const live = isBlockActive(tool, {
+		isActive: b.live,
+		outcome: b.message.outcome
+	});
+	const row = headerRow({
+		affordance: toolGlyph(tool, live, b.ctx),
+		label: toolLabel(tool) || "tool",
+		detail: toolDisplayInput(tool),
+		qualifier: approvalQualifier(tool),
+		trailing: liveTimer(positiveTimestamp(tool.startedAt), tool.durationMs, live, b.ctx),
+		error: tool.status === "error",
+		target: {
+			kind: "row-toggle",
+			rowKey: tool.id
+		}
+	}, b.width, b.ctx);
+	const showOutput = b.ctx.detail !== "collapsed" || b.ctx.opened.isOpen(tool.id, ROW_PATH);
+	return [row, ...showOutput ? toolOutput(tool, b) : []];
+}
+function planRows(plan, b) {
+	const g = b.ctx.glyphs;
+	return plan.entries.flatMap((entry) => {
+		const done = entry.status === "completed";
+		const active = entry.status === "in_progress";
+		const marker = done ? span(g.planDone, {
+			role: "positive",
+			dim: true
+		}) : active ? b.live ? span(spinnerFrame(b.ctx), { role: "marker" }) : span(g.planActive, {
+			role: "caution",
+			dim: true
+		}) : span(g.planPending, { dim: true });
+		const lead = b.ctx.measure(marker.text) + 1;
+		const rows = wrapLines(entry.content, Math.max(1, b.width - lead), b.ctx.measure);
+		return rows.map((row, i) => ({
+			spans: [
+				i === 0 ? marker : span(" ".repeat(b.ctx.measure(marker.text)), { chrome: true }),
+				span(" ", { chrome: true }),
+				span(row.text, {
+					role: "content",
+					...done ? { dim: true } : {}
+				})
+			],
+			...row.wrap ? { wrap: row.wrap } : {}
+		}));
+	});
+}
+function blockLines(block, b) {
+	const { ctx } = b;
+	const live = isBlockActive(block, {
+		isActive: b.live,
+		activeBlockId: b.activeBlockId,
+		outcome: b.message.outcome
+	});
+	if (!isCoreBlockType(block.type)) {
+		const custom = block;
+		const layout = lookupExtension(ctx.blockLayouts, custom.type);
+		if (layout) return layout(custom, {
+			width: b.width,
+			isLive: live,
+			measure: ctx.measure
+		});
+		return [{ spans: [span(summarizeBlock(custom).label, { role: "marker" })] }];
+	}
+	const core = block;
+	switch (core.type) {
+		case "text": return b.message.role === "user" ? wrapped(core.text, b.width, ctx.measure, { role: "user" }) : ctx.markdown(core.text, b.width, {
+			...live ? { streaming: true } : {},
+			measure: ctx.measure,
+			glyphs: ctx.glyphs,
+			image: ctx.image
+		});
+		case "reasoning": {
+			const summary = summarizeBlock(core, { isActive: live });
+			const open = ctx.detail !== "collapsed" || ctx.opened.isOpen(core.id, ROW_PATH);
+			const header = headerRow({
+				affordance: live ? span(spinnerFrame(ctx), { role: "marker" }) : span(open ? ctx.glyphs.expanded : ctx.glyphs.collapsed, { role: "marker" }),
+				icon: ctx.glyphs.brain,
+				label: summary.label,
+				trailing: summary.showTimer ? liveTimer(positiveTimestamp(core.startedAt) ?? b.message.createdAt, core.durationMs, live, ctx) : void 0,
+				target: {
+					kind: "row-toggle",
+					rowKey: core.id
+				}
+			}, b.width, ctx);
+			const text = wrapped(core.text, Math.max(1, b.width - 2), ctx.measure, {
+				role: "muted",
+				italic: true
+			});
+			if (open) return [header, ...indent(text, 2)];
+			return live ? [header, ...indent(text.slice(-3), 2)] : [header];
+		}
+		case "tool_call": return toolRow(core, b);
+		case "plan": {
+			const summary = summarizeBlock(core);
+			const header = headerRow({
+				affordance: span(" "),
+				icon: ctx.glyphs.checklist,
+				label: summary.label
+			}, b.width, ctx);
+			return [header, ...indent(planRows(core, {
+				...b,
+				width: Math.max(1, b.width - 2)
+			}), 2)];
+		}
+		case "status": return [headerRow({
+			affordance: live ? span(spinnerFrame(ctx), { role: "marker" }) : span(" "),
+			label: statusLabel(core.phase, live),
+			trailing: liveTimer(b.message.createdAt, b.live ? void 0 : b.message.metrics?.durationMs, live, ctx)
+		}, b.width, ctx)];
+		case "system": return [headerRow({
+			affordance: span(" "),
+			icon: ctx.glyphs.gear,
+			label: "System prompt"
+		}, b.width, ctx), ...ctx.detail !== "collapsed" ? indent(wrapped(core.text, Math.max(1, b.width - 2), ctx.measure, { role: "muted" }), 2) : []];
+	}
+}
+function groupLines(key, blocks, b) {
+	const { ctx } = b;
+	const g = ctx.glyphs;
+	const plan = planGroupHeader(blocks, {
+		isActive: b.live,
+		activeBlockId: b.activeBlockId,
+		outcome: b.message.outcome,
+		startedAt: b.message.createdAt,
+		durationMs: b.message.metrics?.durationMs
+	});
+	const open = ctx.detail !== "collapsed" || ctx.opened.isOpen(key, ROW_PATH);
+	const icon = plan.summary.iconName ? g[plan.summary.iconName] : void 0;
+	const rate = plan.showRate && !b.live ? formatTokensPerSecond(b.message.metrics?.tokensPerSecond) : void 0;
+	const timer = plan.showTimer ? liveTimer(plan.startedAt, plan.durationMs, plan.isActive, ctx) : void 0;
+	const affordance = plan.isActive ? span(spinnerFrame(ctx), { role: "marker" }) : span(open ? g.expanded : g.collapsed, { role: "marker" });
+	const target = {
+		kind: "row-toggle",
+		rowKey: key
+	};
+	let header;
+	if (plan.tools) {
+		const t = plan.tools;
+		const sep = g.separator;
+		const counts = !t.only && t.failed > 0 ? [
+			span(sep, { role: "muted" }),
+			span(`${t.succeeded} ${g.success}`, { role: "positive" }),
+			span(" "),
+			span(`${t.failed} ${g.error}`, { role: "danger" })
+		] : [];
+		const detail = t.only ? toolDisplayInput(t.only) : t.running ? `${sep.trimStart()}${toolHeadline(t.running)}` : void 0;
+		header = headerRow({
+			affordance,
+			icon: g.wrench,
+			label: t.only ? toolLabel(t.only) || "tool" : `${t.total} tool calls`,
+			after: counts,
+			detail,
+			qualifier: approvalQualifier(t.only),
+			trailing: timer ? `${sep.trimStart()}${timer}` : void 0,
+			error: t.only !== void 0 && t.failed > 0,
+			errorWithoutAfter: t.failed > 0,
+			target
+		}, b.width, ctx);
+	} else header = headerRow({
+		affordance,
+		...plan.hiddenCount > 0 ? { prefix: span(`(+${plan.hiddenCount})`, { role: "marker" }) } : {},
+		...icon ? { icon } : {},
+		label: plan.summary.label,
+		trailing: [timer, rate].filter(Boolean).join(" ") || void 0,
+		target
+	}, b.width, ctx);
+	if (!open) return [header];
+	const inner = {
+		...b,
+		width: Math.max(1, b.width - 2)
+	};
+	return [header, ...indent(blocks.flatMap((block) => blockLines(block, inner)), 2)];
+}
+/** Which side of the content/activity boundary a planned row is on. */
+function rowSide(row) {
+	if (row.kind === "bare") return getBlockTimelineBehavior(row.block).auxEligible ? "activity" : "content";
+	return row.kind === "outcome" ? "content" : "activity";
+}
+/** Lay out a message's body (no frame) at `w` cells. */
+function layoutBody(original, w, ctx) {
+	const live = ctx.isActive(original);
+	const message = stripControlsDeep(original);
+	const plan = planMessage(message, {
+		isActive: live,
+		activityPlacement: ctx.placement,
+		...live && ctx.detail === "collapsed" ? { liveTail: ctx.liveTail } : {},
+		...ctx.detail === "collapsed" && ctx.finishedActivity ? { finishedActivity: ctx.finishedActivity } : {}
+	});
+	const b = {
+		message,
+		live,
+		activeBlockId: plan.activeBlockId,
+		width: w,
+		ctx
+	};
+	const out = [];
+	const spacing = ctx.activitySpacing ?? true;
+	let lastWasText = false;
+	let lastSide;
+	for (const row of plan.rows) {
+		if (row.kind === "bare" && row.block.type === "text" && !row.block.text.trim()) continue;
+		if (row.kind === "bare" && row.block.type === "text" && lastWasText) out.push({ spans: [] });
+		lastWasText = row.kind === "bare" && row.block.type === "text";
+		const side = rowSide(row);
+		if (spacing && lastSide !== void 0 && side !== lastSide) out.push({
+			spans: [],
+			frame: true
+		});
+		lastSide = side;
+		switch (row.kind) {
+			case "pending":
+				out.push(...blockLines({
+					type: "status",
+					id: row.id,
+					phase: "pre-stream"
+				}, {
+					...b,
+					activeBlockId: row.id
+				}));
+				break;
+			case "bare":
+				out.push(...owned(blockLines(row.block, b), {
+					messageId: message.id,
+					blockId: row.block.id
+				}));
+				break;
+			case "group":
+				out.push(...groupLines(row.key, row.blocks, b));
+				break;
+			case "earlier":
+				out.push({ spans: [...ctx.glyphs.earlier ? [span(`${ctx.glyphs.earlier} `, {
+					role: "marker",
+					chrome: true
+				})] : [], span(earlierLabel(row), { role: "muted" })] });
+				break;
+			case "outcome":
+				out.push(...wrapped(`${ctx.glyphs.error} ${row.outcome.message}`, w, ctx.measure, { role: "danger" }));
+				break;
+		}
+	}
+	for (const attachment of message.attachments ?? []) {
+		const label = attachment.description ?? attachment.name ?? attachment.mediaType;
+		out.push({ spans: [span(`${ctx.glyphs.attachment} `, {
+			role: "link",
+			chrome: true
+		}), span(truncate(label, Math.max(1, w - 3), ctx.measure), { dim: true })] });
+	}
+	return out;
+}
+/** The footer spans of a message: planned facts with injected glyphs, then hints. */
+function footerSpans(original, ctx) {
+	const live = ctx.isActive(original);
+	const message = stripControlsDeep(original);
+	const plan = planMessage(message, { isActive: live });
+	const shows = showsSomething(message);
+	if (!(plan.showFooter || live && ctx.liveFooter && shows)) return void 0;
+	const facts = planFooter(message, {
+		isActive: live,
+		detail: ctx.detail,
+		now: ctx.now
+	});
+	const glyph = {
+		reasoning: ctx.glyphs.brain,
+		plan: ctx.glyphs.checklist,
+		tools: ctx.glyphs.wrench
+	};
+	const texts = facts.map((fact) => glyph[fact.key] ? `${glyph[fact.key]} ${fact.text}` : fact.text);
+	texts.push(...ctx.footerExtras?.(original, ctx.detail) ?? []);
+	const counts = countActivity(message.blocks);
+	const hasActivity = counts.reasoningChars > 0 || counts.tools.total > 0 || counts.plan !== void 0;
+	const hasOutput = message.blocks.some((block) => block.type === "tool_call" && block.result !== void 0);
+	const { hints } = ctx;
+	if (message.outcome && hints.retry) texts.push(hints.retry);
+	if (ctx.detail === "collapsed" && hasActivity && hints.details) texts.push(hints.details);
+	if (ctx.detail === "details" && hasOutput && hints.openAll) texts.push(hints.openAll);
+	if (ctx.detail !== "collapsed" && hints.close) texts.push(hints.close);
+	if (texts.length === 0) return void 0;
+	return [span(stripControls(texts.join(ctx.glyphs.separator)), {
+		role: "muted",
+		chrome: true
+	})];
+}
+/** Whether an answer shows anything: content, reasoning, an outcome, a tool call or a plan. */
+function showsSomething(message) {
+	return message.outcome !== void 0 || message.blocks.some((block) => block.type !== "status");
+}
+/** Lay out one message inside its frame. */
+function layoutMessage(original, ctx, next) {
+	const live = ctx.isActive(original);
+	const message = stripControlsDeep(original);
+	const inner = ctx.frame.innerWidth(message, ctx.width);
+	const footer = footerSpans(original, ctx);
+	const drafts = ctx.frame.layout({
+		message,
+		body: layoutBody(original, inner, ctx),
+		...footer ? { footer } : {},
+		shows: message.role !== "assistant" || showsSomething(message),
+		nextShows: next !== void 0 && next.role === "assistant" && showsSomething(next),
+		live,
+		accent: resolveAccent(original, ctx),
+		ctx
+	});
+	return owned(drafts, { messageId: original.id });
+}
+
+//#endregion
+//#region src/lines/markdown/table.ts
+/** The narrowest a wrapped column may get before the table falls back. */
+const MIN_COLUMN = 6;
+const SEPARATOR = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+/** Whether `line` is a GFM table separator row. */
+function isSeparator(line) {
+	return line.includes("-") && SEPARATOR.test(line);
+}
+/** Split a row into cells on pipes that are neither escaped nor inside a code span. */
+function splitRow(line) {
+	let row = line.trim();
+	if (row.startsWith("|")) row = row.slice(1);
+	if (row.endsWith("|") && !row.endsWith("\\|")) row = row.slice(0, -1);
+	const cells$1 = [];
+	let cell = "";
+	let code = 0;
+	for (let i = 0; i < row.length; i++) {
+		const ch = row[i];
+		if (ch === "\\" && row[i + 1] === "|") {
+			cell += "|";
+			i++;
+		} else if (ch === "`") {
+			let run = 0;
+			while (row[i + run] === "`") run++;
+			code = code === run ? 0 : code || run;
+			cell += row.slice(i, i + run);
+			i += run - 1;
+		} else if (ch === "|" && code === 0) {
+			cells$1.push(cell.trim());
+			cell = "";
+		} else cell += ch;
+	}
+	cells$1.push(cell.trim());
+	return cells$1;
+}
+/** Column alignments from a separator row. */
+function alignments(line) {
+	return splitRow(line).map((cell) => cell.startsWith(":") && cell.endsWith(":") ? "center" : cell.endsWith(":") ? "right" : "left");
+}
+/**
+* Fit natural widths into `available` cells: columns within a fair share keep
+* theirs, the rest share what remains. Undefined when a column would fall
+* below its minimum (the minimums together exceed the available cells).
+*/
+function fitColumns(natural, available) {
+	const minimum = natural.map((w) => Math.min(w, MIN_COLUMN));
+	if (minimum.reduce((a, b) => a + b, 0) > available) return void 0;
+	const widths = [...natural];
+	let open = natural.map((_, i) => i);
+	let budget = available;
+	for (;;) {
+		const fair = Math.floor(budget / open.length);
+		const small = open.filter((i) => natural[i] <= fair);
+		if (small.length === 0 || small.length === open.length) break;
+		for (const i of small) budget -= natural[i];
+		open = open.filter((i) => !small.includes(i));
+	}
+	if (open.reduce((sum, i) => sum + natural[i], 0) <= budget) return widths;
+	const share = Math.floor(budget / open.length);
+	open.forEach((i, k) => {
+		widths[i] = share + (k < budget - share * open.length ? 1 : 0);
+	});
+	return widths;
+}
+const width = (spans, measure) => spans.reduce((sum, s) => sum + measure(s.text), 0);
+function pad(spans, cells$1, align, last, measure) {
+	if (last && spans.length === 0) return [];
+	const room = Math.max(0, cells$1 - width(spans, measure));
+	const before$1 = align === "right" ? room : align === "center" ? Math.floor(room / 2) : 0;
+	const after$1 = last ? 0 : room - before$1;
+	return [
+		...before$1 ? [span(" ".repeat(before$1), { chrome: true })] : [],
+		...spans,
+		...after$1 ? [span(" ".repeat(after$1), { chrome: true })] : []
+	];
+}
+/** Drop trailing spaces (an empty last cell leaves the column joint's). */
+function trimEnd(spans) {
+	const merged = mergeSpans(spans);
+	const last = merged.at(-1);
+	if (last?.text.endsWith(" ")) merged[merged.length - 1] = {
+		...last,
+		text: last.text.trimEnd()
+	};
+	return mergeSpans(merged);
+}
+/** Lay out a table from its header, separator and body source rows. */
+function layoutTable(header, separator, body, maxWidth, { glyphs, measure }) {
+	const heads = splitRow(header);
+	const columns = heads.length;
+	const align = alignments(separator);
+	const cells$1 = (row, style) => Array.from({ length: columns }, (_, c) => parseInline(splitRow(row)[c] ?? "", style, glyphs));
+	const head = cells$1(header, {
+		role: "strong",
+		bold: true
+	});
+	const rows = body.map((row) => cells$1(row, { role: "content" }));
+	const natural = Array.from({ length: columns }, (_, c) => Math.max(1, ...[head, ...rows].map((row) => width(row[c], measure))));
+	const joint = 3;
+	const widths = fitColumns(natural, maxWidth - joint * (columns - 1));
+	if (!widths) return fallback(head, rows, maxWidth, measure);
+	const column = [
+		span(" ", { chrome: true }),
+		span(glyphs.tableColumn, {
+			role: "chrome",
+			chrome: true,
+			copyEach: "	"
+		}),
+		span(" ", { chrome: true })
+	];
+	const drawRow = (row) => {
+		const wrapped$1 = row.map((cell, c) => wrapSpans(cell, widths[c], measure));
+		const height = Math.max(...wrapped$1.map((w) => w.length));
+		return Array.from({ length: height }, (_, r) => ({ spans: trimEnd(wrapped$1.flatMap((w, c) => [...c > 0 ? column : [], ...pad(w[r]?.spans ?? [], widths[c], align[c] ?? "left", c === columns - 1, measure)])) }));
+	};
+	const rule = widths.map((w) => glyphs.rule.repeat(w)).join(`${glyphs.rule}${glyphs.tableCross}${glyphs.rule}`);
+	return [
+		...drawRow(head),
+		{
+			spans: [span(rule, { role: "chrome" })],
+			frame: true
+		},
+		...rows.flatMap(drawRow)
+	];
+}
+function fallback(head, rows, maxWidth, measure) {
+	return rows.flatMap((row, r) => [...r > 0 ? [{ spans: [] }] : [], ...row.flatMap((cell, c) => wrapSpans([
+		...head[c],
+		span(": ", { role: "muted" }),
+		...cell
+	], maxWidth, measure))]);
+}
+
+//#endregion
+//#region src/lines/markdown/blocks.ts
+const FENCE = /^ {0,3}(`{3,}|~{3,})\s*([^`\s]*)/;
+const HEADING = /^ {0,3}(#{1,6})(?:\s+(.*?))?(?:\s+#+)?\s*$/;
+const RULE = /^ {0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const QUOTE = /^ {0,3}> ?/;
+const ITEM = /^( *)([-*+]|\d{1,9}[.)])(?: +(.*))?$/;
+const IMAGE_LINE = /^!\[([^\]]*)\]\(\s*<?([^\s)>]+)>?(?:\s+"[^"]*")?\s*\)$/;
+const blank = (line) => line === void 0 || line.trim() === "";
+function startsBlock(lines, i) {
+	const line = lines[i];
+	return FENCE.test(line) || HEADING.test(line) || RULE.test(line) || QUOTE.test(line) || ITEM.test(line) || isTableStart(lines, i);
+}
+function isTableStart(lines, i) {
+	return lines[i].includes("|") && isSeparator(lines[i + 1] ?? "");
+}
+const indentOf = (line) => line.length - line.trimStart().length;
+/** Prefix laid-out lines: `first` on the first line, `rest` on the others. */
+function hang(lines, first, rest) {
+	return lines.map((line, i) => ({
+		...line,
+		spans: [...i === 0 ? first : rest, ...line.spans]
+	}));
+}
+function paragraph(source, width$2, env) {
+	const only = source.length === 1 ? IMAGE_LINE.exec(source[0].trim()) : null;
+	if (only && env.image) {
+		const lines = env.image(only[2], only[1], width$2);
+		if (lines) return lines;
+	}
+	const segments = [""];
+	source.forEach((raw, i) => {
+		const hard = i < source.length - 1 && /(?: {2,}|\\)$/.test(raw);
+		const text = raw.trim().replace(/\\$/, "");
+		const at = segments.length - 1;
+		segments[at] = segments[at] ? `${segments[at]} ${text}` : text;
+		if (hard) segments.push("");
+	});
+	return segments.flatMap((text) => wrapSpans(parseInline(text, { role: "content" }, env.glyphs), width$2, env.measure));
+}
+function fence(lines, i, width$2, env) {
+	const [, marker, lang] = FENCE.exec(lines[i]);
+	const indent$1 = indentOf(lines[i]);
+	const close = new RegExp(`^ {0,3}${marker[0] === "`" ? "`" : "~"}{${marker.length},}\\s*$`);
+	let j = i + 1;
+	const code = [];
+	while (j < lines.length && !close.test(lines[j])) {
+		const line = lines[j];
+		code.push(line.slice(Math.min(indent$1, indentOf(line))));
+		j++;
+	}
+	const bar = span(`${env.glyphs.codeBar} `, {
+		role: "chrome",
+		dim: true,
+		chrome: true
+	});
+	const inner = Math.max(1, width$2 - 2);
+	const out = [];
+	if (lang) out.push({
+		spans: [bar, span(lang, {
+			role: "muted",
+			dim: true
+		})],
+		frame: true
+	});
+	for (const line of code) hardSplit(line.replace(/\t/g, "  "), inner, env.measure).forEach((piece, k) => {
+		out.push({
+			spans: [bar, ...piece ? [span(piece, { role: "code" })] : []],
+			...k > 0 ? { wrap: "hard" } : {}
+		});
+	});
+	return [out, j < lines.length ? j + 1 : j];
+}
+function list(lines, i, width$2, env) {
+	const first = ITEM.exec(lines[i]);
+	const indent$1 = first[1].length;
+	const ordered$1 = /\d/.test(first[2]);
+	let number = ordered$1 ? Number.parseInt(first[2], 10) : 0;
+	const out = [];
+	let j = i;
+	while (j < lines.length) {
+		const match = ITEM.exec(lines[j]);
+		if (!match || match[1].length !== indent$1) break;
+		if (/\d/.test(match[2]) !== ordered$1) break;
+		const content = indent$1 + match[2].length + 1;
+		const body = [match[3] ?? ""];
+		j++;
+		while (j < lines.length) {
+			const line = lines[j];
+			if (blank(line)) {
+				const next = lines[j + 1];
+				if (next !== void 0 && !blank(next) && indentOf(next) >= content) {
+					body.push("");
+					j++;
+					continue;
+				}
+				break;
+			}
+			if (indentOf(line) > indent$1) body.push(line.slice(Math.min(content, indentOf(line))));
+			else if (!startsBlock(lines, j)) body.push(line.trim());
+			else break;
+			j++;
+		}
+		let marker;
+		if (ordered$1) marker = `${number++}${match[2].slice(-1)}`;
+		else marker = env.glyphs.bullet;
+		const task = /^\[([ xX])\] /.exec(body[0]);
+		if (task) {
+			marker = task[1] === " " ? env.glyphs.taskOpen : env.glyphs.taskDone;
+			body[0] = body[0].slice(4);
+		}
+		const markerWidth = env.measure(marker) + 1;
+		const inner = layoutBlocks(body, Math.max(1, width$2 - markerWidth), env, true);
+		out.push(...hang(inner.length ? inner : [{ spans: [] }], [span(`${marker} `, {
+			role: "marker",
+			chrome: true
+		})], [span(" ".repeat(markerWidth), { chrome: true })]));
+		if (blank(lines[j]) && ITEM.test(lines[j + 1] ?? "") && indentOf(lines[j + 1]) === indent$1) j++;
+	}
+	return [out, j];
+}
+/** Lay out markdown source lines as blocks; `tight` drops the blank lines between blocks. */
+function layoutBlocks(lines, width$2, env, tight = false) {
+	const out = [];
+	const add = (block) => {
+		if (out.length && !tight) out.push({ spans: [] });
+		out.push(...block);
+	};
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (blank(line)) {
+			i++;
+			continue;
+		}
+		if (FENCE.test(line)) {
+			const [block, next] = fence(lines, i, width$2, env);
+			add(block);
+			i = next;
+			continue;
+		}
+		const heading = HEADING.exec(line);
+		if (heading) {
+			add(wrapSpans(parseInline(heading[2] ?? "", {
+				role: "strong",
+				bold: true
+			}, env.glyphs), width$2, env.measure));
+			i++;
+			continue;
+		}
+		if (RULE.test(line)) {
+			add([{
+				spans: [span(env.glyphs.rule.repeat(width$2), {
+					role: "chrome",
+					dim: true
+				})],
+				frame: true
+			}]);
+			i++;
+			continue;
+		}
+		if (QUOTE.test(line)) {
+			const quoted = [];
+			while (i < lines.length && QUOTE.test(lines[i])) {
+				quoted.push(lines[i].replace(QUOTE, ""));
+				i++;
+			}
+			const bar = span(`${env.glyphs.quoteBar} `, {
+				role: "chrome",
+				dim: true,
+				chrome: true
+			});
+			const inner = layoutBlocks(quoted, Math.max(1, width$2 - 2), env);
+			add(hang(inner, [bar], [bar]));
+			continue;
+		}
+		if (ITEM.test(line)) {
+			const [block, next] = list(lines, i, width$2, env);
+			add(block);
+			i = next;
+			continue;
+		}
+		if (isTableStart(lines, i)) {
+			const body = [];
+			let j = i + 2;
+			while (j < lines.length && !blank(lines[j]) && lines[j].includes("|")) {
+				body.push(lines[j]);
+				j++;
+			}
+			add(layoutTable(line, lines[i + 1], body, width$2, env));
+			i = j;
+			continue;
+		}
+		const source = [line];
+		i++;
+		while (i < lines.length && !blank(lines[i]) && !startsBlock(lines, i)) {
+			source.push(lines[i]);
+			i++;
+		}
+		add(paragraph(source, width$2, env));
+	}
+	return out;
+}
+/**
+* Split source lines into top-level chunks at blank lines that end a block:
+* never inside a fence, and not where an indented line or a list item
+* continues the block before. Chunks lay out independently.
+*/
+function chunks(lines) {
+	const out = [];
+	let current = [];
+	let fence$1;
+	const nextText = [];
+	for (let i = lines.length - 1, seen; i >= 0; i--) {
+		nextText[i] = seen;
+		if (!blank(lines[i])) seen = lines[i];
+	}
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (fence$1) {
+			if (fence$1.test(line)) fence$1 = void 0;
+			current.push(line);
+			continue;
+		}
+		const open = FENCE.exec(line);
+		if (open) {
+			const marker = open[1];
+			fence$1 = new RegExp(`^ {0,3}${marker[0] === "`" ? "`" : "~"}{${marker.length},}\\s*$`);
+			current.push(line);
+			continue;
+		}
+		if (blank(line)) {
+			if (current.length === 0) continue;
+			const next = nextText[i];
+			if (next !== void 0 && indentOf(next) === 0 && !ITEM.test(next)) {
+				out.push(current);
+				current = [];
+				continue;
+			}
+		}
+		current.push(line);
+	}
+	if (current.length) out.push(current);
+	return out;
+}
+/** Laid-out chunks per glyph set and measure, keyed by width and source. */
+const chunkCache = new WeakMap();
+const CHUNK_CACHE_SIZE = 4e3;
+function cached(env) {
+	let byMeasure = chunkCache.get(env.glyphs);
+	if (!byMeasure) {
+		byMeasure = new WeakMap();
+		chunkCache.set(env.glyphs, byMeasure);
+	}
+	let map = byMeasure.get(env.measure);
+	if (!map) {
+		map = new Map();
+		byMeasure.set(env.measure, map);
+	}
+	return map;
+}
+/**
+* The default terminal markdown: dependency-free, injected roles and glyphs.
+* Finished blocks are cached, so a streamed delta lays out only the tail.
+*/
+const terminalMarkdown = (source, width$2, options) => {
+	const w = Math.max(1, width$2);
+	const cache = cached(options);
+	const out = [];
+	for (const chunk of chunks(source.replace(/\r\n?/g, "\n").split("\n"))) {
+		const text = chunk.join("\n");
+		const cacheable = !(options.image && text.includes("!["));
+		const key = `${w}\n${text}`;
+		let lines = cacheable ? cache.get(key) : void 0;
+		if (!lines) {
+			lines = layoutBlocks(chunk, w, options);
+			if (cacheable) {
+				if (cache.size >= CHUNK_CACHE_SIZE) cache.clear();
+				cache.set(key, lines);
+			}
+		}
+		if (lines.length === 0) continue;
+		if (out.length) out.push({ spans: [] });
+		out.push(...lines);
+	}
+	return out;
+};
+
+//#endregion
+//#region src/lines/mouse.ts
+const ESC = String.fromCharCode(27);
+/** Button-event tracking with SGR encoding, on and off. */
+const MOUSE_ON = `${ESC}[?1002h${ESC}[?1006h`;
+const MOUSE_OFF = `${ESC}[?1006l${ESC}[?1002l`;
+const BUTTONS = [
+	"left",
+	"middle",
+	"right",
+	"none"
+];
+const SGR = new RegExp(`${ESC}\\[<(\\d+);(\\d+);(\\d+)([Mm])`, "g");
+/**
+* Every SGR mouse report in a chunk of terminal input. Horizontal wheel
+* reports (buttons 6 and 7) are dropped: the viewport only scrolls vertically.
+*/
+function parseMouse(data) {
+	const reports = Array.from(data.matchAll(SGR)).filter((m) => (Number(m[1]) & 66) !== 66);
+	return reports.map((m) => {
+		const code = Number(m[1]);
+		const wheel = (code & 64) !== 0;
+		const motion = (code & 32) !== 0;
+		const kind = wheel ? code & 1 ? "wheel-down" : "wheel-up" : m[4] === "m" ? "release" : motion ? "drag" : "press";
+		return {
+			kind,
+			button: wheel ? "none" : BUTTONS[code & 3],
+			x: Number(m[2]) - 1,
+			y: Number(m[3]) - 1,
+			ctrl: (code & 16) !== 0,
+			shift: (code & 4) !== 0,
+			meta: (code & 8) !== 0
+		};
+	});
+}
+/** The longest incomplete report kept for the next chunk; a longer one is noise. */
+const MAX_PENDING = 64;
+const CSI_SEQUENCE = new RegExp(`${ESC}\\[[\\x30-\\x3f]*[\\x20-\\x2f]*[\\x40-\\x7e]`, "g");
+const CSI_PARTIAL = new RegExp(`${ESC}(?:\\[[\\x30-\\x3f]*[\\x20-\\x2f]*)?$`);
+/**
+* A reader of terminal reports across input chunks: each call returns the
+* complete CSI sequences in what has arrived, keeping an unfinished one at
+* the end for the next chunk (a terminal may split a report anywhere). The
+* kept tail is bounded; past the bound it is dropped as noise.
+*/
+function createReportReader() {
+	let pending = "";
+	return (data) => {
+		let text = pending + data;
+		pending = "";
+		const partial = CSI_PARTIAL.exec(text);
+		if (partial) {
+			text = text.slice(0, partial.index);
+			if (partial[0].length <= MAX_PENDING) pending = partial[0];
+		}
+		return Array.from(text.matchAll(CSI_SEQUENCE), (m) => m[0]);
+	};
+}
+/** An OSC 52 clipboard write of `text`. */
+function osc52(text) {
+	return `${ESC}]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`;
+}
+/**
+* The element's position on screen, in cells. This relies on the renderer's
+* layout internals (each node's computed offset from its parent), so it is
+* isolated here.
+*/
+function screenOrigin(node) {
+	let x = 0;
+	let y = 0;
+	for (let n = node ?? void 0; n; n = n.parentNode) {
+		x += n.yogaNode?.getComputedLeft() ?? 0;
+		y += n.yogaNode?.getComputedTop() ?? 0;
+	}
+	return {
+		x,
+		y
+	};
+}
+/** The two ends of a selection, in reading order. */
+function ordered(a, b) {
+	return a.line < b.line || a.line === b.line && a.col <= b.col ? [a, b] : [b, a];
+}
+function cells(line, measure) {
+	const out = [];
+	let at = 0;
+	for (const s of line.spans) for (const g of graphemes(s.text)) {
+		const width$2 = measure(g);
+		out.push({
+			text: g,
+			start: at,
+			width: width$2,
+			span: s
+		});
+		at += width$2;
+	}
+	return out;
+}
+/**
+* Whether a grapheme's cells overlap the columns `start`..`end` (inclusive):
+* a point inside a wide grapheme's later cell still takes the whole grapheme.
+*/
+const within = (cell, start, end) => cell.start <= end && cell.start + Math.max(cell.width, 1) > start;
+/** What a span's grapheme copies as: its replacement, nothing for chrome, else itself. */
+const copied = (cell) => cell.span.copyEach !== void 0 ? cell.span.copyEach : cell.span.chrome ? "" : cell.text;
+/**
+* Copy text between two points (inclusive of the end cell): content spans
+* only, decoration lines skipped, lines right-trimmed, soft joins as a space,
+* hard joins as nothing, other lines by newlines.
+*/
+function copyText(lines, a, b, measure) {
+	const [from, to] = ordered(a, b);
+	let out = "";
+	let first = true;
+	for (let i = from.line; i <= to.line; i++) {
+		const line = lines[i];
+		if (!line || line.frame) continue;
+		const start = i === from.line ? from.col : 0;
+		const end = i === to.line ? to.col : Number.POSITIVE_INFINITY;
+		const text = cells(line, measure).filter((c) => within(c, start, end)).map(copied).join("").trimEnd();
+		if (!first) out += line.wrap === "soft" ? " " : line.wrap === "hard" ? "" : "\n";
+		out += text;
+		first = false;
+	}
+	return out;
+}
+/**
+* Highlight the content cells of a line from `start` to `end` (inclusive) with
+* the selection appearance; selecting past the line's end highlights one more
+* cell. Decoration lines are returned as they are.
+*/
+function highlightLine(line, start, end, selection, measure) {
+	if (line.frame) return line;
+	const all = cells(line, measure);
+	const runs = [];
+	for (const cell of all) {
+		const selected = !cell.span.chrome && within(cell, start, end);
+		const last = runs.at(-1);
+		if (last && last.span === cell.span && last.selected === selected) last.text += cell.text;
+		else runs.push({
+			span: cell.span,
+			selected,
+			text: cell.text
+		});
+	}
+	const spans = runs.map(({ span: span$1, selected, text }) => selected ? {
+		...span$1,
+		text,
+		style: {
+			...span$1.style,
+			...selection
+		}
+	} : {
+		...span$1,
+		text
+	});
+	const width$2 = all.reduce((sum, c) => sum + c.width, 0);
+	if (end >= width$2 && start <= width$2) spans.push({
+		text: " ",
+		style: selection
+	});
+	return {
+		...line,
+		spans
+	};
+}
+/** Call `handler` with every chunk of raw terminal input while active. */
+function useTerminalData(handler, active) {
+	const { stdin } = ink.useStdin();
+	const ref = React.useRef(handler);
+	ref.current = handler;
+	React.useEffect(() => {
+		if (!active) return;
+		const listener = (data) => ref.current(String(data));
+		stdin.on("data", listener);
+		return () => {
+			stdin.off("data", listener);
+		};
+	}, [active, stdin]);
+}
+/** Enable mouse reporting while active; disable on deactivation, unmount and process exit. */
+function useMouseReporting(active, write) {
+	const ref = React.useRef(write);
+	ref.current = write;
+	React.useEffect(() => {
+		if (!active) return;
+		ref.current(MOUSE_ON);
+		const off = () => ref.current(MOUSE_OFF);
+		process.once("exit", off);
+		return () => {
+			process.off("exit", off);
+			off();
+		};
+	}, [active]);
+}
+
+//#endregion
+//#region src/lines/transcript.ts
+const identities = new WeakMap();
+let nextIdentity = 0;
+/** A stable token per object or function: injected inputs compare by identity. */
+function identity(value) {
+	if (value === void 0) return 0;
+	let id = identities.get(value);
+	if (id === void 0) {
+		id = ++nextIdentity;
+		identities.set(value, id);
+	}
+	return id;
+}
+/**
+* Everything a message's layout reads, as a string. Plain values (hint labels,
+* the resolved accent, host footer facts) count by value; injected functions
+* and the glyph set count by identity, so hosts memoise them.
+*/
+function layoutSignature(message, ctx, next, imagesVersion = 0) {
+	const live = ctx.isActive(message);
+	return [
+		ctx.width,
+		ctx.detail,
+		ctx.placement,
+		ctx.frame.id,
+		live ? `live:${Math.floor(ctx.now / 1e3)}` : "done",
+		ctx.opened.version,
+		imagesVersion,
+		next !== void 0 && next.role === "assistant" && showsSomething(next) ? "n" : "-",
+		ctx.liveTail,
+		ctx.liveFooter ? "f" : "-",
+		ctx.finishedActivity ?? "row",
+		ctx.activitySpacing === false ? "-" : "s",
+		ctx.footerExtras?.(message, ctx.detail).join("\0") ?? "",
+		JSON.stringify(ctx.hints),
+		JSON.stringify(resolveAccent(message, ctx)),
+		[
+			ctx.glyphs,
+			ctx.markdown,
+			ctx.measure,
+			ctx.image,
+			ctx.blockLayouts
+		].map(identity).join(",")
+	].join("|");
+}
+function createLayoutCache(imagesVersion = () => 0) {
+	const entries = new WeakMap();
+	let misses = 0;
+	return {
+		get(message, ctx, next) {
+			const signature = layoutSignature(message, ctx, next, imagesVersion());
+			const hit = entries.get(message);
+			if (hit && hit.signature === signature) return hit.lines;
+			misses++;
+			const lines = layoutMessage(message, ctx, next);
+			entries.set(message, {
+				signature,
+				lines
+			});
+			return lines;
+		},
+		get misses() {
+			return misses;
+		}
+	};
+}
+/** Lay out a transcript: all lines, and where each message starts. */
+function layoutTranscript(messages, ctx, cache = createLayoutCache()) {
+	const lines = [];
+	const messageStart = [];
+	messages.forEach((message, i) => {
+		messageStart.push(lines.length);
+		lines.push(...cache.get(message, ctx, messages[i + 1]));
+	});
+	return {
+		lines,
+		messageStart
+	};
+}
+
+//#endregion
+//#region src/lines/Viewport.tsx
+const scrollHome = {
+	follow: false,
+	top: 0
+};
+const scrollEnd = { follow: true };
+/** The window's first line for a scroll state. */
+function firstLine(scroll, total, rows) {
+	const last = Math.max(0, total - rows);
+	return scroll.follow ? last : Math.max(0, Math.min(scroll.top, last));
+}
+/** Scroll by `delta` lines, clamped; reaching the bottom returns to follow. */
+function scrollBy(scroll, delta, g) {
+	const last = Math.max(0, g.total - g.rows);
+	const top = Math.max(0, Math.min(firstLine(scroll, g.total, g.rows) + delta, last));
+	return top >= last ? scrollEnd : {
+		follow: false,
+		top
+	};
+}
+/** Scroll by pages; a page keeps two lines of context. */
+function pageBy(scroll, pages, g) {
+	return scrollBy(scroll, pages * Math.max(1, g.rows - 2), g);
+}
+const NEXT_DETAIL = {
+	collapsed: "details",
+	details: "full",
+	full: "collapsed"
+};
+/** Uncontrolled open state: a version plus the set of open `blockId␟path` keys. */
+function useOpenState() {
+	const [state, setState] = React.useState({
+		version: 0,
+		open: new Set()
+	});
+	const toggle = React.useCallback((blockId, path) => {
+		setState((current) => {
+			const open = new Set(current.open);
+			const key = `${blockId}␟${path}`;
+			if (open.has(key)) open.delete(key);
+			else open.add(key);
+			return {
+				version: current.version + 1,
+				open
+			};
+		});
+	}, []);
+	const opened = React.useMemo(() => ({
+		version: state.version,
+		isOpen: (b, p) => state.open.has(`${b}␟${p}`)
+	}), [state]);
+	return [opened, toggle];
+}
+/** Lay out the transcript and compute the window (for hosts that draw extra chrome). */
+function useTranscriptLayout(props) {
+	const { theme, glyphs } = useInkComponents();
+	const live = props.streamingMessageId !== void 0;
+	const now = Math.floor(hooks.useClock(live, 1e3) / 1e3) * 1e3;
+	const [ownOpened, ownToggle] = useOpenState();
+	const opened = props.opened ?? ownOpened;
+	const provider = props.images;
+	const [, bump] = React.useState(0);
+	React.useEffect(() => provider?.subscribe(() => bump((n) => n + 1)), [provider]);
+	const [expanded, setExpanded] = React.useState({
+		version: 0,
+		open: new Set()
+	});
+	const toggleExpanded = React.useCallback((src) => {
+		setExpanded((current) => {
+			const open = new Set(current.open);
+			if (open.has(src)) open.delete(src);
+			else open.add(src);
+			return {
+				version: current.version + 1,
+				open
+			};
+		});
+	}, []);
+	const imageStates = React.useRef(new Map());
+	const imagesVersion = (props.imagesVersion ?? 0) + (provider?.version ?? 0) + expanded.version;
+	const cache = React.useRef(null);
+	const versionRef = React.useRef(imagesVersion);
+	versionRef.current = imagesVersion;
+	cache.current ??= createLayoutCache(() => versionRef.current);
+	const maxHeight = props.maxImageHeight ?? Math.max(1, props.height - 8);
+	const measure = props.measure ?? defaultMeasure;
+	const image = React.useMemo(() => props.image ?? (provider ? (src, alt, width$2) => layoutImage(src, alt, width$2, {
+		provider: {
+			...provider,
+			get: (source, box) => {
+				const state = provider.get(source, box);
+				imageStates.current.set(source, state);
+				return state;
+			}
+		},
+		expanded: expanded.open.has(src),
+		maxHeight,
+		glyphs,
+		measure
+	}) : void 0), [
+		props.image,
+		provider,
+		expanded,
+		maxHeight,
+		glyphs,
+		measure
+	]);
+	const ctx = {
+		width: props.width,
+		detail: props.detail ?? "collapsed",
+		placement: props.activityPlacement ?? "inline",
+		liveTail: props.liveTail ?? 3,
+		isActive: (message) => message.id === props.streamingMessageId,
+		now,
+		opened,
+		markdown: props.markdown ?? terminalMarkdown,
+		glyphs,
+		theme,
+		hints: props.hints ?? {},
+		liveFooter: props.liveFooter ?? true,
+		...props.blockLayouts ? { blockLayouts: props.blockLayouts } : {},
+		frame: props.frame ?? compactFrame,
+		accentFor: props.accentFor,
+		measure,
+		footerExtras: props.footerExtras,
+		finishedActivity: props.finishedActivity,
+		activitySpacing: props.activitySpacing,
+		image
+	};
+	const { lines } = layoutTranscript(props.messages, ctx, cache.current);
+	const rows = Math.max(0, props.height);
+	const first = firstLine(props.scroll, lines.length, rows);
+	const geometry = {
+		total: lines.length,
+		first,
+		rows,
+		below: Math.max(0, lines.length - first - rows)
+	};
+	return {
+		lines,
+		geometry,
+		window: lines.slice(first, first + rows),
+		toggle: props.onToggle ?? ownToggle,
+		now,
+		imageStates: imageStates.current,
+		toggleExpanded
+	};
+}
+/** Contiguous lines around `index` in the same tool output box, if it is in one. */
+function outputBox(lines, index) {
+	const blockOf = (line) => line?.target && (line.target.kind === "tool-output" || line.target.kind === "json-toggle") ? `${line.owner.messageId}␟${line.target.blockId}` : void 0;
+	const box = blockOf(lines[index]);
+	if (!box) return void 0;
+	let a = index;
+	let b = index;
+	while (blockOf(lines[a - 1]) === box) a--;
+	while (blockOf(lines[b + 1]) === box) b++;
+	return [a, b];
+}
+/** A tool's whole output, JSON pretty-printed. */
+function outputText(tool) {
+	const text = toolResultText(tool.result);
+	try {
+		return JSON.stringify(JSON.parse(text), null, 2);
+	} catch {
+		return text;
+	}
+}
+/** A message as written (an answer's raw markdown). */
+function messageText(message) {
+	return message.blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n\n");
+}
+const ids = new WeakMap();
+let nextId = 0;
+/** A stable id per line object (lines are cached per message, so identity is content). */
+function lineId(line) {
+	let id = ids.get(line);
+	if (id === void 0) {
+		id = ++nextId;
+		ids.set(line, id);
+	}
+	return id;
+}
+/** What a key does in the viewport (pure, so every binding is testable). */
+function viewportKeyAction(input, key, keys, scroll, geometry, detail) {
+	if (keys === false || isTerminalReport(input)) return void 0;
+	if (keys.page !== false && key.pageUp) return { scroll: pageBy(scroll, -1, geometry) };
+	if (keys.page !== false && key.pageDown) return { scroll: pageBy(scroll, 1, geometry) };
+	if (keys.lines !== false && key.shift && key.upArrow) return { scroll: scrollBy(scroll, -3, geometry) };
+	if (keys.lines !== false && key.shift && key.downArrow) return { scroll: scrollBy(scroll, 3, geometry) };
+	if (keys.homeEnd && key.home) return { scroll: scrollHome };
+	if (keys.homeEnd && key.end) return { scroll: scrollEnd };
+	if (keys.detail !== false && key.ctrl && input === "t") return { detail: NEXT_DETAIL[detail] };
+	return void 0;
+}
+function TranscriptViewport(props) {
+	const { theme } = useInkComponents();
+	const { lines, geometry, window, toggle, imageStates, toggleExpanded } = useTranscriptLayout(props);
+	const { onGeometry, onScroll, onDetailChange, scroll, focused = true, keys = {} } = props;
+	const detail = props.detail ?? "collapsed";
+	const measure = props.measure ?? defaultMeasure;
+	const { stdout } = ink.useStdout();
+	const last = React.useRef("");
+	React.useEffect(() => {
+		const key = `${geometry.total}:${geometry.first}:${geometry.rows}:${geometry.below}`;
+		if (key === last.current) return;
+		last.current = key;
+		onGeometry?.(geometry);
+	});
+	const [selection, setSelection] = React.useState(void 0);
+	ink.useInput((input, key) => {
+		const action = viewportKeyAction(input, key, keys, scroll, geometry, detail);
+		if (action && "scroll" in action) onScroll(action.scroll);
+		else if (action) onDetailChange?.(action.detail);
+	}, { isActive: focused && keys !== false });
+	const [readReport] = React.useState(createKeyReportReader);
+	ink.useInput((input) => {
+		const report = readReport(input);
+		if (report.kind === "text" || report.kind === "report" && report.rest) setSelection(void 0);
+	}, { isActive: focused && selection !== void 0 });
+	const mouse = props.mouse;
+	const mouseActive = mouse !== void 0 && focused;
+	const write = mouse?.write ?? props.write ?? ((data) => stdout.write(data));
+	useMouseReporting(mouseActive, write);
+	const box = React.useRef(null);
+	const press = React.useRef(void 0);
+	const lastClick = React.useRef(void 0);
+	const copy = (text, description) => {
+		write(osc52(text));
+		mouse?.onCopy?.(text, description);
+	};
+	/** The point under a screen cell, rows clamped to the visible window. */
+	const pointAt = (e) => {
+		const origin = screenOrigin(box.current);
+		const row = e.y - origin.y;
+		const inside = row >= 0 && row < window.length;
+		const clamped = Math.max(0, Math.min(row, window.length - 1));
+		return {
+			line: geometry.first + clamped,
+			col: Math.max(0, e.x - origin.x),
+			inside
+		};
+	};
+	const click = (at, e) => {
+		const line = lines[at.line];
+		const target = line.target;
+		if (target?.kind === "json-toggle") return toggle(target.blockId, target.path);
+		if (target?.kind === "row-toggle") return toggle(target.rowKey, ROW_PATH);
+		if (target?.kind === "image") {
+			if (e.ctrl) return mouse?.onOpenUrl?.(target.src);
+			const state = imageStates.get(target.src);
+			if (state?.kind === "ask") props.images?.allow(target.src);
+			else if (state?.kind === "ready") toggleExpanded(target.src);
+			return;
+		}
+		const now = Date.now();
+		const previous = lastClick.current;
+		if (previous?.line === at.line && now - previous.at <= (mouse?.doubleClickMs ?? 400)) {
+			lastClick.current = void 0;
+			const message = props.messages.find((m) => m.id === line.owner.messageId);
+			if (target?.kind === "tool-output") {
+				const tool = message.blocks.find((b) => b.type === "tool_call" && b.id === target.blockId);
+				copy(outputText(tool), "tool output");
+				return;
+			}
+			copy(messageText(message), "message");
+			return;
+		}
+		lastClick.current = {
+			line: at.line,
+			at: now
+		};
+	};
+	const onMouse = (e) => {
+		if (window.length === 0) return;
+		if (e.kind === "wheel-up" || e.kind === "wheel-down") {
+			const step = mouse?.wheelStep ?? 3;
+			onScroll(scrollBy(scroll, e.kind === "wheel-up" ? -step : step, geometry));
+			return;
+		}
+		if (e.shift) {
+			if (e.kind === "release") press.current = void 0;
+			return;
+		}
+		if (e.button !== "left" && e.kind !== "release") return;
+		const point = pointAt(e);
+		if (e.kind === "press") {
+			if (!point.inside) return;
+			const clamp$1 = outputBox(lines, point.line);
+			press.current = {
+				at: point,
+				moved: false,
+				...clamp$1 ? { clamp: clamp$1 } : {}
+			};
+			setSelection(void 0);
+			return;
+		}
+		const current = press.current;
+		if (!current) return;
+		const head = current.clamp ? {
+			line: Math.max(current.clamp[0], Math.min(point.line, current.clamp[1])),
+			col: point.col
+		} : {
+			line: point.line,
+			col: point.col
+		};
+		if (e.kind === "drag") {
+			current.moved = true;
+			setSelection({
+				anchor: current.at,
+				head
+			});
+			return;
+		}
+		press.current = void 0;
+		if (!current.moved && head.line === current.at.line && head.col === current.at.col) {
+			click(current.at, e);
+			return;
+		}
+		const text = copyText(lines, current.at, head, measure);
+		setSelection({
+			anchor: current.at,
+			head
+		});
+		const count = text.split("\n").length;
+		if (text) copy(text, `${count} line${count === 1 ? "" : "s"}`);
+	};
+	const images = props.images;
+	const writeRef = React.useRef(write);
+	writeRef.current = write;
+	React.useEffect(() => {
+		if (images?.query) writeRef.current(images.query);
+	}, [images]);
+	const [readReports] = React.useState(createReportReader);
+	useTerminalData((data) => {
+		for (const report of readReports(data)) {
+			if (images?.takeReply?.(report)) continue;
+			if (mouseActive) for (const e of parseMouse(report)) onMouse(e);
+		}
+	}, mouseActive || images?.takeReply !== void 0);
+	const [from, to] = selection ? ordered(selection.anchor, selection.head) : [];
+	const shown = from && to ? window.map((line, i) => {
+		const at = geometry.first + i;
+		if (at < from.line || at > to.line) return line;
+		const start = at === from.line ? from.col : 0;
+		const end = at === to.line ? to.col : Number.POSITIVE_INFINITY;
+		return highlightLine(line, start, end, theme.selection, measure);
+	}) : window;
+	const selected = from && to ? `${from.line}.${from.col}-${to.line}.${to.col}` : "";
+	const signature = `${geometry.first}:${lines.length}:${props.width}:${selected}:${window.map(lineId).join(",")}`;
+	const body = React.useMemo(() => lines.length === 0 && props.empty ? /* @__PURE__ */ React.createElement(ink.Box, {
+		height: props.height,
+		width: props.width,
+		alignItems: "center",
+		justifyContent: "center"
+	}, props.empty) : /* @__PURE__ */ React.createElement(Lines, {
+		lines: shown,
+		theme,
+		...props.override ? { override: (line, i) => props.override?.(line, i, geometry.first + i) } : {}
+	}), [
+		signature,
+		theme,
+		props.override,
+		props.empty,
+		props.height
+	]);
+	return /* @__PURE__ */ React.createElement(ink.Box, {
+		ref: box,
+		height: props.height,
+		width: props.width,
+		flexDirection: "column",
+		overflow: "hidden",
+		flexShrink: 0
+	}, body);
+}
+
+//#endregion
+//#region src/create.ts
+/**
+* One shared clock for every timer, rate, spinner and pulse this package
+* draws (the core hooks' provider, on the host's React).
+*/
+function ClockProvider(props) {
+	return React.createElement(hooks.ClockProvider, props);
+}
+function createChatInk(deps) {
+	bindRuntime(deps);
+	return {
+		React: deps.React,
+		ink: deps.ink,
+		hooks,
+		ClockProvider,
+		Composer,
+		EmptyState,
+		InkChatProvider,
+		Lines,
+		MessageView,
+		PendingRows,
+		PlainMarkdown,
+		Row,
+		Spinner,
+		StatusLine,
+		Styled,
+		Transcript,
+		TranscriptViewport,
+		useInkComponents,
+		useMouseReporting,
+		useOpenState,
+		useTerminalData,
+		useTranscriptLayout
+	};
+}
+
+//#endregion
+//#region src/lines/Markdown.tsx
+function TerminalMarkdown({ content, streaming, width: width$2, measure = defaultMeasure }) {
+	const { theme, glyphs } = useInkComponents();
+	const ref = React.useRef(null);
+	const box = ink.useBoxMetrics(ref);
+	const { columns } = ink.useWindowSize();
+	const cells$1 = width$2 ?? (box.hasMeasured && box.width > 0 ? box.width : columns);
+	const lines = React.useMemo(() => terminalMarkdown(stripControls(content), cells$1, {
+		measure,
+		glyphs,
+		...streaming ? { streaming } : {}
+	}), [
+		content,
+		cells$1,
+		measure,
+		glyphs,
+		streaming
+	]);
+	return /* @__PURE__ */ React.createElement(ink.Box, {
+		ref,
+		flexDirection: "column",
+		flexGrow: 1
+	}, lines.length > 0 && /* @__PURE__ */ React.createElement(Lines, {
+		lines,
+		theme
+	}));
+}
+
+//#endregion
+export { ClockProvider, Composer, EmptyState, InkChatProvider, KITTY_POP, KITTY_PUSH, Lines, MIN_COLUMN, MOUSE_OFF, MOUSE_ON, MessageView, NOTHING_OPEN, PendingRows, PlainMarkdown, ROW_PATH, React, Row, Spinner, StatusLine, Styled, THUMBNAIL, TerminalMarkdown, Transcript, TranscriptViewport, alignments, appearanceProps, asciiGlyphs, backspace, cachedMeasure, caretBoundary, caretLines, caretRow, chunks, clipLines, compactFrame, composerInnerWidth, composerRows, copyText, createChatInk, createHistory, createLayoutCache, createReportReader, defaultMeasure, deleteForward, deleteWordBack, describeSource, emojiGlyphs, emptyComposerValue, emptyEditor, firstLine, fitColumns, footerSpans, graphemes, hardSplit, highlightLine, hooks, ink, insert, isBound, isSeparator, isTerminalReport, killToLineEnd, killToLineStart, layoutBlocks, layoutBody, layoutImage, layoutMessage, layoutSignature, layoutTable, layoutTranscript, lineEnd, lineStart, lineText, mergeInkComponents, mergeSpans, moveBy, moveLine, moveVisual, ordered, osc52, pageBy, parseInline, parseMouse, plainComponents, plainGlyphs, plainMarkdownLayout, plainTheme, prefix, pushHistory, resolveAccent, screenOrigin, scrollBy, scrollEnd, scrollHome, showsSomething, span, spanProps, splitAtCaret, splitRow, splitRuns, stepHistory, stripControls, stripControlsDeep, suffix, terminalMarkdown, threadedFrame, toJson, truncate, useInkComponents, useMouseReporting, useOpenState, useTerminalData, useTranscriptLayout, viewportKeyAction, visualRows, withEntries, wordLeft, wordRight, wrapLines, wrapSpans, wrapText };