gloomberb 0.11.0 → 0.11.2

package/src/sync/core-contributors.ts

@@ -307,6 +307,15 @@ function collectAccountsByPortfolio(
   return output;
 }
 
+type SanitizedTickerMetadata = ReturnType<typeof sanitizeTickerMetadata>;
+
+/** Only tickers the user actually filed somewhere are worth syncing. */
+function isSyncableTicker(metadata: Pick<SanitizedTickerMetadata, "portfolios" | "watchlists" | "positions">): boolean {
+  return metadata.portfolios.length > 0
+    || metadata.watchlists.length > 0
+    || metadata.positions.length > 0;
+}
+
 function collectCoreCollectionsPayload(
   config: AppConfig,
   tickers: Map<string, TickerRecord>,
@@ -316,11 +325,7 @@ function collectCoreCollectionsPayload(
 ) {
   const records = [...tickers.values()]
     .map((ticker) => sanitizeTickerMetadata(ticker.metadata, financials.get(ticker.metadata.ticker)))
-    .filter((metadata) => (
-      metadata.portfolios.length > 0 ||
-      metadata.watchlists.length > 0 ||
-      metadata.positions.length > 0
-    ));
+    .filter(isSyncableTicker);
 
   return {
     baseCurrency: config.baseCurrency,
@@ -375,11 +380,22 @@ function mergeConfigPayload(
   config: AppConfig,
   payload: unknown,
   baselineConfig: AppConfig = config,
+  lastSyncedPayload?: unknown,
 ): AppConfig | null {
   if (!isPlainObject(payload)) return null;
   const next: AppConfig = { ...config };
+  // Two guards, both needed. baselineConfig catches edits made while this pull
+  // was in flight; lastSyncedPayload catches edits made while the app was not
+  // running at all (CLI writes, offline edits), which otherwise look pristine.
+  const lastSynced = isPlainObject(lastSyncedPayload) ? lastSyncedPayload : null;
+  const localPayload = lastSynced
+    ? collectCoreConfigPayload(config) as Record<string, unknown>
+    : null;
+  const matchesLastSynced = (key: string) => (
+    !lastSynced || valuesEqual(localPayload?.[key], lastSynced[key])
+  );
   const canApply = <K extends keyof AppConfig>(key: K) => (
-    valuesEqual(config[key], baselineConfig[key])
+    valuesEqual(config[key], baselineConfig[key]) && matchesLastSynced(key as string)
   );
   const assign = <K extends keyof AppConfig>(key: K) => {
     if (key in payload && canApply(key)) {
@@ -420,7 +436,8 @@ function mergeConfigPayload(
 
   const layoutStateUntouched = config.layout === baselineConfig.layout
     && config.layouts === baselineConfig.layouts
-    && config.activeLayoutIndex === baselineConfig.activeLayoutIndex;
+    && config.activeLayoutIndex === baselineConfig.activeLayoutIndex
+    && ["layout", "layouts", "activeLayoutIndex"].every(matchesLastSynced);
   if (
     layoutStateUntouched
     && ["layout", "layouts", "activeLayoutIndex"].every((key) => key in payload)
@@ -450,12 +467,40 @@ function mergeConfigPayload(
   return next;
 }
 
+function lastSyncedTickersById(baselinePayload: unknown): Map<string, Record<string, unknown>> | null {
+  if (!isPlainObject(baselinePayload) || !Array.isArray(baselinePayload.tickers)) return null;
+  const byId = new Map<string, Record<string, unknown>>();
+  for (const entry of baselinePayload.tickers) {
+    if (isPlainObject(entry) && typeof entry.ticker === "string") byId.set(entry.ticker, entry);
+  }
+  return byId;
+}
+
+/** Quotes churn on every refresh, so they cannot signal a user edit. */
+function withoutQuote(metadata: Record<string, unknown>): Record<string, unknown> {
+  const { quote: _quote, ...rest } = metadata;
+  return rest;
+}
+
+function tickerChangedSinceLastSync(
+  current: TickerRecord | null | undefined,
+  lastSyncedTickers: Map<string, Record<string, unknown>> | null,
+): boolean {
+  if (!lastSyncedTickers || !current) return false;
+  const local = sanitizeTickerMetadata(current.metadata);
+  const baseline = lastSyncedTickers.get(current.metadata.ticker);
+  // No baseline entry means this device never uploaded the ticker: filed
+  // locally it is unsynced work, unfiled it is not something sync tracks.
+  if (!baseline) return isSyncableTicker(local);
+  return !valuesEqual(withoutQuote(local), withoutQuote(baseline));
+}
+
 export const coreConfigSyncContributor: SyncContributor = {
   id: "core.config",
   schemaVersion: 1,
   collect: ({ state }) => collectCoreConfigPayload(state.config),
-  apply: (payload, { baselineState, state, dispatch }) => {
-    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config);
+  apply: (payload, { baselinePayload, baselineState, state, dispatch }) => {
+    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload);
     if (!nextConfig || valuesEqual(nextConfig, state.config)) return;
     dispatch({ type: "SET_CONFIG", config: nextConfig });
     scheduleConfigSave(nextConfig);
@@ -472,9 +517,10 @@ export const coreCollectionsSyncContributor: SyncContributor = {
     state.exchangeRates,
     state.brokerAccounts,
   ),
-  apply: async (payload, { getState, isCurrent, dispatch, tickerRepository }) => {
+  apply: async (payload, { baselinePayload, getState, isCurrent, dispatch, tickerRepository }) => {
     if (!isPlainObject(payload)) return;
     hydrateProfileAnalytics(payload);
+    const lastSyncedTickers = lastSyncedTickersById(baselinePayload);
     const incomingRecords: TickerRecord[] = [];
     const rawTickers = Array.isArray(payload.tickers) ? payload.tickers : [];
     for (const rawTicker of rawTickers) {
@@ -483,6 +529,9 @@ export const coreCollectionsSyncContributor: SyncContributor = {
       const current = typeof rawTicker.ticker === "string"
         ? getState().tickers.get(rawTicker.ticker)
         : null;
+      // Local edits the cloud has never seen (CLI positions, offline changes)
+      // win here and are uploaded by the push that follows this pull.
+      if (tickerChangedSinceLastSync(current, lastSyncedTickers)) continue;
       const metadata = hydrateTickerMetadata({
         ...current?.metadata,
         ...rawTicker,

package/src/sync/react.ts

@@ -1,11 +1,14 @@
-import { useEffect, useSyncExternalStore, type Dispatch } from "react";
+import { useEffect, useMemo, useSyncExternalStore, type Dispatch } from "react";
 import type { AppAction, AppState } from "../core/state/app/state";
 import type { AppTickerRepositoryPort } from "../core/app-service-ports";
 import { apiClient } from "../api-client";
 import type { PluginRegistry } from "../plugins/registry";
 import { subscribeToCloudVerification } from "./auth-transition";
+import { createSyncBaselineStore } from "./baseline";
 import { cloudSyncController } from "./controller";
 
+const CLOUD_SYNC_POLL_MS = 15_000;
+
 interface CloudSyncRuntimeOptions {
   state: AppState;
   getState: () => AppState;
@@ -13,6 +16,7 @@ interface CloudSyncRuntimeOptions {
   tickerRepository: AppTickerRepositoryPort;
   pluginRegistry: PluginRegistry;
   initialized: boolean;
+  appActive?: boolean;
 }
 
 export function useCloudSyncRuntime({
@@ -22,22 +26,38 @@ export function useCloudSyncRuntime({
   tickerRepository,
   pluginRegistry,
   initialized,
+  appActive = true,
 }: CloudSyncRuntimeOptions): void {
+  const baselineStore = useMemo(
+    () => createSyncBaselineStore(pluginRegistry.persistence.pluginState),
+    [pluginRegistry],
+  );
+
   useEffect(() => {
     return cloudSyncController.setRuntime({
       getState,
       dispatch,
       tickerRepository,
+      baselineStore,
       getContributors: () => pluginRegistry.getEnabledSyncContributors(),
       getTransport: () => pluginRegistry.getActiveSyncTransport(),
     });
-  }, [dispatch, getState, pluginRegistry, tickerRepository]);
+  }, [baselineStore, dispatch, getState, pluginRegistry, tickerRepository]);
 
   useEffect(() => {
     if (!initialized) return;
     void cloudSyncController.requestSync({ reason: "startup" });
   }, [initialized, pluginRegistry]);
 
+  useEffect(() => {
+    if (!initialized || !appActive) return;
+    void cloudSyncController.requestSync({ reason: "foreground" });
+    const timer = setInterval(() => {
+      void cloudSyncController.requestSync({ reason: "poll" });
+    }, CLOUD_SYNC_POLL_MS);
+    return () => clearInterval(timer);
+  }, [appActive, initialized]);
+
   useEffect(() => subscribeToCloudVerification(apiClient, () => {
     if (!initialized) return;
     // Email verification makes the Cloud transport available. Force the first

package/src/sync/types.ts

@@ -26,6 +26,12 @@ export interface SyncCollectContext {
 export interface SyncApplyContext {
   snapshot: SyncSnapshot;
   baselineState: AppState;
+  /**
+   * The payload this device last pushed for this contributor, or null when it
+   * never synced. Anything that differs from it is local work the cloud has
+   * never seen (CLI edits, offline edits) and must survive the pull.
+   */
+  baselinePayload: unknown;
   state: AppState;
   getState: () => AppState;
   isCurrent: () => boolean;
@@ -69,6 +75,12 @@ export interface SyncSettings {
   lastRoundupEmailAt?: string | null;
 }
 
+/** Durable record of the payloads this device last pushed to the cloud. */
+export interface SyncBaselineStore {
+  load(): Record<string, unknown> | null;
+  save(payloads: Record<string, unknown>): void;
+}
+
 export interface RegisteredSyncContributor {
   pluginId: string;
   contributor: SyncContributor;

package/src/theme/font-scale.ts

@@ -28,10 +28,6 @@ export function clampFontSize(value: unknown): number {
   return Math.min(MAX_FONT_SIZE_PX, Math.max(MIN_FONT_SIZE_PX, Math.round(numeric)));
 }
 
-export function getFontSize(): number {
-  return appliedFontSizePx;
-}
-
 function roundToHundredth(value: number): number {
   return Math.round(value * 100) / 100;
 }
@@ -60,10 +56,3 @@ export function syncFontScale(fontSizePx: unknown): boolean {
   appliedToDocument = true;
   return true;
 }
-
-export function resetFontScaleForTests(): void {
-  appliedFontSizePx = BASE_FONT_SIZE_PX;
-  appliedToDocument = false;
-  WEB_CELL_WIDTH = BASE_CELL_WIDTH_PX;
-  WEB_CELL_HEIGHT = BASE_CELL_HEIGHT_PX;
-}

package/src/tickers/search/index.test.ts

@@ -521,6 +521,33 @@ describe("ticker-search utilities", () => {
     expect(saved).toHaveLength(1);
   });
 
+  test("replaces a saved listing when search selects a different exchange", async () => {
+    const existing = makeTicker("AAPL", "Apple Inc.");
+    existing.metadata.exchange = "NASDAQ";
+    existing.metadata.currency = "USD";
+    const saved: TickerRecord[] = [];
+    const repository = {
+      loadTicker: async () => existing,
+      createTicker: async (metadata: TickerRecord["metadata"]) => ({ metadata }),
+      saveTicker: async (ticker: TickerRecord) => {
+        saved.push(ticker);
+      },
+    };
+
+    const { ticker } = await upsertTickerFromSearchResult(repository as any, {
+      providerId: "test",
+      symbol: "AAPL",
+      name: "Apple Inc.",
+      exchange: "BYMA",
+      type: "EQUITY",
+      currency: "ARS",
+    });
+
+    expect(ticker.metadata.exchange).toBe("BYMA");
+    expect(ticker.metadata.currency).toBe("ARS");
+    expect(saved).toHaveLength(1);
+  });
+
   test("exposes local ticker candidates in saved category", () => {
     expect(createLocalTickerSearchCandidates([makeTicker("TSLA", "Tesla")])).toEqual([
       expect.objectContaining({

package/src/tickers/search/upsert.ts

@@ -8,6 +8,7 @@ import {
   getSearchResultSymbol,
   shouldReplaceTickerName,
 } from "./result";
+import { canonicalExchange } from "../../utils/exchanges";
 
 export async function upsertTickerFromSearchResult(
   tickerRepository: AppTickerRepositoryPort,
@@ -70,6 +71,15 @@ function mergeTickerMetadataFromSearchResult(metadata: TickerMetadata, result: I
   if (nextExchange && !metadata.exchange) {
     metadata.exchange = nextExchange;
     changed = true;
+  } else if (
+    nextExchange
+    && metadata.exchange
+    && canonicalExchange(nextExchange) !== canonicalExchange(metadata.exchange)
+  ) {
+    metadata.exchange = nextExchange;
+    if (nextName) metadata.name = nextName;
+    if (nextCurrency) metadata.currency = nextCurrency;
+    changed = true;
   }
   if (nextCurrency && !metadata.currency) {
     metadata.currency = nextCurrency;

package/src/types/capability-route-source.ts

@@ -1,11 +1,12 @@
 import type { AssetDataProvider } from "./data-provider";
-import type { NewsArticle, NewsQuery } from "../news/types";
+import type { NewsArticle, NewsPage, NewsQuery } from "../news/types";
 import type { CachePolicyMap } from "./persistence";
 
 export interface NewsDataProvider {
   supports?(query: NewsQuery): boolean;
   getCachedNews?(query: NewsQuery): NewsArticle[];
   fetchNews(query: NewsQuery): Promise<NewsArticle[]>;
+  fetchNewsPage?(query: NewsQuery): Promise<NewsPage>;
   fetchNewsStory?(storyId: string): Promise<NewsArticle | null>;
 }
 

package/src/types/config.ts

@@ -504,7 +504,11 @@ export function removePaneInstances(layout: LayoutConfig, instanceIds: Iterable<
 
 export function normalizePaneLayout(
   layout: LayoutConfig,
-  options?: { defaultFollowSourceInstanceId?: string | null },
+  options?: {
+    defaultFollowSourceInstanceId?: string | null;
+    /** Last resolved symbol used to pin an orphaned follower; otherwise it remains safely unlinked. */
+    resolveOrphanSymbol?: (instanceId: string) => string | null;
+  },
 ): LayoutConfig {
   const fallbackSourceId = options?.defaultFollowSourceInstanceId ?? null;
   const fallbackAvailable = !!fallbackSourceId && layout.instances.some((instance) => instance.instanceId === fallbackSourceId);
@@ -530,14 +534,27 @@ export function normalizePaneLayout(
   for (;;) {
     const validInstanceIds = new Set(nextLayout.instances.map((instance) => instance.instanceId));
     const removedIds = new Set<string>();
+    const orphanBindings = new Map<string, PaneBinding>();
 
     for (const instance of nextLayout.instances) {
       if (instance.binding?.kind === "follow" && !validInstanceIds.has(instance.binding.sourceInstanceId)) {
-        removedIds.add(instance.instanceId);
+        // Structural helpers remove the source before the app can resolve its last ticker. Preserve
+        // the dangling binding until the runtime normalizes again with a resolver.
+        if (!options?.resolveOrphanSymbol) continue;
+        const orphanSymbol = options.resolveOrphanSymbol(instance.instanceId)?.trim();
+        orphanBindings.set(
+          instance.instanceId,
+          orphanSymbol ? { kind: "fixed", symbol: orphanSymbol } : { kind: "none" },
+        );
         continue;
       }
 
-      if (isTickerPaneInstance(instance) && instance.binding?.kind !== "follow" && instance.binding?.kind !== "fixed") {
+      if (
+        isTickerPaneInstance(instance)
+        && instance.paneId !== TICKER_RESEARCH_PANE_ID
+        && instance.binding?.kind !== "follow"
+        && instance.binding?.kind !== "fixed"
+      ) {
         removedIds.add(instance.instanceId);
         continue;
       }
@@ -547,8 +564,21 @@ export function normalizePaneLayout(
       }
     }
 
-    if (removedIds.size === 0) break;
-    nextLayout = removePaneInstances(nextLayout, removedIds);
+    if (orphanBindings.size > 0) {
+      nextLayout = {
+        ...nextLayout,
+        instances: nextLayout.instances.map((instance) => {
+          const binding = orphanBindings.get(instance.instanceId);
+          return binding ? { ...instance, binding } : instance;
+        }),
+      };
+    }
+
+    if (removedIds.size > 0) {
+      nextLayout = removePaneInstances(nextLayout, removedIds);
+      continue;
+    }
+    if (orphanBindings.size === 0) break;
   }
 
   const validInstanceIds = new Set(nextLayout.instances.map((instance) => instance.instanceId));

package/src/types/desktop-menu.ts

@@ -4,6 +4,7 @@ export type DesktopApplicationMenuCommand =
   | { type: "open-url"; url: string }
   | { type: "check-for-updates" }
   | { type: "toggle-status-bar" }
+  | { type: "open-layout-gallery" }
   | { type: "layout-undo" }
   | { type: "layout-redo" }
   | { type: "layout-gridlock" };

package/src/types/plugin.ts

@@ -44,6 +44,18 @@ export interface PaneProps {
   close?: () => void;
 }
 
+export type PaneSharePrivateFields = true | readonly string[];
+
+export interface PanePortableShareDef {
+  /** Fields excluded before pane configuration or state leaves the device. */
+  private?: {
+    title?: boolean;
+    params?: PaneSharePrivateFields;
+    settings?: PaneSharePrivateFields;
+    state?: PaneSharePrivateFields;
+  };
+}
+
 export interface PaneDef {
   id: string;
   name: string;
@@ -53,7 +65,11 @@ export interface PaneDef {
   defaultWidth?: string;
   defaultFloatingSize?: { width: number; height: number };
   defaultMode?: "docked" | "floating";
+  /** Pane publishes its selected symbol as pane-state `cursorSymbol`, so ticker panes can follow it. */
+  tickerSource?: boolean;
   settings?: PaneSettingsDef | ((context: PaneSettingsContext) => PaneSettingsDef | null);
+  /** Portable sharing is public by default; list the few pane-owned fields that must remain local. */
+  portableShare?: PanePortableShareDef;
   /** Compact controls surfaced next to the pane title. Toggle keys reference toggle fields in settings. */
   quickSettings?: readonly PaneQuickSettingDef[];
 }
@@ -177,6 +193,8 @@ export interface PaneTemplateCreateOptions {
   symbols?: string[] | null;
   ticker?: TickerRecord | null;
   searchResult?: InstrumentSearchResult | null;
+  /** Template-owned, validated data restored from a public pane share. */
+  shareData?: unknown;
 }
 
 export interface PaneTemplateInstanceConfig {
@@ -190,6 +208,22 @@ export interface PaneTemplateInstanceConfig {
   relativePosition?: "left" | "right" | "above" | "below";
 }
 
+export interface PaneTemplatePublicShareContext {
+  pane: PaneInstanceConfig;
+  paneState: Record<string, unknown>;
+}
+
+export interface PaneTemplatePublicShareSnapshot {
+  title: string;
+  description?: string;
+  data: Record<string, unknown>;
+}
+
+export interface PaneTemplatePublicShareDef {
+  serialize(context: PaneTemplatePublicShareContext): PaneTemplatePublicShareSnapshot | null;
+  restore(data: Record<string, unknown>): PaneTemplateCreateOptions | null;
+}
+
 export interface PaneTemplateDef {
   id: string;
   paneId: string;
@@ -203,6 +237,8 @@ export interface PaneTemplateDef {
     context: PaneTemplateContext,
     options?: PaneTemplateCreateOptions,
   ) => PaneTemplateInstanceConfig | null | Promise<PaneTemplateInstanceConfig | null>;
+  /** Legacy v1 restoration or an explicit transformed snapshot; normal pane shares use portableShare. */
+  publicShare?: PaneTemplatePublicShareDef;
 }
 
 export interface WizardStep {

package/src/ui/context-menu.tsx

@@ -189,7 +189,7 @@ function appContextMenuItems(registry: Pick<PluginRegistry, "openCommandBar"> |
     {
       id: "app:layout-actions",
       label: "Layout Actions...",
-      onSelect: () => registry?.openCommandBar("LAY "),
+      onSelect: () => registry?.openCommandBar("LMA "),
     },
     contextMenuDivider("app:config-divider"),
     {

package/src/ui/host.tsx

@@ -336,6 +336,10 @@ export interface UiHost {
   capabilities?: {
     nativePaneChrome?: boolean;
     titleBarOverlay?: boolean;
+    /** Native drag regions and traffic-light/window-control spacing. */
+    nativeWindowChrome?: boolean;
+    /** Enables public snapshot sharing controls for this host. */
+    publicSharing?: boolean;
     precisePointer?: boolean;
     fractionalViewport?: boolean;
     cellWidthPx?: number;

package/src/ui/toast.tsx

@@ -1,6 +1,8 @@
 import { createContext, useContext, type ComponentType, type ReactNode } from "react";
 
 export interface ToastOptions {
+  title?: string;
+  subtitle?: string;
   duration?: number;
   action?: {
     label: string;

package/src/utils/back-navigation.ts

@@ -31,10 +31,6 @@ export function isPlainEscape(event: BackNavigationEventLike): boolean {
     && !event.shift;
 }
 
-export function isBackNavigationKey(event: BackNavigationEventLike): boolean {
-  return isPlainBackspace(event) || isPlainEscape(event);
-}
-
 export function isDetailBackNavigationKey(
   event: BackNavigationEventLike,
 ): boolean {

package/src/utils/price-history.ts

@@ -3,6 +3,7 @@ import { resolveExchangeTimeZone } from "./exchanges";
 import { isTimestampStaleForExchangeSession } from "../market-data/market/freshness";
 
 const MAX_CURRENT_INTRADAY_HISTORY_LAG_MS = 18 * 60 * 60 * 1000;
+const MAX_SAME_SESSION_HISTORY_LAG_MS = 30 * 60 * 1000;
 
 interface PriceHistoryFreshnessOptions {
   exchange?: string;
@@ -78,19 +79,19 @@ export function isPriceHistoryStaleForCurrentWindow(
   if (!latest) return false;
 
   const latestTime = getPricePointTimestamp(latest);
-  if (!Number.isFinite(latestTime) || now - latestTime <= MAX_CURRENT_INTRADAY_HISTORY_LAG_MS) {
-    return false;
-  }
-
+  if (!Number.isFinite(latestTime)) return false;
+  const age = now - latestTime;
+  if (age <= MAX_SAME_SESSION_HISTORY_LAG_MS) return false;
+  const exchange = options.exchange || "NASDAQ";
   if (
-    options.exchange
-    && resolveExchangeTimeZone(options.exchange)
-    && !isTimestampStaleForExchangeSession(latestTime, options.exchange, now)
+    resolveExchangeTimeZone(exchange)
+    && isTimestampStaleForExchangeSession(latestTime, exchange, now)
   ) {
-    return false;
+    return true;
   }
-
-  return true;
+  const hasExchangeSession = Boolean(resolveExchangeTimeZone(exchange));
+  if (age <= MAX_CURRENT_INTRADAY_HISTORY_LAG_MS) return hasExchangeSession;
+  return !hasExchangeSession;
 }
 
 export function normalizeTickerFinancialsPriceHistory(financials: TickerFinancials): TickerFinancials {

package/src/utils/sec.test.ts

@@ -35,6 +35,12 @@ describe("isUsEquityTicker", () => {
     }))).toBe(true);
   });
 
+  test("accepts US-listed ADRs", () => {
+    expect(isUsEquityTicker(makeTicker({
+      assetCategory: "ADR",
+    }))).toBe(true);
+  });
+
   test("rejects non-equity instruments", () => {
     expect(isUsEquityTicker(makeTicker({
       assetCategory: "OPT",

package/src/utils/sec.ts

@@ -24,7 +24,7 @@ function isUsExchange(value?: string): boolean {
 
 function isEquityType(value?: string): boolean {
   const normalized = normalize(value);
-  return normalized.length === 0 || normalized === "STK" || normalized === "EQUITY";
+  return normalized.length === 0 || normalized === "STK" || normalized === "EQUITY" || normalized === "ADR";
 }
 
 export function isUsEquityTicker(ticker: TickerRecord | null | undefined): boolean {