@aitty/browser 0.1.0

package/dist/frontend/terminal-app.js

@@ -0,0 +1,1957 @@
+import { nextAltScreenState, parseCsiParams } from "./ansi-sequences.js";
+import { createAnsiStyleTracker } from "./ansi-style-tracker.js";
+import { BrowserTerminalRenderer } from "./browser-terminal-renderer.js";
+import { installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey } from "./terminal-input-policies.js";
+import { createTerminalThemeProtocolParser, resolveTerminalThemeQueryResponse } from "./terminal-theme-protocol.js";
+import { WTerm } from "@wterm/dom";
+import { createPongControlFrame, createResizeControlFrame, normalizeTheme, parseAittyControlFrame } from "@aitty/protocol";
+//#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 };