gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/yield-curve/index.tsx

@@ -1,27 +1,36 @@
-import { Box, ScrollBox, Text } from "../../../ui";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Button, DataTableView, Notice, PaneStatusBody, StaticChartSurface, TextField, type PaneFooterSegment } from "../../../components";
+import { resolveChartPalette } from "../../../components/chart/core/palette";
+import { useAsyncResource } from "../../../react/async-resource";
 import { useShortcut } from "../../../react/input";
-import { Button, EmptyState, Spinner, StaticChartSurface, type PaneFooterSegment } from "../../../components";
+import { usePaneSettingValue } from "../../../state/app/context";
+import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
+import { Box, ScrollBox, Text, type InputRenderable } from "../../../ui";
 import type { PluginModule } from "../plugin-module";
-import { colors } from "../../../theme/colors";
-import { resolveChartPalette } from "../../../components/chart/core/palette";
-import type { ProjectedChartPoint } from "../../../components/chart/core/data";
+import { useAutoRefresh } from "../shared/auto-refresh";
+import { usePaneStatusFooter } from "../shared/pane-footer";
+import { yieldCurveHeadless } from "./headless";
+import { buildYieldCurveChart } from "./chart";
+import { completeYieldCurve, loadHistoricalYieldCurve, yieldCurveDate } from "./history";
 import {
   curveAsOf,
   loadYieldCurve,
   parseYieldPoints,
-  isInverted,
   spreadBasisPoints,
-  TREASURY_MATURITIES,
   type YieldPoint,
+  yieldCurveErrors,
 } from "./treasury-data";
-import { usePaneStatusFooter } from "../shared/pane-footer";
-import { useAutoRefresh, useUpdatedAgo } from "../shared/auto-refresh";
-import { yieldCurveHeadless } from "./headless";
 
 export { yieldCurveHeadless } from "./headless";
 
+const EMPTY_POINTS: YieldPoint[] = [];
+const TABLE_COLUMNS = [
+  { id: "maturity", label: "Maturity", width: 9, align: "left" as const },
+  { id: "yield", label: "Yield", width: 8, align: "right" as const },
+  { id: "asOf", label: "As of", width: 11, align: "left" as const },
+];
+
 function formatYield(y: number | null): string {
   if (y == null) return "—";
   return `${y.toFixed(2)}%`;
@@ -31,118 +40,123 @@ function formatYieldAxis(value: number): string {
   return `${value.toFixed(2)}%`;
 }
 
-function YieldCurvePane({ focused, width, height }: PaneProps) {
-  const [points, setPoints] = useState<YieldPoint[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [lastUpdated, setLastUpdated] = useState<number | null>(null);
-
-  const fetchGenRef = useRef(0);
-
-  const load = useCallback(async () => {
-    fetchGenRef.current += 1;
-    const gen = fetchGenRef.current;
-    setLoading(true);
-    setError(null);
+const pointKey = (point: YieldPoint) => point.maturity;
+const noop = () => {};
+function renderPointCell(point: YieldPoint, column: { id: string }) {
+  return {
+    text: column.id === "yield"
+      ? formatYield(point.yield)
+      : column.id === "asOf" ? point.asOf ?? "—" : point.maturity,
+  };
+}
 
+export function YieldCurvePane({ focused, width, height }: PaneProps) {
+  const [requestedDate, setRequestedDate] = usePaneSettingValue<string>("asOfDate", "");
+  const [draftDate, setDraftDate] = useState(requestedDate);
+  const [dateError, setDateError] = useState<string | null>(null);
+  const [editing, setEditing] = useState(false);
+  const dateInput = useRef<InputRenderable>(null);
+  useEffect(() => { if (editing) dateInput.current?.focus?.(); }, [editing]);
+  useEffect(() => { setDraftDate(requestedDate); }, [requestedDate]);
+  const loadCurve = useCallback(async () => ({
+    requestedDate,
+    points: completeYieldCurve(requestedDate
+      ? await loadHistoricalYieldCurve(requestedDate)
+      : await loadYieldCurve()),
+  }), [requestedDate]);
+  const { data, loading, error, updatedAt: lastUpdated, load } = useAsyncResource(loadCurve);
+  // A pending date change must never relabel the previous curve as the new one.
+  const points = data?.requestedDate === requestedDate ? data.points : EMPTY_POINTS;
+  const refreshLatest = useCallback(() => { if (!requestedDate) void load(); }, [requestedDate, load]);
+  useAutoRefresh(lastUpdated, refreshLatest);
+  const selectDate = (value: string) => {
     try {
-      const data = await loadYieldCurve();
-      if (fetchGenRef.current !== gen) return;
-      setPoints(data);
-      setLastUpdated(Date.now());
-    } catch (err) {
-      if (fetchGenRef.current !== gen) return;
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      if (fetchGenRef.current === gen) setLoading(false);
+      const nextDate = yieldCurveDate(value);
+      setRequestedDate(nextDate);
+      setDraftDate(nextDate);
+      setDateError(null);
+      setEditing(false);
+      if (dateInput.current?.setCursorOffset) dateInput.current.setCursorOffset(0);
+      else if (dateInput.current) dateInput.current.cursorOffset = 0;
+      dateInput.current?.blur?.();
+      if (nextDate === requestedDate) void load();
+    } catch (error) {
+      setDateError(error instanceof Error ? error.message : String(error));
     }
-  }, []);
-
-  useEffect(() => {
-    load();
-  }, [load]);
-  useAutoRefresh(lastUpdated, load);
-  const updatedAgo = useUpdatedAgo(lastUpdated);
+  };
 
   useShortcut((ev) => {
-    if (!focused) return;
-    if (ev.name === "r") {
-      load();
+    if (!focused || editing) return;
+    if (ev.name === "d") {
+      ev.preventDefault();
+      setEditing(true);
+    } else if (ev.name === "r") {
+      void load();
+    } else if (ev.name === "l") {
+      selectDate("");
     }
   });
 
-  const inverted = isInverted(points);
   const bp = spreadBasisPoints(points);
   // Treasury series are daily closes, so which session the curve represents is
   // status the user needs; "updated Xm ago" only says when we last fetched it.
   const asOf = curveAsOf(points);
+  const sourceError = yieldCurveErrors(points).join("; ");
 
   const yieldStatus = useMemo<PaneFooterSegment[]>(() => [
-      ...(inverted ? [{ id: "inverted", parts: [{ text: "INVERTED", tone: "warning" as const, bold: true }] }] : []),
-      ...(bp != null ? [{ id: "spread", parts: [{ text: `2Y-10Y ${bp >= 0 ? "+" : ""}${bp}bp`, tone: bp < 0 ? "warning" as const : "muted" as const }] }] : []),
+      ...(bp != null ? [{ id: "spread", parts: [{ text: `10Y−2Y ${bp >= 0 ? "+" : ""}${bp}bp`, tone: bp < 0 ? "warning" as const : "muted" as const }] }] : []),
       ...(asOf ? [{ id: "as-of", parts: [{ text: `as of ${asOf}`, tone: "muted" as const }] }] : []),
-      ...(updatedAgo ? [{ id: "updated", parts: [{ text: `updated ${updatedAgo}`, tone: "muted" as const }] }] : []),
-  ], [asOf, bp, inverted, updatedAgo]);
+      ...(requestedDate && requestedDate !== asOf ? [{ id: "requested", parts: [{ text: `requested ${requestedDate}`, tone: "muted" as const }] }] : []),
+      ...(!asOf && points.length ? [{ id: "mixed-dates", parts: [{ text: "Mixed or unknown observation dates", tone: "warning" as const }] }] : []),
+      ...(points.some((point) => point.yield == null) ? [{ id: "missing", parts: [{ text: "Some tenors unavailable", tone: "warning" as const }] }] : []),
+      ...(points.some((point) => point.stale) ? [{ id: "stale", parts: [{ text: "Cached source · refresh failed", tone: "warning" as const }] }] : []),
+  ], [asOf, bp, points, requestedDate]);
   usePaneStatusFooter({
     registrationId: "yield-curve",
     loading,
-    error,
-    info: yieldStatus,
+    error: error || sourceError || null,
+    info: error || sourceError ? [] : yieldStatus,
+    hints: [
+      { id: "date", key: "d", label: "ate", onPress: () => setEditing(true) },
+      ...(requestedDate ? [{ id: "latest", key: "l", label: "atest", onPress: () => selectDate("") }] : []),
+    ],
   });
 
-  if (loading && points.length === 0) {
-    return (
-      <Box flexDirection="column" width={width} height={height}>
-        <Box flexGrow={1} justifyContent="center" alignItems="center">
-          <Spinner label="Loading yield curve..." />
-        </Box>
-      </Box>
-    );
-  }
-
-  if (error && points.length === 0) {
-    return (
-      <Box flexDirection="column" width={width} height={height} padding={1} gap={1}>
-        <EmptyState title="Yield curve unavailable." message={error} />
-      </Box>
-    );
-  }
-
-  const validPoints = parseYieldPoints(points);
+  const validPoints = asOf ? parseYieldPoints(points) : [];
 
   const chartWidth = Math.max(10, width - 2);
-  const chartHeight = Math.min(18, Math.max(8, height - 5));
+  const chartHeight = Math.min(12, Math.max(6, height - 18));
 
   const palette = resolveChartPalette(colors, "positive");
 
-  // Map yield points to chart points: use epoch + maturityYears*365*86400000 to space them on the x-axis
-  const chartPoints: ProjectedChartPoint[] = validPoints.map((p) => ({
-    date: new Date(p.maturityYears * 365 * 86400000),
-    open: p.yield!,
-    high: p.yield!,
-    low: p.yield!,
-    close: p.yield!,
-    volume: 0,
-  }));
-
-  // Build maturity label row and yield value row for the table
-  const colWidth = Math.max(6, Math.floor((width - 2) / TREASURY_MATURITIES.length));
-  const maturityLabels = TREASURY_MATURITIES.map((m) => m.maturity.padEnd(colWidth)).join("").trimEnd();
-  const yieldValues = TREASURY_MATURITIES.map((m) => {
-    const pt = points.find((p) => p.maturity === m.maturity);
-    return formatYield(pt?.yield ?? null).padEnd(colWidth);
-  }).join("").trimEnd();
+  const chart = buildYieldCurveChart(validPoints, Math.max(1, chartWidth - 8));
 
   return (
     <Box flexDirection="column" width={width} height={height}>
+      {editing ? <Box flexDirection="row" paddingX={1} gap={1} alignItems="flex-end" flexShrink={0}>
+        <TextField label="As-of date" type="date" value={draftDate} width={12}
+          placeholder="YYYY-MM-DD" inputRef={dateInput} focused={focused && editing}
+          onChange={setDraftDate} onSubmit={selectDate}
+          onMouseDown={() => setEditing(true)}
+          onKeyDown={(event) => {
+            if (event.name === "escape") { setEditing(false); dateInput.current?.blur?.(); }
+          }} />
+        <Button label="View" onPress={() => selectDate(draftDate)} compact />
+      </Box> : null}
+      {dateError ? <Notice tone="negative">{dateError}</Notice> : null}
+      <PaneStatusBody loading={loading && points.length === 0} error={points.length === 0 ? error : null}
+        loadingLabel="Loading yield curve..." subject="yield curve">
       {/* Scrollable chart + table */}
       <ScrollBox flexGrow={1} scrollY focusable={false}>
         <Box flexDirection="column">
           {/* Chart */}
-          {chartPoints.length >= 2 ? (
+          {chart.points.length >= 2 ? (
             <Box flexDirection="column" paddingX={1} marginTop={1}>
               <StaticChartSurface
-                points={chartPoints}
+                points={chart.points}
+                calendarSpaced
+                xAxisTicks={chart.ticks}
+                formatXAxisCursorValue={chart.formatCursor}
                 width={chartWidth}
                 height={chartHeight}
                 mode="line"
@@ -154,19 +168,19 @@ function YieldCurvePane({ focused, width, height }: PaneProps) {
             </Box>
           ) : (
             <Box paddingX={1} marginTop={1}>
-              <Text fg={colors.textMuted}>Not enough data for chart</Text>
+              <Text fg={colors.textMuted}>{points.length && !asOf ? "A curve requires matching observation dates" : "Not enough data for chart"}</Text>
             </Box>
           )}
 
-          {/* Maturity table */}
-          <Box paddingX={1} marginTop={1} height={1}>
-            <Text fg={colors.textDim}>{maturityLabels}</Text>
-          </Box>
-          <Box paddingX={1} height={1}>
-            <Text fg={colors.text}>{yieldValues}</Text>
+          <Box marginTop={1} height={12}>
+            <DataTableView columns={TABLE_COLUMNS} items={points} selection={{ kind: "none" }}
+              focused={focused && !editing} sortColumnId={null} sortDirection="asc" onHeaderClick={noop}
+              getItemKey={pointKey} rootHeight={12} emptyStateTitle="No Treasury observations"
+              renderCell={renderPointCell} />
           </Box>
         </Box>
       </ScrollBox>
+      </PaneStatusBody>
     </Box>
   );
 }
@@ -179,7 +193,7 @@ export const yieldCurveModule: PluginModule = {
     component: YieldCurvePane,
     defaultPosition: "right",
     defaultMode: "floating",
-    defaultFloatingSize: { width: 80, height: 20 },
+    defaultFloatingSize: { width: 80, height: 28 },
   }],
   paneTemplates: [{
     id: "yield-curve-pane",
@@ -187,7 +201,8 @@ export const yieldCurveModule: PluginModule = {
     label: "Yield Curve",
     description: "US Treasury yield curve charted from FRED data.",
     keywords: ["yield", "curve", "treasury", "bonds", "rates", "gc", "interest"],
-    shortcut: { prefix: "GC" },
+    shortcut: { prefix: "GC", argPlaceholder: "YYYY-MM-DD", argKind: "text", argOptional: true },
     headless: yieldCurveHeadless,
+    createInstance: (_context, options) => ({ settings: { asOfDate: yieldCurveDate(options?.arg) } }),
   }],
 };

package/src/plugins/builtin/yield-curve/pane.test.tsx

@@ -0,0 +1,137 @@
+import { afterEach, expect, spyOn, test } from "bun:test";
+import { act, useEffect, useReducer } from "react";
+import { RemoteUiRegistryProvider, useRemoteUiRegistry, type RemoteUiRegistry } from "../../../remote/semantic-tree";
+import { apiClient } from "../../../api-client";
+import { createTestControls, emitKeypress, testRender } from "../../../renderers/opentui/test-utils";
+import { AppContext, PaneInstanceProvider, appReducer, createInitialState } from "../../../state/app/context";
+import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
+import { cloneLayout, createDefaultConfig } from "../../../types/config";
+import { PluginRenderProvider } from "../../runtime";
+import { YieldCurvePane } from "./index";
+import { TREASURY_MATURITIES } from "./treasury-data";
+import { PaneFooterProvider, PaneFooterBar } from "../../../components/layout/pane/footer";
+import { Box } from "../../../ui";
+
+const id = "yield-curve:test";
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+let latestSpy: ReturnType<typeof spyOn> | undefined;
+let historySpy: ReturnType<typeof spyOn> | undefined;
+let registry: RemoteUiRegistry | null = null;
+
+function RegistryProbe() {
+  const value = useRemoteUiRegistry();
+  useEffect(() => { registry = value; }, [value]);
+  return null;
+}
+
+function Harness() {
+  const config = createDefaultConfig("/tmp/gloom-curve-test");
+  config.layout = { dockRoot: { kind: "pane", instanceId: id }, instances: [{ instanceId: id, paneId: "yield-curve", binding: { kind: "none" } }], floating: [], detached: [] };
+  config.layouts = [{ name: "Default", layout: cloneLayout(config.layout) }];
+  const initial = createInitialState(config);
+  initial.focusedPaneId = id;
+  const [state, dispatch] = useReducer(appReducer, initial);
+  return <AppContext value={{state, dispatch}}><PaneInstanceProvider paneId={id}>
+    <PluginRenderProvider pluginId="macro" runtime={createTestPluginRuntime()}>
+      <PaneFooterProvider>{(footer) => <Box width={70} height={30} flexDirection="column">
+        <YieldCurvePane paneId={id} paneType="yield-curve" focused width={70} height={29} />
+        <PaneFooterBar footer={footer} focused width={70} />
+      </Box>}</PaneFooterProvider>
+    </PluginRenderProvider>
+  </PaneInstanceProvider></AppContext>;
+}
+
+async function frame() {
+  await act(async () => { await new Promise((resolve) => setTimeout(resolve, 0)); await setup!.renderOnce(); });
+}
+
+afterEach(async () => {
+  if (setup) await act(async () => { setup!.renderer.destroy(); });
+  setup = undefined;
+  registry = null;
+  latestSpy?.mockRestore(); historySpy?.mockRestore();
+});
+
+test("Treasury curve axis and cursor use maturity rather than synthetic calendar dates", async () => {
+  latestSpy = spyOn(apiClient, "getCloudYieldCurve").mockResolvedValue(TREASURY_MATURITIES.map(({ maturity, years }, index) => ({ maturity, maturityYears: years, yield: 4 + index / 10, asOf: "2026-09-10" })));
+  await act(async () => { setup = await testRender(<RemoteUiRegistryProvider><RegistryProbe /><Harness /></RemoteUiRegistryProvider>, { width: 70, height: 30 }); });
+  await frame(); await frame();
+  expect(setup!.captureCharFrame()).toMatch(/1M.*5Y.*10Y.*20Y.*30Y/);
+  const chart = registry!.snapshot().find((node) => node.metadata?.kind === "static-chart")!;
+  await act(async () => { await registry!.invoke(chart.id, "moveCursor", { x: 30, y: 4 }); });
+  await frame(); await frame();
+  expect(setup!.captureCharFrame()).toMatch(/\d+\.\dY/);
+  expect(setup!.captureCharFrame()).not.toMatch(/19[789]\d/);
+});
+
+test("date submission hides the previous curve while pending and keeps controls available after failure", async () => {
+  latestSpy = spyOn(apiClient, "getCloudYieldCurve").mockResolvedValue(TREASURY_MATURITIES.map(({ maturity, years }) => ({ maturity, maturityYears: years, yield: 4.5, asOf: "2026-09-08" })));
+  let rejectHistory!: (error: Error) => void;
+  const pending = new Promise<never>((_resolve, reject) => { rejectHistory = reject; });
+  historySpy = spyOn(apiClient, "getCloudFredSeries").mockImplementation(() => pending);
+  await act(async () => { setup = await testRender(<Harness />, { width: 70, height: 30 }); });
+  await frame(); await frame();
+  expect(setup!.captureCharFrame()).toContain("2026-09-08");
+  await emitKeypress(setup!, { name: "d" });
+  await act(async () => { await setup!.mockInput.typeText("2024-03-02"); setup!.mockInput.pressEnter(); });
+  await frame();
+  expect(historySpy).toHaveBeenCalledTimes(10);
+  expect(setup!.captureCharFrame()).toContain("2024-03-02");
+  expect(setup!.captureCharFrame()).toContain("Loading yield curve");
+  expect(setup!.captureCharFrame()).not.toContain("2026-09-08");
+  await act(async () => { rejectHistory(new Error("offline")); });
+  await frame();
+  expect(setup!.captureCharFrame()).toContain("Treasury curve unavailable");
+  const controls = createTestControls(() => setup!);
+  await act(async () => { await controls.clickFrameText("[d]ate"); });
+  await frame();
+  expect(setup!.captureCharFrame()).toContain("As-of date");
+  await emitKeypress(setup!, { name: "escape" });
+  await act(async () => { await controls.clickFrameText("[l]atest"); });
+  await frame();
+  expect(setup!.captureCharFrame()).toContain("2026-09-08");
+});
+
+test("the transient date editor can be submitted with the mouse", async () => {
+  latestSpy = spyOn(apiClient, "getCloudYieldCurve").mockResolvedValue(TREASURY_MATURITIES.map(({ maturity, years }) => ({ maturity, maturityYears: years, yield: 4.5, asOf: "2026-09-08" })));
+  historySpy = spyOn(apiClient, "getCloudFredSeries").mockImplementation(async (id) => ({
+    observations: [{ date: "2024-03-01", value: 4.2 }],
+    info: { id, title: "Treasury yield", units: "Percent", frequency: "Daily", seasonalAdjustment: "", source: "FRED", notes: "" },
+  }));
+  await act(async () => { setup = await testRender(<Harness />, { width: 70, height: 30 }); });
+  await frame(); await frame();
+  const controls = createTestControls(() => setup!);
+  await act(async () => { await controls.clickFrameText("[d]ate"); });
+  await frame();
+  await act(async () => { await setup!.mockInput.typeText("2024-03-02"); });
+  await frame();
+  await act(async () => { await controls.clickFrameText("View"); });
+  await frame(); await frame();
+  expect(historySpy).toHaveBeenCalledTimes(10);
+  expect(setup!.captureCharFrame()).toContain("2024-03-01");
+  expect(setup!.captureCharFrame()).toContain("requested 2024-03-02");
+  expect(setup!.captureCharFrame()).not.toContain("As-of date");
+});
+
+
+test("historical partial source failure reaches the existing footer and a valid retry clears it", async () => {
+  let offline = true;
+  latestSpy = spyOn(apiClient, "getCloudYieldCurve").mockResolvedValue([]);
+  historySpy = spyOn(apiClient, "getCloudFredSeries").mockImplementation(async (id) => {
+    if (offline && id === "DGS2") throw new Error("controlled source 503");
+    return { info: null, observations: [{ date: "2024-03-01", value: id === "DGS2" ? 0 : -.2 }] };
+  });
+  await act(async () => { setup = await testRender(<Harness />, { width: 70, height: 30 }); });
+  await frame(); await frame();
+  await emitKeypress(setup!, { name: "d" });
+  await act(async () => { await setup!.mockInput.typeText("2024-03-02"); setup!.mockInput.pressEnter(); });
+  await frame(); await frame();
+  expect(setup!.captureCharFrame()).toContain("controlled source 503");
+  expect(setup!.captureCharFrame()).toContain("-0.20%");
+  offline = false;
+  await emitKeypress(setup!, { name: "r" });
+  await frame(); await frame();
+  expect(setup!.captureCharFrame()).not.toContain("503");
+  expect(setup!.captureCharFrame()).toContain("0.00%");
+  expect(setup!.captureCharFrame()).toContain("10Y−2Y -20bp");
+});

package/src/plugins/builtin/yield-curve/treasury-data.test.ts

@@ -1,25 +1,35 @@
 import { expect, test } from "bun:test";
-import { curveAsOf, type YieldPoint } from "./treasury-data";
+import { curveAsOf, spreadBasisPoints, isInverted, type YieldPoint } from "./treasury-data";
 
 function point(maturity: string, years: number, value: number | null, asOf?: string | null): YieldPoint {
   return { maturity, maturityYears: years, yield: value, asOf };
 }
 
-test("dates the curve from the newest observation present", () => {
+test("does not date a mixed-date curve as a single session", () => {
   expect(curveAsOf([
     point("2Y", 2, 4.19, "2026-08-15"),
     point("10Y", 10, 4.72, "2026-08-17"),
     point("30Y", 30, 5.31, "2026-08-17"),
-  ])).toBe("2026-08-17");
+  ])).toBeNull();
 });
 
-test("ignores points with no date rather than dropping the curve date", () => {
+test("does not infer an undated tenor date from a different tenor", () => {
   expect(curveAsOf([
     point("2Y", 2, 4.19, null),
     point("10Y", 10, 4.72, "2026-08-17"),
-  ])).toBe("2026-08-17");
+  ])).toBeNull();
 });
 
 test("reports no date when the server predates the field", () => {
   expect(curveAsOf([point("2Y", 2, 4.19), point("10Y", 10, 4.72)])).toBeNull();
 });
+
+
+test("curve spreads require same-date yields and preserve basis-point units", () => {
+  const same = [point("2Y", 2, 4.39, "2026-09-08"), point("10Y", 10, 4.80, "2026-09-08")];
+  expect(curveAsOf(same)).toBe("2026-09-08");
+  expect(spreadBasisPoints(same)).toBe(41);
+  expect(isInverted(same)).toBe(false);
+  expect(spreadBasisPoints([same[0]!, { ...same[1]!, asOf: "2026-09-09" }])).toBeNull();
+  expect(isInverted([same[0]!, { ...same[1]!, yield: null }])).toBeNull();
+});

package/src/plugins/builtin/yield-curve/treasury-data.ts

@@ -5,6 +5,19 @@ export interface YieldPoint {
   maturityYears: number; // 0.083, 0.25, 0.5, 1, 2, 5, 7, 10, 20, 30
   yield: number | null;  // percent, e.g., 4.29
   asOf?: string | null;  // FRED observation date, absent on older servers
+  stale?: boolean;
+  fetchedAt?: string;
+  error?: string;
+}
+
+export function isYieldObservationDate(value: unknown): value is string {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && new Date(timestamp).toISOString().slice(0, 10) === value;
+}
+
+export function yieldCurveErrors(points: readonly YieldPoint[]): string[] {
+  return points.flatMap((point) => point.error ? [`${point.maturity}: ${point.error}`] : []);
 }
 
 export const TREASURY_MATURITIES: Array<{ maturity: string; years: number; seriesId: string }> = [
@@ -30,33 +43,28 @@ export async function loadYieldCurve(
 
 export function parseYieldPoints(points: YieldPoint[]): YieldPoint[] {
   return points
-    .filter((p) => p.yield !== null)
+    .filter((p) => p.yield != null && Number.isFinite(p.yield))
     .sort((a, b) => a.maturityYears - b.maturityYears);
 }
 
 /**
- * The newest observation date across the curve. Treasury series publish
- * together, but a single stale series must not date the whole curve forward,
- * so this reports the latest date actually present.
+ * A curve has one as-of date only when all its available tenors agree.
  */
 export function curveAsOf(points: readonly YieldPoint[]): string | null {
-  let latest: string | null = null;
-  for (const point of points) {
-    const asOf = point.asOf;
-    if (!asOf) continue;
-    if (!latest || asOf > latest) latest = asOf;
-  }
-  return latest;
+  const available = points.filter((point) => point.yield != null && Number.isFinite(point.yield));
+  const date = available[0]?.asOf;
+  return isYieldObservationDate(date) && available.every((point) => point.asOf === date) ? date : null;
 }
 
 export function spreadBasisPoints(points: readonly YieldPoint[]): number | null {
-  const y2 = points.find((point) => point.maturity === "2Y")?.yield;
-  const y10 = points.find((point) => point.maturity === "10Y")?.yield;
-  if (y2 == null || y10 == null) return null;
-  return Math.round((y10 - y2) * 100);
+  const y2 = points.find((point) => point.maturity === "2Y");
+  const y10 = points.find((point) => point.maturity === "10Y");
+  if (y2?.yield == null || y10?.yield == null || !Number.isFinite(y2.yield) || !Number.isFinite(y10.yield)
+    || !isYieldObservationDate(y2.asOf) || y2.asOf !== y10.asOf) return null;
+  return Math.round((y10.yield - y2.yield) * 100);
 }
 
-export function isInverted(points: readonly YieldPoint[]): boolean {
+export function isInverted(points: readonly YieldPoint[]): boolean | null {
   const spread = spreadBasisPoints(points);
-  return spread != null && spread < 0;
+  return spread == null ? null : spread < 0;
 }

package/src/plugins/bundle.test.ts

@@ -28,7 +28,9 @@ const fakeExports = async (specifier: string) => (
       ? ["useState"]
       : specifier === "gloomberb/broker"
         ? ["PRESERVED_PASSWORD_HINT", "getBrokerRemoteClient"]
-        : []
+        : specifier === "gloomberb/types/config"
+          ? ["TICKER_RESEARCH_PANE_ID"]
+          : []
 );
 
 describe("buildSharedModuleSource", () => {
@@ -154,6 +156,47 @@ describe("bundleExternalPlugin", () => {
     }
   });
 
+  test("shares the type modules a plugin reads runtime values from", async () => {
+    // `gloomberb/types/config` used to be bundled in from the host's package
+    // directory. The packaged desktop app has no such directory, so a plugin
+    // that read `TICKER_RESEARCH_PANE_ID` from it failed to compile there. It
+    // is served from the host registry now, like `gloomberb/ui`.
+    const dir = scratchPlugin(`
+      import { TICKER_RESEARCH_PANE_ID } from "gloomberb/types/config";
+      export default { id: "scratch", name: "Scratch", version: "1.0.0", pane: TICKER_RESEARCH_PANE_ID };
+    `);
+    try {
+      const result = await bundleExternalPlugin(dir, join(dir, "out"), { exportNamesFor: fakeExports });
+      const code = await Bun.file(result.outputPath).text();
+
+      expect(result.shared).toEqual(["gloomberb/types/config"]);
+      expect(code).toContain(PLUGIN_HOST_GLOBAL);
+      expect(code).not.toContain("ticker-research");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("resolves a host export that is not shared without a linked node_modules", async () => {
+    // `gloomberb/package.json` is data, so it is bundled in rather than shared.
+    // A plugin on disk finds it through the symlinked node_modules the
+    // installer writes; one compiled out of this repo's node_modules has no
+    // such link, and before the export map was read it failed to compile at all.
+    const dir = scratchPlugin(`
+      import pkg from "gloomberb/package.json";
+      export default { id: "scratch", name: "Scratch", version: "1.0.0", host: pkg.description };
+    `);
+    try {
+      const result = await bundleExternalPlugin(dir, join(dir, "out"), { exportNamesFor: fakeExports });
+      const code = await Bun.file(result.outputPath).text();
+
+      expect(result.shared).toEqual([]);
+      expect(code).toContain("Market research and portfolio tracker for the terminal");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   test("rejects a directory with no entry file", async () => {
     const dir = mkdtempSync(join(tmpdir(), "gloom-bundle-empty-"));
     mkdirSync(join(dir, "src"), { recursive: true });