gloomberb 0.9.7 → 0.9.9

package/src/components/ui/ui.test.tsx

@@ -1,7 +1,6 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useEffect, useRef, useState } from "react";
 import { TestDialogProvider, testRender } from "../../renderers/opentui/test-utils";
-import { TextAttributes } from "../../ui";
 import type { BoxRenderable, ScrollBoxRenderable } from "@opentui/core";
 import { ChoiceDialog } from "./choice-dialog";
 import { DataTable, type DataTableColumn } from "./data-table";
@@ -171,37 +170,6 @@ function DataTableHorizontalScrollHarness({
   );
 }
 
-function DataTableColumnGapHarness() {
-  const headerScrollRef = useRef<ScrollBoxRenderable>(null);
-  const scrollRef = useRef<ScrollBoxRenderable>(null);
-  const items = [{ id: "row-0", left: "AA", right: "BB" }];
-
-  return (
-    <DataTableView
-      rootWidth={8}
-      rootHeight={4}
-      selection={{ kind: "none" }}
-      columns={[
-        { id: "left", label: "L", width: 2, align: "left" },
-        { id: "right", label: "R", width: 2, align: "left" },
-      ]}
-      items={items}
-      sortColumnId={null}
-      sortDirection="asc"
-      onHeaderClick={() => {}}
-      headerScrollRef={headerScrollRef}
-      scrollRef={scrollRef}
-      getItemKey={(row) => row.id}
-      renderCell={(row, column) => ({ text: column.id === "left" ? row.left : row.right })}
-      emptyStateTitle="No rows."
-      columnGap={0}
-      horizontalPadding={0}
-      fillAvailableWidth={false}
-      showHorizontalScrollbar={false}
-    />
-  );
-}
-
 function DataTableVirtualizationHarness() {
   const headerScrollRef = useRef<ScrollBoxRenderable>(null);
   const scrollRef = useRef<ScrollBoxRenderable>(null);
@@ -392,31 +360,6 @@ describe("shared UI kit", () => {
     expect(lastSelected).toBe("chart");
   });
 
-  test("marks the active bare tab when it has keyboard focus", async () => {
-    testSetup = await testRender(
-      <Tabs
-        tabs={[
-          { label: "One", value: "one" },
-          { label: "Two", value: "two" },
-        ]}
-        activeValue="one"
-        onSelect={() => {}}
-        variant="bare"
-        compact
-        focused
-      />,
-      { width: 24, height: 2 },
-    );
-
-    await act(async () => {
-      await testSetup!.renderOnce();
-    });
-
-    const activeSpan = testSetup.captureSpans().lines[0]?.spans.find((span) => span.text.includes("One"));
-    expect(activeSpan).toBeDefined();
-    expect((activeSpan!.attributes & TextAttributes.UNDERLINE)).toBe(TextAttributes.UNDERLINE);
-  });
-
   test("selects tabs by clicking their text labels", async () => {
     let lastSelected = "overview";
     const selectedValues: string[] = [];
@@ -794,27 +737,6 @@ describe("shared UI kit", () => {
     expect(tableScrollBoxForTest?.horizontalScrollBar.visible).toBe(false);
   });
 
-  test("renders data table columns without spacer cells when column gap is zero", async () => {
-    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
-    testSetup = await testRender(
-      <AppContext value={{ state, dispatch: () => {} }}>
-        <PaneInstanceProvider paneId="portfolio-list:main">
-          <DataTableColumnGapHarness />
-        </PaneInstanceProvider>
-      </AppContext>,
-      { width: 8, height: 4 },
-    );
-
-    await act(async () => {
-      await testSetup!.renderOnce();
-      await testSetup!.renderOnce();
-    });
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("AABB");
-    expect(frame).not.toContain("AA BB");
-  });
-
   test("hides data table horizontal scrolling when content fits", async () => {
     const state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
     tableScrollBoxForTest = null;

package/src/core/state/app/layout-reducer.ts

@@ -2,7 +2,6 @@ import { cloneLayout, createBlankLayout, type SavedLayout } from "../../../types
 import {
   clonePaneStateMap,
   cloneSavedLayout,
-  getActiveSavedPaneState,
   historyForIndex,
   removeHistoryIndex,
   setHistoryForIndex,

package/src/data/config/layout.ts

@@ -60,9 +60,9 @@ function sanitizePlacementMemory(value: unknown): PanePlacementMemory | undefine
   const docked = (() => {
     const raw = (value as PanePlacementMemory).docked;
     if (!raw || typeof raw !== "object") return undefined;
-    const path = Array.isArray((raw as { path?: unknown }).path)
-      ? (raw as { path?: unknown }).path
-        ?.filter((segment): segment is 0 | 1 => segment === 0 || segment === 1)
+    const rawPath = (raw as { path?: unknown }).path;
+    const path = Array.isArray(rawPath)
+      ? rawPath.filter((segment): segment is 0 | 1 => segment === 0 || segment === 1)
       : undefined;
     const anchorInstanceId = typeof (raw as { anchorInstanceId?: unknown }).anchorInstanceId === "string"
       ? (raw as { anchorInstanceId: string }).anchorInstanceId

package/src/data/resource-store.ts

@@ -291,6 +291,12 @@ export class ResourceStore {
       }
       records.push(record);
     }
+    if (options.touch !== false) {
+      for (const record of records) {
+        const touchedAt = this.touch(record);
+        if (touchedAt != null) record.lastAccessedAt = touchedAt;
+      }
+    }
     return records;
   }
 

package/src/data/sqlite/cache.test.ts

@@ -35,6 +35,7 @@ describe("AppPersistence", () => {
     }, {
       cachePolicy: { staleMs: 60_000, expireMs: 120_000 },
       schemaVersion: 1,
+      fetchedAt: 1,
     });
 
     expect(persistence.resources.get<{ price: number }>({
@@ -43,6 +44,10 @@ describe("AppPersistence", () => {
       entityKey: "AAPL",
       sourceKey: "provider:yahoo",
     }, { allowExpired: true })?.value.price).toBe(123);
+    const listed = persistence.resources.list<{ price: number }>({
+      namespace: "market", kind: "quote", entityKey: "AAPL",
+    }, { allowExpired: true });
+    expect(listed[0]?.lastAccessedAt).toBeGreaterThan(1);
     persistence.close();
   });
 

package/src/data/ticker-store.ts

@@ -47,11 +47,4 @@ export class TickerStore {
       this.db.query("DELETE FROM tickers WHERE symbol = ?").run(symbol);
     });
   }
-
-  count(): number {
-    const row = withSqliteBusyRetry("count tickers", () => (
-      this.db.query<{ count: number }, []>("SELECT COUNT(*) as count FROM tickers").get()
-    ));
-    return row?.count ?? 0;
-  }
 }

package/src/market-data/coordinator/auxiliary.ts

@@ -1,14 +1,12 @@
 import type { DataProvider, SecFilingDocument, SecFilingItem } from "../../types/data-provider";
-import type { NewsArticle } from "../../news/types";
 import type { OptionsChain } from "../../types/financials";
-import type { NewsRequest, OptionsRequest, SecFilingsRequest } from "../request-types";
+import type { OptionsRequest, SecFilingsRequest } from "../request-types";
 import type { QueryEntry } from "../result-types";
 import { QueryStore } from "../query-store";
 import {
   ARTICLE_SUMMARY_CACHE_TTL_MS,
   EXPECTED_EMPTY,
   FX_CACHE_TTL_MS,
-  NEWS_CACHE_TTL_MS,
   OPTIONS_CACHE_TTL_MS,
   SEC_CONTENT_CACHE_TTL_MS,
   SEC_FILINGS_CACHE_TTL_MS,
@@ -23,7 +21,6 @@ import {
 import {
   buildArticleSummaryKey,
   buildFxKey,
-  buildNewsKey,
   buildOptionsKey,
   buildSecContentKey,
   buildSecDocumentsKey,
@@ -42,46 +39,6 @@ interface AuxiliaryLoaderOptions<T> {
   load: (startedAt: number) => Promise<QueryEntry<T>>;
 }
 
-interface NewsDataProvider extends DataProvider {
-  getNews?: (query: {
-    feed: "ticker";
-    ticker: string;
-    exchange?: string;
-    tickerTier: "primary";
-    limit?: number;
-  }) => Promise<NewsArticle[]>;
-}
-
-export function loadNewsEntry(options: {
-  dataProvider: DataProvider;
-  request: NewsRequest;
-  store: QueryStore<NewsArticle[]>;
-  runSingleFlight: RunSingleFlight;
-}): Promise<QueryEntry<NewsArticle[]>> {
-  const { dataProvider, request, store, runSingleFlight } = options;
-  const key = buildNewsKey(request);
-  return loadAuxiliaryEntry({
-    dataProvider,
-    key,
-    store,
-    ttlMs: NEWS_CACHE_TTL_MS,
-    runSingleFlight,
-    load: async (startedAt) => {
-      const newsProvider = dataProvider as NewsDataProvider;
-      if (!newsProvider.getNews) throw new Error("No news provider available");
-      const data = await newsProvider.getNews({
-        feed: "ticker",
-        ticker: request.instrument.symbol,
-        exchange: request.instrument.exchange ?? "",
-        tickerTier: "primary",
-        limit: request.count ?? 50,
-      });
-      const attempts = [createAttempt(dataProvider.id, startedAt, data.length > 0 ? "success" : "empty", data.length === 0 ? "NO_DATA" : undefined)];
-      return store.update(key, (current) => readyEntry(current, data.length > 0 ? data : null, dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
-    },
-  });
-}
-
 export function loadOptionsEntry(options: {
   dataProvider: DataProvider;
   request: OptionsRequest;

package/src/market-data/coordinator/entries.ts

@@ -8,7 +8,6 @@ const EMPTY_MESSAGE = "No data available";
 export const EXPECTED_EMPTY = /no data|not found|delisted|unavailable|unsupported/i;
 export const SNAPSHOT_CACHE_TTL_MS = 5 * 60_000;
 export const CHART_CACHE_TTL_MS = 10 * 60_000;
-export const NEWS_CACHE_TTL_MS = 2 * 60_000;
 export const OPTIONS_CACHE_TTL_MS = 10 * 60_000;
 export const SEC_FILINGS_CACHE_TTL_MS = 10 * 60_000;
 export const SEC_CONTENT_CACHE_TTL_MS = 24 * 60 * 60_000;

package/src/market-data/coordinator/events.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { MarketDataCoordinatorEvents } from "./events";
+
+const waitMicrotask = () => Promise.resolve();
+const waitTimer = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe("MarketDataCoordinatorEvents", () => {
+  test("coalesces version bumps before notifying external-store listeners", async () => {
+    const events = new MarketDataCoordinatorEvents();
+    const calls: number[] = [];
+    events.subscribeKeys(["quote:AMD"], () => {
+      calls.push(events.getKeysVersion(["quote:AMD"]));
+    });
+
+    events.bump("quote:AMD");
+    events.bump("quote:AMD");
+
+    expect(events.getKeysVersion(["quote:AMD"])).toBe(0);
+    expect(calls).toEqual([]);
+
+    await waitMicrotask();
+    expect(events.getKeysVersion(["quote:AMD"])).toBe(1);
+    expect(calls).toEqual([]);
+
+    await waitTimer();
+    expect(calls).toEqual([1]);
+  });
+
+  test("delivers bumps scheduled during notification in a later notification pass", async () => {
+    const events = new MarketDataCoordinatorEvents();
+    const order: string[] = [];
+    events.subscribeKeys(["quote:AMD"], () => {
+      order.push("AMD");
+      events.bump("quote:NVDA");
+    });
+    events.subscribeKeys(["quote:NVDA"], () => {
+      order.push("NVDA");
+    });
+
+    events.bump("quote:AMD");
+    await waitMicrotask();
+    await waitTimer();
+    expect(order).toEqual(["AMD"]);
+
+    await waitMicrotask();
+    await waitTimer();
+    expect(order).toEqual(["AMD", "NVDA"]);
+  });
+});

package/src/market-data/coordinator/events.ts

@@ -4,6 +4,8 @@ export class MarketDataCoordinatorEvents {
   private version = 0;
   private pendingVersionBump = false;
   private pendingChangedKeys = new Set<string>();
+  private pendingNotify = false;
+  private pendingListeners = new Set<() => void>();
   private readonly listeners = new Set<() => void>();
   private readonly keyListeners = new Map<string, Set<() => void>>();
   private readonly keyVersions = new Map<string, number>();
@@ -60,15 +62,34 @@ export class MarketDataCoordinatorEvents {
       for (const key of changedKeys) {
         this.keyVersions.set(key, (this.keyVersions.get(key) ?? 0) + 1);
       }
-      const keyListeners = new Set<() => void>();
+      for (const listener of this.listeners) {
+        this.pendingListeners.add(listener);
+      }
       for (const key of changedKeys) {
         for (const listener of this.keyListeners.get(key) ?? []) {
-          keyListeners.add(listener);
+          this.pendingListeners.add(listener);
         }
       }
 
-      for (const listener of this.listeners) listener();
-      for (const listener of keyListeners) listener();
+      this.scheduleNotify();
     }, { changedKeyCount: changedKeys.size });
   }
+
+  private scheduleNotify(): void {
+    if (this.pendingNotify) return;
+    this.pendingNotify = true;
+    setTimeout(() => this.flushNotify(), 0);
+  }
+
+  private flushNotify(): void {
+    this.pendingNotify = false;
+    const listeners = [...this.pendingListeners];
+    this.pendingListeners.clear();
+    for (const listener of listeners) {
+      listener();
+    }
+    if (this.pendingListeners.size > 0) {
+      this.scheduleNotify();
+    }
+  }
 }

package/src/market-data/coordinator/index.test.ts

@@ -155,13 +155,8 @@ describe("MarketDataCoordinator", () => {
   });
 
   it("reuses fresh empty tab query results instead of refetching on reopen", async () => {
-    let newsCalls = 0;
     let optionsCalls = 0;
     const provider = createProvider({
-      getNews: async () => {
-        newsCalls += 1;
-        return [];
-      },
       getOptionsChain: async () => {
         optionsCalls += 1;
         return {
@@ -175,16 +170,11 @@ describe("MarketDataCoordinator", () => {
     const coordinator = new MarketDataCoordinator(provider);
     const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
 
-    const firstNews = await coordinator.loadNews({ instrument, count: 20 });
-    const secondNews = await coordinator.loadNews({ instrument, count: 20 });
     const firstOptions = await coordinator.loadOptions({ instrument });
     const secondOptions = await coordinator.loadOptions({ instrument });
 
-    expect(firstNews.error?.reasonCode).toBe("NO_DATA");
-    expect(secondNews.error?.reasonCode).toBe("NO_DATA");
     expect(firstOptions.error?.reasonCode).toBe("NO_DATA");
     expect(secondOptions.error?.reasonCode).toBe("NO_DATA");
-    expect(newsCalls).toBe(1);
     expect(optionsCalls).toBe(1);
   });
 
@@ -347,6 +337,229 @@ describe("MarketDataCoordinator", () => {
     expect(coordinator.getQuoteEntry(instrument).data?.price).toBe(412.5);
   });
 
+  it("reconciles stream quotes with cached provider day references before a snapshot loads", () => {
+    let streamed: ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null = null;
+    const provider = createProvider({
+      getCachedFinancialsForTargets: () => new Map([[
+        "VICR",
+        {
+          quote: {
+            symbol: "VICR",
+            providerId: "gloomberb-cloud",
+            price: 292.83,
+            currency: "USD",
+            previousClose: 282.95,
+            change: 9.88,
+            changePercent: 3.49,
+            lastUpdated: Date.parse("2026-07-06T16:54:30Z"),
+            marketState: "REGULAR",
+            dataSource: "live",
+          },
+          quoteContributions: {
+            "gloomberb-cloud": {
+              symbol: "VICR",
+              providerId: "gloomberb-cloud",
+              price: 292.83,
+              currency: "USD",
+              previousClose: 380.07,
+              change: -87.24,
+              changePercent: -22.95,
+              lastUpdated: Date.parse("2026-07-06T16:54:30Z"),
+              marketState: "REGULAR",
+              dataSource: "live",
+            },
+            yahoo: {
+              symbol: "VICR",
+              providerId: "yahoo",
+              price: 294.39,
+              currency: "USD",
+              previousClose: 282.95,
+              change: 11.44,
+              changePercent: 4.04,
+              lastUpdated: Date.parse("2026-07-06T16:45:37Z"),
+              marketState: "REGULAR",
+              dataSource: "delayed",
+            },
+          },
+          annualStatements: [],
+          quarterlyStatements: [],
+          priceHistory: [],
+        },
+      ]]),
+      subscribeQuotes: (_targets, onQuote) => {
+        streamed = onQuote as typeof streamed;
+        return () => {};
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = {
+      symbol: "VICR",
+      exchange: "NASDAQ",
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-work",
+      instrument: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        conId: 275759,
+        symbol: "VICR",
+      },
+    };
+
+    coordinator.subscribeQuotes([{ instrument }]);
+    const onStreamed = streamed as ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null;
+    if (!onStreamed) throw new Error("expected streaming callback");
+    onStreamed(
+      {
+        symbol: "VICR",
+        exchange: "NASDAQ",
+        context: {
+          brokerId: "ibkr",
+          brokerInstanceId: "ibkr-work",
+          instrument: instrument.instrument,
+        },
+      },
+      {
+        symbol: "VICR",
+        providerId: "gloomberb-cloud",
+        price: 293.07,
+        currency: "USD",
+        previousClose: 380.07,
+        change: -87,
+        changePercent: -22.89,
+        lastUpdated: Date.parse("2026-07-06T17:17:00Z"),
+        marketState: "REGULAR",
+        dataSource: "live",
+      },
+    );
+
+    const quote = coordinator.getQuoteEntry(instrument).data;
+    expect(quote?.price).toBe(293.07);
+    expect(quote?.previousClose).toBe(282.95);
+    expect(quote?.changePercent).toBeCloseTo(((293.07 - 282.95) / 282.95) * 100, 10);
+    expect(quote?.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
+  });
+
+  it("reconciles batch quote loads with cached provider day references before a snapshot loads", async () => {
+    const provider = createProvider({
+      getCachedFinancialsForTargets: () => new Map([[
+        "VICR",
+        {
+          quote: {
+            symbol: "VICR",
+            providerId: "gloomberb-cloud",
+            price: 292.83,
+            currency: "USD",
+            previousClose: 282.95,
+            change: 9.88,
+            changePercent: 3.49,
+            lastUpdated: Date.parse("2026-07-06T16:54:30Z"),
+            marketState: "REGULAR",
+            dataSource: "live",
+          },
+          quoteContributions: {
+            "gloomberb-cloud": {
+              symbol: "VICR",
+              providerId: "gloomberb-cloud",
+              price: 292.83,
+              currency: "USD",
+              previousClose: 380.07,
+              change: -87.24,
+              changePercent: -22.95,
+              lastUpdated: Date.parse("2026-07-06T16:54:30Z"),
+              marketState: "REGULAR",
+              dataSource: "live",
+            },
+            yahoo: {
+              symbol: "VICR",
+              providerId: "yahoo",
+              price: 294.39,
+              currency: "USD",
+              previousClose: 282.95,
+              change: 11.44,
+              changePercent: 4.04,
+              lastUpdated: Date.parse("2026-07-06T16:45:37Z"),
+              marketState: "REGULAR",
+              dataSource: "delayed",
+            },
+          },
+          annualStatements: [],
+          quarterlyStatements: [],
+          priceHistory: [],
+        },
+      ]]),
+      getQuotesBatch: async (targets) => targets.map((target) => ({
+        target,
+        quote: {
+          symbol: target.symbol,
+          providerId: "gloomberb-cloud",
+          price: 293.07,
+          currency: "USD",
+          previousClose: 380.07,
+          change: -87,
+          changePercent: -22.89,
+          lastUpdated: Date.parse("2026-07-06T17:17:00Z"),
+          marketState: "REGULAR",
+          dataSource: "live",
+        },
+      })),
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = {
+      symbol: "VICR",
+      exchange: "NASDAQ",
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-work",
+      instrument: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        conId: 275759,
+        symbol: "VICR",
+      },
+    };
+
+    await coordinator.loadQuotesBatch([instrument], { forceRefresh: true });
+
+    const quote = coordinator.getQuoteEntry(instrument).data;
+    expect(quote?.price).toBe(293.07);
+    expect(quote?.previousClose).toBe(282.95);
+    expect(quote?.changePercent).toBeCloseTo(((293.07 - 282.95) / 282.95) * 100, 10);
+    expect(quote?.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
+  });
+
+  it("preserves requested quote stream routes", () => {
+    let subscribedTargets: QuoteSubscriptionTarget[] = [];
+    const provider = createProvider({
+      subscribeQuotes: (targets) => {
+        subscribedTargets = targets;
+        return () => {};
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+
+    coordinator.subscribeQuotes([{
+      instrument: {
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+      },
+      priority: { route: "provider", surface: "portfolio", visible: true },
+    }]);
+
+    expect(subscribedTargets).toEqual([{
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      route: "provider",
+      context: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: null,
+      },
+      surface: "portfolio",
+      visible: true,
+    }]);
+  });
+
   it("routes manual-resolution chart requests through the resolution-aware provider path", async () => {
     let requested: { range: string; resolution: string } | null = null;
     const provider = createProvider({