gloomberb 0.9.7 → 0.9.9

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

@@ -0,0 +1,496 @@
+import { useEffect, type Dispatch } from "react";
+import { getDockedPaneIds } from "../../plugins/pane-manager";
+import type { PluginRegistry } from "../../plugins/registry";
+import type { AppAction, AppState } from "../../state/app/context";
+import {
+  findPaneInstance,
+  resolveFollowBindingInstance,
+  TICKER_RESEARCH_PANE_ID,
+} from "../../types/config";
+import type { DesktopDeepLinkBridge } from "../../types/desktop-deeplink";
+import type { DesktopWindowBridge } from "../../types/desktop-window";
+
+type CloudDeepLinkRoute = {
+  kind: "cloud-alerts" | "cloud-roundup";
+  week: string | null;
+};
+
+type CollectionDeepLinkKind = "collection" | "portfolio" | "watchlist";
+type AlertDeepLinkCondition = "above" | "below" | "crosses";
+type NewsDeepLinkKind = "breaking" | "feed" | "ticker" | "top";
+
+export type DesktopDeepLinkAction =
+  | { type: "open-account-management"; route: CloudDeepLinkRoute; message: string }
+  | { type: "open-ticker"; symbol: string; tabId: string | null; message: string }
+  | { type: "open-collection"; kind: CollectionDeepLinkKind; collectionId: string; message: string }
+  | {
+      type: "create-alert";
+      values: { symbol: string; condition: AlertDeepLinkCondition; price: string };
+      message: string;
+    }
+  | { type: "open-chat-channel"; channelId: string; message: string }
+  | { type: "open-chat-dm"; participants: string; message: string }
+  | { type: "open-news"; kind: NewsDeepLinkKind; symbol: string | null; message: string }
+  | { type: "unsupported"; message: string };
+
+interface ParsedGloomUrl {
+  url: URL;
+  host: string;
+  segments: string[];
+}
+
+interface DesktopDeepLinkHandlerOptions {
+  dispatch: Dispatch<AppAction>;
+  pluginRegistry: PluginRegistry;
+  stateRef: { current: AppState };
+}
+
+function weekSuffix(week: string | null): string {
+  return week ? ` for ${week}` : "";
+}
+
+function safeDecode(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function splitPathSegments(pathname: string): string[] {
+  return pathname
+    .split("/")
+    .map((segment) => safeDecode(segment).trim())
+    .filter(Boolean);
+}
+
+function parseGloomUrl(rawUrl: string): ParsedGloomUrl | null {
+  let url: URL;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "gloomberb:") return null;
+
+  const host = url.hostname.trim().toLowerCase();
+  if (host) {
+    return { url, host, segments: splitPathSegments(url.pathname) };
+  }
+
+  const segments = splitPathSegments(url.pathname);
+  const opaqueHost = segments.shift()?.toLowerCase();
+  return opaqueHost ? { url, host: opaqueHost, segments } : null;
+}
+
+function param(url: URL, ...names: string[]): string | null {
+  for (const name of names) {
+    const value = url.searchParams.get(name)?.trim();
+    if (value) return value;
+  }
+  return null;
+}
+
+function normalizeSymbol(value: string | null | undefined): string | null {
+  const trimmed = value?.trim().replace(/^\$/, "");
+  if (!trimmed) return null;
+  return trimmed.toUpperCase();
+}
+
+function normalizeAlertCondition(value: string | null): AlertDeepLinkCondition | null {
+  switch (value?.trim().toLowerCase()) {
+    case ">":
+    case "above":
+    case "over":
+    case "gt":
+      return "above";
+    case "<":
+    case "below":
+    case "under":
+    case "lt":
+      return "below";
+    case "x":
+    case "cross":
+    case "crosses":
+      return "crosses";
+    default:
+      return null;
+  }
+}
+
+function normalizePrice(value: string | null): string | null {
+  const trimmed = value?.trim().replace(/^\$/, "");
+  if (!trimmed) return null;
+  const price = Number.parseFloat(trimmed);
+  return Number.isFinite(price) && price > 0 ? String(price) : null;
+}
+
+function tickerMessage(symbol: string, tabId: string | null): string {
+  return tabId ? `Opened ${symbol} ${tabId} tab.` : `Opened ${symbol}.`;
+}
+
+function collectionMessage(kind: CollectionDeepLinkKind, collectionId: string): string {
+  const label = kind === "watchlist" ? "watchlist" : kind === "portfolio" ? "portfolio" : "collection";
+  return `Opened ${label} ${collectionId}.`;
+}
+
+function parseCloudDeepLink(parsed: ParsedGloomUrl): DesktopDeepLinkAction {
+  const route = parsed.segments[0] ?? "";
+  const week = parsed.url.searchParams.get("week");
+  if (route === "roundup") {
+    return {
+      type: "open-account-management",
+      route: { kind: "cloud-roundup", week },
+      message: `Opened weekly roundup settings${weekSuffix(week)}.`,
+    };
+  }
+  if (route === "alerts") {
+    return {
+      type: "open-account-management",
+      route: { kind: "cloud-alerts", week },
+      message: `Opened portfolio alert settings${weekSuffix(week)}.`,
+    };
+  }
+  return { type: "unsupported", message: "Unsupported Gloomberb cloud link." };
+}
+
+function parseTickerDeepLink(parsed: ParsedGloomUrl): DesktopDeepLinkAction {
+  const symbol = normalizeSymbol(parsed.segments[0] ?? param(parsed.url, "symbol", "ticker"));
+  if (!symbol) return { type: "unsupported", message: "Ticker links need a symbol." };
+  const tabId = param(parsed.url, "tab");
+  return { type: "open-ticker", symbol, tabId, message: tickerMessage(symbol, tabId) };
+}
+
+function parseCollectionDeepLink(parsed: ParsedGloomUrl, kind: CollectionDeepLinkKind): DesktopDeepLinkAction {
+  const collectionId = parsed.segments[0] ?? param(parsed.url, "id", "collection");
+  if (!collectionId) return { type: "unsupported", message: "Collection links need an id." };
+  return {
+    type: "open-collection",
+    kind,
+    collectionId,
+    message: collectionMessage(kind, collectionId),
+  };
+}
+
+function parseAlertDeepLink(parsed: ParsedGloomUrl): DesktopDeepLinkAction {
+  if ((parsed.segments[0] ?? "new") !== "new") {
+    return { type: "unsupported", message: "Unsupported Gloomberb alert link." };
+  }
+  const symbol = normalizeSymbol(param(parsed.url, "symbol", "ticker"));
+  const condition = normalizeAlertCondition(param(parsed.url, "condition", "side", "trigger"));
+  const price = normalizePrice(param(parsed.url, "price", "target"));
+  if (!symbol || !condition || !price) {
+    return { type: "unsupported", message: "Alert links need symbol, condition, and price." };
+  }
+  return {
+    type: "create-alert",
+    values: { symbol, condition, price },
+    message: `Created ${symbol} ${condition} ${price} alert.`,
+  };
+}
+
+function parseChatDeepLink(parsed: ParsedGloomUrl): DesktopDeepLinkAction {
+  const route = parsed.segments[0] ?? "default";
+  if (route === "channel") {
+    const channelId = parsed.segments[1] ?? param(parsed.url, "id", "channel");
+    if (!channelId) return { type: "unsupported", message: "Chat channel links need a channel id." };
+    return { type: "open-chat-channel", channelId, message: `Opened chat ${channelId}.` };
+  }
+  if (route === "dm") {
+    const participants = param(parsed.url, "users", "participants", "user") ?? parsed.segments.slice(1).join(",");
+    if (!participants.trim()) return { type: "unsupported", message: "DM links need at least one username." };
+    return { type: "open-chat-dm", participants, message: "Opened DM." };
+  }
+  if (route === "default") {
+    return { type: "open-chat-channel", channelId: "", message: "Opened chat." };
+  }
+  return { type: "open-chat-channel", channelId: route, message: `Opened chat ${route}.` };
+}
+
+function parseNewsDeepLink(parsed: ParsedGloomUrl): DesktopDeepLinkAction {
+  const ticker = normalizeSymbol(param(parsed.url, "ticker", "symbol") ?? (parsed.segments[0] === "ticker" ? parsed.segments[1] : null));
+  if (ticker) return { type: "open-news", kind: "ticker", symbol: ticker, message: `Opened ${ticker} news.` };
+
+  const route = parsed.segments[0] ?? "top";
+  if (route === "breaking") {
+    return { type: "open-news", kind: "breaking", symbol: null, message: "Opened breaking news." };
+  }
+  if (route === "feed") {
+    return { type: "open-news", kind: "feed", symbol: null, message: "Opened news feed." };
+  }
+  if (route === "top") {
+    return { type: "open-news", kind: "top", symbol: null, message: "Opened top news." };
+  }
+  return { type: "unsupported", message: "Unsupported Gloomberb news link." };
+}
+
+export function resolveDesktopDeepLinkAction(rawUrl: string): DesktopDeepLinkAction {
+  const parsed = parseGloomUrl(rawUrl);
+  if (!parsed) return { type: "unsupported", message: "Unsupported Gloomberb link." };
+
+  switch (parsed.host) {
+    case "cloud":
+      return parseCloudDeepLink(parsed);
+    case "ticker":
+      return parseTickerDeepLink(parsed);
+    case "portfolio":
+      return parseCollectionDeepLink(parsed, "portfolio");
+    case "watchlist":
+      return parseCollectionDeepLink(parsed, "watchlist");
+    case "collection":
+      return parseCollectionDeepLink(parsed, "collection");
+    case "alert":
+      return parseAlertDeepLink(parsed);
+    case "chat":
+      return parseChatDeepLink(parsed);
+    case "news":
+      return parseNewsDeepLink(parsed);
+    default:
+      return { type: "unsupported", message: "Unsupported Gloomberb link." };
+  }
+}
+
+function notifyError(pluginRegistry: PluginRegistry, body: string): void {
+  pluginRegistry.notify({ body, type: "error" });
+}
+
+function notifySuccess(pluginRegistry: PluginRegistry, body: string): void {
+  pluginRegistry.notify({ body, type: "success" });
+}
+
+function requirePane(pluginRegistry: PluginRegistry, paneId: string, unavailableMessage: string): boolean {
+  if (pluginRegistry.panes.has(paneId)) return true;
+  notifyError(pluginRegistry, unavailableMessage);
+  return false;
+}
+
+function resolveCollectionRecord(
+  state: AppState,
+  action: Extract<DesktopDeepLinkAction, { type: "open-collection" }>,
+): { name?: string } | null {
+  const portfolio = state.config.portfolios.find((entry) => entry.id === action.collectionId);
+  const watchlist = state.config.watchlists.find((entry) => entry.id === action.collectionId);
+  if (action.kind === "portfolio") return portfolio ?? null;
+  if (action.kind === "watchlist") return watchlist ?? null;
+  return portfolio ?? watchlist ?? null;
+}
+
+function visiblePaneIds(state: AppState): Set<string> {
+  return new Set([
+    ...getDockedPaneIds(state.config.layout),
+    ...state.config.layout.floating.map((entry) => entry.instanceId),
+    ...state.config.layout.detached.map((entry) => entry.instanceId),
+  ]);
+}
+
+function isVisiblePane(state: AppState, paneId: string | null | undefined): paneId is string {
+  return !!paneId && visiblePaneIds(state).has(paneId);
+}
+
+function resolveVisibleCollectionPaneId(state: AppState): string | null {
+  const followedPaneId = resolveFollowBindingInstance(
+    state.config.layout,
+    state.focusedPaneId,
+    (instance) => instance.paneId === "portfolio-list",
+  )?.instanceId;
+  if (isVisiblePane(state, followedPaneId)) return followedPaneId;
+
+  const focusedPane = state.focusedPaneId ? findPaneInstance(state.config.layout, state.focusedPaneId) : null;
+  if (focusedPane?.paneId === "portfolio-list" && isVisiblePane(state, focusedPane.instanceId)) {
+    return focusedPane.instanceId;
+  }
+
+  const visibleIds = visiblePaneIds(state);
+  return state.config.layout.instances.find((instance) => (
+    instance.paneId === "portfolio-list" && visibleIds.has(instance.instanceId)
+  ))?.instanceId ?? null;
+}
+
+function applyCollectionSelection(
+  collectionId: string,
+  { dispatch, stateRef }: Pick<DesktopDeepLinkHandlerOptions, "dispatch" | "stateRef">,
+): boolean {
+  const targetPaneId = resolveVisibleCollectionPaneId(stateRef.current);
+  if (!targetPaneId) return false;
+  dispatch({ type: "UPDATE_PANE_STATE", paneId: targetPaneId, patch: { collectionId } });
+  dispatch({ type: "FOCUS_PANE", paneId: targetPaneId });
+  return true;
+}
+
+function retryCollectionSelection(
+  collectionId: string,
+  options: Pick<DesktopDeepLinkHandlerOptions, "dispatch" | "stateRef">,
+): void {
+  globalThis.setTimeout(() => {
+    applyCollectionSelection(collectionId, options);
+  }, 50);
+}
+
+function handleOpenTicker(
+  action: Extract<DesktopDeepLinkAction, { type: "open-ticker" }>,
+  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;
+  }
+
+  pluginRegistry.pinTicker(action.symbol, {
+    floating: true,
+    paneType: TICKER_RESEARCH_PANE_ID,
+  });
+
+  if (action.tabId) {
+    globalThis.setTimeout(() => {
+      pluginRegistry.switchTab(action.tabId!);
+    }, 80);
+  }
+  notifySuccess(pluginRegistry, action.message);
+}
+
+function handleOpenCollection(
+  action: Extract<DesktopDeepLinkAction, { type: "open-collection" }>,
+  options: DesktopDeepLinkHandlerOptions,
+): void {
+  const collection = resolveCollectionRecord(options.stateRef.current, action);
+  if (!collection) {
+    notifyError(options.pluginRegistry, `Collection "${action.collectionId}" is unavailable.`);
+    return;
+  }
+  if (!requirePane(options.pluginRegistry, "portfolio-list", "Collections are unavailable.")) return;
+
+  options.pluginRegistry.showPane("portfolio-list");
+  if (!applyCollectionSelection(action.collectionId, options)) {
+    retryCollectionSelection(action.collectionId, options);
+  }
+  notifySuccess(options.pluginRegistry, collection.name ? `Opened ${collection.name}.` : action.message);
+}
+
+function handleCreateAlert(
+  action: Extract<DesktopDeepLinkAction, { type: "create-alert" }>,
+  pluginRegistry: PluginRegistry,
+): void {
+  const command = pluginRegistry.commands.get("set-alert");
+  if (!command) {
+    notifyError(pluginRegistry, "Alerts are unavailable.");
+    return;
+  }
+  void Promise.resolve(command.execute(action.values)).catch((error) => {
+    notifyError(pluginRegistry, error instanceof Error ? error.message : "Failed to create alert.");
+  });
+}
+
+function handleOpenChatChannel(
+  action: Extract<DesktopDeepLinkAction, { type: "open-chat-channel" }>,
+  pluginRegistry: PluginRegistry,
+): void {
+  if (!pluginRegistry.paneTemplates.has("new-chat-pane")) {
+    notifyError(pluginRegistry, "Chat is unavailable.");
+    return;
+  }
+  const options = action.channelId ? { arg: action.channelId } : undefined;
+  void pluginRegistry.createPaneFromTemplateAsyncFn("new-chat-pane", options).then(() => {
+    notifySuccess(pluginRegistry, action.message);
+  }).catch((error) => {
+    notifyError(pluginRegistry, error instanceof Error ? error.message : "Failed to open chat.");
+  });
+}
+
+function handleOpenChatDm(
+  action: Extract<DesktopDeepLinkAction, { type: "open-chat-dm" }>,
+  pluginRegistry: PluginRegistry,
+): void {
+  const command = pluginRegistry.commands.get("direct-message");
+  if (!command) {
+    notifyError(pluginRegistry, "Direct messages are unavailable.");
+    return;
+  }
+  void Promise.resolve(command.execute({ participants: action.participants })).then(() => {
+    notifySuccess(pluginRegistry, action.message);
+  }).catch((error) => {
+    notifyError(pluginRegistry, error instanceof Error ? error.message : "Failed to open DM.");
+  });
+}
+
+function handleOpenNews(
+  action: Extract<DesktopDeepLinkAction, { type: "open-news" }>,
+  pluginRegistry: PluginRegistry,
+): void {
+  if (action.kind === "ticker") {
+    if (!action.symbol || !pluginRegistry.paneTemplates.has("ticker-news-pane")) {
+      notifyError(pluginRegistry, "Ticker news is unavailable.");
+      return;
+    }
+    void pluginRegistry.createPaneFromTemplateAsyncFn("ticker-news-pane", { symbol: action.symbol }).then(() => {
+      notifySuccess(pluginRegistry, action.message);
+    }).catch((error) => {
+      notifyError(pluginRegistry, error instanceof Error ? error.message : "Failed to open ticker news.");
+    });
+    return;
+  }
+
+  const paneId = action.kind === "breaking"
+    ? "news-breaking"
+    : action.kind === "feed"
+      ? "news-feed"
+      : "news-top";
+  if (!requirePane(pluginRegistry, paneId, "News is unavailable.")) return;
+  pluginRegistry.showPane(paneId);
+  notifySuccess(pluginRegistry, action.message);
+}
+
+export function handleDesktopDeepLink(rawUrl: string, options: DesktopDeepLinkHandlerOptions): void {
+  const action = resolveDesktopDeepLinkAction(rawUrl);
+  if (action.type === "unsupported") {
+    notifyError(options.pluginRegistry, action.message);
+    return;
+  }
+
+  switch (action.type) {
+    case "open-account-management":
+      if (!requirePane(options.pluginRegistry, "account-management", "Account management is unavailable.")) return;
+      options.pluginRegistry.showPane("account-management");
+      notifySuccess(options.pluginRegistry, action.message);
+      return;
+    case "open-ticker":
+      handleOpenTicker(action, options.pluginRegistry);
+      return;
+    case "open-collection":
+      handleOpenCollection(action, options);
+      return;
+    case "create-alert":
+      handleCreateAlert(action, options.pluginRegistry);
+      return;
+    case "open-chat-channel":
+      handleOpenChatChannel(action, options.pluginRegistry);
+      return;
+    case "open-chat-dm":
+      handleOpenChatDm(action, options.pluginRegistry);
+      return;
+    case "open-news":
+      handleOpenNews(action, options.pluginRegistry);
+      return;
+  }
+}
+
+export function useDesktopDeepLinkRuntime({
+  desktopDeepLinkBridge,
+  desktopWindowKind,
+  dispatch,
+  pluginRegistry,
+  stateRef,
+}: {
+  desktopDeepLinkBridge?: DesktopDeepLinkBridge;
+  desktopWindowKind?: DesktopWindowBridge["kind"];
+  dispatch: Dispatch<AppAction>;
+  pluginRegistry: PluginRegistry;
+  stateRef: { current: AppState };
+}) {
+  useEffect(() => {
+    if (desktopWindowKind !== "main" || !desktopDeepLinkBridge) return;
+    return desktopDeepLinkBridge.subscribe((deeplink) => {
+      handleDesktopDeepLink(deeplink.url, { dispatch, pluginRegistry, stateRef });
+    });
+  }, [desktopDeepLinkBridge, desktopWindowKind, dispatch, pluginRegistry, stateRef]);
+}

package/src/app.tsx

@@ -22,6 +22,7 @@ import { PluginRegistry } from "./plugins/registry";
 import type { TickerRepository } from "./data/ticker-repository";
 import { ThemeProvider, useThemeColors } from "./theme/theme-context";
 import type { AppConfig } from "./types/config";
+import type { DesktopDeepLinkBridge } from "./types/desktop-deeplink";
 import type { CliLaunchRequest } from "./types/plugin";
 import type { DataProvider } from "./types/data-provider";
 import type { DesktopDockPreviewState, DesktopSharedStateSnapshot, DesktopThemePreviewState, DesktopWindowBridge } from "./types/desktop-window";
@@ -32,6 +33,7 @@ import type { MarketDataCoordinator } from "./market-data/coordinator";
 import { createAppNotifier } from "./notifications/app-notifier";
 import { createAppServices } from "./core/app-services";
 import { useBrokerImportRuntime } from "./app/runtime/broker-import";
+import { useDesktopDeepLinkRuntime } from "./app/runtime/desktop-deeplink";
 import { useDesktopApplicationMenuRuntime } from "./app/runtime/desktop-menu";
 import { useAppGlobalShortcuts } from "./app/global-shortcuts";
 import { useAppPaneRuntime } from "./app/pane-runtime";
@@ -39,6 +41,8 @@ import { bindPluginRegistryRuntimeAccess } from "./app/runtime/plugin-bindings";
 import { useAppStartupRuntime } from "./app/runtime/startup";
 import { useTickerRefreshRuntime } from "./app/runtime/ticker-refresh";
 import { useAppUpdateRuntime } from "./app/runtime/update";
+import { createCoreSyncContributors } from "./sync/core-contributors";
+import { useCloudSyncRuntime } from "./sync/react";
 import { RemoteControlHost, type RemoteControlAdapter } from "./remote/app-host";
 import { RemoteUiRegistryProvider } from "./remote/semantic-tree";
 import {
@@ -57,6 +61,7 @@ interface AppInnerProps {
   sessionSnapshot?: AppSessionSnapshot | null;
   desktopWindowBridge?: DesktopWindowBridge;
   desktopApplicationMenuBridge?: DesktopApplicationMenuBridge;
+  desktopDeepLinkBridge?: DesktopDeepLinkBridge;
   remoteControlAdapter?: RemoteControlAdapter;
 }
 
@@ -86,6 +91,7 @@ function AppInner({
   sessionSnapshot = null,
   desktopWindowBridge,
   desktopApplicationMenuBridge,
+  desktopDeepLinkBridge,
   remoteControlAdapter,
 }: AppInnerProps) {
   const dispatch = useAppDispatch();
@@ -173,6 +179,15 @@ function AppInner({
     });
   }, [desktopWindowBridge]);
 
+  useEffect(() => {
+    const disposers = createCoreSyncContributors().map((contributor) => (
+      pluginRegistry.registerSyncContributorForPlugin("core", contributor)
+    ));
+    return () => {
+      for (const dispose of disposers) dispose();
+    };
+  }, [pluginRegistry]);
+
   const {
     primeCachedFinancials,
     refreshQuote,
@@ -214,6 +229,14 @@ function AppInner({
     stateRef,
   });
 
+  useDesktopDeepLinkRuntime({
+    desktopDeepLinkBridge,
+    desktopWindowKind: desktopWindowBridge?.kind,
+    dispatch,
+    pluginRegistry,
+    stateRef,
+  });
+
   const focusedTickerSymbol = getFocusedTickerSymbol(state);
   useAppStartupRuntime({
     appActive,
@@ -243,6 +266,14 @@ function AppInner({
     tickerRepository,
   });
 
+  useCloudSyncRuntime({
+    state,
+    dispatch,
+    tickerRepository,
+    pluginRegistry,
+    initialized: state.initialized && desktopWindowBridge?.kind !== "detached",
+  });
+
   useAppPaneRuntime({
     dataProvider,
     detachedPaneId,
@@ -353,6 +384,7 @@ interface AppProps {
   cliLaunchRequest?: CliLaunchRequest | null;
   desktopWindowBridge?: DesktopWindowBridge;
   desktopApplicationMenuBridge?: DesktopApplicationMenuBridge;
+  desktopDeepLinkBridge?: DesktopDeepLinkBridge;
   desktopSnapshot?: DesktopSharedStateSnapshot | null;
   desktopThemePreview?: DesktopThemePreviewState | null;
   remoteControlAdapter?: RemoteControlAdapter;
@@ -364,6 +396,7 @@ export function App({
   cliLaunchRequest = null,
   desktopWindowBridge,
   desktopApplicationMenuBridge,
+  desktopDeepLinkBridge,
   desktopSnapshot = null,
   desktopThemePreview = null,
   remoteControlAdapter,
@@ -451,6 +484,7 @@ export function App({
           sessionSnapshot={sessionSnapshot}
           desktopWindowBridge={desktopWindowBridge}
           desktopApplicationMenuBridge={desktopApplicationMenuBridge}
+          desktopDeepLinkBridge={desktopDeepLinkBridge}
           remoteControlAdapter={remoteControlAdapter}
         />
       </AppProvider>

package/src/brokers/account-cache.ts

@@ -3,6 +3,7 @@ import type { BrokerAdapter } from "../types/broker";
 import type { BrokerInstanceConfig } from "../types/config";
 import type { CachePolicy } from "../types/persistence";
 import type { BrokerAccount } from "../types/trading";
+import { fnv1aHashString } from "../utils/hash";
 
 const BROKER_ACCOUNT_SNAPSHOT_KIND = "account-snapshot";
 const BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -16,15 +17,6 @@ interface PersistedBrokerAccountSnapshot {
   brokerType?: string;
 }
 
-function hashString(input: string): string {
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < input.length; index += 1) {
-    hash ^= input.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return `fnv1a:${(hash >>> 0).toString(16).padStart(8, "0")}`;
-}
-
 function brokerAccountNamespace(instance: BrokerInstanceConfig): string {
   return `plugin:${instance.brokerType}`;
 }
@@ -36,7 +28,7 @@ export function getBrokerAccountCacheSourceKey(
   if (broker?.getAccountCacheSourceKey) {
     return broker.getAccountCacheSourceKey(instance);
   }
-  return hashString(JSON.stringify({
+  return fnv1aHashString(JSON.stringify({
     brokerType: instance.brokerType,
     config: broker?.toConfigValues?.(instance) ?? instance.config,
   }));

package/src/brokers/broker-portfolio-sync.ts

@@ -1,5 +1,4 @@
 import type { AppConfig, BrokerInstanceConfig } from "../types/config";
-import type { BrokerContractRef } from "../types/instrument";
 import type { Portfolio, TickerPosition, TickerRecord } from "../types/ticker";
 import { buildBrokerPortfolioId, getBrokerInstance, isBrokerPortfolioId } from "../utils/broker-instances";
 

package/src/brokers/broker-ticker-sync.ts

@@ -78,29 +78,33 @@ function updateExistingTicker(
   positionEntry: TickerPosition,
   brokerContract?: BrokerContractRef,
 ): TickerRecord {
-  if (position.name && ticker.metadata.name === ticker.metadata.ticker) {
-    ticker.metadata.name = position.name;
-  }
-  if (position.assetCategory && !ticker.metadata.assetCategory) {
-    ticker.metadata.assetCategory = position.assetCategory;
-  }
-  if (position.isin && !ticker.metadata.isin) {
-    ticker.metadata.isin = position.isin;
-  }
-
   const otherPositions = ticker.metadata.positions.filter(
     (entry) => !(entry.portfolio === portfolioId && entry.broker === instance.brokerType),
   );
-  ticker.metadata.positions = [...otherPositions, positionEntry];
-  ticker.metadata.broker_contracts = mergeBrokerContracts(
+  const brokerContracts = mergeBrokerContracts(
     ticker.metadata.broker_contracts ?? [],
     brokerContract ? [brokerContract] : [],
   );
-  if (!ticker.metadata.portfolios.includes(portfolioId)) {
-    ticker.metadata.portfolios.push(portfolioId);
-  }
+  const portfolios = ticker.metadata.portfolios.includes(portfolioId)
+    ? ticker.metadata.portfolios
+    : [...ticker.metadata.portfolios, portfolioId];
 
-  return ticker;
+  return {
+    ...ticker,
+    metadata: {
+      ...ticker.metadata,
+      name: position.name && ticker.metadata.name === ticker.metadata.ticker
+        ? position.name
+        : ticker.metadata.name,
+      assetCategory: position.assetCategory && !ticker.metadata.assetCategory
+        ? position.assetCategory
+        : ticker.metadata.assetCategory,
+      isin: position.isin && !ticker.metadata.isin ? position.isin : ticker.metadata.isin,
+      positions: [...otherPositions, positionEntry],
+      broker_contracts: brokerContracts,
+      portfolios,
+    },
+  };
 }
 
 export async function upsertBrokerPositionTicker({