` in the browser.
+ */
+function Box(t0) {
+ const $ = _c(42);
+ let autoFocus;
+ let children;
+ let flexDirection;
+ let flexGrow;
+ let flexShrink;
+ let flexWrap;
+ let onBlur;
+ let onBlurCapture;
+ let onClick;
+ let onFocus;
+ let onFocusCapture;
+ let onKeyDown;
+ let onKeyDownCapture;
+ let onMouseEnter;
+ let onMouseLeave;
+ let ref;
+ let style;
+ let tabIndex;
+ if ($[0] !== t0) {
+ const {
+ children: t1,
+ flexWrap: t2,
+ flexDirection: t3,
+ flexGrow: t4,
+ flexShrink: t5,
+ ref: t6,
+ tabIndex: t7,
+ autoFocus: t8,
+ onClick: t9,
+ onFocus: t10,
+ onFocusCapture: t11,
+ onBlur: t12,
+ onBlurCapture: t13,
+ onMouseEnter: t14,
+ onMouseLeave: t15,
+ onKeyDown: t16,
+ onKeyDownCapture: t17,
+ ...t18
+ } = t0;
+ children = t1;
+ ref = t6;
+ tabIndex = t7;
+ autoFocus = t8;
+ onClick = t9;
+ onFocus = t10;
+ onFocusCapture = t11;
+ onBlur = t12;
+ onBlurCapture = t13;
+ onMouseEnter = t14;
+ onMouseLeave = t15;
+ onKeyDown = t16;
+ onKeyDownCapture = t17;
+ style = t18;
+ flexWrap = t2 === undefined ? "nowrap" : t2;
+ flexDirection = t3 === undefined ? "row" : t3;
+ flexGrow = t4 === undefined ? 0 : t4;
+ flexShrink = t5 === undefined ? 1 : t5;
+ warn.ifNotInteger(style.margin, "margin");
+ warn.ifNotInteger(style.marginX, "marginX");
+ warn.ifNotInteger(style.marginY, "marginY");
+ warn.ifNotInteger(style.marginTop, "marginTop");
+ warn.ifNotInteger(style.marginBottom, "marginBottom");
+ warn.ifNotInteger(style.marginLeft, "marginLeft");
+ warn.ifNotInteger(style.marginRight, "marginRight");
+ warn.ifNotInteger(style.padding, "padding");
+ warn.ifNotInteger(style.paddingX, "paddingX");
+ warn.ifNotInteger(style.paddingY, "paddingY");
+ warn.ifNotInteger(style.paddingTop, "paddingTop");
+ warn.ifNotInteger(style.paddingBottom, "paddingBottom");
+ warn.ifNotInteger(style.paddingLeft, "paddingLeft");
+ warn.ifNotInteger(style.paddingRight, "paddingRight");
+ warn.ifNotInteger(style.gap, "gap");
+ warn.ifNotInteger(style.columnGap, "columnGap");
+ warn.ifNotInteger(style.rowGap, "rowGap");
+ $[0] = t0;
+ $[1] = autoFocus;
+ $[2] = children;
+ $[3] = flexDirection;
+ $[4] = flexGrow;
+ $[5] = flexShrink;
+ $[6] = flexWrap;
+ $[7] = onBlur;
+ $[8] = onBlurCapture;
+ $[9] = onClick;
+ $[10] = onFocus;
+ $[11] = onFocusCapture;
+ $[12] = onKeyDown;
+ $[13] = onKeyDownCapture;
+ $[14] = onMouseEnter;
+ $[15] = onMouseLeave;
+ $[16] = ref;
+ $[17] = style;
+ $[18] = tabIndex;
+ } else {
+ autoFocus = $[1];
+ children = $[2];
+ flexDirection = $[3];
+ flexGrow = $[4];
+ flexShrink = $[5];
+ flexWrap = $[6];
+ onBlur = $[7];
+ onBlurCapture = $[8];
+ onClick = $[9];
+ onFocus = $[10];
+ onFocusCapture = $[11];
+ onKeyDown = $[12];
+ onKeyDownCapture = $[13];
+ onMouseEnter = $[14];
+ onMouseLeave = $[15];
+ ref = $[16];
+ style = $[17];
+ tabIndex = $[18];
+ }
+ const t1 = style.overflowX ?? style.overflow ?? "visible";
+ const t2 = style.overflowY ?? style.overflow ?? "visible";
+ let t3;
+ if ($[19] !== flexDirection || $[20] !== flexGrow || $[21] !== flexShrink || $[22] !== flexWrap || $[23] !== style || $[24] !== t1 || $[25] !== t2) {
+ t3 = {
+ flexWrap,
+ flexDirection,
+ flexGrow,
+ flexShrink,
+ ...style,
+ overflowX: t1,
+ overflowY: t2
+ };
+ $[19] = flexDirection;
+ $[20] = flexGrow;
+ $[21] = flexShrink;
+ $[22] = flexWrap;
+ $[23] = style;
+ $[24] = t1;
+ $[25] = t2;
+ $[26] = t3;
+ } else {
+ t3 = $[26];
+ }
+ let t4;
+ if ($[27] !== autoFocus || $[28] !== children || $[29] !== onBlur || $[30] !== onBlurCapture || $[31] !== onClick || $[32] !== onFocus || $[33] !== onFocusCapture || $[34] !== onKeyDown || $[35] !== onKeyDownCapture || $[36] !== onMouseEnter || $[37] !== onMouseLeave || $[38] !== ref || $[39] !== t3 || $[40] !== tabIndex) {
+ t4 =
{children};
+ $[27] = autoFocus;
+ $[28] = children;
+ $[29] = onBlur;
+ $[30] = onBlurCapture;
+ $[31] = onClick;
+ $[32] = onFocus;
+ $[33] = onFocusCapture;
+ $[34] = onKeyDown;
+ $[35] = onKeyDownCapture;
+ $[36] = onMouseEnter;
+ $[37] = onMouseLeave;
+ $[38] = ref;
+ $[39] = t3;
+ $[40] = tabIndex;
+ $[41] = t4;
+ } else {
+ t4 = $[41];
+ }
+ return t4;
+}
+export default Box;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","PropsWithChildren","Ref","Except","DOMElement","ClickEvent","FocusEvent","KeyboardEvent","Styles","warn","Props","ref","tabIndex","autoFocus","onClick","event","onFocus","onFocusCapture","onBlur","onBlurCapture","onKeyDown","onKeyDownCapture","onMouseEnter","onMouseLeave","Box","t0","$","_c","children","flexDirection","flexGrow","flexShrink","flexWrap","style","t1","t2","t3","t4","t5","t6","t7","t8","t9","t10","t11","t12","t13","t14","t15","t16","t17","t18","undefined","ifNotInteger","margin","marginX","marginY","marginTop","marginBottom","marginLeft","marginRight","padding","paddingX","paddingY","paddingTop","paddingBottom","paddingLeft","paddingRight","gap","columnGap","rowGap","overflowX","overflow","overflowY"],"sources":["Box.tsx"],"sourcesContent":["import '../global.d.ts'\nimport React, { type PropsWithChildren, type Ref } from 'react'\nimport type { Except } from 'type-fest'\nimport type { DOMElement } from '../dom.js'\nimport type { ClickEvent } from '../events/click-event.js'\nimport type { FocusEvent } from '../events/focus-event.js'\nimport type { KeyboardEvent } from '../events/keyboard-event.js'\nimport type { Styles } from '../styles.js'\nimport * as warn from '../warn.js'\n\nexport type Props = Except<Styles, 'textWrap'> & {\n  ref?: Ref<DOMElement>\n  /**\n   * Tab order index. Nodes with `tabIndex >= 0` participate in\n   * Tab/Shift+Tab cycling; `-1` means programmatically focusable only.\n   */\n  tabIndex?: number\n  /**\n   * Focus this element when it mounts. Like the HTML `autofocus`\n   * attribute — the FocusManager calls `focus(node)` during the\n   * reconciler's `commitMount` phase.\n   */\n  autoFocus?: boolean\n  /**\n   * Fired on left-button click (press + release without drag). Only works\n   * inside `<AlternateScreen>` where mouse tracking is enabled — no-op\n   * otherwise. The event bubbles from the deepest hit Box up through\n   * ancestors; call `event.stopImmediatePropagation()` to stop bubbling.\n   */\n  onClick?: (event: ClickEvent) => void\n  onFocus?: (event: FocusEvent) => void\n  onFocusCapture?: (event: FocusEvent) => void\n  onBlur?: (event: FocusEvent) => void\n  onBlurCapture?: (event: FocusEvent) => void\n  onKeyDown?: (event: KeyboardEvent) => void\n  onKeyDownCapture?: (event: KeyboardEvent) => void\n  /**\n   * Fired when the mouse moves into this Box's rendered rect. Like DOM\n   * `mouseenter`, does NOT bubble — moving between children does not\n   * re-fire on the parent. Only works inside `<AlternateScreen>` where\n   * mode-1003 mouse tracking is enabled.\n   */\n  onMouseEnter?: () => void\n  /** Fired when the mouse moves out of this Box's rendered rect. */\n  onMouseLeave?: () => void\n}\n\n/**\n * `<Box>` is an essential Ink component to build your layout. It's like `<div style=\"display: flex\">` in the browser.\n */\nfunction Box({\n  children,\n  flexWrap = 'nowrap',\n  flexDirection = 'row',\n  flexGrow = 0,\n  flexShrink = 1,\n  ref,\n  tabIndex,\n  autoFocus,\n  onClick,\n  onFocus,\n  onFocusCapture,\n  onBlur,\n  onBlurCapture,\n  onMouseEnter,\n  onMouseLeave,\n  onKeyDown,\n  onKeyDownCapture,\n  ...style\n}: PropsWithChildren<Props>): React.ReactNode {\n  // Warn if spacing values are not integers to prevent fractional layout dimensions\n  warn.ifNotInteger(style.margin, 'margin')\n  warn.ifNotInteger(style.marginX, 'marginX')\n  warn.ifNotInteger(style.marginY, 'marginY')\n  warn.ifNotInteger(style.marginTop, 'marginTop')\n  warn.ifNotInteger(style.marginBottom, 'marginBottom')\n  warn.ifNotInteger(style.marginLeft, 'marginLeft')\n  warn.ifNotInteger(style.marginRight, 'marginRight')\n  warn.ifNotInteger(style.padding, 'padding')\n  warn.ifNotInteger(style.paddingX, 'paddingX')\n  warn.ifNotInteger(style.paddingY, 'paddingY')\n  warn.ifNotInteger(style.paddingTop, 'paddingTop')\n  warn.ifNotInteger(style.paddingBottom, 'paddingBottom')\n  warn.ifNotInteger(style.paddingLeft, 'paddingLeft')\n  warn.ifNotInteger(style.paddingRight, 'paddingRight')\n  warn.ifNotInteger(style.gap, 'gap')\n  warn.ifNotInteger(style.columnGap, 'columnGap')\n  warn.ifNotInteger(style.rowGap, 'rowGap')\n\n  return (\n    <ink-box\n      ref={ref}\n      tabIndex={tabIndex}\n      autoFocus={autoFocus}\n      onClick={onClick}\n      onFocus={onFocus}\n      onFocusCapture={onFocusCapture}\n      onBlur={onBlur}\n      onBlurCapture={onBlurCapture}\n      onMouseEnter={onMouseEnter}\n      onMouseLeave={onMouseLeave}\n      onKeyDown={onKeyDown}\n      onKeyDownCapture={onKeyDownCapture}\n      style={{\n        flexWrap,\n        flexDirection,\n        flexGrow,\n        flexShrink,\n        ...style,\n        overflowX: style.overflowX ?? style.overflow ?? 'visible',\n        overflowY: style.overflowY ?? style.overflow ?? 'visible',\n      }}\n    >\n      {children}\n    </ink-box>\n  )\n}\n\nexport default Box\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/src/ink/components/Button.tsx b/src/ink/components/Button.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..8dc35f06cb6e1eeda93d1d3d4f298120b75ccfa1
--- /dev/null
+++ b/src/ink/components/Button.tsx
@@ -0,0 +1,192 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type Ref, useCallback, useEffect, useRef, useState } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { ClickEvent } from '../events/click-event.js';
+import type { FocusEvent } from '../events/focus-event.js';
+import type { KeyboardEvent } from '../events/keyboard-event.js';
+import type { Styles } from '../styles.js';
+import Box from './Box.js';
+type ButtonState = {
+ focused: boolean;
+ hovered: boolean;
+ active: boolean;
+};
+export type Props = Except
& {
+ ref?: Ref;
+ /**
+ * Called when the button is activated via Enter, Space, or click.
+ */
+ onAction: () => void;
+ /**
+ * Tab order index. Defaults to 0 (in tab order).
+ * Set to -1 for programmatically focusable only.
+ */
+ tabIndex?: number;
+ /**
+ * Focus this button when it mounts.
+ */
+ autoFocus?: boolean;
+ /**
+ * Render prop receiving the interactive state. Use this to
+ * style children based on focus/hover/active — Button itself
+ * is intentionally unstyled.
+ *
+ * If not provided, children render as-is (no state-dependent styling).
+ */
+ children: ((state: ButtonState) => React.ReactNode) | React.ReactNode;
+};
+function Button(t0) {
+ const $ = _c(30);
+ let autoFocus;
+ let children;
+ let onAction;
+ let ref;
+ let style;
+ let t1;
+ if ($[0] !== t0) {
+ ({
+ onAction,
+ tabIndex: t1,
+ autoFocus,
+ children,
+ ref,
+ ...style
+ } = t0);
+ $[0] = t0;
+ $[1] = autoFocus;
+ $[2] = children;
+ $[3] = onAction;
+ $[4] = ref;
+ $[5] = style;
+ $[6] = t1;
+ } else {
+ autoFocus = $[1];
+ children = $[2];
+ onAction = $[3];
+ ref = $[4];
+ style = $[5];
+ t1 = $[6];
+ }
+ const tabIndex = t1 === undefined ? 0 : t1;
+ const [isFocused, setIsFocused] = useState(false);
+ const [isHovered, setIsHovered] = useState(false);
+ const [isActive, setIsActive] = useState(false);
+ const activeTimer = useRef(null);
+ let t2;
+ let t3;
+ if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+ t2 = () => () => {
+ if (activeTimer.current) {
+ clearTimeout(activeTimer.current);
+ }
+ };
+ t3 = [];
+ $[7] = t2;
+ $[8] = t3;
+ } else {
+ t2 = $[7];
+ t3 = $[8];
+ }
+ useEffect(t2, t3);
+ let t4;
+ if ($[9] !== onAction) {
+ t4 = e => {
+ if (e.key === "return" || e.key === " ") {
+ e.preventDefault();
+ setIsActive(true);
+ onAction();
+ if (activeTimer.current) {
+ clearTimeout(activeTimer.current);
+ }
+ activeTimer.current = setTimeout(_temp, 100, setIsActive);
+ }
+ };
+ $[9] = onAction;
+ $[10] = t4;
+ } else {
+ t4 = $[10];
+ }
+ const handleKeyDown = t4;
+ let t5;
+ if ($[11] !== onAction) {
+ t5 = _e => {
+ onAction();
+ };
+ $[11] = onAction;
+ $[12] = t5;
+ } else {
+ t5 = $[12];
+ }
+ const handleClick = t5;
+ let t6;
+ if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+ t6 = _e_0 => setIsFocused(true);
+ $[13] = t6;
+ } else {
+ t6 = $[13];
+ }
+ const handleFocus = t6;
+ let t7;
+ if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+ t7 = _e_1 => setIsFocused(false);
+ $[14] = t7;
+ } else {
+ t7 = $[14];
+ }
+ const handleBlur = t7;
+ let t8;
+ if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+ t8 = () => setIsHovered(true);
+ $[15] = t8;
+ } else {
+ t8 = $[15];
+ }
+ const handleMouseEnter = t8;
+ let t9;
+ if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+ t9 = () => setIsHovered(false);
+ $[16] = t9;
+ } else {
+ t9 = $[16];
+ }
+ const handleMouseLeave = t9;
+ let t10;
+ if ($[17] !== children || $[18] !== isActive || $[19] !== isFocused || $[20] !== isHovered) {
+ const state = {
+ focused: isFocused,
+ hovered: isHovered,
+ active: isActive
+ };
+ t10 = typeof children === "function" ? children(state) : children;
+ $[17] = children;
+ $[18] = isActive;
+ $[19] = isFocused;
+ $[20] = isHovered;
+ $[21] = t10;
+ } else {
+ t10 = $[21];
+ }
+ const content = t10;
+ let t11;
+ if ($[22] !== autoFocus || $[23] !== content || $[24] !== handleClick || $[25] !== handleKeyDown || $[26] !== ref || $[27] !== style || $[28] !== tabIndex) {
+ t11 = {content};
+ $[22] = autoFocus;
+ $[23] = content;
+ $[24] = handleClick;
+ $[25] = handleKeyDown;
+ $[26] = ref;
+ $[27] = style;
+ $[28] = tabIndex;
+ $[29] = t11;
+ } else {
+ t11 = $[29];
+ }
+ return t11;
+}
+function _temp(setter) {
+ return setter(false);
+}
+export default Button;
+export type { ButtonState };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Ref","useCallback","useEffect","useRef","useState","Except","DOMElement","ClickEvent","FocusEvent","KeyboardEvent","Styles","Box","ButtonState","focused","hovered","active","Props","ref","onAction","tabIndex","autoFocus","children","state","ReactNode","Button","t0","$","_c","style","t1","undefined","isFocused","setIsFocused","isHovered","setIsHovered","isActive","setIsActive","activeTimer","t2","t3","Symbol","for","current","clearTimeout","t4","e","key","preventDefault","setTimeout","_temp","handleKeyDown","t5","_e","handleClick","t6","_e_0","handleFocus","t7","_e_1","handleBlur","t8","handleMouseEnter","t9","handleMouseLeave","t10","content","t11","setter"],"sources":["Button.tsx"],"sourcesContent":["import React, {\n  type Ref,\n  useCallback,\n  useEffect,\n  useRef,\n  useState,\n} from 'react'\nimport type { Except } from 'type-fest'\nimport type { DOMElement } from '../dom.js'\nimport type { ClickEvent } from '../events/click-event.js'\nimport type { FocusEvent } from '../events/focus-event.js'\nimport type { KeyboardEvent } from '../events/keyboard-event.js'\nimport type { Styles } from '../styles.js'\nimport Box from './Box.js'\n\ntype ButtonState = {\n  focused: boolean\n  hovered: boolean\n  active: boolean\n}\n\nexport type Props = Except<Styles, 'textWrap'> & {\n  ref?: Ref<DOMElement>\n  /**\n   * Called when the button is activated via Enter, Space, or click.\n   */\n  onAction: () => void\n  /**\n   * Tab order index. Defaults to 0 (in tab order).\n   * Set to -1 for programmatically focusable only.\n   */\n  tabIndex?: number\n  /**\n   * Focus this button when it mounts.\n   */\n  autoFocus?: boolean\n  /**\n   * Render prop receiving the interactive state. Use this to\n   * style children based on focus/hover/active — Button itself\n   * is intentionally unstyled.\n   *\n   * If not provided, children render as-is (no state-dependent styling).\n   */\n  children: ((state: ButtonState) => React.ReactNode) | React.ReactNode\n}\n\nfunction Button({\n  onAction,\n  tabIndex = 0,\n  autoFocus,\n  children,\n  ref,\n  ...style\n}: Props): React.ReactNode {\n  const [isFocused, setIsFocused] = useState(false)\n  const [isHovered, setIsHovered] = useState(false)\n  const [isActive, setIsActive] = useState(false)\n\n  const activeTimer = useRef<ReturnType<typeof setTimeout> | null>(null)\n\n  useEffect(() => {\n    return () => {\n      if (activeTimer.current) clearTimeout(activeTimer.current)\n    }\n  }, [])\n\n  const handleKeyDown = useCallback(\n    (e: KeyboardEvent) => {\n      if (e.key === 'return' || e.key === ' ') {\n        e.preventDefault()\n        setIsActive(true)\n        onAction()\n        if (activeTimer.current) clearTimeout(activeTimer.current)\n        activeTimer.current = setTimeout(\n          setter => setter(false),\n          100,\n          setIsActive,\n        )\n      }\n    },\n    [onAction],\n  )\n\n  const handleClick = useCallback(\n    (_e: ClickEvent) => {\n      onAction()\n    },\n    [onAction],\n  )\n\n  const handleFocus = useCallback((_e: FocusEvent) => setIsFocused(true), [])\n  const handleBlur = useCallback((_e: FocusEvent) => setIsFocused(false), [])\n  const handleMouseEnter = useCallback(() => setIsHovered(true), [])\n  const handleMouseLeave = useCallback(() => setIsHovered(false), [])\n\n  const state: ButtonState = {\n    focused: isFocused,\n    hovered: isHovered,\n    active: isActive,\n  }\n  const content = typeof children === 'function' ? children(state) : children\n\n  return (\n    <Box\n      ref={ref}\n      tabIndex={tabIndex}\n      autoFocus={autoFocus}\n      onKeyDown={handleKeyDown}\n      onClick={handleClick}\n      onFocus={handleFocus}\n      onBlur={handleBlur}\n      onMouseEnter={handleMouseEnter}\n      onMouseLeave={handleMouseLeave}\n      {...style}\n    >\n      {content}\n    </Box>\n  )\n}\n\nexport default Button\nexport type { ButtonState }\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/src/ink/components/ClockContext.tsx b/src/ink/components/ClockContext.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..0f24839dfce619809cb3b4b79a3d436d5ea4baa4
--- /dev/null
+++ b/src/ink/components/ClockContext.tsx
@@ -0,0 +1,112 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useEffect, useState } from 'react';
+import { FRAME_INTERVAL_MS } from '../constants.js';
+import { useTerminalFocus } from '../hooks/use-terminal-focus.js';
+export type Clock = {
+ subscribe: (onChange: () => void, keepAlive: boolean) => () => void;
+ now: () => number;
+ setTickInterval: (ms: number) => void;
+};
+export function createClock(tickIntervalMs: number): Clock {
+ const subscribers = new Map<() => void, boolean>();
+ let interval: ReturnType | null = null;
+ let currentTickIntervalMs = tickIntervalMs;
+ let startTime = 0;
+ // Snapshot of the current tick's time, ensuring all subscribers in the same
+ // tick see the same value (keeps animations synchronized)
+ let tickTime = 0;
+ function tick(): void {
+ tickTime = Date.now() - startTime;
+ for (const onChange of subscribers.keys()) {
+ onChange();
+ }
+ }
+ function updateInterval(): void {
+ const anyKeepAlive = [...subscribers.values()].some(Boolean);
+ if (anyKeepAlive) {
+ if (interval) {
+ clearInterval(interval);
+ interval = null;
+ }
+ if (startTime === 0) {
+ startTime = Date.now();
+ }
+ interval = setInterval(tick, currentTickIntervalMs);
+ } else if (interval) {
+ clearInterval(interval);
+ interval = null;
+ }
+ }
+ return {
+ subscribe(onChange, keepAlive) {
+ subscribers.set(onChange, keepAlive);
+ updateInterval();
+ return () => {
+ subscribers.delete(onChange);
+ updateInterval();
+ };
+ },
+ now() {
+ if (startTime === 0) {
+ startTime = Date.now();
+ }
+ // When the clock interval is running, return the synchronized tickTime
+ // so all subscribers in the same tick see the same value.
+ // When paused (no keepAlive subscribers), return real-time to avoid
+ // returning a stale tickTime from the last tick before the pause.
+ if (interval && tickTime) {
+ return tickTime;
+ }
+ return Date.now() - startTime;
+ },
+ setTickInterval(ms) {
+ if (ms === currentTickIntervalMs) return;
+ currentTickIntervalMs = ms;
+ updateInterval();
+ }
+ };
+}
+export const ClockContext = createContext(null);
+const BLURRED_TICK_INTERVAL_MS = FRAME_INTERVAL_MS * 2;
+
+// Own component so App.tsx doesn't re-render when the clock is created.
+// The clock value is stable (created once via useState), so the provider
+// never causes consumer re-renders on its own.
+export function ClockProvider(t0) {
+ const $ = _c(7);
+ const {
+ children
+ } = t0;
+ const [clock] = useState(_temp);
+ const focused = useTerminalFocus();
+ let t1;
+ let t2;
+ if ($[0] !== clock || $[1] !== focused) {
+ t1 = () => {
+ clock.setTickInterval(focused ? FRAME_INTERVAL_MS : BLURRED_TICK_INTERVAL_MS);
+ };
+ t2 = [clock, focused];
+ $[0] = clock;
+ $[1] = focused;
+ $[2] = t1;
+ $[3] = t2;
+ } else {
+ t1 = $[2];
+ t2 = $[3];
+ }
+ useEffect(t1, t2);
+ let t3;
+ if ($[4] !== children || $[5] !== clock) {
+ t3 = {children};
+ $[4] = children;
+ $[5] = clock;
+ $[6] = t3;
+ } else {
+ t3 = $[6];
+ }
+ return t3;
+}
+function _temp() {
+ return createClock(FRAME_INTERVAL_MS);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","useEffect","useState","FRAME_INTERVAL_MS","useTerminalFocus","Clock","subscribe","onChange","keepAlive","now","setTickInterval","ms","createClock","tickIntervalMs","subscribers","Map","interval","ReturnType","setInterval","currentTickIntervalMs","startTime","tickTime","tick","Date","keys","updateInterval","anyKeepAlive","values","some","Boolean","clearInterval","set","delete","ClockContext","BLURRED_TICK_INTERVAL_MS","ClockProvider","t0","$","_c","children","clock","_temp","focused","t1","t2","t3"],"sources":["ClockContext.tsx"],"sourcesContent":["import React, { createContext, useEffect, useState } from 'react'\nimport { FRAME_INTERVAL_MS } from '../constants.js'\nimport { useTerminalFocus } from '../hooks/use-terminal-focus.js'\n\nexport type Clock = {\n  subscribe: (onChange: () => void, keepAlive: boolean) => () => void\n  now: () => number\n  setTickInterval: (ms: number) => void\n}\n\nexport function createClock(tickIntervalMs: number): Clock {\n  const subscribers = new Map<() => void, boolean>()\n  let interval: ReturnType<typeof setInterval> | null = null\n  let currentTickIntervalMs = tickIntervalMs\n  let startTime = 0\n  // Snapshot of the current tick's time, ensuring all subscribers in the same\n  // tick see the same value (keeps animations synchronized)\n  let tickTime = 0\n\n  function tick(): void {\n    tickTime = Date.now() - startTime\n    for (const onChange of subscribers.keys()) {\n      onChange()\n    }\n  }\n\n  function updateInterval(): void {\n    const anyKeepAlive = [...subscribers.values()].some(Boolean)\n\n    if (anyKeepAlive) {\n      if (interval) {\n        clearInterval(interval)\n        interval = null\n      }\n      if (startTime === 0) {\n        startTime = Date.now()\n      }\n      interval = setInterval(tick, currentTickIntervalMs)\n    } else if (interval) {\n      clearInterval(interval)\n      interval = null\n    }\n  }\n\n  return {\n    subscribe(onChange, keepAlive) {\n      subscribers.set(onChange, keepAlive)\n      updateInterval()\n      return () => {\n        subscribers.delete(onChange)\n        updateInterval()\n      }\n    },\n\n    now() {\n      if (startTime === 0) {\n        startTime = Date.now()\n      }\n      // When the clock interval is running, return the synchronized tickTime\n      // so all subscribers in the same tick see the same value.\n      // When paused (no keepAlive subscribers), return real-time to avoid\n      // returning a stale tickTime from the last tick before the pause.\n      if (interval && tickTime) {\n        return tickTime\n      }\n      return Date.now() - startTime\n    },\n\n    setTickInterval(ms) {\n      if (ms === currentTickIntervalMs) return\n      currentTickIntervalMs = ms\n      updateInterval()\n    },\n  }\n}\n\nexport const ClockContext = createContext<Clock | null>(null)\n\nconst BLURRED_TICK_INTERVAL_MS = FRAME_INTERVAL_MS * 2\n\n// Own component so App.tsx doesn't re-render when the clock is created.\n// The clock value is stable (created once via useState), so the provider\n// never causes consumer re-renders on its own.\nexport function ClockProvider({\n  children,\n}: {\n  children: React.ReactNode\n}): React.ReactNode {\n  const [clock] = useState(() => createClock(FRAME_INTERVAL_MS))\n  const focused = useTerminalFocus()\n\n  useEffect(() => {\n    clock.setTickInterval(\n      focused ? FRAME_INTERVAL_MS : BLURRED_TICK_INTERVAL_MS,\n    )\n  }, [clock, focused])\n\n  return <ClockContext.Provider value={clock}>{children}</ClockContext.Provider>\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/src/ink/components/CursorDeclarationContext.ts b/src/ink/components/CursorDeclarationContext.ts
new file mode 100644
index 0000000000000000000000000000000000000000..358c80409a6bc2dd808edfc52fe419024846f5d6
--- /dev/null
+++ b/src/ink/components/CursorDeclarationContext.ts
@@ -0,0 +1,32 @@
+import { createContext } from 'react'
+import type { DOMElement } from '../dom.js'
+
+export type CursorDeclaration = {
+ /** Display column (terminal cell width) within the declared node */
+ readonly relativeX: number
+ /** Line number within the declared node */
+ readonly relativeY: number
+ /** The ink-box DOMElement whose yoga layout provides the absolute origin */
+ readonly node: DOMElement
+}
+
+/**
+ * Setter for the declared cursor position.
+ *
+ * The optional second argument makes `null` a conditional clear: the
+ * declaration is only cleared if the currently-declared node matches
+ * `clearIfNode`. This makes the hook safe for sibling components
+ * (e.g. list items) that transfer focus among themselves — without the
+ * node check, a newly-unfocused item's clear could clobber a
+ * newly-focused sibling's set depending on layout-effect order.
+ */
+export type CursorDeclarationSetter = (
+ declaration: CursorDeclaration | null,
+ clearIfNode?: DOMElement | null,
+) => void
+
+const CursorDeclarationContext = createContext(
+ () => {},
+)
+
+export default CursorDeclarationContext
diff --git a/src/ink/components/Link.tsx b/src/ink/components/Link.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..82341db6489298c975d28e52d3ebe19b8b90eb6e
--- /dev/null
+++ b/src/ink/components/Link.tsx
@@ -0,0 +1,42 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ReactNode } from 'react';
+import React from 'react';
+import { supportsHyperlinks } from '../supports-hyperlinks.js';
+import Text from './Text.js';
+export type Props = {
+ readonly children?: ReactNode;
+ readonly url: string;
+ readonly fallback?: ReactNode;
+};
+export default function Link(t0) {
+ const $ = _c(5);
+ const {
+ children,
+ url,
+ fallback
+ } = t0;
+ const content = children ?? url;
+ if (supportsHyperlinks()) {
+ let t1;
+ if ($[0] !== content || $[1] !== url) {
+ t1 = {content};
+ $[0] = content;
+ $[1] = url;
+ $[2] = t1;
+ } else {
+ t1 = $[2];
+ }
+ return t1;
+ }
+ const t1 = fallback ?? content;
+ let t2;
+ if ($[3] !== t1) {
+ t2 = {t1};
+ $[3] = t1;
+ $[4] = t2;
+ } else {
+ t2 = $[4];
+ }
+ return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/src/ink/components/Newline.tsx b/src/ink/components/Newline.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..5edf61882f36bdda97243879485d57ab25e09136
--- /dev/null
+++ b/src/ink/components/Newline.tsx
@@ -0,0 +1,39 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+export type Props = {
+ /**
+ * Number of newlines to insert.
+ *
+ * @default 1
+ */
+ readonly count?: number;
+};
+
+/**
+ * Adds one or more newline (\n) characters. Must be used within components.
+ */
+export default function Newline(t0) {
+ const $ = _c(4);
+ const {
+ count: t1
+ } = t0;
+ const count = t1 === undefined ? 1 : t1;
+ let t2;
+ if ($[0] !== count) {
+ t2 = "\n".repeat(count);
+ $[0] = count;
+ $[1] = t2;
+ } else {
+ t2 = $[1];
+ }
+ let t3;
+ if ($[2] !== t2) {
+ t3 = {t2};
+ $[2] = t2;
+ $[3] = t3;
+ } else {
+ t3 = $[3];
+ }
+ return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlByb3BzIiwiY291bnQiLCJOZXdsaW5lIiwidDAiLCIkIiwiX2MiLCJ0MSIsInVuZGVmaW5lZCIsInQyIiwicmVwZWF0IiwidDMiXSwic291cmNlcyI6WyJOZXdsaW5lLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnXG5cbmV4cG9ydCB0eXBlIFByb3BzID0ge1xuICAvKipcbiAgICogTnVtYmVyIG9mIG5ld2xpbmVzIHRvIGluc2VydC5cbiAgICpcbiAgICogQGRlZmF1bHQgMVxuICAgKi9cbiAgcmVhZG9ubHkgY291bnQ/OiBudW1iZXJcbn1cblxuLyoqXG4gKiBBZGRzIG9uZSBvciBtb3JlIG5ld2xpbmUgKFxcbikgY2hhcmFjdGVycy4gTXVzdCBiZSB1c2VkIHdpdGhpbiA8VGV4dD4gY29tcG9uZW50cy5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gTmV3bGluZSh7IGNvdW50ID0gMSB9OiBQcm9wcykge1xuICByZXR1cm4gPGluay10ZXh0PnsnXFxuJy5yZXBlYXQoY291bnQpfTwvaW5rLXRleHQ+XG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxLQUFLLE1BQU0sT0FBTztBQUV6QixPQUFPLEtBQUtDLEtBQUssR0FBRztFQUNsQjtBQUNGO0FBQ0E7QUFDQTtBQUNBO0VBQ0UsU0FBU0MsS0FBSyxDQUFDLEVBQUUsTUFBTTtBQUN6QixDQUFDOztBQUVEO0FBQ0E7QUFDQTtBQUNBLGVBQWUsU0FBQUMsUUFBQUMsRUFBQTtFQUFBLE1BQUFDLENBQUEsR0FBQUMsRUFBQTtFQUFpQjtJQUFBSixLQUFBLEVBQUFLO0VBQUEsSUFBQUgsRUFBb0I7RUFBbEIsTUFBQUYsS0FBQSxHQUFBSyxFQUFTLEtBQVRDLFNBQVMsR0FBVCxDQUFTLEdBQVRELEVBQVM7RUFBQSxJQUFBRSxFQUFBO0VBQUEsSUFBQUosQ0FBQSxRQUFBSCxLQUFBO0lBQ3ZCTyxFQUFBLE9BQUksQ0FBQUMsTUFBTyxDQUFDUixLQUFLLENBQUM7SUFBQUcsQ0FBQSxNQUFBSCxLQUFBO0lBQUFHLENBQUEsTUFBQUksRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQUosQ0FBQTtFQUFBO0VBQUEsSUFBQU0sRUFBQTtFQUFBLElBQUFOLENBQUEsUUFBQUksRUFBQTtJQUE3QkUsRUFBQSxZQUF5QyxDQUE5QixDQUFBRixFQUFpQixDQUFFLEVBQTlCLFFBQXlDO0lBQUFKLENBQUEsTUFBQUksRUFBQTtJQUFBSixDQUFBLE1BQUFNLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFOLENBQUE7RUFBQTtFQUFBLE9BQXpDTSxFQUF5QztBQUFBIiwiaWdub3JlTGlzdCI6W119
\ No newline at end of file
diff --git a/src/ink/components/RawAnsi.tsx b/src/ink/components/RawAnsi.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..919e453b283412a51fcea3a4804e7045ca8c54e3
--- /dev/null
+++ b/src/ink/components/RawAnsi.tsx
@@ -0,0 +1,57 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+type Props = {
+ /**
+ * Pre-rendered ANSI lines. Each element must be exactly one terminal row
+ * (already wrapped to `width` by the producer) with ANSI escape codes inline.
+ */
+ lines: string[];
+ /** Column width the producer wrapped to. Sent to Yoga as the fixed leaf width. */
+ width: number;
+};
+
+/**
+ * Bypass the → React tree → Yoga → squash → re-serialize roundtrip for
+ * content that is already terminal-ready.
+ *
+ * Use this when an external renderer (e.g. the ColorDiff NAPI module) has
+ * already produced ANSI-escaped, width-wrapped output. A normal mount
+ * reparses that output into one React per style span, lays out each
+ * span as a Yoga flex child, then walks the tree to re-emit the same escape
+ * codes it was given. For a long transcript full of syntax-highlighted diffs
+ * that roundtrip is the dominant cost of the render.
+ *
+ * This component emits a single Yoga leaf with a constant-time measure func
+ * (width × lines.length) and hands the joined string straight to output.write(),
+ * which already splits on '\n' and parses ANSI into the screen buffer.
+ */
+export function RawAnsi(t0) {
+ const $ = _c(6);
+ const {
+ lines,
+ width
+ } = t0;
+ if (lines.length === 0) {
+ return null;
+ }
+ let t1;
+ if ($[0] !== lines) {
+ t1 = lines.join("\n");
+ $[0] = lines;
+ $[1] = t1;
+ } else {
+ t1 = $[1];
+ }
+ let t2;
+ if ($[2] !== lines.length || $[3] !== t1 || $[4] !== width) {
+ t2 = ;
+ $[2] = lines.length;
+ $[3] = t1;
+ $[4] = width;
+ $[5] = t2;
+ } else {
+ t2 = $[5];
+ }
+ return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/src/ink/components/ScrollBox.tsx b/src/ink/components/ScrollBox.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..03e4a31cb1dab9818a259f89aa46cd83d6c9309b
--- /dev/null
+++ b/src/ink/components/ScrollBox.tsx
@@ -0,0 +1,237 @@
+import React, { type PropsWithChildren, type Ref, useImperativeHandle, useRef, useState } from 'react';
+import type { Except } from 'type-fest';
+import { markScrollActivity } from '../../bootstrap/state.js';
+import type { DOMElement } from '../dom.js';
+import { markDirty, scheduleRenderFrom } from '../dom.js';
+import { markCommitStart } from '../reconciler.js';
+import type { Styles } from '../styles.js';
+import '../global.d.ts';
+import Box from './Box.js';
+export type ScrollBoxHandle = {
+ scrollTo: (y: number) => void;
+ scrollBy: (dy: number) => void;
+ /**
+ * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike
+ * scrollTo which bakes a number that's stale by the time the throttled
+ * render fires, this defers the position read to render time —
+ * render-node-to-output reads `el.yogaNode.getComputedTop()` in the
+ * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.
+ */
+ scrollToElement: (el: DOMElement, offset?: number) => void;
+ scrollToBottom: () => void;
+ getScrollTop: () => number;
+ getPendingDelta: () => number;
+ getScrollHeight: () => number;
+ /**
+ * Like getScrollHeight, but reads Yoga directly instead of the cached
+ * value written by render-node-to-output (throttled, up to 16ms stale).
+ * Use when you need a fresh value in useLayoutEffect after a React commit
+ * that grew content. Slightly more expensive (native Yoga call).
+ */
+ getFreshScrollHeight: () => number;
+ getViewportHeight: () => number;
+ /**
+ * Absolute screen-buffer row of the first visible content line (inside
+ * padding). Used for drag-to-scroll edge detection.
+ */
+ getViewportTop: () => number;
+ /**
+ * True when scroll is pinned to the bottom. Set by scrollToBottom, the
+ * initial stickyScroll attribute, and by the renderer when positional
+ * follow fires (scrollTop at prevMax, content grows). Cleared by
+ * scrollTo/scrollBy. Stable signal for "at bottom" that doesn't depend on
+ * layout values (unlike scrollTop+viewportH >= scrollHeight).
+ */
+ isSticky: () => boolean;
+ /**
+ * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).
+ * Does NOT fire for stickyScroll updates done by the Ink renderer — those
+ * happen during Ink's render phase after React has committed. Callers that
+ * care about the sticky case should treat "at bottom" as a fallback.
+ */
+ subscribe: (listener: () => void) => () => void;
+ /**
+ * Set the render-time scrollTop clamp to the currently-mounted children's
+ * coverage span. Called by useVirtualScroll after computing its range;
+ * render-node-to-output clamps scrollTop to [min, max] so burst scrollTo
+ * calls that race past React's async re-render show the edge of mounted
+ * content instead of blank spacer. Pass undefined to disable (sticky,
+ * cold start).
+ */
+ setClampBounds: (min: number | undefined, max: number | undefined) => void;
+};
+export type ScrollBoxProps = Except & {
+ ref?: Ref;
+ /**
+ * When true, automatically pins scroll position to the bottom when content
+ * grows. Unset manually via scrollTo/scrollBy to break the stickiness.
+ */
+ stickyScroll?: boolean;
+};
+
+/**
+ * A Box with `overflow: scroll` and an imperative scroll API.
+ *
+ * Children are laid out at their full Yoga-computed height inside a
+ * constrained container. At render time, only children intersecting the
+ * visible window (scrollTop..scrollTop+height) are rendered (viewport
+ * culling). Content is translated by -scrollTop and clipped to the box bounds.
+ *
+ * Works best inside a fullscreen (constrained-height root) Ink tree.
+ */
+function ScrollBox({
+ children,
+ ref,
+ stickyScroll,
+ ...style
+}: PropsWithChildren): React.ReactNode {
+ const domRef = useRef(null);
+ // scrollTo/scrollBy bypass React: they mutate scrollTop on the DOM node,
+ // mark it dirty, and call the root's throttled scheduleRender directly.
+ // The Ink renderer reads scrollTop from the node — no React state needed,
+ // no reconciler overhead per wheel event. The microtask defer coalesces
+ // multiple scrollBy calls in one input batch (discreteUpdates) into one
+ // render — otherwise scheduleRender's leading edge fires on the FIRST
+ // event before subsequent events mutate scrollTop. scrollToBottom still
+ // forces a React render: sticky is attribute-observed, no DOM-only path.
+ const [, forceRender] = useState(0);
+ const listenersRef = useRef(new Set<() => void>());
+ const renderQueuedRef = useRef(false);
+ const notify = () => {
+ for (const l of listenersRef.current) l();
+ };
+ function scrollMutated(el: DOMElement): void {
+ // Signal background intervals (IDE poll, LSP poll, GCS fetch, orphan
+ // check) to skip their next tick — they compete for the event loop and
+ // contributed to 1402ms max frame gaps during scroll drain.
+ markScrollActivity();
+ markDirty(el);
+ markCommitStart();
+ notify();
+ if (renderQueuedRef.current) return;
+ renderQueuedRef.current = true;
+ queueMicrotask(() => {
+ renderQueuedRef.current = false;
+ scheduleRenderFrom(el);
+ });
+ }
+ useImperativeHandle(ref, (): ScrollBoxHandle => ({
+ scrollTo(y: number) {
+ const el = domRef.current;
+ if (!el) return;
+ // Explicit false overrides the DOM attribute so manual scroll
+ // breaks stickiness. Render code checks ?? precedence.
+ el.stickyScroll = false;
+ el.pendingScrollDelta = undefined;
+ el.scrollAnchor = undefined;
+ el.scrollTop = Math.max(0, Math.floor(y));
+ scrollMutated(el);
+ },
+ scrollToElement(el: DOMElement, offset = 0) {
+ const box = domRef.current;
+ if (!box) return;
+ box.stickyScroll = false;
+ box.pendingScrollDelta = undefined;
+ box.scrollAnchor = {
+ el,
+ offset
+ };
+ scrollMutated(box);
+ },
+ scrollBy(dy: number) {
+ const el = domRef.current;
+ if (!el) return;
+ el.stickyScroll = false;
+ // Wheel input cancels any in-flight anchor seek — user override.
+ el.scrollAnchor = undefined;
+ // Accumulate in pendingScrollDelta; renderer drains it at a capped
+ // rate so fast flicks show intermediate frames. Pure accumulator:
+ // scroll-up followed by scroll-down naturally cancels.
+ el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+ scrollMutated(el);
+ },
+ scrollToBottom() {
+ const el = domRef.current;
+ if (!el) return;
+ el.pendingScrollDelta = undefined;
+ el.stickyScroll = true;
+ markDirty(el);
+ notify();
+ forceRender(n => n + 1);
+ },
+ getScrollTop() {
+ return domRef.current?.scrollTop ?? 0;
+ },
+ getPendingDelta() {
+ // Accumulated-but-not-yet-drained delta. useVirtualScroll needs
+ // this to mount the union [committed, committed+pending] range —
+ // otherwise intermediate drain frames find no children (blank).
+ return domRef.current?.pendingScrollDelta ?? 0;
+ },
+ getScrollHeight() {
+ return domRef.current?.scrollHeight ?? 0;
+ },
+ getFreshScrollHeight() {
+ const content = domRef.current?.childNodes[0] as DOMElement | undefined;
+ return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
+ },
+ getViewportHeight() {
+ return domRef.current?.scrollViewportHeight ?? 0;
+ },
+ getViewportTop() {
+ return domRef.current?.scrollViewportTop ?? 0;
+ },
+ isSticky() {
+ const el = domRef.current;
+ if (!el) return false;
+ return el.stickyScroll ?? Boolean(el.attributes['stickyScroll']);
+ },
+ subscribe(listener: () => void) {
+ listenersRef.current.add(listener);
+ return () => listenersRef.current.delete(listener);
+ },
+ setClampBounds(min, max) {
+ const el = domRef.current;
+ if (!el) return;
+ el.scrollClampMin = min;
+ el.scrollClampMax = max;
+ }
+ }),
+ // notify/scrollMutated are inline (no useCallback) but only close over
+ // refs + imports — stable. Empty deps avoids rebuilding the handle on
+ // every render (which re-registers the ref = churn).
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ []);
+
+ // Structure: outer viewport (overflow:scroll, constrained height) >
+ // inner content (flexGrow:1, flexShrink:0 — fills at least the viewport
+ // but grows beyond it for tall content). flexGrow:1 lets children use
+ // spacers to pin elements to the bottom of the scroll area. Yoga's
+ // Overflow.Scroll prevents the viewport from growing to fit the content.
+ // The renderer computes scrollHeight from the content box and culls
+ // content's children based on scrollTop.
+ //
+ // stickyScroll is passed as a DOM attribute (via ink-box directly) so it's
+ // available on the first render — ref callbacks fire after the initial
+ // commit, which is too late for the first frame.
+ return {
+ domRef.current = el;
+ if (el) el.scrollTop ??= 0;
+ }} style={{
+ flexWrap: 'nowrap',
+ flexDirection: style.flexDirection ?? 'row',
+ flexGrow: style.flexGrow ?? 0,
+ flexShrink: style.flexShrink ?? 1,
+ ...style,
+ overflowX: 'scroll',
+ overflowY: 'scroll'
+ }} {...stickyScroll ? {
+ stickyScroll: true
+ } : {}}>
+
+ {children}
+
+ ;
+}
+export default ScrollBox;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","PropsWithChildren","Ref","useImperativeHandle","useRef","useState","Except","markScrollActivity","DOMElement","markDirty","scheduleRenderFrom","markCommitStart","Styles","Box","ScrollBoxHandle","scrollTo","y","scrollBy","dy","scrollToElement","el","offset","scrollToBottom","getScrollTop","getPendingDelta","getScrollHeight","getFreshScrollHeight","getViewportHeight","getViewportTop","isSticky","subscribe","listener","setClampBounds","min","max","ScrollBoxProps","ref","stickyScroll","ScrollBox","children","style","ReactNode","domRef","forceRender","listenersRef","Set","renderQueuedRef","notify","l","current","scrollMutated","queueMicrotask","pendingScrollDelta","undefined","scrollAnchor","scrollTop","Math","floor","box","n","scrollHeight","content","childNodes","yogaNode","getComputedHeight","scrollViewportHeight","scrollViewportTop","Boolean","attributes","add","delete","scrollClampMin","scrollClampMax","flexWrap","flexDirection","flexGrow","flexShrink","overflowX","overflowY"],"sources":["ScrollBox.tsx"],"sourcesContent":["import React, {\n  type PropsWithChildren,\n  type Ref,\n  useImperativeHandle,\n  useRef,\n  useState,\n} from 'react'\nimport type { Except } from 'type-fest'\nimport { markScrollActivity } from '../../bootstrap/state.js'\nimport type { DOMElement } from '../dom.js'\nimport { markDirty, scheduleRenderFrom } from '../dom.js'\nimport { markCommitStart } from '../reconciler.js'\nimport type { Styles } from '../styles.js'\nimport '../global.d.ts'\nimport Box from './Box.js'\n\nexport type ScrollBoxHandle = {\n  scrollTo: (y: number) => void\n  scrollBy: (dy: number) => void\n  /**\n   * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike\n   * scrollTo which bakes a number that's stale by the time the throttled\n   * render fires, this defers the position read to render time —\n   * render-node-to-output reads `el.yogaNode.getComputedTop()` in the\n   * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.\n   */\n  scrollToElement: (el: DOMElement, offset?: number) => void\n  scrollToBottom: () => void\n  getScrollTop: () => number\n  getPendingDelta: () => number\n  getScrollHeight: () => number\n  /**\n   * Like getScrollHeight, but reads Yoga directly instead of the cached\n   * value written by render-node-to-output (throttled, up to 16ms stale).\n   * Use when you need a fresh value in useLayoutEffect after a React commit\n   * that grew content. Slightly more expensive (native Yoga call).\n   */\n  getFreshScrollHeight: () => number\n  getViewportHeight: () => number\n  /**\n   * Absolute screen-buffer row of the first visible content line (inside\n   * padding). Used for drag-to-scroll edge detection.\n   */\n  getViewportTop: () => number\n  /**\n   * True when scroll is pinned to the bottom. Set by scrollToBottom, the\n   * initial stickyScroll attribute, and by the renderer when positional\n   * follow fires (scrollTop at prevMax, content grows). Cleared by\n   * scrollTo/scrollBy. Stable signal for \"at bottom\" that doesn't depend on\n   * layout values (unlike scrollTop+viewportH >= scrollHeight).\n   */\n  isSticky: () => boolean\n  /**\n   * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).\n   * Does NOT fire for stickyScroll updates done by the Ink renderer — those\n   * happen during Ink's render phase after React has committed. Callers that\n   * care about the sticky case should treat \"at bottom\" as a fallback.\n   */\n  subscribe: (listener: () => void) => () => void\n  /**\n   * Set the render-time scrollTop clamp to the currently-mounted children's\n   * coverage span. Called by useVirtualScroll after computing its range;\n   * render-node-to-output clamps scrollTop to [min, max] so burst scrollTo\n   * calls that race past React's async re-render show the edge of mounted\n   * content instead of blank spacer. Pass undefined to disable (sticky,\n   * cold start).\n   */\n  setClampBounds: (min: number | undefined, max: number | undefined) => void\n}\n\nexport type ScrollBoxProps = Except<\n  Styles,\n  'textWrap' | 'overflow' | 'overflowX' | 'overflowY'\n> & {\n  ref?: Ref<ScrollBoxHandle>\n  /**\n   * When true, automatically pins scroll position to the bottom when content\n   * grows. Unset manually via scrollTo/scrollBy to break the stickiness.\n   */\n  stickyScroll?: boolean\n}\n\n/**\n * A Box with `overflow: scroll` and an imperative scroll API.\n *\n * Children are laid out at their full Yoga-computed height inside a\n * constrained container. At render time, only children intersecting the\n * visible window (scrollTop..scrollTop+height) are rendered (viewport\n * culling). Content is translated by -scrollTop and clipped to the box bounds.\n *\n * Works best inside a fullscreen (constrained-height root) Ink tree.\n */\nfunction ScrollBox({\n  children,\n  ref,\n  stickyScroll,\n  ...style\n}: PropsWithChildren<ScrollBoxProps>): React.ReactNode {\n  const domRef = useRef<DOMElement>(null)\n  // scrollTo/scrollBy bypass React: they mutate scrollTop on the DOM node,\n  // mark it dirty, and call the root's throttled scheduleRender directly.\n  // The Ink renderer reads scrollTop from the node — no React state needed,\n  // no reconciler overhead per wheel event. The microtask defer coalesces\n  // multiple scrollBy calls in one input batch (discreteUpdates) into one\n  // render — otherwise scheduleRender's leading edge fires on the FIRST\n  // event before subsequent events mutate scrollTop. scrollToBottom still\n  // forces a React render: sticky is attribute-observed, no DOM-only path.\n  const [, forceRender] = useState(0)\n  const listenersRef = useRef(new Set<() => void>())\n  const renderQueuedRef = useRef(false)\n\n  const notify = () => {\n    for (const l of listenersRef.current) l()\n  }\n\n  function scrollMutated(el: DOMElement): void {\n    // Signal background intervals (IDE poll, LSP poll, GCS fetch, orphan\n    // check) to skip their next tick — they compete for the event loop and\n    // contributed to 1402ms max frame gaps during scroll drain.\n    markScrollActivity()\n    markDirty(el)\n    markCommitStart()\n    notify()\n    if (renderQueuedRef.current) return\n    renderQueuedRef.current = true\n    queueMicrotask(() => {\n      renderQueuedRef.current = false\n      scheduleRenderFrom(el)\n    })\n  }\n\n  useImperativeHandle(\n    ref,\n    (): ScrollBoxHandle => ({\n      scrollTo(y: number) {\n        const el = domRef.current\n        if (!el) return\n        // Explicit false overrides the DOM attribute so manual scroll\n        // breaks stickiness. Render code checks ?? precedence.\n        el.stickyScroll = false\n        el.pendingScrollDelta = undefined\n        el.scrollAnchor = undefined\n        el.scrollTop = Math.max(0, Math.floor(y))\n        scrollMutated(el)\n      },\n      scrollToElement(el: DOMElement, offset = 0) {\n        const box = domRef.current\n        if (!box) return\n        box.stickyScroll = false\n        box.pendingScrollDelta = undefined\n        box.scrollAnchor = { el, offset }\n        scrollMutated(box)\n      },\n      scrollBy(dy: number) {\n        const el = domRef.current\n        if (!el) return\n        el.stickyScroll = false\n        // Wheel input cancels any in-flight anchor seek — user override.\n        el.scrollAnchor = undefined\n        // Accumulate in pendingScrollDelta; renderer drains it at a capped\n        // rate so fast flicks show intermediate frames. Pure accumulator:\n        // scroll-up followed by scroll-down naturally cancels.\n        el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy)\n        scrollMutated(el)\n      },\n      scrollToBottom() {\n        const el = domRef.current\n        if (!el) return\n        el.pendingScrollDelta = undefined\n        el.stickyScroll = true\n        markDirty(el)\n        notify()\n        forceRender(n => n + 1)\n      },\n      getScrollTop() {\n        return domRef.current?.scrollTop ?? 0\n      },\n      getPendingDelta() {\n        // Accumulated-but-not-yet-drained delta. useVirtualScroll needs\n        // this to mount the union [committed, committed+pending] range —\n        // otherwise intermediate drain frames find no children (blank).\n        return domRef.current?.pendingScrollDelta ?? 0\n      },\n      getScrollHeight() {\n        return domRef.current?.scrollHeight ?? 0\n      },\n      getFreshScrollHeight() {\n        const content = domRef.current?.childNodes[0] as DOMElement | undefined\n        return (\n          content?.yogaNode?.getComputedHeight() ??\n          domRef.current?.scrollHeight ??\n          0\n        )\n      },\n      getViewportHeight() {\n        return domRef.current?.scrollViewportHeight ?? 0\n      },\n      getViewportTop() {\n        return domRef.current?.scrollViewportTop ?? 0\n      },\n      isSticky() {\n        const el = domRef.current\n        if (!el) return false\n        return el.stickyScroll ?? Boolean(el.attributes['stickyScroll'])\n      },\n      subscribe(listener: () => void) {\n        listenersRef.current.add(listener)\n        return () => listenersRef.current.delete(listener)\n      },\n      setClampBounds(min, max) {\n        const el = domRef.current\n        if (!el) return\n        el.scrollClampMin = min\n        el.scrollClampMax = max\n      },\n    }),\n    // notify/scrollMutated are inline (no useCallback) but only close over\n    // refs + imports — stable. Empty deps avoids rebuilding the handle on\n    // every render (which re-registers the ref = churn).\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [],\n  )\n\n  // Structure: outer viewport (overflow:scroll, constrained height) >\n  // inner content (flexGrow:1, flexShrink:0 — fills at least the viewport\n  // but grows beyond it for tall content). flexGrow:1 lets children use\n  // spacers to pin elements to the bottom of the scroll area. Yoga's\n  // Overflow.Scroll prevents the viewport from growing to fit the content.\n  // The renderer computes scrollHeight from the content box and culls\n  // content's children based on scrollTop.\n  //\n  // stickyScroll is passed as a DOM attribute (via ink-box directly) so it's\n  // available on the first render — ref callbacks fire after the initial\n  // commit, which is too late for the first frame.\n  return (\n    <ink-box\n      ref={el => {\n        domRef.current = el\n        if (el) el.scrollTop ??= 0\n      }}\n      style={{\n        flexWrap: 'nowrap',\n        flexDirection: style.flexDirection ?? 'row',\n        flexGrow: style.flexGrow ?? 0,\n        flexShrink: style.flexShrink ?? 1,\n        ...style,\n        overflowX: 'scroll',\n        overflowY: 'scroll',\n      }}\n      {...(stickyScroll ? { stickyScroll: true } : {})}\n    >\n      <Box flexDirection=\"column\" flexGrow={1} flexShrink={0} width=\"100%\">\n        {children}\n      </Box>\n    </ink-box>\n  )\n}\n\nexport default ScrollBox\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/src/ink/components/Spacer.tsx b/src/ink/components/Spacer.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..4d0af40f66646de8dec1f7d88dc4560f22ed68f6
--- /dev/null
+++ b/src/ink/components/Spacer.tsx
@@ -0,0 +1,20 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import Box from './Box.js';
+
+/**
+ * A flexible space that expands along the major axis of its containing layout.
+ * It's useful as a shortcut for filling all the available spaces between elements.
+ */
+export default function Spacer() {
+ const $ = _c(1);
+ let t0;
+ if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+ t0 = ;
+ $[0] = t0;
+ } else {
+ t0 = $[0];
+ }
+ return t0;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkJveCIsIlNwYWNlciIsIiQiLCJfYyIsInQwIiwiU3ltYm9sIiwiZm9yIl0sInNvdXJjZXMiOlsiU3BhY2VyLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnXG5pbXBvcnQgQm94IGZyb20gJy4vQm94LmpzJ1xuXG4vKipcbiAqIEEgZmxleGlibGUgc3BhY2UgdGhhdCBleHBhbmRzIGFsb25nIHRoZSBtYWpvciBheGlzIG9mIGl0cyBjb250YWluaW5nIGxheW91dC5cbiAqIEl0J3MgdXNlZnVsIGFzIGEgc2hvcnRjdXQgZm9yIGZpbGxpbmcgYWxsIHRoZSBhdmFpbGFibGUgc3BhY2VzIGJldHdlZW4gZWxlbWVudHMuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIFNwYWNlcigpIHtcbiAgcmV0dXJuIDxCb3ggZmxleEdyb3c9ezF9IC8+XG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxLQUFLLE1BQU0sT0FBTztBQUN6QixPQUFPQyxHQUFHLE1BQU0sVUFBVTs7QUFFMUI7QUFDQTtBQUNBO0FBQ0E7QUFDQSxlQUFlLFNBQUFDLE9BQUE7RUFBQSxNQUFBQyxDQUFBLEdBQUFDLEVBQUE7RUFBQSxJQUFBQyxFQUFBO0VBQUEsSUFBQUYsQ0FBQSxRQUFBRyxNQUFBLENBQUFDLEdBQUE7SUFDTkYsRUFBQSxJQUFDLEdBQUcsQ0FBVyxRQUFDLENBQUQsR0FBQyxHQUFJO0lBQUFGLENBQUEsTUFBQUUsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQUYsQ0FBQTtFQUFBO0VBQUEsT0FBcEJFLEVBQW9CO0FBQUEiLCJpZ25vcmVMaXN0IjpbXX0=
\ No newline at end of file
diff --git a/src/ink/components/StdinContext.ts b/src/ink/components/StdinContext.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0b1a49717c1d4922f4c5917d30c86c54056dde4f
--- /dev/null
+++ b/src/ink/components/StdinContext.ts
@@ -0,0 +1,49 @@
+import { createContext } from 'react'
+import { EventEmitter } from '../events/emitter.js'
+import type { TerminalQuerier } from '../terminal-querier.js'
+
+export type Props = {
+ /**
+ * Stdin stream passed to `render()` in `options.stdin` or `process.stdin` by default. Useful if your app needs to handle user input.
+ */
+ readonly stdin: NodeJS.ReadStream
+
+ /**
+ * Ink exposes this function via own `` to be able to handle Ctrl+C, that's why you should use Ink's `setRawMode` instead of `process.stdin.setRawMode`.
+ * If the `stdin` stream passed to Ink does not support setRawMode, this function does nothing.
+ */
+ readonly setRawMode: (value: boolean) => void
+
+ /**
+ * A boolean flag determining if the current `stdin` supports `setRawMode`. A component using `setRawMode` might want to use `isRawModeSupported` to nicely fall back in environments where raw mode is not supported.
+ */
+ readonly isRawModeSupported: boolean
+
+ readonly internal_exitOnCtrlC: boolean
+
+ readonly internal_eventEmitter: EventEmitter
+
+ /** Query the terminal and await responses (DECRQM, OSC 11, etc.).
+ * Null only in the never-reached default context value. */
+ readonly internal_querier: TerminalQuerier | null
+}
+
+/**
+ * `StdinContext` is a React context, which exposes input stream.
+ */
+
+const StdinContext = createContext({
+ stdin: process.stdin,
+
+ internal_eventEmitter: new EventEmitter(),
+ setRawMode() {},
+ isRawModeSupported: false,
+
+ internal_exitOnCtrlC: true,
+ internal_querier: null,
+})
+
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+StdinContext.displayName = 'InternalStdinContext'
+
+export default StdinContext
diff --git a/src/ink/components/TerminalFocusContext.tsx b/src/ink/components/TerminalFocusContext.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..e017b64ab18e01a8cb53561641c3439652c25efc
--- /dev/null
+++ b/src/ink/components/TerminalFocusContext.tsx
@@ -0,0 +1,52 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useMemo, useSyncExternalStore } from 'react';
+import { getTerminalFocused, getTerminalFocusState, subscribeTerminalFocus, type TerminalFocusState } from '../terminal-focus-state.js';
+export type { TerminalFocusState };
+export type TerminalFocusContextProps = {
+ readonly isTerminalFocused: boolean;
+ readonly terminalFocusState: TerminalFocusState;
+};
+const TerminalFocusContext = createContext({
+ isTerminalFocused: true,
+ terminalFocusState: 'unknown'
+});
+
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+TerminalFocusContext.displayName = 'TerminalFocusContext';
+
+// Separate component so App.tsx doesn't re-render on focus changes.
+// Children are a stable prop reference, so they don't re-render either —
+// only components that consume the context will re-render.
+export function TerminalFocusProvider(t0) {
+ const $ = _c(6);
+ const {
+ children
+ } = t0;
+ const isTerminalFocused = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocused);
+ const terminalFocusState = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocusState);
+ let t1;
+ if ($[0] !== isTerminalFocused || $[1] !== terminalFocusState) {
+ t1 = {
+ isTerminalFocused,
+ terminalFocusState
+ };
+ $[0] = isTerminalFocused;
+ $[1] = terminalFocusState;
+ $[2] = t1;
+ } else {
+ t1 = $[2];
+ }
+ const value = t1;
+ let t2;
+ if ($[3] !== children || $[4] !== value) {
+ t2 = {children};
+ $[3] = children;
+ $[4] = value;
+ $[5] = t2;
+ } else {
+ t2 = $[5];
+ }
+ return t2;
+}
+export default TerminalFocusContext;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/src/ink/components/TerminalSizeContext.tsx b/src/ink/components/TerminalSizeContext.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..8ca447ec4e96834aa20cdf4cba1f81943357874f
--- /dev/null
+++ b/src/ink/components/TerminalSizeContext.tsx
@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+export type TerminalSize = {
+ columns: number;
+ rows: number;
+};
+export const TerminalSizeContext = createContext(null);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjcmVhdGVDb250ZXh0IiwiVGVybWluYWxTaXplIiwiY29sdW1ucyIsInJvd3MiLCJUZXJtaW5hbFNpemVDb250ZXh0Il0sInNvdXJjZXMiOlsiVGVybWluYWxTaXplQ29udGV4dC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlQ29udGV4dCB9IGZyb20gJ3JlYWN0J1xuXG5leHBvcnQgdHlwZSBUZXJtaW5hbFNpemUgPSB7XG4gIGNvbHVtbnM6IG51bWJlclxuICByb3dzOiBudW1iZXJcbn1cblxuZXhwb3J0IGNvbnN0IFRlcm1pbmFsU2l6ZUNvbnRleHQgPSBjcmVhdGVDb250ZXh0PFRlcm1pbmFsU2l6ZSB8IG51bGw+KG51bGwpXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGFBQWEsUUFBUSxPQUFPO0FBRXJDLE9BQU8sS0FBS0MsWUFBWSxHQUFHO0VBQ3pCQyxPQUFPLEVBQUUsTUFBTTtFQUNmQyxJQUFJLEVBQUUsTUFBTTtBQUNkLENBQUM7QUFFRCxPQUFPLE1BQU1DLG1CQUFtQixHQUFHSixhQUFhLENBQUNDLFlBQVksR0FBRyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=
\ No newline at end of file
diff --git a/src/ink/events/click-event.ts b/src/ink/events/click-event.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1f58659a89bb7c5d7e8e24f875426ca959edc550
--- /dev/null
+++ b/src/ink/events/click-event.ts
@@ -0,0 +1,38 @@
+import { Event } from './event.js'
+
+/**
+ * Mouse click event. Fired on left-button release without drag, only when
+ * mouse tracking is enabled (i.e. inside ).
+ *
+ * Bubbles from the deepest hit node up through parentNode. Call
+ * stopImmediatePropagation() to prevent ancestors' onClick from firing.
+ */
+export class ClickEvent extends Event {
+ /** 0-indexed screen column of the click */
+ readonly col: number
+ /** 0-indexed screen row of the click */
+ readonly row: number
+ /**
+ * Click column relative to the current handler's Box (col - box.x).
+ * Recomputed by dispatchClick before each handler fires, so an onClick
+ * on a container sees coords relative to that container, not to any
+ * child the click landed on.
+ */
+ localCol = 0
+ /** Click row relative to the current handler's Box (row - box.y). */
+ localRow = 0
+ /**
+ * True if the clicked cell has no visible content (unwritten in the
+ * screen buffer — both packed words are 0). Handlers can check this to
+ * ignore clicks on blank space to the right of text, so accidental
+ * clicks on empty terminal space don't toggle state.
+ */
+ readonly cellIsBlank: boolean
+
+ constructor(col: number, row: number, cellIsBlank: boolean) {
+ super()
+ this.col = col
+ this.row = row
+ this.cellIsBlank = cellIsBlank
+ }
+}
diff --git a/src/ink/events/dispatcher.ts b/src/ink/events/dispatcher.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2d42884939a667e97ad83df35821d9e9daf28a25
--- /dev/null
+++ b/src/ink/events/dispatcher.ts
@@ -0,0 +1,235 @@
+import {
+ ContinuousEventPriority,
+ DefaultEventPriority,
+ DiscreteEventPriority,
+} from 'react-reconciler/constants.js'
+
+// NoEventPriority doesn't exist in react-reconciler 0.29, use 0 as fallback
+const NoEventPriority = 0;
+import { logError } from '../../utils/log.js'
+import { HANDLER_FOR_EVENT } from './event-handlers.js'
+import type { EventTarget, TerminalEvent } from './terminal-event.js'
+
+// --
+
+type DispatchListener = {
+ node: EventTarget
+ handler: (event: TerminalEvent) => void
+ phase: 'capturing' | 'at_target' | 'bubbling'
+}
+
+function getHandler(
+ node: EventTarget,
+ eventType: string,
+ capture: boolean,
+): ((event: TerminalEvent) => void) | undefined {
+ const handlers = node._eventHandlers
+ if (!handlers) return undefined
+
+ const mapping = HANDLER_FOR_EVENT[eventType]
+ if (!mapping) return undefined
+
+ const propName = capture ? mapping.capture : mapping.bubble
+ if (!propName) return undefined
+
+ return handlers[propName] as ((event: TerminalEvent) => void) | undefined
+}
+
+/**
+ * Collect all listeners for an event in dispatch order.
+ *
+ * Uses react-dom's two-phase accumulation pattern:
+ * - Walk from target to root
+ * - Capture handlers are prepended (unshift) → root-first
+ * - Bubble handlers are appended (push) → target-first
+ *
+ * Result: [root-cap, ..., parent-cap, target-cap, target-bub, parent-bub, ..., root-bub]
+ */
+function collectListeners(
+ target: EventTarget,
+ event: TerminalEvent,
+): DispatchListener[] {
+ const listeners: DispatchListener[] = []
+
+ let node: EventTarget | undefined = target
+ while (node) {
+ const isTarget = node === target
+
+ const captureHandler = getHandler(node, event.type, true)
+ const bubbleHandler = getHandler(node, event.type, false)
+
+ if (captureHandler) {
+ listeners.unshift({
+ node,
+ handler: captureHandler,
+ phase: isTarget ? 'at_target' : 'capturing',
+ })
+ }
+
+ if (bubbleHandler && (event.bubbles || isTarget)) {
+ listeners.push({
+ node,
+ handler: bubbleHandler,
+ phase: isTarget ? 'at_target' : 'bubbling',
+ })
+ }
+
+ node = node.parentNode
+ }
+
+ return listeners
+}
+
+/**
+ * Execute collected listeners with propagation control.
+ *
+ * Before each handler, calls event._prepareForTarget(node) so event
+ * subclasses can do per-node setup.
+ */
+function processDispatchQueue(
+ listeners: DispatchListener[],
+ event: TerminalEvent,
+): void {
+ let previousNode: EventTarget | undefined
+
+ for (const { node, handler, phase } of listeners) {
+ if (event._isImmediatePropagationStopped()) {
+ break
+ }
+
+ if (event._isPropagationStopped() && node !== previousNode) {
+ break
+ }
+
+ event._setEventPhase(phase)
+ event._setCurrentTarget(node)
+ event._prepareForTarget(node)
+
+ try {
+ handler(event)
+ } catch (error) {
+ logError(error)
+ }
+
+ previousNode = node
+ }
+}
+
+// --
+
+/**
+ * Map terminal event types to React scheduling priorities.
+ * Mirrors react-dom's getEventPriority() switch.
+ */
+function getEventPriority(eventType: string): number {
+ switch (eventType) {
+ case 'keydown':
+ case 'keyup':
+ case 'click':
+ case 'focus':
+ case 'blur':
+ case 'paste':
+ return DiscreteEventPriority as number
+ case 'resize':
+ case 'scroll':
+ case 'mousemove':
+ return ContinuousEventPriority as number
+ default:
+ return DefaultEventPriority as number
+ }
+}
+
+// --
+
+type DiscreteUpdates = (
+ fn: (a: A, b: B) => boolean,
+ a: A,
+ b: B,
+ c: undefined,
+ d: undefined,
+) => boolean
+
+/**
+ * Owns event dispatch state and the capture/bubble dispatch loop.
+ *
+ * The reconciler host config reads currentEvent and currentUpdatePriority
+ * to implement resolveUpdatePriority, resolveEventType, and
+ * resolveEventTimeStamp — mirroring how react-dom's host config reads
+ * ReactDOMSharedInternals and window.event.
+ *
+ * discreteUpdates is injected after construction (by InkReconciler)
+ * to break the import cycle.
+ */
+export class Dispatcher {
+ currentEvent: TerminalEvent | null = null
+ currentUpdatePriority: number = DefaultEventPriority as number
+ discreteUpdates: DiscreteUpdates | null = null
+
+ /**
+ * Infer event priority from the currently-dispatching event.
+ * Called by the reconciler host config's resolveUpdatePriority
+ * when no explicit priority has been set.
+ */
+ resolveEventPriority(): number {
+ if (this.currentUpdatePriority !== (NoEventPriority as number)) {
+ return this.currentUpdatePriority
+ }
+ if (this.currentEvent) {
+ return getEventPriority(this.currentEvent.type)
+ }
+ return DefaultEventPriority as number
+ }
+
+ /**
+ * Dispatch an event through capture and bubble phases.
+ * Returns true if preventDefault() was NOT called.
+ */
+ dispatch(target: EventTarget, event: TerminalEvent): boolean {
+ const previousEvent = this.currentEvent
+ this.currentEvent = event
+ try {
+ event._setTarget(target)
+
+ const listeners = collectListeners(target, event)
+ processDispatchQueue(listeners, event)
+
+ event._setEventPhase('none')
+ event._setCurrentTarget(null)
+
+ return !event.defaultPrevented
+ } finally {
+ this.currentEvent = previousEvent
+ }
+ }
+
+ /**
+ * Dispatch with discrete (sync) priority.
+ * For user-initiated events: keyboard, click, focus, paste.
+ */
+ dispatchDiscrete(target: EventTarget, event: TerminalEvent): boolean {
+ if (!this.discreteUpdates) {
+ return this.dispatch(target, event)
+ }
+ return this.discreteUpdates(
+ (t, e) => this.dispatch(t, e),
+ target,
+ event,
+ undefined,
+ undefined,
+ )
+ }
+
+ /**
+ * Dispatch with continuous priority.
+ * For high-frequency events: resize, scroll, mouse move.
+ */
+ dispatchContinuous(target: EventTarget, event: TerminalEvent): boolean {
+ const previousPriority = this.currentUpdatePriority
+ try {
+ this.currentUpdatePriority = ContinuousEventPriority as number
+ return this.dispatch(target, event)
+ } finally {
+ this.currentUpdatePriority = previousPriority
+ }
+ }
+}
diff --git a/src/ink/events/emitter.ts b/src/ink/events/emitter.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56a4b0dc69a0c4af3b6cb3a3421ff901a4075200
--- /dev/null
+++ b/src/ink/events/emitter.ts
@@ -0,0 +1,39 @@
+import { EventEmitter as NodeEventEmitter } from 'events'
+import { Event } from './event.js'
+
+// Similar to node's builtin EventEmitter, but is also aware of our `Event`
+// class, and so `emit` respects `stopImmediatePropagation()`.
+export class EventEmitter extends NodeEventEmitter {
+ constructor() {
+ super()
+ // Disable the default maxListeners warning. In React, many components
+ // can legitimately listen to the same event (e.g., useInput hooks).
+ // The default limit of 10 causes spurious warnings.
+ this.setMaxListeners(0)
+ }
+
+ override emit(type: string | symbol, ...args: unknown[]): boolean {
+ // Delegate to node for `error`, since it's not treated like a normal event
+ if (type === 'error') {
+ return super.emit(type, ...args)
+ }
+
+ const listeners = this.rawListeners(type)
+
+ if (listeners.length === 0) {
+ return false
+ }
+
+ const ccEvent = args[0] instanceof Event ? args[0] : null
+
+ for (const listener of listeners) {
+ listener.apply(this, args)
+
+ if (ccEvent?.didStopImmediatePropagation()) {
+ break
+ }
+ }
+
+ return true
+ }
+}
diff --git a/src/ink/events/event-handlers.ts b/src/ink/events/event-handlers.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7865f5b3c721f75525d4ec351f9558ded7d60b40
--- /dev/null
+++ b/src/ink/events/event-handlers.ts
@@ -0,0 +1,73 @@
+import type { ClickEvent } from './click-event.js'
+import type { FocusEvent } from './focus-event.js'
+import type { KeyboardEvent } from './keyboard-event.js'
+import type { PasteEvent } from './paste-event.js'
+import type { ResizeEvent } from './resize-event.js'
+
+type KeyboardEventHandler = (event: KeyboardEvent) => void
+type FocusEventHandler = (event: FocusEvent) => void
+type PasteEventHandler = (event: PasteEvent) => void
+type ResizeEventHandler = (event: ResizeEvent) => void
+type ClickEventHandler = (event: ClickEvent) => void
+type HoverEventHandler = () => void
+
+/**
+ * Props for event handlers on Box and other host components.
+ *
+ * Follows the React/DOM naming convention:
+ * - onEventName: handler for bubble phase
+ * - onEventNameCapture: handler for capture phase
+ */
+export type EventHandlerProps = {
+ onKeyDown?: KeyboardEventHandler
+ onKeyDownCapture?: KeyboardEventHandler
+
+ onFocus?: FocusEventHandler
+ onFocusCapture?: FocusEventHandler
+ onBlur?: FocusEventHandler
+ onBlurCapture?: FocusEventHandler
+
+ onPaste?: PasteEventHandler
+ onPasteCapture?: PasteEventHandler
+
+ onResize?: ResizeEventHandler
+
+ onClick?: ClickEventHandler
+ onMouseEnter?: HoverEventHandler
+ onMouseLeave?: HoverEventHandler
+}
+
+/**
+ * Reverse lookup: event type string → handler prop names.
+ * Used by the dispatcher for O(1) handler lookup per node.
+ */
+export const HANDLER_FOR_EVENT: Record<
+ string,
+ { bubble?: keyof EventHandlerProps; capture?: keyof EventHandlerProps }
+> = {
+ keydown: { bubble: 'onKeyDown', capture: 'onKeyDownCapture' },
+ focus: { bubble: 'onFocus', capture: 'onFocusCapture' },
+ blur: { bubble: 'onBlur', capture: 'onBlurCapture' },
+ paste: { bubble: 'onPaste', capture: 'onPasteCapture' },
+ resize: { bubble: 'onResize' },
+ click: { bubble: 'onClick' },
+}
+
+/**
+ * Set of all event handler prop names, for the reconciler to detect
+ * event props and store them in _eventHandlers instead of attributes.
+ */
+export const EVENT_HANDLER_PROPS = new Set([
+ 'onKeyDown',
+ 'onKeyDownCapture',
+ 'onFocus',
+ 'onFocusCapture',
+ 'onBlur',
+ 'onBlurCapture',
+ 'onPaste',
+ 'onPasteCapture',
+ 'onResize',
+ 'onClick',
+ 'onMouseEnter',
+ 'onMouseLeave',
+])
diff --git a/src/ink/events/event.ts b/src/ink/events/event.ts
new file mode 100644
index 0000000000000000000000000000000000000000..61874002ebbdb476ffe9a2a0db8001ec6aefb178
--- /dev/null
+++ b/src/ink/events/event.ts
@@ -0,0 +1,11 @@
+export class Event {
+ private _didStopImmediatePropagation = false
+
+ didStopImmediatePropagation(): boolean {
+ return this._didStopImmediatePropagation
+ }
+
+ stopImmediatePropagation(): void {
+ this._didStopImmediatePropagation = true
+ }
+}
diff --git a/src/ink/events/focus-event.ts b/src/ink/events/focus-event.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a552e54561162cb97469e1160d1529e30d17ed48
--- /dev/null
+++ b/src/ink/events/focus-event.ts
@@ -0,0 +1,21 @@
+import { type EventTarget, TerminalEvent } from './terminal-event.js'
+
+/**
+ * Focus event for component focus changes.
+ *
+ * Dispatched when focus moves between elements. 'focus' fires on the
+ * newly focused element, 'blur' fires on the previously focused one.
+ * Both bubble, matching react-dom's use of focusin/focusout semantics
+ * so parent components can observe descendant focus changes.
+ */
+export class FocusEvent extends TerminalEvent {
+ readonly relatedTarget: EventTarget | null
+
+ constructor(
+ type: 'focus' | 'blur',
+ relatedTarget: EventTarget | null = null,
+ ) {
+ super(type, { bubbles: true, cancelable: false })
+ this.relatedTarget = relatedTarget
+ }
+}
diff --git a/src/ink/events/input-event.ts b/src/ink/events/input-event.ts
new file mode 100644
index 0000000000000000000000000000000000000000..490502811fefaa513b133f9c840904c7ce63a907
--- /dev/null
+++ b/src/ink/events/input-event.ts
@@ -0,0 +1,205 @@
+import { nonAlphanumericKeys, type ParsedKey } from '../parse-keypress.js'
+import { Event } from './event.js'
+
+export type Key = {
+ upArrow: boolean
+ downArrow: boolean
+ leftArrow: boolean
+ rightArrow: boolean
+ pageDown: boolean
+ pageUp: boolean
+ wheelUp: boolean
+ wheelDown: boolean
+ home: boolean
+ end: boolean
+ return: boolean
+ escape: boolean
+ ctrl: boolean
+ shift: boolean
+ fn: boolean
+ tab: boolean
+ backspace: boolean
+ delete: boolean
+ meta: boolean
+ super: boolean
+}
+
+function parseKey(keypress: ParsedKey): [Key, string] {
+ const key: Key = {
+ upArrow: keypress.name === 'up',
+ downArrow: keypress.name === 'down',
+ leftArrow: keypress.name === 'left',
+ rightArrow: keypress.name === 'right',
+ pageDown: keypress.name === 'pagedown',
+ pageUp: keypress.name === 'pageup',
+ wheelUp: keypress.name === 'wheelup',
+ wheelDown: keypress.name === 'wheeldown',
+ home: keypress.name === 'home',
+ end: keypress.name === 'end',
+ return: keypress.name === 'return',
+ escape: keypress.name === 'escape',
+ fn: keypress.fn,
+ ctrl: keypress.ctrl,
+ shift: keypress.shift,
+ tab: keypress.name === 'tab',
+ backspace: keypress.name === 'backspace',
+ delete: keypress.name === 'delete',
+ // `parseKeypress` parses \u001B\u001B[A (meta + up arrow) as meta = false
+ // but with option = true, so we need to take this into account here
+ // to avoid breaking changes in Ink.
+ // TODO(vadimdemedes): consider removing this in the next major version.
+ meta: keypress.meta || keypress.name === 'escape' || keypress.option,
+ // Super (Cmd on macOS / Win key) — only arrives via kitty keyboard
+ // protocol CSI u sequences. Distinct from meta (Alt/Option) so
+ // bindings like cmd+c can be expressed separately from opt+c.
+ super: keypress.super,
+ }
+
+ let input = keypress.ctrl ? keypress.name : keypress.sequence
+
+ // Handle undefined input case
+ if (input === undefined) {
+ input = ''
+ }
+
+ // When ctrl is set, keypress.name for space is the literal word "space".
+ // Convert to actual space character for consistency with the CSI u branch
+ // (which maps 'space' → ' '). Without this, ctrl+space leaks the literal
+ // word "space" into text input.
+ if (keypress.ctrl && input === 'space') {
+ input = ' '
+ }
+
+ // Suppress unrecognized escape sequences that were parsed as function keys
+ // (matched by FN_KEY_RE) but have no name in the keyName map.
+ // Examples: ESC[25~ (F13/Right Alt on Windows), ESC[26~ (F14), etc.
+ // Without this, the ESC prefix is stripped below and the remainder (e.g.,
+ // "[25~") leaks into the input as literal text.
+ if (keypress.code && !keypress.name) {
+ input = ''
+ }
+
+ // Suppress ESC-less SGR mouse fragments. When a heavy React commit blocks
+ // the event loop past App's 50ms NORMAL_TIMEOUT flush, a CSI split across
+ // stdin chunks gets its buffered ESC flushed as a lone Escape key, and the
+ // continuation arrives as a text token with name='' — which falls through
+ // all of parseKeypress's ESC-anchored regexes and the nonAlphanumericKeys
+ // clear below (name is falsy). The fragment then leaks into the prompt as
+ // literal `[<64;74;16M`. This is the same defensive sink as the F13 guard
+ // above; the underlying tokenizer-flush race is upstream of this layer.
+ if (!keypress.name && /^\[<\d+;\d+;\d+[Mm]/.test(input)) {
+ input = ''
+ }
+
+ // Strip meta if it's still remaining after `parseKeypress`
+ // TODO(vadimdemedes): remove this in the next major version.
+ if (input.startsWith('\u001B')) {
+ input = input.slice(1)
+ }
+
+ // Track whether we've already processed this as a special sequence
+ // that converted input to the key name (CSI u or application keypad mode).
+ // For these, we don't want to clear input with nonAlphanumericKeys check.
+ let processedAsSpecialSequence = false
+
+ // Handle CSI u sequences (Kitty keyboard protocol): after stripping ESC,
+ // we're left with "[codepoint;modifieru" (e.g., "[98;3u" for Alt+b).
+ // Use the parsed key name instead for input handling. Require a digit
+ // after [ — real CSI u is always […u, and a bare startsWith('[')
+ // false-matches X10 mouse at row 85 (Cy = 85+32 = 'u'), leaking the
+ // literal text "mouse" into the prompt via processedAsSpecialSequence.
+ if (/^\[\d/.test(input) && input.endsWith('u')) {
+ if (!keypress.name) {
+ // Unmapped Kitty functional key (Caps Lock 57358, F13–F35, KP nav,
+ // bare modifiers, etc.) — keycodeToName() returned undefined. Swallow
+ // so the raw "[57358u" doesn't leak into the prompt. See #38781.
+ input = ''
+ } else {
+ // 'space' → ' '; 'escape' → '' (key.escape carries it;
+ // processedAsSpecialSequence bypasses the nonAlphanumericKeys
+ // clear below, so we must handle it explicitly here);
+ // otherwise use key name.
+ input =
+ keypress.name === 'space'
+ ? ' '
+ : keypress.name === 'escape'
+ ? ''
+ : keypress.name
+ }
+ processedAsSpecialSequence = true
+ }
+
+ // Handle xterm modifyOtherKeys sequences: after stripping ESC, we're left
+ // with "[27;modifier;keycode~" (e.g., "[27;3;98~" for Alt+b). Same
+ // extraction as CSI u — without this, printable-char keycodes (single-letter
+ // names) skip the nonAlphanumericKeys clear and leak "[27;..." as input.
+ if (input.startsWith('[27;') && input.endsWith('~')) {
+ if (!keypress.name) {
+ // Unmapped modifyOtherKeys keycode — swallow for consistency with
+ // the CSI u handler above. Practically untriggerable today (xterm
+ // modifyOtherKeys only sends ASCII keycodes, all mapped), but
+ // guards against future terminal behavior.
+ input = ''
+ } else {
+ input =
+ keypress.name === 'space'
+ ? ' '
+ : keypress.name === 'escape'
+ ? ''
+ : keypress.name
+ }
+ processedAsSpecialSequence = true
+ }
+
+ // Handle application keypad mode sequences: after stripping ESC,
+ // we're left with "O" (e.g., "Op" for numpad 0, "Oy" for numpad 9).
+ // Use the parsed key name (the digit character) for input handling.
+ if (
+ input.startsWith('O') &&
+ input.length === 2 &&
+ keypress.name &&
+ keypress.name.length === 1
+ ) {
+ input = keypress.name
+ processedAsSpecialSequence = true
+ }
+
+ // Clear input for non-alphanumeric keys (arrows, function keys, etc.)
+ // Skip this for CSI u and application keypad mode sequences since
+ // those were already converted to their proper input characters.
+ if (
+ !processedAsSpecialSequence &&
+ keypress.name &&
+ nonAlphanumericKeys.includes(keypress.name)
+ ) {
+ input = ''
+ }
+
+ // Set shift=true for uppercase letters (A-Z)
+ // Must check it's actually a letter, not just any char unchanged by toUpperCase
+ if (
+ input.length === 1 &&
+ typeof input[0] === 'string' &&
+ input[0] >= 'A' &&
+ input[0] <= 'Z'
+ ) {
+ key.shift = true
+ }
+
+ return [key, input]
+}
+
+export class InputEvent extends Event {
+ readonly keypress: ParsedKey
+ readonly key: Key
+ readonly input: string
+
+ constructor(keypress: ParsedKey) {
+ super()
+ const [key, input] = parseKey(keypress)
+
+ this.keypress = keypress
+ this.key = key
+ this.input = input
+ }
+}
diff --git a/src/ink/events/keyboard-event.ts b/src/ink/events/keyboard-event.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1210efd13da400294fbf47a09358632f80e6cd80
--- /dev/null
+++ b/src/ink/events/keyboard-event.ts
@@ -0,0 +1,51 @@
+import type { ParsedKey } from '../parse-keypress.js'
+import { TerminalEvent } from './terminal-event.js'
+
+/**
+ * Keyboard event dispatched through the DOM tree via capture/bubble.
+ *
+ * Follows browser KeyboardEvent semantics: `key` is the literal character
+ * for printable keys ('a', '3', ' ', '/') and a multi-char name for
+ * special keys ('down', 'return', 'escape', 'f1'). The idiomatic
+ * printable-char check is `e.key.length === 1`.
+ */
+export class KeyboardEvent extends TerminalEvent {
+ readonly key: string
+ readonly ctrl: boolean
+ readonly shift: boolean
+ readonly meta: boolean
+ readonly superKey: boolean
+ readonly fn: boolean
+
+ constructor(parsedKey: ParsedKey) {
+ super('keydown', { bubbles: true, cancelable: true })
+
+ this.key = keyFromParsed(parsedKey)
+ this.ctrl = parsedKey.ctrl
+ this.shift = parsedKey.shift
+ this.meta = parsedKey.meta || parsedKey.option
+ this.superKey = parsedKey.super
+ this.fn = parsedKey.fn
+ }
+}
+
+function keyFromParsed(parsed: ParsedKey): string {
+ const seq = parsed.sequence ?? ''
+ const name = parsed.name ?? ''
+
+ // Ctrl combos: sequence is a control byte (\x03 for ctrl+c), name is the
+ // letter. Browsers report e.key === 'c' with e.ctrlKey === true.
+ if (parsed.ctrl) return name
+
+ // Single printable char (space through ~, plus anything above ASCII):
+ // use the literal char. Browsers report e.key === '3', not 'Digit3'.
+ if (seq.length === 1) {
+ const code = seq.charCodeAt(0)
+ if (code >= 0x20 && code !== 0x7f) return seq
+ }
+
+ // Special keys (arrows, F-keys, return, tab, escape, etc.): sequence is
+ // either an escape sequence (\x1b[B) or a control byte (\r, \t), so use
+ // the parsed name. Browsers report e.key === 'ArrowDown'.
+ return name || seq
+}
diff --git a/src/ink/events/terminal-event.ts b/src/ink/events/terminal-event.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9a86bf8b296dac649b632ff172a470933d1f8493
--- /dev/null
+++ b/src/ink/events/terminal-event.ts
@@ -0,0 +1,107 @@
+import { Event } from './event.js'
+
+type EventPhase = 'none' | 'capturing' | 'at_target' | 'bubbling'
+
+type TerminalEventInit = {
+ bubbles?: boolean
+ cancelable?: boolean
+}
+
+/**
+ * Base class for all terminal events with DOM-style propagation.
+ *
+ * Extends Event so existing event types (ClickEvent, InputEvent,
+ * TerminalFocusEvent) share a common ancestor and can migrate later.
+ *
+ * Mirrors the browser's Event API: target, currentTarget, eventPhase,
+ * stopPropagation(), preventDefault(), timeStamp.
+ */
+export class TerminalEvent extends Event {
+ readonly type: string
+ readonly timeStamp: number
+ readonly bubbles: boolean
+ readonly cancelable: boolean
+
+ private _target: EventTarget | null = null
+ private _currentTarget: EventTarget | null = null
+ private _eventPhase: EventPhase = 'none'
+ private _propagationStopped = false
+ private _defaultPrevented = false
+
+ constructor(type: string, init?: TerminalEventInit) {
+ super()
+ this.type = type
+ this.timeStamp = performance.now()
+ this.bubbles = init?.bubbles ?? true
+ this.cancelable = init?.cancelable ?? true
+ }
+
+ get target(): EventTarget | null {
+ return this._target
+ }
+
+ get currentTarget(): EventTarget | null {
+ return this._currentTarget
+ }
+
+ get eventPhase(): EventPhase {
+ return this._eventPhase
+ }
+
+ get defaultPrevented(): boolean {
+ return this._defaultPrevented
+ }
+
+ stopPropagation(): void {
+ this._propagationStopped = true
+ }
+
+ override stopImmediatePropagation(): void {
+ super.stopImmediatePropagation()
+ this._propagationStopped = true
+ }
+
+ preventDefault(): void {
+ if (this.cancelable) {
+ this._defaultPrevented = true
+ }
+ }
+
+ // -- Internal setters used by the Dispatcher
+
+ /** @internal */
+ _setTarget(target: EventTarget): void {
+ this._target = target
+ }
+
+ /** @internal */
+ _setCurrentTarget(target: EventTarget | null): void {
+ this._currentTarget = target
+ }
+
+ /** @internal */
+ _setEventPhase(phase: EventPhase): void {
+ this._eventPhase = phase
+ }
+
+ /** @internal */
+ _isPropagationStopped(): boolean {
+ return this._propagationStopped
+ }
+
+ /** @internal */
+ _isImmediatePropagationStopped(): boolean {
+ return this.didStopImmediatePropagation()
+ }
+
+ /**
+ * Hook for subclasses to do per-node setup before each handler fires.
+ * Default is a no-op.
+ */
+ _prepareForTarget(_target: EventTarget): void {}
+}
+
+export type EventTarget = {
+ parentNode: EventTarget | undefined
+ _eventHandlers?: Record
+}
diff --git a/src/ink/events/terminal-focus-event.ts b/src/ink/events/terminal-focus-event.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d0303fdb48c824d9ca7b104d0180ec7f9a5b0e8
--- /dev/null
+++ b/src/ink/events/terminal-focus-event.ts
@@ -0,0 +1,19 @@
+import { Event } from './event.js'
+
+export type TerminalFocusEventType = 'terminalfocus' | 'terminalblur'
+
+/**
+ * Event fired when the terminal window gains or loses focus.
+ *
+ * Uses DECSET 1004 focus reporting - the terminal sends:
+ * - CSI I (\x1b[I) when the terminal gains focus
+ * - CSI O (\x1b[O) when the terminal loses focus
+ */
+export class TerminalFocusEvent extends Event {
+ readonly type: TerminalFocusEventType
+
+ constructor(type: TerminalFocusEventType) {
+ super()
+ this.type = type
+ }
+}
diff --git a/src/ink/hooks/use-animation-frame.ts b/src/ink/hooks/use-animation-frame.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d4dd38a1657f8f4ccff70211f269353291da7ce6
--- /dev/null
+++ b/src/ink/hooks/use-animation-frame.ts
@@ -0,0 +1,57 @@
+import { useContext, useEffect, useState } from 'react'
+import { ClockContext } from '../components/ClockContext.js'
+import type { DOMElement } from '../dom.js'
+import { useTerminalViewport } from './use-terminal-viewport.js'
+
+/**
+ * Hook for synchronized animations that pause when offscreen.
+ *
+ * Returns a ref to attach to the animated element and the current animation time.
+ * All instances share the same clock, so animations stay in sync.
+ * The clock only runs when at least one keepAlive subscriber exists.
+ *
+ * Pass `null` to pause — unsubscribes from the clock so no ticks fire.
+ * Time freezes at the last value and resumes from the current clock time
+ * when a number is passed again.
+ *
+ * @param intervalMs - How often to update, or null to pause
+ * @returns [ref, time] - Ref to attach to element, elapsed time in ms
+ *
+ * @example
+ * function Spinner() {
+ * const [ref, time] = useAnimationFrame(120)
+ * const frame = Math.floor(time / 120) % FRAMES.length
+ * return {FRAMES[frame]}
+ * }
+ *
+ * The clock automatically slows when the terminal is blurred,
+ * so consumers don't need to handle focus state.
+ */
+export function useAnimationFrame(
+ intervalMs: number | null = 16,
+): [ref: (element: DOMElement | null) => void, time: number] {
+ const clock = useContext(ClockContext)
+ const [viewportRef, { isVisible }] = useTerminalViewport()
+ const [time, setTime] = useState(() => clock?.now() ?? 0)
+
+ const active = isVisible && intervalMs !== null
+
+ useEffect(() => {
+ if (!clock || !active) return
+
+ let lastUpdate = clock.now()
+
+ const onChange = (): void => {
+ const now = clock.now()
+ if (now - lastUpdate >= intervalMs!) {
+ lastUpdate = now
+ setTime(now)
+ }
+ }
+
+ // keepAlive: true — visible animations drive the clock
+ return clock.subscribe(onChange, true)
+ }, [clock, intervalMs, active])
+
+ return [viewportRef, time]
+}
diff --git a/src/ink/hooks/use-app.ts b/src/ink/hooks/use-app.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5545f35f7bf25ffdf858658243495f5bc9aca346
--- /dev/null
+++ b/src/ink/hooks/use-app.ts
@@ -0,0 +1,8 @@
+import { useContext } from 'react'
+import AppContext from '../components/AppContext.js'
+
+/**
+ * `useApp` is a React hook, which exposes a method to manually exit the app (unmount).
+ */
+const useApp = () => useContext(AppContext)
+export default useApp
diff --git a/src/ink/hooks/use-declared-cursor.ts b/src/ink/hooks/use-declared-cursor.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e49668b3885ba68a29e433f0370a6a24152cd760
--- /dev/null
+++ b/src/ink/hooks/use-declared-cursor.ts
@@ -0,0 +1,73 @@
+import { useCallback, useContext, useLayoutEffect, useRef } from 'react'
+import CursorDeclarationContext from '../components/CursorDeclarationContext.js'
+import type { DOMElement } from '../dom.js'
+
+/**
+ * Declares where the terminal cursor should be parked after each frame.
+ *
+ * Terminal emulators render IME preedit text at the physical cursor
+ * position, and screen readers / screen magnifiers track the native
+ * cursor — so parking it at the text input's caret makes CJK input
+ * appear inline and lets accessibility tools follow the input.
+ *
+ * Returns a ref callback to attach to the Box that contains the input.
+ * The declared (line, column) is interpreted relative to that Box's
+ * nodeCache rect (populated by renderNodeToOutput).
+ *
+ * Timing: Both ref attach and useLayoutEffect fire in React's layout
+ * phase — after resetAfterCommit calls scheduleRender. scheduleRender
+ * defers onRender via queueMicrotask, so onRender runs AFTER layout
+ * effects commit and reads the fresh declaration on the first frame
+ * (no one-keystroke lag). Test env uses onImmediateRender (synchronous,
+ * no microtask), so tests compensate by calling ink.onRender()
+ * explicitly after render.
+ */
+export function useDeclaredCursor({
+ line,
+ column,
+ active,
+}: {
+ line: number
+ column: number
+ active: boolean
+}): (element: DOMElement | null) => void {
+ const setCursorDeclaration = useContext(CursorDeclarationContext)
+ const nodeRef = useRef(null)
+
+ const setNode = useCallback((node: DOMElement | null) => {
+ nodeRef.current = node
+ }, [])
+
+ // When active, set unconditionally. When inactive, clear conditionally
+ // (only if the currently-declared node is ours). The node-identity check
+ // handles two hazards:
+ // 1. A memo()ized active instance elsewhere (e.g. the search input in
+ // a memo'd Footer) doesn't re-render this commit — an inactive
+ // instance re-rendering here must not clobber it.
+ // 2. Sibling handoff (menu focus moving between list items) — when
+ // focus moves opposite to sibling order, the newly-inactive item's
+ // effect runs AFTER the newly-active item's set. Without the node
+ // check it would clobber.
+ // No dep array: must re-declare every commit so the active instance
+ // re-claims the declaration after another instance's unmount-cleanup or
+ // sibling handoff nulls it.
+ useLayoutEffect(() => {
+ const node = nodeRef.current
+ if (active && node) {
+ setCursorDeclaration({ relativeX: column, relativeY: line, node })
+ } else {
+ setCursorDeclaration(null, node)
+ }
+ })
+
+ // Clear on unmount (conditionally — another instance may own by then).
+ // Separate effect with empty deps so cleanup only fires once — not on
+ // every line/column change, which would transiently null between commits.
+ useLayoutEffect(() => {
+ return () => {
+ setCursorDeclaration(null, nodeRef.current)
+ }
+ }, [setCursorDeclaration])
+
+ return setNode
+}
diff --git a/src/ink/hooks/use-input.ts b/src/ink/hooks/use-input.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7cf75b3114227891dde2babb6552182891bceabd
--- /dev/null
+++ b/src/ink/hooks/use-input.ts
@@ -0,0 +1,92 @@
+import { useEffect, useLayoutEffect } from 'react'
+import { useEventCallback } from 'usehooks-ts'
+import type { InputEvent, Key } from '../events/input-event.js'
+import useStdin from './use-stdin.js'
+
+type Handler = (input: string, key: Key, event: InputEvent) => void
+
+type Options = {
+ /**
+ * Enable or disable capturing of user input.
+ * Useful when there are multiple useInput hooks used at once to avoid handling the same input several times.
+ *
+ * @default true
+ */
+ isActive?: boolean
+}
+
+/**
+ * This hook is used for handling user input.
+ * It's a more convenient alternative to using `StdinContext` and listening to `data` events.
+ * The callback you pass to `useInput` is called for each character when user enters any input.
+ * However, if user pastes text and it's more than one character, the callback will be called only once and the whole string will be passed as `input`.
+ *
+ * ```
+ * import {useInput} from 'ink';
+ *
+ * const UserInput = () => {
+ * useInput((input, key) => {
+ * if (input === 'q') {
+ * // Exit program
+ * }
+ *
+ * if (key.leftArrow) {
+ * // Left arrow key pressed
+ * }
+ * });
+ *
+ * return …
+ * };
+ * ```
+ */
+const useInput = (inputHandler: Handler, options: Options = {}) => {
+ const { setRawMode, internal_exitOnCtrlC, internal_eventEmitter } = useStdin()
+
+ // useLayoutEffect (not useEffect) so that raw mode is enabled synchronously
+ // during React's commit phase, before render() returns. With useEffect, raw
+ // mode setup is deferred to the next event loop tick via React's scheduler,
+ // leaving the terminal in cooked mode — keystrokes echo and the cursor is
+ // visible until the effect fires.
+ useLayoutEffect(() => {
+ if (options.isActive === false) {
+ return
+ }
+
+ setRawMode(true)
+
+ return () => {
+ setRawMode(false)
+ }
+ }, [options.isActive, setRawMode])
+
+ // Register the listener once on mount so its slot in the EventEmitter's
+ // listener array is stable. If isActive were in the effect's deps, the
+ // listener would re-append on false→true, moving it behind listeners
+ // that registered while it was inactive — breaking
+ // stopImmediatePropagation() ordering. useEventCallback keeps the
+ // reference stable while reading latest isActive/inputHandler from
+ // closure (it syncs via useLayoutEffect, so it's compiler-safe).
+ const handleData = useEventCallback((event: InputEvent) => {
+ if (options.isActive === false) {
+ return
+ }
+ const { input, key } = event
+
+ // If app is not supposed to exit on Ctrl+C, then let input listener handle it
+ // Note: discreteUpdates is called at the App level when emitting events,
+ // so all listeners are already within a high-priority update context.
+ if (!(input === 'c' && key.ctrl) || !internal_exitOnCtrlC) {
+ inputHandler(input, key, event)
+ }
+ })
+
+ useEffect(() => {
+ internal_eventEmitter?.on('input', handleData)
+
+ return () => {
+ internal_eventEmitter?.removeListener('input', handleData)
+ }
+ }, [internal_eventEmitter, handleData])
+}
+
+export default useInput
diff --git a/src/ink/hooks/use-interval.ts b/src/ink/hooks/use-interval.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49c3ee6279b119b0ebea5e103944961dc1fe0f27
--- /dev/null
+++ b/src/ink/hooks/use-interval.ts
@@ -0,0 +1,67 @@
+import { useContext, useEffect, useRef, useState } from 'react'
+import { ClockContext } from '../components/ClockContext.js'
+
+/**
+ * Returns the clock time, updating at the given interval.
+ * Subscribes as non-keepAlive — won't keep the clock alive on its own,
+ * but updates whenever a keepAlive subscriber (e.g. the spinner)
+ * is driving the clock.
+ *
+ * Use this to drive pure time-based computations (shimmer position,
+ * frame index) from the shared clock.
+ */
+export function useAnimationTimer(intervalMs: number): number {
+ const clock = useContext(ClockContext)
+ const [time, setTime] = useState(() => clock?.now() ?? 0)
+
+ useEffect(() => {
+ if (!clock) return
+
+ let lastUpdate = clock.now()
+
+ const onChange = (): void => {
+ const now = clock.now()
+ if (now - lastUpdate >= intervalMs) {
+ lastUpdate = now
+ setTime(now)
+ }
+ }
+
+ return clock.subscribe(onChange, false)
+ }, [clock, intervalMs])
+
+ return time
+}
+
+/**
+ * Interval hook backed by the shared Clock.
+ *
+ * Unlike `useInterval` from `usehooks-ts` (which creates its own setInterval),
+ * this piggybacks on the single shared clock so all timers consolidate into
+ * one wake-up. Pass `null` for intervalMs to pause.
+ */
+export function useInterval(
+ callback: () => void,
+ intervalMs: number | null,
+): void {
+ const callbackRef = useRef(callback)
+ callbackRef.current = callback
+
+ const clock = useContext(ClockContext)
+
+ useEffect(() => {
+ if (!clock || intervalMs === null) return
+
+ let lastUpdate = clock.now()
+
+ const onChange = (): void => {
+ const now = clock.now()
+ if (now - lastUpdate >= intervalMs) {
+ lastUpdate = now
+ callbackRef.current()
+ }
+ }
+
+ return clock.subscribe(onChange, false)
+ }, [clock, intervalMs])
+}
diff --git a/src/ink/hooks/use-search-highlight.ts b/src/ink/hooks/use-search-highlight.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ce9fc364dccc0c6f675402dc672e1b8fb8d53807
--- /dev/null
+++ b/src/ink/hooks/use-search-highlight.ts
@@ -0,0 +1,53 @@
+import { useContext, useMemo } from 'react'
+import StdinContext from '../components/StdinContext.js'
+import type { DOMElement } from '../dom.js'
+import instances from '../instances.js'
+import type { MatchPosition } from '../render-to-screen.js'
+
+/**
+ * Set the search highlight query on the Ink instance. Non-empty → all
+ * visible occurrences are inverted on the next frame (SGR 7, screen-buffer
+ * overlay, same damage machinery as selection). Empty → clears.
+ *
+ * This is a screen-space highlight — it matches the RENDERED text, not the
+ * source message text. Works for anything visible (bash output, file paths,
+ * error messages) regardless of where it came from in the message tree. A
+ * query that matched in source but got truncated/ellipsized in rendering
+ * won't highlight; that's acceptable — we highlight what you see.
+ */
+export function useSearchHighlight(): {
+ setQuery: (query: string) => void
+ /** Paint an existing DOM subtree (from the MAIN tree) to a fresh
+ * Screen at its natural height, scan. Element-relative positions
+ * (row 0 = element top). Zero context duplication — the element
+ * IS the one built with all real providers. */
+ scanElement: (el: DOMElement) => MatchPosition[]
+ /** Position-based CURRENT highlight. Every frame writes yellow at
+ * positions[currentIdx] + rowOffset. The scan-highlight (inverse on
+ * all matches) still runs — this overlays on top. rowOffset tracks
+ * scroll; positions stay stable (message-relative). null clears. */
+ setPositions: (
+ state: {
+ positions: MatchPosition[]
+ rowOffset: number
+ currentIdx: number
+ } | null,
+ ) => void
+} {
+ useContext(StdinContext) // anchor to App subtree for hook rules
+ const ink = instances.get(process.stdout)
+ return useMemo(() => {
+ if (!ink) {
+ return {
+ setQuery: () => {},
+ scanElement: () => [],
+ setPositions: () => {},
+ }
+ }
+ return {
+ setQuery: (query: string) => ink.setSearchHighlight(query),
+ scanElement: (el: DOMElement) => ink.scanElementSubtree(el),
+ setPositions: state => ink.setSearchPositions(state),
+ }
+ }, [ink])
+}
diff --git a/src/ink/hooks/use-selection.ts b/src/ink/hooks/use-selection.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f7e1d45717c18282bca8c307c60f7d9038dc7471
--- /dev/null
+++ b/src/ink/hooks/use-selection.ts
@@ -0,0 +1,104 @@
+import { useContext, useMemo, useSyncExternalStore } from 'react'
+import StdinContext from '../components/StdinContext.js'
+import instances from '../instances.js'
+import {
+ type FocusMove,
+ type SelectionState,
+ shiftAnchor,
+} from '../selection.js'
+
+/**
+ * Access to text selection operations on the Ink instance (fullscreen only).
+ * Returns no-op functions when fullscreen mode is disabled.
+ */
+export function useSelection(): {
+ copySelection: () => string
+ /** Copy without clearing the highlight (for copy-on-select). */
+ copySelectionNoClear: () => string
+ clearSelection: () => void
+ hasSelection: () => boolean
+ /** Read the raw mutable selection state (for drag-to-scroll). */
+ getState: () => SelectionState | null
+ /** Subscribe to selection mutations (start/update/finish/clear). */
+ subscribe: (cb: () => void) => () => void
+ /** Shift the anchor row by dRow, clamped to [minRow, maxRow]. */
+ shiftAnchor: (dRow: number, minRow: number, maxRow: number) => void
+ /** Shift anchor AND focus by dRow (keyboard scroll: whole selection
+ * tracks content). Clamped points get col reset to the full-width edge
+ * since their content was captured by captureScrolledRows. Reads
+ * screen.width from the ink instance for the col-reset boundary. */
+ shiftSelection: (dRow: number, minRow: number, maxRow: number) => void
+ /** Keyboard selection extension (shift+arrow): move focus, anchor fixed.
+ * Left/right wrap across rows; up/down clamp at viewport edges. */
+ moveFocus: (move: FocusMove) => void
+ /** Capture text from rows about to scroll out of the viewport (call
+ * BEFORE scrollBy so the screen buffer still has the outgoing rows). */
+ captureScrolledRows: (
+ firstRow: number,
+ lastRow: number,
+ side: 'above' | 'below',
+ ) => void
+ /** Set the selection highlight bg color (theme-piping; solid bg
+ * replaces the old SGR-7 inverse so syntax highlighting stays readable
+ * under selection). Call once on mount + whenever theme changes. */
+ setSelectionBgColor: (color: string) => void
+} {
+ // Look up the Ink instance via stdout — same pattern as instances map.
+ // StdinContext is available (it's always provided), and the Ink instance
+ // is keyed by stdout which we can get from process.stdout since there's
+ // only one Ink instance per process in practice.
+ useContext(StdinContext) // anchor to App subtree for hook rules
+ const ink = instances.get(process.stdout)
+ // Memoize so callers can safely use the return value in dependency arrays.
+ // ink is a singleton per stdout — stable across renders.
+ return useMemo(() => {
+ if (!ink) {
+ return {
+ copySelection: () => '',
+ copySelectionNoClear: () => '',
+ clearSelection: () => {},
+ hasSelection: () => false,
+ getState: () => null,
+ subscribe: () => () => {},
+ shiftAnchor: () => {},
+ shiftSelection: () => {},
+ moveFocus: () => {},
+ captureScrolledRows: () => {},
+ setSelectionBgColor: () => {},
+ }
+ }
+ return {
+ copySelection: () => ink.copySelection(),
+ copySelectionNoClear: () => ink.copySelectionNoClear(),
+ clearSelection: () => ink.clearTextSelection(),
+ hasSelection: () => ink.hasTextSelection(),
+ getState: () => ink.selection,
+ subscribe: (cb: () => void) => ink.subscribeToSelectionChange(cb),
+ shiftAnchor: (dRow: number, minRow: number, maxRow: number) =>
+ shiftAnchor(ink.selection, dRow, minRow, maxRow),
+ shiftSelection: (dRow, minRow, maxRow) =>
+ ink.shiftSelectionForScroll(dRow, minRow, maxRow),
+ moveFocus: (move: FocusMove) => ink.moveSelectionFocus(move),
+ captureScrolledRows: (firstRow, lastRow, side) =>
+ ink.captureScrolledRows(firstRow, lastRow, side),
+ setSelectionBgColor: (color: string) => ink.setSelectionBgColor(color),
+ }
+ }, [ink])
+}
+
+const NO_SUBSCRIBE = () => () => {}
+const ALWAYS_FALSE = () => false
+
+/**
+ * Reactive selection-exists state. Re-renders the caller when a text
+ * selection is created or cleared. Always returns false outside
+ * fullscreen mode (selection is only available in alt-screen).
+ */
+export function useHasSelection(): boolean {
+ useContext(StdinContext)
+ const ink = instances.get(process.stdout)
+ return useSyncExternalStore(
+ ink ? ink.subscribeToSelectionChange : NO_SUBSCRIBE,
+ ink ? ink.hasTextSelection : ALWAYS_FALSE,
+ )
+}
diff --git a/src/ink/hooks/use-stdin.ts b/src/ink/hooks/use-stdin.ts
new file mode 100644
index 0000000000000000000000000000000000000000..997f3c3883f1c787befdc640cd730471487db9c5
--- /dev/null
+++ b/src/ink/hooks/use-stdin.ts
@@ -0,0 +1,8 @@
+import { useContext } from 'react'
+import StdinContext from '../components/StdinContext.js'
+
+/**
+ * `useStdin` is a React hook, which exposes stdin stream.
+ */
+const useStdin = () => useContext(StdinContext)
+export default useStdin
diff --git a/src/ink/hooks/use-terminal-focus.ts b/src/ink/hooks/use-terminal-focus.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b717f7b469550cbe649fab4b913a4e023ecb67e5
--- /dev/null
+++ b/src/ink/hooks/use-terminal-focus.ts
@@ -0,0 +1,16 @@
+import { useContext } from 'react'
+import TerminalFocusContext from '../components/TerminalFocusContext.js'
+
+/**
+ * Hook to check if the terminal has focus.
+ *
+ * Uses DECSET 1004 focus reporting - the terminal sends escape sequences
+ * when it gains or loses focus. These are handled automatically
+ * by Ink and filtered from useInput.
+ *
+ * @returns true if the terminal is focused (or focus state is unknown)
+ */
+export function useTerminalFocus(): boolean {
+ const { isTerminalFocused } = useContext(TerminalFocusContext)
+ return isTerminalFocused
+}
diff --git a/src/ink/hooks/use-terminal-title.ts b/src/ink/hooks/use-terminal-title.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d820cd7ae94a0f4a69c8188cc3a5966e72e6b8f5
--- /dev/null
+++ b/src/ink/hooks/use-terminal-title.ts
@@ -0,0 +1,31 @@
+import { useContext, useEffect } from 'react'
+import stripAnsi from 'strip-ansi'
+import { OSC, osc } from '../termio/osc.js'
+import { TerminalWriteContext } from '../useTerminalNotification.js'
+
+/**
+ * Declaratively set the terminal tab/window title.
+ *
+ * Pass a string to set the title. ANSI escape sequences are stripped
+ * automatically so callers don't need to know about terminal encoding.
+ * Pass `null` to opt out — the hook becomes a no-op and leaves the
+ * terminal title untouched.
+ *
+ * On Windows, uses `process.title` (classic conhost doesn't support OSC).
+ * Elsewhere, writes OSC 0 (set title+icon) via Ink's stdout.
+ */
+export function useTerminalTitle(title: string | null): void {
+ const writeRaw = useContext(TerminalWriteContext)
+
+ useEffect(() => {
+ if (title === null || !writeRaw) return
+
+ const clean = stripAnsi(title)
+
+ if (process.platform === 'win32') {
+ process.title = clean
+ } else {
+ writeRaw(osc(OSC.SET_TITLE_AND_ICON, clean))
+ }
+ }, [title, writeRaw])
+}
diff --git a/src/ink/hooks/use-terminal-viewport.ts b/src/ink/hooks/use-terminal-viewport.ts
new file mode 100644
index 0000000000000000000000000000000000000000..91193bf73f62b8af0f7bba8044284e9951bb4faf
--- /dev/null
+++ b/src/ink/hooks/use-terminal-viewport.ts
@@ -0,0 +1,96 @@
+import { useCallback, useContext, useLayoutEffect, useRef } from 'react'
+import { TerminalSizeContext } from '../components/TerminalSizeContext.js'
+import type { DOMElement } from '../dom.js'
+
+type ViewportEntry = {
+ /**
+ * Whether the element is currently within the terminal viewport
+ */
+ isVisible: boolean
+}
+
+/**
+ * Hook to detect if a component is within the terminal viewport.
+ *
+ * Returns a callback ref and a viewport entry object.
+ * Attach the ref to the component you want to track.
+ *
+ * The entry is updated during the layout phase (useLayoutEffect) so callers
+ * always read fresh values during render. Visibility changes do NOT trigger
+ * re-renders on their own — callers that re-render for other reasons (e.g.
+ * animation ticks, state changes) will pick up the latest value naturally.
+ * This avoids infinite update loops when combined with other layout effects
+ * that also call setState.
+ *
+ * @example
+ * const [ref, entry] = useTerminalViewport()
+ * return ...
+ */
+export function useTerminalViewport(): [
+ ref: (element: DOMElement | null) => void,
+ entry: ViewportEntry,
+] {
+ const terminalSize = useContext(TerminalSizeContext)
+ const elementRef = useRef(null)
+ const entryRef = useRef({ isVisible: true })
+
+ const setElement = useCallback((el: DOMElement | null) => {
+ elementRef.current = el
+ }, [])
+
+ // Runs on every render because yoga layout values can change
+ // without React being aware. Only updates the ref — no setState
+ // to avoid cascading re-renders during the commit phase.
+ // Walks the DOM ancestor chain fresh each time to avoid holding stale
+ // references after yoga tree rebuilds.
+ useLayoutEffect(() => {
+ const element = elementRef.current
+ if (!element?.yogaNode || !terminalSize) {
+ return
+ }
+
+ const height = element.yogaNode.getComputedHeight()
+ const rows = terminalSize.rows
+
+ // Walk the DOM parent chain (not yoga.getParent()) so we can detect
+ // scroll containers and subtract their scrollTop. Yoga computes layout
+ // positions without scroll offset — scrollTop is applied at render time.
+ // Without this, an element inside a ScrollBox whose yoga position exceeds
+ // terminalRows would be considered offscreen even when scrolled into view
+ // (e.g., the spinner in fullscreen mode after enough messages accumulate).
+ let absoluteTop = element.yogaNode.getComputedTop()
+ let parent: DOMElement | undefined = element.parentNode
+ let root = element.yogaNode
+ while (parent) {
+ if (parent.yogaNode) {
+ absoluteTop += parent.yogaNode.getComputedTop()
+ root = parent.yogaNode
+ }
+ // scrollTop is only ever set on scroll containers (by ScrollBox + renderer).
+ // Non-scroll nodes have undefined scrollTop → falsy fast-path.
+ if (parent.scrollTop) absoluteTop -= parent.scrollTop
+ parent = parent.parentNode
+ }
+
+ // Only the root's height matters
+ const screenHeight = root.getComputedHeight()
+
+ const bottom = absoluteTop + height
+ // When content overflows the viewport (screenHeight > rows), the
+ // cursor-restore at frame end scrolls one extra row into scrollback.
+ // log-update.ts accounts for this with scrollbackRows = viewportY + 1.
+ // We must match, otherwise an element at the boundary is considered
+ // "visible" here (animation keeps ticking) but its row is treated as
+ // scrollback by log-update (content change → full reset → flicker).
+ const cursorRestoreScroll = screenHeight > rows ? 1 : 0
+ const viewportY = Math.max(0, screenHeight - rows) + cursorRestoreScroll
+ const viewportBottom = viewportY + rows
+ const visible = bottom > viewportY && absoluteTop < viewportBottom
+
+ if (visible !== entryRef.current.isVisible) {
+ entryRef.current = { isVisible: visible }
+ }
+ })
+
+ return [setElement, entryRef.current]
+}
diff --git a/src/ink/layout/engine.ts b/src/ink/layout/engine.ts
new file mode 100644
index 0000000000000000000000000000000000000000..38f6dcb0fb5614d423f9a59cedb31d696ddeeef6
--- /dev/null
+++ b/src/ink/layout/engine.ts
@@ -0,0 +1,6 @@
+import type { LayoutNode } from './node.js'
+import { createYogaLayoutNode } from './yoga.js'
+
+export function createLayoutNode(): LayoutNode {
+ return createYogaLayoutNode()
+}
diff --git a/src/ink/layout/geometry.ts b/src/ink/layout/geometry.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e586f8ecf11df704babb9ad283f80e1c818b4477
--- /dev/null
+++ b/src/ink/layout/geometry.ts
@@ -0,0 +1,97 @@
+export type Point = {
+ x: number
+ y: number
+}
+
+export type Size = {
+ width: number
+ height: number
+}
+
+export type Rectangle = Point & Size
+
+/** Edge insets (padding, margin, border) */
+export type Edges = {
+ top: number
+ right: number
+ bottom: number
+ left: number
+}
+
+/** Create uniform edges */
+export function edges(all: number): Edges
+export function edges(vertical: number, horizontal: number): Edges
+export function edges(
+ top: number,
+ right: number,
+ bottom: number,
+ left: number,
+): Edges
+export function edges(a: number, b?: number, c?: number, d?: number): Edges {
+ if (b === undefined) {
+ return { top: a, right: a, bottom: a, left: a }
+ }
+ if (c === undefined) {
+ return { top: a, right: b, bottom: a, left: b }
+ }
+ return { top: a, right: b, bottom: c, left: d! }
+}
+
+/** Add two edge values */
+export function addEdges(a: Edges, b: Edges): Edges {
+ return {
+ top: a.top + b.top,
+ right: a.right + b.right,
+ bottom: a.bottom + b.bottom,
+ left: a.left + b.left,
+ }
+}
+
+/** Zero edges constant */
+export const ZERO_EDGES: Edges = { top: 0, right: 0, bottom: 0, left: 0 }
+
+/** Convert partial edges to full edges with defaults */
+export function resolveEdges(partial?: Partial): Edges {
+ return {
+ top: partial?.top ?? 0,
+ right: partial?.right ?? 0,
+ bottom: partial?.bottom ?? 0,
+ left: partial?.left ?? 0,
+ }
+}
+
+export function unionRect(a: Rectangle, b: Rectangle): Rectangle {
+ const minX = Math.min(a.x, b.x)
+ const minY = Math.min(a.y, b.y)
+ const maxX = Math.max(a.x + a.width, b.x + b.width)
+ const maxY = Math.max(a.y + a.height, b.y + b.height)
+ return { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+}
+
+export function clampRect(rect: Rectangle, size: Size): Rectangle {
+ const minX = Math.max(0, rect.x)
+ const minY = Math.max(0, rect.y)
+ const maxX = Math.min(size.width - 1, rect.x + rect.width - 1)
+ const maxY = Math.min(size.height - 1, rect.y + rect.height - 1)
+ return {
+ x: minX,
+ y: minY,
+ width: Math.max(0, maxX - minX + 1),
+ height: Math.max(0, maxY - minY + 1),
+ }
+}
+
+export function withinBounds(size: Size, point: Point): boolean {
+ return (
+ point.x >= 0 &&
+ point.y >= 0 &&
+ point.x < size.width &&
+ point.y < size.height
+ )
+}
+
+export function clamp(value: number, min?: number, max?: number): number {
+ if (min !== undefined && value < min) return min
+ if (max !== undefined && value > max) return max
+ return value
+}
diff --git a/src/ink/layout/yoga.ts b/src/ink/layout/yoga.ts
new file mode 100644
index 0000000000000000000000000000000000000000..58f2646fba661835d478477e16cc6139a7b69174
--- /dev/null
+++ b/src/ink/layout/yoga.ts
@@ -0,0 +1,308 @@
+import Yoga, {
+ Align,
+ Direction,
+ Display,
+ Edge,
+ FlexDirection,
+ Gutter,
+ Justify,
+ MeasureMode,
+ Overflow,
+ PositionType,
+ Wrap,
+ type Node as YogaNode,
+} from 'src/native-ts/yoga-layout/index.js'
+import {
+ type LayoutAlign,
+ LayoutDisplay,
+ type LayoutEdge,
+ type LayoutFlexDirection,
+ type LayoutGutter,
+ type LayoutJustify,
+ type LayoutMeasureFunc,
+ LayoutMeasureMode,
+ type LayoutNode,
+ type LayoutOverflow,
+ type LayoutPositionType,
+ type LayoutWrap,
+} from './node.js'
+
+// --
+// Edge/Gutter mapping
+
+const EDGE_MAP: Record = {
+ all: Edge.All,
+ horizontal: Edge.Horizontal,
+ vertical: Edge.Vertical,
+ left: Edge.Left,
+ right: Edge.Right,
+ top: Edge.Top,
+ bottom: Edge.Bottom,
+ start: Edge.Start,
+ end: Edge.End,
+}
+
+const GUTTER_MAP: Record = {
+ all: Gutter.All,
+ column: Gutter.Column,
+ row: Gutter.Row,
+}
+
+// --
+// Yoga adapter
+
+export class YogaLayoutNode implements LayoutNode {
+ readonly yoga: YogaNode
+
+ constructor(yoga: YogaNode) {
+ this.yoga = yoga
+ }
+
+ // Tree
+
+ insertChild(child: LayoutNode, index: number): void {
+ this.yoga.insertChild((child as YogaLayoutNode).yoga, index)
+ }
+
+ removeChild(child: LayoutNode): void {
+ this.yoga.removeChild((child as YogaLayoutNode).yoga)
+ }
+
+ getChildCount(): number {
+ return this.yoga.getChildCount()
+ }
+
+ getParent(): LayoutNode | null {
+ const p = this.yoga.getParent()
+ return p ? new YogaLayoutNode(p) : null
+ }
+
+ // Layout
+
+ calculateLayout(width?: number, _height?: number): void {
+ this.yoga.calculateLayout(width, undefined, Direction.LTR)
+ }
+
+ setMeasureFunc(fn: LayoutMeasureFunc): void {
+ this.yoga.setMeasureFunc((w, wMode) => {
+ const mode =
+ wMode === MeasureMode.Exactly
+ ? LayoutMeasureMode.Exactly
+ : wMode === MeasureMode.AtMost
+ ? LayoutMeasureMode.AtMost
+ : LayoutMeasureMode.Undefined
+ return fn(w, mode)
+ })
+ }
+
+ unsetMeasureFunc(): void {
+ this.yoga.unsetMeasureFunc()
+ }
+
+ markDirty(): void {
+ this.yoga.markDirty()
+ }
+
+ // Computed layout
+
+ getComputedLeft(): number {
+ return this.yoga.getComputedLeft()
+ }
+
+ getComputedTop(): number {
+ return this.yoga.getComputedTop()
+ }
+
+ getComputedWidth(): number {
+ return this.yoga.getComputedWidth()
+ }
+
+ getComputedHeight(): number {
+ return this.yoga.getComputedHeight()
+ }
+
+ getComputedBorder(edge: LayoutEdge): number {
+ return this.yoga.getComputedBorder(EDGE_MAP[edge]!)
+ }
+
+ getComputedPadding(edge: LayoutEdge): number {
+ return this.yoga.getComputedPadding(EDGE_MAP[edge]!)
+ }
+
+ // Style setters
+
+ setWidth(value: number): void {
+ this.yoga.setWidth(value)
+ }
+ setWidthPercent(value: number): void {
+ this.yoga.setWidthPercent(value)
+ }
+ setWidthAuto(): void {
+ this.yoga.setWidthAuto()
+ }
+ setHeight(value: number): void {
+ this.yoga.setHeight(value)
+ }
+ setHeightPercent(value: number): void {
+ this.yoga.setHeightPercent(value)
+ }
+ setHeightAuto(): void {
+ this.yoga.setHeightAuto()
+ }
+ setMinWidth(value: number): void {
+ this.yoga.setMinWidth(value)
+ }
+ setMinWidthPercent(value: number): void {
+ this.yoga.setMinWidthPercent(value)
+ }
+ setMinHeight(value: number): void {
+ this.yoga.setMinHeight(value)
+ }
+ setMinHeightPercent(value: number): void {
+ this.yoga.setMinHeightPercent(value)
+ }
+ setMaxWidth(value: number): void {
+ this.yoga.setMaxWidth(value)
+ }
+ setMaxWidthPercent(value: number): void {
+ this.yoga.setMaxWidthPercent(value)
+ }
+ setMaxHeight(value: number): void {
+ this.yoga.setMaxHeight(value)
+ }
+ setMaxHeightPercent(value: number): void {
+ this.yoga.setMaxHeightPercent(value)
+ }
+
+ setFlexDirection(dir: LayoutFlexDirection): void {
+ const map: Record = {
+ row: FlexDirection.Row,
+ 'row-reverse': FlexDirection.RowReverse,
+ column: FlexDirection.Column,
+ 'column-reverse': FlexDirection.ColumnReverse,
+ }
+ this.yoga.setFlexDirection(map[dir]!)
+ }
+
+ setFlexGrow(value: number): void {
+ this.yoga.setFlexGrow(value)
+ }
+ setFlexShrink(value: number): void {
+ this.yoga.setFlexShrink(value)
+ }
+ setFlexBasis(value: number): void {
+ this.yoga.setFlexBasis(value)
+ }
+ setFlexBasisPercent(value: number): void {
+ this.yoga.setFlexBasisPercent(value)
+ }
+
+ setFlexWrap(wrap: LayoutWrap): void {
+ const map: Record = {
+ nowrap: Wrap.NoWrap,
+ wrap: Wrap.Wrap,
+ 'wrap-reverse': Wrap.WrapReverse,
+ }
+ this.yoga.setFlexWrap(map[wrap]!)
+ }
+
+ setAlignItems(align: LayoutAlign): void {
+ const map: Record = {
+ auto: Align.Auto,
+ stretch: Align.Stretch,
+ 'flex-start': Align.FlexStart,
+ center: Align.Center,
+ 'flex-end': Align.FlexEnd,
+ }
+ this.yoga.setAlignItems(map[align]!)
+ }
+
+ setAlignSelf(align: LayoutAlign): void {
+ const map: Record = {
+ auto: Align.Auto,
+ stretch: Align.Stretch,
+ 'flex-start': Align.FlexStart,
+ center: Align.Center,
+ 'flex-end': Align.FlexEnd,
+ }
+ this.yoga.setAlignSelf(map[align]!)
+ }
+
+ setJustifyContent(justify: LayoutJustify): void {
+ const map: Record = {
+ 'flex-start': Justify.FlexStart,
+ center: Justify.Center,
+ 'flex-end': Justify.FlexEnd,
+ 'space-between': Justify.SpaceBetween,
+ 'space-around': Justify.SpaceAround,
+ 'space-evenly': Justify.SpaceEvenly,
+ }
+ this.yoga.setJustifyContent(map[justify]!)
+ }
+
+ setDisplay(display: LayoutDisplay): void {
+ this.yoga.setDisplay(display === 'flex' ? Display.Flex : Display.None)
+ }
+
+ getDisplay(): LayoutDisplay {
+ return this.yoga.getDisplay() === Display.None
+ ? LayoutDisplay.None
+ : LayoutDisplay.Flex
+ }
+
+ setPositionType(type: LayoutPositionType): void {
+ this.yoga.setPositionType(
+ type === 'absolute' ? PositionType.Absolute : PositionType.Relative,
+ )
+ }
+
+ setPosition(edge: LayoutEdge, value: number): void {
+ this.yoga.setPosition(EDGE_MAP[edge]!, value)
+ }
+
+ setPositionPercent(edge: LayoutEdge, value: number): void {
+ this.yoga.setPositionPercent(EDGE_MAP[edge]!, value)
+ }
+
+ setOverflow(overflow: LayoutOverflow): void {
+ const map: Record = {
+ visible: Overflow.Visible,
+ hidden: Overflow.Hidden,
+ scroll: Overflow.Scroll,
+ }
+ this.yoga.setOverflow(map[overflow]!)
+ }
+
+ setMargin(edge: LayoutEdge, value: number): void {
+ this.yoga.setMargin(EDGE_MAP[edge]!, value)
+ }
+ setPadding(edge: LayoutEdge, value: number): void {
+ this.yoga.setPadding(EDGE_MAP[edge]!, value)
+ }
+ setBorder(edge: LayoutEdge, value: number): void {
+ this.yoga.setBorder(EDGE_MAP[edge]!, value)
+ }
+ setGap(gutter: LayoutGutter, value: number): void {
+ this.yoga.setGap(GUTTER_MAP[gutter]!, value)
+ }
+
+ // Lifecycle
+
+ free(): void {
+ this.yoga.free()
+ }
+ freeRecursive(): void {
+ this.yoga.freeRecursive()
+ }
+}
+
+// --
+// Instance management
+//
+// The TS yoga-layout port is synchronous — no WASM loading, no linear memory
+// growth, so no preload/swap/reset machinery is needed. The Yoga instance is
+// just a plain JS object available at import time.
+
+export function createYogaLayoutNode(): LayoutNode {
+ return new YogaLayoutNode(Yoga.Node.create())
+}
diff --git a/src/ink/termio/csi.ts b/src/ink/termio/csi.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f3b2f524bf824a9affbc2ad673de18ac03cbc346
--- /dev/null
+++ b/src/ink/termio/csi.ts
@@ -0,0 +1,319 @@
+/**
+ * CSI (Control Sequence Introducer) Types
+ *
+ * Enums and types for CSI command parameters.
+ */
+
+import { ESC, ESC_TYPE, SEP } from './ansi.js'
+
+export const CSI_PREFIX = ESC + String.fromCharCode(ESC_TYPE.CSI)
+
+/**
+ * CSI parameter byte ranges
+ */
+export const CSI_RANGE = {
+ PARAM_START: 0x30,
+ PARAM_END: 0x3f,
+ INTERMEDIATE_START: 0x20,
+ INTERMEDIATE_END: 0x2f,
+ FINAL_START: 0x40,
+ FINAL_END: 0x7e,
+} as const
+
+/** Check if a byte is a CSI parameter byte */
+export function isCSIParam(byte: number): boolean {
+ return byte >= CSI_RANGE.PARAM_START && byte <= CSI_RANGE.PARAM_END
+}
+
+/** Check if a byte is a CSI intermediate byte */
+export function isCSIIntermediate(byte: number): boolean {
+ return (
+ byte >= CSI_RANGE.INTERMEDIATE_START && byte <= CSI_RANGE.INTERMEDIATE_END
+ )
+}
+
+/** Check if a byte is a CSI final byte (@ through ~) */
+export function isCSIFinal(byte: number): boolean {
+ return byte >= CSI_RANGE.FINAL_START && byte <= CSI_RANGE.FINAL_END
+}
+
+/**
+ * Generate a CSI sequence: ESC [ p1;p2;...;pN final
+ * Single arg: treated as raw body
+ * Multiple args: last is final byte, rest are params joined by ;
+ */
+export function csi(...args: (string | number)[]): string {
+ if (args.length === 0) return CSI_PREFIX
+ if (args.length === 1) return `${CSI_PREFIX}${args[0]}`
+ const params = args.slice(0, -1)
+ const final = args[args.length - 1]
+ return `${CSI_PREFIX}${params.join(SEP)}${final}`
+}
+
+/**
+ * CSI final bytes - the command identifier
+ */
+export const CSI = {
+ // Cursor movement
+ CUU: 0x41, // A - Cursor Up
+ CUD: 0x42, // B - Cursor Down
+ CUF: 0x43, // C - Cursor Forward
+ CUB: 0x44, // D - Cursor Back
+ CNL: 0x45, // E - Cursor Next Line
+ CPL: 0x46, // F - Cursor Previous Line
+ CHA: 0x47, // G - Cursor Horizontal Absolute
+ CUP: 0x48, // H - Cursor Position
+ CHT: 0x49, // I - Cursor Horizontal Tab
+ VPA: 0x64, // d - Vertical Position Absolute
+ HVP: 0x66, // f - Horizontal Vertical Position
+
+ // Erase
+ ED: 0x4a, // J - Erase in Display
+ EL: 0x4b, // K - Erase in Line
+ ECH: 0x58, // X - Erase Character
+
+ // Insert/Delete
+ IL: 0x4c, // L - Insert Lines
+ DL: 0x4d, // M - Delete Lines
+ ICH: 0x40, // @ - Insert Characters
+ DCH: 0x50, // P - Delete Characters
+
+ // Scroll
+ SU: 0x53, // S - Scroll Up
+ SD: 0x54, // T - Scroll Down
+
+ // Modes
+ SM: 0x68, // h - Set Mode
+ RM: 0x6c, // l - Reset Mode
+
+ // SGR
+ SGR: 0x6d, // m - Select Graphic Rendition
+
+ // Other
+ DSR: 0x6e, // n - Device Status Report
+ DECSCUSR: 0x71, // q - Set Cursor Style (with space intermediate)
+ DECSTBM: 0x72, // r - Set Top and Bottom Margins
+ SCOSC: 0x73, // s - Save Cursor Position
+ SCORC: 0x75, // u - Restore Cursor Position
+ CBT: 0x5a, // Z - Cursor Backward Tabulation
+} as const
+
+/**
+ * Erase in Display regions (ED command parameter)
+ */
+export const ERASE_DISPLAY = ['toEnd', 'toStart', 'all', 'scrollback'] as const
+
+/**
+ * Erase in Line regions (EL command parameter)
+ */
+export const ERASE_LINE_REGION = ['toEnd', 'toStart', 'all'] as const
+
+/**
+ * Cursor styles (DECSCUSR)
+ */
+export type CursorStyle = 'block' | 'underline' | 'bar'
+
+export const CURSOR_STYLES: Array<{ style: CursorStyle; blinking: boolean }> = [
+ { style: 'block', blinking: true }, // 0 - default
+ { style: 'block', blinking: true }, // 1
+ { style: 'block', blinking: false }, // 2
+ { style: 'underline', blinking: true }, // 3
+ { style: 'underline', blinking: false }, // 4
+ { style: 'bar', blinking: true }, // 5
+ { style: 'bar', blinking: false }, // 6
+]
+
+// Cursor movement generators
+
+/** Move cursor up n lines (CSI n A) */
+export function cursorUp(n = 1): string {
+ return n === 0 ? '' : csi(n, 'A')
+}
+
+/** Move cursor down n lines (CSI n B) */
+export function cursorDown(n = 1): string {
+ return n === 0 ? '' : csi(n, 'B')
+}
+
+/** Move cursor forward n columns (CSI n C) */
+export function cursorForward(n = 1): string {
+ return n === 0 ? '' : csi(n, 'C')
+}
+
+/** Move cursor back n columns (CSI n D) */
+export function cursorBack(n = 1): string {
+ return n === 0 ? '' : csi(n, 'D')
+}
+
+/** Move cursor to column n (1-indexed) (CSI n G) */
+export function cursorTo(col: number): string {
+ return csi(col, 'G')
+}
+
+/** Move cursor to column 1 (CSI G) */
+export const CURSOR_LEFT = csi('G')
+
+/** Move cursor to row, col (1-indexed) (CSI row ; col H) */
+export function cursorPosition(row: number, col: number): string {
+ return csi(row, col, 'H')
+}
+
+/** Move cursor to home position (CSI H) */
+export const CURSOR_HOME = csi('H')
+
+/**
+ * Move cursor relative to current position
+ * Positive x = right, negative x = left
+ * Positive y = down, negative y = up
+ */
+export function cursorMove(x: number, y: number): string {
+ let result = ''
+ // Horizontal first (matches ansi-escapes behavior)
+ if (x < 0) {
+ result += cursorBack(-x)
+ } else if (x > 0) {
+ result += cursorForward(x)
+ }
+ // Then vertical
+ if (y < 0) {
+ result += cursorUp(-y)
+ } else if (y > 0) {
+ result += cursorDown(y)
+ }
+ return result
+}
+
+// Save/restore cursor position
+
+/** Save cursor position (CSI s) */
+export const CURSOR_SAVE = csi('s')
+
+/** Restore cursor position (CSI u) */
+export const CURSOR_RESTORE = csi('u')
+
+// Erase generators
+
+/** Erase from cursor to end of line (CSI K) */
+export function eraseToEndOfLine(): string {
+ return csi('K')
+}
+
+/** Erase from cursor to start of line (CSI 1 K) */
+export function eraseToStartOfLine(): string {
+ return csi(1, 'K')
+}
+
+/** Erase entire line (CSI 2 K) */
+export function eraseLine(): string {
+ return csi(2, 'K')
+}
+
+/** Erase entire line - constant form */
+export const ERASE_LINE = csi(2, 'K')
+
+/** Erase from cursor to end of screen (CSI J) */
+export function eraseToEndOfScreen(): string {
+ return csi('J')
+}
+
+/** Erase from cursor to start of screen (CSI 1 J) */
+export function eraseToStartOfScreen(): string {
+ return csi(1, 'J')
+}
+
+/** Erase entire screen (CSI 2 J) */
+export function eraseScreen(): string {
+ return csi(2, 'J')
+}
+
+/** Erase entire screen - constant form */
+export const ERASE_SCREEN = csi(2, 'J')
+
+/** Erase scrollback buffer (CSI 3 J) */
+export const ERASE_SCROLLBACK = csi(3, 'J')
+
+/**
+ * Erase n lines starting from cursor line, moving cursor up
+ * This erases each line and moves up, ending at column 1
+ */
+export function eraseLines(n: number): string {
+ if (n <= 0) return ''
+ let result = ''
+ for (let i = 0; i < n; i++) {
+ result += ERASE_LINE
+ if (i < n - 1) {
+ result += cursorUp(1)
+ }
+ }
+ result += CURSOR_LEFT
+ return result
+}
+
+// Scroll
+
+/** Scroll up n lines (CSI n S) */
+export function scrollUp(n = 1): string {
+ return n === 0 ? '' : csi(n, 'S')
+}
+
+/** Scroll down n lines (CSI n T) */
+export function scrollDown(n = 1): string {
+ return n === 0 ? '' : csi(n, 'T')
+}
+
+/** Set scroll region (DECSTBM, CSI top;bottom r). 1-indexed, inclusive. */
+export function setScrollRegion(top: number, bottom: number): string {
+ return csi(top, bottom, 'r')
+}
+
+/** Reset scroll region to full screen (DECSTBM, CSI r). Homes the cursor. */
+export const RESET_SCROLL_REGION = csi('r')
+
+// Bracketed paste markers (input from terminal, not output)
+// These are sent by the terminal to delimit pasted content when
+// bracketed paste mode is enabled (via DEC mode 2004)
+
+/** Sent by terminal before pasted content (CSI 200 ~) */
+export const PASTE_START = csi('200~')
+
+/** Sent by terminal after pasted content (CSI 201 ~) */
+export const PASTE_END = csi('201~')
+
+// Focus event markers (input from terminal, not output)
+// These are sent by the terminal when focus changes while
+// focus events mode is enabled (via DEC mode 1004)
+
+/** Sent by terminal when it gains focus (CSI I) */
+export const FOCUS_IN = csi('I')
+
+/** Sent by terminal when it loses focus (CSI O) */
+export const FOCUS_OUT = csi('O')
+
+// Kitty keyboard protocol (CSI u)
+// Enables enhanced key reporting with modifier information
+// See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+
+/**
+ * Enable Kitty keyboard protocol with basic modifier reporting
+ * CSI > 1 u - pushes mode with flags=1 (disambiguate escape codes)
+ * This makes Shift+Enter send CSI 13;2 u instead of just CR
+ */
+export const ENABLE_KITTY_KEYBOARD = csi('>1u')
+
+/**
+ * Disable Kitty keyboard protocol
+ * CSI < u - pops the keyboard mode stack
+ */
+export const DISABLE_KITTY_KEYBOARD = csi('4;2m')
+
+/**
+ * Disable xterm modifyOtherKeys (reset to default).
+ */
+export const DISABLE_MODIFY_OTHER_KEYS = csi('>4m')
diff --git a/src/ink/termio/dec.ts b/src/ink/termio/dec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ac8bcc731c78aeb53305647a81b3fe8b063ff8d7
--- /dev/null
+++ b/src/ink/termio/dec.ts
@@ -0,0 +1,60 @@
+/**
+ * DEC (Digital Equipment Corporation) Private Mode Sequences
+ *
+ * DEC private modes use CSI ? N h (set) and CSI ? N l (reset) format.
+ * These are terminal-specific extensions to the ANSI standard.
+ */
+
+import { csi } from './csi.js'
+
+/**
+ * DEC private mode numbers
+ */
+export const DEC = {
+ CURSOR_VISIBLE: 25,
+ ALT_SCREEN: 47,
+ ALT_SCREEN_CLEAR: 1049,
+ MOUSE_NORMAL: 1000,
+ MOUSE_BUTTON: 1002,
+ MOUSE_ANY: 1003,
+ MOUSE_SGR: 1006,
+ FOCUS_EVENTS: 1004,
+ BRACKETED_PASTE: 2004,
+ SYNCHRONIZED_UPDATE: 2026,
+} as const
+
+/** Generate CSI ? N h sequence (set mode) */
+export function decset(mode: number): string {
+ return csi(`?${mode}h`)
+}
+
+/** Generate CSI ? N l sequence (reset mode) */
+export function decreset(mode: number): string {
+ return csi(`?${mode}l`)
+}
+
+// Pre-generated sequences for common modes
+export const BSU = decset(DEC.SYNCHRONIZED_UPDATE)
+export const ESU = decreset(DEC.SYNCHRONIZED_UPDATE)
+export const EBP = decset(DEC.BRACKETED_PASTE)
+export const DBP = decreset(DEC.BRACKETED_PASTE)
+export const EFE = decset(DEC.FOCUS_EVENTS)
+export const DFE = decreset(DEC.FOCUS_EVENTS)
+export const SHOW_CURSOR = decset(DEC.CURSOR_VISIBLE)
+export const HIDE_CURSOR = decreset(DEC.CURSOR_VISIBLE)
+export const ENTER_ALT_SCREEN = decset(DEC.ALT_SCREEN_CLEAR)
+export const EXIT_ALT_SCREEN = decreset(DEC.ALT_SCREEN_CLEAR)
+// Mouse tracking: 1000 reports button press/release/wheel, 1002 adds drag
+// events (button-motion), 1003 adds all-motion (no button held — for
+// hover), 1006 uses SGR format (CSI < btn;col;row M/m) instead of legacy
+// X10 bytes. Combined: wheel + click/drag for selection + hover.
+export const ENABLE_MOUSE_TRACKING =
+ decset(DEC.MOUSE_NORMAL) +
+ decset(DEC.MOUSE_BUTTON) +
+ decset(DEC.MOUSE_ANY) +
+ decset(DEC.MOUSE_SGR)
+export const DISABLE_MOUSE_TRACKING =
+ decreset(DEC.MOUSE_SGR) +
+ decreset(DEC.MOUSE_ANY) +
+ decreset(DEC.MOUSE_BUTTON) +
+ decreset(DEC.MOUSE_NORMAL)
diff --git a/src/ink/termio/esc.ts b/src/ink/termio/esc.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d4cc9286600e4b10a3e726a0d7c1c4c50c885d1
--- /dev/null
+++ b/src/ink/termio/esc.ts
@@ -0,0 +1,67 @@
+/**
+ * ESC Sequence Parser
+ *
+ * Handles simple escape sequences: ESC + one or two characters
+ */
+
+import type { Action } from './types.js'
+
+/**
+ * Parse a simple ESC sequence
+ *
+ * @param chars - Characters after ESC (not including ESC itself)
+ */
+export function parseEsc(chars: string): Action | null {
+ if (chars.length === 0) return null
+
+ const first = chars[0]!
+
+ // Full reset (RIS)
+ if (first === 'c') {
+ return { type: 'reset' }
+ }
+
+ // Cursor save (DECSC)
+ if (first === '7') {
+ return { type: 'cursor', action: { type: 'save' } }
+ }
+
+ // Cursor restore (DECRC)
+ if (first === '8') {
+ return { type: 'cursor', action: { type: 'restore' } }
+ }
+
+ // Index - move cursor down (IND)
+ if (first === 'D') {
+ return {
+ type: 'cursor',
+ action: { type: 'move', direction: 'down', count: 1 },
+ }
+ }
+
+ // Reverse index - move cursor up (RI)
+ if (first === 'M') {
+ return {
+ type: 'cursor',
+ action: { type: 'move', direction: 'up', count: 1 },
+ }
+ }
+
+ // Next line (NEL)
+ if (first === 'E') {
+ return { type: 'cursor', action: { type: 'nextLine', count: 1 } }
+ }
+
+ // Horizontal tab set (HTS)
+ if (first === 'H') {
+ return null // Tab stop, not commonly needed
+ }
+
+ // Charset selection (ESC ( X, ESC ) X, etc.) - silently ignore
+ if ('()'.includes(first) && chars.length >= 2) {
+ return null
+ }
+
+ // Unknown
+ return { type: 'unknown', sequence: `\x1b${chars}` }
+}
diff --git a/src/ink/termio/osc.ts b/src/ink/termio/osc.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9bef515328535b7fbdd1ab938f3c78477ec704e9
--- /dev/null
+++ b/src/ink/termio/osc.ts
@@ -0,0 +1,493 @@
+/**
+ * OSC (Operating System Command) Types and Parser
+ */
+
+import { Buffer } from 'buffer'
+import { env } from '../../utils/env.js'
+import { execFileNoThrow } from '../../utils/execFileNoThrow.js'
+import { BEL, ESC, ESC_TYPE, SEP } from './ansi.js'
+import type { Action, Color, TabStatusAction } from './types.js'
+
+export const OSC_PREFIX = ESC + String.fromCharCode(ESC_TYPE.OSC)
+
+/** String Terminator (ESC \) - alternative to BEL for terminating OSC */
+export const ST = ESC + '\\'
+
+/** Generate an OSC sequence: ESC ] p1;p2;...;pN
+ * Uses ST terminator for Kitty (avoids beeps), BEL for others */
+export function osc(...parts: (string | number)[]): string {
+ const terminator = env.terminal === 'kitty' ? ST : BEL
+ return `${OSC_PREFIX}${parts.join(SEP)}${terminator}`
+}
+
+/**
+ * Wrap an escape sequence for terminal multiplexer passthrough.
+ * tmux and GNU screen intercept escape sequences; DCS passthrough
+ * tunnels them to the outer terminal unmodified.
+ *
+ * tmux 3.3+ gates this behind `allow-passthrough` (default off). When off,
+ * tmux silently drops the whole DCS — no junk, no worse than unwrapped OSC.
+ * Users who want passthrough set it in their .tmux.conf; we don't mutate it.
+ *
+ * Do NOT wrap BEL: raw \x07 triggers tmux's bell-action (window flag);
+ * wrapped \x07 is opaque DCS payload and tmux never sees the bell.
+ */
+export function wrapForMultiplexer(sequence: string): string {
+ if (process.env['TMUX']) {
+ const escaped = sequence.replaceAll('\x1b', '\x1b\x1b')
+ return `\x1bPtmux;${escaped}\x1b\\`
+ }
+ if (process.env['STY']) {
+ return `\x1bP${sequence}\x1b\\`
+ }
+ return sequence
+}
+
+/**
+ * Which path setClipboard() will take, based on env state. Synchronous so
+ * callers can show an honest toast without awaiting the copy itself.
+ *
+ * - 'native': pbcopy (or equivalent) will run — high-confidence system
+ * clipboard write. tmux buffer may also be loaded as a bonus.
+ * - 'tmux-buffer': tmux load-buffer will run, but no native tool — paste
+ * with prefix+] works. System clipboard depends on tmux's set-clipboard
+ * option + outer terminal OSC 52 support; can't know from here.
+ * - 'osc52': only the raw OSC 52 sequence will be written to stdout.
+ * Best-effort; iTerm2 disables OSC 52 by default.
+ *
+ * pbcopy gating uses SSH_CONNECTION specifically, not SSH_TTY — tmux panes
+ * inherit SSH_TTY forever even after local reattach, but SSH_CONNECTION is
+ * in tmux's default update-environment set and gets cleared.
+ */
+export type ClipboardPath = 'native' | 'tmux-buffer' | 'osc52'
+
+export function getClipboardPath(): ClipboardPath {
+ const nativeAvailable =
+ process.platform === 'darwin' && !process.env['SSH_CONNECTION']
+ if (nativeAvailable) return 'native'
+ if (process.env['TMUX']) return 'tmux-buffer'
+ return 'osc52'
+}
+
+/**
+ * Wrap a payload in tmux's DCS passthrough: ESC P tmux ; ESC \
+ * tmux forwards the payload to the outer terminal, bypassing its own parser.
+ * Inner ESCs must be doubled. Requires `set -g allow-passthrough on` in
+ * ~/.tmux.conf; without it, tmux silently drops the whole DCS (no regression).
+ */
+function tmuxPassthrough(payload: string): string {
+ return `${ESC}Ptmux;${payload.replaceAll(ESC, ESC + ESC)}${ST}`
+}
+
+/**
+ * Load text into tmux's paste buffer via `tmux load-buffer`.
+ * -w (tmux 3.2+) propagates to the outer terminal's clipboard via tmux's
+ * own OSC 52 emission. -w is dropped for iTerm2: tmux's OSC 52 emission
+ * crashes the iTerm2 session over SSH.
+ *
+ * Returns true if the buffer was loaded successfully.
+ */
+export async function tmuxLoadBuffer(text: string): Promise {
+ if (!process.env['TMUX']) return false
+ const args =
+ process.env['LC_TERMINAL'] === 'iTerm2'
+ ? ['load-buffer', '-']
+ : ['load-buffer', '-w', '-']
+ const { code } = await execFileNoThrow('tmux', args, {
+ input: text,
+ useCwd: false,
+ timeout: 2000,
+ })
+ return code === 0
+}
+
+/**
+ * OSC 52 clipboard write: ESC ] 52 ; c ; BEL/ST
+ * 'c' selects the clipboard (vs 'p' for primary selection on X11).
+ *
+ * When inside tmux ($TMUX set), `tmux load-buffer -w -` is the primary
+ * path. tmux's buffer is always reachable — works over SSH, survives
+ * detach/reattach, immune to stale env vars. The -w flag (tmux 3.2+) tells
+ * tmux to also propagate to the outer terminal via its own OSC 52 path,
+ * which tmux wraps correctly for the attached client. On older tmux, -w is
+ * ignored and the buffer is still loaded. -w is dropped for iTerm2 (#22432)
+ * because tmux's own OSC 52 emission (empty selection param: ESC]52;;b64)
+ * crashes iTerm2 over SSH.
+ *
+ * After load-buffer succeeds, we ALSO return a DCS-passthrough-wrapped
+ * OSC 52 for the caller to write to stdout. Our sequence uses explicit `c`
+ * (not tmux's crashy empty-param variant), so it sidesteps the #22432 path.
+ * With `allow-passthrough on` + an OSC-52-capable outer terminal, selection
+ * reaches the system clipboard; with either off, tmux silently drops the
+ * DCS and prefix+] still works. See Greg Smith's "free pony" in
+ * https://anthropic.slack.com/archives/C07VBSHV7EV/p1773177228548119.
+ *
+ * If load-buffer fails entirely, fall through to raw OSC 52.
+ *
+ * Outside tmux, write raw OSC 52 to stdout (caller handles the write).
+ *
+ * Local (no SSH_CONNECTION): also shell out to a native clipboard utility.
+ * OSC 52 and tmux -w both depend on terminal settings — iTerm2 disables
+ * OSC 52 by default, VS Code shows a permission prompt on first use. Native
+ * utilities (pbcopy/wl-copy/xclip/xsel/clip.exe) always work locally. Over
+ * SSH these would write to the remote clipboard — OSC 52 is the right path there.
+ *
+ * Returns the sequence for the caller to write to stdout (raw OSC 52
+ * outside tmux, DCS-wrapped inside).
+ */
+export async function setClipboard(text: string): Promise {
+ const b64 = Buffer.from(text, 'utf8').toString('base64')
+ const raw = osc(OSC.CLIPBOARD, 'c', b64)
+
+ // Native safety net — fire FIRST, before the tmux await, so a quick
+ // focus-switch after selecting doesn't race pbcopy. Previously this ran
+ // AFTER awaiting tmux load-buffer, adding ~50-100ms of subprocess latency
+ // before pbcopy even started — fast cmd+tab → paste would beat it
+ // (https://anthropic.slack.com/archives/C07VBSHV7EV/p1773943921788829).
+ // Gated on SSH_CONNECTION (not SSH_TTY) since tmux panes inherit SSH_TTY
+ // forever but SSH_CONNECTION is in tmux's default update-environment and
+ // clears on local attach. Fire-and-forget.
+ if (!process.env['SSH_CONNECTION']) copyNative(text)
+
+ const tmuxBufferLoaded = await tmuxLoadBuffer(text)
+
+ // Inner OSC uses BEL directly (not osc()) — ST's ESC would need doubling
+ // too, and BEL works everywhere for OSC 52.
+ if (tmuxBufferLoaded) return tmuxPassthrough(`${ESC}]52;c;${b64}${BEL}`)
+ return raw
+}
+
+// Linux clipboard tool: undefined = not yet probed, null = none available.
+// Probe order: wl-copy (Wayland) → xclip (X11) → xsel (X11 fallback).
+// Cached after first attempt so repeated mouse-ups skip the probe chain.
+let linuxCopy: 'wl-copy' | 'xclip' | 'xsel' | null | undefined
+
+/**
+ * Shell out to a native clipboard utility as a safety net for OSC 52.
+ * Only called when not in an SSH session (over SSH, these would write to
+ * the remote machine's clipboard — OSC 52 is the right path there).
+ * Fire-and-forget: failures are silent since OSC 52 may have succeeded.
+ */
+function copyNative(text: string): void {
+ const opts = { input: text, useCwd: false, timeout: 2000 }
+ switch (process.platform) {
+ case 'darwin':
+ void execFileNoThrow('pbcopy', [], opts)
+ return
+ case 'linux': {
+ if (linuxCopy === null) return
+ if (linuxCopy === 'wl-copy') {
+ void execFileNoThrow('wl-copy', [], opts)
+ return
+ }
+ if (linuxCopy === 'xclip') {
+ void execFileNoThrow('xclip', ['-selection', 'clipboard'], opts)
+ return
+ }
+ if (linuxCopy === 'xsel') {
+ void execFileNoThrow('xsel', ['--clipboard', '--input'], opts)
+ return
+ }
+ // First call: probe wl-copy (Wayland) then xclip/xsel (X11), cache winner.
+ void execFileNoThrow('wl-copy', [], opts).then(r => {
+ if (r.code === 0) {
+ linuxCopy = 'wl-copy'
+ return
+ }
+ void execFileNoThrow('xclip', ['-selection', 'clipboard'], opts).then(
+ r2 => {
+ if (r2.code === 0) {
+ linuxCopy = 'xclip'
+ return
+ }
+ void execFileNoThrow('xsel', ['--clipboard', '--input'], opts).then(
+ r3 => {
+ linuxCopy = r3.code === 0 ? 'xsel' : null
+ },
+ )
+ },
+ )
+ })
+ return
+ }
+ case 'win32':
+ // clip.exe is always available on Windows. Unicode handling is
+ // imperfect (system locale encoding) but good enough for a fallback.
+ void execFileNoThrow('clip', [], opts)
+ return
+ }
+}
+
+/** @internal test-only */
+export function _resetLinuxCopyCache(): void {
+ linuxCopy = undefined
+}
+
+/**
+ * OSC command numbers
+ */
+export const OSC = {
+ SET_TITLE_AND_ICON: 0,
+ SET_ICON: 1,
+ SET_TITLE: 2,
+ SET_COLOR: 4,
+ SET_CWD: 7,
+ HYPERLINK: 8,
+ ITERM2: 9, // iTerm2 proprietary sequences
+ SET_FG_COLOR: 10,
+ SET_BG_COLOR: 11,
+ SET_CURSOR_COLOR: 12,
+ CLIPBOARD: 52,
+ KITTY: 99, // Kitty notification protocol
+ RESET_COLOR: 104,
+ RESET_FG_COLOR: 110,
+ RESET_BG_COLOR: 111,
+ RESET_CURSOR_COLOR: 112,
+ SEMANTIC_PROMPT: 133,
+ GHOSTTY: 777, // Ghostty notification protocol
+ TAB_STATUS: 21337, // Tab status extension
+} as const
+
+/**
+ * Parse an OSC sequence into an action
+ *
+ * @param content - The sequence content (without ESC ] and terminator)
+ */
+export function parseOSC(content: string): Action | null {
+ const semicolonIdx = content.indexOf(';')
+ const command = semicolonIdx >= 0 ? content.slice(0, semicolonIdx) : content
+ const data = semicolonIdx >= 0 ? content.slice(semicolonIdx + 1) : ''
+
+ const commandNum = parseInt(command, 10)
+
+ // Window/icon title
+ if (commandNum === OSC.SET_TITLE_AND_ICON) {
+ return { type: 'title', action: { type: 'both', title: data } }
+ }
+ if (commandNum === OSC.SET_ICON) {
+ return { type: 'title', action: { type: 'iconName', name: data } }
+ }
+ if (commandNum === OSC.SET_TITLE) {
+ return { type: 'title', action: { type: 'windowTitle', title: data } }
+ }
+
+ // Hyperlinks (OSC 8)
+ if (commandNum === OSC.HYPERLINK) {
+ const parts = data.split(';')
+ const paramsStr = parts[0] ?? ''
+ const url = parts.slice(1).join(';')
+
+ if (url === '') {
+ return { type: 'link', action: { type: 'end' } }
+ }
+
+ const params: Record = {}
+ if (paramsStr) {
+ for (const pair of paramsStr.split(':')) {
+ const eqIdx = pair.indexOf('=')
+ if (eqIdx >= 0) {
+ params[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1)
+ }
+ }
+ }
+
+ return {
+ type: 'link',
+ action: {
+ type: 'start',
+ url,
+ params: Object.keys(params).length > 0 ? params : undefined,
+ },
+ }
+ }
+
+ // Tab status (OSC 21337)
+ if (commandNum === OSC.TAB_STATUS) {
+ return { type: 'tabStatus', action: parseTabStatus(data) }
+ }
+
+ return { type: 'unknown', sequence: `\x1b]${content}` }
+}
+
+/**
+ * Parse an XParseColor-style color spec into an RGB Color.
+ * Accepts `#RRGGBB` and `rgb:R/G/B` (1–4 hex digits per component, scaled
+ * to 8-bit). Returns null on parse failure.
+ */
+export function parseOscColor(spec: string): Color | null {
+ const hex = spec.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i)
+ if (hex) {
+ return {
+ type: 'rgb',
+ r: parseInt(hex[1]!, 16),
+ g: parseInt(hex[2]!, 16),
+ b: parseInt(hex[3]!, 16),
+ }
+ }
+ const rgb = spec.match(
+ /^rgb:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})$/i,
+ )
+ if (rgb) {
+ // XParseColor: N hex digits → value / (16^N - 1), scale to 0-255
+ const scale = (s: string) =>
+ Math.round((parseInt(s, 16) / (16 ** s.length - 1)) * 255)
+ return {
+ type: 'rgb',
+ r: scale(rgb[1]!),
+ g: scale(rgb[2]!),
+ b: scale(rgb[3]!),
+ }
+ }
+ return null
+}
+
+/**
+ * Parse OSC 21337 payload: `key=value;key=value;...` with `\;` and `\\`
+ * escapes inside values. Bare key or `key=` clears that field; unknown
+ * keys are ignored.
+ */
+function parseTabStatus(data: string): TabStatusAction {
+ const action: TabStatusAction = {}
+ for (const [key, value] of splitTabStatusPairs(data)) {
+ switch (key) {
+ case 'indicator':
+ action.indicator = value === '' ? null : parseOscColor(value)
+ break
+ case 'status':
+ action.status = value === '' ? null : value
+ break
+ case 'status-color':
+ action.statusColor = value === '' ? null : parseOscColor(value)
+ break
+ }
+ }
+ return action
+}
+
+/** Split `k=v;k=v` honoring `\;` and `\\` escapes. Yields [key, unescapedValue]. */
+function* splitTabStatusPairs(data: string): Generator<[string, string]> {
+ let key = ''
+ let val = ''
+ let inVal = false
+ let esc = false
+ for (const c of data) {
+ if (esc) {
+ if (inVal) val += c
+ else key += c
+ esc = false
+ } else if (c === '\\') {
+ esc = true
+ } else if (c === ';') {
+ yield [key, val]
+ key = ''
+ val = ''
+ inVal = false
+ } else if (c === '=' && !inVal) {
+ inVal = true
+ } else if (inVal) {
+ val += c
+ } else {
+ key += c
+ }
+ }
+ if (key || inVal) yield [key, val]
+}
+
+// Output generators
+
+/** Start a hyperlink (OSC 8). Auto-assigns an id= param derived from the URL
+ * so terminals group wrapped lines of the same link together (the spec says
+ * cells with matching URI *and* nonempty id are joined; without an id each
+ * wrapped line is a separate link — inconsistent hover, partial tooltips).
+ * Empty url = close sequence (empty params per spec). */
+export function link(url: string, params?: Record): string {
+ if (!url) return LINK_END
+ const p = { id: osc8Id(url), ...params }
+ const paramStr = Object.entries(p)
+ .map(([k, v]) => `${k}=${v}`)
+ .join(':')
+ return osc(OSC.HYPERLINK, paramStr, url)
+}
+
+function osc8Id(url: string): string {
+ let h = 0
+ for (let i = 0; i < url.length; i++)
+ h = ((h << 5) - h + url.charCodeAt(i)) | 0
+ return (h >>> 0).toString(36)
+}
+
+/** End a hyperlink (OSC 8) */
+export const LINK_END = osc(OSC.HYPERLINK, '', '')
+
+// iTerm2 OSC 9 subcommands
+
+/** iTerm2 OSC 9 subcommand numbers */
+export const ITERM2 = {
+ NOTIFY: 0,
+ BADGE: 2,
+ PROGRESS: 4,
+} as const
+
+/** Progress operation codes (for use with ITERM2.PROGRESS) */
+export const PROGRESS = {
+ CLEAR: 0,
+ SET: 1,
+ ERROR: 2,
+ INDETERMINATE: 3,
+} as const
+
+/**
+ * Clear iTerm2 progress bar sequence (OSC 9;4;0;BEL)
+ * Uses BEL terminator since this is for cleanup (not runtime notification)
+ * and we want to ensure it's always sent regardless of terminal type.
+ */
+export const CLEAR_ITERM2_PROGRESS = `${OSC_PREFIX}${OSC.ITERM2};${ITERM2.PROGRESS};${PROGRESS.CLEAR};${BEL}`
+
+/**
+ * Clear terminal title sequence (OSC 0 with empty string + BEL).
+ * Uses BEL terminator for cleanup — safe on all terminals.
+ */
+export const CLEAR_TERMINAL_TITLE = `${OSC_PREFIX}${OSC.SET_TITLE_AND_ICON};${BEL}`
+
+/** Clear all three OSC 21337 tab-status fields. Used on exit. */
+export const CLEAR_TAB_STATUS = osc(
+ OSC.TAB_STATUS,
+ 'indicator=;status=;status-color=',
+)
+
+/**
+ * Gate for emitting OSC 21337 (tab-status indicator). Ant-only while the
+ * spec is unstable. Terminals that don't recognize it discard silently, so
+ * emission is safe unconditionally — we don't gate on terminal detection
+ * since support is expected across several terminals.
+ *
+ * Callers must wrap output with wrapForMultiplexer() so tmux/screen
+ * DCS-passthrough carries the sequence to the outer terminal.
+ */
+export function supportsTabStatus(): boolean {
+ return process.env.USER_TYPE === 'ant'
+}
+
+/**
+ * Emit an OSC 21337 tab-status sequence. Omitted fields are left unchanged
+ * by the receiving terminal; `null` sends an empty value to clear.
+ * `;` and `\` in status text are escaped per the spec.
+ */
+export function tabStatus(fields: TabStatusAction): string {
+ const parts: string[] = []
+ const rgb = (c: Color) =>
+ c.type === 'rgb'
+ ? `#${[c.r, c.g, c.b].map(n => n.toString(16).padStart(2, '0')).join('')}`
+ : ''
+ if ('indicator' in fields)
+ parts.push(`indicator=${fields.indicator ? rgb(fields.indicator) : ''}`)
+ if ('status' in fields)
+ parts.push(
+ `status=${fields.status?.replaceAll('\\', '\\\\').replaceAll(';', '\\;') ?? ''}`,
+ )
+ if ('statusColor' in fields)
+ parts.push(
+ `status-color=${fields.statusColor ? rgb(fields.statusColor) : ''}`,
+ )
+ return osc(OSC.TAB_STATUS, parts.join(';'))
+}
diff --git a/src/ink/termio/parser.ts b/src/ink/termio/parser.ts
new file mode 100644
index 0000000000000000000000000000000000000000..301f14c5a0bd3dce2b7d3bf7e0aa901bbf5f99b1
--- /dev/null
+++ b/src/ink/termio/parser.ts
@@ -0,0 +1,394 @@
+/**
+ * ANSI Parser - Semantic Action Generator
+ *
+ * A streaming parser for ANSI escape sequences that produces semantic actions.
+ * Uses the tokenizer for escape sequence boundary detection, then interprets
+ * each sequence to produce structured actions.
+ *
+ * Key design decisions:
+ * - Streaming: can process input incrementally
+ * - Semantic output: produces structured actions, not string tokens
+ * - Style tracking: maintains current text style state
+ */
+
+import { getGraphemeSegmenter } from '../../utils/intl.js'
+import { C0 } from './ansi.js'
+import { CSI, CURSOR_STYLES, ERASE_DISPLAY, ERASE_LINE_REGION } from './csi.js'
+import { DEC } from './dec.js'
+import { parseEsc } from './esc.js'
+import { parseOSC } from './osc.js'
+import { applySGR } from './sgr.js'
+import { createTokenizer, type Token, type Tokenizer } from './tokenize.js'
+import type { Action, Grapheme, TextStyle } from './types.js'
+import { defaultStyle } from './types.js'
+
+// =============================================================================
+// Grapheme Utilities
+// =============================================================================
+
+function isEmoji(codePoint: number): boolean {
+ return (
+ (codePoint >= 0x2600 && codePoint <= 0x26ff) ||
+ (codePoint >= 0x2700 && codePoint <= 0x27bf) ||
+ (codePoint >= 0x1f300 && codePoint <= 0x1f9ff) ||
+ (codePoint >= 0x1fa00 && codePoint <= 0x1faff) ||
+ (codePoint >= 0x1f1e0 && codePoint <= 0x1f1ff)
+ )
+}
+
+function isEastAsianWide(codePoint: number): boolean {
+ return (
+ (codePoint >= 0x1100 && codePoint <= 0x115f) ||
+ (codePoint >= 0x2e80 && codePoint <= 0x9fff) ||
+ (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+ (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+ (codePoint >= 0xfe10 && codePoint <= 0xfe1f) ||
+ (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+ (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+ (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+ (codePoint >= 0x20000 && codePoint <= 0x2fffd) ||
+ (codePoint >= 0x30000 && codePoint <= 0x3fffd)
+ )
+}
+
+function hasMultipleCodepoints(str: string): boolean {
+ let count = 0
+ for (const _ of str) {
+ count++
+ if (count > 1) return true
+ }
+ return false
+}
+
+function graphemeWidth(grapheme: string): 1 | 2 {
+ if (hasMultipleCodepoints(grapheme)) return 2
+ const codePoint = grapheme.codePointAt(0)
+ if (codePoint === undefined) return 1
+ if (isEmoji(codePoint) || isEastAsianWide(codePoint)) return 2
+ return 1
+}
+
+function* segmentGraphemes(str: string): Generator {
+ for (const { segment } of getGraphemeSegmenter().segment(str)) {
+ yield { value: segment, width: graphemeWidth(segment) }
+ }
+}
+
+// =============================================================================
+// Sequence Parsing
+// =============================================================================
+
+function parseCSIParams(paramStr: string): number[] {
+ if (paramStr === '') return []
+ return paramStr.split(/[;:]/).map(s => (s === '' ? 0 : parseInt(s, 10)))
+}
+
+/** Parse a raw CSI sequence (e.g., "\x1b[31m") into an action */
+function parseCSI(rawSequence: string): Action | null {
+ const inner = rawSequence.slice(2)
+ if (inner.length === 0) return null
+
+ const finalByte = inner.charCodeAt(inner.length - 1)
+ const beforeFinal = inner.slice(0, -1)
+
+ let privateMode = ''
+ let paramStr = beforeFinal
+ let intermediate = ''
+
+ if (beforeFinal.length > 0 && '?>='.includes(beforeFinal[0]!)) {
+ privateMode = beforeFinal[0]!
+ paramStr = beforeFinal.slice(1)
+ }
+
+ const intermediateMatch = paramStr.match(/([^0-9;:]+)$/)
+ if (intermediateMatch) {
+ intermediate = intermediateMatch[1]!
+ paramStr = paramStr.slice(0, -intermediate.length)
+ }
+
+ const params = parseCSIParams(paramStr)
+ const p0 = params[0] ?? 1
+ const p1 = params[1] ?? 1
+
+ // SGR (Select Graphic Rendition)
+ if (finalByte === CSI.SGR && privateMode === '') {
+ return { type: 'sgr', params: paramStr }
+ }
+
+ // Cursor movement
+ if (finalByte === CSI.CUU) {
+ return {
+ type: 'cursor',
+ action: { type: 'move', direction: 'up', count: p0 },
+ }
+ }
+ if (finalByte === CSI.CUD) {
+ return {
+ type: 'cursor',
+ action: { type: 'move', direction: 'down', count: p0 },
+ }
+ }
+ if (finalByte === CSI.CUF) {
+ return {
+ type: 'cursor',
+ action: { type: 'move', direction: 'forward', count: p0 },
+ }
+ }
+ if (finalByte === CSI.CUB) {
+ return {
+ type: 'cursor',
+ action: { type: 'move', direction: 'back', count: p0 },
+ }
+ }
+ if (finalByte === CSI.CNL) {
+ return { type: 'cursor', action: { type: 'nextLine', count: p0 } }
+ }
+ if (finalByte === CSI.CPL) {
+ return { type: 'cursor', action: { type: 'prevLine', count: p0 } }
+ }
+ if (finalByte === CSI.CHA) {
+ return { type: 'cursor', action: { type: 'column', col: p0 } }
+ }
+ if (finalByte === CSI.CUP || finalByte === CSI.HVP) {
+ return { type: 'cursor', action: { type: 'position', row: p0, col: p1 } }
+ }
+ if (finalByte === CSI.VPA) {
+ return { type: 'cursor', action: { type: 'row', row: p0 } }
+ }
+
+ // Erase
+ if (finalByte === CSI.ED) {
+ const region = ERASE_DISPLAY[params[0] ?? 0] ?? 'toEnd'
+ return { type: 'erase', action: { type: 'display', region } }
+ }
+ if (finalByte === CSI.EL) {
+ const region = ERASE_LINE_REGION[params[0] ?? 0] ?? 'toEnd'
+ return { type: 'erase', action: { type: 'line', region } }
+ }
+ if (finalByte === CSI.ECH) {
+ return { type: 'erase', action: { type: 'chars', count: p0 } }
+ }
+
+ // Scroll
+ if (finalByte === CSI.SU) {
+ return { type: 'scroll', action: { type: 'up', count: p0 } }
+ }
+ if (finalByte === CSI.SD) {
+ return { type: 'scroll', action: { type: 'down', count: p0 } }
+ }
+ if (finalByte === CSI.DECSTBM) {
+ return {
+ type: 'scroll',
+ action: { type: 'setRegion', top: p0, bottom: p1 },
+ }
+ }
+
+ // Cursor save/restore
+ if (finalByte === CSI.SCOSC) {
+ return { type: 'cursor', action: { type: 'save' } }
+ }
+ if (finalByte === CSI.SCORC) {
+ return { type: 'cursor', action: { type: 'restore' } }
+ }
+
+ // Cursor style
+ if (finalByte === CSI.DECSCUSR && intermediate === ' ') {
+ const styleInfo = CURSOR_STYLES[p0] ?? CURSOR_STYLES[0]!
+ return { type: 'cursor', action: { type: 'style', ...styleInfo } }
+ }
+
+ // Private modes
+ if (privateMode === '?' && (finalByte === CSI.SM || finalByte === CSI.RM)) {
+ const enabled = finalByte === CSI.SM
+
+ if (p0 === DEC.CURSOR_VISIBLE) {
+ return {
+ type: 'cursor',
+ action: enabled ? { type: 'show' } : { type: 'hide' },
+ }
+ }
+ if (p0 === DEC.ALT_SCREEN_CLEAR || p0 === DEC.ALT_SCREEN) {
+ return { type: 'mode', action: { type: 'alternateScreen', enabled } }
+ }
+ if (p0 === DEC.BRACKETED_PASTE) {
+ return { type: 'mode', action: { type: 'bracketedPaste', enabled } }
+ }
+ if (p0 === DEC.MOUSE_NORMAL) {
+ return {
+ type: 'mode',
+ action: { type: 'mouseTracking', mode: enabled ? 'normal' : 'off' },
+ }
+ }
+ if (p0 === DEC.MOUSE_BUTTON) {
+ return {
+ type: 'mode',
+ action: { type: 'mouseTracking', mode: enabled ? 'button' : 'off' },
+ }
+ }
+ if (p0 === DEC.MOUSE_ANY) {
+ return {
+ type: 'mode',
+ action: { type: 'mouseTracking', mode: enabled ? 'any' : 'off' },
+ }
+ }
+ if (p0 === DEC.FOCUS_EVENTS) {
+ return { type: 'mode', action: { type: 'focusEvents', enabled } }
+ }
+ }
+
+ return { type: 'unknown', sequence: rawSequence }
+}
+
+/**
+ * Identify the type of escape sequence from its raw form.
+ */
+function identifySequence(
+ seq: string,
+): 'csi' | 'osc' | 'esc' | 'ss3' | 'unknown' {
+ if (seq.length < 2) return 'unknown'
+ if (seq.charCodeAt(0) !== C0.ESC) return 'unknown'
+
+ const second = seq.charCodeAt(1)
+ if (second === 0x5b) return 'csi' // [
+ if (second === 0x5d) return 'osc' // ]
+ if (second === 0x4f) return 'ss3' // O
+ return 'esc'
+}
+
+// =============================================================================
+// Main Parser
+// =============================================================================
+
+/**
+ * Parser class - maintains state for streaming/incremental parsing
+ *
+ * Usage:
+ * ```typescript
+ * const parser = new Parser()
+ * const actions1 = parser.feed('partial\x1b[')
+ * const actions2 = parser.feed('31mred') // state maintained internally
+ * ```
+ */
+export class Parser {
+ private tokenizer: Tokenizer = createTokenizer()
+
+ style: TextStyle = defaultStyle()
+ inLink = false
+ linkUrl: string | undefined
+
+ reset(): void {
+ this.tokenizer.reset()
+ this.style = defaultStyle()
+ this.inLink = false
+ this.linkUrl = undefined
+ }
+
+ /** Feed input and get resulting actions */
+ feed(input: string): Action[] {
+ const tokens = this.tokenizer.feed(input)
+ const actions: Action[] = []
+
+ for (const token of tokens) {
+ const tokenActions = this.processToken(token)
+ actions.push(...tokenActions)
+ }
+
+ return actions
+ }
+
+ private processToken(token: Token): Action[] {
+ switch (token.type) {
+ case 'text':
+ return this.processText(token.value)
+
+ case 'sequence':
+ return this.processSequence(token.value)
+ }
+ }
+
+ private processText(text: string): Action[] {
+ // Handle BEL characters embedded in text
+ const actions: Action[] = []
+ let current = ''
+
+ for (const char of text) {
+ if (char.charCodeAt(0) === C0.BEL) {
+ if (current) {
+ const graphemes = [...segmentGraphemes(current)]
+ if (graphemes.length > 0) {
+ actions.push({ type: 'text', graphemes, style: { ...this.style } })
+ }
+ current = ''
+ }
+ actions.push({ type: 'bell' })
+ } else {
+ current += char
+ }
+ }
+
+ if (current) {
+ const graphemes = [...segmentGraphemes(current)]
+ if (graphemes.length > 0) {
+ actions.push({ type: 'text', graphemes, style: { ...this.style } })
+ }
+ }
+
+ return actions
+ }
+
+ private processSequence(seq: string): Action[] {
+ const seqType = identifySequence(seq)
+
+ switch (seqType) {
+ case 'csi': {
+ const action = parseCSI(seq)
+ if (!action) return []
+ if (action.type === 'sgr') {
+ this.style = applySGR(action.params, this.style)
+ return []
+ }
+ return [action]
+ }
+
+ case 'osc': {
+ // Extract OSC content (between ESC ] and terminator)
+ let content = seq.slice(2)
+ // Remove terminator (BEL or ESC \)
+ if (content.endsWith('\x07')) {
+ content = content.slice(0, -1)
+ } else if (content.endsWith('\x1b\\')) {
+ content = content.slice(0, -2)
+ }
+
+ const action = parseOSC(content)
+ if (action) {
+ if (action.type === 'link') {
+ if (action.action.type === 'start') {
+ this.inLink = true
+ this.linkUrl = action.action.url
+ } else {
+ this.inLink = false
+ this.linkUrl = undefined
+ }
+ }
+ return [action]
+ }
+ return []
+ }
+
+ case 'esc': {
+ const escContent = seq.slice(1)
+ const action = parseEsc(escContent)
+ return action ? [action] : []
+ }
+
+ case 'ss3':
+ // SS3 sequences are typically cursor keys in application mode
+ // For output parsing, treat as unknown
+ return [{ type: 'unknown', sequence: seq }]
+
+ default:
+ return [{ type: 'unknown', sequence: seq }]
+ }
+ }
+}
diff --git a/src/ink/termio/tokenize.ts b/src/ink/termio/tokenize.ts
new file mode 100644
index 0000000000000000000000000000000000000000..68a0d113c596772512a2149a5b58edb0b235d9cf
--- /dev/null
+++ b/src/ink/termio/tokenize.ts
@@ -0,0 +1,319 @@
+/**
+ * Input Tokenizer - Escape sequence boundary detection
+ *
+ * Splits terminal input into tokens: text chunks and raw escape sequences.
+ * Unlike the Parser which interprets sequences semantically, this just
+ * identifies boundaries for use by keyboard input parsing.
+ */
+
+import { C0, ESC_TYPE, isEscFinal } from './ansi.js'
+import { isCSIFinal, isCSIIntermediate, isCSIParam } from './csi.js'
+
+export type Token =
+ | { type: 'text'; value: string }
+ | { type: 'sequence'; value: string }
+
+type State =
+ | 'ground'
+ | 'escape'
+ | 'escapeIntermediate'
+ | 'csi'
+ | 'ss3'
+ | 'osc'
+ | 'dcs'
+ | 'apc'
+
+export type Tokenizer = {
+ /** Feed input and get resulting tokens */
+ feed(input: string): Token[]
+ /** Flush any buffered incomplete sequences */
+ flush(): Token[]
+ /** Reset tokenizer state */
+ reset(): void
+ /** Get any buffered incomplete sequence */
+ buffer(): string
+}
+
+type TokenizerOptions = {
+ /**
+ * Treat `CSI M` as an X10 mouse event prefix and consume 3 payload bytes.
+ * Only enable for stdin input — `\x1b[M` is also CSI DL (Delete Lines) in
+ * output streams, and enabling this there swallows display text. Default false.
+ */
+ x10Mouse?: boolean
+}
+
+/**
+ * Create a streaming tokenizer for terminal input.
+ *
+ * Usage:
+ * ```typescript
+ * const tokenizer = createTokenizer()
+ * const tokens1 = tokenizer.feed('hello\x1b[')
+ * const tokens2 = tokenizer.feed('A') // completes the escape sequence
+ * const remaining = tokenizer.flush() // force output incomplete sequences
+ * ```
+ */
+export function createTokenizer(options?: TokenizerOptions): Tokenizer {
+ let currentState: State = 'ground'
+ let currentBuffer = ''
+ const x10Mouse = options?.x10Mouse ?? false
+
+ return {
+ feed(input: string): Token[] {
+ const result = tokenize(
+ input,
+ currentState,
+ currentBuffer,
+ false,
+ x10Mouse,
+ )
+ currentState = result.state.state
+ currentBuffer = result.state.buffer
+ return result.tokens
+ },
+
+ flush(): Token[] {
+ const result = tokenize('', currentState, currentBuffer, true, x10Mouse)
+ currentState = result.state.state
+ currentBuffer = result.state.buffer
+ return result.tokens
+ },
+
+ reset(): void {
+ currentState = 'ground'
+ currentBuffer = ''
+ },
+
+ buffer(): string {
+ return currentBuffer
+ },
+ }
+}
+
+type InternalState = {
+ state: State
+ buffer: string
+}
+
+function tokenize(
+ input: string,
+ initialState: State,
+ initialBuffer: string,
+ flush: boolean,
+ x10Mouse: boolean,
+): { tokens: Token[]; state: InternalState } {
+ const tokens: Token[] = []
+ const result: InternalState = {
+ state: initialState,
+ buffer: '',
+ }
+
+ const data = initialBuffer + input
+ let i = 0
+ let textStart = 0
+ let seqStart = 0
+
+ const flushText = (): void => {
+ if (i > textStart) {
+ const text = data.slice(textStart, i)
+ if (text) {
+ tokens.push({ type: 'text', value: text })
+ }
+ }
+ textStart = i
+ }
+
+ const emitSequence = (seq: string): void => {
+ if (seq) {
+ tokens.push({ type: 'sequence', value: seq })
+ }
+ result.state = 'ground'
+ textStart = i
+ }
+
+ while (i < data.length) {
+ const code = data.charCodeAt(i)
+
+ switch (result.state) {
+ case 'ground':
+ if (code === C0.ESC) {
+ flushText()
+ seqStart = i
+ result.state = 'escape'
+ i++
+ } else {
+ i++
+ }
+ break
+
+ case 'escape':
+ if (code === ESC_TYPE.CSI) {
+ result.state = 'csi'
+ i++
+ } else if (code === ESC_TYPE.OSC) {
+ result.state = 'osc'
+ i++
+ } else if (code === ESC_TYPE.DCS) {
+ result.state = 'dcs'
+ i++
+ } else if (code === ESC_TYPE.APC) {
+ result.state = 'apc'
+ i++
+ } else if (code === 0x4f) {
+ // 'O' - SS3
+ result.state = 'ss3'
+ i++
+ } else if (isCSIIntermediate(code)) {
+ // Intermediate byte (e.g., ESC ( for charset) - continue buffering
+ result.state = 'escapeIntermediate'
+ i++
+ } else if (isEscFinal(code)) {
+ // Two-character escape sequence
+ i++
+ emitSequence(data.slice(seqStart, i))
+ } else if (code === C0.ESC) {
+ // Double escape - emit first, start new
+ emitSequence(data.slice(seqStart, i))
+ seqStart = i
+ result.state = 'escape'
+ i++
+ } else {
+ // Invalid - treat ESC as text
+ result.state = 'ground'
+ textStart = seqStart
+ }
+ break
+
+ case 'escapeIntermediate':
+ // After intermediate byte(s), wait for final byte
+ if (isCSIIntermediate(code)) {
+ // More intermediate bytes
+ i++
+ } else if (isEscFinal(code)) {
+ // Final byte - complete the sequence
+ i++
+ emitSequence(data.slice(seqStart, i))
+ } else {
+ // Invalid - treat as text
+ result.state = 'ground'
+ textStart = seqStart
+ }
+ break
+
+ case 'csi':
+ // X10 mouse: CSI M + 3 raw payload bytes (Cb+32, Cx+32, Cy+32).
+ // M immediately after [ (offset 2) means no params — SGR mouse
+ // (CSI < … M) has a `<` param byte first and reaches M at offset > 2.
+ // Terminals that ignore DECSET 1006 but honor 1000/1002 emit this
+ // legacy encoding; without this branch the 3 payload bytes leak
+ // through as text (`` `rK `` / `arK` garbage in the prompt).
+ //
+ // Gated on x10Mouse — `\x1b[M` is also CSI DL (Delete Lines) and
+ // blindly consuming 3 chars corrupts output rendering (Parser/Ansi)
+ // and fragments bracketed-paste PASTE_END. Only stdin enables this.
+ // The ≥0x20 check on each payload slot is belt-and-suspenders: X10
+ // guarantees Cb≥32, Cx≥33, Cy≥33, so a control byte (ESC=0x1B) in
+ // any slot means this is CSI DL adjacent to another sequence, not a
+ // mouse event. Checking all three slots prevents PASTE_END's ESC
+ // from being consumed when paste content ends in `\x1b[M`+0-2 chars.
+ //
+ // Known limitation: this counts JS string chars, but X10 is byte-
+ // oriented and stdin uses utf8 encoding (App.tsx). At col 162-191 ×
+ // row 96-159 the two coord bytes (0xC2-0xDF, 0x80-0xBF) form a valid
+ // UTF-8 2-byte sequence and collapse to one char — the length check
+ // fails and the event buffers until the next keypress absorbs it.
+ // Fixing this requires latin1 stdin; X10's 223-coord cap is exactly
+ // why SGR was invented, and no-SGR terminals at 162+ cols are rare.
+ if (
+ x10Mouse &&
+ code === 0x4d /* M */ &&
+ i - seqStart === 2 &&
+ (i + 1 >= data.length || data.charCodeAt(i + 1) >= 0x20) &&
+ (i + 2 >= data.length || data.charCodeAt(i + 2) >= 0x20) &&
+ (i + 3 >= data.length || data.charCodeAt(i + 3) >= 0x20)
+ ) {
+ if (i + 4 <= data.length) {
+ i += 4
+ emitSequence(data.slice(seqStart, i))
+ } else {
+ // Incomplete — exit loop; end-of-input buffers from seqStart.
+ // Re-entry re-tokenizes from ground via the invalid-CSI fallthrough.
+ i = data.length
+ }
+ break
+ }
+ if (isCSIFinal(code)) {
+ i++
+ emitSequence(data.slice(seqStart, i))
+ } else if (isCSIParam(code) || isCSIIntermediate(code)) {
+ i++
+ } else {
+ // Invalid CSI - abort, treat as text
+ result.state = 'ground'
+ textStart = seqStart
+ }
+ break
+
+ case 'ss3':
+ // SS3 sequences: ESC O followed by a single final byte
+ if (code >= 0x40 && code <= 0x7e) {
+ i++
+ emitSequence(data.slice(seqStart, i))
+ } else {
+ // Invalid - treat as text
+ result.state = 'ground'
+ textStart = seqStart
+ }
+ break
+
+ case 'osc':
+ if (code === C0.BEL) {
+ i++
+ emitSequence(data.slice(seqStart, i))
+ } else if (
+ code === C0.ESC &&
+ i + 1 < data.length &&
+ data.charCodeAt(i + 1) === ESC_TYPE.ST
+ ) {
+ i += 2
+ emitSequence(data.slice(seqStart, i))
+ } else {
+ i++
+ }
+ break
+
+ case 'dcs':
+ case 'apc':
+ if (code === C0.BEL) {
+ i++
+ emitSequence(data.slice(seqStart, i))
+ } else if (
+ code === C0.ESC &&
+ i + 1 < data.length &&
+ data.charCodeAt(i + 1) === ESC_TYPE.ST
+ ) {
+ i += 2
+ emitSequence(data.slice(seqStart, i))
+ } else {
+ i++
+ }
+ break
+ }
+ }
+
+ // Handle end of input
+ if (result.state === 'ground') {
+ flushText()
+ } else if (flush) {
+ // Force output incomplete sequence
+ const remaining = data.slice(seqStart)
+ if (remaining) tokens.push({ type: 'sequence', value: remaining })
+ result.state = 'ground'
+ } else {
+ // Buffer incomplete sequence for next call
+ result.buffer = data.slice(seqStart)
+ }
+
+ return { tokens, state: result }
+}
diff --git a/src/ink/termio/types.ts b/src/ink/termio/types.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6c9bf737833153216962006c7e96b1ae64e0d133
--- /dev/null
+++ b/src/ink/termio/types.ts
@@ -0,0 +1,236 @@
+/**
+ * ANSI Parser - Semantic Types
+ *
+ * These types represent the semantic meaning of ANSI escape sequences,
+ * not their string representation. Inspired by ghostty's action-based design.
+ */
+
+// =============================================================================
+// Colors
+// =============================================================================
+
+/** Named colors from the 16-color palette */
+export type NamedColor =
+ | 'black'
+ | 'red'
+ | 'green'
+ | 'yellow'
+ | 'blue'
+ | 'magenta'
+ | 'cyan'
+ | 'white'
+ | 'brightBlack'
+ | 'brightRed'
+ | 'brightGreen'
+ | 'brightYellow'
+ | 'brightBlue'
+ | 'brightMagenta'
+ | 'brightCyan'
+ | 'brightWhite'
+
+/** Color specification - can be named, indexed (256), or RGB */
+export type Color =
+ | { type: 'named'; name: NamedColor }
+ | { type: 'indexed'; index: number } // 0-255
+ | { type: 'rgb'; r: number; g: number; b: number }
+ | { type: 'default' }
+
+// =============================================================================
+// Text Styles
+// =============================================================================
+
+/** Underline style variants */
+export type UnderlineStyle =
+ | 'none'
+ | 'single'
+ | 'double'
+ | 'curly'
+ | 'dotted'
+ | 'dashed'
+
+/** Text style attributes - represents current styling state */
+export type TextStyle = {
+ bold: boolean
+ dim: boolean
+ italic: boolean
+ underline: UnderlineStyle
+ blink: boolean
+ inverse: boolean
+ hidden: boolean
+ strikethrough: boolean
+ overline: boolean
+ fg: Color
+ bg: Color
+ underlineColor: Color
+}
+
+/** Create a default (reset) text style */
+export function defaultStyle(): TextStyle {
+ return {
+ bold: false,
+ dim: false,
+ italic: false,
+ underline: 'none',
+ blink: false,
+ inverse: false,
+ hidden: false,
+ strikethrough: false,
+ overline: false,
+ fg: { type: 'default' },
+ bg: { type: 'default' },
+ underlineColor: { type: 'default' },
+ }
+}
+
+/** Check if two styles are equal */
+export function stylesEqual(a: TextStyle, b: TextStyle): boolean {
+ return (
+ a.bold === b.bold &&
+ a.dim === b.dim &&
+ a.italic === b.italic &&
+ a.underline === b.underline &&
+ a.blink === b.blink &&
+ a.inverse === b.inverse &&
+ a.hidden === b.hidden &&
+ a.strikethrough === b.strikethrough &&
+ a.overline === b.overline &&
+ colorsEqual(a.fg, b.fg) &&
+ colorsEqual(a.bg, b.bg) &&
+ colorsEqual(a.underlineColor, b.underlineColor)
+ )
+}
+
+/** Check if two colors are equal */
+export function colorsEqual(a: Color, b: Color): boolean {
+ if (a.type !== b.type) return false
+ switch (a.type) {
+ case 'named':
+ return a.name === (b as typeof a).name
+ case 'indexed':
+ return a.index === (b as typeof a).index
+ case 'rgb':
+ return (
+ a.r === (b as typeof a).r &&
+ a.g === (b as typeof a).g &&
+ a.b === (b as typeof a).b
+ )
+ case 'default':
+ return true
+ }
+}
+
+// =============================================================================
+// Cursor Actions
+// =============================================================================
+
+export type CursorDirection = 'up' | 'down' | 'forward' | 'back'
+
+export type CursorAction =
+ | { type: 'move'; direction: CursorDirection; count: number }
+ | { type: 'position'; row: number; col: number }
+ | { type: 'column'; col: number }
+ | { type: 'row'; row: number }
+ | { type: 'save' }
+ | { type: 'restore' }
+ | { type: 'show' }
+ | { type: 'hide' }
+ | {
+ type: 'style'
+ style: 'block' | 'underline' | 'bar'
+ blinking: boolean
+ }
+ | { type: 'nextLine'; count: number }
+ | { type: 'prevLine'; count: number }
+
+// =============================================================================
+// Erase Actions
+// =============================================================================
+
+export type EraseAction =
+ | { type: 'display'; region: 'toEnd' | 'toStart' | 'all' | 'scrollback' }
+ | { type: 'line'; region: 'toEnd' | 'toStart' | 'all' }
+ | { type: 'chars'; count: number }
+
+// =============================================================================
+// Scroll Actions
+// =============================================================================
+
+export type ScrollAction =
+ | { type: 'up'; count: number }
+ | { type: 'down'; count: number }
+ | { type: 'setRegion'; top: number; bottom: number }
+
+// =============================================================================
+// Mode Actions
+// =============================================================================
+
+export type ModeAction =
+ | { type: 'alternateScreen'; enabled: boolean }
+ | { type: 'bracketedPaste'; enabled: boolean }
+ | { type: 'mouseTracking'; mode: 'off' | 'normal' | 'button' | 'any' }
+ | { type: 'focusEvents'; enabled: boolean }
+
+// =============================================================================
+// Link Actions (OSC 8)
+// =============================================================================
+
+export type LinkAction =
+ | { type: 'start'; url: string; params?: Record }
+ | { type: 'end' }
+
+// =============================================================================
+// Title Actions (OSC 0/1/2)
+// =============================================================================
+
+export type TitleAction =
+ | { type: 'windowTitle'; title: string }
+ | { type: 'iconName'; name: string }
+ | { type: 'both'; title: string }
+
+// =============================================================================
+// Tab Status Action (OSC 21337)
+// =============================================================================
+
+/**
+ * Per-tab chrome metadata. Tristate for each field:
+ * - property absent → not mentioned in sequence, no change
+ * - null → explicitly cleared (bare key or key= with empty value)
+ * - value → set to this
+ */
+export type TabStatusAction = {
+ indicator?: Color | null
+ status?: string | null
+ statusColor?: Color | null
+}
+
+// =============================================================================
+// Parsed Segments - The output of the parser
+// =============================================================================
+
+/** A segment of styled text */
+export type TextSegment = {
+ type: 'text'
+ text: string
+ style: TextStyle
+}
+
+/** A grapheme (visual character unit) with width info */
+export type Grapheme = {
+ value: string
+ width: 1 | 2 // Display width in columns
+}
+
+/** All possible parsed actions */
+export type Action =
+ | { type: 'text'; graphemes: Grapheme[]; style: TextStyle }
+ | { type: 'cursor'; action: CursorAction }
+ | { type: 'erase'; action: EraseAction }
+ | { type: 'scroll'; action: ScrollAction }
+ | { type: 'mode'; action: ModeAction }
+ | { type: 'link'; action: LinkAction }
+ | { type: 'title'; action: TitleAction }
+ | { type: 'tabStatus'; action: TabStatusAction }
+ | { type: 'sgr'; params: string } // Select Graphic Rendition (style change)
+ | { type: 'bell' }
+ | { type: 'reset' } // Full terminal reset (ESC c)
+ | { type: 'unknown'; sequence: string } // Unrecognized sequence
diff --git a/src/tools/AgentTool/built-in/verificationAgent.ts b/src/tools/AgentTool/built-in/verificationAgent.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3609f97e533c5f38c5eeb37a16e3375e55694877
--- /dev/null
+++ b/src/tools/AgentTool/built-in/verificationAgent.ts
@@ -0,0 +1,152 @@
+import { BASH_TOOL_NAME } from 'src/tools/BashTool/toolName.js'
+import { EXIT_PLAN_MODE_TOOL_NAME } from 'src/tools/ExitPlanModeTool/constants.js'
+import { FILE_EDIT_TOOL_NAME } from 'src/tools/FileEditTool/constants.js'
+import { FILE_WRITE_TOOL_NAME } from 'src/tools/FileWriteTool/prompt.js'
+import { NOTEBOOK_EDIT_TOOL_NAME } from 'src/tools/NotebookEditTool/constants.js'
+import { WEB_FETCH_TOOL_NAME } from 'src/tools/WebFetchTool/prompt.js'
+import { AGENT_TOOL_NAME } from '../constants.js'
+import type { BuiltInAgentDefinition } from '../loadAgentsDir.js'
+
+const VERIFICATION_SYSTEM_PROMPT = `You are a verification specialist. Your job is not to confirm the implementation works — it's to try to break it.
+
+You have two documented failure patterns. First, verification avoidance: when faced with a check, you find reasons not to run it — you read code, narrate what you would test, write "PASS," and move on. Second, being seduced by the first 80%: you see a polished UI or a passing test suite and feel inclined to pass it, not noticing half the buttons do nothing, the state vanishes on refresh, or the backend crashes on bad input. The first 80% is the easy part. Your entire value is in finding the last 20%. The caller may spot-check your commands by re-running them — if a PASS step has no command output, or output that doesn't match re-execution, your report gets rejected.
+
+=== CRITICAL: DO NOT MODIFY THE PROJECT ===
+You are STRICTLY PROHIBITED from:
+- Creating, modifying, or deleting any files IN THE PROJECT DIRECTORY
+- Installing dependencies or packages
+- Running git write operations (add, commit, push)
+
+You MAY write ephemeral test scripts to a temp directory (/tmp or $TMPDIR) via ${BASH_TOOL_NAME} redirection when inline commands aren't sufficient — e.g., a multi-step race harness or a Playwright test. Clean up after yourself.
+
+Check your ACTUAL available tools rather than assuming from this prompt. You may have browser automation (mcp__claude-in-chrome__*, mcp__playwright__*), ${WEB_FETCH_TOOL_NAME}, or other MCP tools depending on the session — do not skip capabilities you didn't think to check for.
+
+=== WHAT YOU RECEIVE ===
+You will receive: the original task description, files changed, approach taken, and optionally a plan file path.
+
+=== VERIFICATION STRATEGY ===
+Adapt your strategy based on what was changed:
+
+**Frontend changes**: Start dev server → check your tools for browser automation (mcp__claude-in-chrome__*, mcp__playwright__*) and USE them to navigate, screenshot, click, and read console — do NOT say "needs a real browser" without attempting → curl a sample of page subresources (image-optimizer URLs like /_next/image, same-origin API routes, static assets) since HTML can serve 200 while everything it references fails → run frontend tests
+**Backend/API changes**: Start server → curl/fetch endpoints → verify response shapes against expected values (not just status codes) → test error handling → check edge cases
+**CLI/script changes**: Run with representative inputs → verify stdout/stderr/exit codes → test edge inputs (empty, malformed, boundary) → verify --help / usage output is accurate
+**Infrastructure/config changes**: Validate syntax → dry-run where possible (terraform plan, kubectl apply --dry-run=server, docker build, nginx -t) → check env vars / secrets are actually referenced, not just defined
+**Library/package changes**: Build → full test suite → import the library from a fresh context and exercise the public API as a consumer would → verify exported types match README/docs examples
+**Bug fixes**: Reproduce the original bug → verify fix → run regression tests → check related functionality for side effects
+**Mobile (iOS/Android)**: Clean build → install on simulator/emulator → dump accessibility/UI tree (idb ui describe-all / uiautomator dump), find elements by label, tap by tree coords, re-dump to verify; screenshots secondary → kill and relaunch to test persistence → check crash logs (logcat / device console)
+**Data/ML pipeline**: Run with sample input → verify output shape/schema/types → test empty input, single row, NaN/null handling → check for silent data loss (row counts in vs out)
+**Database migrations**: Run migration up → verify schema matches intent → run migration down (reversibility) → test against existing data, not just empty DB
+**Refactoring (no behavior change)**: Existing test suite MUST pass unchanged → diff the public API surface (no new/removed exports) → spot-check observable behavior is identical (same inputs → same outputs)
+**Other change types**: The pattern is always the same — (a) figure out how to exercise this change directly (run/call/invoke/deploy it), (b) check outputs against expectations, (c) try to break it with inputs/conditions the implementer didn't test. The strategies above are worked examples for common cases.
+
+=== REQUIRED STEPS (universal baseline) ===
+1. Read the project's CLAUDE.md / README for build/test commands and conventions. Check package.json / Makefile / pyproject.toml for script names. If the implementer pointed you to a plan or spec file, read it — that's the success criteria.
+2. Run the build (if applicable). A broken build is an automatic FAIL.
+3. Run the project's test suite (if it has one). Failing tests are an automatic FAIL.
+4. Run linters/type-checkers if configured (eslint, tsc, mypy, etc.).
+5. Check for regressions in related code.
+
+Then apply the type-specific strategy above. Match rigor to stakes: a one-off script doesn't need race-condition probes; production payments code needs everything.
+
+Test suite results are context, not evidence. Run the suite, note pass/fail, then move on to your real verification. The implementer is an LLM too — its tests may be heavy on mocks, circular assertions, or happy-path coverage that proves nothing about whether the system actually works end-to-end.
+
+=== RECOGNIZE YOUR OWN RATIONALIZATIONS ===
+You will feel the urge to skip checks. These are the exact excuses you reach for — recognize them and do the opposite:
+- "The code looks correct based on my reading" — reading is not verification. Run it.
+- "The implementer's tests already pass" — the implementer is an LLM. Verify independently.
+- "This is probably fine" — probably is not verified. Run it.
+- "Let me start the server and check the code" — no. Start the server and hit the endpoint.
+- "I don't have a browser" — did you actually check for mcp__claude-in-chrome__* / mcp__playwright__*? If present, use them. If an MCP tool fails, troubleshoot (server running? selector right?). The fallback exists so you don't invent your own "can't do this" story.
+- "This would take too long" — not your call.
+If you catch yourself writing an explanation instead of a command, stop. Run the command.
+
+=== ADVERSARIAL PROBES (adapt to the change type) ===
+Functional tests confirm the happy path. Also try to break it:
+- **Concurrency** (servers/APIs): parallel requests to create-if-not-exists paths — duplicate sessions? lost writes?
+- **Boundary values**: 0, -1, empty string, very long strings, unicode, MAX_INT
+- **Idempotency**: same mutating request twice — duplicate created? error? correct no-op?
+- **Orphan operations**: delete/reference IDs that don't exist
+These are seeds, not a checklist — pick the ones that fit what you're verifying.
+
+=== BEFORE ISSUING PASS ===
+Your report must include at least one adversarial probe you ran (concurrency, boundary, idempotency, orphan op, or similar) and its result — even if the result was "handled correctly." If all your checks are "returns 200" or "test suite passes," you have confirmed the happy path, not verified correctness. Go back and try to break something.
+
+=== BEFORE ISSUING FAIL ===
+You found something that looks broken. Before reporting FAIL, check you haven't missed why it's actually fine:
+- **Already handled**: is there defensive code elsewhere (validation upstream, error recovery downstream) that prevents this?
+- **Intentional**: does CLAUDE.md / comments / commit message explain this as deliberate?
+- **Not actionable**: is this a real limitation but unfixable without breaking an external contract (stable API, protocol spec, backwards compat)? If so, note it as an observation, not a FAIL — a "bug" that can't be fixed isn't actionable.
+Don't use these as excuses to wave away real issues — but don't FAIL on intentional behavior either.
+
+=== OUTPUT FORMAT (REQUIRED) ===
+Every check MUST follow this structure. A check without a Command run block is not a PASS — it's a skip.
+
+\`\`\`
+### Check: [what you're verifying]
+**Command run:**
+ [exact command you executed]
+**Output observed:**
+ [actual terminal output — copy-paste, not paraphrased. Truncate if very long but keep the relevant part.]
+**Result: PASS** (or FAIL — with Expected vs Actual)
+\`\`\`
+
+Bad (rejected):
+\`\`\`
+### Check: POST /api/register validation
+**Result: PASS**
+Evidence: Reviewed the route handler in routes/auth.py. The logic correctly validates
+email format and password length before DB insert.
+\`\`\`
+(No command run. Reading code is not verification.)
+
+Good:
+\`\`\`
+### Check: POST /api/register rejects short password
+**Command run:**
+ curl -s -X POST localhost:8000/api/register -H 'Content-Type: application/json' \\
+ -d '{"email":"t@t.co","password":"short"}' | python3 -m json.tool
+**Output observed:**
+ {
+ "error": "password must be at least 8 characters"
+ }
+ (HTTP 400)
+**Expected vs Actual:** Expected 400 with password-length error. Got exactly that.
+**Result: PASS**
+\`\`\`
+
+End with exactly this line (parsed by caller):
+
+VERDICT: PASS
+or
+VERDICT: FAIL
+or
+VERDICT: PARTIAL
+
+PARTIAL is for environmental limitations only (no test framework, tool unavailable, server can't start) — not for "I'm unsure whether this is a bug." If you can run the check, you must decide PASS or FAIL.
+
+Use the literal string \`VERDICT: \` followed by exactly one of \`PASS\`, \`FAIL\`, \`PARTIAL\`. No markdown bold, no punctuation, no variation.
+- **FAIL**: include what failed, exact error output, reproduction steps.
+- **PARTIAL**: what was verified, what could not be and why (missing tool/env), what the implementer should know.`
+
+const VERIFICATION_WHEN_TO_USE =
+ 'Use this agent to verify that implementation work is correct before reporting completion. Invoke after non-trivial tasks (3+ file edits, backend/API changes, infrastructure changes). Pass the ORIGINAL user task description, list of files changed, and approach taken. The agent runs builds, tests, linters, and checks to produce a PASS/FAIL/PARTIAL verdict with evidence.'
+
+export const VERIFICATION_AGENT: BuiltInAgentDefinition = {
+ agentType: 'verification',
+ whenToUse: VERIFICATION_WHEN_TO_USE,
+ color: 'red',
+ background: true,
+ disallowedTools: [
+ AGENT_TOOL_NAME,
+ EXIT_PLAN_MODE_TOOL_NAME,
+ FILE_EDIT_TOOL_NAME,
+ FILE_WRITE_TOOL_NAME,
+ NOTEBOOK_EDIT_TOOL_NAME,
+ ],
+ source: 'built-in',
+ baseDir: 'built-in',
+ model: 'inherit',
+ getSystemPrompt: () => VERIFICATION_SYSTEM_PROMPT,
+ criticalSystemReminder_EXPERIMENTAL:
+ 'CRITICAL: This is a VERIFICATION-ONLY task. You CANNOT edit, write, or create files IN THE PROJECT DIRECTORY (tmp is allowed for ephemeral test scripts). You MUST end with VERDICT: PASS, VERDICT: FAIL, or VERDICT: PARTIAL.',
+}
diff --git a/src/tools/AgentTool/forkSubagent.ts b/src/tools/AgentTool/forkSubagent.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3f5c3542c78fb1ef486d2ea98f7bf75a6d1396ae
--- /dev/null
+++ b/src/tools/AgentTool/forkSubagent.ts
@@ -0,0 +1,210 @@
+import { feature } from 'bun:bundle'
+import type { BetaToolUseBlock } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs'
+import { randomUUID } from 'crypto'
+import { getIsNonInteractiveSession } from '../../bootstrap/state.js'
+import {
+ FORK_BOILERPLATE_TAG,
+ FORK_DIRECTIVE_PREFIX,
+} from '../../constants/xml.js'
+import { isCoordinatorMode } from '../../coordinator/coordinatorMode.js'
+import type {
+ AssistantMessage,
+ Message as MessageType,
+} from '../../types/message.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { createUserMessage } from '../../utils/messages.js'
+import type { BuiltInAgentDefinition } from './loadAgentsDir.js'
+
+/**
+ * Fork subagent feature gate.
+ *
+ * When enabled:
+ * - `subagent_type` becomes optional on the Agent tool schema
+ * - Omitting `subagent_type` triggers an implicit fork: the child inherits
+ * the parent's full conversation context and system prompt
+ * - All agent spawns run in the background (async) for a unified
+ * `` interaction model
+ * - `/fork ` slash command is available
+ *
+ * Mutually exclusive with coordinator mode — coordinator already owns the
+ * orchestration role and has its own delegation model.
+ */
+export function isForkSubagentEnabled(): boolean {
+ if (feature('FORK_SUBAGENT')) {
+ if (isCoordinatorMode()) return false
+ if (getIsNonInteractiveSession()) return false
+ return true
+ }
+ return false
+}
+
+/** Synthetic agent type name used for analytics when the fork path fires. */
+export const FORK_SUBAGENT_TYPE = 'fork'
+
+/**
+ * Synthetic agent definition for the fork path.
+ *
+ * Not registered in builtInAgents — used only when `!subagent_type` and the
+ * experiment is active. `tools: ['*']` with `useExactTools` means the fork
+ * child receives the parent's exact tool pool (for cache-identical API
+ * prefixes). `permissionMode: 'bubble'` surfaces permission prompts to the
+ * parent terminal. `model: 'inherit'` keeps the parent's model for context
+ * length parity.
+ *
+ * The getSystemPrompt here is unused: the fork path passes
+ * `override.systemPrompt` with the parent's already-rendered system prompt
+ * bytes, threaded via `toolUseContext.renderedSystemPrompt`. Reconstructing
+ * by re-calling getSystemPrompt() can diverge (GrowthBook cold→warm) and
+ * bust the prompt cache; threading the rendered bytes is byte-exact.
+ */
+export const FORK_AGENT = {
+ agentType: FORK_SUBAGENT_TYPE,
+ whenToUse:
+ 'Implicit fork — inherits full conversation context. Not selectable via subagent_type; triggered by omitting subagent_type when the fork experiment is active.',
+ tools: ['*'],
+ maxTurns: 200,
+ model: 'inherit',
+ permissionMode: 'bubble',
+ source: 'built-in',
+ baseDir: 'built-in',
+ getSystemPrompt: () => '',
+} satisfies BuiltInAgentDefinition
+
+/**
+ * Guard against recursive forking. Fork children keep the Agent tool in their
+ * tool pool for cache-identical tool definitions, so we reject fork attempts
+ * at call time by detecting the fork boilerplate tag in conversation history.
+ */
+export function isInForkChild(messages: MessageType[]): boolean {
+ return messages.some(m => {
+ if (m.type !== 'user') return false
+ const content = m.message.content
+ if (!Array.isArray(content)) return false
+ return content.some(
+ block =>
+ block.type === 'text' &&
+ block.text.includes(`<${FORK_BOILERPLATE_TAG}>`),
+ )
+ })
+}
+
+/** Placeholder text used for all tool_result blocks in the fork prefix.
+ * Must be identical across all fork children for prompt cache sharing. */
+const FORK_PLACEHOLDER_RESULT = 'Fork started — processing in background'
+
+/**
+ * Build the forked conversation messages for the child agent.
+ *
+ * For prompt cache sharing, all fork children must produce byte-identical
+ * API request prefixes. This function:
+ * 1. Keeps the full parent assistant message (all tool_use blocks, thinking, text)
+ * 2. Builds a single user message with tool_results for every tool_use block
+ * using an identical placeholder, then appends a per-child directive text block
+ *
+ * Result: [...history, assistant(all_tool_uses), user(placeholder_results..., directive)]
+ * Only the final text block differs per child, maximizing cache hits.
+ */
+export function buildForkedMessages(
+ directive: string,
+ assistantMessage: AssistantMessage,
+): MessageType[] {
+ // Clone the assistant message to avoid mutating the original, keeping all
+ // content blocks (thinking, text, and every tool_use)
+ const fullAssistantMessage: AssistantMessage = {
+ ...assistantMessage,
+ uuid: randomUUID(),
+ message: {
+ ...assistantMessage.message,
+ content: [...assistantMessage.message.content],
+ },
+ }
+
+ // Collect all tool_use blocks from the assistant message
+ const toolUseBlocks = assistantMessage.message.content.filter(
+ (block): block is BetaToolUseBlock => block.type === 'tool_use',
+ )
+
+ if (toolUseBlocks.length === 0) {
+ logForDebugging(
+ `No tool_use blocks found in assistant message for fork directive: ${directive.slice(0, 50)}...`,
+ { level: 'error' },
+ )
+ return [
+ createUserMessage({
+ content: [
+ { type: 'text' as const, text: buildChildMessage(directive) },
+ ],
+ }),
+ ]
+ }
+
+ // Build tool_result blocks for every tool_use, all with identical placeholder text
+ const toolResultBlocks = toolUseBlocks.map(block => ({
+ type: 'tool_result' as const,
+ tool_use_id: block.id,
+ content: [
+ {
+ type: 'text' as const,
+ text: FORK_PLACEHOLDER_RESULT,
+ },
+ ],
+ }))
+
+ // Build a single user message: all placeholder tool_results + the per-child directive
+ // TODO(smoosh): this text sibling creates a [tool_result, text] pattern on the wire
+ // (renders as \n\nHuman:). One-off per-child construction,
+ // not a repeated teacher, so low-priority. If we ever care, use smooshIntoToolResult
+ // from src/utils/messages.ts to fold the directive into the last tool_result.content.
+ const toolResultMessage = createUserMessage({
+ content: [
+ ...toolResultBlocks,
+ {
+ type: 'text' as const,
+ text: buildChildMessage(directive),
+ },
+ ],
+ })
+
+ return [fullAssistantMessage, toolResultMessage]
+}
+
+export function buildChildMessage(directive: string): string {
+ return `<${FORK_BOILERPLATE_TAG}>
+STOP. READ THIS FIRST.
+
+You are a forked worker process. You are NOT the main agent.
+
+RULES (non-negotiable):
+1. Your system prompt says "default to forking." IGNORE IT \u2014 that's for the parent. You ARE the fork. Do NOT spawn sub-agents; execute directly.
+2. Do NOT converse, ask questions, or suggest next steps
+3. Do NOT editorialize or add meta-commentary
+4. USE your tools directly: Bash, Read, Write, etc.
+5. If you modify files, commit your changes before reporting. Include the commit hash in your report.
+6. Do NOT emit text between tool calls. Use tools silently, then report once at the end.
+7. Stay strictly within your directive's scope. If you discover related systems outside your scope, mention them in one sentence at most — other workers cover those areas.
+8. Keep your report under 500 words unless the directive specifies otherwise. Be factual and concise.
+9. Your response MUST begin with "Scope:". No preamble, no thinking-out-loud.
+10. REPORT structured facts, then stop
+
+Output format (plain text labels, not markdown headers):
+ Scope:
+ Result:
+ Key files:
+ Files changed:
+ Issues:
+
+
+${FORK_DIRECTIVE_PREFIX}${directive}`
+}
+
+/**
+ * Notice injected into fork children running in an isolated worktree.
+ * Tells the child to translate paths from the inherited context, re-read
+ * potentially stale files, and that its changes are isolated.
+ */
+export function buildWorktreeNotice(
+ parentCwd: string,
+ worktreeCwd: string,
+): string {
+ return `You've inherited the conversation context above from a parent agent working in ${parentCwd}. You are operating in an isolated git worktree at ${worktreeCwd} — same repository, same relative file structure, separate working copy. Paths in the inherited context refer to the parent's working directory; translate them to your worktree root. Re-read files before editing if the parent may have modified them since they appear in the context. Your changes stay in this worktree and will not affect the parent's files.`
+}