gloomberb 0.5.1 → 0.6.0

package/src/plugins/plugin-runtime.test.tsx

@@ -1,22 +1,26 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { act, useEffect, useReducer } from "react";
-import { testRender } from "@opentui/react/test-utils";
+import { act, useEffect, useReducer, type SetStateAction } from "react";
+import { testRender } from "../renderers/opentui/test-utils";
 import {
   AppContext,
   PaneInstanceProvider,
   appReducer,
   createInitialState,
 } from "../state/app-context";
+import { createConfigBackedTestPluginRuntime, createTestPluginRuntime } from "../test-support/plugin-runtime";
 import { createDefaultConfig } from "../types/config";
 import {
   PluginRenderProvider,
   deletePluginPaneStateValue,
   getPluginPaneStateValue,
   setPluginPaneStateValue,
-  type PluginRuntimeAccess,
+  usePluginAppActions,
+  useDebouncedPluginPaneState,
   usePluginConfigState,
+  usePluginPaneActions,
   usePluginPaneState,
   usePluginState,
+  useSetPluginConfigStates,
 } from "./plugin-runtime";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
@@ -51,77 +55,68 @@ describe("plugin runtime helpers", () => {
 });
 
 describe("plugin runtime hooks", () => {
+  test("debounces pane state commits", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-plugin-runtime-debounce");
+    const stateRef: { current: ReturnType<typeof createInitialState> | null } = { current: null };
+    let setSelection: ((value: SetStateAction<string>) => void) | null = null;
+
+    const runtime = createTestPluginRuntime();
+
+    function HookHarness() {
+      const [state, dispatch] = useReducer(appReducer, createInitialState(config));
+      stateRef.current = state;
+
+      return (
+        <AppContext value={{ state, dispatch }}>
+          <PaneInstanceProvider paneId="prediction-markets:main">
+            <PluginRenderProvider pluginId="prediction-markets" runtime={runtime}>
+              <HookProbe />
+            </PluginRenderProvider>
+          </PaneInstanceProvider>
+        </AppContext>
+      );
+    }
+
+    function HookProbe() {
+      const [selection, setDebouncedSelection] = useDebouncedPluginPaneState("selectedRowKey", "row-a", 20);
+      setSelection = setDebouncedSelection;
+      return <text>{selection}</text>;
+    }
+
+    testSetup = await testRender(<HookHarness />, { width: 40, height: 5 });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      setSelection?.("row-b");
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(
+      stateRef.current?.paneState["prediction-markets:main"]?.pluginState?.["prediction-markets"]?.selectedRowKey,
+    ).toBeUndefined();
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 30));
+      await testSetup!.renderOnce();
+    });
+
+    expect(
+      stateRef.current?.paneState["prediction-markets:main"]?.pluginState?.["prediction-markets"]?.selectedRowKey,
+    ).toBe("row-b");
+  });
+
   test("updates pane, global resume, and config state through the plugin hooks", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-plugin-runtime");
     const stateRef: { current: ReturnType<typeof createInitialState> | null } = { current: null };
     const dispatchRef: { current: React.Dispatch<any> | null } = { current: null };
-    const resumeState = new Map<string, unknown>();
-    const listeners = new Map<string, Set<() => void>>();
-
-    const runtime: PluginRuntimeAccess = {
-      pinTicker() {},
-      navigateTicker() {},
-      subscribeResumeState(pluginId, key, listener) {
-        const listenerKey = `${pluginId}:${key}`;
-        if (!listeners.has(listenerKey)) listeners.set(listenerKey, new Set());
-        listeners.get(listenerKey)!.add(listener);
-        return () => {
-          const current = listeners.get(listenerKey);
-          if (!current) return;
-          current.delete(listener);
-        };
-      },
-      getResumeState(pluginId, key) {
-        return (resumeState.get(`${pluginId}:${key}`) as any) ?? null;
-      },
-      setResumeState(pluginId, key, value) {
-        const listenerKey = `${pluginId}:${key}`;
-        resumeState.set(listenerKey, value);
-        for (const listener of listeners.get(listenerKey) ?? []) listener();
-      },
-      deleteResumeState(pluginId, key) {
-        const listenerKey = `${pluginId}:${key}`;
-        resumeState.delete(listenerKey);
-        for (const listener of listeners.get(listenerKey) ?? []) listener();
-      },
-      getConfigState(pluginId, key) {
-        return (stateRef.current?.config.pluginConfig[pluginId]?.[key] as any) ?? null;
-      },
-      async setConfigState(pluginId, key, value) {
-        const currentState = stateRef.current!;
-        dispatchRef.current?.({
-          type: "SET_CONFIG",
-          config: {
-            ...currentState.config,
-            pluginConfig: {
-              ...currentState.config.pluginConfig,
-              [pluginId]: {
-                ...(currentState.config.pluginConfig[pluginId] ?? {}),
-                [key]: value,
-              },
-            },
-          },
-        });
-      },
-      async deleteConfigState(pluginId, key) {
-        const currentState = stateRef.current!;
-        const currentPluginConfig = { ...(currentState.config.pluginConfig[pluginId] ?? {}) };
-        delete currentPluginConfig[key];
-        const nextPluginConfig = { ...currentState.config.pluginConfig };
-        if (Object.keys(currentPluginConfig).length === 0) delete nextPluginConfig[pluginId];
-        else nextPluginConfig[pluginId] = currentPluginConfig;
-        dispatchRef.current?.({
-          type: "SET_CONFIG",
-          config: {
-            ...currentState.config,
-            pluginConfig: nextPluginConfig,
-          },
-        });
-      },
-      getConfigStateKeys(pluginId) {
-        return Object.keys(stateRef.current?.config.pluginConfig[pluginId] ?? {}).sort();
-      },
-    };
+    const runtime = createConfigBackedTestPluginRuntime({
+      getConfig: () => stateRef.current?.config,
+      setConfig: (config) => dispatchRef.current?.({ type: "SET_CONFIG", config }),
+    });
 
     function HookHarness() {
       const [state, dispatch] = useReducer(appReducer, createInitialState(config));
@@ -144,16 +139,24 @@ describe("plugin runtime hooks", () => {
       const [venueScope, setVenueScope] = usePluginPaneState<string>("venueScope", "all");
       const [provider, setProvider] = usePluginState<string>("provider", "claude");
       const [mode, setMode] = usePluginConfigState<string>("displayMode", "compact");
+      const [layoutMode] = usePluginConfigState<string>("layoutMode", "default");
+      const setConfigStates = useSetPluginConfigStates();
 
       useEffect(() => {
         if (paneSelection === 0) setPaneSelection(3);
         if (venueScope === "all") setVenueScope("kalshi");
         if (provider === "claude") setProvider("codex");
-        if (mode === "compact") setMode("expanded");
+        if (mode === "compact") {
+          setMode("expanded");
+        } else if (layoutMode === "default") {
+          setConfigStates({ layoutMode: "wide", density: "dense" });
+        }
       }, [
+        layoutMode,
         mode,
         paneSelection,
         provider,
+        setConfigStates,
         setMode,
         setPaneSelection,
         setProvider,
@@ -161,7 +164,7 @@ describe("plugin runtime hooks", () => {
         venueScope,
       ]);
 
-      return <text>{`${paneSelection}|${venueScope}|${provider}|${mode}`}</text>;
+      return <text>{`${paneSelection}|${venueScope}|${provider}|${mode}|${layoutMode}`}</text>;
     }
 
     testSetup = await testRender(<HookHarness />, { width: 40, height: 5 });
@@ -169,10 +172,11 @@ describe("plugin runtime hooks", () => {
     await act(async () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
     });
 
     const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("3|kalshi|codex|expanded");
+    expect(frame).toContain("3|kalshi|codex|expanded|wide");
     expect(stateRef.current?.paneState["portfolio-list:main"]?.pluginState).toEqual({
       news: {
         selectedIdx: 3,
@@ -180,8 +184,106 @@ describe("plugin runtime hooks", () => {
       },
     });
     expect(stateRef.current?.config.pluginConfig.news).toEqual({
+      density: "dense",
       displayMode: "expanded",
+      layoutMode: "wide",
+    });
+    expect(runtime.getResumeState("news", "provider")).toBe("codex");
+  });
+
+  test("exposes renderer app actions through the plugin hook", async () => {
+    const calls: string[] = [];
+    let actions: ReturnType<typeof usePluginAppActions> | null = null;
+
+    const runtime = createTestPluginRuntime({
+      openCommandBar(query?: string) {
+        calls.push(`command:${query ?? ""}`);
+      },
+      showWidget(widgetId: string) {
+        calls.push(`show:${widgetId}`);
+      },
+      hideWidget(widgetId: string) {
+        calls.push(`hide:${widgetId}`);
+      },
+      openPluginCommandWorkflow(commandId: string) {
+        calls.push(`workflow:${commandId}`);
+      },
+      notify(notification) {
+        calls.push(`notify:${notification.body}`);
+      },
+    });
+
+    function HookProbe() {
+      actions = usePluginAppActions();
+      return <text>actions</text>;
+    }
+
+    testSetup = await testRender(
+      <PluginRenderProvider pluginId="help" runtime={runtime}>
+        <HookProbe />
+      </PluginRenderProvider>,
+      { width: 40, height: 5 },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    actions?.openCommandBar("PL ");
+    actions?.showWidget("debug");
+    actions?.hideWidget("chat");
+    actions?.openPluginCommandWorkflow("set-alert");
+    actions?.notify({ body: "Saved", type: "success" });
+
+    expect(calls).toEqual([
+      "command:PL ",
+      "show:debug",
+      "hide:chat",
+      "workflow:set-alert",
+      "notify:Saved",
+    ]);
+  });
+
+  test("exposes renderer pane actions through the plugin hook", async () => {
+    const calls: string[] = [];
+    let actions: ReturnType<typeof usePluginPaneActions> | null = null;
+
+    const runtime = createTestPluginRuntime({
+      selectTicker(symbol: string, paneId?: string) {
+        calls.push(`select:${symbol}:${paneId ?? ""}`);
+      },
+      switchTab(tabId: string, paneId?: string) {
+        calls.push(`tab:${tabId}:${paneId ?? ""}`);
+      },
+      switchPanel(panel: "left" | "right") {
+        calls.push(`panel:${panel}`);
+      },
     });
-    expect(resumeState.get("news:provider")).toBe("codex");
+
+    function HookProbe() {
+      actions = usePluginPaneActions();
+      return <text>pane-actions</text>;
+    }
+
+    testSetup = await testRender(
+      <PluginRenderProvider pluginId="ibkr" runtime={runtime}>
+        <HookProbe />
+      </PluginRenderProvider>,
+      { width: 40, height: 5 },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    actions?.selectTicker("AAPL", "ibkr:main");
+    actions?.switchTab("ibkr-trade", "ibkr:main");
+    actions?.switchPanel("right");
+
+    expect(calls).toEqual([
+      "select:AAPL:ibkr:main",
+      "tab:ibkr-trade:ibkr:main",
+      "panel:right",
+    ]);
   });
 });

package/src/plugins/plugin-runtime.tsx

@@ -2,22 +2,50 @@ import {
   createContext,
   useCallback,
   useContext,
+  useEffect,
   useRef,
+  useState,
   useSyncExternalStore,
   type ReactNode,
   type SetStateAction,
 } from "react";
-import { useAppState, usePaneInstanceId, type PaneRuntimeState } from "../state/app-context";
+import {
+  useAppDispatch,
+  useAppSelector,
+  useAppStateRef,
+  usePaneInstanceId,
+  type PaneRuntimeState,
+} from "../state/app-context";
+import type { BrokerAdapter } from "../types/broker";
+import type { PluginCapability } from "../capabilities";
+import type { DataProvider } from "../types/data-provider";
+import type { AppNotificationRequest, BrokerInstanceUpdateOptions } from "../types/plugin";
 
 export interface PluginRuntimeAccess {
+  getMarketData(): DataProvider | null;
+  getCapability(capabilityId: string): PluginCapability | null;
+  getBrokerAdapter(brokerType: string): BrokerAdapter | null;
+  connectBrokerInstance(instanceId: string): Promise<void>;
+  updateBrokerInstance(instanceId: string, values: Record<string, unknown>, options?: BrokerInstanceUpdateOptions): Promise<void>;
+  syncBrokerInstance(instanceId: string): Promise<void>;
+  removeBrokerInstance(instanceId: string): Promise<void>;
   pinTicker(symbol: string, options?: { floating?: boolean; paneType?: string }): void;
   navigateTicker(symbol: string): void;
+  selectTicker(symbol: string, paneId?: string): void;
+  switchTab(tabId: string, paneId?: string): void;
+  switchPanel(panel: "left" | "right"): void;
+  openCommandBar(query?: string): void;
+  showWidget(widgetId: string): void;
+  hideWidget(widgetId: string): void;
+  openPluginCommandWorkflow(commandId: string): void;
+  notify(notification: AppNotificationRequest): void;
   subscribeResumeState(pluginId: string, key: string, listener: () => void): () => void;
   getResumeState<T = unknown>(pluginId: string, key: string, schemaVersion?: number): T | null;
   setResumeState(pluginId: string, key: string, value: unknown, schemaVersion?: number): void;
   deleteResumeState(pluginId: string, key: string): void;
   getConfigState<T = unknown>(pluginId: string, key: string): T | null;
   setConfigState(pluginId: string, key: string, value: unknown): Promise<void>;
+  setConfigStates(pluginId: string, values: Record<string, unknown>): Promise<void>;
   deleteConfigState(pluginId: string, key: string): Promise<void>;
   getConfigStateKeys(pluginId: string): string[];
 }
@@ -28,6 +56,7 @@ interface PluginRenderContextValue {
 }
 
 const PluginRenderContext = createContext<PluginRenderContextValue | null>(null);
+const DEFAULT_PLUGIN_PANE_STATE_COMMIT_DELAY_MS = 300;
 
 export function PluginRenderProvider({
   pluginId,
@@ -61,6 +90,81 @@ export function usePluginTickerActions() {
   };
 }
 
+export function usePluginPaneActions() {
+  const { runtime } = usePluginRenderContext();
+  const selectTicker = useCallback((symbol: string, paneId?: string) => {
+    runtime.selectTicker(symbol, paneId);
+  }, [runtime]);
+  const switchTab = useCallback((tabId: string, paneId?: string) => {
+    runtime.switchTab(tabId, paneId);
+  }, [runtime]);
+  const switchPanel = useCallback((panel: "left" | "right") => {
+    runtime.switchPanel(panel);
+  }, [runtime]);
+
+  return {
+    selectTicker,
+    switchTab,
+    switchPanel,
+  };
+}
+
+export function usePluginAppActions() {
+  const { runtime } = usePluginRenderContext();
+  const openCommandBar = useCallback((query?: string) => {
+    runtime.openCommandBar(query);
+  }, [runtime]);
+  const showWidget = useCallback((widgetId: string) => {
+    runtime.showWidget(widgetId);
+  }, [runtime]);
+  const hideWidget = useCallback((widgetId: string) => {
+    runtime.hideWidget(widgetId);
+  }, [runtime]);
+  const openPluginCommandWorkflow = useCallback((commandId: string) => {
+    runtime.openPluginCommandWorkflow(commandId);
+  }, [runtime]);
+  const notify = useCallback((notification: AppNotificationRequest) => {
+    runtime.notify(notification);
+  }, [runtime]);
+
+  return {
+    openCommandBar,
+    showWidget,
+    hideWidget,
+    openPluginCommandWorkflow,
+    notify,
+  };
+}
+
+export function useMarketData(): DataProvider | null {
+  const { runtime } = usePluginRenderContext();
+  return runtime.getMarketData();
+}
+
+export function useAssetData(): DataProvider | null {
+  return useMarketData();
+}
+
+export function useCapability(capabilityId: string): PluginCapability | null {
+  const { runtime } = usePluginRenderContext();
+  return runtime.getCapability(capabilityId);
+}
+
+export function useNewsData(): PluginCapability | null {
+  return useCapability("news.core");
+}
+
+export function usePluginBrokerActions() {
+  const { runtime } = usePluginRenderContext();
+  return {
+    getBrokerAdapter: runtime.getBrokerAdapter,
+    connectBrokerInstance: runtime.connectBrokerInstance,
+    updateBrokerInstance: runtime.updateBrokerInstance,
+    syncBrokerInstance: runtime.syncBrokerInstance,
+    removeBrokerInstance: runtime.removeBrokerInstance,
+  };
+}
+
 export function getPluginPaneStateValue<T>(
   paneState: PaneRuntimeState | undefined,
   pluginId: string,
@@ -111,13 +215,13 @@ export function deletePluginPaneStateValue(
 export function usePluginPaneState<T>(key: string, fallback: T, paneId?: string): [T, (value: SetStateAction<T>) => void] {
   const { pluginId } = usePluginRenderContext();
   const scopedPaneId = paneId ?? usePaneInstanceId();
-  const { state, dispatch } = useAppState();
-  const stateRef = useRef(state);
+  const dispatch = useAppDispatch();
+  const stateRef = useAppStateRef();
   const fallbackRef = useRef(fallback);
-  stateRef.current = state;
   fallbackRef.current = fallback;
-  const paneState = state.paneState[scopedPaneId];
-  const value = getPluginPaneStateValue(paneState, pluginId, key, fallback);
+  const value = useAppSelector((state) => (
+    getPluginPaneStateValue(state.paneState[scopedPaneId], pluginId, key, fallback)
+  ));
 
   const setValue = useCallback((nextValue: SetStateAction<T>) => {
     const currentPaneState = stateRef.current.paneState[scopedPaneId];
@@ -147,6 +251,109 @@ export function usePluginPaneState<T>(key: string, fallback: T, paneId?: string)
   return [value, setValue];
 }
 
+export function useDebouncedPluginPaneState<T>(
+  key: string,
+  fallback: T,
+  delayMs = DEFAULT_PLUGIN_PANE_STATE_COMMIT_DELAY_MS,
+  paneId?: string,
+): [
+  T,
+  (value: SetStateAction<T>, options?: { immediate?: boolean }) => void,
+  () => void,
+] {
+  const [committedValue, setCommittedValue] = usePluginPaneState<T>(key, fallback, paneId);
+  const [localValue, setLocalValueState] = useState(committedValue);
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const hasPendingCommitRef = useRef(false);
+  const pendingValueRef = useRef(committedValue);
+  const appliedValueRef = useRef(committedValue);
+  const localValueRef = useRef(committedValue);
+
+  const clearPendingCommit = useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    hasPendingCommitRef.current = false;
+  }, []);
+
+  const commitValue = useCallback((nextValue?: T) => {
+    const targetValue = nextValue ?? pendingValueRef.current;
+    clearPendingCommit();
+    pendingValueRef.current = targetValue;
+
+    if (Object.is(appliedValueRef.current, targetValue)) {
+      return;
+    }
+
+    appliedValueRef.current = targetValue;
+    setCommittedValue(targetValue);
+  }, [clearPendingCommit, setCommittedValue]);
+
+  const setLocalValue = useCallback((
+    nextValue: SetStateAction<T>,
+    options?: { immediate?: boolean },
+  ) => {
+    const currentValue = localValueRef.current;
+    const resolved = typeof nextValue === "function"
+      ? (nextValue as (previousValue: T) => T)(currentValue)
+      : nextValue;
+
+    if (Object.is(resolved, currentValue)) {
+      if (options?.immediate) {
+        commitValue(resolved);
+      }
+      return;
+    }
+
+    localValueRef.current = resolved;
+    pendingValueRef.current = resolved;
+    setLocalValueState((current) => (Object.is(current, resolved) ? current : resolved));
+
+    if (options?.immediate) {
+      commitValue(resolved);
+      return;
+    }
+
+    clearPendingCommit();
+    if (Object.is(appliedValueRef.current, resolved)) {
+      return;
+    }
+
+    hasPendingCommitRef.current = true;
+    timerRef.current = setTimeout(() => {
+      commitValue();
+    }, delayMs);
+  }, [clearPendingCommit, commitValue, delayMs]);
+
+  useEffect(() => {
+    if (hasPendingCommitRef.current && Object.is(committedValue, pendingValueRef.current)) {
+      clearPendingCommit();
+    }
+
+    if (!hasPendingCommitRef.current) {
+      appliedValueRef.current = committedValue;
+      pendingValueRef.current = committedValue;
+      localValueRef.current = committedValue;
+      setLocalValueState((current) => (Object.is(current, committedValue) ? current : committedValue));
+    }
+  }, [clearPendingCommit, committedValue]);
+
+  useEffect(() => () => {
+    const pending = hasPendingCommitRef.current;
+    const pendingValue = pendingValueRef.current;
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    if (pending && !Object.is(appliedValueRef.current, pendingValue)) {
+      setCommittedValue(pendingValue);
+    }
+  }, [setCommittedValue]);
+
+  return [localValue, setLocalValue, commitValue];
+}
+
 export function usePluginState<T>(key: string, fallback: T, options?: { schemaVersion?: number }): [T, (value: SetStateAction<T>) => void] {
   const { pluginId, runtime } = usePluginRenderContext();
   const schemaVersion = options?.schemaVersion;
@@ -181,12 +388,12 @@ export function usePluginState<T>(key: string, fallback: T, options?: { schemaVe
 
 export function usePluginConfigState<T>(key: string, fallback: T): [T, (value: SetStateAction<T>) => void] {
   const { pluginId, runtime } = usePluginRenderContext();
-  const { state } = useAppState();
-  const stateRef = useRef(state);
+  const stateRef = useAppStateRef();
   const fallbackRef = useRef(fallback);
-  stateRef.current = state;
   fallbackRef.current = fallback;
-  const value = (state.config.pluginConfig[pluginId]?.[key] as T | undefined) ?? fallback;
+  const value = useAppSelector((state) => (
+    (state.config.pluginConfig[pluginId]?.[key] as T | undefined) ?? fallback
+  ));
 
   const setValue = useCallback((nextValue: SetStateAction<T>) => {
     const currentValue =
@@ -203,3 +410,14 @@ export function usePluginConfigState<T>(key: string, fallback: T): [T, (value: S
 
   return [value, setValue];
 }
+
+export function useSetPluginConfigStates(): (values: Record<string, unknown>) => void {
+  const { pluginId, runtime } = usePluginRenderContext();
+
+  return useCallback((values: Record<string, unknown>) => {
+    if (Object.keys(values).length === 0) {
+      return;
+    }
+    void runtime.setConfigStates(pluginId, values);
+  }, [pluginId, runtime]);
+}

package/src/plugins/prediction-markets/cache.ts

@@ -112,3 +112,52 @@ export function updatePredictionErrorState(
     [key]: value,
   };
 }
+
+function sameNullableNumber(
+  left: number | null | undefined,
+  right: number | null | undefined,
+): boolean {
+  return (left ?? null) === (right ?? null);
+}
+
+function sameSummaryForCatalog(
+  left: PredictionMarketSummary,
+  right: PredictionMarketSummary,
+): boolean {
+  return (
+    left.key === right.key &&
+    left.title === right.title &&
+    left.marketLabel === right.marketLabel &&
+    left.eventLabel === right.eventLabel &&
+    left.category === right.category &&
+    left.status === right.status &&
+    left.endsAt === right.endsAt &&
+    left.updatedAt === right.updatedAt &&
+    sameNullableNumber(left.yesPrice, right.yesPrice) &&
+    sameNullableNumber(left.noPrice, right.noPrice) &&
+    sameNullableNumber(left.yesBid, right.yesBid) &&
+    sameNullableNumber(left.yesAsk, right.yesAsk) &&
+    sameNullableNumber(left.noBid, right.noBid) &&
+    sameNullableNumber(left.noAsk, right.noAsk) &&
+    sameNullableNumber(left.spread, right.spread) &&
+    sameNullableNumber(left.lastTradePrice, right.lastTradePrice) &&
+    sameNullableNumber(left.volume24h, right.volume24h) &&
+    sameNullableNumber(left.totalVolume, right.totalVolume) &&
+    sameNullableNumber(left.openInterest, right.openInterest) &&
+    sameNullableNumber(left.liquidity, right.liquidity)
+  );
+}
+
+export function samePredictionCatalogSummaries(
+  left: readonly PredictionMarketSummary[] | undefined,
+  right: readonly PredictionMarketSummary[],
+): boolean {
+  if (!left || left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    const leftSummary = left[index];
+    const rightSummary = right[index];
+    if (!leftSummary || !rightSummary) return false;
+    if (!sameSummaryForCatalog(leftSummary, rightSummary)) return false;
+  }
+  return true;
+}

package/src/plugins/prediction-markets/categories.ts

@@ -183,16 +183,6 @@ export function matchesPredictionCategory(
   return keywords.some((keyword) => haystack.includes(keyword));
 }
 
-export function getAvailablePredictionCategories(
-  markets: PredictionMarketSummary[],
-): PredictionCategoryOption[] {
-  return PREDICTION_CATEGORY_OPTIONS.filter(
-    (category) =>
-      category.id === "all" ||
-      markets.some((market) => matchesPredictionCategory(market, category.id)),
-  );
-}
-
 export function getPolymarketCategoryTagSlugs(
   categoryId: PredictionCategoryId,
 ): string[] {

package/src/plugins/prediction-markets/chart.test.tsx

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import type { ScrollBoxRenderable } from "@opentui/core";
 import { createTestRenderer } from "@opentui/core/testing";
-import { createRoot } from "@opentui/react";
+import { createOpenTuiTestRoot as createRoot } from "../../renderers/opentui/test-utils";
 import { act, useEffect, useReducer, useRef } from "react";
 import {
   AppContext,