@aitty/server 0.1.0

package/dist/frontend/terminal-app.js

@@ -0,0 +1,4780 @@
+//#region node_modules/.pnpm/@wterm+core@0.1.9/node_modules/@wterm/core/dist/wasm-inline.js
+const WASM_BASE64 = "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";
+//#endregion
+//#region node_modules/.pnpm/@wterm+core@0.1.9/node_modules/@wterm/core/dist/wasm-bridge.js
+function decodeBase64(base64) {
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes.buffer;
+}
+var WasmBridge = class WasmBridge {
+	constructor(instance) {
+		this.gridPtr = 0;
+		this.dirtyPtr = 0;
+		this.writeBufferPtr = 0;
+		this.cellSize = 12;
+		this.maxCols = 256;
+		this.encoder = new TextEncoder();
+		this.decoder = new TextDecoder();
+		this.exports = instance.exports;
+		this.memory = this.exports.memory;
+	}
+	static async load(url) {
+		let bytes;
+		if (url) {
+			const response = await fetch(url);
+			if (!response.ok) throw new Error(`[wterm] Failed to load WASM from ${url}: ${response.status} ${response.statusText}`);
+			bytes = await response.arrayBuffer();
+		} else bytes = decodeBase64(WASM_BASE64);
+		const { instance } = await WebAssembly.instantiate(bytes);
+		return new WasmBridge(instance);
+	}
+	init(cols, rows) {
+		this.exports.init(cols, rows);
+		this._updatePointers();
+	}
+	_updatePointers() {
+		this.gridPtr = this.exports.getGridPtr();
+		this.dirtyPtr = this.exports.getDirtyPtr();
+		this.writeBufferPtr = this.exports.getWriteBuffer();
+		this.cellSize = this.exports.getCellSize();
+		this.maxCols = this.exports.getMaxCols();
+		this._dv = new DataView(this.memory.buffer);
+	}
+	writeString(str) {
+		const encoded = this.encoder.encode(str);
+		this.writeRaw(encoded);
+	}
+	writeRaw(data) {
+		const buf = new Uint8Array(this.memory.buffer, this.writeBufferPtr, 8192);
+		let offset = 0;
+		while (offset < data.length) {
+			const chunk = Math.min(data.length - offset, 8192);
+			buf.set(data.subarray(offset, offset + chunk));
+			this.exports.writeBytes(chunk);
+			offset += chunk;
+		}
+	}
+	getCell(row, col) {
+		const offset = this.gridPtr + (row * this.maxCols + col) * this.cellSize;
+		const dv = this._dv;
+		return {
+			char: dv.getUint32(offset, true),
+			fg: dv.getUint16(offset + 4, true),
+			bg: dv.getUint16(offset + 6, true),
+			flags: dv.getUint8(offset + 8)
+		};
+	}
+	isDirtyRow(row) {
+		return new Uint8Array(this.memory.buffer, this.dirtyPtr, 256)[row] !== 0;
+	}
+	clearDirty() {
+		this.exports.clearDirty();
+	}
+	getCursor() {
+		return {
+			row: this.exports.getCursorRow(),
+			col: this.exports.getCursorCol(),
+			visible: this.exports.getCursorVisible() !== 0
+		};
+	}
+	getCols() {
+		return this.exports.getCols();
+	}
+	getRows() {
+		return this.exports.getRows();
+	}
+	cursorKeysApp() {
+		return this.exports.getCursorKeysApp() !== 0;
+	}
+	bracketedPaste() {
+		return this.exports.getBracketedPaste() !== 0;
+	}
+	usingAltScreen() {
+		return this.exports.getUsingAltScreen() !== 0;
+	}
+	getTitle() {
+		if (this.exports.getTitleChanged() === 0) return null;
+		const ptr = this.exports.getTitlePtr();
+		const len = this.exports.getTitleLen();
+		const bytes = new Uint8Array(this.memory.buffer, ptr, len);
+		return this.decoder.decode(bytes);
+	}
+	getResponse() {
+		const len = this.exports.getResponseLen();
+		if (len === 0) return null;
+		const ptr = this.exports.getResponsePtr();
+		const bytes = new Uint8Array(this.memory.buffer, ptr, len);
+		const str = this.decoder.decode(bytes);
+		this.exports.clearResponse();
+		return str;
+	}
+	getScrollbackCount() {
+		return this.exports.getScrollbackCount();
+	}
+	getScrollbackCell(offset, col) {
+		const off = this.exports.getScrollbackLine(offset) + col * this.cellSize;
+		const dv = this._dv;
+		return {
+			char: dv.getUint32(off, true),
+			fg: dv.getUint16(off + 4, true),
+			bg: dv.getUint16(off + 6, true),
+			flags: dv.getUint8(off + 8)
+		};
+	}
+	getScrollbackLineLen(offset) {
+		return this.exports.getScrollbackLineLen(offset);
+	}
+	getUnhandledSequences() {
+		const count = this.exports.getDebugLogCount();
+		if (count === 0) return [];
+		const ptr = this.exports.getDebugLogPtr();
+		const entrySize = this.exports.getDebugLogEntrySize();
+		const maxEntries = this.exports.getDebugLogMax();
+		const total = Math.min(count, maxEntries);
+		const dv = new DataView(this.memory.buffer);
+		const entries = [];
+		const startIdx = count >= maxEntries ? count % maxEntries : 0;
+		for (let i = 0; i < total; i++) {
+			const off = ptr + (startIdx + i) % maxEntries * entrySize;
+			const finalByte = dv.getUint8(off);
+			if (finalByte === 0) continue;
+			const privateByte = dv.getUint8(off + 1);
+			const paramCount = dv.getUint8(off + 2);
+			const params = [];
+			for (let p = 0; p < Math.min(paramCount, 4); p++) params.push(dv.getUint16(off + 4 + p * 2, true));
+			entries.push({
+				final: String.fromCharCode(finalByte),
+				private: privateByte ? String.fromCharCode(privateByte) : "",
+				paramCount,
+				params
+			});
+		}
+		return entries;
+	}
+	resize(cols, rows) {
+		this.exports.resizeTerminal(cols, rows);
+		this._updatePointers();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@wterm+dom@0.1.9/node_modules/@wterm/dom/dist/renderer.js
+const DEFAULT_COLOR$1 = 256;
+const FLAG_BOLD$1 = 1;
+const FLAG_DIM$1 = 2;
+const FLAG_ITALIC$1 = 4;
+const FLAG_UNDERLINE$1 = 8;
+const FLAG_REVERSE$1 = 32;
+const FLAG_INVISIBLE$1 = 64;
+const FLAG_STRIKETHROUGH$1 = 128;
+function colorToCSS$1(index) {
+	if (index === DEFAULT_COLOR$1) return null;
+	if (index < 16) return `var(--term-color-${index})`;
+	if (index < 232) {
+		const n = index - 16;
+		return `rgb(${Math.floor(n / 36) * 51},${Math.floor(n / 6) % 6 * 51},${n % 6 * 51})`;
+	}
+	const level = (index - 232) * 10 + 8;
+	return `rgb(${level},${level},${level})`;
+}
+function buildCellStyle$1(fg, bg, flags) {
+	let fgC = fg, bgC = bg;
+	if (flags & FLAG_REVERSE$1) {
+		const tmp = fgC;
+		fgC = bgC;
+		bgC = tmp;
+		if (fgC === DEFAULT_COLOR$1) fgC = 0;
+		if (bgC === DEFAULT_COLOR$1) bgC = 7;
+	}
+	const fgCSS = colorToCSS$1(fgC);
+	const bgCSS = colorToCSS$1(bgC);
+	let style = "";
+	if (fgCSS) style += `color:${fgCSS};`;
+	if (bgCSS) style += `background:${bgCSS};`;
+	if (flags & FLAG_BOLD$1) style += "font-weight:bold;";
+	if (flags & FLAG_DIM$1) style += "opacity:0.5;";
+	if (flags & FLAG_ITALIC$1) style += "font-style:italic;";
+	const decorations = [];
+	if (flags & FLAG_UNDERLINE$1) decorations.push("underline");
+	if (flags & FLAG_STRIKETHROUGH$1) decorations.push("line-through");
+	if (decorations.length) style += `text-decoration:${decorations.join(" ")};`;
+	if (flags & FLAG_INVISIBLE$1) style += "visibility:hidden;";
+	return style;
+}
+function appendRun$1(parent, text, style) {
+	const span = document.createElement("span");
+	if (style) span.style.cssText = style;
+	span.textContent = text;
+	parent.appendChild(span);
+}
+function resolveColors$1(fg, bg, flags) {
+	let fgC = fg, bgC = bg;
+	if (flags & FLAG_REVERSE$1) {
+		[fgC, bgC] = [bgC, fgC];
+		if (fgC === DEFAULT_COLOR$1) fgC = 0;
+		if (bgC === DEFAULT_COLOR$1) bgC = 7;
+	}
+	return {
+		fg: colorToCSS$1(fgC) || "var(--term-fg)",
+		bg: colorToCSS$1(bgC) || "var(--term-bg)"
+	};
+}
+function getBlockBackground$1(cp, fg, bg) {
+	switch (cp) {
+		case 9600: return `linear-gradient(${fg} 50%,${bg} 50%)`;
+		case 9601: return `linear-gradient(${bg} 87.5%,${fg} 87.5%)`;
+		case 9602: return `linear-gradient(${bg} 75%,${fg} 75%)`;
+		case 9603: return `linear-gradient(${bg} 62.5%,${fg} 62.5%)`;
+		case 9604: return `linear-gradient(${bg} 50%,${fg} 50%)`;
+		case 9605: return `linear-gradient(${bg} 37.5%,${fg} 37.5%)`;
+		case 9606: return `linear-gradient(${bg} 25%,${fg} 25%)`;
+		case 9607: return `linear-gradient(${bg} 12.5%,${fg} 12.5%)`;
+		case 9608: return fg;
+		case 9609: return `linear-gradient(to right,${fg} 87.5%,${bg} 87.5%)`;
+		case 9610: return `linear-gradient(to right,${fg} 75%,${bg} 75%)`;
+		case 9611: return `linear-gradient(to right,${fg} 62.5%,${bg} 62.5%)`;
+		case 9612: return `linear-gradient(to right,${fg} 50%,${bg} 50%)`;
+		case 9613: return `linear-gradient(to right,${fg} 37.5%,${bg} 37.5%)`;
+		case 9614: return `linear-gradient(to right,${fg} 25%,${bg} 25%)`;
+		case 9615: return `linear-gradient(to right,${fg} 12.5%,${bg} 12.5%)`;
+		case 9616: return `linear-gradient(to right,${bg} 50%,${fg} 50%)`;
+		case 9617: return `color-mix(in srgb,${fg} 25%,${bg})`;
+		case 9618: return `color-mix(in srgb,${fg} 50%,${bg})`;
+		case 9619: return `color-mix(in srgb,${fg} 75%,${bg})`;
+		case 9620: return `linear-gradient(${fg} 12.5%,${bg} 12.5%)`;
+		case 9621: return `linear-gradient(to right,${bg} 87.5%,${fg} 87.5%)`;
+		default: {
+			const q = {
+				9622: [
+					false,
+					false,
+					true,
+					false
+				],
+				9623: [
+					false,
+					false,
+					false,
+					true
+				],
+				9624: [
+					true,
+					false,
+					false,
+					false
+				],
+				9625: [
+					true,
+					false,
+					true,
+					true
+				],
+				9626: [
+					true,
+					false,
+					false,
+					true
+				],
+				9627: [
+					true,
+					true,
+					true,
+					false
+				],
+				9628: [
+					true,
+					true,
+					false,
+					true
+				],
+				9629: [
+					false,
+					true,
+					false,
+					false
+				],
+				9630: [
+					false,
+					true,
+					true,
+					false
+				],
+				9631: [
+					false,
+					true,
+					true,
+					true
+				]
+			}[cp];
+			if (!q) return fg;
+			const [tl, tr, bl, br] = q;
+			if (tl && tr && bl && br) return fg;
+			const layers = [];
+			const POS = [
+				"0 0",
+				"100% 0",
+				"0 100%",
+				"100% 100%"
+			];
+			q.forEach((filled, i) => {
+				if (filled) layers.push(`linear-gradient(${fg},${fg}) ${POS[i]}/50% 50% no-repeat`);
+			});
+			layers.push(bg);
+			return layers.join(",");
+		}
+	}
+}
+var Renderer = class {
+	constructor(container) {
+		this.rows = 0;
+		this.cols = 0;
+		this.rowEls = [];
+		this.prevCursorRow = -1;
+		this.prevCursorCol = -1;
+		this.prevContainerBg = "";
+		this.prevRowBg = [];
+		this._scrollbackRowEls = [];
+		this._renderedScrollbackCount = 0;
+		this.container = container;
+	}
+	setup(cols, rows) {
+		this.cols = cols;
+		this.rows = rows;
+		this.container.innerHTML = "";
+		this.rowEls = [];
+		this.prevRowBg = [];
+		this._scrollbackRowEls = [];
+		this._renderedScrollbackCount = 0;
+		const fragment = document.createDocumentFragment();
+		for (let r = 0; r < rows; r++) {
+			const rowEl = document.createElement("div");
+			rowEl.className = "term-row";
+			fragment.appendChild(rowEl);
+			this.rowEls.push(rowEl);
+		}
+		this.container.appendChild(fragment);
+		this.prevCursorRow = -1;
+		this.prevCursorCol = -1;
+	}
+	_buildRowContent(rowEl, getCell, lineLen, cursorCol, rowIndex) {
+		rowEl.textContent = "";
+		let runStyle = "";
+		let runText = "";
+		let runStart = 0;
+		const flushRun = (endCol) => {
+			if (!runText) return;
+			if (cursorCol >= runStart && cursorCol < endCol) {
+				const offset = cursorCol - runStart;
+				const before = runText.slice(0, offset);
+				const cursorChar = runText[offset];
+				const after = runText.slice(offset + 1);
+				if (before) appendRun$1(rowEl, before, runStyle);
+				const cursorSpan = document.createElement("span");
+				cursorSpan.className = "term-cursor";
+				if (runStyle) cursorSpan.style.cssText = runStyle;
+				cursorSpan.textContent = cursorChar;
+				rowEl.appendChild(cursorSpan);
+				if (after) appendRun$1(rowEl, after, runStyle);
+			} else appendRun$1(rowEl, runText, runStyle);
+		};
+		for (let col = 0; col < this.cols; col++) {
+			const cell = getCell(col);
+			const inBounds = col < lineLen;
+			const cp = inBounds ? cell.char : 0;
+			if (inBounds && cp >= 9600 && cp <= 9631) {
+				flushRun(col);
+				const colors = resolveColors$1(cell.fg, cell.bg, cell.flags);
+				const span = document.createElement("span");
+				span.className = col === cursorCol ? "term-block term-cursor" : "term-block";
+				span.style.background = getBlockBackground$1(cp, colors.fg, colors.bg);
+				if (cell.flags & FLAG_DIM$1) span.style.opacity = "0.5";
+				rowEl.appendChild(span);
+				runStyle = "";
+				runText = "";
+				runStart = col + 1;
+			} else {
+				const ch = inBounds && cp >= 32 ? String.fromCodePoint(cp) : " ";
+				const style = inBounds ? buildCellStyle$1(cell.fg, cell.bg, cell.flags) : "";
+				if (style !== runStyle) {
+					flushRun(col);
+					runStyle = style;
+					runText = ch;
+					runStart = col;
+				} else runText += ch;
+			}
+		}
+		flushRun(this.cols);
+		let bgCss = "";
+		if (lineLen >= this.cols && this.cols > 0) {
+			const lastCell = getCell(this.cols - 1);
+			let bgC = lastCell.bg;
+			if (lastCell.flags & FLAG_REVERSE$1) {
+				bgC = lastCell.fg;
+				if (bgC === DEFAULT_COLOR$1) bgC = 7;
+			}
+			bgCss = colorToCSS$1(bgC) || "";
+		}
+		const boxShadow = bgCss ? `0 1px 0 ${bgCss}` : "";
+		if (rowIndex >= 0) {
+			if (bgCss !== (this.prevRowBg[rowIndex] ?? "")) {
+				rowEl.style.background = bgCss;
+				rowEl.style.boxShadow = boxShadow;
+				this.prevRowBg[rowIndex] = bgCss;
+			}
+		} else {
+			rowEl.style.background = bgCss;
+			rowEl.style.boxShadow = boxShadow;
+		}
+	}
+	_buildScrollbackRowEl(bridge, sbOffset) {
+		const rowEl = document.createElement("div");
+		rowEl.className = "term-row term-scrollback-row";
+		const lineLen = bridge.getScrollbackLineLen(sbOffset);
+		this._buildRowContent(rowEl, (col) => bridge.getScrollbackCell(sbOffset, col), lineLen, -1, -1);
+		return rowEl;
+	}
+	syncScrollback(bridge) {
+		const scrollbackCount = bridge.getScrollbackCount();
+		if (scrollbackCount === this._renderedScrollbackCount) return;
+		if (scrollbackCount > this._renderedScrollbackCount) {
+			const newCount = scrollbackCount - this._renderedScrollbackCount;
+			const firstGridRow = this.rowEls[0] ?? null;
+			const fragment = document.createDocumentFragment();
+			for (let i = newCount - 1; i >= 0; i--) {
+				const rowEl = this._buildScrollbackRowEl(bridge, i);
+				fragment.appendChild(rowEl);
+				this._scrollbackRowEls.push(rowEl);
+			}
+			this.container.insertBefore(fragment, firstGridRow);
+		} else {
+			const removeCount = this._renderedScrollbackCount - scrollbackCount;
+			for (let i = 0; i < removeCount; i++) {
+				const el = this._scrollbackRowEls.shift();
+				if (el) el.remove();
+			}
+		}
+		this._renderedScrollbackCount = scrollbackCount;
+	}
+	render(bridge) {
+		const rows = bridge.getRows();
+		const cols = bridge.getCols();
+		let resized = false;
+		if (rows !== this.rows || cols !== this.cols) {
+			this.setup(cols, rows);
+			resized = true;
+		}
+		this.syncScrollback(bridge);
+		const cursor = bridge.getCursor();
+		const cursorVisible = cursor.visible;
+		const needsCursorUpdate = cursor.row !== this.prevCursorRow || cursor.col !== this.prevCursorCol;
+		for (let r = 0; r < this.rows; r++) {
+			const isDirty = resized || bridge.isDirtyRow(r);
+			const hadCursor = r === this.prevCursorRow && needsCursorUpdate;
+			const hasCursor = r === cursor.row;
+			if (isDirty || hadCursor || hasCursor && needsCursorUpdate) {
+				const cCol = hasCursor && cursorVisible ? cursor.col : -1;
+				this._buildRowContent(this.rowEls[r], (col) => bridge.getCell(r, col), this.cols, cCol, r);
+			}
+		}
+		this.prevCursorRow = cursor.row;
+		this.prevCursorCol = cursor.col;
+		if (resized || bridge.isDirtyRow(this.rows - 1)) {
+			const bottomRight = bridge.getCell(this.rows - 1, this.cols - 1);
+			let gridBg = bottomRight.bg;
+			if (bottomRight.flags & FLAG_REVERSE$1) {
+				gridBg = bottomRight.fg;
+				if (gridBg === DEFAULT_COLOR$1) gridBg = 7;
+			}
+			const containerBg = colorToCSS$1(gridBg) || "";
+			if (containerBg !== this.prevContainerBg) {
+				this.container.style.background = containerBg;
+				this.prevContainerBg = containerBg;
+			}
+		}
+		bridge.clearDirty();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@wterm+dom@0.1.9/node_modules/@wterm/dom/dist/input.js
+const NORMAL_KEYS = {
+	ArrowUp: "\x1B[A",
+	ArrowDown: "\x1B[B",
+	ArrowRight: "\x1B[C",
+	ArrowLeft: "\x1B[D",
+	Home: "\x1B[H",
+	End: "\x1B[F"
+};
+const APP_KEYS = {
+	ArrowUp: "\x1BOA",
+	ArrowDown: "\x1BOB",
+	ArrowRight: "\x1BOC",
+	ArrowLeft: "\x1BOD",
+	Home: "\x1BOH",
+	End: "\x1BOF"
+};
+const FIXED_KEYS = {
+	Enter: "\r",
+	Backspace: "",
+	Tab: "	",
+	Escape: "\x1B",
+	Insert: "\x1B[2~",
+	Delete: "\x1B[3~",
+	PageUp: "\x1B[5~",
+	PageDown: "\x1B[6~",
+	F1: "\x1BOP",
+	F2: "\x1BOQ",
+	F3: "\x1BOR",
+	F4: "\x1BOS",
+	F5: "\x1B[15~",
+	F6: "\x1B[17~",
+	F7: "\x1B[18~",
+	F8: "\x1B[19~",
+	F9: "\x1B[20~",
+	F10: "\x1B[21~",
+	F11: "\x1B[23~",
+	F12: "\x1B[24~"
+};
+var InputHandler = class {
+	constructor(element, onData, getBridge) {
+		this.composing = false;
+		this.element = element;
+		this.onData = onData;
+		this.getBridge = getBridge;
+		this.textarea = document.createElement("textarea");
+		this.textarea.setAttribute("autocapitalize", "off");
+		this.textarea.setAttribute("autocomplete", "off");
+		this.textarea.setAttribute("autocorrect", "off");
+		this.textarea.setAttribute("spellcheck", "false");
+		this.textarea.setAttribute("enterkeyhint", "send");
+		this.textarea.setAttribute("tabindex", "0");
+		this.textarea.setAttribute("aria-hidden", "true");
+		const s = this.textarea.style;
+		s.position = "absolute";
+		s.left = "-9999px";
+		s.top = "0";
+		s.width = "1px";
+		s.height = "1px";
+		s.opacity = "0";
+		s.overflow = "hidden";
+		s.border = "0";
+		s.padding = "0";
+		s.margin = "0";
+		s.outline = "none";
+		s.resize = "none";
+		s.pointerEvents = "none";
+		s.caretColor = "transparent";
+		s.color = "transparent";
+		s.background = "transparent";
+		element.appendChild(this.textarea);
+		this._onKeyDown = this.handleKeyDown.bind(this);
+		this._onPaste = this.handlePaste.bind(this);
+		this._onCompositionStart = this.handleCompositionStart.bind(this);
+		this._onCompositionEnd = this.handleCompositionEnd.bind(this);
+		this._onInput = this.handleInput.bind(this);
+		this._onFocus = () => this.element.classList.add("focused");
+		this._onBlur = () => this.element.classList.remove("focused");
+		this.textarea.addEventListener("keydown", this._onKeyDown);
+		this.textarea.addEventListener("paste", this._onPaste);
+		this.textarea.addEventListener("compositionstart", this._onCompositionStart);
+		this.textarea.addEventListener("compositionend", this._onCompositionEnd);
+		this.textarea.addEventListener("input", this._onInput);
+		this.textarea.addEventListener("focus", this._onFocus);
+		this.textarea.addEventListener("blur", this._onBlur);
+	}
+	focus() {
+		this.textarea.focus({ preventScroll: true });
+	}
+	destroy() {
+		this.textarea.removeEventListener("keydown", this._onKeyDown);
+		this.textarea.removeEventListener("paste", this._onPaste);
+		this.textarea.removeEventListener("compositionstart", this._onCompositionStart);
+		this.textarea.removeEventListener("compositionend", this._onCompositionEnd);
+		this.textarea.removeEventListener("input", this._onInput);
+		this.textarea.removeEventListener("focus", this._onFocus);
+		this.textarea.removeEventListener("blur", this._onBlur);
+		this.element.classList.remove("focused");
+		this.textarea.remove();
+	}
+	handleKeyDown(e) {
+		if (this.composing) return;
+		if ((e.metaKey || e.ctrlKey) && e.key === "c") {
+			const sel = window.getSelection();
+			if (sel && sel.toString().length > 0) return;
+		}
+		if ((e.metaKey || e.ctrlKey) && e.key === "v") {
+			this.textarea.focus();
+			return;
+		}
+		if (e.metaKey && !e.ctrlKey) {
+			if (e.key === "Backspace") {
+				e.preventDefault();
+				this.onData("");
+			} else if (e.key === "a") {
+				e.preventDefault();
+				const sel = window.getSelection();
+				if (sel) {
+					const range = document.createRange();
+					range.selectNodeContents(this.element);
+					sel.removeAllRanges();
+					sel.addRange(range);
+				}
+			}
+			return;
+		}
+		e.preventDefault();
+		const seq = this.keyToSequence(e);
+		if (seq) this.onData(seq);
+	}
+	handlePaste(e) {
+		e.preventDefault();
+		const text = e.clipboardData?.getData("text");
+		if (!text) return;
+		const bridge = this.getBridge();
+		if (bridge && bridge.bracketedPaste()) {
+			const safe = text.replace(/\x1b/g, "");
+			this.onData("\x1B[200~" + safe + "\x1B[201~");
+		} else this.onData(text);
+	}
+	handleCompositionStart() {
+		this.composing = true;
+	}
+	handleCompositionEnd(e) {
+		this.composing = false;
+		if (e.data) this.onData(e.data);
+		this.textarea.value = "";
+	}
+	handleInput() {
+		if (this.composing) return;
+		const value = this.textarea.value;
+		if (value) {
+			this.onData(value);
+			this.textarea.value = "";
+		}
+	}
+	keyToSequence(e) {
+		if (e.ctrlKey && !e.altKey && !e.metaKey) {
+			if (e.key.length === 1) {
+				const code = e.key.toLowerCase().charCodeAt(0);
+				if (code >= 97 && code <= 122) return String.fromCharCode(code - 96);
+			}
+			if (e.key === "[") return "\x1B";
+			if (e.key === "\\") return "";
+			if (e.key === "]") return "";
+			if (e.key === "^") return "";
+			if (e.key === "_") return "";
+		}
+		if (e.key === "Enter" && e.shiftKey) return "\x1B[13;2u";
+		if (e.key === "Tab" && e.shiftKey) return "\x1B[Z";
+		const fixed = FIXED_KEYS[e.key];
+		if (fixed) return e.altKey ? "\x1B" + fixed : fixed;
+		const bridge = this.getBridge();
+		const nav = (bridge && bridge.cursorKeysApp() ? APP_KEYS : NORMAL_KEYS)[e.key];
+		if (nav) return e.altKey ? "\x1B" + nav : nav;
+		if (e.key.length === 1 && !e.ctrlKey && !e.metaKey) return e.altKey ? "\x1B" + e.key : e.key;
+		return null;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@wterm+dom@0.1.9/node_modules/@wterm/dom/dist/debug.js
+const FLAG_NAMES = {
+	1: "bold",
+	2: "dim",
+	4: "italic",
+	8: "underline",
+	16: "blink",
+	32: "reverse",
+	64: "invisible",
+	128: "strikethrough"
+};
+function flagsToNames(flags) {
+	const names = [];
+	for (const [bit, name] of Object.entries(FLAG_NAMES)) if (flags & Number(bit)) names.push(name);
+	return names;
+}
+const ESC$2 = 27;
+function scanSequences(data) {
+	const entries = [];
+	const ts = Date.now();
+	let i = 0;
+	let textStart = 0;
+	const flushText = () => {
+		if (i > textStart) {
+			const raw = data.slice(textStart, i);
+			if (raw.length > 0 && !/^[\x00-\x1f]+$/.test(raw)) entries.push({
+				ts,
+				type: "text",
+				raw: raw.slice(0, 60)
+			});
+		}
+	};
+	while (i < data.length) {
+		if (data.charCodeAt(i) !== ESC$2) {
+			i++;
+			continue;
+		}
+		flushText();
+		const seqStart = i;
+		i++;
+		if (i >= data.length) break;
+		const next = data[i];
+		if (next === "[") {
+			i++;
+			let priv = "";
+			if (i < data.length && (data[i] === "?" || data[i] === ">" || data[i] === "!")) {
+				priv = data[i];
+				i++;
+			}
+			let paramStr = "";
+			while (i < data.length && (data.charCodeAt(i) >= 48 && data.charCodeAt(i) <= 59 || data[i] === ":")) {
+				paramStr += data[i];
+				i++;
+			}
+			while (i < data.length && data.charCodeAt(i) >= 32 && data.charCodeAt(i) <= 47) i++;
+			let final = "";
+			if (i < data.length && data.charCodeAt(i) >= 64 && data.charCodeAt(i) <= 126) {
+				final = data[i];
+				i++;
+			}
+			const raw = data.slice(seqStart, i);
+			const params = paramStr ? paramStr.split(/[;:]/).map(Number).filter((n) => !isNaN(n)) : [];
+			const type = final === "m" ? "sgr" : "csi";
+			entries.push({
+				ts,
+				type,
+				raw,
+				params: params.length > 0 ? params : void 0,
+				private: priv || void 0,
+				final
+			});
+		} else if (next === "]") {
+			i++;
+			while (i < data.length && data.charCodeAt(i) !== 7 && !(data.charCodeAt(i) === ESC$2 && i + 1 < data.length && data[i + 1] === "\\")) i++;
+			if (i < data.length) {
+				if (data.charCodeAt(i) === 7) i++;
+				else if (data.charCodeAt(i) === ESC$2) i += 2;
+			}
+			const raw = data.slice(seqStart, i);
+			entries.push({
+				ts,
+				type: "osc",
+				raw: raw.slice(0, 80)
+			});
+		} else if (next >= " " && next <= "~") {
+			i++;
+			entries.push({
+				ts,
+				type: "esc",
+				raw: data.slice(seqStart, i),
+				final: next
+			});
+		} else i++;
+		textStart = i;
+	}
+	flushText();
+	return entries;
+}
+const MAX_TRACES = 500;
+var DebugAdapter = class {
+	constructor() {
+		this._traces = [];
+		this._bridge = null;
+		this._perf = {
+			frameCount: 0,
+			totalRenderMs: 0,
+			avgRenderMs: 0,
+			maxRenderMs: 0,
+			lastDirtyRows: 0
+		};
+	}
+	get traces() {
+		return this._traces;
+	}
+	get perf() {
+		return this._perf;
+	}
+	setBridge(bridge) {
+		this._bridge = bridge;
+	}
+	traceWrite(data) {
+		const entries = scanSequences(typeof data === "string" ? data : new TextDecoder().decode(data));
+		for (const entry of entries) this._traces.push(entry);
+		if (this._traces.length > MAX_TRACES) this._traces = this._traces.slice(-MAX_TRACES);
+	}
+	recordRender(renderMs, dirtyRows) {
+		this._perf.frameCount++;
+		this._perf.totalRenderMs += renderMs;
+		this._perf.avgRenderMs = this._perf.totalRenderMs / this._perf.frameCount;
+		if (renderMs > this._perf.maxRenderMs) this._perf.maxRenderMs = renderMs;
+		this._perf.lastDirtyRows = dirtyRows;
+	}
+	resetPerf() {
+		this._perf = {
+			frameCount: 0,
+			totalRenderMs: 0,
+			avgRenderMs: 0,
+			maxRenderMs: 0,
+			lastDirtyRows: 0
+		};
+	}
+	cell(row, col) {
+		if (!this._bridge) return null;
+		const c = this._bridge.getCell(row, col);
+		return {
+			...c,
+			charStr: c.char >= 32 ? String.fromCodePoint(c.char) : "",
+			flagNames: flagsToNames(c.flags)
+		};
+	}
+	row(row) {
+		if (!this._bridge) return null;
+		const cols = this._bridge.getCols();
+		const cells = [];
+		for (let c = 0; c < cols; c++) cells.push(this.cell(row, c));
+		return cells;
+	}
+	grid() {
+		if (!this._bridge) return null;
+		const cursor = this._bridge.getCursor();
+		return {
+			rows: this._bridge.getRows(),
+			cols: this._bridge.getCols(),
+			cursor,
+			altScreen: this._bridge.usingAltScreen(),
+			scrollbackCount: this._bridge.getScrollbackCount()
+		};
+	}
+	unhandled() {
+		if (!this._bridge) return [];
+		return this._bridge.getUnhandledSequences();
+	}
+	dump(count = 50) {
+		const entries = this._traces.slice(-count);
+		console.group(`%cwterm debug — last ${entries.length} traces`, "color: #569cd6; font-weight: bold");
+		for (const e of entries) {
+			const badge = e.type === "sgr" ? "%cSGR" : e.type === "csi" ? "%cCSI" : e.type === "osc" ? "%cOSC" : e.type === "esc" ? "%cESC" : "%cTXT";
+			const color = e.type === "sgr" ? "background:#2d5a27;color:#fff;padding:1px 4px;border-radius:2px" : e.type === "csi" ? "background:#1e4a7a;color:#fff;padding:1px 4px;border-radius:2px" : "background:#555;color:#fff;padding:1px 4px;border-radius:2px";
+			const detail = [
+				e.private ? `private=${e.private}` : "",
+				e.params ? `params=[${e.params}]` : "",
+				e.final ? `final=${e.final}` : ""
+			].filter(Boolean).join(" ");
+			console.log(`${badge} ${e.raw.slice(0, 40)}`, color, detail ? `  ${detail}` : "");
+		}
+		console.groupEnd();
+	}
+	dumpUnhandled() {
+		const entries = this.unhandled();
+		if (entries.length === 0) {
+			console.log("%cwterm debug — no unhandled sequences", "color: #6a9955");
+			return;
+		}
+		console.group(`%cwterm debug — ${entries.length} unhandled sequences`, "color: #d7ba7d; font-weight: bold");
+		for (const e of entries) console.log(`  final=${e.final} private=${e.private || "-"} params=[${e.params.slice(0, e.paramCount)}]`);
+		console.groupEnd();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@wterm+dom@0.1.9/node_modules/@wterm/dom/dist/wterm.js
+var WTerm = class {
+	constructor(element, options = {}) {
+		this.bridge = null;
+		this.debug = null;
+		this.renderer = null;
+		this.input = null;
+		this.rafId = null;
+		this.resizeObserver = null;
+		this._destroyed = false;
+		this._shouldScrollToBottom = false;
+		this._rowHeight = 0;
+		this.element = element;
+		this.wasmUrl = options.wasmUrl;
+		this.cols = options.cols || 80;
+		this.rows = options.rows || 24;
+		this.autoResize = options.autoResize !== false;
+		this._debugEnabled = options.debug ?? false;
+		this.onData = options.onData || null;
+		this.onTitle = options.onTitle || null;
+		this.onResize = options.onResize || null;
+		this._container = document.createElement("div");
+		this._container.className = "term-grid";
+		this.element.appendChild(this._container);
+		this.element.classList.add("wterm");
+		if (options.cursorBlink) this.element.classList.add("cursor-blink");
+		this._onClickFocus = () => {
+			const sel = window.getSelection();
+			if (!sel || sel.isCollapsed) this.input?.focus();
+		};
+		this.element.addEventListener("click", this._onClickFocus);
+	}
+	async init() {
+		try {
+			this.bridge = await WasmBridge.load(this.wasmUrl);
+			if (this._destroyed) return this;
+			this.bridge.init(this.cols, this.rows);
+			if (this._debugEnabled) {
+				this.debug = new DebugAdapter();
+				this.debug.setBridge(this.bridge);
+				globalThis.__wterm = this;
+			}
+			this._setRowHeight();
+			this.renderer = new Renderer(this._container);
+			this.renderer.setup(this.cols, this.rows);
+			this.input = new InputHandler(this.element, (data) => {
+				this._scrollToBottom();
+				if (this.onData) this.onData(data);
+				else this.write(data);
+			}, () => this.bridge);
+			if (this.autoResize) this._setupResizeObserver();
+			else this._lockHeight();
+			this.input.focus();
+			this._initialRender();
+		} catch (err) {
+			this.destroy();
+			throw new Error(`wterm: failed to initialize: ${err instanceof Error ? err.message : err}`);
+		}
+		return this;
+	}
+	_isScrolledToBottom() {
+		const el = this.element;
+		return el.scrollHeight - el.scrollTop - el.clientHeight < 5;
+	}
+	_scrollToBottom() {
+		const el = this.element;
+		const maxScroll = el.scrollHeight - el.clientHeight;
+		if (maxScroll <= 0) {
+			el.scrollTop = 0;
+			return;
+		}
+		const rh = this._rowHeight || 17;
+		el.scrollTop = Math.floor(maxScroll / rh) * rh;
+	}
+	write(data) {
+		if (!this.bridge) return;
+		if (this.debug) this.debug.traceWrite(data);
+		this._shouldScrollToBottom = this._isScrolledToBottom();
+		if (typeof data === "string") this.bridge.writeString(data);
+		else this.bridge.writeRaw(data);
+		this._scheduleRender();
+	}
+	resize(cols, rows) {
+		if (!this.bridge) return;
+		this._shouldScrollToBottom = this._isScrolledToBottom();
+		this.cols = cols;
+		this.rows = rows;
+		this.bridge.resize(cols, rows);
+		this.renderer?.setup(cols, rows);
+		this._scheduleRender();
+		if (this.onResize) this.onResize(cols, rows);
+	}
+	focus() {
+		if (this.input) this.input.focus();
+		else this.element.focus();
+	}
+	_scheduleRender() {
+		if (this.rafId == null) this.rafId = requestAnimationFrame(() => {
+			this.rafId = null;
+			this._doRender();
+		});
+	}
+	_initialRender() {
+		this._doRender();
+	}
+	_doRender() {
+		if (!this.bridge || !this.renderer) return;
+		let dirtyCount = 0;
+		const t0 = this.debug ? performance.now() : 0;
+		if (this.debug) {
+			for (let r = 0; r < this.rows; r++) if (this.bridge.isDirtyRow(r)) dirtyCount++;
+		}
+		this.renderer.render(this.bridge);
+		if (this.debug) this.debug.recordRender(performance.now() - t0, dirtyCount);
+		const hasScrollback = this.bridge.getScrollbackCount() > 0;
+		this.element.classList.toggle("has-scrollback", hasScrollback);
+		if (this._shouldScrollToBottom) this._scrollToBottom();
+		else if (!hasScrollback && this.element.scrollTop !== 0) this.element.scrollTop = 0;
+		const title = this.bridge.getTitle();
+		if (title !== null && this.onTitle) this.onTitle(title);
+		const response = this.bridge.getResponse();
+		if (response !== null && this.onData) this.onData(response);
+	}
+	_lockHeight() {
+		const rh = this._rowHeight || 17;
+		const gridHeight = this.rows * rh;
+		const cs = getComputedStyle(this.element);
+		let extra = (parseFloat(cs.paddingTop) || 0) + (parseFloat(cs.paddingBottom) || 0);
+		if (cs.boxSizing === "border-box") extra += (parseFloat(cs.borderTopWidth) || 0) + (parseFloat(cs.borderBottomWidth) || 0);
+		this.element.style.height = `${gridHeight + extra}px`;
+	}
+	_setRowHeight() {
+		const probe = document.createElement("div");
+		probe.className = "term-row";
+		probe.style.visibility = "hidden";
+		probe.style.position = "absolute";
+		probe.textContent = "W";
+		this._container.appendChild(probe);
+		const h = probe.getBoundingClientRect().height;
+		probe.remove();
+		if (h > 0) {
+			const rh = Math.ceil(h);
+			this._rowHeight = rh;
+			this.element.style.setProperty("--term-row-height", `${rh}px`);
+		}
+	}
+	_measureCharSize() {
+		const row = document.createElement("div");
+		row.className = "term-row";
+		row.style.visibility = "hidden";
+		row.style.position = "absolute";
+		const probe = document.createElement("span");
+		probe.textContent = "W";
+		row.appendChild(probe);
+		this._container.appendChild(row);
+		const charWidth = probe.getBoundingClientRect().width;
+		const rowHeight = row.getBoundingClientRect().height;
+		row.remove();
+		if (charWidth === 0 || rowHeight === 0) return null;
+		this._rowHeight = rowHeight;
+		return {
+			charWidth,
+			rowHeight
+		};
+	}
+	_setupResizeObserver() {
+		const initial = this._measureCharSize();
+		if (!initial) return;
+		let { charWidth, rowHeight } = initial;
+		this.resizeObserver = new ResizeObserver((entries) => {
+			const measured = this._measureCharSize();
+			if (measured) {
+				charWidth = measured.charWidth;
+				rowHeight = measured.rowHeight;
+			}
+			for (const entry of entries) {
+				const { width, height } = entry.contentRect;
+				const newCols = Math.max(1, Math.floor(width / charWidth));
+				const newRows = Math.max(1, Math.floor(height / rowHeight));
+				if (newCols !== this.cols || newRows !== this.rows) this.resize(newCols, newRows);
+			}
+		});
+		this.resizeObserver.observe(this.element);
+	}
+	destroy() {
+		this._destroyed = true;
+		if (this.rafId != null) cancelAnimationFrame(this.rafId);
+		if (this.resizeObserver) this.resizeObserver.disconnect();
+		if (this.input) this.input.destroy();
+		this.element.removeEventListener("click", this._onClickFocus);
+		this.element.innerHTML = "";
+		if (this.debug && globalThis.__wterm === this) delete globalThis.__wterm;
+		this.debug = null;
+	}
+};
+//#endregion
+//#region packages/protocol/src/index.ts
+function createPongControlFrame() {
+	return JSON.stringify({ type: "pong" });
+}
+function createResizeControlFrame(cols, rows) {
+	return JSON.stringify({
+		cols,
+		rows,
+		type: "resize"
+	});
+}
+function parseAittyControlFrame(data) {
+	try {
+		const parsed = JSON.parse(data);
+		if (!parsed || typeof parsed !== "object" || !("type" in parsed)) return null;
+		if (typeof parsed.type !== "string") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function normalizeTheme(theme) {
+	if (typeof theme !== "string") return;
+	const normalized = theme.trim();
+	return normalized.length > 0 ? normalized : void 0;
+}
+//#endregion
+//#region src/frontend/ansi-sequences.ts
+const ALT_SCREEN_PARAMS = new Set([
+	47,
+	1047,
+	1049
+]);
+function parseCsiParams(paramBuffer) {
+	if (!paramBuffer) return [];
+	return paramBuffer.split(/[;:]/).map((value) => Number(value)).filter((value) => !Number.isNaN(value));
+}
+function nextAltScreenState(currentState, privateMarker, paramBuffer, finalByte) {
+	if (privateMarker !== "?" || finalByte !== "h" && finalByte !== "l") return currentState;
+	if (!parseCsiParams(paramBuffer).some((value) => ALT_SCREEN_PARAMS.has(value))) return currentState;
+	return finalByte === "h";
+}
+//#endregion
+//#region src/frontend/cell-width.ts
+function isWideCodePoint(codePoint) {
+	return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141);
+}
+function cellWidthForCodePoint(codePoint) {
+	return isWideCodePoint(codePoint) ? 2 : 1;
+}
+//#endregion
+//#region src/frontend/ansi-style-tracker.ts
+const ESC$1 = "\x1B";
+function createBlankRow(cols) {
+	return Array.from({ length: cols }, () => null);
+}
+function cloneRow(row) {
+	return row.map((cell) => {
+		if (!cell) return null;
+		return {
+			bg: cell.bg ?? null,
+			displayStart: cell.displayStart,
+			fg: cell.fg ?? null,
+			hidden: cell.hidden,
+			width: cell.width
+		};
+	});
+}
+function clamp$2(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function createBuffer(cols, rows) {
+	return {
+		cursor: {
+			col: 0,
+			displayCol: 0,
+			row: 0
+		},
+		rows: Array.from({ length: rows }, () => createBlankRow(cols)),
+		savedCursor: {
+			col: 0,
+			displayCol: 0,
+			row: 0
+		},
+		scrollback: []
+	};
+}
+function makeRgbCss(red, green, blue) {
+	return `rgb(${clamp$2(red, 0, 255)}, ${clamp$2(green, 0, 255)}, ${clamp$2(blue, 0, 255)})`;
+}
+function isPlainCharacter(character) {
+	return character >= " " && character !== "";
+}
+function createAnsiStyleTracker(options = {}) {
+	let cols = Math.max(1, options.cols ?? 80);
+	let rows = Math.max(1, options.rows ?? 24);
+	let mainBuffer = createBuffer(cols, rows);
+	let altBuffer = createBuffer(cols, rows);
+	let currentStyle = {
+		bg: null,
+		fg: null
+	};
+	let parserState = "text";
+	let csiPrivate = "";
+	let csiParams = "";
+	let decoder = new TextDecoder();
+	let useAltBuffer = false;
+	let renderHints = {
+		clearScreen: false,
+		styleChanged: false
+	};
+	const activeBuffer = () => useAltBuffer ? altBuffer : mainBuffer;
+	const clampCursor = (cursor) => {
+		cursor.row = clamp$2(cursor.row, 0, rows - 1);
+		cursor.col = clamp$2(cursor.col, 0, cols - 1);
+		cursor.displayCol = clamp$2(cursor.displayCol, 0, cols - 1);
+	};
+	const cellDisplayStart = (row, col) => row[col]?.displayStart ?? col;
+	const cellWidth = (row, col) => row[col]?.width ?? 1;
+	const makeCellState = (style, sourceCol, displayStart, width, hidden = false) => {
+		if (!hidden && style.fg === null && style.bg === null && displayStart === sourceCol && width === 1) return null;
+		return {
+			bg: style.bg,
+			displayStart,
+			fg: style.fg,
+			hidden,
+			width
+		};
+	};
+	const markCellHidden = (row, col) => {
+		const cell = row[col];
+		row[col] = {
+			bg: cell?.bg ?? null,
+			displayStart: cellDisplayStart(row, col),
+			fg: cell?.fg ?? null,
+			hidden: true,
+			width: cellWidth(row, col)
+		};
+	};
+	const hideCellsCoveredByDisplayRange = (row, displayStart, width, sourceCol) => {
+		const displayEnd = displayStart + width;
+		for (let col = 0; col < cols; col += 1) {
+			if (col === sourceCol) continue;
+			const cellStart = cellDisplayStart(row, col);
+			const cellEnd = cellStart + cellWidth(row, col);
+			if (cellStart < displayEnd && cellEnd > displayStart) markCellHidden(row, col);
+		}
+	};
+	const storeCellAtCursor = (width) => {
+		const buffer = activeBuffer();
+		const row = buffer.rows[buffer.cursor.row];
+		if (!row) return;
+		const displayStart = buffer.cursor.displayCol;
+		hideCellsCoveredByDisplayRange(row, displayStart, width, buffer.cursor.col);
+		row[buffer.cursor.col] = makeCellState(currentStyle, buffer.cursor.col, displayStart, width);
+	};
+	const scrollActiveBuffer = () => {
+		const buffer = activeBuffer();
+		const droppedRow = buffer.rows.shift() ?? createBlankRow(cols);
+		buffer.rows.push(createBlankRow(cols));
+		if (!useAltBuffer) mainBuffer.scrollback.unshift(cloneRow(droppedRow));
+	};
+	const moveCursorTo = (buffer, row, col) => {
+		buffer.cursor.row = clamp$2(row, 0, rows - 1);
+		buffer.cursor.col = clamp$2(col, 0, cols - 1);
+		buffer.cursor.displayCol = cellDisplayStart(buffer.rows[buffer.cursor.row] ?? [], buffer.cursor.col);
+	};
+	const advanceCursor = (width) => {
+		const buffer = activeBuffer();
+		if (buffer.cursor.col < cols - 1) {
+			buffer.cursor.col += 1;
+			buffer.cursor.displayCol = clamp$2(buffer.cursor.displayCol + width, 0, cols - 1);
+			return;
+		}
+		buffer.cursor.col = 0;
+		buffer.cursor.displayCol = 0;
+		if (buffer.cursor.row < rows - 1) {
+			buffer.cursor.row += 1;
+			return;
+		}
+		scrollActiveBuffer();
+	};
+	const clearRowRange = (rowIndex, startCol, endCol) => {
+		const row = activeBuffer().rows[rowIndex];
+		if (!row) return;
+		for (let index = startCol; index <= endCol; index += 1) row[index] = null;
+	};
+	const clearScreen = () => {
+		const buffer = activeBuffer();
+		buffer.rows = Array.from({ length: rows }, () => createBlankRow(cols));
+		renderHints.clearScreen = true;
+	};
+	const resetTerminalState = () => {
+		mainBuffer = createBuffer(cols, rows);
+		altBuffer = createBuffer(cols, rows);
+		currentStyle = {
+			bg: null,
+			fg: null
+		};
+		useAltBuffer = false;
+		renderHints.clearScreen = true;
+	};
+	const resizeRows = (buffer, nextRows) => {
+		if (nextRows === buffer.rows.length) return;
+		if (nextRows > buffer.rows.length) {
+			const missing = nextRows - buffer.rows.length;
+			buffer.rows = [...buffer.rows, ...Array.from({ length: missing }, () => createBlankRow(cols))];
+			return;
+		}
+		const removeCount = buffer.rows.length - nextRows;
+		const removedRows = buffer.rows.splice(0, removeCount);
+		if (buffer === mainBuffer) for (const row of removedRows) mainBuffer.scrollback.unshift(cloneRow(row));
+		moveCursorTo(buffer, Math.max(0, buffer.cursor.row - removeCount), buffer.cursor.col);
+	};
+	const resizeCols = (buffer, nextCols) => {
+		buffer.rows = buffer.rows.map((row) => {
+			if (nextCols === row.length) return row;
+			if (nextCols > row.length) return [...row, ...Array.from({ length: nextCols - row.length }, () => null)];
+			return row.slice(0, nextCols);
+		});
+		buffer.cursor.col = clamp$2(buffer.cursor.col, 0, nextCols - 1);
+		buffer.cursor.displayCol = clamp$2(buffer.cursor.displayCol, 0, nextCols - 1);
+		buffer.savedCursor.col = clamp$2(buffer.savedCursor.col, 0, nextCols - 1);
+		buffer.savedCursor.displayCol = clamp$2(buffer.savedCursor.displayCol, 0, nextCols - 1);
+	};
+	const setAltBuffer = (nextState) => {
+		if (nextState === useAltBuffer) return;
+		if (nextState) {
+			mainBuffer.savedCursor = { ...mainBuffer.cursor };
+			altBuffer = createBuffer(cols, rows);
+			useAltBuffer = true;
+			return;
+		}
+		useAltBuffer = false;
+		mainBuffer.cursor = { ...mainBuffer.savedCursor };
+	};
+	const handleSgr = (params) => {
+		const values = params.length === 0 ? [0] : params;
+		renderHints.styleChanged = true;
+		for (let index = 0; index < values.length; index += 1) {
+			const value = values[index] ?? 0;
+			if (value === 0) {
+				currentStyle = {
+					bg: null,
+					fg: null
+				};
+				continue;
+			}
+			if (value === 39 || value >= 30 && value <= 37 || value >= 90 && value <= 97) {
+				currentStyle.fg = null;
+				continue;
+			}
+			if (value === 49 || value >= 40 && value <= 47 || value >= 100 && value <= 107) {
+				currentStyle.bg = null;
+				continue;
+			}
+			if (value === 38 || value === 48) {
+				const target = value === 38 ? "fg" : "bg";
+				const mode = values[index + 1];
+				if (mode === 2 && index + 4 < values.length) {
+					currentStyle[target] = makeRgbCss(values[index + 2], values[index + 3], values[index + 4]);
+					index += 4;
+					continue;
+				}
+				if (mode === 5 && index + 2 < values.length) {
+					currentStyle[target] = null;
+					index += 2;
+				}
+			}
+		}
+	};
+	const handleEraseDisplay = (mode) => {
+		const buffer = activeBuffer();
+		if (mode === 2) {
+			clearScreen();
+			return;
+		}
+		if (mode === 0) {
+			clearRowRange(buffer.cursor.row, buffer.cursor.col, cols - 1);
+			for (let row = buffer.cursor.row + 1; row < rows; row += 1) clearRowRange(row, 0, cols - 1);
+			return;
+		}
+		if (mode === 1) {
+			for (let row = 0; row < buffer.cursor.row; row += 1) clearRowRange(row, 0, cols - 1);
+			clearRowRange(buffer.cursor.row, 0, buffer.cursor.col);
+		}
+	};
+	const handleEraseLine = (mode) => {
+		const cursor = activeBuffer().cursor;
+		if (mode === 2) {
+			clearRowRange(cursor.row, 0, cols - 1);
+			return;
+		}
+		if (mode === 1) {
+			clearRowRange(cursor.row, 0, cursor.col);
+			return;
+		}
+		clearRowRange(cursor.row, cursor.col, cols - 1);
+	};
+	const handleCsi = (finalByte) => {
+		const params = parseCsiParams(csiParams);
+		const buffer = activeBuffer();
+		setAltBuffer(nextAltScreenState(useAltBuffer, csiPrivate, csiParams, finalByte));
+		switch (finalByte) {
+			case "A":
+				moveCursorTo(buffer, buffer.cursor.row - Math.max(1, params[0] ?? 1), buffer.cursor.col);
+				break;
+			case "B":
+				moveCursorTo(buffer, buffer.cursor.row + Math.max(1, params[0] ?? 1), buffer.cursor.col);
+				break;
+			case "C":
+				moveCursorTo(buffer, buffer.cursor.row, buffer.cursor.col + Math.max(1, params[0] ?? 1));
+				break;
+			case "D":
+				moveCursorTo(buffer, buffer.cursor.row, buffer.cursor.col - Math.max(1, params[0] ?? 1));
+				break;
+			case "G":
+				moveCursorTo(buffer, buffer.cursor.row, (params[0] ?? 1) - 1);
+				break;
+			case "H":
+			case "f":
+				moveCursorTo(buffer, (params[0] ?? 1) - 1, (params[1] ?? 1) - 1);
+				break;
+			case "J":
+				handleEraseDisplay(params[0] ?? 0);
+				break;
+			case "K":
+				handleEraseLine(params[0] ?? 0);
+				break;
+			case "m":
+				handleSgr(params);
+				break;
+			case "s":
+				buffer.savedCursor = { ...buffer.cursor };
+				break;
+			case "u":
+				buffer.cursor = { ...buffer.savedCursor };
+				break;
+			default: break;
+		}
+	};
+	const writeCharacter = (character) => {
+		const width = cellWidthForCodePoint(character.codePointAt(0) ?? 32);
+		storeCellAtCursor(width);
+		advanceCursor(width);
+	};
+	const processTextCharacter = (character) => {
+		const buffer = activeBuffer();
+		if (character === ESC$1) {
+			parserState = "escape";
+			return;
+		}
+		if (character === "\b") {
+			moveCursorTo(buffer, buffer.cursor.row, buffer.cursor.col - 1);
+			return;
+		}
+		if (character === "\n") {
+			if (buffer.cursor.row < rows - 1) buffer.cursor.row += 1;
+			else scrollActiveBuffer();
+			return;
+		}
+		if (character === "\r") {
+			buffer.cursor.col = 0;
+			buffer.cursor.displayCol = 0;
+			return;
+		}
+		if (character === "	") {
+			const nextTabStop = (Math.floor(buffer.cursor.displayCol / 8) + 1) * 8;
+			moveCursorTo(buffer, buffer.cursor.row, nextTabStop);
+			return;
+		}
+		if (!isPlainCharacter(character)) return;
+		writeCharacter(character);
+	};
+	const appendText = (text) => {
+		for (const character of text) {
+			if (parserState === "escape") {
+				if (character === "[") {
+					parserState = "csi";
+					csiPrivate = "";
+					csiParams = "";
+					continue;
+				}
+				if (character === "]") {
+					parserState = "osc";
+					continue;
+				}
+				if (character === "7") activeBuffer().savedCursor = { ...activeBuffer().cursor };
+				else if (character === "8") activeBuffer().cursor = { ...activeBuffer().savedCursor };
+				else if (character === "c") resetTerminalState();
+				parserState = "text";
+				continue;
+			}
+			if (parserState === "csi") {
+				if ((character === "?" || character === ">" || character === "!") && csiParams.length === 0) {
+					csiPrivate = character;
+					continue;
+				}
+				if (character >= "0" && character <= "9" || character === ";" || character === ":") {
+					csiParams += character;
+					continue;
+				}
+				if (character >= "@" && character <= "~") {
+					handleCsi(character);
+					parserState = "text";
+				}
+				continue;
+			}
+			if (parserState === "osc") {
+				if (character === "\x07") {
+					parserState = "text";
+					continue;
+				}
+				if (character === ESC$1) parserState = "osc_escape";
+				continue;
+			}
+			if (parserState === "osc_escape") {
+				parserState = character === "\\" ? "text" : "osc";
+				continue;
+			}
+			processTextCharacter(character);
+		}
+	};
+	return {
+		append(chunk) {
+			appendText(decoder.decode(chunk, { stream: true }));
+		},
+		getGridOverride(row, col) {
+			return activeBuffer().rows[row]?.[col] ?? null;
+		},
+		getScrollbackOverride(offset, col) {
+			return mainBuffer.scrollback[offset]?.[col] ?? null;
+		},
+		isAltScreenActive() {
+			return useAltBuffer;
+		},
+		reset(nextCols = cols, nextRows = rows) {
+			cols = Math.max(1, nextCols);
+			rows = Math.max(1, nextRows);
+			mainBuffer = createBuffer(cols, rows);
+			altBuffer = createBuffer(cols, rows);
+			currentStyle = {
+				bg: null,
+				fg: null
+			};
+			parserState = "text";
+			renderHints.clearScreen = false;
+			csiPrivate = "";
+			csiParams = "";
+			decoder = new TextDecoder();
+			useAltBuffer = false;
+		},
+		resize(nextCols, nextRows) {
+			cols = Math.max(1, nextCols);
+			rows = Math.max(1, nextRows);
+			resizeCols(mainBuffer, cols);
+			resizeCols(altBuffer, cols);
+			resizeRows(mainBuffer, rows);
+			resizeRows(altBuffer, rows);
+			clampCursor(mainBuffer.cursor);
+			clampCursor(mainBuffer.savedCursor);
+			clampCursor(altBuffer.cursor);
+			clampCursor(altBuffer.savedCursor);
+		},
+		syncFromBridge(bridge) {
+			if (!bridge) return;
+			useAltBuffer = bridge.usingAltScreen();
+			const cursor = bridge.getCursor();
+			const buffer = activeBuffer();
+			buffer.cursor.row = clamp$2(cursor.row, 0, rows - 1);
+			buffer.cursor.col = clamp$2(cursor.col, 0, cols - 1);
+		},
+		consumeRenderHints() {
+			const nextHints = renderHints;
+			renderHints = {
+				clearScreen: false,
+				styleChanged: false
+			};
+			return nextHints;
+		}
+	};
+}
+//#endregion
+//#region src/frontend/browser-terminal-renderer.ts
+const DEFAULT_COLOR = 256;
+const FLAG_BOLD = 1;
+const FLAG_DIM = 2;
+const FLAG_ITALIC = 4;
+const FLAG_UNDERLINE = 8;
+const FLAG_REVERSE = 32;
+const FLAG_INVISIBLE = 64;
+const FLAG_STRIKETHROUGH = 128;
+function colorToCSS(index) {
+	if (index === DEFAULT_COLOR) return null;
+	if (index < 16) return `var(--term-color-${index})`;
+	if (index < 232) {
+		const value = index - 16;
+		return `rgb(${Math.floor(value / 36) * 51}, ${Math.floor(value / 6) % 6 * 51}, ${value % 6 * 51})`;
+	}
+	const level = (index - 232) * 10 + 8;
+	return `rgb(${level}, ${level}, ${level})`;
+}
+function resolveColorChannels(fg, bg, flags, override = null) {
+	let resolvedFg = override?.fg ?? colorToCSS(fg);
+	let resolvedBg = override?.bg ?? colorToCSS(bg);
+	if (flags & FLAG_REVERSE) {
+		[resolvedFg, resolvedBg] = [resolvedBg, resolvedFg];
+		if (resolvedFg === null) resolvedFg = colorToCSS(0);
+		if (resolvedBg === null) resolvedBg = colorToCSS(7);
+	}
+	return {
+		bg: resolvedBg,
+		fg: resolvedFg
+	};
+}
+function buildCellStyle(fg, bg, flags, override = null) {
+	const colors = resolveColorChannels(fg, bg, flags, override);
+	let style = "";
+	if (colors.fg) style += `color:${colors.fg};`;
+	if (colors.bg) style += `background:${colors.bg};`;
+	if (flags & FLAG_BOLD) style += "font-weight:bold;";
+	if (flags & FLAG_DIM) style += "opacity:0.5;";
+	if (flags & FLAG_ITALIC) style += "font-style:italic;";
+	const decorations = [];
+	if (flags & FLAG_UNDERLINE) decorations.push("underline");
+	if (flags & FLAG_STRIKETHROUGH) decorations.push("line-through");
+	if (decorations.length > 0) style += `text-decoration:${decorations.join(" ")};`;
+	if (flags & FLAG_INVISIBLE) style += "visibility:hidden;";
+	return style;
+}
+function appendRun(parent, text, style, className = "") {
+	const span = document.createElement("span");
+	if (className) span.className = className;
+	if (style) span.style.cssText = style;
+	span.textContent = text;
+	parent.appendChild(span);
+}
+function appendWideCell(parent, text, style, cursor = false) {
+	const span = document.createElement("span");
+	span.className = cursor ? "term-wide term-cursor" : "term-wide";
+	if (style) span.style.cssText = style;
+	span.style.width = "2ch";
+	span.style.minWidth = "2ch";
+	span.style.maxWidth = "2ch";
+	span.style.overflow = "hidden";
+	span.textContent = text;
+	parent.appendChild(span);
+}
+function isWideContinuationCell(cell) {
+	return (cell?.char ?? 0) === 0;
+}
+function serializeRowText(getCell, lineLength) {
+	let text = "";
+	for (let col = 0; col < lineLength; col += 1) {
+		const codePoint = getCell(col)?.char ?? 0;
+		if (isWideCodePoint(codePoint)) {
+			text += String.fromCodePoint(codePoint);
+			if (col + 1 < lineLength && isWideContinuationCell(getCell(col + 1))) col += 1;
+			continue;
+		}
+		text += codePoint >= 32 ? String.fromCodePoint(codePoint) : " ";
+	}
+	return normalizeRowText(text);
+}
+function normalizeRowText(text) {
+	return text.trimEnd();
+}
+function cloneSnapshotRow(snapshot) {
+	const rowElement = snapshot.element.cloneNode(true);
+	rowElement.className = "term-row term-scrollback-row term-restored-scrollback-row";
+	rowElement.querySelectorAll(".term-cursor").forEach((cursor) => {
+		cursor.classList.remove("term-cursor");
+	});
+	return rowElement;
+}
+function resolveSnapshotPrefixMatch(snapshotRows, currentRows) {
+	const meaningfulSnapshotRows = snapshotRows.filter((row) => row.text.length > 0);
+	const meaningfulCurrentRows = currentRows.filter((row) => row.length > 0);
+	if (meaningfulSnapshotRows.length === 0) return {
+		missingPrefixCount: 0,
+		overlapCount: 0
+	};
+	if (meaningfulCurrentRows.length === 0) return {
+		missingPrefixCount: meaningfulSnapshotRows.length,
+		overlapCount: 0
+	};
+	let bestStart = meaningfulSnapshotRows.length;
+	let bestOverlap = 0;
+	for (let start = 0; start < meaningfulSnapshotRows.length; start += 1) {
+		let overlap = 0;
+		while (start + overlap < meaningfulSnapshotRows.length && overlap < meaningfulCurrentRows.length && meaningfulSnapshotRows[start + overlap].text === meaningfulCurrentRows[overlap]) overlap += 1;
+		if (overlap > bestOverlap) {
+			bestOverlap = overlap;
+			bestStart = start;
+		}
+	}
+	if (bestOverlap === 0) return {
+		missingPrefixCount: 0,
+		overlapCount: 0
+	};
+	return {
+		missingPrefixCount: bestStart,
+		overlapCount: bestOverlap
+	};
+}
+function findRowSequence(rows, sequence, minStart = 0) {
+	if (sequence.length === 0) return Math.max(0, minStart);
+	outer: for (let start = Math.max(0, minStart); start <= rows.length - sequence.length; start += 1) {
+		for (let index = 0; index < sequence.length; index += 1) if (rows[start + index] !== sequence[index]) continue outer;
+		return start;
+	}
+	return -1;
+}
+function resolveColors(fg, bg, flags, override = null) {
+	const colors = resolveColorChannels(fg, bg, flags, override);
+	return {
+		bg: colors.bg ?? "var(--term-bg)",
+		fg: colors.fg ?? "var(--term-fg)"
+	};
+}
+function getBlockBackground(codePoint, fg, bg) {
+	switch (codePoint) {
+		case 9600: return `linear-gradient(${fg} 50%,${bg} 50%)`;
+		case 9601: return `linear-gradient(${bg} 87.5%,${fg} 87.5%)`;
+		case 9602: return `linear-gradient(${bg} 75%,${fg} 75%)`;
+		case 9603: return `linear-gradient(${bg} 62.5%,${fg} 62.5%)`;
+		case 9604: return `linear-gradient(${bg} 50%,${fg} 50%)`;
+		case 9605: return `linear-gradient(${bg} 37.5%,${fg} 37.5%)`;
+		case 9606: return `linear-gradient(${bg} 25%,${fg} 25%)`;
+		case 9607: return `linear-gradient(${bg} 12.5%,${fg} 12.5%)`;
+		case 9608: return fg;
+		case 9609: return `linear-gradient(to right,${fg} 87.5%,${bg} 87.5%)`;
+		case 9610: return `linear-gradient(to right,${fg} 75%,${bg} 75%)`;
+		case 9611: return `linear-gradient(to right,${fg} 62.5%,${bg} 62.5%)`;
+		case 9612: return `linear-gradient(to right,${fg} 50%,${bg} 50%)`;
+		case 9613: return `linear-gradient(to right,${fg} 37.5%,${bg} 37.5%)`;
+		case 9614: return `linear-gradient(to right,${fg} 25%,${bg} 25%)`;
+		case 9615: return `linear-gradient(to right,${fg} 12.5%,${bg} 12.5%)`;
+		case 9616: return `linear-gradient(to right,${bg} 50%,${fg} 50%)`;
+		case 9617: return `color-mix(in srgb,${fg} 25%,${bg})`;
+		case 9618: return `color-mix(in srgb,${fg} 50%,${bg})`;
+		case 9619: return `color-mix(in srgb,${fg} 75%,${bg})`;
+		case 9620: return `linear-gradient(${fg} 12.5%,${bg} 12.5%)`;
+		case 9621: return `linear-gradient(to right,${bg} 87.5%,${fg} 87.5%)`;
+		default: {
+			const cells = {
+				9622: [
+					false,
+					false,
+					true,
+					false
+				],
+				9623: [
+					false,
+					false,
+					false,
+					true
+				],
+				9624: [
+					true,
+					false,
+					false,
+					false
+				],
+				9625: [
+					true,
+					false,
+					true,
+					true
+				],
+				9626: [
+					true,
+					false,
+					false,
+					true
+				],
+				9627: [
+					true,
+					true,
+					true,
+					false
+				],
+				9628: [
+					true,
+					true,
+					false,
+					true
+				],
+				9629: [
+					false,
+					true,
+					false,
+					false
+				],
+				9630: [
+					false,
+					true,
+					true,
+					false
+				],
+				9631: [
+					false,
+					true,
+					true,
+					true
+				]
+			}[codePoint];
+			if (!cells) return fg;
+			const [topLeft, topRight, bottomLeft, bottomRight] = cells;
+			const layers = [];
+			const positions = [
+				"0 0",
+				"100% 0",
+				"0 100%",
+				"100% 100%"
+			];
+			[
+				topLeft,
+				topRight,
+				bottomLeft,
+				bottomRight
+			].forEach((filled, index) => {
+				if (filled) layers.push(`linear-gradient(${fg},${fg}) ${positions[index]}/50% 50% no-repeat`);
+			});
+			layers.push(bg);
+			return layers.join(",");
+		}
+	}
+}
+var BrowserTerminalRenderer = class {
+	_altScreenMeaningfulScrollbackCount;
+	_altScreenVisibleRowSnapshot;
+	_lastAltScreenState;
+	_renderedScrollbackCount;
+	_restoreSnapshotCount;
+	_scrollbackRowEls;
+	cols;
+	container;
+	prevContainerBg;
+	prevCursorCol;
+	prevCursorRow;
+	prevCursorVisible;
+	prevRowBg;
+	rowEls;
+	rows;
+	styleTracker;
+	constructor(container, styleTracker) {
+		this._altScreenVisibleRowSnapshot = [];
+		this._altScreenMeaningfulScrollbackCount = 0;
+		this._lastAltScreenState = false;
+		this._restoreSnapshotCount = 0;
+		this.cols = 0;
+		this.container = container;
+		this.prevContainerBg = "";
+		this.prevCursorCol = -1;
+		this.prevCursorRow = -1;
+		this.prevCursorVisible = false;
+		this.prevRowBg = [];
+		this.rowEls = [];
+		this.rows = 0;
+		this.styleTracker = styleTracker;
+		this._renderedScrollbackCount = 0;
+		this._scrollbackRowEls = [];
+	}
+	_resolveFirstLiveGridRow() {
+		return Array.from(this.container.children).find((child) => child instanceof HTMLElement && child.classList.contains("term-row") && !child.classList.contains("term-scrollback-row")) ?? null;
+	}
+	_insertScrollbackFragment(fragment) {
+		const firstGridRow = this._resolveFirstLiveGridRow();
+		if (firstGridRow instanceof HTMLElement) {
+			this.container.insertBefore(fragment, firstGridRow);
+			return;
+		}
+		this.container.appendChild(fragment);
+	}
+	setup(cols, rows) {
+		this.cols = cols;
+		this.rows = rows;
+		this.container.innerHTML = "";
+		this.rowEls = [];
+		this.prevRowBg = [];
+		this._scrollbackRowEls = [];
+		this._renderedScrollbackCount = 0;
+		this.prevCursorVisible = false;
+		this.prevCursorRow = -1;
+		this.prevCursorCol = -1;
+		this._altScreenVisibleRowSnapshot = [];
+		this._altScreenMeaningfulScrollbackCount = 0;
+		this._lastAltScreenState = false;
+		this._restoreSnapshotCount = 0;
+		const fragment = document.createDocumentFragment();
+		for (let row = 0; row < rows; row += 1) {
+			const rowElement = document.createElement("div");
+			rowElement.className = "term-row";
+			fragment.appendChild(rowElement);
+			this.rowEls.push(rowElement);
+		}
+		this.container.appendChild(fragment);
+	}
+	_buildRowContent(rowEl, getCell, getOverride, lineLen, cursorCol, rowIndex) {
+		if (rowIndex >= 0) rowEl.className = "term-row";
+		rowEl.textContent = "";
+		let runStart = 0;
+		let runStyle = "";
+		let runText = "";
+		const flushRun = (endCol) => {
+			if (!runText) return;
+			if (cursorCol >= runStart && cursorCol < endCol) {
+				const offset = cursorCol - runStart;
+				const before = runText.slice(0, offset);
+				const cursorChar = runText[offset];
+				const after = runText.slice(offset + 1);
+				if (before) appendRun(rowEl, before, runStyle);
+				appendRun(rowEl, cursorChar, runStyle, "term-cursor");
+				if (after) appendRun(rowEl, after, runStyle);
+			} else appendRun(rowEl, runText, runStyle);
+		};
+		for (let col = 0; col < this.cols; col += 1) {
+			const cell = getCell(col);
+			const inBounds = col < lineLen;
+			const codePoint = inBounds ? cell.char : 0;
+			const override = getOverride(col);
+			if (override?.hidden === true) {
+				flushRun(col);
+				runStart = col + 1;
+				runStyle = "";
+				runText = "";
+				continue;
+			}
+			if (inBounds && isWideCodePoint(codePoint)) {
+				const consumedColumns = (col + 1 < lineLen && isWideContinuationCell(getCell(col + 1)) ? getCell(col + 1) : null) ? 2 : 1;
+				const style = buildCellStyle(cell.fg, cell.bg, cell.flags, override);
+				const cursorOnWideCell = cursorCol === col || consumedColumns === 2 && cursorCol === col + 1 || cursorCol === col + 1 && getOverride(cursorCol)?.hidden === true;
+				flushRun(col);
+				appendWideCell(rowEl, String.fromCodePoint(codePoint), style, cursorOnWideCell);
+				runStart = col + consumedColumns;
+				runStyle = "";
+				runText = "";
+				col += consumedColumns - 1;
+				continue;
+			}
+			if (inBounds && codePoint >= 9600 && codePoint <= 9631) {
+				flushRun(col);
+				const colors = resolveColors(cell.fg, cell.bg, cell.flags, override);
+				const span = document.createElement("span");
+				span.className = col === cursorCol ? "term-block term-cursor" : "term-block";
+				span.style.background = getBlockBackground(codePoint, colors.fg, colors.bg);
+				if (cell.flags & FLAG_DIM) span.style.opacity = "0.5";
+				rowEl.appendChild(span);
+				runStart = col + 1;
+				runStyle = "";
+				runText = "";
+				continue;
+			}
+			const character = inBounds && codePoint >= 32 ? String.fromCodePoint(codePoint) : " ";
+			const style = inBounds ? buildCellStyle(cell.fg, cell.bg, cell.flags, override) : "";
+			if (style !== runStyle) {
+				flushRun(col);
+				runStart = col;
+				runStyle = style;
+				runText = character;
+			} else runText += character;
+		}
+		flushRun(this.cols);
+		if (rowIndex >= 0) {
+			if (this.prevRowBg[rowIndex] !== "") {
+				rowEl.style.background = "";
+				rowEl.style.boxShadow = "";
+				this.prevRowBg[rowIndex] = "";
+			}
+			return;
+		}
+		rowEl.style.background = "";
+		rowEl.style.boxShadow = "";
+	}
+	_buildScrollbackRowEl(bridge, offset) {
+		const rowElement = document.createElement("div");
+		rowElement.className = "term-row term-scrollback-row";
+		const lineLength = bridge.getScrollbackLineLen(offset);
+		this._buildRowContent(rowElement, (col) => bridge.getScrollbackCell(offset, col), (col) => this.styleTracker.getScrollbackOverride(offset, col), lineLength, -1, -1);
+		return rowElement;
+	}
+	_captureVisibleRowSnapshot() {
+		this._altScreenMeaningfulScrollbackCount = this._scrollbackRowEls.reduce((count, rowElement) => count + (normalizeRowText(rowElement.textContent ?? "").length > 0 ? 1 : 0), 0);
+		this._altScreenVisibleRowSnapshot = this.rowEls.map((rowElement) => ({
+			element: rowElement.cloneNode(true),
+			text: normalizeRowText(rowElement.textContent ?? "")
+		}));
+	}
+	_clearAltScreenRestoreSnapshot() {
+		this._altScreenVisibleRowSnapshot = [];
+		this._altScreenMeaningfulScrollbackCount = 0;
+	}
+	_readGridRowText(bridge, row) {
+		return serializeRowText((col) => bridge.getCell(row, col), this.cols);
+	}
+	getVisibleRowTexts(bridge, { trimPadding = true } = {}) {
+		const rows = [];
+		for (let row = 0; row < this.rows; row += 1) rows.push(this._readGridRowText(bridge, row));
+		if (!trimPadding) return rows;
+		let start = 0;
+		let end = rows.length;
+		while (start < end && rows[start] === "") start += 1;
+		while (end > start && rows[end - 1] === "") end -= 1;
+		return rows.slice(start, end);
+	}
+	_readScrollbackRowText(bridge, offset) {
+		return serializeRowText((col) => bridge.getScrollbackCell(offset, col), bridge.getScrollbackLineLen(offset));
+	}
+	_readLiveTranscriptRows(bridge, currentVisibleRows) {
+		const liveRows = [];
+		for (let offset = bridge.getScrollbackCount() - 1; offset >= 0; offset -= 1) {
+			const rowText = this._readScrollbackRowText(bridge, offset);
+			if (rowText.length > 0) liveRows.push(rowText);
+		}
+		for (const rowText of currentVisibleRows) if (rowText.length > 0) liveRows.push(rowText);
+		return liveRows;
+	}
+	_liveTranscriptContainsSnapshots(bridge, snapshots, currentVisibleRows) {
+		if (snapshots.length === 0) return true;
+		return findRowSequence(this._readLiveTranscriptRows(bridge, currentVisibleRows), snapshots.map((snapshot) => snapshot.text), this._altScreenMeaningfulScrollbackCount) !== -1;
+	}
+	_getRestoredScrollbackSnapshots(bridge) {
+		if (bridge.usingAltScreen() || this._altScreenVisibleRowSnapshot.length === 0) return [];
+		const meaningfulSnapshotRows = this._altScreenVisibleRowSnapshot.filter((row) => row.text.length > 0);
+		if (meaningfulSnapshotRows.length === 0) {
+			this._clearAltScreenRestoreSnapshot();
+			return [];
+		}
+		const currentVisibleRows = [];
+		for (let row = 0; row < this.rows; row += 1) currentVisibleRows.push(this._readGridRowText(bridge, row));
+		let { missingPrefixCount, overlapCount } = resolveSnapshotPrefixMatch(this._altScreenVisibleRowSnapshot, currentVisibleRows);
+		if (missingPrefixCount <= 0) if (overlapCount === 0 && this._lastAltScreenState) missingPrefixCount = meaningfulSnapshotRows.length;
+		else if (overlapCount === 0 && this._restoreSnapshotCount > 0) missingPrefixCount = Math.min(this._restoreSnapshotCount, meaningfulSnapshotRows.length);
+		else {
+			this._clearAltScreenRestoreSnapshot();
+			return [];
+		}
+		const restoredSnapshots = meaningfulSnapshotRows.slice(0, missingPrefixCount);
+		if (this._liveTranscriptContainsSnapshots(bridge, restoredSnapshots, currentVisibleRows)) {
+			this._clearAltScreenRestoreSnapshot();
+			return [];
+		}
+		return restoredSnapshots;
+	}
+	_rebuildScrollback(bridge, restoredSnapshots) {
+		for (const rowElement of this._scrollbackRowEls) rowElement.remove();
+		this._scrollbackRowEls = [];
+		if (bridge.usingAltScreen()) {
+			this._renderedScrollbackCount = 0;
+			this._restoreSnapshotCount = 0;
+			return;
+		}
+		const scrollbackCount = bridge.getScrollbackCount();
+		const rowElements = [];
+		for (let offset = scrollbackCount - 1; offset >= 0; offset -= 1) rowElements.push(this._buildScrollbackRowEl(bridge, offset));
+		if (restoredSnapshots.length > 0) {
+			const restoredRowElements = restoredSnapshots.map((snapshot) => cloneSnapshotRow(snapshot));
+			const preservedRowCount = Math.max(0, rowElements.length - restoredRowElements.length);
+			rowElements.splice(preservedRowCount, rowElements.length - preservedRowCount, ...restoredRowElements);
+		}
+		const fragment = document.createDocumentFragment();
+		for (const rowElement of rowElements) fragment.appendChild(rowElement);
+		this._insertScrollbackFragment(fragment);
+		this._scrollbackRowEls = rowElements;
+		this._renderedScrollbackCount = scrollbackCount;
+		this._restoreSnapshotCount = restoredSnapshots.length;
+	}
+	syncScrollback(bridge, restoredSnapshots = []) {
+		const scrollbackCount = bridge.usingAltScreen() ? 0 : bridge.getScrollbackCount();
+		if (bridge.usingAltScreen() !== this._lastAltScreenState || restoredSnapshots.length > 0 || this._restoreSnapshotCount > 0) {
+			this._rebuildScrollback(bridge, restoredSnapshots);
+			return;
+		}
+		if (scrollbackCount === this._renderedScrollbackCount) return;
+		if (scrollbackCount > this._renderedScrollbackCount) {
+			const newCount = scrollbackCount - this._renderedScrollbackCount;
+			const fragment = document.createDocumentFragment();
+			for (let offset = newCount - 1; offset >= 0; offset -= 1) {
+				const rowElement = this._buildScrollbackRowEl(bridge, offset);
+				fragment.appendChild(rowElement);
+				this._scrollbackRowEls.push(rowElement);
+			}
+			this._insertScrollbackFragment(fragment);
+		} else {
+			const removeCount = this._renderedScrollbackCount - scrollbackCount;
+			for (let index = 0; index < removeCount; index += 1) this._scrollbackRowEls.shift()?.remove();
+		}
+		this._renderedScrollbackCount = scrollbackCount;
+	}
+	render(bridge, options = {}) {
+		const rows = bridge.getRows();
+		const cols = bridge.getCols();
+		const altScreenActive = bridge.usingAltScreen();
+		const forceRender = options.force === true;
+		let resized = false;
+		if (rows !== this.rows || cols !== this.cols) {
+			this.setup(cols, rows);
+			resized = true;
+		}
+		if (altScreenActive && !this._lastAltScreenState) this._captureVisibleRowSnapshot();
+		const restoredSnapshots = this._getRestoredScrollbackSnapshots(bridge);
+		this.syncScrollback(bridge, restoredSnapshots);
+		const cursor = bridge.getCursor();
+		const cursorVisible = cursor.visible;
+		const needsCursorUpdate = cursor.row !== this.prevCursorRow || cursor.col !== this.prevCursorCol || cursorVisible !== this.prevCursorVisible;
+		for (let row = 0; row < this.rows; row += 1) {
+			const isDirty = forceRender || resized || bridge.isDirtyRow(row);
+			const hadCursor = row === this.prevCursorRow && (needsCursorUpdate || this.prevCursorVisible);
+			const hasCursor = row === cursor.row;
+			if (isDirty || hadCursor || hasCursor && needsCursorUpdate) {
+				const cursorCol = hasCursor && cursorVisible ? cursor.col : -1;
+				this._buildRowContent(this.rowEls[row], (col) => bridge.getCell(row, col), (col) => this.styleTracker.getGridOverride(row, col), this.cols, cursorCol, row);
+			}
+		}
+		this.prevCursorRow = cursor.row;
+		this.prevCursorCol = cursor.col;
+		this.prevCursorVisible = cursorVisible;
+		if (this.prevContainerBg !== "") {
+			this.container.style.background = "";
+			this.prevContainerBg = "";
+		}
+		bridge.clearDirty();
+		this._lastAltScreenState = altScreenActive;
+	}
+};
+//#endregion
+//#region src/frontend/terminal-input-policies.ts
+const RESERVED_BROWSER_SHORTCUT_KEYS = new Set(["r", "w"]);
+const CONTAINED_TERMINAL_NAVIGATION_KEYS = new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+]);
+const NORMAL_NAVIGATION_SEQUENCES = Object.freeze({
+	ArrowDown: "\x1B[B",
+	ArrowLeft: "\x1B[D",
+	ArrowRight: "\x1B[C",
+	ArrowUp: "\x1B[A",
+	End: "\x1B[F",
+	Home: "\x1B[H"
+});
+const APPLICATION_NAVIGATION_SEQUENCES = Object.freeze({
+	ArrowDown: "\x1BOB",
+	ArrowLeft: "\x1BOD",
+	ArrowRight: "\x1BOC",
+	ArrowUp: "\x1BOA",
+	End: "\x1BOF",
+	Home: "\x1BOH"
+});
+const FIXED_KEY_SEQUENCES = Object.freeze({
+	Backspace: "",
+	Delete: "\x1B[3~",
+	Enter: "\r",
+	Escape: "\x1B",
+	F1: "\x1BOP",
+	F10: "\x1B[21~",
+	F11: "\x1B[23~",
+	F12: "\x1B[24~",
+	F2: "\x1BOQ",
+	F3: "\x1BOR",
+	F4: "\x1BOS",
+	F5: "\x1B[15~",
+	F6: "\x1B[17~",
+	F7: "\x1B[18~",
+	F8: "\x1B[19~",
+	F9: "\x1B[20~",
+	Insert: "\x1B[2~",
+	PageDown: "\x1B[6~",
+	PageUp: "\x1B[5~",
+	Tab: "	"
+});
+const ALT_PRINTABLE_CODE_MAP = Object.freeze({
+	Backquote: "`",
+	BracketLeft: "[",
+	BracketRight: "]",
+	Backslash: "\\",
+	Comma: ",",
+	Digit0: "0",
+	Digit1: "1",
+	Digit2: "2",
+	Digit3: "3",
+	Digit4: "4",
+	Digit5: "5",
+	Digit6: "6",
+	Digit7: "7",
+	Digit8: "8",
+	Digit9: "9",
+	Equal: "=",
+	KeyA: "a",
+	KeyB: "b",
+	KeyC: "c",
+	KeyD: "d",
+	KeyE: "e",
+	KeyF: "f",
+	KeyG: "g",
+	KeyH: "h",
+	KeyI: "i",
+	KeyJ: "j",
+	KeyK: "k",
+	KeyL: "l",
+	KeyM: "m",
+	KeyN: "n",
+	KeyO: "o",
+	KeyP: "p",
+	KeyQ: "q",
+	KeyR: "r",
+	KeyS: "s",
+	KeyT: "t",
+	KeyU: "u",
+	KeyV: "v",
+	KeyW: "w",
+	KeyX: "x",
+	KeyY: "y",
+	KeyZ: "z",
+	Minus: "-",
+	Period: ".",
+	Quote: "'",
+	Semicolon: ";",
+	Slash: "/",
+	Space: " "
+});
+function installTerminalInputPolicies(term, callbacks = {}) {
+	const root = term?.element;
+	const textarea = term?.input?.textarea;
+	const ownerDocument = root?.ownerDocument;
+	const onData = callbacks.onData ?? (() => {});
+	const captureDocumentCtrlN = callbacks.captureDocumentCtrlN === true;
+	const resolveKey = callbacks.resolveKey ?? (() => null);
+	const resolveDocumentKeyData = callbacks.resolveDocumentKeyData ?? (() => null);
+	if (!(root instanceof HTMLElement) || !(textarea instanceof HTMLTextAreaElement) || !(ownerDocument instanceof Document)) return () => {};
+	let composing = false;
+	let pendingCompositionCommit = false;
+	let suppressedCompositionValue = "";
+	let latestCompositionValue = "";
+	let speculativePlainInputText = "";
+	let pendingSyntheticPrintableText = "";
+	let syntheticPrintableFlushQueued = false;
+	const clearSpeculativePlainInputText = () => {
+		speculativePlainInputText = "";
+	};
+	const clearPendingSyntheticPrintableText = () => {
+		pendingSyntheticPrintableText = "";
+	};
+	const flushPendingSyntheticPrintableText = () => {
+		if (!pendingSyntheticPrintableText) return;
+		const pendingText = pendingSyntheticPrintableText;
+		pendingSyntheticPrintableText = "";
+		onData(pendingText);
+	};
+	const clearPendingTextState = () => {
+		clearSpeculativePlainInputText();
+		clearPendingSyntheticPrintableText();
+	};
+	const flushPendingTextState = () => {
+		clearSpeculativePlainInputText();
+		flushPendingSyntheticPrintableText();
+	};
+	const deferSyntheticPrintableText = (text) => {
+		pendingSyntheticPrintableText += text;
+		if (syntheticPrintableFlushQueued) return;
+		syntheticPrintableFlushQueued = true;
+		queueMicrotask(() => {
+			syntheticPrintableFlushQueued = false;
+			if (composing || !pendingSyntheticPrintableText) return;
+			const pendingText = pendingSyntheticPrintableText;
+			pendingSyntheticPrintableText = "";
+			onData(pendingText);
+		});
+	};
+	const rollBackSpeculativePlainInputText = (preeditText) => {
+		const rollbackText = resolveSpeculativeRollbackText(speculativePlainInputText, preeditText);
+		if (!rollbackText) return;
+		const rollback = "".repeat([...rollbackText].length);
+		speculativePlainInputText = speculativePlainInputText.slice(0, -rollbackText.length);
+		onData(rollback);
+	};
+	const sendText = (text) => {
+		if (!text) return;
+		onData(text);
+	};
+	const handleDocumentKeyDownCapture = (event) => {
+		if (event.target === textarea) return;
+		const documentKeyData = captureDocumentCtrlN && !event.altKey && !event.metaKey && event.ctrlKey && event.key.toLowerCase() === "n" ? "" : resolveDocumentKeyData(event);
+		if (documentKeyData === null) return;
+		flushPendingTextState();
+		event.preventDefault();
+		stopInputPropagation(event);
+		onData(documentKeyData);
+	};
+	const handleKeyDownCapture = (event) => {
+		if (isBrowserSafeShortcut(event)) {
+			flushPendingTextState();
+			stopInputPropagation(event);
+			return;
+		}
+		if (isCopyShortcutWithTerminalSelection(root, event)) {
+			flushPendingTextState();
+			stopInputPropagation(event);
+			return;
+		}
+		const customKeyData = resolveKey(event);
+		if (customKeyData != null) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+			onData(customKeyData);
+			return;
+		}
+		const normalizedAltSequence = resolveAltPrintableSequence(event);
+		if (normalizedAltSequence) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+			onData(normalizedAltSequence);
+			return;
+		}
+		if (composing || isCompositionKeyDown(event)) {
+			stopInputPropagation(event);
+			return;
+		}
+		if (isPlainPrintableKey(event)) {
+			pendingCompositionCommit = false;
+			suppressedCompositionValue = "";
+			latestCompositionValue = "";
+			stopInputPropagation(event);
+			if (!event.isTrusted) {
+				event.preventDefault();
+				deferSyntheticPrintableText(event.key);
+			}
+			return;
+		}
+		const terminalSequence = resolveTerminalKeySequence(term, event);
+		if (terminalSequence !== null) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+			onData(terminalSequence);
+			return;
+		}
+		if (isContainedTerminalNavigationKey(event)) {
+			flushPendingTextState();
+			event.preventDefault();
+			stopInputPropagation(event);
+		}
+	};
+	const handleCompositionStartCapture = (event) => {
+		clearPendingSyntheticPrintableText();
+		composing = true;
+		pendingCompositionCommit = false;
+		suppressedCompositionValue = "";
+		latestCompositionValue = "";
+		stopInputPropagation(event);
+	};
+	const handleCompositionEndCapture = (event) => {
+		clearPendingTextState();
+		composing = false;
+		stopInputPropagation(event);
+		pendingCompositionCommit = false;
+		const value = normalizeCompositionCommit(event.data);
+		if (!value) {
+			const fallbackValue = textarea.value;
+			if (latestCompositionValue && fallbackValue && fallbackValue !== latestCompositionValue) {
+				latestCompositionValue = "";
+				suppressedCompositionValue = fallbackValue;
+				sendText(fallbackValue);
+				textarea.value = "";
+				return;
+			}
+			pendingCompositionCommit = true;
+			return;
+		}
+		latestCompositionValue = "";
+		suppressedCompositionValue = value;
+		sendText(value);
+		textarea.value = "";
+	};
+	const handleInputCapture = (event) => {
+		if (composing || isComposingInput(event)) {
+			if (isCompositionPreeditInput(event)) {
+				clearPendingSyntheticPrintableText();
+				rollBackSpeculativePlainInputText(textarea.value);
+			} else clearPendingTextState();
+			latestCompositionValue = textarea.value;
+			stopInputPropagation(event);
+			return;
+		}
+		const value = textarea.value;
+		const compositionInput = isCompositionInput(event);
+		const compositionPreeditInput = isCompositionPreeditInput(event);
+		if (pendingCompositionCommit) {
+			clearPendingTextState();
+			stopInputPropagation(event);
+			if (!value) {
+				textarea.value = "";
+				if (!compositionInput) {
+					pendingCompositionCommit = false;
+					latestCompositionValue = "";
+				}
+				return;
+			}
+			if (compositionPreeditInput && value === latestCompositionValue) {
+				textarea.value = "";
+				return;
+			}
+			pendingCompositionCommit = false;
+			latestCompositionValue = "";
+			suppressedCompositionValue = resolveCommittedInputText(event, value);
+			sendText(suppressedCompositionValue);
+			textarea.value = "";
+			return;
+		}
+		if (compositionPreeditInput) {
+			clearPendingSyntheticPrintableText();
+			latestCompositionValue = value;
+			stopInputPropagation(event);
+			return;
+		}
+		if (suppressedCompositionValue) {
+			if (!value || value === suppressedCompositionValue) {
+				suppressedCompositionValue = "";
+				stopInputPropagation(event);
+				textarea.value = "";
+				return;
+			}
+			suppressedCompositionValue = "";
+		}
+		if (!value) return;
+		latestCompositionValue = "";
+		stopInputPropagation(event);
+		textarea.value = "";
+		if (compositionInput) {
+			const committedText = resolveCommittedInputText(event, value);
+			suppressedCompositionValue = committedText;
+			sendText(committedText);
+			return;
+		}
+		const inputText = resolvePlainInputText(event, value);
+		if (isPotentialImeSeedText(inputText)) speculativePlainInputText += inputText;
+		else clearSpeculativePlainInputText();
+		sendText(inputText);
+	};
+	const handleCopy = (event) => {
+		const selectionText = getSelectionText(root);
+		if (!selectionText || !event.clipboardData?.setData) return;
+		event.clipboardData.setData("text/plain", selectionText);
+		event.preventDefault();
+	};
+	const handlePaste = (event) => {
+		flushPendingTextState();
+		const text = event.clipboardData?.getData("text") ?? event.clipboardData?.getData("text/plain") ?? "";
+		if (!text) return;
+		event.preventDefault();
+		stopInputPropagation(event);
+		if (term?.bridge?.bracketedPaste?.() === true) {
+			onData(`\u001b[200~${text.split("\x1B").join("")}\u001b[201~`);
+			return;
+		}
+		onData(text);
+	};
+	ownerDocument.addEventListener("keydown", handleDocumentKeyDownCapture, true);
+	textarea.addEventListener("keydown", handleKeyDownCapture, true);
+	textarea.addEventListener("compositionstart", handleCompositionStartCapture, true);
+	textarea.addEventListener("compositionend", handleCompositionEndCapture, true);
+	textarea.addEventListener("input", handleInputCapture, true);
+	textarea.addEventListener("paste", handlePaste, true);
+	ownerDocument.addEventListener("copy", handleCopy, true);
+	return () => {
+		ownerDocument.removeEventListener("keydown", handleDocumentKeyDownCapture, true);
+		textarea.removeEventListener("keydown", handleKeyDownCapture, true);
+		textarea.removeEventListener("compositionstart", handleCompositionStartCapture, true);
+		textarea.removeEventListener("compositionend", handleCompositionEndCapture, true);
+		textarea.removeEventListener("input", handleInputCapture, true);
+		textarea.removeEventListener("paste", handlePaste, true);
+		ownerDocument.removeEventListener("copy", handleCopy, true);
+	};
+}
+function isBrowserSafeShortcut(event) {
+	if (event.altKey) return false;
+	if (!(event.metaKey && !event.ctrlKey || event.ctrlKey && !event.metaKey)) return false;
+	return RESERVED_BROWSER_SHORTCUT_KEYS.has(event.key.toLowerCase());
+}
+function isContainedTerminalNavigationKey(event) {
+	if (!CONTAINED_TERMINAL_NAVIGATION_KEYS.has(event.key)) return false;
+	if (event.altKey || event.ctrlKey || event.metaKey) return false;
+	return !(event.shiftKey && (event.key === "PageUp" || event.key === "PageDown"));
+}
+function resolveAltPrintableSequence(event) {
+	if (!event.altKey || event.ctrlKey || event.metaKey) return null;
+	const baseKey = ALT_PRINTABLE_CODE_MAP[event.code];
+	if (!baseKey) return null;
+	return `\u001b${baseKey}`;
+}
+function isPlainPrintableKey(event) {
+	if (event.altKey || event.ctrlKey || event.metaKey) return false;
+	return event.key.length === 1;
+}
+function resolveTerminalKeySequence(term, event) {
+	if (event.metaKey && !event.ctrlKey) {
+		if (event.key === "Backspace") return "";
+		return null;
+	}
+	if (event.ctrlKey) {
+		const controlSequence = resolveControlKeySequence(event);
+		return event.altKey && controlSequence ? `\u001b${controlSequence}` : controlSequence;
+	}
+	if (event.key === "Enter" && event.shiftKey) return "\x1B[13;2u";
+	if (event.key === "Tab" && event.shiftKey) return "\x1B[Z";
+	const fixedSequence = FIXED_KEY_SEQUENCES[event.key];
+	if (fixedSequence) return event.altKey ? `\u001b${fixedSequence}` : fixedSequence;
+	const navigationSequence = (term?.bridge?.cursorKeysApp?.() === true ? APPLICATION_NAVIGATION_SEQUENCES : NORMAL_NAVIGATION_SEQUENCES)[event.key];
+	if (navigationSequence) return event.altKey ? `\u001b${navigationSequence}` : navigationSequence;
+	return null;
+}
+function resolveControlKeySequence(event) {
+	if (event.key.length !== 1) return null;
+	const key = event.key.toLowerCase();
+	if (key >= "a" && key <= "z") return String.fromCharCode(key.charCodeAt(0) - 96);
+	return {
+		" ": "\0",
+		"[": "\x1B",
+		"\\": "",
+		"]": "",
+		"^": "",
+		"_": ""
+	}[key] ?? null;
+}
+function isCompositionKeyDown(event) {
+	return event.isComposing || event.key === "Process" || event.key === "Dead" || event.keyCode === 229 || event.which === 229;
+}
+function isCompositionInput(event) {
+	return typeof event.inputType === "string" && event.inputType.toLowerCase().includes("composition");
+}
+function isCompositionPreeditInput(event) {
+	return event.inputType === "insertCompositionText";
+}
+function isComposingInput(event) {
+	return event.isComposing || isCompositionPreeditInput(event);
+}
+function resolvePlainInputText(event, textareaValue) {
+	if (typeof event.data === "string" && event.data.length > 0) return event.data;
+	if (event.inputType === "insertLineBreak") return "\r";
+	if (event.inputType === "deleteContentBackward") return "";
+	if (event.inputType === "deleteContentForward") return "\x1B[3~";
+	return textareaValue;
+}
+function resolveCommittedInputText(event, textareaValue) {
+	if (typeof event.data === "string" && event.data.length > 0) return event.data;
+	return textareaValue;
+}
+function isPotentialImeSeedText(text) {
+	return /^[0-9A-Za-z']$/.test(text);
+}
+function resolveSpeculativeRollbackText(sentText, preeditText) {
+	if (!sentText || !preeditText || !preeditText.startsWith(sentText)) return "";
+	return sentText;
+}
+function normalizeCompositionCommit(data) {
+	if (typeof data === "string" && data.length > 0) return data;
+	return "";
+}
+function getSelectionText(root) {
+	const selection = root.ownerDocument?.getSelection?.();
+	if (!selection || selection.isCollapsed) return "";
+	if (!nodeIsInsideRoot(root, selection.anchorNode) || !nodeIsInsideRoot(root, selection.focusNode)) return "";
+	return selection.toString();
+}
+function isCopyShortcutWithTerminalSelection(root, event) {
+	if (event.altKey || event.key.toLowerCase() !== "c") return false;
+	if (!(event.metaKey || event.ctrlKey)) return false;
+	return getSelectionText(root).length > 0;
+}
+function nodeIsInsideRoot(root, node) {
+	if (!node) return false;
+	if (node === root) return true;
+	if (node instanceof Element) return root.contains(node);
+	return node.parentElement ? root.contains(node.parentElement) : false;
+}
+function stopInputPropagation(event) {
+	event.stopPropagation();
+	if (typeof event.stopImmediatePropagation === "function") event.stopImmediatePropagation();
+}
+//#endregion
+//#region src/frontend/terminal-theme-protocol.ts
+const BEL = "\x07";
+const ESC = "\x1B";
+const MAX_OSC_LENGTH = 512;
+const DEFAULT_DARK_THEME_COLORS = {
+	background: "#0d1117",
+	cursor: "#f6b967",
+	foreground: "#edf2ff"
+};
+const DEFAULT_LIGHT_THEME_COLORS = {
+	background: "#f4efe3",
+	cursor: "#b96e1a",
+	foreground: "#24323f"
+};
+function createTerminalThemeProtocolParser() {
+	const decoder = new TextDecoder();
+	let parserState = "text";
+	let oscBuffer = "";
+	const reset = () => {
+		parserState = "text";
+		oscBuffer = "";
+	};
+	const appendOscCharacter = (character) => {
+		if (oscBuffer.length < MAX_OSC_LENGTH) oscBuffer += character;
+	};
+	return {
+		append(chunk) {
+			const update = {
+				colors: {},
+				palette: []
+			};
+			const text = decoder.decode(chunk, { stream: true });
+			for (const character of text) {
+				if (parserState === "escape") {
+					if (character === "]") {
+						parserState = "osc";
+						oscBuffer = "";
+						continue;
+					}
+					parserState = "text";
+					continue;
+				}
+				if (parserState === "osc") {
+					if (character === BEL) {
+						mergeThemeUpdate(update, parseOscThemeUpdate(oscBuffer));
+						parserState = "text";
+						oscBuffer = "";
+						continue;
+					}
+					if (character === ESC) {
+						parserState = "osc_escape";
+						continue;
+					}
+					appendOscCharacter(character);
+					continue;
+				}
+				if (parserState === "osc_escape") {
+					if (character === "\\") {
+						mergeThemeUpdate(update, parseOscThemeUpdate(oscBuffer));
+						parserState = "text";
+						oscBuffer = "";
+						continue;
+					}
+					appendOscCharacter(ESC);
+					appendOscCharacter(character);
+					parserState = "osc";
+					continue;
+				}
+				if (character === ESC) parserState = "escape";
+			}
+			return hasThemeUpdate(update) ? update : null;
+		},
+		reset
+	};
+}
+function resolveTerminalThemeQueryResponse(chunk, options) {
+	const text = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+	let response = "";
+	for (const payload of collectOscPayloads(text)) {
+		const parts = payload.split(";");
+		const command = parts[0];
+		if ((command === "10" || command === "11" || command === "12") && parts.slice(1).join(";").trim() === "?") {
+			const slot = resolveColorSlot(command);
+			const color = resolveThemeColor(options.root, slot, options.theme);
+			response += `${ESC}]${command};${toTerminalRgbColor(color)}${ESC}\\`;
+		}
+	}
+	return response.length > 0 ? response : null;
+}
+function parseOscThemeUpdate(payload) {
+	const parts = payload.split(";");
+	const command = parts[0];
+	if (!command) return null;
+	if (command === "10" || command === "11" || command === "12") {
+		const color = normalizeTerminalColor(parts.slice(1).join(";"));
+		if (!color) return null;
+		const slot = resolveColorSlot(command);
+		const update = {
+			colors: { [slot]: color },
+			palette: []
+		};
+		if (slot === "background") update.theme = inferThemeFromBackground(color);
+		return update;
+	}
+	if (command === "4") return parsePaletteUpdate(parts.slice(1));
+	return null;
+}
+function parsePaletteUpdate(parts) {
+	const palette = [];
+	for (let index = 0; index + 1 < parts.length; index += 2) {
+		const colorIndex = Number.parseInt(parts[index] ?? "", 10);
+		const color = normalizeTerminalColor(parts[index + 1] ?? "");
+		if (!Number.isInteger(colorIndex) || colorIndex < 0 || colorIndex > 15 || !color) continue;
+		palette.push({
+			color,
+			index: colorIndex
+		});
+	}
+	if (palette.length === 0) return null;
+	return {
+		colors: {},
+		palette
+	};
+}
+function normalizeTerminalColor(value) {
+	const color = value.trim();
+	if (color.length === 0 || color === "?") return null;
+	const rgb = parseTerminalRgbColor(color);
+	if (rgb) return `rgb(${rgb.red}, ${rgb.green}, ${rgb.blue})`;
+	const cssRgb = parseCssRgbColor(color);
+	if (cssRgb) return `rgb(${cssRgb.red}, ${cssRgb.green}, ${cssRgb.blue})`;
+	if (/^#[0-9a-fA-F]{6}$/.test(color)) return color.toLowerCase();
+	if (/^#[0-9a-fA-F]{3}$/.test(color)) return expandShortHexColor(color);
+	return null;
+}
+function collectOscPayloads(text) {
+	const payloads = [];
+	let parserState = "text";
+	let oscBuffer = "";
+	const pushPayload = () => {
+		payloads.push(oscBuffer);
+		oscBuffer = "";
+	};
+	for (const character of text) {
+		if (parserState === "escape") {
+			if (character === "]") {
+				parserState = "osc";
+				oscBuffer = "";
+				continue;
+			}
+			parserState = "text";
+			continue;
+		}
+		if (parserState === "osc") {
+			if (character === BEL) {
+				pushPayload();
+				parserState = "text";
+				continue;
+			}
+			if (character === ESC) {
+				parserState = "osc_escape";
+				continue;
+			}
+			if (oscBuffer.length < MAX_OSC_LENGTH) oscBuffer += character;
+			continue;
+		}
+		if (parserState === "osc_escape") {
+			if (character === "\\") {
+				pushPayload();
+				parserState = "text";
+				continue;
+			}
+			if (oscBuffer.length < MAX_OSC_LENGTH) {
+				oscBuffer += ESC;
+				oscBuffer += character;
+			}
+			parserState = "osc";
+			continue;
+		}
+		if (character === ESC) parserState = "escape";
+	}
+	return payloads;
+}
+function resolveThemeColor(root, slot, theme) {
+	const variableName = resolveThemeColorVariable(slot);
+	const computedValue = root.ownerDocument.defaultView?.getComputedStyle(root).getPropertyValue(variableName).trim();
+	const normalizedComputed = computedValue ? normalizeTerminalColor(computedValue) : null;
+	if (normalizedComputed) return normalizedComputed;
+	return (theme === "light" ? DEFAULT_LIGHT_THEME_COLORS : DEFAULT_DARK_THEME_COLORS)[slot];
+}
+function resolveThemeColorVariable(slot) {
+	if (slot === "background") return "--theme-term-bg";
+	if (slot === "cursor") return "--theme-term-cursor";
+	return "--theme-term-fg";
+}
+function toTerminalRgbColor(color) {
+	const rgb = parseCssRgbColor(color) ?? parseCssHexColor(color) ?? {
+		blue: 255,
+		green: 255,
+		red: 255
+	};
+	return `rgb:${toTerminalRgbChannel(rgb.red)}/${toTerminalRgbChannel(rgb.green)}/${toTerminalRgbChannel(rgb.blue)}`;
+}
+function toTerminalRgbChannel(value) {
+	return clamp$1(value, 0, 255).toString(16).padStart(2, "0").repeat(2);
+}
+function parseTerminalRgbColor(value) {
+	const match = /^rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})$/.exec(value);
+	if (!match) return null;
+	return {
+		blue: normalizeHexChannel(match[3] ?? ""),
+		green: normalizeHexChannel(match[2] ?? ""),
+		red: normalizeHexChannel(match[1] ?? "")
+	};
+}
+function normalizeHexChannel(value) {
+	if (value.length === 0) return 0;
+	const expanded = value.length === 1 ? `${value}${value}` : value.slice(0, 2);
+	return clamp$1(Number.parseInt(expanded, 16), 0, 255);
+}
+function expandShortHexColor(value) {
+	const [, red = "0", green = "0", blue = "0"] = value;
+	return `#${red}${red}${green}${green}${blue}${blue}`.toLowerCase();
+}
+function resolveColorSlot(command) {
+	if (command === "11") return "background";
+	if (command === "12") return "cursor";
+	return "foreground";
+}
+function inferThemeFromBackground(color) {
+	const rgb = parseCssRgbColor(color) ?? parseCssHexColor(color);
+	if (!rgb) return "dark";
+	return .2126 * toLinearRgb(rgb.red) + .7152 * toLinearRgb(rgb.green) + .0722 * toLinearRgb(rgb.blue) > .45 ? "light" : "dark";
+}
+function parseCssRgbColor(color) {
+	const match = /^rgb\((\d{1,3}), (\d{1,3}), (\d{1,3})\)$/.exec(color);
+	if (!match) return null;
+	return {
+		blue: clamp$1(Number.parseInt(match[3] ?? "", 10), 0, 255),
+		green: clamp$1(Number.parseInt(match[2] ?? "", 10), 0, 255),
+		red: clamp$1(Number.parseInt(match[1] ?? "", 10), 0, 255)
+	};
+}
+function parseCssHexColor(color) {
+	const match = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/.exec(color);
+	if (!match) return null;
+	return {
+		blue: Number.parseInt(match[3] ?? "0", 16),
+		green: Number.parseInt(match[2] ?? "0", 16),
+		red: Number.parseInt(match[1] ?? "0", 16)
+	};
+}
+function toLinearRgb(value) {
+	const channel = clamp$1(value, 0, 255) / 255;
+	return channel <= .03928 ? channel / 12.92 : ((channel + .055) / 1.055) ** 2.4;
+}
+function mergeThemeUpdate(target, source) {
+	if (!source) return;
+	Object.assign(target.colors, source.colors);
+	target.palette.push(...source.palette);
+	target.theme = source.theme ?? target.theme;
+}
+function hasThemeUpdate(update) {
+	return Object.keys(update.colors).length > 0 || update.palette.length > 0 || Boolean(update.theme);
+}
+function clamp$1(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+//#endregion
+//#region src/frontend/terminal-app.ts
+const SUPERSEDED_CLOSE_CODE = 4001;
+const DEFAULT_MAX_BYTES_PER_FRAME = 32 * 1024;
+const DEFAULT_TRANSCRIPT_SCROLLBACK_LIMIT = 1e3;
+const DEFAULT_RECONNECT_DELAY_MS = 250;
+const SCREEN_REDRAW_ARCHIVE_SUPPRESS_MS = 500;
+const TERMINAL_THEME_PROTOCOL_VARIABLES = [
+	"--theme-term-bg",
+	"--theme-term-cursor",
+	"--theme-term-fg",
+	...Array.from({ length: 16 }, (_, index) => `--theme-term-color-${index}`)
+];
+/**
+* Batches raw PTY bytes into animation frames without splitting UTF-8 codepoints or
+* incomplete ANSI sequences. This is the only throttling layer in the browser path.
+*/
+function createBufferedTerminalWriter(target, scheduler = {}, options = {}) {
+	const requestFrame = scheduler.requestFrame ?? ((callback) => requestBrowserFrame(callback));
+	const cancelFrame = scheduler.cancelFrame ?? ((handle) => cancelBrowserFrame(handle));
+	const maxBytesPerFrame = Math.max(1, options.maxBytesPerFrame ?? DEFAULT_MAX_BYTES_PER_FRAME);
+	let chunks = [];
+	let frameHandle = null;
+	let headOffset = 0;
+	const getPendingBytes = () => {
+		if (chunks.length === 0) return new Uint8Array(0);
+		if (chunks.length === 1) return headOffset === 0 ? chunks[0] : chunks[0].subarray(headOffset);
+		return concatChunks([chunks[0].subarray(headOffset), ...chunks.slice(1)]);
+	};
+	const consumePendingBytes = (byteCount) => {
+		let remainingBytes = byteCount;
+		while (chunks.length > 0 && remainingBytes > 0) {
+			const availableBytes = chunks[0].length - headOffset;
+			if (availableBytes <= remainingBytes) {
+				chunks.shift();
+				headOffset = 0;
+				remainingBytes -= availableBytes;
+				continue;
+			}
+			headOffset += remainingBytes;
+			remainingBytes = 0;
+		}
+	};
+	const isUtf8ContinuationByte = (value) => (value & 192) === 128;
+	const isUtf8LeadByte = (value) => (value & 128) !== 0 && !isUtf8ContinuationByte(value);
+	const resolveUtf8SafeBoundary = (bytes, preferredEnd) => {
+		if (preferredEnd <= 0 || preferredEnd >= bytes.length) return preferredEnd;
+		let index = preferredEnd;
+		while (index > 0 && isUtf8ContinuationByte(bytes[index])) index -= 1;
+		if (index < preferredEnd && isUtf8LeadByte(bytes[index])) return index;
+		return preferredEnd;
+	};
+	const resolveAnsiSafeBoundary = (bytes, preferredEnd) => {
+		if (preferredEnd <= 0 || preferredEnd >= bytes.length) return preferredEnd;
+		let lastEscapeIndex = -1;
+		for (let index = 0; index < preferredEnd; index += 1) if (bytes[index] === 27) lastEscapeIndex = index;
+		if (lastEscapeIndex < 0) return preferredEnd;
+		let index = lastEscapeIndex + 1;
+		if (index >= preferredEnd) return lastEscapeIndex;
+		const nextByte = bytes[index];
+		if (nextByte === 91) {
+			index += 1;
+			while (index < preferredEnd) {
+				const value = bytes[index];
+				if (value >= 64 && value <= 126) return preferredEnd;
+				index += 1;
+			}
+			return lastEscapeIndex;
+		}
+		if (nextByte === 93) {
+			index += 1;
+			while (index < preferredEnd) {
+				const value = bytes[index];
+				if (value === 7) return preferredEnd;
+				if (value === 27 && index + 1 < preferredEnd && bytes[index + 1] === 92) return preferredEnd;
+				index += 1;
+			}
+			return lastEscapeIndex;
+		}
+		return preferredEnd;
+	};
+	const resolveTrailingAnsiCarryLength = (bytes) => {
+		let lastEscapeIndex = -1;
+		for (let index = 0; index < bytes.length; index += 1) if (bytes[index] === 27) lastEscapeIndex = index;
+		if (lastEscapeIndex < 0 || lastEscapeIndex >= bytes.length - 1) return lastEscapeIndex < 0 ? 0 : bytes.length - lastEscapeIndex;
+		const nextByte = bytes[lastEscapeIndex + 1];
+		if (nextByte === 91) {
+			for (let index = lastEscapeIndex + 2; index < bytes.length; index += 1) {
+				const value = bytes[index];
+				if (value >= 64 && value <= 126) return 0;
+			}
+			return bytes.length - lastEscapeIndex;
+		}
+		if (nextByte === 93) {
+			for (let index = lastEscapeIndex + 2; index < bytes.length; index += 1) {
+				const value = bytes[index];
+				if (value === 7) return 0;
+				if (value === 27 && index + 1 < bytes.length && bytes[index + 1] === 92) return 0;
+			}
+			return bytes.length - lastEscapeIndex;
+		}
+		return 0;
+	};
+	const resolveSafeSplitBoundary = (bytes, preferredEnd) => {
+		let boundary = resolveUtf8SafeBoundary(bytes, preferredEnd);
+		boundary = resolveAnsiSafeBoundary(bytes, boundary);
+		return boundary > 0 ? boundary : preferredEnd;
+	};
+	const flush = () => {
+		frameHandle = null;
+		if (chunks.length === 0) return;
+		const pendingBytes = getPendingBytes();
+		if (pendingBytes.length === 0) {
+			chunks = [];
+			headOffset = 0;
+			return;
+		}
+		const preferredEnd = Math.min(maxBytesPerFrame, pendingBytes.length);
+		const safeEnd = resolveSafeSplitBoundary(pendingBytes, preferredEnd);
+		const trailingAnsiCarryLength = preferredEnd === pendingBytes.length ? resolveTrailingAnsiCarryLength(pendingBytes) : 0;
+		const payloadByteCount = trailingAnsiCarryLength > 0 ? Math.max(0, safeEnd - trailingAnsiCarryLength) : safeEnd > 0 ? safeEnd : preferredEnd;
+		if (payloadByteCount <= 0) {
+			frameHandle = requestFrame(() => {
+				flush();
+			});
+			return;
+		}
+		const payload = pendingBytes.subarray(0, payloadByteCount);
+		target.write(payload);
+		consumePendingBytes(payloadByteCount);
+		if (chunks.length > 0) frameHandle = requestFrame(() => {
+			flush();
+		});
+	};
+	return {
+		destroy() {
+			if (frameHandle !== null) {
+				cancelFrame(frameHandle);
+				frameHandle = null;
+			}
+			chunks = [];
+			headOffset = 0;
+		},
+		discardPending() {
+			if (frameHandle !== null) {
+				cancelFrame(frameHandle);
+				frameHandle = null;
+			}
+			chunks = [];
+			headOffset = 0;
+		},
+		enqueue(chunk) {
+			if (chunk.length === 0) return;
+			chunks.push(chunk);
+			if (frameHandle === null) frameHandle = requestFrame(() => {
+				flush();
+			});
+		}
+	};
+}
+async function mountTerminalApp(doc = document, dependencies = {}) {
+	const elements = dependencies.elements ?? {};
+	const shell = elements.shell ?? getRequiredElement(doc, "[data-shell]");
+	const status = hasElementOverride(elements, "status") ? elements.status ?? null : getOptionalElement(doc, "[data-terminal-status]");
+	const loading = hasElementOverride(elements, "loading") ? elements.loading ?? null : getOptionalElement(doc, "[data-terminal-loading]");
+	const terminalRoot = elements.terminalRoot ?? getRequiredElement(doc, "[data-terminal-root]");
+	terminalRoot.classList.add("aitty-terminal-root");
+	const windowObject = doc.defaultView ?? window;
+	const sessionUrl = resolveAittySessionUrl(windowObject, dependencies.src);
+	const themeController = createTerminalThemeController(doc, shell, terminalRoot, dependencies.theme);
+	const resolvedRuntimeKind = (dependencies.resolveRuntimeKind ?? ((resolverDoc, resolverShell) => resolveShellRuntimeKind(resolverDoc, resolverShell, sessionUrl)))(doc, shell);
+	const runtimeKind = typeof resolvedRuntimeKind === "string" ? resolvedRuntimeKind : await resolvedRuntimeKind;
+	shell.dataset.runtime = runtimeKind;
+	shell.dataset.terminalPipeline = "raw";
+	terminalRoot.dataset.terminalPipeline = "raw";
+	const frameScheduler = dependencies.frameScheduler ?? {};
+	const requestFrame = frameScheduler.requestFrame ?? ((callback) => windowObject.requestAnimationFrame(callback));
+	const cancelFrame = frameScheduler.cancelFrame ?? ((handle) => windowObject.cancelAnimationFrame(handle));
+	const reconnectDelayMs = Math.max(0, dependencies.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS);
+	const getScrollSurface = () => resolveScrollSurface(doc, terminalRoot, dependencies.scroll);
+	const encoder = new TextEncoder();
+	const ansiStyleTracker = createAnsiStyleTracker();
+	const themeProtocolParser = createTerminalThemeProtocolParser();
+	let transport = null;
+	let term = null;
+	let transcriptArchive = null;
+	let writer = null;
+	let archiveWriter = null;
+	let sessionState = "running";
+	let destroyed = false;
+	let helloReceived = false;
+	let outputReady = false;
+	let reconnecting = false;
+	let termReady = false;
+	let snapScrollbackOnNextWrite = false;
+	let followLiveOutput = false;
+	const pendingFrames = [];
+	const pendingInputFrames = [];
+	let reconnectHandle = null;
+	let scrollbackSnapHandle = null;
+	let scrollbackSnapPassesRemaining = 0;
+	let disposeViewportSizer = null;
+	let disposeScrollMetricsObserver = null;
+	let lastResizeSignature = null;
+	let lastScrollMetrics = null;
+	let suppressTermResizeCallback = false;
+	let statusSnapshot = {
+		connection: normalizeConnectionState(shell.dataset.connection),
+		loading: {
+			message: loading?.textContent ?? "Booting terminal...",
+			visible: loading ? !loading.hidden : false
+		},
+		message: status?.textContent ?? "Connecting to local session...",
+		output: normalizeOutputState(shell.dataset.output),
+		sessionState: normalizeSessionPresentationState(shell.dataset.sessionState)
+	};
+	const getStatusSnapshot = () => cloneTerminalStatusSnapshot(statusSnapshot);
+	const publishScrollMetrics = () => {
+		const onMetricsChange = dependencies.scroll?.onMetricsChange;
+		if (!onMetricsChange) return;
+		const nextMetrics = getScrollMetrics(getScrollSurface());
+		if (lastScrollMetrics && areScrollMetricsEqual(lastScrollMetrics, nextMetrics)) return;
+		lastScrollMetrics = nextMetrics;
+		onMetricsChange({ ...nextMetrics });
+	};
+	const presentStatus = (patch) => {
+		const nextStatus = {
+			...statusSnapshot,
+			...patch,
+			loading: {
+				...statusSnapshot.loading,
+				...patch.loading
+			}
+		};
+		const changed = !areTerminalStatusSnapshotsEqual(statusSnapshot, nextStatus);
+		statusSnapshot = nextStatus;
+		shell.dataset.connection = nextStatus.connection;
+		shell.dataset.output = nextStatus.output;
+		shell.dataset.sessionState = nextStatus.sessionState;
+		if (status) status.textContent = nextStatus.message;
+		if (loading) {
+			loading.textContent = nextStatus.loading.visible ? nextStatus.loading.message : "";
+			loading.hidden = !nextStatus.loading.visible;
+		}
+		if (changed) dependencies.onStatusChange?.(getStatusSnapshot());
+	};
+	dependencies.onStatusChange?.(getStatusSnapshot());
+	const syncTerminalPresentation = () => {
+		if (!transcriptArchive) return;
+		syncTerminalSurface(terminalRoot, transcriptArchive, term, ansiStyleTracker, { interactive: sessionState === "running" });
+		syncTrailingTerminalBlankRows(terminalRoot);
+		requestScrollUiUpdate(dependencies.scroll);
+		publishScrollMetrics();
+	};
+	const markLiveSession = () => {
+		reconnecting = false;
+		presentStatus({
+			connection: "open",
+			loading: {
+				message: "Booting terminal...",
+				visible: false
+			},
+			message: "Live shell on loopback",
+			output: "ready",
+			sessionState: "live"
+		});
+	};
+	const markWaitingForOutput = () => {
+		presentStatus({
+			connection: "open",
+			loading: {
+				message: "Booting terminal...",
+				visible: !outputReady
+			},
+			message: outputReady ? "Live shell on loopback" : "Connected. Waiting for shell output...",
+			sessionState: outputReady ? "live" : "starting"
+		});
+	};
+	const markOutputReady = () => {
+		if (outputReady) return false;
+		outputReady = true;
+		markLiveSession();
+		return true;
+	};
+	const cancelScrollbackSnap = () => {
+		if (scrollbackSnapHandle === null) {
+			scrollbackSnapPassesRemaining = 0;
+			return;
+		}
+		cancelFrame(scrollbackSnapHandle);
+		scrollbackSnapHandle = null;
+		scrollbackSnapPassesRemaining = 0;
+	};
+	const cancelReconnect = () => {
+		if (reconnectHandle === null) return;
+		clearTimeout(reconnectHandle);
+		reconnectHandle = null;
+	};
+	const getTargetScrollTop = (scrollSurface, { preferTranscriptFollow = false } = {}) => {
+		return getScrollbackMax(scrollSurface);
+	};
+	const scheduleScrollbackSnapToBottom = (passes = 1, options = {}) => {
+		scrollbackSnapPassesRemaining = Math.max(scrollbackSnapPassesRemaining, passes);
+		if (scrollbackSnapHandle !== null) return;
+		const runSnap = () => {
+			scrollbackSnapHandle = requestFrame(() => {
+				scrollbackSnapHandle = null;
+				const scrollSurface = getScrollSurface();
+				scrollSurface.scrollTop = getTargetScrollTop(scrollSurface, options);
+				requestScrollUiUpdate(dependencies.scroll);
+				publishScrollMetrics();
+				scrollbackSnapPassesRemaining = Math.max(0, scrollbackSnapPassesRemaining - 1);
+				if (scrollbackSnapPassesRemaining > 0) runSnap();
+			});
+		};
+		runSnap();
+	};
+	const syncLiveOutputFollowScroll = () => {
+		if (!followLiveOutput) return;
+		scheduleScrollbackSnapToBottom(2, { preferTranscriptFollow: true });
+	};
+	const syncPreservedArchiveVisibility = ({ allowReveal = false, scrollTop = getScrollSurface().scrollTop, maxScrollTop = getScrollbackMax(getScrollSurface()) } = {}) => {
+		if (!transcriptArchive) return;
+		if (isAtScrollbackBottom(scrollTop, maxScrollTop)) {
+			transcriptArchive.concealPreservedArchive();
+			return;
+		}
+		if (allowReveal) transcriptArchive.revealPreservedArchive();
+	};
+	const disposeHotkeys = installScrollbackInteractions(terminalRoot, {
+		getScrollSurface,
+		setScrollTop(scrollSurface, scrollTop) {
+			scrollSurface.scrollTop = scrollTop;
+			requestScrollUiUpdate(dependencies.scroll);
+			publishScrollMetrics();
+		},
+		onInput({ event }) {
+			const preserveVisiblePrompt = shouldPreserveVisiblePromptOnInput(event) && isLiveInputSurfaceVisible(shell, terminalRoot, windowObject);
+			const shouldFollowLiveOutput = shouldFollowLiveOutputOnInput(event);
+			snapScrollbackOnNextWrite = !preserveVisiblePrompt;
+			followLiveOutput = shouldFollowLiveOutput;
+			cancelScrollbackSnap();
+			if (!preserveVisiblePrompt) {
+				const scrollSurface = getScrollSurface();
+				scrollSurface.scrollTop = getTargetScrollTop(scrollSurface);
+				requestScrollUiUpdate(dependencies.scroll);
+				publishScrollMetrics();
+			}
+			syncPreservedArchiveVisibility();
+		},
+		onManualScroll({ scrollTop, maxScrollTop }) {
+			syncPreservedArchiveVisibility({
+				allowReveal: true,
+				scrollTop,
+				maxScrollTop
+			});
+			snapScrollbackOnNextWrite = false;
+			followLiveOutput = false;
+			cancelScrollbackSnap();
+			requestScrollUiUpdate(dependencies.scroll);
+			publishScrollMetrics();
+		}
+	});
+	const resetTerminalBuffer = () => {
+		if (!term) return;
+		writer?.discardPending();
+		archiveWriter?.discardPending();
+		transcriptArchive?.preserveSnapshot([]);
+		ansiStyleTracker.reset(term.cols, term.rows);
+		if (term.bridge && typeof term.bridge.init === "function") {
+			term.bridge.init(term.cols, term.rows);
+			term.renderer?.setup?.(term.cols, term.rows);
+			term.renderer?.render?.(term.bridge);
+			ansiStyleTracker.syncFromBridge(term.bridge);
+			syncTerminalPresentation();
+			return;
+		}
+		term.write?.(encoder.encode("\x1Bc"));
+		syncTerminalPresentation();
+	};
+	const flushPendingInput = () => {
+		if (!helloReceived || sessionState !== "running" || pendingInputFrames.length === 0) return;
+		for (const chunk of pendingInputFrames.splice(0)) transport?.send(chunk);
+	};
+	const processVisiblePayload = (data) => {
+		const firstOutput = markOutputReady();
+		const themeUpdate = themeProtocolParser.append(data);
+		let themeChanged = false;
+		if (themeUpdate) themeChanged = themeController.syncProtocolUpdate(themeUpdate);
+		const themeQueryResponse = resolveTerminalThemeQueryResponse(data, {
+			root: terminalRoot,
+			theme: themeController.getTheme()
+		});
+		if (themeQueryResponse) sendInputToPty(themeQueryResponse);
+		if (!termReady || !writer || !archiveWriter) {
+			pendingFrames.push(data);
+			if (themeChanged) renderTerminalNow(term, { force: true });
+			return;
+		}
+		writer.enqueue(data);
+		archiveWriter.enqueue(data);
+		if (themeChanged) renderTerminalNow(term, { force: true });
+		syncTerminalPresentation();
+		if (followLiveOutput) {
+			snapScrollbackOnNextWrite = false;
+			syncLiveOutputFollowScroll();
+		} else if (snapScrollbackOnNextWrite || firstOutput) {
+			snapScrollbackOnNextWrite = false;
+			scheduleScrollbackSnapToBottom(2);
+		}
+	};
+	const sendInputToPty = (data) => {
+		if (sessionState !== "running") return;
+		if (!helloReceived) {
+			pendingInputFrames.push(data);
+			return;
+		}
+		transport?.send(data);
+	};
+	const sendUserInput = (data) => {
+		sendInputToPty(data);
+	};
+	const emitResize = (cols, rows) => {
+		const normalizedCols = normalizeResizeDimension(cols, term?.cols ?? 80);
+		const normalizedRows = normalizeResizeDimension(rows, term?.rows ?? 24);
+		ansiStyleTracker.resize(normalizedCols, normalizedRows);
+		syncDimensions(terminalRoot, normalizedCols, normalizedRows);
+		transcriptArchive?.refresh();
+		syncTerminalPresentation();
+		const signature = `${normalizedCols}x${normalizedRows}`;
+		if (lastResizeSignature === signature) return;
+		lastResizeSignature = signature;
+		if (sessionState !== "running") return;
+		transport?.sendControl?.(createResizeControlFrame(normalizedCols, normalizedRows));
+	};
+	const syncTermDimensionsFromBridge = (requestedCols = term?.cols ?? 80, requestedRows = term?.rows ?? 24) => {
+		if (!term) return {
+			cols: normalizeResizeDimension(requestedCols, 80),
+			rows: normalizeResizeDimension(requestedRows, 24)
+		};
+		const dimensions = resolveTerminalBridgeDimensions(term, requestedCols, requestedRows);
+		term.cols = dimensions.cols;
+		term.rows = dimensions.rows;
+		if (term.renderer && typeof term.renderer.setup === "function" && (term.renderer.cols !== dimensions.cols || term.renderer.rows !== dimensions.rows)) term.renderer.setup(dimensions.cols, dimensions.rows);
+		return dimensions;
+	};
+	const resizeTerminalTo = (cols, rows) => {
+		if (!term) return;
+		const requestedCols = normalizeResizeDimension(cols, term.cols);
+		const requestedRows = normalizeResizeDimension(rows, term.rows);
+		if (term.cols !== requestedCols || term.rows !== requestedRows) {
+			suppressTermResizeCallback = true;
+			try {
+				term.resize(requestedCols, requestedRows);
+			} finally {
+				suppressTermResizeCallback = false;
+			}
+		}
+		const actual = syncTermDimensionsFromBridge(requestedCols, requestedRows);
+		applyTerminalElementHeight(terminalRoot, actual.rows);
+		emitResize(actual.cols, actual.rows);
+	};
+	const handleTermResize = (cols, rows) => {
+		if (suppressTermResizeCallback) return;
+		const actual = syncTermDimensionsFromBridge(cols, rows);
+		emitResize(actual.cols, actual.rows);
+	};
+	const showReconnectState = (statusText) => {
+		reconnecting = true;
+		helloReceived = false;
+		presentStatus({
+			connection: "reconnecting",
+			loading: {
+				message: "Reconnecting...",
+				visible: true
+			},
+			message: statusText,
+			sessionState: outputReady ? "reconnecting" : "starting"
+		});
+	};
+	const scheduleReconnect = () => {
+		if (destroyed || reconnectHandle !== null || sessionState !== "running") return;
+		showReconnectState("Connection lost. Reconnecting...");
+		reconnectHandle = setTimeout(() => {
+			reconnectHandle = null;
+			if (destroyed || sessionState !== "running") return;
+			transport?.connect();
+		}, reconnectDelayMs);
+	};
+	const handleBrowserOffline = () => {
+		if (destroyed || sessionState !== "running" || reconnecting) return;
+		showReconnectState("Connection interrupted. Reconnecting...");
+		syncTerminalPresentation();
+		transport?.disconnect?.("offline");
+	};
+	const handleBrowserOnline = () => {
+		if (destroyed || sessionState !== "running" || !reconnecting) return;
+		cancelReconnect();
+		transport?.connect();
+	};
+	term = (dependencies.createTerm ?? ((element, options) => new WTerm(element, options)))(terminalRoot, {
+		autoResize: false,
+		cursorBlink: true,
+		onData(data) {
+			sendUserInput(data);
+		},
+		onResize(cols, rows) {
+			handleTermResize(cols, rows);
+		},
+		onTitle(title) {
+			if (title) doc.title = `${title} - aitty`;
+		}
+	});
+	terminalRoot._aittyTerm = term;
+	transcriptArchive = createTranscriptArchive(terminalRoot, frameScheduler, {
+		getCols() {
+			return term?.cols ?? 80;
+		},
+		getVisibleRows() {
+			return term?.rows ?? 24;
+		},
+		scrollbackLimit: dependencies.transcriptArchiveOptions?.scrollbackLimit
+	});
+	archiveWriter = createBufferedTerminalWriter({ write(data) {
+		transcriptArchive?.append(data);
+	} }, frameScheduler);
+	writer = createBufferedTerminalWriter({ write(data) {
+		ansiStyleTracker.append(data);
+		term?.write?.(data);
+		ansiStyleTracker.syncFromBridge(term?.bridge);
+		const renderHints = ansiStyleTracker.consumeRenderHints();
+		renderTerminalNow(term, { force: renderHints.clearScreen || renderHints.styleChanged });
+		syncTerminalPresentation();
+	} }, frameScheduler);
+	transport = (dependencies.createTransport ?? ((handlers) => createBrowserTransport(handlers)))({
+		onBinary(data) {
+			if (!helloReceived) helloReceived = true;
+			processVisiblePayload(data);
+			if (reconnecting && outputReady) markLiveSession();
+			flushPendingInput();
+		},
+		onClose(event) {
+			if (destroyed) return;
+			if (sessionState === "running" && event?.code === SUPERSEDED_CLOSE_CODE) {
+				cancelReconnect();
+				reconnecting = false;
+				sessionState = "superseded";
+				presentStatus({
+					connection: "superseded",
+					loading: {
+						message: "Booting terminal...",
+						visible: false
+					},
+					message: "Session was taken over in another tab",
+					sessionState: "superseded"
+				});
+				syncTerminalPresentation();
+				return;
+			}
+			if (sessionState === "running") {
+				scheduleReconnect();
+				syncTerminalPresentation();
+				return;
+			}
+			presentStatus({ connection: sessionState === "error" ? "error" : "closed" });
+			syncTerminalPresentation();
+		},
+		onControlMessage(data) {
+			const message = parseAittyControlFrame(data);
+			if (!message) return;
+			if (message.type === "hello") {
+				helloReceived = true;
+				const replay = decodeHelloReplay(message.replay);
+				if (reconnecting && replay.length > 0) resetTerminalBuffer();
+				if (replay.length > 0) processVisiblePayload(replay);
+				cancelReconnect();
+				if (reconnecting) if (outputReady) markLiveSession();
+				else {
+					reconnecting = false;
+					markWaitingForOutput();
+				}
+				flushPendingInput();
+				return;
+			}
+			if (message.type === "ping") {
+				transport?.sendControl?.(createPongControlFrame());
+				return;
+			}
+			if (message.type === "theme") {
+				let themeChanged = false;
+				if (message.theme === null) {
+					themeChanged = themeController.setTheme(void 0);
+					if (themeChanged) renderTerminalNow(term, { force: true });
+					return;
+				}
+				const theme = normalizeThemeName(message.theme);
+				if (theme) themeChanged = themeController.setTheme(theme);
+				if (themeChanged) renderTerminalNow(term, { force: true });
+				return;
+			}
+			if (message.type !== "exit") return;
+			cancelReconnect();
+			const exitPresentation = resolveExitPresentation(message);
+			sessionState = exitPresentation.sessionState;
+			reconnecting = false;
+			presentStatus({
+				connection: "closed",
+				loading: {
+					message: "Booting terminal...",
+					visible: false
+				},
+				message: exitPresentation.statusText,
+				sessionState: exitPresentation.sessionState
+			});
+			syncTerminalPresentation();
+		},
+		onError(event) {
+			if (destroyed || sessionState !== "running") return;
+			showReconnectState("Connection interrupted. Reconnecting...");
+			syncTerminalPresentation();
+			if (event instanceof ErrorEvent && event.message) event.message;
+		},
+		onOpen() {
+			cancelReconnect();
+			if (reconnecting) {
+				presentStatus({
+					connection: "open",
+					loading: {
+						message: "Reconnecting...",
+						visible: true
+					},
+					message: outputReady ? "Reconnected. Syncing transcript..." : "Connected. Waiting for shell output...",
+					sessionState: outputReady ? "reconnecting" : "starting"
+				});
+				return;
+			}
+			if (!outputReady) {
+				presentStatus({
+					connection: "open",
+					message: "Connected. Waiting for shell output..."
+				});
+				return;
+			}
+			presentStatus({ connection: "open" });
+		}
+	});
+	await term.init();
+	replaceTerminalInputHandler(term);
+	const disposeInputPolicies = installTerminalInputPolicies(term, {
+		captureDocumentCtrlN: false,
+		onData(data) {
+			sendUserInput(data);
+		},
+		resolveKey: dependencies.input?.resolveKey
+	});
+	installBrowserRenderer(term, ansiStyleTracker);
+	termReady = true;
+	const initialSize = syncTermDimensionsFromBridge(term.cols, term.rows);
+	ansiStyleTracker.reset(initialSize.cols, initialSize.rows);
+	disposeViewportSizer = installTerminalViewportSizer(term, terminalRoot, windowObject, resizeTerminalTo);
+	syncTermDimensionsFromBridge(term.cols, term.rows);
+	emitResize(term.cols, term.rows);
+	syncTerminalPresentation();
+	term.focus();
+	disposeScrollMetricsObserver = installScrollMetricsObserver(getScrollSurface(), publishScrollMetrics);
+	publishScrollMetrics();
+	windowObject.addEventListener("offline", handleBrowserOffline);
+	windowObject.addEventListener("online", handleBrowserOnline);
+	transport.connect(toWebSocketUrl(sessionUrl));
+	for (const frame of pendingFrames.splice(0)) writer.enqueue(frame);
+	return {
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			delete terminalRoot._aittyTerm;
+			cancelScrollbackSnap();
+			cancelReconnect();
+			disposeViewportSizer?.();
+			disposeViewportSizer = null;
+			disposeScrollMetricsObserver?.();
+			disposeScrollMetricsObserver = null;
+			archiveWriter?.destroy();
+			transcriptArchive?.destroy();
+			writer?.destroy();
+			disposeHotkeys();
+			disposeInputPolicies();
+			themeController.destroy();
+			windowObject.removeEventListener("offline", handleBrowserOffline);
+			windowObject.removeEventListener("online", handleBrowserOnline);
+			transport?.close();
+			term?.destroy();
+		},
+		getStatus: getStatusSnapshot,
+		getTheme: themeController.getTheme,
+		setTheme: themeController.setTheme,
+		term,
+		transport
+	};
+}
+function mountAitty(containerOrOptions = {}, maybeOptions = {}) {
+	if (typeof containerOrOptions === "string" || isElementLike(containerOrOptions)) return mountAittyInContainer(containerOrOptions, maybeOptions);
+	return mountAittyWithElements(containerOrOptions);
+}
+function mountAittyWithElements(options = {}) {
+	const { document: doc = document, loading, shell, status, terminalRoot, ...dependencies } = options;
+	const elements = { ...dependencies.elements };
+	if ("loading" in options) elements.loading = loading;
+	if (shell) elements.shell = shell;
+	if ("status" in options) elements.status = status;
+	if (terminalRoot) elements.terminalRoot = terminalRoot;
+	return mountTerminalApp(doc, {
+		...dependencies,
+		elements
+	});
+}
+const AITTY_TERMINAL_TAG_NAME = "aitty-terminal";
+function defineAittyTerminalElement(registry = globalThis.customElements) {
+	if (!registry || registry.get(AITTY_TERMINAL_TAG_NAME) || typeof HTMLElement === "undefined") return;
+	registry.define(AITTY_TERMINAL_TAG_NAME, createAittyTerminalElementConstructor());
+}
+function createAittyTerminalElementConstructor() {
+	return class AittyTerminalCustomElement extends HTMLElement {
+		static get observedAttributes() {
+			return ["src", "theme"];
+		}
+		#mounted = null;
+		#mountVersion = 0;
+		connectedCallback() {
+			this.#mount();
+		}
+		disconnectedCallback() {
+			this.#destroyMounted();
+		}
+		attributeChangedCallback(name, oldValue, nextValue) {
+			if (oldValue === nextValue || !this.isConnected) return;
+			if (name === "theme" && this.#mounted) {
+				this.#mounted.setTheme(normalizeThemeName(nextValue ?? void 0));
+				return;
+			}
+			this.#mount();
+		}
+		#destroyMounted() {
+			this.#mountVersion += 1;
+			this.#mounted?.destroy();
+			this.#mounted = null;
+		}
+		async #mount() {
+			this.#destroyMounted();
+			const mountVersion = this.#mountVersion;
+			try {
+				const mounted = await mountAitty(this, {
+					document: this.ownerDocument,
+					onStatusChange: (status) => {
+						this.dispatchEvent(new CustomEvent("aitty:status", {
+							bubbles: true,
+							composed: true,
+							detail: status
+						}));
+					},
+					src: this.getAttribute("src") ?? void 0,
+					theme: normalizeThemeName(this.getAttribute("theme") ?? void 0)
+				});
+				if (!this.isConnected || this.#mountVersion !== mountVersion) {
+					mounted.destroy();
+					return;
+				}
+				this.#mounted = mounted;
+				this.dispatchEvent(new CustomEvent("aitty:mount", {
+					bubbles: true,
+					composed: true,
+					detail: mounted
+				}));
+			} catch (error) {
+				this.dispatchEvent(new CustomEvent("aitty:error", {
+					bubbles: true,
+					composed: true,
+					detail: error
+				}));
+			}
+		}
+	};
+}
+async function mountAittyInContainer(container, options) {
+	const { scrollAdapter, ...dependencies } = options;
+	const doc = dependencies.document ?? resolveAittyDocument(container);
+	const mount = resolveAittyMountContainer(doc, container);
+	const view = createAittyEmbedView(doc, mount);
+	const scrollOptions = {
+		...dependencies.scroll,
+		viewport: view.viewport
+	};
+	const adapter = scrollAdapter?.({
+		content: view.content,
+		scrollOptions,
+		target: view.scrollTarget,
+		viewport: view.viewport
+	});
+	Object.assign(scrollOptions, adapter?.scrollOptions);
+	const mounted = await mountTerminalApp(doc, {
+		...dependencies,
+		scroll: scrollOptions,
+		elements: {
+			shell: view.shell,
+			terminalRoot: view.terminalRoot
+		}
+	});
+	let destroyed = false;
+	return {
+		...mounted,
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			mounted.destroy();
+			adapter?.destroy?.();
+			view.shell.remove();
+			mount.classList.remove("aitty-embed");
+		}
+	};
+}
+function resolveAittyDocument(container) {
+	if (isElementLike(container)) return container.ownerDocument;
+	if (typeof document !== "undefined") return document;
+	throw new Error("mountAitty requires a browser document when mounting by selector");
+}
+function resolveAittyMountContainer(doc, container) {
+	if (isDocumentElement(doc, container)) return container;
+	if (isElementLike(container)) throw new Error("aitty mount container belongs to a different document");
+	const element = doc.querySelector(container);
+	if (!(element instanceof HTMLElement)) throw new Error(`Missing aitty mount container: ${container}`);
+	return element;
+}
+function isElementLike(value) {
+	return typeof value === "object" && value !== null && "nodeType" in value && "ownerDocument" in value;
+}
+function isDocumentElement(doc, value) {
+	const HTMLElementConstructor = doc.defaultView?.HTMLElement;
+	return Boolean(HTMLElementConstructor && value instanceof HTMLElementConstructor);
+}
+function createAittyEmbedView(doc, mount) {
+	mount.replaceChildren();
+	mount.classList.add("aitty-embed");
+	const shell = doc.createElement("div");
+	shell.className = "aitty-shell";
+	shell.dataset.shell = "";
+	shell.dataset.runtime = "session";
+	shell.dataset.connection = "connecting";
+	shell.dataset.output = "pending";
+	shell.dataset.sessionState = "starting";
+	const scrollTarget = doc.createElement("div");
+	scrollTarget.className = "aitty-scroll-target";
+	scrollTarget.dataset.aittyScrollTarget = "";
+	const viewport = doc.createElement("div");
+	viewport.className = "aitty-scroll-viewport";
+	viewport.dataset.aittyScrollViewport = "";
+	viewport.tabIndex = -1;
+	const content = doc.createElement("div");
+	content.className = "aitty-scroll-content";
+	content.dataset.aittyScrollContent = "";
+	const terminalRoot = doc.createElement("div");
+	terminalRoot.className = "aitty-terminal-root terminal-root";
+	terminalRoot.dataset.terminalRoot = "";
+	terminalRoot.role = "application";
+	terminalRoot.setAttribute("aria-label", "Terminal");
+	content.append(terminalRoot);
+	viewport.append(content);
+	scrollTarget.append(viewport);
+	shell.append(scrollTarget);
+	mount.append(shell);
+	return {
+		content,
+		scrollTarget,
+		shell,
+		terminalRoot,
+		viewport
+	};
+}
+function replaceTerminalInputHandler(term) {
+	const previousInput = term.input;
+	if (typeof previousInput?.destroy !== "function") return;
+	previousInput.destroy();
+	const textarea = term.element.ownerDocument.createElement("textarea");
+	configureTerminalTextarea(textarea);
+	term.element.appendChild(textarea);
+	syncTerminalTextareaPosition(term, textarea);
+	const syncInputPosition = () => {
+		syncTerminalTextareaPosition(term, textarea);
+	};
+	const onFocus = () => {
+		syncInputPosition();
+		term.element.classList.add("focused");
+	};
+	const onBlur = () => {
+		term.element.classList.remove("focused");
+	};
+	textarea.addEventListener("focus", onFocus);
+	textarea.addEventListener("blur", onBlur);
+	textarea.addEventListener("beforeinput", syncInputPosition, true);
+	textarea.addEventListener("compositionstart", syncInputPosition, true);
+	textarea.addEventListener("compositionupdate", syncInputPosition, true);
+	textarea.addEventListener("compositionend", syncInputPosition, true);
+	textarea.addEventListener("input", syncInputPosition, true);
+	textarea.addEventListener("keydown", syncInputPosition, true);
+	term.input = {
+		textarea,
+		focus() {
+			syncInputPosition();
+			textarea.focus({ preventScroll: true });
+		},
+		destroy() {
+			textarea.removeEventListener("focus", onFocus);
+			textarea.removeEventListener("blur", onBlur);
+			textarea.removeEventListener("beforeinput", syncInputPosition, true);
+			textarea.removeEventListener("compositionstart", syncInputPosition, true);
+			textarea.removeEventListener("compositionupdate", syncInputPosition, true);
+			textarea.removeEventListener("compositionend", syncInputPosition, true);
+			textarea.removeEventListener("input", syncInputPosition, true);
+			textarea.removeEventListener("keydown", syncInputPosition, true);
+			term.element.classList.remove("focused");
+			textarea.remove();
+		}
+	};
+}
+function configureTerminalTextarea(textarea) {
+	textarea.setAttribute("autocapitalize", "off");
+	textarea.setAttribute("autocomplete", "off");
+	textarea.setAttribute("autocorrect", "off");
+	textarea.setAttribute("spellcheck", "false");
+	textarea.setAttribute("enterkeyhint", "send");
+	textarea.setAttribute("tabindex", "0");
+	textarea.setAttribute("aria-hidden", "true");
+	const style = textarea.style;
+	style.position = "fixed";
+	style.left = "0";
+	style.top = "0";
+	style.width = "1px";
+	style.height = "1px";
+	style.opacity = "0";
+	style.overflow = "hidden";
+	style.border = "0";
+	style.padding = "0";
+	style.margin = "0";
+	style.outline = "none";
+	style.resize = "none";
+	style.pointerEvents = "none";
+	style.caretColor = "transparent";
+	style.color = "transparent";
+	style.background = "transparent";
+}
+function syncTerminalTextareaPosition(term, textarea) {
+	const viewport = resolveTextareaViewport(textarea);
+	const anchorRect = (resolveLiveInputSurfaceAnchor(term.element) ?? term.element).getBoundingClientRect?.();
+	const fallbackRect = term.element.getBoundingClientRect?.();
+	const rect = hasUsableClientRect(anchorRect) ? anchorRect : fallbackRect;
+	if (!hasUsableClientRect(rect)) {
+		textarea.style.left = "0";
+		textarea.style.top = "0";
+		return;
+	}
+	const left = clamp(rect.left, 0, Math.max(0, viewport.width - 1));
+	const top = clamp(rect.top, 0, Math.max(0, viewport.height - 1));
+	textarea.style.left = `${left}px`;
+	textarea.style.top = `${top}px`;
+}
+function resolveTextareaViewport(textarea) {
+	const view = textarea.ownerDocument.defaultView;
+	const root = textarea.ownerDocument.documentElement;
+	const body = textarea.ownerDocument.body;
+	const width = firstFinitePositiveNumber(view?.innerWidth, root?.clientWidth, body?.clientWidth) ?? 1;
+	return {
+		height: firstFinitePositiveNumber(view?.innerHeight, root?.clientHeight, body?.clientHeight) ?? 1,
+		width
+	};
+}
+function installBrowserRenderer(term, styleTracker) {
+	const container = term?._container;
+	if (!(container instanceof HTMLElement)) return;
+	const renderer = new BrowserTerminalRenderer(container, styleTracker);
+	term.renderer = renderer;
+	renderer.setup(term.cols, term.rows);
+	if (term.bridge) renderer.render(term.bridge);
+}
+function renderTerminalNow(term, options = {}) {
+	const bridge = term?.bridge;
+	const renderer = term?.renderer;
+	if (!bridge || !renderer || typeof renderer.render !== "function") return;
+	renderer.render(bridge, options);
+}
+function installTerminalViewportSizer(term, terminalRoot, windowObject, onResize) {
+	const target = resolveViewportSize(term, terminalRoot, windowObject);
+	applyTerminalElementHeight(terminalRoot, target.rows);
+	onResize(target.cols, target.rows);
+	let frameHandle = null;
+	const scheduleResize = () => {
+		if (frameHandle !== null) return;
+		frameHandle = windowObject.requestAnimationFrame(() => {
+			frameHandle = null;
+			const nextTarget = resolveViewportSize(term, terminalRoot, windowObject);
+			applyTerminalElementHeight(terminalRoot, nextTarget.rows);
+			onResize(nextTarget.cols, nextTarget.rows);
+		});
+	};
+	windowObject.addEventListener("resize", scheduleResize);
+	return () => {
+		if (frameHandle !== null) {
+			windowObject.cancelAnimationFrame(frameHandle);
+			frameHandle = null;
+		}
+		windowObject.removeEventListener("resize", scheduleResize);
+	};
+}
+function resolveViewportSize(term, terminalRoot, windowObject) {
+	const metrics = measureTerminalCell(term, terminalRoot);
+	const viewport = resolveAvailableTerminalViewport(terminalRoot, windowObject);
+	if (!viewport) return {
+		cols: normalizeResizeDimension(term?.cols, 80),
+		rows: normalizeResizeDimension(term?.rows, 24)
+	};
+	return {
+		cols: Math.max(1, Math.floor(viewport.width / metrics.charWidth)),
+		rows: Math.max(1, Math.floor(viewport.height / metrics.rowHeight))
+	};
+}
+function measureTerminalCell(term, terminalRoot) {
+	const measured = typeof term?._measureCharSize === "function" ? term._measureCharSize() : null;
+	if (measured && Number.isFinite(measured.charWidth) && measured.charWidth > 0 && Number.isFinite(measured.rowHeight) && measured.rowHeight > 0) {
+		terminalRoot.style.setProperty("--term-row-height", `${measured.rowHeight}px`);
+		return measured;
+	}
+	const computedStyle = getComputedStyle(terminalRoot);
+	const rowHeight = parseCssPixelValue(computedStyle.getPropertyValue("--term-row-height")) || parseCssPixelValue(computedStyle.lineHeight) || 17;
+	const fontSize = parseCssPixelValue(computedStyle.fontSize) || 15;
+	return {
+		charWidth: Math.max(1, fontSize * .6),
+		rowHeight: Math.max(1, rowHeight)
+	};
+}
+function resolveAvailableTerminalViewport(terminalRoot, windowObject) {
+	const rect = terminalRoot.getBoundingClientRect?.();
+	const width = Number.isFinite(rect?.width) && rect.width > 0 ? rect.width : 0;
+	if (width <= 0 || !Number.isFinite(rect?.top)) return null;
+	const viewportHeight = Math.max(1, windowObject.innerHeight || terminalRoot.ownerDocument?.documentElement?.clientHeight || 24);
+	const top = Math.max(0, rect.top);
+	const paddingBottom = parseCssPixelValue(getComputedStyle(terminalRoot).paddingBottom);
+	const height = viewportHeight - top - paddingBottom;
+	if (!Number.isFinite(height) || height <= 0) return null;
+	return {
+		height,
+		width
+	};
+}
+function applyTerminalElementHeight(terminalRoot, rows) {
+	terminalRoot.style.height = `calc(var(--term-row-height, 17px) * ${Math.max(1, rows)})`;
+}
+function parseCssPixelValue(value) {
+	const parsed = Number.parseFloat(value);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+function normalizeResizeDimension(value, fallback) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : Math.max(1, fallback);
+}
+function resolveTerminalBridgeDimensions(term, requestedCols, requestedRows) {
+	const bridge = term?.bridge ?? null;
+	if (!bridge) return {
+		cols: normalizeResizeDimension(requestedCols, 80),
+		rows: normalizeResizeDimension(requestedRows, 24)
+	};
+	const bridgeCols = typeof bridge.getCols === "function" ? bridge.getCols() : requestedCols;
+	const bridgeRows = typeof bridge.getRows === "function" ? bridge.getRows() : requestedRows;
+	return {
+		cols: normalizeResizeDimension(bridgeCols, requestedCols),
+		rows: normalizeResizeDimension(bridgeRows, requestedRows)
+	};
+}
+function syncTerminalSurface(element, transcriptArchive, term, styleTracker, options = {}) {
+	const interactive = options.interactive ?? true;
+	syncTerminalInteractivity(element, term, interactive);
+	const bridge = term?.bridge ?? null;
+	const resolvedAltScreenState = (bridge ? bridge.usingAltScreen() : transcriptArchive.isAlternateScreenActive()) || styleTracker.isAltScreenActive();
+	transcriptArchive.setAlternateScreenActive?.(resolvedAltScreenState);
+	element.dataset.altScreen = String(resolvedAltScreenState);
+	element.dataset.renderMode = resolvedAltScreenState ? "screen" : "transcript";
+	transcriptArchive.setScreenModeActive?.(resolvedAltScreenState);
+	syncScreenModeScrollbackRows(element, resolvedAltScreenState);
+	if (!bridge) {
+		delete element.dataset.cursorVisible;
+		delete element.dataset.cursorRow;
+		delete element.dataset.cursorCol;
+		return;
+	}
+	const cursor = bridge.getCursor();
+	if (!interactive) {
+		element.dataset.cursorVisible = "false";
+		element.dataset.cursorRow = String(cursor.row + 1);
+		element.dataset.cursorCol = String(cursor.col + 1);
+		return;
+	}
+	element.dataset.cursorVisible = String(cursor.visible);
+	element.dataset.cursorRow = String(cursor.row + 1);
+	element.dataset.cursorCol = String(cursor.col + 1);
+}
+function syncTerminalInteractivity(element, term, interactive) {
+	element.dataset.sessionInteractive = String(interactive);
+	element.setAttribute("aria-disabled", String(!interactive));
+	if (interactive) element.removeAttribute("tabindex");
+	else element.setAttribute("tabindex", "-1");
+	const activeElement = element.ownerDocument?.activeElement;
+	if (!interactive && activeElement instanceof HTMLElement && element.contains(activeElement)) activeElement.blur?.();
+	const textarea = term?.input?.textarea;
+	if (textarea instanceof HTMLTextAreaElement) {
+		textarea.disabled = !interactive;
+		textarea.readOnly = !interactive;
+		textarea.tabIndex = interactive ? 0 : -1;
+		textarea.setAttribute("aria-hidden", String(!interactive));
+		if (!interactive) textarea.blur();
+	}
+	element.querySelectorAll(".term-cursor").forEach((cursor) => {
+		cursor.toggleAttribute("hidden", !interactive);
+		cursor.setAttribute("aria-hidden", String(!interactive));
+	});
+}
+function syncScreenModeScrollbackRows(element, screenModeActive) {
+	element.querySelectorAll(".term-scrollback-row").forEach((row) => {
+		row.toggleAttribute("hidden", screenModeActive);
+		row.setAttribute("aria-hidden", String(screenModeActive));
+	});
+}
+function containsScreenRedrawControl(text) {
+	const escape = String.fromCharCode(27);
+	return new RegExp(`(?:${escape}\\[[?0-9;:]*[ABCDEFGHJKSTf]|${escape}[78c])`).test(text);
+}
+function getMonotonicTime() {
+	return globalThis.performance?.now?.() ?? Date.now();
+}
+function requestBrowserFrame(callback, view) {
+	const requestFrame = view?.requestAnimationFrame ?? globalThis.requestAnimationFrame;
+	if (typeof requestFrame === "function") return requestFrame.call(view ?? globalThis, callback);
+	return setTimeout(() => {
+		callback(getMonotonicTime());
+	}, 0);
+}
+function cancelBrowserFrame(handle, view) {
+	const cancelFrame = view?.cancelAnimationFrame ?? globalThis.cancelAnimationFrame;
+	if (typeof cancelFrame === "function") {
+		cancelFrame.call(view ?? globalThis, handle);
+		return;
+	}
+	clearTimeout(handle);
+}
+function createTranscriptArchive(element, scheduler = {}, options = {}) {
+	const doc = element.ownerDocument ?? document;
+	const view = doc.defaultView;
+	const requestFrame = scheduler.requestFrame ?? ((callback) => requestBrowserFrame(callback, view));
+	const cancelFrame = scheduler.cancelFrame ?? ((handle) => cancelBrowserFrame(handle, view));
+	const getCols = options.getCols ?? (() => 80);
+	const scrollbackLimit = Math.max(0, options.scrollbackLimit ?? DEFAULT_TRANSCRIPT_SCROLLBACK_LIMIT);
+	const getVisibleRows = options.getVisibleRows ?? (() => 24);
+	let decoder = new TextDecoder();
+	const archive = doc.createElement("pre");
+	const archiveText = doc.createTextNode("");
+	archive.setAttribute("data-terminal-transcript-archive", "");
+	archive.className = "term-transcript-archive";
+	archive.append(archiveText);
+	element.insertBefore(archive, element.firstChild);
+	let preservedLines = [];
+	const finalizedLines = [];
+	let currentLine = "";
+	let parserState = "text";
+	let csiParams = "";
+	let csiPrivate = "";
+	let carriageReturnPending = false;
+	let frameHandle = null;
+	let archivedLineCount = 0;
+	let alternateScreenActive = false;
+	let screenModeActive = false;
+	let concealedPreservedArchive = false;
+	let screenRedrawArchiveSuppressedUntil = 0;
+	const setPreservedLines = (lines) => {
+		const normalizedLines = normalizePreservedTranscriptLines(lines);
+		preservedLines = scrollbackLimit > 0 ? normalizedLines.slice(-scrollbackLimit) : [];
+	};
+	const syncArchiveVisibility = () => {
+		const hasArchivedContent = preservedLines.length > 0 || archiveText.data.length > 0;
+		const archiveHidden = alternateScreenActive || screenModeActive;
+		const archiveConcealed = !archiveHidden && concealedPreservedArchive && hasArchivedContent;
+		archive.hidden = archiveHidden;
+		archive.style.visibility = archiveConcealed ? "hidden" : "";
+		archive.setAttribute("aria-hidden", String(archiveHidden || archiveConcealed));
+		element.dataset.archiveConcealed = String(archiveConcealed);
+	};
+	const scheduleSync = () => {
+		if (frameHandle !== null) return;
+		frameHandle = requestFrame(() => {
+			frameHandle = null;
+			syncArchive();
+		});
+	};
+	const reconcilePreservedLines = () => {
+		if (preservedLines.length === 0) return;
+		const nextPreservedLines = trimReconciledPreservedTranscriptLines(preservedLines, [...finalizedLines, currentLine]);
+		if (nextPreservedLines.length === preservedLines.length && nextPreservedLines.every((line, index) => line === preservedLines[index])) return;
+		preservedLines = nextPreservedLines;
+		if (preservedLines.length === 0) concealedPreservedArchive = false;
+	};
+	const syncArchive = () => {
+		reconcilePreservedLines();
+		const liveLineCount = finalizedLines.length + 1;
+		const visibleCapacity = Math.max(1, scrollbackLimit + Math.max(1, getVisibleRows()));
+		const hiddenLineCount = Math.max(0, liveLineCount - visibleCapacity);
+		const archivedStart = Math.max(0, hiddenLineCount - Math.min(hiddenLineCount, scrollbackLimit));
+		const liveArchiveWindow = finalizedLines.slice(archivedStart, hiddenLineCount);
+		const archiveWindow = preservedLines.length > 0 ? [...preservedLines, ...liveArchiveWindow] : liveArchiveWindow;
+		archiveText.data = archiveWindow.length > 0 ? `${archiveWindow.join("\n")}\n` : "";
+		archivedLineCount = archiveWindow.length;
+		syncTranscriptMetadata(element, preservedLines.length + liveLineCount, archivedLineCount);
+		syncArchiveVisibility();
+	};
+	const resetLiveTranscript = () => {
+		finalizedLines.length = 0;
+		currentLine = "";
+		parserState = "text";
+		csiParams = "";
+		csiPrivate = "";
+		carriageReturnPending = false;
+	};
+	const resetParser = () => {
+		resetLiveTranscript();
+		decoder = new TextDecoder();
+	};
+	const setAlternateScreenActive = (nextState) => {
+		if (alternateScreenActive === nextState) return;
+		alternateScreenActive = nextState;
+		syncArchiveVisibility();
+	};
+	const setScreenModeActive = (nextState) => {
+		if (screenModeActive === nextState) return;
+		screenModeActive = nextState;
+		syncArchiveVisibility();
+	};
+	const appendPrintableCharacter = (character) => {
+		const cols = Math.max(1, getCols());
+		if (currentLine.length >= cols) {
+			finalizedLines.push(currentLine);
+			currentLine = "";
+		}
+		currentLine += character;
+	};
+	const handleEraseDisplay = (params) => {
+		if (params.includes(3)) {
+			setPreservedLines([]);
+			concealedPreservedArchive = false;
+			resetParser();
+			return;
+		}
+		if (params.includes(2)) {
+			setPreservedLines([
+				...preservedLines,
+				...finalizedLines,
+				currentLine
+			]);
+			concealedPreservedArchive = preservedLines.length > 0;
+			resetLiveTranscript();
+		}
+	};
+	const processDecodedText = (text, { recordPrintable = true } = {}) => {
+		for (const character of text) {
+			if (parserState === "escape") {
+				if (character === "[") {
+					parserState = "csi";
+					csiParams = "";
+					csiPrivate = "";
+					continue;
+				}
+				if (character === "]") {
+					parserState = "osc";
+					continue;
+				}
+				if (character === "c") resetParser();
+				parserState = "text";
+				continue;
+			}
+			if (parserState === "csi") {
+				if ((character === "?" || character === ">" || character === "!") && csiParams.length === 0) {
+					csiPrivate = character;
+					continue;
+				}
+				if (character >= "0" && character <= "9" || character === ";" || character === ":") {
+					csiParams += character;
+					continue;
+				}
+				if (character >= "@" && character <= "~") {
+					const params = parseCsiParams(csiParams);
+					setAlternateScreenActive(nextAltScreenState(alternateScreenActive, csiPrivate, csiParams, character));
+					if (character === "J") handleEraseDisplay(params);
+					parserState = "text";
+				}
+				continue;
+			}
+			if (parserState === "osc") {
+				if (character === "\x07") {
+					parserState = "text";
+					continue;
+				}
+				if (character === "\x1B") parserState = "osc_escape";
+				continue;
+			}
+			if (parserState === "osc_escape") {
+				parserState = character === "\\" ? "text" : "osc";
+				continue;
+			}
+			if (character === "\x1B") {
+				parserState = "escape";
+				continue;
+			}
+			if (alternateScreenActive) continue;
+			if (!recordPrintable) continue;
+			if (carriageReturnPending) {
+				if (character === "\n") {
+					finalizedLines.push(currentLine);
+					currentLine = "";
+					carriageReturnPending = false;
+					continue;
+				}
+				currentLine = "";
+				carriageReturnPending = false;
+			}
+			if (character === "\r") {
+				carriageReturnPending = true;
+				continue;
+			}
+			if (character === "\n") {
+				finalizedLines.push(currentLine);
+				currentLine = "";
+				continue;
+			}
+			if (character === "\b") {
+				currentLine = currentLine.slice(0, -1);
+				continue;
+			}
+			if (character === "	") {
+				currentLine += character;
+				continue;
+			}
+			if (character >= "\0" && character < " " || character === "") continue;
+			appendPrintableCharacter(character);
+		}
+	};
+	syncArchive();
+	return {
+		append(chunk) {
+			if (screenModeActive) return;
+			const text = decoder.decode(chunk, { stream: true });
+			const now = getMonotonicTime();
+			const hasScreenRedrawControl = containsScreenRedrawControl(text);
+			if (hasScreenRedrawControl) screenRedrawArchiveSuppressedUntil = now + SCREEN_REDRAW_ARCHIVE_SUPPRESS_MS;
+			processDecodedText(text, { recordPrintable: !hasScreenRedrawControl && now >= screenRedrawArchiveSuppressedUntil });
+			scheduleSync();
+		},
+		concealPreservedArchive() {
+			const nextState = preservedLines.length > 0;
+			if (concealedPreservedArchive === nextState) return;
+			concealedPreservedArchive = nextState;
+			syncArchiveVisibility();
+		},
+		destroy() {
+			if (frameHandle !== null) {
+				cancelFrame(frameHandle);
+				frameHandle = null;
+			}
+			archive.remove();
+		},
+		getAllLines() {
+			return normalizePreservedTranscriptLines([
+				...preservedLines,
+				...finalizedLines,
+				currentLine
+			]);
+		},
+		isAlternateScreenActive() {
+			return alternateScreenActive;
+		},
+		preserveSnapshot(lines = []) {
+			setPreservedLines(lines);
+			concealedPreservedArchive = preservedLines.length > 0;
+			resetParser();
+			scheduleSync();
+		},
+		refresh() {
+			scheduleSync();
+		},
+		revealPreservedArchive() {
+			if (!concealedPreservedArchive) return;
+			concealedPreservedArchive = false;
+			syncArchiveVisibility();
+		},
+		setAlternateScreenActive,
+		setScreenModeActive
+	};
+}
+function createBrowserTransport(handlers) {
+	const pendingMessages = [];
+	const encoder = new TextEncoder();
+	let socketUrl;
+	let socket = null;
+	let closed = false;
+	const flushPendingMessages = () => {
+		if (!socket || socket.readyState !== WebSocket.OPEN) return;
+		for (const message of pendingMessages.splice(0)) sendMessage(message);
+	};
+	const sendMessage = (message) => {
+		if (closed) return;
+		if (!socket || socket.readyState !== WebSocket.OPEN) {
+			pendingMessages.push(message);
+			return;
+		}
+		if (message.kind === "control") {
+			socket.send(String(message.data));
+			return;
+		}
+		const payload = typeof message.data === "string" ? encoder.encode(message.data) : message.data;
+		socket.send(copyToArrayBuffer(payload));
+	};
+	return {
+		close() {
+			closed = true;
+			pendingMessages.length = 0;
+			socket?.close();
+		},
+		connect(url) {
+			if (closed) return;
+			if (url) socketUrl = url;
+			if (!socketUrl) throw new Error("No WebSocket URL provided");
+			if (socket && socket.readyState !== WebSocket.CLOSED) return;
+			const currentSocket = new WebSocket(socketUrl);
+			socket = currentSocket;
+			currentSocket.binaryType = "arraybuffer";
+			currentSocket.onopen = () => {
+				flushPendingMessages();
+				handlers.onOpen();
+			};
+			currentSocket.onmessage = (event) => {
+				if (event.data instanceof ArrayBuffer) {
+					handlers.onBinary(new Uint8Array(event.data));
+					return;
+				}
+				if (typeof event.data === "string") {
+					handlers.onControlMessage(event.data);
+					return;
+				}
+				if (event.data instanceof Blob) {
+					event.data.arrayBuffer().then((buffer) => {
+						handlers.onBinary(new Uint8Array(buffer));
+					}).catch(() => {
+						handlers.onError(new Event("error"));
+					});
+					return;
+				}
+				handlers.onControlMessage(String(event.data));
+			};
+			currentSocket.onclose = (event) => {
+				if (socket === currentSocket) socket = null;
+				handlers.onClose({
+					code: event.code,
+					reason: event.reason,
+					wasClean: event.wasClean
+				});
+			};
+			currentSocket.onerror = (event) => {
+				handlers.onError(event);
+				if (!closed && currentSocket.readyState < WebSocket.CLOSING) currentSocket.close();
+			};
+		},
+		disconnect(reason = "offline") {
+			if (!socket || socket.readyState >= WebSocket.CLOSING) return;
+			socket.close(1e3, reason);
+		},
+		send(data) {
+			sendMessage({
+				kind: "binary",
+				data
+			});
+		},
+		sendControl(data) {
+			sendMessage({
+				kind: "control",
+				data
+			});
+		}
+	};
+}
+function installScrollbackInteractions(element, callbacks = {}) {
+	const getScrollSurface = callbacks.getScrollSurface ?? (() => element);
+	const onInput = callbacks.onInput ?? (() => {});
+	const onManualScroll = callbacks.onManualScroll ?? (() => {});
+	const setScrollTop = callbacks.setScrollTop ?? ((scrollSurface, scrollTop) => {
+		scrollSurface.scrollTop = scrollTop;
+	});
+	const onWheel = (event) => {
+		const scrollSurface = getScrollSurface();
+		const maxScrollTop = getScrollbackMax(scrollSurface);
+		if (maxScrollTop <= 0 || event.deltaY === 0) return;
+		const nextScrollTop = clamp(scrollSurface.scrollTop + event.deltaY, 0, maxScrollTop);
+		if (nextScrollTop === scrollSurface.scrollTop) return;
+		onManualScroll({
+			scrollTop: nextScrollTop,
+			maxScrollTop
+		});
+		event.preventDefault();
+		event.stopPropagation();
+		setScrollTop(scrollSurface, nextScrollTop);
+	};
+	const onKeyDown = (event) => {
+		if (isScrollbackShortcut(event)) {
+			event.preventDefault();
+			event.stopPropagation();
+			const scrollSurface = getScrollSurface();
+			const maxScrollTop = getScrollbackMax(scrollSurface);
+			const nextScrollTop = event.key === "PageUp" ? scrollSurface.scrollTop - Math.max(scrollSurface.clientHeight, 1) : maxScrollTop;
+			onManualScroll({
+				scrollTop: clamp(nextScrollTop, 0, maxScrollTop),
+				maxScrollTop
+			});
+			setScrollTop(scrollSurface, clamp(nextScrollTop, 0, getScrollbackMax(scrollSurface)));
+			return;
+		}
+		if (shouldSnapScrollbackOnKeyDown(event)) onInput({ event });
+	};
+	element.addEventListener("wheel", onWheel, {
+		capture: true,
+		passive: false
+	});
+	element.addEventListener("keydown", onKeyDown, true);
+	return () => {
+		element.removeEventListener("wheel", onWheel, true);
+		element.removeEventListener("keydown", onKeyDown, true);
+	};
+}
+function hasVisibleTerminalPaint(element) {
+	const style = getComputedStyle(element);
+	return hasVisibleCssPaint(style.backgroundColor) || hasVisibleCssBoxShadow(style.boxShadow);
+}
+function hasVisibleCssBoxShadow(value) {
+	return typeof value === "string" && value.trim().length > 0 && value !== "none";
+}
+function hasVisibleCssPaint(value) {
+	if (typeof value !== "string") return false;
+	const normalizedValue = value.trim().replace(/\s+/g, "").toLowerCase();
+	return normalizedValue.length > 0 && normalizedValue !== "transparent" && !/rgba\((?:[^,]+,){3}0(?:\.0+)?\)/.test(normalizedValue);
+}
+function getScrollbackMax(element) {
+	return Math.max(0, element.scrollHeight - element.clientHeight);
+}
+function resolveScrollSurface(doc, fallbackElement, scrollOptions) {
+	const configuredViewport = scrollOptions?.getViewport?.() ?? scrollOptions?.viewport;
+	if (configuredViewport instanceof HTMLElement) return configuredViewport;
+	const scrollingElement = doc.scrollingElement;
+	if (scrollingElement instanceof HTMLElement) return scrollingElement;
+	if (doc.documentElement instanceof HTMLElement) return doc.documentElement;
+	if (doc.body instanceof HTMLElement) return doc.body;
+	return fallbackElement;
+}
+function requestScrollUiUpdate(scrollOptions) {
+	scrollOptions?.requestUiUpdate?.();
+}
+function getScrollMetrics(element) {
+	const scrollTop = normalizeScrollMetric(element.scrollTop);
+	const scrollHeight = normalizeScrollMetric(element.scrollHeight);
+	const clientHeight = normalizeScrollMetric(element.clientHeight);
+	const maxScrollTop = getScrollbackMax(element);
+	const atTop = scrollTop <= 1;
+	const atBottom = isAtScrollbackBottom(scrollTop, maxScrollTop);
+	const thumbSizeRatio = scrollHeight <= 0 ? 1 : clamp(clientHeight / scrollHeight, 0, 1);
+	return {
+		atBottom,
+		atTop,
+		clientHeight,
+		maxScrollTop,
+		scrollHeight,
+		scrollTop,
+		thumbOffsetRatio: maxScrollTop <= 0 ? 0 : clamp(scrollTop / maxScrollTop, 0, 1),
+		thumbSizeRatio
+	};
+}
+function normalizeScrollMetric(value) {
+	return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function areScrollMetricsEqual(left, right) {
+	return left.atBottom === right.atBottom && left.atTop === right.atTop && left.clientHeight === right.clientHeight && left.maxScrollTop === right.maxScrollTop && left.scrollHeight === right.scrollHeight && left.scrollTop === right.scrollTop && left.thumbOffsetRatio === right.thumbOffsetRatio && left.thumbSizeRatio === right.thumbSizeRatio;
+}
+function installScrollMetricsObserver(element, onScroll) {
+	element.addEventListener("scroll", onScroll, { passive: true });
+	return () => {
+		element.removeEventListener("scroll", onScroll);
+	};
+}
+function isAtScrollbackBottom(scrollTop, maxScrollTop) {
+	return maxScrollTop <= 0 || scrollTop >= maxScrollTop - 1;
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function isScrollbackShortcut(event) {
+	return event.shiftKey && (event.key === "PageUp" || event.key === "PageDown");
+}
+function shouldPreserveVisiblePromptOnInput(event) {
+	if (!(event instanceof KeyboardEvent)) return false;
+	if (event.altKey || event.ctrlKey || event.metaKey) return false;
+	return event.key.length === 1 || event.key === "Backspace" || event.key === "Delete" || isCompositionKeyDown(event);
+}
+function shouldFollowLiveOutputOnInput(event) {
+	if (!(event instanceof KeyboardEvent)) return false;
+	return !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey && event.key === "Enter";
+}
+function isLiveInputSurfaceVisible(shell, terminalRoot, windowObject) {
+	const anchor = resolveLiveInputSurfaceAnchor(terminalRoot);
+	if (!(anchor instanceof HTMLElement)) return false;
+	const rect = anchor.getBoundingClientRect();
+	if (!hasUsableClientRect(rect)) return false;
+	const topBoundary = getViewportTopBoundary(shell);
+	const bottomBoundary = getViewportBottomBoundary(windowObject);
+	return rect.bottom > topBoundary + 1 && rect.top < bottomBoundary - 1;
+}
+function resolveLiveInputSurfaceAnchor(terminalRoot) {
+	const visibleCursors = Array.from(terminalRoot.querySelectorAll(".term-grid .term-cursor")).filter((cursor) => cursor instanceof HTMLElement && !cursor.hidden && cursor.getAttribute("aria-hidden") !== "true");
+	if (visibleCursors.length > 0) return visibleCursors[visibleCursors.length - 1];
+	const rows = Array.from(terminalRoot.querySelectorAll(".term-grid .term-row"));
+	let lastNonEmptyRow = null;
+	for (let index = rows.length - 1; index >= 0; index -= 1) {
+		const row = rows[index];
+		if (!(row instanceof HTMLElement)) continue;
+		const text = row.textContent?.trimEnd() ?? "";
+		if (text.length === 0) continue;
+		if (looksLikePromptLine(text)) return row;
+		lastNonEmptyRow = lastNonEmptyRow ?? row;
+	}
+	return lastNonEmptyRow;
+}
+function getViewportTopBoundary(shell) {
+	const topBar = shell.querySelector("[data-terminal-viewport-offset]");
+	if (topBar instanceof HTMLElement) {
+		const rect = topBar.getBoundingClientRect();
+		if (hasUsableClientRect(rect)) return rect.bottom;
+	}
+	return 0;
+}
+function getViewportBottomBoundary(windowObject) {
+	const candidates = [
+		windowObject?.innerHeight,
+		windowObject?.document?.documentElement?.clientHeight,
+		windowObject?.document?.body?.clientHeight
+	];
+	for (const candidate of candidates) if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) return candidate;
+	return Number.POSITIVE_INFINITY;
+}
+function firstFinitePositiveNumber(...candidates) {
+	for (const candidate of candidates) if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) return candidate;
+	return null;
+}
+function hasUsableClientRect(rect) {
+	if (!rect) return false;
+	return Number.isFinite(rect.top) && Number.isFinite(rect.bottom) && Number.isFinite(rect.left) && Number.isFinite(rect.right) && !(rect.top === 0 && rect.bottom === 0 && rect.left === 0 && rect.right === 0);
+}
+function shouldSnapScrollbackOnKeyDown(event) {
+	if (event.defaultPrevented || isScrollbackShortcut(event) || isBrowserSafeShortcut(event) || isContainedTerminalNavigationKey(event)) return false;
+	return ![
+		"Alt",
+		"CapsLock",
+		"Control",
+		"Fn",
+		"Meta",
+		"NumLock",
+		"ScrollLock",
+		"Shift"
+	].includes(event.key);
+}
+function decodeHelloReplay(value) {
+	if (typeof value !== "string" || value.length === 0) return new Uint8Array(0);
+	try {
+		const normalizedValue = value.replace(/-/g, "+").replace(/_/g, "/");
+		const missingPadding = normalizedValue.length % 4;
+		const decoded = atob(missingPadding === 0 ? normalizedValue : `${normalizedValue}${"=".repeat(4 - missingPadding)}`);
+		const bytes = new Uint8Array(decoded.length);
+		for (let index = 0; index < decoded.length; index += 1) bytes[index] = decoded.charCodeAt(index);
+		return bytes;
+	} catch {
+		return new Uint8Array(0);
+	}
+}
+function formatExitStatus(message) {
+	if (typeof message.signal === "string" && message.signal) return `Session ended (${message.signal})`;
+	if (typeof message.code === "number") return `Session ended (code ${message.code})`;
+	return "Session ended";
+}
+function resolveExitPresentation(message) {
+	if (isShutdownSignal(message.signal)) return {
+		sessionState: "shutdown",
+		statusText: `Session shut down (${message.signal})`
+	};
+	return {
+		sessionState: "ended",
+		statusText: formatExitStatus(message)
+	};
+}
+function isShutdownSignal(signal) {
+	return signal === "SIGINT" || signal === "SIGTERM";
+}
+function getRequiredElement(doc, selector) {
+	const element = doc.querySelector(selector);
+	if (!(element instanceof HTMLElement)) throw new Error(`Missing required element: ${selector}`);
+	return element;
+}
+function getOptionalElement(doc, selector) {
+	const element = doc.querySelector(selector);
+	return element instanceof HTMLElement ? element : null;
+}
+function hasElementOverride(elements, key) {
+	return Object.prototype.hasOwnProperty.call(elements, key);
+}
+function createTerminalThemeController(doc, shell, terminalRoot, theme) {
+	const explicitTheme = normalizeThemeName(theme);
+	let observingTheme = false;
+	const clearProtocolOverrides = () => {
+		clearTerminalThemeProtocolOverrides(doc.documentElement);
+		clearTerminalThemeProtocolOverrides(shell);
+		clearTerminalThemeProtocolOverrides(terminalRoot);
+	};
+	const MutationObserverCtor = doc.defaultView?.MutationObserver ?? globalThis.MutationObserver;
+	const mutationObserver = typeof MutationObserverCtor === "function" ? new MutationObserverCtor(() => {
+		const externalTheme = normalizeThemeName(doc.documentElement.dataset.theme);
+		if (shell.dataset.theme === externalTheme && terminalRoot.dataset.theme === externalTheme) return;
+		clearProtocolOverrides();
+		syncInternalTheme(externalTheme);
+	}) : null;
+	const observeTheme = () => {
+		if (observingTheme) return;
+		mutationObserver?.observe(doc.documentElement, {
+			attributeFilter: ["data-theme"],
+			attributes: true
+		});
+		observingTheme = true;
+	};
+	const pauseThemeObservation = () => {
+		if (!observingTheme) return;
+		mutationObserver?.disconnect();
+		observingTheme = false;
+	};
+	const syncTheme = (nextTheme) => {
+		const configuredTheme = normalizeThemeName(nextTheme);
+		if (!configuredTheme) {
+			if (doc.documentElement.dataset.theme !== void 0) delete doc.documentElement.dataset.theme;
+			doc.documentElement.style.removeProperty("color-scheme");
+			delete shell.dataset.theme;
+			delete terminalRoot.dataset.theme;
+			return;
+		}
+		if (configuredTheme === "light" || configuredTheme === "dark") doc.documentElement.style.setProperty("color-scheme", configuredTheme);
+		else doc.documentElement.style.removeProperty("color-scheme");
+		if (doc.documentElement.dataset.theme !== configuredTheme) doc.documentElement.dataset.theme = configuredTheme;
+		if (shell.dataset.theme !== configuredTheme) shell.dataset.theme = configuredTheme;
+		if (terminalRoot.dataset.theme !== configuredTheme) terminalRoot.dataset.theme = configuredTheme;
+	};
+	const syncInternalTheme = (nextTheme) => {
+		pauseThemeObservation();
+		try {
+			syncTheme(nextTheme);
+			mutationObserver?.takeRecords();
+		} finally {
+			observeTheme();
+		}
+	};
+	syncTheme(explicitTheme ?? doc.documentElement.dataset.theme);
+	observeTheme();
+	return {
+		destroy() {
+			mutationObserver?.disconnect();
+		},
+		getTheme() {
+			return doc.documentElement.dataset.theme;
+		},
+		syncProtocolUpdate(update) {
+			let themeChanged = false;
+			if (update.theme && normalizeThemeName(update.theme) !== this.getTheme()) {
+				clearProtocolOverrides();
+				syncInternalTheme(update.theme);
+				themeChanged = true;
+			}
+			applyTerminalThemeProtocolUpdate(doc.documentElement, update);
+			applyTerminalThemeProtocolUpdate(shell, update);
+			applyTerminalThemeProtocolUpdate(terminalRoot, update);
+			return themeChanged || hasTerminalThemeProtocolUpdate(update);
+		},
+		setTheme(nextTheme) {
+			const previousTheme = this.getTheme();
+			const normalizedTheme = normalizeThemeName(nextTheme);
+			clearProtocolOverrides();
+			syncInternalTheme(nextTheme);
+			return normalizedTheme !== previousTheme;
+		}
+	};
+}
+function clearTerminalThemeProtocolOverrides(element) {
+	for (const variableName of TERMINAL_THEME_PROTOCOL_VARIABLES) element.style.removeProperty(variableName);
+}
+function applyTerminalThemeProtocolUpdate(element, update) {
+	const { background, cursor, foreground } = update.colors;
+	if (background) element.style.setProperty("--theme-term-bg", background);
+	if (cursor) element.style.setProperty("--theme-term-cursor", cursor);
+	if (foreground) element.style.setProperty("--theme-term-fg", foreground);
+	for (const { color, index } of update.palette) element.style.setProperty(`--theme-term-color-${index}`, color);
+}
+function hasTerminalThemeProtocolUpdate(update) {
+	return Object.keys(update.colors).length > 0 || update.palette.length > 0 || Boolean(update.theme);
+}
+function normalizeThemeName(theme) {
+	return normalizeTheme(theme);
+}
+function normalizeConnectionState(value) {
+	switch (value) {
+		case "open":
+		case "reconnecting":
+		case "superseded":
+		case "closed":
+		case "error": return value;
+		default: return "connecting";
+	}
+}
+function normalizeOutputState(value) {
+	return value === "ready" ? "ready" : "pending";
+}
+function normalizeSessionPresentationState(value) {
+	switch (value) {
+		case "live":
+		case "reconnecting":
+		case "superseded":
+		case "shutdown":
+		case "ended":
+		case "error": return value;
+		default: return "starting";
+	}
+}
+function cloneTerminalStatusSnapshot(status) {
+	return {
+		...status,
+		loading: { ...status.loading }
+	};
+}
+function areTerminalStatusSnapshotsEqual(left, right) {
+	return left.connection === right.connection && left.message === right.message && left.output === right.output && left.sessionState === right.sessionState && left.loading.message === right.loading.message && left.loading.visible === right.loading.visible;
+}
+function toWebSocketUrl(sessionUrl) {
+	const url = new URL(sessionUrl.href);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	url.pathname = "/ws";
+	return url.toString();
+}
+function resolveAittySessionUrl(windowObject, src) {
+	if (src instanceof URL) return new URL(src.href);
+	if (typeof src === "string" && src.trim()) return new URL(src, windowObject.location.href);
+	return new URL(windowObject.location.href);
+}
+function resolveShellRuntimeKind(doc, shell, sessionUrl) {
+	const configuredRuntime = shell.dataset.runtime;
+	if (configuredRuntime === "droid" || configuredRuntime === "pty") return configuredRuntime;
+	if (configuredRuntime !== "session") return "pty";
+	const windowObject = doc.defaultView ?? window;
+	const fetchRuntimeKind = typeof windowObject.fetch === "function" ? windowObject.fetch.bind(windowObject) : null;
+	if (!fetchRuntimeKind) return "pty";
+	return fetchRuntimeKindFromSession(sessionUrl ?? resolveAittySessionUrl(windowObject), fetchRuntimeKind);
+}
+async function fetchRuntimeKindFromSession(sessionUrl, fetchRuntimeKind) {
+	try {
+		const url = new URL(sessionUrl.href);
+		url.pathname = "/session-info";
+		url.hash = "";
+		const response = await fetchRuntimeKind(url.toString());
+		if (!response.ok) return "pty";
+		return (await response.json()).runtimeKind === "droid" ? "droid" : "pty";
+	} catch {
+		return "pty";
+	}
+}
+function syncDimensions(element, cols, rows) {
+	element.dataset.cols = String(cols);
+	element.dataset.rows = String(rows);
+}
+function syncTranscriptMetadata(element, transcriptLineCount, archivedLineCount) {
+	element.dataset.transcriptLines = String(transcriptLineCount);
+	element.dataset.archivedLines = String(archivedLineCount);
+	element.classList.toggle("has-scrollback", archivedLineCount > 0 || element.querySelector(".term-scrollback-row") !== null);
+}
+function syncTrailingTerminalBlankRows(element) {
+	const rows = Array.from(element.querySelectorAll(".term-grid .term-row"));
+	let trailingBlank = true;
+	for (let index = rows.length - 1; index >= 0; index -= 1) {
+		const row = rows[index];
+		if (!(row instanceof HTMLElement)) continue;
+		const isBlank = (row.textContent ?? "").trim().length === 0 && !hasVisibleTerminalPaint(row);
+		row.classList.toggle("term-row--trailing-blank", trailingBlank && isBlank);
+		if (!isBlank) trailingBlank = false;
+	}
+}
+function trimReconciledPreservedTranscriptLines(preservedLines, liveLines) {
+	if (preservedLines.length === 0 || liveLines.length === 0) return preservedLines;
+	const normalizedLiveLines = normalizePreservedTranscriptLines(liveLines);
+	for (let start = 0; start < preservedLines.length; start += 1) {
+		const candidate = preservedLines.slice(start);
+		if (candidate.length <= normalizedLiveLines.length && candidate.every((line, index) => line === normalizedLiveLines[index])) return preservedLines.slice(0, start);
+	}
+	return preservedLines;
+}
+function normalizePreservedTranscriptLines(lines) {
+	return lines.map((line) => line.trimEnd()).filter((line, index, array) => line.length > 0 || index > 0 && index < array.length - 1);
+}
+function looksLikePromptLine(text) {
+	return /^\s*(?:[$>#]|[^\s]+[@:][^\s]+[$#])\s?/.test(text);
+}
+function copyToArrayBuffer(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+function concatChunks(chunks) {
+	const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+	const payload = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		payload.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return payload;
+}
+if (typeof document !== "undefined") {
+	defineAittyTerminalElement();
+	if (shouldAutoMount(document)) mountTerminalApp().catch((error) => {
+		const shell = document.querySelector("[data-shell]");
+		const status = document.querySelector("[data-terminal-status]");
+		const loading = document.querySelector("[data-terminal-loading]");
+		if (shell instanceof HTMLElement) {
+			shell.dataset.connection = "error";
+			shell.dataset.sessionState = "error";
+		}
+		if (status instanceof HTMLElement) status.textContent = "Failed to start terminal";
+		if (loading instanceof HTMLElement) loading.hidden = true;
+		console.error(error);
+	});
+}
+function shouldAutoMount(doc) {
+	const shell = doc.querySelector("[data-shell]");
+	return shell instanceof HTMLElement && !shell.hasAttribute("data-aitty-manual");
+}
+//#endregion
+export { createBufferedTerminalWriter, defineAittyTerminalElement, mountAitty, mountTerminalApp };