@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/context/modalContext.js

@@ -0,0 +1,34 @@
+import { c as _c } from "react/compiler-runtime";
+import { createContext, useContext } from 'react';
+export const ModalContext = createContext(null);
+export function useIsInsideModal() {
+    return useContext(ModalContext) !== null;
+}
+/**
+ * Available content rows/columns when inside a Modal, else falls back to
+ * the provided terminal size. Use instead of `useTerminalSize()` when a
+ * component caps its visible content height — the modal's inner area is
+ * smaller than the terminal.
+ */
+export function useModalOrTerminalSize(fallback) {
+    const $ = _c(3);
+    const ctx = useContext(ModalContext);
+    let t0;
+    if ($[0] !== ctx || $[1] !== fallback) {
+        t0 = ctx ? {
+            rows: ctx.rows,
+            columns: ctx.columns
+        } : fallback;
+        $[0] = ctx;
+        $[1] = fallback;
+        $[2] = t0;
+    }
+    else {
+        t0 = $[2];
+    }
+    return t0;
+}
+export function useModalScrollRef() {
+    return useContext(ModalContext)?.scrollRef ?? null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/context/notifications.js

@@ -0,0 +1,199 @@
+import { useCallback, useEffect } from 'react';
+import { useAppStateStore, useSetAppState } from '../state/AppState.js';
+const DEFAULT_TIMEOUT_MS = 8000;
+// Track current timeout to clear it when immediate notifications arrive
+let currentTimeoutId = null;
+export function useNotifications() {
+    const store = useAppStateStore();
+    const setAppState = useSetAppState();
+    // Process queue when current notification finishes or queue changes
+    const processQueue = useCallback(() => {
+        setAppState(prev => {
+            const next = getNext(prev.notifications.queue);
+            if (prev.notifications.current !== null || !next) {
+                return prev;
+            }
+            currentTimeoutId = setTimeout((setAppState, nextKey, processQueue) => {
+                currentTimeoutId = null;
+                setAppState(prev => {
+                    // Compare by key instead of reference to handle re-created notifications
+                    if (prev.notifications.current?.key !== nextKey) {
+                        return prev;
+                    }
+                    return {
+                        ...prev,
+                        notifications: {
+                            queue: prev.notifications.queue,
+                            current: null
+                        }
+                    };
+                });
+                processQueue();
+            }, next.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, next.key, processQueue);
+            return {
+                ...prev,
+                notifications: {
+                    queue: prev.notifications.queue.filter(_ => _ !== next),
+                    current: next
+                }
+            };
+        });
+    }, [setAppState]);
+    const addNotification = useCallback((notif) => {
+        // Handle immediate priority notifications
+        if (notif.priority === 'immediate') {
+            // Clear any existing timeout since we're showing a new immediate notification
+            if (currentTimeoutId) {
+                clearTimeout(currentTimeoutId);
+                currentTimeoutId = null;
+            }
+            // Set up timeout for the immediate notification
+            currentTimeoutId = setTimeout((setAppState, notif, processQueue) => {
+                currentTimeoutId = null;
+                setAppState(prev => {
+                    // Compare by key instead of reference to handle re-created notifications
+                    if (prev.notifications.current?.key !== notif.key) {
+                        return prev;
+                    }
+                    return {
+                        ...prev,
+                        notifications: {
+                            queue: prev.notifications.queue.filter(_ => !notif.invalidates?.includes(_.key)),
+                            current: null
+                        }
+                    };
+                });
+                processQueue();
+            }, notif.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, notif, processQueue);
+            // Show the immediate notification right away
+            setAppState(prev => ({
+                ...prev,
+                notifications: {
+                    current: notif,
+                    queue: 
+                    // Only re-queue the current notification if it's not immediate
+                    [...(prev.notifications.current ? [prev.notifications.current] : []), ...prev.notifications.queue].filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key))
+                }
+            }));
+            return; // IMPORTANT: Exit addNotification for immediate notifications
+        }
+        // Handle non-immediate notifications
+        setAppState(prev => {
+            // Check if we can fold into an existing notification with the same key
+            if (notif.fold) {
+                // Fold into current notification if keys match
+                if (prev.notifications.current?.key === notif.key) {
+                    const folded = notif.fold(prev.notifications.current, notif);
+                    // Reset timeout for the folded notification
+                    if (currentTimeoutId) {
+                        clearTimeout(currentTimeoutId);
+                        currentTimeoutId = null;
+                    }
+                    currentTimeoutId = setTimeout((setAppState, foldedKey, processQueue) => {
+                        currentTimeoutId = null;
+                        setAppState(p => {
+                            if (p.notifications.current?.key !== foldedKey) {
+                                return p;
+                            }
+                            return {
+                                ...p,
+                                notifications: {
+                                    queue: p.notifications.queue,
+                                    current: null
+                                }
+                            };
+                        });
+                        processQueue();
+                    }, folded.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, folded.key, processQueue);
+                    return {
+                        ...prev,
+                        notifications: {
+                            current: folded,
+                            queue: prev.notifications.queue
+                        }
+                    };
+                }
+                // Fold into queued notification if keys match
+                const queueIdx = prev.notifications.queue.findIndex(_ => _.key === notif.key);
+                if (queueIdx !== -1) {
+                    const folded = notif.fold(prev.notifications.queue[queueIdx], notif);
+                    const newQueue = [...prev.notifications.queue];
+                    newQueue[queueIdx] = folded;
+                    return {
+                        ...prev,
+                        notifications: {
+                            current: prev.notifications.current,
+                            queue: newQueue
+                        }
+                    };
+                }
+            }
+            // Only add to queue if not already present (prevent duplicates)
+            const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key));
+            const shouldAdd = !queuedKeys.has(notif.key) && prev.notifications.current?.key !== notif.key;
+            if (!shouldAdd)
+                return prev;
+            const invalidatesCurrent = prev.notifications.current !== null && notif.invalidates?.includes(prev.notifications.current.key);
+            if (invalidatesCurrent && currentTimeoutId) {
+                clearTimeout(currentTimeoutId);
+                currentTimeoutId = null;
+            }
+            return {
+                ...prev,
+                notifications: {
+                    current: invalidatesCurrent ? null : prev.notifications.current,
+                    queue: [...prev.notifications.queue.filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key)), notif]
+                }
+            };
+        });
+        // Process queue after adding the notification
+        processQueue();
+    }, [setAppState, processQueue]);
+    const removeNotification = useCallback((key) => {
+        setAppState(prev => {
+            const isCurrent = prev.notifications.current?.key === key;
+            const inQueue = prev.notifications.queue.some(n => n.key === key);
+            if (!isCurrent && !inQueue) {
+                return prev;
+            }
+            if (isCurrent && currentTimeoutId) {
+                clearTimeout(currentTimeoutId);
+                currentTimeoutId = null;
+            }
+            return {
+                ...prev,
+                notifications: {
+                    current: isCurrent ? null : prev.notifications.current,
+                    queue: prev.notifications.queue.filter(n => n.key !== key)
+                }
+            };
+        });
+        processQueue();
+    }, [setAppState, processQueue]);
+    // Process queue on mount if there are notifications in the initial state.
+    // Imperative read (not useAppState) — a subscription in a mount-only
+    // effect would be vestigial and make every caller re-render on queue changes.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref
+    useEffect(() => {
+        if (store.getState().notifications.queue.length > 0) {
+            processQueue();
+        }
+    }, []);
+    return {
+        addNotification,
+        removeNotification
+    };
+}
+const PRIORITIES = {
+    immediate: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+};
+export function getNext(queue) {
+    if (queue.length === 0)
+        return undefined;
+    return queue.reduce((min, n) => PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useAppStateStore","useSetAppState","Theme","Priority","BaseNotification","key","invalidates","priority","timeoutMs","fold","accumulator","Notification","incoming","TextNotification","text","color","JSXNotification","jsx","ReactNode","AddNotificationFn","content","RemoveNotificationFn","DEFAULT_TIMEOUT_MS","currentTimeoutId","NodeJS","Timeout","useNotifications","addNotification","removeNotification","store","setAppState","processQueue","prev","next","getNext","notifications","queue","current","setTimeout","nextKey","filter","_","notif","clearTimeout","includes","folded","foldedKey","p","queueIdx","findIndex","newQueue","queuedKeys","Set","map","shouldAdd","has","invalidatesCurrent","isCurrent","inQueue","some","n","getState","length","PRIORITIES","Record","immediate","high","medium","low","undefined","reduce","min"],"sources":["notifications.tsx"],"sourcesContent":["import type * as React from 'react'\nimport { useCallback, useEffect } from 'react'\nimport { useAppStateStore, useSetAppState } from 'src/state/AppState.js'\nimport type { Theme } from '../utils/theme.js'\n\ntype Priority = 'low' | 'medium' | 'high' | 'immediate'\n\ntype BaseNotification = {\n  key: string\n  /**\n   * Keys of notifications that this notification invalidates.\n   * If a notification is invalidated, it will be removed from the queue\n   * and, if currently displayed, cleared immediately.\n   */\n  invalidates?: string[]\n  priority: Priority\n  timeoutMs?: number\n  /**\n   * Combine notifications with the same key, like Array.reduce().\n   * Called as fold(accumulator, incoming) when a notification with a matching\n   * key already exists in the queue or is currently displayed.\n   * Returns the merged notification (should carry fold forward for future merges).\n   */\n  fold?: (accumulator: Notification, incoming: Notification) => Notification\n}\n\ntype TextNotification = BaseNotification & {\n  text: string\n  color?: keyof Theme\n}\n\ntype JSXNotification = BaseNotification & {\n  jsx: React.ReactNode\n}\n\ntype AddNotificationFn = (content: Notification) => void\ntype RemoveNotificationFn = (key: string) => void\n\nexport type Notification = TextNotification | JSXNotification\n\nconst DEFAULT_TIMEOUT_MS = 8000\n\n// Track current timeout to clear it when immediate notifications arrive\nlet currentTimeoutId: NodeJS.Timeout | null = null\n\nexport function useNotifications(): {\n  addNotification: AddNotificationFn\n  removeNotification: RemoveNotificationFn\n} {\n  const store = useAppStateStore()\n  const setAppState = useSetAppState()\n\n  // Process queue when current notification finishes or queue changes\n  const processQueue = useCallback(() => {\n    setAppState(prev => {\n      const next = getNext(prev.notifications.queue)\n      if (prev.notifications.current !== null || !next) {\n        return prev\n      }\n\n      currentTimeoutId = setTimeout(\n        (setAppState, nextKey, processQueue) => {\n          currentTimeoutId = null\n          setAppState(prev => {\n            // Compare by key instead of reference to handle re-created notifications\n            if (prev.notifications.current?.key !== nextKey) {\n              return prev\n            }\n            return {\n              ...prev,\n              notifications: {\n                queue: prev.notifications.queue,\n                current: null,\n              },\n            }\n          })\n          processQueue()\n        },\n        next.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n        setAppState,\n        next.key,\n        processQueue,\n      )\n\n      return {\n        ...prev,\n        notifications: {\n          queue: prev.notifications.queue.filter(_ => _ !== next),\n          current: next,\n        },\n      }\n    })\n  }, [setAppState])\n\n  const addNotification = useCallback<AddNotificationFn>(\n    (notif: Notification) => {\n      // Handle immediate priority notifications\n      if (notif.priority === 'immediate') {\n        // Clear any existing timeout since we're showing a new immediate notification\n        if (currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        // Set up timeout for the immediate notification\n        currentTimeoutId = setTimeout(\n          (setAppState, notif, processQueue) => {\n            currentTimeoutId = null\n            setAppState(prev => {\n              // Compare by key instead of reference to handle re-created notifications\n              if (prev.notifications.current?.key !== notif.key) {\n                return prev\n              }\n              return {\n                ...prev,\n                notifications: {\n                  queue: prev.notifications.queue.filter(\n                    _ => !notif.invalidates?.includes(_.key),\n                  ),\n                  current: null,\n                },\n              }\n            })\n            processQueue()\n          },\n          notif.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n          setAppState,\n          notif,\n          processQueue,\n        )\n\n        // Show the immediate notification right away\n        setAppState(prev => ({\n          ...prev,\n          notifications: {\n            current: notif,\n            queue:\n              // Only re-queue the current notification if it's not immediate\n              [\n                ...(prev.notifications.current\n                  ? [prev.notifications.current]\n                  : []),\n                ...prev.notifications.queue,\n              ].filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n          },\n        }))\n        return // IMPORTANT: Exit addNotification for immediate notifications\n      }\n\n      // Handle non-immediate notifications\n      setAppState(prev => {\n        // Check if we can fold into an existing notification with the same key\n        if (notif.fold) {\n          // Fold into current notification if keys match\n          if (prev.notifications.current?.key === notif.key) {\n            const folded = notif.fold(prev.notifications.current, notif)\n            // Reset timeout for the folded notification\n            if (currentTimeoutId) {\n              clearTimeout(currentTimeoutId)\n              currentTimeoutId = null\n            }\n            currentTimeoutId = setTimeout(\n              (setAppState, foldedKey, processQueue) => {\n                currentTimeoutId = null\n                setAppState(p => {\n                  if (p.notifications.current?.key !== foldedKey) {\n                    return p\n                  }\n                  return {\n                    ...p,\n                    notifications: {\n                      queue: p.notifications.queue,\n                      current: null,\n                    },\n                  }\n                })\n                processQueue()\n              },\n              folded.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n              setAppState,\n              folded.key,\n              processQueue,\n            )\n\n            return {\n              ...prev,\n              notifications: {\n                current: folded,\n                queue: prev.notifications.queue,\n              },\n            }\n          }\n\n          // Fold into queued notification if keys match\n          const queueIdx = prev.notifications.queue.findIndex(\n            _ => _.key === notif.key,\n          )\n          if (queueIdx !== -1) {\n            const folded = notif.fold(\n              prev.notifications.queue[queueIdx]!,\n              notif,\n            )\n            const newQueue = [...prev.notifications.queue]\n            newQueue[queueIdx] = folded\n            return {\n              ...prev,\n              notifications: {\n                current: prev.notifications.current,\n                queue: newQueue,\n              },\n            }\n          }\n        }\n\n        // Only add to queue if not already present (prevent duplicates)\n        const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key))\n        const shouldAdd =\n          !queuedKeys.has(notif.key) &&\n          prev.notifications.current?.key !== notif.key\n\n        if (!shouldAdd) return prev\n\n        const invalidatesCurrent =\n          prev.notifications.current !== null &&\n          notif.invalidates?.includes(prev.notifications.current.key)\n\n        if (invalidatesCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: invalidatesCurrent ? null : prev.notifications.current,\n            queue: [\n              ...prev.notifications.queue.filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n              notif,\n            ],\n          },\n        }\n      })\n\n      // Process queue after adding the notification\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  const removeNotification = useCallback<RemoveNotificationFn>(\n    (key: string) => {\n      setAppState(prev => {\n        const isCurrent = prev.notifications.current?.key === key\n        const inQueue = prev.notifications.queue.some(n => n.key === key)\n\n        if (!isCurrent && !inQueue) {\n          return prev\n        }\n\n        if (isCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: isCurrent ? null : prev.notifications.current,\n            queue: prev.notifications.queue.filter(n => n.key !== key),\n          },\n        }\n      })\n\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  // Process queue on mount if there are notifications in the initial state.\n  // Imperative read (not useAppState) — a subscription in a mount-only\n  // effect would be vestigial and make every caller re-render on queue changes.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref\n  useEffect(() => {\n    if (store.getState().notifications.queue.length > 0) {\n      processQueue()\n    }\n  }, [])\n\n  return { addNotification, removeNotification }\n}\n\nconst PRIORITIES: Record<Priority, number> = {\n  immediate: 0,\n  high: 1,\n  medium: 2,\n  low: 3,\n}\nexport function getNext(queue: Notification[]): Notification | undefined {\n  if (queue.length === 0) return undefined\n  return queue.reduce((min, n) =>\n    PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min,\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/src/context/overlayContext.js

@@ -0,0 +1,149 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Overlay tracking for Escape key coordination.
+ *
+ * This solves the problem of escape key handling when overlays (like Select with onCancel)
+ * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't
+ * cancel requests when the user just wants to dismiss the overlay.
+ *
+ * Usage:
+ * 1. Call useRegisterOverlay() in any overlay component to automatically register it
+ * 2. Call useIsOverlayActive() to check if any overlay is currently active
+ *
+ * The hook automatically registers on mount and unregisters on unmount,
+ * so no manual cleanup or state management is needed.
+ */
+import { useContext, useEffect, useLayoutEffect } from 'react';
+import instances from '../ink/instances.js';
+import { AppStoreContext, useAppState } from '../state/AppState.js';
+// Non-modal overlays that shouldn't disable TextInput focus
+const NON_MODAL_OVERLAYS = new Set(['autocomplete']);
+/**
+ * Hook to register a component as an active overlay.
+ * Automatically registers on mount and unregisters on unmount.
+ *
+ * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')
+ * @param enabled - Whether to register (default: true). Use this to conditionally register
+ *                  based on component props, e.g., only register when onCancel is provided.
+ *
+ * @example
+ * // Conditional registration based on whether cancel is supported
+ * function useSelectInput({ state }) {
+ *   useRegisterOverlay('select', !!state.onCancel)
+ *   // ...
+ * }
+ */
+export function useRegisterOverlay(id, t0) {
+    const $ = _c(8);
+    const enabled = t0 === undefined ? true : t0;
+    const store = useContext(AppStoreContext);
+    const setAppState = store?.setState;
+    let t1;
+    let t2;
+    if ($[0] !== enabled || $[1] !== id || $[2] !== setAppState) {
+        t1 = () => {
+            if (!enabled || !setAppState) {
+                return;
+            }
+            setAppState(prev => {
+                if (prev.activeOverlays.has(id)) {
+                    return prev;
+                }
+                const next = new Set(prev.activeOverlays);
+                next.add(id);
+                return {
+                    ...prev,
+                    activeOverlays: next
+                };
+            });
+            return () => {
+                setAppState(prev_0 => {
+                    if (!prev_0.activeOverlays.has(id)) {
+                        return prev_0;
+                    }
+                    const next_0 = new Set(prev_0.activeOverlays);
+                    next_0.delete(id);
+                    return {
+                        ...prev_0,
+                        activeOverlays: next_0
+                    };
+                });
+            };
+        };
+        t2 = [id, enabled, setAppState];
+        $[0] = enabled;
+        $[1] = id;
+        $[2] = setAppState;
+        $[3] = t1;
+        $[4] = t2;
+    }
+    else {
+        t1 = $[3];
+        t2 = $[4];
+    }
+    useEffect(t1, t2);
+    let t3;
+    let t4;
+    if ($[5] !== enabled) {
+        t3 = () => {
+            if (!enabled) {
+                return;
+            }
+            return _temp;
+        };
+        t4 = [enabled];
+        $[5] = enabled;
+        $[6] = t3;
+        $[7] = t4;
+    }
+    else {
+        t3 = $[6];
+        t4 = $[7];
+    }
+    useLayoutEffect(t3, t4);
+}
+/**
+ * Hook to check if any overlay is currently active.
+ * This is reactive - the component will re-render when the overlay state changes.
+ *
+ * @returns true if any overlay is currently active
+ *
+ * @example
+ * function CancelRequestHandler() {
+ *   const isOverlayActive = useIsOverlayActive()
+ *   const isActive = !isOverlayActive && canCancelRunningTask
+ *   useKeybinding('chat:cancel', handleCancel, { isActive })
+ * }
+ */
+function _temp() {
+    return instances.get(process.stdout)?.invalidatePrevFrame();
+}
+export function useIsOverlayActive() {
+    return useAppState(_temp2);
+}
+/**
+ * Hook to check if any modal overlay is currently active.
+ * Modal overlays are overlays that should capture all input (like Select dialogs).
+ * Non-modal overlays (like autocomplete) don't disable TextInput focus.
+ *
+ * @returns true if any modal overlay is currently active
+ *
+ * @example
+ * // Use for TextInput focus - allows typing during autocomplete
+ * focus: !isSearchingHistory && !isModalOverlayActive
+ */
+function _temp2(s) {
+    return s.activeOverlays.size > 0;
+}
+export function useIsModalOverlayActive() {
+    return useAppState(_temp3);
+}
+function _temp3(s) {
+    for (const id of s.activeOverlays) {
+        if (!NON_MODAL_OVERLAYS.has(id)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useContext","useEffect","useLayoutEffect","instances","AppStoreContext","useAppState","NON_MODAL_OVERLAYS","Set","useRegisterOverlay","id","t0","$","_c","enabled","undefined","store","setAppState","setState","t1","t2","prev","activeOverlays","has","next","add","prev_0","next_0","delete","t3","t4","_temp","get","process","stdout","invalidatePrevFrame","useIsOverlayActive","_temp2","s","size","useIsModalOverlayActive","_temp3"],"sources":["overlayContext.tsx"],"sourcesContent":["/**\n * Overlay tracking for Escape key coordination.\n *\n * This solves the problem of escape key handling when overlays (like Select with onCancel)\n * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't\n * cancel requests when the user just wants to dismiss the overlay.\n *\n * Usage:\n * 1. Call useRegisterOverlay() in any overlay component to automatically register it\n * 2. Call useIsOverlayActive() to check if any overlay is currently active\n *\n * The hook automatically registers on mount and unregisters on unmount,\n * so no manual cleanup or state management is needed.\n */\nimport { useContext, useEffect, useLayoutEffect } from 'react'\nimport instances from '../ink/instances.js'\nimport { AppStoreContext, useAppState } from '../state/AppState.js'\n\n// Non-modal overlays that shouldn't disable TextInput focus\nconst NON_MODAL_OVERLAYS = new Set(['autocomplete'])\n\n/**\n * Hook to register a component as an active overlay.\n * Automatically registers on mount and unregisters on unmount.\n *\n * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')\n * @param enabled - Whether to register (default: true). Use this to conditionally register\n *                  based on component props, e.g., only register when onCancel is provided.\n *\n * @example\n * // Conditional registration based on whether cancel is supported\n * function useSelectInput({ state }) {\n *   useRegisterOverlay('select', !!state.onCancel)\n *   // ...\n * }\n */\nexport function useRegisterOverlay(id: string, enabled = true): void {\n  // Use context directly so this is a no-op when rendered outside AppStateProvider\n  // (e.g., in isolated component tests that don't need the full app state tree).\n  const store = useContext(AppStoreContext)\n  const setAppState = store?.setState\n  useEffect(() => {\n    if (!enabled || !setAppState) return\n    setAppState(prev => {\n      if (prev.activeOverlays.has(id)) return prev\n      const next = new Set(prev.activeOverlays)\n      next.add(id)\n      return { ...prev, activeOverlays: next }\n    })\n    return () => {\n      setAppState(prev => {\n        if (!prev.activeOverlays.has(id)) return prev\n        const next = new Set(prev.activeOverlays)\n        next.delete(id)\n        return { ...prev, activeOverlays: next }\n      })\n    }\n  }, [id, enabled, setAppState])\n\n  // On overlay close, force the next render to full-damage diff instead\n  // of blit. A tall overlay (e.g. FuzzyPicker with a 20-line preview)\n  // shrinks the Ink-managed region on unmount; the blit fast path can\n  // copy stale cells from the overlay's previous frame into rows the\n  // shorter layout no longer reaches, leaving a ghost title/divider.\n  // useLayoutEffect so cleanup runs synchronously before the microtask-\n  // deferred onRender (scheduleRender queues a microtask from\n  // resetAfterCommit; passive-effect cleanup would land after it).\n  useLayoutEffect(() => {\n    if (!enabled) return\n    return () => instances.get(process.stdout)?.invalidatePrevFrame()\n  }, [enabled])\n}\n\n/**\n * Hook to check if any overlay is currently active.\n * This is reactive - the component will re-render when the overlay state changes.\n *\n * @returns true if any overlay is currently active\n *\n * @example\n * function CancelRequestHandler() {\n *   const isOverlayActive = useIsOverlayActive()\n *   const isActive = !isOverlayActive && canCancelRunningTask\n *   useKeybinding('chat:cancel', handleCancel, { isActive })\n * }\n */\nexport function useIsOverlayActive(): boolean {\n  return useAppState(s => s.activeOverlays.size > 0)\n}\n\n/**\n * Hook to check if any modal overlay is currently active.\n * Modal overlays are overlays that should capture all input (like Select dialogs).\n * Non-modal overlays (like autocomplete) don't disable TextInput focus.\n *\n * @returns true if any modal overlay is currently active\n *\n * @example\n * // Use for TextInput focus - allows typing during autocomplete\n * focus: !isSearchingHistory && !isModalOverlayActive\n */\nexport function useIsModalOverlayActive(): boolean {\n  return useAppState(s => {\n    for (const id of s.activeOverlays) {\n      if (!NON_MODAL_OVERLAYS.has(id)) return true\n    }\n    return false\n  })\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/src/context/promptOverlayContext.js

@@ -0,0 +1,118 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Portal for content that floats above the prompt so it escapes
+ * FullscreenLayout's bottom-slot `overflowY:hidden` clip.
+ *
+ * The clip is load-bearing (CC-668: tall pastes squash the ScrollBox
+ * without it), but floating overlays use `position:absolute
+ * bottom="100%"` to float above the prompt — and Ink's clip stack
+ * intersects ALL descendants, so they were clipped to ~1 row.
+ *
+ * Two channels:
+ * - `useSetPromptOverlay` — slash-command suggestion data (structured,
+ *   written by PromptInputFooter)
+ * - `useSetPromptOverlayDialog` — arbitrary dialog node (e.g.
+ *   AutoModeOptInDialog, written by PromptInput)
+ *
+ * FullscreenLayout reads both and renders them outside the clipped slot.
+ *
+ * Split into data/setter context pairs so writers never re-render on
+ * their own writes — the setter contexts are stable.
+ */
+import { createContext, useContext, useEffect, useState } from 'react';
+const DataContext = createContext(null);
+const SetContext = createContext(null);
+const DialogContext = createContext(null);
+const SetDialogContext = createContext(null);
+export function PromptOverlayProvider(t0) {
+    const $ = _c(6);
+    const { children } = t0;
+    const [data, setData] = useState(null);
+    const [dialog, setDialog] = useState(null);
+    let t1;
+    if ($[0] !== children || $[1] !== dialog) {
+        t1 = _jsx(DialogContext.Provider, { value: dialog, children: children });
+        $[0] = children;
+        $[1] = dialog;
+        $[2] = t1;
+    }
+    else {
+        t1 = $[2];
+    }
+    let t2;
+    if ($[3] !== data || $[4] !== t1) {
+        t2 = _jsx(SetContext.Provider, { value: setData, children: _jsx(SetDialogContext.Provider, { value: setDialog, children: _jsx(DataContext.Provider, { value: data, children: t1 }) }) });
+        $[3] = data;
+        $[4] = t1;
+        $[5] = t2;
+    }
+    else {
+        t2 = $[5];
+    }
+    return t2;
+}
+export function usePromptOverlay() {
+    return useContext(DataContext);
+}
+export function usePromptOverlayDialog() {
+    return useContext(DialogContext);
+}
+/**
+ * Register suggestion data for the floating overlay. Clears on unmount.
+ * No-op outside the provider (non-fullscreen renders inline instead).
+ */
+export function useSetPromptOverlay(data) {
+    const $ = _c(4);
+    const set = useContext(SetContext);
+    let t0;
+    let t1;
+    if ($[0] !== data || $[1] !== set) {
+        t0 = () => {
+            if (!set) {
+                return;
+            }
+            set(data);
+            return () => set(null);
+        };
+        t1 = [set, data];
+        $[0] = data;
+        $[1] = set;
+        $[2] = t0;
+        $[3] = t1;
+    }
+    else {
+        t0 = $[2];
+        t1 = $[3];
+    }
+    useEffect(t0, t1);
+}
+/**
+ * Register a dialog node to float above the prompt. Clears on unmount.
+ * No-op outside the provider (non-fullscreen renders inline instead).
+ */
+export function useSetPromptOverlayDialog(node) {
+    const $ = _c(4);
+    const set = useContext(SetDialogContext);
+    let t0;
+    let t1;
+    if ($[0] !== node || $[1] !== set) {
+        t0 = () => {
+            if (!set) {
+                return;
+            }
+            set(node);
+            return () => set(null);
+        };
+        t1 = [set, node];
+        $[0] = node;
+        $[1] = set;
+        $[2] = t0;
+        $[3] = t1;
+    }
+    else {
+        t0 = $[2];
+        t1 = $[3];
+    }
+    useEffect(t0, t1);
+}