gloomberb 0.9.5 → 0.9.6

package/README.md

@@ -4,11 +4,13 @@
 
 # Gloomberb
 
-**Open-source finance terminal. Fast, keyboard-driven and extensible.**
+**Open-source finance terminal. Fast, keyboard-driven, and extensible.**
 
-Available as a desktop app or TUI.
+Desktop app for macOS and Windows. Terminal UI for macOS, Linux, and Windows.
 
-<a href="https://gloomberb.com/download/desktop"><strong>Download desktop for Mac</strong></a>
+<a href="https://gloomberb.com/download/desktop"><strong>Download desktop</strong></a>
+&nbsp;&middot;&nbsp;
+<a href="#install"><strong>Install the TUI</strong></a>
 
 <br />
 <br />
@@ -17,9 +19,22 @@ Available as a desktop app or TUI.
 
 </div>
 
+## Desktop App or TUI?
+
+Gloomberb has two ways in:
+
+| Surface | Best for | How it runs |
+|---------|----------|-------------|
+| Desktop app | A polished app window, pop-out panes, OS shortcuts, and built-in updates | Published for macOS and Windows. It also installs a `gloomberb` terminal command for the TUI. |
+| Terminal UI | Fast keyboard workflows inside your terminal, SSH/dev boxes, Linux machines, and script-friendly setups | Runs with `gloomberb` on macOS, Linux, and Windows. |
+
+Both share the same command language, plugin system, market data surfaces, portfolios, watchlists, alerts, notes, and AI tools.
+
 ## Install
 
-macOS desktop app + terminal command:
+### macOS
+
+Install the desktop app and the `gloomberb` terminal command:
 
 ```bash
 brew install --cask vincelwt/tap/gloomberb
@@ -27,13 +42,37 @@ brew install --cask vincelwt/tap/gloomberb
 curl -fsSL gloomberb.com/install | bash
 ```
 
-Both install `Gloomberb.app` and a `gloomberb` terminal command that runs the TUI through the app bundle, so the Bun runtime is stored once.
+Both install `Gloomberb.app` and a `gloomberb` command that runs the TUI through the app bundle, so the bundled runtime is stored once.
 
-Desktop-only download:
+Prefer a direct download?
 
 - [Download Gloomberb for Mac](https://gloomberb.com/download/desktop)
 
-Terminal-only install:
+### Linux
+
+Install the standalone TUI binary:
+
+```bash
+curl -fsSL gloomberb.com/install | bash
+```
+
+This installs `gloomberb` to `~/.local/bin` by default. A Linux desktop package is not published yet.
+
+### Windows
+
+Install the desktop app:
+
+- [Download GloomberbSetup.exe for Windows x64](https://github.com/vincelwt/gloomberb/releases/latest/download/stable-win-x64-GloomberbSetup.exe)
+
+The installer adds the app and a `gloomberb` terminal command. For a terminal-only setup, install Bun and use the package:
+
+```powershell
+bun install -g gloomberb
+```
+
+### Terminal Package
+
+Already have Bun installed on any supported OS?
 
 ```bash
 bun install -g gloomberb
@@ -45,7 +84,7 @@ Then run:
 gloomberb
 ```
 
-On macOS, app updates replace the app bundle in place and keep the terminal command pointing at the updated bundle. Homebrew users can also update through `brew upgrade --cask gloomberb`.
+On macOS and Windows, desktop updates replace the installed app in place and keep the terminal command pointing at the updated runtime. Homebrew users can also update through `brew upgrade --cask gloomberb`.
 
 For the best terminal experience, use a [Kitty](https://sw.kovidgoyal.net/kitty/)-compatible terminal such as Ghostty, Kitty, or WezTerm.
 
@@ -58,6 +97,7 @@ Open command mode with `Ctrl+P`, then type a command. Press `` ` `` to open tick
 | `DES AAPL` | Security details |
 | `GP NVDA` | Price chart |
 | `TOP` | Ranked market stories |
+| `HM` | Market heatmap |
 | `MOST` | Market movers |
 | `PF` | Portfolios and watchlists |
 | `KELLY AAPL` | Position sizing |
@@ -177,6 +217,7 @@ Use `HELP` inside Gloomberb for the live shortcut list. The common command-bar p
 | Shortcut | Function |
 |----------|----------|
 | `TOP` | Ranked market stories |
+| `HM` | Market heatmap for large US stocks and ETFs |
 | `MOST` | Top gainers, losers, most active, and trending tickers |
 | `PM <query>` | Polymarket and Kalshi prediction data |
 | `N` | News feed |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",
@@ -18,7 +18,7 @@
     "build": "bun run scripts/build.ts",
     "build:all": "bun run scripts/build.ts --all",
     "desktop:view:build": "bun run scripts/build-electrobun-view.ts",
-    "desktop:dev": "electrobun dev --watch",
+    "desktop:dev": "bun run scripts/electrobun-dev.ts",
     "desktop:build": "electrobun build",
     "desktop:release": "electrobun build --env=stable",
     "desktop:release:windows": "electrobun build --env=stable --targets=win-x64",

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

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { createTestRenderer } from "@opentui/core/testing";
 import { act } from "react";
 import { createOpenTuiTestRoot as createRoot, TestDialogProvider } from "../renderers/opentui/test-utils";
-import { createDefaultConfig } from "../types/config";
+import { cloneLayout, createDefaultConfig } from "../types/config";
 import { createInitialState, type AppAction, type AppState } from "../state/app/context";
 import type { PluginRegistry } from "../plugins/registry";
 import { useAppGlobalShortcuts } from "./global-shortcuts";
@@ -164,6 +164,25 @@ 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");
+    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));
+
+    const event = await emitKeypress({ name: "2", ctrl: true });
+
+    expect(actions).toEqual([{ type: "SWITCH_LAYOUT", index: 1 }]);
+    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[] = [];

package/src/app/global-shortcuts.ts

@@ -76,6 +76,8 @@ export function useAppGlobalShortcuts({
       if (idx < layouts.length && idx !== state.config.activeLayoutIndex) {
         dispatch({ type: "SWITCH_LAYOUT", index: idx });
       }
+      event.preventDefault();
+      event.stopPropagation();
       return;
     }
 

package/src/app/pane-runtime/index.tsx

@@ -73,23 +73,30 @@ export function useAppPaneRuntime({
     return resolvePaneTargetInLayout(layout, paneId);
   }, [state.config.layout]);
 
-  const persistLayout = useCallback((layout: LayoutConfig, options?: { pushHistory?: boolean }) => {
+  const persistLayout = useCallback((layout: LayoutConfig, options?: { pushHistory?: boolean; focusedPaneId?: string | null }) => {
     const currentState = stateRef.current;
     const normalizedLayout = normalizePaneLayout(layout);
     if (options?.pushHistory !== false) {
       dispatch({ type: "PUSH_LAYOUT_HISTORY" });
     }
-    dispatch({ type: "UPDATE_LAYOUT", layout: normalizedLayout });
+    const hasFocusTarget = !!options && Object.prototype.hasOwnProperty.call(options, "focusedPaneId");
+    dispatch(hasFocusTarget
+      ? { type: "UPDATE_LAYOUT", layout: normalizedLayout, focusedPaneId: options.focusedPaneId ?? null }
+      : { type: "UPDATE_LAYOUT", layout: normalizedLayout });
     scheduleConfigSave(syncConfigActiveLayoutState(
       { ...currentState.config, layout: normalizedLayout },
       currentState.paneState,
-      currentState.focusedPaneId,
+      hasFocusTarget ? (options.focusedPaneId ?? null) : currentState.focusedPaneId,
       currentState.activePanel,
     ));
   }, [dispatch, stateRef]);
 
   const activatePane = useCallback((paneId: string, layout: LayoutConfig = state.config.layout) => {
-    dispatch({ type: "SET_ACTIVE_PANEL", panel: resolvePanelForPane({ layout, paneId, pluginRegistry }) });
+    dispatch({
+      type: "SET_ACTIVE_PANEL",
+      panel: resolvePanelForPane({ layout, paneId, pluginRegistry }),
+      preserveFocus: true,
+    });
     dispatch({ type: "FOCUS_PANE", paneId });
   }, [dispatch, pluginRegistry, state.config.layout]);
 

package/src/app/pane-runtime/pane-settings-runtime.tsx

@@ -15,7 +15,7 @@ interface UseAppPaneSettingsRuntimeOptions {
   dataProvider: DataProvider;
   dialog: DialogApi;
   dispatch: Dispatch<AppAction>;
-  persistLayout: (layout: LayoutConfig, options?: { pushHistory?: boolean }) => void;
+  persistLayout: (layout: LayoutConfig, options?: { pushHistory?: boolean; focusedPaneId?: string | null }) => void;
   pluginRegistry: PluginRegistry;
   resolvePaneTarget: (paneId: string, layout?: LayoutConfig) => string | null;
   stateRef: { current: AppState };

package/src/app.tsx

@@ -39,6 +39,8 @@ import { bindPluginRegistryRuntimeAccess } from "./app/runtime/plugin-bindings";
 import { useAppStartupRuntime } from "./app/runtime/startup";
 import { useTickerRefreshRuntime } from "./app/runtime/ticker-refresh";
 import { useAppUpdateRuntime } from "./app/runtime/update";
+import { RemoteControlHost, type RemoteControlAdapter } from "./remote/app-host";
+import { RemoteUiRegistryProvider } from "./remote/semantic-tree";
 import {
   resolveAppSessionSnapshot,
   resolveCliLaunchConfig,
@@ -55,6 +57,7 @@ interface AppInnerProps {
   sessionSnapshot?: AppSessionSnapshot | null;
   desktopWindowBridge?: DesktopWindowBridge;
   desktopApplicationMenuBridge?: DesktopApplicationMenuBridge;
+  remoteControlAdapter?: RemoteControlAdapter;
 }
 
 function ThemedAppRoot({ children }: { children: ReactNode }) {
@@ -83,9 +86,11 @@ function AppInner({
   sessionSnapshot = null,
   desktopWindowBridge,
   desktopApplicationMenuBridge,
+  remoteControlAdapter,
 }: AppInnerProps) {
   const dispatch = useAppDispatch();
   const stateRef = useAppStateRef();
+  const getRemoteState = useCallback(() => stateRef.current, [stateRef]);
   const config = useAppSelector((state) => state.config);
   const tickers = useAppSelector((state) => state.tickers);
   const paneState = useAppSelector((state) => state.paneState);
@@ -288,6 +293,13 @@ function AppInner({
   if (desktopWindowBridge?.kind === "detached" && desktopWindowBridge.paneId) {
     return (
       <ContextMenuProvider pluginRegistry={pluginRegistry}>
+        <RemoteControlHost
+          adapter={remoteControlAdapter}
+          dispatch={dispatch}
+          getState={getRemoteState}
+          pluginRegistry={pluginRegistry}
+          desktopWindowBridge={desktopWindowBridge}
+        />
         <ThemedAppRoot>
           <DetachedPaneShell
             pluginRegistry={pluginRegistry}
@@ -301,6 +313,13 @@ function AppInner({
 
   return (
     <ContextMenuProvider pluginRegistry={pluginRegistry}>
+      <RemoteControlHost
+        adapter={remoteControlAdapter}
+        dispatch={dispatch}
+        getState={getRemoteState}
+        pluginRegistry={pluginRegistry}
+        desktopWindowBridge={desktopWindowBridge}
+      />
       <ThemedAppRoot>
         <Header />
         <TransientLayoutProvider>
@@ -336,6 +355,7 @@ interface AppProps {
   desktopApplicationMenuBridge?: DesktopApplicationMenuBridge;
   desktopSnapshot?: DesktopSharedStateSnapshot | null;
   desktopThemePreview?: DesktopThemePreviewState | null;
+  remoteControlAdapter?: RemoteControlAdapter;
 }
 
 export function App({
@@ -346,6 +366,7 @@ export function App({
   desktopApplicationMenuBridge,
   desktopSnapshot = null,
   desktopThemePreview = null,
+  remoteControlAdapter,
 }: AppProps) {
   const renderer = useNativeRenderer();
   const effectiveInitialConfig = useMemo(() => {
@@ -413,23 +434,26 @@ export function App({
   }
 
   return (
-    <AppProvider
-      config={config}
-      sessionStore={desktopWindowBridge?.kind === "detached" ? undefined : services.persistence.sessions}
-      sessionSnapshot={sessionSnapshot}
-      desktopBridge={desktopWindowBridge}
-      desktopSnapshot={desktopSnapshot}
-      initialThemePreview={desktopThemePreview}
-    >
-      <AppInner
-        pluginRegistry={services.pluginRegistry}
-        tickerRepository={services.tickerRepository}
-        dataProvider={services.dataProvider}
-        marketData={services.marketData}
+    <RemoteUiRegistryProvider>
+      <AppProvider
+        config={config}
+        sessionStore={desktopWindowBridge?.kind === "detached" ? undefined : services.persistence.sessions}
         sessionSnapshot={sessionSnapshot}
-        desktopWindowBridge={desktopWindowBridge}
-        desktopApplicationMenuBridge={desktopApplicationMenuBridge}
-      />
-    </AppProvider>
+        desktopBridge={desktopWindowBridge}
+        desktopSnapshot={desktopSnapshot}
+        initialThemePreview={desktopThemePreview}
+      >
+        <AppInner
+          pluginRegistry={services.pluginRegistry}
+          tickerRepository={services.tickerRepository}
+          dataProvider={services.dataProvider}
+          marketData={services.marketData}
+          sessionSnapshot={sessionSnapshot}
+          desktopWindowBridge={desktopWindowBridge}
+          desktopApplicationMenuBridge={desktopApplicationMenuBridge}
+          remoteControlAdapter={remoteControlAdapter}
+        />
+      </AppProvider>
+    </RemoteUiRegistryProvider>
   );
 }

package/src/cli/commands/remote.ts

@@ -0,0 +1,206 @@
+import { getDataDir } from "../../data/config/store";
+import type { CliCommandContext, CliCommandDef } from "../../types/plugin";
+import { sendRemoteControlRequest } from "../../remote/client";
+import type { RemoteAppKind, RemoteControlRequest, RemoteControlResponse } from "../../remote/types";
+
+interface RemoteArgs {
+  args: string[];
+  appKind?: RemoteAppKind;
+  expectRev?: string;
+  intervalMs: number;
+}
+
+export const remoteCliCommand: CliCommandDef = {
+  name: "remote",
+  description: "Control a running app through the semantic remote API",
+  help: {
+    usage: [
+      "remote schema [--app tui|desktop]",
+      "remote help [--app tui|desktop]",
+      "remote get <resource> [--app tui|desktop]",
+      "remote call <operation> [json] [--dry-run] [--app tui|desktop]",
+      "remote patch <resource> <json-patch> [--expect-rev rev] [--dry-run] [--app tui|desktop]",
+      "remote batch <json> [--dry-run] [--app tui|desktop]",
+      "remote watch <resource> [--interval ms] [--limit n] [--app tui|desktop]",
+    ],
+  },
+  execute: async (rawArgs, ctx) => {
+    const parsed = parseRemoteArgs(rawArgs);
+    const action = parsed.args[0];
+    if (!action) {
+      ctx.fail("Usage: gloomberb remote <schema|help|get|call|patch|batch|watch>");
+      return;
+    }
+
+    const dataDir = await getDataDir();
+    if (!dataDir) {
+      ctx.fail("No data directory configured.", "Run gloomberb once before using remote control.");
+      return;
+    }
+
+    if (action === "watch") {
+      const resource = parsed.args[1];
+      if (!resource) {
+        ctx.fail("Usage: gloomberb remote watch <resource>");
+        return;
+      }
+      const limit = ctx.cliOptions.limit ?? Number.POSITIVE_INFINITY;
+      for (let index = 0; index < limit; index += 1) {
+        const response = await sendRemoteControlRequest({ type: "get", resource }, {
+          dataDir,
+          appKind: parsed.appKind,
+        });
+        printRemoteResponse(response, ctx);
+        if (index < limit - 1) await new Promise((resolve) => setTimeout(resolve, parsed.intervalMs));
+      }
+      return;
+    }
+
+    const request = buildRemoteRequest(action, parsed, ctx.cliOptions.dryRun);
+    const response = await sendRemoteControlRequest(request, {
+      dataDir,
+      appKind: parsed.appKind,
+    });
+    printRemoteResponse(response, ctx);
+  },
+};
+
+function parseRemoteArgs(rawArgs: string[]): RemoteArgs {
+  const args: string[] = [];
+  let appKind: RemoteAppKind | undefined;
+  let expectRev: string | undefined;
+  let intervalMs = 1_000;
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index]!;
+    if (arg === "--app") {
+      index += 1;
+      appKind = parseAppKind(rawArgs[index]);
+      continue;
+    }
+    if (arg.startsWith("--app=")) {
+      appKind = parseAppKind(arg.slice("--app=".length));
+      continue;
+    }
+    if (arg === "--expect-rev") {
+      index += 1;
+      expectRev = rawArgs[index];
+      if (!expectRev) throw new Error("Missing value for --expect-rev.");
+      continue;
+    }
+    if (arg.startsWith("--expect-rev=")) {
+      expectRev = arg.slice("--expect-rev=".length);
+      continue;
+    }
+    if (arg === "--interval") {
+      index += 1;
+      intervalMs = parseInterval(rawArgs[index]);
+      continue;
+    }
+    if (arg.startsWith("--interval=")) {
+      intervalMs = parseInterval(arg.slice("--interval=".length));
+      continue;
+    }
+    args.push(arg);
+  }
+
+  return { args, appKind, expectRev, intervalMs };
+}
+
+function buildRemoteRequest(action: string, parsed: RemoteArgs, dryRun: boolean): RemoteControlRequest {
+  switch (action) {
+    case "schema":
+      return { type: "schema" };
+    case "help":
+      return { type: "help" };
+    case "get": {
+      const resource = parsed.args[1];
+      if (!resource) throw new Error("Usage: gloomberb remote get <resource>");
+      return { type: "get", resource };
+    }
+    case "call": {
+      const operation = parsed.args[1];
+      if (!operation) throw new Error("Usage: gloomberb remote call <operation> [json]");
+      return {
+        type: "call",
+        operation,
+        input: parseJsonValue(parsed.args[2], {}),
+        dryRun,
+      };
+    }
+    case "patch": {
+      const resource = parsed.args[1];
+      const patchRaw = parsed.args[2];
+      if (!resource || !patchRaw) throw new Error("Usage: gloomberb remote patch <resource> <json-patch>");
+      const patch = parseJsonValue(patchRaw, []);
+      if (!Array.isArray(patch)) throw new Error("Remote patch payload must be a JSON array.");
+      return {
+        type: "patch",
+        resource,
+        patch,
+        expectRev: parsed.expectRev,
+        dryRun,
+      };
+    }
+    case "batch": {
+      const payload = parseJsonValue(parsed.args[1], null);
+      if (!payload) throw new Error("Usage: gloomberb remote batch <json>");
+      if (Array.isArray(payload)) return { type: "batch", requests: payload as RemoteControlRequest[], dryRun };
+      return withCliDryRun(payload as RemoteControlRequest, dryRun);
+    }
+    default:
+      throw new Error(`Unknown remote action "${action}".`);
+  }
+}
+
+function withCliDryRun(request: RemoteControlRequest, dryRun: boolean): RemoteControlRequest {
+  if (!dryRun) return request;
+  if (request.type === "batch") return { ...request, dryRun: true };
+  if (request.type === "call" || request.type === "patch") return { ...request, dryRun: true };
+  return request;
+}
+
+function parseAppKind(value: string | undefined): RemoteAppKind {
+  if (value === "tui" || value === "desktop") return value;
+  throw new Error("--app must be either tui or desktop.");
+}
+
+function parseInterval(value: string | undefined): number {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 100) {
+    throw new Error("--interval must be an integer >= 100.");
+  }
+  return parsed;
+}
+
+function parseJsonValue<T>(raw: string | undefined, fallback: T): unknown {
+  if (raw == null) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON payload: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function printRemoteResponse(
+  response: RemoteControlResponse,
+  ctx: CliCommandContext,
+): void {
+  if (!response.ok) {
+    const details = response.error.details == null
+      ? undefined
+      : typeof response.error.details === "string"
+        ? response.error.details
+        : JSON.stringify(response.error.details, null, 2);
+    ctx.fail(response.error.message, details);
+    return;
+  }
+  const data = response.state ? { data: response.data, state: response.state } : response.data;
+  ctx.printResult({
+    data,
+    metadata: response.rev ? { rev: response.rev } : undefined,
+    warnings: response.warnings,
+  }, {
+    text: (data) => JSON.stringify(data, null, 2),
+  });
+}

package/src/cli/index.ts

@@ -18,6 +18,7 @@ import { ticker, buildTickerReport } from "./commands/ticker";
 import { apiCliCommand } from "./commands/api";
 import { marketDataCliCommands } from "./commands/market";
 import { overviewCliCommands } from "./commands/overview";
+import { remoteCliCommand } from "./commands/remote";
 import { createSystemCliCommands } from "./commands/system";
 import {
   aiCliCommand,
@@ -188,6 +189,7 @@ function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
     apiCliCommand,
     ...marketDataCliCommands,
     ...overviewCliCommands,
+    remoteCliCommand,
     ...createSystemCliCommands(() => commands),
     brokerCliCommand,
     ibkrCliCommand,

package/src/components/chart/core/keyboard.ts

@@ -1,4 +1,13 @@
-export function resolveChartKeyboardKey(event: { name?: string; sequence?: string }): string {
+export function resolveChartKeyboardKey(event: {
+  name?: string;
+  sequence?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  alt?: boolean;
+  super?: boolean;
+}): string {
+  if (event.ctrl || event.meta || event.alt || event.super) return "";
+
   const name = event.name ?? "";
   const sequence = event.sequence ?? "";
   const candidates = [name, sequence];

package/src/components/chart/static/bar-chart-surface.test.tsx

@@ -47,6 +47,8 @@ describe("StaticBarChartSurface", () => {
 
     await act(async () => {
       await testSetup!.mockMouse.moveTo(14, 4);
+    });
+    await act(async () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
     });
@@ -86,6 +88,8 @@ describe("StaticBarChartSurface", () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
       await testSetup!.mockMouse.moveTo(14, 4);
+    });
+    await act(async () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
     });

package/src/components/chart/static/chart/surface.test.tsx

@@ -1,19 +1,23 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { act } from "react";
+import { act, useEffect } from "react";
 import { testRender } from "../../../../renderers/opentui/test-utils";
 import { colors } from "../../../../theme/colors";
+import { RemoteUiRegistryProvider, useRemoteUiRegistry, type RemoteUiRegistry } from "../../../../remote/semantic-tree";
 import { resolveChartPalette } from "../../core/renderer";
 import { StaticChartSurface } from "./surface";
 import type { ProjectedChartPoint } from "../../core/data";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let remoteRegistry: RemoteUiRegistry | null = null;
 
 afterEach(async () => {
-  if (!testSetup) return;
+  const setup = testSetup;
+  testSetup = undefined;
+  remoteRegistry = null;
+  if (!setup) return;
   await act(async () => {
-    testSetup!.renderer.destroy();
+    setup.renderer.destroy();
   });
-  testSetup = undefined;
 });
 
 const points: ProjectedChartPoint[] = [
@@ -22,6 +26,14 @@ const points: ProjectedChartPoint[] = [
   { date: new Date("2026-01-03"), open: 4.9, high: 4.9, low: 4.9, close: 4.9, volume: 0 },
 ];
 
+function RemoteRegistryProbe() {
+  const registry = useRemoteUiRegistry();
+  useEffect(() => {
+    remoteRegistry = registry;
+  }, [registry]);
+  return null;
+}
+
 describe("StaticChartSurface", () => {
   test("renders unit and custom y-axis labels", async () => {
     testSetup = await testRender(
@@ -132,6 +144,49 @@ describe("StaticChartSurface", () => {
 
     await act(async () => {
       await testSetup!.mockMouse.moveTo(20, 4);
+    });
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(testSetup.captureCharFrame()).not.toBe(initialFrame);
+    expect(testSetup.captureCharFrame()).toContain("X49");
+    expect(testSetup.captureCharFrame()).toContain("Y3.97");
+  });
+
+  test("exposes semantic remote cursor control", async () => {
+    testSetup = await testRender(
+      <RemoteUiRegistryProvider>
+        <RemoteRegistryProbe />
+        <StaticChartSurface
+          points={points}
+          width={48}
+          height={10}
+          mode="line"
+          colors={resolveChartPalette(colors, "positive")}
+          xAxisLabels={["0%", "50%", "100%"]}
+          formatXAxisCursorValue={(ratio) => `X${Math.round(ratio * 100)}`}
+          formatYAxisValue={(value) => `Y${value.toFixed(2)}`}
+        />
+      </RemoteUiRegistryProvider>,
+      { width: 50, height: 12 },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+    const initialFrame = testSetup.captureCharFrame();
+    const chartNode = remoteRegistry?.snapshot().find((node) => (
+      node.role === "chart" && node.metadata?.kind === "static-chart"
+    ));
+    expect(chartNode?.actions).toContain("moveCursor");
+
+    await act(async () => {
+      await remoteRegistry!.invoke(chartNode!.id, "moveCursor", { x: 20, y: 4 });
+    });
+    await act(async () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
     });