@aitty/browser 0.1.1 → 0.2.0

package/dist/frontend/terminal-app.js

@@ -1,22 +1,86 @@
-import { nextAltScreenState, parseCsiParams } from "./ansi-sequences.js";
+import { createFocusReportingParser, 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 { areTerminalAppearancesEqual, areTerminalBehaviorsEqual, cloneTerminalConfig, hasTerminalLayoutAppearanceChange, mergeTerminalConfig, normalizeTerminalConfig, normalizeThemeName, normalizeThemeTarget } from "./terminal-config.js";
+import { installShellControls } from "./shell-controls.js";
+import { installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey, resolveTerminalDocumentKeyData } from "./terminal-input-policies.js";
+import { resolveScrollAnchorRestoreTop } from "./terminal-scroll-anchor.js";
+import { isScrollAtBottom, resolveScrollFollowPolicy } from "./terminal-scroll-follow.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
+import { resolveVirtualTranscriptWindow } from "./virtual-transcript-window.js";
+import { WTerm, hasTerminalSelection } from "@aitty/wterm-dom";
+import { createPongControlFrame, createPushSubscribeControlFrame, createPushUnsubscribeControlFrame, createResizeControlFrame, createTakeoverRequestControlFrame, createTakeoverResponseControlFrame, isAittyRoleControlFrame, isAittyTakeoverRequestControlFrame, isAittyTakeoverResultControlFrame, parseAittyControlFrame } from "@aitty/protocol";
+//#region packages/browser/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 DEFAULT_TERMINAL_OUTPUT_FRAME_INTERVAL_MS = 1e3 / 30;
+const HIGH_PRESSURE_TERMINAL_OUTPUT_FRAME_INTERVAL_MS = 1e3 / 24;
+const HIGH_PRESSURE_TERMINAL_OUTPUT_PENDING_BYTES = 96 * 1024;
+const OUTPUT_PRESSURE_WINDOW_MS = 750;
+const OUTPUT_PRESSURE_CHUNK_THRESHOLD = 12;
+const OUTPUT_PRESSURE_BYTE_THRESHOLD = 128 * 1024;
+const OUTPUT_PRESSURE_HOLD_MS = 1e3;
+const DEFAULT_TERMINAL_RENDER_FONT_SIZE = 15;
 const SCREEN_REDRAW_ARCHIVE_SUPPRESS_MS = 500;
+const DESKTOP_IME_TEXTAREA_INSET_PX = 8;
+const DESKTOP_IME_CANDIDATE_SAFE_WIDTH_PX = 560;
+const DESKTOP_IME_CANDIDATE_SAFE_HEIGHT_PX = 260;
+const IOS_BROWSER_CHROME_KEYBOARD_GUARD_PX = 56;
+const MOBILE_SCREEN_KEYBOARD_BASELINE_MIN_INSET_PX = 240;
+const MOBILE_FOCUS_PROXY_MIN_WIDTH_PX = 280;
+const MOBILE_FOCUS_PROXY_HEIGHT_PX = 44;
+const MOBILE_FOCUS_PROXY_VIEWPORT_GAP_PX = 10;
+const MOBILE_FOCUS_PROXY_OPACITY = "0.02";
+const MOBILE_KEYBOARD_ALIGN_DELAYS_MS = [
+	60,
+	180,
+	360,
+	700,
+	1100
+];
+const MOBILE_COMPOSER_DIRECTION_LONG_PRESS_MS = 480;
+const MOBILE_COMPOSER_DOCK_SIZE_PX = 58;
+const MOBILE_COMPOSER_BUTTON_SIZE_PX = 54;
+const MOBILE_COMPOSER_BUTTON_GAP_PX = 10;
+const MOBILE_COMPOSER_EXPANDED_GAP_PX = 64;
+const MOBILE_COMPOSER_MARGIN_PX = 10;
+const MOBILE_COMPOSER_DIRECTION_OUTSET_PX = 62;
+const MOBILE_COMPOSER_DIRECTION_BOTTOM_OUTSET_PX = 66;
+const MOBILE_COMPOSER_TAP_SLOP_PX = 8;
+const MOBILE_COMPOSER_CLICK_SUPPRESS_MS = 420;
+const MOBILE_KEYBOARD_SCROLL_INTENT_MS = 1200;
+const MOBILE_KEYBOARD_MANUAL_SCROLL_SUPPRESS_MS = 1800;
+const TAKEOVER_NOTICE_TIMEOUT_MS = 6e4;
+const OUTPUT_DRAIN_SETTLE_DELAY_MS = 80;
+const LAYOUT_BOTTOM_FOLLOW_DELAYS_MS = [
+	80,
+	180,
+	360,
+	700,
+	1100,
+	1600
+];
+const USER_INPUT_LAYOUT_STICK_MS = 12e4;
+const KEYBOARD_VISIBLE_HEIGHT_RATIO = .85;
+const VIEWPORT_BASELINE_WIDTH_RESET_PX = 24;
+const LIVE_INPUT_KEYBOARD_MAX_GAP_PX = 112;
+const TERMINAL_FOCUS_IN = "\x1B[I";
 const TERMINAL_THEME_PROTOCOL_VARIABLES = [
 	"--theme-term-bg",
 	"--theme-term-cursor",
 	"--theme-term-fg",
+	"--theme-term-reverse-bg",
+	"--theme-term-reverse-fg",
 	...Array.from({ length: 16 }, (_, index) => `--theme-term-color-${index}`)
 ];
+let nextTerminalInputId = 0;
+const MOBILE_COMPOSER_PRIMARY_CONTROLS = Object.freeze([
+	"esc",
+	"tab",
+	"enter"
+]);
+const browserViewportBaselines = /* @__PURE__ */ new WeakMap();
 /**
 * 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.
@@ -24,21 +88,60 @@ const TERMINAL_THEME_PROTOCOL_VARIABLES = [
 function createBufferedTerminalWriter(target, scheduler = {}, options = {}) {
 	const requestFrame = scheduler.requestFrame ?? ((callback) => requestBrowserFrame(callback));
 	const cancelFrame = scheduler.cancelFrame ?? ((handle) => cancelBrowserFrame(handle));
+	const now = scheduler.now ?? getMonotonicTime;
+	const scheduleTimeout = scheduler.setTimeout ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+	const clearScheduledTimeout = scheduler.clearTimeout ?? ((handle) => clearTimeout(handle));
 	const maxBytesPerFrame = Math.max(1, options.maxBytesPerFrame ?? DEFAULT_MAX_BYTES_PER_FRAME);
+	const minFrameIntervalMs = Math.max(0, options.minFrameIntervalMs ?? 0);
 	let chunks = [];
 	let frameHandle = null;
+	let frameTimer = null;
+	let headIndex = 0;
 	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)]);
+	let lastFlushTimestamp = 0;
+	let pendingByteLength = 0;
+	const resetQueue = () => {
+		chunks = [];
+		headIndex = 0;
+		headOffset = 0;
+		pendingByteLength = 0;
+	};
+	const compactQueue = () => {
+		if (headIndex === 0) return;
+		if (headIndex < 64 && headIndex * 2 < chunks.length) return;
+		chunks = chunks.slice(headIndex);
+		headIndex = 0;
+	};
+	const peekPendingBytes = (maxByteCount) => {
+		const byteCount = Math.min(Math.max(0, maxByteCount), pendingByteLength);
+		if (byteCount === 0) return new Uint8Array(0);
+		const head = chunks[headIndex];
+		if (!head) {
+			resetQueue();
+			return new Uint8Array(0);
+		}
+		if (byteCount <= head.length - headOffset) return head.subarray(headOffset, headOffset + byteCount);
+		const payload = new Uint8Array(byteCount);
+		let copiedBytes = 0;
+		let chunkIndex = headIndex;
+		while (copiedBytes < byteCount && chunkIndex < chunks.length) {
+			const chunk = chunks[chunkIndex];
+			const chunkOffset = chunkIndex === headIndex ? headOffset : 0;
+			const chunkAvailableBytes = chunk.length - chunkOffset;
+			const copyBytes = Math.min(chunkAvailableBytes, byteCount - copiedBytes);
+			payload.set(chunk.subarray(chunkOffset, chunkOffset + copyBytes), copiedBytes);
+			copiedBytes += copyBytes;
+			chunkIndex += 1;
+		}
+		return payload;
 	};
 	const consumePendingBytes = (byteCount) => {
-		let remainingBytes = byteCount;
-		while (chunks.length > 0 && remainingBytes > 0) {
-			const availableBytes = chunks[0].length - headOffset;
+		let remainingBytes = Math.min(Math.max(0, byteCount), pendingByteLength);
+		pendingByteLength -= remainingBytes;
+		while (headIndex < chunks.length && remainingBytes > 0) {
+			const availableBytes = chunks[headIndex].length - headOffset;
 			if (availableBytes <= remainingBytes) {
-				chunks.shift();
+				headIndex += 1;
 				headOffset = 0;
 				remainingBytes -= availableBytes;
 				continue;
@@ -46,14 +149,31 @@ function createBufferedTerminalWriter(target, scheduler = {}, options = {}) {
 			headOffset += remainingBytes;
 			remainingBytes = 0;
 		}
+		if (pendingByteLength === 0) {
+			resetQueue();
+			return;
+		}
+		compactQueue();
 	};
 	const isUtf8ContinuationByte = (value) => (value & 192) === 128;
 	const isUtf8LeadByte = (value) => (value & 128) !== 0 && !isUtf8ContinuationByte(value);
+	const resolveUtf8SequenceLength = (value) => {
+		if ((value & 224) === 192) return 2;
+		if ((value & 240) === 224) return 3;
+		if ((value & 248) === 240) return 4;
+		return null;
+	};
 	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;
+		if (index < preferredEnd && isUtf8LeadByte(bytes[index])) {
+			if (index === 0) {
+				const sequenceLength = resolveUtf8SequenceLength(bytes[index]);
+				if (sequenceLength && sequenceLength <= bytes.length) return sequenceLength;
+			}
+			return index;
+		}
 		return preferredEnd;
 	};
 	const resolveAnsiSafeBoundary = (bytes, preferredEnd) => {
@@ -112,68 +232,209 @@ function createBufferedTerminalWriter(target, scheduler = {}, options = {}) {
 		boundary = resolveAnsiSafeBoundary(bytes, boundary);
 		return boundary > 0 ? boundary : preferredEnd;
 	};
-	const flush = () => {
+	const clearScheduledFrame = () => {
+		if (frameHandle !== null) {
+			cancelFrame(frameHandle);
+			frameHandle = null;
+		}
+		if (frameTimer !== null) {
+			clearScheduledTimeout(frameTimer);
+			frameTimer = null;
+		}
+	};
+	const resolveMinFrameIntervalMs = () => {
+		const resolved = options.resolveMinFrameIntervalMs?.({ pendingByteLength });
+		return Math.max(0, resolved ?? minFrameIntervalMs);
+	};
+	const scheduleFlush = () => {
+		if (frameHandle !== null || frameTimer !== null) return;
+		const frameIntervalMs = resolveMinFrameIntervalMs();
+		const delayMs = frameIntervalMs <= 0 ? 0 : Math.max(0, frameIntervalMs - (now() - lastFlushTimestamp));
+		const requestNextFrame = () => {
+			frameHandle = requestFrame((timestamp) => {
+				flush(timestamp);
+			});
+		};
+		if (delayMs > 1) {
+			frameTimer = scheduleTimeout(() => {
+				frameTimer = null;
+				requestNextFrame();
+			}, delayMs);
+			return;
+		}
+		requestNextFrame();
+	};
+	const flush = (timestamp = now()) => {
 		frameHandle = null;
-		if (chunks.length === 0) return;
-		const pendingBytes = getPendingBytes();
+		if (pendingByteLength === 0) {
+			resetQueue();
+			return;
+		}
+		const preferredEnd = Math.min(maxBytesPerFrame, pendingByteLength);
+		const pendingBytes = peekPendingBytes(preferredEnd < pendingByteLength ? preferredEnd + 1 : preferredEnd);
 		if (pendingBytes.length === 0) {
-			chunks = [];
-			headOffset = 0;
+			resetQueue();
 			return;
 		}
-		const preferredEnd = Math.min(maxBytesPerFrame, pendingBytes.length);
 		const safeEnd = resolveSafeSplitBoundary(pendingBytes, preferredEnd);
-		const trailingAnsiCarryLength = preferredEnd === pendingBytes.length ? resolveTrailingAnsiCarryLength(pendingBytes) : 0;
+		const trailingAnsiCarryLength = preferredEnd === pendingByteLength ? resolveTrailingAnsiCarryLength(pendingBytes) : 0;
 		const payloadByteCount = trailingAnsiCarryLength > 0 ? Math.max(0, safeEnd - trailingAnsiCarryLength) : safeEnd > 0 ? safeEnd : preferredEnd;
-		if (payloadByteCount <= 0) {
-			frameHandle = requestFrame(() => {
-				flush();
-			});
-			return;
-		}
+		if (payloadByteCount <= 0) return;
 		const payload = pendingBytes.subarray(0, payloadByteCount);
 		target.write(payload);
+		lastFlushTimestamp = timestamp;
 		consumePendingBytes(payloadByteCount);
-		if (chunks.length > 0) frameHandle = requestFrame(() => {
-			flush();
+		options.onFlush?.({
+			pendingByteLength,
+			wroteByteLength: payloadByteCount
 		});
+		if (pendingByteLength > 0) {
+			scheduleFlush();
+			return;
+		}
+		options.onDrain?.();
 	};
 	return {
 		destroy() {
-			if (frameHandle !== null) {
-				cancelFrame(frameHandle);
-				frameHandle = null;
-			}
-			chunks = [];
-			headOffset = 0;
+			clearScheduledFrame();
+			resetQueue();
 		},
 		discardPending() {
-			if (frameHandle !== null) {
-				cancelFrame(frameHandle);
-				frameHandle = null;
-			}
-			chunks = [];
-			headOffset = 0;
+			clearScheduledFrame();
+			resetQueue();
 		},
 		enqueue(chunk) {
 			if (chunk.length === 0) return;
 			chunks.push(chunk);
-			if (frameHandle === null) frameHandle = requestFrame(() => {
-				flush();
-			});
+			pendingByteLength += chunk.length;
+			scheduleFlush();
 		}
 	};
 }
+function resolveBrowserViewport(windowObject) {
+	const visualViewport = windowObject.visualViewport;
+	const root = windowObject.document?.documentElement;
+	const body = windowObject.document?.body;
+	const layoutWidth = firstFinitePositiveNumber(windowObject.innerWidth, root?.clientWidth, body?.clientWidth) ?? 1;
+	const currentLayoutHeight = largestFinitePositiveNumber(windowObject.innerHeight, root?.clientHeight) ?? firstFinitePositiveNumber(body?.clientHeight) ?? 1;
+	const visualWidth = firstFinitePositiveNumber(visualViewport?.width);
+	const visualHeight = firstFinitePositiveNumber(visualViewport?.height);
+	const visualOffsetTop = normalizeViewportOffset(visualViewport?.offsetTop);
+	const height = visualHeight ?? currentLayoutHeight;
+	const layoutHeight = resolveStableViewportBaselineHeight(windowObject, layoutWidth, currentLayoutHeight, height);
+	const visualKeyboardVisible = layoutHeight > 0 && height < layoutHeight * KEYBOARD_VISIBLE_HEIGHT_RATIO;
+	const keyboardInsetBottom = visualKeyboardVisible ? Math.max(0, layoutHeight - height) : 0;
+	const keyboardVisible = visualKeyboardVisible && keyboardInsetBottom > 0;
+	const browserChromeInsetBottom = resolveBrowserChromeKeyboardGuard(windowObject, keyboardVisible);
+	return {
+		browserChromeInsetBottom,
+		height,
+		keyboardInsetBottom,
+		offsetTop: visualOffsetTop,
+		safeHeight: keyboardVisible ? layoutHeight : Math.max(1, height - browserChromeInsetBottom),
+		width: visualWidth ?? layoutWidth
+	};
+}
+function resolveStableViewportBaselineHeight(windowObject, width, layoutHeight, visibleHeight) {
+	const screenHeight = resolveMobileScreenViewportBaselineHeight(windowObject, width, visibleHeight);
+	const height = Math.max(1, layoutHeight, visibleHeight, screenHeight ?? 0);
+	const previous = browserViewportBaselines.get(windowObject);
+	if (!previous || Math.abs(previous.width - width) > VIEWPORT_BASELINE_WIDTH_RESET_PX) {
+		browserViewportBaselines.set(windowObject, {
+			height,
+			width
+		});
+		return height;
+	}
+	if (height > previous.height) {
+		const nextBaseline = {
+			height,
+			width
+		};
+		browserViewportBaselines.set(windowObject, nextBaseline);
+		return nextBaseline.height;
+	}
+	return previous.height;
+}
+function resolveMobileScreenViewportBaselineHeight(windowObject, width, visibleHeight) {
+	if (!isCoarseMobileViewport(windowObject) || !isAittyInputFocused(windowObject)) return null;
+	const screen = windowObject.screen;
+	const candidate = largestFinitePositiveNumber(screen?.availHeight, screen?.height);
+	if (!candidate || candidate < width) return null;
+	if (candidate - visibleHeight < MOBILE_SCREEN_KEYBOARD_BASELINE_MIN_INSET_PX) return null;
+	return candidate;
+}
+function isAittyInputFocused(windowObject) {
+	return (windowObject.document?.activeElement)?.hasAttribute?.("data-aitty-input") === true;
+}
+function resolveMobileFocusProxyPosition(windowObject) {
+	const viewport = resolveBrowserViewport(windowObject);
+	const anchor = resolveMobileLiveInputAnchorRect(windowObject);
+	const width = Math.max(44, viewport.width - 16);
+	const height = MOBILE_FOCUS_PROXY_HEIGHT_PX;
+	const viewportTop = viewport.offsetTop + MOBILE_FOCUS_PROXY_VIEWPORT_GAP_PX;
+	const viewportBottom = resolveMobileFocusProxyBottom(viewport, height);
+	if (anchor) return {
+		anchor: "mobile-focus-proxy",
+		height,
+		left: 8,
+		top: clamp(anchor.top + Math.max(0, anchor.height - height), viewportTop, viewportBottom - height),
+		width
+	};
+	const topAnchor = viewport.keyboardInsetBottom > 0 ? viewportBottom - height : viewport.offsetTop + Math.max(12, Math.min(96, viewport.height * .32));
+	return {
+		anchor: "mobile-focus-proxy",
+		height,
+		left: Math.max(8, Math.min(24, viewport.width - 2)),
+		top: clamp(topAnchor, viewportTop, viewportBottom - height),
+		width
+	};
+}
+function shouldEnableMobileFocusProxyPointerEvents(windowObject, state = {}) {
+	if (!isCoarseMobileViewport(windowObject)) return false;
+	if (state.keyboardOpen) return true;
+	return resolveMobileLiveInputAnchorRect(windowObject) !== null;
+}
+function isMobileLiveInputTapTarget(terminalRoot, windowObject, clientX, clientY) {
+	const anchorRect = resolveLiveInputSurfaceAnchor(terminalRoot)?.getBoundingClientRect?.();
+	if (!hasUsableClientRect(anchorRect)) return false;
+	const rect = anchorRect;
+	const viewport = resolveBrowserViewport(windowObject);
+	const proxyHeight = MOBILE_FOCUS_PROXY_HEIGHT_PX;
+	const viewportTop = viewport.offsetTop + MOBILE_FOCUS_PROXY_VIEWPORT_GAP_PX;
+	const viewportBottom = resolveMobileFocusProxyBottom(viewport, proxyHeight);
+	const hitTop = clamp(rect.top + Math.max(0, rect.height - proxyHeight), viewportTop, viewportBottom - proxyHeight);
+	const hitBottom = hitTop + proxyHeight;
+	return clientX >= 0 && clientX <= viewport.width && clientY >= hitTop && clientY <= hitBottom;
+}
+function resolveMobileFocusProxyBottom(viewport, proxyHeight) {
+	const visibleBottom = viewport.offsetTop + viewport.height - viewport.browserChromeInsetBottom - MOBILE_FOCUS_PROXY_VIEWPORT_GAP_PX;
+	return Math.max(viewport.offsetTop + MOBILE_FOCUS_PROXY_VIEWPORT_GAP_PX + proxyHeight, visibleBottom);
+}
+function resolveMobileKeyboardPromptAlignDelays() {
+	return [...MOBILE_KEYBOARD_ALIGN_DELAYS_MS];
+}
+function resolveTerminalOutputFrameIntervalMs({ pendingByteLength, sustainedPressure = false }) {
+	if (sustainedPressure || pendingByteLength >= HIGH_PRESSURE_TERMINAL_OUTPUT_PENDING_BYTES) return HIGH_PRESSURE_TERMINAL_OUTPUT_FRAME_INTERVAL_MS;
+	return DEFAULT_TERMINAL_OUTPUT_FRAME_INTERVAL_MS;
+}
+function resolveMobileComposerExpandedListHeight(controlCount = MOBILE_COMPOSER_PRIMARY_CONTROLS.length) {
+	return controlCount * MOBILE_COMPOSER_BUTTON_SIZE_PX + Math.max(0, controlCount - 1) * MOBILE_COMPOSER_BUTTON_GAP_PX;
+}
 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]");
+	const takeoverControl = shell.querySelector("[data-aitty-take-control]");
 	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 initialConfig = normalizeTerminalConfig(dependencies.config);
+	const themeController = createTerminalThemeController(doc, shell, terminalRoot, initialConfig.appearance.theme, initialConfig.appearance.themeTarget);
+	let terminalConfig = initialConfig;
+	applyTerminalAppearance(shell, terminalRoot, terminalConfig.appearance);
 	const resolvedRuntimeKind = (dependencies.resolveRuntimeKind ?? ((resolverDoc, resolverShell) => resolveShellRuntimeKind(resolverDoc, resolverShell, sessionUrl)))(doc, shell);
 	const runtimeKind = typeof resolvedRuntimeKind === "string" ? resolvedRuntimeKind : await resolvedRuntimeKind;
 	shell.dataset.runtime = runtimeKind;
@@ -183,33 +444,60 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 	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 getScrollSurface = () => resolveScrollSurface(doc, shell, terminalRoot, dependencies.scroll);
 	const encoder = new TextEncoder();
 	const ansiStyleTracker = createAnsiStyleTracker();
+	const focusReportingParser = createFocusReportingParser();
 	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 terminalFocusReportingEnabled = false;
+	let terminalInputFocused = false;
+	let clientId = null;
+	let clientRole = null;
+	let takeoverPending = false;
+	let authoritativeTerminalSize = null;
+	let takeoverNotice = null;
 	let snapScrollbackOnNextWrite = false;
 	let followLiveOutput = false;
+	let pendingInitialBottomFollow = false;
 	const pendingFrames = [];
 	const pendingInputFrames = [];
 	let reconnectHandle = null;
 	let scrollbackSnapHandle = null;
 	let scrollbackSnapPassesRemaining = 0;
+	let scrollProgrammaticGeneration = 0;
+	const programmaticScrollSurfaces = /* @__PURE__ */ new WeakMap();
+	let pendingLayoutBottomFollow = false;
 	let disposeViewportSizer = null;
+	let disposeViewportDebugOverlay = null;
+	let mobileComposer = null;
 	let disposeScrollMetricsObserver = null;
+	let disposeTerminalFocusInteractions = null;
 	let lastResizeSignature = null;
 	let lastScrollMetrics = null;
+	let keyboardVisible = false;
+	let shellViewportVariablesFrame = null;
+	let mobileKeyboardAlignFrame = null;
+	let outputDrainSettleTimer = null;
+	const mobileKeyboardAlignTimers = /* @__PURE__ */ new Set();
+	const layoutBottomFollowTimers = /* @__PURE__ */ new Set();
+	let mobileKeyboardAlignAllowedUntil = 0;
+	let mobileKeyboardAlignSuppressedUntil = 0;
+	let userInputLayoutStickUntil = 0;
 	let suppressTermResizeCallback = false;
+	let outputPressureWindowStart = null;
+	let outputPressureWindowBytes = 0;
+	let outputPressureWindowChunks = 0;
+	let highOutputPressureUntil = 0;
 	let statusSnapshot = {
 		connection: normalizeConnectionState(shell.dataset.connection),
 		loading: {
@@ -221,13 +509,193 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 		sessionState: normalizeSessionPresentationState(shell.dataset.sessionState)
 	};
 	const getStatusSnapshot = () => cloneTerminalStatusSnapshot(statusSnapshot);
+	const syncTerminalInputAnchor = () => {
+		term?.input?.setImeAnchor?.(resolveLiveInputSurfaceAnchor(terminalRoot));
+	};
+	const syncShellViewportVariables = () => {
+		const viewport = resolveBrowserViewport(windowObject);
+		const wasKeyboardVisible = keyboardVisible;
+		const visibleViewportHeight = Math.max(1, viewport.height - viewport.browserChromeInsetBottom);
+		keyboardVisible = viewport.keyboardInsetBottom > 0;
+		shell.style.setProperty("--shell-visual-viewport-height", `${viewport.safeHeight}px`);
+		shell.style.setProperty("--shell-visible-viewport-height", `${visibleViewportHeight}px`);
+		shell.style.setProperty("--shell-terminal-viewport-height", `${keyboardVisible ? visibleViewportHeight : viewport.safeHeight}px`);
+		shell.style.setProperty("--shell-visual-viewport-offset-top", `${viewport.offsetTop}px`);
+		shell.style.setProperty("--shell-keyboard-inset-bottom", `${viewport.keyboardInsetBottom}px`);
+		shell.style.setProperty("--shell-browser-chrome-inset-bottom", `${viewport.browserChromeInsetBottom}px`);
+		shell.style.setProperty("--shell-mobile-obstruction-inset-bottom", keyboardVisible ? "0px" : `${viewport.browserChromeInsetBottom}px`);
+		shell.dataset.keyboardOpen = String(keyboardVisible);
+		terminalRoot.style.setProperty("--shell-terminal-keyboard-padding-block-end", "0px");
+		syncTerminalInputAnchor();
+		if (!wasKeyboardVisible && keyboardVisible && terminalInputFocused) scheduleMobileKeyboardPromptAlign({ force: true });
+	};
+	const scheduleShellViewportVariableSync = () => {
+		if (shellViewportVariablesFrame !== null) return;
+		shellViewportVariablesFrame = requestFrame(() => {
+			shellViewportVariablesFrame = null;
+			syncShellViewportVariables();
+		});
+	};
 	const publishScrollMetrics = () => {
-		const onMetricsChange = dependencies.scroll?.onMetricsChange;
-		if (!onMetricsChange) return;
 		const nextMetrics = getScrollMetrics(getScrollSurface());
 		if (lastScrollMetrics && areScrollMetricsEqual(lastScrollMetrics, nextMetrics)) return;
 		lastScrollMetrics = nextMetrics;
-		onMetricsChange({ ...nextMetrics });
+		dependencies.scroll?.onMetricsChange?.({ ...nextMetrics });
+	};
+	syncShellViewportVariables();
+	disposeViewportDebugOverlay = shouldInstallViewportDebugOverlay(windowObject, shell) ? installViewportDebugOverlay(shell, terminalRoot, getScrollSurface, windowObject) : null;
+	windowObject.addEventListener("resize", scheduleShellViewportVariableSync);
+	windowObject.visualViewport?.addEventListener("resize", scheduleShellViewportVariableSync);
+	windowObject.visualViewport?.addEventListener("scroll", scheduleShellViewportVariableSync);
+	const shouldKeepBottomFollow = () => pendingInitialBottomFollow || pendingLayoutBottomFollow || followLiveOutput;
+	const markProgrammaticScroll = (scrollSurface) => {
+		const generation = scrollProgrammaticGeneration += 1;
+		programmaticScrollSurfaces.set(scrollSurface, generation);
+		requestFrame(() => {
+			requestFrame(() => {
+				if (programmaticScrollSurfaces.get(scrollSurface) === generation) programmaticScrollSurfaces.delete(scrollSurface);
+			});
+		});
+	};
+	const isProgrammaticScroll = (scrollSurface) => programmaticScrollSurfaces.has(scrollSurface);
+	const setProgrammaticScrollTop = (scrollSurface, scrollTop) => {
+		const nextScrollTop = clamp(scrollTop, 0, getScrollbackMax(scrollSurface));
+		markProgrammaticScroll(scrollSurface);
+		setScrollSurfaceScrollTop(scrollSurface, nextScrollTop);
+	};
+	const stopBottomFollow = () => {
+		pendingInitialBottomFollow = false;
+		pendingLayoutBottomFollow = false;
+		snapScrollbackOnNextWrite = false;
+		followLiveOutput = false;
+		clearOutputDrainSettleTimer();
+		clearLayoutBottomFollowTimers();
+		cancelScrollbackSnap();
+	};
+	const syncAfterProgrammaticScroll = () => {
+		transcriptArchive?.refreshNow();
+		requestScrollUiUpdate(dependencies.scroll);
+		publishScrollMetrics();
+	};
+	const clearMobileKeyboardPromptAlign = () => {
+		if (mobileKeyboardAlignFrame !== null) {
+			cancelFrame(mobileKeyboardAlignFrame);
+			mobileKeyboardAlignFrame = null;
+		}
+		for (const timer of mobileKeyboardAlignTimers) clearTimeout(timer);
+		mobileKeyboardAlignTimers.clear();
+	};
+	const clearLayoutBottomFollowTimers = () => {
+		for (const timer of layoutBottomFollowTimers) clearTimeout(timer);
+		layoutBottomFollowTimers.clear();
+	};
+	const clearOutputDrainSettleTimer = () => {
+		if (outputDrainSettleTimer === null) return;
+		clearTimeout(outputDrainSettleTimer);
+		outputDrainSettleTimer = null;
+	};
+	const now = () => windowObject.performance?.now?.() ?? Date.now();
+	const noteOutputPressure = (byteLength) => {
+		const currentTime = now();
+		if (outputPressureWindowStart === null || currentTime - outputPressureWindowStart > OUTPUT_PRESSURE_WINDOW_MS) {
+			outputPressureWindowStart = currentTime;
+			outputPressureWindowBytes = 0;
+			outputPressureWindowChunks = 0;
+		}
+		outputPressureWindowBytes += Math.max(0, byteLength);
+		outputPressureWindowChunks += 1;
+		if (outputPressureWindowBytes >= OUTPUT_PRESSURE_BYTE_THRESHOLD || outputPressureWindowChunks >= OUTPUT_PRESSURE_CHUNK_THRESHOLD) highOutputPressureUntil = Math.max(highOutputPressureUntil, currentTime + OUTPUT_PRESSURE_HOLD_MS);
+	};
+	const hasHighOutputPressure = () => highOutputPressureUntil > now();
+	const grantMobileKeyboardPromptAlign = (durationMs = MOBILE_KEYBOARD_SCROLL_INTENT_MS) => {
+		mobileKeyboardAlignAllowedUntil = Math.max(mobileKeyboardAlignAllowedUntil, now() + durationMs);
+	};
+	const grantUserInputLayoutStick = (durationMs = USER_INPUT_LAYOUT_STICK_MS) => {
+		userInputLayoutStickUntil = Math.max(userInputLayoutStickUntil, now() + durationMs);
+	};
+	const isMobileKeyboardPromptAlignAllowed = (force = false) => force || mobileKeyboardAlignAllowedUntil > now();
+	const suppressMobileKeyboardPromptAlign = () => {
+		mobileKeyboardAlignSuppressedUntil = Math.max(mobileKeyboardAlignSuppressedUntil, now() + MOBILE_KEYBOARD_MANUAL_SCROLL_SUPPRESS_MS);
+		clearMobileKeyboardPromptAlign();
+	};
+	const noteMobileKeyboardManualScrollIntent = () => {
+		suppressMobileKeyboardPromptAlign();
+		userInputLayoutStickUntil = 0;
+		stopBottomFollow();
+	};
+	const isMobileKeyboardPromptAlignSuppressed = (force = false) => !force && mobileKeyboardAlignSuppressedUntil > now();
+	const hasRecentMobileKeyboardManualScrollIntent = () => mobileKeyboardAlignSuppressedUntil > now();
+	const hasRecentUserInputLayoutStick = () => userInputLayoutStickUntil > now();
+	const handleMobileKeyboardTouchScrollIntent = () => {
+		if (!terminalInputFocused || resolveBrowserViewport(windowObject).keyboardInsetBottom <= 0) return;
+		noteMobileKeyboardManualScrollIntent();
+	};
+	windowObject.addEventListener("touchmove", handleMobileKeyboardTouchScrollIntent, { passive: true });
+	const alignMobileKeyboardPrompt = (options = {}) => {
+		const viewport = resolveBrowserViewport(windowObject);
+		if (!terminalInputFocused || viewport.keyboardInsetBottom <= 0 || isMobileKeyboardPromptAlignSuppressed(options.force) || !isMobileKeyboardPromptAlignAllowed(options.force)) return;
+		syncShellViewportVariables();
+		syncTerminalInputAnchor();
+		const scrollSurface = getScrollSurface();
+		if (options.onlyIfNeeded && isLiveInputSurfaceSafelyAboveViewportBottom(shell, terminalRoot, windowObject)) return;
+		markProgrammaticScroll(scrollSurface);
+		alignLiveInputSurfaceToBottom(scrollSurface, shell, terminalRoot, windowObject);
+		markProgrammaticScroll(getScrollSurface());
+		alignLiveInputSurfaceIntoViewport(shell, terminalRoot, windowObject, scrollSurface);
+		syncAfterProgrammaticScroll();
+	};
+	const requestMobileKeyboardPromptAlign = (options = {}) => {
+		if (mobileKeyboardAlignFrame !== null || !terminalInputFocused || resolveBrowserViewport(windowObject).keyboardInsetBottom <= 0 || isMobileKeyboardPromptAlignSuppressed(options.force) || !isMobileKeyboardPromptAlignAllowed(options.force)) return;
+		mobileKeyboardAlignFrame = requestFrame(() => {
+			mobileKeyboardAlignFrame = null;
+			alignMobileKeyboardPrompt(options);
+		});
+	};
+	const scheduleMobileKeyboardPromptAlign = (options = {}) => {
+		grantMobileKeyboardPromptAlign();
+		clearMobileKeyboardPromptAlign();
+		requestMobileKeyboardPromptAlign(options);
+		for (const delay of MOBILE_KEYBOARD_ALIGN_DELAYS_MS) {
+			const timer = setTimeout(() => {
+				mobileKeyboardAlignTimers.delete(timer);
+				alignMobileKeyboardPrompt(options);
+			}, delay);
+			mobileKeyboardAlignTimers.add(timer);
+		}
+	};
+	const refreshScrollMetricsObserver = () => {
+		disposeScrollMetricsObserver?.();
+		disposeScrollMetricsObserver = installScrollMetricsObserver(getScrollSurface(), () => {
+			const scrollSurface = getScrollSurface();
+			const maxScrollTop = getScrollbackMax(scrollSurface);
+			const followDecision = resolveScrollFollowPolicy({
+				keepBottomFollow: shouldKeepBottomFollow(),
+				maxScrollTop,
+				previousScrollTop: lastScrollMetrics?.scrollTop ?? scrollSurface.scrollTop,
+				programmaticScroll: isProgrammaticScroll(scrollSurface),
+				scrollTop: scrollSurface.scrollTop
+			});
+			if (followDecision.action !== "idle") {
+				if (followDecision.action === "stop-follow") {
+					stopBottomFollow();
+					syncPreservedArchiveVisibility({
+						allowReveal: true,
+						maxScrollTop,
+						scrollTop: scrollSurface.scrollTop
+					});
+					requestScrollUiUpdate(dependencies.scroll);
+					publishScrollMetrics();
+					return;
+				}
+				setProgrammaticScrollTop(scrollSurface, maxScrollTop);
+				syncAfterProgrammaticScroll();
+				scheduleScrollbackSnapToBottom(followDecision.passes, { preferTranscriptFollow: followDecision.preferTranscriptFollow });
+				return;
+			}
+			transcriptArchive?.refresh();
+			publishScrollMetrics();
+		});
+		publishScrollMetrics();
 	};
 	const presentStatus = (patch) => {
 		const nextStatus = {
@@ -251,13 +719,35 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 		if (changed) dependencies.onStatusChange?.(getStatusSnapshot());
 	};
 	dependencies.onStatusChange?.(getStatusSnapshot());
+	const resolveLiveStatusMessage = () => {
+		if (clientRole === "viewer") return takeoverPending ? "Viewer mode. Waiting for control..." : "Viewer mode. Read-only.";
+		return "Live shell connected";
+	};
+	const syncTakeoverControl = () => {
+		shell.dataset.clientRole = clientRole ?? "unknown";
+		shell.dataset.clientId = clientId ?? "";
+		shell.dataset.takeoverPending = String(takeoverPending);
+		terminalRoot.dataset.clientRole = clientRole ?? "unknown";
+		if (!takeoverControl) return;
+		takeoverControl.hidden = clientRole !== "viewer";
+		takeoverControl.disabled = clientRole !== "viewer" || takeoverPending || sessionState !== "running";
+		takeoverControl.textContent = takeoverPending ? "Request sent" : "Take control";
+		takeoverControl.setAttribute("aria-label", takeoverPending ? "Control request pending" : "Request terminal control");
+	};
 	const syncTerminalPresentation = () => {
 		if (!transcriptArchive) return;
-		syncTerminalSurface(terminalRoot, transcriptArchive, term, ansiStyleTracker, { interactive: sessionState === "running" });
-		syncTrailingTerminalBlankRows(terminalRoot);
+		syncTerminalSurface(terminalRoot, transcriptArchive, term, ansiStyleTracker, { interactive: sessionState === "running" && clientRole === "controller" });
+		syncTakeoverControl();
+		takeoverNotice?.syncPermissionPrompt(sessionState === "running" && clientRole === "controller");
+		takeoverNotice?.syncNotificationControl();
+		mobileComposer?.setEnabled(sessionState === "running" && clientRole === "controller");
 		requestScrollUiUpdate(dependencies.scroll);
 		publishScrollMetrics();
 	};
+	const syncTerminalToAuthoritativeSize = (size) => {
+		authoritativeTerminalSize = size;
+		resizeTerminalTo(size.cols, size.rows);
+	};
 	const markLiveSession = () => {
 		reconnecting = false;
 		presentStatus({
@@ -266,11 +756,44 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 				message: "Booting terminal...",
 				visible: false
 			},
-			message: "Live shell on loopback",
+			message: resolveLiveStatusMessage(),
 			output: "ready",
 			sessionState: "live"
 		});
 	};
+	const requestTakeover = () => {
+		if (clientRole !== "viewer" || takeoverPending || sessionState !== "running") {
+			syncTakeoverControl();
+			return;
+		}
+		takeoverPending = true;
+		presentStatus({ message: "Requesting terminal control..." });
+		syncTakeoverControl();
+		transport?.sendControl?.(createTakeoverRequestControlFrame());
+	};
+	const handleTakeoverClick = (event) => {
+		event.preventDefault();
+		requestTakeover();
+	};
+	takeoverControl?.addEventListener("click", handleTakeoverClick);
+	takeoverNotice = installTakeoverNotice(shell, windowObject, {
+		getClientId() {
+			return clientId;
+		},
+		getClientRole() {
+			return clientRole;
+		},
+		onRespond(requestId, approved) {
+			if (clientRole !== "controller") return;
+			transport?.sendControl?.(createTakeoverResponseControlFrame({
+				approved,
+				requestId
+			}));
+		},
+		sendControl(data) {
+			transport?.sendControl?.(data);
+		}
+	});
 	const markWaitingForOutput = () => {
 		presentStatus({
 			connection: "open",
@@ -278,7 +801,7 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 				message: "Booting terminal...",
 				visible: !outputReady
 			},
-			message: outputReady ? "Live shell on loopback" : "Connected. Waiting for shell output...",
+			message: outputReady ? resolveLiveStatusMessage() : "Connected. Waiting for shell output...",
 			sessionState: outputReady ? "live" : "starting"
 		});
 	};
@@ -305,26 +828,93 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 	const getTargetScrollTop = (scrollSurface, { preferTranscriptFollow = false } = {}) => {
 		return getScrollbackMax(scrollSurface);
 	};
+	const alignTerminalPrompt = () => {
+		const scrollSurface = getScrollSurface();
+		setProgrammaticScrollTop(scrollSurface, getTargetScrollTop(scrollSurface));
+		markProgrammaticScroll(scrollSurface);
+		alignLiveInputSurfaceToBottom(scrollSurface, shell, terminalRoot, windowObject);
+		markProgrammaticScroll(getScrollSurface());
+		alignLiveInputSurfaceIntoViewport(shell, terminalRoot, windowObject, scrollSurface);
+		syncAfterProgrammaticScroll();
+		syncPreservedArchiveVisibility();
+	};
+	const focusTerminalInput = ({ alignToPrompt = false } = {}) => {
+		syncTerminalInputAnchor();
+		if (alignToPrompt && resolveBrowserViewport(windowObject).keyboardInsetBottom <= 0) alignTerminalPrompt();
+		else if (alignToPrompt) scheduleMobileKeyboardPromptAlign({ force: true });
+		term?.focus?.();
+	};
+	const followBottomNow = (options = {}) => {
+		const scrollSurface = getScrollSurface();
+		setProgrammaticScrollTop(scrollSurface, getTargetScrollTop(scrollSurface, options));
+		if (options.preferTranscriptFollow) {
+			markProgrammaticScroll(scrollSurface);
+			alignLiveInputSurfaceToBottom(scrollSurface, shell, terminalRoot, windowObject);
+			markProgrammaticScroll(getScrollSurface());
+			alignLiveInputSurfaceIntoViewport(shell, terminalRoot, windowObject, scrollSurface);
+		}
+		if (options.sync !== false) syncAfterProgrammaticScroll();
+	};
 	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();
+				followBottomNow(options);
 				scrollbackSnapPassesRemaining = Math.max(0, scrollbackSnapPassesRemaining - 1);
 				if (scrollbackSnapPassesRemaining > 0) runSnap();
 			});
 		};
 		runSnap();
 	};
-	const syncLiveOutputFollowScroll = () => {
-		if (!followLiveOutput) return;
+	const followBottomAfterLayoutChange = () => {
+		if (!pendingLayoutBottomFollow) return;
+		followBottomNow({ preferTranscriptFollow: true });
+		scheduleScrollbackSnapToBottom(12, { preferTranscriptFollow: true });
+		clearLayoutBottomFollowTimers();
+		for (const delay of LAYOUT_BOTTOM_FOLLOW_DELAYS_MS) {
+			const timer = setTimeout(() => {
+				layoutBottomFollowTimers.delete(timer);
+				if (!pendingLayoutBottomFollow) return;
+				followBottomNow({ preferTranscriptFollow: true });
+				if (layoutBottomFollowTimers.size === 0) requestFrame(() => {
+					pendingLayoutBottomFollow = false;
+				});
+			}, delay);
+			layoutBottomFollowTimers.add(timer);
+		}
+	};
+	const followBottomAfterOutputFlush = () => {
+		if (!shouldKeepBottomFollow()) return;
+		if (terminalInputFocused && resolveBrowserViewport(windowObject).keyboardInsetBottom > 0 && hasRecentMobileKeyboardManualScrollIntent()) {
+			stopBottomFollow();
+			return;
+		}
+		followBottomNow({ preferTranscriptFollow: true });
+	};
+	const settleBottomAfterOutputDrain = () => {
+		if (!shouldKeepBottomFollow()) return;
+		if (terminalInputFocused && resolveBrowserViewport(windowObject).keyboardInsetBottom > 0 && hasRecentMobileKeyboardManualScrollIntent()) {
+			stopBottomFollow();
+			return;
+		}
+		followBottomNow({ preferTranscriptFollow: true });
 		scheduleScrollbackSnapToBottom(2, { preferTranscriptFollow: true });
 	};
+	const scheduleBottomSettleAfterOutputDrain = () => {
+		if (!shouldKeepBottomFollow()) return;
+		clearOutputDrainSettleTimer();
+		outputDrainSettleTimer = setTimeout(() => {
+			outputDrainSettleTimer = null;
+			settleBottomAfterOutputDrain();
+		}, OUTPUT_DRAIN_SETTLE_DELAY_MS);
+	};
+	const isScrollSurfaceAtBottom = () => {
+		const scrollSurface = getScrollSurface();
+		return isAtScrollbackBottom(scrollSurface.scrollTop, getScrollbackMax(scrollSurface));
+	};
+	const isScrollSurfaceKnownAtBottom = () => lastScrollMetrics?.atBottom ?? isScrollSurfaceAtBottom();
 	const syncPreservedArchiveVisibility = ({ allowReveal = false, scrollTop = getScrollSurface().scrollTop, maxScrollTop = getScrollbackMax(getScrollSurface()) } = {}) => {
 		if (!transcriptArchive) return;
 		if (isAtScrollbackBottom(scrollTop, maxScrollTop)) {
@@ -336,9 +926,8 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 	const disposeHotkeys = installScrollbackInteractions(terminalRoot, {
 		getScrollSurface,
 		setScrollTop(scrollSurface, scrollTop) {
-			scrollSurface.scrollTop = scrollTop;
-			requestScrollUiUpdate(dependencies.scroll);
-			publishScrollMetrics();
+			setProgrammaticScrollTop(scrollSurface, scrollTop);
+			syncAfterProgrammaticScroll();
 		},
 		onInput({ event }) {
 			const preserveVisiblePrompt = shouldPreserveVisiblePromptOnInput(event) && isLiveInputSurfaceVisible(shell, terminalRoot, windowObject);
@@ -348,29 +937,38 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 			cancelScrollbackSnap();
 			if (!preserveVisiblePrompt) {
 				const scrollSurface = getScrollSurface();
-				scrollSurface.scrollTop = getTargetScrollTop(scrollSurface);
-				requestScrollUiUpdate(dependencies.scroll);
-				publishScrollMetrics();
+				setProgrammaticScrollTop(scrollSurface, getTargetScrollTop(scrollSurface));
+				syncAfterProgrammaticScroll();
 			}
 			syncPreservedArchiveVisibility();
 		},
-		onManualScroll({ scrollTop, maxScrollTop }) {
+		onManualScroll({ scrollTop, maxScrollTop, source }) {
+			noteMobileKeyboardManualScrollIntent();
 			syncPreservedArchiveVisibility({
 				allowReveal: true,
 				scrollTop,
 				maxScrollTop
 			});
-			snapScrollbackOnNextWrite = false;
-			followLiveOutput = false;
-			cancelScrollbackSnap();
+			stopBottomFollow();
+			if (source) shell.dataset.lastManualScrollSource = source;
 			requestScrollUiUpdate(dependencies.scroll);
 			publishScrollMetrics();
 		}
 	});
+	disposeTerminalFocusInteractions = installTerminalFocusInteractions(shell, terminalRoot, {
+		focusTerminal({ alignToPrompt = false } = {}) {
+			focusTerminalInput({ alignToPrompt });
+		},
+		resolveKeyData(event) {
+			return resolveTerminalDocumentKeyData(term, event);
+		},
+		sendData(data) {
+			sendUserInput(data);
+		}
+	});
 	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") {
@@ -388,42 +986,139 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 		if (!helloReceived || sessionState !== "running" || pendingInputFrames.length === 0) return;
 		for (const chunk of pendingInputFrames.splice(0)) transport?.send(chunk);
 	};
+	const sendTerminalFocusReport = (focused, { updateFocusState = true } = {}) => {
+		if (updateFocusState) terminalInputFocused = focused;
+		if (!terminalFocusReportingEnabled) return;
+		sendInputToPty(focused ? TERMINAL_FOCUS_IN : "\x1B[O");
+	};
+	const syncTerminalFocusReportingMode = (data) => {
+		const nextState = focusReportingParser.append(data);
+		if (nextState === null) return;
+		const changed = terminalFocusReportingEnabled !== nextState;
+		terminalFocusReportingEnabled = nextState;
+		if (changed && nextState && terminalInputFocused) sendInputToPty(TERMINAL_FOCUS_IN);
+	};
+	const notifyTerminalThemeChanged = () => {
+		renderTerminalNow(term, { force: true });
+		if (terminalInputFocused) sendTerminalFocusReport(true, { updateFocusState: false });
+	};
+	const applyTheme = (theme) => {
+		const changed = themeController.setTheme(theme);
+		if (changed) notifyTerminalThemeChanged();
+		return changed;
+	};
+	const getConfigSnapshot = () => cloneTerminalConfig(terminalConfig);
+	const updateTerminalConfig = (patch) => {
+		const nextConfig = mergeTerminalConfig(terminalConfig, patch);
+		const previousAppearance = terminalConfig.appearance;
+		const nextAppearance = nextConfig.appearance;
+		const appearanceChanged = !areTerminalAppearancesEqual(previousAppearance, nextAppearance);
+		if (!appearanceChanged && areTerminalBehaviorsEqual(terminalConfig.behavior, nextConfig.behavior)) return getConfigSnapshot();
+		const shouldRelayout = hasTerminalLayoutAppearanceChange(previousAppearance, nextAppearance);
+		const scrollAnchor = shouldRelayout ? captureScrollSurfaceAnchor(getScrollSurface(), shell) : null;
+		terminalConfig = nextConfig;
+		if (appearanceChanged) {
+			applyTerminalAppearance(shell, terminalRoot, nextAppearance, previousAppearance);
+			if (previousAppearance.theme !== nextAppearance.theme) applyTheme(nextAppearance.theme);
+			else renderTerminalNow(term, { force: true });
+		}
+		if (shouldRelayout) {
+			resizeTerminalToViewport();
+			renderTerminalNow(term, { force: true });
+			syncTerminalPresentation();
+			if (scrollAnchor) scheduleScrollAnchorRestore(scrollAnchor);
+		}
+		const snapshot = getConfigSnapshot();
+		dependencies.onConfigChange?.(snapshot);
+		return snapshot;
+	};
 	const processVisiblePayload = (data) => {
+		clearOutputDrainSettleTimer();
+		noteOutputPressure(data.length);
 		const firstOutput = markOutputReady();
+		const shouldFollowOutput = isScrollSurfaceKnownAtBottom() && !hasRecentMobileKeyboardManualScrollIntent();
+		syncTerminalFocusReportingMode(data);
 		const themeUpdate = themeProtocolParser.append(data);
 		let themeChanged = false;
-		if (themeUpdate) themeChanged = themeController.syncProtocolUpdate(themeUpdate);
+		if (themeUpdate) {
+			themeChanged = themeController.syncProtocolUpdate(themeUpdate);
+			if (themeUpdate.theme && normalizeThemeName(themeUpdate.theme) !== terminalConfig.appearance.theme) {
+				terminalConfig = mergeTerminalConfig(terminalConfig, { appearance: { theme: themeUpdate.theme } });
+				dependencies.onConfigChange?.(getConfigSnapshot());
+			}
+		}
 		const themeQueryResponse = resolveTerminalThemeQueryResponse(data, {
 			root: terminalRoot,
 			theme: themeController.getTheme()
 		});
 		if (themeQueryResponse) sendInputToPty(themeQueryResponse);
-		if (!termReady || !writer || !archiveWriter) {
+		if (!termReady || !writer) {
 			pendingFrames.push(data);
-			if (themeChanged) renderTerminalNow(term, { force: true });
+			pendingInitialBottomFollow = pendingInitialBottomFollow || firstOutput;
+			if (themeChanged) notifyTerminalThemeChanged();
 			return;
 		}
 		writer.enqueue(data);
-		archiveWriter.enqueue(data);
-		if (themeChanged) renderTerminalNow(term, { force: true });
-		syncTerminalPresentation();
-		if (followLiveOutput) {
+		if (themeChanged) notifyTerminalThemeChanged();
+		if (followLiveOutput || shouldFollowOutput) {
+			const keyboardOpen = terminalInputFocused && resolveBrowserViewport(windowObject).keyboardInsetBottom > 0;
+			if (keyboardOpen && hasRecentMobileKeyboardManualScrollIntent()) {
+				stopBottomFollow();
+				return;
+			}
+			if (keyboardOpen && !followLiveOutput) {
+				snapScrollbackOnNextWrite = false;
+				pendingInitialBottomFollow = pendingInitialBottomFollow || firstOutput;
+				grantMobileKeyboardPromptAlign(280);
+				requestMobileKeyboardPromptAlign({
+					force: true,
+					onlyIfNeeded: true
+				});
+				return;
+			}
 			snapScrollbackOnNextWrite = false;
-			syncLiveOutputFollowScroll();
+			pendingInitialBottomFollow = pendingInitialBottomFollow || firstOutput || shouldFollowOutput;
 		} else if (snapScrollbackOnNextWrite || firstOutput) {
 			snapScrollbackOnNextWrite = false;
-			scheduleScrollbackSnapToBottom(2);
+			pendingInitialBottomFollow = pendingInitialBottomFollow || firstOutput;
 		}
 	};
 	const sendInputToPty = (data) => {
-		if (sessionState !== "running") return;
+		if (sessionState !== "running" || clientRole !== "controller") return;
 		if (!helloReceived) {
 			pendingInputFrames.push(data);
 			return;
 		}
 		transport?.send(data);
 	};
-	const sendUserInput = (data) => {
+	const sendUserInput = (data, options = {}) => {
+		if (clientRole !== "controller") {
+			syncTerminalPresentation();
+			return;
+		}
+		if (options.focus === false) {
+			sendInputToPty(data);
+			return;
+		}
+		const shouldFollowLiveOutput = shouldFollowLiveOutputOnUserInputData(data);
+		const keyboardOpen = resolveBrowserViewport(windowObject).keyboardInsetBottom > 0;
+		grantUserInputLayoutStick();
+		focusTerminalInput({ alignToPrompt: shouldFollowLiveOutput || !keyboardOpen });
+		if (shouldFollowLiveOutput) {
+			followLiveOutput = true;
+			pendingInitialBottomFollow = true;
+			snapScrollbackOnNextWrite = true;
+			cancelScrollbackSnap();
+			scheduleMobileKeyboardPromptAlign({ force: true });
+			followBottomNow({ preferTranscriptFollow: true });
+			scheduleScrollbackSnapToBottom(2, { preferTranscriptFollow: true });
+		} else {
+			grantMobileKeyboardPromptAlign(280);
+			requestMobileKeyboardPromptAlign({
+				force: true,
+				onlyIfNeeded: true
+			});
+		}
 		sendInputToPty(data);
 	};
 	const emitResize = (cols, rows) => {
@@ -433,10 +1128,11 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 		syncDimensions(terminalRoot, normalizedCols, normalizedRows);
 		transcriptArchive?.refresh();
 		syncTerminalPresentation();
+		followBottomAfterLayoutChange();
 		const signature = `${normalizedCols}x${normalizedRows}`;
 		if (lastResizeSignature === signature) return;
 		lastResizeSignature = signature;
-		if (sessionState !== "running") return;
+		if (sessionState !== "running" || clientRole !== "controller") return;
 		transport?.sendControl?.(createResizeControlFrame(normalizedCols, normalizedRows));
 	};
 	const syncTermDimensionsFromBridge = (requestedCols = term?.cols ?? 80, requestedRows = term?.rows ?? 24) => {
@@ -450,7 +1146,7 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 		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) => {
+	const resizeTerminalTo = (cols, rows, options = {}) => {
 		if (!term) return;
 		const requestedCols = normalizeResizeDimension(cols, term.cols);
 		const requestedRows = normalizeResizeDimension(rows, term.rows);
@@ -464,16 +1160,55 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 		}
 		const actual = syncTermDimensionsFromBridge(requestedCols, requestedRows);
 		applyTerminalElementHeight(terminalRoot, actual.rows);
-		emitResize(actual.cols, actual.rows);
+		if (options.sendControl === true) {
+			emitResize(actual.cols, actual.rows);
+			return;
+		}
+		ansiStyleTracker.resize(actual.cols, actual.rows);
+		syncDimensions(terminalRoot, actual.cols, actual.rows);
+		transcriptArchive?.refresh();
+		syncTerminalPresentation();
+		followBottomAfterLayoutChange();
+	};
+	const resizeTerminalToViewport = () => {
+		if (!term) return;
+		syncShellViewportVariables();
+		if (clientRole !== "controller" && authoritativeTerminalSize) {
+			syncTerminalToAuthoritativeSize(authoritativeTerminalSize);
+			return;
+		}
+		const target = resolveViewportSize(term, terminalRoot, windowObject);
+		resizeTerminalTo(target.cols, target.rows, { sendControl: clientRole === "controller" });
+	};
+	const handleViewportResize = (cols, rows) => {
+		if (clientRole !== "controller") return;
+		resizeTerminalTo(cols, rows, { sendControl: true });
+	};
+	const scheduleScrollAnchorRestore = (anchor, passes = 10) => {
+		let remainingPasses = Math.max(1, passes);
+		const restore = () => {
+			requestFrame(() => {
+				markProgrammaticScroll(getScrollSurface());
+				restoreScrollSurfaceAnchor(getScrollSurface(), shell, anchor);
+				syncAfterProgrammaticScroll();
+				remainingPasses -= 1;
+				if (remainingPasses > 0) restore();
+			});
+		};
+		restore();
 	};
 	const handleTermResize = (cols, rows) => {
 		if (suppressTermResizeCallback) return;
 		const actual = syncTermDimensionsFromBridge(cols, rows);
-		emitResize(actual.cols, actual.rows);
+		if (clientRole === "controller") emitResize(actual.cols, actual.rows);
 	};
 	const showReconnectState = (statusText) => {
 		reconnecting = true;
 		helloReceived = false;
+		clientRole = null;
+		clientId = null;
+		takeoverPending = false;
+		syncTakeoverControl();
 		presentStatus({
 			connection: "reconnecting",
 			loading: {
@@ -522,22 +1257,31 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 		getCols() {
 			return term?.cols ?? 80;
 		},
+		getScrollSurface,
 		getVisibleRows() {
-			return term?.rows ?? 24;
+			return (term?.renderer?.getRenderedScrollbackCount?.() ?? 0) + (term?.rows ?? 24);
 		},
-		scrollbackLimit: dependencies.transcriptArchiveOptions?.scrollbackLimit
+		scrollbackLimit: terminalConfig.behavior.scrollbackLimit
 	});
-	archiveWriter = createBufferedTerminalWriter({ write(data) {
-		transcriptArchive?.append(data);
-	} }, frameScheduler);
 	writer = createBufferedTerminalWriter({ write(data) {
 		ansiStyleTracker.append(data);
-		term?.write?.(data);
+		transcriptArchive?.append(data);
+		term?.write?.(data, { scheduleRender: false });
 		ansiStyleTracker.syncFromBridge(term?.bridge);
 		const renderHints = ansiStyleTracker.consumeRenderHints();
 		renderTerminalNow(term, { force: renderHints.clearScreen || renderHints.styleChanged });
 		syncTerminalPresentation();
-	} }, frameScheduler);
+	} }, frameScheduler, {
+		minFrameIntervalMs: DEFAULT_TERMINAL_OUTPUT_FRAME_INTERVAL_MS,
+		resolveMinFrameIntervalMs({ pendingByteLength }) {
+			return resolveTerminalOutputFrameIntervalMs({
+				pendingByteLength,
+				sustainedPressure: hasHighOutputPressure()
+			});
+		},
+		onDrain: scheduleBottomSettleAfterOutputDrain,
+		onFlush: followBottomAfterOutputFlush
+	});
 	transport = (dependencies.createTransport ?? ((handlers) => createBrowserTransport(handlers)))({
 		onBinary(data) {
 			if (!helloReceived) helloReceived = true;
@@ -576,7 +1320,12 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 			if (!message) return;
 			if (message.type === "hello") {
 				helloReceived = true;
+				pendingInputFrames.length = 0;
 				const replay = decodeHelloReplay(message.replay);
+				syncTerminalToAuthoritativeSize({
+					cols: message.cols,
+					rows: message.rows
+				});
 				if (reconnecting && replay.length > 0) resetTerminalBuffer();
 				if (replay.length > 0) processVisiblePayload(replay);
 				cancelReconnect();
@@ -592,16 +1341,58 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 				transport?.sendControl?.(createPongControlFrame());
 				return;
 			}
+			if (message.type === "resize") {
+				const cols = normalizeResizeDimension(message.cols, term?.cols ?? 80);
+				const rows = normalizeResizeDimension(message.rows, term?.rows ?? 24);
+				if (clientRole !== "controller") syncTerminalToAuthoritativeSize({
+					cols,
+					rows
+				});
+				else authoritativeTerminalSize = {
+					cols,
+					rows
+				};
+				return;
+			}
+			if (isAittyRoleControlFrame(message)) {
+				clientId = message.clientId;
+				persistAittyClientId(windowObject, sessionUrl, clientId);
+				clientRole = message.role;
+				takeoverNotice?.syncClient(clientId, clientRole);
+				takeoverPending = false;
+				pendingInputFrames.length = 0;
+				syncTakeoverControl();
+				if (clientRole === "controller") {
+					authoritativeTerminalSize = null;
+					lastResizeSignature = null;
+					resizeTerminalToViewport();
+				} else if (authoritativeTerminalSize) syncTerminalToAuthoritativeSize(authoritativeTerminalSize);
+				else resizeTerminalToViewport();
+				markWaitingForOutput();
+				syncTerminalPresentation();
+				return;
+			}
+			if (isAittyTakeoverRequestControlFrame(message)) {
+				if (clientRole !== "controller" || !message.requestId) return;
+				takeoverNotice?.show({
+					requestId: message.requestId,
+					requesterId: message.requesterId
+				});
+				return;
+			}
+			if (isAittyTakeoverResultControlFrame(message)) {
+				takeoverPending = false;
+				if (!message.approved) presentStatus({ message: resolveTakeoverResultMessage(message.reason) });
+				syncTerminalPresentation();
+				return;
+			}
 			if (message.type === "theme") {
-				let themeChanged = false;
 				if (message.theme === null) {
-					themeChanged = themeController.setTheme(void 0);
-					if (themeChanged) renderTerminalNow(term, { force: true });
+					updateTerminalConfig({ appearance: { theme: void 0 } });
 					return;
 				}
 				const theme = normalizeThemeName(message.theme);
-				if (theme) themeChanged = themeController.setTheme(theme);
-				if (themeChanged) renderTerminalNow(term, { force: true });
+				if (theme) updateTerminalConfig({ appearance: { theme } });
 				return;
 			}
 			if (message.type !== "exit") return;
@@ -650,29 +1441,85 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 			presentStatus({ connection: "open" });
 		}
 	});
+	const disposeShellControls = dependencies.shellControls ? installShellControls({
+		captureScrollAnchor() {
+			return captureScrollSurfaceAnchor(getScrollSurface(), shell);
+		},
+		doc,
+		focusTerminal() {
+			focusTerminalInput();
+		},
+		getConfig: getConfigSnapshot,
+		onInterrupt() {
+			sendUserInput("");
+		},
+		onScrollSurfaceChange() {
+			syncShellViewportVariables();
+			syncTerminalInputAnchor();
+			lastScrollMetrics = null;
+			syncAfterProgrammaticScroll();
+			refreshScrollMetricsObserver();
+		},
+		onStickToBottomChange(stickToBottom) {
+			pendingLayoutBottomFollow = stickToBottom || hasRecentUserInputLayoutStick();
+			if (pendingLayoutBottomFollow) followBottomAfterLayoutChange();
+		},
+		resetConfig: initialConfig,
+		restoreScrollAnchor(anchor) {
+			restoreScrollSurfaceAnchor(getScrollSurface(), shell, anchor);
+			syncTerminalInputAnchor();
+		},
+		shell,
+		updateConfig: updateTerminalConfig,
+		windowObject
+	}) : () => {};
 	await term.init();
-	replaceTerminalInputHandler(term);
+	replaceTerminalInputHandler(term, {
+		getScrollSurface,
+		onBlur() {
+			sendTerminalFocusReport(false);
+		},
+		onFocus() {
+			sendTerminalFocusReport(true);
+			syncTerminalInputAnchor();
+			scheduleMobileKeyboardPromptAlign({ force: true });
+		},
+		windowObject
+	});
+	mobileComposer = shouldInstallMobileComposer(shell, windowObject) ? installMobileComposer(shell, terminalRoot, {
+		focusTerminal() {
+			focusTerminalInput({ alignToPrompt: true });
+		},
+		sendData(data) {
+			sendUserInput(data, { focus: false });
+		},
+		windowObject
+	}) : null;
 	const disposeInputPolicies = installTerminalInputPolicies(term, {
 		captureDocumentCtrlN: false,
 		onData(data) {
 			sendUserInput(data);
 		},
-		resolveKey: dependencies.input?.resolveKey
+		onPasteShortcut(event) {
+			return pasteClipboardImageFromShortcut(windowObject, sessionUrl, event);
+		},
+		pasteShortcut: resolveBrowserPasteShortcut(windowObject),
+		resolveKey: terminalConfig.behavior.input?.resolveKey
 	});
-	installBrowserRenderer(term, ansiStyleTracker);
+	installBrowserRenderer(term, { onScrollbackRowsDropped(rows) {
+		transcriptArchive?.appendPreservedLines(rows);
+	} });
 	termReady = true;
 	const initialSize = syncTermDimensionsFromBridge(term.cols, term.rows);
 	ansiStyleTracker.reset(initialSize.cols, initialSize.rows);
-	disposeViewportSizer = installTerminalViewportSizer(term, terminalRoot, windowObject, resizeTerminalTo);
+	disposeViewportSizer = installTerminalViewportSizer(term, terminalRoot, windowObject, handleViewportResize, () => clientRole === "controller" && resolveBrowserViewport(windowObject).keyboardInsetBottom <= 0);
 	syncTermDimensionsFromBridge(term.cols, term.rows);
-	emitResize(term.cols, term.rows);
 	syncTerminalPresentation();
-	term.focus();
-	disposeScrollMetricsObserver = installScrollMetricsObserver(getScrollSurface(), publishScrollMetrics);
-	publishScrollMetrics();
+	if (!shouldAllowImeViewportAvoidance(windowObject)) term.focus();
+	refreshScrollMetricsObserver();
 	windowObject.addEventListener("offline", handleBrowserOffline);
 	windowObject.addEventListener("online", handleBrowserOnline);
-	transport.connect(toWebSocketUrl(sessionUrl));
+	transport.connect(toWebSocketUrl(sessionUrl, resolveStoredAittyClientId(windowObject, sessionUrl)));
 	for (const frame of pendingFrames.splice(0)) writer.enqueue(frame);
 	return {
 		destroy() {
@@ -683,24 +1530,47 @@ async function mountTerminalApp(doc = document, dependencies = {}) {
 			cancelReconnect();
 			disposeViewportSizer?.();
 			disposeViewportSizer = null;
+			disposeViewportDebugOverlay?.();
+			disposeViewportDebugOverlay = null;
+			mobileComposer?.destroy();
+			mobileComposer = null;
+			clearMobileKeyboardPromptAlign();
+			clearOutputDrainSettleTimer();
+			clearLayoutBottomFollowTimers();
+			if (mobileKeyboardAlignFrame !== null) {
+				cancelFrame(mobileKeyboardAlignFrame);
+				mobileKeyboardAlignFrame = null;
+			}
+			if (shellViewportVariablesFrame !== null) {
+				cancelFrame(shellViewportVariablesFrame);
+				shellViewportVariablesFrame = null;
+			}
 			disposeScrollMetricsObserver?.();
 			disposeScrollMetricsObserver = null;
-			archiveWriter?.destroy();
+			disposeTerminalFocusInteractions?.();
+			disposeTerminalFocusInteractions = null;
 			transcriptArchive?.destroy();
 			writer?.destroy();
+			disposeShellControls();
 			disposeHotkeys();
 			disposeInputPolicies();
 			themeController.destroy();
+			takeoverControl?.removeEventListener("click", handleTakeoverClick);
+			takeoverNotice?.destroy();
+			windowObject.removeEventListener("resize", scheduleShellViewportVariableSync);
+			windowObject.removeEventListener("touchmove", handleMobileKeyboardTouchScrollIntent);
+			windowObject.visualViewport?.removeEventListener("resize", scheduleShellViewportVariableSync);
+			windowObject.visualViewport?.removeEventListener("scroll", scheduleShellViewportVariableSync);
 			windowObject.removeEventListener("offline", handleBrowserOffline);
 			windowObject.removeEventListener("online", handleBrowserOnline);
 			transport?.close();
 			term?.destroy();
 		},
+		getConfig: getConfigSnapshot,
 		getStatus: getStatusSnapshot,
-		getTheme: themeController.getTheme,
-		setTheme: themeController.setTheme,
 		term,
-		transport
+		transport,
+		updateConfig: updateTerminalConfig
 	};
 }
 function mountAitty(containerOrOptions = {}, maybeOptions = {}) {
@@ -727,7 +1597,13 @@ function defineAittyTerminalElement(registry = globalThis.customElements) {
 function createAittyTerminalElementConstructor() {
 	return class AittyTerminalCustomElement extends HTMLElement {
 		static get observedAttributes() {
-			return ["src", "theme"];
+			return [
+				"font-size",
+				"line-height",
+				"src",
+				"theme",
+				"theme-target"
+			];
 		}
 		#mounted = null;
 		#mountVersion = 0;
@@ -739,8 +1615,8 @@ function createAittyTerminalElementConstructor() {
 		}
 		attributeChangedCallback(name, oldValue, nextValue) {
 			if (oldValue === nextValue || !this.isConnected) return;
-			if (name === "theme" && this.#mounted) {
-				this.#mounted.setTheme(normalizeThemeName(nextValue ?? void 0));
+			if (name !== "src" && this.#mounted) {
+				this.#mounted.updateConfig(this.#readConfig());
 				return;
 			}
 			this.#mount();
@@ -763,8 +1639,15 @@ function createAittyTerminalElementConstructor() {
 							detail: status
 						}));
 					},
-					src: this.getAttribute("src") ?? void 0,
-					theme: normalizeThemeName(this.getAttribute("theme") ?? void 0)
+					onConfigChange: (config) => {
+						this.dispatchEvent(new CustomEvent("aitty:configchange", {
+							bubbles: true,
+							composed: true,
+							detail: config
+						}));
+					},
+					config: this.#readConfig(),
+					src: this.getAttribute("src") ?? void 0
 				});
 				if (!this.isConnected || this.#mountVersion !== mountVersion) {
 					mounted.destroy();
@@ -784,6 +1667,14 @@ function createAittyTerminalElementConstructor() {
 				}));
 			}
 		}
+		#readConfig() {
+			return { appearance: {
+				fontSize: parseOptionalNumber(this.getAttribute("font-size") ?? void 0),
+				lineHeight: parseOptionalNumber(this.getAttribute("line-height") ?? void 0),
+				theme: normalizeThemeName(this.getAttribute("theme") ?? void 0),
+				themeTarget: normalizeThemeTarget(this.getAttribute("theme-target") ?? void 0)
+			} };
+		}
 	};
 }
 async function mountAittyInContainer(container, options) {
@@ -879,139 +1770,1038 @@ function createAittyEmbedView(doc, mount) {
 		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);
+}
+function replaceTerminalInputHandler(term, options = {}) {
+	const previousInput = term.input;
+	if (typeof previousInput?.destroy !== "function") return;
+	previousInput.destroy();
+	const textarea = term.element.ownerDocument.createElement("textarea");
+	const inputOwnerId = `aitty-input-${nextTerminalInputId += 1}`;
+	configureTerminalTextarea(textarea);
+	term.element.dataset.aittyInputOwner = inputOwnerId;
+	textarea.dataset.aittyInputOwner = inputOwnerId;
+	appendTerminalTextarea(term.element, textarea);
+	const windowObject = options.windowObject ?? textarea.ownerDocument.defaultView ?? window;
+	syncTerminalTextareaPosition(term, textarea, { allowViewportAvoidance: shouldAllowImeViewportAvoidance(windowObject) });
+	let imeScrollLock = null;
+	let imeRestoreFrame = null;
+	let imeReleaseTimer = null;
+	const syncInputPosition = () => {
+		syncTerminalTextareaPosition(term, textarea, { allowViewportAvoidance: shouldAllowImeViewportAvoidance(windowObject) });
+	};
+	const clearImeReleaseTimer = () => {
+		if (imeReleaseTimer === null) return;
+		clearTimeout(imeReleaseTimer);
+		imeReleaseTimer = null;
+	};
+	const restoreDesktopImeScroll = () => {
+		const lock = imeScrollLock;
+		if (!lock || shouldAllowImeViewportAvoidance(windowObject)) return;
+		restoreImeScrollLock(lock);
+	};
+	const scheduleDesktopImeScrollRestore = () => {
+		if (!imeScrollLock || shouldAllowImeViewportAvoidance(windowObject)) return;
+		if (imeRestoreFrame !== null) windowObject.cancelAnimationFrame(imeRestoreFrame);
+		imeRestoreFrame = windowObject.requestAnimationFrame(() => {
+			imeRestoreFrame = null;
+			restoreDesktopImeScroll();
+			windowObject.setTimeout(restoreDesktopImeScroll, 0);
+		});
+	};
+	const captureDesktopImeScroll = () => {
+		clearImeReleaseTimer();
+		if (shouldAllowImeViewportAvoidance(windowObject)) {
+			imeScrollLock = null;
+			return;
+		}
+		imeScrollLock = captureImeScrollLock(windowObject, options.getScrollSurface?.());
+	};
+	const releaseDesktopImeScroll = () => {
+		clearImeReleaseTimer();
+		scheduleDesktopImeScrollRestore();
+		imeReleaseTimer = setTimeout(() => {
+			restoreDesktopImeScroll();
+			imeScrollLock = null;
+			imeReleaseTimer = null;
+		}, 120);
+	};
+	const syncInputPositionPreservingDesktopImeScroll = () => {
+		syncInputPosition();
+		scheduleDesktopImeScrollRestore();
+	};
+	const handleCompositionStart = () => {
+		captureDesktopImeScroll();
+		syncInputPositionPreservingDesktopImeScroll();
+	};
+	const handleCompositionUpdate = () => {
+		syncInputPositionPreservingDesktopImeScroll();
+	};
+	const handleCompositionEnd = () => {
+		syncInputPositionPreservingDesktopImeScroll();
+		releaseDesktopImeScroll();
+	};
+	const onFocus = () => {
+		syncInputPosition();
+		term.element.classList.add("focused");
+		options.onFocus?.();
+	};
+	const onBlur = () => {
+		clearImeReleaseTimer();
+		imeScrollLock = null;
+		term.element.classList.remove("focused");
+		options.onBlur?.();
+	};
+	textarea.addEventListener("focus", onFocus);
+	textarea.addEventListener("blur", onBlur);
+	textarea.addEventListener("beforeinput", syncInputPositionPreservingDesktopImeScroll, true);
+	textarea.addEventListener("compositionstart", handleCompositionStart, true);
+	textarea.addEventListener("compositionupdate", handleCompositionUpdate, true);
+	textarea.addEventListener("compositionend", handleCompositionEnd, true);
+	textarea.addEventListener("input", syncInputPositionPreservingDesktopImeScroll, true);
+	textarea.addEventListener("keydown", syncInputPositionPreservingDesktopImeScroll, true);
+	term.input = {
+		textarea,
+		focus() {
+			syncInputPosition();
+			textarea.focus({ preventScroll: true });
+		},
+		setImeAnchor(anchor) {
+			syncTerminalTextareaPosition(term, textarea, {
+				allowViewportAvoidance: shouldAllowImeViewportAvoidance(windowObject),
+				anchor
+			});
+		},
+		destroy() {
+			clearImeReleaseTimer();
+			if (imeRestoreFrame !== null) {
+				windowObject.cancelAnimationFrame(imeRestoreFrame);
+				imeRestoreFrame = null;
+			}
+			textarea.removeEventListener("focus", onFocus);
+			textarea.removeEventListener("blur", onBlur);
+			textarea.removeEventListener("beforeinput", syncInputPositionPreservingDesktopImeScroll, true);
+			textarea.removeEventListener("compositionstart", handleCompositionStart, true);
+			textarea.removeEventListener("compositionupdate", handleCompositionUpdate, true);
+			textarea.removeEventListener("compositionend", handleCompositionEnd, true);
+			textarea.removeEventListener("input", syncInputPositionPreservingDesktopImeScroll, true);
+			textarea.removeEventListener("keydown", syncInputPositionPreservingDesktopImeScroll, true);
+			term.element.classList.remove("focused");
+			delete term.element.dataset.aittyInputOwner;
+			textarea.remove();
+		}
+	};
+}
+function appendTerminalTextarea(terminalRoot, textarea) {
+	const body = terminalRoot.ownerDocument.body;
+	if (body) {
+		body.appendChild(textarea);
+		return;
+	}
+	terminalRoot.appendChild(textarea);
+}
+function shouldInstallMobileComposer(shell, windowObject) {
+	return shell.hasAttribute("data-aitty-mobile-composer") && isCoarseMobileViewport(windowObject);
+}
+function installMobileComposer(shell, terminalRoot, options) {
+	const doc = shell.ownerDocument;
+	const dock = doc.createElement("div");
+	const toggleButton = doc.createElement("button");
+	const controlList = doc.createElement("div");
+	const directionPad = doc.createElement("div");
+	let dockExpanded = false;
+	let dockDragState = null;
+	let dockPositionFrame = null;
+	let pendingDockPosition = null;
+	let directionModeActive = false;
+	let toggleLongPressState = null;
+	let suppressDockClickUntil = 0;
+	let terminalTapFocusState = null;
+	let composerEnabled = true;
+	dock.className = "aitty-mobile-control-dock";
+	dock.dataset.aittyMobileControlDock = "";
+	dock.style.setProperty("--aitty-mobile-dock-x", "calc(100vw - 78px - env(safe-area-inset-right))");
+	dock.style.setProperty("--aitty-mobile-dock-y", "calc(var(--shell-visual-viewport-offset-top, 0px) + var(--shell-visible-viewport-height, 100dvh) - 96px - env(safe-area-inset-bottom))");
+	dock.setAttribute("aria-label", "Mobile terminal controls");
+	toggleButton.className = "aitty-mobile-control-toggle";
+	toggleButton.type = "button";
+	toggleButton.setAttribute("aria-label", "Show terminal controls");
+	toggleButton.setAttribute("aria-expanded", "false");
+	toggleButton.innerHTML = "<span aria-hidden=\"true\"></span><span aria-hidden=\"true\"></span><span aria-hidden=\"true\"></span>";
+	controlList.className = "aitty-mobile-control-list";
+	for (const control of MOBILE_COMPOSER_PRIMARY_CONTROLS) {
+		const button = createMobileComposerButton(doc, control, resolveMobileComposerControlLabel(control));
+		if (control === "enter") button.classList.add("aitty-mobile-composer-enter");
+		controlList.append(button);
+	}
+	directionPad.className = "aitty-mobile-direction-pad";
+	directionPad.setAttribute("aria-label", "Arrow keys");
+	directionPad.append(createMobileDirectionButton(doc, "arrow-up", "Up", "↑"), createMobileDirectionButton(doc, "arrow-right", "Right", "→"), createMobileDirectionButton(doc, "arrow-down", "Down", "↓"), createMobileDirectionButton(doc, "arrow-left", "Left", "←"));
+	dock.append(controlList, directionPad, toggleButton);
+	shell.append(dock);
+	const applyDockPosition = (left, top) => {
+		dock.style.setProperty("--aitty-mobile-dock-x", `${Math.round(left)}px`);
+		dock.style.setProperty("--aitty-mobile-dock-y", `${Math.round(top)}px`);
+	};
+	const queueDockPosition = (left, top) => {
+		pendingDockPosition = {
+			left,
+			top
+		};
+		if (dockPositionFrame !== null) return;
+		dockPositionFrame = options.windowObject.requestAnimationFrame(() => {
+			dockPositionFrame = null;
+			if (!pendingDockPosition) return;
+			const nextPosition = pendingDockPosition;
+			pendingDockPosition = null;
+			applyDockPosition(nextPosition.left, nextPosition.top);
+		});
+	};
+	const flushDockPosition = () => {
+		if (!pendingDockPosition) return;
+		const nextPosition = pendingDockPosition;
+		pendingDockPosition = null;
+		if (dockPositionFrame !== null) {
+			options.windowObject.cancelAnimationFrame(dockPositionFrame);
+			dockPositionFrame = null;
+		}
+		applyDockPosition(nextPosition.left, nextPosition.top);
+	};
+	const syncDockExpandedState = () => {
+		dock.hidden = !composerEnabled;
+		dock.dataset.expanded = dockExpanded ? "true" : "false";
+		dock.dataset.directionMode = directionModeActive ? "true" : "false";
+		dock.dataset.enabled = composerEnabled ? "true" : "false";
+		toggleButton.disabled = !composerEnabled;
+		for (const button of dock.querySelectorAll("button")) button.disabled = !composerEnabled;
+		toggleButton.setAttribute("aria-expanded", String(dockExpanded || directionModeActive));
+		toggleButton.setAttribute("aria-label", directionModeActive ? "Hide arrow controls" : dockExpanded ? "Hide terminal controls" : "Show terminal controls");
+	};
+	const setDockExpanded = (expanded) => {
+		if (!composerEnabled) return;
+		dockExpanded = expanded;
+		if (expanded) directionModeActive = false;
+		syncDockExpandedState();
+		keepActiveDockInsideViewport();
+		scheduleDockViewportClamp();
+	};
+	const resolveVisibleDockBounds = () => {
+		const viewport = resolveBrowserViewport(options.windowObject);
+		const visibleHeight = Math.max(1, viewport.height - viewport.browserChromeInsetBottom);
+		return {
+			bottom: viewport.offsetTop + visibleHeight - MOBILE_COMPOSER_MARGIN_PX,
+			left: MOBILE_COMPOSER_MARGIN_PX,
+			right: viewport.width - MOBILE_COMPOSER_MARGIN_PX,
+			top: viewport.offsetTop + MOBILE_COMPOSER_MARGIN_PX
+		};
+	};
+	const resolveCurrentDockPosition = () => {
+		flushDockPosition();
+		const rect = dock.getBoundingClientRect();
+		return {
+			left: rect.left,
+			top: rect.top
+		};
+	};
+	const clampDockPosition = ({ dockHeight = MOBILE_COMPOSER_DOCK_SIZE_PX, dockWidth = MOBILE_COMPOSER_DOCK_SIZE_PX, minLeftOffset = 0, minTopOffset = 0, bottomOffset = 0, left, rightOffset = 0, top }) => {
+		const bounds = resolveVisibleDockBounds();
+		const minLeft = bounds.left + minLeftOffset;
+		const minTop = bounds.top + minTopOffset;
+		const maxLeft = Math.max(minLeft, bounds.right - dockWidth - rightOffset);
+		const maxTop = Math.max(minTop, bounds.bottom - dockHeight - bottomOffset);
+		return {
+			left: clamp(left, minLeft, maxLeft),
+			top: clamp(top, minTop, maxTop)
+		};
+	};
+	const keepCollapsedDockInsideViewport = () => {
+		const current = resolveCurrentDockPosition();
+		const next = clampDockPosition(current);
+		if (Math.abs(next.left - current.left) >= 1 || Math.abs(next.top - current.top) >= 1) applyDockPosition(next.left, next.top);
+	};
+	const keepExpandedControlsInsideViewport = () => {
+		const current = resolveCurrentDockPosition();
+		const listHeight = resolveMobileComposerExpandedListHeight();
+		const next = clampDockPosition({
+			...current,
+			minTopOffset: listHeight + MOBILE_COMPOSER_EXPANDED_GAP_PX
+		});
+		if (Math.abs(next.left - current.left) >= 1 || Math.abs(next.top - current.top) >= 1) applyDockPosition(next.left, next.top);
+	};
+	const keepDirectionPadInsideViewport = () => {
+		const current = resolveCurrentDockPosition();
+		const next = clampDockPosition({
+			...current,
+			bottomOffset: MOBILE_COMPOSER_DIRECTION_BOTTOM_OUTSET_PX,
+			minLeftOffset: MOBILE_COMPOSER_DIRECTION_OUTSET_PX,
+			minTopOffset: MOBILE_COMPOSER_DIRECTION_OUTSET_PX,
+			rightOffset: MOBILE_COMPOSER_DIRECTION_OUTSET_PX
+		});
+		if (Math.abs(next.left - current.left) >= 1 || Math.abs(next.top - current.top) >= 1) applyDockPosition(next.left, next.top);
+	};
+	const keepActiveDockInsideViewport = () => {
+		if (directionModeActive) {
+			keepDirectionPadInsideViewport();
+			return;
+		}
+		if (dockExpanded) {
+			keepExpandedControlsInsideViewport();
+			return;
+		}
+		keepCollapsedDockInsideViewport();
+	};
+	const scheduleDockViewportClamp = () => {
+		if (dockPositionFrame !== null) return;
+		dockPositionFrame = options.windowObject.requestAnimationFrame(() => {
+			dockPositionFrame = null;
+			keepActiveDockInsideViewport();
+		});
+	};
+	const setDirectionModeActive = (active) => {
+		if (!composerEnabled) return;
+		directionModeActive = active;
+		if (active) dockExpanded = false;
+		syncDockExpandedState();
+		keepActiveDockInsideViewport();
+	};
+	const open = () => {
+		if (!composerEnabled || terminalRoot.dataset.sessionInteractive === "false") return;
+		options.focusTerminal();
+	};
+	syncDockExpandedState();
+	const sendControl = (control) => {
+		if (!composerEnabled) return;
+		const hadTerminalFocus = isElementInside(doc.activeElement, terminalRoot);
+		options.sendData(resolveMobileComposerControlSequence(control));
+		if (!hadTerminalFocus && doc.activeElement instanceof HTMLElement && isElementInside(doc.activeElement, terminalRoot)) doc.activeElement.blur();
+	};
+	const activateControl = (control) => {
+		if (isMobileComposerDirectionControl(control)) setDirectionModeActive(true);
+		else setDockExpanded(false);
+		sendControl(control);
+	};
+	const activateToggle = () => {
+		if (!composerEnabled) return;
+		if (directionModeActive) {
+			setDirectionModeActive(false);
+			return;
+		}
+		setDockExpanded(!dockExpanded);
+	};
+	const resolvePointerAction = (target) => {
+		if (!(target instanceof Element)) return { kind: "none" };
+		if (target.closest(".aitty-mobile-control-toggle") === toggleButton) return { kind: "toggle" };
+		const controlButton = target.closest("[data-aitty-mobile-composer-control]");
+		if (!(controlButton instanceof HTMLButtonElement)) return { kind: "none" };
+		const control = controlButton.dataset.aittyMobileComposerControl;
+		return control ? {
+			kind: "control",
+			control
+		} : { kind: "none" };
+	};
+	const clearToggleLongPress = () => {
+		if (!toggleLongPressState) return;
+		options.windowObject.clearTimeout(toggleLongPressState.timer);
+		toggleLongPressState = null;
+	};
+	const startToggleLongPress = (event) => {
+		if (directionModeActive || !(event.target instanceof Element) || !event.target.closest(".aitty-mobile-control-toggle")) return;
+		clearToggleLongPress();
+		const pointerId = event.pointerId;
+		const timer = options.windowObject.setTimeout(() => {
+			if (!toggleLongPressState || toggleLongPressState.pointerId !== pointerId) return;
+			toggleLongPressState.triggered = true;
+			setDirectionModeActive(true);
+		}, MOBILE_COMPOSER_DIRECTION_LONG_PRESS_MS);
+		toggleLongPressState = {
+			pointerId,
+			startX: event.clientX,
+			startY: event.clientY,
+			timer,
+			triggered: false
+		};
+	};
+	const cancelToggleLongPressOnMove = (event) => {
+		if (!toggleLongPressState || toggleLongPressState.pointerId !== event.pointerId) return;
+		if (Math.hypot(event.clientX - toggleLongPressState.startX, event.clientY - toggleLongPressState.startY) >= MOBILE_COMPOSER_TAP_SLOP_PX) clearToggleLongPress();
+	};
+	const onShellPointerDown = (event) => {
+		if (event.defaultPrevented || !isCoarseMobileViewport(options.windowObject)) return;
+		const target = event.target;
+		if (target instanceof Element && target.closest("[data-shell-control], .aitty-mobile-control-dock")) return;
+		if (!isElementInside(target, terminalRoot) && !isElementInside(target, shell)) {
+			terminalTapFocusState = null;
+			return;
+		}
+		if (hasTerminalSelection(terminalRoot) || !isMobileLiveInputTapTarget(terminalRoot, options.windowObject, event.clientX, event.clientY)) {
+			terminalTapFocusState = null;
+			return;
+		}
+		terminalTapFocusState = {
+			pointerId: event.pointerId,
+			startTime: options.windowObject.performance.now(),
+			startX: event.clientX,
+			startY: event.clientY
+		};
+	};
+	const onShellPointerMove = (event) => {
+		if (!terminalTapFocusState || terminalTapFocusState.pointerId !== event.pointerId) return;
+		if (Math.hypot(event.clientX - terminalTapFocusState.startX, event.clientY - terminalTapFocusState.startY) >= 8) terminalTapFocusState = null;
+	};
+	const onShellPointerUp = (event) => {
+		if (!terminalTapFocusState || terminalTapFocusState.pointerId !== event.pointerId) return;
+		const tapState = terminalTapFocusState;
+		terminalTapFocusState = null;
+		if (Math.hypot(event.clientX - tapState.startX, event.clientY - tapState.startY) >= 8) return;
+		const pressedForMs = options.windowObject.performance.now() - tapState.startTime;
+		const isLiveInputTarget = isMobileLiveInputTapTarget(terminalRoot, options.windowObject, event.clientX, event.clientY);
+		if (hasTerminalSelection(terminalRoot) || !isLiveInputTarget) return;
+		if (pressedForMs >= MOBILE_COMPOSER_DIRECTION_LONG_PRESS_MS) return;
+		options.focusTerminal();
+	};
+	const onShellPointerCancel = (event) => {
+		if (terminalTapFocusState?.pointerId === event.pointerId) terminalTapFocusState = null;
+	};
+	const onControlClick = (event) => {
+		event.preventDefault();
+		if (suppressDockClickUntil > options.windowObject.performance.now()) return;
+		const target = event.target;
+		if (!(target instanceof HTMLButtonElement)) return;
+		if (dockDragState?.moved) return;
+		const control = target.dataset.aittyMobileComposerControl;
+		if (!control) return;
+		activateControl(control);
+	};
+	const onToggleClick = (event) => {
+		event.preventDefault();
+		if (suppressDockClickUntil > options.windowObject.performance.now()) return;
+		if (dockDragState?.moved) return;
+		activateToggle();
+	};
+	const onDockPointerDown = (event) => {
+		if (!composerEnabled || event.button > 0 || !isCoarseMobileViewport(options.windowObject)) return;
+		event.preventDefault();
+		flushDockPosition();
+		const rect = dock.getBoundingClientRect();
+		dockDragState = {
+			action: resolvePointerAction(event.target),
+			dockHeight: rect.height || MOBILE_COMPOSER_DOCK_SIZE_PX,
+			dockWidth: rect.width || MOBILE_COMPOSER_DOCK_SIZE_PX,
+			moved: false,
+			originLeft: rect.left,
+			originTop: rect.top,
+			pointerId: event.pointerId,
+			startX: event.clientX,
+			startY: event.clientY
+		};
+		startToggleLongPress(event);
+		try {
+			dock.setPointerCapture?.(event.pointerId);
+		} catch {}
+		dock.dataset.dragging = "true";
+	};
+	const onDockPointerMove = (event) => {
+		if (!dockDragState || dockDragState.pointerId !== event.pointerId) return;
+		const deltaX = event.clientX - dockDragState.startX;
+		const deltaY = event.clientY - dockDragState.startY;
+		cancelToggleLongPressOnMove(event);
+		if (!dockDragState.moved && Math.hypot(deltaX, deltaY) < MOBILE_COMPOSER_TAP_SLOP_PX) return;
+		dockDragState.moved = true;
+		const bounds = resolveVisibleDockBounds();
+		const maxLeft = Math.max(bounds.left, bounds.right - dockDragState.dockWidth);
+		const maxTop = Math.max(bounds.top, bounds.bottom - dockDragState.dockHeight);
+		queueDockPosition(clamp(dockDragState.originLeft + deltaX, bounds.left, maxLeft), clamp(dockDragState.originTop + deltaY, bounds.top, maxTop));
+		event.preventDefault();
+	};
+	const onDockPointerEnd = (event) => {
+		if (!dockDragState || dockDragState.pointerId !== event.pointerId) return;
+		const cancelled = event.type === "pointercancel";
+		try {
+			dock.releasePointerCapture?.(event.pointerId);
+		} catch {}
+		if (toggleLongPressState?.pointerId === event.pointerId && toggleLongPressState.triggered) {
+			suppressDockClickUntil = options.windowObject.performance.now() + MOBILE_COMPOSER_CLICK_SUPPRESS_MS;
+			options.windowObject.setTimeout(() => {
+				clearToggleLongPress();
+			}, 0);
+		} else clearToggleLongPress();
+		if (cancelled) suppressDockClickUntil = options.windowObject.performance.now() + MOBILE_COMPOSER_CLICK_SUPPRESS_MS;
+		else if (dockDragState.moved) {
+			flushDockPosition();
+			keepActiveDockInsideViewport();
+			suppressDockClickUntil = options.windowObject.performance.now() + MOBILE_COMPOSER_CLICK_SUPPRESS_MS;
+			event.preventDefault();
+		} else if (suppressDockClickUntil <= options.windowObject.performance.now()) {
+			if (dockDragState.action.kind === "toggle") {
+				activateToggle();
+				suppressDockClickUntil = options.windowObject.performance.now() + MOBILE_COMPOSER_CLICK_SUPPRESS_MS;
+				event.preventDefault();
+			} else if (dockDragState.action.kind === "control") {
+				activateControl(dockDragState.action.control);
+				suppressDockClickUntil = options.windowObject.performance.now() + MOBILE_COMPOSER_CLICK_SUPPRESS_MS;
+				event.preventDefault();
+			}
+		}
+		delete dock.dataset.dragging;
+		options.windowObject.setTimeout(() => {
+			dockDragState = null;
+		}, 0);
+	};
+	shell.addEventListener("pointerdown", onShellPointerDown, true);
+	shell.addEventListener("pointermove", onShellPointerMove, true);
+	shell.addEventListener("pointerup", onShellPointerUp, true);
+	shell.addEventListener("pointercancel", onShellPointerCancel, true);
+	toggleButton.addEventListener("click", onToggleClick);
+	controlList.addEventListener("click", onControlClick);
+	directionPad.addEventListener("click", onControlClick);
+	dock.addEventListener("pointerdown", onDockPointerDown);
+	dock.addEventListener("pointermove", onDockPointerMove);
+	dock.addEventListener("pointerup", onDockPointerEnd);
+	dock.addEventListener("pointercancel", onDockPointerEnd);
+	options.windowObject.visualViewport?.addEventListener("resize", scheduleDockViewportClamp);
+	options.windowObject.visualViewport?.addEventListener("scroll", scheduleDockViewportClamp);
+	return {
+		destroy() {
+			shell.removeEventListener("pointerdown", onShellPointerDown, true);
+			shell.removeEventListener("pointermove", onShellPointerMove, true);
+			shell.removeEventListener("pointerup", onShellPointerUp, true);
+			shell.removeEventListener("pointercancel", onShellPointerCancel, true);
+			toggleButton.removeEventListener("click", onToggleClick);
+			controlList.removeEventListener("click", onControlClick);
+			directionPad.removeEventListener("click", onControlClick);
+			dock.removeEventListener("pointerdown", onDockPointerDown);
+			dock.removeEventListener("pointermove", onDockPointerMove);
+			dock.removeEventListener("pointerup", onDockPointerEnd);
+			dock.removeEventListener("pointercancel", onDockPointerEnd);
+			options.windowObject.visualViewport?.removeEventListener("resize", scheduleDockViewportClamp);
+			options.windowObject.visualViewport?.removeEventListener("scroll", scheduleDockViewportClamp);
+			clearToggleLongPress();
+			if (dockPositionFrame !== null) {
+				options.windowObject.cancelAnimationFrame(dockPositionFrame);
+				dockPositionFrame = null;
+			}
+			dock.remove();
+		},
+		focus() {
+			open();
+		},
+		setEnabled(enabled) {
+			if (composerEnabled === enabled) return;
+			composerEnabled = enabled;
+			if (!enabled) {
+				dockExpanded = false;
+				directionModeActive = false;
+				dockDragState = null;
+				terminalTapFocusState = null;
+				clearToggleLongPress();
+				delete dock.dataset.dragging;
+			}
+			syncDockExpandedState();
+		}
+	};
+}
+function installTakeoverNotice(shell, windowObject, options) {
+	const doc = shell.ownerDocument;
+	const notice = resolveTakeoverApprovalElement(shell);
+	const message = notice.querySelector("[data-aitty-takeover-message]");
+	const allowButton = notice.querySelector("[data-aitty-takeover-allow]");
+	const denyButton = notice.querySelector("[data-aitty-takeover-deny]");
+	const enableNotificationsButton = resolveNotificationEnableButton(shell);
+	const pushPublicKey = resolvePushPublicKey(doc);
+	let permissionPromptEnabled = false;
+	let activeRequest = null;
+	let timeoutHandle = null;
+	let systemNotification = null;
+	let activePushEndpoint = null;
+	let pushRegistrationInFlight = false;
+	let lastAutoRegisteredRole = null;
+	const clearTimer = () => {
+		if (timeoutHandle !== null) {
+			windowObject.clearTimeout(timeoutHandle);
+			timeoutHandle = null;
+		}
+	};
+	const closeSystemNotification = () => {
+		systemNotification?.close?.();
+		systemNotification = null;
+	};
+	const hide = () => {
+		clearTimer();
+		closeSystemNotification();
+		activeRequest = null;
+		notice.hidden = true;
+	};
+	const respond = (approved) => {
+		const request = activeRequest;
+		if (!request) {
+			hide();
+			return;
+		}
+		options.onRespond(request.requestId, approved);
+		hide();
+	};
+	const focusWindow = () => {
+		windowObject.focus?.();
+		notice.scrollIntoView?.({
+			block: "nearest",
+			inline: "nearest"
+		});
+	};
+	const showSystemNotification = (request) => {
+		const NotificationConstructor = windowObject.Notification;
+		if (typeof NotificationConstructor !== "function" || NotificationConstructor.permission !== "granted" || doc.visibilityState !== "hidden") return;
+		try {
+			closeSystemNotification();
+			systemNotification = new NotificationConstructor("Terminal control requested", {
+				body: `${formatTakeoverRequester(request)} wants to control this terminal. Click to review.`,
+				tag: "aitty-takeover-request"
+			});
+			systemNotification.onclick = () => {
+				focusWindow();
+				closeSystemNotification();
+			};
+		} catch {
+			closeSystemNotification();
+		}
+	};
+	const hasNotificationPermission = () => {
+		const NotificationConstructor = windowObject.Notification;
+		return typeof NotificationConstructor === "function" && NotificationConstructor.permission === "granted";
+	};
+	const requestNotificationPermission = async () => {
+		const NotificationConstructor = windowObject.Notification;
+		if (typeof NotificationConstructor !== "function" || NotificationConstructor.permission !== "default") return;
+		await NotificationConstructor.requestPermission?.();
+	};
+	const registerPushNotifications = async () => {
+		if (pushRegistrationInFlight || activePushEndpoint || options.getClientRole() !== "controller") return;
+		pushRegistrationInFlight = true;
+		try {
+			const subscription = await subscribeBrowserPush(windowObject, pushPublicKey);
+			if (!subscription) return;
+			const payload = normalizePushSubscription(subscription.toJSON());
+			if (!payload) return;
+			activePushEndpoint = payload.endpoint;
+			options.sendControl(createPushSubscribeControlFrame({
+				subscription: payload,
+				url: windowObject.location?.href
+			}));
+		} finally {
+			pushRegistrationInFlight = false;
+		}
+	};
+	const syncNotificationPermissionControl = () => {
+		if (!enableNotificationsButton) return;
+		const NotificationConstructor = windowObject.Notification;
+		const canRequestPageNotification = typeof NotificationConstructor === "function" && NotificationConstructor.permission === "default";
+		const canRequestPush = Boolean(pushPublicKey) && canUseBrowserPush(windowObject) && activePushEndpoint === null && options.getClientRole() === "controller";
+		enableNotificationsButton.hidden = !(permissionPromptEnabled && options.getClientRole() === "controller" && (canRequestPageNotification || canRequestPush));
+		enableNotificationsButton.disabled = pushRegistrationInFlight;
+		enableNotificationsButton.textContent = pushRegistrationInFlight ? "Enabling alerts..." : "Enable alerts";
+		enableNotificationsButton.setAttribute("aria-label", "Enable takeover alerts for this controller");
+	};
+	const syncNotificationState = () => {
+		if (options.getClientRole() === "controller" && hasNotificationPermission()) registerPushNotifications().catch(() => void 0).finally(() => syncNotificationPermissionControl());
+		syncNotificationPermissionControl();
+	};
+	const onAllow = (event) => {
+		event.preventDefault();
+		respond(true);
+	};
+	const onDeny = (event) => {
+		event.preventDefault();
+		respond(false);
 	};
-	const onFocus = () => {
-		syncInputPosition();
-		term.element.classList.add("focused");
+	const onVisibilityChange = () => {
+		const request = activeRequest;
+		if (request && doc.visibilityState === "hidden") showSystemNotification(request);
 	};
-	const onBlur = () => {
-		term.element.classList.remove("focused");
+	const onEnableNotifications = (event) => {
+		event.preventDefault();
+		requestNotificationPermission().then(() => registerPushNotifications()).catch(() => void 0).finally(() => syncNotificationPermissionControl());
+		syncNotificationPermissionControl();
 	};
-	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 });
-		},
+	allowButton?.addEventListener("click", onAllow);
+	denyButton?.addEventListener("click", onDeny);
+	enableNotificationsButton?.addEventListener("click", onEnableNotifications);
+	doc.addEventListener("visibilitychange", onVisibilityChange);
+	return {
 		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();
+			hide();
+			if (activePushEndpoint) {
+				options.sendControl(createPushUnsubscribeControlFrame({ endpoint: activePushEndpoint }));
+				activePushEndpoint = null;
+			}
+			allowButton?.removeEventListener("click", onAllow);
+			denyButton?.removeEventListener("click", onDeny);
+			enableNotificationsButton?.removeEventListener("click", onEnableNotifications);
+			doc.removeEventListener("visibilitychange", onVisibilityChange);
+		},
+		show(request) {
+			activeRequest = request;
+			notice.hidden = false;
+			if (message) message.textContent = `${formatTakeoverRequester(request)} wants to control this terminal. Approve only if you intend to hand off input.`;
+			syncNotificationPermissionControl();
+			clearTimer();
+			timeoutHandle = windowObject.setTimeout(() => {
+				respond(false);
+			}, TAKEOVER_NOTICE_TIMEOUT_MS);
+			showSystemNotification(request);
+		},
+		syncClient() {
+			const role = options.getClientRole();
+			if (role !== lastAutoRegisteredRole) {
+				lastAutoRegisteredRole = role;
+				syncNotificationState();
+				return;
+			}
+			syncNotificationPermissionControl();
+		},
+		syncNotificationControl() {
+			syncNotificationPermissionControl();
+		},
+		syncPermissionPrompt(enabled) {
+			const wasEnabled = permissionPromptEnabled;
+			const role = options.getClientRole();
+			if (role !== lastAutoRegisteredRole) lastAutoRegisteredRole = role;
+			permissionPromptEnabled = enabled;
+			if (!wasEnabled && enabled && hasNotificationPermission()) {
+				syncNotificationState();
+				return;
+			}
+			syncNotificationPermissionControl();
+		}
+	};
+}
+function resolveNotificationEnableButton(shell) {
+	const existing = shell.querySelector("[data-aitty-notification-enable]");
+	if (existing) return existing;
+	const statusActions = shell.querySelector(".shell-status-actions");
+	if (!statusActions) return null;
+	const button = shell.ownerDocument.createElement("button");
+	button.className = "notification-enable-button";
+	button.dataset.aittyNotificationEnable = "";
+	button.hidden = true;
+	button.type = "button";
+	button.textContent = "Enable alerts";
+	statusActions.append(button);
+	return button;
+}
+function resolvePushPublicKey(doc) {
+	const key = doc.querySelector("meta[name=\"aitty-vapid-public-key\"]")?.content.trim();
+	return key ? key : null;
+}
+function canUseBrowserPush(windowObject) {
+	const navigatorLike = windowObject.navigator;
+	return Boolean(windowObject.isSecureContext && navigatorLike.serviceWorker && "PushManager" in windowObject && typeof navigatorLike.serviceWorker.register === "function");
+}
+async function subscribeBrowserPush(windowObject, publicKey) {
+	if (!publicKey || !canUseBrowserPush(windowObject)) return null;
+	const registration = await windowObject.navigator.serviceWorker.register("/assets/aitty-sw.js", { scope: "/" });
+	const existing = await registration.pushManager.getSubscription();
+	if (existing) return existing;
+	return registration.pushManager.subscribe({
+		applicationServerKey: urlBase64ToArrayBuffer(publicKey),
+		userVisibleOnly: true
+	});
+}
+function normalizePushSubscription(subscription) {
+	if (typeof subscription.endpoint !== "string" || !subscription.endpoint || !subscription.keys || typeof subscription.keys.auth !== "string" || !subscription.keys.auth || typeof subscription.keys.p256dh !== "string" || !subscription.keys.p256dh) return null;
+	return {
+		endpoint: subscription.endpoint,
+		expirationTime: typeof subscription.expirationTime === "number" ? subscription.expirationTime : null,
+		keys: {
+			auth: subscription.keys.auth,
+			p256dh: subscription.keys.p256dh
 		}
 	};
 }
+function urlBase64ToArrayBuffer(value) {
+	const base64 = `${value}${"=".repeat((4 - value.length % 4) % 4)}`.replace(/-/g, "+").replace(/_/g, "/");
+	const raw = atob(base64);
+	const output = new Uint8Array(raw.length);
+	for (let index = 0; index < raw.length; index += 1) output[index] = raw.charCodeAt(index);
+	return output.buffer;
+}
+function resolveTakeoverApprovalElement(shell) {
+	const existing = shell.querySelector("[data-aitty-takeover-approval]");
+	if (existing) return existing;
+	const notice = shell.ownerDocument.createElement("section");
+	notice.className = "takeover-approval";
+	notice.dataset.aittyTakeoverApproval = "";
+	notice.hidden = true;
+	notice.setAttribute("aria-live", "polite");
+	notice.innerHTML = [
+		"<strong>Terminal control requested</strong>",
+		"<p data-aitty-takeover-message>Another browser wants to control this terminal.</p>",
+		"<div class=\"takeover-approval-actions\">",
+		"<button type=\"button\" data-aitty-takeover-deny>Deny</button>",
+		"<button type=\"button\" data-aitty-takeover-allow>Allow</button>",
+		"</div>"
+	].join("");
+	shell.append(notice);
+	return notice;
+}
+function formatTakeoverRequester(request) {
+	return request.requesterId ? `Browser ${request.requesterId}` : "Another browser";
+}
+function resolveTakeoverResultMessage(reason) {
+	switch (reason) {
+		case "controller-disconnected": return "Control request expired because the controller disconnected.";
+		case "controller-suspended": return "Controller is reconnecting. Try again shortly.";
+		case "pending": return "Control request already pending.";
+		case "rejected": return "Control request rejected.";
+		default: return "Control request failed.";
+	}
+}
+function createMobileComposerButton(doc, control, label) {
+	const button = doc.createElement("button");
+	button.className = "aitty-mobile-composer-button";
+	button.dataset.aittyMobileComposerControl = control;
+	button.type = "button";
+	button.textContent = label;
+	return button;
+}
+function resolveMobileComposerControlLabel(control) {
+	if (control === "enter") return "Enter";
+	if (control === "esc") return "Esc";
+	if (control === "tab") return "Tab";
+	return control.replace("arrow-", "");
+}
+function createMobileDirectionButton(doc, control, label, glyph) {
+	const button = createMobileComposerButton(doc, control, glyph);
+	button.classList.add("aitty-mobile-direction-button", `aitty-mobile-direction-${control.replace("arrow-", "")}`);
+	button.setAttribute("aria-label", `${label} arrow`);
+	return button;
+}
+function isCoarseMobileViewport(windowObject) {
+	return (firstFinitePositiveNumber(windowObject.visualViewport?.width, windowObject.innerWidth, windowObject.document?.documentElement?.clientWidth) ?? Number.POSITIVE_INFINITY) <= 768 && windowObject.matchMedia?.("(pointer: coarse)").matches === true;
+}
 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("inputmode", "text");
 	textarea.setAttribute("tabindex", "0");
 	textarea.setAttribute("aria-hidden", "true");
+	textarea.dataset.aittyInput = "";
 	const style = textarea.style;
 	style.position = "fixed";
 	style.left = "0";
 	style.top = "0";
-	style.width = "1px";
-	style.height = "1px";
-	style.opacity = "0";
+	style.zIndex = "1400";
+	style.width = "2px";
+	style.height = "2px";
+	style.opacity = "0.01";
 	style.overflow = "hidden";
 	style.border = "0";
 	style.padding = "0";
 	style.margin = "0";
 	style.outline = "none";
 	style.resize = "none";
+	style.boxSizing = "border-box";
+	style.fontSize = "16px";
+	style.lineHeight = "16px";
 	style.pointerEvents = "none";
+	style.touchAction = "manipulation";
+	style.userSelect = "text";
+	style.setProperty("-webkit-touch-callout", "default");
+	style.setProperty("-webkit-user-select", "text");
 	style.caretColor = "transparent";
 	style.color = "transparent";
 	style.background = "transparent";
+	style.colorScheme = "inherit";
+	suppressNativeTextareaChrome(textarea);
+}
+function suppressNativeTextareaChrome(textarea) {
+	const style = textarea.style;
+	style.borderRadius = "0";
+	style.boxShadow = "none";
+	style.textDecoration = "none";
+	style.setProperty("appearance", "none");
+	style.setProperty("-webkit-appearance", "none");
+	style.setProperty("-webkit-text-fill-color", "transparent");
+	style.setProperty("outline-color", "transparent");
+	style.setProperty("text-decoration", "none");
+	style.setProperty("text-decoration-color", "transparent");
+	style.setProperty("text-decoration-line", "none");
+}
+function resolveMobileLiveInputAnchorRect(windowObject) {
+	const doc = windowObject.document;
+	if (typeof doc?.querySelector !== "function") return null;
+	const owner = doc.querySelector("[data-terminal-root][data-aitty-input-owner]");
+	if (!isTerminalRootLike(owner)) return null;
+	const rect = resolveLiveInputSurfaceAnchor(owner)?.getBoundingClientRect?.();
+	return rect && hasUsableClientRect(rect) ? rect : null;
 }
-function syncTerminalTextareaPosition(term, textarea) {
+function isTerminalRootLike(value) {
+	return typeof value === "object" && value !== null && "querySelectorAll" in value && typeof value.querySelectorAll === "function";
+}
+function syncTerminalTextareaPosition(term, textarea, options = {}) {
+	const windowObject = textarea.ownerDocument.defaultView;
 	const viewport = resolveTextareaViewport(textarea);
-	const anchorRect = (resolveLiveInputSurfaceAnchor(term.element) ?? term.element).getBoundingClientRect?.();
+	const anchorRect = (options.anchor ?? 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";
+	if (options.allowViewportAvoidance !== true) {
+		textarea.dataset.aittyImeAnchor = "safe-cursor";
+		textarea.style.width = "2px";
+		textarea.style.height = "2px";
+		textarea.style.opacity = "0.01";
+		textarea.style.padding = "0";
+		textarea.style.fontSize = "16px";
+		textarea.style.lineHeight = "16px";
+		textarea.style.pointerEvents = "none";
+		textarea.style.touchAction = "manipulation";
+		textarea.style.caretColor = "transparent";
+		textarea.style.color = "transparent";
+		textarea.style.background = "transparent";
+		suppressNativeTextareaChrome(textarea);
+		if (!hasUsableClientRect(rect)) {
+			textarea.style.left = `${Math.min(DESKTOP_IME_TEXTAREA_INSET_PX, Math.max(0, viewport.width - 1))}px`;
+			textarea.style.top = `${Math.min(DESKTOP_IME_TEXTAREA_INSET_PX, Math.max(0, viewport.height - 1))}px`;
+			return;
+		}
+		const safeMaxLeft = Math.max(DESKTOP_IME_TEXTAREA_INSET_PX, viewport.width - DESKTOP_IME_CANDIDATE_SAFE_WIDTH_PX);
+		const safeMaxTop = Math.max(DESKTOP_IME_TEXTAREA_INSET_PX, viewport.height - DESKTOP_IME_CANDIDATE_SAFE_HEIGHT_PX);
+		const left = clamp(rect.left, DESKTOP_IME_TEXTAREA_INSET_PX, safeMaxLeft);
+		const top = clamp(rect.top, DESKTOP_IME_TEXTAREA_INSET_PX, safeMaxTop);
+		textarea.style.left = `${left}px`;
+		textarea.style.top = `${top}px`;
 		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.dataset.aittyImeAnchor = "mobile-focus-proxy";
+	const proxyPosition = windowObject ? resolveMobileFocusProxyPosition(windowObject) : {
+		anchor: "mobile-focus-proxy",
+		height: MOBILE_FOCUS_PROXY_HEIGHT_PX,
+		left: 0,
+		top: 0,
+		width: MOBILE_FOCUS_PROXY_MIN_WIDTH_PX
+	};
+	const left = clamp(proxyPosition.left, 0, Math.max(0, viewport.width - proxyPosition.width));
+	const top = clamp(proxyPosition.top, 0, Math.max(0, viewport.height - proxyPosition.height));
 	textarea.style.left = `${left}px`;
 	textarea.style.top = `${top}px`;
+	textarea.style.width = `${proxyPosition.width}px`;
+	textarea.style.height = `${proxyPosition.height}px`;
+	textarea.style.opacity = MOBILE_FOCUS_PROXY_OPACITY;
+	textarea.style.padding = "0";
+	textarea.style.fontSize = "16px";
+	textarea.style.lineHeight = "16px";
+	const mobileViewport = isCoarseMobileViewport(windowObject ?? window);
+	const keyboardOpen = windowObject ? resolveBrowserViewport(windowObject).keyboardInsetBottom > 0 : false;
+	const textareaFocused = textarea.ownerDocument.activeElement === textarea;
+	const proxyPointerEvents = windowObject && shouldEnableMobileFocusProxyPointerEvents(windowObject, {
+		keyboardOpen,
+		textareaFocused
+	}) && !hasTerminalSelection(term.element);
+	textarea.style.pointerEvents = mobileViewport && proxyPointerEvents ? "auto" : "none";
+	textarea.style.touchAction = "manipulation";
+	textarea.style.caretColor = "transparent";
+	textarea.style.color = "transparent";
+	textarea.style.background = "transparent";
+	suppressNativeTextareaChrome(textarea);
+}
+function captureImeScrollLock(windowObject, surface) {
+	const doc = windowObject.document;
+	const targets = /* @__PURE__ */ new Set();
+	if (surface instanceof HTMLElement) targets.add(surface);
+	if (doc?.scrollingElement) targets.add(doc.scrollingElement);
+	if (doc?.documentElement) targets.add(doc.documentElement);
+	if (doc?.body) targets.add(doc.body);
+	return {
+		scrollTargets: Array.from(targets).map((element) => ({
+			element,
+			scrollLeft: element.scrollLeft,
+			scrollTop: element.scrollTop
+		})),
+		windowObject,
+		windowScrollX: normalizeScrollMetric(windowObject.scrollX ?? windowObject.pageXOffset ?? 0),
+		windowScrollY: normalizeScrollMetric(windowObject.scrollY ?? windowObject.pageYOffset ?? 0)
+	};
+}
+function restoreImeScrollLock(lock) {
+	for (const target of lock.scrollTargets) {
+		target.element.scrollLeft = target.scrollLeft;
+		target.element.scrollTop = target.scrollTop;
+	}
+	try {
+		lock.windowObject.scrollTo(lock.windowScrollX, lock.windowScrollY);
+	} catch {}
 }
 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;
+	if (view) {
+		const viewport = resolveBrowserViewport(view);
+		return {
+			height: viewport.safeHeight,
+			width: viewport.width
+		};
+	}
 	return {
-		height: firstFinitePositiveNumber(view?.innerHeight, root?.clientHeight, body?.clientHeight) ?? 1,
-		width
+		height: 1,
+		width: 1
 	};
 }
-function installBrowserRenderer(term, styleTracker) {
+function shouldAllowImeViewportAvoidance(windowObject) {
+	const root = windowObject.document?.documentElement;
+	const layoutWidth = firstFinitePositiveNumber(windowObject.innerWidth, root?.clientWidth) ?? 1;
+	const layoutHeight = firstFinitePositiveNumber(windowObject.innerHeight, root?.clientHeight) ?? 1;
+	const visualHeight = windowObject.visualViewport?.height;
+	const viewportShrunkForKeyboard = typeof visualHeight === "number" && Number.isFinite(visualHeight) && visualHeight > 0 && visualHeight < layoutHeight * .85;
+	const primaryPointerIsCoarse = windowObject.matchMedia?.("(pointer: coarse)").matches === true;
+	return viewportShrunkForKeyboard || primaryPointerIsCoarse && layoutWidth <= 1024;
+}
+function installBrowserRenderer(term, options = {}) {
 	const container = term?._container;
 	if (!(container instanceof HTMLElement)) return;
-	const renderer = new BrowserTerminalRenderer(container, styleTracker);
+	const renderer = new BrowserTerminalRenderer(container, options);
 	term.renderer = renderer;
 	renderer.setup(term.cols, term.rows);
 	if (term.bridge) renderer.render(term.bridge);
 }
 function renderTerminalNow(term, options = {}) {
+	if (typeof term?.renderNow === "function") {
+		term.renderNow(options);
+		return;
+	}
 	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);
+function installTerminalViewportSizer(term, terminalRoot, windowObject, onResize, shouldResizeToViewport = () => true, onViewportChange = () => {}) {
+	const resizeToViewport = () => {
+		if (!shouldResizeToViewport()) {
+			onViewportChange();
+			return;
+		}
+		const target = resolveViewportSize(term, terminalRoot, windowObject);
+		applyTerminalElementHeight(terminalRoot, target.rows);
+		onResize(target.cols, target.rows);
+	};
+	resizeToViewport();
 	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);
+			if (resolveBrowserViewport(windowObject).keyboardInsetBottom > 0) return;
+			resizeToViewport();
 		});
 	};
 	windowObject.addEventListener("resize", scheduleResize);
+	windowObject.visualViewport?.addEventListener("resize", scheduleResize);
+	windowObject.visualViewport?.addEventListener("scroll", scheduleResize);
 	return () => {
 		if (frameHandle !== null) {
 			windowObject.cancelAnimationFrame(frameHandle);
 			frameHandle = null;
 		}
 		windowObject.removeEventListener("resize", scheduleResize);
+		windowObject.visualViewport?.removeEventListener("resize", scheduleResize);
+		windowObject.visualViewport?.removeEventListener("scroll", scheduleResize);
 	};
 }
 function resolveViewportSize(term, terminalRoot, windowObject) {
@@ -1027,28 +2817,50 @@ function resolveViewportSize(term, terminalRoot, windowObject) {
 	};
 }
 function measureTerminalCell(term, terminalRoot) {
+	const rowHeight = syncTerminalRowHeight(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;
+	if (measured && Number.isFinite(measured.charWidth) && measured.charWidth > 0 && rowHeight > 0) {
+		terminalRoot.style.setProperty("--term-cell-width", `${measured.charWidth}px`);
+		return {
+			charWidth: measured.charWidth,
+			rowHeight
+		};
 	}
-	const computedStyle = getComputedStyle(terminalRoot);
-	const rowHeight = parseCssPixelValue(computedStyle.getPropertyValue("--term-row-height")) || parseCssPixelValue(computedStyle.lineHeight) || 17;
-	const fontSize = parseCssPixelValue(computedStyle.fontSize) || 15;
+	const fontSize = parseCssPixelValue(getComputedStyle(terminalRoot).fontSize) || 15;
+	const charWidth = Math.max(1, fontSize * .6);
+	terminalRoot.style.setProperty("--term-cell-width", `${charWidth}px`);
 	return {
-		charWidth: Math.max(1, fontSize * .6),
-		rowHeight: Math.max(1, rowHeight)
+		charWidth,
+		rowHeight
 	};
 }
+function syncTerminalRowHeight(terminalRoot) {
+	const computedStyle = getComputedStyle(terminalRoot);
+	const fontSize = parseCssPixelValue(computedStyle.fontSize) || DEFAULT_TERMINAL_RENDER_FONT_SIZE;
+	const configuredLineHeight = computedStyle.lineHeight;
+	const rowHeight = configuredLineHeight === "normal" ? Math.ceil(fontSize * 1.2) : Math.ceil(parseCssPixelValue(configuredLineHeight) || fontSize * 1.2);
+	const normalizedRowHeight = Math.max(1, rowHeight);
+	terminalRoot.style.setProperty("--term-row-height", `${normalizedRowHeight}px`);
+	return normalizedRowHeight;
+}
 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;
+	const borderBoxWidth = Number.isFinite(rect?.width) && rect.width > 0 ? rect.width : 0;
+	const scrollViewport = terminalRoot.closest("[data-aitty-scroll-viewport]");
+	const scrollViewportRect = scrollViewport instanceof HTMLElement ? scrollViewport.getBoundingClientRect?.() : null;
+	const shell = terminalRoot.closest("[data-shell]");
+	const scrollViewportHeight = scrollViewportRect && hasUsableClientRect(scrollViewportRect) && Number.isFinite(scrollViewportRect.height) && scrollViewportRect.height > 0 ? scrollViewportRect.height : 0;
+	const isDocumentViewport = !scrollViewportHeight || shell?.dataset.fullscreen === "true" || shell?.dataset.viewportFullscreen === "true";
+	if (borderBoxWidth <= 0 || !Number.isFinite(rect?.top)) return null;
+	const viewportHeight = isDocumentViewport ? Math.max(1, resolveBrowserViewport(windowObject).safeHeight) : scrollViewportHeight;
+	const computedStyle = getComputedStyle(terminalRoot);
+	const paddingLeft = parseCssPixelValue(computedStyle.paddingLeft);
+	const paddingRight = parseCssPixelValue(computedStyle.paddingRight);
+	const paddingTop = parseCssPixelValue(computedStyle.paddingTop);
+	const paddingBottom = parseCssPixelValue(computedStyle.paddingBottom);
+	const width = borderBoxWidth - paddingLeft - paddingRight;
+	const height = viewportHeight - (isDocumentViewport ? Math.max(0, rect.top + paddingTop) : paddingTop) - paddingBottom;
+	if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(height) || height <= 0) return null;
 	return {
 		height,
 		width
@@ -1061,6 +2873,27 @@ function parseCssPixelValue(value) {
 	const parsed = Number.parseFloat(value);
 	return Number.isFinite(parsed) ? parsed : 0;
 }
+function applyTerminalAppearance(shell, terminalRoot, appearance, previousAppearance) {
+	terminalRoot.style.setProperty("--theme-term-font-size", `${appearance.fontSize}px`);
+	terminalRoot.dataset.fontSize = String(appearance.fontSize);
+	shell.dataset.fontSize = String(appearance.fontSize);
+	if (appearance.lineHeight === void 0) terminalRoot.style.removeProperty("--theme-term-line-height");
+	else terminalRoot.style.setProperty("--theme-term-line-height", String(appearance.lineHeight));
+	for (const name of Object.keys(previousAppearance?.cssVars ?? {})) if (!(name in appearance.cssVars)) {
+		terminalRoot.style.removeProperty(name);
+		shell.style.removeProperty(name);
+	}
+	for (const [name, value] of Object.entries(appearance.cssVars)) {
+		terminalRoot.style.setProperty(name, value);
+		shell.style.setProperty(name, value);
+	}
+	syncTerminalRowHeight(terminalRoot);
+}
+function parseOptionalNumber(value) {
+	if (value === void 0 || value.trim().length === 0) return;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
 function normalizeResizeDimension(value, fallback) {
 	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : Math.max(1, fallback);
 }
@@ -1086,7 +2919,6 @@ function syncTerminalSurface(element, transcriptArchive, term, styleTracker, opt
 	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;
@@ -1105,7 +2937,9 @@ function syncTerminalSurface(element, transcriptArchive, term, styleTracker, opt
 	element.dataset.cursorCol = String(cursor.col + 1);
 }
 function syncTerminalInteractivity(element, term, interactive) {
-	element.dataset.sessionInteractive = String(interactive);
+	const nextState = String(interactive);
+	if (element.dataset.sessionInteractive === nextState) return;
+	element.dataset.sessionInteractive = nextState;
 	element.setAttribute("aria-disabled", String(!interactive));
 	if (interactive) element.removeAttribute("tabindex");
 	else element.setAttribute("tabindex", "-1");
@@ -1119,16 +2953,6 @@ function syncTerminalInteractivity(element, term, interactive) {
 		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);
@@ -1158,14 +2982,21 @@ function createTranscriptArchive(element, scheduler = {}, options = {}) {
 	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 scrollbackLimit = normalizeTranscriptScrollbackLimit(options.scrollbackLimit);
 	const getVisibleRows = options.getVisibleRows ?? (() => 24);
 	let decoder = new TextDecoder();
-	const archive = doc.createElement("pre");
+	const archive = doc.createElement("div");
+	const topSpacer = doc.createElement("div");
+	const visibleArchive = doc.createElement("pre");
+	const bottomSpacer = doc.createElement("div");
 	const archiveText = doc.createTextNode("");
 	archive.setAttribute("data-terminal-transcript-archive", "");
 	archive.className = "term-transcript-archive";
-	archive.append(archiveText);
+	topSpacer.className = "term-transcript-spacer term-transcript-spacer-top";
+	visibleArchive.className = "term-transcript-visible";
+	bottomSpacer.className = "term-transcript-spacer term-transcript-spacer-bottom";
+	visibleArchive.append(archiveText);
+	archive.append(topSpacer, visibleArchive, bottomSpacer);
 	element.insertBefore(archive, element.firstChild);
 	let preservedLines = [];
 	const finalizedLines = [];
@@ -1180,9 +3011,14 @@ function createTranscriptArchive(element, scheduler = {}, options = {}) {
 	let screenModeActive = false;
 	let concealedPreservedArchive = false;
 	let screenRedrawArchiveSuppressedUntil = 0;
+	let reconciledDroppedTranscriptIndex = 0;
+	const getScrollSurface = options.getScrollSurface ?? (() => element);
+	const getRowHeight = () => {
+		const computedStyle = getComputedStyle(element);
+		return parseCssPixelValue(computedStyle.getPropertyValue("--term-row-height")) || parseCssPixelValue(computedStyle.lineHeight) || 17;
+	};
 	const setPreservedLines = (lines) => {
-		const normalizedLines = normalizePreservedTranscriptLines(lines);
-		preservedLines = scrollbackLimit > 0 ? normalizedLines.slice(-scrollbackLimit) : [];
+		preservedLines = trimTranscriptLines(normalizePreservedTranscriptLines(lines), scrollbackLimit);
 	};
 	const syncArchiveVisibility = () => {
 		const hasArchivedContent = preservedLines.length > 0 || archiveText.data.length > 0;
@@ -1210,12 +3046,19 @@ function createTranscriptArchive(element, scheduler = {}, options = {}) {
 	const syncArchive = () => {
 		reconcilePreservedLines();
 		const liveLineCount = finalizedLines.length + 1;
-		const visibleCapacity = Math.max(1, scrollbackLimit + Math.max(1, getVisibleRows()));
+		const visibleCapacity = scrollbackLimit === null ? Math.max(1, getVisibleRows()) : 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 archivedStart = Math.max(0, hiddenLineCount - (scrollbackLimit === null ? 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` : "";
+		renderVirtualTranscriptArchive(archiveWindow, {
+			archiveText,
+			bottomSpacer,
+			rowHeight: getRowHeight(),
+			scrollSurface: getScrollSurface(),
+			topSpacer,
+			visibleArchive
+		});
 		archivedLineCount = archiveWindow.length;
 		syncTranscriptMetadata(element, preservedLines.length + liveLineCount, archivedLineCount);
 		syncArchiveVisibility();
@@ -1223,6 +3066,7 @@ function createTranscriptArchive(element, scheduler = {}, options = {}) {
 	const resetLiveTranscript = () => {
 		finalizedLines.length = 0;
 		currentLine = "";
+		reconciledDroppedTranscriptIndex = 0;
 		parserState = "text";
 		csiParams = "";
 		csiPrivate = "";
@@ -1352,6 +3196,23 @@ function createTranscriptArchive(element, scheduler = {}, options = {}) {
 	};
 	syncArchive();
 	return {
+		appendPreservedLines(lines) {
+			const normalizedLines = normalizePreservedTranscriptLines(lines);
+			if (normalizedLines.length === 0) return;
+			const liveLines = normalizePreservedTranscriptLines([...finalizedLines, currentLine]);
+			const missingLines = [];
+			for (const line of normalizedLines) {
+				if (liveLines[reconciledDroppedTranscriptIndex] === line) {
+					reconciledDroppedTranscriptIndex += 1;
+					continue;
+				}
+				missingLines.push(line);
+			}
+			if (missingLines.length === 0) return;
+			setPreservedLines([...preservedLines, ...missingLines]);
+			concealedPreservedArchive = preservedLines.length > 0;
+			scheduleSync();
+		},
 		append(chunk) {
 			if (screenModeActive) return;
 			const text = decoder.decode(chunk, { stream: true });
@@ -1393,6 +3254,13 @@ function createTranscriptArchive(element, scheduler = {}, options = {}) {
 		refresh() {
 			scheduleSync();
 		},
+		refreshNow() {
+			if (frameHandle !== null) {
+				cancelFrame(frameHandle);
+				frameHandle = null;
+			}
+			syncArchive();
+		},
 		revealPreservedArchive() {
 			if (!concealedPreservedArchive) return;
 			concealedPreservedArchive = false;
@@ -1402,6 +3270,47 @@ function createTranscriptArchive(element, scheduler = {}, options = {}) {
 		setScreenModeActive
 	};
 }
+function renderVirtualTranscriptArchive(lines, context) {
+	if (lines.length === 0) {
+		context.archiveText.data = "";
+		context.topSpacer.style.height = "";
+		context.bottomSpacer.style.height = "";
+		context.visibleArchive.dataset.virtualStart = "0";
+		context.visibleArchive.dataset.virtualEnd = "0";
+		return;
+	}
+	const rowHeight = Math.max(1, context.rowHeight);
+	const windowState = resolveVirtualTranscriptWindow({
+		archiveTop: resolveElementScrollOffset(context.visibleArchive.parentElement, context.scrollSurface),
+		rowHeight,
+		scrollTop: context.scrollSurface.scrollTop,
+		thresholdRows: 600,
+		totalRows: lines.length,
+		viewportHeight: context.scrollSurface.clientHeight || rowHeight,
+		overscanRows: 80
+	});
+	if (!windowState.virtualized) {
+		context.archiveText.data = `${lines.join("\n")}\n`;
+		context.topSpacer.style.height = "";
+		context.bottomSpacer.style.height = "";
+		context.visibleArchive.dataset.virtualStart = "0";
+		context.visibleArchive.dataset.virtualEnd = String(lines.length);
+		return;
+	}
+	const visibleLines = lines.slice(windowState.startRow, windowState.endRow);
+	context.archiveText.data = `${visibleLines.join("\n")}\n`;
+	context.topSpacer.style.height = `${windowState.topSpacerHeight}px`;
+	context.bottomSpacer.style.height = `${windowState.bottomSpacerHeight}px`;
+	context.visibleArchive.dataset.virtualStart = String(windowState.startRow);
+	context.visibleArchive.dataset.virtualEnd = String(windowState.endRow);
+}
+function resolveElementScrollOffset(element, scrollSurface) {
+	if (!(element instanceof HTMLElement)) return 0;
+	const elementRect = element.getBoundingClientRect?.();
+	const surfaceRect = scrollSurface.getBoundingClientRect?.();
+	if (elementRect && surfaceRect) return Math.max(0, elementRect.top - surfaceRect.top + scrollSurface.scrollTop);
+	return Math.max(0, element.offsetTop ?? 0);
+}
 function createBrowserTransport(handlers) {
 	const pendingMessages = [];
 	const encoder = new TextEncoder();
@@ -1423,7 +3332,7 @@ function createBrowserTransport(handlers) {
 			return;
 		}
 		const payload = typeof message.data === "string" ? encoder.encode(message.data) : message.data;
-		socket.send(copyToArrayBuffer(payload));
+		socket.send(toWebSocketPayload(payload));
 	};
 	return {
 		close() {
@@ -1507,8 +3416,9 @@ function installScrollbackInteractions(element, callbacks = {}) {
 		const nextScrollTop = clamp(scrollSurface.scrollTop + event.deltaY, 0, maxScrollTop);
 		if (nextScrollTop === scrollSurface.scrollTop) return;
 		onManualScroll({
+			maxScrollTop,
 			scrollTop: nextScrollTop,
-			maxScrollTop
+			source: "wheel"
 		});
 		event.preventDefault();
 		event.stopPropagation();
@@ -1523,7 +3433,8 @@ function installScrollbackInteractions(element, callbacks = {}) {
 			const nextScrollTop = event.key === "PageUp" ? scrollSurface.scrollTop - Math.max(scrollSurface.clientHeight, 1) : maxScrollTop;
 			onManualScroll({
 				scrollTop: clamp(nextScrollTop, 0, maxScrollTop),
-				maxScrollTop
+				maxScrollTop,
+				source: "keyboard"
 			});
 			setScrollTop(scrollSurface, clamp(nextScrollTop, 0, getScrollbackMax(scrollSurface)));
 			return;
@@ -1540,24 +3451,57 @@ function installScrollbackInteractions(element, callbacks = {}) {
 		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 installTerminalFocusInteractions(shell, terminalRoot, callbacks) {
+	const doc = shell.ownerDocument;
+	const focusTerminal = ({ alignToPrompt = false } = {}) => {
+		if (terminalRoot.dataset.sessionInteractive === "false") return;
+		callbacks.focusTerminal({ alignToPrompt });
+	};
+	const onPointerDown = (event) => {
+		if (shouldIgnoreTerminalFocusPointer(event, shell, terminalRoot)) return;
+		const view = shell.ownerDocument.defaultView;
+		if (view && shouldAllowImeViewportAvoidance(view)) return;
+		focusTerminal();
+	};
+	const onKeyDownCapture = (event) => {
+		if (!isShellFullscreenLike(shell) || event.defaultPrevented || isEditableEventTarget(event.target) || isCopyShortcutWithShellSelection(shell, event)) return;
+		if (isElementInside(event.target, terminalRoot)) return;
+		const data = callbacks.resolveKeyData(event);
+		if (data === null) return;
+		event.preventDefault();
+		event.stopPropagation();
+		focusTerminal({ alignToPrompt: true });
+		callbacks.sendData(data);
+	};
+	shell.addEventListener("pointerdown", onPointerDown, true);
+	doc.addEventListener("keydown", onKeyDownCapture, true);
+	return () => {
+		shell.removeEventListener("pointerdown", onPointerDown, true);
+		doc.removeEventListener("keydown", onKeyDownCapture, true);
+	};
 }
 function getScrollbackMax(element) {
 	return Math.max(0, element.scrollHeight - element.clientHeight);
 }
-function resolveScrollSurface(doc, fallbackElement, scrollOptions) {
+function setScrollSurfaceScrollTop(element, scrollTop) {
+	const doc = element.ownerDocument;
+	const view = doc.defaultView;
+	if (!(element === doc.scrollingElement || element === doc.documentElement || element === doc.body) || !view) {
+		element.scrollTop = scrollTop;
+		return;
+	}
+	element.scrollTop = scrollTop;
+	try {
+		view.scrollTo(view.scrollX ?? view.pageXOffset ?? 0, scrollTop);
+	} catch {
+		element.scrollTop = scrollTop;
+	}
+}
+function resolveScrollSurface(doc, shell, fallbackElement, scrollOptions) {
 	const configuredViewport = scrollOptions?.getViewport?.() ?? scrollOptions?.viewport;
 	if (configuredViewport instanceof HTMLElement) return configuredViewport;
+	const shellViewport = shell.querySelector("[data-aitty-scroll-viewport]");
+	if (shellViewport instanceof HTMLElement) return shellViewport;
 	const scrollingElement = doc.scrollingElement;
 	if (scrollingElement instanceof HTMLElement) return scrollingElement;
 	if (doc.documentElement instanceof HTMLElement) return doc.documentElement;
@@ -1586,6 +3530,91 @@ function getScrollMetrics(element) {
 		thumbSizeRatio
 	};
 }
+function captureScrollSurfaceAnchor(element, shell) {
+	const maxScrollTop = getScrollbackMax(element);
+	const scrollTop = normalizeScrollMetric(element.scrollTop);
+	const rowAnchor = captureVisibleTerminalRowAnchor(element, shell);
+	const inputBottomOffset = captureLiveInputBottomOffset(element, shell);
+	const stickToBottom = isAtScrollbackBottom(scrollTop, maxScrollTop) || isLiveInputSurfaceAtBottom(shell, element);
+	return {
+		inputBottomOffset,
+		maxScrollTop,
+		ratio: maxScrollTop <= 0 ? 0 : clamp(scrollTop / maxScrollTop, 0, 1),
+		row: rowAnchor ?? void 0,
+		scrollTop,
+		stickToBottom
+	};
+}
+function restoreScrollSurfaceAnchor(element, shell, anchor) {
+	const maxScrollTop = getScrollbackMax(element);
+	setScrollSurfaceScrollTop(element, resolveScrollAnchorRestoreTop({
+		anchoredScrollTop: anchor.row ? resolveScrollTopForRowAnchor(element, shell, anchor.row) : null,
+		inputAnchoredScrollTop: anchor.inputBottomOffset === null ? null : resolveScrollTopForLiveInputBottomOffset(element, shell, anchor.inputBottomOffset),
+		maxScrollTop,
+		ratio: anchor.ratio,
+		scrollTop: anchor.scrollTop,
+		stickToBottom: anchor.stickToBottom
+	}));
+}
+function captureLiveInputBottomOffset(element, shell) {
+	const anchor = resolveLiveInputSurfaceAnchor(shell);
+	const scrollRect = element.getBoundingClientRect?.() ?? null;
+	const anchorRect = anchor?.getBoundingClientRect?.() ?? null;
+	if (!anchor || scrollRect === null || anchorRect === null || !hasUsableClientRect(scrollRect) || !hasUsableClientRect(anchorRect)) return null;
+	return scrollRect.bottom - anchorRect.bottom;
+}
+function resolveScrollTopForLiveInputBottomOffset(element, shell, inputBottomOffset) {
+	const anchor = resolveLiveInputSurfaceAnchor(shell);
+	const scrollRect = element.getBoundingClientRect?.() ?? null;
+	const anchorRect = anchor?.getBoundingClientRect?.() ?? null;
+	if (!anchor || scrollRect === null || anchorRect === null || !hasUsableClientRect(scrollRect) || !hasUsableClientRect(anchorRect)) return null;
+	return element.scrollTop + anchorRect.bottom - (scrollRect.bottom - inputBottomOffset);
+}
+function captureVisibleTerminalRowAnchor(element, shell) {
+	const scrollRect = element.getBoundingClientRect();
+	if (!hasUsableClientRect(scrollRect)) return null;
+	const topBoundary = Math.max(scrollRect.top, getViewportTopBoundary(shell));
+	const rows = Array.from(shell.querySelectorAll(".term-grid .term-row"));
+	const seenTexts = /* @__PURE__ */ new Map();
+	let firstVisibleRow = null;
+	for (const row of rows) {
+		if (!(row instanceof HTMLElement)) continue;
+		const text = row.textContent?.trimEnd() ?? "";
+		const occurrenceIndex = seenTexts.get(text) ?? 0;
+		seenTexts.set(text, occurrenceIndex + 1);
+		const rect = row.getBoundingClientRect();
+		if (!hasUsableClientRect(rect) || rect.bottom < topBoundary) continue;
+		const rowAnchor = {
+			offsetTop: rect.top - topBoundary,
+			occurrenceIndex,
+			row,
+			text
+		};
+		if (text.length > 0) return rowAnchor;
+		firstVisibleRow = firstVisibleRow ?? rowAnchor;
+	}
+	return firstVisibleRow;
+}
+function resolveScrollTopForRowAnchor(element, shell, anchor) {
+	const row = anchor.row.isConnected ? anchor.row : resolveAnchoredTerminalRow(shell, anchor);
+	if (!element.isConnected || !row) return null;
+	const scrollRect = element.getBoundingClientRect();
+	const rowRect = row.getBoundingClientRect();
+	if (!hasUsableClientRect(scrollRect) || !hasUsableClientRect(rowRect)) return null;
+	const topBoundary = Math.max(scrollRect.top, getViewportTopBoundary(shell));
+	return element.scrollTop + rowRect.top - topBoundary - anchor.offsetTop;
+}
+function resolveAnchoredTerminalRow(shell, anchor) {
+	if (anchor.text.length === 0) return null;
+	let occurrenceIndex = 0;
+	for (const row of shell.querySelectorAll(".term-grid .term-row")) {
+		if (!(row instanceof HTMLElement)) continue;
+		if ((row.textContent?.trimEnd() ?? "") !== anchor.text) continue;
+		if (occurrenceIndex === anchor.occurrenceIndex) return row;
+		occurrenceIndex += 1;
+	}
+	return null;
+}
 function normalizeScrollMetric(value) {
 	return Number.isFinite(value) ? Math.max(0, value) : 0;
 }
@@ -1599,7 +3628,7 @@ function installScrollMetricsObserver(element, onScroll) {
 	};
 }
 function isAtScrollbackBottom(scrollTop, maxScrollTop) {
-	return maxScrollTop <= 0 || scrollTop >= maxScrollTop - 1;
+	return isScrollAtBottom(scrollTop, maxScrollTop);
 }
 function clamp(value, min, max) {
 	return Math.min(max, Math.max(min, value));
@@ -1607,6 +3636,37 @@ function clamp(value, min, max) {
 function isScrollbackShortcut(event) {
 	return event.shiftKey && (event.key === "PageUp" || event.key === "PageDown");
 }
+function isShellFullscreenLike(shell) {
+	return shell.dataset.fullscreen === "true" || shell.dataset.viewportFullscreen === "true";
+}
+function shouldIgnoreTerminalFocusPointer(event, shell, terminalRoot) {
+	if (event.button !== 0 || event.defaultPrevented) return true;
+	const target = event.target;
+	if (!isElementInside(target, shell) || isInteractiveEventTarget(target)) return true;
+	const selection = shell.ownerDocument.getSelection?.();
+	if (selection && !selection.isCollapsed && isElementInside(target, terminalRoot)) return true;
+	return false;
+}
+function isElementInside(target, element) {
+	return target instanceof Node && element.contains(target);
+}
+function isInteractiveEventTarget(target) {
+	if (!(target instanceof Element)) return false;
+	return target.closest("button, a, input, textarea, select, option, [contenteditable=\"\"], [contenteditable=\"true\"], [data-shell-control]") !== null;
+}
+function isEditableEventTarget(target) {
+	if (!(target instanceof Element)) return false;
+	return target.closest("input, textarea, select, [contenteditable=\"\"], [contenteditable=\"true\"]") !== null;
+}
+function isCopyShortcutWithShellSelection(shell, event) {
+	if (event.altKey || event.key.toLowerCase() !== "c" || !(event.metaKey || event.ctrlKey)) return false;
+	const selection = shell.ownerDocument.getSelection?.();
+	if (!selection || selection.isCollapsed || !selection.toString()) return false;
+	return isNodeInside(selection.anchorNode, shell) && isNodeInside(selection.focusNode, shell);
+}
+function isNodeInside(node, element) {
+	return node !== null && element.contains(node);
+}
 function shouldPreserveVisiblePromptOnInput(event) {
 	if (!(event instanceof KeyboardEvent)) return false;
 	if (event.altKey || event.ctrlKey || event.metaKey) return false;
@@ -1616,15 +3676,201 @@ function shouldFollowLiveOutputOnInput(event) {
 	if (!(event instanceof KeyboardEvent)) return false;
 	return !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey && event.key === "Enter";
 }
+function shouldFollowLiveOutputOnUserInputData(data) {
+	if (typeof data === "string") return data.includes("\r") || data.includes("\n");
+	return data.includes(13) || data.includes(10);
+}
+function resolveMobileComposerControlSequence(control) {
+	if (control === "enter") return "\r";
+	if (control === "esc") return "\x1B";
+	if (control === "tab") return "	";
+	if (control === "arrow-up") return "\x1B[A";
+	if (control === "arrow-down") return "\x1B[B";
+	if (control === "arrow-right") return "\x1B[C";
+	return "\x1B[D";
+}
+function isMobileComposerDirectionControl(control) {
+	return control === "arrow-down" || control === "arrow-left" || control === "arrow-right" || control === "arrow-up";
+}
+function isLiveInputSurfaceAtBottom(shell, scrollSurface) {
+	const terminalRoot = shell.querySelector("[data-terminal-root]");
+	if (!(terminalRoot instanceof HTMLElement)) return false;
+	const anchor = resolveLiveInputSurfaceAnchor(terminalRoot);
+	if (!(anchor instanceof HTMLElement)) return false;
+	const rect = anchor.getBoundingClientRect();
+	if (!hasUsableClientRect(rect)) return false;
+	const bottomBoundary = getScrollSurfaceBottomBoundary(scrollSurface, shell.ownerDocument?.defaultView ?? window);
+	return rect.bottom >= bottomBoundary - 96;
+}
+function alignLiveInputSurfaceToBottom(scrollSurface, shell, terminalRoot, windowObject) {
+	const anchor = resolveLiveInputSurfaceAnchor(terminalRoot);
+	if (!(anchor instanceof HTMLElement)) return;
+	const rect = anchor.getBoundingClientRect();
+	if (!hasUsableClientRect(rect)) return;
+	const topBoundary = getViewportTopBoundary(shell);
+	const bottomBoundary = getScrollSurfaceBottomBoundary(scrollSurface, windowObject);
+	const targetBottom = Math.max(topBoundary + 1, bottomBoundary - 24);
+	if (rect.bottom <= targetBottom && rect.top >= topBoundary) return;
+	setScrollSurfaceScrollTop(scrollSurface, clamp(scrollSurface.scrollTop + rect.bottom - targetBottom, 0, getScrollbackMax(scrollSurface)));
+}
+function alignLiveInputSurfaceIntoViewport(shell, terminalRoot, windowObject, scrollSurface) {
+	if (!shouldAlignDocumentViewportForShell(shell, scrollSurface)) return;
+	const anchor = resolveLiveInputSurfaceAnchor(terminalRoot);
+	if (!(anchor instanceof HTMLElement)) return;
+	const rect = anchor.getBoundingClientRect();
+	if (!hasUsableClientRect(rect)) return;
+	const topBoundary = getViewportTopBoundary(shell);
+	const bottomBoundary = getVisibleViewportBottomBoundary(windowObject);
+	const targetBottom = Math.max(topBoundary + 1, bottomBoundary - 24);
+	const inputGap = targetBottom - rect.bottom;
+	const inputTooFarAboveKeyboard = resolveBrowserViewport(windowObject).keyboardInsetBottom > 0 && inputGap > LIVE_INPUT_KEYBOARD_MAX_GAP_PX;
+	if (rect.bottom <= targetBottom && rect.top >= topBoundary && !inputTooFarAboveKeyboard) return;
+	const currentScrollY = normalizeScrollMetric(windowObject.scrollY ?? windowObject.pageYOffset ?? 0);
+	const maxScrollY = getDocumentScrollMax(windowObject);
+	const nextScrollY = clamp(currentScrollY + rect.bottom - targetBottom, 0, maxScrollY);
+	if (Math.abs(nextScrollY - currentScrollY) < 1) return;
+	try {
+		windowObject.scrollTo(windowObject.scrollX ?? windowObject.pageXOffset ?? 0, nextScrollY);
+	} catch {
+		const scrollingElement = windowObject.document?.scrollingElement;
+		if (scrollingElement instanceof HTMLElement) scrollingElement.scrollTop = nextScrollY;
+	}
+}
+function shouldAlignDocumentViewportForShell(shell, scrollSurface) {
+	const doc = shell.ownerDocument;
+	const isDocumentScrollSurface = scrollSurface === doc.scrollingElement || scrollSurface === doc.documentElement || scrollSurface === doc.body;
+	if (shell.dataset.viewportFullscreen === "true") return false;
+	return isDocumentScrollSurface || shell.dataset.keyboardOpen === "true" || shell.dataset.fullscreen === "true" || shell.dataset.viewportFullscreen === "true";
+}
+function getDocumentScrollMax(windowObject) {
+	const doc = windowObject.document;
+	const scrollingElement = doc?.scrollingElement;
+	if (scrollingElement instanceof HTMLElement) return getScrollbackMax(scrollingElement);
+	const documentElement = doc?.documentElement;
+	const body = doc?.body;
+	const scrollHeight = Math.max(normalizeScrollMetric(documentElement?.scrollHeight ?? 0), normalizeScrollMetric(body?.scrollHeight ?? 0));
+	const clientHeight = Math.max(normalizeScrollMetric(documentElement?.clientHeight ?? 0), normalizeScrollMetric(body?.clientHeight ?? 0), normalizeScrollMetric(windowObject.innerHeight ?? 0));
+	return Math.max(0, scrollHeight - clientHeight);
+}
+function getScrollSurfaceBottomBoundary(scrollSurface, windowObject) {
+	const scrollRect = scrollSurface.getBoundingClientRect();
+	const doc = scrollSurface.ownerDocument;
+	const isDocumentScrollSurface = scrollSurface === doc.scrollingElement || scrollSurface === doc.documentElement || scrollSurface === doc.body;
+	const viewportBottom = getVisibleViewportBottomBoundary(windowObject);
+	if (!isDocumentScrollSurface && hasUsableClientRect(scrollRect) && scrollRect.height > 0) return Math.min(scrollRect.bottom, viewportBottom);
+	return viewportBottom;
+}
 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);
+	const bottomBoundary = getVisibleViewportBottomBoundary(windowObject);
 	return rect.bottom > topBoundary + 1 && rect.top < bottomBoundary - 1;
 }
+function isLiveInputSurfaceSafelyAboveViewportBottom(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 = getVisibleViewportBottomBoundary(windowObject);
+	const inputGap = bottomBoundary - rect.bottom;
+	const keyboardOpen = resolveBrowserViewport(windowObject).keyboardInsetBottom > 0;
+	return rect.top >= topBoundary && rect.bottom <= bottomBoundary - 24 && (!keyboardOpen || inputGap <= LIVE_INPUT_KEYBOARD_MAX_GAP_PX);
+}
+function shouldInstallViewportDebugOverlay(windowObject, shell) {
+	if (shell.dataset.aittyViewportDebug === "true") return true;
+	try {
+		return new URLSearchParams(windowObject.location?.search ?? "").has("aittyViewportDebug");
+	} catch {
+		return false;
+	}
+}
+function installViewportDebugOverlay(shell, terminalRoot, getScrollSurface, windowObject) {
+	const doc = shell.ownerDocument;
+	const overlay = doc.createElement("pre");
+	let frameHandle = null;
+	let observedScrollSurface = null;
+	overlay.className = "aitty-viewport-debug";
+	overlay.setAttribute("aria-hidden", "true");
+	doc.body?.append(overlay);
+	const render = () => {
+		frameHandle = null;
+		const viewport = resolveBrowserViewport(windowObject);
+		const layoutHeight = largestFinitePositiveNumber(windowObject.innerHeight, windowObject.document?.documentElement?.clientHeight) ?? firstFinitePositiveNumber(windowObject.document?.body?.clientHeight) ?? 0;
+		const visualViewport = windowObject.visualViewport;
+		const scrollSurface = getScrollSurface();
+		if (scrollSurface !== observedScrollSurface) {
+			observedScrollSurface?.removeEventListener("scroll", schedule);
+			observedScrollSurface = scrollSurface;
+			observedScrollSurface.addEventListener("scroll", schedule);
+		}
+		const scrollRect = scrollSurface.getBoundingClientRect?.();
+		const anchorRect = resolveLiveInputSurfaceAnchor(terminalRoot)?.getBoundingClientRect?.() ?? null;
+		const anchorBottom = anchorRect && hasUsableClientRect(anchorRect) ? anchorRect.bottom : NaN;
+		const safeViewportBottom = getViewportBottomBoundary(windowObject);
+		const viewportBottom = getVisibleViewportBottomBoundary(windowObject);
+		const inputGap = Number.isFinite(anchorBottom) ? viewportBottom - anchorBottom : NaN;
+		const activeElement = windowObject.document?.activeElement;
+		const activeElementLabel = activeElement instanceof HTMLElement ? `${activeElement.tagName.toLowerCase()}${activeElement.hasAttribute("data-aitty-input") ? "[aitty-input]" : ""}` : "none";
+		overlay.textContent = [
+			"aitty viewport debug",
+			`ua: ${navigator.userAgent}`,
+			`ios: ${String(isLikelyIosBrowser(windowObject))}`,
+			`standalone: ${String(isStandaloneDisplayMode(windowObject))}`,
+			`fullscreen: ${shell.dataset.fullscreen === "true" ? "system" : "false"}`,
+			`viewportFullscreen: ${shell.dataset.viewportFullscreen === "true"}`,
+			`active: ${activeElementLabel}`,
+			`inner: ${formatNumber(windowObject.innerWidth)} x ${formatNumber(windowObject.innerHeight)}`,
+			`docEl: ${formatNumber(windowObject.document?.documentElement?.clientWidth)} x ${formatNumber(windowObject.document?.documentElement?.clientHeight)}`,
+			`layoutH: ${formatNumber(layoutHeight)}`,
+			`vv: ${formatNumber(visualViewport?.width)} x ${formatNumber(visualViewport?.height)} @ top ${formatNumber(visualViewport?.offsetTop)}`,
+			`safeH: ${formatNumber(viewport.safeHeight)}`,
+			`kbd: ${formatNumber(viewport.keyboardInsetBottom)}`,
+			`chrome: ${formatNumber(viewport.browserChromeInsetBottom)}`,
+			`bottom: ${formatNumber(viewportBottom)}`,
+			`safeBottom: ${formatNumber(safeViewportBottom)}`,
+			`scroll: top ${formatNumber(scrollSurface.scrollTop)} / max ${formatNumber(getScrollbackMax(scrollSurface))}`,
+			`scrollRect: ${formatNumber(scrollRect?.top)}..${formatNumber(scrollRect?.bottom)} h ${formatNumber(scrollRect?.height)}`,
+			`inputBottom: ${formatNumber(anchorBottom)}`,
+			`inputGap: ${formatNumber(inputGap)}`
+		].join("\n");
+	};
+	const schedule = () => {
+		if (frameHandle !== null) return;
+		frameHandle = windowObject.requestAnimationFrame(render);
+	};
+	const observer = new MutationObserver(schedule);
+	observer.observe(terminalRoot, {
+		attributes: true,
+		childList: true,
+		subtree: true
+	});
+	render();
+	windowObject.addEventListener("resize", schedule);
+	windowObject.addEventListener("scroll", schedule, true);
+	windowObject.visualViewport?.addEventListener("resize", schedule);
+	windowObject.visualViewport?.addEventListener("scroll", schedule);
+	return () => {
+		if (frameHandle !== null) {
+			windowObject.cancelAnimationFrame(frameHandle);
+			frameHandle = null;
+		}
+		observer.disconnect();
+		windowObject.removeEventListener("resize", schedule);
+		windowObject.removeEventListener("scroll", schedule, true);
+		windowObject.visualViewport?.removeEventListener("resize", schedule);
+		windowObject.visualViewport?.removeEventListener("scroll", schedule);
+		observedScrollSurface?.removeEventListener("scroll", schedule);
+		observedScrollSurface = null;
+		overlay.remove();
+	};
+}
+function formatNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? String(Math.round(value)) : "n/a";
+}
 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];
@@ -1649,18 +3895,38 @@ function getViewportTopBoundary(shell) {
 	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;
+	const viewport = resolveBrowserViewport(windowObject);
+	return viewport.offsetTop + viewport.safeHeight;
+}
+function getVisibleViewportBottomBoundary(windowObject) {
+	const viewport = resolveBrowserViewport(windowObject);
+	return viewport.offsetTop + viewport.height - viewport.browserChromeInsetBottom;
 }
 function firstFinitePositiveNumber(...candidates) {
 	for (const candidate of candidates) if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) return candidate;
 	return null;
 }
+function largestFinitePositiveNumber(...candidates) {
+	const values = candidates.filter((candidate) => typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0);
+	return values.length > 0 ? Math.max(...values) : null;
+}
+function resolveBrowserChromeKeyboardGuard(windowObject, keyboardVisible) {
+	if (isStandaloneDisplayMode(windowObject) || !isLikelyIosBrowser(windowObject)) return 0;
+	return IOS_BROWSER_CHROME_KEYBOARD_GUARD_PX;
+}
+function isStandaloneDisplayMode(windowObject) {
+	return windowObject.navigator?.standalone === true || windowObject.matchMedia?.("(display-mode: standalone)").matches === true || windowObject.matchMedia?.("(display-mode: fullscreen)").matches === true;
+}
+function isLikelyIosBrowser(windowObject) {
+	const navigatorLike = windowObject.navigator;
+	const platform = navigatorLike?.platform ?? "";
+	const userAgent = navigatorLike?.userAgent ?? "";
+	const maxTouchPoints = navigatorLike?.maxTouchPoints ?? 0;
+	return /iP(?:hone|ad|od)/.test(platform) || /iP(?:hone|ad|od)/.test(userAgent) || platform === "MacIntel" && maxTouchPoints > 1;
+}
+function normalizeViewportOffset(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
 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);
@@ -1721,11 +3987,12 @@ function getOptionalElement(doc, selector) {
 function hasElementOverride(elements, key) {
 	return Object.prototype.hasOwnProperty.call(elements, key);
 }
-function createTerminalThemeController(doc, shell, terminalRoot, theme) {
+function createTerminalThemeController(doc, shell, terminalRoot, theme, target) {
 	const explicitTheme = normalizeThemeName(theme);
 	let observingTheme = false;
+	const usesDocumentTheme = target === "document";
 	const clearProtocolOverrides = () => {
-		clearTerminalThemeProtocolOverrides(doc.documentElement);
+		if (usesDocumentTheme) clearTerminalThemeProtocolOverrides(doc.documentElement);
 		clearTerminalThemeProtocolOverrides(shell);
 		clearTerminalThemeProtocolOverrides(terminalRoot);
 	};
@@ -1752,17 +4019,26 @@ function createTerminalThemeController(doc, shell, terminalRoot, theme) {
 	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");
+			if (usesDocumentTheme && doc.documentElement.dataset.theme !== void 0) delete doc.documentElement.dataset.theme;
+			if (usesDocumentTheme) doc.documentElement.style.removeProperty("color-scheme");
+			shell.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);
+		const colorScheme = configuredTheme === "light" || configuredTheme === "dark" ? configuredTheme : void 0;
+		if (usesDocumentTheme) if (colorScheme) doc.documentElement.style.setProperty("color-scheme", colorScheme);
 		else doc.documentElement.style.removeProperty("color-scheme");
-		if (doc.documentElement.dataset.theme !== configuredTheme) doc.documentElement.dataset.theme = configuredTheme;
+		if (colorScheme) shell.style.setProperty("color-scheme", colorScheme);
+		else shell.style.removeProperty("color-scheme");
+		if (usesDocumentTheme && 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 textarea = resolveTerminalTextarea(terminalRoot);
+		if (textarea) {
+			const themeValue = configuredTheme === "light" || configuredTheme === "dark" ? configuredTheme : "inherit";
+			textarea.style.colorScheme = themeValue;
+		}
 	};
 	const syncInternalTheme = (nextTheme) => {
 		pauseThemeObservation();
@@ -1780,7 +4056,7 @@ function createTerminalThemeController(doc, shell, terminalRoot, theme) {
 			mutationObserver?.disconnect();
 		},
 		getTheme() {
-			return doc.documentElement.dataset.theme;
+			return shell.dataset.theme ?? doc.documentElement.dataset.theme;
 		},
 		syncProtocolUpdate(update) {
 			let themeChanged = false;
@@ -1789,7 +4065,7 @@ function createTerminalThemeController(doc, shell, terminalRoot, theme) {
 				syncInternalTheme(update.theme);
 				themeChanged = true;
 			}
-			applyTerminalThemeProtocolUpdate(doc.documentElement, update);
+			if (usesDocumentTheme) applyTerminalThemeProtocolUpdate(doc.documentElement, update);
 			applyTerminalThemeProtocolUpdate(shell, update);
 			applyTerminalThemeProtocolUpdate(terminalRoot, update);
 			return themeChanged || hasTerminalThemeProtocolUpdate(update);
@@ -1803,6 +4079,17 @@ function createTerminalThemeController(doc, shell, terminalRoot, theme) {
 		}
 	};
 }
+function resolveTerminalTextarea(terminalRoot) {
+	const inputOwner = terminalRoot.dataset.aittyInputOwner;
+	if (inputOwner) {
+		const ownedTextarea = Array.from(terminalRoot.ownerDocument.querySelectorAll("textarea[data-aitty-input]")).find((textarea) => {
+			return textarea instanceof HTMLTextAreaElement && textarea.dataset.aittyInputOwner === inputOwner;
+		});
+		if (ownedTextarea) return ownedTextarea;
+	}
+	const localTextarea = terminalRoot.querySelector("textarea[data-aitty-input]");
+	return localTextarea instanceof HTMLTextAreaElement ? localTextarea : null;
+}
 function clearTerminalThemeProtocolOverrides(element) {
 	for (const variableName of TERMINAL_THEME_PROTOCOL_VARIABLES) element.style.removeProperty(variableName);
 }
@@ -1816,9 +4103,6 @@ function applyTerminalThemeProtocolUpdate(element, update) {
 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":
@@ -1852,12 +4136,55 @@ function cloneTerminalStatusSnapshot(status) {
 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) {
+function toWebSocketUrl(sessionUrl, clientId) {
 	const url = new URL(sessionUrl.href);
 	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
 	url.pathname = "/ws";
+	if (clientId) url.searchParams.set("cid", clientId);
 	return url.toString();
 }
+function resolveStoredAittyClientId(windowObject, sessionUrl) {
+	const key = resolveAittyClientIdStorageKey(sessionUrl);
+	const stored = normalizeStoredAittyClientId(readSessionStorageItem(windowObject, key));
+	if (stored) return stored;
+	const generated = createAittyBrowserClientId(windowObject);
+	writeSessionStorageItem(windowObject, key, generated);
+	return generated;
+}
+function persistAittyClientId(windowObject, sessionUrl, clientId) {
+	const normalized = normalizeStoredAittyClientId(clientId);
+	if (!normalized) return;
+	writeSessionStorageItem(windowObject, resolveAittyClientIdStorageKey(sessionUrl), normalized);
+}
+function resolveAittyClientIdStorageKey(sessionUrl) {
+	const token = sessionUrl.searchParams.get("t") ?? "";
+	return `aitty:client-id:${sessionUrl.origin}${sessionUrl.pathname}:${token.slice(0, 12)}`;
+}
+function createAittyBrowserClientId(windowObject) {
+	const crypto = windowObject.crypto;
+	if (crypto && typeof crypto.randomUUID === "function") return `b-${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+	const values = new Uint8Array(12);
+	if (crypto && typeof crypto.getRandomValues === "function") crypto.getRandomValues(values);
+	else for (let index = 0; index < values.length; index += 1) values[index] = Math.floor(Math.random() * 256);
+	return `b-${Array.from(values, (value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+function normalizeStoredAittyClientId(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return /^[A-Za-z0-9_-]{1,80}$/.test(normalized) ? normalized : null;
+}
+function readSessionStorageItem(windowObject, key) {
+	try {
+		return windowObject.sessionStorage?.getItem(key) ?? null;
+	} catch {
+		return null;
+	}
+}
+function writeSessionStorageItem(windowObject, key, value) {
+	try {
+		windowObject.sessionStorage?.setItem(key, value);
+	} catch {}
+}
 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);
@@ -1884,26 +4211,81 @@ async function fetchRuntimeKindFromSession(sessionUrl, fetchRuntimeKind) {
 		return "pty";
 	}
 }
+async function uploadClipboardImage(file, sessionUrl, fetchRuntime) {
+	if (!fetchRuntime || !sessionUrl || !file.type.startsWith("image/")) return null;
+	const uploadUrl = new URL("/clipboard/image", sessionUrl);
+	const token = sessionUrl.searchParams.get("t");
+	uploadUrl.hash = "";
+	if (token) uploadUrl.searchParams.set("t", token);
+	const response = await fetchRuntime(uploadUrl.toString(), {
+		body: file,
+		headers: { "Content-Type": file.type },
+		method: "POST"
+	});
+	if (!response.ok) return null;
+	const body = await response.json();
+	if (!body || typeof body !== "object" || !("path" in body)) return null;
+	const { path } = body;
+	return typeof path === "string" && path.length > 0 ? path : null;
+}
+async function pasteClipboardImageFromShortcut(windowObject, sessionUrl, event) {
+	const image = readClipboardImageFromPasteEvent(event) ?? await readClipboardImage(windowObject);
+	if (!image) return {
+		allowTerminalFallback: isLoopbackBrowserHost(windowObject.location?.hostname),
+		data: null
+	};
+	const path = await uploadClipboardImage(image, sessionUrl, windowObject.fetch?.bind(windowObject));
+	if (path) return `${path} `;
+	return {
+		allowTerminalFallback: isLoopbackBrowserHost(windowObject.location?.hostname),
+		data: null
+	};
+}
+function isLoopbackBrowserHost(hostname) {
+	const normalizedHostname = (hostname ?? "").toLowerCase();
+	return normalizedHostname === "localhost" || normalizedHostname === "127.0.0.1" || normalizedHostname === "::1" || normalizedHostname.endsWith(".localhost");
+}
+function resolveBrowserPasteShortcut(windowObject) {
+	if (windowObject.isSecureContext || isLoopbackBrowserHost(windowObject.location?.hostname)) return "ctrl-v";
+	return "cmd-v";
+}
+function readClipboardImageFromPasteEvent(event) {
+	const clipboardData = event?.clipboardData;
+	if (!clipboardData) return null;
+	for (const item of Array.from(clipboardData.items)) {
+		if (item.kind !== "file" || !item.type.startsWith("image/")) continue;
+		const file = item.getAsFile();
+		if (file) return file;
+	}
+	for (const file of Array.from(clipboardData.files)) if (file.type.startsWith("image/")) return file;
+	return null;
+}
+async function readClipboardImage(windowObject) {
+	const clipboard = windowObject.navigator?.clipboard;
+	if (!clipboard || typeof clipboard.read !== "function") return null;
+	try {
+		const items = await clipboard.read();
+		for (const item of items) {
+			const imageType = item.types.find((type) => type.startsWith("image/"));
+			if (!imageType) continue;
+			return item.getType(imageType);
+		}
+	} catch {
+		return null;
+	}
+	return null;
+}
 function syncDimensions(element, cols, rows) {
 	element.dataset.cols = String(cols);
 	element.dataset.rows = String(rows);
+	element.style.setProperty("--term-cols", String(cols));
+	element.style.setProperty("--term-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);
@@ -1913,30 +4295,30 @@ function trimReconciledPreservedTranscriptLines(preservedLines, liveLines) {
 	}
 	return preservedLines;
 }
+function normalizeTranscriptScrollbackLimit(value) {
+	if (value === void 0) return null;
+	if (!Number.isFinite(value)) return null;
+	return Math.max(0, Math.floor(value));
+}
+function trimTranscriptLines(lines, limit) {
+	if (limit === null) return lines;
+	return limit > 0 ? lines.slice(-limit) : [];
+}
 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) {
+function toWebSocketPayload(bytes) {
+	if (bytes.buffer instanceof ArrayBuffer) return 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;
+	return copy;
 }
 if (typeof document !== "undefined") {
 	defineAittyTerminalElement();
-	if (shouldAutoMount(document)) mountTerminalApp().catch((error) => {
+	if (shouldAutoMount(document)) mountTerminalApp(document, resolveAutoMountOptions(document)).catch((error) => {
 		const shell = document.querySelector("[data-shell]");
 		const status = document.querySelector("[data-terminal-status]");
 		const loading = document.querySelector("[data-terminal-loading]");
@@ -1951,7 +4333,19 @@ if (typeof document !== "undefined") {
 }
 function shouldAutoMount(doc) {
 	const shell = doc.querySelector("[data-shell]");
-	return shell instanceof HTMLElement && !shell.hasAttribute("data-aitty-manual");
+	return shell instanceof HTMLElement && shell.hasAttribute("data-aitty-autostart") && !shell.hasAttribute("data-aitty-manual");
+}
+function resolveAutoMountOptions(doc) {
+	const shell = doc.querySelector("[data-shell]");
+	if (!(shell instanceof HTMLElement)) return {};
+	return {
+		config: { appearance: {
+			fontSize: parseOptionalNumber(shell.dataset.aittyFontSize),
+			lineHeight: parseOptionalNumber(shell.dataset.aittyLineHeight),
+			themeTarget: shell.hasAttribute("data-aitty-document-theme") ? "document" : "container"
+		} },
+		shellControls: shell.hasAttribute("data-aitty-shell-controls")
+	};
 }
 //#endregion
-export { createBufferedTerminalWriter, defineAittyTerminalElement, mountAitty, mountTerminalApp };
+export { MOBILE_COMPOSER_PRIMARY_CONTROLS, createBufferedTerminalWriter, defineAittyTerminalElement, isMobileLiveInputTapTarget, mountAitty, mountTerminalApp, resolveBrowserViewport, resolveMobileComposerControlSequence, resolveMobileComposerExpandedListHeight, resolveMobileFocusProxyPosition, resolveMobileKeyboardPromptAlignDelays, resolveTerminalOutputFrameIntervalMs, shouldEnableMobileFocusProxyPointerEvents, shouldFollowLiveOutputOnUserInputData };