@askdkc/dsh-cli 0.11.3

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,EAAsD,MAAM,OAAO,CAAC;AACpH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAM5C,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,CA6RrD;AACD,eAAe,SAAS,CAAC"}

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

@@ -0,0 +1,309 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useImperativeHandle, useRef, useState } from 'react';
+import { FRAME_INTERVAL_MS } from '../constants.js';
+import { markScrollActivity } from '../../bootstrap/state.js';
+import { markDirty, scheduleRenderFrom } from '../dom.js';
+import { noteFrameCause } from '../geometry-trace.js';
+import { markCommitStart } from '../reconciler.js';
+import { swallowNestedUpdateOverflow } from '../update-overflow-guard.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);
+    // The imperative handle, kept in a ref so the onWheel handler below can
+    // call scrollBy through the full public path (clamp bounds, sticky
+    // clearing, subscriber notify) instead of duplicating its logic.
+    const handleRef = useRef(null);
+    const notify = () => {
+        // #185 self-heal: scroll subscribers drive React state (setScrollTick);
+        // a thrown overflow here resets React's nested counter — absorb it.
+        for (const l of listenersRef.current) {
+            try {
+                l();
+            }
+            catch (error) {
+                if (!swallowNestedUpdateOverflow(error, 'scrollbox.notify'))
+                    throw error;
+            }
+        }
+    };
+    // Input-edge intent coalescing (Qwen Code's 16ms wheel merge, Crush's
+    // pre-queue filter): subscribers drive React state (MessageList's mount
+    // window, Chat's sticky flag, the timeline rail), so notifying per wheel
+    // EVENT runs a full React commit per event — a fast flick is 10-30
+    // events, each re-running the offsets/window/timeline loops on a big
+    // session. The scrollTop mutation and the ink render are already
+    // frame-throttled; this aligns the React commits to the same frame
+    // budget. Both edges defer to a microtask: the remaining input events of
+    // the same stdin batch then land BEFORE any commit, and one commit
+    // covers the whole batch (the sync leading edge used to run a full
+    // commit inside the wheel dispatch itself — pure input latency).
+    const notifyQueuedRef = useRef(false);
+    const lastNotifyAtRef = useRef(-Infinity);
+    const notifyCoalesced = () => {
+        const since = performance.now() - lastNotifyAtRef.current;
+        if (!notifyQueuedRef.current && since >= FRAME_INTERVAL_MS) {
+            notifyQueuedRef.current = true;
+            lastNotifyAtRef.current = performance.now();
+            queueMicrotask(() => {
+                notifyQueuedRef.current = false;
+                notify();
+            });
+            return;
+        }
+        if (notifyQueuedRef.current)
+            return;
+        notifyQueuedRef.current = true;
+        setTimeout(() => {
+            notifyQueuedRef.current = false;
+            lastNotifyAtRef.current = performance.now();
+            notify();
+        }, Math.max(0, FRAME_INTERVAL_MS - since));
+    };
+    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();
+        noteFrameCause('scroll');
+        markDirty(el);
+        markCommitStart();
+        notifyCoalesced();
+        queueRender(el);
+    }
+    function queueRender(el) {
+        if (renderQueuedRef.current)
+            return;
+        renderQueuedRef.current = true;
+        queueMicrotask(() => {
+            renderQueuedRef.current = false;
+            scheduleRenderFrom(el);
+        });
+    }
+    useImperativeHandle(ref, () => {
+        const handle = {
+            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;
+                const dyFloor = Math.floor(dy);
+                // Wheel-down / scroll-down while the view is already AT the bottom is
+                // pure overscroll: nothing left to reveal. Ignore it entirely — no
+                // sticky clear, no pending delta, no dirty mark, no subscriber
+                // notify. The old path ran every notch through sticky-break → drain →
+                // re-pin, which (with streaming content) flip-flopped the sticky flag
+                // frame by frame, remounted the virtualization window (isSticky is
+                // React state), flashed the "↓ back to bottom" pill while the user
+                // WAS at the bottom, let the drain overshoot past maxScroll on
+                // measure frames, and repainted the transcript per notch (flicker).
+                // Gate:
+                //  - sticky === true: the renderer keeps scrollTop pinned at
+                //    maxScroll each frame — a wheel-down must never unpin it
+                //    (leaving the bottom is wheel-UP's job).
+                //  - else positionally at the bottom or past it (a shrink-frozen
+                //    scrollTop can sit above the cached maxScroll): scrollTop >=
+                //    maxScroll with no in-flight scroll-UP (pending >= 0).
+                //    pending < 0 means an earlier wheel-up hasn't drained yet: a
+                //    down-notch must land so the accumulator cancels (scroll-up
+                //    followed by scroll-down naturally cancels — see the
+                //    accumulation comment below).
+                //  - Notches from ABOVE (scrollTop < maxScroll) are NOT gated —
+                //    including the landing notch that would finish the final row:
+                //    ±1-row callers (panel ↑/↓ keys) and scrollTo/seek landings can
+                //    rest at maxScroll - 1, and gating there would leave the last
+                //    row unreachable and never trigger the renderer's at-bottom
+                //    re-pin (which requires scrollTop >= maxScroll). The landing
+                //    notch drains to the bottom and the re-pin restores sticky /
+                //    clears the new-messages pill on that frame. No epsilon is
+                //    needed — the whole chain is integer rows.
+                if (dyFloor > 0) {
+                    const sticky = el.stickyScroll ?? Boolean(el.attributes['stickyScroll']);
+                    const pending = el.pendingScrollDelta ?? 0;
+                    const maxScroll = Math.max(0, (el.scrollHeight ?? 0) - (el.scrollViewportHeight ?? 0));
+                    if (sticky || ((el.scrollTop ?? 0) >= maxScroll && pending >= 0)) {
+                        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) + dyFloor;
+                scrollMutated(el);
+            },
+            scrollToBottom() {
+                const el = domRef.current;
+                if (!el)
+                    return;
+                el.scrollAnchor = undefined;
+                const viewportH = el.scrollViewportHeight ?? 0;
+                const maxScroll = Math.max(0, (el.scrollHeight ?? 0) - viewportH);
+                el.pendingScrollDelta = undefined;
+                el.stickyScroll = true;
+                // Jump intent is not wheel debt: mounting the union of the current
+                // position and a far pending delta defeats virtualization. MessageList's
+                // sticky tail walk mounts the destination directly, even with estimated
+                // heights. Publish sticky + target before notifying; the renderer then
+                // pins to the fresh maxScroll as those tail rows are measured.
+                el.scrollTop = maxScroll;
+                scrollMutated(el);
+                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;
+                if (el.scrollClampMin === min && el.scrollClampMax === max)
+                    return;
+                el.scrollClampMin = min;
+                el.scrollClampMax = max;
+                // Layout effects publish the new mount window AFTER resetAfterCommit
+                // may have painted with the previous bounds. Warm rows need no measure
+                // tick, so that paint can otherwise remain on blank spacer indefinitely.
+                // Invalidate the blit and schedule a paint, without notifying React
+                // subscribers (the window is already committed).
+                markDirty(el);
+                queueRender(el);
+            }
+        };
+        handleRef.current = handle;
+        return handle;
+    }, 
+    // 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
+    []);
+    // Position-routed wheel events (pointer over this box) scroll THIS box
+    // through the public scrollBy path — clamp bounds, sticky clearing, and
+    // subscriber notify all apply. Horizontal wheel (deltaX) has no renderer
+    // support yet (no scrollLeft in the DOM model) and is ignored.
+    const handleWheel = useCallback((e) => {
+        if (e.deltaY !== 0)
+            handleRef.current?.scrollBy(e.deltaY);
+    }, []);
+    // Keep the host ref attached across updates. A new callback would detach
+    // it before children's layout effects publish their clamp bounds, making
+    // setClampBounds silently miss the commit (child effects run first).
+    const attachNode = useCallback((el) => {
+        domRef.current = el;
+        if (el) {
+            el.scrollTop ??= 0;
+            el.onStickyRestore = notify;
+            // A viewport-height change since the last layout pass means every
+            // geometry-reading subscriber painted the previous bounds (the
+            // renderer owns the write and this pass was otherwise silent). Wire
+            // it to the same subscriber notify as scroll mutations, coalesced to
+            // the frame budget: a terminal resize storm or a landing's chained
+            // chrome unmounts each produce a pass, and merging them bounds the
+            // React commits without dropping the final state — notifyCoalesced
+            // always runs the queued notify, and subscribers re-read the handle
+            // (level-triggered), so a coalesced pass still sees the latest bounds.
+            el.onViewportHeightChange = notifyCoalesced;
+        }
+        // notify/notifyCoalesced only close over refs, like the imperative handle
+        // above.
+        // 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: attachNode, onWheel: handleWheel, 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,4 @@
+import React from 'react';
+/** Consume unused space on the parent's flex axis. */
+export default function Spacer(): React.JSX.Element;
+//# 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":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,sDAAsD;AACtD,MAAM,CAAC,OAAO,UAAU,MAAM,sBAE7B"}

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

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import Box from './Box.js';
+/** Consume unused space on the parent's flex axis. */
+export default function Spacer() {
+    return _jsx(Box, { flexGrow: 1 });
+}

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, { type PropsWithChildren } 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({ children }: PropsWithChildren): React.JSX.Element;
+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":"AAAA,OAAO,KAAK,EAAE,EAAiB,KAAK,iBAAiB,EAAiC,MAAM,OAAO,CAAA;AACnG,OAAO,EAAiD,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AACnH,YAAY,EAAE,kBAAkB,EAAE,CAAA;AAClC,MAAM,MAAM,yBAAyB,GAAG;IAAE,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAChI,QAAA,MAAM,oBAAoB,0CAAuG,CAAA;AAGjI,wBAAgB,qBAAqB,CAAC,EAAE,QAAQ,EAAE,EAAE,iBAAiB,qBAIpE;AACD,eAAe,oBAAoB,CAAA"}

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

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useMemo, useSyncExternalStore } from 'react';
+import { getTerminalFocusState, subscribeTerminalFocus } from '../terminal-focus-state.js';
+const TerminalFocusContext = createContext({ isTerminalFocused: true, terminalFocusState: 'unknown' });
+TerminalFocusContext.displayName = 'TerminalFocusContext';
+export function TerminalFocusProvider({ children }) {
+    const terminalFocusState = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocusState);
+    const value = useMemo(() => ({ terminalFocusState, isTerminalFocused: terminalFocusState !== 'blurred' }), [terminalFocusState]);
+    return _jsx(TerminalFocusContext.Provider, { value: value, children: children });
+}
+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,2 @@
+import { createContext } from 'react';
+export const TerminalSizeContext = createContext(null);

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

@@ -0,0 +1,64 @@
+import type { ReactNode, Ref } from 'react';
+import React from 'react';
+import type { Color, Styles } from '../styles.js';
+import type { DOMElement } from '../dom.js';
+type BaseProps = {
+    /**
+     * Change text color. Accepts a raw color value (rgb, hex, ansi).
+     */
+    readonly color?: Color;
+    /**
+     * Ref to the underlying ink-text DOMElement. dsh-tui addition: lets
+     * useDeclaredCursor park the native cursor on an inline caret cell without
+     * wrapping it in a Box (a wrapper Box changes flex shrink behaviour and
+     * breaks wrapped-line layouts).
+     */
+    readonly ref?: Ref<DOMElement>;
+    /**
+     * Same as `color`, but for background.
+     */
+    readonly backgroundColor?: Color;
+    /**
+     * Make the text italic.
+     */
+    readonly italic?: boolean;
+    /**
+     * Make the text underlined.
+     */
+    readonly underline?: boolean;
+    /**
+     * Make the text crossed with a line.
+     */
+    readonly strikethrough?: boolean;
+    /**
+     * Inverse background and foreground colors.
+     */
+    readonly inverse?: boolean;
+    /**
+     * This property tells Ink to wrap or truncate text if its width is larger than container.
+     * If `wrap` is passed (by default), Ink will wrap text and split it into multiple lines.
+     * If `truncate-*` is passed, Ink will truncate text instead, which will result in one line of text with the rest cut off.
+     */
+    readonly wrap?: Styles['textWrap'];
+    readonly children?: ReactNode;
+};
+/**
+ * Bold and dim are mutually exclusive in terminals.
+ * This type ensures you can use one or the other, but not both.
+ */
+type WeightProps = {
+    bold?: never;
+    dim?: never;
+} | {
+    bold: boolean;
+    dim?: never;
+} | {
+    dim: boolean;
+    bold?: never;
+};
+export type Props = BaseProps & WeightProps;
+/** A text leaf. Empty children produce no layout node. */
+declare function Text({ children, ref, wrap, color, backgroundColor, bold, dim, italic, underline, strikethrough, inverse, }: Props): React.JSX.Element | null;
+declare const _default: React.MemoExoticComponent<typeof Text>;
+export default _default;
+//# sourceMappingURL=Text.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Text.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/Text.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAc,MAAM,cAAc,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,KAAK,SAAS,GAAG;IACf;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IAE/B;;OAEG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,KAAK,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;CAC/B,CAAC;AAEF;;;GAGG;AACH,KAAK,WAAW,GAAG;IACjB,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,GAAG,CAAC,EAAE,KAAK,CAAC;CACb,GAAG;IACF,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,KAAK,CAAC;CACb,GAAG;IACF,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,KAAK,CAAC;CACd,CAAC;AACF,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,WAAW,CAAC;AAG5C,0DAA0D;AAC1D,iBAAS,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAa,EAAE,KAAK,EAAE,eAAe,EAClE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,GACrD,EAAE,KAAK,4BAYP;;AAED,wBAA+B"}

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

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+const wrapStyles = new Map();
+/** A text leaf. Empty children produce no layout node. */
+function Text({ children, ref, wrap = 'wrap', color, backgroundColor, bold, dim, italic, underline, strikethrough, inverse, }) {
+    const textStyles = React.useMemo(() => {
+        const values = { color, backgroundColor, bold, dim, italic, underline, strikethrough, inverse };
+        return Object.fromEntries(Object.entries(values).filter(([, value]) => Boolean(value)));
+    }, [color, backgroundColor, bold, dim, italic, underline, strikethrough, inverse]);
+    if (children == null)
+        return null;
+    let style = wrapStyles.get(wrap);
+    if (!style) {
+        style = { flexDirection: 'row', flexGrow: 0, flexShrink: 1, textWrap: wrap };
+        wrapStyles.set(wrap, style);
+    }
+    return _jsx("ink-text", { ref: ref, style: style, textStyles: textStyles, children: children });
+}
+export default React.memo(Text);

package/lib/types/ink/constants.d.ts

@@ -0,0 +1,12 @@
+/** Shared frame interval for render throttling and animations (~60fps). */
+export declare const FRAME_INTERVAL_MS = 16;
+/**
+ * In-flight pty gate threshold (bytes) for scroll-drain frames — Grok
+ * Build's Presenter in_flight gate. While stdout holds more unflushed
+ * output than this, drain frames hold off instead of stacking latency
+ * into a slow ConPTY/ssh link. Sized above one full-screen diff (~4KB at
+ * 100 cols) so the gate only trips on genuine backlog, never on a single
+ * in-transit frame.
+ */
+export declare const PTY_BACKLOG_BYTES = 8192;
+//# sourceMappingURL=constants.d.ts.map

package/lib/types/ink/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/ink/constants.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,KAAK,CAAA;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAA"}

package/lib/types/ink/constants.js

@@ -0,0 +1,11 @@
+/** Shared frame interval for render throttling and animations (~60fps). */
+export const FRAME_INTERVAL_MS = 16;
+/**
+ * In-flight pty gate threshold (bytes) for scroll-drain frames — Grok
+ * Build's Presenter in_flight gate. While stdout holds more unflushed
+ * output than this, drain frames hold off instead of stacking latency
+ * into a slow ConPTY/ssh link. Sized above one full-screen diff (~4KB at
+ * 100 cols) so the gate only trips on genuine backlog, never on a single
+ * in-transit frame.
+ */
+export const PTY_BACKLOG_BYTES = 8192;

package/lib/types/ink/cursor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cursor position within a frame. The original module lived outside the
+ * published ink tree; only the shape below is consumed (log-update.ts walks
+ * cursor.x/y/visible while diffing frames).
+ */
+export interface Cursor {
+    x: number;
+    y: number;
+    visible: boolean;
+}
+//# sourceMappingURL=cursor.d.ts.map

package/lib/types/ink/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../src/ink/cursor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACrB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,OAAO,EAAE,OAAO,CAAA;CACjB"}

package/lib/types/ink/cursor.js

@@ -0,0 +1 @@
+export {};