gloomberb 0.11.3 → 0.13.1

package/src/sources/provider-router/search.ts

@@ -7,6 +7,12 @@ const SEARCH_CACHE_TTL_MS = 30_000;
 const SEARCH_CACHE_MAX_ENTRIES = 100;
 
 const SEARCH_PROVIDER_TIMEOUT_MS = 5_000;
+/**
+ * A keystroke path cannot wait the batch budget on a source that is failing
+ * slowly. A broker whose gateway is down is the common case, and five seconds
+ * of it is indistinguishable from the feature being broken.
+ */
+const INTERACTIVE_SEARCH_TIMEOUT_MS = 800;
 
 interface BrokerSearchCandidate {
   brokerId: string;
@@ -14,9 +20,9 @@ interface BrokerSearchCandidate {
   brokerLabel: string;
 }
 
-function withSearchTimeout<T>(promise: Promise<T>): Promise<T | null> {
+function withSearchTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null> {
   return new Promise<T | null>((resolve) => {
-    const timer = setTimeout(() => resolve(null), SEARCH_PROVIDER_TIMEOUT_MS);
+    const timer = setTimeout(() => resolve(null), timeoutMs);
     promise.then(
       (value) => { clearTimeout(timer); resolve(value); },
       () => { clearTimeout(timer); resolve(null); },
@@ -93,72 +99,119 @@ export class ProviderRouterSearchRoutes {
     const inFlight = this.searchInFlight.get(cacheKey);
     if (inFlight) return inFlight;
 
-    const task = this.fetchSearchResults(query, context, cacheKey).finally(() => {
+    const { first, settled } = this.fetchSearchResults(query, context, cacheKey);
+    // Held until every source settles, not until the first answer, so a repeat
+    // of the same query joins this run instead of starting a second one.
+    this.searchInFlight.set(cacheKey, first);
+    void settled.finally(() => {
       this.searchInFlight.delete(cacheKey);
     });
-
-    this.searchInFlight.set(cacheKey, task);
-    return task;
+    return first;
   }
 
-  private async fetchSearchResults(
+  /**
+   * Brokers and the preferred provider run at once, rather than each being
+   * awaited in turn. The old order tried brokers one at a time before the
+   * preferred provider was asked at all, so one unreachable broker delayed
+   * every lookup by its full timeout.
+   *
+   * Fallback providers stay a fallback: they are only asked when that first
+   * round found nothing, because they are metered upstreams and racing them on
+   * every keystroke would bill for answers already in hand.
+   *
+   * Ordering still matters, it just no longer costs latency: `mergeSearchResults`
+   * keeps the richest entry per symbol, so a broker arriving after the cloud
+   * still upgrades the row, and `onPartial` hands that upgrade to the caller.
+   */
+  private fetchSearchResults(
     query: string,
     context: SearchRequestContext | undefined,
     cacheKey: string,
-  ): Promise<InstrumentSearchResult[]> {
+  ): { first: Promise<InstrumentSearchResult[]>; settled: Promise<void> } {
     const results: InstrumentSearchResult[] = [];
     const resultIndexByKey = new Map<string, number>();
+    const timeoutMs = context?.interactive
+      ? INTERACTIVE_SEARCH_TIMEOUT_MS
+      : SEARCH_PROVIDER_TIMEOUT_MS;
+
     const cacheResults = (ttl = SEARCH_CACHE_TTL_MS) => {
       this.searchCache.set(cacheKey, {
         expiresAt: Date.now() + ttl,
-        results,
+        results: [...results],
       });
       if (this.searchCache.size > SEARCH_CACHE_MAX_ENTRIES) {
         this.searchCache.delete(this.searchCache.keys().next().value!);
       }
     };
-    const push = (items: InstrumentSearchResult[]) => {
+
+    let resolveFirst!: (value: InstrumentSearchResult[]) => void;
+    const first = new Promise<InstrumentSearchResult[]>((resolve) => {
+      resolveFirst = resolve;
+    });
+    let answered = false;
+
+    const record = (items: InstrumentSearchResult[] | null) => {
+      if (!items?.length) return;
       mergeSearchResults(results, resultIndexByKey, items, context);
+      cacheResults();
+      if (!answered) {
+        answered = true;
+        resolveFirst([...results]);
+        return;
+      }
+      // The caller already has an answer, so a later, richer source is handed
+      // over rather than silently dropped into the cache.
+      context?.onPartial?.([...results]);
     };
 
-    if (context?.preferBroker !== false) {
-      for (const candidate of this.deps.getBrokerCandidates(
-        context?.brokerInstanceId,
-        context?.brokerId,
-      )) {
-        if (!candidate.broker.searchInstruments) continue;
-        try {
-          const items = await withSearchTimeout(candidate.broker.searchInstruments(query, candidate.instance));
-          if (!items) continue;
-          push(annotateBrokerSearchResults(items, candidate));
-          if (results.length > 0) {
-            cacheResults();
-            return results;
-          }
-        } catch {
-          // continue through broker candidates
-        }
+    const searchBroker = (candidate: BrokerCandidate) => (async () => {
+      try {
+        const items = await withSearchTimeout(
+          candidate.broker.searchInstruments!(query, candidate.instance),
+          timeoutMs,
+        );
+        record(items && annotateBrokerSearchResults(items, candidate));
+      } catch {
+        // A broker that cannot answer must not hold up the ones that can.
       }
-    }
+    })();
 
-    for (const provider of this.deps.providersInPriorityOrder()) {
+    const searchProvider = (provider: DataProvider) => (async () => {
       try {
-        const items = await withSearchTimeout(provider.search(query, context));
-        if (!items) continue;
-        push(items);
-        if (results.length > 0) {
-          cacheResults();
-          return results;
-        }
+        record(await withSearchTimeout(provider.search(query, context), timeoutMs));
       } catch (error) {
         if (shouldLogProviderError(error)) {
           this.deps.logProviderError(`${provider.id} failed: ${error}`);
         }
       }
-    }
+    })();
+
+    const brokers = context?.preferBroker === false
+      ? []
+      : this.deps
+        .getBrokerCandidates(context?.brokerInstanceId, context?.brokerId)
+        .filter((candidate) => candidate.broker.searchInstruments);
+    const [preferred, ...fallbacks] = this.deps.providersInPriorityOrder();
+
+    const settled = (async () => {
+      await Promise.allSettled([
+        ...brokers.map(searchBroker),
+        ...(preferred ? [searchProvider(preferred)] : []),
+      ]);
+      if (results.length === 0) {
+        await Promise.allSettled(fallbacks.map(searchProvider));
+      }
+    })().then(() => {
+      if (!answered) {
+        answered = true;
+        // Nothing matched anywhere, so hold the empty answer briefly rather
+        // than asking every source again on the next keystroke.
+        cacheResults(Math.min(SEARCH_CACHE_TTL_MS, 5_000));
+        resolveFirst([]);
+      }
+    });
 
-    cacheResults(Math.min(SEARCH_CACHE_TTL_MS, 5_000));
-    return results;
+    return { first, settled };
   }
 }
 

package/src/state/app/context/index.tsx

@@ -287,6 +287,7 @@ export function usePaneStateValue<T>(key: string, fallback: T, paneId?: string):
     const resolved = typeof nextValue === "function"
       ? (nextValue as (previousValue: T) => T)(currentValue)
       : nextValue;
+    if (Object.is(currentValue, resolved)) return;
     dispatch({ type: "UPDATE_PANE_STATE", paneId: scopedPaneId, patch: { [key]: resolved } });
   }, [dispatch, key, scopedPaneId, stateRef]);
   return [value, setValue];
@@ -309,6 +310,7 @@ export function usePaneSettingValue<T>(
     const resolved = typeof nextValue === "function"
       ? (nextValue as (previousValue: T) => T)(currentValue)
       : nextValue;
+    if (Object.is(currentValue, resolved)) return;
     const layout = setPaneSetting(currentState.config.layout, scopedPaneId, key, resolved);
     const nextConfig = syncConfigActiveLayoutState(
       { ...currentState.config, layout },

package/src/state/app/context/selector.test.tsx

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useRef, type Dispatch } from "react";
 import { testRender } from "../../../renderers/opentui/test-utils";
-import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneTicker, type AppAction } from "./index";
+import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneSettingValue, usePaneTicker, type AppAction } from "./index";
 import { cloneLayout, createDefaultConfig, type AppConfig } from "../../../types/config";
 import { applyTheme } from "../../../theme/colors";
 import { useThemeId } from "../../../theme/theme-context";
@@ -11,6 +11,7 @@ const TEST_PANE_ID = "ticker-detail:test";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let capturedDispatch: Dispatch<AppAction> | null = null;
+let capturedPaneSetting: ((value: string) => void) | null = null;
 
 function createTickerDetailConfig(symbol: string): AppConfig {
   const config = createDefaultConfig("/tmp/gloomberb-test");
@@ -44,6 +45,14 @@ function PaneTickerHarness() {
   return <text>{`${symbol ?? "none"}:${renderCountRef.current}`}</text>;
 }
 
+function PaneSettingHarness() {
+  const renderCountRef = useRef(0);
+  renderCountRef.current += 1;
+  const [value, setValue] = usePaneSettingValue("mode", "table");
+  capturedPaneSetting = setValue;
+  return <text>{`${value}:${renderCountRef.current}`}</text>;
+}
+
 function ThemeSelectorHarness() {
   const focusedPaneId = useAppSelector((state) => state.focusedPaneId);
   const themeId = useThemeId();
@@ -99,6 +108,7 @@ describe("pane selectors", () => {
     }
     testSetup = undefined;
     capturedDispatch = null;
+    capturedPaneSetting = null;
     applyTheme("amber");
   });
 
@@ -125,6 +135,28 @@ describe("pane selectors", () => {
     expect(testSetup.captureCharFrame()).toContain("AAPL:1");
   });
 
+  test("does not dispatch or rerender when a pane setting keeps its effective value", async () => {
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")}>
+        <PaneInstanceProvider paneId={TEST_PANE_ID}>
+          <PaneSettingHarness />
+        </PaneInstanceProvider>
+      </AppProvider>,
+      { width: 24, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("table:1");
+
+    await act(() => {
+      capturedPaneSetting?.("table");
+    });
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+
+    expect(testSetup.captureCharFrame()).toContain("table:1");
+  });
+
   test("rerenders theme hook consumers when the theme changes", async () => {
     testSetup = await testRender(
       <AppProvider config={createTickerDetailConfig("AAPL")}>

package/src/state/hooks/quote-streaming.test.tsx

@@ -10,6 +10,7 @@ import { useLiveQuoteEntries, useQuoteStreaming, useQuoteUpdates } from "./quote
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let bumpHarness: (() => void) | null = null;
+let toggleStreamingPriority: (() => void) | null = null;
 let togglePollingPriority: (() => void) | null = null;
 let updateLiveTargets: ((symbol: string) => void) | null = null;
 let updateFreshnessScope: ((scope: string) => void) | null = null;
@@ -27,6 +28,31 @@ function QuoteStreamingHarness() {
   return <text>{String(tick)}</text>;
 }
 
+function QuoteStreamingPriorityHarness() {
+  const [selected, setSelected] = useState(false);
+  toggleStreamingPriority = () => setSelected((current) => !current);
+  useQuoteStreaming([{
+    symbol: "AAPL",
+    exchange: "NASDAQ",
+    context: {
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-work",
+      instrument: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        conId: 1001,
+        symbol: "AAPL",
+      },
+    },
+    route: "provider",
+    surface: selected ? "detail" : "portfolio",
+    visible: true,
+    selected,
+    weight: selected ? 100 : 10,
+  }]);
+  return <text>{selected ? "selected" : "idle"}</text>;
+}
+
 function QuotePollingHarness() {
   useQuoteUpdates([{
     symbol: "AAPL",
@@ -82,6 +108,7 @@ afterEach(async () => {
     testSetup = undefined;
   }
   bumpHarness = null;
+  toggleStreamingPriority = null;
   togglePollingPriority = null;
   updateLiveTargets = null;
   updateFreshnessScope = null;
@@ -127,6 +154,72 @@ describe("useQuoteStreaming", () => {
     expect(unsubscribeCalls).toBe(0);
   });
 
+  test("updates priorities without replacing the hook subscription", async () => {
+    type CoordinatorTargets = Parameters<MarketDataCoordinator["subscribeQuotes"]>[0];
+    const initialTargets: CoordinatorTargets[] = [];
+    const updates: CoordinatorTargets[] = [];
+    let unsubscribeCalls = 0;
+    const coordinator = {
+      subscribeQuotes: (targets: CoordinatorTargets) => {
+        initialTargets.push(targets);
+        return Object.assign(
+          () => { unsubscribeCalls += 1; },
+          { update: (nextTargets: CoordinatorTargets) => updates.push(nextTargets) },
+        );
+      },
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(<QuoteStreamingPriorityHarness />, {
+      width: 20,
+      height: 1,
+    });
+    await act(async () => testSetup!.renderOnce());
+
+    expect(initialTargets).toHaveLength(1);
+    expect(initialTargets[0]?.[0]).toMatchObject({
+      instrument: {
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: { conId: 1001, symbol: "AAPL" },
+      },
+      priority: {
+        route: "provider",
+        surface: "portfolio",
+        visible: true,
+        selected: false,
+        weight: 10,
+      },
+    });
+
+    await act(async () => {
+      toggleStreamingPriority?.();
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+
+    expect(initialTargets).toHaveLength(1);
+    expect(unsubscribeCalls).toBe(0);
+    expect(updates).toHaveLength(1);
+    expect(updates[0]?.[0]).toMatchObject({
+      instrument: {
+        symbol: "AAPL",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: { conId: 1001 },
+      },
+      priority: {
+        route: "provider",
+        surface: "detail",
+        visible: true,
+        selected: true,
+        weight: 100,
+      },
+    });
+  });
+
   test("uses forced polling instead of a subscription when live streaming is disabled", async () => {
     let subscribeCalls = 0;
     let loadCalls = 0;

package/src/state/hooks/quote-streaming.ts

@@ -4,7 +4,7 @@ import type { QuoteSubscriptionTarget } from "../../types/data-provider";
 import type { Quote } from "../../types/financials";
 import { debugLog } from "../../utils/debug-log";
 import { normalizeSymbol } from "../../utils/exchanges";
-import { getSharedMarketDataCoordinator } from "../../market-data/coordinator";
+import { getSharedMarketDataCoordinator, type MarketDataCoordinator } from "../../market-data/coordinator";
 import { useQuoteEntries } from "../../market-data/hooks";
 import type { InstrumentRef } from "../../market-data/request-types";
 import type { QueryEntry } from "../../market-data/result-types";
@@ -33,12 +33,11 @@ export function normalizeQuoteStreamSubscriptionTarget(target: QuoteSubscription
   };
 }
 
-export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget): string {
+export function buildQuoteStreamSubscriptionIdentityKey(target: QuoteSubscriptionTarget): string {
   const contractKey = target.context?.instrument?.conId
     ?? target.context?.instrument?.localSymbol
     ?? target.context?.instrument?.symbol
     ?? "";
-  const weight = Number.isFinite(target.weight) ? String(target.weight) : "";
   return [
     target.symbol,
     target.exchange ?? "",
@@ -46,6 +45,13 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
     target.context?.brokerInstanceId ?? "",
     contractKey,
     target.route ?? "auto",
+  ].join("|");
+}
+
+export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget): string {
+  const weight = Number.isFinite(target.weight) ? String(target.weight) : "";
+  return [
+    buildQuoteStreamSubscriptionIdentityKey(target),
     target.surface ?? "",
     target.visible ? "visible" : "",
     target.selected ? "selected" : "",
@@ -53,6 +59,37 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
   ].join("|");
 }
 
+type CoordinatorQuoteTargets = Parameters<MarketDataCoordinator["subscribeQuotes"]>[0];
+type UpdateableQuoteSubscription = (() => void) & {
+  update?: (targets: CoordinatorQuoteTargets) => void;
+};
+
+interface ActiveQuoteSubscription {
+  identityKey: string;
+  subscriptionKey: string;
+  count: number;
+  dispose: UpdateableQuoteSubscription;
+}
+
+function toCoordinatorQuoteTargets(targets: QuoteSubscriptionTarget[]): CoordinatorQuoteTargets {
+  return targets.map((target) => ({
+    instrument: {
+      symbol: target.symbol,
+      exchange: target.exchange,
+      brokerId: target.context?.brokerId,
+      brokerInstanceId: target.context?.brokerInstanceId,
+      instrument: target.context?.instrument ?? null,
+    },
+    priority: {
+      route: target.route,
+      surface: target.surface,
+      visible: target.visible,
+      selected: target.selected,
+      weight: target.weight,
+    },
+  }));
+}
+
 export function useQuoteStreaming(
   targets: QuoteSubscriptionTarget[],
   { enabled = true }: QuoteStreamingOptions = {},
@@ -70,48 +107,86 @@ export function useQuoteStreaming(
   const sortedEntries = [...normalizedEntries.entries()].sort(([left], [right]) => left.localeCompare(right));
   const normalizedTargets = sortedEntries.map(([, target]) => target);
   const subscriptionKey = sortedEntries.map(([key]) => key).join("|");
+  const identityKey = [...new Set(normalizedTargets.map(buildQuoteStreamSubscriptionIdentityKey))]
+    .sort()
+    .join("\u001f");
+  const coordinatorTargets = toCoordinatorQuoteTargets(normalizedTargets);
+  const latestSubscriptionRef = useRef({
+    identityKey,
+    subscriptionKey,
+    targets: coordinatorTargets,
+  });
+  latestSubscriptionRef.current = {
+    identityKey,
+    subscriptionKey,
+    targets: coordinatorTargets,
+  };
+  const activeSubscriptionRef = useRef<ActiveQuoteSubscription | null>(null);
 
   useEffect(() => {
+    const latest = latestSubscriptionRef.current;
     if (!enabled || !appActive) {
-      if (normalizedTargets.length > 0) {
+      if (latest.targets.length > 0) {
         quoteStreamLog.info("skipping subscription", {
           reason: enabled ? "inactive" : "disabled",
-          targets: subscriptionKey,
+          targets: latest.subscriptionKey,
         });
       }
       return;
     }
-    if (!coordinator || normalizedTargets.length === 0) return;
+    if (!coordinator || latest.targets.length === 0) return;
     quoteStreamLog.info("subscribe", {
       providerId: "market-data",
-      count: normalizedTargets.length,
-      targets: subscriptionKey,
+      count: latest.targets.length,
+      targets: latest.subscriptionKey,
     });
-    const unsubscribe = coordinator.subscribeQuotes(normalizedTargets.map((target) => ({
-      instrument: {
-        symbol: target.symbol,
-        exchange: target.exchange,
-        brokerId: target.context?.brokerId,
-        brokerInstanceId: target.context?.brokerInstanceId,
-        instrument: target.context?.instrument ?? null,
-      },
-      priority: {
-        route: target.route,
-        surface: target.surface,
-        visible: target.visible,
-        selected: target.selected,
-        weight: target.weight,
-      },
-    })));
+    const active: ActiveQuoteSubscription = {
+      identityKey: latest.identityKey,
+      subscriptionKey: latest.subscriptionKey,
+      count: latest.targets.length,
+      dispose: coordinator.subscribeQuotes(latest.targets) as UpdateableQuoteSubscription,
+    };
+    activeSubscriptionRef.current = active;
     return () => {
+      if (activeSubscriptionRef.current === active) {
+        activeSubscriptionRef.current = null;
+      }
       quoteStreamLog.info("unsubscribe", {
         providerId: "market-data",
-        count: normalizedTargets.length,
-        targets: subscriptionKey,
+        count: active.count,
+        targets: active.subscriptionKey,
       });
-      unsubscribe?.();
+      active.dispose();
     };
-  }, [appActive, coordinator, enabled, subscriptionKey]);
+  }, [appActive, coordinator, enabled, identityKey]);
+
+  useEffect(() => {
+    if (!enabled || !appActive || !coordinator) return;
+    const active = activeSubscriptionRef.current;
+    const latest = latestSubscriptionRef.current;
+    if (
+      !active
+      || active.identityKey !== latest.identityKey
+      || active.subscriptionKey === latest.subscriptionKey
+    ) {
+      return;
+    }
+
+    quoteStreamLog.info("update subscription", {
+      providerId: "market-data",
+      count: latest.targets.length,
+      targets: latest.subscriptionKey,
+    });
+    if (typeof active.dispose.update === "function") {
+      active.dispose.update(latest.targets);
+    } else {
+      const previousDispose = active.dispose;
+      active.dispose = coordinator.subscribeQuotes(latest.targets) as UpdateableQuoteSubscription;
+      previousDispose();
+    }
+    active.subscriptionKey = latest.subscriptionKey;
+    active.count = latest.targets.length;
+  }, [appActive, coordinator, enabled, identityKey, subscriptionKey]);
 }
 
 export function useQuoteUpdates(
@@ -195,8 +270,9 @@ export function useLiveQuoteEntries(
     const normalized = normalizeQuoteStreamSubscriptionTarget(target);
     return normalized ? [normalized] : [];
   });
-  const targetKey = normalizedTargets
-    .map((target) => buildQuoteStreamSubscriptionKey(target))
+  const targetKey = [...new Set(
+    normalizedTargets.map((target) => buildQuoteStreamSubscriptionIdentityKey(target)),
+  )]
     .sort()
     .join("\u001f");
   const liveStreaming = options.liveStreaming !== false;

package/src/state/pane-table-export-registry.ts

@@ -1,3 +1,5 @@
+import { createCsvExportFilename } from "../utils/csv";
+
 export type PaneTableExporter = (filename: string) => Promise<string>;
 
 const exporters = new Map<string, Map<symbol, PaneTableExporter>>();
@@ -29,3 +31,20 @@ export async function exportPaneTable(paneId: string, filename: string): Promise
   }
   return [...paneExporters.values()][0]!(filename);
 }
+
+/**
+ * Shared entry point for the pane menu, the keyboard shortcut, and pane settings so
+ * every surface produces the same filename and the same success/failure notification.
+ */
+export async function exportPaneTableCsv(
+  paneId: string,
+  title: string,
+  notify: (notification: { body: string; type: "success" | "error" }) => void,
+): Promise<void> {
+  try {
+    const location = await exportPaneTable(paneId, createCsvExportFilename(title));
+    notify({ body: `Exported to ${location}`, type: "success" });
+  } catch {
+    notify({ body: "Failed to export CSV", type: "error" });
+  }
+}