gloomberb 0.15.5 → 0.15.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.15.5",
+  "version": "0.15.6",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/public/index.ts",

package/src/api-client/auth.ts

@@ -6,6 +6,7 @@ import type {
   AuthUser,
   BuildoutAccountResponse,
   BuildoutTokenResponse,
+  CalendarFeed,
   CloudAccountPlan,
   CloudBrowserHandoffResponse,
   CloudPricing,
@@ -250,6 +251,33 @@ export class CloudAuthApi {
     );
   }
 
+  /** The private calendar feed link, or null until it is first created. */
+  async getCalendarFeed(): Promise<CalendarFeed | null> {
+    const result = await this.options.request<{ feed: CalendarFeed | null }>(
+      "/account/calendar-feed",
+      { method: "GET" },
+    );
+    return result.feed;
+  }
+
+  /** The calendar feed link, created on first use. */
+  async ensureCalendarFeed(): Promise<CalendarFeed> {
+    const result = await this.options.request<{ feed: CalendarFeed }>(
+      "/account/calendar-feed",
+      { method: "POST", body: JSON.stringify({}) },
+    );
+    return result.feed;
+  }
+
+  /** A new calendar feed link; the old one stops working. */
+  async rotateCalendarFeed(): Promise<CalendarFeed> {
+    const result = await this.options.request<{ feed: CalendarFeed }>(
+      "/account/calendar-feed/rotate",
+      { method: "POST", body: JSON.stringify({}) },
+    );
+    return result.feed;
+  }
+
   async updateAccountProfile(
     update: AccountProfileUpdate,
   ): Promise<AccountProfile> {

package/src/api-client/index.ts

@@ -360,7 +360,7 @@ class GloomApiClient {
     event: import("./research-activity").ResearchActivity; eventId: string;
     surface: "web" | "desktop" | "tui" | "cli"; anonymousId?: string;
     attribution?: Record<string, string>; feature?: import("./research-activity").ResearchFeature;
-    tab?: string;
+    tab?: string; desks?: readonly string[];
   }): Promise<void> {
     await this.request("/activity/research", { method: "POST", body: JSON.stringify(payload) });
   }
@@ -405,6 +405,9 @@ class GloomApiClient {
   getBuildoutAccount = this.auth.getBuildoutAccount.bind(this.auth);
   getBuildoutToken = this.auth.getBuildoutToken.bind(this.auth);
   updateAccountProfile = this.auth.updateAccountProfile.bind(this.auth);
+  getCalendarFeed = this.auth.getCalendarFeed.bind(this.auth);
+  ensureCalendarFeed = this.auth.ensureCalendarFeed.bind(this.auth);
+  rotateCalendarFeed = this.auth.rotateCalendarFeed.bind(this.auth);
 
   async getSyncSnapshot(): Promise<CloudSyncSnapshotResponse> {
     return this.request<CloudSyncSnapshotResponse>("/sync/snapshot", { method: "GET" });

package/src/api-client/research-activity.ts

@@ -318,12 +318,14 @@ function attributionPayload(): Record<string, string> | undefined {
 /**
  * Counts milestones once per feature/session/account, never their content.
  * Native surfaces report anonymously only with an identifier the website
- * handed over; they still never mint one of their own.
+ * handed over; they still never mint one of their own. `desks` rides on the
+ * end of the first-run funnel: the desks picked at "What do you trade?".
  */
 export function recordResearchActivity(
   event: ResearchActivity,
   feature?: ResearchFeature,
   tab?: string,
+  desks?: readonly string[],
 ): void {
   const target = getCurrentPluginTarget();
   const user = apiClient.getCurrentUser();
@@ -342,6 +344,7 @@ export function recordResearchActivity(
       attribution: attributionPayload(),
       feature,
       tab,
+      desks,
     })
     .catch(() => {
       sent.delete(key);

package/src/api-client/types.ts

@@ -193,6 +193,14 @@ export interface CloudPricing {
   yearly: CloudPricingTier;
 }
 
+/** The account's private calendar feed link (`/account/calendar-feed`). */
+export interface CalendarFeed {
+  url: string;
+  createdAt: string;
+  /** The last time a calendar app read it, to the hour. */
+  lastFetchedAt: string | null;
+}
+
 /** One command-bar prefix described for `/assist/command`. */
 export interface AssistCommandDescriptor {
   prefix: string;

package/src/app/pane-runtime/index.tsx

@@ -18,6 +18,7 @@ import {
   type AppState,
 } from "../../state/app/context";
 import { scheduleConfigSave } from "../../state/config-save-scheduler";
+import { pinFollowingPane } from "../../layout/pane-follow";
 import {
   createPaneInstance,
   isTickerPaneId,
@@ -82,6 +83,7 @@ export function useAppPaneRuntime({
     const currentState = stateRef.current;
     const normalizedLayout = normalizePaneLayout(layout, {
       resolveOrphanSymbol: (instanceId) => resolveTickerForPane(currentState, instanceId),
+      pinOrphan: pinFollowingPane,
     });
     if (options?.pushHistory !== false) {
       dispatch({ type: "PUSH_LAYOUT_HISTORY" });

package/src/app/runtime/broker-import.ts

@@ -8,6 +8,7 @@ import {
 import type { SyncBrokerInstanceResult } from "../../brokers/sync-broker-instance";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import type { PluginRegistry } from "../../plugins/registry";
+import { adoptHeldPortfolioCurrencies } from "../../plugins/builtin/portfolio-list/mutations";
 import { saveConfigImmediately } from "../../state/config-save-scheduler";
 import type { AppAction, AppState } from "../../state/app/context";
 import type { AppConfig } from "../../types/config";
@@ -133,11 +134,12 @@ export function useBrokerImportRuntime({
   }, [applyBrokerImportResult, pluginRegistry.brokers, pluginRegistry.persistence.resources, stateRef, tickerRepository]);
 
   const autoImportBrokerPositions = useCallback(async (tickerMap: Map<string, TickerRecord>) => {
-    const restoredConfig = restoreBrokerPortfoliosFromTickerPositions(
+    // Once per install, manual portfolios held in one other currency take it (see adoptHeldPortfolioCurrencies).
+    const restoredConfig = adoptHeldPortfolioCurrencies(restoreBrokerPortfoliosFromTickerPositions(
       stateRef.current.config,
       tickerMap.values(),
       pluginRegistry.brokers,
-    );
+    ), tickerMap.values());
     if (restoredConfig !== stateRef.current.config) {
       dispatch({ type: "SET_CONFIG", config: restoredConfig });
       await saveConfigImmediately(restoredConfig);

package/src/cli/pane-functions/function-help.ts

@@ -922,6 +922,13 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     data: null,
     bloomberg: ["BLP"],
   },
+  DESK: {
+    summary: "Adds a ready-made desk as a new layout tab: equities, options, futures and commodities, rates and credit, FX and macro, or active trading.",
+    usage: ["DESK", "DESK options"],
+    keys: [],
+    data: null,
+    bloomberg: [],
+  },
   LMA: {
     summary: "Float, dock, swap, remove and save panes and layouts.",
     usage: ["LMA", "LMA float"],

package/src/components/chart/composite/composite-chart.tsx

@@ -19,6 +19,7 @@ import type { ContextMenuItem } from "../../../types/context-menu";
 import { useOptionalPaneInstanceId, usePaneSettingValue } from "../../../state/app/context";
 import { colors as themeColors, hoverBg } from "../../../theme/colors";
 import { useThemeColors } from "../../../theme/theme-context";
+import { chartSurfaceBackground, usePaneSurface } from "../../layout/pane/surface";
 import { CANONICAL_EXCHANGE_ALIASES } from "../../../utils/exchanges";
 import { displayWidth, formatPercentRaw, truncateToDisplayWidth } from "../../../utils/format";
 import { isPlainKey } from "../../../utils/keyboard";
@@ -2171,14 +2172,15 @@ export function CompositeChart({
     return `${entry.id}:${last.date.getTime()}:${last.close ?? ""}:${last.value ?? ""}:${last.high ?? ""}:${last.low ?? ""}:${last.volume ?? ""}:${entry.latestChangePercent ?? ""}`;
   }).join("|");
   const plotHeight = Math.max(panelCount, totalHeight - legendRows - timeAxisRows - xMarkerRows);
+  const paneSurface = usePaneSurface();
   const resolvedColors = useMemo<CompositeChartColors>(() => ({
-    background: colors?.background ?? activeThemeColors.bg,
+    background: chartSurfaceBackground(colors?.background, activeThemeColors.bg, paneSurface),
     grid: colors?.grid ?? activeThemeColors.border,
     crosshair: colors?.crosshair ?? activeThemeColors.borderFocused,
     text: colors?.text ?? activeThemeColors.text,
     textDim: colors?.textDim ?? activeThemeColors.textDim,
     negative: colors?.negative ?? activeThemeColors.negative,
-  }), [activeThemeColors, colors]);
+  }), [activeThemeColors, colors, paneSurface]);
   // A custom x axis means x is not time: a tenor, a fraction, a return. Its
   // last observation belongs at the right edge, under its own label.
   const rightOffsetRatio = xAxis ? 0 : COMPOSITE_RIGHT_OFFSET_RATIO;

package/src/components/chart/composite/rasterizer.ts

@@ -1,5 +1,6 @@
 import type { NativeChartBitmap } from "../native/chart-rasterizer";
 import {
+  blendPixel,
   drawCircle,
   drawLine,
   fillOpaque,
@@ -51,6 +52,72 @@ function pixelY(value: number, domain: CompositeAxisDomain, height: number): num
   return ratio === null ? null : clamp(ratio * Math.max(height - 1, 0), 0, Math.max(height - 1, 0));
 }
 
+const AREA_FILL_MAX_OPACITY = 0.3;
+const AREA_FILL_MIN_OPACITY = 0.02;
+
+/**
+ * The area under a line, filled once per pixel column with a vertical
+ * gradient: strongest at the series' furthest point from the baseline, fading
+ * to almost nothing at the baseline. Filling per segment instead stacked
+ * alpha wherever neighbouring segments shared a column, which on dense
+ * series (years of daily closes in a few hundred pixels) read as a barcode.
+ */
+function fillAreaGradient(
+  data: Uint8Array,
+  width: number,
+  height: number,
+  series: CompositeProjectedSeries,
+  points: readonly { x: number; y: number }[],
+  baseline: number,
+  step: boolean,
+  color: RgbaColor,
+): void {
+  // Per column, the line's furthest point from the baseline, on either side.
+  const above = new Float64Array(width).fill(Number.NaN);
+  const below = new Float64Array(width).fill(Number.NaN);
+  for (let index = 1; index < points.length; index += 1) {
+    if (series.points[index]?.breakBefore) continue;
+    const previous = points[index - 1]!;
+    const current = points[index]!;
+    const from = previous.x <= current.x ? previous : current;
+    const to = previous.x <= current.x ? current : previous;
+    const start = Math.round(from.x);
+    const span = Math.round(to.x) - start;
+    for (let x = Math.max(0, start); x <= Math.min(width - 1, start + span); x += 1) {
+      const y = step ? previous.y : span === 0 ? to.y : from.y + (to.y - from.y) * ((x - start) / span);
+      if (y <= baseline) above[x] = Number.isNaN(above[x]!) ? y : Math.min(above[x]!, y);
+      if (y >= baseline) below[x] = Number.isNaN(below[x]!) ? y : Math.max(below[x]!, y);
+    }
+  }
+
+  const floor = Math.min(Math.max(baseline, 0), height - 1);
+  let peakAbove = floor;
+  let peakBelow = floor;
+  for (let x = 0; x < width; x += 1) {
+    if (!Number.isNaN(above[x]!)) peakAbove = Math.min(peakAbove, above[x]!);
+    if (!Number.isNaN(below[x]!)) peakBelow = Math.max(peakBelow, below[x]!);
+  }
+  const reachAbove = Math.max(1, floor - Math.max(0, peakAbove));
+  const reachBelow = Math.max(1, Math.min(height - 1, peakBelow) - floor);
+
+  for (let x = 0; x < width; x += 1) {
+    const top = above[x]!;
+    if (!Number.isNaN(top)) {
+      for (let y = Math.max(0, Math.ceil(top)); y <= floor; y += 1) {
+        const strength = (floor - y) / reachAbove;
+        blendPixel(data, width, height, x, y, color, AREA_FILL_MIN_OPACITY + (AREA_FILL_MAX_OPACITY - AREA_FILL_MIN_OPACITY) * strength);
+      }
+    }
+    const bottom = below[x]!;
+    if (!Number.isNaN(bottom)) {
+      for (let y = floor + 1; y <= Math.min(height - 1, Math.floor(bottom)); y += 1) {
+        const strength = (y - floor) / reachBelow;
+        blendPixel(data, width, height, x, y, color, AREA_FILL_MIN_OPACITY + (AREA_FILL_MAX_OPACITY - AREA_FILL_MIN_OPACITY) * strength);
+      }
+    }
+  }
+}
+
 function drawConnectedSeries(
   data: Uint8Array,
   width: number,
@@ -65,19 +132,12 @@ function drawConnectedSeries(
   const baseline = pixelY(0, domain, height) ?? height - 1;
   const step = series.source.style === "step" || series.source.interpolation === "step-after";
 
+  if (area) fillAreaGradient(data, width, height, series, points, baseline, step, color);
+
   for (let index = 1; index < points.length; index += 1) {
     const previous = points[index - 1]!;
     const current = points[index]!;
     if (series.points[index]?.breakBefore) continue;
-    if (area) {
-      const left = Math.round(Math.min(previous.x, current.x));
-      const right = Math.round(Math.max(previous.x, current.x));
-      for (let x = left; x <= right; x += 1) {
-        const ratio = right === left ? 0 : (x - left) / (right - left);
-        const y = step ? previous.y : previous.y + (current.y - previous.y) * ratio;
-        fillRect(data, width, height, x, Math.min(y, baseline), x, Math.max(y, baseline), color, 0.14);
-      }
-    }
     if (step) {
       drawLine(data, width, height, previous.x, previous.y, current.x, previous.y, color, 1.4);
       drawLine(data, width, height, current.x, previous.y, current.x, current.y, color, 1.4);

package/src/components/command-bar/layout-items/current-layout.ts

@@ -195,5 +195,15 @@ export function buildCurrentLayoutItems({
       kind: "action",
       action: () => openBuiltInWorkflow("new-layout"),
     },
+    {
+      id: "layout-add-desk",
+      label: "Add a Desk",
+      detail: "A ready-made layout for equities, options, futures, rates, FX or trading",
+      searchText: "desk add workspace template starter",
+      category: "Current Layout",
+      kind: "action",
+      right: "DESK",
+      action: () => dispatch({ type: "SET_COMMAND_BAR", open: true, query: "DESK " }),
+    },
   ];
 }

package/src/components/command-bar/workflow/collection-actions.ts

@@ -17,8 +17,10 @@ import {
 } from "../../../brokers/signed-in/connect";
 import {
   addTickerToPortfolio,
+  adoptFirstPositionCurrency,
   createManualPortfolio as createManualPortfolioConfig,
   deleteManualPortfolio,
+  hasOpenPortfolioPositions,
   isManualPortfolio,
   resolveManualPositionCurrency,
   setManualPortfolioPosition,
@@ -253,8 +255,14 @@ export function createCommandBarCollectionWorkflowActions(options: {
         avgCost,
         currency,
       });
+      const firstPosition = !hasOpenPortfolioPositions(portfolio.id, getState().tickers.values());
       await tickerRepository.saveTicker(result.ticker);
       dispatch({ type: "UPDATE_TICKER", ticker: result.ticker });
+      const adopted = firstPosition ? adoptFirstPositionCurrency(getState().config, portfolio.id, currency) : null;
+      if (adopted) {
+        dispatch({ type: "SET_CONFIG", config: adopted });
+        persistConfig(adopted);
+      }
       pluginRegistry.events.emit("host:portfolio-ticker-saved", {
         symbol: result.ticker.metadata.ticker,
         portfolioId: portfolio.id,

package/src/components/command-bar/workflow/ops.ts

@@ -98,12 +98,53 @@ function stableKey(value: unknown): string {
   ));
 }
 
+/**
+ * A ticker pane's id names the ticker it opened on (`options:AAPL`), but a pane linked to a list
+ * since then, or unlinked on another ticker, shows something else. Typing `OMON AAPL` must not
+ * retarget it: a linked pane would silently stop following, and an unlinked one would be taken over.
+ */
+function showsOtherTicker(owner: PaneInstanceConfig, spec: PaneTemplateInstanceConfig): boolean {
+  return spec.binding?.kind === "fixed" && (
+    owner.binding?.kind === "follow"
+    || (owner.binding?.kind === "fixed" && owner.binding.symbol !== spec.binding.symbol)
+  );
+}
+
+/**
+ * When the pane holding a ticker template's id shows another ticker, the command opens its own
+ * pinned pane under a further stable id (`options:AAPL:pinned`, then `:pinned-2`), so typing it
+ * again lands on that pane rather than a new one (OMON keeps rewriting its settings, so the
+ * whole-spec match below would miss it). A pinned pane that was linked or moved on since is
+ * skipped the same way, so the ids never run out into unkeyed duplicates.
+ */
+function withFreeTickerInstanceId(
+  instances: PaneInstanceConfig[],
+  paneId: string,
+  spec: PaneTemplateInstanceConfig,
+): PaneTemplateInstanceConfig {
+  const baseId = spec.instanceId;
+  if (!baseId) return spec;
+  const byId = new Map(instances.map((instance) => [instance.instanceId, instance]));
+  const owner = byId.get(baseId);
+  if (owner?.paneId !== paneId || !showsOtherTicker(owner, spec)) return spec;
+  let free: string | null = null;
+  // One more id than there are panes is always enough to find a free one.
+  for (let index = 1; index <= instances.length + 1; index += 1) {
+    const instanceId = index === 1 ? `${baseId}:pinned` : `${baseId}:pinned-${index}`;
+    const holder = byId.get(instanceId);
+    if (!holder) free ??= instanceId;
+    else if (holder.paneId === paneId && !showsOtherTicker(holder, spec)) return { ...spec, instanceId };
+  }
+  return { ...spec, instanceId: free ?? undefined };
+}
+
 /**
  * Find the pane a template would otherwise duplicate. A template that owns a
  * stable instance id (Chat keys one pane per channel) claims that instance even
  * after its settings drifted at runtime, as long as the id still belongs to the
- * same kind of pane; everything else has to match the whole create spec, so a
- * different ticker, collection or setting still opens its own pane.
+ * same kind of pane and, for a ticker pane, still shows that ticker; everything
+ * else has to match the whole create spec, so a different ticker, collection or
+ * setting still opens its own pane.
  */
 function findReusablePaneInstance(
   instances: PaneInstanceConfig[],
@@ -112,7 +153,8 @@ function findReusablePaneInstance(
 ): PaneInstanceConfig | null {
   if (spec.instanceId) {
     const owner = instances.find((instance) => instance.instanceId === spec.instanceId);
-    return owner?.paneId === paneId ? owner : null;
+    if (!owner || owner.paneId !== paneId) return null;
+    if (!showsOtherTicker(owner, spec)) return owner;
   }
   const specKey = stableKey([spec.binding ?? { kind: "none" }, spec.params ?? {}, spec.settings ?? {}]);
   return instances.find((instance) => (
@@ -277,6 +319,7 @@ export async function createPaneTemplateOrThrow(
   }
 
   const instances = deps.getState().config.layout.instances;
+  spec = withFreeTickerInstanceId(instances, template.paneId, spec);
   const existing = findReusablePaneInstance(instances, template.paneId, spec);
   if (existing) {
     const retargeted = retargetPaneInstance(existing, spec);

package/src/components/layout/pane/frame.tsx

@@ -1,6 +1,7 @@
 import type { ReactNode } from "react";
 import { Box } from "../../../ui";
 import { colors } from "../../../theme/colors";
+import { PaneSurfaceContext } from "./surface";
 
 export function getPaneWindowAttributes({
   enabled = true,
@@ -49,7 +50,7 @@ export function PaneBodyFrame({
 }) {
   return (
     <Box {...layoutProps} overflow="hidden" backgroundColor={backgroundColor} data-gloom-role="pane-body">
-      {children}
+      <PaneSurfaceContext.Provider value={backgroundColor}>{children}</PaneSurfaceContext.Provider>
     </Box>
   );
 }

package/src/components/layout/pane/surface.ts

@@ -0,0 +1,26 @@
+import { createContext, useContext } from "react";
+
+/**
+ * The body color of the pane a component renders in. Charts draw on it, so a
+ * plot reads as part of the pane instead of a darker box inside it. Null
+ * outside a pane (dialogs, screenshots of a lone chart).
+ */
+export const PaneSurfaceContext = createContext<string | null>(null);
+
+export function usePaneSurface(): string | null {
+  return useContext(PaneSurfaceContext);
+}
+
+/**
+ * A chart's background: an explicit color wins, except the theme's own
+ * background, which callers pass only because it was the default. That one,
+ * or none at all, becomes the pane surface when there is one.
+ */
+export function chartSurfaceBackground(
+  requested: string | null | undefined,
+  themeBackground: string,
+  paneSurface: string | null,
+): string {
+  if (requested && requested.toLowerCase() !== themeBackground.toLowerCase()) return requested;
+  return paneSurface ?? requested ?? themeBackground;
+}

package/src/components/layout/pane/title.ts

@@ -6,14 +6,18 @@ import {
   type PaneInstanceConfig,
 } from "../../../types/config";
 import type { PaneDef } from "../../../types/plugin";
+import { paneTitleMnemonic } from "../../../layout/pane-follow";
+import { canFollowTickerSource } from "../../../layout/ticker-navigation";
 
 /** Single-cell link glyph: emoji link icons render double-width in terminals. */
 const LINK_GLYPH = "\u29c9";
 
-function getBasePaneDisplayTitle(
+/** The title without the link suffix; a menu row naming a source uses it as is. */
+export function getBasePaneDisplayTitle(
   state: Pick<AppState, "config" | "paneState">,
   instance: PaneInstanceConfig,
   paneDef: PaneDef,
+  panes?: ReadonlyMap<string, PaneDef>,
 ): string {
   if (instance.paneId === "chat") {
     const channelId = typeof instance.settings?.channelId === "string" && instance.settings.channelId.trim()
@@ -36,6 +40,15 @@ function getBasePaneDisplayTitle(
       ?? t(paneDef.name);
   }
 
+  // A linked pane stores only its command ("OPX") and shows the ticker its source has selected.
+  const mnemonic = instance.binding?.kind === "follow" && panes && canFollowTickerSource(instance, panes)
+    ? paneTitleMnemonic(instance.title)
+    : null;
+  if (mnemonic) {
+    const ticker = resolveTickerForPane(state as AppState, instance.instanceId);
+    return ticker ? `${mnemonic} ${ticker}` : mnemonic;
+  }
+
   if (instance.title) return instance.title;
 
   if (instance.paneId === "portfolio-list") {
@@ -58,14 +71,17 @@ export function getPaneDisplayTitle(
   paneDef: PaneDef,
   panes?: ReadonlyMap<string, PaneDef>,
 ): string {
-  const title = getBasePaneDisplayTitle(state, instance, paneDef);
-  if (instance.paneId !== TICKER_RESEARCH_PANE_ID || instance.binding?.kind !== "follow" || !panes) {
-    return title;
-  }
+  const title = getBasePaneDisplayTitle(state, instance, paneDef, panes);
+  if (instance.binding?.kind !== "follow" || !panes) return title;
+  const research = instance.paneId === TICKER_RESEARCH_PANE_ID;
+  if (!research && !canFollowTickerSource(instance, panes)) return title;
 
   const source = findPaneInstance(state.config.layout, instance.binding.sourceInstanceId);
   const sourceDef = source ? panes.get(source.paneId) : null;
   if (!source || !sourceDef) return title;
+  // Other panes name only the list or scanner they follow; one chained to a fixed pane (a desk's
+  // OMON following OVDV) reads as it always has.
+  if (!research && !sourceDef.tickerSource) return title;
   const sourceTitle = getBasePaneDisplayTitle(state, source, sourceDef);
   return `${title}  ${LINK_GLYPH} ${tf("Linked to {source}", { source: sourceTitle })}`;
 }

package/src/components/layout/shell/index.tsx

@@ -598,7 +598,7 @@ export function Shell({
         instance: pane.instance,
         layout: visibleLayout,
         panes: pluginRegistry.panes,
-        state: titleState,
+        state: { ...titleState, tickers: stateRef.current.tickers },
         persistLayout,
       }),
       canExportPaneCsv(paneId) ? exportPaneCsv : undefined,

package/src/components/layout/shell/ticker-link-menu.ts

@@ -1,6 +1,9 @@
+import { tf } from "../../../i18n";
 import { updatePaneInstance } from "../../../pane-settings";
-import { listVisibleTickerSourcePanes } from "../../../layout/ticker-navigation";
+import { canFollowTickerSource, listVisibleTickerSourcePanes } from "../../../layout/ticker-navigation";
 import { resolveTickerForPane, type AppState } from "../../../state/app/context";
+import { resolveInstrumentForPane } from "../../../core/state/app/instrument";
+import { paneTitleMnemonic, pinFollowingPane } from "../../../layout/pane-follow";
 import {
   TICKER_RESEARCH_PANE_ID,
   type LayoutConfig,
@@ -8,11 +11,13 @@ import {
 } from "../../../types/config";
 import type { ContextMenuItem } from "../../../types/context-menu";
 import type { PaneDef } from "../../../types/plugin";
-import { getPaneDisplayTitle } from "../pane/title";
+import { getBasePaneDisplayTitle } from "../pane/title";
 
 /**
- * Flat link controls for a Ticker Research pane: one entry per visible ticker source, plus an
- * unlink entry that pins the pane on the symbol it currently shows.
+ * Flat link controls for a pane that shows one ticker (Ticker Research, or a pane that sets
+ * `PaneDef.tickerFollower`): one "Link to" entry per visible ticker source, plus an unlink entry
+ * that pins the pane on the symbol it currently shows. Only list panes and scanners are targets;
+ * a pane following anything else (a desk's OMON following OVDV) gets no rows.
  */
 export function tickerLinkMenuItems({
   instance,
@@ -24,54 +29,72 @@ export function tickerLinkMenuItems({
   instance: PaneInstanceConfig;
   layout: LayoutConfig;
   panes: ReadonlyMap<string, PaneDef>;
-  state: Pick<AppState, "config" | "paneState">;
+  state: Pick<AppState, "config" | "paneState" | "tickers">;
   persistLayout: (nextLayout: LayoutConfig) => void;
 }): ContextMenuItem[] {
-  if (instance.paneId !== TICKER_RESEARCH_PANE_ID) return [];
+  const research = instance.paneId === TICKER_RESEARCH_PANE_ID;
+  // A chart that gained a comparison while linked can still be unlinked, but not linked again.
+  const followerType = research || !!panes.get(instance.paneId)?.tickerFollower;
+  if (!followerType) return [];
+  const linkable = research || canFollowTickerSource(instance, panes);
 
   const sourceInstanceId = instance.binding?.kind === "follow" ? instance.binding.sourceInstanceId : null;
-  const rebind = (binding: PaneInstanceConfig["binding"]) => {
-    persistLayout(updatePaneInstance(layout, instance.instanceId, (current) => ({ ...current, binding })));
+  const unlink = (symbol: string) => {
+    const contract = resolveInstrumentForPane(state, instance.instanceId)?.instrument;
+    persistLayout(updatePaneInstance(layout, instance.instanceId, (current) => {
+      const mnemonic = research ? null : paneTitleMnemonic(current.title);
+      return pinFollowingPane(mnemonic ? { ...current, title: mnemonic } : current, symbol, contract);
+    }));
   };
   const linkToSource = (nextSourceId: string) => {
     persistLayout({
       ...layout,
       instances: layout.instances.map((current) => {
         if (current.instanceId === instance.instanceId) {
-          return { ...current, binding: { kind: "follow" as const, sourceInstanceId: nextSourceId } };
+          // The stored title drops its ticker ("OMON AAPL" to "OMON"); the header adds the live one.
+          const mnemonic = research ? null : paneTitleMnemonic(current.title);
+          return {
+            ...current,
+            ...(mnemonic ? { title: mnemonic } : {}),
+            binding: { kind: "follow" as const, sourceInstanceId: nextSourceId },
+          };
         }
+        // Ticker Research keeps one follower per source, so Enter on a source row has one target.
+        // Any number of other panes may follow the same source.
         if (
-          current.paneId !== TICKER_RESEARCH_PANE_ID
+          !research
+          || current.paneId !== TICKER_RESEARCH_PANE_ID
           || current.binding?.kind !== "follow"
           || current.binding.sourceInstanceId !== nextSourceId
         ) return current;
-
-        const symbol = resolveTickerForPane(state as AppState, current.instanceId);
-        return { ...current, binding: symbol ? { kind: "fixed" as const, symbol } : { kind: "none" as const } };
+        return pinFollowingPane(current, resolveTickerForPane(state as AppState, current.instanceId));
       }),
     });
   };
 
   return listVisibleTickerSourcePanes(layout, panes).flatMap((source): ContextMenuItem[] => {
     const paneDef = panes.get(source.paneId);
-    if (!paneDef) return [];
-    const title = getPaneDisplayTitle(state, source, paneDef, panes);
+    if (!paneDef || source.instanceId === instance.instanceId) return [];
+    const title = getBasePaneDisplayTitle(state, source, paneDef);
 
     if (source.instanceId !== sourceInstanceId) {
-      return [{
-        id: `link:${source.instanceId}`,
-        label: `Link to ${title}`,
-        onSelect: () => linkToSource(source.instanceId),
-      }];
+      return linkable
+        ? [{
+          id: `link:${source.instanceId}`,
+          label: tf("Link to {source}", { source: title }),
+          onSelect: () => linkToSource(source.instanceId),
+        }]
+        : [];
     }
 
-    // Unlinking keeps the pane alive, so it only works once a symbol has resolved.
+    // Unlinking keeps the pane alive, so it only works once a symbol has resolved: pinning a
+    // ticker pane to nothing would let the next layout pass remove it.
     const symbol = resolveTickerForPane(state as AppState, instance.instanceId);
     return symbol
       ? [{
         id: `unlink:${source.instanceId}`,
-        label: `Unlink from ${title}`,
-        onSelect: () => rebind({ kind: "fixed", symbol }),
+        label: tf("Unlink from {source}", { source: title }),
+        onSelect: () => unlink(symbol),
       }]
       : [];
   });