@hoox-sh/hoox-tui 0.2.0 → 0.3.1

package/src/components/views/trade-monitor.tsx

@@ -22,13 +22,14 @@
  * Colors from @hoox-sh/hoox-shared design tokens. No CSS, no DOM.
  */
 import { useState, useMemo, useRef, useEffect } from "react";
-import { useKeyboard } from "@opentui/react";
+
 import { Colors, useServiceStore, useUIStore } from "@hoox-sh/hoox-shared";
 import type { Trade, TradeSide } from "@hoox-sh/hoox-shared";
 import { ErrorBoundary } from "../shared/error-boundary";
 import { Spinner, EmptyState } from "../shared/spinner";
 import { ViewHeader } from "../shared/view-header";
 import { Panel } from "../shared/panel";
+import { useViewKeyboard } from "../../hooks/shell-overlay";
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
@@ -235,19 +236,25 @@ function LiveTradeFeed({
 
   // Snapshot frozen trades when paused; keep updating otherwise
   const frozenRef = useRef<Trade[]>([]);
-  const wasPausedRef = useRef(false);
+  const [frozenStream, setFrozenStream] = useState<Trade[] | null>(null);
 
-  // Capture snapshot on pause edge, release on resume
-  if (!paused && wasPausedRef.current) {
-    frozenRef.current = [];
-  }
-  if (paused && !wasPausedRef.current) {
-    frozenRef.current = [...tradeStream];
-  }
-  wasPausedRef.current = paused;
+  // Capture snapshot on pause edge, release on resume (not during render)
+  useEffect(() => {
+    if (paused) {
+      frozenRef.current = [...tradeStream];
+      setFrozenStream(frozenRef.current);
+    } else {
+      frozenRef.current = [];
+      setFrozenStream(null);
+    }
+    // Only react to pause edge — intentionally omit tradeStream from deps
+    // when already paused so the frozen snapshot stays stable.
+  }, [paused]);
 
   // Use frozen snapshot when paused, live stream when not
-  const effectiveStream = paused ? frozenRef.current : tradeStream;
+  const effectiveStream = paused
+    ? (frozenStream ?? frozenRef.current)
+    : tradeStream;
 
   // Newest first, only the render window (store is newest-last)
   const sortedTrades = useMemo(
@@ -265,7 +272,7 @@ function LiveTradeFeed({
   const safeIndex = Math.min(selectedIndex, maxIndex);
 
   // Keyboard: navigate trade rows only while this view is active
-  useKeyboard((key) => {
+  useViewKeyboard((key) => {
     if (!isActive) return;
     if (key.name === "up") {
       setSelectedIndex((i) => Math.max(0, i - 1));
@@ -687,7 +694,7 @@ export function TradeMonitor() {
   const offline = connectionStatus === "offline";
 
   // Keyboard: space toggles pause/resume only while this view is active
-  useKeyboard((key) => {
+  useViewKeyboard((key) => {
     if (!isActive) return;
     if (key.name === "space") {
       setPaused((p) => !p);

package/src/components/views/worker-detail.tsx

@@ -21,7 +21,7 @@
  * Colors from @hoox-sh/hoox-shared tokens — no hardcoded hex.
  */
 import { useState, useMemo, useEffect, useCallback, useRef } from "react";
-import { useKeyboard } from "@opentui/react";
+
 import {
   Colors,
   LogLevelColor,
@@ -36,6 +36,7 @@ import {
 import { ErrorBoundary } from "../shared/error-boundary";
 import { StatusDot, type StatusDotStatus } from "../shared/status-dot";
 import { ViewHeader } from "../shared/view-header";
+import { useViewKeyboard } from "../../hooks/shell-overlay";
 
 // ── Local type aliases (inferred from store return types) ──────────────────
 
@@ -97,14 +98,20 @@ export function redactConfigEntries(
 /**
  * Breadcrumb header showing back navigation, worker name, and status indicator.
  */
-function BreadcrumbHeader({ worker }: { worker: Worker }) {
+function BreadcrumbHeader({
+  worker,
+  onBack,
+}: {
+  worker: Worker;
+  onBack: () => void;
+}) {
   return (
     <ViewHeader
       title={worker.name}
       showDivider={false}
       meta={
         <box flexDirection="row" gap={2}>
-          <text fg={Colors.muted} dim>
+          <text fg={Colors.accent} onMouseUp={onBack}>
             ← BACK
           </text>
           <StatusDot
@@ -207,7 +214,7 @@ function LogsPane({
   }, [workerLogs.length, paused]);
 
   // Keyboard: Space toggles pause when this pane is focused
-  useKeyboard((key) => {
+  useViewKeyboard((key) => {
     if (!focused) return;
     if (key.name === "space") {
       setPaused((p) => !p);
@@ -546,25 +553,32 @@ export function WorkerDetail() {
     void fetchConfig();
   }, [fetchConfig]);
 
-  // Fetch logs via CLI as fallback when SSE is not connected
+  // Fetch logs via CLI when SSE is offline OR when connected but empty for this worker
   useEffect(() => {
     if (connectionStatus !== "connected") {
       void fetchLogs();
+      return;
     }
-  }, [connectionStatus, fetchLogs]);
+    // Connected but no lines yet for this worker — still allow a one-shot CLI seed
+    const hasWorkerLogs = useServiceStore
+      .getState()
+      .logs.some((l) => l.workerId === worker?.id || l.source === worker?.name);
+    if (!hasWorkerLogs && worker) {
+      void fetchLogs();
+    }
+  }, [connectionStatus, fetchLogs, worker]);
 
   const handleRefresh = useCallback(() => {
     void fetchConfig();
-    if (connectionStatus !== "connected") {
-      void fetchLogs();
-    }
-  }, [fetchConfig, fetchLogs, connectionStatus]);
+    // Always refresh logs on explicit Ctrl+R — not only when offline
+    void fetchLogs();
+  }, [fetchConfig, fetchLogs]);
 
   const activeView = useUIStore((s) => s.activeView);
   const isActive = activeView === "worker-detail";
 
   // View-local keyboard handling (only when this view is active)
-  useKeyboard((key) => {
+  useViewKeyboard((key) => {
     if (!isActive) return;
     switch (key.name) {
       case "tab":
@@ -586,6 +600,7 @@ export function WorkerDetail() {
       <ErrorBoundary viewName="Worker Detail">
         <box flexDirection="column" flexGrow={1} padding={2} gap={1}>
           <BreadcrumbHeader
+            onBack={goBack}
             worker={{
               id: selectedWorkerId || "unknown",
               name: selectedWorkerId || "Unknown Worker",
@@ -631,7 +646,7 @@ export function WorkerDetail() {
     <ErrorBoundary viewName={`Worker: ${worker.name}`}>
       <box flexDirection="column" flexGrow={1} padding={1} gap={1}>
         {/* Breadcrumb header */}
-        <BreadcrumbHeader worker={worker} />
+        <BreadcrumbHeader worker={worker} onBack={goBack} />
 
         {/* 2×2 Grid of panes */}
         <box flexDirection="column" flexGrow={1} gap={1}>

package/src/components/views/worker-settings.test.tsx

@@ -24,20 +24,19 @@ describe("WorkerSettingsView", () => {
     expect(display).not.toMatch(/sk-|token|password/i);
   });
 
-  it("dangerous fields require a second confirm before write (contract)", () => {
-    // Mirrors saveCurrent double-Enter gate for kind === "dangerous"
+  it("all non-secret fields require a second confirm before write (contract)", () => {
+    // Mirrors saveCurrent double-Enter gate for every non-secret write
     let pending: string | null = null;
-    const fieldKey = "risk:kill_switch";
-    const kind = "dangerous" as const;
+    const fieldKey = "risk:max_position_size";
 
     // First Enter → arm confirm
-    if (kind === "dangerous" && pending !== fieldKey) {
+    if (pending !== fieldKey) {
       pending = fieldKey;
     }
     expect(pending).toBe(fieldKey);
 
     // Second Enter with same key → proceed
-    const shouldWrite = kind === "dangerous" && pending === fieldKey;
+    const shouldWrite = pending === fieldKey;
     expect(shouldWrite).toBe(true);
   });
 });

package/src/components/views/worker-settings.tsx

@@ -16,7 +16,7 @@
  * `hoox config kv set`. Secret fields are read-only (CLI command shown).
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useKeyboard } from "@opentui/react";
+
 import {
   Colors,
   AGENT_CONFIG_KV_KEY,
@@ -37,6 +37,7 @@ import { Panel } from "../shared/panel";
 import { Spinner, EmptyState } from "../shared/spinner";
 import { cliBridge } from "../../services/cli-bridge";
 import { loadDashboardSettingsManifests } from "../../services/dashboard-settings-loader";
+import { useViewKeyboard } from "../../hooks/shell-overlay";
 
 function parseKvValue(
   raw: string | null,
@@ -276,15 +277,16 @@ export function WorkerSettingsView() {
       return;
     }
 
-    // Fail-closed confirm for dangerous fields: require a second Enter.
-    if (row.field.kind === "dangerous") {
-      if (pendingDangerousKey !== row.field.key) {
-        setPendingDangerousKey(row.field.key);
-        setStatus(
-          `Confirm dangerous write for "${row.field.label}" — press Enter again to save, Esc to cancel`
-        );
-        return;
-      }
+    // Fail-closed confirm for ALL non-secret writes: require a second Enter.
+    // Prevents accidental live KV mutations from a single mis-press.
+    if (pendingDangerousKey !== row.field.key) {
+      setPendingDangerousKey(row.field.key);
+      const kindLabel =
+        row.field.kind === "dangerous" ? "dangerous write" : "write";
+      setStatus(
+        `Confirm ${kindLabel} for "${row.field.label}" — press Enter again to save, Esc to cancel`
+      );
+      return;
     }
     setPendingDangerousKey(null);
 
@@ -350,7 +352,7 @@ export function WorkerSettingsView() {
     }
   }, [flatFields, fieldIndex, selected, values, pendingDangerousKey, saving]);
 
-  useKeyboard((key) => {
+  useViewKeyboard((key) => {
     if (!isActive) return;
     if (key.name === "escape") {
       if (pendingDangerousKey) {

package/src/components/views/workers-overview.tsx

@@ -25,7 +25,7 @@
  * Follows TUI Patterns 1 (View Composition), 2 (Store Subscription), 8 (ScrollBox).
  */
 import { useState, useMemo, useCallback, useEffect, useRef } from "react";
-import { useKeyboard } from "@opentui/react";
+
 import { Colors } from "@hoox-sh/hoox-shared";
 import { useServiceStore } from "@hoox-sh/hoox-shared";
 import { useUIStore } from "@hoox-sh/hoox-shared";
@@ -39,6 +39,7 @@ import { redactSecretsInText } from "../../services/dev-log";
 import type { WorkerInfo } from "@hoox-sh/hoox-shared";
 import { showConfirm } from "../ui/dialog";
 import type { DialogHandle } from "../ui/dialog";
+import { useViewKeyboard } from "../../hooks/shell-overlay";
 
 // ── Props ─────────────────────────────────────────────────────────────────────
 
@@ -337,7 +338,7 @@ export function WorkersOverview({ dialog }: WorkersOverviewProps = {}) {
   }, [maxIndex]);
 
   // ── View-local keyboard: 2D grid navigation ─────────────────────────────
-  useKeyboard((key) => {
+  useViewKeyboard((key) => {
     switch (key.name) {
       case "up":
         setFocusedIndex((i) => Math.max(0, i - COLS));
@@ -371,25 +372,45 @@ export function WorkersOverview({ dialog }: WorkersOverviewProps = {}) {
 
   const handleLogs = useCallback(async (worker: WorkerInfo) => {
     if (deployingRef.current) return;
+    const store = useServiceStore.getState();
+    // Select worker and open Logs Viewer — primary operator path
+    store.selectWorker(worker.id);
+    useUIStore.getState().setView("logs-viewer");
+
     try {
       const result = await cliBridge.workerLogs(worker.name);
       if (!mountedRef.current) return;
+      if (result.success && result.stdout) {
+        // Seed the log ring so Logs Viewer has content immediately
+        const lines = result.stdout.split("\n").filter((l) => l.trim());
+        const now = Date.now();
+        for (const line of lines.slice(-100)) {
+          store.pushLog({
+            id: `cli-log-${now}-${Math.random().toString(36).slice(2, 8)}`,
+            timestamp: now,
+            level: "info",
+            workerId: worker.id,
+            message: redactSecretsInText(line).slice(0, 500),
+            source: worker.name,
+          });
+        }
+      }
       const failDetail = redactSecretsInText(
         result.stderr || result.stdout || "unknown error"
       );
-      useServiceStore.getState().addAlert({
+      store.addAlert({
         id: `logs-${Date.now()}-${worker.name}`,
         type: "logs",
         severity: result.success ? "info" : "warning",
         message: result.success
-          ? `${worker.name} logs retrieved (${(result.duration / 1000).toFixed(1)}s)`
-          : `${worker.name} logs failed: ${failDetail}`,
+          ? `Opened logs for ${worker.name}`
+          : `${worker.name} logs fetch failed: ${failDetail}`,
         timestamp: Date.now(),
         acknowledged: false,
       });
     } catch (err) {
       if (!mountedRef.current) return;
-      useServiceStore.getState().addAlert({
+      store.addAlert({
         id: `logs-err-${Date.now()}`,
         type: "logs",
         severity: "warning",

package/src/hooks/hooks.test.ts

@@ -6,8 +6,15 @@
 /**
  * Hook unit tests — renderer ref, global keyboard registration, polling helpers.
  */
-import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
-import { setRendererRef, getRendererRef, registerGlobalHandler } from "./index";
+import { describe, it, expect, beforeEach, afterEach, jest } from "bun:test";
+import {
+  setRendererRef,
+  getRendererRef,
+  registerGlobalHandler,
+  computePollingBackoff,
+  createPollingController,
+  POLLING_MAX_BACKOFF_MS,
+} from "./index";
 import type { KeyEvent } from "./use-keyboard";
 
 describe("renderer-ref", () => {
@@ -36,6 +43,10 @@ describe("registerGlobalHandler", () => {
     setRendererRef(null);
   });
 
+  afterEach(() => {
+    setRendererRef(null);
+  });
+
   it("registers and unregisters without throwing", () => {
     const calls: string[] = [];
     const unsub = registerGlobalHandler((key: KeyEvent) => {
@@ -54,19 +65,302 @@ describe("registerGlobalHandler", () => {
     b();
     c();
   });
+
+  it("dispatches keypresses in priority order when renderer is attached", () => {
+    const order: number[] = [];
+    const listeners = new Map<string, Set<(...args: unknown[]) => void>>();
+    const keyInput = {
+      on: (event: string, fn: (...args: unknown[]) => void) => {
+        if (!listeners.has(event)) listeners.set(event, new Set());
+        listeners.get(event)!.add(fn);
+        return () => listeners.get(event)?.delete(fn);
+      },
+      off: (event: string, fn: (...args: unknown[]) => void) => {
+        listeners.get(event)?.delete(fn);
+      },
+    };
+    setRendererRef({
+      keyInput,
+    } as unknown as import("@opentui/core").CliRenderer);
+
+    const unsubHigh = registerGlobalHandler(() => {
+      order.push(0);
+    }, 0);
+    const unsubMid = registerGlobalHandler(() => {
+      order.push(10);
+    }, 10);
+    const unsubLow = registerGlobalHandler(() => {
+      order.push(50);
+    }, 50);
+
+    const handlers = listeners.get("keypress");
+    expect(handlers?.size).toBe(1);
+    for (const h of handlers ?? []) {
+      h({
+        name: "a",
+        ctrl: false,
+        shift: false,
+        alt: false,
+        meta: false,
+        sequence: "a",
+      });
+    }
+    expect(order).toEqual([0, 10, 50]);
+
+    unsubHigh();
+    unsubMid();
+    unsubLow();
+    // Last unsubscribe detaches key input
+    expect(listeners.get("keypress")?.size ?? 0).toBe(0);
+  });
+
+  it("snapshot protects against unsubscribe mid-dispatch", () => {
+    const seen: string[] = [];
+    let unsubB: (() => void) | null = null;
+    const listeners = new Map<string, Set<(...args: unknown[]) => void>>();
+    const keyInput = {
+      on: (event: string, fn: (...args: unknown[]) => void) => {
+        if (!listeners.has(event)) listeners.set(event, new Set());
+        listeners.get(event)!.add(fn);
+        return () => listeners.get(event)?.delete(fn);
+      },
+      off: () => {},
+    };
+    setRendererRef({
+      keyInput,
+    } as unknown as import("@opentui/core").CliRenderer);
+
+    const unsubA = registerGlobalHandler(() => {
+      seen.push("a");
+      unsubB?.();
+    }, 0);
+    unsubB = registerGlobalHandler(() => {
+      seen.push("b");
+    }, 1);
+
+    for (const h of listeners.get("keypress") ?? []) {
+      h({
+        name: "x",
+        ctrl: false,
+        shift: false,
+        alt: false,
+        meta: false,
+        sequence: "x",
+      });
+    }
+    // Snapshot ensures b still runs even though unsub mid-dispatch
+    expect(seen).toEqual(["a", "b"]);
+    unsubA();
+  });
+
+  it("attaches when on() returns non-function (off fallback path)", () => {
+    let offCalled = false;
+    const keyInput = {
+      on: () => undefined,
+      off: () => {
+        offCalled = true;
+      },
+    };
+    setRendererRef({
+      keyInput,
+    } as unknown as import("@opentui/core").CliRenderer);
+    const unsub = registerGlobalHandler(() => {}, 5);
+    unsub();
+    expect(offCalled).toBe(true);
+  });
 });
 
-describe("usePolling backoff math", () => {
+describe("computePollingBackoff", () => {
   it("caps exponential backoff at 16s", () => {
     const base = 1000;
-    const MAX = 16_000;
     for (let retry = 0; retry < 10; retry++) {
-      const backoff = Math.min(base * Math.pow(2, retry), MAX);
-      expect(backoff).toBeLessThanOrEqual(MAX);
+      const backoff = computePollingBackoff(base, retry);
+      expect(backoff).toBeLessThanOrEqual(POLLING_MAX_BACKOFF_MS);
     }
-    expect(Math.min(base * Math.pow(2, 10), MAX)).toBe(MAX);
+    expect(computePollingBackoff(base, 10)).toBe(POLLING_MAX_BACKOFF_MS);
+  });
+
+  it("doubles per retry until cap", () => {
+    expect(computePollingBackoff(500, 0)).toBe(500);
+    expect(computePollingBackoff(500, 1)).toBe(1000);
+    expect(computePollingBackoff(500, 2)).toBe(2000);
+    expect(computePollingBackoff(500, 3)).toBe(4000);
+  });
+
+  it("respects custom max backoff", () => {
+    expect(computePollingBackoff(1000, 5, 3000)).toBe(3000);
   });
 });
 
-// Silence unused import if mock is tree-shaken away in some runners
-void mock;
+describe("createPollingController", () => {
+  /** Flush microtasks after advancing fake timers (Bun has no advanceTimersByTimeAsync). */
+  async function advance(ms: number): Promise<void> {
+    jest.advanceTimersByTime(ms);
+    // Drain promise chains scheduled by timer callbacks
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("invokes callback immediately when immediate=true", async () => {
+    let calls = 0;
+    const ctrl = createPollingController({
+      getCallback: () => async () => {
+        calls++;
+      },
+      getIntervalMs: () => 1000,
+      immediate: true,
+    });
+    ctrl.start();
+    // Let the microtask from the immediate poll resolve
+    await Promise.resolve();
+    expect(calls).toBe(1);
+    ctrl.stop();
+  });
+
+  it("defers first poll when immediate=false", async () => {
+    let calls = 0;
+    const ctrl = createPollingController({
+      getCallback: () => async () => {
+        calls++;
+      },
+      getIntervalMs: () => 500,
+      immediate: false,
+    });
+    ctrl.start();
+    await Promise.resolve();
+    expect(calls).toBe(0);
+    await advance(500);
+    expect(calls).toBe(1);
+    ctrl.stop();
+  });
+
+  it("increments retry count on failure and resets on success", async () => {
+    let shouldFail = true;
+    const ctrl = createPollingController({
+      getCallback: () => async () => {
+        if (shouldFail) throw new Error("boom");
+      },
+      getIntervalMs: () => 100,
+      immediate: true,
+    });
+    ctrl.start();
+    await Promise.resolve();
+    expect(ctrl.getRetryCount()).toBe(1);
+
+    // Next scheduled poll after backoff 100 * 2^1 = 200
+    shouldFail = false;
+    await advance(200);
+    expect(ctrl.getRetryCount()).toBe(0);
+    ctrl.stop();
+  });
+
+  it("stop prevents further polls after pending timeout", async () => {
+    let calls = 0;
+    const ctrl = createPollingController({
+      getCallback: () => async () => {
+        calls++;
+      },
+      getIntervalMs: () => 1000,
+      immediate: true,
+    });
+    ctrl.start();
+    await Promise.resolve();
+    expect(calls).toBe(1);
+    ctrl.stop();
+    await advance(10_000);
+    expect(calls).toBe(1);
+  });
+
+  it("reads fresh interval on each iteration", async () => {
+    let interval = 100;
+    let calls = 0;
+    const ctrl = createPollingController({
+      getCallback: () => async () => {
+        calls++;
+      },
+      getIntervalMs: () => interval,
+      immediate: true,
+    });
+    ctrl.start();
+    await Promise.resolve();
+    expect(calls).toBe(1);
+    interval = 250;
+    // Next poll was scheduled at previous interval (100); after it runs,
+    // subsequent delay uses the new interval.
+    await advance(100);
+    expect(calls).toBe(2);
+    await advance(249);
+    expect(calls).toBe(2);
+    await advance(1);
+    expect(calls).toBe(3);
+    ctrl.stop();
+  });
+
+  it("stop during in-flight callback does not schedule next poll", async () => {
+    let resolveCb!: () => void;
+    let calls = 0;
+    const ctrl = createPollingController({
+      getCallback: () => () =>
+        new Promise<void>((resolve) => {
+          calls++;
+          resolveCb = resolve;
+        }),
+      getIntervalMs: () => 100,
+      immediate: true,
+    });
+    ctrl.start();
+    await Promise.resolve();
+    expect(calls).toBe(1);
+    ctrl.stop();
+    resolveCb();
+    await Promise.resolve();
+    await advance(1000);
+    expect(calls).toBe(1);
+  });
+});
+
+describe("useServiceData", () => {
+  afterEach(async () => {
+    const { __setServiceStoreHookForTests } =
+      await import("./use-service-data");
+    __setServiceStoreHookForTests(null);
+  });
+
+  it("applies the selector via the store hook", async () => {
+    const { useServiceData, __setServiceStoreHookForTests } =
+      await import("./use-service-data");
+    const { useServiceStore } = await import("@hoox-sh/hoox-shared");
+    const snapshot = useServiceStore.getState();
+
+    __setServiceStoreHookForTests((selector) => selector(snapshot));
+
+    const status = useServiceData((s) => s.connectionStatus);
+    expect(status).toBe(snapshot.connectionStatus);
+
+    const workers = useServiceData((s) => s.workers);
+    expect(workers).toBe(snapshot.workers);
+  });
+
+  it("restores real store hook after null reset", async () => {
+    const { useServiceData, __setServiceStoreHookForTests } =
+      await import("./use-service-data");
+    __setServiceStoreHookForTests((() => "injected") as never);
+    expect(useServiceData((() => "x") as never) as unknown).toBe("injected");
+    __setServiceStoreHookForTests(null);
+    // Real hook throws outside React — proves restore happened
+    expect(() => useServiceData((s) => s.connectionStatus)).toThrow();
+  });
+
+  it("is re-exported from hooks index", async () => {
+    const mod = await import("./index");
+    expect(typeof mod.useServiceData).toBe("function");
+  });
+});

package/src/hooks/index.ts

@@ -5,7 +5,13 @@
 
 export { useKeyboard, registerGlobalHandler } from "./use-keyboard";
 export type { KeyEvent, UseKeyboardOptions } from "./use-keyboard";
-export { usePolling } from "./use-polling";
+export {
+  usePolling,
+  computePollingBackoff,
+  createPollingController,
+  POLLING_MAX_BACKOFF_MS,
+} from "./use-polling";
 export type { UsePollingOptions } from "./use-polling";
 export { useServiceData } from "./use-service-data";
 export { setRendererRef, getRendererRef } from "./renderer-ref";
+export { isShellOverlayOpen, useViewKeyboard } from "./shell-overlay";