gloomberb 0.15.2 → 0.15.3

package/src/time-series/calendar-month-end-resolution.test.ts

@@ -1,106 +0,0 @@
-import { expect, test } from "bun:test";
-import { createTestDataProvider } from "../test-support/data-provider";
-import type { PricePoint } from "../types/financials";
-import { ChartResolveCache, resolveChartSpecData } from "./resolve";
-import type { ChartResolutionSupport, ManualChartResolution } from "./resolution";
-import type { ChartSpec } from "./types";
-
-const DAY = 86_400_000;
-const monthSupport: ChartResolutionSupport[] = [
-  { resolution: "15m", maxRange: "1M" }, { resolution: "1h", maxRange: "3M" },
-];
-function chart(start: string, end: string, resolution: ChartSpec["viewport"]["resolution"] = "15m"): ChartSpec {
-  return {
-    version: 2, viewport: { range: "1M", resolution, dateWindow: { start, end } },
-    panels: [{ id: "price" }], studies: [],
-    series: [{ id: "price", source: { kind: "security", instrument: { symbol: "TEST", exchange: "CCC" }, fieldId: "market.close" },
-      style: "line", transform: "raw", axis: "left", panelId: "price", interpolation: "none" }],
-  };
-}
-function providerFor(points: PricePoint[], support: ChartResolutionSupport[] | Promise<ChartResolutionSupport[]>) {
-  const requests: { start: string; end: string; resolution: ManualChartResolution }[] = [];
-  const provider = createTestDataProvider({
-    getChartResolutionSupport: () => support,
-    getQuoteMetadata: async (symbol, exchange) => ({ symbol, exchange, currency: "USD", instrumentType: "CRYPTOCURRENCY" }),
-    getDetailedPriceHistory: async (_symbol, _exchange, start, end, resolution) => {
-      requests.push({ start: start.toISOString(), end: end.toISOString(), resolution: resolution as ManualChartResolution });
-      return points.filter(point => point.date >= start && point.date < end);
-    },
-  });
-  return { requests, sources: { dataProvider: provider, now: new Date("2026-04-01T00:00:00Z"),
-    loadFredSeries: async () => { throw Error("Unexpected FRED request"); } } };
-}
-
-for (const boundary of [
-  { start: "2026-02-28", end: "2026-03-31", interval: "15m", expected: "15m", capStart: "2026-02-28T00:00:00.000Z", requestEnd: "2026-04-01T00:00:00.000Z" },
-  { start: "2026-02-28T15:45:12.345Z", end: "2026-03-31T15:45:12.345Z", interval: "15m", expected: "15m", capStart: "2026-02-28T15:45:12.345Z", requestEnd: "2026-03-31T15:45:12.346Z" },
-  { start: "2026-02-28T15:45:12.344Z", end: "2026-03-31T15:45:12.345Z", interval: "15m", expected: "1h" },
-  // An exact timestamp is not reduced to the authored calendar date for support.
-  { start: "2026-02-28T00:00:00.000Z", end: "2026-03-31T23:59:59.999Z", interval: "15m", expected: "1h" },
-  { start: "2023-02-28", end: "2024-02-29", interval: "1d", expected: "1d", capStart: "2023-02-28T00:00:00.000Z", requestEnd: "2024-03-01T00:00:00.000Z" },
-  { start: "2023-02-27T23:59:59.999Z", end: "2024-02-29T00:00:00.000Z", interval: "1d", expected: "1wk" },
-] as const) {
-  test(`clamped support preserves the exact boundary: ${boundary.start} to ${boundary.end}`, async () => {
-    const last = boundary.end.length === 10 ? `${boundary.end}T23:45:00.000Z` : boundary.end;
-    const points = [{ date: new Date(boundary.start), close: 100 }, { date: new Date(last), close: 120 }];
-    const support: ChartResolutionSupport[] = boundary.interval === "1d"
-      ? [{ resolution: "1d", maxRange: "1Y" }, { resolution: "1wk", maxRange: "5Y" }] : monthSupport;
-    const { requests, sources } = providerFor(points, support);
-    const spec = chart(boundary.start, boundary.end, boundary.interval);
-    if (boundary.interval === "1d") spec.viewport.range = "1Y";
-    const result = await resolveChartSpecData(spec, sources, undefined, { awaitResolutionSupport: true });
-    expect(result.errors).toEqual([]);
-    expect(result.resolution).toBe(boundary.expected);
-    expect(requests).toHaveLength(1);
-    expect(requests[0]?.resolution).toBe(boundary.expected);
-    expect(result.series[0]?.points.map(point => point.value)).toEqual([100, 120]);
-    if ("capStart" in boundary) {
-      expect(requests[0]).toEqual({ start: boundary.capStart, end: boundary.requestEnd, resolution: boundary.expected });
-      expect(result.warnings).toEqual([]);
-    } else {
-      expect(result.warnings.some(warning => warning.includes("data is unavailable for this range"))).toBe(true);
-    }
-  });
-}
-
-for (const cap of ["1M", "1W"] as const) {
-  test(`late source support uses the clamped month without extending a ${cap} cap`, async () => {
-    let settle!: (value: ChartResolutionSupport[]) => void;
-    const support = new Promise<ChartResolutionSupport[]>(resolve => { settle = resolve; });
-    const points = [{ date: new Date("2026-02-28"), close: 100 }, { date: new Date("2026-03-31"), close: 120 }];
-    const { requests, sources } = providerFor(points, support), cache = new ChartResolveCache();
-    const spec = chart("2026-02-28", "2026-03-31", "auto");
-    await resolveChartSpecData(spec, sources, cache);
-    settle([{ resolution: "15m", maxRange: cap }, { resolution: "1h", maxRange: "3M" }]);
-    await support;
-    requests.length = 0;
-    const settled = await resolveChartSpecData(spec, sources, cache, { awaitResolutionSupport: true });
-    const fresh = await resolveChartSpecData(spec, sources, undefined, { awaitResolutionSupport: true });
-    expect(settled.resolution).toBe(cap === "1M" ? "15m" : "1h");
-    expect(fresh.resolution).toBe(settled.resolution);
-    expect(settled.series).toEqual(fresh.series);
-    expect(settled.errors).toEqual([]);
-    expect(requests.length).toBeGreaterThan(0);
-    expect(requests.every(request => request.resolution === settled.resolution)).toBe(true);
-  });
-}
-
-for (const cap of ["3M", "1M"] as const) {
-  test(`month-end SMA uses earlier observations only within the source ${cap} cap`, async () => {
-    const points = Array.from({ length: 91 }, (_, index) => ({ date: new Date(Date.parse("2025-12-31") + index * DAY), close: 100 + index }));
-    const { requests, sources } = providerFor(points, [{ resolution: "1d", maxRange: cap }]);
-    const spec = chart("2026-02-28", "2026-03-31", "1d");
-    spec.studies = [{ id: "sma", kind: "sma", inputSeriesIds: ["price"], parameters: { period: 20 }, panelId: "price", axis: "left" }];
-    const result = await resolveChartSpecData(spec, sources, undefined, { awaitResolutionSupport: true });
-    expect(result.errors).toEqual([]);
-    expect(result.resolution).toBe("1d");
-    expect(requests).toEqual([{ start: cap === "3M" ? "2025-12-31T00:00:00.000Z" : "2026-02-28T00:00:00.000Z",
-      end: "2026-04-01T00:00:00.000Z", resolution: "1d" }]);
-    expect(result.series.find(series => series.id === "price")?.points[0]?.date.toISOString()).toBe("2026-02-28T00:00:00.000Z");
-    const sma = result.series.find(series => series.id === "sma")!;
-    const first = sma.points.find(point => typeof point.value === "number" && Number.isFinite(point.value))!;
-    expect(first.date.toISOString()).toBe(cap === "3M" ? "2026-02-28T00:00:00.000Z" : "2026-03-19T00:00:00.000Z");
-    expect(first.value).toBeCloseTo(cap === "3M" ? 149.5 : 168.5, 10);
-    if (cap === "1M") expect(sma.points.filter(point => point.date < first.date).every(point => point.value == null)).toBe(true);
-  });
-}

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

@@ -1,133 +0,0 @@
-import { expect, test } from "bun:test";
-import { createSnapshotDataProvider } from "../market-data/snapshot-provider";
-import { buildComparisonChartPreset } from "../plugins/builtin/chart-composer/presets";
-import { loadChartPaneModel } from "../plugins/builtin/chart-composer/headless";
-import { parseChartSpec, serializeChartSpec } from "../plugins/builtin/chart-composer/chart-spec";
-import { createTestDataProvider } from "../test-support/data-provider";
-import { createDefaultConfig } from "../types/config";
-import type { HeadlessPaneContext } from "../types/headless";
-import { ChartResolveCache, resolveChartSpecData } from "./resolve";
-import type { ChartResolutionSupport } from "./resolution";
-
-const history = Array.from({ length: 368 }, (_, index) => ({
-  date: new Date(Date.UTC(2025, 8, 14 + index)), close: 100 + index,
-}));
-const context = (marketData: HeadlessPaneContext["marketData"]): HeadlessPaneContext => ({
-  marketData, apiClient: {} as HeadlessPaneContext["apiClient"],
-  config: createDefaultConfig("/tmp/gloom-calendar-window"), signal: new AbortController().signal,
-});
-const noLive = createTestDataProvider({
-  getQuote: async () => { throw Error("Unexpected live quote"); },
-  getTickerFinancials: async () => { throw Error("Unexpected live financials"); },
-  getDetailedPriceHistory: async () => { throw Error("Unexpected live history"); },
-});
-
-for (const start of ["2026-08-15", "2025-09-16", "2025-09-15"]) {
-  test(`date-only daily window ${start} retains both endpoints and snapshot cadence`, async () => {
-    const requests: Array<{ start: string; end: string; resolution: string }> = [];
-    const provider = createTestDataProvider({
-      getChartResolutionSupport: () => [{ resolution: "1d", maxRange: "1Y" }, { resolution: "1wk", maxRange: "5Y" }],
-      getQuoteMetadata: async (symbol, exchange) => ({ symbol, exchange, currency: "USD", instrumentType: "EQUITY" }),
-      getDetailedPriceHistory: async (_symbol, _exchange, from, to, resolution) => {
-        requests.push({ start: from.toISOString(), end: to.toISOString(), resolution });
-        return history.filter(point => point.date >= from && point.date < to);
-      },
-    });
-    const spec = buildComparisonChartPreset(["AAA:XNAS", "BBB:XTSE"]);
-    spec.viewport = { range: "1Y", resolution: "1d", dateWindow: { start, end: "2026-09-15" } };
-    const reopened = parseChartSpec(serializeChartSpec(spec))!;
-    expect(reopened.viewport.resolution).toBe("1d");
-    const model = await loadChartPaneModel(reopened, context(provider));
-    expect(model.chart.resolution).toBe("1d");
-    expect(model.errors).toEqual([]);
-    expect(requests).toHaveLength(2);
-    for (const request of requests) {
-      expect(request.end).toBe("2026-09-16T00:00:00.000Z");
-      expect(request.resolution).toBe("1d");
-      expect(Date.parse(request.start)).toBeLessThanOrEqual(Date.parse(start));
-      if (start === "2025-09-15") expect(request.start).toBe("2025-09-15T00:00:00.000Z");
-    }
-    for (const series of model.series) {
-      expect(series.points[0]?.date.toISOString().slice(0, 10)).toBe(start);
-      expect(series.points.at(-1)?.date.toISOString()).toBe("2026-09-15T00:00:00.000Z");
-    }
-    const snapshot = JSON.parse(JSON.stringify(model.snapshot), (_key, value) =>
-      value && typeof value === "object" && typeof value.date === "string" ? { ...value, date: new Date(value.date) } : value);
-    const replay = await loadChartPaneModel(reopened, context(createSnapshotDataProvider(snapshot, noLive)));
-    expect(replay.chart.resolution).toBe("1d");
-    expect(replay.series).toEqual(model.series);
-    expect(replay.metadata?.priceComparison).toEqual(model.metadata?.priceComparison);
-  });
-}
-
-for (const dateWindow of [
-  { start: "2025-09-14", end: "2026-09-15" },
-  { start: "2025-09-15T00:00:00.000Z", end: "2026-09-15T00:00:00.001Z" },
-]) {
-  test(`a longer window still exceeds daily support: ${dateWindow.start} to ${dateWindow.end}`, async () => {
-    const spec = buildComparisonChartPreset(["AAA:XNAS", "BBB:XTSE"]);
-    spec.viewport = { range: "1Y", resolution: "1d", dateWindow };
-    const provider = createTestDataProvider({
-      getChartResolutionSupport: () => [{ resolution: "1d", maxRange: "1Y" }, { resolution: "1wk", maxRange: "5Y" }],
-      getDetailedPriceHistory: async () => history,
-    });
-    const model = await loadChartPaneModel(spec, context(provider));
-    expect(model.chart.resolution).toBe("1wk");
-    expect(model.chart.warnings).toContain("1D data is unavailable for this range. Auto resolution was used instead.");
-  });
-}
-
-test("ordinary trailing one-year daily snapshots keep their existing range semantics", async () => {
-  const spec = buildComparisonChartPreset(["AAA:XNAS", "BBB:XTSE"]);
-  spec.viewport = { range: "1Y", resolution: "1d" };
-  const provider = createSnapshotDataProvider({ financials: ["AAA:XNAS", "BBB:XTSE"].map(key => [key, {
-    annualStatements: [], quarterlyStatements: [], priceHistory: history.slice(0, -1),
-  }]) }, noLive);
-  const model = await resolveChartSpecData(spec, {
-    dataProvider: provider, now: new Date("2026-09-15T00:00:00Z"), loadFredSeries: async () => { throw Error("Unexpected FRED call"); },
-  });
-  expect(model.resolution).toBe("1d");
-  expect(model.priceComparison?.start).toBe(Date.parse("2025-09-15"));
-  expect(model.priceComparison?.end).toBe(Date.parse("2026-09-15"));
-});
-
-for (const resolution of ["auto", "1d"] as const) for (const dailyMax of ["1Y", "6M"] as const) {
-  test(`${resolution} calendar windows adopt delayed ${dailyMax} daily support without extending its cap`, async () => {
-    let settle!: (support: ChartResolutionSupport[]) => void;
-    const gate = new Promise<ChartResolutionSupport[]>(resolve => { settle = resolve; });
-    const requests: string[] = [];
-    const provider = createTestDataProvider({
-      getChartResolutionSupport: () => gate,
-      getDetailedPriceHistory: async (_symbol, _exchange, start, end, selected) => {
-        requests.push(selected);
-        return history.filter(point => point.date >= start && point.date < end);
-      },
-    });
-    const spec = buildComparisonChartPreset(["AAA:XNAS", "BBB:XTSE"]);
-    spec.viewport = { range: "1Y", resolution, dateWindow: { start: "2025-09-15", end: "2026-09-15" } };
-    const cache = new ChartResolveCache();
-    const sources = { dataProvider: provider, now: new Date("2026-09-16"),
-      loadFredSeries: async () => { throw Error("Unexpected FRED call"); } };
-    const provisional = await resolveChartSpecData(spec, sources, cache);
-    expect(provisional.resolution).toBe("1d");
-    expect(provisional.errors).toEqual([]);
-    expect(requests).toEqual(["1d", "1d"]);
-
-    settle([{ resolution: "1d", maxRange: dailyMax }, { resolution: "1wk", maxRange: "5Y" }]);
-    await gate;
-    // The awaited pass and a fresh one-shot loader must agree on the real cap.
-    requests.length = 0;
-    const settled = await resolveChartSpecData(spec, sources, cache, { awaitResolutionSupport: true });
-    const oneShot = await loadChartPaneModel(spec, context(provider));
-    const expected = dailyMax === "1Y" ? "1d" : "1wk";
-    expect(settled.resolution).toBe(expected);
-    expect(oneShot.chart.resolution).toBe(expected);
-    expect(settled.errors).toEqual([]);
-    expect(oneShot.errors).toEqual([]);
-    expect(new Set(requests)).toEqual(new Set([expected]));
-    if (dailyMax === "1Y") {
-      expect(settled.priceComparison?.start).toBe(Date.parse("2025-09-15"));
-      expect(settled.priceComparison?.end).toBe(Date.parse("2026-09-15"));
-    }
-  });
-}

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

@@ -1,288 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { resetServerClockForTests, setForwardedServerClockOffset } from "../market-data/quotes/clock";
-import { appendLiveQuotePoint } from "./chart-data";
-import type { PricePoint, Quote } from "../types/financials";
-
-function quoteFixture(overrides: Partial<Quote> = {}): Quote {
-  return {
-    symbol: "INTC",
-    price: 129,
-    currency: "USD",
-    change: 0,
-    changePercent: 0,
-    lastUpdated: Date.parse("2026-05-15T19:30:00Z"),
-    listingExchangeName: "NASDAQ",
-    marketState: "REGULAR",
-    ...overrides,
-  };
-}
-
-describe("appendLiveQuotePoint", () => {
-  test("follows quotes from a server clock measured more than five minutes ahead", () => {
-    const now = Date.parse("2026-05-15T19:30:00Z");
-    const history: PricePoint[] = [
-      { date: new Date("2026-05-15T19:34:00Z"), close: 128 },
-      { date: new Date("2026-05-15T19:35:00Z"), close: 128.5 },
-    ];
-    const quote = quoteFixture({ lastUpdated: Date.parse("2026-05-15T19:36:00Z") });
-    try {
-      expect(appendLiveQuotePoint(history, quote, { now })).toBe(history);
-      setForwardedServerClockOffset(6 * 60_000);
-      expect(appendLiveQuotePoint(history, quote, { now }).at(-1)).toEqual({ date: new Date("2026-05-15T19:36:00Z"), close: 129 });
-    } finally {
-      resetServerClockForTests();
-    }
-  });
-
-  test("merges daily quote updates by session for date labels and opening timestamps", () => {
-    const now = Date.parse("2026-09-10T18:44:00Z");
-    const quote = quoteFixture({ price: 39.75, lastUpdated: now });
-    for (const date of ["2026-09-10T00:00:00Z", "2026-09-10T13:30:00Z"]) {
-      const history = [{ date: new Date(date), open: 40, high: 41, low: 39, close: 39.77, volume: 1000 }];
-      const updated = appendLiveQuotePoint(history, quote, { now, mode: "ohlc", resolution: "1d" });
-      expect(updated).toHaveLength(1);
-      expect(updated[0]).toMatchObject({ close: 39.75, open: 40, high: 41, low: 39, volume: 1000 });
-      expect(history[0]?.close).toBe(39.77);
-    }
-  });
-
-  test("does not merge the next premarket into yesterday's daily bar within 24 hours", () => {
-    const now = Date.parse("2026-09-11T12:00:00Z");
-    const history = [{ date: new Date("2026-09-10T13:30:00Z"), close: 100 }];
-    const updated = appendLiveQuotePoint(history, quoteFixture({
-      price: 100, preMarketPrice: 105, marketState: "PRE", lastUpdated: now,
-    }), { now, mode: "ohlc", resolution: "1d" });
-    expect(updated).toHaveLength(2);
-    expect(updated[0]?.close).toBe(100);
-    expect(updated[1]?.close).toBe(105);
-  });
-
-  test("keeps an after-hours quote in its exchange session across UTC midnight", () => {
-    const now = Date.parse("2026-09-11T00:01:00Z");
-    const updated = appendLiveQuotePoint([{ date: new Date("2026-09-10T00:00:00Z"), close: 100 }],
-      quoteFixture({ price: 100, postMarketPrice: 105, marketState: "POST", lastUpdated: now - 60_000 }),
-      { now, mode: "ohlc", resolution: "1d" });
-    expect(updated).toHaveLength(1);
-    expect(updated[0]?.close).toBe(105);
-  });
-
-  test("merges a quote into a London-dated FX bar that opened at 23:00 UTC", () => {
-    const now = Date.parse("2026-09-17T23:30:00Z");
-    const quote = quoteFixture({
-      symbol: "EURUSD=X", price: 1.149, lastUpdated: now - 60_000,
-      listingExchangeName: "CCY", exchangeName: "CCY",
-    });
-    const history: PricePoint[] = [
-      { date: new Date("2026-09-17T00:00:00Z"), open: 1.146, high: 1.148, low: 1.145, close: 1.1476 },
-      { date: new Date("2026-09-18T00:00:00Z"), open: 1.1476, high: 1.1482, low: 1.1471, close: 1.148 },
-    ];
-    for (const resolution of ["1d", "1wk"] as const) {
-      const updated = appendLiveQuotePoint(history, quote, { now, mode: "ohlc", resolution });
-      expect(updated).toHaveLength(2);
-      expect(updated[1]).toMatchObject({ open: 1.1476, high: 1.149, low: 1.1471, close: 1.149 });
-    }
-    const scalar = appendLiveQuotePoint(history.map(({ date, close }) => ({ date, close })), quote, { now });
-    expect(scalar.map((point) => point.close)).toEqual([1.1476, 1.149]);
-    // Intraday bars never start in the future; an older quote stays out.
-    expect(appendLiveQuotePoint(history, quote, { now, mode: "ohlc", resolution: "1h" })).toBe(history);
-    expect(appendLiveQuotePoint(history, quote, { now: Date.parse("2026-09-18T00:30:00Z"), mode: "ohlc", resolution: "1d" }))
-      .toBe(history);
-  });
-
-  test("extends coarse chart histories with a fresh quote tail", () => {
-    const history: PricePoint[] = [
-      { date: new Date("2026-05-04T00:00:00Z"), close: 56 },
-      { date: new Date("2026-05-11T00:00:00Z"), close: 68 },
-    ];
-
-    const extended = appendLiveQuotePoint(
-      history,
-      quoteFixture(),
-      { now: Date.parse("2026-05-15T19:45:00Z") },
-    );
-
-    expect(extended).toHaveLength(3);
-    expect(extended.at(-1)).toEqual({
-      date: new Date("2026-05-15T19:30:00Z"),
-      close: 129,
-    });
-  });
-
-  test("merges a quote into the active OHLC bucket", () => {
-    const history: PricePoint[] = [
-      {
-        date: new Date("2026-05-15T19:25:00Z"),
-        open: 124,
-        high: 130,
-        low: 122,
-        close: 126,
-        volume: 1_000,
-      },
-    ];
-
-    const extended = appendLiveQuotePoint(
-      history,
-      quoteFixture({ lastUpdated: Date.parse("2026-05-15T19:29:00Z") }),
-      {
-        now: Date.parse("2026-05-15T19:30:00Z"),
-        mode: "ohlc",
-        resolution: "5m",
-      },
-    );
-
-    expect(extended).toHaveLength(1);
-    expect(extended[0]).toEqual({
-      date: new Date("2026-05-15T19:25:00Z"),
-      open: 124,
-      high: 130,
-      low: 122,
-      close: 129,
-      volume: 1_000,
-    });
-  });
-
-  test("seeds a new OHLC bucket from the live price instead of prior-bar extremes", () => {
-    const history: PricePoint[] = [
-      {
-        date: new Date("2026-05-15T19:25:00Z"),
-        open: 124,
-        high: 180,
-        low: 80,
-        close: 126,
-        volume: 1_000,
-      },
-    ];
-
-    const extended = appendLiveQuotePoint(
-      history,
-      quoteFixture({ lastUpdated: Date.parse("2026-05-15T19:30:00Z") }),
-      {
-        now: Date.parse("2026-05-15T19:31:00Z"),
-        mode: "ohlc",
-        resolution: "5m",
-      },
-    );
-
-    expect(extended).toHaveLength(2);
-    expect(extended[1]).toEqual({
-      date: new Date("2026-05-15T19:30:00Z"),
-      open: 129,
-      high: 129,
-      low: 129,
-      close: 129,
-    });
-  });
-
-  test("treats calendar-month bars as variable-length buckets", () => {
-    const history: PricePoint[] = [{
-      date: new Date("2026-01-01T00:00:00Z"),
-      open: 120,
-      high: 140,
-      low: 110,
-      close: 125,
-    }];
-
-    const endOfJanuary = appendLiveQuotePoint(
-      history,
-      quoteFixture({ lastUpdated: Date.parse("2026-01-31T20:30:00Z") }),
-      {
-        now: Date.parse("2026-01-31T20:31:00Z"),
-        mode: "ohlc",
-        resolution: "1mo",
-      },
-    );
-    const startOfFebruary = appendLiveQuotePoint(
-      history,
-      quoteFixture({ lastUpdated: Date.parse("2026-02-01T20:30:00Z") }),
-      {
-        now: Date.parse("2026-02-01T20:31:00Z"),
-        mode: "ohlc",
-        resolution: "1mo",
-      },
-    );
-
-    expect(endOfJanuary).toHaveLength(1);
-    expect(endOfJanuary[0]?.close).toBe(129);
-    expect(startOfFebruary).toHaveLength(2);
-    expect(startOfFebruary[1]).toMatchObject({
-      open: 129,
-      high: 129,
-      low: 129,
-      close: 129,
-    });
-  });
-
-  test("uses the active extended-hours price for the live tail", () => {
-    const history: PricePoint[] = [
-      { date: new Date("2026-05-15T19:30:00Z"), close: 128 },
-    ];
-
-    const extended = appendLiveQuotePoint(
-      history,
-      quoteFixture({
-        marketState: "POST",
-        postMarketPrice: 131,
-        lastUpdated: Date.parse("2026-05-15T21:10:00Z"),
-      }),
-      { now: Date.parse("2026-05-15T21:15:00Z") },
-    );
-
-    expect(extended.at(-1)?.close).toBe(131);
-  });
-
-  test("does not bridge a missing intraday history window with one synthetic candle", () => {
-    const history: PricePoint[] = [
-      { date: new Date("2026-07-22T14:49:00Z"), close: 347.73 },
-      { date: new Date("2026-07-22T14:50:00Z"), close: 347.76 },
-      { date: new Date("2026-07-22T14:51:00Z"), close: 347.68 },
-    ];
-
-    const extended = appendLiveQuotePoint(
-      history,
-      quoteFixture({
-        symbol: "GOOG",
-        price: 346.27,
-        lastUpdated: Date.parse("2026-07-22T18:52:00Z"),
-      }),
-      { now: Date.parse("2026-07-22T18:53:00Z") },
-    );
-
-    expect(extended).toBe(history);
-  });
-
-  test("does not append a live quote tail with a likely unit mismatch", () => {
-    const history: PricePoint[] = [
-      { date: new Date("2026-05-18T00:00:00Z"), close: 405 },
-      { date: new Date("2026-05-22T00:00:00Z"), close: 379 },
-    ];
-
-    const extended = appendLiveQuotePoint(
-      history,
-      quoteFixture({
-        symbol: "FTC",
-        currency: "GBP",
-        price: 3.79,
-        lastUpdated: Date.parse("2026-05-22T16:39:00Z"),
-      }),
-      { now: Date.parse("2026-05-22T16:45:00Z") },
-    );
-
-    expect(extended).toBe(history);
-  });
-
-  test("does not append stale quotes from an older active session", () => {
-    const history: PricePoint[] = [
-      { date: new Date("2026-05-11T00:00:00Z"), close: 68 },
-    ];
-
-    const extended = appendLiveQuotePoint(
-      history,
-      quoteFixture({
-        lastUpdated: Date.parse("2026-05-08T20:00:00Z"),
-      }),
-      { now: Date.parse("2026-05-15T15:00:00Z") },
-    );
-
-    expect(extended).toBe(history);
-  });
-});

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

@@ -1,113 +0,0 @@
-import { expect, test } from "bun:test";
-
-const replay = `
-import { createSnapshotDataProvider } from "../market-data/snapshot-provider.ts";
-import { createTestDataProvider } from "../test-support/data-provider.ts";
-import { historicalPricesHeadless } from "../plugins/builtin/ticker-detail/headless.ts";
-import { correlationHeadless } from "../plugins/builtin/correlation/headless.ts";
-import { createDefaultConfig } from "../types/config.ts";
-import { subtractTimeRange, isDateWindowWithinTimeRange } from "./date-window.ts";
-import { clipPriceHistoryToRange } from "./history-window.ts";
-import { buildPresetDateWindow } from "../components/chart/core/date-window.ts";
-import { buildPriceReturnFields } from "../market-data/performance.ts";
-import { apiClient } from "../api-client/index.ts";
-import { CloudDataApi } from "../api-client/data.ts";
-import { GloomberbCloudProvider } from "../sources/gloomberb-cloud/index.ts";
-import { setSystemTime } from "bun:test";
-
-let liveCalls = 0;
-const fallback = createTestDataProvider({ getPriceHistory: async () => { liveCalls++; throw new Error("Unexpected live history"); } });
-const symbols = ["BTC-USD:CCC", "ETH-USD:CCC"];
-const cases = [];
-for (const end of ["2026-04-03T00:00:00Z", "2025-11-03T00:00:00Z", "2026-09-22T00:00:00Z", "2026-03-31T00:00:00Z", "2024-03-31T00:00:00Z"]) {
-  setSystemTime(Date.parse(end));
-  const history = Array.from({ length: 40 }, (_, index) => ({ date: new Date(Date.parse(end) - (39 - index) * 86400000), close: 100 + index }));
-  const financials = symbols.map((symbol, asset) => [symbol, {
-    annualStatements: [], quarterlyStatements: [], priceHistoryResolution: "1d",
-    priceHistory: asset ? history.map((point, index) => ({ ...point, close: 200 + index * 2 + 3 * Math.sin(index / 3) })) : history,
-  }]);
-  const run = async (captured) => {
-    const context = { marketData: createSnapshotDataProvider({ financials: captured }, fallback),
-      config: createDefaultConfig(":memory:"), apiClient: {}, signal: new AbortController().signal };
-    const args = { argument: symbols[0], rawArgument: symbols[0], symbols: [symbols[0]], options: { range: "1M" } };
-    const prices = await historicalPricesHeadless.load(args, context);
-    const all = await historicalPricesHeadless.load({ ...args, options: { range: "ALL" } }, context);
-    const correlation = await correlationHeadless.load({ ...args, argument: symbols, symbols, options: { rangePreset: "1M" } }, context);
-    return { first: prices.rows[0].date, last: prices.rows.at(-1).date, rows: prices.rows.length, allRows: all.rows.length,
-      sampleSize: correlation.rows[0].sampleSize, correlation: correlation.rows[0].correlation,
-      errors: [...prices.errors ?? [], ...correlation.errors ?? []] };
-  };
-  const original = await run(financials);
-  const serialized = await run(JSON.parse(JSON.stringify(financials)));
-  const cloudRequests = [];
-  const transport = new CloudDataApi(async path => {
-    const url = new URL(path, "https://controlled.invalid");
-    cloudRequests.push({ symbol: url.searchParams.get("symbol"), exchange: url.searchParams.get("exchange"),
-      interval: url.searchParams.get("interval"), start: url.searchParams.get("startDate"), end: url.searchParams.get("endDate") });
-    return { status: "success", data: [{ date: end, close: 139 }] };
-  });
-  apiClient.getCloudHistory = transport.getCloudHistory.bind(transport);
-  const cloud = new GloomberbCloudProvider();
-  const cloudValues = [];
-  for (const [symbol, exchange, resolution] of [["BTC-USD", "CCC", "15m"], ["AAPL", "NASDAQ", "15m"], ["AAPL", "NASDAQ", "1d"]]) {
-    cloudValues.push((await cloud.getPriceHistoryForResolutionWithMetadata(symbol, exchange, "1M", resolution)).points[0].close);
-  }
-  cases.push({ ...serialized, datesRoundTrip: JSON.stringify(original) === JSON.stringify(serialized),
-    oneMonthReturn: buildPriceReturnFields(history).find(field => field.id === "1M").value,
-    cloudRequests, cloudValues,
-    supportedAtBoundary: isDateWindowWithinTimeRange(new Date(serialized.first), new Date(end), "1M"),
-    unsupportedBeforeBoundary: !isDateWindowWithinTimeRange(new Date(Date.parse(serialized.first) - 1), new Date(end), "1M") });
-}
-const end = new Date("2026-03-30T15:45:12.345Z");
-const ranges = ["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"].map(range => subtractTimeRange(end, range).toISOString());
-const rollover = [["2026-03-31T15:45:00Z", "1M"], ["2026-08-31T15:45:00Z", "6M"], ["2024-02-29T15:45:00Z", "1Y"]]
-  .map(([date, range]) => subtractTimeRange(new Date(date), range).toISOString());
-const oldHistory = [{ date: new Date("1950-01-01"), close: 1 }, { date: new Date("2024-02-29"), close: 2 }];
-const allContract = { first: clipPriceHistoryToRange(oldHistory, "ALL")[0].date.toISOString(),
-  chartStart: buildPresetDateWindow(oldHistory.map(point => point.date), "ALL").start.toISOString(),
-  supported: isDateWindowWithinTimeRange(oldHistory[0].date, oldHistory[1].date, "ALL"),
-  requestStart: subtractTimeRange(oldHistory[1].date, "ALL").toISOString() };
-const yearlyReturn = buildPriceReturnFields([
-  { date: "2025-10-25T00:00:00Z", close: 100 }, { date: "2025-10-26T00:00:00Z", close: 110 },
-  { date: "2026-10-26T00:00:00Z", close: 121 },
-]).find(field => field.id === "1Y").value;
-setSystemTime();
-console.log(JSON.stringify({ cases, liveCalls, ranges, rollover, yearlyReturn, allContract, input: end.toISOString() }));
-`;
-
-test("saved daily exports, correlation and range boundaries use the same UTC dates across DST and host timezones", () => {
-  for (const timezone of ["UTC", "Europe/Berlin", "America/Los_Angeles"]) {
-    const processResult = Bun.spawnSync([process.execPath, "--eval", replay], {
-      cwd: import.meta.dir, env: { ...process.env, TZ: timezone }, stdout: "pipe", stderr: "pipe",
-    });
-    expect({ timezone, code: processResult.exitCode, error: new TextDecoder().decode(processResult.stderr) })
-      .toEqual({ timezone, code: 0, error: "" });
-    const result = JSON.parse(new TextDecoder().decode(processResult.stdout));
-    const endpoints = [["2026-03-03", "2026-04-03"], ["2025-10-03", "2025-11-03"], ["2026-08-22", "2026-09-22"], ["2026-02-28", "2026-03-31"], ["2024-02-29", "2024-03-31"]];
-    const newYorkBounds = [["2026-03-02 19:00:00", "2026-04-02 20:00:00"], ["2025-10-02 20:00:00", "2025-11-02 19:00:00"], ["2026-08-21 20:00:00", "2026-09-21 20:00:00"], ["2026-02-27 19:00:00", "2026-03-30 20:00:00"], ["2024-02-28 19:00:00", "2024-03-30 20:00:00"]];
-    for (const [index, [first, last]] of endpoints.entries()) {
-      expect(result.cases[index]).toMatchObject({ first: first + "T00:00:00.000Z", last: last + "T00:00:00.000Z",
-        rows: 32, allRows: 40, sampleSize: 31, errors: [], datesRoundTrip: true,
-        supportedAtBoundary: true, unsupportedBeforeBoundary: true });
-      expect(result.cases[index].correlation).toBeCloseTo(-0.0955022928516023, 12);
-      expect(result.cases[index].oneMonthReturn).toBeCloseTo(31 / 108, 12);
-      expect(result.cases[index].cloudRequests).toEqual([
-        { symbol: "BTC-USD", exchange: "CCC", interval: "15min", start: first + " 00:00:00", end: last + " 00:00:00" },
-        { symbol: "AAPL", exchange: "NASDAQ", interval: "15min", start: newYorkBounds[index][0], end: newYorkBounds[index][1] },
-        { symbol: "AAPL", exchange: "NASDAQ", interval: "1day", start: first, end: last },
-      ]);
-      expect(result.cases[index].cloudValues).toEqual([139, 139, 139]);
-    }
-    expect(result.liveCalls).toBe(0);
-    expect(result.allContract).toEqual({ first: "1950-01-01T00:00:00.000Z", chartStart: "1950-01-01T00:00:00.000Z",
-      supported: true, requestStart: "1974-02-28T00:00:00.000Z" });
-    expect(result.ranges).toEqual([
-      "2026-03-29T15:45:12.345Z", "2026-03-23T15:45:12.345Z", "2026-02-28T15:45:12.345Z", "2025-12-30T15:45:12.345Z",
-      "2025-09-30T15:45:12.345Z", "2025-03-30T15:45:12.345Z", "2021-03-30T15:45:12.345Z", "1976-03-30T15:45:12.345Z",
-    ]);
-    // Month/year cutoffs clamp to valid calendar dates and retain their UTC clock.
-    expect(result.rollover).toEqual(["2026-02-28T15:45:00.000Z", "2026-02-28T15:45:00.000Z", "2023-02-28T15:45:00.000Z"]);
-    expect(result.input).toBe("2026-03-30T15:45:12.345Z");
-    expect(result.yearlyReturn).toBeCloseTo(0.1, 12);
-  }
-});