@askdkc/dsh-cli 0.11.3

package/lib/types/ink/hit-test.js

@@ -0,0 +1,540 @@
+import { ClickEvent } from './events/click-event.js';
+import { ContextMenuEvent } from './events/context-menu-event.js';
+import { PointerEvent } from './events/pointer-event.js';
+import { WheelEvent } from './events/wheel-event.js';
+import { logError } from '../utils/log.js';
+import { nodeCache } from './node-cache.js';
+import { getAbsoluteHitList } from './render-node-to-output.js';
+import { dispatcher } from './reconciler.js';
+/**
+ * Find the deepest DOM element whose rendered rect contains (col, row).
+ *
+ * Uses the nodeCache populated by renderNodeToOutput — rects are in screen
+ * coordinates with all offsets (including scrollTop translation) already
+ * applied. Children are traversed in reverse so later siblings (painted on
+ * top) win. Nodes not in nodeCache (not rendered this frame, or lacking a
+ * yogaNode) are skipped along with their subtrees.
+ *
+ * Ancestor containment is NOT required: an unclipped node's children can
+ * paint (and receive hits) outside the parent's rect — negative margins
+ * (the PageMargin bleed row: the transcript gutter rail sits at the
+ * terminal edge while its ancestors end at the content column) and plain
+ * overflow. Pruning at such a node would leave the overflow region dead to
+ * the mouse. Only clipped nodes (overflow hidden/scroll) confine their
+ * subtree and prune. Each node still gates on its OWN rect, so the walk
+ * stays cheap whenever the point falls inside a clipped subtree (the
+ * transcript ScrollBox prunes everything below it).
+ *
+ * Returns the hit node even if it has no onClick — dispatchClick walks up
+ * via parentNode to find handlers.
+ * @param node - the subtree root to test.
+ * @param col - the screen column to test.
+ * @param row - the screen row to test.
+ * @returns the deepest element whose rect contains (col, row), or null.
+ */
+export function hitTest(node, col, row) {
+    const rect = nodeCache.get(node);
+    if (!rect)
+        return null;
+    const inside = col >= rect.x &&
+        col < rect.x + rect.width &&
+        row >= rect.y &&
+        row < rect.y + rect.height;
+    if (!inside) {
+        const style = node.style;
+        const overflowX = style.overflowX ?? style.overflow;
+        const overflowY = style.overflowY ?? style.overflow;
+        const clipped = overflowX === 'hidden' ||
+            overflowX === 'scroll' ||
+            overflowY === 'hidden' ||
+            overflowY === 'scroll';
+        // Clipped nodes confine their subtree: no child can sit at a point
+        // outside the clip. Unclipped nodes do not — descend anyway and let
+        // each child's own rect decide (see the overflow note above).
+        if (clipped)
+            return null;
+    }
+    // Later siblings paint on top; reversed traversal returns topmost hit.
+    for (let i = node.childNodes.length - 1; i >= 0; i--) {
+        const child = node.childNodes[i];
+        if (child.nodeName === '#text')
+            continue;
+        const hit = hitTest(child, col, row);
+        if (hit)
+            return hit;
+    }
+    return inside ? node : null;
+}
+// Full-tree hit-test call counter. Regression tests (verify-hover-coalesce)
+// reset it and assert the no-interest fast path actually skips work. Benign
+// in production — a monotonic counter, never read on hot paths.
+let hitTestWithOverlaysCount = 0;
+/**
+ * Number of hitTestWithOverlays calls since the last reset (or module load).
+ * @returns the call count.
+ */
+export function getHitTestWithOverlaysCount() {
+    return hitTestWithOverlaysCount;
+}
+/** Reset the hitTestWithOverlays call counter (test instrumentation). */
+export function resetHitTestWithOverlaysCount() {
+    hitTestWithOverlaysCount = 0;
+}
+/**
+ * hitTest, but overlay-aware: absolute-positioned nodes can paint OUTSIDE
+ * every ancestor's rect (OverlayAbove's `bottom:'100%'` pickers float over
+ * the transcript), so the plain containment recursion never reaches them —
+ * a click on the picker lands in the ScrollBox's rows instead. Check the
+ * frame's absolute hit list FIRST, in reverse paint order (later = visually
+ * on top), then fall back to the in-flow tree.
+ * @param root - the tree root for the in-flow fallback.
+ * @param col - the screen column to test.
+ * @param row - the screen row to test.
+ * @returns the deepest element at (col, row), or null.
+ */
+export function hitTestWithOverlays(root, col, row) {
+    hitTestWithOverlaysCount++;
+    const overlays = getAbsoluteHitList();
+    for (let i = overlays.length - 1; i >= 0; i--) {
+        const { node, rect } = overlays[i];
+        if (col >= rect.x &&
+            col < rect.x + rect.width &&
+            row >= rect.y &&
+            row < rect.y + rect.height) {
+            // hitTest re-checks containment via nodeCache and descends normally;
+            // nested absolutes deeper inside are themselves in the list and were
+            // already offered (later paint order) above.
+            const hit = hitTest(node, col, row);
+            if (hit)
+                return hit;
+        }
+    }
+    return hitTest(root, col, row);
+}
+/**
+ * Hit-test the root at (col, row) and bubble a ClickEvent from the deepest
+ * containing node up through parentNode. Only nodes with an onClick handler
+ * fire. Stops when a handler calls stopImmediatePropagation(). Returns
+ * true if at least one onClick handler fired.
+ *
+ * Each handler call is isolated: a throwing handler is logged and the
+ * bubbling continues, so one broken onClick cannot swallow the click from
+ * its ancestors or the rest of the input batch.
+ *
+ * @param root - the tree root to hit-test.
+ * @param col - the screen column of the click.
+ * @param row - the screen row of the click.
+ * @param cellIsBlank - whether the clicked cell is blank, reported on the event.
+ * @param button - raw SGR release byte (carries shift/alt/ctrl modifier bits).
+ * @returns true when at least one onClick handler fired.
+ */
+export function dispatchClick(root, col, row, cellIsBlank = false, button = 0) {
+    let target = hitTestWithOverlays(root, col, row) ?? undefined;
+    if (!target)
+        return false;
+    // Click-to-focus: find the closest focusable ancestor and focus it.
+    // root is always ink-root, which owns the FocusManager.
+    if (root.focusManager) {
+        let focusTarget = target;
+        while (focusTarget) {
+            if (typeof focusTarget.attributes['tabIndex'] === 'number') {
+                root.focusManager.handleClickFocus(focusTarget);
+                break;
+            }
+            focusTarget = focusTarget.parentNode;
+        }
+    }
+    const event = new ClickEvent(col, row, cellIsBlank, { button });
+    let handled = false;
+    while (target) {
+        const handler = target._eventHandlers?.onClick;
+        if (handler) {
+            handled = true;
+            const rect = nodeCache.get(target);
+            if (rect) {
+                event.localCol = col - rect.x;
+                event.localRow = row - rect.y;
+            }
+            else {
+                event.localCol = 0;
+                event.localRow = 0;
+            }
+            try {
+                handler(event);
+            }
+            catch (error) {
+                logError(error);
+            }
+            if (event.didStopImmediatePropagation())
+                return true;
+        }
+        target = target.parentNode;
+    }
+    return handled;
+}
+/**
+ * Hit-test the root at (col, row) and bubble a ContextMenuEvent from the
+ * deepest containing node up through parentNode. Only nodes with an
+ * onContextMenu handler fire. Stops when a handler calls
+ * stopImmediatePropagation(). Returns true if at least one onContextMenu
+ * handler fired.
+ *
+ * Unlike dispatchClick this does NOT move focus: the menu is a press-time
+ * affordance and the target's own handler decides whether focus follows.
+ * Handler isolation matches dispatchClick — a throwing handler is logged
+ * and the bubbling continues.
+ *
+ * @param root - the tree root to hit-test.
+ * @param col - the screen column of the press.
+ * @param row - the screen row of the press.
+ * @param button - raw SGR press byte (low bits 2 = right button, carries
+ *   shift/alt/ctrl modifier bits).
+ * @returns true when at least one onContextMenu handler fired.
+ */
+export function dispatchContextMenu(root, col, row, button = 0) {
+    const target = hitTestWithOverlays(root, col, row);
+    if (!target)
+        return false;
+    const event = new ContextMenuEvent(col, row, { button });
+    let node = target;
+    let handled = false;
+    while (node) {
+        const handler = node._eventHandlers?.onContextMenu;
+        if (handler) {
+            handled = true;
+            const rect = nodeCache.get(node);
+            if (rect) {
+                event.localCol = col - rect.x;
+                event.localRow = row - rect.y;
+            }
+            else {
+                event.localCol = 0;
+                event.localRow = 0;
+            }
+            try {
+                handler(event);
+            }
+            catch (error) {
+                logError(error);
+            }
+            if (event.didStopImmediatePropagation())
+                return true;
+        }
+        node = node.parentNode;
+    }
+    return handled;
+}
+/**
+ * Find the drag target at (col, row): hit-test the root (overlay-aware,
+ * like dispatchClick), then walk the ancestor chain from the deepest hit
+ * node and return the FIRST node carrying an onDragStart handler. That
+ * node is captured as the drag session target — subsequent dragmove/
+ * dragend events bubble from it even when the pointer leaves its rect.
+ *
+ * @param root - the tree root to hit-test.
+ * @param col - the screen column of the press.
+ * @param row - the screen row of the press.
+ * @returns the deepest node with an onDragStart handler, or null when no
+ *   ancestor of the hit node is a drag target.
+ */
+export function findDragTarget(root, col, row) {
+    let node = hitTestWithOverlays(root, col, row) ?? undefined;
+    while (node) {
+        if (node._eventHandlers?.onDragStart)
+            return node;
+        node = node.parentNode;
+    }
+    return null;
+}
+/**
+ * Bubble a drag event (dragstart/dragmove/dragend) from the captured
+ * drag session target up through parentNode. The handler prop is looked
+ * up per event type (onDragStart/onDragMove/onDragEnd). Stops when a
+ * handler calls stopImmediatePropagation(). Handler isolation matches
+ * dispatchClick — a throwing handler is logged and the bubbling
+ * continues.
+ *
+ * Unlike dispatchClick the target comes from the drag session captured
+ * at press time, NOT a fresh hit-test: like DOM element capture, the
+ * drag source keeps receiving events for the whole gesture.
+ *
+ * @param target - the captured drag session target node.
+ * @param event - the drag event to dispatch.
+ */
+export function dispatchDragEvent(target, event) {
+    // Use the shared dispatcher so target/currentTarget/eventPhase,
+    // stopPropagation, exception isolation, and React update priority match the
+    // rest of the terminal event model. Motion is continuous; lifecycle edges
+    // are discrete user actions.
+    if (event.type === 'dragmove')
+        dispatcher.dispatchContinuous(target, event);
+    else
+        dispatcher.dispatchDiscrete(target, event);
+}
+/**
+ * Fire onMouseLeave on every tracked hover node, then empty the set.
+ *
+ * The pointer-state resets (alt-screen swap, terminal resize) drop the hover
+ * set because the geometry it was computed against is gone. But the React
+ * components behind those nodes still hold their `hovered=true` state: a bare
+ * `set.clear()` never tells them the pointer "left", so every row crossed
+ * before the reset keeps its highlight forever — the next motion event only
+ * fires enter on the new row (the old nodes are no longer in the set, so no
+ * diff ever produces their leave). Firing leave first is what makes the
+ * reset invisible to the rows.
+ *
+ * @param hovered - the tracked hover set; emptied in place.
+ * @param col - pointer column for the synthetic leave events (-1 = unknown).
+ * @param row - pointer row for the synthetic leave events.
+ */
+export function clearHovered(hovered, col = -1, row = -1) {
+    for (const node of hovered) {
+        hovered.delete(node);
+        // Detached nodes (screen already swapped out from under us) can no
+        // longer re-render — skip them; their component state dies with the
+        // subtree anyway.
+        if (!node.parentNode)
+            continue;
+        const handler = node._eventHandlers
+            ?.onMouseLeave;
+        if (handler) {
+            try {
+                handler(new PointerEvent('hover', col, row, { action: 'move' }));
+            }
+            catch (error) {
+                logError(error);
+            }
+        }
+    }
+}
+/**
+ * Route a wheel event to the ScrollBox (or any onWheel handler) under the
+ * pointer. Dispatches through the shared Dispatcher at continuous priority
+ * so the event bubbles from the deepest hit node and React schedules any
+ * state updates at the right lane.
+ *
+ * @param root - the tree root to hit-test.
+ * @param col - the screen column of the wheel event.
+ * @param row - the screen row of the wheel event.
+ * @param deltaY - rows to scroll (positive = scroll down).
+ * @param deltaX - columns to scroll (positive = right; informational).
+ * @param button - raw SGR byte (carries modifier bits).
+ * @returns true when an onWheel handler existed under the pointer.
+ */
+export function dispatchWheel(root, col, row, deltaY, deltaX = 0, button = 0) {
+    const target = hitTestWithOverlays(root, col, row);
+    if (!target)
+        return false;
+    // Does any ancestor (target inclusive) carry an onWheel handler?
+    let node = target;
+    let hasHandler = false;
+    while (node && !hasHandler) {
+        hasHandler = Boolean(node._eventHandlers?.onWheel);
+        node = node.parentNode;
+    }
+    if (!hasHandler)
+        return false;
+    const event = new WheelEvent(col, row, deltaY, deltaX, { button });
+    dispatcher.dispatchContinuous(target, event);
+    return true;
+}
+// Per-root: multiple Ink instances can coexist in tests/embedders and must
+// never reuse geometry from another tree.
+let noInterestRects = new WeakMap();
+/**
+ * Optional hover-interest probe consulted when deciding whether a region is
+ * hover-inert. A tooltip system registers a predicate here so tooltip-
+ * bearing nodes are never skipped by the no-interest fast path. Null (the
+ * default) means only React enter/leave handlers count.
+ */
+let hoverInterestProbe = null;
+/**
+ * Install or clear the hover-interest probe.
+ * @param probe - the interest predicate, or null to clear it.
+ */
+export function setHoverInterestProbe(probe) {
+    hoverInterestProbe = probe;
+}
+/**
+ * Drop the cached no-interest rect. Call at every render commit and at the
+ * start of every render pass (see the cache doc above); also call from
+ * pointer-state resets. Idempotent and effectively free.
+ */
+export function invalidateNoInterestRect() {
+    noInterestRects = new WeakMap();
+}
+/** Whether a node participates in hover semantics (handler or tooltip probe). */
+function hasHoverInterest(node) {
+    const h = node._eventHandlers;
+    if (h?.onMouseEnter || h?.onMouseLeave)
+        return true;
+    return hoverInterestProbe?.(node) === true;
+}
+/**
+ * Fail-fast subtree scan for an overlapping sibling/absolute candidate.
+ * Text children are skipped like hitTest does.
+ */
+function subtreeHasHoverInterest(node) {
+    for (const childNode of node.childNodes) {
+        if (childNode.nodeName === '#text')
+            continue;
+        const child = childNode;
+        if (hasHoverInterest(child) || subtreeHasHoverInterest(child))
+            return true;
+    }
+    return false;
+}
+function hasElementChildren(node) {
+    return node.childNodes.some(child => child.nodeName !== '#text');
+}
+function rectsOverlap(left, right) {
+    return !(right.x >= left.x + left.width ||
+        right.x + right.width <= left.x ||
+        right.y >= left.y + left.height ||
+        right.y + right.height <= left.y);
+}
+/** Whether a hover-interested in-flow sibling can win inside the candidate. */
+function overlappingSiblingHasHoverInterest(hit, rect) {
+    let branch = hit;
+    for (let parent = hit.parentNode; parent; parent = parent.parentNode) {
+        for (const siblingNode of parent.childNodes) {
+            if (siblingNode === branch || siblingNode.nodeName === '#text')
+                continue;
+            const sibling = siblingNode;
+            const siblingRect = nodeCache.get(sibling);
+            if (siblingRect &&
+                rectsOverlap(rect, siblingRect) &&
+                (hasHoverInterest(sibling) || subtreeHasHoverInterest(sibling))) {
+                return true;
+            }
+        }
+        branch = parent;
+    }
+    return false;
+}
+/** Whether a hover-interested absolute layer overlaps a candidate inert rect. */
+function overlappingAbsoluteHasHoverInterest(rect) {
+    for (const entry of getAbsoluteHitList()) {
+        const overlay = entry.rect;
+        if (!rectsOverlap(rect, overlay))
+            continue;
+        if (subtreeHasHoverInterest(entry.node))
+            return true;
+        for (let node = entry.node; node; node = node.parentNode) {
+            if (hasHoverInterest(node))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Fire onMouseEnter/onMouseLeave as the pointer moves. Like DOM
+ * mouseenter/mouseleave: does NOT bubble — moving between children does
+ * not re-fire on the parent. Walks up from the hit node collecting every
+ * ancestor with a hover handler; diffs against the previous hovered set;
+ * fires leave on the nodes exited, enter on the nodes entered.
+ *
+ * Handlers receive a PointerEvent ('hover') with the pointer position;
+ * existing `() => void` handlers simply ignore the argument. Each call is
+ * isolated so one throwing handler cannot break the rest of the diff.
+ *
+ * Mutates `hovered` in place so the caller (App instance) can hold it
+ * across calls. Clears the set when the hit is null (cursor moved into a
+ * non-rendered gap or off the root rect).
+ * @param root - the tree root to hit-test.
+ * @param col - the screen column of the pointer.
+ * @param row - the screen row of the pointer.
+ * @param hovered - the previously hovered element set; updated in place.
+ */
+export function dispatchHover(root, col, row, hovered) {
+    const next = new Set();
+    const cached = noInterestRects.get(root);
+    if (cached &&
+        col >= cached.x &&
+        col < cached.x + cached.width &&
+        row >= cached.y &&
+        row < cached.y + cached.height) {
+        // Pointer still inside the last confirmed hover-inert rect: skip the
+        // full-tree hit-test. `next` stays empty — exactly what a real
+        // hit-test would produce while the rect is valid (the handler topology
+        // is frozen between commits and every commit/frame invalidates the
+        // cache). The diff below still runs, firing any pending leaves
+        // defensively (hovered is empty here by construction — the rect is
+        // only cached right after the diff emptied it).
+    }
+    else {
+        let hit = hitTestWithOverlays(root, col, row) ?? undefined;
+        // Chain walk collects the enter/leave set AND decides cache
+        // eligibility: the rect is only trusted when no node in the hit chain
+        // has any hover interest.
+        let chainInert = true;
+        for (let node = hit; node; node = node.parentNode) {
+            const h = node._eventHandlers;
+            if (h?.onMouseEnter || h?.onMouseLeave) {
+                next.add(node);
+                chainInert = false;
+            }
+            else if (hasHoverInterest(node)) {
+                // Tooltip interest without enter/leave handlers: keeps the region
+                // out of the no-interest cache without joining the hovered set.
+                chainInert = false;
+            }
+        }
+        if (chainInert && hit) {
+            const rect = nodeCache.get(hit);
+            // Cache only a leaf hit region. An empty container with element
+            // descendants may cover a huge area; recursively scanning that subtree
+            // on every motion is O(tree), while caching it can hide a descendant.
+            // Overlapping interested siblings/absolute layers also disqualify the
+            // rect because they can become the topmost hit elsewhere inside it.
+            if (rect &&
+                rect.width > 0 &&
+                rect.height > 0 &&
+                !hasElementChildren(hit) &&
+                !overlappingSiblingHasHoverInterest(hit, rect) &&
+                !overlappingAbsoluteHasHoverInterest(rect)) {
+                // Copy the fields — nodeCache entries are replaced per frame and
+                // the cache dies at the frame boundary anyway, but never alias.
+                noInterestRects.set(root, {
+                    x: rect.x,
+                    y: rect.y,
+                    width: rect.width,
+                    height: rect.height,
+                });
+            }
+        }
+    }
+    for (const old of hovered) {
+        if (!next.has(old)) {
+            hovered.delete(old);
+            // Skip handlers on detached nodes (removed between mouse events)
+            if (old.parentNode) {
+                const handler = old._eventHandlers
+                    ?.onMouseLeave;
+                if (handler) {
+                    try {
+                        handler(new PointerEvent('hover', col, row, { action: 'move' }));
+                    }
+                    catch (error) {
+                        logError(error);
+                    }
+                }
+            }
+        }
+    }
+    for (const n of next) {
+        if (!hovered.has(n)) {
+            hovered.add(n);
+            const handler = n._eventHandlers
+                ?.onMouseEnter;
+            if (handler) {
+                try {
+                    handler(new PointerEvent('hover', col, row, { action: 'move' }));
+                }
+                catch (error) {
+                    logError(error);
+                }
+            }
+        }
+    }
+}

package/lib/types/ink/hooks/use-animation-frame.d.ts

@@ -0,0 +1,27 @@
+import type { DOMElement } from '../dom.js';
+/**
+ * Hook for synchronized animations that pause when offscreen.
+ *
+ * Returns a ref to attach to the animated element and the current animation time.
+ * All instances share the same clock, so animations stay in sync.
+ * The clock only runs when at least one keepAlive subscriber exists.
+ *
+ * Pass `null` to pause — unsubscribes from the clock so no ticks fire.
+ * Time freezes at the last value and resumes from the current clock time
+ * when a number is passed again.
+ *
+ * @param intervalMs - How often to update, or null to pause
+ * @returns [ref, time] - Ref to attach to element, elapsed time in ms
+ *
+ * @example
+ * function Spinner() {
+ *   const [ref, time] = useAnimationFrame(120)
+ *   const frame = Math.floor(time / 120) % FRAMES.length
+ *   return <Box ref={ref}>{FRAMES[frame]}</Box>
+ * }
+ *
+ * The clock automatically slows when the terminal is blurred,
+ * so consumers don't need to handle focus state.
+ */
+export declare function useAnimationFrame(intervalMs?: number | null): [ref: (element: DOMElement | null) => void, time: number];
+//# sourceMappingURL=use-animation-frame.d.ts.map

package/lib/types/ink/hooks/use-animation-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-animation-frame.d.ts","sourceRoot":"","sources":["../../../../src/ink/hooks/use-animation-frame.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAG3C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,GAAE,MAAM,GAAG,IAAS,GAC7B,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAyB3D"}

package/lib/types/ink/hooks/use-animation-frame.js

@@ -0,0 +1,48 @@
+import { useContext, useEffect, useState } from 'react';
+import { ClockContext } from '../components/ClockContext.js';
+import { useTerminalViewport } from './use-terminal-viewport.js';
+/**
+ * Hook for synchronized animations that pause when offscreen.
+ *
+ * Returns a ref to attach to the animated element and the current animation time.
+ * All instances share the same clock, so animations stay in sync.
+ * The clock only runs when at least one keepAlive subscriber exists.
+ *
+ * Pass `null` to pause — unsubscribes from the clock so no ticks fire.
+ * Time freezes at the last value and resumes from the current clock time
+ * when a number is passed again.
+ *
+ * @param intervalMs - How often to update, or null to pause
+ * @returns [ref, time] - Ref to attach to element, elapsed time in ms
+ *
+ * @example
+ * function Spinner() {
+ *   const [ref, time] = useAnimationFrame(120)
+ *   const frame = Math.floor(time / 120) % FRAMES.length
+ *   return <Box ref={ref}>{FRAMES[frame]}</Box>
+ * }
+ *
+ * The clock automatically slows when the terminal is blurred,
+ * so consumers don't need to handle focus state.
+ */
+export function useAnimationFrame(intervalMs = 16) {
+    const clock = useContext(ClockContext);
+    const [viewportRef, { isVisible }] = useTerminalViewport();
+    const [time, setTime] = useState(() => clock?.now() ?? 0);
+    const active = isVisible && intervalMs !== null;
+    useEffect(() => {
+        if (!clock || !active)
+            return;
+        let lastUpdate = clock.now();
+        const onChange = () => {
+            const now = clock.now();
+            if (now - lastUpdate >= intervalMs) {
+                lastUpdate = now;
+                setTime(now);
+            }
+        };
+        // keepAlive: true — visible animations drive the clock
+        return clock.subscribe(onChange, true);
+    }, [clock, intervalMs, active]);
+    return [viewportRef, time];
+}

package/lib/types/ink/hooks/use-app.d.ts

@@ -0,0 +1,7 @@
+import { type Props } from '../components/AppContext.js';
+/**
+ * Access this Ink app's output stream and manual exit handler.
+ */
+declare const useApp: () => Props;
+export default useApp;
+//# sourceMappingURL=use-app.d.ts.map

package/lib/types/ink/hooks/use-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-app.d.ts","sourceRoot":"","sources":["../../../../src/ink/hooks/use-app.ts"],"names":[],"mappings":"AACA,OAAmB,EAAE,KAAK,KAAK,EAAE,MAAM,6BAA6B,CAAA;AAEpE;;GAEG;AACH,QAAA,MAAM,MAAM,QAAO,KAA+B,CAAA;AAClD,eAAe,MAAM,CAAA"}

package/lib/types/ink/hooks/use-app.js

@@ -0,0 +1,7 @@
+import { useContext } from 'react';
+import AppContext from '../components/AppContext.js';
+/**
+ * Access this Ink app's output stream and manual exit handler.
+ */
+const useApp = () => useContext(AppContext);
+export default useApp;

package/lib/types/ink/hooks/use-copy-on-select.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copy-on-select: when a drag finishes (or a double/triple click, or a
+ * shift+arrow extension, lands a selection), copy the selected text to the
+ * clipboard — OSC 52 plus the native-utility fallback — then clear the
+ * highlight so the copy reads as a completed action.
+ *
+ * Implemented as a subscription rather than a mouse-release hook so every
+ * path that settles a selection (release, lost-release recovery, focus-out
+ * recovery, multi-click, keyboard extension) funnels through the same
+ * `notifySelectionChange` and fires the copy exactly once per settle.
+ *
+ * No-op outside fullscreen: without mouse tracking no selection can ever
+ * exist, and `useSelection` returns stubs when there is no Ink instance.
+ * Mount once near the app root (e.g. Chat) — the copy itself is gated on
+ * `hasSelection`, so an always-mounted hook costs one no-op callback per
+ * selection notification.
+ * @param onCopied - called with the copied text after each successful copy
+ *   (e.g. to show a toast). Stored in a ref, so an inline closure is fine
+ *   and never re-subscribes.
+ * @param onRefused - called when the selection was marked stale (its rows
+ *   were replaced in place while highlighted): the highlight is cleared
+ *   and NOTHING is copied — the caller should tell the user why (e.g.
+ *   "content changed, copy cancelled") instead of staying silent.
+ */
+export declare function useCopyOnSelect(onCopied?: (text: string) => void, onRefused?: () => void): void;
+//# sourceMappingURL=use-copy-on-select.d.ts.map

package/lib/types/ink/hooks/use-copy-on-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-on-select.d.ts","sourceRoot":"","sources":["../../../../src/ink/hooks/use-copy-on-select.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EACjC,SAAS,CAAC,EAAE,MAAM,IAAI,GACrB,IAAI,CAyBN"}