giggles 0.2.4 → 0.3.1

package/dist/index.js

@@ -1,427 +1,29 @@
-// src/core/GigglesError.ts
-var GigglesError = class extends Error {
-  constructor(message) {
-    super(`[giggles] ${message}`);
-    this.name = "GigglesError";
-  }
-};
-
-// src/core/focus/FocusContext.tsx
-import { createContext, useCallback, useContext, useRef, useState } from "react";
-import { jsx } from "react/jsx-runtime";
-var FocusContext = createContext(null);
-var FocusProvider = ({ children }) => {
-  const nodesRef = useRef(/* @__PURE__ */ new Map());
-  const pendingFocusFirstChildRef = useRef(/* @__PURE__ */ new Set());
-  const [focusedId, setFocusedId] = useState(null);
-  const [activeBranchNodes, setActiveBranchNodes] = useState(/* @__PURE__ */ new Set());
-  const [activeBranchPath, setActiveBranchPath] = useState([]);
-  const focusNode = useCallback((id) => {
-    const nodes = nodesRef.current;
-    if (!nodes.has(id)) return;
-    setFocusedId((current) => {
-      if (current === id) return current;
-      const pathSet = /* @__PURE__ */ new Set();
-      const pathArray = [];
-      let currentNode = id;
-      while (currentNode) {
-        pathSet.add(currentNode);
-        pathArray.push(currentNode);
-        const node = nodes.get(currentNode);
-        currentNode = (node == null ? void 0 : node.parentId) ?? null;
-      }
-      setActiveBranchNodes(pathSet);
-      setActiveBranchPath(pathArray);
-      return id;
-    });
-  }, []);
-  const focusFirstChild = useCallback(
-    (parentId) => {
-      const nodes = nodesRef.current;
-      const parent = nodes.get(parentId);
-      if (parent && parent.childrenIds.length > 0) {
-        focusNode(parent.childrenIds[0]);
-      } else {
-        pendingFocusFirstChildRef.current.add(parentId);
-      }
-    },
-    [focusNode]
-  );
-  const registerNode = useCallback(
-    (id, parentId) => {
-      const nodes = nodesRef.current;
-      const node = {
-        id,
-        parentId,
-        childrenIds: []
-      };
-      nodes.set(id, node);
-      if (parentId) {
-        const parent = nodes.get(parentId);
-        if (parent && !parent.childrenIds.includes(id)) {
-          const wasEmpty = parent.childrenIds.length === 0;
-          parent.childrenIds.push(id);
-          if (wasEmpty && pendingFocusFirstChildRef.current.has(parentId)) {
-            pendingFocusFirstChildRef.current.delete(parentId);
-            focusNode(id);
-          }
-        }
-      }
-      nodes.forEach((existingNode) => {
-        if (existingNode.parentId === id && !node.childrenIds.includes(existingNode.id)) {
-          node.childrenIds.push(existingNode.id);
-        }
-      });
-      if (nodes.size === 1) {
-        focusNode(id);
-      }
-    },
-    [focusNode]
-  );
-  const unregisterNode = useCallback((id) => {
-    const nodes = nodesRef.current;
-    const node = nodes.get(id);
-    if (!node) return;
-    if (node.parentId) {
-      const parent = nodes.get(node.parentId);
-      if (parent) {
-        parent.childrenIds = parent.childrenIds.filter((childId) => childId !== id);
-      }
-    }
-    nodes.delete(id);
-    pendingFocusFirstChildRef.current.delete(id);
-    setFocusedId((current) => {
-      if (current !== id) return current;
-      if (node.parentId) {
-        const pathSet = /* @__PURE__ */ new Set();
-        const pathArray = [];
-        let currentNode = node.parentId;
-        while (currentNode) {
-          pathSet.add(currentNode);
-          pathArray.push(currentNode);
-          const n = nodes.get(currentNode);
-          currentNode = (n == null ? void 0 : n.parentId) ?? null;
-        }
-        setActiveBranchNodes(pathSet);
-        setActiveBranchPath(pathArray);
-        return node.parentId;
-      }
-      setActiveBranchNodes(/* @__PURE__ */ new Set());
-      setActiveBranchPath([]);
-      return null;
-    });
-  }, []);
-  const isFocused = useCallback(
-    (id) => {
-      return id === focusedId;
-    },
-    [focusedId]
-  );
-  const getFocusedId = useCallback(() => {
-    return focusedId;
-  }, [focusedId]);
-  const isInActiveBranch = useCallback(
-    (id) => {
-      return activeBranchNodes.has(id);
-    },
-    [activeBranchNodes]
-  );
-  const getActiveBranchPath = useCallback(() => {
-    return activeBranchPath;
-  }, [activeBranchPath]);
-  const navigateSibling = useCallback(
-    (direction, wrap = true) => {
-      const currentId = focusedId;
-      if (!currentId) return;
-      const nodes = nodesRef.current;
-      const currentNode = nodes.get(currentId);
-      if (!(currentNode == null ? void 0 : currentNode.parentId)) return;
-      const parent = nodes.get(currentNode.parentId);
-      if (!parent || parent.childrenIds.length === 0) return;
-      const siblings = parent.childrenIds;
-      const currentIndex = siblings.indexOf(currentId);
-      if (currentIndex === -1) return;
-      let nextIndex;
-      if (wrap) {
-        nextIndex = direction === "next" ? (currentIndex + 1) % siblings.length : (currentIndex - 1 + siblings.length) % siblings.length;
-      } else {
-        nextIndex = direction === "next" ? Math.min(currentIndex + 1, siblings.length - 1) : Math.max(currentIndex - 1, 0);
-      }
-      focusNode(siblings[nextIndex]);
-    },
-    [focusedId, focusNode]
-  );
-  return /* @__PURE__ */ jsx(
-    FocusContext.Provider,
-    {
-      value: {
-        registerNode,
-        unregisterNode,
-        focusNode,
-        focusFirstChild,
-        isFocused,
-        getFocusedId,
-        isInActiveBranch,
-        getActiveBranchPath,
-        navigateSibling
-      },
-      children
-    }
-  );
-};
-var FocusNodeContext = createContext(null);
-var useFocusContext = () => {
-  const context = useContext(FocusContext);
-  if (!context) {
-    throw new GigglesError("useFocusContext must be used within a FocusProvider");
-  }
-  return context;
-};
-
-// src/core/focus/FocusGroup.tsx
-import { useCallback as useCallback3, useEffect as useEffect4, useMemo, useRef as useRef3 } from "react";
-
-// src/core/input/InputContext.tsx
-import { createContext as createContext2, useCallback as useCallback2, useContext as useContext2, useRef as useRef2 } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var InputContext = createContext2(null);
-var InputProvider = ({ children }) => {
-  const bindingsRef = useRef2(/* @__PURE__ */ new Map());
-  const trapNodeIdRef = useRef2(null);
-  const registerKeybindings = useCallback2((nodeId, bindings, options) => {
-    const registration = {
-      bindings: new Map(Object.entries(bindings).filter((entry) => entry[1] != null)),
-      capture: (options == null ? void 0 : options.capture) ?? false,
-      onKeypress: options == null ? void 0 : options.onKeypress,
-      layer: options == null ? void 0 : options.layer
-    };
-    bindingsRef.current.set(nodeId, registration);
-  }, []);
-  const unregisterKeybindings = useCallback2((nodeId) => {
-    bindingsRef.current.delete(nodeId);
-  }, []);
-  const getNodeBindings = useCallback2((nodeId) => {
-    return bindingsRef.current.get(nodeId);
-  }, []);
-  const setTrap = useCallback2((nodeId) => {
-    trapNodeIdRef.current = nodeId;
-  }, []);
-  const clearTrap = useCallback2((nodeId) => {
-    if (trapNodeIdRef.current === nodeId) {
-      trapNodeIdRef.current = null;
-    }
-  }, []);
-  const getTrapNodeId = useCallback2(() => {
-    return trapNodeIdRef.current;
-  }, []);
-  const getAllBindings = useCallback2(() => {
-    const allBindings = [];
-    bindingsRef.current.forEach((nodeBindings, nodeId) => {
-      nodeBindings.bindings.forEach((handler, key) => {
-        allBindings.push({
-          nodeId,
-          key,
-          handler,
-          layer: nodeBindings.layer
-        });
-      });
-    });
-    return allBindings;
-  }, []);
-  return /* @__PURE__ */ jsx2(
-    InputContext.Provider,
-    {
-      value: {
-        registerKeybindings,
-        unregisterKeybindings,
-        getNodeBindings,
-        setTrap,
-        clearTrap,
-        getTrapNodeId,
-        getAllBindings
-      },
-      children
-    }
-  );
-};
-function useInputContext() {
-  const context = useContext2(InputContext);
-  if (!context) {
-    throw new GigglesError("useInputContext must be used within an InputProvider");
-  }
-  return context;
-}
-
-// src/core/input/InputRouter.tsx
-import { useInput } from "ink";
-
-// src/core/input/normalizeKey.ts
-function normalizeKey(input, key) {
-  if (key.downArrow) return "down";
-  if (key.upArrow) return "up";
-  if (key.leftArrow) return "left";
-  if (key.rightArrow) return "right";
-  if (key.return) return "enter";
-  if (key.escape) return "escape";
-  if (key.tab) return "tab";
-  if (key.backspace) return "backspace";
-  if (key.delete) return "delete";
-  if (key.pageUp) return "pageup";
-  if (key.pageDown) return "pagedown";
-  if (key.home) return "home";
-  if (key.end) return "end";
-  return input;
-}
-
-// src/core/input/InputRouter.tsx
-import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
-function InputRouter({ children }) {
-  const { getFocusedId, getActiveBranchPath } = useFocusContext();
-  const { getNodeBindings, getTrapNodeId } = useInputContext();
-  useInput((input, key) => {
-    const focusedId = getFocusedId();
-    if (!focusedId) return;
-    const path = getActiveBranchPath();
-    const trapNodeId = getTrapNodeId();
-    const keyName = normalizeKey(input, key);
-    for (const nodeId of path) {
-      const nodeBindings = getNodeBindings(nodeId);
-      if (!nodeBindings) continue;
-      const handler = nodeBindings.bindings.get(keyName);
-      if (handler) {
-        handler(input, key);
-        return;
-      }
-      if (nodeBindings.capture && nodeBindings.onKeypress) {
-        nodeBindings.onKeypress(input, key);
-        return;
-      }
-      if (nodeId === trapNodeId) {
-        return;
-      }
-    }
-  });
-  return /* @__PURE__ */ jsx3(Fragment, { children });
-}
-
-// src/core/input/useKeybindings.tsx
-import { useEffect } from "react";
-function useKeybindings(focus, bindings, options) {
-  const { registerKeybindings, unregisterKeybindings } = useInputContext();
-  registerKeybindings(focus.id, bindings, options);
-  useEffect(() => {
-    return () => unregisterKeybindings(focus.id);
-  }, [focus.id, unregisterKeybindings]);
-}
-
-// src/core/input/FocusTrap.tsx
-import { useEffect as useEffect2 } from "react";
-import { Fragment as Fragment2, jsx as jsx4 } from "react/jsx-runtime";
-function FocusTrap({ children }) {
-  const { id } = useFocus();
-  const { setTrap, clearTrap } = useInputContext();
-  useEffect2(() => {
-    setTrap(id);
-    return () => clearTrap(id);
-  }, [id, setTrap, clearTrap]);
-  return /* @__PURE__ */ jsx4(Fragment2, { children });
-}
-
-// src/core/focus/FocusBindContext.tsx
-import { createContext as createContext3 } from "react";
-var FocusBindContext = createContext3(null);
-
-// src/core/focus/useFocus.ts
-import { useContext as useContext3, useEffect as useEffect3, useId } from "react";
-var useFocus = (id) => {
-  const nodeId = useId();
-  const parentId = useContext3(FocusNodeContext);
-  const bindContext = useContext3(FocusBindContext);
-  const { focusNode, registerNode, unregisterNode, isFocused } = useFocusContext();
-  useEffect3(() => {
-    registerNode(nodeId, parentId);
-    if (id && bindContext) {
-      bindContext.register(id, nodeId);
-    }
-    return () => {
-      unregisterNode(nodeId);
-      if (id && bindContext) {
-        bindContext.unregister(id);
-      }
-    };
-  }, [nodeId, parentId, id, bindContext, registerNode, unregisterNode]);
-  return {
-    id: nodeId,
-    focused: isFocused(nodeId),
-    focus: () => focusNode(nodeId)
-  };
-};
-
-// src/core/focus/FocusGroup.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
-function FocusGroup({
-  children,
-  direction = "vertical",
-  value,
-  wrap = true,
-  navigable = true
-}) {
-  const focus = useFocus();
-  const { focusNode, navigateSibling } = useFocusContext();
-  const bindMapRef = useRef3(/* @__PURE__ */ new Map());
-  const register = useCallback3((logicalId, nodeId) => {
-    if (bindMapRef.current.has(logicalId)) {
-      throw new GigglesError(`FocusGroup: Duplicate id "${logicalId}". Each child must have a unique id.`);
-    }
-    bindMapRef.current.set(logicalId, nodeId);
-  }, []);
-  const unregister = useCallback3((logicalId) => {
-    bindMapRef.current.delete(logicalId);
-  }, []);
-  useEffect4(() => {
-    if (value) {
-      const nodeId = bindMapRef.current.get(value);
-      if (nodeId) {
-        focusNode(nodeId);
-      }
-    }
-  }, [value, focusNode]);
-  const bindContextValue = value ? { register, unregister } : null;
-  const navigationKeys = useMemo(() => {
-    if (!navigable) return {};
-    const next = () => navigateSibling("next", wrap);
-    const prev = () => navigateSibling("prev", wrap);
-    return direction === "vertical" ? {
-      j: next,
-      k: prev,
-      down: next,
-      up: prev
-    } : {
-      l: next,
-      h: prev,
-      right: next,
-      left: prev
-    };
-  }, [navigable, direction, wrap, navigateSibling]);
-  useKeybindings(focus, navigationKeys);
-  return /* @__PURE__ */ jsx5(FocusNodeContext.Provider, { value: focus.id, children: /* @__PURE__ */ jsx5(FocusBindContext.Provider, { value: bindContextValue, children }) });
-}
-
-// src/core/focus/useFocusState.ts
-import { useState as useState2 } from "react";
-function useFocusState(initial) {
-  const [focused, setFocused] = useState2(initial);
-  return [focused, setFocused];
-}
+import {
+  AlternateScreen
+} from "./chunk-7PDVDYFB.js";
+import {
+  FocusGroup,
+  FocusNodeContext,
+  FocusProvider,
+  FocusTrap,
+  GigglesError,
+  InputProvider,
+  InputRouter,
+  useFocus,
+  useFocusContext,
+  useFocusState,
+  useKeybindingRegistry,
+  useKeybindings
+} from "./chunk-4LED4GXQ.js";
 
 // src/core/GigglesProvider.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 function GigglesProvider({ children }) {
-  return /* @__PURE__ */ jsx6(FocusProvider, { children: /* @__PURE__ */ jsx6(InputProvider, { children: /* @__PURE__ */ jsx6(InputRouter, { children }) }) });
+  return /* @__PURE__ */ jsx(AlternateScreen, { children: /* @__PURE__ */ jsx(FocusProvider, { children: /* @__PURE__ */ jsx(InputProvider, { children: /* @__PURE__ */ jsx(InputRouter, { children }) }) }) });
 }
 
 // src/core/router/Router.tsx
-import React4, { useCallback as useCallback4, useReducer, useRef as useRef5 } from "react";
+import React2, { useCallback, useReducer, useRef as useRef2 } from "react";
 
 // src/core/router/Screen.tsx
 function Screen(_props) {
@@ -429,14 +31,14 @@ function Screen(_props) {
 }
 
 // src/core/router/ScreenEntry.tsx
-import React3, { useEffect as useEffect5, useId as useId2, useMemo as useMemo2, useRef as useRef4 } from "react";
+import React, { useEffect, useId, useMemo, useRef } from "react";
 import { Box } from "ink";
 
 // src/core/router/NavigationContext.tsx
-import { createContext as createContext4, useContext as useContext4 } from "react";
-var NavigationContext = createContext4(null);
+import { createContext, useContext } from "react";
+var NavigationContext = createContext(null);
 var useNavigation = () => {
-  const context = useContext4(NavigationContext);
+  const context = useContext(NavigationContext);
   if (!context) {
     throw new GigglesError("useNavigation must be used within a Router");
   }
@@ -444,7 +46,7 @@ var useNavigation = () => {
 };
 
 // src/core/router/ScreenEntry.tsx
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function ScreenEntry({
   entry,
   isTop,
@@ -456,18 +58,18 @@ function ScreenEntry({
   replace,
   reset
 }) {
-  const screenNodeId = useId2();
-  const parentId = React3.useContext(FocusNodeContext);
+  const screenNodeId = useId();
+  const parentId = React.useContext(FocusNodeContext);
   const { registerNode, unregisterNode, focusFirstChild, focusNode, getFocusedId } = useFocusContext();
-  const lastFocusedChildRef = useRef4(null);
-  const wasTopRef = useRef4(isTop);
-  useEffect5(() => {
+  const lastFocusedChildRef = useRef(null);
+  const wasTopRef = useRef(isTop);
+  useEffect(() => {
     registerNode(screenNodeId, parentId);
     return () => {
       unregisterNode(screenNodeId);
     };
   }, [screenNodeId, parentId, registerNode, unregisterNode]);
-  useEffect5(() => {
+  useEffect(() => {
     if (!wasTopRef.current && isTop) {
       const saved = restoreFocus ? lastFocusedChildRef.current : null;
       if (saved) {
@@ -482,15 +84,15 @@ function ScreenEntry({
     }
     wasTopRef.current = isTop;
   }, [isTop, screenNodeId, restoreFocus, focusFirstChild, focusNode, getFocusedId]);
-  const value = useMemo2(
+  const value = useMemo(
     () => ({ currentRoute: entry, active: isTop, canGoBack, push, pop, replace, reset }),
     [entry, isTop, canGoBack, push, pop, replace, reset]
   );
-  return /* @__PURE__ */ jsx7(NavigationContext.Provider, { value, children: /* @__PURE__ */ jsx7(FocusNodeContext.Provider, { value: screenNodeId, children: /* @__PURE__ */ jsx7(Box, { display: isTop ? "flex" : "none", children: /* @__PURE__ */ jsx7(Component, { ...entry.params }) }) }) });
+  return /* @__PURE__ */ jsx2(NavigationContext.Provider, { value, children: /* @__PURE__ */ jsx2(FocusNodeContext.Provider, { value: screenNodeId, children: /* @__PURE__ */ jsx2(Box, { display: isTop ? "flex" : "none", children: /* @__PURE__ */ jsx2(Component, { ...entry.params }) }) }) });
 }
 
 // src/core/router/Router.tsx
-import { Fragment as Fragment3, jsx as jsx8 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
 function routerReducer(stack, action) {
   switch (action.type) {
     case "push":
@@ -504,11 +106,11 @@ function routerReducer(stack, action) {
   }
 }
 function Router({ children, initialScreen, initialParams, restoreFocus = true }) {
-  const screenId = useRef5(0);
-  const routes = React4.Children.toArray(children).filter((child) => React4.isValidElement(child) && child.type === Screen).map((child) => child.props);
-  const screenNamesRef = useRef5(/* @__PURE__ */ new Set());
+  const screenId = useRef2(0);
+  const routes = React2.Children.toArray(children).filter((child) => React2.isValidElement(child) && child.type === Screen).map((child) => child.props);
+  const screenNamesRef = useRef2(/* @__PURE__ */ new Set());
   screenNamesRef.current = new Set(routes.map((r) => r.name));
-  const assertScreen = useCallback4((name) => {
+  const assertScreen = useCallback((name) => {
     if (!screenNamesRef.current.has(name)) {
       throw new GigglesError(
         `Screen "${name}" is not registered. Available screens: ${[...screenNamesRef.current].join(", ")}`
@@ -523,24 +125,24 @@ function Router({ children, initialScreen, initialParams, restoreFocus = true })
     }
     return [{ id: screenId.current++, name, params: initialParams }];
   });
-  const push = useCallback4(
+  const push = useCallback(
     (name, params) => {
       assertScreen(name);
       dispatch({ type: "push", route: { id: screenId.current++, name, params } });
     },
     [assertScreen]
   );
-  const pop = useCallback4(() => {
+  const pop = useCallback(() => {
     dispatch({ type: "pop" });
   }, []);
-  const replace = useCallback4(
+  const replace = useCallback(
     (name, params) => {
       assertScreen(name);
       dispatch({ type: "replace", route: { id: screenId.current++, name, params } });
     },
     [assertScreen]
   );
-  const reset = useCallback4(
+  const reset = useCallback(
     (name, params) => {
       assertScreen(name);
       dispatch({ type: "reset", route: { id: screenId.current++, name, params } });
@@ -552,10 +154,10 @@ function Router({ children, initialScreen, initialParams, restoreFocus = true })
     components.set(route.name, route.component);
   }
   const canGoBack = stack.length > 1;
-  return /* @__PURE__ */ jsx8(Fragment3, { children: stack.map((entry, i) => {
+  return /* @__PURE__ */ jsx3(Fragment, { children: stack.map((entry, i) => {
     const Component = components.get(entry.name);
     if (!Component) return null;
-    return /* @__PURE__ */ jsx8(
+    return /* @__PURE__ */ jsx3(
       ScreenEntry,
       {
         entry,
@@ -581,6 +183,7 @@ export {
   Screen,
   useFocus,
   useFocusState,
+  useKeybindingRegistry,
   useKeybindings,
   useNavigation
 };

package/dist/terminal/index.d.ts

@@ -0,0 +1,23 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+type TerminalSize = {
+    rows: number;
+    columns: number;
+};
+
+declare function useTerminalSize(): TerminalSize;
+
+declare function useTerminalFocus(callback: (focused: boolean) => void): void;
+
+declare function AlternateScreen({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+
+declare function useShellOut(): {
+    run: (command: string) => Promise<{
+        exitCode: number;
+    }>;
+};
+
+export { AlternateScreen, type TerminalSize, useShellOut, useTerminalFocus, useTerminalSize };

package/dist/terminal/index.js

@@ -0,0 +1,83 @@
+import {
+  AlternateScreen
+} from "../chunk-7PDVDYFB.js";
+
+// src/terminal/hooks/useTerminalSize.ts
+import { useEffect, useState } from "react";
+function useTerminalSize() {
+  const [size, setSize] = useState({
+    rows: process.stdout.rows,
+    columns: process.stdout.columns
+  });
+  useEffect(() => {
+    const handleResize = () => {
+      setSize({
+        rows: process.stdout.rows,
+        columns: process.stdout.columns
+      });
+    };
+    process.stdout.on("resize", handleResize);
+    return () => {
+      process.stdout.off("resize", handleResize);
+    };
+  }, []);
+  return size;
+}
+
+// src/terminal/hooks/useTerminalFocus.ts
+import { useEffect as useEffect2, useRef } from "react";
+function useTerminalFocus(callback) {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect2(() => {
+    const handler = (data) => {
+      const str = data.toString();
+      if (str.includes("\x1B[I")) callbackRef.current(true);
+      if (str.includes("\x1B[O")) callbackRef.current(false);
+    };
+    process.stdin.on("data", handler);
+    const timer = setTimeout(() => {
+      process.stdout.write("\x1B[?1004h");
+    }, 0);
+    return () => {
+      clearTimeout(timer);
+      process.stdout.write("\x1B[?1004l");
+      process.stdin.off("data", handler);
+    };
+  }, []);
+}
+
+// src/terminal/hooks/useShellout.ts
+import { execa } from "execa";
+import { useCallback, useState as useState2 } from "react";
+import { useStdin } from "ink";
+function useShellOut() {
+  const [, setRedrawCount] = useState2(0);
+  const { setRawMode } = useStdin();
+  const run = useCallback(
+    async (command) => {
+      process.stdout.write("\x1B[?1049l");
+      setRawMode(false);
+      try {
+        const result = await execa(command, { stdio: "inherit", shell: true, reject: false });
+        return { exitCode: result.exitCode ?? 0 };
+      } finally {
+        setRawMode(true);
+        process.stdout.write("\x1B[?1049h");
+        process.stdout.write("\x1B[2J");
+        process.stdout.write("\x1B[H");
+        setRedrawCount((c) => c + 1);
+      }
+    },
+    [setRawMode]
+  );
+  return {
+    run
+  };
+}
+export {
+  AlternateScreen,
+  useShellOut,
+  useTerminalFocus,
+  useTerminalSize
+};