gloomberb 0.18.2 → 0.18.4

package/src/plugins/builtin/world-venue-map/geo-series.ts

@@ -1,3 +1,5 @@
+import { ApiRequestError } from "../../../api-client/errors";
+import { logFailure } from "../../../utils/log-failure";
 /**
  * Map series in G: numbers over time for things with a place (chokepoint
  * transits, port calls). `GEO:<id or alias>` resolves through the server's
@@ -54,9 +56,20 @@ export async function resolveGeoChartSeries(
   viewport: ChartViewportSpec,
   signal?: AbortSignal,
 ): Promise<ResolvedSeries> {
-  const hit = await resolveGeoSeries(request, token, signal).catch(() => null);
+  let indexFailed = false;
+  const hit = await resolveGeoSeries(request, token, signal).catch((error: unknown) => {
+    if (signal?.aborted) throw error;
+    logFailure("world-venue-map.geo-series", "Resolve map series failed")(error);
+    indexFailed = true;
+    return null;
+  });
   const payload = await getGeoSeries(request, hit?.id ?? token, geoSeriesRange(viewport), signal).catch((error: unknown) => {
-    throw hit ? error : new Error(`No map series named ${token}.`);
+    if (signal?.aborted) throw error;
+    if (hit) throw error;
+    if (!indexFailed && error instanceof ApiRequestError && error.status === 404) {
+      throw new Error(`No map series named ${token}.`);
+    }
+    throw new Error("Map series unavailable.", { cause: error });
   });
   const points: TimeSeriesPoint[] = (payload.points ?? []).flatMap(([day, value]) => {
     const date = new Date(`${day}T00:00:00Z`);
@@ -83,7 +96,11 @@ export async function resolveGeoChartSeries(
 
 export function createGeoChartSeriesCapability(request: GeoRequest = cloudGeoRequest): ChartSeriesCapability {
   const search = async (query: string, limit: number, signal?: AbortSignal) => {
-    const { series } = await searchGeoSeries(request, query, signal).catch(() => ({ series: [] as GeoSeriesSearchHit[] }));
+    const { series } = await searchGeoSeries(request, query, signal).catch((error: unknown) => {
+      if (signal?.aborted) throw error;
+      logFailure("world-venue-map.geo-series", "Search map series failed")(error);
+      throw new Error("Map series search unavailable.", { cause: error });
+    });
     return series.slice(0, limit).map(catalogItem);
   };
   return chartSeriesProvider({
@@ -118,6 +135,25 @@ const CHOKEPOINT_NAMES: Readonly<Record<string, string>> = {
   BOSPHORUS: "Bosphorus",
 };
 
+/**
+ * The key straits as a legend of all six can carry them: the full series
+ * names ("Strait of Hormuz transits") would be cut to a fragment each. The
+ * chart's title and unit already say these are transits.
+ */
+const CHOKEPOINT_SHORT_NAMES: Readonly<Record<string, string>> = {
+  SUEZ: "Suez",
+  PANAMA: "Panama",
+  HORMUZ: "Hormuz",
+  BABELMANDEB: "Bab el-Mandeb",
+  MALACCA: "Malacca",
+  BOSPHORUS: "Bosphorus",
+};
+
+/** A key strait's short legend name; undefined for any other series, which keeps the name the index gives it. */
+export function chokepointShortName(alias: string): string | undefined {
+  return CHOKEPOINT_SHORT_NAMES[alias.toUpperCase()];
+}
+
 /**
  * Who publishes the chokepoints' daily transits, as the server's chokepoints
  * layer names them (`publisher`); the catalog lists the key straits offline.
@@ -161,16 +197,59 @@ export async function chokepointSeriesIds(request: GeoRequest, signal?: AbortSig
   });
 }
 
+/** A series' chokepoint as the index names it: "Strait of Hormuz transits" is "Strait of Hormuz". */
+function chokepointName(seriesName: string): string {
+  return seriesName.replace(/\s+transits$/i, "");
+}
+
+/** A chokepoint's name without what straits and canals share ("Strait of Hormuz" is Hormuz, "Suez Canal" Suez), as it is typed short. */
+function chokepointCore(name: string): string {
+  return compact(chokepointName(name)
+    .replace(/^strait of\s+/i, "")
+    .replace(/\s+(strait|canal|channel|passage)$/i, ""));
+}
+
+function matchIndexedChokepoint(series: readonly GeoSeriesSearchHit[], wanted: string): string | null {
+  const chokepoints = series.filter((hit) => hit.layer === CHOKEPOINTS_LAYER && hit.alias);
+  // A main transit series has the plain alias (SUEZ), its splits a suffix (SUEZ.TANKER).
+  const exact = chokepoints.find((hit) => compact(hit.alias!) === wanted);
+  if (exact) return exact.alias!;
+  const main = chokepoints.filter((hit) => !hit.alias!.includes("."));
+  const named = main.find((hit) => compact(chokepointName(hit.name)) === wanted || chokepointCore(hit.name) === wanted);
+  if (named) return named.alias!;
+  // Part of one strait's name ("mandeb") finds it; part of several ("strait") names none.
+  return main.length === 1 ? main[0]!.alias! : null;
+}
+
+function matchKeyChokepoint(wanted: string): string | null {
+  return KEY_CHOKEPOINTS.find((alias) => alias === wanted || compact(CHOKEPOINT_NAMES[alias] ?? "") === wanted
+    || chokepointCore(CHOKEPOINT_NAMES[alias] ?? "") === wanted) ?? null;
+}
+
 /**
  * The series a typed chokepoint names: "suez", "Bab el-Mandeb" and "Strait
- * of Hormuz" all find the strait's main transit series.
+ * of Hormuz" all find the strait's main transit series. Null for text that
+ * names no chokepoint (a ticker), so CHOKE can say which exist. Without the
+ * series index, the key straits are still known by name.
  */
-export async function chokepointSeriesFor(request: GeoRequest, typed: string, signal?: AbortSignal): Promise<string> {
+export async function chokepointSeriesFor(request: GeoRequest, typed: string, signal?: AbortSignal): Promise<string | null> {
   const wanted = compact(typed);
-  const { series } = await searchGeoSeries(request, typed, signal).catch(() => ({ series: [] as GeoSeriesSearchHit[] }));
-  const chokepoints = series.filter((hit) => hit.layer === CHOKEPOINTS_LAYER);
-  const exact = chokepoints.find((hit) => hit.alias && compact(hit.alias) === wanted);
-  // A main transit series has the plain alias (SUEZ), its splits a suffix (SUEZ.TANKER).
-  const named = chokepoints.find((hit) => hit.alias && !hit.alias.includes("."));
-  return exact?.alias ?? named?.alias ?? wanted;
+  if (!wanted) return null;
+  let series: GeoSeriesSearchHit[];
+  try {
+    ({ series } = await searchGeoSeries(request, typed, signal));
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    logFailure("world-venue-map.geo-series", "Find chokepoint series failed")(error);
+    const known = matchKeyChokepoint(wanted);
+    if (known) return known;
+    throw new Error("Chokepoint search unavailable. Try again.", { cause: error });
+  }
+  return matchIndexedChokepoint(series, wanted) ?? matchKeyChokepoint(wanted);
+}
+
+/** What CHOKE tells text that names no chokepoint: the key straits, as it takes them typed. */
+export function unknownChokepointMessage(typed: string): string {
+  const names = KEY_CHOKEPOINTS.map((alias) => (CHOKEPOINT_SHORT_NAMES[alias] ?? alias).toUpperCase());
+  return `No chokepoint named ${typed.trim()}. Try CHOKE ${names.slice(0, -1).join(", ")} or ${names.at(-1)}.`;
 }

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

@@ -1,5 +1,5 @@
 /**
- * `gloomberb fn MAP`: the venue list, or with a layer (`MAP ships`,
+ * `gloom fn MAP`: the venue list, or with a layer (`MAP ships`,
  * `--layer vessels`) that layer's entity table with plain values and the
  * linked tickers, for JSON and CSV.
  */

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

@@ -1,19 +1,15 @@
 import { peekGeoCatalog } from "../../../api-client/geo";
-import { SERIES_COLORS } from "../../../theme/series-colors";
 import { CHART_COMPOSER_PANE_ID } from "../../../types/config";
 import type { PaneTemplateDef } from "../../../types/plugin";
 import { chartHeadless } from "../chart-composer/headless";
-import { buildCustomChartPreset } from "../chart-composer/presets";
-import { formatGeoSeriesExpression } from "../chart-composer/series-expression";
 import type { PluginModule } from "../plugin-module";
+import { createChokepointInstance } from "./chokepoint-chart";
 import { cloudGeoRequest } from "./client";
-import { chokepointSeriesFor, chokepointSeriesIds, CHOKEPOINT_SERIES, createGeoChartSeriesCapability, KEY_CHOKEPOINTS } from "./geo-series";
+import { CHOKEPOINT_SERIES, createGeoChartSeriesCapability } from "./geo-series";
 import { mapHeadless } from "./headless";
 import { buildMapSettingsDef, groupTitle, MAP_PRESET_OPTIONS, parseMapPreset } from "./layers";
 import { WORLD_VENUE_MAP_PANE_ID, WorldVenueMapPane } from "./pane";
 
-const CHOKE_SERIES_LIMIT = 6;
-
 const chartComposerHeadless = chartHeadless("chart-composer-pane");
 
 const chokepointTemplate: PaneTemplateDef = {
@@ -37,26 +33,7 @@ const chokepointTemplate: PaneTemplateDef = {
   keywords: ["chokepoint", "chokepoints", "transits", "suez", "panama", "hormuz", "malacca", "shipping", "strait", "canal"],
   shortcut: { prefix: "CHOKE", argPlaceholder: "chokepoint", argKind: "text", argOptional: true },
   canCreate: () => true,
-  createInstance: async (_context, options) => {
-    const typed = options?.arg?.trim();
-    const named = typed ? await chokepointSeriesFor(cloudGeoRequest, typed) : null;
-    const ids = named
-      ? [named]
-      // Without the series index, CHOKE still asks for the key straits by name.
-      : await chokepointSeriesIds(cloudGeoRequest).then((found) => (found.length ? found : KEY_CHOKEPOINTS)).catch(() => KEY_CHOKEPOINTS);
-    const base = buildCustomChartPreset(ids.slice(0, CHOKE_SERIES_LIMIT).map(formatGeoSeriesExpression).join(", "));
-    // Daily transits read best over a year, each strait in its own colour.
-    const spec = {
-      ...base,
-      viewport: { ...base.viewport, range: "1Y" as const },
-      series: base.series.map((series, index) => ({ ...series, color: series.color ?? SERIES_COLORS[index % SERIES_COLORS.length]! })),
-    };
-    return {
-      title: named ? `G ${named} transits` : "G Chokepoint transits",
-      placement: "floating",
-      settings: { chartSpec: spec },
-    };
-  },
+  createInstance: (_context, options) => createChokepointInstance(cloudGeoRequest, options?.arg),
 };
 
 export const worldVenueMapModule: PluginModule = {

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

@@ -163,7 +163,7 @@ const LAYER_COVERAGE: Readonly<Record<string, string>> = {
 
 /**
  * Why a layer can have nothing for a search or a view outside its region:
- * "Terminals cover the United States only (as of 31 Aug 2023)." Null for a
+ * "Terminals cover the United States only (as of 1 Oct 2026)." Null for a
  * worldwide layer.
  */
 export function layerCoverageNote(layer: Pick<GeoLayerInfo, "id" | "name" | "asOf" | "cadence">): string | null {

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

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import { createElement, useCallback, useEffect, useMemo, useRef, useState, type PointerEvent as ReactPointerEvent } from "react";
 import type { CloudWorldVenuePayload } from "../../../api-client";
 import { Box, ChartSurface, Text, useNativeRenderer, useUiCapabilities, useUiHost } from "../../../ui";
@@ -399,7 +400,7 @@ function useCountryLabels(): readonly CountryLabel[] | null {
     let current = true;
     loadCountryLabels().then((loaded) => {
       if (current) setLabels(loaded);
-    }, () => {});
+    }, logFailure("world-venue-map.map", "Load country labels failed"));
     return () => {
       current = false;
     };

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

@@ -21,6 +21,7 @@ import { useAsyncResource, usePaneSettingValue, usePluginPaneState } from "../..
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, TextAttributes, useUiCapabilities } from "../../../ui";
+import { withCountryFlag } from "../../../components/ui/country-flag";
 import { loadWorldVenues } from "./client";
 import { WORLD_VENUE_MAP_PANE_ID } from "./ids";
 import { LayeredMapView } from "./layered-pane";
@@ -160,11 +161,12 @@ function VenueMapView({ focused, width, height }: PaneProps) {
       case "mic":
         return { text: venue.mic, color: colors.textBright, attributes: TextAttributes.BOLD };
       case "name":
-        return { text: venue.title, color: colors.textMuted };
+        // The desktop and the web lead each venue with its country's flag.
+        return withCountryFlag({ text: venue.title, color: colors.textMuted }, venue.countryCode, nativePaneChrome === true);
       case "time":
         return { text: formatVenueLocalTime(venue.timezone, now), color: colors.textDim };
     }
-  }, [now]);
+  }, [nativePaneChrome, now]);
 
   const sidebarHeader = (
     <QueryBar

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

@@ -1,6 +1,7 @@
 import type { CloudWorldVenuePayload } from "../../../api-client";
 import { colors } from "../../../theme/colors";
-import { Box, Text, TextAttributes } from "../../../ui";
+import { CountryFlagLead } from "../../../components/ui/country-flag";
+import { Box, Text, TextAttributes, useUiCapabilities } from "../../../ui";
 import { formatVenueCountdown, formatVenueLocalTime, venueRemainingSeconds } from "./model";
 
 export function SelectedVenueHeader({
@@ -14,19 +15,29 @@ export function SelectedVenueHeader({
   now: number;
   width: number;
 }) {
+  const desktop = useUiCapabilities().nativePaneChrome === true;
   if (!venue) return <Box height={2} />;
   const remaining = formatVenueCountdown(venueRemainingSeconds(venue, checkedAt, now));
   const state = venue.isOpen ? "OPEN" : "CLOSED";
   const transition = remaining ? `${venue.isOpen ? "closes" : "opens"} ${remaining}` : "";
+  const place = (
+    <Text fg={colors.textMuted}>
+      {`${venue.city}, ${venue.country} · ${formatVenueLocalTime(venue.timezone, now)}${transition ? ` · ${transition}` : ""}`}
+    </Text>
+  );
   return (
     <Box flexDirection="column" height={2} width={width} paddingX={1}>
       <Box flexDirection="row" justifyContent="space-between" width="100%">
         <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>{venue.mic}</Text>
         <Text fg={venue.isOpen ? colors.positive : colors.textDim}>{state}</Text>
       </Box>
-      <Text fg={colors.textMuted}>
-        {`${venue.city}, ${venue.country} · ${formatVenueLocalTime(venue.timezone, now)}${transition ? ` · ${transition}` : ""}`}
-      </Text>
+      {desktop ? (
+        // The desktop and the web lead the venue's place with its country's flag.
+        <Box flexDirection="row" alignItems="center">
+          <CountryFlagLead value={venue.countryCode} />
+          {place}
+        </Box>
+      ) : place}
     </Box>
   );
 }

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

@@ -0,0 +1,25 @@
+import { apiClient } from "../../../api-client";
+import type { SwapCurvePayload, SwapTenor } from "../../../api-client/swap-curve";
+import { createPluginCache } from "../../../data/plugin-cache";
+import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
+import { validateSwapCurve } from "./swaps-model";
+
+export const swapCurveCache = createPluginCache<SwapCurvePayload>({
+  kind: "sofr-swap-curve", source: "gloom-cloud", schemaVersion: 1,
+  policy: { staleMs: 60 * 60_000, expireMs: 7 * 24 * 60 * 60_000 },
+});
+
+export async function fetchSwapCurve(tenor: SwapTenor,
+  client: Pick<typeof apiClient, "getCloudSwapCurve"> = apiClient): Promise<SwapCurvePayload> {
+  try {
+    const payload = validateSwapCurve(await client.getCloudSwapCurve(tenor, 365));
+    if (payload.history.tenor !== tenor) throw new Error("The server returned history for a different swap tenor");
+    return payload;
+  } catch (error) {
+    throw unavailableOnServer(error, "SOFR swap rates are not available yet.");
+  }
+}
+
+export const getCachedSwapCurve = (tenor: SwapTenor) => cachedCloudResource(swapCurveCache, tenor, validateSwapCurve);
+export const loadSwapCurve = (tenor: SwapTenor, force = false) =>
+  loadCloudResource(swapCurveCache, tenor, () => fetchSwapCurve(tenor), { force, validate: validateSwapCurve });

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

@@ -5,7 +5,7 @@ import type { MoveHorizon } from "../shared/move-rank";
 import type { CurveBasis } from "./forward";
 import { yieldSpreads, type YieldLookbackCurves } from "./chart";
 import { completeYieldCurve, loadHistoricalYieldCurve, yieldCurveDate } from "./history";
-import { DATE_OPTION_FORMATS, readCalendarDate } from "../../../utils/calendar-date";
+import { DATE_OPTION_FORMATS, dateOptionHint, readCalendarDate } from "../../../utils/calendar-date";
 import { isYieldObservationDate, loadYieldCurve, type YieldPoint } from "./treasury-data";
 
 export type CurveId = CloudCurveId;
@@ -178,7 +178,7 @@ export async function loadComparePoints(curve: CurveId, date: string, client: Cu
 }
 
 const RELATIVE = /^(\d{1,2})([DWMY])$/i;
-const COMPARE_HELP = `Compare with a date as ${DATE_OPTION_FORMATS}, or a span such as 1D, 1W, 3M or 1Y.`;
+const COMPARE_FORMS = `Compare with a date as ${DATE_OPTION_FORMATS}, 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 {
@@ -191,12 +191,15 @@ export function isCompareSpan(value: string): boolean {
  * 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 {
+export function parseCompareInput(value: string, now = new Date(), option = ""): string {
   const text = value.trim();
   if (!text) return "";
   if (isCompareSpan(text)) return text.toUpperCase();
   const date = readCalendarDate(text);
-  if (!date) throw new Error(COMPARE_HELP);
+  if (!date) {
+    const hint = dateOptionHint(text, option);
+    throw new Error(hint ? `${COMPARE_FORMS}: ${hint}.` : `${COMPARE_FORMS}.`);
+  }
   return yieldCurveDate(date, now);
 }
 

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

@@ -12,6 +12,9 @@ import { loadYieldCurveLookbacks, yieldCurveDate } from "./history";
 import { loadWorldRows, type WorldRow } from "./world";
 import { formatBasisPoints, toBasisPoints } from "../../../utils/basis-points";
 import { DATE_OPTION_EXAMPLES } from "../../../utils/calendar-date";
+import { SWAP_TENORS, type SwapCurvePayload, type SwapTenor } from "../../../api-client/swap-curve";
+import { fetchSwapCurve } from "./client";
+import { formatSwapBp, selectedSwapTenor } from "./swaps-model";
 
 const percent = (value: unknown) => value == null ? "-" : `${Number(value).toFixed(2)}%`;
 /** A move already in basis points: `+3bp`, `-1bp`, `0bp`. */
@@ -65,6 +68,14 @@ const WORLD_COLUMNS = [
   { key: "tenYearChangeBasisPoints", header: "10Y 1D bp", align: "right" as const, format: basisPoints },
   { key: "asOf", header: "As of" },
 ];
+const SWAP_COLUMNS = [
+  { key: "tenor", header: "Tenor" },
+  { key: "rate", header: "Rate %", align: "right" as const, format: percent },
+  { key: "changeBp", header: "1D bp", align: "right" as const, format: (value: unknown) => value == null ? "-" : formatSwapBp(Number(value)) },
+  { key: "spreadBp", header: "Spread bp", align: "right" as const, format: (value: unknown) => value == null ? "-" : formatSwapBp(Number(value)) },
+  { key: "tradeCount", header: "Trades", align: "right" as const,
+    format: (value: unknown, row: Record<string, unknown>) => `${value}${row.quality === "thin" ? " Thin" : ""}` },
+];
 
 export interface YieldCurveHeadlessDependencies {
   load(curve: CurveId, requestedDate: string, context: HeadlessPaneContext): Promise<CurveData>;
@@ -72,6 +83,7 @@ export interface YieldCurveHeadlessDependencies {
   /** 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[]>;
+  swaps?(tenor: SwapTenor, context: HeadlessPaneContext): Promise<SwapCurvePayload>;
 }
 
 const defaultDependencies: Required<YieldCurveHeadlessDependencies> = {
@@ -82,6 +94,7 @@ const defaultDependencies: Required<YieldCurveHeadlessDependencies> = {
       .map((lookback) => [lookback.id, lookback.points]),
   ),
   world: (context) => loadWorldRows(context.apiClient),
+  swaps: (tenor, context) => fetchSwapCurve(tenor, context.apiClient),
 };
 
 const bp = (value: number | null) => value == null ? null : Math.round(value * 100);
@@ -116,6 +129,7 @@ export function createYieldCurveHeadless(
   const loadCompare = dependencies.compare ?? defaultDependencies.compare;
   const loadLookbacks = dependencies.lookbacks ?? defaultDependencies.lookbacks;
   const loadWorld = dependencies.world ?? defaultDependencies.world;
+  const loadSwaps = dependencies.swaps ?? defaultDependencies.swaps;
   return {
     shape: "rows",
     argument: { kind: "free-text", optional: true, placeholder: "[curve] [date]",
@@ -129,14 +143,21 @@ export function createYieldCurveHeadless(
         pluginState: { pluginId: "macro", key: "yield-curve:view" } },
       { key: "forward", type: "boolean", description: "Overlay the one-year-forward curve on the chart.",
         pluginState: { pluginId: "macro", key: "yield-curve:forward" } },
-      { key: "tab", type: "enum", values: [{ value: "curve" }, { value: "world" }],
-        description: "curve (default), or world: each market's 2Y, 10Y, 30Y and 2s10s on its own latest session.",
+      { key: "tab", type: "enum", values: [{ value: "curve" }, { value: "world" }, { value: "swaps" }],
+        description: "curve (default), world (government yields), or swaps (USD SOFR rates and Treasury swap spreads). Spreads use native quotes: annual ACT/360 OIS versus semiannual bond-equivalent Treasury yields.",
         pluginState: { pluginId: "macro", key: "yield-curve:tab" } },
+      { key: "tenor", type: "enum", values: SWAP_TENORS.map((value) => ({ value })),
+        description: "Swaps history tenor (default 10Y); the curve table always includes every tenor.",
+        pluginState: { pluginId: "macro", key: "yield-curve:swap-tenor" } },
+      { key: "swap-view", type: "enum", values: [{ value: "curve" }, { value: "history" }],
+        description: "Swaps chart: current curve with 1W/1M comparisons, or the selected tenor's history.",
+        pluginState: { pluginId: "macro", key: "yield-curve:swap-view" } },
     ],
     columns: COLUMNS,
     // The title names the curve, as the pane's Curve select does.
     describe: (args) => {
       if (args.options.tab === "world") return "Yield Curves | World";
+      if (args.options.tab === "swaps") return "Yield Curves | USD SOFR Swaps";
       try {
         const curve = curveIdOf(args.options.curve) ?? parseCurveArgument(args.argument).curve ?? "us";
         return `Yield Curves | ${curveOption(curve).label}`;
@@ -145,6 +166,19 @@ export function createYieldCurveHeadless(
       }
     },
     async load(args, context) {
+      if (args.options.tab === "swaps") {
+        const data = await loadSwaps(selectedSwapTenor(args.options.tenor), context);
+        return {
+          freshness: { source: "DTCC public swap reports", status: "not-a-feed", basis: "daily trade estimates", cadence: "daily",
+            tradingDayMarket: "US" },
+          columns: SWAP_COLUMNS,
+          rows: (data.asOf ? data.points : []).map((point) => ({ ...point, asOf: data.asOf })),
+          metadata: { currency: data.currency, benchmark: data.benchmark, units: "Percent", changeUnit: "Basis points",
+            asOf: data.asOf, fetchedAt: data.fetchedAt, stale: data.stale, previousDate: data.previousDate,
+            treasuryDate: data.treasuryDate, comparisons: data.comparisons, history: data.history },
+          errors: !data.asOf ? ["No swap rates yet."] : data.stale ? ["The swap curve is stale."] : [],
+        };
+      }
       if (args.options.tab === "world") {
         const rows = await loadWorld(context);
         return {
@@ -161,8 +195,8 @@ export function createYieldCurveHeadless(
         throw new Error(`Unknown curve ${String(args.options.curve)}; use ${CURVE_OPTIONS.map((option) => option.aliases[0]).join(", ")}.`);
       }
       const curve = optionCurve ?? argument.curve ?? "us";
-      const requestedDate = args.options.date != null ? yieldCurveDate(args.options.date) : argument.date;
-      const compareInput = args.options.compare == null ? "" : parseCompareInput(String(args.options.compare));
+      const requestedDate = args.options.date != null ? yieldCurveDate(args.options.date, new Date(), "--date") : argument.date;
+      const compareInput = args.options.compare == null ? "" : parseCompareInput(String(args.options.compare), new Date(), "--compare");
       const data = await dependencies.load(curve, requestedDate, context);
       const points = data.points;
       const session = curveAsOf(points);

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

@@ -1,6 +1,6 @@
 import { apiClient, type CloudFredSeriesPayload } from "../../../api-client";
 import { isYieldObservationDate, TREASURY_MATURITIES, type YieldPoint } from "./treasury-data";
-import { DATE_OPTION_FORMATS, readCalendarDate } from "../../../utils/calendar-date";
+import { dateOptionError, dateOptionFormatsOr, readCalendarDate } from "../../../utils/calendar-date";
 
 const DAY_MS = 86_400_000;
 export type TreasurySeriesLoader = (seriesId: string, options: {
@@ -10,12 +10,13 @@ export type TreasurySeriesLoader = (seriesId: string, options: {
   sortOrder: "desc";
 }) => Promise<CloudFredSeriesPayload>;
 
-export function yieldCurveDate(value: unknown, now = new Date()): string {
+/** An as-of date, or "latest" (empty) for the newest session; `option` is how a command line types it (`--date`), empty for the pane's field. */
+export function yieldCurveDate(value: unknown, now = new Date(), option = ""): string {
   if (value == null) return "";
   const text = typeof value === "string" ? value.trim() : "";
   if (typeof value === "string" && (text === "" || text.toLowerCase() === "latest")) return "";
   const date = readCalendarDate(text);
-  if (!date) throw new Error(`Use an as-of date as ${DATE_OPTION_FORMATS}, or latest.`);
+  if (!date) throw new Error(dateOptionError(text, option, { now, subject: "an as-of date", formats: dateOptionFormatsOr("latest") }));
   if (date > now.toISOString().slice(0, 10)) throw new Error("A Treasury curve cannot use a future date.");
   return date;
 }

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

@@ -35,9 +35,11 @@ import { forwardCurve, type CurveBasis } from "./forward";
 import { loadYieldCurveLookbacks, yieldCurveDate } from "./history";
 import { curveAsOf, isYieldObservationDate, type YieldPoint, yieldCurveErrors } from "./treasury-data";
 import { loadWorldRows, type WorldRow } from "./world";
+import { SwapsTab } from "./swaps";
+import { swapCurveCache } from "./client";
 
-type GcTab = "curve" | "world";
-const TABS = [{ label: "Curve", value: "curve" }, { label: "World", value: "world" }];
+type GcTab = "curve" | "world" | "swaps";
+const TABS = [{ label: "Curve", value: "curve" }, { label: "World", value: "world" }, { label: "Swaps", value: "swaps" }];
 const EMPTY_POINTS: YieldPoint[] = [];
 /** Axis word for the loaded curve's basis. */
 const BASIS_LABEL: Record<CurveBasis, string> = {
@@ -129,13 +131,15 @@ export function YieldCurvePane({ focused, width, height }: PaneProps) {
   return (
     <Box flexDirection="column" width={width} height={height}>
       {strip}
-      {(["curve", "world"] as const).map((id) => mounted.has(id) ? (
+      {(["curve", "world", "swaps"] as const).map((id) => mounted.has(id) ? (
         <Box key={id} visible={tab === id} flexDirection="column" width={width} height={bodyHeight} flexGrow={1} flexBasis={0}
           overflow="hidden">
           <PaneFooterScope active={tab === id}>
             {id === "curve"
               ? <CurveTab curve={curve} onCurveChange={setCurve} focused={focused && tab === "curve"} width={width} height={bodyHeight} />
-              : <WorldTab onOpen={openCurve} focused={focused && tab === "world"} width={width} height={bodyHeight} />}
+              : id === "world"
+                ? <WorldTab onOpen={openCurve} focused={focused && tab === "world"} width={width} height={bodyHeight} />
+                : <SwapsTab focused={focused && tab === "swaps"} width={width} height={bodyHeight} />}
           </PaneFooterScope>
         </Box>
       ) : null)}
@@ -461,6 +465,8 @@ function WorldTab({ onOpen, focused, width, height }: {
 }
 
 export const yieldCurveModule: PluginModule = {
+  setup(ctx) { swapCurveCache.attach(ctx.persistence); },
+  dispose() { swapCurveCache.reset(); },
   series: [...TREASURY_SERIES, ...GOVERNMENT_BOND_SERIES],
   panes: [{
     id: "yield-curve",
@@ -475,9 +481,9 @@ export const yieldCurveModule: PluginModule = {
     id: "yield-curve-pane",
     paneId: "yield-curve",
     label: "Yield Curve",
-    description: "Government bond curves: US Treasury, TIPS real, breakevens, euro AAA, Bund, Gilt, JGB and Canada, with a world grid.",
+    description: "Government bond curves, a world grid, and USD SOFR swap rates, swap spreads and tenor history.",
     keywords: ["yield", "curve", "treasury", "bonds", "rates", "gc", "interest", "tips", "breakeven", "bund", "gilt", "jgb",
-      "sovereign", "world", "forward"],
+      "sovereign", "world", "forward", "swaps", "sofr", "ois", "swap spread"],
     shortcut: { prefix: "GC", argPlaceholder: "[curve] [date]", argKind: "text", argOptional: true },
     headless: yieldCurveHeadless,
     createInstance: (_context, options) => {

package/src/plugins/builtin/yield-curve/swaps-model.ts

@@ -0,0 +1,93 @@
+import { SWAP_TENORS, type SwapCurvePayload, type SwapPoint, type SwapTenor } from "../../../api-client/swap-curve";
+import type { CurveSeries } from "../../../components/chart/curve";
+import { staticSeries } from "../../../components/chart/static/series";
+
+const finite = (value: unknown) => value === null || typeof value === "number" && Number.isFinite(value);
+const count = (value: number) => Number.isInteger(value) && value >= 0;
+const date = (value: unknown) => value === null || typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)
+  && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+const quality = (value: unknown) => value === "ok" || value === "thin" || value === "missing";
+
+/** Reject incompatible observations before they replace the last usable cache. */
+export function validateSwapCurve(payload: SwapCurvePayload): SwapCurvePayload {
+  const invalid = () => { throw new Error("The server returned invalid SOFR swap observations"); };
+  if (!payload || payload.currency !== "USD" || payload.benchmark !== "SOFR" || typeof payload.stale !== "boolean"
+    || !date(payload.asOf) || !date(payload.previousDate) || !date(payload.treasuryDate)
+    || !payload.comparisons?.week || !payload.comparisons.month || !payload.history
+    || !SWAP_TENORS.includes(payload.history.tenor) || !Array.isArray(payload.history.points)) return invalid();
+  for (const snapshot of [{ date: payload.asOf, points: payload.points }, payload.comparisons.week, payload.comparisons.month]) {
+    if (!date(snapshot.date) || !Array.isArray(snapshot.points)
+      || new Set(snapshot.points.map((point) => point.tenor)).size !== snapshot.points.length) return invalid();
+    for (const point of snapshot.points) {
+      if (!SWAP_TENORS.includes(point.tenor) || point.years !== Number.parseInt(point.tenor)
+        || !finite(point.rate) || !finite(point.changeBp) || !finite(point.spreadBp) || !finite(point.treasuryRate)
+        || !count(point.tradeCount) || !count(point.candidateCount) || !count(point.excludedCount)
+        || !Number.isFinite(point.notionalUsd) || point.notionalUsd < 0 || !quality(point.quality)
+        || point.rate != null && (snapshot.date == null || point.tradeCount < 3 || point.quality === "missing" || point.quality === "ok" && point.tradeCount < 5)
+        || point.rate == null && (point.changeBp != null || point.spreadBp != null)
+        || point.tenor === "15Y" && point.spreadBp != null) return invalid();
+    }
+  }
+  if (payload.points.length !== SWAP_TENORS.length) return invalid();
+  let previous = "";
+  for (const point of payload.history.points) {
+    if (point.date == null || !date(point.date) || point.date <= previous || !finite(point.rate) || !finite(point.spreadBp)
+      || !count(point.tradeCount) || !quality(point.quality)
+      || point.rate != null && (point.tradeCount < 3 || point.quality === "missing" || point.quality === "ok" && point.tradeCount < 5)
+      || point.rate == null && point.spreadBp != null
+      || payload.history.tenor === "15Y" && point.spreadBp != null) return invalid();
+    previous = point.date;
+  }
+  return payload;
+}
+
+export function selectedSwapTenor(value: unknown): SwapTenor {
+  return SWAP_TENORS.includes(value as SwapTenor) ? value as SwapTenor : "10Y";
+}
+
+const curvePoints = (points: readonly SwapPoint[]) => points.map((point) => ({
+  id: point.tenor, label: point.tenor, x: point.years, value: point.rate,
+}));
+
+/** Missing tenors remain null nodes, which break the line instead of bridging the gap. */
+export function swapCurveSeries(payload: SwapCurvePayload,
+  colors: { current: string; thin: string; ghosts: Readonly<Record<string, string>> }): CurveSeries[] {
+  const series: CurveSeries[] = [
+    { id: "sofr", label: "SOFR", role: "primary", color: colors.current, points: curvePoints(payload.points) },
+    ...(["week", "month"] as const).flatMap((key): CurveSeries[] => {
+      const snapshot = payload.comparisons[key];
+      const id = key === "week" ? "1W" : "1M";
+      return snapshot.date == null ? [] : [{ id, label: id, role: "ghost", asOf: snapshot.date,
+        color: colors.ghosts[id], points: curvePoints(snapshot.points) }];
+    }),
+  ];
+  // The shared marker layer identifies thin observations on every dated curve.
+  // Keep their values in the main series so selection/readouts still show them.
+  const snapshots = [payload.points, ...(["week", "month"] as const)
+    .filter((key) => payload.comparisons[key].date != null).map((key) => payload.comparisons[key].points)];
+  return [...series, ...series.flatMap((entry, index): CurveSeries[] => {
+    const points = curvePoints(snapshots[index]!.filter((point) => point.quality === "thin" && point.rate != null));
+    return points.length ? [{ id: `${entry.id}-thin`, label: "Thin", role: "marker", color: colors.thin, points }] : [];
+  })];
+}
+
+/** Preserve missing sessions and their null values on the calendar axis. */
+export function swapHistorySeries(history: SwapCurvePayload["history"], color: string, thinColor: string) {
+  const observation = (point: SwapCurvePayload["history"]["points"][number], thin: boolean) => ({
+    date: new Date(point.date), observedAt: new Date(point.date),
+    value: (point.quality === "thin") === thin ? point.rate : null,
+  });
+  return [
+    staticSeries(history.points.map((point) => observation(point, false)),
+      { id: `sofr-${history.tenor}`, label: `${history.tenor} SOFR`, color, calendarSpaced: true }),
+    ...(history.points.some((point) => point.quality === "thin" && point.rate != null)
+      ? [staticSeries(history.points.map((point) => observation(point, true)),
+        { id: `sofr-${history.tenor}-thin`, label: "Thin", color: thinColor, style: "points", calendarSpaced: true })] : []),
+  ];
+}
+
+/** Already in basis points: never multiply a swap change or spread by 100 again. */
+export function formatSwapBp(value: number): string {
+  const rounded = Math.round(value * 10) / 10;
+  return `${rounded > 0 ? "+" : ""}${rounded.toFixed(1)}bp`;
+}