@askdkc/dsh-cli 0.11.3

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

@@ -0,0 +1,33 @@
+import { PointerEvent } from './pointer-event.js';
+/**
+ * Mouse click event. Fired on left-button release without drag, only when
+ * mouse tracking is enabled (i.e. inside <AlternateScreen>).
+ *
+ * Bubbles from the deepest hit node up through parentNode. Call
+ * stopImmediatePropagation() to prevent ancestors' onClick from firing.
+ *
+ * Extends PointerEvent: `shift`/`alt`/`ctrl` expose the modifiers the
+ * terminal reported on the release, and `localCol`/`localRow` are recomputed
+ * per handler so containers see coordinates relative to themselves.
+ */
+export class ClickEvent extends PointerEvent {
+    /**
+     * 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.
+     */
+    cellIsBlank;
+    constructor(col, row, cellIsBlank, init) {
+        // A click is by definition a left-button release without drag. Normalize
+        // the low button bits to 0 (left) while preserving modifier bits
+        // (0x04 shift / 0x08 alt / 0x10 ctrl) from the release byte.
+        const button = init?.button ?? 0;
+        super('click', col, row, {
+            ...init,
+            action: 'release',
+            button: button & ~0x03,
+        });
+        this.cellIsBlank = cellIsBlank;
+    }
+}

package/lib/types/ink/events/context-menu-event.d.ts

@@ -0,0 +1,19 @@
+import { PointerEvent, type PointerEventInit } from './pointer-event.js';
+/**
+ * Mouse context-menu event. Fired on right-button press (SGR button 2,
+ * low bits of the raw button byte), mirroring the DOM `contextmenu` event
+ * which shows on mousedown. Only works inside `<AlternateScreen>` where
+ * mouse tracking is enabled — right presses are ignored elsewhere.
+ *
+ * Bubbles from the deepest hit node up through parentNode. Call
+ * stopImmediatePropagation() to prevent ancestors' onContextMenu from
+ * firing.
+ *
+ * Carries the raw SGR button byte (`button`: low bits 2 = right button,
+ * with 0x04 shift / 0x08 alt / 0x10 ctrl modifier bits) plus absolute
+ * `col`/`row`, so a handler can anchor a popup menu at the pointer.
+ */
+export declare class ContextMenuEvent extends PointerEvent {
+    constructor(col: number, row: number, init?: PointerEventInit);
+}
+//# sourceMappingURL=context-menu-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/context-menu-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAExE;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;gBACpC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB;CAG9D"}

package/lib/types/ink/events/context-menu-event.js

@@ -0,0 +1,20 @@
+import { PointerEvent } from './pointer-event.js';
+/**
+ * Mouse context-menu event. Fired on right-button press (SGR button 2,
+ * low bits of the raw button byte), mirroring the DOM `contextmenu` event
+ * which shows on mousedown. Only works inside `<AlternateScreen>` where
+ * mouse tracking is enabled — right presses are ignored elsewhere.
+ *
+ * Bubbles from the deepest hit node up through parentNode. Call
+ * stopImmediatePropagation() to prevent ancestors' onContextMenu from
+ * firing.
+ *
+ * Carries the raw SGR button byte (`button`: low bits 2 = right button,
+ * with 0x04 shift / 0x08 alt / 0x10 ctrl modifier bits) plus absolute
+ * `col`/`row`, so a handler can anchor a popup menu at the pointer.
+ */
+export class ContextMenuEvent extends PointerEvent {
+    constructor(col, row, init) {
+        super('contextmenu', col, row, { ...init, action: 'press' });
+    }
+}

package/lib/types/ink/events/dispatcher.d.ts

@@ -0,0 +1,63 @@
+import type { EventTarget, TerminalEvent } from './terminal-event.js';
+type DiscreteUpdates = <A, B>(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 declare class Dispatcher {
+    /**
+     * The terminal event currently being dispatched, or null between dispatches.
+     */
+    currentEvent: TerminalEvent | null;
+    /**
+     * The update priority currently applied to updates triggered by dispatch,
+     * or the default priority when none is set.
+     */
+    currentUpdatePriority: number;
+    /**
+     * The reconciler's `discreteUpdates` helper, injected after construction to
+     * break the import cycle, or null before injection.
+     */
+    discreteUpdates: DiscreteUpdates | null;
+    /**
+     * Infer event priority from the currently-dispatching event.
+     * Called by the reconciler host config's resolveUpdatePriority
+     * when no explicit priority has been set.
+     * @returns the current update priority, the dispatching event's mapped
+     *   priority, or the default priority.
+     */
+    resolveEventPriority(): number;
+    /**
+     * Dispatch an event through capture and bubble phases.
+     * Returns true if preventDefault() was NOT called.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatch(target: EventTarget, event: TerminalEvent): boolean;
+    /**
+     * Dispatch with discrete (sync) priority.
+     * For user-initiated events: keyboard, click, focus, paste.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatchDiscrete(target: EventTarget, event: TerminalEvent): boolean;
+    /**
+     * Dispatch with continuous priority.
+     * For high-frequency events: resize, scroll, mouse move.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatchContinuous(target: EventTarget, event: TerminalEvent): boolean;
+}
+export {};
+//# sourceMappingURL=dispatcher.d.ts.map

package/lib/types/ink/events/dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/dispatcher.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAqIrE,KAAK,eAAe,GAAG,CAAC,CAAC,EAAE,CAAC,EAC1B,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,EAC3B,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,KACT,OAAO,CAAA;AAEZ;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACrB;;OAEG;IACH,YAAY,EAAE,aAAa,GAAG,IAAI,CAAO;IAEzC;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAiC;IAE9D;;;OAGG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAO;IAE9C;;;;;;OAMG;IACH,oBAAoB,IAAI,MAAM;IAU9B;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO;IAkB5D;;;;;;OAMG;IACH,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO;IAapE;;;;;;OAMG;IACH,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO;CASvE"}

package/lib/types/ink/events/dispatcher.js

@@ -0,0 +1,194 @@
+import { ContinuousEventPriority, DefaultEventPriority, DiscreteEventPriority, NoEventPriority, } from 'react-reconciler/constants.js';
+import { logError } from '../../utils/log.js';
+import { HANDLER_FOR_EVENT } from './event-handlers.js';
+function getHandler(node, eventType, capture) {
+    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];
+}
+/**
+ * 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, event) {
+    const listeners = [];
+    let node = 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, event) {
+    let previousNode;
+    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) {
+    switch (eventType) {
+        case 'keydown':
+        case 'keyup':
+        case 'click':
+        case 'focus':
+        case 'blur':
+        case 'paste':
+            return DiscreteEventPriority;
+        case 'resize':
+        case 'scroll':
+        case 'mousemove':
+            return ContinuousEventPriority;
+        default:
+            return DefaultEventPriority;
+    }
+}
+/**
+ * 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 {
+    /**
+     * The terminal event currently being dispatched, or null between dispatches.
+     */
+    currentEvent = null;
+    /**
+     * The update priority currently applied to updates triggered by dispatch,
+     * or the default priority when none is set.
+     */
+    currentUpdatePriority = DefaultEventPriority;
+    /**
+     * The reconciler's `discreteUpdates` helper, injected after construction to
+     * break the import cycle, or null before injection.
+     */
+    discreteUpdates = null;
+    /**
+     * Infer event priority from the currently-dispatching event.
+     * Called by the reconciler host config's resolveUpdatePriority
+     * when no explicit priority has been set.
+     * @returns the current update priority, the dispatching event's mapped
+     *   priority, or the default priority.
+     */
+    resolveEventPriority() {
+        if (this.currentUpdatePriority !== NoEventPriority) {
+            return this.currentUpdatePriority;
+        }
+        if (this.currentEvent) {
+            return getEventPriority(this.currentEvent.type);
+        }
+        return DefaultEventPriority;
+    }
+    /**
+     * Dispatch an event through capture and bubble phases.
+     * Returns true if preventDefault() was NOT called.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatch(target, event) {
+        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.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatchDiscrete(target, event) {
+        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.
+     * @param target - the node the event is dispatched to.
+     * @param event - the event to dispatch.
+     * @returns true when `preventDefault()` was not called on the event.
+     */
+    dispatchContinuous(target, event) {
+        const previousPriority = this.currentUpdatePriority;
+        try {
+            this.currentUpdatePriority = ContinuousEventPriority;
+            return this.dispatch(target, event);
+        }
+        finally {
+            this.currentUpdatePriority = previousPriority;
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+import { PointerEvent, type PointerEventInit } from './pointer-event.js';
+/**
+ * Which phase of a drag gesture the event represents — a subset of the
+ * DOM HTML5 drag event semantics:
+ *
+ * - `dragstart`: the pointer moved for the first time after a press on a
+ *   drag target (DOM fires dragstart on first move, not on press)
+ * - `dragmove`:   subsequent motion while the button stays held
+ * - `dragend`:    the button was released (or the session was interrupted
+ *   by focus loss / screen swap) after dragstart had fired
+ */
+export type DragEventType = 'dragstart' | 'dragmove' | 'dragend';
+/**
+ * Component-level drag event (DOM HTML5 drag semantics subset).
+ *
+ * A drag session opens on an unmodified LEFT-button press over a node
+ * whose ancestor chain carries an `onDragStart` handler, but stays
+ * dormant until the first drag motion — `dragstart` fires then, followed
+ * by `dragmove` on every further motion and `dragend` on release. A
+ * press+release without any movement never fires drag events and still
+ * resolves to a normal click (`onClick`). Modifier presses (shift/alt/
+ * ctrl) never open a drag session — they keep the baseline text-selection
+ * gesture. Only works inside `<AlternateScreen>` where mouse tracking is
+ * enabled.
+ *
+ * Bubbles from the captured drag target up through parentNode (the target
+ * is captured at press, so motion events keep going to it even when the
+ * pointer leaves its rect — like DOM element capture). Call
+ * `stopImmediatePropagation()` to prevent ancestors' handlers from
+ * firing.
+ *
+ * `col`/`row` are the current absolute pointer position (0-indexed);
+ * `startCol`/`startRow` is the press origin; `localCol`/`localRow` are
+ * recomputed per handler from the nodeCache rect so containers see
+ * coordinates relative to themselves.
+ */
+export declare class DragEvent extends PointerEvent {
+    /** 0-indexed screen column of the press that started this drag. */
+    readonly startCol: number;
+    /** 0-indexed screen row of the press that started this drag. */
+    readonly startRow: number;
+    constructor(type: DragEventType, col: number, row: number, startCol: number, startRow: number, init?: PointerEventInit);
+}
+//# sourceMappingURL=drag-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drag-event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/drag-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAExE;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,SAAU,SAAQ,YAAY;IACzC,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;gBAGvB,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,gBAAgB;CAS1B"}

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

@@ -0,0 +1,39 @@
+import { PointerEvent } from './pointer-event.js';
+/**
+ * Component-level drag event (DOM HTML5 drag semantics subset).
+ *
+ * A drag session opens on an unmodified LEFT-button press over a node
+ * whose ancestor chain carries an `onDragStart` handler, but stays
+ * dormant until the first drag motion — `dragstart` fires then, followed
+ * by `dragmove` on every further motion and `dragend` on release. A
+ * press+release without any movement never fires drag events and still
+ * resolves to a normal click (`onClick`). Modifier presses (shift/alt/
+ * ctrl) never open a drag session — they keep the baseline text-selection
+ * gesture. Only works inside `<AlternateScreen>` where mouse tracking is
+ * enabled.
+ *
+ * Bubbles from the captured drag target up through parentNode (the target
+ * is captured at press, so motion events keep going to it even when the
+ * pointer leaves its rect — like DOM element capture). Call
+ * `stopImmediatePropagation()` to prevent ancestors' handlers from
+ * firing.
+ *
+ * `col`/`row` are the current absolute pointer position (0-indexed);
+ * `startCol`/`startRow` is the press origin; `localCol`/`localRow` are
+ * recomputed per handler from the nodeCache rect so containers see
+ * coordinates relative to themselves.
+ */
+export class DragEvent extends PointerEvent {
+    /** 0-indexed screen column of the press that started this drag. */
+    startCol;
+    /** 0-indexed screen row of the press that started this drag. */
+    startRow;
+    constructor(type, col, row, startCol, startRow, init) {
+        super(type, col, row, {
+            ...init,
+            action: type === 'dragend' ? 'release' : 'move',
+        });
+        this.startCol = startCol;
+        this.startRow = startRow;
+    }
+}

package/lib/types/ink/events/emitter.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter as NodeEventEmitter } from 'events';
+/**
+ * Node-compatible event emitter that is aware of the `Event` class, so
+ * `emit` respects `stopImmediatePropagation()` on dispatched events.
+ */
+export declare class EventEmitter extends NodeEventEmitter {
+    constructor();
+    /**
+     * Emit an event to all registered listeners.
+     * `error` events delegate to Node's implementation; other events stop at the
+     * first listener that calls `stopImmediatePropagation()` on an `Event` first
+     * argument.
+     * @param type - the event name.
+     * @param args - arguments passed to each listener.
+     * @returns true when at least one listener received the event; false when
+     *   no listeners were registered, or Node's result for `error` events.
+     */
+    emit(type: string | symbol, ...args: unknown[]): boolean;
+}
+//# sourceMappingURL=emitter.d.ts.map

package/lib/types/ink/events/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/emitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AAGzD;;;GAGG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;;IAShD;;;;;;;;;OASG;IACM,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO;CAwBlE"}

package/lib/types/ink/events/emitter.js

@@ -0,0 +1,43 @@
+import { EventEmitter as NodeEventEmitter } from 'events';
+import { Event } from './event.js';
+/**
+ * Node-compatible event emitter that is aware of the `Event` class, so
+ * `emit` respects `stopImmediatePropagation()` on dispatched events.
+ */
+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);
+    }
+    /**
+     * Emit an event to all registered listeners.
+     * `error` events delegate to Node's implementation; other events stop at the
+     * first listener that calls `stopImmediatePropagation()` on an `Event` first
+     * argument.
+     * @param type - the event name.
+     * @param args - arguments passed to each listener.
+     * @returns true when at least one listener received the event; false when
+     *   no listeners were registered, or Node's result for `error` events.
+     */
+    emit(type, ...args) {
+        // 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;
+    }
+}

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

@@ -0,0 +1,65 @@
+import type { ClickEvent } from './click-event.js';
+import type { ContextMenuEvent } from './context-menu-event.js';
+import type { DragEvent } from './drag-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 { PointerEvent } from './pointer-event.js';
+import type { ResizeEvent } from './resize-event.js';
+import type { WheelEvent } from './wheel-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 ContextMenuEventHandler = (event: ContextMenuEvent) => void;
+type DragEventHandler = (event: DragEvent) => void;
+/**
+ * Hover handlers receive the pointer position. Existing `() => void`
+ * handlers remain assignable (a function taking fewer parameters is
+ * assignable to one taking more), so this widening is fully backwards
+ * compatible.
+ */
+type HoverEventHandler = (event: PointerEvent) => void;
+type WheelEventHandler = (event: WheelEvent) => 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;
+    onContextMenu?: ContextMenuEventHandler;
+    onDragStart?: DragEventHandler;
+    onDragMove?: DragEventHandler;
+    onDragEnd?: DragEventHandler;
+    onMouseEnter?: HoverEventHandler;
+    onMouseLeave?: HoverEventHandler;
+    onWheel?: WheelEventHandler;
+};
+/**
+ * Reverse lookup: event type string → handler prop names.
+ * Used by the dispatcher for O(1) handler lookup per node.
+ */
+export declare const HANDLER_FOR_EVENT: Record<string, {
+    bubble?: keyof EventHandlerProps;
+    capture?: keyof EventHandlerProps;
+}>;
+/**
+ * Set of all event handler prop names, for the reconciler to detect
+ * event props and store them in _eventHandlers instead of attributes.
+ */
+export declare const EVENT_HANDLER_PROPS: Set<string>;
+export {};
+//# sourceMappingURL=event-handlers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event-handlers.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/event-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,KAAK,oBAAoB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;AAC1D,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AACpD,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AACpD,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAA;AACtD,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AACpD,KAAK,uBAAuB,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAA;AAChE,KAAK,gBAAgB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;AAClD;;;;;GAKG;AACH,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;AACtD,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,CAAC,EAAE,oBAAoB,CAAA;IAChC,gBAAgB,CAAC,EAAE,oBAAoB,CAAA;IAEvC,OAAO,CAAC,EAAE,iBAAiB,CAAA;IAC3B,cAAc,CAAC,EAAE,iBAAiB,CAAA;IAClC,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,aAAa,CAAC,EAAE,iBAAiB,CAAA;IAEjC,OAAO,CAAC,EAAE,iBAAiB,CAAA;IAC3B,cAAc,CAAC,EAAE,iBAAiB,CAAA;IAElC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAE7B,OAAO,CAAC,EAAE,iBAAiB,CAAA;IAC3B,aAAa,CAAC,EAAE,uBAAuB,CAAA;IACvC,WAAW,CAAC,EAAE,gBAAgB,CAAA;IAC9B,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAC7B,SAAS,CAAC,EAAE,gBAAgB,CAAA;IAC5B,YAAY,CAAC,EAAE,iBAAiB,CAAA;IAChC,YAAY,CAAC,EAAE,iBAAiB,CAAA;IAChC,OAAO,CAAC,EAAE,iBAAiB,CAAA;CAC5B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CACpC,MAAM,EACN;IAAE,MAAM,CAAC,EAAE,MAAM,iBAAiB,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,iBAAiB,CAAA;CAAE,CAaxE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aAkB9B,CAAA"}

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

@@ -0,0 +1,40 @@
+/**
+ * Reverse lookup: event type string → handler prop names.
+ * Used by the dispatcher for O(1) handler lookup per node.
+ */
+export const HANDLER_FOR_EVENT = {
+    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' },
+    contextmenu: { bubble: 'onContextMenu' },
+    dragstart: { bubble: 'onDragStart' },
+    dragmove: { bubble: 'onDragMove' },
+    dragend: { bubble: 'onDragEnd' },
+    wheel: { bubble: 'onWheel' },
+};
+/**
+ * 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',
+    'onContextMenu',
+    'onDragStart',
+    'onDragMove',
+    'onDragEnd',
+    'onMouseEnter',
+    'onMouseLeave',
+    'onWheel',
+]);

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

@@ -0,0 +1,19 @@
+/**
+ * Base class for events with immediate-propagation control.
+ *
+ * `stopImmediatePropagation()` marks the event so the emitter stops invoking
+ * any further listeners for it.
+ */
+export declare class Event {
+    private _didStopImmediatePropagation;
+    /**
+     * Whether `stopImmediatePropagation()` was called on this event.
+     * @returns true when immediate propagation has been stopped.
+     */
+    didStopImmediatePropagation(): boolean;
+    /**
+     * Stop the emitter from invoking any further listeners for this event.
+     */
+    stopImmediatePropagation(): void;
+}
+//# sourceMappingURL=event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../../src/ink/events/event.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,4BAA4B,CAAQ;IAE5C;;;OAGG;IACH,2BAA2B,IAAI,OAAO;IAItC;;OAEG;IACH,wBAAwB,IAAI,IAAI;CAGjC"}

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

@@ -0,0 +1,22 @@
+/**
+ * Base class for events with immediate-propagation control.
+ *
+ * `stopImmediatePropagation()` marks the event so the emitter stops invoking
+ * any further listeners for it.
+ */
+export class Event {
+    _didStopImmediatePropagation = false;
+    /**
+     * Whether `stopImmediatePropagation()` was called on this event.
+     * @returns true when immediate propagation has been stopped.
+     */
+    didStopImmediatePropagation() {
+        return this._didStopImmediatePropagation;
+    }
+    /**
+     * Stop the emitter from invoking any further listeners for this event.
+     */
+    stopImmediatePropagation() {
+        this._didStopImmediatePropagation = true;
+    }
+}