@iaforged/context-code 1.0.62 → 1.0.65

package/dist/src/ink/events/input-event.js

@@ -1,161 +0,0 @@
-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];
-}
-export class InputEvent extends Event {
-    keypress;
-    key;
-    input;
-    constructor(keypress) {
-        super();
-        const [key, input] = parseKey(keypress);
-        this.keypress = keypress;
-        this.key = key;
-        this.input = input;
-    }
-}

package/dist/src/ink/events/keyboard-event.js

@@ -1,45 +0,0 @@
-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 {
-    key;
-    ctrl;
-    shift;
-    meta;
-    superKey;
-    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/dist/src/ink/events/terminal-event.js

@@ -1,78 +0,0 @@
-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 {
-    type;
-    timeStamp;
-    bubbles;
-    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;
-    }
-    get target() {
-        return this._target;
-    }
-    get currentTarget() {
-        return this._currentTarget;
-    }
-    get eventPhase() {
-        return this._eventPhase;
-    }
-    get defaultPrevented() {
-        return this._defaultPrevented;
-    }
-    stopPropagation() {
-        this._propagationStopped = true;
-    }
-    stopImmediatePropagation() {
-        super.stopImmediatePropagation();
-        this._propagationStopped = true;
-    }
-    preventDefault() {
-        if (this.cancelable) {
-            this._defaultPrevented = true;
-        }
-    }
-    // -- Internal setters used by the Dispatcher
-    /** @internal */
-    _setTarget(target) {
-        this._target = target;
-    }
-    /** @internal */
-    _setCurrentTarget(target) {
-        this._currentTarget = target;
-    }
-    /** @internal */
-    _setEventPhase(phase) {
-        this._eventPhase = phase;
-    }
-    /** @internal */
-    _isPropagationStopped() {
-        return this._propagationStopped;
-    }
-    /** @internal */
-    _isImmediatePropagationStopped() {
-        return this.didStopImmediatePropagation();
-    }
-    /**
-     * Hook for subclasses to do per-node setup before each handler fires.
-     * Default is a no-op.
-     */
-    _prepareForTarget(_target) { }
-}

package/dist/src/ink/events/terminal-focus-event.js

@@ -1,15 +0,0 @@
-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 {
-    type;
-    constructor(type) {
-        super();
-        this.type = type;
-    }
-}

package/dist/src/ink/focus.js

@@ -1,158 +0,0 @@
-import { FocusEvent } from './events/focus-event.js';
-const MAX_FOCUS_STACK = 32;
-/**
- * DOM-like focus manager for the Ink terminal UI.
- *
- * Pure state — tracks activeElement and a focus stack. Has no reference
- * to the tree; callers pass the root when tree walks are needed.
- *
- * Stored on the root DOMElement so any node can reach it by walking
- * parentNode (like browser's `node.ownerDocument`).
- */
-export class FocusManager {
-    activeElement = null;
-    dispatchFocusEvent;
-    enabled = true;
-    focusStack = [];
-    constructor(dispatchFocusEvent) {
-        this.dispatchFocusEvent = dispatchFocusEvent;
-    }
-    focus(node) {
-        if (node === this.activeElement)
-            return;
-        if (!this.enabled)
-            return;
-        const previous = this.activeElement;
-        if (previous) {
-            // Deduplicate before pushing to prevent unbounded growth from Tab cycling
-            const idx = this.focusStack.indexOf(previous);
-            if (idx !== -1)
-                this.focusStack.splice(idx, 1);
-            this.focusStack.push(previous);
-            if (this.focusStack.length > MAX_FOCUS_STACK)
-                this.focusStack.shift();
-            this.dispatchFocusEvent(previous, new FocusEvent('blur', node));
-        }
-        this.activeElement = node;
-        this.dispatchFocusEvent(node, new FocusEvent('focus', previous));
-    }
-    blur() {
-        if (!this.activeElement)
-            return;
-        const previous = this.activeElement;
-        this.activeElement = null;
-        this.dispatchFocusEvent(previous, new FocusEvent('blur', null));
-    }
-    /**
-     * Called by the reconciler when a node is removed from the tree.
-     * Handles both the exact node and any focused descendant within
-     * the removed subtree. Dispatches blur and restores focus from stack.
-     */
-    handleNodeRemoved(node, root) {
-        // Remove the node and any descendants from the stack
-        this.focusStack = this.focusStack.filter(n => n !== node && isInTree(n, root));
-        // Check if activeElement is the removed node OR a descendant
-        if (!this.activeElement)
-            return;
-        if (this.activeElement !== node && isInTree(this.activeElement, root)) {
-            return;
-        }
-        const removed = this.activeElement;
-        this.activeElement = null;
-        this.dispatchFocusEvent(removed, new FocusEvent('blur', null));
-        // Restore focus to the most recent still-mounted element
-        while (this.focusStack.length > 0) {
-            const candidate = this.focusStack.pop();
-            if (isInTree(candidate, root)) {
-                this.activeElement = candidate;
-                this.dispatchFocusEvent(candidate, new FocusEvent('focus', removed));
-                return;
-            }
-        }
-    }
-    handleAutoFocus(node) {
-        this.focus(node);
-    }
-    handleClickFocus(node) {
-        const tabIndex = node.attributes['tabIndex'];
-        if (typeof tabIndex !== 'number')
-            return;
-        this.focus(node);
-    }
-    enable() {
-        this.enabled = true;
-    }
-    disable() {
-        this.enabled = false;
-    }
-    focusNext(root) {
-        this.moveFocus(1, root);
-    }
-    focusPrevious(root) {
-        this.moveFocus(-1, root);
-    }
-    moveFocus(direction, root) {
-        if (!this.enabled)
-            return;
-        const tabbable = collectTabbable(root);
-        if (tabbable.length === 0)
-            return;
-        const currentIndex = this.activeElement
-            ? tabbable.indexOf(this.activeElement)
-            : -1;
-        const nextIndex = currentIndex === -1
-            ? direction === 1
-                ? 0
-                : tabbable.length - 1
-            : (currentIndex + direction + tabbable.length) % tabbable.length;
-        const next = tabbable[nextIndex];
-        if (next) {
-            this.focus(next);
-        }
-    }
-}
-function collectTabbable(root) {
-    const result = [];
-    walkTree(root, result);
-    return result;
-}
-function walkTree(node, result) {
-    const tabIndex = node.attributes['tabIndex'];
-    if (typeof tabIndex === 'number' && tabIndex >= 0) {
-        result.push(node);
-    }
-    for (const child of node.childNodes) {
-        if (child.nodeName !== '#text') {
-            walkTree(child, result);
-        }
-    }
-}
-function isInTree(node, root) {
-    let current = node;
-    while (current) {
-        if (current === root)
-            return true;
-        current = current.parentNode;
-    }
-    return false;
-}
-/**
- * Walk up to root and return it. The root is the node that holds
- * the FocusManager — like browser's `node.getRootNode()`.
- */
-export function getRootNode(node) {
-    let current = node;
-    while (current) {
-        if (current.focusManager)
-            return current;
-        current = current.parentNode;
-    }
-    throw new Error('Node is not in a tree with a FocusManager');
-}
-/**
- * Walk up to root and return its FocusManager.
- * Like browser's `node.ownerDocument` — focus belongs to the root.
- */
-export function getFocusManager(node) {
-    return getRootNode(node).focusManager;
-}

package/dist/src/ink/frame.js

@@ -1,30 +0,0 @@
-import { createScreen, } from './screen.js';
-export function emptyFrame(rows, columns, stylePool, charPool, hyperlinkPool) {
-    return {
-        screen: createScreen(0, 0, stylePool, charPool, hyperlinkPool),
-        viewport: { width: columns, height: rows },
-        cursor: { x: 0, y: 0, visible: true },
-    };
-}
-/**
- * Determines whether the screen should be cleared based on the current and previous frame.
- * Returns the reason for clearing, or undefined if no clear is needed.
- *
- * Screen clearing is triggered when:
- * 1. Terminal has been resized (viewport dimensions changed) → 'resize'
- * 2. Current frame screen height exceeds available terminal rows → 'offscreen'
- * 3. Previous frame screen height exceeded available terminal rows → 'offscreen'
- */
-export function shouldClearScreen(prevFrame, frame) {
-    const didResize = frame.viewport.height !== prevFrame.viewport.height ||
-        frame.viewport.width !== prevFrame.viewport.width;
-    if (didResize) {
-        return 'resize';
-    }
-    const currentFrameOverflows = frame.screen.height >= frame.viewport.height;
-    const previousFrameOverflowed = prevFrame.screen.height >= prevFrame.viewport.height;
-    if (currentFrameOverflows || previousFrameOverflowed) {
-        return 'offscreen';
-    }
-    return undefined;
-}

package/dist/src/ink/get-max-width.js

@@ -1,23 +0,0 @@
-import { LayoutEdge } from './layout/node.js';
-/**
- * Returns the yoga node's content width (computed width minus padding and
- * border).
- *
- * Warning: can return a value WIDER than the parent container. In a
- * column-direction flex parent, width is the cross axis — align-items:
- * stretch never shrinks children below their intrinsic size, so the text
- * node overflows (standard CSS behavior). Yoga measures leaf nodes in two
- * passes: the AtMost pass determines width, the Exactly pass determines
- * height. getComputedWidth() reflects the wider AtMost result while
- * getComputedHeight() reflects the narrower Exactly result. Callers that
- * use this for wrapping should clamp to actual available screen space so
- * the rendered line count stays consistent with the layout height.
- */
-const getMaxWidth = (yogaNode) => {
-    return (yogaNode.getComputedWidth() -
-        yogaNode.getComputedPadding(LayoutEdge.Left) -
-        yogaNode.getComputedPadding(LayoutEdge.Right) -
-        yogaNode.getComputedBorder(LayoutEdge.Left) -
-        yogaNode.getComputedBorder(LayoutEdge.Right));
-};
-export default getMaxWidth;

package/dist/src/ink/hit-test.js

@@ -1,113 +0,0 @@
-import { ClickEvent } from './events/click-event.js';
-import { nodeCache } from './node-cache.js';
-/**
- * Find the deepest DOM element whose rendered rect contains (col, row).
- *
- * Uses the nodeCache populated by renderNodeToOutput — rects are in screen
- * coordinates with all offsets (including scrollTop translation) already
- * applied. Children are traversed in reverse so later siblings (painted on
- * top) win. Nodes not in nodeCache (not rendered this frame, or lacking a
- * yogaNode) are skipped along with their subtrees.
- *
- * Returns the hit node even if it has no onClick — dispatchClick walks up
- * via parentNode to find handlers.
- */
-export function hitTest(node, col, row) {
-    const rect = nodeCache.get(node);
-    if (!rect)
-        return null;
-    if (col < rect.x ||
-        col >= rect.x + rect.width ||
-        row < rect.y ||
-        row >= rect.y + rect.height) {
-        return null;
-    }
-    // Later siblings paint on top; reversed traversal returns topmost hit.
-    for (let i = node.childNodes.length - 1; i >= 0; i--) {
-        const child = node.childNodes[i];
-        if (child.nodeName === '#text')
-            continue;
-        const hit = hitTest(child, col, row);
-        if (hit)
-            return hit;
-    }
-    return node;
-}
-/**
- * Hit-test the root at (col, row) and bubble a ClickEvent from the deepest
- * containing node up through parentNode. Only nodes with an onClick handler
- * fire. Stops when a handler calls stopImmediatePropagation(). Returns
- * true if at least one onClick handler fired.
- */
-export function dispatchClick(root, col, row, cellIsBlank = false) {
-    let target = hitTest(root, col, row) ?? undefined;
-    if (!target)
-        return false;
-    // Click-to-focus: find the closest focusable ancestor and focus it.
-    // root is always ink-root, which owns the FocusManager.
-    if (root.focusManager) {
-        let focusTarget = target;
-        while (focusTarget) {
-            if (typeof focusTarget.attributes['tabIndex'] === 'number') {
-                root.focusManager.handleClickFocus(focusTarget);
-                break;
-            }
-            focusTarget = focusTarget.parentNode;
-        }
-    }
-    const event = new ClickEvent(col, row, cellIsBlank);
-    let handled = false;
-    while (target) {
-        const handler = target._eventHandlers?.onClick;
-        if (handler) {
-            handled = true;
-            const rect = nodeCache.get(target);
-            if (rect) {
-                event.localCol = col - rect.x;
-                event.localRow = row - rect.y;
-            }
-            handler(event);
-            if (event.didStopImmediatePropagation())
-                return true;
-        }
-        target = target.parentNode;
-    }
-    return handled;
-}
-/**
- * Fire onMouseEnter/onMouseLeave as the pointer moves. Like DOM
- * mouseenter/mouseleave: does NOT bubble — moving between children does
- * not re-fire on the parent. Walks up from the hit node collecting every
- * ancestor with a hover handler; diffs against the previous hovered set;
- * fires leave on the nodes exited, enter on the nodes entered.
- *
- * Mutates `hovered` in place so the caller (App instance) can hold it
- * across calls. Clears the set when the hit is null (cursor moved into a
- * non-rendered gap or off the root rect).
- */
-export function dispatchHover(root, col, row, hovered) {
-    const next = new Set();
-    let node = hitTest(root, col, row) ?? undefined;
-    while (node) {
-        const h = node._eventHandlers;
-        if (h?.onMouseEnter || h?.onMouseLeave)
-            next.add(node);
-        node = node.parentNode;
-    }
-    for (const old of hovered) {
-        if (!next.has(old)) {
-            hovered.delete(old);
-            // Skip handlers on detached nodes (removed between mouse events)
-            if (old.parentNode) {
-                ;
-                old._eventHandlers?.onMouseLeave?.();
-            }
-        }
-    }
-    for (const n of next) {
-        if (!hovered.has(n)) {
-            hovered.add(n);
-            n._eventHandlers?.onMouseEnter?.();
-        }
-    }
-}

package/dist/src/ink/hooks/use-animation-frame.js

@@ -1,48 +0,0 @@
-import { useContext, useEffect, useState } from 'react';
-import { ClockContext } from '../components/ClockContext.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 <Box ref={ref}>{FRAMES[frame]}</Box>
- * }
- *
- * The clock automatically slows when the terminal is blurred,
- * so consumers don't need to handle focus state.
- */
-export function useAnimationFrame(intervalMs = 16) {
-    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 = () => {
-            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];
-}

package/dist/src/ink/hooks/use-app.js

@@ -1,7 +0,0 @@
-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;