gloomberb 0.16.4 → 0.16.6

package/src/plugins/builtin/world-venue-map/model.ts

@@ -18,15 +18,44 @@ export interface WorldMapViewport {
   centerLatitude: number;
 }
 
-const MAX_LATITUDE = 85;
-const MIN_LATITUDE = -60;
+/** The map's northern and southern edges; the land data is cut at the south one. */
+export const MAX_LATITUDE = 80;
+export const MIN_LATITUDE = -60;
 const LONGITUDE_SPAN = 360;
-export const MAX_WORLD_MAP_ZOOM = 18;
+/** The most the map zooms in a narrow pane: 4,096 times the world. A wider pane stops sooner, at a pixel density (see map.tsx). */
+export const MAX_WORLD_MAP_ZOOM = 4096;
+
+/** Web Mercator stops here, where the projection runs to infinity. */
+const MERCATOR_LIMIT = 85.0511287798;
+
+/**
+ * Where a latitude falls on the map's vertical axis: Mercator, in degrees of
+ * longitude at the equator, so one unit north is one unit east wherever the
+ * point is. That keeps a country's proportions at every latitude, as on any
+ * web map. Plain latitude would stretch everything sideways by 1/cos(latitude):
+ * France drew about 1.4 times wider than it is tall.
+ */
+export function mercatorY(latitude: number): number {
+  const radians = (clamp(latitude, -MERCATOR_LIMIT, MERCATOR_LIMIT) * Math.PI) / 180;
+  return (Math.log(Math.tan(Math.PI / 4 + radians / 2)) * 180) / Math.PI;
+}
+
+/** The latitude at a Mercator `y`, the inverse of {@link mercatorY}. */
+function latitudeAtMercatorY(y: number): number {
+  return (Math.atan(Math.exp((y * Math.PI) / 180)) * 360) / Math.PI - 90;
+}
+
+const MERCATOR_TOP = mercatorY(MAX_LATITUDE);
+const MERCATOR_BOTTOM = mercatorY(MIN_LATITUDE);
+const MERCATOR_SPAN = MERCATOR_TOP - MERCATOR_BOTTOM;
+
+/** The whole map's height over its width, for a pane that sizes itself to the world. */
+export const WORLD_MAP_HEIGHT_RATIO = MERCATOR_SPAN / LONGITUDE_SPAN;
 
 export const DEFAULT_WORLD_MAP_VIEWPORT: WorldMapViewport = {
   zoom: 1,
   centerLongitude: 0,
-  centerLatitude: (MAX_LATITUDE + MIN_LATITUDE) / 2,
+  centerLatitude: latitudeAtMercatorY((MERCATOR_TOP + MERCATOR_BOTTOM) / 2),
 };
 
 function mapExtent(width: number, height: number, yUnitAspect = 1) {
@@ -34,13 +63,21 @@ function mapExtent(width: number, height: number, yUnitAspect = 1) {
   const availableHeight = Math.max(height - 1, 0);
   const unitAspect = Math.max(yUnitAspect, Number.EPSILON);
   const effectiveHeight = availableHeight * unitAspect;
-  const latitudeSpan = MAX_LATITUDE - MIN_LATITUDE;
-  return { availableWidth, availableHeight, unitAspect, effectiveHeight, latitudeSpan };
+  return { availableWidth, availableHeight, unitAspect, effectiveHeight, mercatorSpan: MERCATOR_SPAN };
 }
 
 function fittedWorldMapScale(width: number, height: number, yUnitAspect = 1): number {
-  const { availableWidth, effectiveHeight, latitudeSpan } = mapExtent(width, height, yUnitAspect);
-  return Math.min(availableWidth / LONGITUDE_SPAN, effectiveHeight / latitudeSpan);
+  const { availableWidth, effectiveHeight, mercatorSpan } = mapExtent(width, height, yUnitAspect);
+  return Math.min(availableWidth / LONGITUDE_SPAN, effectiveHeight / mercatorSpan);
+}
+
+/**
+ * The zoom at which the map draws `unitsPerDegree` view units to each degree of
+ * longitude, so a ceiling set in screen pixels follows the size of the pane.
+ */
+export function zoomForDegreeScale(unitsPerDegree: number, width: number, height: number, yUnitAspect = 1): number {
+  const fit = fittedWorldMapScale(width, height, yUnitAspect);
+  return fit > 0 ? unitsPerDegree / fit : Number.POSITIVE_INFINITY;
 }
 
 function worldMapScale(
@@ -62,11 +99,11 @@ export function projectWorldPoint(
 ): WorldMapPoint {
   const { availableWidth, unitAspect, effectiveHeight } = mapExtent(width, height, yUnitAspect);
   const scale = worldMapScale(width, height, yUnitAspect, viewport);
-  const clampedLatitude = clamp(latitude, MIN_LATITUDE, MAX_LATITUDE);
+  const northing = mercatorY(clamp(latitude, MIN_LATITUDE, MAX_LATITUDE)) - mercatorY(viewport.centerLatitude);
 
   return {
     x: availableWidth / 2 + (longitude - viewport.centerLongitude) * scale,
-    y: (effectiveHeight / 2 - (clampedLatitude - viewport.centerLatitude) * scale) / unitAspect,
+    y: (effectiveHeight / 2 - northing * scale) / unitAspect,
   };
 }
 
@@ -82,7 +119,7 @@ export function unprojectWorldPoint(
   const scale = worldMapScale(width, height, yUnitAspect, viewport);
   return {
     longitude: viewport.centerLongitude + (x - availableWidth / 2) / scale,
-    latitude: viewport.centerLatitude - (y * unitAspect - effectiveHeight / 2) / scale,
+    latitude: latitudeAtMercatorY(mercatorY(viewport.centerLatitude) - (y * unitAspect - effectiveHeight / 2) / scale),
   };
 }
 
@@ -96,25 +133,25 @@ export function clampWorldMapViewport(
   const zoom = clamp(viewport.zoom, 1, maxZoom);
   if (zoom <= 1) return DEFAULT_WORLD_MAP_VIEWPORT;
 
-  const { availableWidth, effectiveHeight, latitudeSpan } = mapExtent(width, height, yUnitAspect);
+  const { availableWidth, effectiveHeight, mercatorSpan } = mapExtent(width, height, yUnitAspect);
   // A plot with no area yet (a pane mid-layout) says nothing about what fits:
   // keep the centre rather than resetting it to the middle of the world.
   if (availableWidth <= 0 || effectiveHeight <= 0) return { ...viewport, zoom };
   const scale = fittedWorldMapScale(width, height, yUnitAspect) * zoom;
   const halfLongitude = availableWidth / (2 * scale);
-  const halfLatitude = effectiveHeight / (2 * scale);
+  const halfNorthing = effectiveHeight / (2 * scale);
   const minLongitude = -180 + halfLongitude;
   const maxLongitude = 180 - halfLongitude;
-  const minLatitude = MIN_LATITUDE + halfLatitude;
-  const maxLatitude = MAX_LATITUDE - halfLatitude;
+  const minNorthing = MERCATOR_BOTTOM + halfNorthing;
+  const maxNorthing = MERCATOR_TOP - halfNorthing;
 
   return {
     zoom,
     centerLongitude: minLongitude < maxLongitude
       ? clamp(viewport.centerLongitude, minLongitude, maxLongitude)
       : DEFAULT_WORLD_MAP_VIEWPORT.centerLongitude,
-    centerLatitude: halfLatitude < latitudeSpan / 2
-      ? clamp(viewport.centerLatitude, minLatitude, maxLatitude)
+    centerLatitude: halfNorthing < mercatorSpan / 2
+      ? latitudeAtMercatorY(clamp(mercatorY(viewport.centerLatitude), minNorthing, maxNorthing))
       : DEFAULT_WORLD_MAP_VIEWPORT.centerLatitude,
   };
 }
@@ -150,7 +187,7 @@ export function zoomWorldMapViewport(
   return clampWorldMapViewport({
     zoom: nextZoom,
     centerLongitude: geographic.longitude - (point.x - availableWidth / 2) / scale,
-    centerLatitude: geographic.latitude + (point.y * unitAspect - effectiveHeight / 2) / scale,
+    centerLatitude: latitudeAtMercatorY(mercatorY(geographic.latitude) + (point.y * unitAspect - effectiveHeight / 2) / scale),
   }, width, height, yUnitAspect, maxZoom);
 }
 
@@ -169,7 +206,7 @@ export function panWorldMapViewport(
   return clampWorldMapViewport({
     zoom: viewport.zoom,
     centerLongitude: viewport.centerLongitude - deltaX / scale,
-    centerLatitude: viewport.centerLatitude + (deltaY * unitAspect) / scale,
+    centerLatitude: latitudeAtMercatorY(mercatorY(viewport.centerLatitude) + (deltaY * unitAspect) / scale),
   }, width, height, yUnitAspect, maxZoom);
 }
 

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

@@ -25,7 +25,7 @@ import { loadWorldVenues } from "./client";
 import { WORLD_VENUE_MAP_PANE_ID } from "./ids";
 import { LayeredMapView } from "./layered-pane";
 import { activeLayerTokens, isPlainMap, LAYERS_SETTING_KEY, resolveActiveLayers, VENUES_SETTING_KEY } from "./layers";
-import { WorldVenueMap } from "./map";
+import { useMapKeyboard, WorldVenueMap } from "./map";
 import { filterWorldVenues, formatVenueLocalTime } from "./model";
 import { useGeoCatalog } from "./use-geo";
 import { SelectedVenueHeader } from "./venue-header";
@@ -72,6 +72,7 @@ function VenueMapView({ focused, width, height }: PaneProps) {
   const { data, loading, error, load } = useAsyncResource(loadWorldVenues);
   const [query, setQuery] = useState("");
   const { active: searchFocused, focus: focusSearch, searchProps } = useQueryBarSearch();
+  const mapKeys = useMapKeyboard(searchFocused);
   const [selectedMic, setSelectedMic] = useState<string | null>(null);
   const [now, setNow] = useState(Date.now());
 
@@ -182,7 +183,8 @@ function VenueMapView({ focused, width, height }: PaneProps) {
 
   const table = (
     <DataTableView<CloudWorldVenuePayload, VenueColumn>
-      focused={focused && !searchFocused}
+      focused={focused && !searchFocused && !mapKeys.active}
+      onTableMouseDown={mapKeys.release}
       selection={{
         kind: "id",
         selectedId: selectedMic,
@@ -222,6 +224,7 @@ function VenueMapView({ focused, width, height }: PaneProps) {
         onSelect={(venue) => setSelectedMic(venue.mic)}
         savedViewport={savedViewport}
         onViewportSettled={setSavedViewport}
+        keyboard={mapKeys.keyboard}
       />
     </Box>
   );

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

@@ -1,4 +1,5 @@
 import type { CurveSeries } from "../../../components/chart/curve";
+import { formatBasisPoints } from "../../../utils/basis-points";
 import type { CurveNode } from "./forward";
 import type { YieldCurveLookbackId } from "./history";
 import { curveAsOf, curveSpread, isYieldObservationDate, type YieldPoint } from "./treasury-data";
@@ -9,8 +10,7 @@ export function formatYield(value: number): string {
 
 /** A yield change in percentage points, read in basis points: `+7bp`, `-12bp`. */
 export function formatYieldChange(change: number): string {
-  const bp = Math.round(change * 100);
-  return `${bp > 0 ? "+" : ""}${bp === 0 ? 0 : bp}bp`;
+  return formatBasisPoints(change);
 }
 
 export function buildYieldCurveSeries(points: readonly YieldPoint[]): CurveSeries {

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

@@ -140,29 +140,42 @@ export async function loadComparePoints(curve: CurveId, date: string, client: Cu
   }
 }
 
-const RELATIVE = /^(\d{1,2})([WMY])$/i;
+const RELATIVE = /^(\d{1,2})([DWMY])$/i;
+const COMPARE_HELP = "Compare with a date in YYYY-MM-DD format or a span such as 1D, 1W, 3M or 1Y.";
+
+/** A span back from the session (1D, 1W, 3M, 1Y): what the compare field takes besides a date. */
+export function isCompareSpan(value: string): boolean {
+  const match = value.trim().match(RELATIVE);
+  return match != null && Number(match[1]) > 0;
+}
 
 /**
  * What the compare field accepts: a date, or a span back from the curve's
- * session (1W, 3M, 1Y). Empty turns comparing off.
+ * session (1D, 1W, 3M, 1Y). Empty turns comparing off. Anything else gets the
+ * help for both forms, not the as-of field's date-only message.
  */
 export function parseCompareInput(value: string, now = new Date()): string {
   const text = value.trim();
   if (!text) return "";
-  if (RELATIVE.test(text)) return text.toUpperCase();
-  const date = yieldCurveDate(text, now);
-  if (!date) throw new Error("Compare with a date in YYYY-MM-DD format or a span such as 1W, 3M or 1Y.");
-  return date;
+  if (isCompareSpan(text)) return text.toUpperCase();
+  if (!isYieldObservationDate(text)) throw new Error(COMPARE_HELP);
+  return yieldCurveDate(text, now);
 }
 
-/** The date a compare input asks for, given the session shown. */
+/**
+ * The date a compare input asks for, given the session shown. A day back is the
+ * day before, and the curve loaded for it is the last session on or before
+ * that day, so 1D is the previous session.
+ */
 export function compareDate(input: string, asOf: string): string {
   const match = input.match(RELATIVE);
   if (!match) return input;
   const count = Number(match[1]);
   const unit = match[2]!.toUpperCase();
   const [year, month, day] = asOf.split("-").map(Number) as [number, number, number];
-  if (unit === "W") return new Date(Date.UTC(year, month - 1, day - 7 * count)).toISOString().slice(0, 10);
+  if (unit === "D" || unit === "W") {
+    return new Date(Date.UTC(year, month - 1, day - (unit === "W" ? 7 : 1) * count)).toISOString().slice(0, 10);
+  }
   const months = unit === "M" ? count : count * 12;
   const target = new Date(Date.UTC(year, month - 1 - months, 1));
   const lastDay = new Date(Date.UTC(target.getUTCFullYear(), target.getUTCMonth() + 1, 0)).getUTCDate();

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

@@ -6,13 +6,16 @@ import {
   compareDate, CURVE_OPTIONS, curveIdOf, curveOption, curveSpreadFigures, loadComparePoints, loadCurveData, parseCompareInput,
   parseCurveArgument, type CurveData, type CurveId,
 } from "./curves";
+import { yieldTenorRows, type YieldLookbackCurves } from "./chart";
 import { curveAsOf, type YieldPoint, yieldCurveErrors } from "./treasury-data";
-import { yieldCurveDate } from "./history";
+import { loadYieldCurveLookbacks, yieldCurveDate } from "./history";
 import { loadWorldRows, type WorldRow } from "./world";
+import { formatBasisPoints, toBasisPoints } from "../../../utils/basis-points";
 
 const percent = (value: unknown) => value == null ? "-" : `${Number(value).toFixed(2)}%`;
-const basisPoints = (value: unknown) => value == null ? "-" : `${Number(value) > 0 ? "+" : ""}${Math.round(Number(value))}bp`;
-const COLUMNS = [
+/** A move already in basis points: `+3bp`, `-1bp`, `0bp`. */
+const basisPoints = (value: unknown) => value == null ? "-" : formatBasisPoints(Number(value) / 100);
+const MATURITY_COLUMNS = [
   { key: "maturity", header: "Maturity" },
   {
     key: "maturityYears",
@@ -21,11 +24,19 @@ const COLUMNS = [
     format: (value: unknown) => Number(value).toFixed(2).replace(/\.00$/, ""),
   },
   { key: "yield", header: "Yield", align: "right" as const, format: percent },
-  { key: "asOf", header: "As of" },
 ];
-const COMPARE_COLUMNS = [
-  ...COLUMNS,
-  { key: "compare", header: "Compare", align: "right" as const, format: percent },
+const AS_OF_COLUMN = { key: "asOf", header: "As of" };
+/** The move since the previous session with a yield, per tenor. */
+const COLUMNS = [
+  ...MATURITY_COLUMNS,
+  { key: "change1dBasisPoints", header: "1D bp", align: "right" as const, format: basisPoints },
+  AS_OF_COLUMN,
+];
+/** Both curves and the difference; the compare curve's own session heads its column, as it may be a day or a year back. */
+const compareColumns = (compareAsOf: string | null) => [
+  ...MATURITY_COLUMNS,
+  AS_OF_COLUMN,
+  { key: "compare", header: compareAsOf ? `vs ${compareAsOf}` : "Compare", align: "right" as const, format: percent },
   { key: "changeBasisPoints", header: "Chg bp", align: "right" as const, format: basisPoints },
 ];
 const WORLD_COLUMNS = [
@@ -41,12 +52,18 @@ const WORLD_COLUMNS = [
 export interface YieldCurveHeadlessDependencies {
   load(curve: CurveId, requestedDate: string, context: HeadlessPaneContext): Promise<CurveData>;
   compare?(curve: CurveId, date: string, context: HeadlessPaneContext): Promise<YieldPoint[]>;
+  /** The 1D, 1W and 1M curves of a session, for a curve loaded without them (the FRED fallback). */
+  lookbacks?(session: string, context: HeadlessPaneContext): Promise<YieldLookbackCurves>;
   world?(context: HeadlessPaneContext): Promise<WorldRow[]>;
 }
 
 const defaultDependencies: Required<YieldCurveHeadlessDependencies> = {
   load: (curve, requestedDate, context) => loadCurveData(curve, requestedDate, context.apiClient),
   compare: (curve, date, context) => loadComparePoints(curve, date, context.apiClient),
+  lookbacks: async (session, context) => Object.fromEntries(
+    (await loadYieldCurveLookbacks(session, (id, options) => context.apiClient.getCloudFredSeries(id, options)))
+      .map((lookback) => [lookback.id, lookback.points]),
+  ),
   world: (context) => loadWorldRows(context.apiClient),
 };
 
@@ -64,10 +81,23 @@ const CURVE_PUBLISHERS: Record<CurveId, string> = {
   ca: "Bank of Canada",
 };
 
+/** Whose business days each curve's dates are, so a report names the day it means. */
+const CURVE_MARKETS: Record<CurveId, string> = {
+  us: "US",
+  "us-real": "US",
+  "us-breakeven": "US",
+  "eu-aaa": "Euro area",
+  de: "Germany",
+  gb: "UK",
+  jp: "Japan",
+  ca: "Canada",
+};
+
 export function createYieldCurveHeadless(
   dependencies: YieldCurveHeadlessDependencies = defaultDependencies,
 ): HeadlessPaneDefinition<"rows"> {
   const loadCompare = dependencies.compare ?? defaultDependencies.compare;
+  const loadLookbacks = dependencies.lookbacks ?? defaultDependencies.lookbacks;
   const loadWorld = dependencies.world ?? defaultDependencies.world;
   return {
     shape: "rows",
@@ -76,7 +106,7 @@ export function createYieldCurveHeadless(
     options: [
       { key: "date", type: "string", description: "Historical as-of date (YYYY-MM-DD); uses the latest session on or before it." },
       { key: "curve", type: "string", description: "ust (default), tips, breakeven, euro, bund, gilt, jgb or canada." },
-      { key: "compare", type: "string", description: "Compare with a date (YYYY-MM-DD) or a span back from the curve's session (1W, 3M, 1Y)." },
+      { key: "compare", type: "string", description: "Compare with a date (YYYY-MM-DD) or a span back from the curve's session (1D, 1W, 1M, 3M, 1Y)." },
       { key: "view", type: "enum", values: [{ value: "curve" }, { value: "difference", aliases: ["diff"] }],
         description: "With a compare date: both curves, or the bp change by tenor as bars.",
         pluginState: { pluginId: "macro", key: "yield-curve:view" } },
@@ -87,7 +117,16 @@ export function createYieldCurveHeadless(
         pluginState: { pluginId: "macro", key: "yield-curve:tab" } },
     ],
     columns: COLUMNS,
-    describe: "Yield Curves",
+    // The title names the curve, as the pane's Curve select does.
+    describe: (args) => {
+      if (args.options.tab === "world") return "Yield Curves | World";
+      try {
+        const curve = curveIdOf(args.options.curve) ?? parseCurveArgument(args.argument).curve ?? "us";
+        return `Yield Curves | ${curveOption(curve).label}`;
+      } catch {
+        return "Yield Curves";
+      }
+    },
     async load(args, context) {
       if (args.options.tab === "world") {
         const rows = await loadWorld(context);
@@ -111,26 +150,40 @@ export function createYieldCurveHeadless(
       const points = data.points;
       const session = curveAsOf(points);
       const comparePoints = compareInput && session ? await loadCompare(curve, compareDate(compareInput, session), context) : null;
+      const compareAsOf = comparePoints ? curveAsOf(comparePoints) : null;
       const compareAt = (maturity: string) => comparePoints?.find((point) => point.maturity === maturity)?.yield ?? null;
+      // The stored curve brings its look-backs; the FRED fallback's load after it, and a failure leaves the move blank.
+      const lookbacks = data.lookbacks ?? (session ? await loadLookbacks(session, context).catch(() => ({})) : {});
+      const change1d = new Map(yieldTenorRows(points, lookbacks).map((row) => [row.id, row.change1d]));
       const rows = [...points].sort((a, b) => a.maturityYears - b.maturityYears);
-      const missingTenors = points.filter((point) => point.yield == null).map((point) => point.maturity);
-      const spreads = curveSpreadFigures(data, data.lookbacks ?? {});
+      const missing = points.filter((point) => point.yield == null);
+      const missingTenors = missing.map((point) => point.maturity);
+      // On a past date a tenor the publisher has no yield for was most likely not issued yet: a note, not an error.
+      const notIssued = requestedDate && missing.length < points.length ? missing.filter((point) => !point.error).map((point) => point.maturity) : [];
+      const unavailable = missingTenors.filter((maturity) => !notIssued.includes(maturity));
+      const spreads = curveSpreadFigures(data, lookbacks);
       const spread = (id: string) => bp(spreads.find((entry) => entry.id === id)?.value ?? null);
       const twosTens = spread("2s10s");
       return {
         // Each curve is its official publisher's daily close; a past date is a historical curve, not a feed.
-        freshness: { source: CURVE_PUBLISHERS[curve], status: "not-a-feed",
+        freshness: { source: CURVE_PUBLISHERS[curve], status: "not-a-feed", tradingDayMarket: CURVE_MARKETS[curve],
           ...(requestedDate ? { basis: "historical curve" } : { basis: "daily curve", cadence: "daily" }) },
-        ...(comparePoints ? { columns: COMPARE_COLUMNS } : {}),
+        ...(comparePoints ? { columns: compareColumns(compareAsOf) } : {}),
         rows: rows.map((point) => {
           const compare = compareAt(point.maturity);
-          return comparePoints
-            ? { ...point, compare, changeBasisPoints: point.yield != null && compare != null ? (point.yield - compare) * 100 : null }
-            : { ...point };
+          const change = change1d.get(point.maturity) ?? null;
+          return {
+            ...point,
+            change1dBasisPoints: change == null ? null : toBasisPoints(change, 1),
+            ...(comparePoints
+              ? { compare, changeBasisPoints: point.yield != null && compare != null ? (point.yield - compare) * 100 : null }
+              : {}),
+          };
         }),
+        ...(notIssued.length ? { notes: [`Not issued then: ${notIssued.join(", ")}`] } : {}),
         errors: [
           ...yieldCurveErrors(points),
-          ...(missingTenors.length ? [`Tenors unavailable: ${missingTenors.join(", ")}`] : []),
+          ...(unavailable.length ? [`Tenors unavailable: ${unavailable.join(", ")}`] : []),
           ...(!session ? ["Curve has mixed or unknown observation dates."] : []),
           ...(points.some((point) => point.stale) ? ["Some Treasury sources are stale cached data."] : []),
         ],
@@ -140,7 +193,7 @@ export function createYieldCurveHeadless(
           units: "Percent",
           requestedDate: requestedDate || null,
           asOf: session,
-          ...(comparePoints ? { compareAsOf: curveAsOf(comparePoints) } : {}),
+          ...(comparePoints ? { compare: compareInput, compareAsOf } : {}),
           inverted: twosTens == null ? null : twosTens < 0,
           spread2Y10YBasisPoints: twosTens,
           spread3M10YBasisPoints: spread("3m10y"),

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

@@ -15,6 +15,7 @@ import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, type InputRenderable } from "../../../ui";
 import type { PluginModule } from "../plugin-module";
+import { GOVERNMENT_BOND_SERIES, TREASURY_SERIES } from "./series";
 import { useAutoRefresh } from "../../../react/auto-refresh";
 import { usePaneStatusFooter } from "../../../components/layout/pane/status-footer";
 import { formatPercentileRank } from "../../../utils/format";
@@ -59,7 +60,7 @@ const AS_OF_COLUMN: DataTableColumn = { id: "asOf", label: "As of", width: 12, a
 const tenorKey = (row: YieldTenorRow) => row.id;
 // Left and Right step along the maturities, the way the curve reads.
 const tenorPosition = (row: YieldTenorRow) => new Date(row.years * 86_400_000);
-const RELATIVE_COMPARE = /^\d+[WMY]$/;
+const RELATIVE_COMPARE = /^\d+[DWMY]$/;
 /** A difference in basis points: `+7bp`, `-12bp`. */
 const formatBp = (value: number) => {
   const bp = Math.round(value);
@@ -328,7 +329,7 @@ function CurveTab({ curve, onCurveChange, focused, width, height }: {
           onChange: setShowForward }] : []),
       ]}
       // The session actually shown; a requested date the field already shows is not repeated.
-      meta={asOf && asOf !== requestedDate ? `as of ${asOf}` : undefined}
+      asOf={asOf && asOf !== requestedDate ? `as of ${asOf}` : undefined}
     />
   );
   // The query bar stays above the status body so the curve or date can change
@@ -438,6 +439,7 @@ function WorldTab({ onOpen, focused, width, height }: {
 }
 
 export const yieldCurveModule: PluginModule = {
+  series: [...TREASURY_SERIES, ...GOVERNMENT_BOND_SERIES],
   panes: [{
     id: "yield-curve",
     name: "Yield Curves",

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

@@ -0,0 +1,86 @@
+import { apiClient } from "../../../api-client";
+import type { CloudCurveId } from "../../../api-client/yield-curves";
+import { fredSeriesUrl } from "../../../sources/gloomberb-cloud/fred-series";
+import type { SeriesDefinition } from "../../../series/types";
+import { unavailableOnServer } from "../shared/cloud-resource";
+import { TREASURY_MATURITIES } from "./treasury-data";
+
+/** Each Treasury constant maturity the curve draws, as `UST:10Y`. */
+export const TREASURY_SERIES: readonly SeriesDefinition[] = TREASURY_MATURITIES.map((entry) => ({
+  id: `ust:${entry.maturity}`,
+  name: `${entry.maturity} Treasury yield`,
+  unit: "%",
+  frequency: "daily",
+  group: "Rates",
+  tags: ["treasury", "yield curve", entry.seriesId],
+  publisher: "FRED",
+  url: fredSeriesUrl(entry.seriesId),
+  expression: `UST:${entry.maturity}`,
+}));
+
+/** The government curves stored beside the Treasury's, with the tenors each publisher prints. */
+const CURVES: ReadonlyArray<{
+  curve: CloudCurveId;
+  name: (tenor: string) => string;
+  publisher: string;
+  tags: readonly string[];
+  tenors: readonly string[];
+}> = [
+  {
+    curve: "de", publisher: "Bundesbank", tags: ["Germany", "Bund", "euro"],
+    name: (tenor) => `Germany ${tenor} Bund yield`,
+    tenors: ["1Y", "2Y", "3Y", "4Y", "5Y", "6Y", "7Y", "8Y", "9Y", "10Y", "15Y", "20Y", "25Y", "30Y"],
+  },
+  {
+    curve: "gb", publisher: "Bank of England", tags: ["UK", "gilt", "sterling", "zero coupon"],
+    name: (tenor) => `UK ${tenor} gilt yield (zero coupon)`,
+    tenors: ["6M", "1Y", "2Y", "3Y", "4Y", "5Y", "7Y", "10Y", "15Y", "20Y", "25Y", "30Y", "40Y"],
+  },
+  {
+    curve: "jp", publisher: "Japan Ministry of Finance", tags: ["Japan", "JGB", "yen"],
+    name: (tenor) => `Japan ${tenor} JGB yield`,
+    tenors: ["1Y", "2Y", "3Y", "4Y", "5Y", "6Y", "7Y", "8Y", "9Y", "10Y", "15Y", "20Y", "25Y", "30Y", "40Y"],
+  },
+  {
+    curve: "ca", publisher: "Bank of Canada", tags: ["Canada", "benchmark"],
+    name: (tenor) => `Canada ${tenor} benchmark yield`,
+    tenors: ["1M", "3M", "6M", "1Y", "2Y", "3Y", "5Y", "7Y", "10Y", "30Y"],
+  },
+  {
+    curve: "eu-aaa", publisher: "ECB", tags: ["euro area", "AAA", "euro"],
+    name: (tenor) => `Euro area AAA ${tenor} yield`,
+    tenors: ["3M", "6M", "1Y", "2Y", "3Y", "5Y", "7Y", "10Y", "15Y", "20Y", "30Y"],
+  },
+  {
+    // FRED lists the 5Y and 10Y; the curve has the rest.
+    curve: "us-real", publisher: "U.S. Treasury", tags: ["TIPS", "real yield", "treasury"],
+    name: (tenor) => `${tenor} TIPS real yield`,
+    tenors: ["7Y", "20Y", "30Y"],
+  },
+  {
+    curve: "us-breakeven", publisher: "U.S. Treasury", tags: ["breakeven", "inflation expectations", "treasury"],
+    name: (tenor) => `${tenor} breakeven inflation (nominal less TIPS)`,
+    tenors: ["7Y", "20Y", "30Y"],
+  },
+];
+
+/** Each tenor of each government curve the yield curve pane draws, over time. */
+export const GOVERNMENT_BOND_SERIES: readonly SeriesDefinition[] = CURVES.flatMap(({ curve, name, publisher, tags, tenors }) => (
+  tenors.map((tenor): SeriesDefinition => ({
+    id: `bond-yield:${curve}-${tenor.toLowerCase()}`,
+    name: name(tenor),
+    unit: "%",
+    frequency: "daily",
+    group: "Rates",
+    tags: [...tags, "government bond", "yield curve", tenor],
+    publisher,
+    load: async ({ start }) => {
+      try {
+        const history = await apiClient.getCloudCurveHistory(curve, tenor, start?.toISOString().slice(0, 10));
+        return history.points;
+      } catch (error) {
+        throw unavailableOnServer(error, `${name(tenor)} history is not available yet.`);
+      }
+    },
+  }))
+));

package/src/plugins/catalog-browser.ts

@@ -56,6 +56,7 @@ import { cotModule } from "./builtin/cot";
 import { doeModule } from "./builtin/doe";
 import { gpuModule } from "./builtin/gpu";
 import { fxMatrixModule } from "./builtin/fx-matrix";
+import { docsModule } from "./builtin/docs";
 import { helpModule } from "./builtin/help";
 import { positionSizerModule } from "./builtin/kelly-sizer";
 import { layoutManagerModule } from "./builtin/layout-manager";
@@ -113,7 +114,7 @@ import {
 
 const browserApplicationPlugin = composeBuiltinPlugin({
   ...applicationPluginMeta,
-  modules: [layoutManagerModule, helpModule, changelogModule, connectionsModule],
+  modules: [layoutManagerModule, helpModule, changelogModule, connectionsModule, docsModule],
 });
 
 const browserPortfolioPlugin = composeBuiltinPlugin({

package/src/plugins/installer.ts

@@ -3,7 +3,7 @@ import { existsSync, lstatSync, mkdirSync, readdirSync, rmSync, symlinkSync } fr
 import { execFile as execFileCallback, execFileSync, spawn } from "child_process";
 import { promisify } from "util";
 import { findAbsorbedPlugin, type AbsorbedPlugin } from "./absorbed";
-import type { PluginPin } from "./builtin/plugin-marketplace/store";
+import type { PluginPin } from "./marketplace/store";
 import { bunCommand } from "./dependencies";
 import { linkHostPackages, missingPeerPlugins } from "./host-link";
 import {
@@ -518,7 +518,7 @@ export interface RegistryListing {
 export async function loadRegistryListings(): Promise<Map<string, RegistryListing>> {
   const listings = new Map<string, RegistryListing>();
   try {
-    const { loadRegistry } = await import("./builtin/plugin-marketplace/feed");
+    const { loadRegistry } = await import("./marketplace/feed");
     const feed = await loadRegistry();
     for (const plugin of feed.plugins) {
       if (!plugin.repo) continue;

package/src/plugins/loader.ts

@@ -201,6 +201,12 @@ export function pluginsMissingHostExports(): string[] {
   return [...missingHostExportFailures].sort();
 }
 
+/**
+ * Link failures of a new entry against files this process kept from the old
+ * commit: an export the old file lacks, or a package that was not there.
+ */
+const STALE_LINK_FAILURE = /Export named '[^']+' not found in module|No matching export in "[^"]+" for import|Cannot find (?:module|package) '/;
+
 /** Bun's wording when an import does not resolve, from a native import. */
 const UNRESOLVED_MODULE = /Cannot find (?:module|package) '([^']+)'/;
 
@@ -317,6 +323,15 @@ export async function loadExternalPlugin(
       loaderLog.info(`${directory} loads after a restart: ${message}`);
       return { ...base, plugin: placeholder, needsRestart: true };
     }
+    // An update that links against modules this process imported at the old
+    // commit, which Bun keeps until a restart. The row already asks for one,
+    // and the next launch imports everything fresh; a plugin that is really
+    // broken fails there, and is reported there. A host export the running
+    // Gloomberb lacks is a different failure and stays one.
+    if (restart.needsRestart && !findMissingHostExport(message) && STALE_LINK_FAILURE.test(message)) {
+      loaderLog.info(`${directory} loads after a restart: ${message}`);
+      return { ...base, plugin: placeholder, needsRestart: true };
+    }
     loaderLog.error(`Failed to load plugin from ${pluginDir}: ${err}`);
     reportCrash(err, { kind: "plugin", plugin: directory });
     if (findMissingHostExport(message)) missingHostExportFailures.add(directory);

package/src/plugins/manager-node.ts

@@ -1,5 +1,5 @@
 import { join } from "path";
-import type { PluginManager, PluginOperationResult } from "./builtin/plugin-marketplace/store";
+import type { PluginManager, PluginOperationResult } from "./marketplace/store";
 import { getPluginsDir, loadExternalPlugin } from "./loader";
 import type { PluginTarget } from "../types/plugin";
 

package/src/plugins/{builtin/plugin-marketplace → marketplace}/feed.ts

@@ -1,5 +1,5 @@
-import { createThrottledFetch } from "../../../utils/throttled-fetch";
-import { isOfficialPluginRepo } from "../../auto-update";
+import { createThrottledFetch } from "../../utils/throttled-fetch";
+import { isOfficialPluginRepo } from "../auto-update";
 import type { RegistryFeed, RegistryPlugin } from "./model";
 
 /**

package/src/plugins/{builtin/plugin-marketplace → marketplace}/model.ts

@@ -1,9 +1,9 @@
-import type { PluginTarget } from "../../../types/plugin";
-import { compareSemver, formatVersion, requiredGloomberb } from "../../../utils/semver";
-import { runsExternalPlugins } from "../../current-target";
-import { BUILTIN_EDITORIAL } from "../../builtin-editorial";
-import { builtinPluginGroupMembers } from "../../ownership";
-import type { FunctionAccess } from "../../../cli/pane-functions/function-help";
+import type { PluginTarget } from "../../types/plugin";
+import { compareSemver, formatVersion, requiredGloomberb } from "../../utils/semver";
+import { runsExternalPlugins } from "../current-target";
+import { BUILTIN_EDITORIAL } from "../builtin-editorial";
+import { builtinPluginGroupMembers } from "../ownership";
+import type { FunctionAccess } from "../../cli/pane-functions/function-help";
 import { PACK_PLUGIN_IDS } from "./packs";
 
 type PluginTier = "official" | "verified" | "community";