gloomberb 0.10.0 → 0.10.2

package/src/theme/colors.test.ts

@@ -3,6 +3,7 @@ import {
   applyTheme,
   clearTransientThemePreview,
   getCurrentThemeId,
+  getThemeColors,
   previewTheme,
   syncTheme,
 } from "./colors";
@@ -43,6 +44,15 @@ afterEach(() => {
 });
 
 describe("theme colors", () => {
+  test("provides immutable palette snapshots while the compatibility facade follows the active theme", () => {
+    const amber = getThemeColors(DEFAULT_THEME);
+    const midnight = getThemeColors("midnight");
+
+    expect(Object.isFrozen(amber)).toBe(true);
+    expect(Object.isFrozen(midnight)).toBe(true);
+    expect(amber).not.toBe(midnight);
+  });
+
   test("syncs CSS variables when a theme is applied", () => {
     const values = installDocumentStyleMock();
     const theme = getTheme("midnight");

package/src/theme/colors.ts

@@ -1,9 +1,24 @@
 import { blendForContrast, blendHex, higherContrast } from "./color-utils";
 import { getTheme, DEFAULT_THEME, type Theme } from "./themes";
 
-// Mutable colors object — properties are updated in-place when the theme changes.
-// React components re-read these on each render triggered by the SET_THEME action.
-export const colors: Omit<Theme, "name" | "description"> = { ...getTheme(DEFAULT_THEME) };
+export type ThemeColors = Readonly<Omit<Theme, "name" | "description">>;
+
+export function getThemeColors(id: string): ThemeColors {
+  const { name: _name, description: _description, ...palette } = getTheme(id);
+  return Object.freeze(palette);
+}
+
+let currentColors = getThemeColors(DEFAULT_THEME);
+
+/** Compatibility facade for non-React formatting and rendering helpers. */
+export const colors = new Proxy({ ...currentColors } as ThemeColors, {
+  get: (_target, property) => currentColors[property as keyof ThemeColors],
+  getOwnPropertyDescriptor: (_target, property) => ({
+    configurable: true,
+    enumerable: true,
+    value: currentColors[property as keyof ThemeColors],
+  }),
+}) as ThemeColors;
 
 type ColorKey = keyof typeof colors;
 
@@ -38,10 +53,8 @@ export function getCurrentThemeId(): string {
 }
 
 export function applyTheme(id: string): void {
-  const theme = getTheme(id);
   currentThemeId = id;
-  // Mutate in-place so every existing import sees the new values
-  Object.assign(colors, theme);
+  currentColors = getThemeColors(id);
   syncThemeCssVariables();
 }
 
@@ -73,22 +86,6 @@ export function syncTheme(id: string): void {
 
 export { blendHex } from "./color-utils";
 
-export function getComparisonSeriesColor(index: number): string {
-  const seriesColors = [
-    colors.borderFocused,
-    colors.warning,
-    colors.positive,
-    colors.negative,
-    colors.textBright,
-    colors.neutral,
-    blendHex(colors.borderFocused, colors.positive, 0.45),
-    blendHex(colors.warning, colors.negative, 0.35),
-    blendHex(colors.textBright, colors.positive, 0.35),
-    blendHex(colors.borderFocused, colors.negative, 0.35),
-  ];
-  return seriesColors[((index % seriesColors.length) + seriesColors.length) % seriesColors.length]!;
-}
-
 export function getChartIndicatorColor(index: number): string {
   const accent = higherContrast(colors.warning, colors.borderFocused, colors.bg);
   const indicatorColors = [
@@ -112,8 +109,8 @@ export function getChartIndicatorColor(index: number): string {
 }
 
 /** Returns a hover background color derived from bg and selected */
-export function hoverBg(): string {
-  return blendHex(colors.bg, colors.selected, 0.5);
+export function hoverBg(palette: ThemeColors = colors): string {
+  return blendHex(palette.bg, palette.selected, 0.5);
 }
 
 function syncThemeCssVariables(): void {
@@ -126,62 +123,62 @@ function syncThemeCssVariables(): void {
   cssThemeId = currentThemeId;
   cssThemeDocument = documentLike;
   for (const [key, name] of THEME_CSS_VARIABLES) {
-    style.setProperty(name, colors[key]);
+    style.setProperty(name, currentColors[key]);
   }
   style.setProperty("--gloom-hover-bg", hoverBg());
 }
 
-export function commandBarBg(): string {
-  const base = higherContrast(colors.commandBg, colors.panel, colors.bg);
-  const accent = higherContrast(colors.textBright, colors.borderFocused, base);
-  return blendForContrast(base, colors.bg, accent, 1.45);
+export function commandBarBg(palette: ThemeColors = colors): string {
+  const base = higherContrast(palette.commandBg, palette.panel, palette.bg);
+  const accent = higherContrast(palette.textBright, palette.borderFocused, base);
+  return blendForContrast(base, palette.bg, accent, 1.45);
 }
 
-export function commandBarPanelBg(): string {
-  return blendHex(commandBarBg(), colors.panel, 0.28);
+export function commandBarPanelBg(palette: ThemeColors = colors): string {
+  return blendHex(commandBarBg(palette), palette.panel, 0.28);
 }
 
-export function commandBarInputBg(): string {
-  return blendHex(commandBarPanelBg(), colors.bg, 0.22);
+export function commandBarInputBg(palette: ThemeColors = colors): string {
+  return blendHex(commandBarPanelBg(palette), palette.bg, 0.22);
 }
 
-export function commandBarSelectedBg(): string {
-  const base = commandBarBg();
-  const accent = higherContrast(colors.selectedText, colors.textBright, colors.selected);
-  return blendForContrast(colors.selected, base, accent, 1.45);
+export function commandBarSelectedBg(palette: ThemeColors = colors): string {
+  const base = commandBarBg(palette);
+  const accent = higherContrast(palette.selectedText, palette.textBright, palette.selected);
+  return blendForContrast(palette.selected, base, accent, 1.45);
 }
 
-export function commandBarHoverBg(): string {
-  return blendHex(commandBarBg(), commandBarSelectedBg(), 0.45);
+export function commandBarHoverBg(palette: ThemeColors = colors): string {
+  return blendHex(commandBarBg(palette), commandBarSelectedBg(palette), 0.45);
 }
 
-export function commandBarText(): string {
-  const base = commandBarBg();
-  const fallback = higherContrast(colors.textBright, "#f2f2f2", base);
-  return blendForContrast(colors.text, base, fallback, 5.4);
+export function commandBarText(palette: ThemeColors = colors): string {
+  const base = commandBarBg(palette);
+  const fallback = higherContrast(palette.textBright, "#f2f2f2", base);
+  return blendForContrast(palette.text, base, fallback, 5.4);
 }
 
-export function commandBarHeadingText(): string {
-  const base = commandBarBg();
+export function commandBarHeadingText(palette: ThemeColors = colors): string {
+  const base = commandBarBg(palette);
   const fallback = higherContrast(
-    higherContrast(colors.textDim, colors.text, base),
-    higherContrast(colors.textBright, colors.selectedText, base),
+    higherContrast(palette.textDim, palette.text, base),
+    higherContrast(palette.textBright, palette.selectedText, base),
     base,
   );
-  return blendForContrast(colors.textMuted, base, fallback, 3.6);
+  return blendForContrast(palette.textMuted, base, fallback, 3.6);
 }
 
-export function commandBarSubtleText(): string {
-  const base = commandBarBg();
-  const fallback = higherContrast(commandBarText(), "#d8d8d8", base);
-  return blendForContrast(colors.textDim, base, fallback, 4.1);
+export function commandBarSubtleText(palette: ThemeColors = colors): string {
+  const base = commandBarBg(palette);
+  const fallback = higherContrast(commandBarText(palette), "#d8d8d8", base);
+  return blendForContrast(palette.textDim, base, fallback, 4.1);
 }
 
-export function commandBarSelectedText(): string {
-  const base = commandBarSelectedBg();
-  const preferred = higherContrast(colors.selectedText, colors.text, base);
+export function commandBarSelectedText(palette: ThemeColors = colors): string {
+  const base = commandBarSelectedBg(palette);
+  const preferred = higherContrast(palette.selectedText, palette.text, base);
   const fallback = higherContrast(
-    higherContrast(colors.textBright, colors.text, base),
+    higherContrast(palette.textBright, palette.text, base),
     higherContrast("#ffffff", "#000000", base),
     base,
   );
@@ -189,44 +186,44 @@ export function commandBarSelectedText(): string {
 }
 
 /** Background for docked pane bodies */
-export function paneBg(focused: boolean): string {
-  if (focused) return blendHex(colors.bg, colors.borderFocused, 0.06);
-  return blendHex(colors.panel, colors.border, 0.08);
+export function paneBg(focused: boolean, palette: ThemeColors = colors): string {
+  if (focused) return blendHex(palette.bg, palette.borderFocused, 0.06);
+  return blendHex(palette.panel, palette.border, 0.08);
 }
 
 /** Background for floating pane bodies — elevated above docked panes */
-export function floatingPaneBg(focused: boolean): string {
-  if (focused) return blendHex(colors.bg, colors.borderFocused, 0.08);
-  return blendHex(colors.panel, colors.border, 0.18);
+export function floatingPaneBg(focused: boolean, palette: ThemeColors = colors): string {
+  if (focused) return blendHex(palette.bg, palette.borderFocused, 0.08);
+  return blendHex(palette.panel, palette.border, 0.18);
 }
 
 /** Background for pane title bars */
-export function paneTitleBg(focused: boolean): string {
-  if (focused) return blendHex(colors.bg, colors.borderFocused, 0.22);
-  return blendHex(colors.panel, colors.border, 0.15);
+export function paneTitleBg(focused: boolean, palette: ThemeColors = colors): string {
+  if (focused) return blendHex(palette.bg, palette.borderFocused, 0.22);
+  return blendHex(palette.panel, palette.border, 0.15);
 }
 
 /** Background for floating pane title bars */
-export function floatingPaneTitleBg(focused: boolean): string {
-  if (focused) return blendHex(colors.bg, colors.borderFocused, 0.25);
-  return blendHex(colors.panel, colors.border, 0.25);
+export function floatingPaneTitleBg(focused: boolean, palette: ThemeColors = colors): string {
+  if (focused) return blendHex(palette.bg, palette.borderFocused, 0.25);
+  return blendHex(palette.panel, palette.border, 0.25);
 }
 
 /** Title text color for panes */
-export function paneTitleText(focused: boolean, floating = false): string {
-  const background = floating ? floatingPaneTitleBg(focused) : paneTitleBg(focused);
+export function paneTitleText(focused: boolean, floating = false, palette: ThemeColors = colors): string {
+  const background = floating ? floatingPaneTitleBg(focused, palette) : paneTitleBg(focused, palette);
   const preferred = focused
-    ? higherContrast(colors.textBright, colors.headerText, background)
-    : colors.textDim;
+    ? higherContrast(palette.textBright, palette.headerText, background)
+    : palette.textDim;
   const fallback = focused
-    ? higherContrast(colors.text, "#f2f2f2", background)
-    : higherContrast(colors.text, colors.textBright, background);
+    ? higherContrast(palette.text, "#f2f2f2", background)
+    : higherContrast(palette.text, palette.textBright, background);
   return blendForContrast(preferred, background, fallback, focused ? 5.2 : 4.5);
 }
 
 /** Returns green for positive, red for negative, neutral for zero */
-export function priceColor(value: number): string {
-  if (value > 0) return colors.positive;
-  if (value < 0) return colors.negative;
-  return colors.neutral;
+export function priceColor(value: number, palette: ThemeColors = colors): string {
+  if (value > 0) return palette.positive;
+  if (value < 0) return palette.negative;
+  return palette.neutral;
 }

package/src/theme/theme-context.test.tsx

@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { createTestRenderer } from "@opentui/core/testing";
+import { act } from "react";
+import { createOpenTuiTestRoot as createRoot } from "../renderers/opentui/test-utils";
+import { commandBarBg, getThemeColors, paneBg, syncTheme } from "./colors";
+import { ThemeProvider, useThemeColors } from "./theme-context";
+import { DEFAULT_THEME } from "./themes";
+
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
+let root: ReturnType<typeof createRoot> | undefined;
+const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+
+function ThemeProbe() {
+  const colors = useThemeColors();
+  return <text>{`${colors.bg}|${commandBarBg(colors)}|${paneBg(true, colors)}`}</text>;
+}
+
+afterEach(async () => {
+  if (root) {
+    await act(async () => {
+      root?.unmount();
+      await Promise.resolve();
+    });
+    root = undefined;
+  }
+  testSetup?.renderer.destroy();
+  testSetup = undefined;
+  syncTheme(DEFAULT_THEME);
+});
+
+describe("ThemeProvider", () => {
+  test("render helpers switch with the context palette in the same render", async () => {
+    testSetup = await createTestRenderer({ width: 120, height: 2 });
+    root = createRoot(testSetup.renderer);
+
+    act(() => {
+      root?.render(
+        <ThemeProvider themeId={DEFAULT_THEME}>
+          <ThemeProbe />
+        </ThemeProvider>,
+      );
+    });
+    await act(async () => {
+      await testSetup?.renderOnce();
+      await testSetup?.renderOnce();
+    });
+
+    const nextThemeId = "midnight";
+    const nextColors = getThemeColors(nextThemeId);
+    act(() => {
+      root?.render(
+        <ThemeProvider themeId={nextThemeId}>
+          <ThemeProbe />
+        </ThemeProvider>,
+      );
+    });
+    await act(async () => {
+      await testSetup?.renderOnce();
+      await testSetup?.renderOnce();
+    });
+
+    expect(testSetup.captureCharFrame()).toContain(
+      `${nextColors.bg}|${commandBarBg(nextColors)}|${paneBg(true, nextColors)}`,
+    );
+  });
+});

package/src/theme/theme-context.tsx

@@ -1,8 +1,11 @@
 import { createContext, useContext, useMemo, type ReactNode } from "react";
-import { colors, getCurrentThemeId, syncTheme } from "./colors";
-import type { Theme } from "./themes";
-
-type ThemeColors = Omit<Theme, "name" | "description">;
+import {
+  colors,
+  getCurrentThemeId,
+  getThemeColors,
+  syncTheme,
+  type ThemeColors,
+} from "./colors";
 
 interface ThemeContextValue {
   themeId: string;
@@ -13,7 +16,8 @@ const ThemeContext = createContext<ThemeContextValue | null>(null);
 
 export function ThemeProvider({ themeId, children }: { themeId: string; children: ReactNode }) {
   syncTheme(themeId);
-  const value = useMemo(() => ({ themeId, colors }), [themeId]);
+  const themeColors = useMemo(() => getThemeColors(themeId), [themeId]);
+  const value = useMemo(() => ({ themeId, colors: themeColors }), [themeColors, themeId]);
   return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
 }
 

package/src/tickers/open-target.ts

@@ -1,4 +1,4 @@
-import type { TickerRepository } from "../data/ticker-repository";
+import type { AppTickerRepositoryPort } from "../core/app-service-ports";
 import type { SearchRequestContext, DataProvider } from "../types/data-provider";
 import type { TickerRecord } from "../types/ticker";
 import {
@@ -21,7 +21,7 @@ export async function resolveTickerOpenTarget({
   query: string;
   tickers: ReadonlyMap<string, TickerRecord>;
   dataProvider: DataProvider;
-  tickerRepository: TickerRepository;
+  tickerRepository: AppTickerRepositoryPort;
   searchContext?: SearchRequestContext;
 }): Promise<TickerOpenTarget | null> {
   const symbol = normalizeTickerInput(null, query);

package/src/tickers/search/upsert.ts

@@ -1,6 +1,6 @@
 import type { InstrumentSearchResult } from "../../types/instrument";
 import type { TickerRecord, TickerMetadata } from "../../types/ticker";
-import type { TickerRepository } from "../../data/ticker-repository";
+import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import {
   classifyInstrumentKind,
 } from "./ranking";
@@ -10,7 +10,7 @@ import {
 } from "./result";
 
 export async function upsertTickerFromSearchResult(
-  tickerRepository: TickerRepository,
+  tickerRepository: AppTickerRepositoryPort,
   result: InstrumentSearchResult,
 ): Promise<{ ticker: TickerRecord; created: boolean }> {
   const symbol = getSearchResultSymbol(result);

package/src/time-series/alignment.ts

@@ -127,13 +127,6 @@ export function alignTimeSeries(
   return rows;
 }
 
-export function firstCommonValueDate(series: readonly ResolvedSeries[]): Date | null {
-  const row = alignTimeSeries(series, { mode: "intersection" }).find((entry) => (
-    series.every(({ id }) => finiteNumber(entry.values[id]?.value))
-  ));
-  return row ? new Date(row.date) : null;
-}
-
 /** Returns visible points and optionally the prior step anchor needed to draw continuity. */
 export function clipSeriesToWindow(
   series: ResolvedSeries,

package/src/time-series/chart-data.ts

@@ -0,0 +1,145 @@
+import type { PricePoint, Quote } from "../types/financials";
+import { isQuoteStaleForCurrentSession } from "../market-data/quotes/freshness";
+import { hasLikelyQuoteUnitMismatch } from "../utils/currency-units";
+import {
+  CHART_RESOLUTION_STEP_MS,
+  type ManualChartResolution,
+} from "./resolution";
+
+const MAX_LIVE_QUOTE_TAIL_AGE_MS = 7 * 24 * 60 * 60_000;
+const MAX_LIVE_QUOTE_CLOCK_SKEW_MS = 5 * 60_000;
+const MAX_INTRADAY_BAR_INTERVAL_MS = 6 * 60 * 60_000;
+const MIN_LIVE_QUOTE_TAIL_GAP_MS = 5 * 60_000;
+
+export type AppendLiveQuotePointOptions =
+  | {
+    now?: number;
+    mode?: "scalar";
+  }
+  | {
+    now?: number;
+    mode: "ohlc";
+    resolution: ManualChartResolution;
+  };
+
+function coerceDate(value: Date | string | number): Date {
+  return value instanceof Date ? value : new Date(value);
+}
+
+function getPointTime(point: Pick<PricePoint, "date">): number {
+  return coerceDate(point.date as Date | string | number).getTime();
+}
+
+function getActiveQuotePrice(quote: Quote): number {
+  if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
+    return quote.preMarketPrice;
+  }
+  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice != null) {
+    return quote.postMarketPrice;
+  }
+  return quote.price;
+}
+
+function quoteBelongsToLatestBar(
+  latestTime: number,
+  quoteTime: number,
+  resolution: ManualChartResolution,
+): boolean {
+  if (quoteTime < latestTime) return false;
+  if (resolution === "1mo") {
+    const latestDate = new Date(latestTime);
+    const quoteDate = new Date(quoteTime);
+    return latestDate.getUTCFullYear() === quoteDate.getUTCFullYear()
+      && latestDate.getUTCMonth() === quoteDate.getUTCMonth();
+  }
+  return quoteTime - latestTime < CHART_RESOLUTION_STEP_MS[resolution];
+}
+
+function finiteOrFallback(value: number | undefined, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function mergeQuoteIntoLatestBar(latest: PricePoint, quotePrice: number): PricePoint {
+  const open = finiteOrFallback(latest.open, latest.close);
+  const high = finiteOrFallback(latest.high, Math.max(open, latest.close));
+  const low = finiteOrFallback(latest.low, Math.min(open, latest.close));
+  return {
+    ...latest,
+    open,
+    high: Math.max(high, open, latest.close, quotePrice),
+    low: Math.min(low, open, latest.close, quotePrice),
+    close: quotePrice,
+  };
+}
+
+export function appendLiveQuotePoint(
+  points: PricePoint[],
+  quote: Quote | null | undefined,
+  options: AppendLiveQuotePointOptions = {},
+): PricePoint[] {
+  const now = options.now ?? Date.now();
+  if (!quote || isQuoteStaleForCurrentSession(quote, now)) return points;
+
+  const quoteTime = quote.lastUpdated;
+  const quotePrice = getActiveQuotePrice(quote);
+  if (
+    !Number.isFinite(quoteTime)
+    || !Number.isFinite(quotePrice)
+    || quotePrice <= 0
+    || quoteTime > now + MAX_LIVE_QUOTE_CLOCK_SKEW_MS
+    || now - quoteTime > MAX_LIVE_QUOTE_TAIL_AGE_MS
+  ) {
+    return points;
+  }
+
+  const latest = points.at(-1);
+  if (!latest) return points;
+
+  const latestTime = getPointTime(latest);
+  if (!Number.isFinite(latestTime) || quoteTime < latestTime) return points;
+
+  const previous = points.at(-2);
+  const latestInterval = previous ? latestTime - getPointTime(previous) : Number.NaN;
+  if (
+    latestInterval > 0
+    && latestInterval <= MAX_INTRADAY_BAR_INTERVAL_MS
+    && quoteTime - latestTime > Math.max(MIN_LIVE_QUOTE_TAIL_GAP_MS, latestInterval * 3)
+  ) {
+    return points;
+  }
+
+  const latestClose = latest.close;
+  if (hasLikelyQuoteUnitMismatch(
+    { currency: quote.currency, price: latestClose },
+    { currency: quote.currency, price: quotePrice },
+  )) {
+    return points;
+  }
+
+  if (options.mode === "ohlc") {
+    if (quoteBelongsToLatestBar(latestTime, quoteTime, options.resolution)) {
+      const merged = mergeQuoteIntoLatestBar(latest, quotePrice);
+      return [...points.slice(0, -1), merged];
+    }
+    return [
+      ...points,
+      {
+        date: new Date(quoteTime),
+        open: quotePrice,
+        high: quotePrice,
+        low: quotePrice,
+        close: quotePrice,
+      },
+    ];
+  }
+
+  if (quoteTime === latestTime) return points;
+
+  return [
+    ...points,
+    {
+      date: new Date(quoteTime),
+      close: quotePrice,
+    },
+  ];
+}

package/src/time-series/date-window.ts

@@ -0,0 +1,44 @@
+import { TIME_RANGES, type ChartDateWindow, type TimeRange } from "./range";
+
+export interface DateWindowRange extends ChartDateWindow {}
+
+export function subtractTimeRange(endDate: Date, range: TimeRange): Date {
+  const startDate = new Date(endDate);
+  switch (range) {
+    case "1D":
+      startDate.setDate(startDate.getDate() - 1);
+      break;
+    case "1W":
+      startDate.setDate(startDate.getDate() - 7);
+      break;
+    case "1M":
+      startDate.setMonth(startDate.getMonth() - 1);
+      break;
+    case "3M":
+      startDate.setMonth(startDate.getMonth() - 3);
+      break;
+    case "6M":
+      startDate.setMonth(startDate.getMonth() - 6);
+      break;
+    case "1Y":
+      startDate.setFullYear(startDate.getFullYear() - 1);
+      break;
+    case "5Y":
+      startDate.setFullYear(startDate.getFullYear() - 5);
+      break;
+    case "ALL":
+      startDate.setFullYear(startDate.getFullYear() - 50);
+      break;
+  }
+  return startDate;
+}
+
+export function isDateWindowWithinTimeRange(startDate: Date, endDate: Date, maxRange: TimeRange): boolean {
+  if (maxRange === "ALL") return true;
+  return startDate.getTime() >= subtractTimeRange(endDate, maxRange).getTime();
+}
+
+export function getTimeRangeForDateWindow(window: DateWindowRange | null): TimeRange {
+  if (!window?.start || !window.end) return "ALL";
+  return TIME_RANGES.find((candidate) => isDateWindowWithinTimeRange(window.start!, window.end!, candidate)) ?? "ALL";
+}

package/src/time-series/history-window.ts

@@ -0,0 +1,21 @@
+import { subtractTimeRange } from "./date-window";
+import type { TimeRange } from "./range";
+import type { PricePoint } from "../types/financials";
+import { getPricePointTimestamp } from "../utils/price-history";
+
+export function clipPriceHistoryToRange(points: PricePoint[], range: TimeRange): PricePoint[] {
+  if (range === "ALL" || points.length === 0) return points;
+  const dated = points.flatMap((point) => {
+    const timestamp = getPricePointTimestamp(point);
+    return Number.isFinite(timestamp) ? [{ point, timestamp }] : [];
+  });
+  const endTimestamp = dated.reduce<number | null>((latest, entry) => (
+    latest == null || entry.timestamp > latest ? entry.timestamp : latest
+  ), null);
+  if (endTimestamp == null) return [];
+  const end = new Date(endTimestamp);
+  const start = subtractTimeRange(end, range);
+  return dated
+    .filter(({ timestamp }) => timestamp >= start.getTime() && timestamp <= endTimestamp)
+    .map(({ point }) => point);
+}

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

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { buildComparisonChartPreset } from "../plugins/builtin/chart-composer/presets";
+import type { TickerRecord } from "../types/ticker";
+import { hydrateChartSpecInstruments } from "./hooks";
+
+function ticker(symbol: string, exchange: string): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange,
+      currency: "USD",
+      name: symbol,
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+describe("hydrateChartSpecInstruments", () => {
+  test("fills missing exchanges without replacing explicit chart identities", () => {
+    const initial = buildComparisonChartPreset(["SNDK", "SAP:XETR"]);
+    const spec = {
+      ...initial,
+      series: initial.series.map((entry, index) => (
+        index === 0 && entry.source.kind === "security"
+          ? {
+            ...entry,
+            source: {
+              ...entry.source,
+              instrument: { ...entry.source.instrument, exchange: "" },
+            },
+          }
+          : entry
+      )),
+    };
+
+    const hydrated = hydrateChartSpecInstruments(spec, new Map([
+      ["SNDK", ticker("SNDK", "NASDAQ")],
+      ["SAP", ticker("SAP", "JSE")],
+    ]));
+
+    expect(hydrated.series[0]?.source).toMatchObject({
+      kind: "security",
+      instrument: { symbol: "SNDK", exchange: "NASDAQ" },
+    });
+    expect(hydrated.series[1]?.source).toMatchObject({
+      kind: "security",
+      instrument: { symbol: "SAP", exchange: "XETRA" },
+    });
+    expect(spec.series[0]?.source).toMatchObject({
+      kind: "security",
+      instrument: { symbol: "SNDK", exchange: "" },
+    });
+    expect(hydrateChartSpecInstruments(hydrated, new Map())).toBe(hydrated);
+  });
+});