@askdkc/dsh-cli 0.11.3

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

@@ -0,0 +1,19 @@
+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 declare class FocusEvent extends TerminalEvent {
+    /**
+     * The other element involved in the focus change: the previously focused
+     * element for 'focus' events, the newly focused element for 'blur' events,
+     * or null when there is none.
+     */
+    readonly relatedTarget: EventTarget | null;
+    constructor(type: 'focus' | 'blur', relatedTarget?: EventTarget | null);
+}
+//# sourceMappingURL=focus-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"focus-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/focus-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAErE;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,aAAa;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,WAAW,GAAG,IAAI,CAAA;gBAGxC,IAAI,EAAE,OAAO,GAAG,MAAM,EACtB,aAAa,GAAE,WAAW,GAAG,IAAW;CAK3C"}

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

@@ -0,0 +1,21 @@
+import { 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 {
+    /**
+     * The other element involved in the focus change: the previously focused
+     * element for 'focus' events, the newly focused element for 'blur' events,
+     * or null when there is none.
+     */
+    relatedTarget;
+    constructor(type, relatedTarget = null) {
+        super(type, { bubbles: true, cancelable: false });
+        this.relatedTarget = relatedTarget;
+    }
+}

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

@@ -0,0 +1,72 @@
+import { type ParsedKey } from '../parse-keypress.js';
+import { Event } from './event.js';
+/**
+ * Boolean flags describing which named keys (arrows, modifiers, home/end,
+ * etc.) a parsed keypress reports as pressed.
+ */
+export type Key = {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    pageDown: boolean;
+    pageUp: boolean;
+    wheelUp: boolean;
+    wheelDown: boolean;
+    wheelLeft: boolean;
+    wheelRight: 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;
+    /**
+     * Pointer column (0-indexed) when the key is a wheel event — the SGR/X10
+     * sequence carries the position. Undefined for non-wheel keys.
+     */
+    mouseCol?: number;
+    /** Pointer row (0-indexed) when the key is a wheel event. See mouseCol. */
+    mouseRow?: number;
+    /**
+     * True when this input arrived as a bracketed paste (terminal paste —
+     * Ctrl+Shift+V / right-click / a terminal that intercepts Ctrl+V) rather
+     * than typed characters. Mirrors `InputEvent.isPasted` so modal handlers
+     * can treat a paste chunk as text without reaching for the third callback
+     * argument: pasted content — even a chunk that is all line breaks — is
+     * never an Enter/submit press. Optional so hand-built key literals (tests,
+     * synthetic dispatches) keep compiling; the live pipeline always sets it.
+     */
+    isPasted?: boolean;
+};
+/**
+ * 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 declare class InputEvent extends Event {
+    /**
+     * The raw parsed keypress this event was built from.
+     */
+    readonly keypress: ParsedKey;
+    /**
+     * Named-key flags describing which keys the keypress reports as pressed.
+     */
+    readonly key: Key;
+    /**
+     * The text input produced by this keypress ('' for non-printing keys).
+     */
+    readonly input: string;
+    /** 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. */
+    readonly isPasted: boolean;
+    constructor(keypress: ParsedKey);
+}
+//# sourceMappingURL=input-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/input-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAC1E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElC;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,EAAE,EAAE,OAAO,CAAA;IACX,GAAG,EAAE,OAAO,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AA4KD;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAA;IAE5B;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IAEjB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;wBAGoB;IACpB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;gBAEd,QAAQ,EAAE,SAAS;CAShC"}

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

@@ -0,0 +1,185 @@
+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',
+        wheelLeft: keypress.name === 'wheelleft',
+        wheelRight: keypress.name === 'wheelright',
+        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,
+        isPasted: keypress.isPasted === true,
+        mouseCol: keypress.mouseCol,
+        mouseRow: keypress.mouseRow,
+    };
+    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
+ * renderer 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
+ * renderer 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/pointer-event.d.ts

@@ -0,0 +1,61 @@
+import { TerminalEvent, type EventTarget } from './terminal-event.js';
+/**
+ * Pointer action reported by the terminal protocol.
+ *
+ * - `press`: a button went down (SGR `M` terminator / X10 press)
+ * - `release`: a button came up (SGR `m` terminator; X10 cannot report this)
+ * - `move`: pointer motion (SGR drag bit or mode-1003 no-button motion)
+ */
+export type PointerAction = 'press' | 'release' | 'move';
+/** Optional state when constructing a {@link PointerEvent}. */
+export type PointerEventInit = {
+    /** Raw protocol button byte (SGR bits: 0x04 shift, 0x08 alt, 0x10 ctrl). */
+    button?: number;
+    action?: PointerAction;
+    bubbles?: boolean;
+    cancelable?: boolean;
+};
+/**
+ * Base class for pointer-derived terminal events (click, wheel, hover).
+ *
+ * Carries the raw SGR/X10 button byte so handlers can read modifier flags
+ * (`shift`/`alt`/`ctrl`) without re-parsing the escape sequence, plus
+ * per-handler local coordinates: `_prepareForTarget` recomputes
+ * `localCol`/`localRow` from the nodeCache rect before each handler fires,
+ * so an onClick on a container sees coordinates relative to that container,
+ * not to the child the pointer actually landed on.
+ *
+ * `meta` is deliberately always false: xterm.js drops metaKey before SGR
+ * encoding (the SGR bit we call "meta" is wired to alt), so no pointer
+ * protocol can distinguish it reliably.
+ */
+export declare class PointerEvent extends TerminalEvent {
+    /** 0-indexed screen column of the pointer. */
+    readonly col: number;
+    /** 0-indexed screen row of the pointer. */
+    readonly row: number;
+    /** Raw protocol button byte (SGR encoding). */
+    readonly button: number;
+    /** Which pointer action produced this event. */
+    readonly action: PointerAction;
+    /** Shift held (SGR button bit 0x04). */
+    readonly shift: boolean;
+    /** Alt/Option held (SGR button bit 0x08). */
+    readonly alt: boolean;
+    /** Ctrl held (SGR button bit 0x10). */
+    readonly ctrl: boolean;
+    /** Always false — see class doc. */
+    readonly meta = false;
+    /** Column relative to the current handler's node (set during dispatch). */
+    localCol: number;
+    /** Row relative to the current handler's node (set during dispatch). */
+    localRow: number;
+    constructor(type: string, col: number, row: number, init?: PointerEventInit);
+    /**
+     * Refresh localCol/localRow for the node whose handler is about to run.
+     * Nodes without a cached rect (not rendered this frame) get 0,0 — handlers
+     * should prefer absolute col/row when that distinction matters.
+     */
+    _prepareForTarget(target: EventTarget): void;
+}
+//# sourceMappingURL=pointer-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pointer-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/pointer-event.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA;AAExD,+DAA+D;AAC/D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAa,SAAQ,aAAa;IAC7C,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,2CAA2C;IAC3C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;IAC9B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,6CAA6C;IAC7C,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,SAAQ;IACrB,2EAA2E;IAC3E,QAAQ,SAAI;IACZ,wEAAwE;IACxE,QAAQ,SAAI;gBAEA,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAc3E;;;;OAIG;IACM,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;CAKtD"}

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

@@ -0,0 +1,61 @@
+import { nodeCache } from '../node-cache.js';
+import { TerminalEvent } from './terminal-event.js';
+/**
+ * Base class for pointer-derived terminal events (click, wheel, hover).
+ *
+ * Carries the raw SGR/X10 button byte so handlers can read modifier flags
+ * (`shift`/`alt`/`ctrl`) without re-parsing the escape sequence, plus
+ * per-handler local coordinates: `_prepareForTarget` recomputes
+ * `localCol`/`localRow` from the nodeCache rect before each handler fires,
+ * so an onClick on a container sees coordinates relative to that container,
+ * not to the child the pointer actually landed on.
+ *
+ * `meta` is deliberately always false: xterm.js drops metaKey before SGR
+ * encoding (the SGR bit we call "meta" is wired to alt), so no pointer
+ * protocol can distinguish it reliably.
+ */
+export class PointerEvent extends TerminalEvent {
+    /** 0-indexed screen column of the pointer. */
+    col;
+    /** 0-indexed screen row of the pointer. */
+    row;
+    /** Raw protocol button byte (SGR encoding). */
+    button;
+    /** Which pointer action produced this event. */
+    action;
+    /** Shift held (SGR button bit 0x04). */
+    shift;
+    /** Alt/Option held (SGR button bit 0x08). */
+    alt;
+    /** Ctrl held (SGR button bit 0x10). */
+    ctrl;
+    /** Always false — see class doc. */
+    meta = false;
+    /** Column relative to the current handler's node (set during dispatch). */
+    localCol = 0;
+    /** Row relative to the current handler's node (set during dispatch). */
+    localRow = 0;
+    constructor(type, col, row, init) {
+        super(type, {
+            bubbles: init?.bubbles ?? true,
+            cancelable: init?.cancelable ?? true,
+        });
+        this.col = col;
+        this.row = row;
+        this.button = init?.button ?? 0;
+        this.action = init?.action ?? 'move';
+        this.shift = (this.button & 0x04) !== 0;
+        this.alt = (this.button & 0x08) !== 0;
+        this.ctrl = (this.button & 0x10) !== 0;
+    }
+    /**
+     * Refresh localCol/localRow for the node whose handler is about to run.
+     * Nodes without a cached rect (not rendered this frame) get 0,0 — handlers
+     * should prefer absolute col/row when that distinction matters.
+     */
+    _prepareForTarget(target) {
+        const rect = nodeCache.get(target);
+        this.localCol = rect ? this.col - rect.x : 0;
+        this.localRow = rect ? this.row - rect.y : 0;
+    }
+}

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 renderer; 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 renderer; 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;
+    }
+}