gloomberb 0.3.3 → 0.3.7

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

@@ -90,7 +90,8 @@ describe("prediction markets pane interactions", () => {
     await flushFrames(testSetup);
 
     let frame = testSetup.captureCharFrame();
-    expect(frame).toContain("Prediction Markets");
+    expect(frame).toContain("All venues");
+    expect(frame).not.toContain("VOL = native venue units");
     expect(frame).toContain("Will inflation fall?");
     expect(frame).toContain("Kalshi");
 
@@ -117,6 +118,45 @@ describe("prediction markets pane interactions", () => {
     expect(frame).toContain("Kalshi primary rule");
   });
 
+  test("loads selected detail once instead of refetching in a render loop", async () => {
+    const { fetchUrls } = installPredictionMarketMocks();
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    const lines = frame.split("\n");
+    const kalshiRow = lines.findIndex((line) =>
+      line.includes("Will the Fed cut rates?"),
+    );
+    const kalshiCol = lines[kalshiRow]?.indexOf("Will the Fed cut rates?") ?? -1;
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup, 8);
+
+    const eventFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/events/FED-1"),
+    );
+    const orderbookFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/markets/KAL-1/orderbook"),
+    );
+    const tradeFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/markets/trades?ticker=KAL-1"),
+    );
+    const historyFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/series/FED/markets/KAL-1/candlesticks"),
+    );
+
+    expect(eventFetches).toHaveLength(2);
+    expect(orderbookFetches).toHaveLength(1);
+    expect(tradeFetches).toHaveLength(1);
+    expect(historyFetches).toHaveLength(1);
+    expect(testSetup.captureCharFrame()).not.toContain("Loading market detail...");
+  });
+
   test("moves selection through the list with keyboard navigation", async () => {
     installPredictionMarketMocks();
 

package/src/plugins/prediction-markets/pane.tsx

@@ -1,16 +1,14 @@
 import { useRef } from "react";
 import { TextAttributes, type BoxRenderable } from "@opentui/core";
-import { Spinner, TabBar } from "../../components";
+import { TabBar } from "../../components";
 import { usePredictionMarketsController } from "./controller";
 import { PredictionMarketDetailPane } from "./detail/pane";
 import { BROWSE_TABS, VENUE_TABS } from "./navigation";
 import { PredictionMarketsTable } from "./table";
-import { formatPredictionTransportBadge } from "./status";
 import { PREDICTION_CATEGORY_OPTIONS } from "./categories";
 import type { PredictionBrowseTab, PredictionCategoryId } from "./types";
 import type { PaneProps } from "../../types/plugin";
 import { colors } from "../../theme/colors";
-import { formatTimeAgo } from "../../utils/format";
 
 function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
@@ -22,12 +20,6 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
   const splitDragRef = useRef<{ startX: number; startRatio: number } | null>(
     null,
   );
-  const statusBadge = formatPredictionTransportBadge(
-    controller.catalogLoadCount > 0 || controller.detailLoadCount > 0
-      ? "loading"
-      : controller.transportState,
-  );
-  const showSummaryUnitsHint = controller.effectiveVenueScope === "all";
   const minTableWidth = 44;
   const minDetailWidth = 36;
   const effectiveMinTableWidth = controller.selectedSummary
@@ -108,28 +100,6 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
       backgroundColor={colors.panel}
       onMouse={handlePaneMouse}
     >
-      {!controller.paneSettings.hideHeader && (
-        <box flexDirection="row" height={1} paddingX={1}>
-          <text fg={colors.textBright} attributes={TextAttributes.BOLD}>
-            Prediction Markets
-          </text>
-          <box flexGrow={1} />
-          {showSummaryUnitsHint && (
-            <text fg={colors.textDim}>VOL = native venue units</text>
-          )}
-          <box width={1} />
-          {controller.searchLoading && <Spinner />}
-          {controller.searchLoading && <box width={1} />}
-          <text fg={statusBadge.color}>{statusBadge.label}</text>
-          <box width={1} />
-          <text fg={colors.textDim}>
-            {controller.lastRefreshAt
-              ? `refresh ${formatTimeAgo(new Date(controller.lastRefreshAt))}`
-              : "waiting"}
-          </text>
-        </box>
-      )}
-
       {!controller.paneSettings.hideTabs && (
         <TabBar
           tabs={VENUE_TABS.map((tab) => ({

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

@@ -1355,6 +1355,49 @@ describe("ProviderRouter", () => {
     expect(history.map((point) => point.close)).toEqual([101, 102, 103]);
   });
 
+  test("ignores poisoned cached chart history and refetches clean data", async () => {
+    const dbPath = createTempDbPath("poisoned-chart-cache");
+    const persistence = new AppPersistence(dbPath);
+
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "price-history",
+        entityKey: "AAPL",
+        variantKey: "exchange=NASDAQ;range=1Y",
+        sourceKey: "provider:yahoo",
+      },
+      [
+        { date: null as any, close: 101 },
+        { date: null as any, close: 102 },
+      ],
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 60_000 },
+      },
+    );
+
+    let providerCalls = 0;
+    const router = new ProviderRouter({
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      async getPriceHistory() {
+        providerCalls += 1;
+        return [
+          { date: new Date("2026-03-27T00:00:00Z"), close: 201 },
+          { date: new Date("2026-03-28T00:00:00Z"), close: 202 },
+        ];
+      },
+    }, [], persistence.resources);
+
+    const history = await router.getPriceHistory("AAPL", "NASDAQ", "1Y");
+
+    expect(providerCalls).toBe(1);
+    expect(history.map((point) => point.close)).toEqual([201, 202]);
+
+    persistence.close();
+  });
+
   test("bypasses cached financials on explicit refresh requests", async () => {
     const dbPath = createTempDbPath("forced-financial-refresh");
     const persistence = new AppPersistence(dbPath);

package/src/sources/provider-router.ts

@@ -483,9 +483,10 @@ export class ProviderRouter implements DataProvider {
       ...this.getProviderSourceKeys(),
     ];
     const cached = this.selectCachedArrayResource<PricePoint>("price-history", entityKey, variantKeys, sourceKeys, false);
+    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
     const forceRefresh = context?.cacheMode === "refresh";
-    if (cached && !forceRefresh && !cached.stale) {
-      return cached.value;
+    if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale) {
+      return cachedValue;
     }
 
     const brokerHistory = await withBrokerTimeout(this.fetchBrokerPriceHistory(ticker, exchange, range, context));
@@ -495,7 +496,7 @@ export class ProviderRouter implements DataProvider {
     if (providerHistory && providerHistory.value.length > 0) {
       return providerHistory.value;
     }
-    if (cached) return cached.value;
+    if (cachedValue.length > 0) return cachedValue;
     if (!providerHistory) {
       throw new Error(`No history provider available for ${ticker}`);
     }
@@ -520,9 +521,10 @@ export class ProviderRouter implements DataProvider {
       ...this.getProviderSourceKeys(),
     ];
     const cached = this.selectCachedArrayResource<PricePoint>("detailed-price-history", entityKey, variantKeys, sourceKeys, false);
+    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
     const forceRefresh = context?.cacheMode === "refresh";
-    if (cached && !forceRefresh && !cached.stale) {
-      return cached.value;
+    if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale) {
+      return cachedValue;
     }
 
     const brokerResult = await withBrokerTimeout(this.fetchBrokerDetailedPriceHistory(ticker, exchange, startDate, endDate, barSize, context));
@@ -532,7 +534,7 @@ export class ProviderRouter implements DataProvider {
     if (providerResult && providerResult.value.length > 0) {
       return providerResult.value;
     }
-    return cached?.value ?? providerResult?.value ?? [];
+    return cachedValue.length > 0 ? cachedValue : (providerResult?.value ?? []);
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, context?: MarketDataRequestContext): Promise<OptionsChain> {

package/src/utils/price-history.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { normalizePriceHistory } from "./price-history";
+
+describe("normalizePriceHistory", () => {
+  test("drops poisoned cached history when every timestamp collapses to the same value", () => {
+    const history = normalizePriceHistory([
+      { date: null as any, close: 101 },
+      { date: null as any, close: 102 },
+      { date: null as any, close: 103 },
+    ]);
+
+    expect(history).toEqual([]);
+  });
+
+  test("filters invalid dates and keeps the remaining points in chronological order", () => {
+    const history = normalizePriceHistory([
+      { date: new Date("2026-03-29T00:00:00Z"), close: 103 },
+      { date: null as any, close: 999 },
+      { date: new Date("2026-03-27T00:00:00Z"), close: 101 },
+      { date: new Date("2026-03-28T00:00:00Z"), close: 102 },
+    ]);
+
+    expect(history.map((point) => point.close)).toEqual([101, 102, 103]);
+  });
+});

package/src/utils/price-history.ts

@@ -1,7 +1,10 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
 
 function getPointTimestamp(point: PricePoint): number {
-  return point.date instanceof Date ? point.date.getTime() : new Date(point.date).getTime();
+  const value = point.date as Date | string | number | null | undefined;
+  if (value instanceof Date) return value.getTime();
+  if (value == null) return Number.NaN;
+  return new Date(value).getTime();
 }
 
 function comparePricePointsByDate(left: PricePoint, right: PricePoint): number {
@@ -17,18 +20,39 @@ function comparePricePointsByDate(left: PricePoint, right: PricePoint): number {
 }
 
 export function normalizePriceHistory(points: PricePoint[]): PricePoint[] {
-  if (points.length <= 1) return points;
+  if (points.length === 0) return points;
 
+  const validPoints: PricePoint[] = [];
+  let sawDistinctTimestamp = false;
+  let firstTimestamp: number | null = null;
   let previousTime = Number.NEGATIVE_INFINITY;
+  let requiresSort = false;
+
   for (const point of points) {
     const time = getPointTimestamp(point);
-    if (!Number.isFinite(time) || time < previousTime) {
-      return [...points].sort(comparePricePointsByDate);
+    if (!Number.isFinite(time)) continue;
+
+    if (firstTimestamp === null) {
+      firstTimestamp = time;
+    } else if (time !== firstTimestamp) {
+      sawDistinctTimestamp = true;
+    }
+
+    if (time < previousTime) {
+      requiresSort = true;
     }
     previousTime = time;
+    validPoints.push(point);
   }
 
-  return points;
+  if (validPoints.length === 0) return [];
+  if (validPoints.length === 1) return validPoints;
+  if (!sawDistinctTimestamp) return [];
+
+  if (requiresSort) {
+    return [...validPoints].sort(comparePricePointsByDate);
+  }
+  return validPoints.length === points.length ? points : validPoints;
 }
 
 export function normalizeTickerFinancialsPriceHistory(financials: TickerFinancials): TickerFinancials {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.3.3";
+export const VERSION = "0.3.4";