gloomberb 0.10.2 → 0.10.4

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

@@ -9,6 +9,7 @@ import {
   type ChartResolutionSupport,
   type ManualChartResolution,
 } from "../../time-series/resolution";
+import { repairIsolatedIntradayOhlcOutliers } from "../../time-series/history-quality";
 import { canonicalExchange } from "../../utils/exchanges";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
 import { isPriceHistoryStaleForCurrentWindow, normalizePriceHistory } from "../../utils/price-history";
@@ -29,7 +30,7 @@ type PriceHistoryCachePolicyKey = Extract<
   ProviderRouterCachePolicyKey,
   "priceHistoryIntraday" | "priceHistoryDaily"
 >;
-const PRICE_HISTORY_CACHE_VERSION = 3;
+const PRICE_HISTORY_CACHE_VERSION = 4;
 
 interface HistoryRequestDescriptor {
   identity: RouterRequestIdentity;
@@ -83,6 +84,16 @@ function makeHistoryRequestIdentity(
   };
 }
 
+function normalizeRequestHistory(
+  points: PricePoint[],
+  request: Pick<HistoryRequestDescriptor, "cachePolicyKey">,
+): PricePoint[] {
+  const normalized = normalizePriceHistory(points);
+  return request.cachePolicyKey === "priceHistoryIntraday"
+    ? repairIsolatedIntradayOhlcOutliers(normalized)
+    : normalized;
+}
+
 export class ProviderRouterHistoryRoutes {
   constructor(private readonly deps: ProviderRouterCoreDeps) {}
 
@@ -282,7 +293,7 @@ export class ProviderRouterHistoryRoutes {
       sourceKeys,
       false,
     );
-    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
+    const cachedValue = cached ? normalizeRequestHistory(cached.value, request) : [];
     const cachedHistoryStale = request.isCachedValueStale(cachedValue);
     const forceRefresh = request.context?.cacheMode === "refresh";
     if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale && !cachedHistoryStale) {
@@ -308,7 +319,7 @@ export class ProviderRouterHistoryRoutes {
     return this.firstBrokerResult(candidates, async (candidate) => {
       const fetched = await request.fetchBroker(candidate);
       if (fetched === null) return null;
-      const value = normalizePriceHistory(fetched);
+      const value = normalizeRequestHistory(fetched, request);
       if (request.isFetchedValueStale(value)) return null;
       this.deps.cacheResource(
         request.identity.kind,
@@ -326,7 +337,7 @@ export class ProviderRouterHistoryRoutes {
     return this.firstProviderArrayResult(async (provider) => {
       const fetched = await request.fetchProvider(provider);
       if (fetched === null) return null;
-      const value = normalizePriceHistory(fetched);
+      const value = normalizeRequestHistory(fetched, request);
       if (request.isFetchedValueStale(value)) return null;
       this.deps.cacheResource(
         request.identity.kind,

package/src/sources/yahoo-finance/history.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { loadYahooPriceHistoryForResolution } from "./history";
+
+describe("Yahoo chart history", () => {
+  test("repairs an isolated intraday wick without dropping the bar", async () => {
+    const history = await loadYahooPriceHistoryForResolution({
+      ticker: "AMD",
+      exchange: "NASDAQ",
+      bufferRange: "1M",
+      resolution: "15m",
+      fetchChart: async () => ({
+        meta: { currency: "USD" },
+        history: [
+          {
+            date: new Date("2026-07-06T14:00:00.000Z"),
+            open: 99.5,
+            high: 101,
+            low: 99,
+            close: 100,
+          },
+          {
+            date: new Date("2026-07-06T14:15:00.000Z"),
+            open: 100,
+            high: 150,
+            low: 99,
+            close: 100.5,
+          },
+          {
+            date: new Date("2026-07-06T14:30:00.000Z"),
+            open: 100.5,
+            high: 101,
+            low: 100,
+            close: 100.7,
+          },
+        ],
+      }),
+    });
+
+    expect(history).toHaveLength(3);
+    expect(history[1]).toMatchObject({
+      open: 100,
+      high: 100.5,
+      low: 99,
+      close: 100.5,
+    });
+  });
+});

package/src/sources/yahoo-finance/history.ts

@@ -1,9 +1,11 @@
 import type { TimeRange } from "../../time-series/range";
 import {
+  isIntradayResolution,
   normalizeChartResolutionSupport,
   type ChartResolutionSupport,
   type ManualChartResolution,
 } from "../../time-series/resolution";
+import { repairIsolatedIntradayOhlcOutliers } from "../../time-series/history-quality";
 import type { PricePoint } from "../../types/financials";
 import { normalizeSubUnitCurrency } from "./mappers";
 import { getYahooSymbolsToTry } from "./symbols";
@@ -101,7 +103,9 @@ export async function loadYahooPriceHistoryForResolution({
         }
       }
 
-      return history;
+      return isIntradayResolution(resolution)
+        ? repairIsolatedIntradayOhlcOutliers(history)
+        : history;
     } catch (err) {
       lastError = err;
     }

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

@@ -2,10 +2,18 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { act, useState } from "react";
 import { testRender } from "../../renderers/opentui/test-utils";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../market-data/coordinator";
-import { useQuoteStreaming } from "./quote-streaming";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import { AppProvider, PaneInstanceProvider } from "../../state/app/context";
+import { createDefaultConfig } from "../../types/config";
+import { useLiveStreamingSetting } from "../../plugins/builtin/shared/live-streaming";
+import { useLiveQuoteEntries, useQuoteStreaming, useQuoteUpdates } from "./quote-streaming";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let bumpHarness: (() => void) | null = null;
+let togglePollingPriority: (() => void) | null = null;
+let updateLiveTargets: ((symbol: string) => void) | null = null;
+let updateFreshnessScope: ((scope: string) => void) | null = null;
+let observedSubscriptionStartedAt = 0;
 
 function QuoteStreamingHarness() {
   const [tick, setTick] = useState(0);
@@ -19,6 +27,53 @@ function QuoteStreamingHarness() {
   return <text>{String(tick)}</text>;
 }
 
+function QuotePollingHarness() {
+  useQuoteUpdates([{
+    symbol: "AAPL",
+    exchange: "NASDAQ",
+  }], {
+    liveStreaming: false,
+    pollIntervalMs: 30,
+  });
+  return <text>polling</text>;
+}
+
+function QuotePollingPriorityHarness() {
+  const [selected, setSelected] = useState(false);
+  togglePollingPriority = () => setSelected((current) => !current);
+  useQuoteUpdates([{
+    symbol: "AAPL",
+    exchange: "NASDAQ",
+    selected,
+    weight: selected ? 100 : 10,
+  }], {
+    liveStreaming: false,
+    pollIntervalMs: 1_000,
+  });
+  return <text>{selected ? "selected" : "idle"}</text>;
+}
+
+function FollowedQuoteStreamingHarness() {
+  const liveStreaming = useLiveStreamingSetting();
+  useQuoteUpdates([{
+    symbol: "AMD",
+    exchange: "NASDAQ",
+  }], { liveStreaming });
+  return <text>{liveStreaming ? "live" : "polling"}</text>;
+}
+
+function LiveQuoteFreshnessHarness() {
+  const [symbol, setSymbol] = useState("AAPL");
+  const [freshnessScopeKey, setFreshnessScopeKey] = useState("expiration-1");
+  updateLiveTargets = setSymbol;
+  updateFreshnessScope = setFreshnessScopeKey;
+  observedSubscriptionStartedAt = useLiveQuoteEntries(
+    [{ symbol, exchange: "OPTIONS" }],
+    { freshnessScopeKey },
+  ).subscriptionStartedAt;
+  return <text>{symbol}</text>;
+}
+
 afterEach(async () => {
   if (testSetup) {
     await act(async () => {
@@ -27,6 +82,10 @@ afterEach(async () => {
     testSetup = undefined;
   }
   bumpHarness = null;
+  togglePollingPriority = null;
+  updateLiveTargets = null;
+  updateFreshnessScope = null;
+  observedSubscriptionStartedAt = 0;
   setSharedMarketDataCoordinator(null);
 });
 
@@ -67,4 +126,125 @@ describe("useQuoteStreaming", () => {
     expect(subscribeCalls).toBe(1);
     expect(unsubscribeCalls).toBe(0);
   });
+
+  test("uses forced polling instead of a subscription when live streaming is disabled", async () => {
+    let subscribeCalls = 0;
+    let loadCalls = 0;
+    const coordinator = {
+      subscribeQuotes: () => {
+        subscribeCalls += 1;
+        return () => {};
+      },
+      loadQuotesBatch: async (_instruments: unknown[], options: { forceRefresh?: boolean }) => {
+        expect(options.forceRefresh).toBe(true);
+        loadCalls += 1;
+        return [];
+      },
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(<QuotePollingHarness />, { width: 20, height: 1 });
+    await act(async () => testSetup!.renderOnce());
+    expect(subscribeCalls).toBe(0);
+    expect(loadCalls).toBe(1);
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 45));
+    });
+    expect(loadCalls).toBeGreaterThanOrEqual(2);
+  });
+
+  test("inherits disabled streaming from a followed portfolio pane", async () => {
+    let subscribeCalls = 0;
+    let loadCalls = 0;
+    const config = createDefaultConfig("/tmp/gloomberb-live-streaming-test");
+    const portfolioPane = config.layout.instances.find((pane) => pane.instanceId === "portfolio-list:main");
+    if (!portfolioPane) throw new Error("expected default portfolio pane");
+    portfolioPane.settings = { ...portfolioPane.settings, liveStreaming: false };
+    setSharedMarketDataCoordinator({
+      subscribeQuotes: () => {
+        subscribeCalls += 1;
+        return () => {};
+      },
+      loadQuotesBatch: async () => {
+        loadCalls += 1;
+        return [];
+      },
+    } as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(
+      <AppProvider config={config}>
+        <PaneInstanceProvider paneId="ticker-detail:main">
+          <FollowedQuoteStreamingHarness />
+        </PaneInstanceProvider>
+      </AppProvider>,
+      { width: 20, height: 1 },
+    );
+    await act(async () => testSetup!.renderOnce());
+
+    expect(testSetup.captureCharFrame()).toContain("polling");
+    expect(subscribeCalls).toBe(0);
+    expect(loadCalls).toBe(1);
+  });
+
+  test("does not restart polling when only subscription priority changes", async () => {
+    let loadCalls = 0;
+    const coordinator = {
+      subscribeQuotes: () => () => {},
+      loadQuotesBatch: async () => {
+        loadCalls += 1;
+        return [];
+      },
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(<QuotePollingPriorityHarness />, { width: 20, height: 1 });
+    await act(async () => testSetup!.renderOnce());
+    expect(loadCalls).toBe(1);
+
+    await act(async () => {
+      togglePollingPriority?.();
+      await Promise.resolve();
+    });
+    await act(async () => testSetup!.renderOnce());
+    expect(loadCalls).toBe(1);
+  });
+
+  test("keeps quote freshness stable while targets move within one surface", async () => {
+    const originalDateNow = Date.now;
+    let now = 100;
+    Date.now = () => now;
+    setSharedMarketDataCoordinator(new MarketDataCoordinator(createTestDataProvider({
+      subscribeQuotes: () => () => {},
+    })));
+
+    try {
+      testSetup = await testRender(<LiveQuoteFreshnessHarness />, {
+        width: 20,
+        height: 1,
+      });
+      await act(async () => {
+        await testSetup!.renderOnce();
+      });
+      expect(observedSubscriptionStartedAt).toBe(100);
+
+      now = 200;
+      await act(async () => {
+        updateLiveTargets?.("MSFT");
+        await Promise.resolve();
+        await testSetup!.renderOnce();
+      });
+      expect(observedSubscriptionStartedAt).toBe(100);
+
+      now = 300;
+      await act(async () => {
+        updateFreshnessScope?.("expiration-2");
+        await Promise.resolve();
+        await testSetup!.renderOnce();
+      });
+      expect(observedSubscriptionStartedAt).toBe(300);
+    } finally {
+      Date.now = originalDateNow;
+    }
+  });
 });

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

@@ -11,6 +11,17 @@ import type { QueryEntry } from "../../market-data/result-types";
 import { buildQuoteKey } from "../../market-data/selectors";
 
 const quoteStreamLog = debugLog.createLogger("quote-stream");
+export const DEFAULT_QUOTE_POLL_INTERVAL_MS = 60_000;
+
+export interface QuoteStreamingOptions {
+  enabled?: boolean;
+}
+
+export interface QuoteUpdateOptions {
+  liveStreaming?: boolean;
+  pollIntervalMs?: number;
+  freshnessScopeKey?: string;
+}
 
 export function normalizeQuoteStreamSubscriptionTarget(target: QuoteSubscriptionTarget): QuoteSubscriptionTarget | null {
   const symbol = normalizeSymbol(target.symbol);
@@ -42,7 +53,10 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
   ].join("|");
 }
 
-export function useQuoteStreaming(targets: QuoteSubscriptionTarget[]): void {
+export function useQuoteStreaming(
+  targets: QuoteSubscriptionTarget[],
+  { enabled = true }: QuoteStreamingOptions = {},
+): void {
   const appActive = useAppActive();
   const coordinator = getSharedMarketDataCoordinator();
 
@@ -58,9 +72,12 @@ export function useQuoteStreaming(targets: QuoteSubscriptionTarget[]): void {
   const subscriptionKey = sortedEntries.map(([key]) => key).join("|");
 
   useEffect(() => {
-    if (!appActive) {
+    if (!enabled || !appActive) {
       if (normalizedTargets.length > 0) {
-        quoteStreamLog.info("skipping subscription while inactive", { targets: subscriptionKey });
+        quoteStreamLog.info("skipping subscription", {
+          reason: enabled ? "inactive" : "disabled",
+          targets: subscriptionKey,
+        });
       }
       return;
     }
@@ -94,14 +111,81 @@ export function useQuoteStreaming(targets: QuoteSubscriptionTarget[]): void {
       });
       unsubscribe?.();
     };
-  }, [appActive, coordinator, subscriptionKey]);
+  }, [appActive, coordinator, enabled, subscriptionKey]);
+}
+
+export function useQuoteUpdates(
+  targets: QuoteSubscriptionTarget[],
+  {
+    liveStreaming = true,
+    pollIntervalMs = DEFAULT_QUOTE_POLL_INTERVAL_MS,
+  }: QuoteUpdateOptions = {},
+): void {
+  const appActive = useAppActive();
+  const coordinator = getSharedMarketDataCoordinator();
+  const normalizedTargets = targets.flatMap((target) => {
+    const normalized = normalizeQuoteStreamSubscriptionTarget(target);
+    return normalized ? [normalized] : [];
+  });
+  const instrumentKey = normalizedTargets
+    .map((target) => buildQuoteKey({
+      symbol: target.symbol,
+      exchange: target.exchange,
+      brokerId: target.context?.brokerId,
+      brokerInstanceId: target.context?.brokerInstanceId,
+      instrument: target.context?.instrument ?? null,
+    }))
+    .sort()
+    .join("\u001f");
+  const instruments = useMemo(() => {
+    const unique = new Map<string, InstrumentRef>();
+    for (const target of normalizedTargets) {
+      const instrument: InstrumentRef = {
+        symbol: target.symbol,
+        exchange: target.exchange,
+        brokerId: target.context?.brokerId,
+        brokerInstanceId: target.context?.brokerInstanceId,
+        instrument: target.context?.instrument ?? null,
+      };
+      unique.set(buildQuoteKey(instrument), instrument);
+    }
+    return [...unique.values()];
+  }, [instrumentKey]);
+
+  useQuoteStreaming(targets, { enabled: liveStreaming });
+
+  useEffect(() => {
+    if (liveStreaming || !appActive || !coordinator || instruments.length === 0) return;
+    let cancelled = false;
+    let inFlight = false;
+    const refresh = async () => {
+      if (cancelled || inFlight) return;
+      inFlight = true;
+      try {
+        await coordinator.loadQuotesBatch(instruments, { forceRefresh: true });
+      } catch {
+        // Polling is best effort and the coordinator retains the last good quote.
+      } finally {
+        inFlight = false;
+      }
+    };
+    void refresh();
+    const intervalId = setInterval(() => void refresh(), pollIntervalMs);
+    return () => {
+      cancelled = true;
+      clearInterval(intervalId);
+    };
+  }, [appActive, coordinator, instrumentKey, instruments, liveStreaming, pollIntervalMs]);
 }
 
 /**
  * Subscribe to a bounded target set and observe the coordinator entries filled
  * by that stream. This intentionally avoids per-symbol HTTP quote loads.
  */
-export function useLiveQuoteEntries(targets: QuoteSubscriptionTarget[]): {
+export function useLiveQuoteEntries(
+  targets: QuoteSubscriptionTarget[],
+  options: QuoteUpdateOptions = {},
+): {
   entries: Map<string, QueryEntry<Quote>>;
   freshnessNow: number;
   subscriptionStartedAt: number;
@@ -115,7 +199,9 @@ export function useLiveQuoteEntries(targets: QuoteSubscriptionTarget[]): {
     .map((target) => buildQuoteStreamSubscriptionKey(target))
     .sort()
     .join("\u001f");
-  const subscriptionKey = `${appActive ? "active" : "inactive"}\u001f${targetKey}`;
+  const liveStreaming = options.liveStreaming !== false;
+  const freshnessKey = options.freshnessScopeKey ?? targetKey;
+  const subscriptionKey = `${appActive ? "active" : "inactive"}\u001f${liveStreaming ? "live" : "poll"}\u001f${freshnessKey}`;
   const subscriptionRef = useRef({
     key: subscriptionKey,
     startedAt: Date.now(),
@@ -149,7 +235,7 @@ export function useLiveQuoteEntries(targets: QuoteSubscriptionTarget[]): {
     return () => clearInterval(interval);
   }, [appActive, targetKey]);
 
-  useQuoteStreaming(targets);
+  useQuoteUpdates(targets, options);
   return {
     entries: useQuoteEntries(instruments),
     freshnessNow,

package/src/theme/colors.ts

@@ -1,4 +1,4 @@
-import { blendForContrast, blendHex, higherContrast } from "./color-utils";
+import { blendForContrast, blendForContrastOnSurfaces, blendHex, higherContrast } from "./color-utils";
 import { getTheme, DEFAULT_THEME, type Theme } from "./themes";
 
 export type ThemeColors = Readonly<Omit<Theme, "name" | "description">>;
@@ -8,6 +8,9 @@ export function getThemeColors(id: string): ThemeColors {
   return Object.freeze(palette);
 }
 
+/** Soft violet the AI section is tinted with, before per-theme contrast fixup. */
+const ASSIST_ACCENT = "#a877ff";
+
 let currentColors = getThemeColors(DEFAULT_THEME);
 
 /** Compatibility facade for non-React formatting and rendering helpers. */
@@ -174,6 +177,22 @@ export function commandBarSubtleText(palette: ThemeColors = colors): string {
   return blendForContrast(palette.textDim, base, fallback, 4.1);
 }
 
+/**
+ * Accent for the command bar's AI section. No theme ships a violet token, so the
+ * hue is fixed — that is the point, it has to read as "not one of your results"
+ * on monochrome palettes too — and only darkened or lightened until it clears
+ * the subtle-text contrast floor on both command bar surfaces.
+ */
+export function commandBarAccentText(palette: ThemeColors = colors): string {
+  const surfaces = [commandBarBg(palette), commandBarPanelBg(palette)] as const;
+  return blendForContrastOnSurfaces(
+    ASSIST_ACCENT,
+    surfaces,
+    higherContrast("#000000", "#ffffff", surfaces[0]),
+    3.6,
+  );
+}
+
 export function commandBarSelectedText(palette: ThemeColors = colors): string {
   const base = commandBarSelectedBg(palette);
   const preferred = higherContrast(palette.selectedText, palette.text, base);

package/src/theme/themes.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, test } from "bun:test";
 import {
   applyTheme,
+  commandBarAccentText,
   commandBarBg,
   commandBarHeadingText,
   commandBarPanelBg,
@@ -65,6 +66,8 @@ describe("theme contrast", () => {
       assertMinContrast(id, "commandBarText/bg", commandBarText(), commandBarBg(), BODY_TEXT_MIN);
       assertMinContrast(id, "commandBarHeadingText/bg", commandBarHeadingText(), commandBarBg(), SUBTLE_TEXT_MIN);
       assertMinContrast(id, "commandBarSubtleText/panel", commandBarSubtleText(), commandBarPanelBg(), SUBTLE_TEXT_MIN);
+      assertMinContrast(id, "commandBarAccentText/bg", commandBarAccentText(), commandBarBg(), SUBTLE_TEXT_MIN);
+      assertMinContrast(id, "commandBarAccentText/panel", commandBarAccentText(), commandBarPanelBg(), SUBTLE_TEXT_MIN);
       assertMinContrast(id, "commandBarSelectedText/selected", commandBarSelectedText(), commandBarSelectedBg(), BODY_TEXT_MIN);
     }
   });

package/src/{sources/gloomberb-cloud → time-series}/history-quality.ts

@@ -1,5 +1,5 @@
-import type { PricePoint } from "../../types/financials";
-import { getPricePointTimestamp } from "../../utils/price-history";
+import type { PricePoint } from "../types/financials";
+import { getPricePointTimestamp } from "../utils/price-history";
 
 const MAX_NEIGHBOR_GAP_MS = 60 * 60 * 1000;
 const STABLE_NEIGHBOR_CLOSE_RATIO = 0.01;
@@ -34,7 +34,7 @@ function isIsolatedOhlcOutlier(
   ));
 }
 
-export function hasMalformedCloudIntradayHistory(points: readonly PricePoint[]): boolean {
+export function hasMalformedIntradayHistory(points: readonly PricePoint[]): boolean {
   for (let index = 1; index < points.length - 1; index += 1) {
     if (isIsolatedOhlcOutlier(points[index - 1]!, points[index]!, points[index + 1]!)) {
       return true;
@@ -42,3 +42,27 @@ export function hasMalformedCloudIntradayHistory(points: readonly PricePoint[]):
   }
   return false;
 }
+
+export function repairIsolatedIntradayOhlcOutliers(
+  points: readonly PricePoint[],
+): PricePoint[] {
+  return points.map((point, index) => {
+    const previous = points[index - 1];
+    const next = points[index + 1];
+    if (!previous || !next || !isIsolatedOhlcOutlier(previous, point, next)) return point;
+
+    const isOutlier = (value: number | undefined) => (
+      typeof value === "number"
+      && Number.isFinite(value)
+      && relativeDifference(value, point.close) > ISOLATED_OHLC_OUTLIER_RATIO
+    );
+    const open = isOutlier(point.open) ? previous.close : point.open;
+    const bodyOpen = open ?? point.close;
+    return {
+      ...point,
+      open,
+      high: isOutlier(point.high) ? Math.max(bodyOpen, point.close) : point.high,
+      low: isOutlier(point.low) ? Math.min(bodyOpen, point.close) : point.low,
+    };
+  });
+}

package/src/time-series/resolution.test.ts

@@ -4,10 +4,12 @@ import {
   getBestSupportedResolutionForVisibleWindow,
   getExpandedBufferRange,
   getPresetResolution,
+  getSupportedChartResolutionsForViewport,
   isRangePresetSupported,
   normalizeChartResolution,
   sortChartResolutions,
 } from "./resolution";
+import { TIME_RANGES } from "./range";
 
 describe("chart-resolution", () => {
   test("maps range presets to their default manual resolutions", () => {
@@ -79,4 +81,53 @@ describe("chart-resolution", () => {
 
     expect(CHART_RESOLUTION_STEP_MS["1h"]).toBe(60 * 60_000);
   });
+
+  test("exposes only intervals that can cover and chart the authored viewport", () => {
+    const support = [
+      { resolution: "1m", maxRange: "1W" },
+      { resolution: "15m", maxRange: "3M" },
+      { resolution: "30m", maxRange: "6M" },
+      { resolution: "1h", maxRange: "1Y" },
+      { resolution: "1d", maxRange: "ALL" },
+    ] as const;
+
+    expect(getSupportedChartResolutionsForViewport("1M", support))
+      .toEqual(["15m", "30m", "1h", "1d"]);
+    expect(getSupportedChartResolutionsForViewport("1Y", support))
+      .toEqual(["1h", "1d"]);
+    expect(getSupportedChartResolutionsForViewport("1M", support, {
+      start: "2024-01-01",
+      end: "2026-01-01",
+    })).toEqual(["1d"]);
+  });
+
+  test("hides intervals too coarse to form a chart for the selected range", () => {
+    const support = (Object.keys(CHART_RESOLUTION_STEP_MS) as Array<
+      keyof typeof CHART_RESOLUTION_STEP_MS
+    >).map((resolution) => ({ resolution, maxRange: "ALL" as const }));
+
+    expect(getSupportedChartResolutionsForViewport("1D", support))
+      .toEqual(["1m", "5m", "15m", "30m", "45m", "1h"]);
+    expect(getSupportedChartResolutionsForViewport("1W", support))
+      .toEqual(["1m", "5m", "15m", "30m", "45m", "1h", "1d"]);
+    expect(getSupportedChartResolutionsForViewport("1M", support))
+      .toEqual(["1m", "5m", "15m", "30m", "45m", "1h", "1d", "1wk"]);
+    expect(getSupportedChartResolutionsForViewport("3M", support))
+      .toEqual(Object.keys(CHART_RESOLUTION_STEP_MS));
+  });
+
+  test("evaluates every range and resolution capability boundary", () => {
+    const resolutions = ["1m", "5m", "15m", "30m", "45m", "1h"] as const;
+    const support = resolutions.map((resolution, index) => ({
+      resolution,
+      maxRange: TIME_RANGES[Math.min(index, TIME_RANGES.length - 1)]!,
+    }));
+
+    for (const [rangeIndex, range] of TIME_RANGES.entries()) {
+      const available = new Set(getSupportedChartResolutionsForViewport(range, support));
+      for (const [resolutionIndex, resolution] of resolutions.entries()) {
+        expect(available.has(resolution)).toBe(rangeIndex <= resolutionIndex);
+      }
+    }
+  });
 });