gloomberb 0.10.4 → 0.11.0

package/src/api-client/socket-health.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+import {
+  ConnectionHealthRegistry,
+  GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+  type ConnectionHealthStatus,
+} from "../core/connection-health";
+import { CloudApiSocket } from "./socket";
+
+function waitForStatus(
+  health: ConnectionHealthRegistry,
+  status: ConnectionHealthStatus,
+): Promise<void> {
+  if (health.getSnapshot().sources[0]?.status === status) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      unsubscribe();
+      reject(new Error(`Timed out waiting for ${status}`));
+    }, 2_000);
+    const unsubscribe = health.subscribe(() => {
+      if (health.getSnapshot().sources[0]?.status !== status) return;
+      clearTimeout(timer);
+      unsubscribe();
+      resolve();
+    });
+  });
+}
+
+describe("CloudApiSocket connection health", () => {
+  test("reports transitions from a real loopback websocket", async () => {
+    let peer: ServerWebSocket<unknown> | null = null;
+    const server = Bun.serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      fetch(request, server) {
+        return server.upgrade(request) ? undefined : new Response("Upgrade required", { status: 426 });
+      },
+      websocket: {
+        open(socket) {
+          peer = socket;
+        },
+        message() {},
+      },
+    });
+    const health = new ConnectionHealthRegistry();
+    health.registerSource({
+      id: GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+      name: "Gloom Cloud Stream",
+      kind: "websocket",
+    });
+    const socket = new CloudApiSocket({
+      getBaseUrl: () => `http://127.0.0.1:${server.port}`,
+      getSocketAuthToken: () => null,
+      hasVerifiedUser: () => false,
+      isUsingWebSocketToken: () => false,
+      clearWebSocketTokenForFallback: () => false,
+      markCurrentUserUnverified: () => {},
+      updateCurrentUserFromSocket: () => {},
+    }, health);
+
+    try {
+      socket.subscribeQuotes([{ symbol: "AAPL" }], () => {});
+      expect(health.getSnapshot().sources[0]).toMatchObject({
+        status: "connecting",
+        socketState: "connecting",
+      });
+
+      await waitForStatus(health, "connected");
+      peer!.close(1000, "network lost");
+      await waitForStatus(health, "disconnected");
+      expect(health.getSnapshot().sources[0]).toMatchObject({
+        socketState: "closed",
+        currentDetail: "network lost",
+      });
+    } finally {
+      socket.dispose();
+      void server.stop(true);
+    }
+  });
+});

package/src/api-client/socket.ts

@@ -4,6 +4,8 @@ import type {
   ChatNotification,
   CloudQuotePayload,
   QuoteStreamTarget,
+  ScannerFeedEvent,
+  ScannerKind,
 } from "./types";
 import {
   normalizeChatMessage,
@@ -12,6 +14,11 @@ import {
 import { debugLog } from "../utils/debug-log";
 import { canonicalExchange, normalizeSymbol } from "../utils/exchanges";
 import { mergeQuoteSubscriptionTargets } from "../market-data/quote-subscription-target";
+import {
+  connectionHealth,
+  GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+  type ConnectionHealthRegistry,
+} from "../core/connection-health";
 
 const QUOTE_SUBSCRIPTION_FLUSH_MS = 25;
 const cloudApiLog = debugLog.createLogger("cloud-api");
@@ -24,6 +31,12 @@ type QuoteSubscription = {
   target: QuoteStreamTarget;
   listener: QuoteListener;
 };
+type ScannerListener = (event: ScannerFeedEvent) => void;
+
+const SCANNER_MESSAGE_KINDS: Record<string, ScannerKind> = {
+  "scanner.hilo": "hilo",
+  "scanner.flow": "flow",
+};
 
 function mergeQuoteStreamSubscriptions(
   subscriptions: Iterable<QuoteSubscription>,
@@ -68,8 +81,14 @@ export class CloudApiSocket {
   private readonly pendingQuoteSubscribes = new Map<string, QuoteStreamTarget>();
   private readonly pendingQuoteUnsubscribes = new Map<string, QuoteStreamTarget>();
   private quoteSubscriptionFlushTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly scannerListeners = new Map<ScannerKind, Set<ScannerListener>>();
+  /** Latest fan-out payload, so a pane opened mid-stream does not wait for the next tick. */
+  private readonly scannerSnapshots = new Map<ScannerKind, ScannerFeedEvent>();
 
-  constructor(private readonly delegate: CloudApiSocketDelegate) {}
+  constructor(
+    private readonly delegate: CloudApiSocketDelegate,
+    private readonly health: ConnectionHealthRegistry = connectionHealth,
+  ) {}
 
   syncAuthState(options: { reconnect?: boolean } = {}): void {
     if (!this.shouldKeepSocketOpen()) {
@@ -91,6 +110,7 @@ export class CloudApiSocket {
     this.ws = null;
     if (ws) {
       cloudApiLog.info("teardown websocket");
+      this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "idle", "Socket closed locally");
     }
     try {
       ws?.close();
@@ -163,6 +183,37 @@ export class CloudApiSocket {
     };
   }
 
+  /**
+   * Subscribes to a shared server-computed scanner. Every open pane of the same
+   * kind shares one upstream subscription; the socket fans the payload out.
+   */
+  subscribeScanner(scanner: ScannerKind, listener: ScannerListener): () => void {
+    const listeners = this.scannerListeners.get(scanner) ?? new Set<ScannerListener>();
+    const firstListener = listeners.size === 0;
+    listeners.add(listener);
+    this.scannerListeners.set(scanner, listeners);
+    this.ensureSocket();
+    if (firstListener) {
+      this.sendSocketMessage({ type: "scanner.subscribe", scanner });
+    } else {
+      const snapshot = this.scannerSnapshots.get(scanner);
+      if (snapshot) listener(snapshot);
+    }
+
+    return () => {
+      const current = this.scannerListeners.get(scanner);
+      if (!current || !current.delete(listener)) return;
+      if (current.size === 0) {
+        this.scannerListeners.delete(scanner);
+        this.scannerSnapshots.delete(scanner);
+        this.sendSocketMessage({ type: "scanner.unsubscribe", scanner });
+      }
+      if (!this.shouldKeepSocketOpen()) {
+        this.teardown();
+      }
+    };
+  }
+
   subscribeQuotes(
     targets: QuoteStreamTarget[],
     onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
@@ -264,6 +315,8 @@ export class CloudApiSocket {
     this.quoteTargets.clear();
     this.pendingQuoteSubscribes.clear();
     this.pendingQuoteUnsubscribes.clear();
+    this.scannerListeners.clear();
+    this.scannerSnapshots.clear();
     if (this.quoteSubscriptionFlushTimer) {
       clearTimeout(this.quoteSubscriptionFlushTimer);
       this.quoteSubscriptionFlushTimer = null;
@@ -296,7 +349,7 @@ export class CloudApiSocket {
         return;
       }
       this.delegate.markCurrentUserUnverified();
-      if (this.quoteTargets.size > 0) {
+      if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0) {
         return;
       }
       this.teardown();
@@ -326,6 +379,24 @@ export class CloudApiSocket {
       return;
     }
 
+    const scannerKind = typeof parsed?.type === "string" ? SCANNER_MESSAGE_KINDS[parsed.type] : undefined;
+    if (scannerKind) {
+      const { type: _type, ...payload } = parsed;
+      this.emitScannerEvent(scannerKind, { type: "data", payload });
+      return;
+    }
+
+    if (parsed?.type === "scanner.denied") {
+      const denied = SCANNER_MESSAGE_KINDS[`scanner.${parsed.scanner}`];
+      if (denied) {
+        this.emitScannerEvent(denied, {
+          type: "denied",
+          reason: typeof parsed.reason === "string" ? parsed.reason : "pro_required",
+        });
+      }
+      return;
+    }
+
     if (parsed?.type === "market.quote" && parsed.quote && typeof parsed.symbol === "string") {
       const key = marketKey(parsed.symbol, parsed.exchange);
       const quote: CloudQuotePayload = {
@@ -347,8 +418,15 @@ export class CloudApiSocket {
     return baseUrl.replace(/^https?/, wsProtocol);
   }
 
+  private emitScannerEvent(scanner: ScannerKind, event: ScannerFeedEvent): void {
+    this.scannerSnapshots.set(scanner, event);
+    for (const listener of this.scannerListeners.get(scanner) ?? []) {
+      listener(event);
+    }
+  }
+
   private shouldKeepSocketOpen(): boolean {
-    if (this.quoteTargets.size > 0) return true;
+    if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0) return true;
     return !!this.delegate.getSocketAuthToken()
       && this.delegate.hasVerifiedUser()
       && this.channelListeners.size > 0;
@@ -368,12 +446,24 @@ export class CloudApiSocket {
       quoteTargets: this.quoteTargets.size,
       channelTargets: this.channelListeners.size,
     });
-    const ws = new WebSocket(url);
+    this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "connecting", this.getWebSocketBaseUrl());
+    let ws: WebSocket;
+    try {
+      ws = new WebSocket(url);
+    } catch (error) {
+      this.health.reportSocketState(
+        GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+        "error",
+        error instanceof Error ? error.message : String(error),
+      );
+      throw error;
+    }
     this.ws = ws;
 
     ws.onopen = () => {
       if (this.ws !== ws) return;
       cloudApiLog.info("websocket open");
+      this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "open", this.getWebSocketBaseUrl());
       this.reconnectDelayMs = 1000;
       this.flushSubscriptions();
     };
@@ -396,6 +486,11 @@ export class CloudApiSocket {
         tokenSource: usingWebSocketToken ? "websocket" : "session",
       });
       if (!activeSocket) return;
+      this.health.reportSocketState(
+        GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+        "closed",
+        closeEvent?.reason || (closeEvent?.code ? `Closed (${closeEvent.code})` : "Socket closed"),
+      );
       if (usingWebSocketToken && this.delegate.clearWebSocketTokenForFallback()) {
         this.reconnectDelayMs = 1000;
         cloudApiLog.warn("cleared websocket token after socket close; falling back to session token");
@@ -405,7 +500,9 @@ export class CloudApiSocket {
     };
 
     ws.onerror = () => {
-      // reconnect is handled by onclose
+      if (this.ws !== ws) return;
+      this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "error", "WebSocket error");
+      // Reconnect is handled by onclose.
     };
   }
 
@@ -428,6 +525,8 @@ export class CloudApiSocket {
         || type === "market.unsubscribe"
         || type === "chat.subscribe"
         || type === "chat.unsubscribe"
+        || type === "scanner.subscribe"
+        || type === "scanner.unsubscribe"
       ) {
         cloudApiLog.info("send websocket message", payload);
       }
@@ -442,6 +541,10 @@ export class CloudApiSocket {
       this.sendSocketMessage({ type: "chat.subscribe", channelId });
     }
 
+    for (const scanner of this.scannerListeners.keys()) {
+      this.sendSocketMessage({ type: "scanner.subscribe", scanner });
+    }
+
     if (this.quoteTargets.size > 0) {
       this.sendSocketMessage({
         type: "market.subscribe",

package/src/api-client/types.ts

@@ -322,10 +322,28 @@ export interface CloudFredSeriesPayload {
   info: CloudFredSeriesInfoPayload | null;
 }
 
+export interface CloudShortInterestPointPayload {
+  settlementDate: string;
+  sharesShort: number;
+  previousSharesShort: number | null;
+  averageDailyVolume: number | null;
+  daysToCover: number | null;
+  changePercent: number | null;
+  revised: boolean;
+}
+
+export interface CloudShortInterestPayload {
+  symbol: string;
+  issueName: string | null;
+  points: CloudShortInterestPointPayload[];
+}
+
 export interface CloudYieldPointPayload {
   maturity: string;
   maturityYears: number;
   yield: number | null;
+  /** FRED observation date. Absent on servers older than the field. */
+  asOf?: string | null;
 }
 
 type CloudCongressTradeSide = "BUY" | "SELL" | "EXCHANGE" | "OTHER";
@@ -570,12 +588,133 @@ export interface CloudMarketBatchPayload<T> {
   items: Array<CloudMarketBatchItem<T>>;
 }
 
+export type CloudMarketScreenerCategory = "gainers" | "losers" | "most-active";
+
+export interface CloudMarketScreenerItem {
+  rank: number;
+  symbol: string;
+  name: string;
+  price: number;
+  change: number;
+  changePercent: number;
+  volume: number;
+  tradeCount?: number;
+  currency: string;
+  high52w?: number;
+  low52w?: number;
+  dayHigh?: number;
+  dayLow?: number;
+  exchange: string;
+  lastUpdated: number;
+  dataSource: "live";
+}
+
+export interface CloudMarketScreenerPayload {
+  providerId: "gloomberb-cloud";
+  category: CloudMarketScreenerCategory;
+  asOf: string;
+  stale?: boolean;
+  items: CloudMarketScreenerItem[];
+}
+
 export interface CloudVerificationResponse {
   sent: boolean;
   email?: string;
   alreadyVerified?: boolean;
 }
 
+/** A short-lived, single-use browser URL that establishes the existing desktop session. */
+export interface CloudBrowserHandoffResponse {
+  url: string;
+}
+
+export interface DeviceAuthStartResponse {
+  deviceCode: string;
+  /** 8 characters formatted "XXXX-XXXX", shown so a user without the app can type it. */
+  userCode: string;
+  expiresAt: string;
+  /** Like https://gloom.sh/link/<userCode>; this is what the QR code encodes. */
+  verificationUri: string;
+  pollIntervalMs: number;
+}
+
+/** The approved response is single-use; polling again returns a non-approved status. */
+export type DeviceAuthTokenResponse =
+  | { status: "pending" }
+  | { status: "denied" }
+  | { status: "expired" }
+  | { status: "approved"; sessionToken: string; user: AuthUser };
+
+/** Shared server-computed scanners fanned out to every subscriber. */
+export type ScannerKind = "hilo" | "flow";
+
+export type ScannerStatus = "live" | "starting" | "closed" | "degraded";
+
+export interface ScannerWindowCounts {
+  highs: number;
+  lows: number;
+}
+
+export interface ScannerHiloExtreme {
+  symbol: string;
+  price: number;
+  volume?: number | null;
+  /** Times this symbol printed a new session extreme today. */
+  count: number;
+  at: number;
+}
+
+/** Which entitlement tier produced the payload: free accounts get a delayed instance. */
+export interface ScannerAccessInfo {
+  access: "realtime" | "delayed";
+  /** 0 on the realtime instance, 15 on the delayed one. */
+  delayMinutes: number;
+}
+
+export interface ScannerHiloPayload extends ScannerAccessInfo {
+  status: ScannerStatus;
+  asOf: number;
+  windows: {
+    s30: ScannerWindowCounts;
+    m1: ScannerWindowCounts;
+    m5: ScannerWindowCounts;
+  };
+  highs: ScannerHiloExtreme[];
+  lows: ScannerHiloExtreme[];
+}
+
+export interface ScannerFlowEvent {
+  id: string;
+  at: number;
+  underlying: string;
+  contract: string;
+  right: "C" | "P";
+  strike: number;
+  expiry: string;
+  side: "ask" | "bid" | "mid" | "unknown";
+  kind: "sweep" | "block" | "split" | "trade";
+  size: number;
+  price: number;
+  premium: number;
+  volume?: number | null;
+  openInterest?: number | null;
+  volOi?: number | null;
+  iv?: number | null;
+}
+
+export interface ScannerFlowPayload extends ScannerAccessInfo {
+  status: ScannerStatus;
+  asOf: number;
+  events: ScannerFlowEvent[];
+}
+
+export type ScannerPayload = ScannerHiloPayload | ScannerFlowPayload;
+
+/** What a scanner subscriber receives: data, or the entitlement refusal. */
+export type ScannerFeedEvent<T extends ScannerPayload = ScannerPayload> =
+  | { type: "data"; payload: T }
+  | { type: "denied"; reason: string };
+
 export interface QuoteStreamTarget {
   symbol: string;
   exchange?: string;

package/src/app/global-shortcuts.test.tsx

@@ -26,7 +26,10 @@ afterEach(async () => {
   }
 });
 
-function createRegistry(shortcutExecute?: () => void): PluginRegistry {
+function createRegistry(
+  shortcutExecute?: () => void,
+  onShowPane?: (paneId: string) => void,
+): PluginRegistry {
   return {
     shortcuts: new Map(shortcutExecute
       ? [["test-shortcut", { id: "test-shortcut", key: "x", execute: shortcutExecute }]]
@@ -39,6 +42,7 @@ function createRegistry(shortcutExecute?: () => void): PluginRegistry {
     ]),
     getPluginPaneIds: () => [],
     getShortcutPluginId: () => null,
+    showPane: onShowPane ?? (() => {}),
   } as unknown as PluginRegistry;
 }
 
@@ -96,12 +100,28 @@ async function renderHarness(
   });
 }
 
-async function emitKeypress(event: { name?: string; ctrl?: boolean; meta?: boolean; super?: boolean; shift?: boolean }) {
+/** The OpenTUI input host derives `targetEditable` from the focused editor. */
+function focusEditor() {
+  Object.defineProperty(testSetup!.renderer, "currentFocusedEditor", {
+    configurable: true,
+    get: () => ({}),
+  });
+}
+
+async function emitKeypress(event: {
+  name?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+  shift?: boolean;
+  alt?: boolean;
+}) {
   const keyEvent = {
     ctrl: false,
     meta: false,
     super: false,
     option: false,
+    alt: false,
     shift: false,
     eventType: "press",
     repeated: false,
@@ -164,17 +184,20 @@ describe("useAppGlobalShortcuts", () => {
     expect(event.propagationStopped).toBe(true);
   });
 
-  test("switches saved layouts with Ctrl-number and consumes the shortcut", async () => {
-    const actions: AppAction[] = [];
-    const config = createDefaultConfig("/tmp/gloomberb-global-shortcuts-layouts");
+  function layoutState(suffix: string, options: { commandBarOpen?: boolean } = {}) {
+    const config = createDefaultConfig(`/tmp/gloomberb-global-shortcuts-${suffix}`);
     config.layouts = [
       { name: "One", layout: cloneLayout(config.layout) },
       { name: "Two", layout: cloneLayout(config.layout) },
       { name: "Three", layout: cloneLayout(config.layout) },
     ];
     config.activeLayoutIndex = 0;
-    const state = createInitialState(config);
-    await renderHarness(state, createRegistry(), (action) => actions.push(action));
+    return { ...createInitialState(config), ...options };
+  }
+
+  test("switches saved layouts with Ctrl-number and consumes the shortcut", async () => {
+    const actions: AppAction[] = [];
+    await renderHarness(layoutState("layouts"), createRegistry(), (action) => actions.push(action));
 
     const event = await emitKeypress({ name: "2", ctrl: true });
 
@@ -183,6 +206,72 @@ describe("useAppGlobalShortcuts", () => {
     expect(event.propagationStopped).toBe(true);
   });
 
+  // Browsers and the desktop webview report Cmd as meta; the OpenTUI host maps
+  // the kitty `super` modifier onto the same field.
+  test("switches saved layouts with the Cmd-number reported by web and kitty hosts", async () => {
+    const actions: AppAction[] = [];
+    await renderHarness(layoutState("layouts-meta"), createRegistry(), (action) => actions.push(action));
+
+    const event = await emitKeypress({ name: "3", super: true });
+
+    expect(actions).toEqual([{ type: "SWITCH_LAYOUT", index: 2 }]);
+    expect(event.defaultPrevented).toBe(true);
+    expect(event.propagationStopped).toBe(true);
+  });
+
+  // Alt-digit keeps its terminal meaning; only the primary modifier switches.
+  test("ignores Alt-number", async () => {
+    const actions: AppAction[] = [];
+    await renderHarness(layoutState("layouts-alt"), createRegistry(), (action) => actions.push(action));
+
+    const event = await emitKeypress({ name: "2", alt: true });
+
+    expect(actions).toEqual([]);
+    expect(event.defaultPrevented).toBe(false);
+  });
+
+  // Leaving the digit unclaimed lets the desktop webview treat Cmd-digit as its
+  // own browser tab shortcut, which navigates the app away.
+  test("consumes layout numbers while the command bar is open without switching", async () => {
+    const actions: AppAction[] = [];
+    await renderHarness(
+      layoutState("layouts-command-bar", { commandBarOpen: true }),
+      createRegistry(),
+      (action) => actions.push(action),
+    );
+
+    const event = await emitKeypress({ name: "2", ctrl: true });
+
+    expect(actions).toEqual([]);
+    expect(event.defaultPrevented).toBe(true);
+    expect(event.propagationStopped).toBe(true);
+  });
+
+  test("consumes primary-modifier numbers with only one layout", async () => {
+    const actions: AppAction[] = [];
+    const config = createDefaultConfig("/tmp/gloomberb-global-shortcuts-one-layout");
+    const state = { ...createInitialState(config), commandBarOpen: true };
+    await renderHarness(state, createRegistry(), (action) => actions.push(action));
+
+    const event = await emitKeypress({ name: "1", super: true });
+
+    expect(actions).toEqual([]);
+    expect(event.defaultPrevented).toBe(true);
+    expect(event.propagationStopped).toBe(true);
+  });
+
+  test("consumes layout numbers while an editable field owns the keyboard", async () => {
+    const actions: AppAction[] = [];
+    await renderHarness(layoutState("layouts-editable"), createRegistry(), (action) => actions.push(action));
+    focusEditor();
+
+    const event = await emitKeypress({ name: "2", super: true });
+
+    expect(actions).toEqual([]);
+    expect(event.defaultPrevented).toBe(true);
+    expect(event.propagationStopped).toBe(true);
+  });
+
   test("does not run plain plugin shortcuts while input is captured", async () => {
     let executed = 0;
     const actions: AppAction[] = [];
@@ -202,6 +291,54 @@ describe("useAppGlobalShortcuts", () => {
     expect(event.propagationStopped).toBe(false);
   });
 
+  test("opens Help with question mark after the command bar is closed", async () => {
+    const openedPanes: string[] = [];
+    const actions: AppAction[] = [];
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-global-shortcuts-help"));
+    await renderHarness(state, createRegistry(undefined, (paneId) => openedPanes.push(paneId)), (action) => actions.push(action));
+
+    const event = await emitKeypress({ name: "?", shift: true });
+
+    expect(openedPanes).toEqual(["help"]);
+    expect(actions).toEqual([]);
+    expect(event.defaultPrevented).toBe(true);
+    expect(event.propagationStopped).toBe(true);
+  });
+
+  test("does not open Help with question mark while using the command bar", async () => {
+    const openedPanes: string[] = [];
+    const actions: AppAction[] = [];
+    const config = createDefaultConfig("/tmp/gloomberb-global-shortcuts-help-guard");
+    const commandBarState = {
+      ...createInitialState(config),
+      commandBarOpen: true,
+    };
+    await renderHarness(commandBarState, createRegistry(undefined, (paneId) => openedPanes.push(paneId)), (action) => actions.push(action));
+
+    let event = await emitKeypress({ name: "?", shift: true });
+    expect(openedPanes).toEqual([]);
+    expect(actions).toEqual([]);
+    expect(event.defaultPrevented).toBe(false);
+    expect(event.propagationStopped).toBe(false);
+  });
+
+  test("does not open Help with question mark while typing", async () => {
+    const openedPanes: string[] = [];
+    const actions: AppAction[] = [];
+    const config = createDefaultConfig("/tmp/gloomberb-global-shortcuts-help-input");
+    const inputCapturedState = {
+      ...createInitialState(config),
+      inputCaptured: true,
+    };
+    await renderHarness(inputCapturedState, createRegistry(undefined, (paneId) => openedPanes.push(paneId)), (action) => actions.push(action));
+
+    const event = await emitKeypress({ name: "?", shift: true });
+    expect(openedPanes).toEqual([]);
+    expect(actions).toEqual([]);
+    expect(event.defaultPrevented).toBe(false);
+    expect(event.propagationStopped).toBe(false);
+  });
+
   test("cycles panes with Tab while input is captured", async () => {
     const actions: AppAction[] = [];
     const state = {
@@ -218,8 +355,6 @@ describe("useAppGlobalShortcuts", () => {
         "portfolio-list:main",
         "chat:main",
         "ticker-detail:main",
-        "ticker-detail:nvda",
-        "help:main",
       ],
     }]);
     expect(event.defaultPrevented).toBe(true);