gloomberb 0.9.1 → 0.9.3

package/src/components/chart/comparison-stock-chart/render-data.ts

@@ -3,7 +3,8 @@ import {
   DEFAULT_LIVE_CHART_REFRESH_INTERVAL_MS,
   useChartQueries,
 } from "../../../market-data/hooks";
-import { buildChartKey } from "../../../market-data/selectors";
+import type { ChartRequest, InstrumentRef } from "../../../market-data/request-types";
+import { buildChartKey, resolveEntryData } from "../../../market-data/selectors";
 import { getSharedMarketData } from "../../../plugins/registry";
 import { blendHex, colors, getComparisonSeriesColor } from "../../../theme/colors";
 import type { BrokerContractRef } from "../../../types/instrument";
@@ -24,6 +25,8 @@ import type {
   ComparisonChartViewState,
 } from "../core/types";
 
+const COMPARISON_PERFORMANCE_RANGE = "5Y" as const;
+
 export interface ComparisonChartSymbolSource {
   symbol: string;
   currency: string | undefined;
@@ -40,6 +43,16 @@ interface UseComparisonChartRenderDataOptions {
   viewState: ComparisonChartViewState;
 }
 
+function instrumentFromSymbolSource(source: ComparisonChartSymbolSource): InstrumentRef {
+  return {
+    symbol: source.symbol,
+    exchange: source.exchange,
+    brokerId: source.brokerId,
+    brokerInstanceId: source.brokerInstanceId,
+    instrument: source.instrument,
+  };
+}
+
 export function useComparisonChartRenderData({
   symbolSources,
   viewState,
@@ -143,21 +156,25 @@ export function useComparisonChartRenderData({
   );
   const chartRequests = useMemo(() => (
     symbolSources.map((source) => ({
-      instrument: {
-        symbol: source.symbol,
-        exchange: source.exchange,
-        brokerId: source.brokerId,
-        brokerInstanceId: source.brokerInstanceId,
-        instrument: source.instrument,
-      },
+      instrument: instrumentFromSymbolSource(source),
       bufferRange: viewState.bufferRange,
       granularity: effectiveResolution === "auto" ? "range" as const : "resolution" as const,
       resolution: effectiveResolution === "auto" ? undefined : effectiveResolution,
     }))
   ), [effectiveResolution, symbolSources, viewState.bufferRange]);
+  const performanceRequests = useMemo<ChartRequest[]>(() => (
+    symbolSources.map((source) => ({
+      instrument: instrumentFromSymbolSource(source),
+      bufferRange: COMPARISON_PERFORMANCE_RANGE,
+      granularity: "range",
+    }))
+  ), [symbolSources]);
   const chartEntries = useChartQueries(chartRequests, {
     refreshIntervalMs: DEFAULT_LIVE_CHART_REFRESH_INTERVAL_MS,
   });
+  const performanceEntries = useChartQueries(performanceRequests, {
+    refreshIntervalMs: DEFAULT_LIVE_CHART_REFRESH_INTERVAL_MS,
+  });
   const entryStates = useMemo(() => chartRequests.map((request) => (
     resolveChartBodyState(chartEntries.get(buildChartKey(request)), (value) => Array.isArray(value) && value.length > 0, "No chart data yet.")
   )), [chartEntries, chartRequests]);
@@ -182,6 +199,17 @@ export function useComparisonChartRenderData({
       points,
     };
   }), [chartEntries, chartRequests, symbolSources]);
+  const performanceHistoryBySymbol = useMemo(() => {
+    const bySymbol = new Map<string, PricePoint[]>();
+    symbolSources.forEach((source, index) => {
+      const request = performanceRequests[index];
+      const history = request ? resolveEntryData(performanceEntries.get(buildChartKey(request))) : null;
+      if (history?.length) {
+        bySymbol.set(source.symbol, history);
+      }
+    });
+    return bySymbol;
+  }, [performanceEntries, performanceRequests, symbolSources]);
 
   return {
     availableManualResolutions,
@@ -192,6 +220,7 @@ export function useComparisonChartRenderData({
     isUpdating,
     resolutionChips,
     selectionSupportMap,
+    performanceHistoryBySymbol,
     series,
     supportMap,
   };

package/src/components/chart/comparison-stock-chart/selection-runtime.ts

@@ -1,6 +1,7 @@
-import { useEffect, useRef, type Dispatch, type MutableRefObject, type SetStateAction } from "react";
+import { useCallback, useEffect, useRef, type Dispatch, type MutableRefObject, type SetStateAction } from "react";
 import type { BoxRenderable, NativeRendererHost } from "../../../ui";
-import { buildDisplayCursorState } from "../core/pointer";
+import { useAppDispatch, usePaneInstanceId } from "../../../state/app/context";
+import { buildDisplayCursorState, type MouseInteractionEvent } from "../core/pointer";
 import type { ComparisonChartViewState } from "../core/types";
 import { useChartDisplayCursor, useChartDisplayCursorLayoutRemap } from "../display-cursor";
 import { clamp } from "./helpers";
@@ -10,6 +11,7 @@ interface UseComparisonChartSelectionRuntimeOptions {
   chartWidth: number;
   cursorX: number | null;
   cursorY: number | null;
+  focused: boolean;
   renderer: NativeRendererHost;
   setViewState: Dispatch<SetStateAction<ComparisonChartViewState>>;
   symbols: string[];
@@ -20,6 +22,7 @@ export function useComparisonChartSelectionRuntime({
   chartWidth,
   cursorX: viewCursorX,
   cursorY: viewCursorY,
+  focused,
   renderer,
   setViewState,
   symbols,
@@ -28,6 +31,7 @@ export function useComparisonChartSelectionRuntime({
   displayCursor: ReturnType<typeof useChartDisplayCursor>["displayCursor"];
   displayCursorX: number | null;
   displayCursorY: number | null;
+  focusPaneForMouseInteraction: (event: MouseInteractionEvent | null | undefined) => void;
   mouseCrosshairDisabledRef: MutableRefObject<boolean>;
   plotRef: MutableRefObject<BoxRenderable | null>;
   scrollPanCellRemainderRef: MutableRefObject<number>;
@@ -35,6 +39,8 @@ export function useComparisonChartSelectionRuntime({
   setSelectedSymbol: (symbol: string) => void;
   updateDisplayCursorTarget: ReturnType<typeof useChartDisplayCursor>["updateDisplayCursorTarget"];
 } {
+  const dispatch = useAppDispatch();
+  const paneId = usePaneInstanceId();
   const plotRef = useRef<BoxRenderable | null>(null);
   const mouseCrosshairDisabledRef = useRef(false);
   const scrollPanCellRemainderRef = useRef(0);
@@ -52,6 +58,16 @@ export function useComparisonChartSelectionRuntime({
   const displayCursorX = displayCursor.cellX !== null ? clamp(displayCursor.cellX, 0, chartWidth - 1) : null;
   const displayCursorY = displayCursor.cellY !== null ? clamp(displayCursor.cellY, 0, chartHeight - 1) : null;
 
+  const focusPaneForMouseInteraction = useCallback((
+    event: MouseInteractionEvent | null | undefined,
+  ) => {
+    event?.stopPropagation?.();
+    event?.preventDefault?.();
+    if (!focused) {
+      dispatch({ type: "FOCUS_PANE", paneId });
+    }
+  }, [dispatch, focused, paneId]);
+
   const setSelectedSymbol = (symbol: string) => {
     setViewState((current) => (
       current.selectedSymbol === symbol
@@ -101,6 +117,7 @@ export function useComparisonChartSelectionRuntime({
     displayCursor,
     displayCursorX,
     displayCursorY,
+    focusPaneForMouseInteraction,
     mouseCrosshairDisabledRef,
     plotRef,
     scrollPanCellRemainderRef,

package/src/components/chart/comparison-stock-chart/sources.ts

@@ -24,17 +24,21 @@ export function useComparisonChartSymbolSources(symbols: string[]): {
   const marketFinancials = useTickerFinancialsMap(stableTickers);
   const symbolSources = useMemo<ComparisonChartSymbolSource[]>(() => stableSymbols.map((symbol) => {
     const ticker = tickers.get(symbol) ?? null;
-    const financial = marketFinancials.get(symbol) ?? financials.get(symbol) ?? null;
+    const marketFinancial = marketFinancials.get(symbol) ?? null;
+    const storedFinancial = financials.get(symbol) ?? null;
     const instrument = ticker?.metadata.broker_contracts?.[0] ?? null;
+    const quote = marketFinancial?.quote ?? storedFinancial?.quote;
     return {
       symbol,
-      currency: financial?.quote?.currency ?? ticker?.metadata.currency,
-      quote: financial?.quote,
+      currency: quote?.currency ?? ticker?.metadata.currency,
+      quote,
       exchange: ticker?.metadata.exchange ?? "",
       brokerId: instrument?.brokerId,
       brokerInstanceId: instrument?.brokerInstanceId,
       instrument,
-      priceHistory: financial?.priceHistory ?? [],
+      priceHistory: marketFinancial?.priceHistory?.length
+        ? marketFinancial.priceHistory
+        : storedFinancial?.priceHistory ?? [],
     };
   }), [financials, marketFinancials, stableSymbols, tickers]);
 

package/src/components/chart/comparison-stock-chart/toolbar.tsx

@@ -12,6 +12,7 @@ import {
   type ComparisonChartRenderMode,
   type TimeRange,
 } from "../core/types";
+import type { MouseInteractionEvent } from "../core/pointer";
 
 const MODE_CHIPS: Record<ComparisonChartRenderMode, string> = {
   area: "A",
@@ -22,6 +23,7 @@ interface ComparisonChartToolbarProps {
   activePreset: TimeRange | null;
   availableManualResolutions: ManualChartResolution[];
   effectiveResolution: ChartResolution;
+  focusPaneForMouseInteraction: (event: MouseInteractionEvent | null | undefined) => void;
   isUpdating: boolean;
   onRangeSelect: (range: TimeRange) => void;
   onRenderModeSelect: (mode: ComparisonChartRenderMode) => void;
@@ -36,6 +38,7 @@ export function ComparisonChartToolbar({
   activePreset,
   availableManualResolutions,
   effectiveResolution,
+  focusPaneForMouseInteraction,
   isUpdating,
   onRangeSelect,
   onRenderModeSelect,
@@ -54,7 +57,8 @@ export function ComparisonChartToolbar({
               key={range}
               fg={activePreset === range ? colors.textBright : (isRangePresetSupported(range, availableManualResolutions) ? colors.textDim : colors.textMuted)}
               attributes={activePreset === range ? TextAttributes.BOLD : 0}
-              onMouseDown={() => {
+              onMouseDown={(event: any) => {
+                focusPaneForMouseInteraction(event);
                 if (isRangePresetSupported(range, availableManualResolutions)) {
                   onRangeSelect(range);
                 }
@@ -73,7 +77,10 @@ export function ComparisonChartToolbar({
               key={resolution}
               fg={effectiveResolution === resolution ? colors.textBright : colors.textDim}
               attributes={effectiveResolution === resolution ? TextAttributes.BOLD : 0}
-              onMouseDown={() => onResolutionSelect(resolution)}
+              onMouseDown={(event: any) => {
+                focusPaneForMouseInteraction(event);
+                onResolutionSelect(resolution);
+              }}
             >
               {getChartResolutionLabel(resolution)}
             </Text>
@@ -89,7 +96,10 @@ export function ComparisonChartToolbar({
               key={mode}
               fg={renderMode === mode ? colors.textBright : colors.textDim}
               attributes={renderMode === mode ? TextAttributes.BOLD : 0}
-              onMouseDown={() => onRenderModeSelect(mode)}
+              onMouseDown={(event: any) => {
+                focusPaneForMouseInteraction(event);
+                onRenderModeSelect(mode);
+              }}
             >
               {MODE_CHIPS[mode]}
             </Text>

package/src/components/chart/comparison-stock-chart/view.tsx

@@ -5,6 +5,11 @@ import { blendHex, colors } from "../../../theme/colors";
 import { useThemeColors } from "../../../theme/theme-context";
 import { usePaneSettingValue } from "../../../state/app/context";
 import { useQuoteStreaming } from "../../../state/hooks/quote-streaming";
+import {
+  appendQuoteToPriceReturnHistory,
+  buildPriceReturnFields,
+  type PriceReturnField,
+} from "../../../market-data/performance";
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import {
   type ChartRendererPreference,
@@ -170,6 +175,27 @@ function useComparisonChartQuoteStreaming({
   useQuoteStreaming(streamingTargets);
 }
 
+function getOneYearReturn(fields: readonly PriceReturnField[]): number | null {
+  return fields.find((field) => field.id === "1Y")?.value ?? null;
+}
+
+function sortSymbolsByOneYearReturn(
+  symbols: readonly string[],
+  performanceBySymbol: ReadonlyMap<string, PriceReturnField[]>,
+): string[] {
+  const originalIndex = new Map(symbols.map((symbol, index) => [symbol, index]));
+  return [...symbols].sort((left, right) => {
+    const leftReturn = getOneYearReturn(performanceBySymbol.get(left) ?? []);
+    const rightReturn = getOneYearReturn(performanceBySymbol.get(right) ?? []);
+    if (leftReturn != null && rightReturn != null && leftReturn !== rightReturn) {
+      return rightReturn - leftReturn;
+    }
+    if (leftReturn != null && rightReturn == null) return -1;
+    if (leftReturn == null && rightReturn != null) return 1;
+    return (originalIndex.get(left) ?? 0) - (originalIndex.get(right) ?? 0);
+  });
+}
+
 function ComparisonStockChartView({
   paneId,
   width,
@@ -244,12 +270,33 @@ function ComparisonStockChartView({
     isUpdating,
     resolutionChips,
     selectionSupportMap,
+    performanceHistoryBySymbol,
     series,
     supportMap,
   } = useComparisonChartRenderData({
     symbolSources,
     viewState,
   });
+  const performanceBySymbol = useMemo(() => {
+    const bySymbol = new Map<string, PriceReturnField[]>();
+    for (const source of symbolSources) {
+      const baselineHistory = performanceHistoryBySymbol.get(source.symbol) ?? [];
+      const sourceHistory = appendQuoteToPriceReturnHistory(
+        baselineHistory.length >= 2 ? baselineHistory : source.priceHistory,
+        source.quote,
+      );
+      const fallbackHistory = series.find((entry) => entry.symbol === source.symbol)?.points ?? [];
+      bySymbol.set(
+        source.symbol,
+        buildPriceReturnFields(sourceHistory.length >= 2 ? sourceHistory : fallbackHistory),
+      );
+    }
+    return bySymbol;
+  }, [performanceHistoryBySymbol, series, symbolSources]);
+  const summarySymbols = useMemo(
+    () => sortSymbolsByOneYearReturn(symbols, performanceBySymbol),
+    [performanceBySymbol, symbols],
+  );
 
   useEffect(() => {
     if (symbols.includes(viewState.selectedSymbol ?? "")) return;
@@ -298,6 +345,7 @@ function ComparisonStockChartView({
     displayCursor,
     displayCursorX,
     displayCursorY,
+    focusPaneForMouseInteraction,
     mouseCrosshairDisabledRef,
     plotRef,
     scrollPanCellRemainderRef,
@@ -309,9 +357,10 @@ function ComparisonStockChartView({
     chartWidth,
     cursorX: viewState.cursorX,
     cursorY: viewState.cursorY,
+    focused,
     renderer,
     setViewState,
-    symbols,
+    symbols: summarySymbols,
   });
   const {
     activePreset,
@@ -352,7 +401,6 @@ function ComparisonStockChartView({
     result,
     staticScene,
     timeAxisLabel,
-    visiblePriceRange,
   } = useComparisonChartRenderOutput({
     axisMode,
     chartColors,
@@ -386,7 +434,7 @@ function ComparisonStockChartView({
     setResolution,
     setViewState,
     supportMap,
-    symbols,
+    symbols: summarySymbols,
     updateDisplayCursorTarget,
     viewState,
     visibleDateWindow,
@@ -403,6 +451,7 @@ function ComparisonStockChartView({
     chartWidth,
     commitSelectionCursor,
     expandBufferRange,
+    focusPaneForMouseInteraction,
     mouseCrosshairDisabledRef,
     plotRef,
     pointCount: projection.dates.length,
@@ -479,15 +528,15 @@ function ComparisonStockChartView({
       legend={(
         <ComparisonChartLegend
           legendActiveIndex={legendActiveIndex}
-          legendColumns={legendColumns}
           legendItemWidth={legendItemWidth}
           legendRows={legendRows}
+          onFocusInteraction={focusPaneForMouseInteraction}
           onOpenSymbol={onOpenSymbol}
           onSelectSymbol={setSelectedSymbol}
+          performanceBySymbol={performanceBySymbol}
           projection={projection}
           selectedSymbol={viewState.selectedSymbol}
-          symbols={symbols}
-          visiblePriceRange={visiblePriceRange}
+          symbols={summarySymbols}
         />
       )}
       plotBitmaps={plotBitmaps}
@@ -502,6 +551,7 @@ function ComparisonStockChartView({
           activePreset={activePreset}
           availableManualResolutions={availableManualResolutions}
           effectiveResolution={effectiveResolution}
+          focusPaneForMouseInteraction={focusPaneForMouseInteraction}
           isUpdating={isUpdating}
           onRangeSelect={setRangePreset}
           onRenderModeSelect={(mode) => setViewState((current) => ({ ...current, renderMode: mode }))}

package/src/components/chart/core/pane-settings.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, test } from "bun:test";
+import {
+  createDefaultConfig,
+  findPaneInstance,
+} from "../../../types/config";
 import {
   consumeStoredChartSelectionChange,
+  createChartRenderModeConfig,
   createStoredChartSelectionSyncState,
   markStoredChartSelectionLocallyApplied,
 } from "./pane-settings";
@@ -22,4 +27,26 @@ describe("chart pane setting sync", () => {
     expect(consumeStoredChartSelectionChange(state, "5Y", "1wk")).toBe(true);
     expect(state.lastAppliedKey).toBe("5Y:1wk");
   });
+
+  test("persists chart render mode as both pane state and global default", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-chart-mode-test");
+
+    const nextConfig = createChartRenderModeConfig({
+      activePanel: "right",
+      config,
+      focusedPaneId: "ticker-detail:main",
+      paneState: {},
+    }, "ticker-detail:main", "candles");
+
+    expect(nextConfig.chartPreferences.defaultRenderMode).toBe("candles");
+    expect(findPaneInstance(nextConfig.layout, "ticker-detail:main")?.settings).toMatchObject({
+      chartRangePreset: "5Y",
+      chartRenderMode: "candles",
+      chartResolution: "auto",
+    });
+    expect(findPaneInstance(
+      nextConfig.layouts[nextConfig.activeLayoutIndex]!.layout,
+      "ticker-detail:main",
+    )?.settings?.chartRenderMode).toBe("candles");
+  });
 });

package/src/components/chart/core/pane-settings.ts

@@ -7,7 +7,18 @@ import {
   syncConfigActiveLayoutState,
 } from "../../../state/app/context";
 import { scheduleConfigSave } from "../../../state/config-save-scheduler";
-import type { ChartResolution, TimeRange } from "./types";
+import {
+  findPaneInstance,
+  type AppConfig,
+} from "../../../types/config";
+import type { ChartRenderMode, ChartResolution, TimeRange } from "./types";
+
+interface ChartRenderModePersistenceState {
+  activePanel: "left" | "right";
+  config: AppConfig;
+  focusedPaneId: string | null;
+  paneState: Record<string, Record<string, unknown>>;
+}
 
 export interface StoredChartSelectionSyncState {
   lastAppliedKey: string;
@@ -80,3 +91,51 @@ export function usePersistChartControlSelection(rangePresetKey: string): (
     scheduleConfigSave(nextConfig);
   };
 }
+
+export function createChartRenderModeConfig(
+  currentState: ChartRenderModePersistenceState,
+  paneId: string,
+  renderMode: ChartRenderMode,
+): AppConfig {
+  const currentPane = findPaneInstance(currentState.config.layout, paneId);
+  const layout = currentPane
+    ? setPaneSettings(currentState.config.layout, paneId, {
+        ...(currentPane.settings ?? {}),
+        chartRenderMode: renderMode,
+      })
+    : currentState.config.layout;
+  return syncConfigActiveLayoutState(
+    {
+      ...currentState.config,
+      chartPreferences: {
+        ...currentState.config.chartPreferences,
+        defaultRenderMode: renderMode,
+      },
+      layout,
+    },
+    currentState.paneState,
+    currentState.focusedPaneId,
+    currentState.activePanel,
+  );
+}
+
+export function usePersistChartRenderMode(): (renderMode: ChartRenderMode) => void {
+  const dispatch = useAppDispatch();
+  const stateRef = useAppStateRef();
+  const paneId = usePaneInstanceId();
+
+  return (renderMode) => {
+    const currentState = stateRef.current;
+    const currentPane = findPaneInstance(currentState.config.layout, paneId);
+    if (
+      currentState.config.chartPreferences.defaultRenderMode === renderMode
+      && currentPane?.settings?.chartRenderMode === renderMode
+    ) {
+      return;
+    }
+
+    const nextConfig = createChartRenderModeConfig(currentState, paneId, renderMode);
+    dispatch({ type: "SET_CONFIG", config: nextConfig });
+    scheduleConfigSave(nextConfig);
+  };
+}

package/src/components/chart/core/pointer.ts

@@ -31,6 +31,8 @@ export interface ChartMouseEvent {
   };
 }
 
+export type MouseInteractionEvent = Pick<ChartMouseEvent, "stopPropagation" | "preventDefault">;
+
 export function consumeChartMouseEvent(event: Pick<ChartMouseEvent, "stopPropagation" | "preventDefault">): void {
   event.stopPropagation?.();
   event.preventDefault?.();

package/src/components/chart/stock-chart/resolved/runtime.ts

@@ -221,12 +221,12 @@ export function useResolvedStockChartRuntime({
     pendingCanonicalResetRef: interactionRuntime.pendingCanonicalResetRef,
     pendingExpansionRef: interactionRuntime.pendingExpansionRef,
     persistChartControls: settings.persistChartControls,
+    persistChartRenderMode: settings.persistChartRenderMode,
     renderedResolution: dataRuntime.renderedResolution,
     selectionSupportMap: resolutionRuntime.selectionSupportMap,
     setPendingAutoWindowOverride: dataRuntime.setPendingAutoWindowOverride,
     setRenderedAutoView: dataRuntime.setRenderedAutoView,
     setRequestedResolution: settings.setRequestedResolution,
-    setStoredRenderMode: settings.setStoredRenderMode,
     setViewState: settings.setViewState,
     storedRangePreset: settings.storedRangePreset,
     storedRenderMode: settings.storedRenderMode,

package/src/components/chart/stock-chart/settings.ts

@@ -3,7 +3,10 @@ import {
   usePaneInstance,
   usePaneSettingValue,
 } from "../../../state/app/context";
-import { usePersistChartControlSelection } from "../core/pane-settings";
+import {
+  usePersistChartControlSelection,
+  usePersistChartRenderMode,
+} from "../core/pane-settings";
 import type { IndicatorConfig } from "../indicators/types";
 import {
   DEFAULT_TICKER_CHART_RANGE_PRESET,
@@ -30,8 +33,9 @@ export function useStockChartSettings({
   const pane = usePaneInstance();
   const [storedRangePreset] = usePaneSettingValue("chartRangePreset", DEFAULT_TICKER_CHART_RANGE_PRESET);
   const [storedResolution] = usePaneSettingValue<ChartResolution>("chartResolution", DEFAULT_TICKER_CHART_RESOLUTION);
-  const [storedRenderMode, setStoredRenderMode] = usePaneSettingValue<ChartRenderMode>("chartRenderMode", defaultRenderMode);
+  const [storedRenderMode] = usePaneSettingValue<ChartRenderMode>("chartRenderMode", defaultRenderMode);
   const persistChartControls = usePersistChartControlSelection("chartRangePreset");
+  const persistChartRenderMode = usePersistChartRenderMode();
   const [viewState, setViewState] = useState<StockChartViewportState>({
     presetRange: compact ? "1Y" : storedRangePreset,
     bufferRange: compact ? "1Y" : storedRangePreset,
@@ -67,7 +71,7 @@ export function useStockChartSettings({
     persistChartControls,
     requestedResolution,
     setRequestedResolution,
-    setStoredRenderMode,
+    persistChartRenderMode,
     setViewState,
     storedRangePreset,
     storedRenderMode,

package/src/components/chart/stock-chart/viewport/runtime.ts

@@ -67,10 +67,10 @@ interface UseStockChartViewportRuntimeOptions {
   persistChartControls: (range: TimeRange, resolution: ChartResolution) => void;
   renderedResolution: ChartResolution;
   selectionSupportMap: ReadonlyMap<ManualChartResolution, TimeRange>;
+  persistChartRenderMode: (mode: ChartRenderMode) => void;
   setPendingAutoWindowOverride: Dispatch<SetStateAction<DateWindowRange | null>>;
   setRenderedAutoView: Dispatch<SetStateAction<AutoRenderedView | null>>;
   setRequestedResolution: Dispatch<SetStateAction<ChartResolution>>;
-  setStoredRenderMode: Dispatch<SetStateAction<ChartRenderMode>>;
   setViewState: Dispatch<SetStateAction<StockChartViewportState>>;
   storedRangePreset: TimeRange;
   storedRenderMode: ChartRenderMode;
@@ -101,12 +101,12 @@ export function useStockChartViewportRuntime({
   pendingCanonicalResetRef,
   pendingExpansionRef,
   persistChartControls,
+  persistChartRenderMode,
   renderedResolution,
   selectionSupportMap,
   setPendingAutoWindowOverride,
   setRenderedAutoView,
   setRequestedResolution,
-  setStoredRenderMode,
   setViewState,
   storedRangePreset,
   storedRenderMode,
@@ -172,10 +172,10 @@ export function useStockChartViewportRuntime({
   });
 
   const persistRenderMode = useCallback((nextMode: ChartRenderMode) => {
-    if (!compact && nextMode !== storedRenderMode) {
-      setStoredRenderMode(nextMode);
+    if (!compact) {
+      persistChartRenderMode(nextMode);
     }
-  }, [compact, setStoredRenderMode, storedRenderMode]);
+  }, [compact, persistChartRenderMode]);
 
   const expandBufferRange = useCallback((action: PendingExpansionAction): boolean => {
     if (compact) return false;

package/src/components/command-bar/pane-templates/workflow-route.ts

@@ -16,7 +16,17 @@ import {
   getPaneTemplateDisplayLabel,
 } from "./items";
 
+function paneTemplateHasConfigFields(template: PaneTemplateDef): boolean {
+  if (template.wizard?.some((step) => step.type !== "info")) {
+    return true;
+  }
+  return !!buildGeneratedTemplateField(template, null).field;
+}
+
 export function shouldOpenPaneTemplateConfig(template: PaneTemplateDef, arg?: string): boolean {
+  if (!paneTemplateHasConfigFields(template)) {
+    return false;
+  }
   if (template.wizard && template.wizard.length > 0) {
     if (!arg?.trim()) {
       return true;