@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/components/Box.d.ts

@@ -0,0 +1,49 @@
+import { type Ref } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { ClickEvent } from '../events/click-event.js';
+import type { FocusEvent } from '../events/focus-event.js';
+import type { KeyboardEvent } from '../events/keyboard-event.js';
+import type { Styles } from '../styles.js';
+export type Props = Except<Styles, 'textWrap'> & {
+    ref?: Ref<DOMElement>;
+    /**
+     * Tab order index. Nodes with `tabIndex >= 0` participate in
+     * Tab/Shift+Tab cycling; `-1` means programmatically focusable only.
+     */
+    tabIndex?: number;
+    /**
+     * Focus this element when it mounts. Like the HTML `autofocus`
+     * attribute — the FocusManager calls `focus(node)` during the
+     * reconciler's `commitMount` phase.
+     */
+    autoFocus?: boolean;
+    /**
+     * Fired on left-button click (press + release without drag). Only works
+     * inside `<AlternateScreen>` where mouse tracking is enabled — no-op
+     * otherwise. The event bubbles from the deepest hit Box up through
+     * ancestors; call `event.stopImmediatePropagation()` to stop bubbling.
+     */
+    onClick?: (event: ClickEvent) => void;
+    onFocus?: (event: FocusEvent) => void;
+    onFocusCapture?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+    onBlurCapture?: (event: FocusEvent) => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+    onKeyDownCapture?: (event: KeyboardEvent) => void;
+    /**
+     * Fired when the mouse moves into this Box's rendered rect. Like DOM
+     * `mouseenter`, does NOT bubble — moving between children does not
+     * re-fire on the parent. Only works inside `<AlternateScreen>` where
+     * mode-1003 mouse tracking is enabled.
+     */
+    onMouseEnter?: () => void;
+    /** Fired when the mouse moves out of this Box's rendered rect. */
+    onMouseLeave?: () => void;
+};
+/**
+ * `<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
+ */
+declare function Box(t0: any): any;
+export default Box;
+//# sourceMappingURL=Box.d.ts.map

package/lib/types/ink/components/Box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Box.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/Box.tsx"],"names":[],"mappings":"AACA,OAAc,EAA0B,KAAK,GAAG,EAAE,MAAM,OAAO,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG;IAC/C,GAAG,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC7C,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACrC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAC3C,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAClD;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,iBAAS,GAAG,CAAC,EAAE,KAAA,OAiKd;AACD,eAAe,GAAG,CAAC"}

package/lib/types/ink/components/Box.js

@@ -0,0 +1,153 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import * as warn from '../warn.js';
+/**
+ * `<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
+ */
+function Box(t0) {
+    const $ = _c(42);
+    let autoFocus;
+    let children;
+    let flexDirection;
+    let flexGrow;
+    let flexShrink;
+    let flexWrap;
+    let onBlur;
+    let onBlurCapture;
+    let onClick;
+    let onFocus;
+    let onFocusCapture;
+    let onKeyDown;
+    let onKeyDownCapture;
+    let onMouseEnter;
+    let onMouseLeave;
+    let ref;
+    let style;
+    let tabIndex;
+    if ($[0] !== t0) {
+        const { children: t1, flexWrap: t2, flexDirection: t3, flexGrow: t4, flexShrink: t5, ref: t6, tabIndex: t7, autoFocus: t8, onClick: t9, onFocus: t10, onFocusCapture: t11, onBlur: t12, onBlurCapture: t13, onMouseEnter: t14, onMouseLeave: t15, onKeyDown: t16, onKeyDownCapture: t17, ...t18 } = t0;
+        children = t1;
+        ref = t6;
+        tabIndex = t7;
+        autoFocus = t8;
+        onClick = t9;
+        onFocus = t10;
+        onFocusCapture = t11;
+        onBlur = t12;
+        onBlurCapture = t13;
+        onMouseEnter = t14;
+        onMouseLeave = t15;
+        onKeyDown = t16;
+        onKeyDownCapture = t17;
+        style = t18;
+        flexWrap = t2 === undefined ? "nowrap" : t2;
+        flexDirection = t3 === undefined ? "row" : t3;
+        flexGrow = t4 === undefined ? 0 : t4;
+        flexShrink = t5 === undefined ? 1 : t5;
+        warn.ifNotInteger(style.margin, "margin");
+        warn.ifNotInteger(style.marginX, "marginX");
+        warn.ifNotInteger(style.marginY, "marginY");
+        warn.ifNotInteger(style.marginTop, "marginTop");
+        warn.ifNotInteger(style.marginBottom, "marginBottom");
+        warn.ifNotInteger(style.marginLeft, "marginLeft");
+        warn.ifNotInteger(style.marginRight, "marginRight");
+        warn.ifNotInteger(style.padding, "padding");
+        warn.ifNotInteger(style.paddingX, "paddingX");
+        warn.ifNotInteger(style.paddingY, "paddingY");
+        warn.ifNotInteger(style.paddingTop, "paddingTop");
+        warn.ifNotInteger(style.paddingBottom, "paddingBottom");
+        warn.ifNotInteger(style.paddingLeft, "paddingLeft");
+        warn.ifNotInteger(style.paddingRight, "paddingRight");
+        warn.ifNotInteger(style.gap, "gap");
+        warn.ifNotInteger(style.columnGap, "columnGap");
+        warn.ifNotInteger(style.rowGap, "rowGap");
+        $[0] = t0;
+        $[1] = autoFocus;
+        $[2] = children;
+        $[3] = flexDirection;
+        $[4] = flexGrow;
+        $[5] = flexShrink;
+        $[6] = flexWrap;
+        $[7] = onBlur;
+        $[8] = onBlurCapture;
+        $[9] = onClick;
+        $[10] = onFocus;
+        $[11] = onFocusCapture;
+        $[12] = onKeyDown;
+        $[13] = onKeyDownCapture;
+        $[14] = onMouseEnter;
+        $[15] = onMouseLeave;
+        $[16] = ref;
+        $[17] = style;
+        $[18] = tabIndex;
+    }
+    else {
+        autoFocus = $[1];
+        children = $[2];
+        flexDirection = $[3];
+        flexGrow = $[4];
+        flexShrink = $[5];
+        flexWrap = $[6];
+        onBlur = $[7];
+        onBlurCapture = $[8];
+        onClick = $[9];
+        onFocus = $[10];
+        onFocusCapture = $[11];
+        onKeyDown = $[12];
+        onKeyDownCapture = $[13];
+        onMouseEnter = $[14];
+        onMouseLeave = $[15];
+        ref = $[16];
+        style = $[17];
+        tabIndex = $[18];
+    }
+    const t1 = style.overflowX ?? style.overflow ?? "visible";
+    const t2 = style.overflowY ?? style.overflow ?? "visible";
+    let t3;
+    if ($[19] !== flexDirection || $[20] !== flexGrow || $[21] !== flexShrink || $[22] !== flexWrap || $[23] !== style || $[24] !== t1 || $[25] !== t2) {
+        t3 = {
+            flexWrap,
+            flexDirection,
+            flexGrow,
+            flexShrink,
+            ...style,
+            overflowX: t1,
+            overflowY: t2
+        };
+        $[19] = flexDirection;
+        $[20] = flexGrow;
+        $[21] = flexShrink;
+        $[22] = flexWrap;
+        $[23] = style;
+        $[24] = t1;
+        $[25] = t2;
+        $[26] = t3;
+    }
+    else {
+        t3 = $[26];
+    }
+    let t4;
+    if ($[27] !== autoFocus || $[28] !== children || $[29] !== onBlur || $[30] !== onBlurCapture || $[31] !== onClick || $[32] !== onFocus || $[33] !== onFocusCapture || $[34] !== onKeyDown || $[35] !== onKeyDownCapture || $[36] !== onMouseEnter || $[37] !== onMouseLeave || $[38] !== ref || $[39] !== t3 || $[40] !== tabIndex) {
+        t4 = _jsx("ink-box", { ref: ref, tabIndex: tabIndex, autoFocus: autoFocus, onClick: onClick, onFocus: onFocus, onFocusCapture: onFocusCapture, onBlur: onBlur, onBlurCapture: onBlurCapture, onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave, onKeyDown: onKeyDown, onKeyDownCapture: onKeyDownCapture, style: t3, children: children });
+        $[27] = autoFocus;
+        $[28] = children;
+        $[29] = onBlur;
+        $[30] = onBlurCapture;
+        $[31] = onClick;
+        $[32] = onFocus;
+        $[33] = onFocusCapture;
+        $[34] = onKeyDown;
+        $[35] = onKeyDownCapture;
+        $[36] = onMouseEnter;
+        $[37] = onMouseLeave;
+        $[38] = ref;
+        $[39] = t3;
+        $[40] = tabIndex;
+        $[41] = t4;
+    }
+    else {
+        t4 = $[41];
+    }
+    return t4;
+}
+export default Box;

package/lib/types/ink/components/Button.d.ts

@@ -0,0 +1,37 @@
+import React, { type Ref } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { Styles } from '../styles.js';
+type ButtonState = {
+    focused: boolean;
+    hovered: boolean;
+    active: boolean;
+};
+export type Props = Except<Styles, 'textWrap'> & {
+    ref?: Ref<DOMElement>;
+    /**
+     * Called when the button is activated via Enter, Space, or click.
+     */
+    onAction: () => void;
+    /**
+     * Tab order index. Defaults to 0 (in tab order).
+     * Set to -1 for programmatically focusable only.
+     */
+    tabIndex?: number;
+    /**
+     * Focus this button when it mounts.
+     */
+    autoFocus?: boolean;
+    /**
+     * Render prop receiving the interactive state. Use this to
+     * style children based on focus/hover/active — Button itself
+     * is intentionally unstyled.
+     *
+     * If not provided, children render as-is (no state-dependent styling).
+     */
+    children: ((state: ButtonState) => React.ReactNode) | React.ReactNode;
+};
+declare function Button(t0: any): any;
+export default Button;
+export type { ButtonState };
+//# sourceMappingURL=Button.d.ts.map

package/lib/types/ink/components/Button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Button.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/Button.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,KAAK,GAAG,EAA4C,MAAM,OAAO,CAAC;AAClF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAI5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AACF,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG;IAC/C,GAAG,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IACtB;;OAEG;IACH,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,WAAW,KAAK,KAAK,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC;CACvE,CAAC;AACF,iBAAS,MAAM,CAAC,EAAE,KAAA,OAmJjB;AAID,eAAe,MAAM,CAAC;AACtB,YAAY,EAAE,WAAW,EAAE,CAAC"}

package/lib/types/ink/components/Button.js

@@ -0,0 +1,166 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { useEffect, useRef, useState } from 'react';
+import Box from './Box.js';
+function Button(t0) {
+    const $ = _c(30);
+    let autoFocus;
+    let children;
+    let onAction;
+    let ref;
+    let style;
+    let t1;
+    if ($[0] !== t0) {
+        ({
+            onAction,
+            tabIndex: t1,
+            autoFocus,
+            children,
+            ref,
+            ...style
+        } = t0);
+        $[0] = t0;
+        $[1] = autoFocus;
+        $[2] = children;
+        $[3] = onAction;
+        $[4] = ref;
+        $[5] = style;
+        $[6] = t1;
+    }
+    else {
+        autoFocus = $[1];
+        children = $[2];
+        onAction = $[3];
+        ref = $[4];
+        style = $[5];
+        t1 = $[6];
+    }
+    const tabIndex = t1 === undefined ? 0 : t1;
+    const [isFocused, setIsFocused] = useState(false);
+    const [isHovered, setIsHovered] = useState(false);
+    const [isActive, setIsActive] = useState(false);
+    const activeTimer = useRef(null);
+    let t2;
+    let t3;
+    if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+        t2 = () => () => {
+            if (activeTimer.current) {
+                clearTimeout(activeTimer.current);
+            }
+        };
+        t3 = [];
+        $[7] = t2;
+        $[8] = t3;
+    }
+    else {
+        t2 = $[7];
+        t3 = $[8];
+    }
+    useEffect(t2, t3);
+    let t4;
+    if ($[9] !== onAction) {
+        t4 = e => {
+            if (e.key === "return" || e.key === " ") {
+                e.preventDefault();
+                setIsActive(true);
+                onAction();
+                if (activeTimer.current) {
+                    clearTimeout(activeTimer.current);
+                }
+                activeTimer.current = setTimeout(_temp, 100, setIsActive);
+            }
+        };
+        $[9] = onAction;
+        $[10] = t4;
+    }
+    else {
+        t4 = $[10];
+    }
+    const handleKeyDown = t4;
+    let t5;
+    if ($[11] !== onAction) {
+        t5 = _e => {
+            onAction();
+        };
+        $[11] = onAction;
+        $[12] = t5;
+    }
+    else {
+        t5 = $[12];
+    }
+    const handleClick = t5;
+    let t6;
+    if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+        t6 = _e_0 => setIsFocused(true);
+        $[13] = t6;
+    }
+    else {
+        t6 = $[13];
+    }
+    const handleFocus = t6;
+    let t7;
+    if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+        t7 = _e_1 => setIsFocused(false);
+        $[14] = t7;
+    }
+    else {
+        t7 = $[14];
+    }
+    const handleBlur = t7;
+    let t8;
+    if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+        t8 = () => setIsHovered(true);
+        $[15] = t8;
+    }
+    else {
+        t8 = $[15];
+    }
+    const handleMouseEnter = t8;
+    let t9;
+    if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+        t9 = () => setIsHovered(false);
+        $[16] = t9;
+    }
+    else {
+        t9 = $[16];
+    }
+    const handleMouseLeave = t9;
+    let t10;
+    if ($[17] !== children || $[18] !== isActive || $[19] !== isFocused || $[20] !== isHovered) {
+        const state = {
+            focused: isFocused,
+            hovered: isHovered,
+            active: isActive
+        };
+        t10 = typeof children === "function" ? children(state) : children;
+        $[17] = children;
+        $[18] = isActive;
+        $[19] = isFocused;
+        $[20] = isHovered;
+        $[21] = t10;
+    }
+    else {
+        t10 = $[21];
+    }
+    const content = t10;
+    let t11;
+    if ($[22] !== autoFocus || $[23] !== content || $[24] !== handleClick || $[25] !== handleKeyDown || $[26] !== ref || $[27] !== style || $[28] !== tabIndex) {
+        t11 = _jsx(Box, { ref: ref, tabIndex: tabIndex, autoFocus: autoFocus, onKeyDown: handleKeyDown, onClick: handleClick, onFocus: handleFocus, onBlur: handleBlur, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, ...style, children: content });
+        $[22] = autoFocus;
+        $[23] = content;
+        $[24] = handleClick;
+        $[25] = handleKeyDown;
+        $[26] = ref;
+        $[27] = style;
+        $[28] = tabIndex;
+        $[29] = t11;
+    }
+    else {
+        t11 = $[29];
+    }
+    return t11;
+}
+function _temp(setter) {
+    return setter(false);
+}
+export default Button;

package/lib/types/ink/components/ClockContext.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export type Clock = {
+    subscribe: (onChange: () => void, keepAlive: boolean) => () => void;
+    now: () => number;
+    setTickInterval: (ms: number) => void;
+};
+export declare function createClock(tickIntervalMs: number): Clock;
+export declare const ClockContext: React.Context<Clock | null>;
+export declare function ClockProvider(t0: any): any;
+//# sourceMappingURL=ClockContext.d.ts.map

package/lib/types/ink/components/ClockContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClockContext.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/ClockContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAA6C,MAAM,OAAO,CAAC;AAGlE,MAAM,MAAM,KAAK,GAAG;IAClB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,SAAS,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;IACpE,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,eAAe,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,CAAC;AACF,wBAAgB,WAAW,CAAC,cAAc,EAAE,MAAM,GAAG,KAAK,CA0DzD;AACD,eAAO,MAAM,YAAY,6BAAoC,CAAC;AAM9D,wBAAgB,aAAa,CAAC,EAAE,KAAA,OAiC/B"}

package/lib/types/ink/components/ClockContext.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { createContext, useEffect, useState } from 'react';
+import { FRAME_INTERVAL_MS } from '../constants.js';
+import { useTerminalFocus } from '../hooks/use-terminal-focus.js';
+export function createClock(tickIntervalMs) {
+    const subscribers = new Map();
+    let interval = null;
+    let currentTickIntervalMs = tickIntervalMs;
+    let startTime = 0;
+    // Snapshot of the current tick's time, ensuring all subscribers in the same
+    // tick see the same value (keeps animations synchronized)
+    let tickTime = 0;
+    function tick() {
+        tickTime = Date.now() - startTime;
+        for (const onChange of subscribers.keys()) {
+            onChange();
+        }
+    }
+    function updateInterval() {
+        const anyKeepAlive = [...subscribers.values()].some(Boolean);
+        if (anyKeepAlive) {
+            if (interval) {
+                clearInterval(interval);
+                interval = null;
+            }
+            if (startTime === 0) {
+                startTime = Date.now();
+            }
+            interval = setInterval(tick, currentTickIntervalMs);
+        }
+        else if (interval) {
+            clearInterval(interval);
+            interval = null;
+        }
+    }
+    return {
+        subscribe(onChange, keepAlive) {
+            subscribers.set(onChange, keepAlive);
+            updateInterval();
+            return () => {
+                subscribers.delete(onChange);
+                updateInterval();
+            };
+        },
+        now() {
+            if (startTime === 0) {
+                startTime = Date.now();
+            }
+            // When the clock interval is running, return the synchronized tickTime
+            // so all subscribers in the same tick see the same value.
+            // When paused (no keepAlive subscribers), return real-time to avoid
+            // returning a stale tickTime from the last tick before the pause.
+            if (interval && tickTime) {
+                return tickTime;
+            }
+            return Date.now() - startTime;
+        },
+        setTickInterval(ms) {
+            if (ms === currentTickIntervalMs)
+                return;
+            currentTickIntervalMs = ms;
+            updateInterval();
+        }
+    };
+}
+export const ClockContext = createContext(null);
+const BLURRED_TICK_INTERVAL_MS = FRAME_INTERVAL_MS * 2;
+// Own component so App.tsx doesn't re-render when the clock is created.
+// The clock value is stable (created once via useState), so the provider
+// never causes consumer re-renders on its own.
+export function ClockProvider(t0) {
+    const $ = _c(7);
+    const { children } = t0;
+    const [clock] = useState(_temp);
+    const focused = useTerminalFocus();
+    let t1;
+    let t2;
+    if ($[0] !== clock || $[1] !== focused) {
+        t1 = () => {
+            clock.setTickInterval(focused ? FRAME_INTERVAL_MS : BLURRED_TICK_INTERVAL_MS);
+        };
+        t2 = [clock, focused];
+        $[0] = clock;
+        $[1] = focused;
+        $[2] = t1;
+        $[3] = t2;
+    }
+    else {
+        t1 = $[2];
+        t2 = $[3];
+    }
+    useEffect(t1, t2);
+    let t3;
+    if ($[4] !== children || $[5] !== clock) {
+        t3 = _jsx(ClockContext.Provider, { value: clock, children: children });
+        $[4] = children;
+        $[5] = clock;
+        $[6] = t3;
+    }
+    else {
+        t3 = $[6];
+    }
+    return t3;
+}
+function _temp() {
+    return createClock(FRAME_INTERVAL_MS);
+}

package/lib/types/ink/components/CursorDeclarationContext.d.ts

@@ -0,0 +1,30 @@
+import type { DOMElement } from '../dom.js';
+/**
+ * A declared cursor parking position: a node plus the line and column within
+ * it where the terminal cursor should sit.
+ */
+export type CursorDeclaration = {
+    /** Display column (terminal cell width) within the declared node */
+    readonly relativeX: number;
+    /** Line number within the declared node */
+    readonly relativeY: number;
+    /** The ink-box DOMElement whose yoga layout provides the absolute origin */
+    readonly node: DOMElement;
+};
+/**
+ * Setter for the declared cursor position.
+ *
+ * The optional second argument makes `null` a conditional clear: the
+ * declaration is only cleared if the currently-declared node matches
+ * `clearIfNode`. This makes the hook safe for sibling components
+ * (e.g. list items) that transfer focus among themselves — without the
+ * node check, a newly-unfocused item's clear could clobber a
+ * newly-focused sibling's set depending on layout-effect order.
+ */
+export type CursorDeclarationSetter = (declaration: CursorDeclaration | null, clearIfNode?: DOMElement | null) => void;
+/**
+ * React context that provides the cursor-declaration setter to descendants.
+ */
+declare const CursorDeclarationContext: import("react").Context<CursorDeclarationSetter>;
+export default CursorDeclarationContext;
+//# sourceMappingURL=CursorDeclarationContext.d.ts.map

package/lib/types/ink/components/CursorDeclarationContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursorDeclarationContext.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/CursorDeclarationContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAE3C;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAC1B,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,GAAG,CACpC,WAAW,EAAE,iBAAiB,GAAG,IAAI,EACrC,WAAW,CAAC,EAAE,UAAU,GAAG,IAAI,KAC5B,IAAI,CAAA;AAET;;GAEG;AACH,QAAA,MAAM,wBAAwB,kDAE7B,CAAA;AAED,eAAe,wBAAwB,CAAA"}

package/lib/types/ink/components/CursorDeclarationContext.js

@@ -0,0 +1,6 @@
+import { createContext } from 'react';
+/**
+ * React context that provides the cursor-declaration setter to descendants.
+ */
+const CursorDeclarationContext = createContext(() => { });
+export default CursorDeclarationContext;

package/lib/types/ink/components/ErrorOverview.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    readonly error: Error;
+};
+export default function ErrorOverview({ error }: Props): React.JSX.Element;
+export {};
+//# sourceMappingURL=ErrorOverview.d.ts.map

package/lib/types/ink/components/ErrorOverview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorOverview.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/ErrorOverview.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAsB1B,KAAK,KAAK,GAAG;IACX,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB,CAAC;AACF,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,EACpC,KAAK,EACN,EAAE,KAAK,qBA8EP"}

package/lib/types/ink/components/ErrorOverview.js

@@ -0,0 +1,49 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import codeExcerpt from 'code-excerpt';
+import { readFileSync } from 'fs';
+import StackUtils from 'stack-utils';
+import Box from './Box.js';
+import Text from './Text.js';
+/* eslint-disable custom-rules/no-process-cwd -- stack trace file:// paths are relative to the real OS cwd, not the virtual cwd */
+// Error's source file is reported as file:///home/user/file.js
+// This function removes the file://[cwd] part
+const cleanupPath = (path) => {
+    return path?.replace(`file://${process.cwd()}/`, '');
+};
+let stackUtils;
+function getStackUtils() {
+    return stackUtils ??= new StackUtils({
+        cwd: process.cwd(),
+        internals: StackUtils.nodeInternals()
+    });
+}
+export default function ErrorOverview({ error }) {
+    const stack = error.stack ? error.stack.split('\n').slice(1) : undefined;
+    const origin = stack ? getStackUtils().parseLine(stack[0]) : undefined;
+    const filePath = cleanupPath(origin?.file);
+    let excerpt;
+    let lineWidth = 0;
+    if (filePath && origin?.line) {
+        try {
+            // eslint-disable-next-line custom-rules/no-sync-fs -- sync render path; error overlay can't go async without suspense restructuring
+            const sourceCode = readFileSync(filePath, 'utf8');
+            excerpt = codeExcerpt(sourceCode, origin.line);
+            if (excerpt) {
+                for (const { line } of excerpt) {
+                    lineWidth = Math.max(lineWidth, String(line).length);
+                }
+            }
+        }
+        catch {
+            // file not readable — skip source context
+        }
+    }
+    return _jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { backgroundColor: "ansi:red", color: "ansi:white", children: [' ', "ERROR", ' '] }), _jsxs(Text, { children: [" ", error.message] })] }), origin && filePath && _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dim: true, children: [filePath, ":", origin.line, ":", origin.column] }) }), origin && excerpt && _jsx(Box, { marginTop: 1, flexDirection: "column", children: excerpt.map(({ line: line_0, value }) => _jsxs(Box, { children: [_jsx(Box, { width: lineWidth + 1, children: _jsxs(Text, { dim: line_0 !== origin.line, backgroundColor: line_0 === origin.line ? 'ansi:red' : undefined, color: line_0 === origin.line ? 'ansi:white' : undefined, children: [String(line_0).padStart(lineWidth, ' '), ":"] }) }), _jsx(Text, { backgroundColor: line_0 === origin.line ? 'ansi:red' : undefined, color: line_0 === origin.line ? 'ansi:white' : undefined, children: ' ' + value }, line_0)] }, line_0)) }), error.stack && _jsx(Box, { marginTop: 1, flexDirection: "column", children: error.stack.split('\n').slice(1).map(line_1 => {
+                    const parsedLine = getStackUtils().parseLine(line_1);
+                    // If the line from the stack cannot be parsed, we print out the unparsed line.
+                    if (!parsedLine) {
+                        return _jsxs(Box, { children: [_jsx(Text, { dim: true, children: "- " }), _jsx(Text, { bold: true, children: line_1 })] }, line_1);
+                    }
+                    return _jsxs(Box, { children: [_jsx(Text, { dim: true, children: "- " }), _jsx(Text, { bold: true, children: parsedLine.function }), _jsxs(Text, { dim: true, children: [' ', "(", cleanupPath(parsedLine.file) ?? '', ":", parsedLine.line, ":", parsedLine.column, ")"] })] }, line_1);
+                }) })] });
+}

package/lib/types/ink/components/Link.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export type Props = {
+    readonly children?: ReactNode;
+    readonly url: string;
+    readonly fallback?: ReactNode;
+};
+export default function Link(t0: any): any;
+//# sourceMappingURL=Link.d.ts.map

package/lib/types/ink/components/Link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/Link.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;CAC/B,CAAC;AACF,MAAM,CAAC,OAAO,UAAU,IAAI,CAAC,EAAE,KAAA,OA8B9B"}