gloomberb 0.13.2 → 0.14.0

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

@@ -22,8 +22,9 @@ import {
   type PaneInstanceConfig,
 } from "../../../types/config";
 import type { DesktopSharedStateSnapshot, DesktopThemePreviewState, DesktopWindowBridge } from "../../../types/desktop-window";
-import { setPaneSetting } from "../../../pane-settings";
+import { setPaneSetting, updatePaneInstance } from "../../../pane-settings";
 import { useTickerFinancials } from "../../../market-data/hooks";
+import { hasAmbiguousTickerContracts, resolveInstrumentForPane, resolveListingForPane, tickerForInstrument } from "../../../core/state/app/instrument";
 import {
   APP_SESSION_ID,
   APP_SESSION_SCHEMA_VERSION,
@@ -42,6 +43,7 @@ import {
 } from "../../../core/state/app/state";
 import type { AppAction, AppState } from "../../../core/state/app/state";
 import { scheduleConfigSave } from "../../config-save-scheduler";
+import { LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS } from "../../persist-scheduler";
 
 export {
   appReducer,
@@ -210,44 +212,77 @@ export function usePaneInstance(): PaneInstanceConfig | null {
   return useAppSelector((state) => (paneId ? findPaneInstance(state.config.layout, paneId) ?? null : null));
 }
 
+function sameConfigOutsideLayoutMirror(previous: AppConfig, next: AppConfig): boolean {
+  const previousKeys = Object.keys(previous) as Array<keyof AppConfig>;
+  if (previousKeys.length !== Object.keys(next).length) return false;
+  for (const key of previousKeys) {
+    if (key === "layouts" || key === "activeLayoutIndex") continue;
+    if (!Object.is(previous[key], next[key])) return false;
+  }
+  return true;
+}
+
+/**
+ * The config for panes that read settings and collections but never the saved
+ * layouts. Every pane-state update mirrors the live pane state into
+ * `config.layouts`, which replaces the config object; a pane subscribed to the
+ * whole config re-renders on every cursor move in every other pane. This
+ * keeps the previous reference while nothing outside that mirror changed.
+ * Anything that writes config back must read the live `state.config` instead,
+ * because `SET_CONFIG` reapplies the saved pane state it carries.
+ */
+export function usePaneAppConfig(): AppConfig {
+  const lastRef = useRef<AppConfig | null>(null);
+  return useAppSelector((state) => {
+    const next = state.config;
+    const previous = lastRef.current;
+    if (previous && (previous === next || sameConfigOutsideLayoutMirror(previous, next))) return previous;
+    lastRef.current = next;
+    return next;
+  });
+}
+
 export function usePaneTicker(paneId?: string) {
   const paneContextId = useContext(PaneContext);
   const needsFocusedPane = paneId == null && paneContextId == null;
   const focusedPaneId = useAppSelector((state) => (needsFocusedPane ? state.focusedPaneId : null));
   const scopedPaneId = paneId ?? paneContextId ?? focusedPaneId;
+  return useScopedTicker(scopedPaneId);
+}
+
+function useScopedTicker(scopedPaneId: string | null) {
   const symbol = useAppSelector((state) => (
     scopedPaneId ? resolveTickerForPane(state, scopedPaneId) : null
   ));
-  const ticker = useAppSelector((state) => (
+  const savedTicker = useAppSelector((state) => (
     symbol ? state.tickers.get(symbol) ?? null : null
   ));
+  const contract = useAppSelector((state) => (
+    scopedPaneId ? resolveInstrumentForPane(state, scopedPaneId)?.instrument : undefined
+  ));
+  const listing = useAppSelector((state) => scopedPaneId ? resolveListingForPane(state, scopedPaneId) : undefined);
+  const ticker = useMemo(() => tickerForInstrument(savedTicker, contract, listing), [savedTicker, contract, listing]);
   const cachedFinancials = useAppSelector((state) => (
     symbol ? state.financials.get(symbol) ?? null : null
   ));
-  const marketFinancials = useTickerFinancials(symbol, ticker);
+  const marketFinancials = useTickerFinancials(contract === undefined ? null : symbol, contract === undefined ? null : ticker);
 
   return useMemo(() => {
-    if (!scopedPaneId) return { symbol: null, ticker: null, financials: null };
+    if (!scopedPaneId) return { symbol: null, ticker: null, financials: null, error: undefined };
     return {
       symbol,
       ticker,
-      financials: marketFinancials ?? cachedFinancials,
+      error: contract === undefined && hasAmbiguousTickerContracts(savedTicker) ? "Choose a contract in search." : undefined,
+      financials: marketFinancials ?? (cachedFinancials && (contract || contract === undefined || savedTicker?.metadata.broker_contracts?.length)
+        ? { ...cachedFinancials, quote: undefined, quoteContributions: undefined, quoteMetadata: undefined, priceHistory: [] }
+        : cachedFinancials),
     };
-  }, [cachedFinancials, marketFinancials, scopedPaneId, symbol, ticker]);
+  }, [cachedFinancials, contract, marketFinancials, savedTicker, scopedPaneId, symbol, ticker]);
 }
 
 export function useFocusedTicker() {
-  const symbol = useAppSelector((state) => getFocusedTickerSymbol(state));
-  const ticker = useAppSelector((state) => (symbol ? state.tickers.get(symbol) ?? null : null));
-  const cachedFinancials = useAppSelector((state) => (symbol ? state.financials.get(symbol) ?? null : null));
-  const marketFinancials = useTickerFinancials(symbol, ticker);
-  return useMemo(() => {
-    return {
-      symbol,
-      ticker,
-      financials: marketFinancials ?? cachedFinancials,
-    };
-  }, [cachedFinancials, marketFinancials, symbol, ticker]);
+  const paneId = useAppSelector((state) => state.focusedPaneId);
+  return useScopedTicker(paneId);
 }
 
 export function usePaneCollection(paneId?: string) {
@@ -273,7 +308,7 @@ export function usePaneStateValue<T>(key: string, fallback: T, paneId?: string):
   const dispatch = useAppDispatch();
   const stateRef = useAppStateRef();
   const fallbackRef = useRef(fallback);
-  const scopedPaneId = paneId ?? usePaneInstanceId();
+  const scopedPaneId = useScopedPaneId(paneId);
   const value = useAppSelector((state) => (
     (state.paneState[scopedPaneId]?.[key] as T | undefined) ?? fallback
   ));
@@ -298,9 +333,9 @@ export function usePaneSettingValue<T>(
   fallback: T,
   paneId?: string,
 ): [T, (value: SetStateAction<T>) => void] {
-  const dispatch = useAppDispatch();
   const stateRef = useAppStateRef();
-  const scopedPaneId = paneId ?? usePaneInstanceId();
+  const scopedPaneId = useScopedPaneId(paneId);
+  const updateLayout = useUpdatePaneLayout();
   const instance = useAppSelector((state) => findPaneInstance(state.config.layout, scopedPaneId) ?? null);
   const value = (instance?.settings?.[key] as T | undefined) ?? fallback;
 
@@ -311,20 +346,50 @@ export function usePaneSettingValue<T>(
       ? (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 },
-      currentState.paneState,
-      currentState.focusedPaneId,
-      currentState.activePanel,
-    );
-    dispatch({ type: "SET_CONFIG", config: nextConfig });
-    scheduleConfigSave(nextConfig);
-  }, [dispatch, fallback, key, scopedPaneId, stateRef]);
+    updateLayout((layout) => setPaneSetting(layout, scopedPaneId, key, resolved));
+  }, [fallback, key, scopedPaneId, stateRef, updateLayout]);
 
   return [value, setValue];
 }
 
+function useScopedPaneId(paneId?: string): string {
+  const contextId = useOptionalPaneInstanceId();
+  const id = paneId ?? contextId;
+  if (!id) throw new Error("A pane ID or PaneInstanceProvider is required.");
+  return id;
+}
+
+function useUpdatePaneLayout(options: { saveDelayMs?: number } = {}) {
+  const dispatch = useAppDispatch();
+  const stateRef = useAppStateRef();
+  const { saveDelayMs } = options;
+  return useCallback((update: (layout: AppConfig["layout"]) => AppConfig["layout"]) => {
+    const state = stateRef.current;
+    const layout = update(state.config.layout);
+    if (layout === state.config.layout) return;
+    const config = syncConfigActiveLayoutState(
+      { ...state.config, layout }, state.paneState, state.focusedPaneId, state.activePanel,
+    );
+    dispatch({ type: "SET_CONFIG", config });
+    scheduleConfigSave(config, { delayMs: saveDelayMs });
+  }, [dispatch, saveDelayMs, stateRef]);
+}
+
+/** Keep a content-derived pane title in its saved layout, without exposing config writes. */
+export function usePaneTitle(title: string, paneId?: string): void {
+  const id = useScopedPaneId(paneId);
+  // A follower's title changes with every cursor move in its source; that is
+  // not worth a config write per step.
+  const updateLayout = useUpdatePaneLayout({ saveDelayMs: LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS });
+  useEffect(() => {
+    updateLayout((layout) => {
+      const pane = findPaneInstance(layout, id);
+      return !pane || pane.title === title ? layout
+        : updatePaneInstance(layout, id, (instance) => ({ ...instance, title }));
+    });
+  }, [id, title, updateLayout]);
+}
+
 export function AppProvider({
   config,
   children,
@@ -435,7 +500,12 @@ export function AppProvider({
   useEffect(() => {
     if (sameStringList(previousRecentTickers.current, state.recentTickers)) return;
     previousRecentTickers.current = state.recentTickers;
-    scheduleConfigSave({ ...state.config, recentTickers: state.recentTickers });
+    // Assembled when the write fires so it carries whatever config and recent
+    // tickers are current by then, not the ones from this cursor move.
+    scheduleConfigSave(
+      () => ({ ...stateRef.current.config, recentTickers: stateRef.current.recentTickers }),
+      { delayMs: LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS },
+    );
   }, [state.config, state.recentTickers]);
 
   useEffect(() => {

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 { act, useRef, useState, type Dispatch } from "react";
 import { testRender } from "../../../renderers/opentui/test-utils";
-import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneSettingValue, usePaneTicker, type AppAction } from "./index";
+import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneSettingValue, usePaneStateValue, usePaneTicker, usePaneTitle, type AppAction } from "./index";
 import { cloneLayout, createDefaultConfig, type AppConfig } from "../../../types/config";
 import { applyTheme } from "../../../theme/colors";
 import { useThemeId } from "../../../theme/theme-context";
@@ -112,6 +112,42 @@ describe("pane selectors", () => {
     applyTheme("amber");
   });
 
+  test("pane settings and derived titles preserve the saved layout when pane scoping changes", async () => {
+    let useContextId: () => void = () => {};
+    let changeChannel: (value: string) => void = () => {};
+    let currentConfig = createTickerDetailConfig("AAPL");
+    function PaneModel() {
+      const [explicit, setExplicit] = useState(true);
+      useContextId = () => setExplicit(false);
+      const id = explicit ? TEST_PANE_ID : undefined;
+      const [channel, setChannel] = usePaneSettingValue("channel", "one", id);
+      const [position] = usePaneStateValue("position", 0, id);
+      changeChannel = setChannel;
+      usePaneTitle(`Feed: ${channel}`, id);
+      currentConfig = useAppSelector((state) => state.config);
+      return <text>{`${channel}:${position}`}</text>;
+    }
+    testSetup = await testRender(
+      <AppProvider config={currentConfig}>
+        <PaneInstanceProvider paneId={TEST_PANE_ID}><PaneModel /></PaneInstanceProvider>
+      </AppProvider>,
+      { width: 24, height: 4 },
+    );
+    await testSetup.renderOnce();
+    await act(useContextId);
+    await testSetup.renderOnce();
+    await act(() => changeChannel("two"));
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    const pane = currentConfig.layout.instances[0]!;
+    expect(pane).toMatchObject({
+      instanceId: TEST_PANE_ID, title: "Feed: two", settings: { channel: "two" },
+      binding: { kind: "fixed", symbol: "AAPL" },
+    });
+    expect(currentConfig.layouts[0]!.layout.instances[0]).toEqual(pane);
+    expect(testSetup.captureCharFrame()).toContain("two:0");
+  });
+
   test("does not rerender usePaneTicker consumers for unrelated app state updates", async () => {
     testSetup = await testRender(
       <AppProvider config={createTickerDetailConfig("AAPL")}>

package/src/state/config-save-scheduler.ts

@@ -9,16 +9,28 @@ import {
 
 const log = debugLog.createLogger("persist");
 
-const configSaveScheduler = createPersistScheduler<AppConfig>({
+type ConfigSource = AppConfig | (() => AppConfig);
+
+function resolveConfig(source: ConfigSource): AppConfig {
+  return typeof source === "function" ? source() : source;
+}
+
+const configSaveScheduler = createPersistScheduler<ConfigSource>({
   delayMs: CONFIG_SAVE_DEBOUNCE_MS,
-  save: (config) => measurePerfAsync("persist.config.save", () => saveConfig(config)),
+  save: (source) => measurePerfAsync("persist.config.save", () => saveConfig(resolveConfig(source))),
   onError: (error) => {
     log.warn("config.save.failed", { error: error instanceof Error ? error.message : String(error) });
   },
 });
 
-export function scheduleConfigSave(config: AppConfig): void {
-  configSaveScheduler.schedule(config);
+/**
+ * A function source is resolved when the write happens, so a caller that
+ * schedules often (every cursor move updates recent tickers) can defer the
+ * cost of assembling the config until it is actually persisted, and a longer
+ * delay keeps such a save from queueing behind every keystroke.
+ */
+export function scheduleConfigSave(config: ConfigSource, options: { delayMs?: number } = {}): void {
+  configSaveScheduler.schedule(config, options.delayMs);
 }
 
 export async function saveConfigImmediately(config: AppConfig): Promise<void> {

package/src/state/hooks/inline-ticker-failures.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import {
+  INLINE_TICKER_ERROR_RETRY_MS,
+  INLINE_TICKER_UNKNOWN_RETRY_MS,
+  createInlineTickerFailureCache,
+} from "./inline-ticker-failures";
+
+describe("inline ticker failure cache", () => {
+  test("a transient error expires so the symbol is tried again", () => {
+    const cache = createInlineTickerFailureCache();
+    const now = 1_000_000;
+
+    cache.record("RSG", "error", now);
+
+    expect(cache.read("RSG", now)).toBe("error");
+    expect(cache.read("RSG", now + INLINE_TICKER_ERROR_RETRY_MS - 1)).toBe("error");
+    expect(cache.read("RSG", now + INLINE_TICKER_ERROR_RETRY_MS)).toBeNull();
+  });
+
+  test("an unknown symbol is held far longer than a failed lookup", () => {
+    const cache = createInlineTickerFailureCache();
+    const now = 1_000_000;
+
+    cache.record("NOPE", "unknown", now);
+
+    expect(cache.read("NOPE", now + INLINE_TICKER_ERROR_RETRY_MS)).toBe("unknown");
+    expect(cache.read("NOPE", now + INLINE_TICKER_UNKNOWN_RETRY_MS)).toBeNull();
+  });
+
+  test("an ambiguous symbol never expires, because retrying cannot settle it", () => {
+    const cache = createInlineTickerFailureCache();
+    const now = 1_000_000;
+
+    cache.record("QSR", "ambiguous", now);
+
+    expect(cache.read("QSR", now + INLINE_TICKER_UNKNOWN_RETRY_MS * 100)).toBe("ambiguous");
+    expect(cache.nextRetryAt(["QSR"], now)).toBeNull();
+  });
+
+  test("the next retry is the soonest deadline among the symbols asked for", () => {
+    const cache = createInlineTickerFailureCache();
+    const now = 1_000_000;
+
+    cache.record("AAA", "unknown", now);
+    cache.record("BBB", "error", now);
+    cache.record("CCC", "ambiguous", now);
+
+    expect(cache.nextRetryAt(["AAA", "BBB", "CCC"], now)).toBe(now + INLINE_TICKER_ERROR_RETRY_MS);
+    expect(cache.nextRetryAt(["AAA", "CCC"], now)).toBe(now + INLINE_TICKER_UNKNOWN_RETRY_MS);
+    expect(cache.nextRetryAt(["DDD"], now)).toBeNull();
+  });
+
+  test("a resolved symbol drops its failure", () => {
+    const cache = createInlineTickerFailureCache();
+
+    cache.record("LIN", "error");
+    cache.clear("LIN");
+
+    expect(cache.read("LIN")).toBeNull();
+  });
+
+  test("rebinding the provider forgets every verdict it produced", () => {
+    const cache = createInlineTickerFailureCache();
+    const provider = {};
+    const now = 1_000_000;
+
+    cache.scopeTo(provider);
+    cache.record("AMCR", "ambiguous", now);
+    cache.scopeTo(provider);
+
+    expect(cache.read("AMCR", now)).toBe("ambiguous");
+
+    cache.scopeTo({});
+
+    expect(cache.read("AMCR", now)).toBeNull();
+  });
+});

package/src/state/hooks/inline-ticker-failures.ts

@@ -0,0 +1,100 @@
+/**
+ * Resolving an inline ticker is a network lookup, and a lookup fails in three
+ * different ways that deserve three different answers:
+ *
+ * - `unknown`: the provider answered and knows no such symbol. Asking again in
+ *   a minute repeats the same answer, so the verdict is held for a long while.
+ * - `error`: the lookup itself failed (offline, rate limited, provider hiccup).
+ *   That describes the moment, not the symbol, so it expires quickly.
+ * - `ambiguous`: the symbol names more than one listing and only a person can
+ *   say which one. No amount of retrying settles it, so it is held until the
+ *   symbol resolves locally or the market data provider is replaced.
+ *
+ * Holding every failure for the lifetime of the process was the old behaviour,
+ * and it let one flaky lookup hide a badge until the app restarted.
+ */
+export type InlineTickerFailureKind = "unknown" | "error" | "ambiguous";
+
+export const INLINE_TICKER_UNKNOWN_RETRY_MS = 10 * 60_000;
+export const INLINE_TICKER_ERROR_RETRY_MS = 30_000;
+
+const RETRY_DELAYS_MS: Record<InlineTickerFailureKind, number> = {
+  unknown: INLINE_TICKER_UNKNOWN_RETRY_MS,
+  error: INLINE_TICKER_ERROR_RETRY_MS,
+  ambiguous: Number.POSITIVE_INFINITY,
+};
+
+interface CachedFailure {
+  kind: InlineTickerFailureKind;
+  retryAt: number;
+}
+
+export interface InlineTickerFailureCache {
+  /** The failure still standing for a symbol, or null once it may be retried. */
+  read(symbol: string, now?: number): InlineTickerFailureKind | null;
+  record(symbol: string, kind: InlineTickerFailureKind, now?: number): void;
+  clear(symbol: string): void;
+  /** When the soonest of these symbols becomes retryable, or null if none will. */
+  nextRetryAt(symbols: readonly string[], now?: number): number | null;
+  /**
+   * Failures describe one market data provider. Rebinding the registry means a
+   * different provider, a reconnect, or a restored network, so its verdicts no
+   * longer apply and every symbol gets a fresh chance.
+   */
+  scopeTo(scope: unknown): void;
+  reset(): void;
+}
+
+export function createInlineTickerFailureCache(): InlineTickerFailureCache {
+  const failures = new Map<string, CachedFailure>();
+  let scope: unknown;
+  let scoped = false;
+
+  return {
+    read(symbol, now = Date.now()) {
+      const failure = failures.get(symbol);
+      if (!failure) return null;
+      if (now < failure.retryAt) return failure.kind;
+      failures.delete(symbol);
+      return null;
+    },
+    record(symbol, kind, now = Date.now()) {
+      failures.set(symbol, { kind, retryAt: now + RETRY_DELAYS_MS[kind] });
+    },
+    clear(symbol) {
+      failures.delete(symbol);
+    },
+    nextRetryAt(symbols, now = Date.now()) {
+      let soonest: number | null = null;
+      for (const symbol of symbols) {
+        const failure = failures.get(symbol);
+        if (!failure || !Number.isFinite(failure.retryAt)) continue;
+        const retryAt = Math.max(failure.retryAt, now);
+        if (soonest === null || retryAt < soonest) soonest = retryAt;
+      }
+      return soonest;
+    },
+    scopeTo(nextScope) {
+      if (scoped && scope === nextScope) return;
+      scoped = true;
+      scope = nextScope;
+      failures.clear();
+    },
+    reset() {
+      failures.clear();
+      scope = undefined;
+      scoped = false;
+    },
+  };
+}
+
+/** Symbols the provider could not turn into a ticker. */
+export const inlineTickerResolutionFailures = createInlineTickerFailureCache();
+
+/** Tickers the provider could not quote. */
+export const inlineTickerQuoteFailures = createInlineTickerFailureCache();
+
+export function resetInlineTickerFailures(): void {
+  inlineTickerResolutionFailures.reset();
+  inlineTickerQuoteFailures.reset();
+}

package/src/state/hooks/inline-tickers.test.tsx

@@ -3,9 +3,11 @@ import { act } from "react";
 import { testRender } from "../../renderers/opentui/test-utils";
 import { setSharedMarketDataCoordinator } from "../../market-data/coordinator";
 import { setSharedRegistryForTests, type PluginRegistry } from "../../plugins/registry";
+import { createTestDataProvider } from "../../test-support/data-provider";
 import { createDefaultConfig } from "../../types/config";
 import { AppContext, createInitialState } from "../app/context";
 import { useInlineTickers } from "./inline-tickers";
+import { resetInlineTickerFailures } from "./inline-ticker-failures";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
@@ -14,6 +16,20 @@ function InlineTickerHarness({ liveQuotes = true }: { liveQuotes?: boolean }) {
   return <text>{catalog.LGD1L?.status ?? "none"}</text>;
 }
 
+/** Lookups leave on a timer, so settle real time, not just the microtask queue. */
+async function renderUntil(status: string): Promise<string> {
+  let frame = "";
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 2));
+      await testSetup!.renderOnce();
+    });
+    frame = testSetup!.captureCharFrame();
+    if (frame.includes(status)) break;
+  }
+  return frame;
+}
+
 afterEach(async () => {
   if (testSetup) {
     await act(async () => {
@@ -21,12 +37,13 @@ afterEach(async () => {
     });
   }
   testSetup = undefined;
+  resetInlineTickerFailures();
   setSharedMarketDataCoordinator(null);
   setSharedRegistryForTests(undefined);
 });
 
 describe("useInlineTickers", () => {
-  test("does not leak rejected quote lookups for existing inline tickers", async () => {
+  test("keeps the badge for a ticker the provider cannot quote, and stops asking", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-inline-tickers-test");
     const state = createInitialState(config);
     state.tickers.set("LGD1L", {
@@ -62,16 +79,7 @@ describe("useInlineTickers", () => {
       );
     });
 
-    await act(async () => {
-      await testSetup!.renderOnce();
-      await Promise.resolve();
-      await Promise.resolve();
-    });
-    await act(async () => {
-      await testSetup!.renderOnce();
-    });
-
-    expect(testSetup!.captureCharFrame()).toContain("missing");
+    expect(await renderUntil("ready")).toContain("ready");
     expect(actions).toEqual([]);
   });
 
@@ -120,4 +128,32 @@ describe("useInlineTickers", () => {
     expect(testSetup!.captureCharFrame()).toContain("ready");
     expect(quoteCalls).toBe(0);
   });
+
+  test("a symbol with several listings stays a badge instead of failing", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-inline-tickers-ambiguous-test");
+    const state = createInitialState(config);
+    setSharedRegistryForTests({
+      marketData: createTestDataProvider({
+        search: async () => [
+          { providerId: "test", symbol: "LGD1L", name: "Listing one", exchange: "NYSE", currency: "USD", type: "EQUITY" },
+          { providerId: "test", symbol: "LGD1L", name: "Listing two", exchange: "TSX", currency: "CAD", type: "EQUITY" },
+        ],
+        getQuote: async () => {
+          throw new Error("Quote unavailable");
+        },
+      }),
+      pinTicker: () => {},
+    } as unknown as PluginRegistry);
+
+    await act(async () => {
+      testSetup = await testRender(
+        <AppContext value={{ state, dispatch: () => {} }}>
+          <InlineTickerHarness />
+        </AppContext>,
+        { width: 20, height: 1 },
+      );
+    });
+
+    expect(await renderUntil("ambiguous")).toContain("ambiguous");
+  });
 });