@deepseek-harness-tui/dsh-tui 0.5.0

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

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { supportsHyperlinks } from '../supports-hyperlinks.js';
+import Text from './Text.js';
+export default function Link(t0) {
+    const $ = _c(5);
+    const { children, url, fallback } = t0;
+    const content = children ?? url;
+    if (supportsHyperlinks()) {
+        let t1;
+        if ($[0] !== content || $[1] !== url) {
+            t1 = _jsx(Text, { children: _jsx("ink-link", { href: url, children: content }) });
+            $[0] = content;
+            $[1] = url;
+            $[2] = t1;
+        }
+        else {
+            t1 = $[2];
+        }
+        return t1;
+    }
+    const t1 = fallback ?? content;
+    let t2;
+    if ($[3] !== t1) {
+        t2 = _jsx(Text, { children: t1 });
+        $[3] = t1;
+        $[4] = t2;
+    }
+    else {
+        t2 = $[4];
+    }
+    return t2;
+}

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

@@ -0,0 +1,13 @@
+export type Props = {
+    /**
+     * Number of newlines to insert.
+     *
+     * @default 1
+     */
+    readonly count?: number;
+};
+/**
+ * Adds one or more newline (\n) characters. Must be used within <Text> components.
+ */
+export default function Newline(t0: any): any;
+//# sourceMappingURL=Newline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Newline.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/Newline.tsx"],"names":[],"mappings":"AAEA,MAAM,MAAM,KAAK,GAAG;IAClB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,EAAE,KAAA,OAuBjC"}

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

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Adds one or more newline (\n) characters. Must be used within <Text> components.
+ */
+export default function Newline(t0) {
+    const $ = _c(4);
+    const { count: t1 } = t0;
+    const count = t1 === undefined ? 1 : t1;
+    let t2;
+    if ($[0] !== count) {
+        t2 = "\n".repeat(count);
+        $[0] = count;
+        $[1] = t2;
+    }
+    else {
+        t2 = $[1];
+    }
+    let t3;
+    if ($[2] !== t2) {
+        t3 = _jsx("ink-text", { children: t2 });
+        $[2] = t2;
+        $[3] = t3;
+    }
+    else {
+        t3 = $[3];
+    }
+    return t3;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Marks its contents as non-selectable in fullscreen text selection.
+ * Cells inside this box are skipped by both the selection highlight and
+ * the copied text — the gutter stays visually unchanged while the user
+ * drags, making it clear what will be copied.
+ *
+ * Use to fence off gutters (line numbers, diff +/- sigils, list bullets)
+ * so click-drag over rendered code yields clean pasteable content:
+ *
+ *   <Box flexDirection="row">
+ *     <NoSelect fromLeftEdge><Text dimColor> 42 +</Text></NoSelect>
+ *     <Text>const x = 1</Text>
+ *   </Box>
+ *
+ * Only affects alt-screen text selection (<AlternateScreen> with mouse
+ * tracking). No-op in the main-screen scrollback render where the
+ * terminal's native selection is used instead.
+ */
+export declare function NoSelect(t0: any): any;
+//# sourceMappingURL=NoSelect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NoSelect.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/NoSelect.tsx"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,EAAE,KAAA,OAgC1B"}

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

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import Box from './Box.js';
+/**
+ * Marks its contents as non-selectable in fullscreen text selection.
+ * Cells inside this box are skipped by both the selection highlight and
+ * the copied text — the gutter stays visually unchanged while the user
+ * drags, making it clear what will be copied.
+ *
+ * Use to fence off gutters (line numbers, diff +/- sigils, list bullets)
+ * so click-drag over rendered code yields clean pasteable content:
+ *
+ *   <Box flexDirection="row">
+ *     <NoSelect fromLeftEdge><Text dimColor> 42 +</Text></NoSelect>
+ *     <Text>const x = 1</Text>
+ *   </Box>
+ *
+ * Only affects alt-screen text selection (<AlternateScreen> with mouse
+ * tracking). No-op in the main-screen scrollback render where the
+ * terminal's native selection is used instead.
+ */
+export function NoSelect(t0) {
+    const $ = _c(8);
+    let boxProps;
+    let children;
+    let fromLeftEdge;
+    if ($[0] !== t0) {
+        ({
+            children,
+            fromLeftEdge,
+            ...boxProps
+        } = t0);
+        $[0] = t0;
+        $[1] = boxProps;
+        $[2] = children;
+        $[3] = fromLeftEdge;
+    }
+    else {
+        boxProps = $[1];
+        children = $[2];
+        fromLeftEdge = $[3];
+    }
+    const t1 = fromLeftEdge ? "from-left-edge" : true;
+    let t2;
+    if ($[4] !== boxProps || $[5] !== children || $[6] !== t1) {
+        t2 = _jsx(Box, { ...boxProps, noSelect: t1, children: children });
+        $[4] = boxProps;
+        $[5] = children;
+        $[6] = t1;
+        $[7] = t2;
+    }
+    else {
+        t2 = $[7];
+    }
+    return t2;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Bypass the <Ansi> → React tree → Yoga → squash → re-serialize roundtrip for
+ * content that is already terminal-ready.
+ *
+ * Use this when an external renderer (e.g. the ColorDiff NAPI module) has
+ * already produced ANSI-escaped, width-wrapped output. A normal <Ansi> mount
+ * reparses that output into one React <Text> per style span, lays out each
+ * span as a Yoga flex child, then walks the tree to re-emit the same escape
+ * codes it was given. For a long transcript full of syntax-highlighted diffs
+ * that roundtrip is the dominant cost of the render.
+ *
+ * This component emits a single Yoga leaf with a constant-time measure func
+ * (width × lines.length) and hands the joined string straight to output.write(),
+ * which already splits on '\n' and parses ANSI into the screen buffer.
+ */
+export declare function RawAnsi(t0: any): any;
+//# sourceMappingURL=RawAnsi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RawAnsi.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/RawAnsi.tsx"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,EAAE,KAAA,OA4BzB"}

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

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Bypass the <Ansi> → React tree → Yoga → squash → re-serialize roundtrip for
+ * content that is already terminal-ready.
+ *
+ * Use this when an external renderer (e.g. the ColorDiff NAPI module) has
+ * already produced ANSI-escaped, width-wrapped output. A normal <Ansi> mount
+ * reparses that output into one React <Text> per style span, lays out each
+ * span as a Yoga flex child, then walks the tree to re-emit the same escape
+ * codes it was given. For a long transcript full of syntax-highlighted diffs
+ * that roundtrip is the dominant cost of the render.
+ *
+ * This component emits a single Yoga leaf with a constant-time measure func
+ * (width × lines.length) and hands the joined string straight to output.write(),
+ * which already splits on '\n' and parses ANSI into the screen buffer.
+ */
+export function RawAnsi(t0) {
+    const $ = _c(6);
+    const { lines, width } = t0;
+    if (lines.length === 0) {
+        return null;
+    }
+    let t1;
+    if ($[0] !== lines) {
+        t1 = lines.join("\n");
+        $[0] = lines;
+        $[1] = t1;
+    }
+    else {
+        t1 = $[1];
+    }
+    let t2;
+    if ($[2] !== lines.length || $[3] !== t1 || $[4] !== width) {
+        t2 = _jsx("ink-raw-ansi", { rawText: t1, rawWidth: width, rawHeight: lines.length });
+        $[2] = lines.length;
+        $[3] = t1;
+        $[4] = width;
+        $[5] = t2;
+    }
+    else {
+        t2 = $[5];
+    }
+    return t2;
+}

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

@@ -0,0 +1,78 @@
+import React, { type PropsWithChildren, type Ref } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { Styles } from '../styles.js';
+export type ScrollBoxHandle = {
+    scrollTo: (y: number) => void;
+    scrollBy: (dy: number) => void;
+    /**
+     * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike
+     * scrollTo which bakes a number that's stale by the time the throttled
+     * render fires, this defers the position read to render time —
+     * render-node-to-output reads `el.yogaNode.getComputedTop()` in the
+     * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.
+     */
+    scrollToElement: (el: DOMElement, offset?: number) => void;
+    scrollToBottom: () => void;
+    getScrollTop: () => number;
+    getPendingDelta: () => number;
+    getScrollHeight: () => number;
+    /**
+     * Like getScrollHeight, but reads Yoga directly instead of the cached
+     * value written by render-node-to-output (throttled, up to 16ms stale).
+     * Use when you need a fresh value in useLayoutEffect after a React commit
+     * that grew content. Slightly more expensive (native Yoga call).
+     */
+    getFreshScrollHeight: () => number;
+    getViewportHeight: () => number;
+    /**
+     * Absolute screen-buffer row of the first visible content line (inside
+     * padding). Used for drag-to-scroll edge detection.
+     */
+    getViewportTop: () => number;
+    /**
+     * True when scroll is pinned to the bottom. Set by scrollToBottom, the
+     * initial stickyScroll attribute, and by the renderer when positional
+     * follow fires (scrollTop at prevMax, content grows). Cleared by
+     * scrollTo/scrollBy. Stable signal for "at bottom" that doesn't depend on
+     * layout values (unlike scrollTop+viewportH >= scrollHeight).
+     */
+    isSticky: () => boolean;
+    /**
+     * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).
+     * Does NOT fire for stickyScroll updates done by the Ink renderer — those
+     * happen during Ink's render phase after React has committed. Callers that
+     * care about the sticky case should treat "at bottom" as a fallback.
+     */
+    subscribe: (listener: () => void) => () => void;
+    /**
+     * Set the render-time scrollTop clamp to the currently-mounted children's
+     * coverage span. Called by useVirtualScroll after computing its range;
+     * render-node-to-output clamps scrollTop to [min, max] so burst scrollTo
+     * calls that race past React's async re-render show the edge of mounted
+     * content instead of blank spacer. Pass undefined to disable (sticky,
+     * cold start).
+     */
+    setClampBounds: (min: number | undefined, max: number | undefined) => void;
+};
+export type ScrollBoxProps = Except<Styles, 'textWrap' | 'overflow' | 'overflowX' | 'overflowY'> & {
+    ref?: Ref<ScrollBoxHandle>;
+    /**
+     * When true, automatically pins scroll position to the bottom when content
+     * grows. Unset manually via scrollTo/scrollBy to break the stickiness.
+     */
+    stickyScroll?: boolean;
+};
+/**
+ * A Box with `overflow: scroll` and an imperative scroll API.
+ *
+ * Children are laid out at their full Yoga-computed height inside a
+ * constrained container. At render time, only children intersecting the
+ * visible window (scrollTop..scrollTop+height) are rendered (viewport
+ * culling). Content is translated by -scrollTop and clipped to the box bounds.
+ *
+ * Works best inside a fullscreen (constrained-height root) Ink tree.
+ */
+declare function ScrollBox({ children, ref, stickyScroll, ...style }: PropsWithChildren<ScrollBoxProps>): React.ReactNode;
+export default ScrollBox;
+//# sourceMappingURL=ScrollBox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollBox.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/ScrollBox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAE,KAAK,GAAG,EAAyC,MAAM,OAAO,CAAC;AACvG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B;;;;;;OAMG;IACH,eAAe,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,MAAM,CAAC;IAC9B,eAAe,EAAE,MAAM,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,oBAAoB,EAAE,MAAM,MAAM,CAAC;IACnC,iBAAiB,EAAE,MAAM,MAAM,CAAC;IAChC;;;OAGG;IACH,cAAc,EAAE,MAAM,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB;;;;;OAKG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAChD;;;;;;;OAOG;IACH,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;CAC5E,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC,GAAG;IACjG,GAAG,CAAC,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;;;GASG;AACH,iBAAS,SAAS,CAAC,EACjB,QAAQ,EACR,GAAG,EACH,YAAY,EACZ,GAAG,KAAK,EACT,EAAE,iBAAiB,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC,SAAS,CAyJrD;AACD,eAAe,SAAS,CAAC"}

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

@@ -0,0 +1,174 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useImperativeHandle, useRef, useState } from 'react';
+import { markScrollActivity } from '../../bootstrap/state.js';
+import { markDirty, scheduleRenderFrom } from '../dom.js';
+import { markCommitStart } from '../reconciler.js';
+import Box from './Box.js';
+/**
+ * A Box with `overflow: scroll` and an imperative scroll API.
+ *
+ * Children are laid out at their full Yoga-computed height inside a
+ * constrained container. At render time, only children intersecting the
+ * visible window (scrollTop..scrollTop+height) are rendered (viewport
+ * culling). Content is translated by -scrollTop and clipped to the box bounds.
+ *
+ * Works best inside a fullscreen (constrained-height root) Ink tree.
+ */
+function ScrollBox({ children, ref, stickyScroll, ...style }) {
+    const domRef = useRef(null);
+    // scrollTo/scrollBy bypass React: they mutate scrollTop on the DOM node,
+    // mark it dirty, and call the root's throttled scheduleRender directly.
+    // The Ink renderer reads scrollTop from the node — no React state needed,
+    // no reconciler overhead per wheel event. The microtask defer coalesces
+    // multiple scrollBy calls in one input batch (discreteUpdates) into one
+    // render — otherwise scheduleRender's leading edge fires on the FIRST
+    // event before subsequent events mutate scrollTop. scrollToBottom still
+    // forces a React render: sticky is attribute-observed, no DOM-only path.
+    const [, forceRender] = useState(0);
+    const listenersRef = useRef(new Set());
+    const renderQueuedRef = useRef(false);
+    const notify = () => {
+        for (const l of listenersRef.current)
+            l();
+    };
+    function scrollMutated(el) {
+        // Signal background intervals (IDE poll, LSP poll, GCS fetch, orphan
+        // check) to skip their next tick — they compete for the event loop and
+        // contributed to 1402ms max frame gaps during scroll drain.
+        markScrollActivity();
+        markDirty(el);
+        markCommitStart();
+        notify();
+        if (renderQueuedRef.current)
+            return;
+        renderQueuedRef.current = true;
+        queueMicrotask(() => {
+            renderQueuedRef.current = false;
+            scheduleRenderFrom(el);
+        });
+    }
+    useImperativeHandle(ref, () => ({
+        scrollTo(y) {
+            const el = domRef.current;
+            if (!el)
+                return;
+            // Explicit false overrides the DOM attribute so manual scroll
+            // breaks stickiness. Render code checks ?? precedence.
+            el.stickyScroll = false;
+            el.pendingScrollDelta = undefined;
+            el.scrollAnchor = undefined;
+            el.scrollTop = Math.max(0, Math.floor(y));
+            scrollMutated(el);
+        },
+        scrollToElement(el, offset = 0) {
+            const box = domRef.current;
+            if (!box)
+                return;
+            box.stickyScroll = false;
+            box.pendingScrollDelta = undefined;
+            box.scrollAnchor = {
+                el,
+                offset
+            };
+            scrollMutated(box);
+        },
+        scrollBy(dy) {
+            const el = domRef.current;
+            if (!el)
+                return;
+            el.stickyScroll = false;
+            // Wheel input cancels any in-flight anchor seek — user override.
+            el.scrollAnchor = undefined;
+            // Accumulate in pendingScrollDelta; renderer drains it at a capped
+            // rate so fast flicks show intermediate frames. Pure accumulator:
+            // scroll-up followed by scroll-down naturally cancels.
+            el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+            scrollMutated(el);
+        },
+        scrollToBottom() {
+            const el = domRef.current;
+            if (!el)
+                return;
+            el.pendingScrollDelta = undefined;
+            el.stickyScroll = true;
+            markDirty(el);
+            notify();
+            forceRender(n => n + 1);
+        },
+        getScrollTop() {
+            return domRef.current?.scrollTop ?? 0;
+        },
+        getPendingDelta() {
+            // Accumulated-but-not-yet-drained delta. useVirtualScroll needs
+            // this to mount the union [committed, committed+pending] range —
+            // otherwise intermediate drain frames find no children (blank).
+            return domRef.current?.pendingScrollDelta ?? 0;
+        },
+        getScrollHeight() {
+            return domRef.current?.scrollHeight ?? 0;
+        },
+        getFreshScrollHeight() {
+            const content = domRef.current?.childNodes[0];
+            return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
+        },
+        getViewportHeight() {
+            return domRef.current?.scrollViewportHeight ?? 0;
+        },
+        getViewportTop() {
+            return domRef.current?.scrollViewportTop ?? 0;
+        },
+        isSticky() {
+            const el = domRef.current;
+            if (!el)
+                return false;
+            return el.stickyScroll ?? Boolean(el.attributes['stickyScroll']);
+        },
+        subscribe(listener) {
+            listenersRef.current.add(listener);
+            return () => listenersRef.current.delete(listener);
+        },
+        setClampBounds(min, max) {
+            const el = domRef.current;
+            if (!el)
+                return;
+            el.scrollClampMin = min;
+            el.scrollClampMax = max;
+        }
+    }), 
+    // notify/scrollMutated are inline (no useCallback) but only close over
+    // refs + imports — stable. Empty deps avoids rebuilding the handle on
+    // every render (which re-registers the ref = churn).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    // Structure: outer viewport (overflow:scroll, constrained height) >
+    // inner content (flexGrow:1, flexShrink:0 — fills at least the viewport
+    // but grows beyond it for tall content). flexGrow:1 lets children use
+    // spacers to pin elements to the bottom of the scroll area. Yoga's
+    // Overflow.Scroll prevents the viewport from growing to fit the content.
+    // The renderer computes scrollHeight from the content box and culls
+    // content's children based on scrollTop.
+    //
+    // stickyScroll is passed as a DOM attribute (via ink-box directly) so it's
+    // available on the first render — ref callbacks fire after the initial
+    // commit, which is too late for the first frame.
+    return _jsx("ink-box", { ref: el => {
+            domRef.current = el;
+            if (el) {
+                el.scrollTop ??= 0;
+                // Renderer-side sticky restores (positional re-pin at the bottom)
+                // must reach React subscribers too — see dom.ts onStickyRestore.
+                el.onStickyRestore = notify;
+            }
+        }, style: {
+            flexWrap: 'nowrap',
+            flexDirection: style.flexDirection ?? 'row',
+            flexGrow: style.flexGrow ?? 0,
+            flexShrink: style.flexShrink ?? 1,
+            ...style,
+            overflowX: 'scroll',
+            overflowY: 'scroll'
+        }, ...stickyScroll ? {
+            stickyScroll: true
+        } : {}, children: _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 0, width: "100%", children: children }) });
+}
+export default ScrollBox;

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

@@ -0,0 +1,6 @@
+/**
+ * A flexible space that expands along the major axis of its containing layout.
+ * It's useful as a shortcut for filling all the available spaces between elements.
+ */
+export default function Spacer(): any;
+//# sourceMappingURL=Spacer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Spacer.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/Spacer.tsx"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,QAU7B"}

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

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import Box from './Box.js';
+/**
+ * A flexible space that expands along the major axis of its containing layout.
+ * It's useful as a shortcut for filling all the available spaces between elements.
+ */
+export default function Spacer() {
+    const $ = _c(1);
+    let t0;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t0 = _jsx(Box, { flexGrow: 1 });
+        $[0] = t0;
+    }
+    else {
+        t0 = $[0];
+    }
+    return t0;
+}

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

@@ -0,0 +1,32 @@
+import { EventEmitter } from '../events/emitter.js';
+import type { TerminalQuerier } from '../terminal-querier.js';
+/**
+ * The `StdinContext` value: the stdin stream plus the raw-mode and Ctrl+C
+ * handling helpers Ink provides around it.
+ */
+export type Props = {
+    /**
+     * Stdin stream passed to `render()` in `options.stdin` or `process.stdin` by default. Useful if your app needs to handle user input.
+     */
+    readonly stdin: NodeJS.ReadStream;
+    /**
+     * Ink exposes this function via own `<StdinContext>` to be able to handle Ctrl+C, that's why you should use Ink's `setRawMode` instead of `process.stdin.setRawMode`.
+     * If the `stdin` stream passed to Ink does not support setRawMode, this function does nothing.
+     */
+    readonly setRawMode: (value: boolean) => void;
+    /**
+     * A boolean flag determining if the current `stdin` supports `setRawMode`. A component using `setRawMode` might want to use `isRawModeSupported` to nicely fall back in environments where raw mode is not supported.
+     */
+    readonly isRawModeSupported: boolean;
+    readonly internal_exitOnCtrlC: boolean;
+    readonly internal_eventEmitter: EventEmitter;
+    /** Query the terminal and await responses (DECRQM, OSC 11, etc.).
+     *  Null only in the never-reached default context value. */
+    readonly internal_querier: TerminalQuerier | null;
+};
+/**
+ * `StdinContext` is a React context, which exposes input stream.
+ */
+declare const StdinContext: import("react").Context<Props>;
+export default StdinContext;
+//# sourceMappingURL=StdinContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StdinContext.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/StdinContext.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D;;;GAGG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,UAAU,CAAA;IAEjC;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAE7C;;OAEG;IACH,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAA;IAEpC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAA;IAEtC,QAAQ,CAAC,qBAAqB,EAAE,YAAY,CAAA;IAE5C;gEAC4D;IAC5D,QAAQ,CAAC,gBAAgB,EAAE,eAAe,GAAG,IAAI,CAAA;CAClD,CAAA;AAED;;GAEG;AAEH,QAAA,MAAM,YAAY,gCAShB,CAAA;AAKF,eAAe,YAAY,CAAA"}

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

@@ -0,0 +1,16 @@
+import { createContext } from 'react';
+import { EventEmitter } from '../events/emitter.js';
+/**
+ * `StdinContext` is a React context, which exposes input stream.
+ */
+const StdinContext = createContext({
+    stdin: process.stdin,
+    internal_eventEmitter: new EventEmitter(),
+    setRawMode() { },
+    isRawModeSupported: false,
+    internal_exitOnCtrlC: true,
+    internal_querier: null,
+});
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+StdinContext.displayName = 'InternalStdinContext';
+export default StdinContext;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type TerminalFocusState } from '../terminal-focus-state.js';
+export type { TerminalFocusState };
+export type TerminalFocusContextProps = {
+    readonly isTerminalFocused: boolean;
+    readonly terminalFocusState: TerminalFocusState;
+};
+declare const TerminalFocusContext: React.Context<TerminalFocusContextProps>;
+export declare function TerminalFocusProvider(t0: any): any;
+export default TerminalFocusContext;
+//# sourceMappingURL=TerminalFocusContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TerminalFocusContext.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/TerminalFocusContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAAuD,MAAM,OAAO,CAAC;AAC5E,OAAO,EAAqE,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACxI,YAAY,EAAE,kBAAkB,EAAE,CAAC;AACnC,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;CACjD,CAAC;AACF,QAAA,MAAM,oBAAoB,0CAGxB,CAAC;AAQH,wBAAgB,qBAAqB,CAAC,EAAE,KAAA,OA8BvC;AACD,eAAe,oBAAoB,CAAC"}

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

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { createContext, useSyncExternalStore } from 'react';
+import { getTerminalFocused, getTerminalFocusState, subscribeTerminalFocus } from '../terminal-focus-state.js';
+const TerminalFocusContext = createContext({
+    isTerminalFocused: true,
+    terminalFocusState: 'unknown'
+});
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+TerminalFocusContext.displayName = 'TerminalFocusContext';
+// Separate component so App.tsx doesn't re-render on focus changes.
+// Children are a stable prop reference, so they don't re-render either —
+// only components that consume the context will re-render.
+export function TerminalFocusProvider(t0) {
+    const $ = _c(6);
+    const { children } = t0;
+    const isTerminalFocused = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocused);
+    const terminalFocusState = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocusState);
+    let t1;
+    if ($[0] !== isTerminalFocused || $[1] !== terminalFocusState) {
+        t1 = {
+            isTerminalFocused,
+            terminalFocusState
+        };
+        $[0] = isTerminalFocused;
+        $[1] = terminalFocusState;
+        $[2] = t1;
+    }
+    else {
+        t1 = $[2];
+    }
+    const value = t1;
+    let t2;
+    if ($[3] !== children || $[4] !== value) {
+        t2 = _jsx(TerminalFocusContext.Provider, { value: value, children: children });
+        $[3] = children;
+        $[4] = value;
+        $[5] = t2;
+    }
+    else {
+        t2 = $[5];
+    }
+    return t2;
+}
+export default TerminalFocusContext;

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

@@ -0,0 +1,6 @@
+export type TerminalSize = {
+    columns: number;
+    rows: number;
+};
+export declare const TerminalSizeContext: import("react").Context<TerminalSize | null>;
+//# sourceMappingURL=TerminalSizeContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TerminalSizeContext.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/TerminalSizeContext.tsx"],"names":[],"mappings":"AACA,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AACF,eAAO,MAAM,mBAAmB,8CAA2C,CAAC"}

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

@@ -0,0 +1,3 @@
+import { createContext } from 'react';
+export const TerminalSizeContext = createContext(null);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjcmVhdGVDb250ZXh0IiwiVGVybWluYWxTaXplIiwiY29sdW1ucyIsInJvd3MiLCJUZXJtaW5hbFNpemVDb250ZXh0Il0sInNvdXJjZXMiOlsiVGVybWluYWxTaXplQ29udGV4dC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlQ29udGV4dCB9IGZyb20gJ3JlYWN0J1xuXG5leHBvcnQgdHlwZSBUZXJtaW5hbFNpemUgPSB7XG4gIGNvbHVtbnM6IG51bWJlclxuICByb3dzOiBudW1iZXJcbn1cblxuZXhwb3J0IGNvbnN0IFRlcm1pbmFsU2l6ZUNvbnRleHQgPSBjcmVhdGVDb250ZXh0PFRlcm1pbmFsU2l6ZSB8IG51bGw+KG51bGwpXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGFBQWEsUUFBUSxPQUFPO0FBRXJDLE9BQU8sS0FBS0MsWUFBWSxHQUFHO0VBQ3pCQyxPQUFPLEVBQUUsTUFBTTtFQUNmQyxJQUFJLEVBQUUsTUFBTTtBQUNkLENBQUM7QUFFRCxPQUFPLE1BQU1DLG1CQUFtQixHQUFHSixhQUFhLENBQUNDLFlBQVksR0FBRyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=