gloomberb 0.13.2 → 0.14.0

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

@@ -1,17 +1,26 @@
-import { describe, expect, test } from "bun:test";
+import { FINANCIAL_VINTAGE_NOTICE } from "../utils/financial-statements";
+import { describe, expect, spyOn, test } from "bun:test";
+import { chartSeriesSourceKey } from "../capabilities";
 import type { FredSeriesData, FredSeriesLoadResult } from "../data/fred-series";
+import { buildCustomChartPreset } from "../plugins/builtin/chart-composer/presets";
 import { createTestDataProvider } from "../test-support/data-provider";
 import type { TickerFinancials } from "../types/financials";
-import { CHART_SPEC_VERSION, type ChartSpec } from "./types";
+import { chartQuoteOverrideKeyForSource } from "./live-quotes";
 import {
   ChartResolveCache,
   mergePriceHistoryWindows,
   resolveChartSpecData,
   seedChartResolutionResult,
 } from "./resolve";
-import { chartQuoteOverrideKeyForSource } from "./live-quotes";
-import { chartSeriesSourceKey } from "../capabilities";
-import { buildCustomChartPreset } from "../plugins/builtin/chart-composer/presets";
+import { CHART_SPEC_VERSION, type ChartSeriesSpec, type ChartSpec } from "./types";
+
+function chartSeries(input: Pick<ChartSeriesSpec, "source"> & Partial<ChartSeriesSpec>): ChartSeriesSpec {
+  return { id: "price", style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none", ...input };
+}
+
+function chartSpec(input: Pick<ChartSpec, "viewport" | "series"> & Partial<ChartSpec>): ChartSpec {
+  return { version: CHART_SPEC_VERSION, panels: [{ id: "main" }], studies: [], ...input };
+}
 
 const emptyFinancials = (): TickerFinancials => ({
   annualStatements: [],
@@ -31,26 +40,109 @@ const fredLoad = (
 });
 
 describe("resolveChartSpecData", () => {
+  test("credit stress windows disclose source coverage without clipping buffers or scaling effective yields", async () => {
+    const spec = buildCustomChartPreset("FRED:BAMLC0A0CM,FRED:BAMLC0A0CMEY");
+    const requests: string[] = [];
+    const sources = {
+      now: new Date("2026-09-11"),
+      loadFredSeries: async (request: { seriesId: string; startDate?: string }) => {
+        requests.push(request.startDate!);
+        const yieldSeries = request.seriesId.endsWith("EY");
+        return fredLoad({
+          observations: [
+            { date: "2023-09-12", value: yieldSeries ? 5.82 : 1.23 },
+            { date: "2025-04-09", value: yieldSeries ? 5.5 : 1.21 },
+            { date: "2026-09-10", value: yieldSeries ? 5.68 : 0.8 },
+          ],
+          info: { id: request.seriesId, title: yieldSeries ? "IG effective yield" : "IG OAS", units: "Percent",
+            frequency: "Daily, Close", seasonalAdjustment: "Not Seasonally Adjusted", source: "FRED", notes: "",
+            observationStart: "2023-09-12", observationEnd: "2026-09-10" },
+        });
+      },
+    };
+    const fiveYear = await resolveChartSpecData(spec, sources);
+    expect(fiveYear.warnings.filter((warning) => warning.includes("FRED coverage"))).toHaveLength(2);
+    expect(fiveYear.warnings.some((warning) => warning.includes("vintage dates"))).toBe(true);
+    expect(fiveYear.series.map((series) => series.points.at(-1)?.value)).toEqual([0.8, 5.68]);
+    expect(fiveYear.series.map((series) => series.unit)).toEqual(["%", "%"]);
+    const recent = await resolveChartSpecData({ ...spec, viewport: { ...spec.viewport, range: "1Y" } }, sources);
+    expect(requests.at(-1)! < "2023-09-12").toBe(true); // Calculation buffer predates the visible window.
+    expect(recent.warnings.some((warning) => warning.includes("FRED coverage"))).toBe(false);
+    const old = await resolveChartSpecData({ ...spec, viewport: { ...spec.viewport,
+      dateWindow: { start: "2020-01-01", end: "2020-06-30" } } }, sources);
+    expect(old.series.every((series) => series.points.length === 0)).toBe(true);
+    expect(old.warnings.filter((warning) => warning.includes("Earlier dates are unavailable"))).toHaveLength(2);
+    expect(old.viewport.start?.toISOString().slice(0, 10)).toBe("2020-01-01");
+  });
+
+  test("credit history keeps newer observations when source coverage metadata lags", async () => {
+    const spec = buildCustomChartPreset("FRED:BAMLC0A0CM");
+    spec.viewport.dateWindow = { start: "2021-09-16", end: "2026-09-16" };
+    const data: FredSeriesData = {
+      observations: [{ date: "2023-09-18", value: 1.22 }, { date: "2026-09-14", value: 0.8 }],
+      info: { id: "BAMLC0A0CM", title: "IG OAS", units: "Percent", frequency: "Daily, Close",
+        seasonalAdjustment: "Not Seasonally Adjusted", source: "FRED", notes: "",
+        observationStart: "2023-09-12", observationEnd: "2026-09-10" },
+    };
+    const sources = { loadFredSeries: async () => fredLoad(data) };
+    const before = await resolveChartSpecData(spec, sources);
+    expect(before.series[0]?.points.at(-1)?.value).toBe(0.8);
+    expect(before.series[0]?.points.at(-1)?.date.toISOString()).toBe("2026-09-14T00:00:00.000Z");
+    expect(before.warnings.some((warning) => warning.includes("exact coverage dates are unavailable"))).toBe(true);
+    expect(before.warnings.some((warning) => warning.includes("2026-09-10"))).toBe(false);
+    data.info = { ...data.info!, observationStart: "2023-09-18", observationEnd: "2026-09-14" };
+    const recovered = await resolveChartSpecData(spec, sources);
+    expect(recovered.series[0]?.points).toEqual(before.series[0]?.points);
+    expect(recovered.warnings.some((warning) => warning.includes("2023-09-18 to 2026-09-14"))).toBe(true);
+    expect(recovered.warnings.some((warning) => warning.includes("exact coverage dates are unavailable"))).toBe(false);
+  });
+
+  test("qualified price charts retain quote metadata without injecting the fetched snapshot into history", async () => {
+    let quoteCalls = 0;
+    let financialCalls = 0;
+    const history = [{ date: new Date("2026-01-15"), close: 77.53, volume: 1234 }];
+    const provider = createTestDataProvider({
+      getQuote: async () => { quoteCalls++; return { symbol: "NESN", listingExchangeName: "SWX", currency: "CHF", instrumentType: "EQUITY", price: 999, change: 0, changePercent: 0, lastUpdated: Date.parse("2026-01-16") }; },
+      getTickerFinancials: async () => { financialCalls++; return emptyFinancials(); },
+      getPriceHistory: async () => history,
+      getPriceHistoryForResolution: async () => history,
+    });
+    const spec = chartSpec({ viewport: { range: "1M", resolution: "1d" }, series: [chartSeries({ source: { kind: "security", instrument: { symbol: "NESN", exchange: "SWX" }, fieldId: "market.close" } })] });
+    const cache = new ChartResolveCache();
+    const sources = { dataProvider: provider, loadFredSeries: async () => fredLoad(), now: new Date("2026-01-16") };
+    const result = await resolveChartSpecData(spec, sources, cache);
+    expect(result.series[0]).toMatchObject({ unit: "CHF/share", unitGroup: "price:CHF", volumeUnit: "shares" });
+    expect(result.series[0]?.points.map((point) => point.value)).toEqual([77.53]);
+    await resolveChartSpecData(spec, sources, cache);
+    expect(quoteCalls).toBe(1);
+    expect(financialCalls).toBe(0);
+
+    const unavailable = createTestDataProvider({
+      // Optional metadata can also fail synchronously in a provider adapter.
+      getQuote: () => { throw new Error("Quote temporarily unavailable"); },
+      getPriceHistory: async () => history,
+      getPriceHistoryForResolution: async () => history,
+    });
+    const withoutMetadata = await resolveChartSpecData(spec, { ...sources, dataProvider: unavailable });
+    expect(withoutMetadata.errors).toEqual([]);
+    expect(withoutMetadata.series[0]?.points.map((point) => point.value)).toEqual([77.53]);
+    expect(withoutMetadata.series[0]?.unit).toBe("currency");
+  });
+
   test("seeds study series so their panels survive the wait for real data", async () => {
     const date = new Date("2026-01-05T00:00:00.000Z");
     const seeded = seedChartResolutionResult(
-      {
-        version: CHART_SPEC_VERSION,
+      chartSpec({
         viewport: { range: "1M", resolution: "auto" },
         panels: [{ id: "main" }, { id: "volume" }],
-        series: [{
-          id: "price",
+        series: [chartSeries({
           source: {
             kind: "security",
             instrument: { symbol: "TEST", exchange: "NASDAQ" },
             fieldId: "market.ohlcv",
           },
           style: "candles",
-          transform: "raw",
-          axis: "left",
-          panelId: "main",
-          interpolation: "none",
-        }],
+        })],
         studies: [{
           id: "volume",
           kind: "volume",
@@ -59,7 +151,7 @@ describe("resolveChartSpecData", () => {
           panelId: "volume",
           axis: "left",
         }],
-      },
+      }),
       new Map([[
         chartQuoteOverrideKeyForSource({
           kind: "security",
@@ -72,7 +164,98 @@ describe("resolveChartSpecData", () => {
 
     const volume = seeded?.series.find((entry) => entry.panelId === "volume");
     expect(volume?.points.map((point) => point.value)).toEqual([5_000]);
-    expect(seeded?.bufferedSeries).toBe(seeded?.series);
+    expect(seeded?.bufferedSeries?.find((entry) => entry.panelId === "volume")?.points).toHaveLength(1);
+  });
+
+  test("a currency-only live quote still loads security type without replacing its price", async () => {
+    let quoteCalls = 0;
+    let financialCalls = 0;
+    const source = { kind: "security" as const, instrument: { symbol: "NVDA", exchange: "XNAS" }, fieldId: "market.close" };
+    const history = [{ date: new Date("2026-01-15T14:30:00Z"), close: 77.53, volume: 1234 }];
+    const provider = createTestDataProvider({
+      getQuote: async () => { quoteCalls++; return { symbol: "NVDA", listingExchangeName: "NASDAQ", currency: "USD", instrumentType: "Common Stock", price: 999, change: 0, changePercent: 0, lastUpdated: Date.parse("2026-01-16T16:00:00Z") }; },
+      getTickerFinancials: async () => { financialCalls++; return emptyFinancials(); },
+      getPriceHistory: async () => history,
+      getPriceHistoryForResolution: async () => history,
+    });
+    const spec = chartSpec({ viewport: { range: "1M", resolution: "1d" }, series: [chartSeries({ source })],
+      studies: [{ id: "volume", kind: "volume", inputSeriesIds: ["price"], parameters: {}, panelId: "main", axis: "left" }] });
+    const sources = { dataProvider: provider, loadFredSeries: async () => fredLoad(), now: new Date("2026-01-16T16:00:00Z"),
+      quoteOverrides: new Map([[chartQuoteOverrideKeyForSource(source), { symbol: "NVDA", currency: "USD", price: 78, change: 0, changePercent: 0, lastUpdated: Date.parse("2026-01-16T16:00:00Z") }]]) };
+    const cache = new ChartResolveCache();
+    const result = await resolveChartSpecData(spec, sources, cache);
+    expect(result.series[0]).toMatchObject({ unit: "USD/share", volumeUnit: "shares" });
+    expect(result.series.find((series) => series.id === "volume")?.unit).toBe("shares");
+    expect(result.series[0]?.points.map((point) => point.value)).toEqual([77.53, 78]);
+    expect(result.warnings.some((warning) => warning.includes("Volume unit unknown"))).toBe(false);
+    await resolveChartSpecData(spec, sources, cache);
+    expect(quoteCalls).toBe(1);
+    expect(financialCalls).toBe(0);
+  });
+
+  test("direct volume fields and volume studies retain established units without labeling crypto volume as shares", async () => {
+    for (const [instrumentType, expectedUnit] of [["EQUITY", "shares"], ["Common Stock", "shares"], ["FUTURE", "contracts"], ["CRYPTOCURRENCY", ""], [undefined, ""]] as const) {
+      const history = [{ date: new Date("2026-01-15"), close: 1, volume: 1234 }];
+      const financials = { ...emptyFinancials(), quote: { symbol: "TEST", currency: "USD", price: 1, change: 0, changePercent: 0, lastUpdated: Date.parse("2026-01-15"), instrumentType }, priceHistory: history };
+      const provider = createTestDataProvider({
+        getQuote: async () => financials.quote,
+        getTickerFinancials: async () => financials,
+        getPriceHistory: async () => history,
+        getPriceHistoryForResolution: async () => history,
+      });
+      const result = await resolveChartSpecData(chartSpec({
+        viewport: { range: "1M", resolution: "1d" },
+        series: [chartSeries({ id: "direct", source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "market.volume" } }), chartSeries({ id: "price", source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "market.close" } })],
+        studies: [{ id: "volume", kind: "volume", inputSeriesIds: ["price"], parameters: {}, panelId: "main", axis: "left" }],
+      }), { dataProvider: provider, loadFredSeries: async () => fredLoad(), now: new Date("2026-01-16") });
+      for (const id of ["direct", "volume"]) {
+        expect(result.series.find((entry) => entry.id === id)?.unit).toBe(expectedUnit);
+        expect(result.series.find((entry) => entry.id === id)?.points.map((point) => point.value)).toEqual([1234]);
+      }
+      expect(result.warnings.some((warning) => warning.includes("Volume unit unknown"))).toBe(!expectedUnit);
+    }
+  });
+
+  test("cached history honors the visible date range before the network resolves", () => {
+    const source = { kind: "security" as const, instrument: { symbol: "TEST", exchange: "NASDAQ" }, fieldId: "market.close" };
+    const history = ["2021-01-01", "2026-08-01", "2026-08-15", "2026-09-10"].map((day, i) => ({
+      date: new Date(`${day}T00:00:00Z`), close: 100 + i, volume: 1_000 + i,
+    }));
+    const seeded = seedChartResolutionResult(chartSpec({
+      viewport: { range: "1M", resolution: "auto" },
+      series: [chartSeries({ source, transform: "percent" })],
+    }), new Map([[chartQuoteOverrideKeyForSource(source), history]]));
+    expect(seeded?.viewport?.start.toISOString()).toBe("2026-08-10T00:00:00.000Z");
+    expect(seeded?.viewport?.end.toISOString()).toBe("2026-09-10T00:00:00.000Z");
+    expect(seeded?.series[0]?.points.map((p) => p.date.toISOString().slice(0, 10))).toEqual(["2026-08-15", "2026-09-10"]);
+    expect(seeded?.series[0]?.points[0]?.value).toBe(0);
+    expect(seeded?.bufferedSeries?.[0]?.points).toHaveLength(4);
+  });
+
+  test("a point-limited seed exposes a viewport only for an explicit date window", () => {
+    const source = { kind: "security" as const, instrument: { symbol: "TEST", exchange: "NASDAQ" }, fieldId: "market.close" };
+    const history = ["2026-08-01", "2026-08-15", "2026-09-10"].map((day, index) => ({
+      date: new Date(`${day}T00:00:00Z`), close: 100 + index,
+    }));
+    const cached = new Map([[chartQuoteOverrideKeyForSource(source), history]]);
+    const spec = chartSpec({ viewport: { range: "1Y", resolution: "auto", maxPoints: 2 }, series: [chartSeries({ source })] });
+    const seed = seedChartResolutionResult(spec, cached);
+    expect(seed?.series[0]?.points).toHaveLength(2);
+    expect(seed?.viewport).toBeUndefined();
+    expect(seed?.bufferedSeries).toBeUndefined();
+    const explicit = seedChartResolutionResult({ ...spec, viewport: {
+      ...spec.viewport, dateWindow: { start: "2026-08-01", end: "2026-09-10" },
+    } }, cached);
+    expect(explicit?.viewport?.start.toISOString()).toBe("2026-08-01T00:00:00.000Z");
+    expect(explicit?.viewport?.end.toISOString()).toBe("2026-09-10T23:59:59.999Z");
+  });
+
+  test("stale cached observations cannot move a current preset window into the past", () => {
+    const source = { kind: "security" as const, instrument: { symbol: "TEST" }, fieldId: "market.close" };
+    const cached = new Map([[chartQuoteOverrideKeyForSource(source), [{ date: new Date("2026-08-31T00:00:00Z"), close: 100 }]]]);
+    const result = seedChartResolutionResult(chartSpec({ viewport: { range: "1M", resolution: "auto" },
+      series: [chartSeries({ source })] }), cached, new Date("2026-09-10T18:00:00Z"));
+    expect(result?.viewport).toEqual({ start: new Date("2026-08-10T18:00:00Z"), end: new Date("2026-09-10T18:00:00Z") });
   });
 
   test("keeps study output over the whole buffered history its base series carries", async () => {
@@ -88,23 +271,16 @@ describe("resolveChartSpecData", () => {
       getPriceHistoryForResolution: async () => history,
       getDetailedPriceHistory: async () => history,
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
       panels: [{ id: "main" }, { id: "volume", label: "Volume", height: 0.24 }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.close",
         },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
+      })],
       studies: [{
         id: "volume",
         kind: "volume",
@@ -113,7 +289,7 @@ describe("resolveChartSpecData", () => {
         panelId: "volume",
         axis: "left",
       }],
-    };
+    });
     const sources = {
       dataProvider: provider,
       now: new Date("2026-06-15T00:00:00.000Z"),
@@ -177,21 +353,15 @@ describe("resolveChartSpecData", () => {
   });
 
   test("keeps missing capability series visible with a useful error and resolves them through the injected boundary", async () => {
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1M", resolution: "auto" },
-      panels: [{ id: "main" }],
-      series: [{
+      series: [chartSeries({
         id: "plugin-series",
         source: { kind: "capability", capabilityId: "charts.test", seriesId: "one" },
         style: "area",
-        transform: "raw",
         axis: "auto",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
     const sources = { dataProvider: null, loadFredSeries: async () => fredLoad(), now: new Date("2026-02-01") };
     const missing = await resolveChartSpecData(spec, sources);
     expect(missing.series).toHaveLength(1);
@@ -222,21 +392,13 @@ describe("resolveChartSpecData", () => {
   });
 
   test("resolves capability coverage for each effective panned viewport and caches by structured bounds", async () => {
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1M", resolution: "auto" },
-      panels: [{ id: "main" }],
-      series: [{
+      series: [chartSeries({
         id: "plugin-series",
         source: { kind: "capability", capabilityId: "charts.test", seriesId: "provider/series" },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
     const requested: ChartSpec["viewport"][] = [];
     const cache = new ChartResolveCache();
     const sources = {
@@ -296,11 +458,9 @@ describe("resolveChartSpecData", () => {
           return [{ date: new Date("2025-01-07T16:00:00Z"), close: 100 }];
         },
       });
-      const spec: ChartSpec = {
-        version: CHART_SPEC_VERSION,
+      const spec: ChartSpec = chartSpec({
         viewport: { range: scenario.range, resolution: "auto" },
-        panels: [{ id: "main" }],
-        series: scenario.periods.map((period, index) => ({
+        series: scenario.periods.map((period, index) => (chartSeries({
           id: `price-${index}`,
           source: {
             kind: "security" as const,
@@ -311,11 +471,9 @@ describe("resolveChartSpecData", () => {
           style: "line" as const,
           transform: "raw" as const,
           axis: "left" as const,
-          panelId: "main",
           interpolation: "none" as const,
-        })),
-        studies: [],
-      };
+        }))),
+      });
 
       const result = await resolveChartSpecData(spec, {
         dataProvider: provider,
@@ -347,25 +505,17 @@ describe("resolveChartSpecData", () => {
         { date: new Date("2025-01-07T16:00:00Z"), close: 100 },
       ],
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "5Y", resolution: "auto" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.ohlcv",
         },
         style: "candles",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await Promise.race([
       resolveChartSpecData(spec, {
@@ -394,21 +544,12 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date("2025-01-07T16:00:00Z"), close: 100 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1W", resolution: "5m" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "market.close" },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -438,25 +579,16 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date("2026-07-30T15:00:00Z"), close: 100 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1M", resolution: "45m" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.close",
         },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -475,6 +607,97 @@ describe("resolveChartSpecData", () => {
     ]);
   });
 
+  test.each([
+    { selected: "1wk", maxRange: "ALL", range: "ALL", expected: "1wk" },
+    { selected: "1mo", maxRange: "ALL", range: "ALL", expected: "1mo" },
+    { selected: "1wk", maxRange: "5Y", range: "ALL", expected: "1mo" },
+    { selected: "5m", maxRange: "1W", range: "ALL", expected: "1mo" },
+    { selected: "1wk", maxRange: "5Y", range: "1Y", expected: "1wk" },
+  ] as const)("honors $selected/$range only within the provider's $maxRange limit", async ({ selected, maxRange, range, expected }) => {
+    const requests: string[] = [];
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getChartResolutionSupport: () => [
+        { resolution: selected, maxRange },
+        { resolution: "1mo", maxRange: "ALL" },
+      ],
+      getPriceHistoryForResolution: async (_symbol, _exchange, _range, resolution) => {
+        requests.push(resolution);
+        return [{ date: new Date("2026-08-03"), close: resolution === "1wk" ? 35 : 33 }];
+      },
+    });
+    const spec = chartSpec({
+      viewport: { range, resolution: selected },
+      series: [chartSeries({ source: {
+        kind: "security", instrument: { symbol: "TEST", exchange: "LSE" }, fieldId: "market.close",
+      } })],
+    });
+    const result = await resolveChartSpecData(spec, {
+      dataProvider: provider, now: new Date("2026-09-11"), loadFredSeries: async () => fredLoad(),
+    });
+
+    expect(requests).toEqual([expected]);
+    expect(result.resolution).toBe(expected);
+    expect(result.series[0]?.points.at(-1)?.value).toBe(expected === "1wk" ? 35 : 33);
+    expect(result.errors).toEqual([]);
+    expect(result.warnings.some((warning) => warning.includes("Auto resolution was used instead")))
+      .toBe(expected !== selected);
+  });
+
+  test.each(["ALL", "5Y"] as const)("checks explicit long date windows against the %s manual limit", async (maxRange) => {
+    const requests: string[] = [];
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getChartResolutionSupport: () => [
+        { resolution: "1wk", maxRange },
+        { resolution: "1mo", maxRange: "ALL" },
+      ],
+      getDetailedPriceHistory: async (_symbol, _exchange, _start, _end, resolution) => {
+        requests.push(resolution);
+        return [{ date: new Date("1997-07-01"), close: 10 }];
+      },
+    });
+    const spec = chartSpec({
+      viewport: { range: "ALL", resolution: "1wk", dateWindow: { start: "1997-01-01", end: "2026-09-11" } },
+      series: [chartSeries({ source: {
+        kind: "security", instrument: { symbol: "TEST", exchange: "LSE" }, fieldId: "market.close",
+      } })],
+    });
+    const result = await resolveChartSpecData(spec, {
+      dataProvider: provider, now: new Date("2026-09-11"), loadFredSeries: async () => fredLoad(),
+    });
+    expect(requests).toEqual([maxRange === "ALL" ? "1wk" : "1mo"]);
+    expect(result.errors).toEqual([]);
+  });
+
+  test("requires every comparison source to support the manual ALL interval", async () => {
+    const requests: string[] = [];
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getChartResolutionSupport: (symbol) => [
+        { resolution: "1wk", maxRange: symbol === "UNLIMITED" ? "ALL" : "5Y" },
+        { resolution: "1mo", maxRange: "ALL" },
+      ],
+      getPriceHistoryForResolution: async (symbol, _exchange, _range, resolution) => {
+        requests.push(`${symbol}:${resolution}`);
+        return [{ date: new Date("2026-08-03"), close: 33 }];
+      },
+    });
+    const spec = chartSpec({
+      viewport: { range: "ALL", resolution: "1wk" },
+      series: ["UNLIMITED", "LIMITED"].map((symbol) => chartSeries({ id: symbol, source: {
+        kind: "security", instrument: { symbol, exchange: "LSE" }, fieldId: "market.close",
+      } })),
+    });
+    const result = await resolveChartSpecData(spec, {
+      dataProvider: provider, now: new Date("2026-09-11"), loadFredSeries: async () => fredLoad(),
+    });
+    expect(requests.sort()).toEqual(["LIMITED:1mo", "UNLIMITED:1mo"]);
+    expect(result.resolution).toBe("1mo");
+    expect(result.resolutionSupport).toContainEqual({ resolution: "1wk", maxRange: "5Y" });
+    expect(result.warnings).toContain("1WK data is unavailable for this range. Auto resolution was used instead.");
+  });
+
   test("keeps the snapshot exchange when a newer quote omits it", async () => {
     const historyExchanges: string[] = [];
     const source = {
@@ -506,10 +729,8 @@ describe("resolveChartSpecData", () => {
         }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1D", resolution: "5m" },
-      panels: [{ id: "main" }],
       series: [{
         id: "price",
         source,
@@ -519,8 +740,7 @@ describe("resolveChartSpecData", () => {
         panelId: "main",
         interpolation: "none",
       }],
-      studies: [],
-    };
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -577,25 +797,16 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date("2026-07-30T15:20:00Z"), close: 1_240 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1D", resolution: "auto" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "SNDK" },
           fieldId: "market.close",
         },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(
       spec,
@@ -631,21 +842,12 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date("2025-01-07T16:00:00Z"), close: 100 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1W", resolution: "auto" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "market.close" },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -668,21 +870,12 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date("2025-01-07T16:00:00Z"), close: 100 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1W", resolution: "auto" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "market.close" },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -716,25 +909,16 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date("2025-01-15T16:00:00.000Z"), close: 100 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "3M", resolution: "auto" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.close",
         },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(
       spec,
@@ -795,25 +979,16 @@ describe("resolveChartSpecData", () => {
         return historicalHistory;
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1h" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.close",
         },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
     const sources = {
       dataProvider: provider,
       now: new Date("2026-07-30T16:00:00.000Z"),
@@ -871,25 +1046,16 @@ describe("resolveChartSpecData", () => {
       getPriceHistoryForResolution: async () => currentHistory,
       getDetailedPriceHistory: async () => historicalHistory,
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.close",
         },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
     const sources = {
       dataProvider: provider,
       now: new Date("2026-07-30T16:00:00.000Z"),
@@ -923,23 +1089,16 @@ describe("resolveChartSpecData", () => {
         { date: new Date("2024-10-16T16:00:00.000Z"), close: 110 },
       ],
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "3M", resolution: "1d" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.close",
         },
-        style: "line",
         transform: "percent",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
+      })],
       studies: [{
         id: "sma",
         kind: "sma",
@@ -948,7 +1107,7 @@ describe("resolveChartSpecData", () => {
         panelId: "main",
         axis: "left",
       }],
-    };
+    });
 
     const result = await resolveChartSpecData(
       spec,
@@ -996,21 +1155,17 @@ describe("resolveChartSpecData", () => {
         ];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
       panels: [{ id: "main" }, { id: "macro", height: 0.4 }],
       series: [
-        {
+        chartSeries({
           id: "aapl-price",
           source: { kind: "security", instrument: { symbol: "AAPL" }, fieldId: "market.close" },
-          style: "line",
           transform: "percent",
           axis: "auto",
-          panelId: "main",
-          interpolation: "none",
-        },
-        {
+        }),
+        chartSeries({
           id: "msft-revenue",
           source: {
             kind: "security",
@@ -1020,23 +1175,19 @@ describe("resolveChartSpecData", () => {
             timestampMode: "available-at",
           },
           style: "columns",
-          transform: "raw",
           axis: "auto",
-          panelId: "main",
           interpolation: "step-after",
-        },
-        {
+        }),
+        chartSeries({
           id: "cpi",
           source: { kind: "economic", provider: "fred", seriesId: "CPIAUCSL" },
           style: "step",
-          transform: "raw",
           axis: "auto",
           panelId: "macro",
           interpolation: "step-after",
-        },
+        }),
       ],
-      studies: [],
-    };
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -1101,23 +1252,15 @@ describe("resolveChartSpecData", () => {
         ];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: {
         range: "1Y",
         resolution: "auto",
         dateWindow: { start: "2025-01-01", end: "2025-01-31" },
       },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "market.close" },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
+      })],
       studies: [{
         id: "sma",
         kind: "sma",
@@ -1126,7 +1269,7 @@ describe("resolveChartSpecData", () => {
         panelId: "main",
         axis: "left",
       }],
-    };
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -1165,25 +1308,16 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date("2025-01-31T16:00:00Z"), close: 40 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: {
         range: "1D",
         resolution: "auto",
         dateWindow: { start: "2025-01-01", end: "2025-01-31" },
       },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "market.close" },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -1209,15 +1343,13 @@ describe("resolveChartSpecData", () => {
         }],
       }),
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: {
         range: "1M",
         resolution: "auto",
         dateWindow: { start: "2025-01-01", end: "2025-01-31" },
       },
-      panels: [{ id: "main" }],
-      series: [{
+      series: [chartSeries({
         id: "revenue",
         source: {
           kind: "security",
@@ -1227,13 +1359,9 @@ describe("resolveChartSpecData", () => {
           timestampMode: "available-at",
         },
         style: "step",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
         interpolation: "step-after",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -1251,6 +1379,7 @@ describe("resolveChartSpecData", () => {
     const provider = createTestDataProvider({
       getTickerFinancials: async (symbol) => ({
         ...emptyFinancials(),
+        financialCurrency: "USD",
         quarterlyStatements: symbol === "LEFT"
           ? [
             {
@@ -1282,7 +1411,7 @@ describe("resolveChartSpecData", () => {
           ],
       }),
     });
-    const fundamental = (id: string, symbol: string): ChartSpec["series"][number] => ({
+    const fundamental = (id: string, symbol: string): ChartSpec["series"][number] => (chartSeries({
       id,
       source: {
         kind: "security",
@@ -1294,13 +1423,8 @@ describe("resolveChartSpecData", () => {
       // The built-in fundamental comparison preset uses columns without
       // display interpolation; formula calculation still uses as-of values.
       style: "columns",
-      transform: "raw",
-      axis: "left",
-      panelId: "main",
-      interpolation: "none",
-    });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    }));
+    const spec: ChartSpec = chartSpec({
       viewport: {
         range: "1Y",
         resolution: "auto",
@@ -1326,7 +1450,7 @@ describe("resolveChartSpecData", () => {
           axis: "left",
         },
       ],
-    };
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -1373,16 +1497,14 @@ describe("resolveChartSpecData", () => {
         ],
       }),
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: {
         range: "ALL",
         resolution: "auto",
         dateWindow: { start: "2025-01-01", end: "2025-02-28" },
         maxPoints: 1,
       },
-      panels: [{ id: "main" }],
-      series: [{
+      series: [chartSeries({
         id: "revenue",
         source: {
           kind: "security",
@@ -1392,13 +1514,9 @@ describe("resolveChartSpecData", () => {
           timestampMode: "available-at",
         },
         style: "step",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
         interpolation: "step-after",
-      }],
-      studies: [],
-    };
+      })],
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -1422,24 +1540,16 @@ describe("resolveChartSpecData", () => {
         { date: new Date("2025-01-03T16:00:00Z"), close: 30 },
       ],
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "TEST", exchange: "NASDAQ" },
           fieldId: "market.close",
         },
-        style: "line",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
         visible: false,
-      }],
+      })],
       studies: [{
         id: "sma",
         kind: "sma",
@@ -1448,7 +1558,7 @@ describe("resolveChartSpecData", () => {
         panelId: "main",
         axis: "left",
       }],
-    };
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -1491,10 +1601,8 @@ describe("resolveChartSpecData", () => {
         { date: new Date(now - 86_400_000), close: 110 },
       ],
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
-      panels: [{ id: "main" }],
       series: [{
         id: "price",
         source,
@@ -1512,7 +1620,7 @@ describe("resolveChartSpecData", () => {
         panelId: "main",
         axis: "left",
       }],
-    };
+    });
     const quoteOverrides = new Map([[
       chartQuoteOverrideKeyForSource(source),
       {
@@ -1543,9 +1651,10 @@ describe("resolveChartSpecData", () => {
     expect(sma.points.at(-1)?.value).toBeCloseTo(15.5);
   });
 
-  test("keeps a quote received after resolution starts inside the latest viewport", async () => {
-    const now = Date.parse("2026-08-05T14:00:00Z");
+  test.each([0, 60_000])("validates a quote received after resolution starts against %i ms elapsed", async (elapsed) => {
+    const now = Date.parse("2026-08-05T22:00:00Z");
     const quoteTime = now + 60_000;
+    const clock = spyOn(Date, "now").mockReturnValue(now);
     const provider = createTestDataProvider({
       getTickerFinancials: async () => ({
         ...emptyFinancials(),
@@ -1563,28 +1672,24 @@ describe("resolveChartSpecData", () => {
           postMarketChangePercent: -0.77,
         },
       }),
-      getPriceHistoryForResolution: async () => [
-        { date: new Date(now - 2 * 86_400_000), open: 99, high: 102, low: 98, close: 100 },
-        { date: new Date(now - 86_400_000), open: 100, high: 101, low: 99, close: 100 },
-      ],
+      getPriceHistoryForResolution: async () => {
+        clock.mockReturnValue(now + elapsed);
+        return [
+          { date: new Date(now - 2 * 86_400_000), open: 99, high: 102, low: 98, close: 100 },
+          { date: new Date(now - 86_400_000), open: 100, high: 101, low: 99, close: 100 },
+        ];
+      },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "6M", resolution: "1d" },
-      panels: [{ id: "main" }],
-      series: [{
-        id: "price",
+      series: [chartSeries({
         source: {
           kind: "security",
           instrument: { symbol: "FRESH", exchange: "XNAS" },
           fieldId: "market.ohlcv",
         },
         style: "candles",
-        transform: "raw",
-        axis: "left",
-        panelId: "main",
-        interpolation: "none",
-      }],
+      })],
       studies: [{
         id: "sma",
         kind: "sma",
@@ -1593,42 +1698,89 @@ describe("resolveChartSpecData", () => {
         panelId: "main",
         axis: "left",
       }],
-    };
+    });
 
-    const result = await resolveChartSpecData(spec, {
+    try {
+      const result = await resolveChartSpecData(spec, {
+        dataProvider: provider,
+        now: new Date(now),
+        quoteOverrides: new Map([[
+          chartQuoteOverrideKeyForSource({
+            kind: "security",
+            instrument: { symbol: "FRESH", exchange: "XNAS" },
+            fieldId: "market.ohlcv",
+          }),
+          {
+            symbol: "FRESH",
+            price: 130,
+            currency: "USD",
+            change: 30,
+            changePercent: 30,
+            lastUpdated: quoteTime,
+            listingExchangeName: "XNAS",
+            marketState: "POST",
+            postMarketPrice: 129,
+            postMarketChange: -1,
+            postMarketChangePercent: -0.77,
+          },
+        ]]),
+        loadFredSeries: async () => fredLoad(),
+      });
+
+      expect(result.errors).toEqual([]);
+      expect(result.viewport?.end.getTime()).toBe(elapsed ? quoteTime : now);
+      const price = result.series.find((entry) => entry.id === "price");
+      const sma = result.series.find((entry) => entry.id === "sma");
+      expect(price?.points.at(-1)?.date.getTime()).toBe(elapsed ? quoteTime : now - 86_400_000);
+      expect(price?.points.at(-1)?.close).toBe(elapsed ? 129 : 100);
+      expect(price?.latestChangePercent).toBe(elapsed ? 30 : undefined);
+      expect(sma?.points.at(-1)?.date.getTime()).toBe(elapsed ? quoteTime : now - 86_400_000);
+    } finally { clock.mockRestore(); }
+  });
+
+  test.each(["line", "candles"] as const)("keeps one daily bar when a live quote updates a %s chart", async (style) => {
+    const now = Date.parse("2026-09-10T18:44:00Z");
+    const source = { kind: "security" as const, instrument: { symbol: "SQQQ", exchange: "NASDAQ" }, fieldId: "market.close" };
+    const provider = createTestDataProvider({
+      getPriceHistoryForResolution: async () => [{
+        date: new Date("2026-09-10T13:30:00Z"), open: 40, high: 41, low: 39, close: 39.77, volume: 1000,
+      }],
+    });
+    const result = await resolveChartSpecData(chartSpec({
+      viewport: { range: "1M", resolution: "1d" },
+      series: [{ id: "price", source, style, transform: "raw", axis: "left", panelId: "main", interpolation: "none" }],
+    }), {
       dataProvider: provider,
       now: new Date(now),
-      quoteOverrides: new Map([[
-        chartQuoteOverrideKeyForSource({
-          kind: "security",
-          instrument: { symbol: "FRESH", exchange: "XNAS" },
-          fieldId: "market.ohlcv",
-        }),
-        {
-          symbol: "FRESH",
-          price: 130,
-          currency: "USD",
-          change: 30,
-          changePercent: 30,
-          lastUpdated: quoteTime,
-          listingExchangeName: "XNAS",
-          marketState: "POST",
-          postMarketPrice: 129,
-          postMarketChange: -1,
-          postMarketChangePercent: -0.77,
-        },
-      ]]),
-      loadFredSeries: async () => fredLoad(),
+      quoteOverrides: new Map([[chartQuoteOverrideKeyForSource(source), {
+        symbol: "SQQQ", price: 39.75, currency: "USD", change: 0, changePercent: 0,
+        lastUpdated: now, listingExchangeName: "NASDAQ", marketState: "REGULAR",
+      }]]),
     });
+    expect(result.errors).toEqual([]);
+    expect(result.series[0]?.points).toHaveLength(1);
+    expect(result.series[0]?.points[0]).toMatchObject({ value: 39.75, open: 40, high: 41, low: 39, volume: 1000 });
+  });
 
+  test("retains the known listing session when the quote omits exchange metadata", async () => {
+    const now = Date.parse("2026-09-11T00:01:00Z");
+    const source = { kind: "security" as const, instrument: { symbol: "SQQQ", exchange: "NASDAQ" }, fieldId: "market.close" };
+    const result = await resolveChartSpecData(chartSpec({
+      viewport: { range: "1M", resolution: "1d" },
+      series: [{ id: "price", source, style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none" }],
+    }), {
+      dataProvider: createTestDataProvider({ getPriceHistoryForResolution: async () => [
+        { date: new Date("2026-09-10T00:00:00Z"), close: 100 },
+      ] }),
+      now: new Date(now),
+      quoteOverrides: new Map([[chartQuoteOverrideKeyForSource(source), {
+        symbol: "SQQQ", price: 100, postMarketPrice: 105, currency: "USD", change: 0, changePercent: 0,
+        lastUpdated: now - 60_000, marketState: "POST",
+      }]]),
+    });
     expect(result.errors).toEqual([]);
-    expect(result.viewport?.end.getTime()).toBe(quoteTime);
-    const price = result.series.find((entry) => entry.id === "price");
-    const sma = result.series.find((entry) => entry.id === "sma");
-    expect(price?.points.at(-1)?.date.getTime()).toBe(quoteTime);
-    expect(price?.points.at(-1)?.close).toBe(129);
-    expect(price?.latestChangePercent).toBe(30);
-    expect(sma?.points.at(-1)?.date.getTime()).toBe(quoteTime);
+    expect(result.series[0]?.points).toHaveLength(1);
+    expect(result.series[0]?.points[0]?.value).toBe(105);
   });
 
   test("reuses raw source loads while live quotes recompute the chart tail", async () => {
@@ -1651,10 +1803,8 @@ describe("resolveChartSpecData", () => {
         return [{ date: new Date(now - 86_400_000), close: 100 }];
       },
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
-      panels: [{ id: "main" }],
       series: [{
         id: "price",
         source,
@@ -1663,17 +1813,12 @@ describe("resolveChartSpecData", () => {
         axis: "left",
         panelId: "main",
         interpolation: "none",
-      }, {
+      }, chartSeries({
         id: "cpi",
         source: { kind: "economic", provider: "fred", seriesId: "CPIAUCSL" },
-        style: "line",
-        transform: "raw",
         axis: "right",
-        panelId: "main",
-        interpolation: "none",
-      }],
-      studies: [],
-    };
+      })],
+    });
     const loadFredSeries = async () => {
       fredCalls += 1;
       return fredLoad({
@@ -1776,6 +1921,7 @@ describe("resolveChartSpecData", () => {
       getTickerFinancials: async () => ({
         ...emptyFinancials(),
         quarterlyStatements: statements,
+        financialCurrency: "USD",
         quote: {
           symbol: "LIVE",
           price: 50,
@@ -1799,7 +1945,7 @@ describe("resolveChartSpecData", () => {
       "evEbitda",
       "priceFcf",
     ] as const;
-    const makeSeries = (metric: typeof valuationFields[number]): ChartSpec["series"][number] => ({
+    const makeSeries = (metric: typeof valuationFields[number]): ChartSpec["series"][number] => (chartSeries({
       id: metric,
       source: {
         kind: "security",
@@ -1809,18 +1955,12 @@ describe("resolveChartSpecData", () => {
         timestampMode: "available-at",
       },
       style: "step",
-      transform: "raw",
-      axis: "left",
-      panelId: "main",
       interpolation: "step-after",
-    });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    }));
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
-      panels: [{ id: "main" }],
       series: valuationFields.map(makeSeries),
-      studies: [],
-    };
+    });
     const firstSource = spec.series[0]!.source;
     if (firstSource.kind !== "security") throw new Error("expected security source");
     const quoteOverrides = new Map([[
@@ -1881,7 +2021,7 @@ describe("resolveChartSpecData", () => {
         return [];
       },
     });
-    const makeSeries = (metric: "forwardPE" | "pegRatio"): ChartSpec["series"][number] => ({
+    const makeSeries = (metric: "forwardPE" | "pegRatio"): ChartSpec["series"][number] => (chartSeries({
       id: metric,
       source: {
         kind: "security",
@@ -1890,18 +2030,12 @@ describe("resolveChartSpecData", () => {
         timestampMode: "available-at",
       },
       style: "step",
-      transform: "raw",
-      axis: "left",
-      panelId: "main",
       interpolation: "step-after",
-    });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    }));
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
-      panels: [{ id: "main" }],
       series: [makeSeries("forwardPE"), makeSeries("pegRatio")],
-      studies: [],
-    };
+    });
     const firstSource = spec.series[0]!.source;
     if (firstSource.kind !== "security") throw new Error("expected security source");
     const quoteOverrides = new Map([[
@@ -1961,10 +2095,8 @@ describe("resolveChartSpecData", () => {
         },
       ],
     });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1D", resolution: "5m" },
-      panels: [{ id: "main" }],
       series: [{
         id: "price",
         source,
@@ -1974,8 +2106,7 @@ describe("resolveChartSpecData", () => {
         panelId: "main",
         interpolation: "none",
       }],
-      studies: [],
-    };
+    });
     const quoteOverrides = new Map([[
       chartQuoteOverrideKeyForSource(source),
       {
@@ -2022,17 +2153,12 @@ describe("resolveChartSpecData", () => {
           { date: new Date("2025-01-02T00:00:00Z"), close: 240, volume: 2_400 },
         ],
     });
-    const makeSeries = (id: string, symbol: string): ChartSpec["series"][number] => ({
+    const makeSeries = (id: string, symbol: string): ChartSpec["series"][number] => (chartSeries({
       id,
       source: { kind: "security", instrument: { symbol }, fieldId: "market.ohlcv" },
-      style: "line",
       transform: "percent",
-      axis: "left",
-      panelId: "main",
-      interpolation: "none",
-    });
-    const spec: ChartSpec = {
-      version: CHART_SPEC_VERSION,
+    }));
+    const spec: ChartSpec = chartSpec({
       viewport: { range: "1Y", resolution: "1d" },
       panels: [{ id: "main" }, { id: "formula" }, { id: "volume" }],
       series: [makeSeries("left", "LEFT"), makeSeries("right", "RIGHT")],
@@ -2062,7 +2188,7 @@ describe("resolveChartSpecData", () => {
           axis: "left",
         },
       ],
-    };
+    });
 
     const result = await resolveChartSpecData(spec, {
       dataProvider: provider,
@@ -2133,3 +2259,39 @@ describe("mergePriceHistoryWindows", () => {
     }
   });
 });
+
+test("financial charts disclose snapshot vintages once without changing period or availability timestamps", async () => {
+  const dataProvider = createTestDataProvider({ getTickerFinancials: async () => ({
+    annualStatements: [{ date: "2017-06-30", totalRevenue: 96_571_000_000, netIncome: 25_489_000_000, fieldAvailability: { totalRevenue: "2018-08-03", netIncome: "2018-08-03" } }],
+    quarterlyStatements: [], priceHistory: [],
+  }) });
+  for (const timestampMode of ["period-end", "available-at"] as const) {
+    const result = await resolveChartSpecData(chartSpec({ viewport: { range: "ALL", resolution: "auto" },
+      series: ["totalRevenue", "netIncome"].map((field) => chartSeries({ id: field, style: "columns",
+        source: { kind: "security", instrument: { symbol: "MSFT", exchange: "NASDAQ" }, fieldId: `fundamental.${field}`, period: "annual", timestampMode },
+      })),
+    }), { dataProvider });
+    expect(result.warnings.filter((warning) => warning === FINANCIAL_VINTAGE_NOTICE)).toHaveLength(1);
+    expect(result.series[0]?.points[0]).toMatchObject({ value: 96_571_000_000, observedAt: new Date("2017-06-30T00:00:00Z"), availableAt: new Date("2018-08-03T00:00:00Z"), date: new Date(timestampMode === "period-end" ? "2017-06-30T00:00:00Z" : "2018-08-03T00:00:00Z") });
+  }
+});
+
+test.each([-9, 0, 12])("forward P/E chart handles reported multiple %s without inventing comparable points", async (forwardPE) => {
+  const now = new Date("2026-06-01T16:00:00Z");
+  const financials = { ...emptyFinancials(), fundamentals: { forwardPE },
+    quote: { symbol: "TEST", price: 20, currency: "USD", change: 0, changePercent: 0, lastUpdated: now.getTime() } };
+  const provider = createTestDataProvider({ getTickerFinancials: async () => financials });
+  const spec = chartSpec({ viewport: { range: "1Y", resolution: "auto" }, series: [chartSeries({
+    source: { kind: "security", instrument: { symbol: "TEST" }, fieldId: "valuation.forwardPE" },
+  })] });
+  const result = await resolveChartSpecData(spec, { dataProvider: provider, now, loadFredSeries: async () => fredLoad() });
+  expect(result.errors).toEqual([]);
+  if (forwardPE > 0) {
+    expect(result.series[0]?.points.map((point) => point.value)).toEqual([12]);
+    expect(result.series[0]?.warning).toBeUndefined();
+  } else {
+    expect(result.series[0]?.points).toEqual([]);
+    expect(result.series[0]?.warning).toContain("not meaningful");
+  }
+  expect(financials.fundamentals.forwardPE).toBe(forwardPE);
+});