gloomberb 0.18.3 → 0.18.4

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

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 /**
  * The land under the desktop and web map: a quiet fill, 1 px coastlines and
  * fainter borders, at 1:50m for the world and 1:10m for the tiles in view once
@@ -67,7 +68,7 @@ function useWorldPaths(): BasemapPaths | null {
     let current = true;
     loadWorldBasemap().then((loaded) => {
       if (current) setPaths(loaded);
-    }, () => {});
+    }, logFailure("world-venue-map.basemap", "Load world basemap failed"));
     return () => {
       current = false;
     };
@@ -83,7 +84,7 @@ function useDetailTiles(active: boolean, view: GeoBox): { tiles: DetailTile[]; l
     let current = true;
     loadDetailIndex().then((tiles) => {
       if (current) setIndex(tiles);
-    }, () => {});
+    }, logFailure("world-venue-map.basemap", "Load detail tile index failed"));
     return () => {
       current = false;
     };
@@ -105,7 +106,7 @@ function useDetailTiles(active: boolean, view: GeoBox): { tiles: DetailTile[]; l
           while (next.size > TILE_CACHE_SIZE) next.delete(next.keys().next().value!);
           return next;
         });
-      }, () => {});
+      }, logFailure("world-venue-map.basemap", "Load detail tile failed"));
     }
     return () => {
       current = false;

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

@@ -221,7 +221,9 @@ export function loadDetailTile(tile: DetailTile): Promise<BasemapPaths> {
   const pending = tile.load()
     .then((chunk) => {
       const decoded = decodeQueue.then(nextTask).then(() => basemapPaths(chunk, tile.box));
-      decodeQueue = decoded.catch(() => {});
+      decodeQueue = decoded.catch(() => {
+        // Intentional ignore: keep the decode queue usable; the returned decoded promise still rejects to the tile caller.
+      });
       return decoded;
     })
     .catch((error: unknown) => {

package/src/plugins/builtin/world-venue-map/chokepoint-chart.ts

@@ -0,0 +1,40 @@
+import type { GeoRequest } from "../../../api-client/geo";
+import { SERIES_COLORS } from "../../../theme/series-colors";
+import type { PaneTemplateInstanceConfig } from "../../../types/plugin";
+import { buildCustomChartPreset } from "../chart-composer/presets";
+import { formatGeoSeriesExpression } from "../chart-composer/series-expression";
+import { chokepointSeriesFor, chokepointSeriesIds, chokepointShortName, KEY_CHOKEPOINTS, unknownChokepointMessage } from "./geo-series";
+
+const CHOKE_SERIES_LIMIT = 6;
+
+/**
+ * CHOKE's chart: the key straits' daily transits together, or the one the
+ * argument names. Text that names no strait (a ticker) is told which do, as
+ * COT and PSD tell an unknown market or crop, rather than charting nothing.
+ */
+export async function createChokepointInstance(request: GeoRequest, arg?: string): Promise<PaneTemplateInstanceConfig> {
+  const typed = arg?.trim();
+  const named = typed ? await chokepointSeriesFor(request, typed) : null;
+  if (typed && !named) throw new Error(unknownChokepointMessage(typed));
+  const ids = named
+    ? [named]
+    // Without the series index, CHOKE still asks for the key straits by name.
+    : await chokepointSeriesIds(request).then((found) => (found.length ? found : KEY_CHOKEPOINTS)).catch(() => KEY_CHOKEPOINTS);
+  const charted = ids.slice(0, CHOKE_SERIES_LIMIT);
+  const base = buildCustomChartPreset(charted.map(formatGeoSeriesExpression).join(", "));
+  // Daily transits read best over a year, each strait in its own colour. Six together
+  // take short names so the legend shows each whole; one strait keeps the index's full name.
+  const spec = {
+    ...base,
+    viewport: { ...base.viewport, range: "1Y" as const },
+    series: base.series.map((series, index) => {
+      const label = named ? undefined : chokepointShortName(charted[index] ?? "");
+      return { ...series, color: series.color ?? SERIES_COLORS[index % SERIES_COLORS.length]!, ...(label ? { label } : {}) };
+    }),
+  };
+  return {
+    title: named ? `G ${named} transits` : "G Chokepoint transits",
+    placement: "floating",
+    settings: { chartSpec: spec },
+  };
+}

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

@@ -1,5 +1,5 @@
 /**
- * What `gloomberb shot MAP <layers>` certifies: the layers the map drew and
+ * What `gloom shot MAP <layers>` certifies: the layers the map drew and
  * what each held, so a capture taken before the features arrived is refused.
  */
 import type { PaneScreenshotEvidenceHook } from "../../../cli/pane-functions/screenshot-evidence";

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) => {