gloomberb 0.18.3 → 0.18.4

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";
@@ -52,13 +56,17 @@ import { colors } from "../../../theme/colors";
 import { isUsListingExchange, parsePublicTickerKey, publicTickerKey } from "../../../utils/exchanges";
 import { 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;
@@ -474,7 +505,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 +617,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 +633,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 +700,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 +874,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 +915,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 +1001,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 +1014,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 +1043,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,6 +1270,7 @@ function ChartComposerSurface({
           onToggleSeries={toggleSeries}
           isSeriesToggleable={isSeriesToggleable}
           timePick={timePick}
+          pricePick={pricePick}
           levels={chartLevels}
           emptyMessage={emptyMessage}
           emptyDetail={emptyDetail}
@@ -1287,6 +1366,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/series-catalog.ts

@@ -391,6 +391,7 @@ function catalogFormula(expression: string): boolean {
   try {
     return parseFormulaExpression(expression) !== null;
   } catch {
+    // Intentional ignore: invalid catalog formulas are excluded from the chartable suggestions.
     return false;
   }
 }

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

@@ -1,4 +1,6 @@
 import { futuresGenericCaption, futuresGenericListing } from "../../../utils/futures-generic";
+import { isIsoCurrencyCode } from "../../../utils/crypto-pair";
+import { readTerminalListingCode } from "../../../tickers/terminal-codes";
 import type { ChartSeriesSpec, SeriesStyle, SeriesTransform } from "../../../time-series/types";
 import {
   canonicalTimeSeriesFieldId,
@@ -164,21 +166,78 @@ export function parseSeriesExpression(value: string): ParsedSeriesExpression | n
 
 const SERIES_FORMS = "Use SYMBOL, SYMBOL:field, FUT:code, UST:maturity, FRED:series, GEO:series, or CAP:capability-id:series-id.";
 
+/** A word that reads as a series, not an operator or a number of a formula. */
+const LIST_WORD = /^[A-Za-z^][\w.^=:/~-]*$/;
+
+/** The words that close a Bloomberg security (`AAPL US Equity`, `EURUSD Curncy`), and its exchange code `US`. */
+const BLOOMBERG_WORDS = new Set(["EQUITY", "INDEX", "CURNCY", "COMDTY", "GOVT", "CORP", "MTGE", "MUNI", "PFD"]);
+
+/** Why words typed with spaces between them are no list of series, when they are not: what to say, if anything. */
+interface NotAList {
+  hint?: string;
+}
+
+/**
+ * Words with spaces between them that are one thing and not tickers side by
+ * side: a Bloomberg security, a currency pair, or a series whose field has
+ * spaces in it (`MSFT:net income`). Charting each word would draw series
+ * nobody asked for, so these are errors, with a hint where one helps.
+ */
+function notAList(words: readonly string[]): NotAList | null {
+  if (words.some((word, index) => BLOOMBERG_WORDS.has(word.toUpperCase()) || (index > 0 && word.toUpperCase() === "US"))) {
+    const code = readTerminalListingCode(words.join(" "));
+    return { hint: code ? ` That is a Bloomberg code: write it ${code.key}.` : " That is a Bloomberg security: write the ticker alone (AAPL), or with its exchange (AAPL:NASDAQ)." };
+  }
+  if (words.length === 2 && words.every((word) => /^[A-Za-z]{3}$/.test(word) && isIsoCurrencyCode(word.toUpperCase()))) {
+    const [base, quote] = words.map((word) => word.toUpperCase());
+    return { hint: ` ${base} ${quote} reads as a currency pair: write it ${base}/${quote}, or separate tickers with commas.` };
+  }
+  return words.some((word, index) => word.includes(":") && spacedField(words, index)) ? {} : null;
+}
+
+/** Whether the words from `start` on, joined, are one series whose field has spaces in it (`MSFT:net income`). */
+function spacedField(words: readonly string[], start: number): boolean {
+  for (let end = start + 2; end <= words.length; end += 1) {
+    if (parseSeriesExpression(words.slice(start, end).join(" "))) return true;
+  }
+  return false;
+}
+
+/**
+ * One leg of a list: a series, or series typed with spaces between them
+ * (`AAPL MSFT`, as `fn G AAPL MSFT` passes them), each word a series of its
+ * own. Null when it is neither.
+ */
+function parseLeg(leg: string): ParsedSeriesExpression[] | null {
+  const parsed = parseSeriesExpression(leg);
+  if (parsed) return [parsed];
+  const words = leg.trim().split(/\s+/);
+  if (words.length < 2 || notAList(words)) return null;
+  const series = words.map(parseSeriesExpression);
+  return series.every((entry): entry is ParsedSeriesExpression => entry != null) ? series : null;
+}
+
 export function parseChartExpression(value: string): ParsedSeriesExpression[] {
   if (!value.trim()) return [];
   // A list pasted with a stray separator (`BRK.B,SPY,`, `,SPY`, `A,,B`) has no series between them.
   const legs = value.split(/[;,\n]/).filter((leg) => leg.trim());
   // Separators alone name no series at all.
   if (legs.length === 0) throw new Error(`Invalid chart series "${value.trim()}": no series between its separators. ${SERIES_FORMS}`);
-  if (legs.length > MAX_CHART_COMPOSER_SERIES) {
-    throw new Error(`Charts support up to ${MAX_CHART_COMPOSER_SERIES} base series.`);
-  }
 
-  return legs.map((leg) => {
-    const parsed = parseSeriesExpression(leg);
+  const series = legs.flatMap((leg) => {
+    const parsed = parseLeg(leg);
     if (parsed) return parsed;
-    throw new Error(`Invalid chart series "${leg.trim()}". ${SERIES_FORMS}`);
+    // Words with spaces between them that are not all series: a list is written with commas.
+    const words = leg.trim().split(/\s+/);
+    const reason = words.length > 1 ? notAList(words) : null;
+    const listHint = reason ? reason.hint ?? ""
+      : words.length > 1 && words.every((word) => LIST_WORD.test(word)) ? ` Separate series with commas: ${words.join(",")}.` : "";
+    throw new Error(`Invalid chart series "${leg.trim()}".${listHint} ${SERIES_FORMS}`);
   });
+  if (series.length > MAX_CHART_COMPOSER_SERIES) {
+    throw new Error(`Charts support up to ${MAX_CHART_COMPOSER_SERIES} base series.`);
+  }
+  return series;
 }
 
 export function formatSeriesExpression(series: ChartSeriesSpec): string {

package/src/plugins/builtin/chart-composer/session-history.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import type { DataProvider, MarketDataRequestContext } from "../../../types/data-provider";
 import type { PricePoint, Quote } from "../../../types/financials";
 import type { TimeRange } from "../../../time-series/range";
@@ -10,6 +11,7 @@ import {
 import { parsePublicTickerKey, resolveExchangeTimeZone } from "../../../utils/exchanges";
 import { listingSuffixExchange } from "../../../sources/listing-symbols";
 import { getPricePointTimestamp } from "../../../utils/price-history";
+import { dateOptionError, readCalendarDate } from "../../../utils/calendar-date";
 import { pricePointIntegrity } from "../../../utils/price-history-integrity";
 import { zonedDateKey, zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
 import { fetchHistoryResult } from "../../../sources/history-result";
@@ -46,28 +48,22 @@ export interface LoadedIntradayWindow extends IntradayWindow {
   sourceKey?: string;
 }
 
-const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
 const HISTORICAL_RETRY_DELAY_MS = 61 * 60_000;
 const DAY_MS = 24 * 60 * 60_000;
 
+/** `--session` as YYYY-MM-DD: any date a date option reads, or an error that lists the formats. */
+function readSessionDate(value: string): string {
+  const date = readCalendarDate(value);
+  if (!date) throw new Error(`Invalid --session value "${value}". ${dateOptionError(value, "--session", { subject: "a session date" })}`);
+  return date;
+}
+
 function parseSessionDate(value: string): {
   year: number;
   month: number;
   day: number;
 } {
-  const match = DATE_ONLY_PATTERN.exec(value.trim());
-  if (!match) throw new Error(`Invalid --session value "${value}". Use YYYY-MM-DD.`);
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  const day = Number(match[3]);
-  const candidate = new Date(Date.UTC(year, month - 1, day));
-  if (
-    candidate.getUTCFullYear() !== year
-    || candidate.getUTCMonth() !== month - 1
-    || candidate.getUTCDate() !== day
-  ) {
-    throw new Error(`Invalid --session value "${value}". Use a real calendar date.`);
-  }
+  const [year, month, day] = value.split("-").map(Number) as [number, number, number];
   return { year, month, day };
 }
 
@@ -152,8 +148,7 @@ export function resolveIntradaySessionWindow(
     bySession.set(date, sessionPoints);
   }
 
-  const requestedSession = options.session?.trim() || null;
-  if (requestedSession) parseSessionDate(requestedSession);
+  const requestedSession = options.session?.trim() ? readSessionDate(options.session.trim()) : null;
   const availableSessions = [...bySession.keys()].sort();
   const selectedSessions = requestedSession
     ? availableSessions.filter((date) => date === requestedSession)
@@ -195,9 +190,8 @@ export function resolveIntradayRequest(options: {
   support?: readonly ChartResolutionSupport[];
 }): IntradayRequest {
   const session = typeof options.session === "string" && options.session.trim()
-    ? options.session.trim()
+    ? readSessionDate(options.session.trim())
     : null;
-  if (session) parseSessionDate(session);
   const rangePreset = session
     ? "1D"
     : options.rangePreset === "1W" ? "1W" : "1D";
@@ -254,13 +248,13 @@ async function loadHistoricalFallback(
   if (request.session) {
     const bounds = sessionUtcBounds(request.session, timeZone);
     return await fetchHistoryResult(provider, symbol, exchange,
-      { kind: "detail", start: bounds.start, end: bounds.end, interval: request.resolution }, context).catch(() => null) ?? empty;
+      { kind: "detail", start: bounds.start, end: bounds.end, interval: request.resolution }, context).catch(logFailure("chart-composer.session-history", "Load requested intraday session failed", null)) ?? empty;
   }
   const end = new Date(now.getTime() - HISTORICAL_RETRY_DELAY_MS);
   const lookbackDays = request.rangePreset === "1W" ? 35 : 8;
   const start = new Date(end.getTime() - lookbackDays * DAY_MS);
   return await fetchHistoryResult(provider, symbol, exchange,
-    { kind: "detail", start, end, interval: request.resolution }, context).catch(() => null) ?? empty;
+    { kind: "detail", start, end, interval: request.resolution }, context).catch(logFailure("chart-composer.session-history", "Load historical intraday fallback failed", null)) ?? empty;
 }
 
 export async function loadIntradayWindow(options: {
@@ -354,7 +348,7 @@ export async function loadIntradayWindow(options: {
   if (nonpositive.length) {
     // Metadata is needed only at this boundary. Do not infer a futures domain
     // from a ticker suffix, a contract multiplier, or an option security type.
-    const reportedQuote = await options.provider.getQuote(options.symbol, options.exchange, options.context).catch(() => undefined);
+    const reportedQuote = await options.provider.getQuote(options.symbol, options.exchange, options.context).catch(logFailure("chart-composer.session-history", "Read intraday instrument metadata failed"));
     const quote = reportedQuote?.symbol.trim().toUpperCase() === options.symbol.trim().toUpperCase()
       ? reportedQuote : undefined;
     const instrumentType = quote?.instrumentType?.trim().toUpperCase() || null;