gloomberb 0.16.4 → 0.16.5

package/src/plugins/builtin/chart-composer/data-catalog-pane.tsx

@@ -12,7 +12,7 @@ import {
 } from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
 import { colors } from "../../../theme/colors";
-import { compareSortValues, nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
+import { nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
 import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { usePaneSettingValue } from "../../../state/app/context";
 import { usePluginAppActions, usePluginPaneState } from "../../runtime";
@@ -20,22 +20,28 @@ import { usePaneStatusLinkFooter } from "../../../components/layout/pane/status-
 import { PaneTemplateInputStep } from "../../../components/pane-template-wizard";
 import { type PromptContext, useDialog } from "../../../ui/dialog";
 import {
-  CATALOG_FILTERS,
   CHART_COMPOSER_TEMPLATE_ID,
   DATA_CATALOG_PANE_ID,
   catalogEmptyCopy,
   catalogExpressionForRow,
   catalogInstrumentMatchesQuery,
+  catalogRowsForListedCrypto,
   catalogRowsForResolvedInstruments,
+  catalogRowsFromEntries,
+  catalogTabs,
+  compareCatalogGroups,
+  compareCatalogText,
   filterCatalogRows,
-  listStaticCatalogInventory,
+  frequencyRank,
   looksLikeCatalogTickerQuery,
+  mergeCatalogRows,
+  normalizeCatalogFilter,
   type CatalogFilterId,
   type CatalogSeriesRow,
 } from "./catalog-inventory";
-import { useCatalogUniverse } from "./use-series-catalog";
+import { useCatalogUniverse, useRegisteredSeries } from "./use-series-catalog";
 
-type CatalogColumnId = "series" | "publisher" | "kind" | "expression";
+type CatalogColumnId = "series" | "group" | "unit" | "frequency" | "publisher" | "expression";
 type CatalogColumn = DataTableColumn & { id: CatalogColumnId };
 
 interface CatalogSortPreference {
@@ -43,32 +49,59 @@ interface CatalogSortPreference {
   direction: SortDirection;
 }
 
-const DEFAULT_SORT: CatalogSortPreference = { columnId: "publisher", direction: "asc" };
+const DEFAULT_SORT: CatalogSortPreference = { columnId: "group", direction: "asc" };
 
-function sortValue(columnId: CatalogColumnId, row: CatalogSeriesRow): string | null {
+const FREQUENCY_LABELS: Record<CatalogSeriesRow["frequency"], string> = {
+  intraday: "Intraday",
+  daily: "Daily",
+  weekly: "Weekly",
+  monthly: "Monthly",
+  quarterly: "Quarterly",
+  annual: "Annual",
+  irregular: "Irregular",
+};
+
+function compareRows(columnId: CatalogColumnId, left: CatalogSeriesRow, right: CatalogSeriesRow): number {
   switch (columnId) {
     case "series":
-      return row.label;
+      return compareCatalogText(left.label, right.label);
+    case "group":
+      return compareCatalogGroups(left.group, right.group);
+    case "unit":
+      return compareCatalogText(left.unit, right.unit);
+    case "frequency":
+      return frequencyRank(left.frequency) - frequencyRank(right.frequency);
     case "publisher":
-      // Blank publishers (market data) sort after the named ones.
-      return row.publisher || null;
-    case "kind":
-      return row.kind;
+      // Blank publishers (market data) sort after the named ones, either way.
+      if (!left.publisher || !right.publisher) return 0;
+      return compareCatalogText(left.publisher, right.publisher);
     case "expression":
-      return row.expression;
+      return compareCatalogText(left.expression, right.expression);
   }
 }
 
-function buildColumns(width: number): CatalogColumn[] {
-  const publisherWidth = 10;
-  const kindWidth = 12;
-  const expressionWidth = Math.min(28, Math.max(16, Math.floor(width * 0.28)));
-  return [
+function sortRows(rows: CatalogSeriesRow[], { columnId, direction }: CatalogSortPreference): CatalogSeriesRow[] {
+  // Rows arrive in the default order, so the default sort is free.
+  if (columnId === DEFAULT_SORT.columnId && direction === DEFAULT_SORT.direction) return rows;
+  const sign = direction === "asc" ? 1 : -1;
+  return [...rows].sort((left, right) => {
+    if (columnId === "publisher" && !left.publisher !== !right.publisher) return left.publisher ? -1 : 1;
+    return sign * compareRows(columnId, left, right) || left.order - right.order;
+  });
+}
+
+/** The table keeps the series name and its expression; the rest fold away as the pane narrows. */
+function buildColumns(width: number, showGroup: boolean): CatalogColumn[] {
+  const expressionWidth = Math.min(30, Math.max(16, Math.floor(width * 0.26)));
+  const columns: CatalogColumn[] = [
     { id: "series", label: "SERIES", width: 18, flexGrow: 1, align: "left" },
-    { id: "publisher", label: "PUBLISHER", width: publisherWidth, align: "left" },
-    { id: "kind", label: "KIND", width: kindWidth, align: "left" },
-    { id: "expression", label: "EXPRESSION", width: expressionWidth, align: "left" },
   ];
+  if (showGroup && width >= 70) columns.push({ id: "group", label: "KIND", width: 12, align: "left" });
+  if (width >= 84) columns.push({ id: "unit", label: "UNIT", width: 10, align: "left" });
+  if (width >= 96) columns.push({ id: "frequency", label: "FREQ", width: 9, align: "left" });
+  if (width >= 60) columns.push({ id: "publisher", label: "PUBLISHER", width: 10, align: "left" });
+  columns.push({ id: "expression", label: "EXPRESSION", width: expressionWidth, align: "left" });
+  return columns;
 }
 
 export function DataCatalogPane({ focused, width, height }: PaneProps) {
@@ -76,11 +109,14 @@ export function DataCatalogPane({ focused, width, height }: PaneProps) {
   const dialog = useDialog();
   const [seedQuery] = usePaneSettingValue("query", "");
   const [searchQuery, setSearchQuery] = useState(seedQuery);
-  const [filter, setFilter] = usePluginPaneState<CatalogFilterId>("activeTab", "all");
+  const [savedFilter, setFilter] = usePluginPaneState<CatalogFilterId>("activeTab", "all");
   const [selectedId, setSelectedId] = usePluginPaneState<string | null>("selectedId", null);
   const [sortPreference, setSortPreference] = useState<CatalogSortPreference>(DEFAULT_SORT);
   const { active: searchFocused, focus: focusSearch, searchProps } = useQueryBarSearch();
 
+  const entries = useRegisteredSeries();
+  const catalogRows = useMemo(() => catalogRowsFromEntries(entries), [entries]);
+  const filter = normalizeCatalogFilter(savedFilter, catalogRows);
   const tickerQuery = looksLikeCatalogTickerQuery(searchQuery);
   const { instruments, loading: universeLoading } = useCatalogUniverse(
     tickerQuery ? searchQuery : "",
@@ -88,25 +124,20 @@ export function DataCatalogPane({ focused, width, height }: PaneProps) {
   const loading = tickerQuery && universeLoading;
   const emptyCopy = catalogEmptyCopy(loading, searchQuery);
 
+  const listedCrypto = useMemo(
+    () => catalogRowsForListedCrypto(catalogRows, instruments),
+    [catalogRows, instruments],
+  );
   const rows = useMemo(() => {
-    const staticRows = listStaticCatalogInventory(instruments);
     const resolvedRows = tickerQuery
       ? catalogRowsForResolvedInstruments(
+        catalogRows,
         instruments.filter((instrument) => catalogInstrumentMatchesQuery(instrument, searchQuery)),
       )
       : [];
-    const merged = new Map<string, CatalogSeriesRow>();
-    for (const entry of [...resolvedRows, ...staticRows]) {
-      if (!merged.has(entry.id)) merged.set(entry.id, entry);
-    }
-    const filtered = filterCatalogRows([...merged.values()], filter, searchQuery);
-    const direction = sortPreference.direction;
-    const columnId = sortPreference.columnId;
-    return [...filtered].sort((left, right) => (
-      compareSortValues(sortValue(columnId, left), sortValue(columnId, right), direction)
-      || left.label.localeCompare(right.label)
-    ));
-  }, [filter, instruments, searchQuery, sortPreference, tickerQuery]);
+    const merged = mergeCatalogRows(catalogRows, [...resolvedRows, ...listedCrypto]);
+    return sortRows(filterCatalogRows(merged, filter, searchQuery), sortPreference);
+  }, [catalogRows, filter, instruments, listedCrypto, searchQuery, sortPreference, tickerQuery]);
 
   useEffect(() => {
     if (selectedId && rows.some((row) => row.id === selectedId)) return;
@@ -119,12 +150,13 @@ export function DataCatalogPane({ focused, width, height }: PaneProps) {
   );
   const selectedUrl = selectedRow?.url ?? null;
 
-  const columns = useMemo(() => buildColumns(width), [width]);
+  const columns = useMemo(() => buildColumns(width, filter === "all"), [filter, width]);
 
   const chartSelected = useCallback(async (row: CatalogSeriesRow | null) => {
     if (!row) return;
-    if (row.needsTicker) {
-      const option = row.sourceId === "option";
+    if (row.input) {
+      const option = row.input === "option";
+      const crypto = row.input === "crypto";
       const ticker = await dialog.prompt<string>({
         closeOnClickOutside: true,
         content: (context: PromptContext<string>) => (
@@ -133,11 +165,13 @@ export function DataCatalogPane({ focused, width, height }: PaneProps) {
             step={{
               key: "ticker",
               label: `Chart ${row.label}`,
-              placeholder: option ? "AAPL 260618C00200000" : "AAPL",
+              placeholder: option ? "AAPL 260618C00200000" : crypto ? "BTC-USD" : "AAPL",
               type: "text",
               body: [option
                 ? `Enter an option symbol to chart ${row.label}.`
-                : `Enter a ticker to chart ${row.label}.`],
+                : crypto
+                  ? `Enter a crypto pair to chart ${row.label}.`
+                  : `Enter a ticker to chart ${row.label}.`],
             }}
           />
         ),
@@ -147,7 +181,7 @@ export function DataCatalogPane({ focused, width, height }: PaneProps) {
       createPaneFromTemplate(CHART_COMPOSER_TEMPLATE_ID, { arg: expression });
       return;
     }
-    createPaneFromTemplate(CHART_COMPOSER_TEMPLATE_ID, { arg: row.expression });
+    createPaneFromTemplate(CHART_COMPOSER_TEMPLATE_ID, { arg: row.template });
   }, [createPaneFromTemplate, dialog]);
 
   // `/` and `g` are footer hints, which bind their own keys; the table only
@@ -171,10 +205,14 @@ export function DataCatalogPane({ focused, width, height }: PaneProps) {
     switch (column.id) {
       case "series":
         return { text: row.label, color: colors.textBright };
+      case "group":
+        return { text: row.group, color: colors.textDim };
+      case "unit":
+        return { text: row.unit, color: colors.textDim };
+      case "frequency":
+        return { text: FREQUENCY_LABELS[row.frequency], color: colors.textDim };
       case "publisher":
         return { text: row.publisher, color: colors.textMuted };
-      case "kind":
-        return { text: row.kind, color: colors.textDim };
       case "expression":
         return { text: row.expression, color: colors.text };
     }
@@ -195,10 +233,10 @@ export function DataCatalogPane({ focused, width, height }: PaneProps) {
   });
 
   const tabs = useMemo(
-    () => CATALOG_FILTERS.map((entry) => ({ label: entry.label, value: entry.id })),
-    [],
+    () => catalogTabs(catalogRows).map((entry) => ({ label: entry.label, value: entry.id })),
+    [catalogRows],
   );
-  const selectFilter = useCallback((value: string) => setFilter(value as CatalogFilterId), [setFilter]);
+  const selectFilter = useCallback((value: string) => setFilter(value), [setFilter]);
   const { strip: tabStrip } = usePaneTabs({
     tabs,
     activeValue: filter,

package/src/plugins/builtin/chart-composer/editor.tsx

@@ -78,14 +78,15 @@ export function SeriesEditorDialog({ dialogId, resolve, initialSpec }: SeriesEdi
   while (navigationKeys.length > 0 && [...navigationKeys, ...seriesKeys].join(" · ").length > tuiContentWidth) {
     navigationKeys.pop();
   }
-  const footer = isDesktop
-    ? seriesKeys.join(" · ") || undefined
-    : [...navigationKeys, ...seriesKeys].join(" · ");
 
   return (
     <DialogFrame
       title="Chart Series"
-      footer={footer}
+      footer={[...navigationKeys, ...seriesKeys].join(" · ")}
+      // The desktop's fields take the pointer and arrows like any form.
+      desktopFooter={selected
+        ? { keys: [{ key: "E", label: "source" }, { key: "P", label: "panel" }, { key: "L", label: "log scale" }] }
+        : null}
     >
       <Box
         flexDirection="column"

package/src/plugins/builtin/chart-composer/field-series.ts

@@ -0,0 +1,40 @@
+import { isMarketFieldId, listTimeSeriesFields } from "../../../time-series/field-catalog";
+import type { SeriesPeriod, TimeSeriesFieldDefinition } from "../../../time-series/types";
+import type { SeriesDefinition, SeriesFrequency } from "../../../series/types";
+import { fieldCategory } from "./series-catalog";
+
+/** The short name an expression uses for a field: `price` for OHLCV, else the id's last part. */
+function chartFieldToken(fieldId: string): string {
+  if (fieldId === "market.ohlcv") return "price";
+  return fieldId.split(".").at(-1) ?? fieldId;
+}
+
+function fieldFrequency(period: SeriesPeriod): SeriesFrequency {
+  if (period === "auto") return "daily";
+  return period === "ttm" ? "quarterly" : period;
+}
+
+function fieldSeries(field: TimeSeriesFieldDefinition, input: "ticker" | "option"): SeriesDefinition {
+  return {
+    id: `${input === "option" ? "option" : "field"}:${field.id}`,
+    name: field.label,
+    unit: field.unit,
+    frequency: fieldFrequency(field.nativeFrequency),
+    group: input === "option" ? "Options" : "Securities",
+    tags: [fieldCategory(field), field.shortLabel, ...(input === "option" ? ["option"] : [])],
+    input,
+    expression: `{ticker}:${chartFieldToken(field.id)}`,
+  };
+}
+
+/**
+ * Every ticker field once, asking for the ticker when charted, and the market
+ * fields again for option contracts. Typing a ticker in the catalog fills them in.
+ */
+export function listFieldSeries(): SeriesDefinition[] {
+  const fields = listTimeSeriesFields();
+  return [
+    ...fields.map((field) => fieldSeries(field, "ticker")),
+    ...fields.filter((field) => isMarketFieldId(field.id)).map((field) => fieldSeries(field, "option")),
+  ];
+}

package/src/plugins/builtin/chart-composer/headless.ts

@@ -212,11 +212,16 @@ export async function loadChartPaneModel(
 /**
  * Price series are bar histories, stale once bars of the coarsest size stop
  * arriving; fundamentals, valuations and economic series are reported data.
+ * A chart of capability series alone (CHOKE's vessel transits) is a dataset,
+ * dated by its newest observation and how far behind that is.
  */
-function chartFreshness(series: readonly HeadlessSeries[]): HeadlessPaneFreshness {
+function chartFreshness(series: readonly HeadlessSeries[], spec: ChartSpec): HeadlessPaneFreshness {
   const order = ["1wk", "1mo"];
   const resolutions = series.map((entry) => (entry as HeadlessSeries & { historyResolution?: string }).historyResolution);
-  if (!series.length || resolutions.some((resolution) => !resolution)) return { ...REPORTED_DATA, basis: "reported and published data" };
+  const dataset = spec.series.length > 0 && spec.series.every(({ source }) => source.kind === "capability");
+  if (!series.length || resolutions.some((resolution) => !resolution)) {
+    return { ...REPORTED_DATA, basis: "reported and published data", ...(dataset ? { dataset } : {}) };
+  }
   const coarsest = resolutions.reduce((worst, resolution) => (
     order.indexOf(resolution!) > order.indexOf(worst!) ? resolution : worst
   ), resolutions[0]);
@@ -296,7 +301,7 @@ export function chartHeadless(template: keyof typeof paneSchemas): HeadlessPaneD
         }
       }
       model.snapshot.intradayHistories = intradayHistories;
-      model.freshness = chartFreshness(model.series);
+      model.freshness = chartFreshness(model.series, model.spec);
       const priceDomainFailures = intradayHistories.flatMap(({ symbol, exchange, priceDomainFailure }) =>
         priceDomainFailure ? [{ symbol, exchange, ...priceDomainFailure }] : []);
       if (priceDomainFailures.length) {

package/src/plugins/builtin/chart-composer/index.tsx

@@ -13,6 +13,8 @@ import type { ChartSpec } from "../../../time-series/types";
 import { isPriceOnlyMarketFieldId } from "../../../time-series/field-catalog";
 import { ChartComposerPane, ChartComposerResearchTab } from "./pane";
 import { DataCatalogPane } from "./data-catalog-pane";
+import { listFieldSeries } from "./field-series";
+import { registeredSeriesName } from "./series-expression";
 import {
   CHART_COMPOSER_TEMPLATE_ID,
   DATA_CATALOG_PANE_ID,
@@ -104,7 +106,7 @@ function chartTitle(spec: ChartSpec, prefix = "G"): string {
       ? tickerInstrumentLabel(publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange), series.source.instrument.instrument)
       : series.source.kind === "economic"
         ? `FRED:${series.source.seriesId}`
-        : series.label?.trim() || series.source.seriesId
+        : series.label?.trim() || registeredSeriesName(series.source) || series.source.seriesId
   ));
   if (labels.length === 0) return "Custom Chart";
   const remaining = spec.series.length - labels.length;
@@ -319,7 +321,7 @@ const chartComposerTemplates: PaneTemplateDef[] = [
     id: DATA_CATALOG_TEMPLATE_ID,
     paneId: DATA_CATALOG_PANE_ID,
     label: "Data Catalog",
-    description: "Browse and search the series Custom Chart already knows: securities, options, crypto, FRED, treasuries, and futures.",
+    description: "Browse and search every series a chart can draw: securities, rates, credit, economic data, volatility, sentiment, positioning and your own files.",
     keywords: [
       "catalog",
       "series",
@@ -331,6 +333,9 @@ const chartComposerTemplates: PaneTemplateDef[] = [
       "crypto",
       "options",
       "option",
+      "credit",
+      "sentiment",
+      "positioning",
     ],
     shortcut: { prefix: "CAT", argPlaceholder: "query", argKind: "text", argOptional: true },
     canCreate: () => true,
@@ -424,6 +429,8 @@ function chartShowsOneSecurity(pane: PaneInstanceConfig): boolean {
 }
 
 export const chartComposerModule: PluginModule = {
+  // Every ticker field, asking for the ticker when charted.
+  series: listFieldSeries(),
   panes: [{
     id: CHART_COMPOSER_PANE_ID,
     name: "Chart",

package/src/plugins/builtin/chart-composer/series-catalog.ts

@@ -7,11 +7,7 @@ import {
   type ChartSeriesCatalogItem,
 } from "../../../capabilities";
 import type { TimeSeriesFieldDefinition } from "../../../time-series/types";
-import {
-  FUTURES_CONTRACTS,
-  FUTURES_SECTOR_LABELS,
-} from "../futures/contracts";
-import { TREASURY_MATURITIES } from "../yield-curve/treasury-data";
+import type { SeriesCatalogEntry } from "../../../series/types";
 import {
   canonicalExchange,
   parsePublicTickerKey,
@@ -271,50 +267,61 @@ function matchesAliasQuery(query: string, ...values: string[]): boolean {
   return tokens.length > 0 && tokens.every((token) => searchable.includes(token));
 }
 
-function coreAliasSuggestions(query: string): SeriesCatalogSuggestion[] {
-  const futures = FUTURES_CONTRACTS
-    .filter((contract) => matchesAliasQuery(
-      query,
-      `FUT:${contract.code}`,
-      contract.code,
-      contract.name,
-      `${contract.name} futures`,
-      contract.sector,
-      FUTURES_SECTOR_LABELS[contract.sector],
-    ))
-    .map((contract): SeriesCatalogSuggestion => ({
-      id: `${contract.symbol}:market.ohlcv`,
-      label: `FUT:${contract.code} · ${contract.name}`,
-      description: `${FUTURES_SECTOR_LABELS[contract.sector]} futures`,
-      detail: "Futures",
-      expression: {
-        kind: "security",
-        symbol: contract.symbol,
-        fieldId: "market.ohlcv",
-        label: contract.name,
-      },
-    }));
-  const treasuries = TREASURY_MATURITIES
-    .filter((treasury) => matchesAliasQuery(
-      query,
-      `UST:${treasury.maturity}`,
-      treasury.maturity,
-      treasury.seriesId,
-      `${treasury.maturity.replace("M", " month").replace("Y", " year")} US Treasury yield`,
-    ))
-    .map((treasury): SeriesCatalogSuggestion => ({
-      id: `fred:${treasury.seriesId}`,
-      label: `UST:${treasury.maturity} · Treasury Yield`,
-      description: `U.S. Treasury ${treasury.maturity} yield · FRED ${treasury.seriesId}`,
-      detail: "Treasury",
-      expression: {
-        kind: "economic",
-        provider: "fred",
-        seriesId: treasury.seriesId,
-        label: `${treasury.maturity} Treasury Yield`,
-      },
-    }));
-  return [...futures, ...treasuries];
+function suggestionId(expression: ParsedSeriesExpression): string {
+  if (expression.kind === "economic") return `fred:${expression.seriesId}`;
+  if (expression.kind === "capability") {
+    return chartSeriesSourceKey({ kind: "capability", capabilityId: expression.capabilityId, seriesId: expression.seriesId });
+  }
+  return `${publicTickerKey(expression.symbol, expression.exchange)}:${expression.fieldId}`;
+}
+
+function registeredMatchRank(entry: SeriesCatalogEntry, query: string): number {
+  const name = compact(entry.name);
+  const needle = compact(query);
+  if (name === needle || compact(entry.expression) === needle) return 0;
+  if (name.startsWith(needle)) return 1;
+  return 2;
+}
+
+/**
+ * Registered catalog series the query names: by name, expression, group or
+ * tags. A series that takes a ticker is filled in with the one the query
+ * names, or the chart's own; ticker fields come from the field ranking instead.
+ */
+function registeredSeriesSuggestions(
+  query: string,
+  registered: readonly SeriesCatalogEntry[],
+  analysis: SeriesSearchAnalysis,
+  defaultInstrument: SeriesCatalogInstrument,
+): SeriesCatalogSuggestion[] {
+  if (!query.trim() || registered.length === 0) return [];
+  const instrument = analysis.directInstrument ?? defaultInstrument;
+  const tickerQuery = analysis.directInstrument ? analysis.metricQuery : query;
+  const hits: Array<{ entry: SeriesCatalogEntry; rank: number; expression: ParsedSeriesExpression }> = [];
+  for (const entry of registered) {
+    let template = entry.expression;
+    let text = query;
+    if (entry.input) {
+      // Ticker fields are ranked against the security below; options and pairs need their own symbol.
+      if (entry.input !== "ticker" || /^\{ticker\}:[A-Za-z]/.test(template) || !tickerQuery.trim()) continue;
+      const symbol = publicTickerKey(instrument.symbol, instrument.exchange);
+      template = template.replaceAll("{ticker}", template.startsWith("CAP:") ? encodeURIComponent(symbol) : symbol);
+      text = tickerQuery;
+    }
+    if (!matchesAliasQuery(text, entry.name, entry.expression, entry.id, entry.group ?? "", ...(entry.tags ?? []))) continue;
+    const parsed = parseSeriesExpression(template);
+    if (!parsed) continue;
+    const label = entry.input ? `${publicTickerKey(instrument.symbol, instrument.exchange)} · ${entry.name}` : entry.name;
+    hits.push({ entry, rank: registeredMatchRank(entry, text), expression: { ...parsed, label } });
+  }
+  hits.sort((left, right) => left.rank - right.rank || left.entry.name.length - right.entry.name.length);
+  return hits.map(({ entry, expression }): SeriesCatalogSuggestion => ({
+    id: suggestionId(expression),
+    label: expression.kind === "capability" ? expression.label ?? entry.name : `${entry.expression} · ${entry.name}`,
+    description: [entry.group, entry.unit, entry.frequency].filter(Boolean).join(" · "),
+    detail: entry.group ?? "Series",
+    expression,
+  }));
 }
 
 export function buildCapabilitySeriesSuggestions(
@@ -345,6 +352,7 @@ export function buildSeriesCatalogSuggestions(
   defaultInstrument: SeriesCatalogInstrument,
   searchedInstruments: readonly SeriesCatalogInstrument[] = [],
   limit = 8,
+  registered: readonly SeriesCatalogEntry[] = [],
 ): SeriesCatalogSuggestion[] {
   const exact = exactExpressionSuggestion(query.trim());
   const analysis = analyzeSeriesSearchQuery(query);
@@ -362,7 +370,7 @@ export function buildSeriesCatalogSuggestions(
     .sort((left, right) => right.score - left.score || left.field.label.localeCompare(right.field.label));
 
   const suggestions: SeriesCatalogSuggestion[] = exact ? [exact] : [];
-  for (const suggestion of coreAliasSuggestions(query)) {
+  for (const suggestion of registeredSeriesSuggestions(query, registered, analysis, defaultInstrument)) {
     if (!suggestions.some((entry) => entry.id === suggestion.id)) suggestions.push(suggestion);
   }
   const fieldLimit = instruments.length > 1 && !analysis.metricQuery ? 1 : rankedFields.length;

package/src/plugins/builtin/chart-composer/series-expression.ts

@@ -15,7 +15,8 @@ import {
   isValidChartCapabilityId,
   isValidChartSeriesId,
 } from "../../../capabilities/chart-series";
-import { FUTURES_CONTRACTS } from "../futures/contracts";
+import { futuresContractByCode } from "../../../market-data/futures-board";
+import { getSharedRegistry } from "../../registry";
 import { TREASURY_MATURITIES } from "../yield-curve/treasury-data";
 
 export const CHART_FIELD_IDS = {
@@ -100,9 +101,9 @@ export function parseSeriesExpression(value: string): ParsedSeriesExpression | n
     if (separator < 0) return null;
     const capabilityId = trimmed.slice(4, separator);
     const seriesId = trimmed.slice(separator + 1);
-    return isValidChartCapabilityId(capabilityId) && isValidChartSeriesId(seriesId)
-      ? { kind: "capability", capabilityId, seriesId }
-      : null;
+    if (!isValidChartCapabilityId(capabilityId) || !isValidChartSeriesId(seriesId)) return null;
+    const label = registeredSeriesName({ capabilityId, seriesId });
+    return { kind: "capability", capabilityId, seriesId, ...(label ? { label } : {}) };
   }
   if (parts[0]?.trim().toUpperCase() === "GEO") {
     const seriesId = trimmed.slice(trimmed.indexOf(":") + 1).trim();
@@ -112,13 +113,13 @@ export function parseSeriesExpression(value: string): ParsedSeriesExpression | n
   }
   if (parts[0]?.trim().toUpperCase() === "FRED") {
     const seriesId = parts.length === 2 ? parts[1]?.trim().toUpperCase() ?? "" : "";
-    return /^[A-Z0-9._-]{1,80}$/.test(seriesId)
-      ? { kind: "economic", provider: "fred", seriesId }
-      : null;
+    if (!/^[A-Z0-9._-]{1,80}$/.test(seriesId)) return null;
+    // The catalog's name for a listed series, so the legend says what the catalog said.
+    const label = getSharedRegistry()?.series?.findByExpression(`FRED:${seriesId}`)?.definition.name;
+    return { kind: "economic", provider: "fred", seriesId, ...(label ? { label } : {}) };
   }
   if (parts.length === 2 && parts[0]?.trim().toUpperCase() === "FUT") {
-    const code = parts[1]?.trim().toUpperCase();
-    const contract = FUTURES_CONTRACTS.find((entry) => entry.code === code);
+    const contract = futuresContractByCode(parts[1]);
     return contract
       ? { kind: "security", symbol: contract.symbol, fieldId: CHART_FIELD_IDS.price, label: contract.name }
       : null;
@@ -189,10 +190,17 @@ export function formatSeriesExpression(series: ChartSeriesSpec): string {
   return `${publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange)}:${series.source.fieldId}`;
 }
 
+/** A registered catalog series' name, with the ticker it was charted for. */
+export function registeredSeriesName(source: { capabilityId: string; seriesId: string }): string | null {
+  const found = getSharedRegistry()?.series?.findLoaded(source.capabilityId, source.seriesId);
+  if (!found) return null;
+  return found.ticker ? `${found.ticker} ${found.series.definition.name}` : found.series.definition.name;
+}
+
 export function chartSeriesLabel(series: ChartSeriesSpec): string {
   if (series.label?.trim()) return series.label.trim();
   if (series.source.kind === "economic") return `FRED ${series.source.seriesId}`;
-  if (series.source.kind === "capability") return series.source.seriesId;
+  if (series.source.kind === "capability") return registeredSeriesName(series.source) ?? series.source.seriesId;
   const generic = getTimeSeriesField(series.source.fieldId)?.unitGroup === "price"
     ? futuresGenericListing(series.source.instrument.symbol, series.source.instrument.exchange) : null;
   if (generic) return futuresGenericCaption(generic);