gloomberb 0.18.3 → 0.18.5

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

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import { financialPeriodCoverage } from "../../../time-series/financial-period-coverage";
 import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../../../utils/financial-statements";
 import { graphRowsForFinancials, summarizeResolvedSeries } from "../../../time-series/reporting";
@@ -5,13 +6,19 @@ import { priceHistoryIntegrityNotices, chartPriceHistoryIntegrityNotices } from
 import type { HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneFreshness, HeadlessSeries, HeadlessSeriesResult } from "../../../types/headless";
 import type { CapabilitySeriesSource, ChartResolutionResult, ChartSeriesSource, ChartSeriesSpec, ChartSpec, ChartViewportSpec, ResolvedSeries } from "../../../time-series/types";
 import { resolveGeoChartSeries } from "../world-venue-map/geo-series";
-import { GEO_SERIES_CAPABILITY_ID, parseSeriesExpression } from "./series-expression";
-import { mergePriceHistoryWindows, priceHistoryAcquisitionIdentity, priceHistoryTailAcquisition, resolveChartSpecData } from "../../../time-series/resolve";
+import { CHART_FIELD_IDS, GEO_SERIES_CAPABILITY_ID, parseSeriesExpression } from "./series-expression";
+import { buildSeriesSpec } from "./chart-spec-edit";
+import { getSharedRegistry } from "../../registry";
+import { notATickerSymbol } from "../../../sources/provider-errors";
+import { resolveChartSpecData } from "../../../time-series/resolve";
+import { mergePriceHistoryWindows, priceHistoryAcquisitionIdentity, priceHistoryTailAcquisition } from "../../../time-series/history-acquisition";
 import {
+  chartBarSizeSource,
   getSupportMaxRange,
   intersectChartResolutionSupport,
   isIntradayResolution,
   normalizeChartResolutionSupport,
+  type ChartBarSize,
   type ManualChartResolution,
 } from "../../../time-series/resolution";
 import type { ChartResolution } from "../../../time-series/range";
@@ -24,14 +31,22 @@ import type { TickerFinancials, PricePoint, Quote } from "../../../types/financi
 import { chartQuoteOverrideKeyForTarget, getLiveChartQuoteTargets } from "../../../time-series/live-quotes";
 import { createChartSeriesResolver } from "../../../capabilities";
 import { loadFuturesContractTerms, loadFuturesPriceUnit } from "../../../market-data/futures-contract";
-import { parsePublicTickerKey, publicTickerKey } from "../../../utils/exchanges";
+import { isUsListingExchange, parsePublicTickerKey, publicTickerKey } from "../../../utils/exchanges";
+import { zonedDateTimeParts } from "../../../utils/zoned-date-time";
+import { futuresSessionOpenMinute } from "../../../market-data/market/trading-sessions";
+import { cleanFloat32Price } from "../../../cli/history-rows";
 import { parseChartSpec } from "./chart-spec";
 import { paneSchemas } from "./headless-schema";
-import { barHistoryFreshness, REPORTED_DATA } from "../shared/report-freshness";
+import { barHistoryFreshness, DAILY_CLOSES, REPORTED_DATA } from "../shared/report-freshness";
 import type { BarPeriodToDate } from "../../../market-data/market/bar-period";
 import { closedHistoryBarDay, formingHistoryBar } from "../ticker-detail/data-panes/history-bars";
 import { inferSeriesFrequency } from "../../../series/csv";
 import { isDatasetChart } from "../../../time-series/spec";
+import { loadFundFacts } from "../sec/fund-facts";
+import { comparedFundTickers, loadDailyObjectives, mayDrawDailyObjective, withLeverageOverlay } from "./leverage-overlay";
+import { classifyInstrumentType } from "../../../tickers/instrument-kind";
+import { priceComparisonEndsIntraday, type PriceComparison } from "../../../time-series/price-comparison";
+import { LATEST_INTRADAY_TEXT } from "../../../market-data/market/period-return";
 
 export interface ChartPaneModel extends HeadlessSeriesResult {
   /** The renderer consumes the full model; generic reports project series and metadata. */
@@ -87,7 +102,7 @@ export async function loadChartPaneModel(
   if (getQuote && !spec.viewport.dateWindow) {
     await Promise.all(getLiveChartQuoteTargets(spec).map(async (target) => {
       const quote = await getQuote(target.symbol, target.exchange ?? "",
-        context.refresh ? { ...target.context, cacheMode: "refresh" } : target.context).catch(() => null);
+        context.refresh ? { ...target.context, cacheMode: "refresh" } : target.context).catch(logFailure("chart-composer.headless", "Load chart live quote failed", null));
       if (quote) quoteOverrides.set(chartQuoteOverrideKeyForTarget(target), quote);
     }));
   }
@@ -136,6 +151,7 @@ export async function loadChartPaneModel(
     },
     resolveCapabilitySeries: headlessCapabilityResolver(context),
     loadFuturesPriceUnit: (symbol) => loadFuturesPriceUnit(symbol, (key) => loadFuturesContractTerms(key, context.apiClient)),
+    loadEarningsHistory: (symbol) => context.apiClient.getCloudEarningsHistory(symbol, 100),
     loadFredSeries: async (request) => ({
       data: await context.apiClient.getCloudFredSeries(request.seriesId, {
         startDate: request.startDate,
@@ -206,9 +222,12 @@ export async function loadChartPaneModel(
         kind, source.fieldId.split(".")[1]!, source.period === "quarterly" ? "quarterly" : "annual",
         source.instrument.symbol,
       ).map((row) => [row.date, row.growth])) : null;
+      // A formula or a converted price prints at its legs' decimals in text; JSON keeps every digit.
+      const { valueDecimals, ...reported } = series;
       return {
-        ...series,
+        ...reported,
         ...name ? { name } : {},
+        ...valueDecimals !== undefined ? { textDecimals: valueDecimals } : {},
         derived: !ids.has(series.id),
         points: series.points.map((point) => ({
           ...point,
@@ -260,31 +279,46 @@ function seriesPeriodicity(dates: readonly Date[]): Periodicity | null {
  * days or periods, never instants (FRED's series, a plugin's daily closes): it
  * 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 a price series or a series observed at a time of day.
+ * in the same one: `Aug 2026 (monthly)`, not `Sat 1 Aug 2026 00:00 UTC`;
+ * with the newest figure's release when its points say it (`releasedOn`):
+ * `Sep 2026, released Tue 20 Oct`. Nothing for a chart with a price series
+ * or a series observed at a time of day.
  */
-export function periodChartDates(series: readonly HeadlessSeries[], spec: Pick<ChartSpec, "series">): Pick<HeadlessPaneFreshness, "asOf" | "oldest" | "periodicity"> {
+export function periodChartDates(series: readonly HeadlessSeries[], spec: Pick<ChartSpec, "series">): Pick<HeadlessPaneFreshness, "asOf" | "oldest" | "periodicity" | "releasedOn"> {
   if (!spec.series.length || spec.series.some(({ source }) => source.kind !== "economic" && source.kind !== "capability")) return {};
-  const ends: string[] = [];
+  const ends: Array<{ day: string; releasedOn: string | null }> = [];
   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)]);
+    const points = entry.points.filter((point) => (point.value ?? point.close) != null);
+    const dates = points.map((point) => 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));
+    const newest = dates.reduce((latest, date, index) => (date > dates[latest]! ? index : latest), 0);
+    ends.push({ day: dates[newest]!.toISOString().slice(0, 10), releasedOn: releaseDay(points[newest]!.releasedOn) });
     periods.add(seriesPeriodicity(dates));
   }
   if (!ends.length) return {};
-  ends.sort();
+  ends.sort((left, right) => left.day.localeCompare(right.day));
   const [periodicity] = periods.size === 1 ? [...periods] : [null];
+  const asOf = ends.at(-1)!.day;
+  // The newest figure's release, when every series ending that day says the same one: `Sep 2026, released Tue 20 Oct`.
+  const releases = new Set(ends.filter((end) => end.day === asOf).map((end) => end.releasedOn));
+  const [releasedOn] = releases.size === 1 ? [...releases] : [null];
   return {
-    asOf: ends.at(-1)!,
-    ...(ends[0] !== ends.at(-1) ? { oldest: ends[0]! } : {}),
+    asOf,
+    ...(ends[0]!.day !== asOf ? { oldest: ends[0]!.day } : {}),
     ...(periodicity ? { periodicity } : {}),
+    ...(releasedOn ? { releasedOn } : {}),
   };
 }
 
+/** A point's release (`releasedOn`) as a day, when it is one. */
+function releaseDay(value: unknown): string | null {
+  const time = value instanceof Date ? value.getTime() : typeof value === "string" || typeof value === "number" ? new Date(value).getTime() : Number.NaN;
+  return Number.isFinite(time) ? new Date(time).toISOString().slice(0, 10) : null;
+}
+
 /**
  * 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.
@@ -306,12 +340,28 @@ function seriesAttribution(series: readonly HeadlessSeries[]): Pick<HeadlessPane
  * 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[], spec: ChartSpec): HeadlessPaneFreshness {
+function chartFreshness(
+  allSeries: readonly HeadlessSeries[],
+  spec: ChartSpec,
+  comparison?: PriceComparison | null,
+  quoteTimes: ReadonlyMap<string, number> = new Map(),
+): HeadlessPaneFreshness {
   const order = ["1wk", "1mo"];
+  // A leg that failed to load has no bars to date; the ones that loaded say what the chart is.
+  const loaded = allSeries.filter((entry) => entry.points.length > 0);
+  const series = loaded.length ? loaded : allSeries;
+  const visible = spec.series.filter((entry) => entry.visible !== false);
+  if (visible.length && series.every(entry => (entry as HeadlessSeries & Pick<ResolvedSeries, "nativeFrequency">).nativeFrequency === "daily")
+    && visible.every((entry) => entry.source.kind === "security"
+    && entry.source.period === "daily" && entry.source.fieldId.startsWith("valuation."))) {
+    const ends = series.flatMap((entry) => entry.points.at(-1)?.date ?? []).map((date) => new Date(date).toISOString().slice(0, 10)).sort();
+    return { ...DAILY_CLOSES, ...(ends.length ? { asOf: ends.at(-1)!, oldest: ends[0]! } : {}) };
+  }
   const resolutions = series.map((entry) => (entry as HeadlessSeries & { historyResolution?: string }).historyResolution);
   const dataset = isDatasetChart(spec);
   if (!series.length || resolutions.some((resolution) => !resolution)) {
-    return { ...REPORTED_DATA, basis: "reported and published data", ...(dataset ? { dataset } : {}), ...periodChartDates(series, spec), ...seriesAttribution(series) };
+    const dates = resolutions.some(Boolean) ? mixedChartDates(series, spec, quoteTimes) : periodChartDates(series, spec);
+    return { ...REPORTED_DATA, basis: "reported and published data", ...(dataset ? { dataset } : {}), ...dates, ...seriesAttribution(series) };
   }
   const coarsest = resolutions.reduce((worst, resolution) => (
     order.indexOf(resolution!) > order.indexOf(worst!) ? resolution : worst
@@ -320,7 +370,73 @@ function chartFreshness(series: readonly HeadlessSeries[], spec: ChartSpec): Hea
   // A history: its first bars are not stale data, so the line dates it by the bar still forming alone.
   if (forming) return { ...barHistoryFreshness(coarsest), periodToDate: forming, oldest: null };
   const closedDay = closedPriceBarDay(series);
-  return { ...barHistoryFreshness(coarsest), ...(closedDay ? { asOf: closedDay } : {}) };
+  // A comparison whose newest point is a session still trading is not a day's closes.
+  const basis = coarsest === "1d" && priceComparisonEndsIntraday(comparison) ? { basis: LATEST_INTRADAY_TEXT } : {};
+  // Daily bars are dated by the time of the newest point: a closed session's day, or when a session still trading was last quoted.
+  const asOf = coarsest === "1d" ? newestDailyPoint(series, closedDay, quoteTimes) : closedDay;
+  return { ...barHistoryFreshness(coarsest), ...basis, ...(asOf ? { asOf } : {}) };
+}
+
+/**
+ * The dates of a chart of price bars beside reported series (`G DHI,
+ * FRED:PERMIT`): as of its newest daily point, as a chart of the prices alone
+ * is, and when the reported series end before it, the oldest is their newest
+ * period: `Fri 23 Oct 2026 (oldest Sep 2026)`. Bars of a time of day keep the
+ * line's own dating; only the oldest is named.
+ */
+function mixedChartDates(series: readonly HeadlessSeries[], spec: ChartSpec, quoteTimes: ReadonlyMap<string, number>): Pick<HeadlessPaneFreshness, "asOf" | "oldest" | "oldestPeriodicity"> {
+  const withResolution = series as ReadonlyArray<HeadlessSeries & Partial<Pick<ResolvedSeries, "historyResolution">>>;
+  const priced = withResolution.filter((entry) => entry.historyResolution);
+  const reported = withResolution.filter((entry) => !entry.historyResolution);
+  const reportedIds = new Set(reported.map((entry) => entry.id));
+  const ends = periodChartDates(reported, { series: spec.series.filter((entry) => reportedIds.has(entry.id)) });
+  const daily = priced.every((entry) => ["1d", "1wk", "1mo"].includes(entry.historyResolution!));
+  const asOf = !daily ? null
+    : priced.every((entry) => entry.historyResolution === "1d") ? newestDailyPoint(priced, closedPriceBarDay(priced), quoteTimes)
+    : closedPriceBarDay(priced);
+  const newestPrice = asOf ?? priced.flatMap((entry) => entry.points.at(-1)?.date ?? []).map((date) => new Date(date).toISOString()).sort().at(-1);
+  const oldest = typeof ends.asOf === "string" && newestPrice && ends.asOf < newestPrice.slice(0, 10) ? ends.asOf : null;
+  return {
+    ...(asOf ? { asOf } : {}),
+    ...(oldest ? { oldest, oldestPeriodicity: ends.periodicity ?? null } : {}),
+  };
+}
+
+/**
+ * When the newest point of a chart of daily bars is from: for a session still
+ * trading, the time its listing was last quoted (`Fri 23 Oct 2026 15:42 UTC`),
+ * or its day when no quote of that day is known; else the day of the newest
+ * closed session (`closedDay`). Never the midnight a daily bar is dated at.
+ */
+function newestDailyPoint(series: readonly HeadlessSeries[], closedDay: string | null, quoteTimes: ReadonlyMap<string, number>): string | null {
+  const now = Date.now();
+  const stamps = closedDay ? [{ time: Date.parse(`${closedDay}T00:00:00Z`), text: closedDay }] : [];
+  for (const entry of series as ReadonlyArray<HeadlessSeries & Partial<Pick<ResolvedSeries, "historyResolution" | "timeBasis" | "listing">>>) {
+    const bar = entry.historyResolution === "1d" ? newestBar(entry) : null;
+    if (!bar || closedHistoryBarDay("1d", bar.day, bar.venue, now)) continue;
+    const quoted = quoteTimes.get(entry.id);
+    const dayStart = Date.parse(`${bar.day}T00:00:00Z`);
+    stamps.push(quoted != null && quoted >= dayStart && quoted <= now + 10 * 60_000
+      ? { time: quoted, text: new Date(quoted).toISOString() }
+      : { time: dayStart, text: bar.day });
+  }
+  return stamps.reduce<{ time: number; text: string } | null>((newest, stamp) => (!newest || stamp.time > newest.time ? stamp : newest), null)?.text ?? null;
+}
+
+/** When each security series' listing was last quoted, by series id, from the quotes the chart was read with. */
+function chartQuoteTimes(model: Pick<ChartPaneModel, "spec" | "snapshot">): Map<string, number> {
+  const times = new Map<string, number>();
+  for (const entry of model.spec.series) {
+    if (entry.source.kind !== "security") continue;
+    const { instrument } = entry.source;
+    const key = publicTickerKey(instrument.symbol, instrument.exchange);
+    const instrumentKey = snapshotInstrumentKey(instrument);
+    const data = model.snapshot.financials.find(([candidate]) => candidate === key)?.[1]
+      ?? model.snapshot.instrumentFinancials?.find((item) => snapshotInstrumentKey(item.instrument) === instrumentKey)?.financials;
+    const time = data?.quote?.lastUpdated;
+    if (typeof time === "number" && Number.isFinite(time)) times.set(entry.id, time);
+  }
+  return times;
 }
 
 /** A series' venue and the day its newest bar starts, as the forming and closed bar checks read them. */
@@ -332,9 +448,9 @@ function newestBar(entry: HeadlessSeries & Partial<Pick<ResolvedSeries, "history
 }
 
 /**
- * The day the newest complete weekly or monthly bar of the chart closed on,
- * the latest across its series: a week of bars dated Mon 12 Oct 2026 is dated
- * Fri 16 Oct, the day their closes are from. Null for daily and intraday bars.
+ * The day the newest complete daily, weekly or monthly bar of the chart closed
+ * on, the latest across its series: a week of bars dated Mon 12 Oct 2026 is
+ * dated Fri 16 Oct, the day their closes are from. Null for intraday bars.
  */
 function closedPriceBarDay(series: readonly HeadlessSeries[]): string | null {
   const days = (series as ReadonlyArray<HeadlessSeries & Partial<Pick<ResolvedSeries, "historyResolution" | "timeBasis" | "listing">>>).flatMap((entry) => {
@@ -360,6 +476,48 @@ function formingPriceBar(series: readonly HeadlessSeries[]): BarPeriodToDate | n
   return null;
 }
 
+const REGULAR_OPEN_MINUTE = 9 * 60 + 30;
+const REGULAR_CLOSE_MINUTE = 16 * 60;
+
+/**
+ * GIP asks for a US listing's regular session only, so an 08:30 New York
+ * release is not in its bars. Said when every bar of a US stock venue's
+ * window starts from the 09:30 open to the 16:00 close; null for another
+ * venue, a future, or bars outside those hours.
+ */
+function regularSessionNotice(windows: ReadonlyArray<{ symbol: string; exchange: string; points: ReadonlyArray<Pick<PricePoint, "date">> }>): string | null {
+  const us = windows.filter(({ symbol, exchange, points }) => points.length > 0 && isUsListingExchange(exchange) && futuresSessionOpenMinute(symbol, exchange) == null);
+  if (!us.length) return null;
+  const regular = us.every(({ points }) => points.every(({ date }) => {
+    const { hour, minute } = zonedDateTimeParts(new Date(date).getTime(), "America/New_York");
+    const at = hour * 60 + minute;
+    return at >= REGULAR_OPEN_MINUTE && at <= REGULAR_CLOSE_MINUTE;
+  }));
+  return regular ? "Regular session only, from the 09:30 New York open: pre-market and after-hours bars are not included." : null;
+}
+
+/**
+ * Intraday bars as traded: each price the decimal the feed's float stands
+ * for (85.1, not 85.099998; a sub-penny print such as 86.3775 stays), as
+ * `history` writes them. A `value` that only repeats each bar's close is
+ * marked so, and `--csv` writes Close alone.
+ */
+function tradedBars(series: HeadlessSeries): HeadlessSeries {
+  if (!series.points.some((point) => point.close != null)) return series;
+  const valueIsClose = series.points.every((point) => point.value == null || point.value === point.close);
+  const traded = (price: number | null | undefined) => price == null || !Number.isFinite(price) ? price : cleanFloat32Price(price);
+  return {
+    ...series,
+    ...(valueIsClose ? { valueIsClose } : {}),
+    points: series.points.map((point) => {
+      const bar = { ...point };
+      for (const field of ["open", "high", "low", "close"] as const) if (point[field] !== undefined) bar[field] = traded(point[field]);
+      if (point.value != null && valueIsClose) bar.value = bar.close;
+      return bar;
+    }),
+  };
+}
+
 /** What a chart series was asked as: a listing as typed (`USDZAR=X`, `SAN:EPA`), a FRED series by its ID. */
 function askedSymbol(source: ChartSeriesSource): string {
   switch (source.kind) {
@@ -374,8 +532,8 @@ function askedSymbol(source: ChartSeriesSource): string {
  * observes (`quarterly`), else how far apart its points are (a FRED series
  * charts at its own frequency, `daily` for DEXSFUS).
  */
-function servedInterval(series: Pick<ResolvedSeries, "historyResolution" | "nativeFrequency"> & Pick<HeadlessSeries, "points">): string | undefined {
-  if (series.historyResolution) return series.historyResolution;
+function servedInterval(series: Pick<ResolvedSeries, "historyResolution" | "barSize" | "nativeFrequency"> & Pick<HeadlessSeries, "points">): string | undefined {
+  if (series.historyResolution) return series.barSize ?? series.historyResolution;
   if (series.nativeFrequency && series.nativeFrequency !== "auto") return series.nativeFrequency;
   const spacing = inferSeriesFrequency(series.points.map((point) => ({ date: point.date, value: 0 })));
   return spacing === "irregular" ? undefined : spacing;
@@ -383,8 +541,8 @@ function servedInterval(series: Pick<ResolvedSeries, "historyResolution" | "nati
 
 /** A dropped resolution, as JSON's `metadata.resolution` states it. */
 export interface ChartResolutionDrop {
-  requested: ManualChartResolution;
-  returned: ManualChartResolution;
+  requested: ChartBarSize;
+  returned: ChartBarSize;
   range: string;
   reason: string;
 }
@@ -398,18 +556,21 @@ export interface ChartResolutionDrop {
 export function chartResolutionDrop(
   requested: ChartResolution,
   viewport: Pick<ChartViewportSpec, "range" | "dateWindow">,
-  series: ReadonlyArray<Pick<ResolvedSeries, "historyResolution"> & { symbol?: string }>,
+  series: ReadonlyArray<Pick<ResolvedSeries, "historyResolution" | "barSize"> & { symbol?: string }>,
   support: ChartResolutionResult["resolutionSupport"],
 ): { drop: ChartResolutionDrop; warning: string } | null {
   if (requested === "auto") return null;
-  const dropped = series.filter((entry) => entry.historyResolution && entry.historyResolution !== requested);
-  const returned = dropped[0]?.historyResolution;
+  const servedIn = (entry: Pick<ResolvedSeries, "historyResolution" | "barSize">) => entry.historyResolution ? entry.barSize ?? entry.historyResolution : null;
+  const dropped = series.filter((entry) => servedIn(entry) && servedIn(entry) !== requested);
+  const returned = dropped[0] ? servedIn(dropped[0]) : null;
   if (!returned) return null;
   const range = viewport.dateWindow ? "this window" : viewport.range;
   const symbols = [...new Set(dropped.flatMap((entry) => entry.symbol ? [entry.symbol] : []))];
-  const maxRange = support?.length ? getSupportMaxRange(support, requested) : null;
+  // A size built from shorter bars reaches back as far as those do.
+  const source = chartBarSizeSource(requested, support ?? []);
+  const maxRange = support?.length ? getSupportMaxRange(support, source) : null;
   const reason = !support?.length ? `the source returned ${returned} bars`
-    : maxRange == null ? `the source does not serve ${requested} bars`
+    : maxRange == null ? `the source does not serve ${source === requested ? requested : `the ${source} bars ${requested} bars are built from`}`
       : `${requested} bars go back ${maxRange} at most`;
   const on = symbols.length > 0 ? ` on ${symbols.join(" and ")}` : "";
   return {
@@ -436,19 +597,79 @@ export function argumentWithListing(argument: string, symbol: string, key: strin
   return named ? legs.join("") : key;
 }
 
+/**
+ * A FRED series id typed where a ticker goes (`fn G DFII10`), as the chart of
+ * FRED:DFII10: the catalog lists it, no listing answers to it, and the quote
+ * source says it is not a ticker. A real ticker of the same letters, read as
+ * a listing or quoted, still charts as the ticker; null then, and for any
+ * other series.
+ */
+export async function bareFredSeries(
+  series: ChartSeriesSpec,
+  readListing: () => Promise<unknown>,
+  context: Pick<HeadlessPaneContext, "marketData" | "catalogSeriesName">,
+): Promise<ChartSeriesSpec | null> {
+  const { source } = series;
+  if (source.kind !== "security" || source.instrument.exchange || source.instrument.instrument || source.fieldId !== CHART_FIELD_IDS.price) return null;
+  const id = source.instrument.symbol.trim().toUpperCase();
+  const expression = `FRED:${id}`;
+  const label = /^[A-Z0-9]+$/.test(id)
+    ? context.catalogSeriesName?.(expression) ?? getSharedRegistry()?.series?.findByExpression(expression)?.definition.name
+    : undefined;
+  if (!label || await readListing()) return null;
+  const failure = await Promise.resolve().then(() => context.marketData.getQuote(id, ""))
+    .then((quote) => quote ? null : `Not a ticker: ${id}.`, (error: unknown) => error instanceof Error ? error.message : String(error));
+  if (!failure || !notATickerSymbol(failure)) return null;
+  const fred = buildSeriesSpec({ kind: "economic", provider: "fred", seriesId: id, label }, 0);
+  return { ...fred, id: series.id, transform: series.transform, axis: series.axis, panelId: series.panelId };
+}
+
+/**
+ * The compared tickers whose fund facts could state a daily objective: each
+ * but those a quote already cached says are not funds (a stock, an index).
+ * The facts are read through the ETF pane's cache, so a ticker read once
+ * is not asked again for a day.
+ */
+async function possibleFundTickers(spec: ChartSpec, context: HeadlessPaneContext): Promise<string[]> {
+  const tickers = comparedFundTickers(spec);
+  const read = context.marketData.getCachedFinancialsForTargets;
+  const cached = tickers.length && read
+    ? await Promise.resolve().then(() => read.call(context.marketData, tickers.map((symbol) => ({ symbol })), { allowExpired: true, includeStaleQuotes: true }))
+      .catch(logFailure("chart-composer.headless", "Read cached chart fund types failed", null))
+    : null;
+  return tickers.filter((ticker) => {
+    const financials = cached?.get(ticker);
+    const kind = classifyInstrumentType(financials?.quote?.instrumentType ?? financials?.quoteMetadata?.instrumentType);
+    return kind === null || kind === "fund";
+  });
+}
+
 export function chartHeadless(template: keyof typeof paneSchemas): HeadlessPaneDefinition<"series"> {
   return {
     ...paneSchemas[template],
     shape: "series",
     async load(args, context) {
       const intradayHistories: ChartPaneModel["snapshot"]["intradayHistories"] = [];
-      const parsed = parseChartSpec(context.settings?.chartSpec);
-      if (!parsed) throw new Error("The chart specification is invalid.");
+      const saved = parseChartSpec(context.settings?.chartSpec);
+      if (!saved) throw new Error("The chart specification is invalid.");
+      // A leveraged or inverse fund compared with anything draws its daily objective beside it.
+      const parsed = template === "comparison-chart-pane" && mayDrawDailyObjective(saved)
+        ? withLeverageOverlay(saved, await loadDailyObjectives(
+          await possibleFundTickers(saved, context),
+          async (ticker, signal) => (await loadFundFacts(ticker, false, { client: context.apiClient, signal })).payload,
+          { signal: context.signal },
+        ))
+        : saved;
       // A bare symbol is the listing `quote` reads it as: BDI, which two companies list, asks which,
       // as `quote BDI` does, instead of charting whichever line a source picked.
       const reads = new Map<string, ReturnType<typeof readSeriesListing>>();
+      const listings = new Map<string, Promise<Awaited<ReturnType<NonNullable<typeof context.resolveListing>>> | null>>();
+      const readListing = (symbol: string) => {
+        if (!listings.has(symbol)) listings.set(symbol, context.resolveListing?.(symbol, (key) => argumentWithListing(args.rawArgument, symbol, key)) ?? Promise.resolve(null));
+        return listings.get(symbol)!;
+      };
       const readSeriesListing = async (symbol: string): Promise<{ symbol: string; exchange?: string } | null> => {
-        const read = await context.resolveListing?.(symbol, (key) => argumentWithListing(args.rawArgument, symbol, key));
+        const read = await readListing(symbol);
         if (read) return { symbol: read.symbol, ...read.exchange ? { exchange: read.exchange } : {} };
         return context.resolveInstrument ? context.resolveInstrument(symbol) : null;
       };
@@ -457,6 +678,9 @@ export function chartHeadless(template: keyof typeof paneSchemas): HeadlessPaneD
         series: await Promise.all(parsed.series.map(async (series) => {
           if (series.source.kind !== "security" || series.source.instrument.exchange) return series;
           const { symbol } = series.source.instrument;
+          // A FRED id no ticker answers to (DFII10) is its FRED series; an intraday chart has none.
+          const fred = template === "graph-intraday-price-pane" ? null : await bareFredSeries(series, () => readListing(symbol), context);
+          if (fred) return fred;
           if (!reads.has(symbol)) reads.set(symbol, readSeriesListing(symbol));
           const instrument = await reads.get(symbol)!;
           return instrument ? { ...series, source: { ...series.source, instrument: { ...series.source.instrument, ...instrument } } } : series;
@@ -469,7 +693,7 @@ export function chartHeadless(template: keyof typeof paneSchemas): HeadlessPaneD
           ? intersectChartResolutionSupport(await Promise.all([...instruments.values()].map(async (target) => (
             normalizeChartResolutionSupport(await Promise.resolve(context.marketData.getChartResolutionSupport!(
               target.symbol, target.exchange ?? "", { brokerId: target.brokerId, brokerInstanceId: target.brokerInstanceId, instrument: target.instrument },
-            )).catch(() => []))
+            )).catch(logFailure("chart-composer.headless", "Read intraday resolution support failed", [])))
           ))))
           : [];
         const request = resolveIntradayRequest({
@@ -534,20 +758,25 @@ export function chartHeadless(template: keyof typeof paneSchemas): HeadlessPaneD
       const asked = new Map(parsed.series.map((series) => [series.id, askedSymbol(series.source)]));
       model.series = model.series.map((series) => {
         const symbol = asked.get(series.id);
-        const interval = servedInterval(series as HeadlessSeries & Pick<ResolvedSeries, "historyResolution" | "nativeFrequency">);
+        const interval = servedInterval(series as HeadlessSeries & Pick<ResolvedSeries, "historyResolution" | "barSize" | "nativeFrequency">);
         return { ...series, ...(symbol ? { symbol } : {}), ...(interval ? { interval } : {}) };
       });
+      if (template === "graph-intraday-price-pane") {
+        model.series = model.series.map(tradedBars);
+        const regular = regularSessionNotice(intradayHistories.map((window) => ({ ...window, exchange: listingExchange(window.symbol, window.exchange) })));
+        if (regular) model.metadata = { ...model.metadata, notices: [...(Array.isArray(model.metadata?.notices) ? model.metadata.notices : []), regular] };
+      }
       const dropped = chartResolutionDrop(
         parsed.viewport.resolution,
         model.spec.viewport,
-        (model.series as Array<HeadlessSeries & Pick<ResolvedSeries, "historyResolution"> & { derived?: boolean }>).filter((series) => !series.derived),
+        (model.series as Array<HeadlessSeries & Pick<ResolvedSeries, "historyResolution" | "barSize"> & { derived?: boolean }>).filter((series) => !series.derived),
         model.chart.resolutionSupport,
       );
       if (dropped) {
         model.warnings = [...model.warnings ?? [], dropped.warning];
         model.metadata = { ...model.metadata, resolution: dropped.drop };
       }
-      model.freshness = chartFreshness(model.series, model.spec);
+      model.freshness = chartFreshness(model.series, model.spec, model.chart.priceComparison, chartQuoteTimes(model));
       const priceDomainFailures = intradayHistories.flatMap(({ symbol, exchange, priceDomainFailure }) =>
         priceDomainFailure ? [{ symbol, exchange, ...priceDomainFailure }] : []);
       if (priceDomainFailures.length) {

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

@@ -22,6 +22,7 @@ import {
 } from "./catalog-inventory";
 import {
   CHART_INTERACTION_VIEWPORT_SETTING_KEY,
+  CHART_LEVERAGE_PENDING_SETTING_KEY,
   CHART_PINNED_MOMENT_SETTING_KEY,
   CHART_SPEC_SETTING_KEY,
   parseChartInteractionViewport,
@@ -259,6 +260,7 @@ function securityTemplate({
   minimumSymbols,
   build,
   keywords = [],
+  settings,
 }: {
   id: Parameters<typeof chartHeadless>[0];
   prefix: "GP" | "GIP" | "CMP" | "GF" | "GE";
@@ -272,6 +274,8 @@ function securityTemplate({
   argKind: "ticker" | "ticker-list";
   minimumSymbols: number;
   build: (symbols: string[]) => ChartSpec;
+  /** Pane settings the template opens with besides the chart. */
+  settings?: Record<string, unknown>;
 }): PaneTemplateDef {
   return {
     id,
@@ -296,7 +300,9 @@ function securityTemplate({
     canCreate: (context, options) => templateSymbols(context, options).length >= minimumSymbols,
     createInstance: (context, options) => {
       const symbols = templateSymbols(context, options);
-      return symbols.length >= minimumSymbols ? selectedInstanceFor(build(symbols), prefix, context, options) : null;
+      if (symbols.length < minimumSymbols) return null;
+      const instance = selectedInstanceFor(build(symbols), prefix, context, options);
+      return settings ? { ...instance, settings: { ...instance.settings, ...settings } } : instance;
     },
   };
 }
@@ -399,6 +405,7 @@ const chartComposerTemplates: PaneTemplateDef[] = [
       "positioning",
     ],
     shortcut: { prefix: "CAT", argPlaceholder: "query", argKind: "text", argOptional: true },
+    reportFreshness: { status: "not-a-feed", basis: "series catalog" },
     canCreate: () => true,
     createInstance: (_context, options) => {
       const query = options?.arg?.trim() ?? options?.values?.query?.trim() ?? "";
@@ -446,10 +453,13 @@ const chartComposerTemplates: PaneTemplateDef[] = [
     prefix: "CMP",
     aliases: ["COMP", "TRA"],
     label: "Comparison Chart",
-    description: "Compare price returns over shared observation dates for two or more tickers.",
+    description: "Compare price returns over shared observation dates for two or more tickers. A leveraged or inverse fund gets its daily objective drawn from its index fund (3× daily QQQ beside TQQQ) and its decay against it.",
+    // Leveraged and inverse funds: the daily line and the decay come with the comparison.
+    keywords: ["leveraged", "inverse", "decay", "daily-reset", "daily reset", "volatility decay"],
     argKind: "ticker-list",
     minimumSymbols: 2,
     build: buildComparisonChartPreset,
+    settings: { [CHART_LEVERAGE_PENDING_SETTING_KEY]: true },
   }),
   securityTemplate({
     id: "fundamental-graph-pane",