@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/events/input-event.js

@@ -0,0 +1,180 @@
+import { nonAlphanumericKeys } from '../parse-keypress.js';
+import { Event } from './event.js';
+function parseKey(keypress) {
+    const 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 [<digits>…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<letter>" (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];
+}
+/**
+ * Event fired for each input chunk received from stdin (a typed character or
+ * a paste), carrying the parsed key flags and the text it produced.
+ */
+export class InputEvent extends Event {
+    /**
+     * The raw parsed keypress this event was built from.
+     */
+    keypress;
+    /**
+     * Named-key flags describing which keys the keypress reports as pressed.
+     */
+    key;
+    /**
+     * The text input produced by this keypress ('' for non-printing keys).
+     */
+    input;
+    /** True when this input arrived as a bracketed paste (terminal paste —
+     *  Ctrl+Shift+V / right-click) rather than typed characters. Handlers use
+     *  this to insert paste content verbatim instead of treating newlines as
+     *  Enter/submit. */
+    isPasted;
+    constructor(keypress) {
+        super();
+        const [key, input] = parseKey(keypress);
+        this.keypress = keypress;
+        this.key = key;
+        this.input = input;
+        this.isPasted = keypress.isPasted === true;
+    }
+}

package/lib/types/ink/events/keyboard-event.d.ts

@@ -0,0 +1,40 @@
+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 declare class KeyboardEvent extends TerminalEvent {
+    /**
+     * The pressed key: the literal character for printable keys ('a', '3', ' '),
+     * a multi-char name for special keys ('down', 'return', 'escape', 'f1').
+     */
+    readonly key: string;
+    /**
+     * Whether the Ctrl modifier was held.
+     */
+    readonly ctrl: boolean;
+    /**
+     * Whether the Shift modifier was held.
+     */
+    readonly shift: boolean;
+    /**
+     * Whether the Meta (Alt/Option) modifier was held.
+     */
+    readonly meta: boolean;
+    /**
+     * Whether the Super (Cmd/Win) modifier was held; only reported by the kitty
+     * keyboard protocol.
+     */
+    readonly superKey: boolean;
+    /**
+     * Whether the Fn modifier was held.
+     */
+    readonly fn: boolean;
+    constructor(parsedKey: ParsedKey);
+}
+//# sourceMappingURL=keyboard-event.d.ts.map

package/lib/types/ink/events/keyboard-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/keyboard-event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAEnD;;;;;;;GAOG;AACH,qBAAa,aAAc,SAAQ,aAAa;IAC9C;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IAEtB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IAEvB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IAEtB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;gBAER,SAAS,EAAE,SAAS;CAUjC"}

package/lib/types/ink/events/keyboard-event.js

@@ -0,0 +1,65 @@
+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 {
+    /**
+     * The pressed key: the literal character for printable keys ('a', '3', ' '),
+     * a multi-char name for special keys ('down', 'return', 'escape', 'f1').
+     */
+    key;
+    /**
+     * Whether the Ctrl modifier was held.
+     */
+    ctrl;
+    /**
+     * Whether the Shift modifier was held.
+     */
+    shift;
+    /**
+     * Whether the Meta (Alt/Option) modifier was held.
+     */
+    meta;
+    /**
+     * Whether the Super (Cmd/Win) modifier was held; only reported by the kitty
+     * keyboard protocol.
+     */
+    superKey;
+    /**
+     * Whether the Fn modifier was held.
+     */
+    fn;
+    constructor(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) {
+    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;
+}

package/lib/types/ink/events/paste-event.d.ts

@@ -0,0 +1,11 @@
+import { Event } from './event.js';
+/**
+ * Terminal paste event (bracketed-paste protocol). Not yet dispatched by the
+ * ported core; declared for the event-handler props surface.
+ */
+export declare class PasteEvent extends Event {
+    /** The pasted text content. */
+    readonly data: string;
+    constructor(data: string);
+}
+//# sourceMappingURL=paste-event.d.ts.map

package/lib/types/ink/events/paste-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/paste-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;gBACT,IAAI,EAAE,MAAM;CAIzB"}

package/lib/types/ink/events/paste-event.js

@@ -0,0 +1,13 @@
+import { Event } from './event.js';
+/**
+ * Terminal paste event (bracketed-paste protocol). Not yet dispatched by the
+ * ported core; declared for the event-handler props surface.
+ */
+export class PasteEvent extends Event {
+    /** The pasted text content. */
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+}

package/lib/types/ink/events/resize-event.d.ts

@@ -0,0 +1,13 @@
+import { Event } from './event.js';
+/**
+ * Terminal resize event. Not yet dispatched by the ported core; declared for
+ * the event-handler props surface.
+ */
+export declare class ResizeEvent extends Event {
+    /** The new terminal width in columns. */
+    readonly columns: number;
+    /** The new terminal height in rows. */
+    readonly rows: number;
+    constructor(columns: number, rows: number);
+}
+//# sourceMappingURL=resize-event.d.ts.map

package/lib/types/ink/events/resize-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/resize-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;gBACT,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAK1C"}

package/lib/types/ink/events/resize-event.js

@@ -0,0 +1,16 @@
+import { Event } from './event.js';
+/**
+ * Terminal resize event. Not yet dispatched by the ported core; declared for
+ * the event-handler props surface.
+ */
+export class ResizeEvent extends Event {
+    /** The new terminal width in columns. */
+    columns;
+    /** The new terminal height in rows. */
+    rows;
+    constructor(columns, rows) {
+        super();
+        this.columns = columns;
+        this.rows = rows;
+    }
+}

package/lib/types/ink/events/terminal-event.d.ts

@@ -0,0 +1,112 @@
+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 declare class TerminalEvent extends Event {
+    /**
+     * The event type name, e.g. 'keydown', 'focus', or 'resize'.
+     */
+    readonly type: string;
+    /**
+     * The time the event was created, in milliseconds via `performance.now()`.
+     */
+    readonly timeStamp: number;
+    /**
+     * Whether the event bubbles from the target up through its ancestors.
+     */
+    readonly bubbles: boolean;
+    /**
+     * Whether `preventDefault()` can cancel the event's default behavior.
+     */
+    readonly cancelable: boolean;
+    private _target;
+    private _currentTarget;
+    private _eventPhase;
+    private _propagationStopped;
+    private _defaultPrevented;
+    constructor(type: string, init?: TerminalEventInit);
+    /**
+     * The node the event was dispatched to, or null before and after dispatch.
+     */
+    get target(): EventTarget | null;
+    /**
+     * The node whose listener is currently running, or null outside dispatch.
+     */
+    get currentTarget(): EventTarget | null;
+    /**
+     * The current propagation phase: 'none', 'capturing', 'at_target', or 'bubbling'.
+     */
+    get eventPhase(): EventPhase;
+    /**
+     * Whether `preventDefault()` was called on this event.
+     */
+    get defaultPrevented(): boolean;
+    /**
+     * Stop the event from reaching listeners on any further nodes; listeners on
+     * the current node still run.
+     */
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    /**
+     * Cancel the event's default behavior when the event is cancelable.
+     */
+    preventDefault(): void;
+    /**
+     * Set the node the event was dispatched to. Used by the dispatcher.
+     * @internal
+     * @param target - the dispatch target node.
+     */
+    _setTarget(target: EventTarget): void;
+    /**
+     * Set the node whose listener is currently running. Used by the dispatcher.
+     * @internal
+     * @param target - the current target node, or null outside dispatch.
+     */
+    _setCurrentTarget(target: EventTarget | null): void;
+    /**
+     * Set the current propagation phase. Used by the dispatcher.
+     * @internal
+     * @param phase - the phase to record.
+     */
+    _setEventPhase(phase: EventPhase): void;
+    /**
+     * Whether `stopPropagation()` was called on this event. Used by the dispatcher.
+     * @internal
+     * @returns true when propagation has been stopped.
+     */
+    _isPropagationStopped(): boolean;
+    /**
+     * Whether `stopImmediatePropagation()` was called on this event. Used by the
+     * dispatcher.
+     * @internal
+     * @returns true when immediate propagation has been stopped.
+     */
+    _isImmediatePropagationStopped(): boolean;
+    /**
+     * Hook for subclasses to do per-node setup before each handler fires.
+     * Default is a no-op.
+     * @param _target - the node the next listener belongs to.
+     */
+    _prepareForTarget(_target: EventTarget): void;
+}
+/**
+ * A node in the component tree that can receive events: its parent node and
+ * its per-event-type handler maps.
+ */
+export type EventTarget = {
+    parentNode: EventTarget | undefined;
+    _eventHandlers?: Record<string, unknown>;
+};
+export {};
+//# sourceMappingURL=terminal-event.d.ts.map

package/lib/types/ink/events/terminal-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/terminal-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC,KAAK,UAAU,GAAG,MAAM,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAA;AAEjE,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;;;;;GAQG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IAEzB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAE5B,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,cAAc,CAA2B;IACjD,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,iBAAiB,CAAQ;gBAErB,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,iBAAiB;IAQlD;;OAEG;IACH,IAAI,MAAM,IAAI,WAAW,GAAG,IAAI,CAE/B;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,WAAW,GAAG,IAAI,CAEtC;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED;;OAEG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAE9B;IAED;;;OAGG;IACH,eAAe,IAAI,IAAI;IAId,wBAAwB,IAAI,IAAI;IAKzC;;OAEG;IACH,cAAc,IAAI,IAAI;IAQtB;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAIrC;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI;IAInD;;;;OAIG;IACH,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAIvC;;;;OAIG;IACH,qBAAqB,IAAI,OAAO;IAIhC;;;;;OAKG;IACH,8BAA8B,IAAI,OAAO;IAIzC;;;;OAIG;IACH,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;CAC9C;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,WAAW,GAAG,SAAS,CAAA;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACzC,CAAA"}

package/lib/types/ink/events/terminal-event.js

@@ -0,0 +1,131 @@
+import { Event } from './event.js';
+/**
+ * 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 {
+    /**
+     * The event type name, e.g. 'keydown', 'focus', or 'resize'.
+     */
+    type;
+    /**
+     * The time the event was created, in milliseconds via `performance.now()`.
+     */
+    timeStamp;
+    /**
+     * Whether the event bubbles from the target up through its ancestors.
+     */
+    bubbles;
+    /**
+     * Whether `preventDefault()` can cancel the event's default behavior.
+     */
+    cancelable;
+    _target = null;
+    _currentTarget = null;
+    _eventPhase = 'none';
+    _propagationStopped = false;
+    _defaultPrevented = false;
+    constructor(type, init) {
+        super();
+        this.type = type;
+        this.timeStamp = performance.now();
+        this.bubbles = init?.bubbles ?? true;
+        this.cancelable = init?.cancelable ?? true;
+    }
+    /**
+     * The node the event was dispatched to, or null before and after dispatch.
+     */
+    get target() {
+        return this._target;
+    }
+    /**
+     * The node whose listener is currently running, or null outside dispatch.
+     */
+    get currentTarget() {
+        return this._currentTarget;
+    }
+    /**
+     * The current propagation phase: 'none', 'capturing', 'at_target', or 'bubbling'.
+     */
+    get eventPhase() {
+        return this._eventPhase;
+    }
+    /**
+     * Whether `preventDefault()` was called on this event.
+     */
+    get defaultPrevented() {
+        return this._defaultPrevented;
+    }
+    /**
+     * Stop the event from reaching listeners on any further nodes; listeners on
+     * the current node still run.
+     */
+    stopPropagation() {
+        this._propagationStopped = true;
+    }
+    stopImmediatePropagation() {
+        super.stopImmediatePropagation();
+        this._propagationStopped = true;
+    }
+    /**
+     * Cancel the event's default behavior when the event is cancelable.
+     */
+    preventDefault() {
+        if (this.cancelable) {
+            this._defaultPrevented = true;
+        }
+    }
+    // -- Internal setters used by the Dispatcher
+    /**
+     * Set the node the event was dispatched to. Used by the dispatcher.
+     * @internal
+     * @param target - the dispatch target node.
+     */
+    _setTarget(target) {
+        this._target = target;
+    }
+    /**
+     * Set the node whose listener is currently running. Used by the dispatcher.
+     * @internal
+     * @param target - the current target node, or null outside dispatch.
+     */
+    _setCurrentTarget(target) {
+        this._currentTarget = target;
+    }
+    /**
+     * Set the current propagation phase. Used by the dispatcher.
+     * @internal
+     * @param phase - the phase to record.
+     */
+    _setEventPhase(phase) {
+        this._eventPhase = phase;
+    }
+    /**
+     * Whether `stopPropagation()` was called on this event. Used by the dispatcher.
+     * @internal
+     * @returns true when propagation has been stopped.
+     */
+    _isPropagationStopped() {
+        return this._propagationStopped;
+    }
+    /**
+     * Whether `stopImmediatePropagation()` was called on this event. Used by the
+     * dispatcher.
+     * @internal
+     * @returns true when immediate propagation has been stopped.
+     */
+    _isImmediatePropagationStopped() {
+        return this.didStopImmediatePropagation();
+    }
+    /**
+     * Hook for subclasses to do per-node setup before each handler fires.
+     * Default is a no-op.
+     * @param _target - the node the next listener belongs to.
+     */
+    _prepareForTarget(_target) { }
+}

package/lib/types/ink/events/terminal-focus-event.d.ts

@@ -0,0 +1,21 @@
+import { Event } from './event.js';
+/**
+ * The focus change kind: 'terminalfocus' when the terminal gains focus,
+ * 'terminalblur' when it loses focus.
+ */
+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 declare class TerminalFocusEvent extends Event {
+    /**
+     * The focus change kind, 'terminalfocus' or 'terminalblur'.
+     */
+    readonly type: TerminalFocusEventType;
+    constructor(type: TerminalFocusEventType);
+}
+//# sourceMappingURL=terminal-focus-event.d.ts.map

package/lib/types/ink/events/terminal-focus-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-focus-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/terminal-focus-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG,cAAc,CAAA;AAErE;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;gBAEzB,IAAI,EAAE,sBAAsB;CAIzC"}

package/lib/types/ink/events/terminal-focus-event.js

@@ -0,0 +1,18 @@
+import { Event } from './event.js';
+/**
+ * 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 {
+    /**
+     * The focus change kind, 'terminalfocus' or 'terminalblur'.
+     */
+    type;
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+}