gloomberb 0.18.3 → 0.18.5

package/src/plugins/builtin/chart-composer/leverage-overlay.ts

@@ -0,0 +1,142 @@
+import { logFailure } from "../../../utils/log-failure";
+import type { ChartSeriesSpec, ChartSpec, ChartStudySpec } from "../../../time-series/types";
+import { isLeverageFactor } from "../../../time-series/leverage";
+import { priceComparisonSeriesIds } from "../../../time-series/price-comparison";
+import { isUsListingExchange, parsePublicTickerKey } from "../../../utils/exchanges";
+import { MAX_CHART_COMPOSER_SERIES } from "./chart-spec";
+import { buildSeriesSpec, reconcilePanels } from "./chart-spec-edit";
+import { normalizeInstrument } from "./series-expression";
+
+/** A fund's daily objective as CMP draws it: `factor` times the index fund `proxy` each session. */
+export interface DailyObjective {
+  factor: number;
+  proxy: string;
+}
+
+/** What CMP needs of a fund's facts: a daily objective with an index fund to draw it from. */
+export interface LeverageFacts {
+  leverage?: { value: number; reset: string; proxy: { ticker: string } | null } | null;
+}
+
+export function dailyObjective(facts: LeverageFacts | null | undefined): DailyObjective | null {
+  const leverage = facts?.leverage;
+  if (!leverage || leverage.reset !== "daily" || !isLeverageFactor(leverage.value) || !leverage.proxy?.ticker) return null;
+  return { factor: leverage.value, proxy: leverage.proxy.ticker.toUpperCase() };
+}
+
+const LEVERAGE_STUDY_PREFIX = "leverage:";
+const DECAY_STUDY_PREFIX = "leverage-decay:";
+
+/** The bare ticker a compared leg is of (`TQQQ` for TQQQ:NASDAQ). */
+function legTicker(series: ChartSeriesSpec): string | null {
+  return series.source.kind === "security" ? parsePublicTickerKey(series.source.instrument.symbol).symbol.toUpperCase() : null;
+}
+
+/** A ticker the fund facts read: US-listed, as its symbol is written there (SPY, BRK.B). */
+const US_FUND_TICKER = /^[A-Z][A-Z0-9]{0,5}(?:\.[A-Z])?$/;
+
+/** The US-listed tickers of a price comparison, whose facts can say they are leveraged funds. */
+export function comparedFundTickers(spec: ChartSpec): string[] {
+  const compared = new Set(priceComparisonSeriesIds(spec) ?? []);
+  return [...new Set(spec.series.flatMap((series) => {
+    if (!compared.has(series.id) || series.source.kind !== "security") return [];
+    const exchange = series.source.instrument.exchange || parsePublicTickerKey(series.source.instrument.symbol).exchange;
+    const ticker = legTicker(series);
+    return ticker && US_FUND_TICKER.test(ticker) && (!exchange || isUsListingExchange(exchange)) ? [ticker] : [];
+  }))];
+}
+
+/** Whether the chart already draws a fund's objective, as built here or kept from before. */
+function hasLeverageOverlay(spec: ChartSpec): boolean {
+  return spec.studies.some((study) => study.kind === "leverage" || study.kind === "leverage-decay");
+}
+
+/**
+ * Whether a report of this chart could draw a daily objective at all: a
+ * price comparison without one yet, over daily bars. One session's chart, or
+ * bars asked for by the week, month or hour, would only warn that the line
+ * needs daily bars, so its legs' facts are not asked for.
+ */
+export function mayDrawDailyObjective(spec: ChartSpec): boolean {
+  if (hasLeverageOverlay(spec) || !priceComparisonSeriesIds(spec)) return false;
+  if (spec.viewport.range === "1D" && !spec.viewport.dateWindow) return false;
+  return spec.viewport.resolution === "auto" || spec.viewport.resolution === "1d";
+}
+
+/**
+ * A price comparison with each leveraged or inverse fund's daily objective
+ * drawn beside it: `factor` times its index fund each session, compounded
+ * from where the chart compares (3× daily QQQ beside TQQQ), with the index
+ * fund added as a leg when the chart has no room for it otherwise, and the
+ * fund's decay against that line and against the factor times the index
+ * fund's period return in a Decay panel. Any other chart, or a chart that
+ * already draws an objective, is returned as it was.
+ */
+export function withLeverageOverlay(spec: ChartSpec, objectives: ReadonlyMap<string, DailyObjective>): ChartSpec {
+  const compared = priceComparisonSeriesIds(spec);
+  if (!compared || hasLeverageOverlay(spec) || objectives.size === 0) return spec;
+  const series = [...spec.series];
+  const studies: ChartStudySpec[] = [...spec.studies];
+  for (const fund of spec.series.filter((entry) => compared.includes(entry.id))) {
+    const objective = objectives.get(legTicker(fund) ?? "");
+    if (!objective || fund.source.kind !== "security") continue;
+    // A compared leg of the index fund, or the one added for another fund (TQQQ and SQQQ share QQQ).
+    let index = series.find((entry) => legTicker(entry) === objective.proxy && (compared.includes(entry.id) || !spec.series.includes(entry)));
+    if (!index) {
+      const instrument = normalizeInstrument(objective.proxy, true);
+      if (!instrument || series.length >= MAX_CHART_COMPOSER_SERIES) continue;
+      index = buildSeriesSpec({ kind: "security", ...instrument, fieldId: fund.source.fieldId }, series.length, {
+        style: fund.style, transform: fund.transform, axis: fund.axis, panelId: fund.panelId,
+      });
+      series.push(index);
+    }
+    const parameters = { factor: objective.factor };
+    studies.push(
+      { id: `${LEVERAGE_STUDY_PREFIX}${fund.id}`, kind: "leverage", inputSeriesIds: [index.id], parameters, panelId: fund.panelId, axis: "left" },
+      { id: `${DECAY_STUDY_PREFIX}${fund.id}`, kind: "leverage-decay", inputSeriesIds: [fund.id, index.id], parameters, panelId: "decay", axis: "auto" },
+    );
+  }
+  if (studies.length === spec.studies.length) return spec;
+  return { ...spec, series, studies, panels: reconcilePanels(spec.panels, series, studies) };
+}
+
+/** How long a comparison waits for its legs' fund facts before it is charted without objectives. */
+const DAILY_OBJECTIVES_TIMEOUT_MS = 2_500;
+/** A pane draws its chart meanwhile and adds the objectives when they come. */
+export const LEVERAGE_FACTS_PANE_TIMEOUT_MS = 15_000;
+
+/**
+ * Each compared fund's daily objective, from its facts. A fund whose facts
+ * fail to load, or are not in by `timeoutMs`, is charted without one: the
+ * comparison never waits long on them. The reads still running then are
+ * aborted through the signal `loadFacts` is given, as they are when `signal`
+ * (the caller's) aborts.
+ */
+export async function loadDailyObjectives(
+  tickers: readonly string[],
+  loadFacts: (ticker: string, signal: AbortSignal) => Promise<LeverageFacts | null>,
+  { timeoutMs = DAILY_OBJECTIVES_TIMEOUT_MS, signal }: { timeoutMs?: number; signal?: AbortSignal } = {},
+): Promise<Map<string, DailyObjective>> {
+  const objectives = new Map<string, DailyObjective>();
+  if (tickers.length === 0) return objectives;
+  const deadline = new AbortController();
+  const expired = new Promise<null>((resolve) => deadline.signal.addEventListener("abort", () => resolve(null), { once: true }));
+  const timer = setTimeout(() => deadline.abort(new DOMException("Fund facts took too long.", "TimeoutError")), timeoutMs);
+  const cancel = () => deadline.abort(signal?.reason);
+  if (signal?.aborted) cancel();
+  else signal?.addEventListener("abort", cancel, { once: true });
+  try {
+    await Promise.all(tickers.map(async (ticker) => {
+      const facts = await Promise.race([loadFacts(ticker, deadline.signal).catch(logFailure("chart-composer.leverage-overlay", "Load chart fund objective failed", null)), expired]);
+      const objective = dailyObjective(facts);
+      // An index fund charted beside its leveraged fund is not leveraged itself.
+      if (objective && objective.proxy !== ticker) objectives.set(ticker, objective);
+    }));
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", cancel);
+    // Reads still running are no longer waited for.
+    deadline.abort();
+  }
+  return objectives;
+}

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

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../../../utils/financial-statements";
 import { usePaneSharePreparation } from "../../../shares/prepare";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
@@ -26,10 +27,13 @@ import type { PaneProps, TickerResearchTabProps } from "../../../types/plugin";
 import type { ChartResolution, TimeRange } from "../../../components/chart/core/types";
 import type { ChartSpec, ResolvedSeries } from "../../../time-series/types";
 import {
-  getSupportedChartResolutionsForViewport,
+  getSupportedChartBarSizesForViewport,
   isIntradayResolution,
+  parseChartBarSize,
+  type ChartBarSize,
   type ManualChartResolution,
 } from "../../../time-series/resolution";
+import { futuresSessionOpenMinute } from "../../../market-data/market/trading-sessions";
 import { useResolvedChartSpec } from "../../../time-series/hooks";
 import { shortCompanyName } from "../../../tickers/company-name";
 import { useSeriesListings } from "./series-listings";
@@ -50,15 +54,19 @@ import {
 } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
 import { isUsListingExchange, parsePublicTickerKey, publicTickerKey } from "../../../utils/exchanges";
-import { isMarketFieldId } from "../../../time-series/field-catalog";
+import { getTimeSeriesField, isMarketFieldId } from "../../../time-series/field-catalog";
 import { isDatasetChart } from "../../../time-series/spec";
+import { seriesMessageName, studyMessageName } from "../../../time-series/series-name";
 import { CHART_COMPOSER_PANE_ID } from "../../../types/config";
 import { useRemoteUiNode } from "../../../remote/semantic-tree";
 import { SeriesEditorDialog } from "./editor";
 import { chartComposerSemanticMetadata } from "./semantic";
+import { comparedFundTickers, LEVERAGE_FACTS_PANE_TIMEOUT_MS, loadDailyObjectives, withLeverageOverlay } from "./leverage-overlay";
+import { loadFundFacts } from "../sec/fund-facts";
 import {
   canToggleChartSeries,
   CHART_INTERACTION_VIEWPORT_SETTING_KEY,
+  CHART_LEVERAGE_PENDING_SETTING_KEY,
   CHART_PINNED_MOMENT_SETTING_KEY,
   CHART_SPEC_SETTING_KEY,
   parseChartInteractionViewport,
@@ -106,11 +114,13 @@ import { buildEmptyChartPreset, buildPriceChartPreset } from "./presets";
 import type { ChartInteractionViewport } from "./chart-spec";
 import {
   CHART_FORMULA_OPTIONS,
+  CHART_BAR_SIZE_PRESETS,
   CHART_RANGES as RANGES,
-  CHART_RESOLUTIONS as RESOLUTIONS,
+  CHART_RESOLUTIONS,
   chartStudyOptionsFor,
   chartStudyPeriodTitle,
   chartStudySettingLabel,
+  withChartBarSize,
 } from "./settings";
 import { resolveChartComposerShortcut } from "./shortcuts";
 import { describeChartResolution, formatChartDateWindow, formatChartResolution } from "./viewport-labels";
@@ -134,6 +144,9 @@ import { CHART_FOLLOW_SERIES_SETTING_KEY, rebindFollowChartSpec, resolveFollowSe
 import type { InstrumentRef } from "../../../market-data/request-types";
 
 const RANGE_OPTIONS = RANGES.map((range, index) => ({ label: range, value: range, hint: String(index + 1) }));
+const SOURCE_BAR_SIZES = CHART_RESOLUTIONS.filter((value): value is ManualChartResolution => value !== "auto");
+/** The bar size dialog's last choice, which asks for a size to type. */
+const CUSTOM_BAR_SIZE_CHOICE = "custom";
 const AUTO_VIEWPORT_DEBOUNCE_MS = 350;
 /** A load for a moving view that has not answered in this long no longer holds the next one back. */
 const LOAD_AHEAD_TIMEOUT_MS = 4_000;
@@ -379,28 +392,46 @@ function ChartComposerSurface({
   const hasMarketSeries = spec.series.some((entry) => (
     entry.source.kind === "security" && isMarketFieldId(entry.source.fieldId)
   ));
-  const availableResolutions = useMemo<ChartResolution[]>(() => {
+  // Bars built from a future's clock-aligned bars must not straddle its session's open.
+  const openMinute = useMemo(() => {
+    const listing = spec.series.find((entry) => entry.source.kind === "security" && isMarketFieldId(entry.source.fieldId));
+    return listing?.source.kind === "security" ? futuresSessionOpenMinute(listing.source.instrument.symbol, listing.source.instrument.exchange) : null;
+  }, [spec.series]);
+  // The sizes of `sizes` this chart can draw now, after Auto.
+  const availableOf = useCallback((sizes: readonly ChartBarSize[]): ChartResolution[] => {
     if (!resolution.resolutionSupport) {
       if (!hasMarketSeries) return ["auto"];
-      if (!resolution.loading) return RESOLUTIONS;
+      if (!resolution.loading) return ["auto", ...sizes];
       return spec.viewport.resolution === "auto"
         ? ["auto"]
         : ["auto", spec.viewport.resolution];
     }
-    const supported = new Set(getSupportedChartResolutionsForViewport(
+    return ["auto", ...getSupportedChartBarSizesForViewport(
       spec.viewport.range,
       resolution.resolutionSupport,
+      sizes,
       spec.viewport.dateWindow,
-    ));
-    return RESOLUTIONS.filter((value) => value === "auto" || supported.has(value));
+      openMinute,
+    )];
   }, [
     hasMarketSeries,
+    openMinute,
     resolution.loading,
     resolution.resolutionSupport,
     spec.viewport.dateWindow,
     spec.viewport.range,
     spec.viewport.resolution,
   ]);
+  // The bar lists the sizes sources serve, and a built one (4h) while the chart is set to it;
+  // the bar size dialog (b) lists the built ones too, and takes any other typed in.
+  const availableResolutions = useMemo(
+    () => availableOf(withChartBarSize(SOURCE_BAR_SIZES, spec.viewport.resolution)),
+    [availableOf, spec.viewport.resolution],
+  );
+  const dialogResolutions = useMemo(
+    () => availableOf(withChartBarSize(CHART_BAR_SIZE_PRESETS, spec.viewport.resolution)),
+    [availableOf, spec.viewport.resolution],
+  );
   // Auto names the bars it is on, which change as the view moves: a pan back
   // past where a source keeps 30-minute bars charts days instead.
   const autoBars = spec.viewport.resolution === "auto" ? resolution.resolution ?? null : null;
@@ -415,6 +446,14 @@ function ChartComposerSurface({
   const selectedPairStudies = getSelectedPairStudies(spec);
   const viewport = resolution.viewport;
   const baseSeriesIds = useMemo(() => new Set(spec.series.map((series) => series.id)), [spec.series]);
+  const rangeStatisticsSeriesId = spec.series.length === 1
+    && spec.series[0]!.source.kind === "security"
+    && spec.series[0]!.source.fieldId.startsWith("valuation.")
+    && spec.series[0]!.source.period === "daily"
+    && resolution.series.find(series => series.id === spec.series[0]!.id)?.nativeFrequency === "daily"
+    && spec.series[0]!.transform === "raw"
+    && spec.series[0]!.visible !== false
+    ? spec.series[0]!.id : undefined;
   // Hidden series are never loaded, so the resolver has nothing to report for
   // them. Without a placeholder they vanish from the legend entirely and the
   // only way back is the series dialog.
@@ -422,6 +461,12 @@ function ChartComposerSurface({
     // Each security series names its company once, beside its label: "AAPL Price · Apple".
     const named = new Set<string>();
     const resolved = (resolution.legendSeries ?? []).map((entry) => {
+      const authored = spec.series.find((series) => series.id === entry.id);
+      if (authored?.source.kind === "security" && authored.source.fieldId.startsWith("valuation.")) {
+        const field = getTimeSeriesField(authored.source.fieldId);
+        return { ...entry, label: authored.label?.trim()
+          || `${authored.source.instrument.symbol} ${field?.shortLabel ?? "Multiple"}` };
+      }
       const name = nameSeries ? listings.names.get(entry.id) : undefined;
       const company = name ? shortCompanyName(name) : "";
       if (!company || named.has(company)) return entry;
@@ -430,7 +475,7 @@ function ChartComposerSurface({
     });
     const resolvedIds = new Set(resolved.map((entry) => entry.id));
     const missing = spec.series.filter((entry) => !resolvedIds.has(entry.id));
-    if (missing.length === 0) return named.size > 0 ? resolved : resolution.legendSeries;
+    if (missing.length === 0) return resolved;
     const bySpecOrder = new Map(spec.series.map((entry, index) => [entry.id, index] as const));
     return [
       ...resolved,
@@ -474,7 +519,15 @@ function ChartComposerSurface({
     () => listingRef.current,
     [freshListing?.seriesId, freshListing?.key, freshListing?.target.symbol, freshListing?.target.exchange],
   );
+  // The ticket's levels (its draft and working orders) move through the ticket, which reviews any change.
+  const tradeRef = useRef(trade);
+  tradeRef.current = trade;
   const editLevels = useCallback((edit: CompositeLevelEdit) => {
+    const ticket = tradeRef.current;
+    if (ticket?.levels.some((level) => level.id === edit.id)) {
+      if (edit.kind === "move") ticket.moveLevel?.(edit.id, edit.value);
+      return;
+    }
     const key = listingRef.current?.key;
     if (!key) return;
     setLevelStore((current: unknown) => {
@@ -578,7 +631,7 @@ function ChartComposerSurface({
           ]}
         />
       ),
-    }).catch(() => undefined);
+    }).catch(logFailure("chart-composer.pane", "Open VWAP anchor choices failed"));
     if (choice === "pick") {
       pickAnchorAfterDialogRef.current = true;
       return { close: true };
@@ -594,7 +647,7 @@ function ChartComposerSurface({
       content: (ctx: PromptContext<string>) => (
         <TextPromptDialog {...ctx} title="Anchor VWAP at" placeholder="2026-09-30 or 2026-09-30 10:00" confirmLabel="Anchor" width={44} />
       ),
-    }).catch(() => undefined);
+    }).catch(logFailure("chart-composer.pane", "Open VWAP date prompt failed"));
     if (!text) return;
     const anchor = parseVwapAnchor(text, anchorInputRef.current);
     if (anchor === null) {
@@ -661,6 +714,11 @@ function ChartComposerSurface({
     },
     onCancel: () => setPickingAnchor(false),
   } : null, [pickingAnchor, updateSpec]);
+  // The ticket beside the chart asks for a price: a press on the plot, or Enter at the cursor, sets it.
+  const tradeOnChart = !!trade && !!listing && researchTradeMatches(trade, { ...listing.instrument, exchange: listing.target.exchange });
+  const pricePick = useMemo(() => tradeOnChart && trade?.picking && trade.finishPick && trade.cancelPick ? {
+    label: `set ${trade.picking.label}`, onPick: trade.finishPick, onCancel: trade.cancelPick,
+  } : null, [tradeOnChart, trade?.picking, trade?.finishPick, trade?.cancelPick]);
   const formulasDialogRef = useRef<MultiSelectDialogButtonHandle | null>(null);
   const indicatorsDisabled = !isPriceStudyTarget(spec);
   const formulasDisabled = spec.series.filter((series) => series.visible !== false).length < 2;
@@ -830,7 +888,7 @@ function ChartComposerSurface({
         content: (context: PromptContext<ChartSpec | null>) => (
           <SeriesEditorDialog {...context} initialSpec={spec} />
         ),
-      }).catch(() => null);
+      }).catch(logFailure("chart-composer.pane", "Open chart series editor failed", null));
       if (next) setSpec(next);
     } finally {
       setInteractionCaptured("prompt", false);
@@ -871,23 +929,57 @@ function ChartComposerSurface({
         content: (context: PromptContext<string>) => (
           <ChoiceDialog
             {...context}
-            title="Chart Resolution"
+            title="Bar Size"
             selectedChoiceId={spec.viewport.resolution}
-            choices={availableResolutions.map((value) => ({
-              id: value,
-              label: formatChartResolution(value),
-              description: describeChartResolution(value),
-            }))}
+            choices={[
+              ...dialogResolutions.map((value) => ({
+                id: value,
+                label: formatChartResolution(value),
+                description: describeChartResolution(value),
+              })),
+              ...(hasMarketSeries ? [{ id: CUSTOM_BAR_SIZE_CHOICE, label: "Custom…", description: "Type any number of minutes, hours, days, weeks or months." }] : []),
+            ]}
           />
         ),
-      }).catch(() => "");
-      if (availableResolutions.includes(next as ChartResolution)) setResolution(next as ChartResolution);
+      }).catch(logFailure("chart-composer.pane", "Open chart bar size choices failed", ""));
+      if (next === CUSTOM_BAR_SIZE_CHOICE) {
+        // A row picked with the mouse closes on mousedown; the field opens after the
+        // click has placed the focus, or the desktop leaves it on the dialog.
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const typed = await dialog.prompt<string>({
+          content: (ctx: PromptContext<string>) => (
+            <TextPromptDialog {...ctx} title="Custom Bar Size" placeholder="10m, 90m, 4h, 2D, 3W, 6mo" confirmLabel="Chart" width={44} />
+          ),
+        }).catch(logFailure("chart-composer.pane", "Open custom chart bar size prompt failed"));
+        if (!typed) return;
+        const size = parseChartBarSize(typed);
+        const count = /^\s*(\d+)\s*M\s*$/.exec(typed)?.[1];
+        if (!size) {
+          notify({
+            body: count
+              ? `Write ${count}m for ${count} minutes or ${count}mo for ${count} months.`
+              : `${typed} is not a bar size. Use a number and a unit: 10m, 4h, 2D, 3W, 6mo; up to a day of minutes or hours, a year of days or weeks, or 12 months.`,
+            type: "error",
+          });
+          return;
+        }
+        if (!availableOf(withChartBarSize([], size)).includes(size)) {
+          notify({ body: `${formatChartResolution(size)} bars are unavailable for this range.`, type: "error" });
+          return;
+        }
+        setResolution(size);
+        return;
+      }
+      if (dialogResolutions.includes(next as ChartResolution)) setResolution(next as ChartResolution);
     } finally {
       setInteractionCaptured("prompt", false);
     }
   }, [
-    availableResolutions,
+    availableOf,
     dialog,
+    dialogResolutions,
+    hasMarketSeries,
+    notify,
     setInteractionCaptured,
     setResolution,
     spec.viewport.resolution,
@@ -923,7 +1015,7 @@ function ChartComposerSurface({
         void openSeriesEditor();
         return;
       case "resolution":
-        if (availableResolutions.length > 1) void openResolutionPicker();
+        if (dialogResolutions.length > 1) void openResolutionPicker();
     }
   }, { enabled: focused && !dialogOpen });
 
@@ -936,13 +1028,13 @@ function ChartComposerSurface({
   const loading = resolution.loading || listings.pending;
   // A bare code several companies list asks which, as `quote` does, before anything else is said.
   const statusError = listings.errors[0] ?? resolution.errors[0];
-  // A spread or formula error names its legs and their units; the study's id adds nothing to it.
+  // A spread or formula error names its legs and their units; the study's name adds nothing to it.
   const formulaStudy = spec.studies.find((study) => (study.kind === "spread" || study.kind === "formula")
-    && statusError?.startsWith(`${study.id}: `));
-  const statusErrorNotice = formulaStudy ? statusError?.slice(`${formulaStudy.id}: `.length) : statusError;
-  // Failed series use their authored id in errors and their display label in warnings.
-  const errorSeries = spec.series.find((entry) => statusError?.startsWith(`${entry.label ?? entry.id}: `));
-  const errorMessage = errorSeries ? statusError?.slice(`${errorSeries.label ?? errorSeries.id}: `.length) : undefined;
+    && statusError?.startsWith(`${studyMessageName(study)}: `));
+  const statusErrorNotice = formulaStudy ? statusError?.slice(`${studyMessageName(formulaStudy)}: `.length) : statusError;
+  // Failed series name what was asked for in errors and their display label in warnings.
+  const errorSeries = spec.series.find((entry) => statusError?.startsWith(`${seriesMessageName(entry)}: `));
+  const errorMessage = errorSeries ? statusError?.slice(`${seriesMessageName(errorSeries)}: `.length) : undefined;
   // The label the resolver wrote its warnings with, before the legend named the company.
   const errorSeriesLabel = (resolution.legendSeries?.find((entry) => entry.id === errorSeries?.id)
     ?? legendSeries?.find((entry) => entry.id === errorSeries?.id))?.label;
@@ -965,9 +1057,9 @@ function ChartComposerSurface({
     && !FORWARD_VALUATION_BASIS_NOTICES.has(warning)
     && !duplicateErrorNotices.has(warning) && !comparisonEmptyNotices.has(warning)
     && !spec.studies.some((study) => (
-      (study.kind === "ratio" && warning.startsWith(`${study.id}: ratio inputs use different currencies (`)
+      (study.kind === "ratio" && warning.startsWith(`${studyMessageName(study)}: ratio inputs use different currencies (`)
         && warning.endsWith("); raw values are not FX-converted."))
-      || (study.kind === "correlation" && warning.startsWith(`${study.id}: correlation mixes `)
+      || (study.kind === "correlation" && warning.startsWith(`${studyMessageName(study)}: correlation mixes `)
         && warning.endsWith("; only matching observation times contribute."))
     ))
   ));
@@ -1192,7 +1284,9 @@ function ChartComposerSurface({
           onToggleSeries={toggleSeries}
           isSeriesToggleable={isSeriesToggleable}
           timePick={timePick}
+          pricePick={pricePick}
           levels={chartLevels}
+          rangeStatisticsSeriesId={rangeStatisticsSeriesId}
           emptyMessage={emptyMessage}
           emptyDetail={emptyDetail}
           legendAccessory={(
@@ -1287,6 +1381,26 @@ export function ChartComposerPane({ paneId, focused, width, height }: PaneProps)
       savedForTarget.current = targetKey;
     }
   }, [follows, ownedIds, savedIds, setSpec, spec, stored, target, unlinkedFrom, updateSettings]);
+  // A comparison CMP opened draws each leveraged or inverse fund's daily objective once its facts are read.
+  const leveragePending = instance?.settings?.[CHART_LEVERAGE_PENDING_SETTING_KEY] === true;
+  const storedRef = useRef(stored);
+  storedRef.current = stored;
+  useEffect(() => {
+    if (!leveragePending) return;
+    const mounted = new AbortController();
+    // The chart draws meanwhile, so it can wait longer for them than a report does.
+    void loadDailyObjectives(comparedFundTickers(storedRef.current),
+      async (ticker, signal) => (await loadFundFacts(ticker, false, { signal })).payload,
+      { timeoutMs: LEVERAGE_FACTS_PANE_TIMEOUT_MS, signal: mounted.signal })
+      .then((objectives) => {
+        if (mounted.signal.aborted) return;
+        updateSettings({
+          [CHART_SPEC_SETTING_KEY]: withLeverageOverlay(storedRef.current, objectives),
+          [CHART_LEVERAGE_PENDING_SETTING_KEY]: undefined,
+        });
+      });
+    return () => mounted.abort();
+  }, [leveragePending, updateSettings]);
   if (follows && !target && ownedIds.length > 0) {
     return <EmptyState title={error ?? "Select a ticker."} />;
   }

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

@@ -6,7 +6,7 @@ import {
 } from "../../../time-series/types";
 import type { ChartResolution, TimeRange } from "../../../components/chart/core/types";
 import { MAX_CHART_COMPOSER_SERIES } from "./chart-spec";
-import { appendChartSeries, appendPlacedSeries, buildCustomSeries, buildSeriesSpec, panelsForSeries } from "./chart-spec-edit";
+import { appendChartSeries, appendPlacedSeries, buildCustomSeries, buildSeriesSpec, nextGeneratedPanelId, panelsForSeries } from "./chart-spec-edit";
 import { currencyPairSpelling } from "../../../utils/currency-pair";
 import { dashedCoinPair } from "../../../utils/crypto-pair";
 import {
@@ -82,21 +82,51 @@ function placeFormulaLeg(formula: ParsedFormula, index: number, series: ChartSer
   return mixed && series.panelId === "main" && !formula.legs[index]!.perBarrel ? { ...series, axis: "right" } : series;
 }
 
-/** The study that weighs a formula's legs, charted as the given series, in the Formula panel. */
+/**
+ * A series the formula is divided or multiplied by (an FX rate) counts
+ * something else again: it is drawn in a panel of its own, not on the legs' axes.
+ */
+function placeFormulaFactor(spec: Pick<ChartSpec, "panels" | "series" | "studies">, series: ChartSeriesSpec): ChartSeriesSpec {
+  return { ...series, panelId: nextGeneratedPanelId(spec), axis: "auto" };
+}
+
+/** A factor's panel is shorter than a series panel, so the legs and the formula keep their room. */
+const FACTOR_PANEL_HEIGHT = 0.2;
+
+/** The panels with each new factor's last and short: the formula reads right under its legs. */
+function withFactorPanels(panels: ChartSpec["panels"], factors: readonly ChartSeriesSpec[]): ChartSpec["panels"] {
+  const ids = new Set(factors.map((series) => series.panelId));
+  return [
+    ...panels.filter((panel) => !ids.has(panel.id)),
+    ...panels.filter((panel) => ids.has(panel.id)).map((panel) => ({ ...panel, height: FACTOR_PANEL_HEIGHT })),
+  ];
+}
+
+/** The study that weighs a formula's legs and scales the sum, charted as the given series, in the Formula panel. */
 function formulaStudy(formula: ParsedFormula, inputSeriesIds: string[]): ChartStudySpec {
   const parameters: ChartStudySpec["parameters"] = { divisor: formula.divisor };
   formula.legs.forEach((leg, index) => {
     parameters[`weight${index + 1}`] = leg.weight;
     if (leg.perBarrel) parameters[`perBarrel${index + 1}`] = 1;
+    if (leg.perTonne) parameters[`perTonne${index + 1}`] = leg.perTonne;
+  });
+  formula.factors.forEach((factor, index) => {
+    parameters[`power${formula.legs.length + index + 1}`] = factor.power;
   });
   return { id: FORMULA_STUDY_ID, kind: "formula", inputSeriesIds, parameters, panelId: "formula", axis: "auto" };
 }
 
-/** A formula's legs as series, with the study that sums them in the Formula panel. */
+/** A formula's legs and factors as series, with the study that sums them in the Formula panel. */
 function formulaChartPreset(formula: ParsedFormula): ChartSpec {
-  const series = buildCustomSeries(formula.legs.map((leg) => leg.series))
-    .map((entry, index) => placeFormulaLeg(formula, index, entry));
-  return chartSpec(series, { studies: [formulaStudy(formula, series.map((entry) => entry.id))] });
+  const legs = buildCustomSeries([...formula.legs, ...formula.factors].map((entry) => entry.series));
+  const series: ChartSeriesSpec[] = [];
+  legs.forEach((entry, index) => {
+    series.push(index < formula.legs.length
+      ? placeFormulaLeg(formula, index, entry)
+      : placeFormulaFactor({ panels: [], series, studies: [] }, entry));
+  });
+  const spec = chartSpec(series, { studies: [formulaStudy(formula, series.map((entry) => entry.id))] });
+  return { ...spec, panels: withFactorPanels(spec.panels, series.slice(formula.legs.length)) };
 }
 
 /**
@@ -107,17 +137,22 @@ function appendChartFormula(spec: ChartSpec, expression: string): { spec: ChartS
   const formula = parseFormulaExpression(expression);
   if (!formula) throw new Error(`"${expression}" is not a formula.`);
   const key = (series: ChartSeriesSpec) => formatSeriesExpression(series).toLowerCase();
-  const legs = formula.legs.map((leg) => key(buildSeriesSpec(leg.series, 0)));
+  const terms = [...formula.legs, ...formula.factors];
+  const legs = terms.map((leg) => key(buildSeriesSpec(leg.series, 0)));
   const missing = legs.filter((leg) => !spec.series.some((series) => key(series) === leg)).length;
   if (spec.series.length + missing > MAX_CHART_COMPOSER_SERIES) {
     throw new Error(`Charts support up to ${MAX_CHART_COMPOSER_SERIES} base series.`);
   }
   let next: ChartSpec = { ...spec, studies: spec.studies.filter((study) => study.id !== FORMULA_STUDY_ID) };
-  const inputs = formula.legs.map((leg, index) => {
+  const placedFactors: ChartSeriesSpec[] = [];
+  const inputs = terms.map((leg, index) => {
     const charted = next.series.find((series) => key(series) === legs[index]);
     if (charted) return charted;
     const appended = appendChartSeries(next, leg.series);
-    const placed = placeFormulaLeg(formula, index, appended.series);
+    const placed = index < formula.legs.length
+      ? placeFormulaLeg(formula, index, appended.series)
+      : placeFormulaFactor(next, appended.series);
+    if (index >= formula.legs.length) placedFactors.push(placed);
     next = { ...appended.spec, series: appended.spec.series.map((series) => series.id === placed.id ? placed : series) };
     return placed;
   });
@@ -127,7 +162,10 @@ function appendChartFormula(spec: ChartSpec, expression: string): { spec: ChartS
     spec: {
       ...next,
       studies,
-      panels: [...next.panels, ...panelsForSeries(next.series, studies).filter((panel) => !known.has(panel.id))],
+      panels: withFactorPanels(
+        [...next.panels, ...panelsForSeries(next.series, studies).filter((panel) => !known.has(panel.id))],
+        placedFactors,
+      ),
     },
     series: inputs.at(-1)!,
   };
@@ -275,11 +313,8 @@ export function buildValuationChartPreset(
     const series = buildSeriesSpec(
       { kind: "security", ...instrument, fieldId: resolvedField },
       index,
-      { style: normalized.length === 1 ? "line" : "columns", axis: "left" },
+      { style: "line", axis: "left" },
     );
-    // Fiscal years: most US filers report no Q4 EPS, which charts do not
-    // reconstruct, so a quarterly trailing multiple has only its latest few
-    // quarters. Quarterly is the series' Period control away.
-    return series.source.kind === "security" ? { ...series, source: { ...series.source, period: "annual" } } : series;
+    return series.source.kind === "security" ? { ...series, source: { ...series.source, period: "daily" } } : series;
   }));
 }