gloomberb 0.13.3 → 0.14.0

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

@@ -1,9 +1,11 @@
+import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../../../utils/financial-statements";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useUiCapabilities, useUiHost } from "../../../ui";
 import {
   ChoiceDialog,
   Tabs,
   usePaneFooter,
+  usePaneNoticeFooter,
   type PaneFooterPressEvent,
 } from "../../../components";
 import {
@@ -29,6 +31,7 @@ import {
   usePaneTicker,
 } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
+import { publicTickerKey } from "../../../utils/exchanges";
 import { CHART_COMPOSER_PANE_ID } from "../../../types/config";
 import { useRemoteUiNode } from "../../../remote/semantic-tree";
 import { SeriesEditorDialog } from "./editor";
@@ -51,7 +54,7 @@ import {
   getSelectedPairStudies,
   setBuiltinStudies,
   setPairStudies,
-  rebindChartSecuritySymbol,
+  rebindResearchChartSpec,
   type BuiltinStudySelection,
   type PairStudySelection,
 } from "./presets";
@@ -65,12 +68,17 @@ import {
 import { resolveChartComposerShortcut } from "./shortcuts";
 import { ChartSeriesQuickAdd } from "./quick-add";
 import { useLiveStreamingSetting } from "../shared/live-streaming";
-import { usePublicShare } from "../shared/public-share";
-import { buildChartShareData } from "../../../shares/chart-snapshot";
+import { usePluginAppActions } from "../../runtime";
 import { isPlainKey } from "../../../utils/keyboard";
 
 const RANGE_TABS = RANGES.map((range, index) => ({ label: `${index + 1}:${range}`, value: range }));
 const AUTO_VIEWPORT_DEBOUNCE_MS = 350;
+/**
+ * Drawings persist into pane settings on a short debounce after the pointer
+ * settles. A share reads those settings, so it waits at least that long for a
+ * stroke finished a moment before the key press.
+ */
+const SHARE_SETTLE_DELAY_MS = 450;
 /** Bar pitch AUTO aims for; the coarser neighbour wins ties so bars stay readable. */
 const AUTO_RESOLUTION_BAR_PIXELS = 7;
 const MINIMUM_AUTO_RESOLUTION_POINTS = 60;
@@ -102,14 +110,6 @@ function runtimeViewportFromSetting(
   };
 }
 
-function footerAnchorPoint(event?: PaneFooterPressEvent): { x: number; y: number } | undefined {
-  const x = event?.pixelX;
-  const y = event?.pixelY;
-  return typeof x === "number" && Number.isFinite(x) && typeof y === "number" && Number.isFinite(y)
-    ? { x, y }
-    : undefined;
-}
-
 interface ChartComposerSurfaceProps {
   spec: ChartSpec;
   setSpec: (next: ChartSpec) => void;
@@ -123,6 +123,14 @@ interface ChartComposerSurfaceProps {
 
 const QUICK_ADD_CAPTURE = "quick-add";
 
+function footerAnchorPoint(event?: PaneFooterPressEvent): { x: number; y: number } | undefined {
+  const x = event?.pixelX;
+  const y = event?.pixelY;
+  return typeof x === "number" && Number.isFinite(x) && typeof y === "number" && Number.isFinite(y)
+    ? { x, y }
+    : undefined;
+}
+
 function isPriceStudyTarget(spec: ChartSpec): boolean {
   return spec.series.some((series) => (
     series.source.kind === "security"
@@ -182,6 +190,7 @@ function ChartComposerSurface({
   const runtimeViewportTimerRef = useRef<ReturnType<typeof globalThis.setTimeout> | null>(null);
   const adaptiveViewportRef = useRef<RuntimeChartViewport | null>(null);
   const requestViewportRef = useRef<RuntimeChartViewport | null>(null);
+  const requestViewportOwnerRef = useRef(authoredViewportKey);
   const activeRuntimeViewport = runtimeViewportState?.key === authoredViewportKey
     ? runtimeViewportState
     : null;
@@ -272,11 +281,11 @@ function ChartComposerSurface({
     ),
     [resolution.bufferedSeries, resolution.legendSeries, resolution.series, spec],
   );
-  const shareData = useMemo(() => buildChartShareData(plottedSeries), [plottedSeries]);
-  const createPublicShare = usePublicShare();
-  const shareChart = useCallback(() => {
-    if (shareData) void createPublicShare({ kind: "chart", data: shareData });
-  }, [createPublicShare, shareData]);
+  const { sharePane } = usePluginAppActions();
+  const shareTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  useEffect(() => () => {
+    if (shareTimerRef.current !== null) clearTimeout(shareTimerRef.current);
+  }, []);
   const [interactionCaptured, setInteractionCapturedState] = useState(false);
   // Typing in quick-add must not freeze the plot: it only takes the keyboard.
   const [modalCaptured, setModalCaptured] = useState(false);
@@ -324,6 +333,7 @@ function ChartComposerSurface({
     );
     adaptiveViewportRef.current = restored?.adaptiveViewport ?? null;
     requestViewportRef.current = restored?.requestViewport ?? null;
+    requestViewportOwnerRef.current = authoredViewportKey;
     setRuntimeViewportState((current) => current?.key === authoredViewportKey ? current : restored);
     if (persistedInteractionViewport && !restored) setStoredInteractionViewport(null);
     return () => {
@@ -333,6 +343,24 @@ function ChartComposerSurface({
       }
     };
   }, [authoredViewportKey, persistedInteractionViewport, setStoredInteractionViewport]);
+  const commitRuntimeViewport = useCallback(() => {
+    const requestViewport = requestViewportRef.current;
+    if (!requestViewport) return;
+    const adaptiveViewport = spec.viewport.resolution === "auto"
+      ? adaptiveViewportRef.current
+      : null;
+    setRuntimeViewportState({
+      key: authoredViewportKey,
+      adaptiveViewport,
+      requestViewport,
+    });
+    setStoredInteractionViewport({
+      authoredViewportKey,
+      start: requestViewport.start.toISOString(),
+      end: requestViewport.end.toISOString(),
+      adaptive: adaptiveViewport !== null,
+    } satisfies ChartInteractionViewport);
+  }, [authoredViewportKey, setStoredInteractionViewport, spec.viewport.resolution]);
   const handleChartViewportChange = useCallback((
     next: { start: Date; end: Date } | null,
     _interaction: "pan" | "reset" | "zoom",
@@ -353,29 +381,28 @@ function ChartComposerSurface({
     if (!Number.isFinite(start) || !Number.isFinite(end) || start > end) return;
     const viewport = { start: new Date(start), end: new Date(end) };
     requestViewportRef.current = viewport;
+    requestViewportOwnerRef.current = authoredViewportKey;
     // A pan can leave the window a provider serves at the current resolution
     // just as a zoom can, so both re-pick.
     if (spec.viewport.resolution === "auto") adaptiveViewportRef.current = viewport;
     runtimeViewportTimerRef.current = globalThis.setTimeout(() => {
       runtimeViewportTimerRef.current = null;
-      const requestViewport = requestViewportRef.current;
-      if (!requestViewport) return;
-      const adaptiveViewport = spec.viewport.resolution === "auto"
-        ? adaptiveViewportRef.current
-        : null;
-      setRuntimeViewportState({
-        key: authoredViewportKey,
-        adaptiveViewport,
-        requestViewport,
-      });
-      setStoredInteractionViewport({
-        authoredViewportKey,
-        start: requestViewport.start.toISOString(),
-        end: requestViewport.end.toISOString(),
-        adaptive: adaptiveViewport !== null,
-      } satisfies ChartInteractionViewport);
+      commitRuntimeViewport();
     }, AUTO_VIEWPORT_DEBOUNCE_MS);
-  }, [authoredViewportKey, setStoredInteractionViewport, spec.viewport.resolution]);
+  }, [authoredViewportKey, commitRuntimeViewport, spec.viewport.resolution]);
+  const shareChart = useCallback(() => {
+    // The share reads pane settings, so the gesture in flight lands there first.
+    if (runtimeViewportTimerRef.current !== null) {
+      clearTimeout(runtimeViewportTimerRef.current);
+      runtimeViewportTimerRef.current = null;
+      commitRuntimeViewport();
+    }
+    if (shareTimerRef.current !== null) return;
+    shareTimerRef.current = globalThis.setTimeout(() => {
+      shareTimerRef.current = null;
+      sharePane(paneId);
+    }, SHARE_SETTLE_DELAY_MS);
+  }, [commitRuntimeViewport, paneId, sharePane]);
 
   useRemoteUiNode({
     role: "chart-data",
@@ -421,29 +448,6 @@ function ChartComposerSurface({
     }
     setResolution("auto");
   }, [availableResolutions, setResolution, spec.viewport.resolution]);
-  const openRangePicker = useCallback(async () => {
-    setInteractionCaptured("prompt", true);
-    try {
-      const range = await dialog.prompt<string>({
-        closeOnClickOutside: true,
-        content: (context: PromptContext<string>) => (
-          <ChoiceDialog
-            {...context}
-            title="Chart Range"
-            selectedChoiceId={spec.viewport.dateWindow ? undefined : spec.viewport.range}
-            choices={RANGES.map((value) => ({
-              id: value,
-              label: value,
-              description: `Show the latest ${value === "ALL" ? "available history" : value}.`,
-            }))}
-          />
-        ),
-      }).catch(() => "");
-      if (RANGES.includes(range as TimeRange)) setRange(range as TimeRange);
-    } finally {
-      setInteractionCaptured("prompt", false);
-    }
-  }, [dialog, setInteractionCaptured, setRange, spec.viewport.dateWindow, spec.viewport.range]);
   const openResolutionPicker = useCallback(async () => {
     setInteractionCaptured("prompt", true);
     try {
@@ -487,32 +491,9 @@ function ChartComposerSurface({
     (active: boolean) => setInteractionCaptured(QUICK_ADD_CAPTURE, active),
     [setInteractionCaptured],
   );
-  const openIndicators = useCallback((event?: PaneFooterPressEvent) => {
-    indicatorsDialogRef.current?.open(footerAnchorPoint(event));
-  }, []);
-  const openFormulas = useCallback((event?: PaneFooterPressEvent) => {
-    formulasDialogRef.current?.open(footerAnchorPoint(event));
-  }, []);
-  const currentActionsRef = useRef({
-    openSeriesEditor,
-    openResolutionPicker,
-    openRangePicker,
-    reload: resolution.reload,
-  });
-  currentActionsRef.current = {
-    openSeriesEditor,
-    openResolutionPicker,
-    openRangePicker,
-    reload: resolution.reload,
-  };
-  const footerSeries = useCallback(() => { void currentActionsRef.current.openSeriesEditor(); }, []);
-  const footerResolution = useCallback(() => { void currentActionsRef.current.openResolutionPicker(); }, []);
-  const footerReload = useCallback(() => { currentActionsRef.current.reload(); }, []);
-  const footerRange = useCallback(() => { void currentActionsRef.current.openRangePicker(); }, []);
-
   useShortcut((event) => {
     if (interactionCaptureRef.current || dialogOpen) return;
-    if (publicSharing && shareData && isPlainKey(event, "y")) {
+    if (publicSharing && isPlainKey(event, "y")) {
       event.preventDefault();
       event.stopPropagation();
       shareChart();
@@ -539,46 +520,77 @@ function ChartComposerSurface({
     }
   }, { enabled: focused && !dialogOpen });
 
+  const comparisonNotice = resolution.priceComparison?.notice;
+  const comparisonHasNoWindow = resolution.priceComparison?.start === null;
+  // A partial history seed cannot establish that the requested comparison failed.
+  const comparisonUnavailable = comparisonHasNoWindow && !resolution.loading
+    ? "Comparison unavailable: need two shared dates and a nonzero baseline."
+    : null;
+  const statusError = resolution.errors[0];
+  const spreadUnitError = spec.studies.some((study) => study.kind === "spread"
+    && statusError?.startsWith(`${study.id}: spread cannot subtract `)
+    && statusError.endsWith("; inputs require matching known units, currencies and scales."));
+  const statusErrorNotice = spreadUnitError
+    ? "Spread unavailable: incompatible or unknown units."
+    : 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;
+  const errorSeriesLabel = legendSeries?.find((entry) => entry.id === errorSeries?.id)?.label;
+  const duplicateErrorNotices = new Set([statusError, errorMessage,
+    errorSeriesLabel && errorMessage ? `${errorSeriesLabel}: ${errorMessage}` : undefined]);
+  // A failed shared window empties every compared leg; one comparison message explains it.
+  const comparisonEmptyNotices = new Set(comparisonHasNoWindow
+    ? resolution.legendSeries?.filter((entry) => resolution.priceComparison?.seriesIds.includes(entry.id))
+      .map((entry) => `${entry.label}: no observations in the selected date range.`)
+    : []);
+  const statusWarnings = resolution.warnings.filter((warning) => (
+    warning !== FINANCIAL_VINTAGE_NOTICE && warning !== SEC_EPS_BASIS_NOTICE && warning !== comparisonNotice
+    && !duplicateErrorNotices.has(warning) && !comparisonEmptyNotices.has(warning)
+    && !spec.studies.some((study) => (
+      (study.kind === "ratio" && warning.startsWith(`${study.id}: ratio inputs use different currencies (`)
+        && warning.endsWith("); raw values are not FX-converted."))
+      || (study.kind === "correlation" && warning.startsWith(`${study.id}: correlation mixes `)
+        && warning.endsWith("; only matching observation times contribute."))
+    ))
+  ));
+  const statusNotices = [...new Set([...(statusErrorNotice ? [statusErrorNotice] : []), ...(comparisonUnavailable ? [comparisonUnavailable] : []), ...statusWarnings])];
+  usePaneNoticeFooter({
+    registrationId: `${footerId}:notices`,
+    notices: statusNotices,
+    focused: shortcutActive,
+    title: "Chart data",
+  });
+
+  // Footer registrations compare presentation, so their callbacks must read current actions.
+  const currentActionsRef = useRef({ openSeriesEditor, shareChart });
+  currentActionsRef.current = { openSeriesEditor, shareChart };
+  const footerSeries = useCallback(() => { void currentActionsRef.current.openSeriesEditor(); }, []);
+  const footerShare = useCallback(() => { currentActionsRef.current.shareChart(); }, []);
+  const openIndicators = useCallback((event?: PaneFooterPressEvent) => {
+    indicatorsDialogRef.current?.open(footerAnchorPoint(event));
+  }, []);
+  const openFormulas = useCallback((event?: PaneFooterPressEvent) => {
+    formulasDialogRef.current?.open(footerAnchorPoint(event));
+  }, []);
+
   usePaneFooter(footerId, () => ({
-    info: [
-      ...(resolution.loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
-      ...(resolution.errors[0] ? [{ id: "error", parts: [{ text: resolution.errors[0], tone: "warning" as const }] }] : []),
-      ...(!resolution.errors[0] && resolution.warnings[0]
-        ? [{ id: "warning", parts: [{ text: resolution.warnings[0], tone: "warning" as const }] }]
-        : []),
-    ],
+    info: resolution.loading
+      ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }]
+      : [],
     hints: [
       { id: "series", key: "s", label: "eries", onPress: footerSeries },
       { id: "indicators", key: "i", label: "ndicators", onPress: openIndicators, disabled: indicatorsDisabled },
       { id: "formulas", key: "f", label: "ormulas", onPress: openFormulas, disabled: formulasDisabled },
-      { id: "resolution", key: "t", label: "imeframe", onPress: footerResolution },
-      { id: "range", key: "1-8", label: "range", onPress: footerRange },
-      ...(publicSharing
-        ? [{ id: "share", key: "y", label: " share", onPress: shareChart, disabled: !shareData }]
-        : []),
+      ...(publicSharing ? [{ id: "share", key: "y", label: " share", onPress: footerShare }] : []),
     ],
-  }), [
-    footerRange,
-    footerReload,
-    footerResolution,
-    footerSeries,
-    formulasDisabled,
-    indicatorsDisabled,
-    openFormulas,
-    openIndicators,
-    publicSharing,
-    shareChart,
-    shareData,
-    resolution.errors,
-    resolution.loading,
-    resolution.warnings,
-  ]);
+  }), [resolution.loading, footerSeries, openIndicators, indicatorsDisabled, openFormulas, formulasDisabled, publicSharing, footerShare]);
 
   const emptyMessage = spec.series.length === 0
     ? "Add a series to start the chart"
     : resolution.loading
       ? "Loading chart data"
-      : resolution.errors[0] ?? "No observations in this range";
+      : statusErrorNotice ?? comparisonUnavailable ?? "No observations in this range";
 
   return (
     <Box flexDirection="column" width={width} height={height} backgroundColor={colors.panel}>
@@ -654,7 +666,6 @@ function ChartComposerSurface({
         onOpenChange={setFormulasOpen}
         renderTrigger={() => null}
       />
-
       <Box flexGrow={1} minHeight={4}>
         <CompositeChart
           series={plottedSeries}
@@ -662,6 +673,7 @@ function ChartComposerSurface({
           timelineSeries={resolution.timelineSeries}
           panels={spec.panels}
           viewport={viewport}
+          clipToViewport={!!spec.viewport.dateWindow}
           viewportResetKey={authoredViewportKey}
           width={Math.max(1, width)}
           height={Math.max(4, height - 1)}
@@ -715,22 +727,9 @@ export function ChartComposerPane({ paneId, focused, width, height }: PaneProps)
   );
 }
 
-function firstChartSecuritySymbol(spec: ChartSpec): string | null {
-  for (const entry of spec.series) {
-    if (entry.source.kind === "security") return entry.source.instrument.symbol;
-  }
-  return null;
-}
-
-function specHasSecuritySymbol(spec: ChartSpec, symbol: string | null | undefined): boolean {
-  if (!symbol) return false;
-  return spec.series.some((entry) => (
-    entry.source.kind === "security" && entry.source.instrument.symbol === symbol
-  ));
-}
-
 export function ChartComposerResearchTab({ focused, width, height, onCapture }: TickerResearchTabProps) {
-  const { symbol } = usePaneTicker();
+  const { symbol: paneSymbol, ticker } = usePaneTicker();
+  const symbol = paneSymbol ? publicTickerKey(paneSymbol, ticker?.metadata.exchange) : null;
   const fallback = useMemo(() => symbol ? buildPriceChartPreset(symbol) : buildEmptyChartPreset(), [symbol]);
   const [storedSpec, setStoredSpec] = usePaneSettingValue<unknown>(CHART_SPEC_SETTING_KEY, fallback);
   const spec = useMemo(() => parseChartSpecOr(storedSpec, fallback), [fallback, storedSpec]);
@@ -738,15 +737,7 @@ export function ChartComposerResearchTab({ focused, width, height, onCapture }:
 
   useEffect(() => {
     if (!symbol) return;
-    const previousSymbol = previousSymbolRef.current;
-    const fromSymbol = specHasSecuritySymbol(spec, previousSymbol)
-      ? previousSymbol
-      : firstChartSecuritySymbol(spec) ?? previousSymbol;
-    if (!fromSymbol || fromSymbol === symbol) {
-      previousSymbolRef.current = symbol;
-      return;
-    }
-    const rebound = rebindChartSecuritySymbol(spec, fromSymbol, symbol);
+    const rebound = rebindResearchChartSpec(spec, previousSymbolRef.current, symbol);
     if (rebound !== spec) setStoredSpec(rebound);
     previousSymbolRef.current = symbol;
   }, [setStoredSpec, spec, symbol]);

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

@@ -22,6 +22,7 @@ import {
   parseChartExpression,
   parseSeriesExpression,
   rebindChartSecuritySymbol,
+  rebindResearchChartSpec,
   resolveChartFieldAlias,
   setBuiltinStudies,
   setPairStudies,
@@ -202,6 +203,17 @@ describe("chart composer expressions", () => {
       .toThrow('Invalid chart series "MSFT:revenu"');
   });
 
+  test("preserves futures and forex identifiers in direct and custom chart presets", () => {
+    for (const symbol of ["ES=F", "6J=F", "JPY=X", "EURUSD=X", "EUR/USD"]) {
+      const spec = buildPriceChartPreset(symbol);
+      expect(spec.series[0]?.source).toMatchObject({ kind: "security", instrument: { symbol } });
+      expect(parseSeriesExpression(formatSeriesExpression(spec.series[0]!)))
+        .toMatchObject({ kind: "security", symbol });
+      expect(buildCustomChartPreset(`${symbol}:price`).series[0]?.source)
+        .toMatchObject({ kind: "security", instrument: { symbol } });
+    }
+  });
+
   test("parses exchange-qualified tickers without confusing the exchange for a field", () => {
     const spec = buildCustomChartPreset("3hnx:lse, 3HNX:LSE:revenue");
 
@@ -406,6 +418,40 @@ describe("chart composer presets and formulas", () => {
     expect(rebound.series[1]).toEqual(customized.series[1]);
   });
 
+  test("research follows the exact listing while preserving other venues and authored chart state", () => {
+    for (const [previous, next, exchange] of [["ASML:XAMS", "ASML:NASDAQ", "NASDAQ"], ["ASML:XNAS", "ASML:AMS", "AMS"]]) {
+      const comparison = buildComparisonChartPreset([previous!, next!, "SPY:ARCX"]);
+      const customized = setBuiltinStudies({ ...comparison,
+        viewport: { range: "3M", resolution: "1h" },
+        series: comparison.series.map((entry, index) => ({ ...entry, label: index === 0 ? "My primary listing" : entry.label })),
+      }, ["sma20"]);
+      const rebound = rebindResearchChartSpec(customized, previous!, next!);
+      expect(rebound.series[0]).toMatchObject({ id: customized.series[0]!.id, label: "My primary listing", transform: "percent",
+        source: { instrument: { symbol: "ASML", exchange } } });
+      expect(rebound.series.slice(1)).toEqual(customized.series.slice(1));
+      expect(rebound.viewport).toEqual(customized.viewport);
+      expect(rebound.panels).toEqual(customized.panels);
+      expect(rebound.studies).toEqual(customized.studies);
+    }
+  });
+
+  test("research repairs a persisted qualified primary once and keeps equivalent aliases unchanged", () => {
+    const stored = buildPriceChartPreset("ASML:XAMS");
+    const restored = rebindResearchChartSpec(stored, "ASML:XNAS", "ASML:XNAS");
+    expect(restored.series[0]?.source).toMatchObject({ instrument: { symbol: "ASML", exchange: "NASDAQ" } });
+    expect(rebindResearchChartSpec(restored, "ASML:XNAS", "ASML:NASDAQ")).toBe(restored);
+    expect(rebindResearchChartSpec(stored, "ASML:XAMS", "ASML:AMS")).toBe(stored);
+    const labelled = { ...stored, series: stored.series.map((entry) => ({ ...entry, label: "ASML:XAMS" })) };
+    expect(rebindResearchChartSpec(labelled, "ASML:AMS", "ASML:XNAS").series[0]?.label).toBe("ASML:XNAS");
+  });
+
+  test("a restored target or economic-only chart does not replace unrelated comparisons", () => {
+    const comparison = buildComparisonChartPreset(["SPY:ARCX", "ASML:XNAS"]);
+    expect(rebindResearchChartSpec(comparison, "ASML:XAMS", "ASML:NASDAQ")).toBe(comparison);
+    const economic = buildCustomChartPreset("FRED:CPIAUCSL");
+    expect(rebindResearchChartSpec(economic, "ASML:XAMS", "ASML:XNAS")).toBe(economic);
+  });
+
   test("binds pair formulas to the first two visible series after reordering", () => {
     const comparison = buildComparisonChartPreset(["AAPL", "MSFT", "NVDA"]);
     const withFormulas = setPairStudies(comparison, ["ratio", "correlation"]);

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

@@ -65,7 +65,7 @@ export type ParsedSeriesExpression =
 
 function normalizeBaseSymbol(value: string): string | null {
   const symbol = value.trim().toUpperCase();
-  return /^[A-Z0-9^][A-Z0-9.^_-]{0,31}$/.test(symbol) ? symbol : null;
+  return /^[A-Z0-9^][A-Z0-9.^_/=-]{0,31}$/.test(symbol) ? symbol : null;
 }
 
 function normalizeInstrument(
@@ -664,6 +664,26 @@ export function rebindChartSecuritySymbol(spec: ChartSpec, previous: string, nex
   return changed ? { ...spec, series } : spec;
 }
 
+/** Follow the research listing, including its venue, while keeping comparisons. */
+export function rebindResearchChartSpec(spec: ChartSpec, previous: string | null, next: string | null): ChartSpec {
+  const nextInstrument = next ? normalizeInstrument(next, true) : null;
+  if (!nextInstrument) return spec;
+  const previousInstrument = previous ? normalizeInstrument(previous, true) : null;
+  const previousKey = previousInstrument && publicTickerKey(previousInstrument.symbol, previousInstrument.exchange);
+  const nextKey = publicTickerKey(nextInstrument.symbol, nextInstrument.exchange);
+  const securityKeys = spec.series.flatMap((entry) => entry.source.kind === "security"
+    ? [publicTickerKey(entry.source.instrument.symbol, entry.source.instrument.exchange)]
+    : []);
+  if (previousKey && securityKeys.includes(previousKey)) {
+    return rebindChartSecuritySymbol(spec, previousKey, nextKey);
+  }
+  // A restored chart can already contain the target after its old context was
+  // lost. Do not replace an unrelated first comparison in that case.
+  if (securityKeys.includes(nextKey)) return spec;
+  const primary = securityKeys[0];
+  return primary ? rebindChartSecuritySymbol(spec, primary, nextKey) : spec;
+}
+
 export function buildIntradayPriceChartPreset(symbol: string): ChartSpec {
   const normalized = normalizeInstrument(symbol, true);
   if (!normalized) return buildEmptyChartPreset();
@@ -786,18 +806,26 @@ export function setPairStudies(spec: ChartSpec, selected: readonly PairStudySele
   const pairStudies: ChartStudySpec[] = inputs.length === 2
     ? (["ratio", "spread", "correlation"] as PairStudySelection[])
       .filter((kind) => selectedSet.has(kind))
-      .map((kind): ChartStudySpec => ({
-        id: `${PAIR_STUDY_ID_PREFIX}${kind}`,
-        kind,
-        inputSeriesIds: inputs.map((series) => series.id),
-        parameters: kind === "spread"
-          ? { multiplier: 1 }
-          : kind === "correlation"
-            ? { period: 20, returns: 1 }
-            : {},
-        panelId: kind === "correlation" ? "correlation" : "formula",
-        axis: "auto",
-      }))
+      .map((kind): ChartStudySpec => {
+        const id = `${PAIR_STUDY_ID_PREFIX}${kind}`;
+        const inputSeriesIds = inputs.map((series) => series.id);
+        const previous = spec.studies.find((study) => study.id === id && study.kind === kind
+          && study.inputSeriesIds.length === inputSeriesIds.length
+          && study.inputSeriesIds.every((inputId, index) => inputId === inputSeriesIds[index]));
+        if (previous) return { ...previous, inputSeriesIds, parameters: { ...previous.parameters } };
+        return {
+          id,
+          kind,
+          inputSeriesIds,
+          parameters: kind === "spread"
+            ? { multiplier: 1 }
+            : kind === "correlation"
+              ? { period: 20, returns: 1 }
+              : {},
+          panelId: kind === "correlation" ? "correlation" : "formula",
+          axis: "auto",
+        };
+      })
     : [];
   const studies: ChartStudySpec[] = [
     ...spec.studies.filter((study) => !study.id.startsWith(PAIR_STUDY_ID_PREFIX)),

package/src/plugins/builtin/chart-composer/quick-add.tsx

@@ -203,7 +203,13 @@ export function ChartSeriesQuickAdd({
 
   useEffect(() => {
     setSelectedIndex(0);
-  }, [query, suggestions.length]);
+  }, [query]);
+
+  // Plugin catalogs land after the securities: only pull a stranded cursor
+  // back into range, so a row the user already moved to stays selected.
+  useEffect(() => {
+    setSelectedIndex((current) => clampSelection(current, suggestions.length));
+  }, [suggestions.length]);
 
   useEffect(() => {
     if (focused || !active) return;