gloomberb 0.13.3 → 0.14.0

package/src/plugins/builtin/world-indices/pane.test.tsx

@@ -1,11 +1,14 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useMemo, useState } from "react";
 import { testRender } from "../../../renderers/opentui/test-utils";
-import { AppContext, createInitialState, PaneInstanceProvider } from "../../../state/app/context";
+import { createInitialState } from "../../../state/app/context";
 import { createDefaultConfig } from "../../../types/config";
 import type { QuoteBatchResult } from "../../../types/data-provider";
-import { PluginRenderProvider, type PluginRuntimeAccess } from "../../runtime";
+import type { PluginRuntimeAccess } from "../../runtime";
 import { worldIndicesModule } from "./index";
+import { Box } from "../../../ui";
+import { PaneFooterProvider, PaneFooterBar } from "../../../components/layout/pane/footer";
+import { TestPaneProvider, createTestPaneConfig } from "../../../test-support/pane";
 
 const WorldIndicesPane = worldIndicesModule.panes![0]!.component as (props: {
   paneId: string;
@@ -53,19 +56,15 @@ function Harness() {
   }, [mode]);
 
   return (
-    <AppContext value={{ state, dispatch: () => {} }}>
-      <PluginRenderProvider runtime={runtime} pluginId="market-overview">
-        <PaneInstanceProvider paneId="world-indices">
-          <WorldIndicesPane
-            paneId="world-indices"
-            paneType="world-indices"
-            focused
-            width={80}
-            height={24}
-          />
-        </PaneInstanceProvider>
-      </PluginRenderProvider>
-    </AppContext>
+    <TestPaneProvider state={state} paneId="world-indices" runtime={runtime} pluginId="market-overview">
+      <WorldIndicesPane
+        paneId="world-indices"
+        paneType="world-indices"
+        focused
+        width={80}
+        height={24}
+      />
+    </TestPaneProvider>
   );
 }
 
@@ -95,6 +94,7 @@ describe("WorldIndicesPane", () => {
     expect(frame).toContain("Americas");
     expect(frame).toContain("SPX");
     expect(frame).toContain("6,812.44");
+    expect(frame).not.toContain("$6,812.44");
     expect(frame).toContain("+0.42%");
   });
 
@@ -114,3 +114,43 @@ describe("WorldIndicesPane", () => {
     expect(frame).toContain("SPX");
   });
 });
+
+// Saved selections share one live pane, so removed regions must leave no status behind.
+test.each([80, 120])("saved index selection prunes unavailable counts and source times at %i cells", async (width) => {
+  const times = { "^GSPC": Date.parse("2026-09-11T20:46:00Z"), "^FTSE": Date.parse("2026-09-11T15:35:00Z") };
+  let selectSymbols!: (symbols: string[]) => void;
+  const provider = { getQuotesBatch: async (targets: Array<{ symbol: string }>) => targets.map((target) => ({
+    target, quote: target.symbol === "DX-Y.NYB" ? null : {
+      symbol: target.symbol, price: PRICES[target.symbol], change: 12.5, changePercent: 0.42,
+      currency: "USD", marketState: "CLOSED", lastUpdated: times[target.symbol as keyof typeof times],
+    },
+  })) };
+  const runtime = { getMarketData: () => provider } as unknown as PluginRuntimeAccess;
+  function SelectionHarness() {
+    const [symbols, setSymbols] = useState(["^GSPC", "^FTSE", "DX-Y.NYB"]);
+    selectSymbols = setSymbols;
+    const config = createTestPaneConfig("/tmp/gloomberb-wei-selection-test", {
+      paneId: "world-indices", instanceId: "world-indices", settings: { symbols },
+    });
+    const state = createInitialState(config);
+    return <TestPaneProvider state={state} paneId="world-indices" runtime={runtime} pluginId="market-overview">
+      <PaneFooterProvider>{(footer) => <Box width={width} height={24} flexDirection="column">
+        <Box width={width} height={23}><WorldIndicesPane paneId="world-indices" paneType="world-indices" focused width={width} height={23} /></Box>
+        <PaneFooterBar footer={footer} focused width={width} />
+      </Box>}</PaneFooterProvider>
+    </TestPaneProvider>;
+  }
+  await act(async () => { testSetup = await testRender(<SelectionHarness />, { width, height: 24 }); });
+  await settle();
+  const formatTime = (value: number) => new Date(value).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  expect(testSetup!.captureCharFrame()).toContain("1 unavailable");
+  expect(testSetup!.captureCharFrame()).toContain(formatTime(times["^GSPC"]));
+  await act(async () => selectSymbols(["^FTSE"]));
+  await settle();
+  const frame = testSetup!.captureCharFrame();
+  expect(frame).toContain("FTSE");
+  expect(frame).not.toContain("DXY");
+  expect(frame).not.toContain("unavailable");
+  expect(frame).toContain(formatTime(times["^FTSE"]));
+  expect(frame).not.toContain(formatTime(times["^GSPC"]));
+});

package/src/plugins/builtin/world-indices/table.tsx

@@ -2,7 +2,7 @@ import type { DataTableCell, DataTableColumn } from "../../../components";
 import { marketStateColor, marketStateLabel } from "../../../market-data/market/status";
 import { colors, priceColor } from "../../../theme/colors";
 import { TextAttributes } from "../../../ui";
-import { formatCurrency, formatNumber, formatPercentRaw } from "../../../utils/format";
+import { formatNumber, formatPercentRaw } from "../../../utils/format";
 import { marketStatusDot, type BoardQuoteMap } from "../shared/use-quote-board";
 import type {
   WorldIndexColumnId,
@@ -114,10 +114,10 @@ export function renderWorldIndexCell(
       };
     case "price":
       if (loadingCell) return { text: "…", color: dimmed };
-      if (quote?.price === undefined) return { text: "—", color: dimmed };
+      if (!quote || !Number.isFinite(quote.price)) return { text: "—", color: dimmed };
       // A retained quote still beats a dash; dim it so stale is visible.
       return {
-        text: formatCurrency(quote.price, quote.currency ?? "USD"),
+        text: formatNumber(quote.price, 2),
         color: state?.stale ? dimmed : selectedColor,
       };
     case "change":

package/src/plugins/builtin/world-venue-map/map.desktop.test.tsx

@@ -1,53 +1,11 @@
 /** @jsxImportSource react */
-import { Window } from "happy-dom";
-
-const testWindow = new Window({ url: "http://localhost" });
-const domGlobals = {
-  IS_REACT_ACT_ENVIRONMENT: true,
-  window: testWindow,
-  document: testWindow.document,
-  navigator: testWindow.navigator,
-  KeyboardEvent: testWindow.KeyboardEvent,
-  MouseEvent: testWindow.MouseEvent,
-  WheelEvent: testWindow.WheelEvent,
-  HTMLElement: testWindow.HTMLElement,
-  Node: testWindow.Node,
-};
-const priorGlobals = Object.fromEntries(
-  Object.keys(domGlobals).map((key) => [key, (globalThis as Record<string, unknown>)[key]]),
-);
-Object.assign(globalThis, domGlobals);
-
-import { afterAll, afterEach, expect, test } from "bun:test";
+import { expect, test } from "bun:test";
 import { act } from "react";
-import { createRoot } from "react-dom/client";
-import { UiHostProvider, type RendererHost, type UiHost } from "../../../ui";
-import { WebBox } from "../../../renderers/electrobun/view/host/box";
-import { WebText } from "../../../renderers/electrobun/view/host/text";
 import { WorldVenueMap } from "./map";
 import type { CloudWorldVenuePayload } from "../../../api-client";
+import { createDomTestHarness } from "../../../renderers/electrobun/view/test-utils";
 
-const renderer: RendererHost = {
-  requestExit() {},
-  async openExternal() {},
-  async copyText() {},
-  async readText() { return ""; },
-  notify() {},
-};
-
-const ui = {
-  kind: "desktop-web",
-  capabilities: { cellWidthPx: 8, cellHeightPx: 18, fractionalViewport: true },
-  Box: WebBox,
-  Text: WebText,
-} as unknown as UiHost;
-
-afterAll(() => {
-  for (const [key, value] of Object.entries(priorGlobals)) {
-    if (value === undefined) delete (globalThis as Record<string, unknown>)[key];
-    else (globalThis as Record<string, unknown>)[key] = value;
-  }
-});
+const { window: testWindow, render: renderDom } = createDomTestHarness();
 
 const venue: CloudWorldVenuePayload = {
   mic: "XNYS",
@@ -62,35 +20,16 @@ const venue: CloudWorldVenuePayload = {
   isOpen: true,
 };
 
-let root: ReturnType<typeof createRoot> | undefined;
-let container: HTMLElement | undefined;
-
-afterEach(async () => {
-  if (root) {
-    await act(async () => root!.unmount());
-    root = undefined;
-  }
-  container?.remove();
-  container = undefined;
-});
-
 test("zooms the desktop map toward the pointer on wheel", async () => {
-  container = testWindow.document.createElement("div") as unknown as HTMLElement;
-  testWindow.document.body.appendChild(container as unknown as Node);
-  root = createRoot(container);
-  await act(async () => {
-    root!.render(
-      <UiHostProvider ui={ui} renderer={renderer}>
-        <WorldVenueMap
-          venues={[venue]}
-          selectedMic="XNYS"
-          width={80}
-          height={24}
-          onSelect={() => {}}
-        />
-      </UiHostProvider>,
-    );
-  });
+  const container = await renderDom(
+    <WorldVenueMap
+      venues={[venue]}
+      selectedMic="XNYS"
+      width={80}
+      height={24}
+      onSelect={() => {}}
+    />,
+  );
 
   const surface = container.querySelector('[data-gloom-role="world-venue-map"]') as HTMLElement;
   expect(surface).toBeTruthy();

package/src/plugins/builtin/world-venue-map/pane.tsx

@@ -3,25 +3,23 @@ import { apiClient, type CloudWorldVenueMapPayload, type CloudWorldVenuePayload
 import {
   DataTableView,
   EmptyState,
-  InputSearchBar,
-  Spinner,
-  usePaneFooter,
+  InputSearchBar, PaneStatusBody, usePaneFooter,
   type DataTableCell,
   type DataTableColumn,
-  type DataTableKeyEvent,
+  type DataTableKeyEvent
 } from "../../../components";
 import { useShortcut } from "../../../react/input";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, Text, TextAttributes, type InputRenderable } from "../../../ui";
 import { isPlainKey } from "../../../utils/keyboard";
+import { WorldVenueMap } from "./map";
 import {
   filterWorldVenues,
   formatVenueCountdown,
   formatVenueLocalTime,
   venueRemainingSeconds,
 } from "./model";
-import { WorldVenueMap } from "./map";
 
 export const WORLD_VENUE_MAP_PANE_ID = "world-venue-map";
 
@@ -266,10 +264,10 @@ export function WorldVenueMapPane({ focused, width, height }: PaneProps) {
   );
 
   if (!data && loading) {
-    return <Box width={width} height={height} alignItems="center" justifyContent="center"><Spinner label="Loading world venues..." /></Box>;
+    return <PaneStatusBody loading align="center" width={width} height={height} loadingLabel="Loading world venues..." />;
   }
   if (!data) {
-    return <EmptyState title="World venues unavailable." hint={error ?? "Try again."} />;
+    return <EmptyState status={error ? "error" : "empty"} title="World venues unavailable." hint={error ?? "Try again."} />;
   }
 
   const map = (

package/src/plugins/builtin/yield-curve/chart.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from "bun:test";
+import { buildStaticChartSeries } from "../../../components/chart/static/chart-surface";
+import { buildCompositeChartScene } from "../../../components/chart/composite/scene";
+import { buildYieldCurveChart } from "./chart";
+import { TREASURY_MATURITIES } from "./treasury-data";
+
+test("curve projection preserves maturity distances, including missing tenors", () => {
+  const source = TREASURY_MATURITIES.map(({ maturity, years }, index) => ({
+    maturity, maturityYears: years, yield: 4 + index / 10,
+  }));
+  for (const data of [source, source.filter(({ maturity }) => maturity !== "6M")]) {
+    const chart = buildYieldCurveChart(data, 62);
+    const scene = buildCompositeChartScene(buildStaticChartSeries(chart.points, "line", "green", [], true),
+      [{ id: "main" }], { width: 70, height: 12, rightOffsetRatio: 0 })!;
+    expect(scene.timeScale.kind).toBe("calendar");
+    const projected = scene.panels[0]!.series[0]!.points;
+    for (let index = 0; index < data.length; index++) {
+      expect(projected[index]!.xRatio).toBeCloseTo((data[index]!.maturityYears - 1 / 12) / (30 - 1 / 12), 10);
+      expect(projected[index]!.value).toBe(data[index]!.yield);
+    }
+    expect(chart.formatCursor(0)).toBe("1.0M");
+    expect(chart.formatCursor(1)).toBe("30.0Y");
+  }
+});
+
+test("partial curve ticks stay in range and readable at narrow widths", () => {
+  const source = [{ maturity: "5Y", maturityYears: 5, yield: 4 }, { maturity: "10Y", maturityYears: 10, yield: 4.3 }];
+  const chart = buildYieldCurveChart(source, 20);
+  expect(chart.ticks).toEqual([{ label: "5Y", ratio: 0 }, { label: "10Y", ratio: 1 }]);
+  expect(chart.formatCursor(0.5)).toBe("7.5Y");
+  expect(buildYieldCurveChart([], 20).points).toEqual([]);
+});

package/src/plugins/builtin/yield-curve/chart.ts

@@ -0,0 +1,37 @@
+import type { ProjectedChartPoint } from "../../../components/chart/core/data";
+import type { YieldPoint } from "./treasury-data";
+
+const YEAR_MS = 365 * 86_400_000;
+
+/** Encode maturity in the chart's continuous coordinate space, never as calendar labels. */
+export function buildYieldCurveChart(points: readonly YieldPoint[], width: number) {
+  const available = points.filter((point) => point.yield != null && Number.isFinite(point.yield)
+    && Number.isFinite(point.maturityYears) && point.maturityYears > 0)
+    .toSorted((a, b) => a.maturityYears - b.maturityYears);
+  const first = available[0];
+  const last = available.at(-1);
+  const min = first?.maturityYears ?? 0;
+  const span = (last?.maturityYears ?? min) - min;
+  const ratio = (years: number) => span > 0 ? (years - min) / span : 0;
+  const ticks = first && last && first !== last
+    ? [{ label: first.maturity, ratio: 0 }, { label: last.maturity, ratio: 1 }]
+    : [];
+  // Keep the short end dense in the data without piling up overlapping labels.
+  for (const years of [10, 20, 5, 2, 1]) {
+    const x = ratio(years);
+    if (x <= 0 || x >= 1 || ticks.some((tick) => Math.abs(tick.ratio - x) * Math.max(1, width - 1) < 6)) continue;
+    ticks.push({ label: `${years}Y`, ratio: x });
+  }
+  const chartPoints: ProjectedChartPoint[] = available.map((point) => ({
+    date: new Date(point.maturityYears * YEAR_MS),
+    open: point.yield!, high: point.yield!, low: point.yield!, close: point.yield!, volume: 0,
+  }));
+  return {
+    points: chartPoints,
+    ticks: ticks.toSorted((a, b) => a.ratio - b.ratio),
+    formatCursor: (x: number) => {
+      const years = min + Math.max(0, Math.min(1, x)) * span;
+      return years < 1 ? `${(years * 12).toFixed(1)}M` : `${years.toFixed(1)}Y`;
+    },
+  };
+}

package/src/plugins/builtin/yield-curve/headless.test.ts

@@ -1,11 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
 import { createYieldCurveHeadless } from "./headless";
+import { TREASURY_MATURITIES } from "./treasury-data";
 
 const args: HeadlessPaneLoadArgs = { rawArgument: "", argument: null, symbols: [], options: {} };
 
 describe("yield curve headless model", () => {
-  test("returns ordered maturities and the shared 2Y to 10Y spread", async () => {
+  test("marks a partial, mixed-date curve incomplete and does not calculate a spread", async () => {
     const headless = createYieldCurveHeadless({
       load: async () => [
         { maturity: "10Y", maturityYears: 10, yield: 4.1, asOf: "2026-09-03" },
@@ -13,12 +14,27 @@ describe("yield curve headless model", () => {
       ],
     });
     const result = await headless.load(args, {} as HeadlessPaneContext);
-
-    expect(result.rows.map((row) => row.maturity)).toEqual(["2Y", "10Y"]);
-    expect(result.metadata).toEqual({
-      asOf: "2026-09-04",
-      inverted: true,
-      spread2Y10YBasisPoints: -25,
+    expect(result.rows).toHaveLength(10);
+    expect(result.metadata).toMatchObject({
+      requestedDate: null, asOf: null, inverted: null, spread2Y10YBasisPoints: null,
+      missingTenors: ["1M", "3M", "6M", "1Y", "5Y", "7Y", "20Y", "30Y"], stale: false,
     });
+    expect(result.errors).toHaveLength(2);
+  });
+
+  test("date options call bounded series history, preserve observation dates and flag stale sources", async () => {
+    const calls: string[] = [];
+    const context = { apiClient: { getCloudFredSeries: async (id: string, options: { endDate: string }) => {
+      calls.push(`${id}:${options.endDate}`);
+      return {
+        info: { id, units: "Percent", frequency: "Daily" },
+        observations: [{ date: "2024-03-01", value: id === "DGS2" ? 4.54 : 4.19 }],
+        stale: id === "DGS30",
+      };
+    } } } as unknown as HeadlessPaneContext;
+    const result = await createYieldCurveHeadless().load({ ...args, options: { date: "2024-03-02" } }, context);
+    expect(calls).toEqual(TREASURY_MATURITIES.map(({ seriesId }) => `${seriesId}:2024-03-02`));
+    expect(result.metadata).toMatchObject({ requestedDate: "2024-03-02", asOf: "2024-03-01", spread2Y10YBasisPoints: -35, missingTenors: [], stale: true });
+    expect(result.errors).toEqual(["Some Treasury sources are stale cached data."]);
   });
 });

package/src/plugins/builtin/yield-curve/headless.ts

@@ -6,11 +6,12 @@ import {
   curveAsOf,
   isInverted,
   loadYieldCurve,
-  parseYieldPoints,
   spreadBasisPoints,
   type YieldCurveLoader,
   type YieldPoint,
+  yieldCurveErrors,
 } from "./treasury-data";
+import { completeYieldCurve, loadHistoricalYieldCurve, yieldCurveDate } from "./history";
 
 const COLUMNS = [
   { key: "maturity", header: "Maturity" },
@@ -42,22 +43,38 @@ export function createYieldCurveHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
-    argument: { kind: "none" },
-    options: [],
+    argument: { kind: "free-text", optional: true, placeholder: "YYYY-MM-DD", description: "Historical as-of date; omit for latest." },
+    options: [{ key: "date", type: "string", description: "Historical as-of date (YYYY-MM-DD); uses the latest observation on or before it." }],
     columns: COLUMNS,
     describe: "US Treasury Yield Curve",
     async load(args, ctx) {
-      const points = await dependencies.load(
+      const requestedDate = yieldCurveDate(args.options.date ?? args.argument);
+      const points = completeYieldCurve(await dependencies.load(
         args,
-        () => ctx.apiClient.getCloudYieldCurve(),
-      );
-      const rows = parseYieldPoints(points);
+        requestedDate
+          ? () => loadHistoricalYieldCurve(requestedDate, (id, options) => ctx.apiClient.getCloudFredSeries(id, options))
+          : () => ctx.apiClient.getCloudYieldCurve(),
+      ));
+      const rows = [...points].sort((a, b) => a.maturityYears - b.maturityYears);
+      const missingTenors = points.filter((point) => point.yield == null).map((point) => point.maturity);
+      const sourceErrors = yieldCurveErrors(points);
       return {
         rows: rows.map((point) => ({ ...point })),
+        errors: [
+          ...sourceErrors,
+          ...(missingTenors.length ? [`Treasury tenors unavailable: ${missingTenors.join(", ")}`] : []),
+          ...(!curveAsOf(points) ? ["Curve has mixed or unknown observation dates."] : []),
+          ...(points.some((point) => point.stale) ? ["Some Treasury sources are stale cached data."] : []),
+        ],
         metadata: {
+          source: "FRED / US Treasury constant maturity rates",
+          units: "Percent",
+          requestedDate: requestedDate || null,
           asOf: curveAsOf(points),
           inverted: isInverted(points),
           spread2Y10YBasisPoints: spreadBasisPoints(points),
+          missingTenors,
+          stale: points.some((point) => point.stale),
         },
       };
     },

package/src/plugins/builtin/yield-curve/history.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudFredSeriesPayload } from "../../../api-client";
+import { completeYieldCurve, loadHistoricalYieldCurve, yieldCurveDate } from "./history";
+import { curveAsOf, spreadBasisPoints } from "./treasury-data";
+
+function payload(id: string, observations: CloudFredSeriesPayload["observations"]): CloudFredSeriesPayload {
+  return {
+    observations,
+    info: { id, title: "Treasury", units: "Percent", frequency: "Daily", seasonalAdjustment: "Not Seasonally Adjusted", source: "FRED", notes: "" },
+    fetchedAt: "2026-09-10T12:00:00Z",
+    stale: false,
+  };
+}
+
+describe("historical Treasury curves", () => {
+  test("uses one preceding business date for a weekend and keeps the requested bounds", async () => {
+    const requests: unknown[] = [];
+    const points = await loadHistoricalYieldCurve("2024-03-02", async (id, options) => {
+      requests.push(options);
+      return payload(id, [
+        { date: "2024-03-04", value: 99 }, // An upstream over-fetch must not leak into the selected curve.
+        { date: "2024-03-02", value: null },
+        { date: "2024-03-01", value: id === "DGS2" ? 4.54 : 4.19 },
+        { date: "2024-02-29", value: 4.25 },
+      ]);
+    });
+    expect(requests).toHaveLength(10);
+    expect(requests[0]).toEqual({ startDate: "2024-02-21", endDate: "2024-03-02", limit: 10, sortOrder: "desc" });
+    expect(points).toHaveLength(10);
+    expect(curveAsOf(points)).toBe("2024-03-01");
+    expect(spreadBasisPoints(points)).toBe(-35);
+    expect(points.every((point) => point.asOf === "2024-03-01")).toBe(true);
+  });
+
+  test("partial failures and lagging tenors never carry older values into a newer curve", async () => {
+    const points = await loadHistoricalYieldCurve("2024-02-29", async (id) => {
+      if (id === "DGS30") throw new Error("provider unavailable");
+      if (id === "DGS2") return payload(id, [{ date: "2024-02-28", value: 4.64 }]);
+      if (id === "DGS20") return { ...payload(id, [{ date: "2024-02-29", value: 450 }]), info: { ...payload(id, []).info!, units: "Basis Points" } };
+      if (id === "DGS6MO") return { ...payload(id, [{ date: "2024-02-29", value: -0.2 }]), info: null };
+      return { ...payload(id, [{ date: "2024-02-29", value: id === "DGS1" ? 0 : -0.1 }]), stale: true };
+    });
+    expect(curveAsOf(points)).toBe("2024-02-29");
+    expect(spreadBasisPoints(points)).toBeNull();
+    expect(points.filter((point) => point.yield == null).map((point) => point.maturity)).toEqual(["2Y", "20Y", "30Y"]);
+    expect(points.find((point) => point.maturity === "1Y")?.yield).toBe(0);
+    expect(points[0]?.yield).toBe(-0.1);
+    expect(points[0]?.stale).toBe(true);
+    expect(points[0]?.fetchedAt).toBe("2026-09-10T12:00:00Z");
+    expect(points.find((point) => point.maturity === "6M")?.yield).toBe(-0.2);
+  });
+
+  test("does not return a fabricated empty curve when every series fails", async () => {
+    await expect(loadHistoricalYieldCurve("2024-02-29", async () => { throw new Error("offline"); })).rejects.toThrow("offline");
+    await expect(loadHistoricalYieldCurve("2024-02-29", async (id) => payload(id, [{ date: "2024-02-01", value: 4 }]))).rejects.toThrow("No Treasury observations");
+  });
+
+  test("validates real calendar dates before requesting history", async () => {
+    const now = new Date("2026-09-10T12:00:00Z");
+    expect(yieldCurveDate("2024-02-29", now)).toBe("2024-02-29");
+    expect(yieldCurveDate(" latest ", now)).toBe("");
+    for (const date of ["2023-02-29", "2024-02-30", "2024-2-1", "2024-01-01T00:00:00Z", 2024]) {
+      expect(() => yieldCurveDate(date, now)).toThrow("YYYY-MM-DD");
+    }
+    expect(() => yieldCurveDate("2026-09-11", now)).toThrow("future date");
+    let calls = 0;
+    await expect(loadHistoricalYieldCurve("2023-02-29", async (id) => { calls++; return payload(id, []); })).rejects.toThrow("YYYY-MM-DD");
+    expect(calls).toBe(0);
+  });
+
+  test("exposes omitted and invalid latest tenors as missing", () => {
+    const points = completeYieldCurve([
+      { maturity: "2Y", maturityYears: 2, yield: Number.NaN, asOf: "2024-02-29" },
+      { maturity: "10Y", maturityYears: 100, yield: 0, asOf: "2024-02-29" },
+    ]);
+    expect(points).toHaveLength(10);
+    expect(points.find((point) => point.maturity === "2Y")).toMatchObject({ yield: null, asOf: null });
+    expect(points.find((point) => point.maturity === "10Y")).toMatchObject({ yield: 0, maturityYears: 10 });
+  });
+});
+
+
+test("rejects a contrary or unidentified metadata response without dropping other tenors", async () => {
+  for (const identity of ["DGS10", "", undefined]) {
+    const points = await loadHistoricalYieldCurve("2024-03-02", async id => ({
+      ...payload(id, [{date: "2024-03-01", value: id === "DGS1" ? -0.2 : 0}]),
+      info: {...payload(id, []).info!, id: id === "DGS2" ? identity as string : id},
+    }));
+    expect(points.find(p => p.maturity === "2Y")).toMatchObject({yield: null, error: expect.stringContaining("Expected DGS2")});
+    expect(points.find(p => p.maturity === "10Y")).toMatchObject({yield: 0, asOf: "2024-03-01", error: undefined});
+    expect(points.find(p => p.maturity === "1Y")?.yield).toBe(-0.2);
+    expect(spreadBasisPoints(points)).toBeNull();
+  }
+});
+
+test("malformed dated observations cannot own a session but valid observations in that source survive", async () => {
+  const points = await loadHistoricalYieldCurve("2024-03-02", async id => payload(id, [
+    {date: "2024-02-30", value: 99}, {date: "2024-02-29", value: id === "DGS2" ? 4.54 : 4.19},
+  ]));
+  expect(curveAsOf(points)).toBe("2024-02-29");
+  expect(spreadBasisPoints(points)).toBe(-35);
+  expect(points.every(p => p.error?.includes("2024-02-30"))).toBe(true);
+  expect(points[0]?.fetchedAt).toBe("2026-09-10T12:00:00Z");
+  await expect(loadHistoricalYieldCurve("2024-03-02", async id => payload(id, [{date: "2024-02-30", value: 99}]))).rejects.toThrow("Invalid Treasury observation date");
+});
+
+test("latest invalid date retains reported yield as undated and cannot establish a spread", () => {
+  const raw = [{maturity: "2Y", maturityYears: 2, yield: 0, asOf: "2024-02-30"}, {maturity: "10Y", maturityYears: 10, yield: -0.2, asOf: "2024-02-30"}];
+  expect(curveAsOf(raw)).toBeNull();
+  expect(spreadBasisPoints(raw)).toBeNull();
+  const points = completeYieldCurve(raw);
+  expect(points.find(p => p.maturity === "2Y")).toMatchObject({yield: 0, asOf: null, error: "Invalid Treasury observation date: 2024-02-30"});
+  expect(points.find(p => p.maturity === "10Y")?.yield).toBe(-0.2);
+});
+
+test("missing metadata compatibility preserves values while a failed tenor carries its actual cause", async () => {
+  const points = await loadHistoricalYieldCurve("2024-03-02", async id => {
+    if (id === "DGS2") throw new Error("controlled 503");
+    return {...payload(id, [{date: "2024-03-01", value: 0}]), info: null};
+  });
+  expect(points.find(p => p.maturity === "2Y")).toMatchObject({yield: null, error: "controlled 503"});
+  expect(points.find(p => p.maturity === "10Y")).toMatchObject({yield: 0, error: undefined});
+  expect(curveAsOf(points)).toBe("2024-03-01");
+});

package/src/plugins/builtin/yield-curve/history.ts

@@ -0,0 +1,89 @@
+import { apiClient, type CloudFredSeriesPayload } from "../../../api-client";
+import { isYieldObservationDate, TREASURY_MATURITIES, type YieldPoint } from "./treasury-data";
+
+const DAY_MS = 86_400_000;
+export type TreasurySeriesLoader = (seriesId: string, options: {
+  startDate: string;
+  endDate: string;
+  limit: number;
+  sortOrder: "desc";
+}) => Promise<CloudFredSeriesPayload>;
+
+export function yieldCurveDate(value: unknown, now = new Date()): string {
+  if (value == null) return "";
+  const date = typeof value === "string" ? value.trim() : "";
+  if (typeof value === "string" && (date === "" || date.toLowerCase() === "latest")) return "";
+  if (!isYieldObservationDate(date)) {
+    throw new Error("Use an as-of date in YYYY-MM-DD format, or latest.");
+  }
+  if (date > now.toISOString().slice(0, 10)) throw new Error("A Treasury curve cannot use a future date.");
+  return date;
+}
+
+export function completeYieldCurve(points: readonly YieldPoint[]): YieldPoint[] {
+  return TREASURY_MATURITIES.map(({ maturity, years }) => {
+    const found = points.find((point) => point.maturity === maturity);
+    return found && found.yield != null && Number.isFinite(found.yield)
+      ? { ...found, maturityYears: years,
+        ...(found.asOf != null && !isYieldObservationDate(found.asOf)
+          ? { asOf: null, error: `Invalid Treasury observation date: ${found.asOf}` } : {}) }
+      : { ...found, maturity, maturityYears: years, yield: null, asOf: null };
+  });
+}
+
+/** Pick one published session on/before the requested date. A lagging tenor is
+ * unavailable for that curve, never silently carried from a different session. */
+export async function loadHistoricalYieldCurve(
+  requestedDate: string,
+  loader: TreasurySeriesLoader = (id, options) => apiClient.getCloudFredSeries(id, options),
+): Promise<YieldPoint[]> {
+  const endDate = yieldCurveDate(requestedDate);
+  if (!endDate) throw new Error("A historical curve requires a date.");
+  const startDate = new Date(Date.parse(endDate) - 10 * DAY_MS).toISOString().slice(0, 10);
+  const results = await Promise.allSettled(TREASURY_MATURITIES.map(async ({ seriesId }) => {
+    const payload = await loader(seriesId, { startDate, endDate, limit: 10, sortOrder: "desc" });
+    if (payload.info && payload.info.id !== seriesId) {
+      throw new Error(`Expected ${seriesId}, received ${payload.info.id || "unknown series"}`);
+    }
+    // These fixed DGS series are daily percentages. A metadata endpoint outage
+    // can retain usable observations; contradictory metadata must not be used.
+    if (payload.info && (payload.info.units?.toLowerCase() !== "percent" || payload.info.frequency?.toLowerCase() !== "daily")) {
+      throw new Error(`${seriesId}: unexpected Treasury units or frequency`);
+    }
+    const invalidDate = payload.observations.find((point) =>
+      point.value != null && Number.isFinite(point.value) && !isYieldObservationDate(point.date));
+    const observations = payload.observations.filter((point): point is { date: string; value: number } =>
+      isYieldObservationDate(point.date) && point.date >= startDate && point.date <= endDate
+      && point.value != null && Number.isFinite(point.value));
+    return { payload, observations,
+      error: invalidDate ? `Invalid Treasury observation date: ${invalidDate.date}` : undefined };
+  }));
+  const dates = results.flatMap((result) => result.status === "fulfilled"
+    ? result.value.observations.map((point) => point.date) : []);
+  const asOf = dates.sort().at(-1);
+  const errors = results.flatMap((result, index) => {
+    const error = result.status === "rejected"
+      ? result.reason instanceof Error ? result.reason.message : String(result.reason)
+      : result.value.error;
+    return error ? [`${TREASURY_MATURITIES[index]!.maturity}: ${error}`] : [];
+  });
+  if (!asOf) throw new Error(errors.length
+    ? `Treasury curve unavailable: ${errors.join("; ")}`
+    : `No Treasury observations available on or within 10 days before ${endDate}.`);
+  return TREASURY_MATURITIES.map(({ maturity, years }, index) => {
+    const result = results[index]!;
+    const data = result.status === "fulfilled" ? result.value : null;
+    const point = data?.observations.find((entry) => entry.date === asOf);
+    return {
+      maturity,
+      maturityYears: years,
+      yield: point?.value ?? null,
+      asOf: point ? asOf : null,
+      stale: data?.payload.stale ?? false,
+      fetchedAt: data?.payload.fetchedAt,
+      error: result.status === "rejected"
+        ? result.reason instanceof Error ? result.reason.message : String(result.reason)
+        : data?.error,
+    };
+  });
+}