gloomberb 0.15.2 → 0.15.4

package/src/time-series/valuation-currency.test.ts

@@ -1,129 +0,0 @@
-import { expect, test } from "bun:test";
-import { createTestDataProvider } from "../test-support/data-provider";
-import { createDefaultConfig } from "../types/config";
-import type { TickerFinancials } from "../types/financials";
-import { loadChartPaneModel } from "../plugins/builtin/chart-composer/headless";
-import { extractFundamentalSeries, valuationCurrencyWarning } from "./fundamentals";
-import { CHART_SPEC_VERSION, type ChartSpec, type SecuritySeriesSource } from "./types";
-
-const fields = ["trailingPE", "priceSales", "evSales", "evEbitda", "priceFcf"] as const;
-const source = (metric: string): SecuritySeriesSource => ({
-  kind: "security", instrument: { symbol: "SHEL", exchange: "LSE" },
-  fieldId: `valuation.${metric}`, period: "annual", timestampMode: "available-at",
-});
-const fixture = (): TickerFinancials => ({
-  financialCurrency: "GBP",
-  quote: { symbol: "SHEL", currency: "GBP", price: 35, change: 0, changePercent: 0,
-    lastUpdated: Date.parse("2026-09-11T16:00:00Z") },
-  annualStatements: [{ date: "2025-12-31", availableAt: "2026-03-12", eps: 3,
-    totalRevenue: 300, dilutedShares: 10, totalDebt: 20, cashAndCashEquivalents: 5,
-    ebitda: 60, freeCashFlow: 25 }],
-  quarterlyStatements: [],
-  priceHistory: [{ date: new Date("2026-03-12"), close: 30 }],
-});
-
-test("missing statement currency cannot turn a known foreign or unknown basis into valuation ratios", () => {
-  for (const reporting of ["USD", undefined]) {
-    const data = fixture(); data.financialCurrency = reporting;
-    // Summary fundamentals may have been converted separately and cannot fill this gap.
-    data.fundamentals = { financialCurrency: "GBP" };
-    const original = JSON.stringify(data);
-    for (const metric of fields) {
-      expect(extractFundamentalSeries(data, source(metric))).toEqual([]);
-      expect(valuationCurrencyWarning(data, source(metric))).toContain(reporting ?? "unknown");
-    }
-    expect(extractFundamentalSeries(data, { ...source(""), fieldId: "fundamental.totalRevenue" })[0]?.value).toBe(300);
-    expect(JSON.stringify(data)).toBe(original);
-  }
-});
-
-test("same-currency monetary ratios retain historical and current values", () => {
-  const data = fixture();
-  const expected = [[10, 35 / 3], [1, 350 / 300], [315 / 300, 365 / 300], [315 / 60, 365 / 60], [12, 14]];
-  for (const [index, metric] of fields.entries()) {
-    expect(extractFundamentalSeries(data, source(metric)).map((point) => point.value)).toEqual(expected[index]!);
-    expect(valuationCurrencyWarning(data, source(metric))).toBeUndefined();
-  }
-  // Row metadata wins over a contradictory current aggregate.
-  data.annualStatements[0]!.currency = "GBP";
-  data.financialCurrency = "EUR";
-  expect(extractFundamentalSeries(data, source("trailingPE")).at(-1)?.value).toBe(35 / 3);
-});
-
-test("missing or unknown price units cannot borrow the statement currency or an exchange default", () => {
-  for (const currency of [undefined, "", "   ", "XXX", "unknown"]) {
-    const data = fixture(); data.quote!.currency = currency;
-    for (const metric of fields) {
-      expect(extractFundamentalSeries(data, source(metric))).toEqual([]);
-      expect(valuationCurrencyWarning(data, source(metric))).toContain("unknown price");
-    }
-    // The provider's own forward multiple does not multiply these statement legs.
-    data.fundamentals = { forwardPE: 12 };
-    expect(extractFundamentalSeries(data, source("forwardPE"))[0]?.value).toBe(12);
-    expect(valuationCurrencyWarning(data, source("forwardPE"))).toBeUndefined();
-  }
-});
-
-test("historical currency changes prevent filling missing row units from the current aggregate", () => {
-  const data = fixture();
-  data.quote!.lastUpdated = 0; // Historical observations only.
-  data.annualStatements = [
-    { ...data.annualStatements[0]!, date: "2023-12-31", currency: "GBP" },
-    { ...data.annualStatements[0]!, date: "2024-12-31", currency: "EUR" },
-    { ...data.annualStatements[0]!, date: "2025-12-31" },
-  ];
-  const points = extractFundamentalSeries(data, source("trailingPE"));
-  expect(points.map((point) => point.observedAt.toISOString().slice(0, 10))).toEqual(["2023-12-31", "2024-12-31", "2025-12-31"]);
-  expect(points.map((point) => point.value)).toEqual([10, null, null]);
-  expect(valuationCurrencyWarning(data, source("trailingPE"))).toContain("EUR/unknown");
-});
-
-test("GBP and explicitly declared pence denominations produce the same ratios without FX or double scaling", () => {
-  const baseline = fixture();
-  for (const currency of ["GBp", "GBX"]) {
-    const raw = fixture(); raw.quote!.currency = currency; raw.quote!.price *= 100;
-    raw.priceHistory = raw.priceHistory.map((row) => ({ ...row, close: row.close * 100 }));
-    for (const metric of fields) {
-      expect(extractFundamentalSeries(raw, source(metric)).map((point) => point.value))
-        .toEqual(extractFundamentalSeries(baseline, source(metric)).map((point) => point.value));
-      expect(valuationCurrencyWarning(raw, source(metric))).toBeUndefined();
-    }
-  }
-  const minorStatement = fixture();
-  minorStatement.annualStatements[0]!.currency = "GBp";
-  for (const key of ["eps", "totalRevenue", "totalDebt", "cashAndCashEquivalents", "ebitda", "freeCashFlow"] as const) {
-    minorStatement.annualStatements[0]![key]! *= 100;
-  }
-  for (const metric of fields) {
-    expect(extractFundamentalSeries(minorStatement, source(metric)).map((point) => point.value))
-      .toEqual(extractFundamentalSeries(baseline, source(metric)).map((point) => point.value));
-  }
-  // A denomination change cannot supply the units of a missing historical row.
-  minorStatement.annualStatements.push({ ...baseline.annualStatements[0]!, date: "2026-03-31" });
-  expect(valuationCurrencyWarning(minorStatement, source("trailingPE"))).toContain("unknown");
-});
-
-test("chart and headless export explain withheld currency ratios and recover when compatible units arrive", async () => {
-  const data = fixture(); data.financialCurrency = "USD";
-  const spec: ChartSpec = { version: CHART_SPEC_VERSION, viewport: { range: "5Y", resolution: "1d" },
-    panels: [{ id: "main" }], studies: [], series: [{ id: "pe", source: source("trailingPE"),
-      style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none" }] };
-  const context = {
-    marketData: createTestDataProvider({ getTickerFinancials: async () => data,
-      getQuote: async () => data.quote!, getPriceHistoryForResolution: async () => data.priceHistory }),
-    config: createDefaultConfig("/tmp/valuation-currency-test"), signal: new AbortController().signal,
-    apiClient: {} as Parameters<typeof loadChartPaneModel>[1]["apiClient"],
-  };
-  const blocked = await loadChartPaneModel(spec, context);
-  expect(blocked.series[0]?.points).toEqual([]);
-  expect(blocked.unavailableSymbols).toHaveLength(1);
-  expect(blocked.metadata?.warnings).toEqual(expect.arrayContaining([expect.stringContaining("USD reporting, GBP price")]));
-  // The mismatch is the one explanation for the empty series.
-  expect((blocked.metadata?.warnings as string[]).some((warning) => warning.includes("no observations"))).toBe(false);
-  expect(blocked.metadata?.summaries).toEqual(expect.arrayContaining([expect.objectContaining({ endValue: null, unit: "x" })]));
-  data.annualStatements[0]!.currency = "GBP";
-  const recovered = await loadChartPaneModel(spec, context);
-  expect(recovered.series[0]?.points.at(-1)?.value).toBe(35 / 3);
-  expect(recovered.unavailableSymbols).toEqual([]);
-  expect((recovered.metadata?.warnings as string[]).some((warning) => warning.includes("Valuation currency"))).toBe(false);
-});

package/src/time-series/valuation-denominator.test.ts

@@ -1,240 +0,0 @@
-import { expect, test } from "bun:test";
-import { createTestDataProvider } from "../test-support/data-provider";
-import { createDefaultConfig } from "../types/config";
-import type { FinancialStatement, TickerFinancials } from "../types/financials";
-import { loadChartPaneModel } from "../plugins/builtin/chart-composer/headless";
-import { deriveQuarterlyStatements, extractFundamentalSeries } from "./fundamentals";
-import type { ChartSpec, SecuritySeriesSource } from "./types";
-
-const source = (period: SecuritySeriesSource["period"] = "annual", metric = "trailingPE"): SecuritySeriesSource => ({
-  kind: "security", instrument: { symbol: "TEST", exchange: "NYSE" },
-  fieldId: `valuation.${metric}`, period, timestampMode: "available-at",
-});
-const fixture = (): TickerFinancials => ({
-  financialCurrency: "USD",
-  quote: { symbol: "TEST", currency: "USD", price: 60, lastUpdated: Date.parse("2026-09-11T20:00Z"), change: 0, changePercent: 0 },
-  annualStatements: [
-    { date: "2024-12-31", availableAt: "2025-03-01", currency: "USD", eps: 10 },
-    { date: "2025-12-31", availableAt: "2026-03-01", currency: "USD", eps: -2 },
-  ],
-  quarterlyStatements: [],
-  priceHistory: [
-    { date: new Date("2025-03-01"), close: 50 },
-    { date: new Date("2026-03-01"), close: 55 },
-  ],
-});
-
-test("Current valuation chooses the latest available statement before evaluating its denominator", () => {
-  for (const earnings of [-2, 0, undefined]) {
-    const data = fixture(); data.annualStatements[1]!.eps = earnings;
-    const original = JSON.stringify(data);
-    expect(extractFundamentalSeries(data, source()).map(({ value, periodLabel }) => [value, periodLabel]))
-      .toEqual([[5, "Year ended 2024-12-31"], [null, "Year ended 2025-12-31"]]);
-    expect(JSON.stringify(data)).toBe(original);
-  }
-  // An unpublished loss does not replace the earnings known at this quote time.
-  const future = fixture(); future.annualStatements[1]!.fieldAvailability = { eps: "2026-10-01" };
-  expect(extractFundamentalSeries(future, source()).find(point => point.periodLabel === "Current")?.value).toBe(6);
-  // A corrected positive latest observation resumes calculation on that period.
-  future.annualStatements[1] = { ...future.annualStatements[1]!, eps: 3, fieldAvailability: { eps: "2026-03-01" } };
-  expect(extractFundamentalSeries(future, source()).at(-1)?.value).toBe(20);
-});
-
-test("automatic valuation coverage does not substitute a profitable annual period for loss-making TTM inputs", () => {
-  const data = fixture();
-  data.annualStatements = [data.annualStatements[0]!];
-  data.quarterlyStatements = ["2025-06-30", "2025-09-30", "2025-12-31", "2026-03-31"]
-    .map((date) => ({ date, currency: "USD", eps: -1 }));
-  for (const period of ["auto", "ttm"] as const) {
-    expect(extractFundamentalSeries(data, source(period))).toEqual([]);
-  }
-  // Missing TTM earnings coverage can still use the independently requested
-  // automatic annual fallback; this is different from known unprofitable input.
-  data.quarterlyStatements = data.quarterlyStatements.map(({ eps, ...row }) => row);
-  expect(extractFundamentalSeries(data, source("auto")).at(-1)?.value).toBe(6);
-  expect(extractFundamentalSeries(data, source("ttm"))).toEqual([]);
-});
-
-test("finite reported EPS takes precedence over aggregate income and shares, including zero", () => {
-  for (const eps of [0, -0, -2, 2]) {
-    const data = fixture();
-    Object.assign(data.annualStatements[1]!, { eps, netIncome: 100, netIncomeCommonStockholders: eps * 10, dilutedShares: 10 });
-    const original = structuredClone(data);
-    const points = extractFundamentalSeries(data, source());
-    expect(points.map(({ value }) => value)).toEqual(eps > 0 ? [5, 27.5, 30] : [5, null]);
-    expect(data).toEqual(original);
-  }
-  // Only unavailable/nonfinite reported EPS keeps the existing derivation.
-  for (const eps of [undefined, NaN, Infinity]) {
-    const data = fixture();
-    Object.assign(data.annualStatements[1]!, { eps, netIncome: 100, dilutedShares: 10 });
-    expect(extractFundamentalSeries(data, source()).map(({ value }) => value)).toEqual([5, 5.5, 6]);
-  }
-});
-
-test("zero TTM reported EPS is coverage, not permission to use aggregate income or annual EPS", () => {
-  for (const earnings of [[0, 0, 0, 0], [1, -1, 2, -2]]) {
-    const data = fixture();
-    data.annualStatements = [data.annualStatements[0]!];
-    data.quarterlyStatements = ["2025-06-30", "2025-09-30", "2025-12-31", "2026-03-31"]
-      .map((date, index) => ({ date, currency: "USD", eps: earnings[index], netIncome: 25, dilutedShares: 10 }));
-    for (const period of ["auto", "ttm"] as const) {
-      expect(extractFundamentalSeries(data, source(period))).toEqual([]);
-    }
-    data.quarterlyStatements = data.quarterlyStatements.map(({ eps, ...row }) => row);
-    for (const period of ["auto", "ttm"] as const) {
-      expect(extractFundamentalSeries(data, source(period)).at(-1)?.value).toBe(6);
-    }
-  }
-});
-
-test("reported zero EPS uses its own availability; absent EPS uses income and shares availability", () => {
-  const data = fixture();
-  const latest = data.annualStatements[1]!;
-  Object.assign(latest, { eps: 0, netIncome: 200, dilutedShares: 10,
-    fieldAvailability: { eps: "2026-03-01", netIncome: "2026-10-01", dilutedShares: "2026-10-01" } });
-  // The known zero is effective even though alternative inputs are unpublished.
-  expect(extractFundamentalSeries(data, source()).map(({ value }) => value)).toEqual([5, null]);
-  latest.fieldAvailability = { eps: "2026-10-01", netIncome: "2026-03-01", dilutedShares: "2026-03-01" };
-  // Before reported EPS is available, the older published period remains current.
-  expect(extractFundamentalSeries(data, source()).map(({ value }) => value)).toEqual([5, 6, null]);
-  latest.eps = undefined;
-  expect(extractFundamentalSeries(data, source()).map(({ value }) => value)).toEqual([5, 2.75, 3]);
-  latest.fieldAvailability.dilutedShares = "2026-10-01";
-  expect(extractFundamentalSeries(data, source()).find(({ periodLabel }) => periodLabel === "Current")?.value).toBe(6);
-});
-
-test("missing EPS selects common income including zero and loss, without requiring aggregate income", () => {
-  for (const common of [60, 0, -20]) {
-    for (const netIncome of [100, undefined]) {
-      const data = fixture();
-      Object.assign(data.annualStatements[1]!, { eps: undefined, netIncome, netIncomeCommonStockholders: common, dilutedShares: 10, basicShares: 8 });
-      const original = structuredClone(data);
-      const points = extractFundamentalSeries(data, source());
-      expect(points.map(({ value }) => value)).toEqual(common > 0 ? [5, 55 / 6, 10] : [5, null]);
-      expect(points.every(({ provenance }) => provenance?.quality === "derived")).toBe(true);
-      expect(data).toEqual(original);
-    }
-  }
-  // Unusable common-income inputs do not manufacture a number or zero claim.
-  for (const common of [undefined, NaN, Infinity]) {
-    const data = fixture();
-    Object.assign(data.annualStatements[1]!, { eps: undefined, netIncome: 100, netIncomeCommonStockholders: common, dilutedShares: 10 });
-    expect(extractFundamentalSeries(data, source()).at(-1)?.value).toBe(6);
-  }
-});
-
-test("common-income fallback uses selected share and income availability, not aggregate publication time", () => {
-  const data = fixture();
-  const latest = data.annualStatements[1]!;
-  Object.assign(latest, { eps: undefined, netIncome: 100, netIncomeCommonStockholders: 60, dilutedShares: 10, basicShares: 8,
-    fieldAvailability: { netIncome: "2026-10-01", netIncomeCommonStockholders: "2026-03-01", dilutedShares: "2026-03-01", basicShares: "2026-03-01" } });
-  let points = extractFundamentalSeries(data, source());
-  expect(points.at(-1)?.value).toBe(10);
-  expect(points[1]?.availableAt?.toISOString()).toBe("2026-03-01T00:00:00.000Z");
-  latest.fieldAvailability!.netIncomeCommonStockholders = "2026-10-01";
-  expect(extractFundamentalSeries(data, source()).find(({ periodLabel }) => periodLabel === "Current")?.value).toBe(6);
-  latest.fieldAvailability!.netIncomeCommonStockholders = "2026-03-01";
-  latest.fieldAvailability!.dilutedShares = "2026-10-01";
-  expect(extractFundamentalSeries(data, source()).find(({ periodLabel }) => periodLabel === "Current")?.value).toBe(6);
-  for (const dilutedShares of [undefined, 0, -1, NaN, Infinity]) {
-    latest.dilutedShares = dilutedShares;
-    expect(extractFundamentalSeries(data, source()).at(-1)?.value).toBe(8);
-  }
-  latest.basicShares = undefined;
-  expect(extractFundamentalSeries(data, source()).map(({ value }) => value)).toEqual([5, null]);
-  latest.ordinarySharesNumber = 5;
-  latest.fieldAvailability!.ordinarySharesNumber = "2026-03-01";
-  expect(extractFundamentalSeries(data, source()).at(-1)?.value).toBe(5);
-  latest.ordinarySharesNumber = undefined;
-  latest.shareIssued = 4;
-  latest.fieldAvailability!.shareIssued = "2026-03-01";
-  expect(extractFundamentalSeries(data, source()).at(-1)?.value).toBe(4);
-  latest.dilutedShares = 10;
-  latest.fieldAvailability!.dilutedShares = "2026-03-01";
-  delete latest.fieldAvailability!.netIncomeCommonStockholders;
-  const undated = extractFundamentalSeries(data, source()).find(({ periodLabel }) => periodLabel === "Year ended 2025-12-31")!;
-  expect(undated.availableAt).toBeUndefined();
-  expect(undated.date.toISOString()).toBe("2025-12-31T00:00:00.000Z");
-});
-
-test("TTM keeps a complete common numerator and averaged shares; partial common coverage cannot become aggregate earnings", () => {
-  const data = fixture();
-  data.annualStatements = [data.annualStatements[0]!];
-  data.quarterlyStatements = ["2025-06-30", "2025-09-30", "2025-12-31", "2026-03-31"].map((date, index) => ({
-    date, currency: "USD", netIncome: 25, netIncomeCommonStockholders: [6, 12, 18, 24][index],
-    dilutedShares: [8, 10, 12, 10][index], basicShares: 5,
-    fieldAvailability: { netIncomeCommonStockholders: "2026-04-30", dilutedShares: "2026-05-01", netIncome: "2026-10-01" },
-  }));
-  for (const period of ["ttm", "auto"] as const) {
-    const points = extractFundamentalSeries(data, source(period));
-    expect(points.at(-1)?.value).toBe(10);
-    expect(points[0]?.availableAt?.toISOString()).toBe("2026-05-01T00:00:00.000Z");
-  }
-  data.quarterlyStatements[1]!.netIncomeCommonStockholders = undefined;
-  for (const period of ["ttm", "auto"] as const) expect(extractFundamentalSeries(data, source(period))).toEqual([]);
-  expect(extractFundamentalSeries(data, { ...source("ttm"), fieldId: "fundamental.netIncome" }).at(-1)?.value).toBe(100);
-  // Complete reported EPS overrides the fallback coverage guard, including zero.
-  for (const eps of [0, 0.5]) {
-    for (const quarter of data.quarterlyStatements) { quarter.eps = eps; quarter.fieldAvailability!.eps = "2026-04-30"; }
-    expect(extractFundamentalSeries(data, source("auto")).at(-1)?.value).toBe(eps === 0 ? undefined : 30);
-  }
-  for (const quarter of data.quarterlyStatements) {
-    delete quarter.eps; delete quarter.netIncomeCommonStockholders;
-    quarter.fieldAvailability!.netIncome = "2026-04-30";
-  }
-  expect(extractFundamentalSeries(data, source("auto")).at(-1)?.value).toBe(6);
-});
-
-test("reported Q4 common earnings use their own income and share dates while unresolved EPS blocks fallback", () => {
-  const annual: FinancialStatement = { date: "2025-12-31", currency: "USD", netIncome: 100, netIncomeCommonStockholders: 60, dilutedShares: 10,
-    fieldAvailability: { netIncome: "2026-03-01", netIncomeCommonStockholders: "2026-03-05", dilutedShares: "2026-03-06" } };
-  const quarters: FinancialStatement[] = ["2025-03-31", "2025-06-30", "2025-09-30"].map((date, index) => ({ date, currency: "USD", netIncome: 25,
-    netIncomeCommonStockholders: [10, 20, 15][index], dilutedShares: [8, 10, 12][index], availableAt: "2025-11-01" }));
-  // Common allocations and weighted-average shares both require quarter inputs.
-  quarters.push({ date: "2025-12-31", currency: "USD", netIncomeCommonStockholders: 15, dilutedShares: 10,
-    fieldAvailability: { netIncomeCommonStockholders: "2026-03-05", dilutedShares: "2026-03-06" } });
-  const q4 = deriveQuarterlyStatements(quarters, [annual]).at(-1)!;
-  expect(q4).toMatchObject({ netIncomeCommonStockholders: 15, dilutedShares: 10,
-    fieldAvailability: { netIncomeCommonStockholders: "2026-03-05", dilutedShares: "2026-03-06" } });
-  const data = { ...fixture(), annualStatements: [annual], quarterlyStatements: quarters };
-  const points = extractFundamentalSeries(data, source("ttm"));
-  expect(points.at(-1)?.value).toBe(10);
-  expect(points[0]?.availableAt?.toISOString()).toBe("2026-03-06T00:00:00.000Z");
-  annual.epsBasis = { status: "unresolved", source: "sec", originalValue: 6, basisDate: "2026-03-01", evidence: [] };
-  quarters[3]!.epsBasis = { ...annual.epsBasis, originalValue: 1.5 };
-  expect(extractFundamentalSeries(data, source("annual"))).toEqual([]);
-  expect(extractFundamentalSeries(data, source("ttm"))).toEqual([]);
-});
-
-test("other current monetary ratios cannot skip a latest zero denominator", () => {
-  const cases: Array<[string, Partial<FinancialStatement>, keyof FinancialStatement]> = [
-    ["priceSales", { totalRevenue: 100, dilutedShares: 10 }, "totalRevenue"],
-    ["evSales", { totalRevenue: 100, dilutedShares: 10, totalDebt: 20, cashAndCashEquivalents: 5 }, "totalRevenue"],
-    ["evEbitda", { ebitda: 100, dilutedShares: 10, totalDebt: 20, cashAndCashEquivalents: 5 }, "ebitda"],
-    ["priceFcf", { freeCashFlow: 100, dilutedShares: 10 }, "freeCashFlow"],
-  ];
-  for (const [metric, fields, denominator] of cases) {
-    const data = fixture();
-    data.annualStatements = data.annualStatements.map((row, index) => ({ ...row, ...fields, ...(index ? { [denominator]: 0 } : {}) }));
-    expect(extractFundamentalSeries(data, source("annual", metric)).some((point) => point.periodLabel === "Current")).toBe(false);
-    data.quarterlyStatements = ["2025-06-30", "2025-09-30", "2025-12-31", "2026-03-31"]
-      .map((date) => ({ date, currency: "USD", ...fields, [denominator]: 0 }));
-    expect(extractFundamentalSeries(data, source("auto", metric))).toEqual([]);
-  }
-});
-
-test("chart and headless export preserve historical P/E without a Current point sourced from older earnings", async () => {
-  const data = fixture();
-  const spec: ChartSpec = { version: 1, viewport: { range: "5Y", resolution: "1d" }, panels: [{ id: "main" }], studies: [],
-    series: [{ id: "pe", source: source(), style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none" }] };
-  const context = { marketData: createTestDataProvider({ getTickerFinancials: async () => data,
-    getQuote: async () => data.quote!, getPriceHistoryForResolution: async () => data.priceHistory }),
-    apiClient: {} as any, config: createDefaultConfig("/tmp/valuation-denominator-test"), signal: new AbortController().signal };
-  const model = await loadChartPaneModel(spec, context);
-  expect(model.series[0]?.points.map((point) => point.value)).toEqual([5, null]);
-  expect(model.snapshot.financials[0]?.[1].annualStatements.at(-1)?.eps).toBe(-2);
-  data.annualStatements[1]!.eps = 3;
-  const recovered = await loadChartPaneModel(spec, context);
-  expect(recovered.series[0]?.points.at(-1)?.value).toBe(20);
-});

package/src/time-series/valuation-live-status.test.ts

@@ -1,64 +0,0 @@
-import { expect, test } from "bun:test";
-import { createTestDataProvider } from "../test-support/data-provider";
-import { resolveChartSpecData } from "./resolve";
-import { getLiveChartQuoteTargets, observeLiveChartQuotes } from "./live-quotes";
-import { createQuoteStoreFixture } from "./fixtures/quote-store";
-import type { Quote, TickerFinancials } from "../types/financials";
-import { CHART_SPEC_VERSION, type ChartSpec } from "./types";
-
-// Synthetic boundary inputs. This exercises actual subscription + resolver,
-// not a claim of a newly fetched provider quote or native render execution.
-for (const receivedAt of [undefined, 42]) {
-  test(`equal source-time stale changes flow through actual resolver with receipt ${receivedAt}`, async () => {
-    const quote: Quote = { symbol: "TEST", currency: "USD", price: 60, change: 0, changePercent: 0,
-      lastUpdated: Date.parse("2026-09-11T20:00:00Z"), stale: false,
-      ...(receivedAt === undefined ? {} : { receivedAt }) };
-    const financials: TickerFinancials = { financialCurrency: "USD", quote,
-      annualStatements: [{ date: "2025-12-31", availableAt: "2026-09-10T14:00:00Z", currency: "USD", eps: 10 }],
-      quarterlyStatements: [], priceHistory: [{ date: new Date("2026-09-10T13:30:00Z"), close: 55 }] };
-    const spec: ChartSpec = { version: CHART_SPEC_VERSION, viewport: { range: "5Y", resolution: "1d" },
-      panels: [{ id: "main" }], studies: [], series: [{ id: "pe", source: { kind: "security", instrument: { symbol: "TEST", exchange: "NYSE" },
-        fieldId: "valuation.trailingPE", period: "annual", timestampMode: "available-at" },
-        style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none" }] };
-    const provider = createTestDataProvider({ getTickerFinancials: async () => financials,
-      getQuote: async () => financials.quote!, getPriceHistoryForResolution: async () => financials.priceHistory });
-    const store = createQuoteStoreFixture();
-    const target = getLiveChartQuoteTargets(spec)[0]!;
-    const results: Awaited<ReturnType<typeof resolveChartSpecData>>[] = [];
-    const pending: Promise<unknown>[] = [];
-    const stop = observeLiveChartQuotes({ spec, store, onChange: (quoteOverrides) => {
-      pending.push(resolveChartSpecData(spec, { dataProvider: provider,
-        now: new Date("2026-09-12T00:00:00Z"), quoteOverrides }).then((result) => results.push(result)));
-    } });
-    async function send(next: Quote) {
-      store.emit(target, next);
-      await Promise.all(pending);
-    }
-    try {
-      await send({ ...quote });
-      expect(results).toHaveLength(1);
-      expect(results.at(-1)?.series[0]?.points.map(point => point.value)).toEqual([5.5, 6]);
-      await send({ ...quote, stale: true });
-      expect(results).toHaveLength(2);
-      expect(results.at(-1)?.series[0]?.points.map(point => point.value)).toEqual([5.5]);
-      expect(results.at(-1)?.warnings.some(warning => warning.includes("source quote is stale"))).toBe(true);
-      await send({ ...quote, stale: false });
-      expect(results).toHaveLength(3);
-      expect(results.at(-1)?.series[0]?.points.map(point => point.value)).toEqual([5.5, 6]);
-      expect(results.at(-1)?.warnings.some(warning => warning.includes("source quote is stale"))).toBe(false);
-      // An older source observation must remain rejected even with a newer receipt.
-      await send({ ...quote, lastUpdated: quote.lastUpdated - 60_000, stale: true, receivedAt: 500 });
-      expect(results).toHaveLength(3);
-      // Exact duplicate and receipt-only heartbeat must not rebuild the chart.
-      await send({ ...quote });
-      await send({ ...quote, receivedAt: 1000 });
-      expect(results).toHaveLength(3);
-      // After advancing the receipt, delayed older-receipt status is also rejected.
-      await send({ ...quote, stale: true, receivedAt: 999 });
-      expect(results).toHaveLength(3);
-      await send({ ...quote, stale: true, receivedAt: 1000 });
-      expect(results).toHaveLength(4);
-      expect(results.at(-1)?.series[0]?.points.map(point => point.value)).toEqual([5.5]);
-    } finally { stop(); }
-  });
-}