gloomberb 0.13.2 → 0.14.0

package/src/app/pane-runtime/ticker-open-runtime.test.tsx

@@ -0,0 +1,170 @@
+import { getDockedPaneIds } from "../../plugins/pane-manager";
+import { expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../renderers/opentui/test-utils";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import { createBrowserResearchLayout, BROWSER_RESEARCH_PANE_ID } from "../../renderers/browser/config-host";
+import { createInitialState, type AppAction } from "../../state/app/context";
+import { createDefaultConfig, createPaneInstance, TICKER_RESEARCH_PANE_ID } from "../../types/config";
+import type { TickerRecord } from "../../types/ticker";
+import { useAppTickerOpenRuntime } from "./ticker-open-runtime";
+import { researchEntryFromSearch } from "../../renderers/browser/research-entry";
+
+test("a slow linked ticker applies its tab to the reused or new pane after hydration", async () => {
+  for (const { savedListing, savedExchange, reusePane } of [
+    { savedListing: "VOD:XLON", savedExchange: "JSE", reusePane: true },
+    { savedListing: "VOD", savedExchange: "LSE", reusePane: true },
+    { savedListing: "VOD", savedExchange: "JSE", reusePane: false },
+  ]) {
+    const config = createDefaultConfig(":memory:");
+    config.layout = createBrowserResearchLayout(savedListing);
+    const stateRef = { current: createInitialState(config) };
+    // A saved same-spelling issuer on another venue must not satisfy the link.
+    stateRef.current.tickers.set("VOD", { metadata: {
+      ticker: "VOD", exchange: savedExchange,
+      currency: savedExchange === "LSE" ? "GBP" : "ZAR", name: savedExchange === "LSE" ? "Vodafone" : "Vodacom",
+      portfolios: [], watchlists: [], positions: [], custom: {}, tags: [],
+    } });
+    const actions: AppAction[] = [];
+    const focused: string[] = [];
+    let layouts = 0;
+    let releaseSearch!: () => void;
+    const pendingSearch = new Promise<void>((resolve) => { releaseSearch = resolve; });
+    let runtime!: ReturnType<typeof useAppTickerOpenRuntime>;
+    function Harness() {
+      runtime = useAppTickerOpenRuntime({
+        stateRef,
+        dataProvider: createTestDataProvider({ search: async () => {
+          await pendingSearch;
+          return [{ providerId: "cloud", symbol: "VOD", name: "Vodafone", exchange: "LSE", currency: "GBP", type: "EQUITY" }];
+        } }),
+        tickerRepository: {
+          loadTicker: async () => null,
+          createTicker: async (metadata: TickerRecord["metadata"]) => ({ metadata }),
+        } as any,
+        dispatch: (action) => { actions.push(action); },
+        pluginRegistry: {
+          panes: new Map([[TICKER_RESEARCH_PANE_ID, { id: TICKER_RESEARCH_PANE_ID }]]),
+          events: { emit() {} }, notify() {}, getTermSizeFn: () => ({ width: 120, height: 40 }),
+        } as any,
+        buildPaneInstance: (paneId, options) => createPaneInstance(paneId, { ...options, instanceId: "ticker-detail:linked" }),
+        persistLayout: (layout) => { layouts++; stateRef.current.config.layout = layout; },
+        activatePane: (paneId) => { focused.push(paneId); },
+        focusVisiblePane: (paneId) => { focused.push(paneId); },
+      });
+      return <text>Research</text>;
+    }
+    const rendered = await testRender(<Harness />, { width: 20, height: 2 });
+    try {
+      await act(async () => { await rendered.renderOnce(); });
+      const entry = researchEntryFromSearch("?ticker=VOD&exchange=LSE&tab=financials")!;
+      const opening = runtime.openPinnedTicker(entry.symbol, { tabId: entry.tab, floating: true });
+      // Focus may change while the provider is still resolving the linked listing.
+      stateRef.current.focusedPaneId = "world-indices:main";
+      // Explicit exact local matches may resolve without the deferred provider.
+      if (savedExchange !== "LSE") expect(actions).toEqual([]);
+      releaseSearch();
+      await act(async () => { await opening; });
+      const paneId = reusePane ? BROWSER_RESEARCH_PANE_ID : "ticker-detail:linked";
+      expect(actions).toContainEqual({ type: "UPDATE_PANE_STATE", paneId, patch: { activeTabId: "financials" } });
+      expect(actions.filter((action) => action.type === "UPDATE_PANE_STATE")).toHaveLength(1);
+      expect(actions.find((action) => action.type === "UPDATE_TICKER")).toMatchObject({ ticker: { metadata: { ticker: "VOD:XLON", exchange: "LSE" } } });
+      expect(stateRef.current.config.layout.instances.find((pane) => pane.instanceId === paneId)?.binding)
+        .toMatchObject({ kind: "fixed", symbol: "VOD:XLON" });
+      expect(focused).toEqual([paneId]);
+      expect(layouts).toBe(1);
+      expect(stateRef.current.config.layout.instances.filter((pane) => pane.paneId === TICKER_RESEARCH_PANE_ID))
+        .toHaveLength(reusePane ? 1 : 2);
+    } finally {
+      await act(async () => { rendered.renderer.destroy(); });
+    }
+  }
+});
+
+
+test.each(["ambiguous", "missing"])("%s ticker feedback waits for current navigation ownership", async (mode) => {
+  const actions: AppAction[] = [];
+  const notifications: string[] = [];
+  const stateRef = { current: createInitialState(createDefaultConfig(":memory:")) };
+  let releaseSearch!: () => void;
+  const pendingSearch = new Promise<void>((resolve) => { releaseSearch = resolve; });
+  let current = true;
+  let runtime!: ReturnType<typeof useAppTickerOpenRuntime>;
+  function Harness() {
+    runtime = useAppTickerOpenRuntime({
+      stateRef,
+      dataProvider: createTestDataProvider({
+        search: async () => {
+          await pendingSearch;
+          return mode === "missing" ? [] : ["BYMA", "NYSE"].map((exchange) => ({ providerId: "cloud", symbol: "GLD", name: "SPDR", exchange, type: "ETF" }));
+        },
+        getQuote: async () => {
+          if (mode === "missing") throw new Error("No quote available");
+          return { symbol: "GLD", price: 400, currency: "USD", lastUpdated: 1, change: 0, changePercent: 0 };
+        },
+      }),
+      tickerRepository: { createTicker: async () => { throw new Error("Must not create an ambiguous ticker"); } } as any,
+      dispatch: (action) => { actions.push(action); },
+      pluginRegistry: { notify: ({ body }: { body: string }) => { notifications.push(body); } } as any,
+      buildPaneInstance: () => null, persistLayout() {}, activatePane() {}, focusVisiblePane() {},
+    });
+    return <text>Research</text>;
+  }
+  const rendered = await testRender(<Harness />, { width: 20, height: 2 });
+  try {
+    await act(async () => { await rendered.renderOnce(); });
+    const obsolete = runtime.resolveOpenTickerTarget("GLD", false, () => current);
+    current = false;
+    releaseSearch();
+    await act(async () => { expect(await obsolete).toBeNull(); });
+    expect(actions).toEqual([]);
+    expect(notifications).toEqual([]);
+
+    // Ordinary opening still presents the actionable failure or listing picker.
+    await act(async () => { await runtime.openPinnedTicker("GLD"); });
+    expect(actions).toEqual(mode === "ambiguous"
+      ? [{ type: "SET_COMMAND_BAR", open: true, query: "GLD", launch: { kind: "ticker-search", query: "GLD" } }]
+      : []);
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0]).toContain(mode === "ambiguous" ? "Multiple listings match GLD" : "Could not open GLD");
+  } finally {
+    await act(async () => { rendered.renderer.destroy(); });
+  }
+});
+
+test.each(["floating", "docked", "only-floating"])("ticker research opens visibly from a %s source", async (mode) => {
+  const source = createPaneInstance("relative-valuation", { instanceId: "relative-valuation:source", binding: { kind: "none" } });
+  const anchor = createPaneInstance("world-indices", { instanceId: "world-indices:anchor", binding: { kind: "none" } });
+  const config = createDefaultConfig(":memory:");
+  config.layout = { dockRoot: mode === "only-floating" ? null : { kind: "pane", instanceId: mode === "docked" ? source.instanceId : anchor.instanceId },
+    instances: mode === "only-floating" || mode === "docked" ? [source] : [source, anchor],
+    floating: mode === "docked" ? [] : [{ instanceId: source.instanceId, x: 2, y: 2, width: 80, height: 20, zIndex: 1 }], detached: [] };
+  const stateRef = { current: createInitialState(config) };
+  stateRef.current.focusedPaneId = source.instanceId;
+  const ticker: TickerRecord = { metadata: { ticker: "RIVN:XNAS", exchange: "NASDAQ", currency: "USD", name: "Rivian",
+    portfolios: [], watchlists: [], positions: [], custom: {}, tags: [] } };
+  let runtime!: ReturnType<typeof useAppTickerOpenRuntime>;
+  const activated: string[] = [];
+  function Harness() {
+    runtime = useAppTickerOpenRuntime({ stateRef, dataProvider: createTestDataProvider(), tickerRepository: {} as any, dispatch() {},
+      pluginRegistry: { panes: new Map([[TICKER_RESEARCH_PANE_ID, { id: TICKER_RESEARCH_PANE_ID }]]), events: { emit() {} },
+        getTermSizeFn: () => ({ width: 120, height: 40 }) } as any,
+      buildPaneInstance: (paneId, options) => createPaneInstance(paneId, { ...options, instanceId: "ticker-detail:opened" }),
+      persistLayout: (layout) => { stateRef.current.config.layout = layout; },
+      activatePane: (paneId) => { activated.push(paneId); }, focusVisiblePane() {},
+    });
+    return <text>Research</text>;
+  }
+  const rendered = await testRender(<Harness />, { width: 20, height: 2 });
+  try {
+    await act(async () => { await rendered.renderOnce(); runtime.placePinnedTickerTarget({ symbol: "RIVN:XNAS", ticker, created: false }, { floating: false }); });
+    const layout = stateRef.current.config.layout;
+    expect(getDockedPaneIds(layout)).toContain("ticker-detail:opened");
+    expect(layout.instances.find((pane) => pane.instanceId === "ticker-detail:opened")?.binding).toEqual({ kind: "fixed", symbol: "RIVN:XNAS" });
+    expect(activated).toEqual(["ticker-detail:opened"]);
+    if (mode !== "docked") expect(layout.floating.map((pane) => pane.instanceId)).toContain(source.instanceId);
+    else expect(getDockedPaneIds(layout)).toContain(source.instanceId);
+  } finally {
+    await act(async () => { rendered.renderer.destroy(); });
+  }
+});

package/src/app/pane-runtime/ticker-open-runtime.ts

@@ -5,6 +5,7 @@ import {
   addPaneToLayout,
   getDockedPaneIds,
   isPaneInLayout,
+  isPaneDocked,
 } from "../../plugins/pane-manager";
 import type { PluginRegistry } from "../../plugins/registry";
 import { findFixedTickerPaneForSymbol } from "../../plugins/ticker-navigation";
@@ -21,6 +22,11 @@ import {
   resolveTickerOpenTarget,
   type TickerOpenTarget,
 } from "../../tickers/open-target";
+import { AmbiguousTickerError, findExactTickerSearchMatch } from "../../tickers/search";
+import { parsePublicTickerKey } from "../../utils/exchanges";
+import { tickerHasYahooSuffix } from "../../sources/yahoo-finance/symbols";
+import { instrumentFromTicker } from "../../market-data/request-types";
+import { tickerInstrumentLabel } from "../../tickers/instrument-label";
 
 interface UseAppTickerOpenRuntimeOptions {
   activatePane: (paneId: string, layout?: LayoutConfig) => void;
@@ -51,24 +57,33 @@ export function useAppTickerOpenRuntime({
   stateRef,
   tickerRepository,
 }: UseAppTickerOpenRuntimeOptions) {
-  const resolveOpenTickerTarget = useCallback(async (rawSymbol: string): Promise<TickerOpenTarget | null> => {
+  const resolveOpenTickerTarget = useCallback(async (
+    rawSymbol: string,
+    publicOnly = false,
+    canPresentFeedback: () => boolean = () => true,
+  ): Promise<TickerOpenTarget | null> => {
     try {
       const target = await resolveTickerOpenTarget({
-        query: rawSymbol,
+        query: rawSymbol, publicOnly,
         tickers: stateRef.current.tickers,
         dataProvider,
         tickerRepository,
       });
-      if (!target) {
+      if (!target && canPresentFeedback()) {
         pluginRegistry.notify({ body: `Could not open ${rawSymbol}.`, type: "error" });
       }
       return target;
     } catch (err) {
+      if (!canPresentFeedback()) return null;
+      if (err instanceof AmbiguousTickerError) {
+        dispatch({ type: "SET_COMMAND_BAR", open: true, query: rawSymbol,
+          launch: { kind: "ticker-search", query: rawSymbol } });
+      }
       const message = err instanceof Error ? err.message : String(err);
       pluginRegistry.notify({ body: `Failed to open ${rawSymbol}: ${message}`, type: "error" });
       return null;
     }
-  }, [dataProvider, pluginRegistry, stateRef, tickerRepository]);
+  }, [dataProvider, dispatch, pluginRegistry, stateRef, tickerRepository]);
 
   const publishTickerOpenTarget = useCallback((target: TickerOpenTarget) => {
     const currentTicker = stateRef.current.tickers.get(target.symbol);
@@ -87,19 +102,53 @@ export function useAppTickerOpenRuntime({
 
     publishTickerOpenTarget(target);
     const symbol = target.symbol;
+    const instrument = options?.instrument !== undefined ? options.instrument
+      : target.instrument !== undefined ? target.instrument : instrumentFromTicker(target.ticker)?.instrument ?? undefined;
+    const listing = options?.listing ?? target.listing;
+    const binding = { kind: "fixed" as const, symbol, ...(instrument !== undefined ? { instrument } : {}), ...(listing ? { listing } : {}) };
     const currentState = stateRef.current;
     const currentLayout = currentState.config.layout;
-    const existing = options?.forceNewPane
+    let existing = options?.forceNewPane
       ? null
-      : findFixedTickerPaneForSymbol(currentLayout, paneType, symbol);
+      : findFixedTickerPaneForSymbol(currentLayout, paneType, symbol, instrument);
+    if (!options?.forceNewPane && !existing && instrument === null && !target.ticker.metadata.broker_contracts?.length) {
+      existing = findFixedTickerPaneForSymbol(currentLayout, paneType, symbol);
+    }
+    if (!options?.forceNewPane && !existing && !instrument && (parsePublicTickerKey(symbol).exchange || tickerHasYahooSuffix(symbol))) {
+      existing = currentLayout.instances.find((instance) => {
+        if (instance.paneId !== paneType || instance.binding?.kind !== "fixed" || instance.binding.instrument || !isPaneInLayout(currentLayout, instance.instanceId)) return false;
+        const ticker = currentState.tickers.get(instance.binding.symbol);
+        return !!ticker?.metadata.exchange && !!findExactTickerSearchMatch([
+          { label: instance.binding.symbol, right: ticker.metadata.exchange },
+        ], symbol);
+      }) ?? null;
+    }
     if (existing) {
-      focusVisiblePane(existing.instanceId, currentLayout);
+      // A reload can qualify a previously bare saved symbol. Reuse only the
+      // verified same listing, retaining its pane identity and its followers.
+      const previousSymbol = existing.binding?.kind === "fixed" ? existing.binding.symbol : null;
+      let nextLayout = currentLayout;
+      if (previousSymbol && (previousSymbol !== symbol || JSON.stringify(existing.binding) !== JSON.stringify(binding))) {
+        const existingId = existing.instanceId;
+        nextLayout = { ...currentLayout, instances: currentLayout.instances.map((instance) => (
+          instance.instanceId === existingId ? {
+            ...instance,
+            binding,
+            title: !instance.title || instance.title === previousSymbol ? symbol : instance.title,
+          } : instance
+        )) };
+        persistLayout(nextLayout);
+      }
+      if (paneType === TICKER_RESEARCH_PANE_ID && options?.tabId) {
+        dispatch({ type: "UPDATE_PANE_STATE", paneId: existing.instanceId, patch: { activeTabId: options.tabId } });
+      }
+      focusVisiblePane(existing.instanceId, nextLayout);
       return;
     }
 
     const instance = buildPaneInstance(paneType, {
-      title: symbol,
-      binding: { kind: "fixed", symbol },
+      title: tickerInstrumentLabel(symbol, instrument),
+      binding,
     });
     if (!instance) return;
 
@@ -111,17 +160,21 @@ export function useAppTickerOpenRuntime({
         currentLayout,
         instance,
         {
-          relativeTo: currentState.focusedPaneId && isPaneInLayout(currentLayout, currentState.focusedPaneId)
+          relativeTo: currentState.focusedPaneId && isPaneDocked(currentLayout, currentState.focusedPaneId)
             ? currentState.focusedPaneId
             : (getDockedPaneIds(currentLayout).at(-1) ?? instance.instanceId),
           position: "right",
         },
       );
     persistLayout(nextLayout);
+    if (paneType === TICKER_RESEARCH_PANE_ID && options?.tabId) {
+      dispatch({ type: "UPDATE_PANE_STATE", paneId: instance.instanceId, patch: { activeTabId: options.tabId } });
+    }
     activatePane(instance.instanceId, nextLayout);
   }, [
     activatePane,
     buildPaneInstance,
+    dispatch,
     focusVisiblePane,
     persistLayout,
     pluginRegistry,
@@ -130,10 +183,13 @@ export function useAppTickerOpenRuntime({
   ]);
 
   const openPinnedTicker = useCallback(async (rawSymbol: string, options?: PinTickerOptions) => {
-    const target = await resolveOpenTickerTarget(rawSymbol);
+    const selectedTicker = options?.instrument !== undefined && (options.instrument || options.listing) ? await tickerRepository.loadTicker(rawSymbol) : null;
+    const target = selectedTicker
+      ? { symbol: selectedTicker.metadata.ticker, ticker: selectedTicker, created: false, instrument: options?.instrument, listing: options?.listing }
+      : await resolveOpenTickerTarget(rawSymbol, options?.instrument === null);
     if (!target) return;
     placePinnedTickerTarget(target, options);
-  }, [placePinnedTickerTarget, resolveOpenTickerTarget]);
+  }, [placePinnedTickerTarget, resolveOpenTickerTarget, tickerRepository]);
 
   return {
     openPinnedTicker,

package/src/app/runtime/desktop-deeplink.test.ts

@@ -1,7 +1,36 @@
 import { describe, expect, test } from "bun:test";
-import { resolveDesktopDeepLinkAction } from "./desktop-deeplink";
+import { handleDesktopDeepLink, resolveDesktopDeepLinkAction } from "./desktop-deeplink";
+import type { PluginRegistry } from "../../plugins/registry";
+import type { AppState } from "../../state/app/context";
 
 describe("desktop deeplinks", () => {
+  test("opens a valid ticker on overview when a requested tab is unavailable, preserving registered tabs and rejected links", () => {
+    const pinned: Array<{ symbol: string; options: unknown }> = [];
+    const notices: Array<{ body: string; type: string }> = [];
+    const panes = new Map([["ticker-research", {}]]);
+    const registry = {
+      panes,
+      getTickerResearchTabPluginId: (id: string) => ["overview", "corporate-actions"].includes(id) ? "research" : undefined,
+      pinTicker: (symbol: string, options: unknown) => { pinned.push({ symbol, options }); },
+      notify: (notice: { body: string; type: string }) => { notices.push(notice); },
+    } as unknown as PluginRegistry;
+    const options = { pluginRegistry: registry, dispatch: () => {}, stateRef: { current: {} as AppState } };
+
+    handleDesktopDeepLink("gloomberb://ticker/RIVN?tab=events", options);
+    expect(pinned).toEqual([{ symbol: "RIVN", options: { floating: true, paneType: "ticker-research", tabId: "overview" } }]);
+    expect(notices.at(-1)).toEqual({ body: 'Ticker tab "events" is unavailable. Opening RIVN overview.', type: "info" });
+
+    handleDesktopDeepLink("gloomberb://ticker/RIVN?tab=corporate-actions", options);
+    expect(pinned.at(-1)?.options).toMatchObject({ tabId: "corporate-actions" });
+    handleDesktopDeepLink("gloomberb://ticker?tab=events", options);
+    expect(pinned).toHaveLength(2);
+    expect(notices.at(-1)?.type).toBe("error");
+    panes.clear();
+    handleDesktopDeepLink("gloomberb://ticker/RIVN?tab=events", options);
+    expect(pinned).toHaveLength(2);
+    expect(notices.at(-1)?.body).toBe("Ticker research is unavailable.");
+  });
+
   test("routes cloud roundup links to account management", () => {
     expect(resolveDesktopDeepLinkAction("gloomberb://cloud/roundup?week=2026-07-03")).toEqual({
       type: "open-account-management",
@@ -26,6 +55,20 @@ describe("desktop deeplinks", () => {
     });
   });
 
+  test("ignores the website's analytics handoff parameters", () => {
+    const handoff =
+      "_gloom=0f1e2d3c-4b5a-4968-8776-655443322110&utm_source=x&twclid=click_1&first_touch_at=2026-09-10T11:00:00.000Z&first_touch_referrer=https%3A%2F%2Ft.co%2Fabc";
+    expect(resolveDesktopDeepLinkAction(`gloomberb://cloud/success?${handoff}`)).toEqual(
+      resolveDesktopDeepLinkAction("gloomberb://cloud/success"),
+    );
+    expect(resolveDesktopDeepLinkAction(`gloomberb://ticker/NVDA?tab=chart&${handoff}`)).toEqual(
+      resolveDesktopDeepLinkAction("gloomberb://ticker/NVDA?tab=chart"),
+    );
+    expect(resolveDesktopDeepLinkAction(`gloomberb://cloud/roundup?week=2026-07-03&${handoff}`)).toEqual(
+      resolveDesktopDeepLinkAction("gloomberb://cloud/roundup?week=2026-07-03"),
+    );
+  });
+
   test("routes ticker links with arbitrary registered tab ids", () => {
     expect(resolveDesktopDeepLinkAction("gloomberb://ticker/NVDA?tab=analyst-research")).toEqual({
       type: "open-ticker",

package/src/app/runtime/desktop-deeplink.ts

@@ -11,13 +11,14 @@ import {
 import type { DesktopDeepLinkBridge } from "../../types/desktop-deeplink";
 import type { DesktopWindowBridge } from "../../types/desktop-window";
 import { requestAccountManagementTab } from "../../plugins/builtin/account-management/navigation";
+import { openTeamPane } from "../../plugins/builtin/cloud/team/pane-request";
 import { chatController } from "../../plugins/builtin/chat/controller";
 import { getShare } from "../../shares/api";
 import { openPaneShare } from "../../shares/pane";
 import { materializeMarketplaceLayout } from "../../layout-marketplace/payload";
 
 type CloudDeepLinkRoute = {
-  kind: "cloud-alerts" | "cloud-emails" | "cloud-roundup" | "cloud-success";
+  kind: "cloud-alerts" | "cloud-emails" | "cloud-roundup" | "cloud-success" | "cloud-teams";
   week: string | null;
 };
 
@@ -167,6 +168,13 @@ function parseCloudDeepLink(parsed: ParsedGloomUrl): DesktopDeepLinkAction {
       message: "Opened email settings.",
     };
   }
+  if (route === "teams") {
+    return {
+      type: "open-account-management",
+      route: { kind: "cloud-teams", week: null },
+      message: "Opened teams.",
+    };
+  }
   if (route === "success") {
     return {
       type: "open-account-management",
@@ -373,22 +381,19 @@ function handleOpenTicker(
   pluginRegistry: PluginRegistry,
 ): void {
   if (!requirePane(pluginRegistry, TICKER_RESEARCH_PANE_ID, "Ticker research is unavailable.")) return;
-  if (action.tabId && !pluginRegistry.getTickerResearchTabPluginId(action.tabId)) {
-    notifyError(pluginRegistry, `Ticker tab "${action.tabId}" is unavailable.`);
-    return;
-  }
+  const unavailableTab = action.tabId && !pluginRegistry.getTickerResearchTabPluginId(action.tabId);
+  const tabId = unavailableTab ? "overview" : action.tabId;
 
   pluginRegistry.pinTicker(action.symbol, {
     floating: true,
     paneType: TICKER_RESEARCH_PANE_ID,
+    tabId: tabId ?? undefined,
   });
-
-  if (action.tabId) {
-    globalThis.setTimeout(() => {
-      pluginRegistry.switchTab(action.tabId!);
-    }, 80);
+  if (unavailableTab) {
+    pluginRegistry.notify({ body: `Ticker tab "${action.tabId}" is unavailable. Opening ${action.symbol} overview.`, type: "info" });
+  } else {
+    notifySuccess(pluginRegistry, action.message);
   }
-  notifySuccess(pluginRegistry, action.message);
 }
 
 function handleOpenCollection(
@@ -525,6 +530,12 @@ export function handleDesktopDeepLink(rawUrl: string, options: DesktopDeepLinkHa
     case "open-account-management":
       if (!requirePane(options.pluginRegistry, "account-management", "Account management is unavailable.")) return;
       if (action.route.kind === "cloud-emails") requestAccountManagementTab("emails");
+      if (action.route.kind === "cloud-teams") {
+        // Teams have their own pane; the web hand-off lands there.
+        openTeamPane((templateId, opts) => options.pluginRegistry.createPaneFromTemplate(templateId, opts), {});
+        notifySuccess(options.pluginRegistry, action.message);
+        return;
+      }
       if (action.route.kind === "cloud-success") {
         requestAccountManagementTab("pro");
         // Checkout just completed: re-read the session so the new plan shows at once.

package/src/app/runtime/layout-warmup.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig, createPaneInstance, type LayoutConfig } from "../../types/config";
+import type { TickerRecord } from "../../types/ticker";
+import { collectSavedLayoutInstruments } from "./layout-warmup";
+
+function ticker(symbol: string): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: symbol,
+      positions: [],
+      portfolios: [],
+      watchlists: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+function fixedLayout(entries: Array<{ instanceId: string; symbol: string; floating?: boolean }>): LayoutConfig {
+  const docked = entries.filter((entry) => !entry.floating);
+  return {
+    dockRoot: docked.length === 0
+      ? null
+      : docked.slice(1).reduce<LayoutConfig["dockRoot"]>(
+        (node, entry) => ({ kind: "split", axis: "horizontal", ratio: 0.5, first: node!, second: { kind: "pane", instanceId: entry.instanceId } }),
+        { kind: "pane", instanceId: docked[0]!.instanceId },
+      ),
+    instances: entries.map((entry) => createPaneInstance("ticker-detail", {
+      instanceId: entry.instanceId,
+      binding: { kind: "fixed", symbol: entry.symbol },
+    })),
+    floating: entries.filter((entry) => entry.floating).map((entry) => ({ instanceId: entry.instanceId, x: 0, y: 0, width: 20, height: 10 })),
+    detached: [],
+  };
+}
+
+describe("collectSavedLayoutInstruments", () => {
+  test("resolves the panes of every layout except the active one, deduplicated, docked before floating", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    config.layouts = [
+      { name: "Home", layout: config.layout, paneState: {} },
+      { name: "Tech", layout: fixedLayout([
+        { instanceId: "ticker-detail:a", symbol: "MSFT" },
+        { instanceId: "ticker-detail:b", symbol: "NVDA", floating: true },
+      ]), paneState: {} },
+      { name: "Banks", layout: fixedLayout([
+        { instanceId: "ticker-detail:c", symbol: "JPM" },
+        { instanceId: "ticker-detail:d", symbol: "MSFT" },
+      ]), paneState: {} },
+    ];
+    config.activeLayoutIndex = 0;
+    const tickers = new Map(["MSFT", "NVDA", "JPM"].map((symbol) => [symbol, ticker(symbol)]));
+
+    const instruments = collectSavedLayoutInstruments(config, tickers);
+    expect(instruments.map((instrument) => instrument.symbol)).toEqual(["MSFT", "NVDA", "JPM"]);
+  });
+
+  test("stops at the limit", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const symbols = ["A", "B", "C", "D"];
+    config.layouts = [
+      { name: "Home", layout: config.layout, paneState: {} },
+      { name: "Many", layout: fixedLayout(symbols.map((symbol) => ({ instanceId: `ticker-detail:${symbol}`, symbol }))), paneState: {} },
+    ];
+    config.activeLayoutIndex = 0;
+    const tickers = new Map(symbols.map((symbol) => [symbol, ticker(symbol)]));
+
+    expect(collectSavedLayoutInstruments(config, tickers, 2).map((instrument) => instrument.symbol)).toEqual(["A", "B"]);
+  });
+});

package/src/app/runtime/layout-warmup.ts

@@ -0,0 +1,118 @@
+import { useEffect, useRef } from "react";
+import { resolveInstrumentForPane } from "../../core/state/app/instrument";
+import type { InstrumentRef } from "../../market-data/request-types";
+import { buildInstrumentKey } from "../../market-data/selectors";
+import { getDockedPaneIds } from "../../plugins/pane-manager/dock-tree";
+import type { AppConfig } from "../../types/config";
+import type { TickerRecord } from "../../types/ticker";
+import { recordPerfSample } from "../../utils/perf-marks";
+
+/** Enough to cover a couple of saved workspaces without turning startup into a crawl. */
+const MAX_WARM_INSTRUMENTS = 12;
+/** Spread requests so a layout switch is warm without a burst at startup. */
+const WARM_INTERVAL_MS = 150;
+const QUIET_SAMPLE_MS = 200;
+const QUIET_LAG_MS = 4;
+const QUIET_SAMPLES_REQUIRED = 3;
+const QUIET_MAX_WAIT_MS = 8_000;
+
+/**
+ * The instruments a saved layout would show if switched to, in the order its
+ * panes appear, resolved the same way the live layout resolves them.
+ */
+export function collectSavedLayoutInstruments(
+  config: AppConfig,
+  tickers: Map<string, TickerRecord>,
+  limit = MAX_WARM_INSTRUMENTS,
+): InstrumentRef[] {
+  const seen = new Set<string>();
+  const instruments: InstrumentRef[] = [];
+  config.layouts.forEach((saved, index) => {
+    if (index === config.activeLayoutIndex) return;
+    const state = { config: { ...config, layout: saved.layout }, paneState: saved.paneState ?? {}, tickers };
+    const paneIds = [...getDockedPaneIds(saved.layout), ...saved.layout.floating.map((entry) => entry.instanceId)];
+    for (const paneId of paneIds) {
+      if (instruments.length >= limit) return;
+      const instrument = resolveInstrumentForPane(state, paneId);
+      if (!instrument) continue;
+      const key = buildInstrumentKey(instrument);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      instruments.push(instrument);
+    }
+  });
+  return instruments;
+}
+
+/** Resolves once the event loop has been responsive for a few samples, or after the cap. */
+function whenMainThreadQuiet(signal: { cancelled: boolean }): Promise<void> {
+  return new Promise((resolve) => {
+    const startedAt = performance.now();
+    let quietSamples = 0;
+    const sample = () => {
+      if (signal.cancelled) return;
+      const before = performance.now();
+      setTimeout(() => {
+        if (signal.cancelled) return;
+        const lag = performance.now() - before - QUIET_SAMPLE_MS;
+        quietSamples = lag < QUIET_LAG_MS ? quietSamples + 1 : 0;
+        if (quietSamples >= QUIET_SAMPLES_REQUIRED || performance.now() - startedAt >= QUIET_MAX_WAIT_MS) {
+          resolve();
+          return;
+        }
+        sample();
+      }, QUIET_SAMPLE_MS);
+    };
+    sample();
+  });
+}
+
+/**
+ * After startup settles, warms the snapshot and baseline chart of the
+ * instruments the other saved layouts would show, so switching layouts lands
+ * on cached data. Runs once per process, only while the app is active, and
+ * waits for a quiet main thread first so it never competes with the first
+ * paint or the user's first keystrokes.
+ */
+export function useSavedLayoutWarmup({
+  appActive,
+  config,
+  initialized,
+  prefetch,
+  tickers,
+}: {
+  appActive: boolean;
+  config: AppConfig;
+  initialized: boolean;
+  prefetch: (instrument: InstrumentRef) => void;
+  tickers: Map<string, TickerRecord>;
+}): void {
+  const started = useRef(false);
+  const latest = useRef({ appActive, config, prefetch, tickers });
+  latest.current = { appActive, config, prefetch, tickers };
+
+  useEffect(() => {
+    if (!initialized || !appActive || started.current) return;
+    started.current = true;
+    const signal = { cancelled: false };
+    const startedAt = performance.now();
+    void (async () => {
+      await whenMainThreadQuiet(signal);
+      if (signal.cancelled) return;
+      const { config: currentConfig, tickers: currentTickers } = latest.current;
+      const instruments = collectSavedLayoutInstruments(currentConfig, currentTickers);
+      recordPerfSample("startup.saved-layout-warmup", performance.now() - startedAt, {
+        count: instruments.length,
+        symbols: instruments.map((instrument) => instrument.symbol),
+      });
+      for (const instrument of instruments) {
+        if (signal.cancelled || !latest.current.appActive) return;
+        latest.current.prefetch(instrument);
+        await new Promise((resolve) => setTimeout(resolve, WARM_INTERVAL_MS));
+      }
+    })();
+    return () => {
+      signal.cancelled = true;
+    };
+  }, [appActive, initialized]);
+}