@aitty/browser 0.1.1 → 0.2.0

package/dist/frontend/terminal-config.d.ts

@@ -0,0 +1,62 @@
+import { TerminalKeyResolver } from "./terminal-input-policies.js";
+import { AittyTheme } from "@aitty/protocol";
+
+//#region packages/browser/src/frontend/terminal-config.d.ts
+type TerminalTheme = AittyTheme;
+type TerminalThemeTarget = "container" | "document";
+type TerminalFontSizeRange = {
+  max?: number;
+  min?: number;
+  step?: number;
+};
+type TerminalAppearanceConfig = {
+  cssVars?: Record<string, string | null | undefined>;
+  fontSize?: number;
+  fontSizeRange?: TerminalFontSizeRange;
+  lineHeight?: number;
+  theme?: TerminalTheme;
+  themeTarget?: TerminalThemeTarget;
+};
+type TerminalBehaviorConfig = {
+  input?: {
+    resolveKey?: TerminalKeyResolver;
+  };
+  scrollbackLimit?: number;
+};
+type TerminalConfig = {
+  appearance?: TerminalAppearanceConfig;
+  behavior?: TerminalBehaviorConfig;
+};
+type TerminalConfigPatch = {
+  appearance?: TerminalAppearanceConfig;
+  behavior?: TerminalBehaviorConfig;
+};
+type TerminalResolvedAppearanceConfig = {
+  cssVars: Record<string, string>;
+  fontSize: number;
+  fontSizeRange: Required<TerminalFontSizeRange>;
+  lineHeight?: number;
+  theme?: TerminalTheme;
+  themeTarget: TerminalThemeTarget;
+};
+type TerminalResolvedBehaviorConfig = {
+  input?: {
+    resolveKey?: TerminalKeyResolver;
+  };
+  scrollbackLimit?: number;
+};
+type TerminalResolvedConfig = {
+  appearance: TerminalResolvedAppearanceConfig;
+  behavior: TerminalResolvedBehaviorConfig;
+};
+type TerminalConfigListener = (config: TerminalResolvedConfig) => void;
+declare function normalizeTerminalConfig(config: TerminalConfig | undefined): TerminalResolvedConfig;
+declare function mergeTerminalConfig(current: TerminalResolvedConfig, patch: TerminalConfigPatch): TerminalResolvedConfig;
+declare function cloneTerminalConfig(config: TerminalResolvedConfig): TerminalResolvedConfig;
+declare function areTerminalAppearancesEqual(left: TerminalResolvedAppearanceConfig, right: TerminalResolvedAppearanceConfig): boolean;
+declare function areTerminalBehaviorsEqual(left: TerminalResolvedBehaviorConfig, right: TerminalResolvedBehaviorConfig): boolean;
+declare function hasTerminalLayoutAppearanceChange(previous: TerminalResolvedAppearanceConfig, next: TerminalResolvedAppearanceConfig): boolean;
+declare function normalizeThemeName(theme: TerminalTheme | undefined): string | undefined;
+declare function normalizeThemeTarget(value: TerminalThemeTarget | string | undefined): TerminalThemeTarget;
+//#endregion
+export { TerminalAppearanceConfig, TerminalBehaviorConfig, TerminalConfig, TerminalConfigListener, TerminalConfigPatch, TerminalFontSizeRange, TerminalResolvedAppearanceConfig, TerminalResolvedBehaviorConfig, TerminalResolvedConfig, TerminalTheme, TerminalThemeTarget, areTerminalAppearancesEqual, areTerminalBehaviorsEqual, cloneTerminalConfig, hasTerminalLayoutAppearanceChange, mergeTerminalConfig, normalizeTerminalConfig, normalizeThemeName, normalizeThemeTarget };

package/dist/frontend/terminal-config.js

@@ -0,0 +1,126 @@
+import { normalizeTheme } from "@aitty/protocol";
+//#region packages/browser/src/frontend/terminal-config.ts
+const DEFAULT_TERMINAL_FONT_SIZE = 15;
+const DEFAULT_TERMINAL_FONT_SIZE_MAX = 24;
+const DEFAULT_TERMINAL_FONT_SIZE_MIN = 11;
+const DEFAULT_TERMINAL_FONT_SIZE_STEP = 1;
+function normalizeTerminalConfig(config) {
+	const appearance = config?.appearance ?? {};
+	const fontSizeRange = normalizeTerminalFontSizeRange(appearance.fontSizeRange);
+	const fontSize = normalizeTerminalFontSize(appearance.fontSize, fontSizeRange);
+	return {
+		appearance: {
+			cssVars: normalizeTerminalCssVars(appearance.cssVars),
+			fontSize,
+			fontSizeRange,
+			lineHeight: normalizeTerminalLineHeight(appearance.lineHeight),
+			theme: normalizeThemeName(appearance.theme),
+			themeTarget: normalizeThemeTarget(appearance.themeTarget)
+		},
+		behavior: {
+			input: config?.behavior?.input,
+			scrollbackLimit: normalizeOptionalNonNegativeInteger(config?.behavior?.scrollbackLimit)
+		}
+	};
+}
+function mergeTerminalConfig(current, patch) {
+	const nextAppearancePatch = patch.appearance ?? {};
+	const fontSizeRange = normalizeTerminalFontSizeRange(nextAppearancePatch.fontSizeRange ?? current.appearance.fontSizeRange);
+	const fontSize = normalizeTerminalFontSize(nextAppearancePatch.fontSize, fontSizeRange, current.appearance.fontSize);
+	return {
+		appearance: {
+			cssVars: normalizeTerminalCssVars({
+				...current.appearance.cssVars,
+				...nextAppearancePatch.cssVars
+			}),
+			fontSize,
+			fontSizeRange,
+			lineHeight: "lineHeight" in nextAppearancePatch ? normalizeTerminalLineHeight(nextAppearancePatch.lineHeight) : current.appearance.lineHeight,
+			theme: "theme" in nextAppearancePatch ? normalizeThemeName(nextAppearancePatch.theme) : current.appearance.theme,
+			themeTarget: current.appearance.themeTarget
+		},
+		behavior: {
+			input: patch.behavior?.input ?? current.behavior.input,
+			scrollbackLimit: "scrollbackLimit" in (patch.behavior ?? {}) ? normalizeOptionalNonNegativeInteger(patch.behavior?.scrollbackLimit) : current.behavior.scrollbackLimit
+		}
+	};
+}
+function cloneTerminalConfig(config) {
+	return {
+		appearance: {
+			cssVars: { ...config.appearance.cssVars },
+			fontSize: config.appearance.fontSize,
+			fontSizeRange: { ...config.appearance.fontSizeRange },
+			lineHeight: config.appearance.lineHeight,
+			theme: config.appearance.theme,
+			themeTarget: config.appearance.themeTarget
+		},
+		behavior: {
+			input: config.behavior.input,
+			scrollbackLimit: config.behavior.scrollbackLimit
+		}
+	};
+}
+function areTerminalAppearancesEqual(left, right) {
+	return left.fontSize === right.fontSize && left.lineHeight === right.lineHeight && left.theme === right.theme && left.themeTarget === right.themeTarget && areFontSizeRangesEqual(left.fontSizeRange, right.fontSizeRange) && areCssVarsEqual(left.cssVars, right.cssVars);
+}
+function areTerminalBehaviorsEqual(left, right) {
+	return left.input === right.input && left.scrollbackLimit === right.scrollbackLimit;
+}
+function hasTerminalLayoutAppearanceChange(previous, next) {
+	return previous.fontSize !== next.fontSize || previous.lineHeight !== next.lineHeight;
+}
+function normalizeThemeName(theme) {
+	return normalizeTheme(theme);
+}
+function normalizeThemeTarget(value) {
+	return value === "document" ? "document" : "container";
+}
+function areFontSizeRangesEqual(left, right) {
+	return left.min === right.min && left.max === right.max && left.step === right.step;
+}
+function areCssVarsEqual(left, right) {
+	const leftEntries = Object.entries(left);
+	const rightKeys = new Set(Object.keys(right));
+	return leftEntries.length === rightKeys.size && leftEntries.every(([key, value]) => right[key] === value);
+}
+function normalizeTerminalCssVars(vars) {
+	const normalized = {};
+	for (const [name, value] of Object.entries(vars ?? {})) {
+		if (!name.startsWith("--") || value === null || value === void 0) continue;
+		normalized[name] = String(value);
+	}
+	return normalized;
+}
+function normalizeTerminalLineHeight(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return;
+	return Math.round(value * 100) / 100;
+}
+function normalizeOptionalNonNegativeInteger(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return Math.max(0, Math.floor(value));
+}
+function normalizeTerminalFontSizeRange(range) {
+	const min = normalizeFiniteNumber(range?.min, DEFAULT_TERMINAL_FONT_SIZE_MIN);
+	const max = normalizeFiniteNumber(range?.max, DEFAULT_TERMINAL_FONT_SIZE_MAX);
+	const low = Math.max(1, Math.min(min, max));
+	const high = Math.max(low, Math.max(min, max));
+	const step = Math.max(.1, roundTerminalFontSize(normalizeFiniteNumber(range?.step, DEFAULT_TERMINAL_FONT_SIZE_STEP)));
+	return {
+		max: roundTerminalFontSize(high),
+		min: roundTerminalFontSize(low),
+		step
+	};
+}
+function normalizeTerminalFontSize(value, range, fallback = DEFAULT_TERMINAL_FONT_SIZE) {
+	const base = normalizeFiniteNumber(value, fallback);
+	return roundTerminalFontSize(Math.min(range.max, Math.max(range.min, base)));
+}
+function normalizeFiniteNumber(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function roundTerminalFontSize(value) {
+	return Math.round(value * 10) / 10;
+}
+//#endregion
+export { areTerminalAppearancesEqual, areTerminalBehaviorsEqual, cloneTerminalConfig, hasTerminalLayoutAppearanceChange, mergeTerminalConfig, normalizeTerminalConfig, normalizeThemeName, normalizeThemeTarget };

package/dist/frontend/terminal-input-policies.d.ts

@@ -1,4 +1,4 @@
-//#region src/frontend/terminal-input-policies.d.ts
+//#region packages/browser/src/frontend/terminal-input-policies.d.ts
 type TerminalInputHost = {
   bridge?: {
     bracketedPaste?: () => boolean;
@@ -10,15 +10,25 @@ type TerminalInputHost = {
   } | null;
 } | null | undefined;
 type TerminalKeyResolver = (event: KeyboardEvent) => string | null | undefined;
+type TerminalPasteShortcut = "cmd-v" | "ctrl-v";
+type TerminalPasteShortcutResult = string | {
+  allowTerminalFallback?: boolean;
+  data?: string | null;
+} | null | undefined;
 type TerminalInputCallbacks = {
   captureDocumentCtrlN?: boolean;
   onData?: (data: string) => void;
+  onPasteShortcut?: (event?: ClipboardEvent) => Promise<TerminalPasteShortcutResult> | TerminalPasteShortcutResult;
+  pasteShortcut?: TerminalPasteShortcut;
   resolveKey?: TerminalKeyResolver;
   resolveDocumentKeyData?: (event: KeyboardEvent) => string | null;
 };
 declare function installTerminalInputPolicies(term: TerminalInputHost, callbacks?: TerminalInputCallbacks): () => void;
 declare function isBrowserSafeShortcut(event: KeyboardEvent): boolean;
 declare function isContainedTerminalNavigationKey(event: KeyboardEvent): boolean;
+declare function resolveTerminalDocumentKeyData(term: TerminalInputHost, event: KeyboardEvent): string | null;
 declare function isCompositionKeyDown(event: KeyboardEvent): boolean;
+declare function resolvePlainInputText(event: InputEvent, textareaValue: string): string;
+declare function resolveCommittedInputText(event: InputEvent, textareaValue: string): string;
 //#endregion
-export { TerminalInputCallbacks, TerminalKeyResolver, installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey };
+export { TerminalInputCallbacks, TerminalKeyResolver, TerminalPasteShortcut, TerminalPasteShortcutResult, installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey, resolveCommittedInputText, resolvePlainInputText, resolveTerminalDocumentKeyData };

package/dist/frontend/terminal-input-policies.js

@@ -1,4 +1,5 @@
-//#region src/frontend/terminal-input-policies.ts
+import { getTerminalSelectionText, hasTerminalSelection } from "@aitty/wterm-dom";
+//#region packages/browser/src/frontend/terminal-input-policies.ts
 const RESERVED_BROWSER_SHORTCUT_KEYS = new Set(["r", "w"]);
 const CONTAINED_TERMINAL_NAVIGATION_KEYS = new Set([
 	"ArrowUp",
@@ -98,11 +99,17 @@ const ALT_PRINTABLE_CODE_MAP = Object.freeze({
 	Slash: "/",
 	Space: " "
 });
+const PASTE_SHORTCUT_PENDING_MS = 15e3;
+const PASTE_SHORTCUT_FALLBACK_MS = 0;
+const CTRL_V_SEQUENCE = "";
+const DEFAULT_PASTE_SHORTCUT = "ctrl-v";
 function installTerminalInputPolicies(term, callbacks = {}) {
 	const root = term?.element;
 	const textarea = term?.input?.textarea;
 	const ownerDocument = root?.ownerDocument;
 	const onData = callbacks.onData ?? (() => {});
+	const onPasteShortcut = callbacks.onPasteShortcut;
+	const pasteShortcut = callbacks.pasteShortcut ?? DEFAULT_PASTE_SHORTCUT;
 	const captureDocumentCtrlN = callbacks.captureDocumentCtrlN === true;
 	const resolveKey = callbacks.resolveKey ?? (() => null);
 	const resolveDocumentKeyData = callbacks.resolveDocumentKeyData ?? (() => null);
@@ -111,11 +118,58 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 	let pendingCompositionCommit = false;
 	let suppressedCompositionValue = "";
 	let latestCompositionValue = "";
-	let speculativePlainInputText = "";
 	let pendingSyntheticPrintableText = "";
 	let syntheticPrintableFlushQueued = false;
-	const clearSpeculativePlainInputText = () => {
-		speculativePlainInputText = "";
+	let pendingPasteShortcut = false;
+	let pendingPasteShortcutClearTimer = null;
+	let pendingPasteShortcutFallbackTimer = null;
+	let pasteShortcutGeneration = 0;
+	let consumedPasteShortcutGeneration = 0;
+	const schedulePasteShortcutFallback = (generation) => {
+		if (pendingPasteShortcutFallbackTimer !== null) ownerDocument.defaultView?.clearTimeout(pendingPasteShortcutFallbackTimer);
+		pendingPasteShortcutFallbackTimer = ownerDocument.defaultView?.setTimeout(() => {
+			pendingPasteShortcutFallbackTimer = null;
+			if (pendingPasteShortcut && pasteShortcutGeneration === generation && consumedPasteShortcutGeneration !== generation) {
+				consumedPasteShortcutGeneration = generation;
+				clearPendingPasteShortcut();
+				onData(CTRL_V_SEQUENCE);
+			}
+		}, PASTE_SHORTCUT_FALLBACK_MS) ?? null;
+	};
+	const runPasteShortcut = (generation, event) => {
+		if (!onPasteShortcut) return;
+		Promise.resolve(onPasteShortcut(event)).then((result) => {
+			const data = resolvePasteShortcutData(result);
+			if (typeof data === "string" && data.length > 0 && pendingPasteShortcut && pasteShortcutGeneration === generation && consumedPasteShortcutGeneration !== generation) {
+				consumedPasteShortcutGeneration = generation;
+				clearPendingPasteShortcut();
+				sendPasteText(data);
+				return;
+			}
+			if (pasteShortcut === "ctrl-v" && shouldAllowPasteShortcutFallback(result) && pendingPasteShortcut && pasteShortcutGeneration === generation && consumedPasteShortcutGeneration !== generation && event === void 0) schedulePasteShortcutFallback(generation);
+		}).catch(() => void 0);
+	};
+	const clearPendingPasteShortcut = () => {
+		pendingPasteShortcut = false;
+		if (pendingPasteShortcutClearTimer !== null) {
+			ownerDocument.defaultView?.clearTimeout(pendingPasteShortcutClearTimer);
+			pendingPasteShortcutClearTimer = null;
+		}
+		if (pendingPasteShortcutFallbackTimer !== null) {
+			ownerDocument.defaultView?.clearTimeout(pendingPasteShortcutFallbackTimer);
+			pendingPasteShortcutFallbackTimer = null;
+		}
+	};
+	const markPendingPasteShortcut = () => {
+		clearPendingPasteShortcut();
+		pasteShortcutGeneration += 1;
+		pendingPasteShortcut = true;
+		const generation = pasteShortcutGeneration;
+		pendingPasteShortcutClearTimer = ownerDocument.defaultView?.setTimeout(() => {
+			if (pasteShortcutGeneration !== generation) return;
+			pendingPasteShortcut = false;
+			pendingPasteShortcutClearTimer = null;
+		}, PASTE_SHORTCUT_PENDING_MS) ?? null;
 	};
 	const clearPendingSyntheticPrintableText = () => {
 		pendingSyntheticPrintableText = "";
@@ -127,11 +181,9 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 		onData(pendingText);
 	};
 	const clearPendingTextState = () => {
-		clearSpeculativePlainInputText();
 		clearPendingSyntheticPrintableText();
 	};
 	const flushPendingTextState = () => {
-		clearSpeculativePlainInputText();
 		flushPendingSyntheticPrintableText();
 	};
 	const deferSyntheticPrintableText = (text) => {
@@ -146,17 +198,18 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 			onData(pendingText);
 		});
 	};
-	const rollBackSpeculativePlainInputText = (preeditText) => {
-		const rollbackText = resolveSpeculativeRollbackText(speculativePlainInputText, preeditText);
-		if (!rollbackText) return;
-		const rollback = "".repeat([...rollbackText].length);
-		speculativePlainInputText = speculativePlainInputText.slice(0, -rollbackText.length);
-		onData(rollback);
-	};
 	const sendText = (text) => {
 		if (!text) return;
 		onData(text);
 	};
+	const sendPasteText = (text) => {
+		if (!text) return;
+		if (term?.bridge?.bracketedPaste?.() === true) {
+			onData(`\u001b[200~${text.split("\x1B").join("")}\u001b[201~`);
+			return;
+		}
+		onData(text);
+	};
 	const handleDocumentKeyDownCapture = (event) => {
 		if (event.target === textarea) return;
 		const documentKeyData = captureDocumentCtrlN && !event.altKey && !event.metaKey && event.ctrlKey && event.key.toLowerCase() === "n" ? "" : resolveDocumentKeyData(event);
@@ -167,6 +220,7 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 		onData(documentKeyData);
 	};
 	const handleKeyDownCapture = (event) => {
+		if (!isTerminalSessionInteractive(root)) return;
 		if (isBrowserSafeShortcut(event)) {
 			flushPendingTextState();
 			stopInputPropagation(event);
@@ -177,6 +231,14 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 			stopInputPropagation(event);
 			return;
 		}
+		if (isPasteShortcut(event, pasteShortcut) && onPasteShortcut) {
+			flushPendingTextState();
+			stopInputPropagation(event);
+			markPendingPasteShortcut();
+			runPasteShortcut(pasteShortcutGeneration);
+			return;
+		}
+		clearPendingPasteShortcut();
 		const customKeyData = resolveKey(event);
 		if (customKeyData != null) {
 			flushPendingTextState();
@@ -223,7 +285,7 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 		}
 	};
 	const handleCompositionStartCapture = (event) => {
-		clearPendingSyntheticPrintableText();
+		clearPendingTextState();
 		composing = true;
 		pendingCompositionCommit = false;
 		suppressedCompositionValue = "";
@@ -255,10 +317,8 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 	};
 	const handleInputCapture = (event) => {
 		if (composing || isComposingInput(event)) {
-			if (isCompositionPreeditInput(event)) {
-				clearPendingSyntheticPrintableText();
-				rollBackSpeculativePlainInputText(textarea.value);
-			} else clearPendingTextState();
+			if (isCompositionPreeditInput(event)) clearPendingTextState();
+			else clearPendingTextState();
 			latestCompositionValue = textarea.value;
 			stopInputPropagation(event);
 			return;
@@ -313,28 +373,37 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 			sendText(committedText);
 			return;
 		}
-		const inputText = resolvePlainInputText(event, value);
-		if (isPotentialImeSeedText(inputText)) speculativePlainInputText += inputText;
-		else clearSpeculativePlainInputText();
-		sendText(inputText);
+		sendText(resolvePlainInputText(event, value));
 	};
 	const handleCopy = (event) => {
-		const selectionText = getSelectionText(root);
+		const selectionText = getTerminalSelectionText(root);
 		if (!selectionText || !event.clipboardData?.setData) return;
 		event.clipboardData.setData("text/plain", selectionText);
 		event.preventDefault();
 	};
 	const handlePaste = (event) => {
 		flushPendingTextState();
+		if (!isTerminalSessionInteractive(root)) return;
+		if (onPasteShortcut && clipboardEventHasImage(event)) {
+			if (!pendingPasteShortcut) markPendingPasteShortcut();
+			event.preventDefault();
+			stopInputPropagation(event);
+			runPasteShortcut(pasteShortcutGeneration, event);
+			return;
+		}
 		const text = event.clipboardData?.getData("text") ?? event.clipboardData?.getData("text/plain") ?? "";
-		if (!text) return;
-		event.preventDefault();
-		stopInputPropagation(event);
-		if (term?.bridge?.bracketedPaste?.() === true) {
-			onData(`\u001b[200~${text.split("\x1B").join("")}\u001b[201~`);
+		if (!text) {
+			if (pendingPasteShortcut && onPasteShortcut) {
+				event.preventDefault();
+				stopInputPropagation(event);
+				runPasteShortcut(pasteShortcutGeneration, event);
+			}
 			return;
 		}
-		onData(text);
+		clearPendingPasteShortcut();
+		event.preventDefault();
+		stopInputPropagation(event);
+		sendPasteText(text);
 	};
 	ownerDocument.addEventListener("keydown", handleDocumentKeyDownCapture, true);
 	textarea.addEventListener("keydown", handleKeyDownCapture, true);
@@ -344,6 +413,8 @@ function installTerminalInputPolicies(term, callbacks = {}) {
 	textarea.addEventListener("paste", handlePaste, true);
 	ownerDocument.addEventListener("copy", handleCopy, true);
 	return () => {
+		clearPendingTextState();
+		clearPendingPasteShortcut();
 		ownerDocument.removeEventListener("keydown", handleDocumentKeyDownCapture, true);
 		textarea.removeEventListener("keydown", handleKeyDownCapture, true);
 		textarea.removeEventListener("compositionstart", handleCompositionStartCapture, true);
@@ -363,6 +434,13 @@ function isContainedTerminalNavigationKey(event) {
 	if (event.altKey || event.ctrlKey || event.metaKey) return false;
 	return !(event.shiftKey && (event.key === "PageUp" || event.key === "PageDown"));
 }
+function resolveTerminalDocumentKeyData(term, event) {
+	if (isBrowserSafeShortcut(event) || isCompositionKeyDown(event)) return null;
+	const normalizedAltSequence = resolveAltPrintableSequence(event);
+	if (normalizedAltSequence) return normalizedAltSequence;
+	if (isPlainPrintableKey(event)) return event.key;
+	return resolveTerminalKeySequence(term, event);
+}
 function resolveAltPrintableSequence(event) {
 	if (!event.altKey || event.ctrlKey || event.metaKey) return null;
 	const baseKey = ALT_PRINTABLE_CODE_MAP[event.code];
@@ -426,37 +504,41 @@ function resolveCommittedInputText(event, textareaValue) {
 	if (typeof event.data === "string" && event.data.length > 0) return event.data;
 	return textareaValue;
 }
-function isPotentialImeSeedText(text) {
-	return /^[0-9A-Za-z']$/.test(text);
-}
-function resolveSpeculativeRollbackText(sentText, preeditText) {
-	if (!sentText || !preeditText || !preeditText.startsWith(sentText)) return "";
-	return sentText;
-}
 function normalizeCompositionCommit(data) {
 	if (typeof data === "string" && data.length > 0) return data;
 	return "";
 }
-function getSelectionText(root) {
-	const selection = root.ownerDocument?.getSelection?.();
-	if (!selection || selection.isCollapsed) return "";
-	if (!nodeIsInsideRoot(root, selection.anchorNode) || !nodeIsInsideRoot(root, selection.focusNode)) return "";
-	return selection.toString();
-}
 function isCopyShortcutWithTerminalSelection(root, event) {
 	if (event.altKey || event.key.toLowerCase() !== "c") return false;
 	if (!(event.metaKey || event.ctrlKey)) return false;
-	return getSelectionText(root).length > 0;
+	return hasTerminalSelection(root);
+}
+function isPasteShortcut(event, shortcut) {
+	if (event.altKey || event.key.toLowerCase() !== "v") return false;
+	return shortcut === "cmd-v" ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey;
+}
+function clipboardEventHasImage(event) {
+	const clipboardData = event.clipboardData;
+	if (!clipboardData) return false;
+	for (const item of Array.from(clipboardData.items)) if (item.kind === "file" && item.type.startsWith("image/")) return true;
+	for (const file of Array.from(clipboardData.files)) if (file.type.startsWith("image/")) return true;
+	return false;
+}
+function resolvePasteShortcutData(result) {
+	if (typeof result === "string") return result;
+	if (!result || typeof result !== "object") return null;
+	return typeof result.data === "string" ? result.data : null;
+}
+function shouldAllowPasteShortcutFallback(result) {
+	if (!result || typeof result === "string") return true;
+	return result.allowTerminalFallback !== false;
 }
-function nodeIsInsideRoot(root, node) {
-	if (!node) return false;
-	if (node === root) return true;
-	if (node instanceof Element) return root.contains(node);
-	return node.parentElement ? root.contains(node.parentElement) : false;
+function isTerminalSessionInteractive(root) {
+	return root.dataset?.sessionInteractive !== "false";
 }
 function stopInputPropagation(event) {
 	event.stopPropagation();
 	if (typeof event.stopImmediatePropagation === "function") event.stopImmediatePropagation();
 }
 //#endregion
-export { installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey };
+export { installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey, resolveCommittedInputText, resolvePlainInputText, resolveTerminalDocumentKeyData };

package/dist/frontend/terminal-scroll-anchor.js

@@ -0,0 +1,25 @@
+//#region packages/browser/src/frontend/terminal-scroll-anchor.ts
+function resolveScrollAnchorRestoreTop(options) {
+	const maxScrollTop = normalizeScrollMetric(options.maxScrollTop);
+	if (options.stickToBottom) return maxScrollTop;
+	return clamp(normalizeOptionalScrollMetric(options.inputAnchoredScrollTop) ?? normalizeOptionalScrollMetric(options.anchoredScrollTop) ?? resolveRatioFallbackScrollTop({
+		maxScrollTop,
+		ratio: options.ratio,
+		scrollTop: options.scrollTop
+	}), 0, maxScrollTop);
+}
+function resolveRatioFallbackScrollTop({ maxScrollTop, ratio, scrollTop }) {
+	if (maxScrollTop <= 0) return Math.min(normalizeScrollMetric(scrollTop), maxScrollTop);
+	return Math.round(maxScrollTop * clamp(Number.isFinite(ratio) ? ratio : 0, 0, 1));
+}
+function normalizeOptionalScrollMetric(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizeScrollMetric(value) {
+	return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+//#endregion
+export { resolveScrollAnchorRestoreTop };

package/dist/frontend/terminal-scroll-follow.js

@@ -0,0 +1,23 @@
+function resolveScrollFollowPolicy(options) {
+	const tolerancePx = normalizeNonNegativeMetric(options.tolerancePx ?? 1);
+	const maxScrollTop = normalizeNonNegativeMetric(options.maxScrollTop);
+	const scrollTop = normalizeNonNegativeMetric(options.scrollTop);
+	const previousScrollTop = normalizeNonNegativeMetric(options.previousScrollTop);
+	if (!options.keepBottomFollow || isScrollAtBottom(scrollTop, maxScrollTop, tolerancePx)) return { action: "idle" };
+	if (scrollTop < previousScrollTop - tolerancePx) return { action: "stop-follow" };
+	if (options.programmaticScroll) return { action: "idle" };
+	return {
+		action: "snap-to-bottom",
+		passes: 3,
+		preferTranscriptFollow: true
+	};
+}
+function isScrollAtBottom(scrollTop, maxScrollTop, tolerancePx = 1) {
+	const normalizedMaxScrollTop = normalizeNonNegativeMetric(maxScrollTop);
+	return normalizedMaxScrollTop <= 0 || normalizeNonNegativeMetric(scrollTop) >= normalizedMaxScrollTop - normalizeNonNegativeMetric(tolerancePx);
+}
+function normalizeNonNegativeMetric(value) {
+	return Number.isFinite(value) ? Math.max(0, Math.round(value)) : 0;
+}
+//#endregion
+export { isScrollAtBottom, resolveScrollFollowPolicy };

package/dist/frontend/terminal-scrollback-window.js

@@ -0,0 +1,18 @@
+//#region packages/browser/src/frontend/terminal-scrollback-window.ts
+const DEFAULT_RENDERED_SCROLLBACK_ROW_LIMIT = 1200;
+function resolveRenderedScrollbackWindow(options) {
+	const totalRows = Math.max(0, Math.floor(options.totalRows));
+	const limit = normalizeRenderedScrollbackLimit(options.limit);
+	const renderedRows = Math.min(totalRows, limit);
+	return {
+		firstOffset: Math.max(0, renderedRows - 1),
+		renderedRows,
+		skippedRows: Math.max(0, totalRows - renderedRows)
+	};
+}
+function normalizeRenderedScrollbackLimit(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_RENDERED_SCROLLBACK_ROW_LIMIT;
+	return Math.max(1, Math.floor(value));
+}
+//#endregion
+export { DEFAULT_RENDERED_SCROLLBACK_ROW_LIMIT, resolveRenderedScrollbackWindow };

package/dist/frontend/terminal-theme-protocol.d.ts

@@ -1,4 +1,4 @@
-//#region src/frontend/terminal-theme-protocol.d.ts
+//#region packages/browser/src/frontend/terminal-theme-protocol.d.ts
 type TerminalThemeName = "dark" | "light";
 type TerminalThemeProtocolUpdate = {
   colors: Partial<Record<TerminalThemeColorSlot, string>>;

package/dist/frontend/terminal-theme-protocol.js

@@ -1,4 +1,4 @@
-//#region src/frontend/terminal-theme-protocol.ts
+//#region packages/browser/src/frontend/terminal-theme-protocol.ts
 const BEL = "\x07";
 const ESC = "\x1B";
 const MAX_OSC_LENGTH = 512;