gloomberb 0.16.4 → 0.16.6

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-schema.ts

@@ -81,7 +81,7 @@ export const paneSchemas = {
         description: "Intraday sampling interval. Auto uses 1m for 1D and 5m for 1W.",
         type: "enum",
         aliases: ["resolution"],
-        values: [{ value: "auto" }, { value: "5m" }, { value: "15m" }, { value: "1h" }],
+        values: [{ value: "auto" }, { value: "1m" }, { value: "5m" }, { value: "15m" }, { value: "1h" }],
         defaultValue: "auto",
       },
       {

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

@@ -3,7 +3,7 @@ import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../../../utils/f
 import { graphRowsForFinancials, summarizeResolvedSeries } from "../../../time-series/reporting";
 import { priceHistoryIntegrityNotices, chartPriceHistoryIntegrityNotices } from "../../../time-series/market";
 import type { HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneFreshness, HeadlessSeries, HeadlessSeriesResult } from "../../../types/headless";
-import type { CapabilitySeriesSource, ChartResolutionResult, ChartSeriesSpec, ChartSpec, ChartViewportSpec } from "../../../time-series/types";
+import type { CapabilitySeriesSource, ChartResolutionResult, ChartSeriesSpec, ChartSpec, ChartViewportSpec, ResolvedSeries } from "../../../time-series/types";
 import { resolveGeoChartSeries } from "../world-venue-map/geo-series";
 import { GEO_SERIES_CAPABILITY_ID } from "./series-expression";
 import { mergePriceHistoryWindows, priceHistoryAcquisitionIdentity, priceHistoryTailAcquisition, resolveChartSpecData } from "../../../time-series/resolve";
@@ -19,6 +19,7 @@ import { parsePublicTickerKey, publicTickerKey, resolveExchangeTimeZone } from "
 import { parseChartSpec } from "./chart-spec";
 import { paneSchemas } from "./headless-schema";
 import { barHistoryFreshness, REPORTED_DATA } from "../shared/report-freshness";
+import { inferSeriesFrequency } from "../../../series/csv";
 
 export interface ChartPaneModel extends HeadlessSeriesResult {
   /** The renderer consumes the full model; generic reports project series and metadata. */
@@ -209,14 +210,78 @@ export async function loadChartPaneModel(
   };
 }
 
+const DAY_MS = 24 * 60 * 60_000;
+const PERIOD_MONTHS = { monthly: 1, quarterly: 3, annual: 12 } as const;
+type Periodicity = keyof typeof PERIOD_MONTHS;
+
+/**
+ * The period a series of period dates publishes in, from the spacing of its
+ * dates, when its newest date starts one (FRED dates August's CPI 1 Aug).
+ */
+function seriesPeriodicity(dates: readonly Date[]): Periodicity | null {
+  const frequency = inferSeriesFrequency(dates.map((date) => ({ date, value: 0 })));
+  if (frequency !== "monthly" && frequency !== "quarterly" && frequency !== "annual") return null;
+  const newest = dates.reduce((latest, date) => (date > latest ? date : latest));
+  return newest.getUTCDate() === 1 && newest.getUTCMonth() % PERIOD_MONTHS[frequency] === 0 ? frequency : null;
+}
+
+/**
+ * An economic chart's dates: each series observes a period or a day, never an
+ * instant, so the chart is dated by the day of its newest observation, with
+ * the oldest series' newest when they end apart, and by the period when every
+ * series publishes in the same one: `Aug 2026 (monthly)`, not `Sat 1 Aug 2026
+ * 00:00 UTC`. Nothing for a chart with any other series.
+ */
+export function economicChartDates(series: readonly HeadlessSeries[], spec: Pick<ChartSpec, "series">): Pick<HeadlessPaneFreshness, "asOf" | "oldest" | "periodicity"> {
+  if (!spec.series.length || spec.series.some(({ source }) => source.kind !== "economic")) return {};
+  const ends: string[] = [];
+  const periods = new Set<Periodicity | null>();
+  for (const entry of series) {
+    const dates = entry.points.flatMap((point) => (point.value ?? point.close) == null ? [] : [new Date(point.date)]);
+    if (!dates.length) continue;
+    // A date at midnight UTC is a day; anything else is an observation time and keeps it.
+    if (dates.some((date) => !Number.isFinite(date.getTime()) || date.getTime() % DAY_MS !== 0)) return {};
+    ends.push(dates.reduce((latest, date) => (date > latest ? date : latest)).toISOString().slice(0, 10));
+    periods.add(seriesPeriodicity(dates));
+  }
+  if (!ends.length) return {};
+  ends.sort();
+  const [periodicity] = periods.size === 1 ? [...periods] : [null];
+  return {
+    asOf: ends.at(-1)!,
+    ...(ends[0] !== ends.at(-1) ? { oldest: ends[0]! } : {}),
+    ...(periodicity ? { periodicity } : {}),
+  };
+}
+
+/**
+ * Who a chart cites when each of its series names its own dataset (CBR's
+ * policy rates: `FRED series ECBDFR`); nothing, so Gloom Cloud, otherwise.
+ */
+function seriesAttribution(series: readonly HeadlessSeries[]): Pick<HeadlessPaneFreshness, "source" | "publisher"> {
+  const cited = series.map((entry) => (entry as HeadlessSeries & Pick<ResolvedSeries, "attribution">).attribution);
+  if (!cited.length || cited.some((attribution) => !attribution)) return {};
+  const publishers = [...new Set(cited.map((attribution) => attribution!.publisher))];
+  return {
+    source: [...new Set(cited.map((attribution) => attribution!.source))].join(", "),
+    ...(publishers.every(Boolean) ? { publisher: publishers.join(", ") } : {}),
+  };
+}
+
 /**
  * Price series are bar histories, stale once bars of the coarsest size stop
- * arriving; fundamentals, valuations and economic series are reported data.
+ * arriving; fundamentals, valuations and economic series are reported data,
+ * economic series dated by their periods (`economicChartDates`). 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 } : {}), ...economicChartDates(series, spec), ...seriesAttribution(series) };
+  }
   const coarsest = resolutions.reduce((worst, resolution) => (
     order.indexOf(resolution!) > order.indexOf(worst!) ? resolution : worst
   ), resolutions[0]);
@@ -296,7 +361,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;
@@ -199,10 +201,13 @@ function securityTemplate({
   argKind,
   minimumSymbols,
   build,
+  keywords = [],
 }: {
   id: Parameters<typeof chartHeadless>[0];
   prefix: "GP" | "GIP" | "CMP" | "GF" | "GE";
   aliases?: readonly string[];
+  /** Searches beyond the label that should find it. */
+  keywords?: readonly string[];
   label: string;
   description: string;
   /** What the report returns, when the description is about drawing the chart. */
@@ -217,7 +222,7 @@ function securityTemplate({
     headless: { ...chartHeadless(id), ...(returns ? { description: returns } : {}) },
     label,
     description,
-    keywords: ["chart", "graph", prefix.toLowerCase(), ...label.toLowerCase().split(" ")],
+    keywords: ["chart", "graph", prefix.toLowerCase(), ...label.toLowerCase().split(" "), ...keywords],
     shortcut: {
       prefix,
       ...(aliases ? { aliases } : {}),
@@ -319,7 +324,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 +336,9 @@ const chartComposerTemplates: PaneTemplateDef[] = [
       "crypto",
       "options",
       "option",
+      "credit",
+      "sentiment",
+      "positioning",
     ],
     shortcut: { prefix: "CAT", argPlaceholder: "query", argKind: "text", argOptional: true },
     canCreate: () => true,
@@ -369,6 +377,8 @@ const chartComposerTemplates: PaneTemplateDef[] = [
     label: "Intraday Price Graph",
     description: "Open an intraday price chart for one or five sessions.",
     returns: "Intraday price bars for one ticker over the last one or five sessions. Returns the data; it does not open or show a chart.",
+    // The finest bars there are; tick and second searches land here and on QR.
+    keywords: ["1 minute", "minute bars", "1m", "tick", "ticks", "second", "seconds", "trades"],
     argKind: "ticker",
     minimumSymbols: 1,
     build: (symbols) => buildIntradayPriceChartPreset(symbols[0]!),
@@ -424,6 +434,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",