gloomberb 0.17.5 → 0.18.0

package/src/sources/provider-router/index.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import type { PriceHistoryResult } from "../../types/price-history";
 import type { ResourceStore } from "../../data/resource-store";
 import type { ConnectionHealthRegistry } from "../../core/connection-health";
@@ -174,8 +175,8 @@ export class AssetDataRouter implements DataProvider {
         if (!provider.canProvide || await provider.canProvide(ticker, exchange, context)) {
           return true;
         }
-      } catch {
-        // continue through provider chain
+      } catch (error) {
+        logFailure("sources.provider-router.index", "Checking provider availability failed")(error);
       }
     }
     return false;
@@ -252,7 +253,9 @@ export class AssetDataRouter implements DataProvider {
           known = mergeQuoteMetadata(known, metadata);
           if (known?.currency && known.instrumentType) return known;
         }
-      } catch { /* Optional listing metadata must not prevent historical research. */ }
+      } catch (error) {
+        logFailure("sources.provider-router.index", "Loading listing metadata failed")(error);
+      }
     }
     return known ?? null;
   }
@@ -289,6 +292,18 @@ export class AssetDataRouter implements DataProvider {
     return (await this.getCachedQuery("getCorporateActions", [ticker, exchange, context]).load({ force: context?.cacheMode === "refresh", background: this.revalidateInBackground })).value;
   }
 
+  searchBatch(queries: string[], options?: { limit?: number; signal?: AbortSignal }): Promise<Map<string, InstrumentSearchResult[]> | null> {
+    return this.searchRoutes.searchBatch(queries, options);
+  }
+
+  /** The first source that answers a batch of symbol changes; null when none can or it fails. */
+  async getTickerChangesBatch(symbols: string[], options?: { signal?: AbortSignal }): Promise<Map<string, TickerChanges | null> | null> {
+    const provider = this.providersInPriorityOrder().find((candidate) => candidate.getTickerChangesBatch);
+    if (!provider) return null;
+    return await provider.getTickerChangesBatch!(symbols, options)
+      .catch(logFailure("sources.provider-router.index", "Batched ticker changes failed", null));
+  }
+
   /** The first source that keeps symbol changes answers; one that fails is passed over. */
   async getTickerChanges(symbol: string, options?: { signal?: AbortSignal }): Promise<TickerChanges | null> {
     for (const provider of this.providersInPriorityOrder()) {

package/src/sources/provider-router/primary.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import { selectCachedResource } from "./cache";
 import { financialHistoryVariants, hasReusableExtendedHistory } from "./statement-history";
 import type { MarketDataRequestContext } from "../../types/data-provider";
@@ -57,8 +58,8 @@ export class ProviderRouterPrimaryRoutes {
           this.options.resolveBrokerPolicy("financials", candidate.broker),
         );
         return { sourceKey: this.options.brokerSourceKey(candidate), value: result };
-      } catch {
-        // continue
+      } catch (error) {
+        logFailure("sources.provider-router.primary", "Loading broker financials failed")(error);
       }
     }
     return null;
@@ -179,8 +180,8 @@ export class ProviderRouterPrimaryRoutes {
           this.options.resolveBrokerPolicy("brokerQuote", candidate.broker),
         );
         return { sourceKey: this.options.brokerSourceKey(candidate), value: result };
-      } catch {
-        // continue
+      } catch (error) {
+        logFailure("sources.provider-router.primary", "Loading a broker quote failed")(error);
       }
     }
     return null;

package/src/sources/provider-router/quote-route.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import type { QuoteSubscriptionTarget } from "../../types/data-provider";
 import { canonicalExchange, US_LISTING_EXCHANGES } from "../../utils/exchanges";
 import type { BrokerCandidate } from "./brokers";
@@ -54,7 +55,8 @@ export function resolveBrokerQuoteStreamState(
     const status = broker.getStatus?.(instance);
     if (status && status.state !== "connected") return "offline";
     return status?.quoteData === "delayed" || observedDelayed ? "delayed" : "live";
-  } catch {
+  } catch (error) {
+    logFailure("sources.provider-router.quote-route", "Reading broker quote stream status failed")(error);
     return "unsupported";
   }
 }

package/src/sources/provider-router/routing.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import type { MarketDataRequestContext } from "../../types/data-provider";
 import type { ProviderRouterCoreDeps } from "./route-types";
 import { buildVariantKey } from "./cache";
@@ -35,7 +36,7 @@ export function scheduleRouterRevalidation(
 ): void {
   if (inFlight.has(key)) return;
   const promise = task()
-    .catch(() => {})
+    .catch(logFailure("sources.provider-router.routing", "Refreshing a cached provider result failed"))
     .finally(() => {
       inFlight.delete(key);
     });

package/src/sources/provider-router/search.ts

@@ -1,9 +1,10 @@
+import { logFailure } from "../../utils/log-failure";
 import type { DataProvider, SearchRequestContext } from "../../types/data-provider";
 import type { InstrumentSearchResult } from "../../types/instrument";
 import type { BrokerCandidate } from "./brokers";
-import { shouldLogProviderError } from "../provider-errors";
+import { isProviderBusy, ProviderBusyError, SEARCH_BUSY_MESSAGE, shouldLogProviderError } from "../provider-errors";
 import { searchInstrumentKey } from "../../tickers/search/identity";
-import { settleWithin } from "../../utils/async-deadline";
+import { OperationTimeoutError, settleWithin, withDeadline } from "../../utils/async-deadline";
 
 const SEARCH_CACHE_TTL_MS = 30_000;
 const SEARCH_CACHE_MAX_ENTRIES = 100;
@@ -87,6 +88,25 @@ export class ProviderRouterSearchRoutes {
 
   constructor(private readonly deps: ProviderRouterSearchDeps) {}
 
+  /**
+   * Several searches answered by the preferred provider in a few requests,
+   * each merged as `search` merges that source's rows. Null while a broker can
+   * search: its rows join every search's answer, so those go one at a time.
+   */
+  async searchBatch(queries: string[], options?: { limit?: number; signal?: AbortSignal }): Promise<Map<string, InstrumentSearchResult[]> | null> {
+    if (this.deps.getBrokerCandidates().some((candidate) => candidate.broker.searchInstruments)) return null;
+    const [preferred] = this.deps.providersInPriorityOrder();
+    if (!preferred?.searchBatch) return null;
+    const answers = await preferred.searchBatch(queries, options)
+      .catch(logFailure("sources.provider-router.search", "Batched search failed", null));
+    if (!answers) return null;
+    return new Map([...answers].map(([query, items]) => {
+      const results: InstrumentSearchResult[] = [];
+      mergeSearchResults(results, new Map(), items);
+      return [query, results] as const;
+    }));
+  }
+
   async search(query: string, context?: SearchRequestContext): Promise<InstrumentSearchResult[]> {
     const cacheKey = buildSearchCacheKey(query, context);
     const cached = this.searchCache.get(cacheKey);
@@ -118,6 +138,10 @@ export class ProviderRouterSearchRoutes {
    * Ordering still matters, it just no longer costs latency: `mergeSearchResults`
    * keeps the richest entry per symbol, so a broker arriving after the cloud
    * still upgrades the row, and `onPartial` hands that upgrade to the caller.
+   *
+   * A search nothing answered because a provider was busy (rate limited,
+   * overloaded, out of time) rejects with a `ProviderBusyError` instead of
+   * reading as an empty one, and is not cached, so asking again asks again.
    */
   private fetchSearchResults(
     query: string,
@@ -141,10 +165,13 @@ export class ProviderRouterSearchRoutes {
     };
 
     let resolveFirst!: (value: InstrumentSearchResult[]) => void;
-    const first = new Promise<InstrumentSearchResult[]>((resolve) => {
+    let rejectFirst!: (error: unknown) => void;
+    const first = new Promise<InstrumentSearchResult[]>((resolve, reject) => {
       resolveFirst = resolve;
+      rejectFirst = reject;
     });
     let answered = false;
+    let busy = false;
 
     const record = (items: InstrumentSearchResult[] | null) => {
       if (!items?.length) return;
@@ -167,16 +194,20 @@ export class ProviderRouterSearchRoutes {
           timeoutMs,
         );
         record(items && annotateBrokerSearchResults(items, candidate));
-      } catch {
-        // A broker that cannot answer must not hold up the ones that can.
+      } catch (error) {
+        logFailure("sources.provider-router.search", "Searching broker instruments failed")(error);
       }
     })();
 
     const searchProvider = (provider: DataProvider) => (async () => {
       try {
-        record(await settleWithin(provider.search(query, context), timeoutMs));
+        record(await withDeadline(provider.search(query, context), timeoutMs, `${provider.id} search timed out`));
       } catch (error) {
-        if (shouldLogProviderError(error)) {
+        const timedOut = error instanceof OperationTimeoutError;
+        // A keystroke gives up on a slow source by design and asks again on the next one; only a full wait is busy.
+        if (isProviderBusy(error) || (timedOut && !context?.interactive)) {
+          busy = true;
+        } else if (!timedOut && shouldLogProviderError(error)) {
           this.deps.logProviderError(`${provider.id} failed: ${error}`);
         }
       }
@@ -198,13 +229,16 @@ export class ProviderRouterSearchRoutes {
         await Promise.allSettled(fallbacks.map(searchProvider));
       }
     })().then(() => {
-      if (!answered) {
-        answered = true;
-        // Nothing matched anywhere, so hold the empty answer briefly rather
-        // than asking every source again on the next keystroke.
-        cacheResults(Math.min(SEARCH_CACHE_TTL_MS, 5_000));
-        resolveFirst([]);
+      if (answered) return;
+      answered = true;
+      if (busy) {
+        rejectFirst(new ProviderBusyError(SEARCH_BUSY_MESSAGE));
+        return;
       }
+      // Nothing matched anywhere, so hold the empty answer briefly rather
+      // than asking every source again on the next keystroke.
+      cacheResults(Math.min(SEARCH_CACHE_TTL_MS, 5_000));
+      resolveFirst([]);
     });
 
     return { first, settled };

package/src/sources/provider-router/streaming.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import type { DataProvider, MarketDataRequestContext, QuoteSubscriptionTarget } from "../../types/data-provider";
 import type { Quote } from "../../types/financials";
 import type { BrokerCandidate } from "./brokers";
@@ -51,7 +52,8 @@ function isBrokerConnected(candidate: BrokerCandidate): boolean {
   try {
     const status = candidate.broker.getStatus?.(candidate.instance);
     return !status || status.state === "connected";
-  } catch {
+  } catch (error) {
+    logFailure("sources.provider-router.streaming", "Reading broker connection status failed")(error);
     return false;
   }
 }
@@ -62,7 +64,8 @@ function canWakeBroker(candidate: BrokerCandidate): boolean {
   try {
     const state = candidate.broker.getStatus?.(candidate.instance)?.state;
     return state === "disconnected" || state === "error";
-  } catch {
+  } catch (error) {
+    logFailure("sources.provider-router.streaming", "Reading broker connection status failed")(error);
     return false;
   }
 }
@@ -195,8 +198,8 @@ export class ProviderRouterStreamingRoutes {
             scheduleApply();
           });
           if (unsubscribe) watchers.push(unsubscribe);
-        } catch {
-          // A broker that cannot report status keeps the route it has now.
+        } catch (error) {
+          logFailure("sources.provider-router.streaming", "Subscribing to broker connection status failed")(error);
         }
       }
       this.delayedSessionListeners.add(scheduleApply);

package/src/sources/sec-edgar.ts

@@ -171,9 +171,7 @@ function resolveSecArchiveUrl(href: string, filingUrl: string): string | null {
       return new URL(ixviewerDocument, "https://www.sec.gov").toString();
     }
     return url.toString();
-  } catch {
-    return null;
-  }
+  } catch { /* Intentional ignore: Malformed document hrefs are not usable archive links. */ return null; }
 }
 
 function isHtmlResponse(body: string): boolean {

package/src/state/app/context/index.tsx

@@ -458,6 +458,7 @@ export function AppProvider({
   const effectiveThemeId = getEffectiveThemeId(state);
   const previousRecentTickers = useRef(state.recentTickers);
   const previousRecentCommands = useRef(state.config.recentCommands);
+  const previousCommandBarOpens = useRef(state.config.commandBarOpens);
   const stateRef = useRef(state);
   const listenersRef = useRef(new Set<() => void>());
   const storeRef = useRef<AppContextStoreValue | null>(null);
@@ -538,6 +539,14 @@ export function AppProvider({
     scheduleConfigSave(() => ({ ...stateRef.current.config, recentTickers: stateRef.current.recentTickers }));
   }, [state.config.recentCommands]);
 
+  // Opening the empty bar changes only config.commandBarOpens, until it stops
+  // counting; nothing else saves it.
+  useEffect(() => {
+    if (previousCommandBarOpens.current === state.config.commandBarOpens) return;
+    previousCommandBarOpens.current = state.config.commandBarOpens;
+    scheduleConfigSave(() => ({ ...stateRef.current.config, recentTickers: stateRef.current.recentTickers }));
+  }, [state.config.commandBarOpens]);
+
   useEffect(() => {
     if (!desktopBridge) return;
     return desktopBridge.subscribeState((snapshot) => {

package/src/state/app/tab-cursor.ts

@@ -0,0 +1,222 @@
+import { useCallback, useContext, useEffect, useMemo, useSyncExternalStore } from "react";
+import type { AppState } from "../../core/state/app/state";
+import { findPaneInstance, type SavedLayout } from "../../types/config";
+import { AppContext, useOptionalAppSelector, useOptionalPaneInstanceId, type AppContextStoreValue } from "./context";
+
+/**
+ * The time the pointer or keyboard cursor is at on one chart of a layout tab,
+ * which the tab's other charts show at the same moment: the last instant the
+ * cursor covers, so a chart reads its data as of then. It is held per tab, in
+ * memory only: a cursor moves on every pointer event, and the app store would
+ * re-run every pane's selectors on each one.
+ */
+interface TabCursor {
+  time: number;
+  /** The chart the cursor is on; it never follows its own time back. */
+  sourceId: string;
+}
+
+const cursors = new Map<string, TabCursor>();
+/**
+ * A pinned cursor belongs to no chart: every chart in the tab follows it, the
+ * one it was pinned from too, and no pointer leaving a chart takes it away.
+ */
+const PINNED = "\u0000pinned";
+/** How many charts in each tab are mounted to show its pin; see `useTabCursorLink`. */
+const pinViewers = new Map<string, number>();
+const listeners = new Set<() => void>();
+
+/** A time a Date can hold. A pin is never NaN, infinite or past the Date range, whatever asks for it. */
+function isMoment(time: number): boolean {
+  return Number.isFinite(time) && Math.abs(time) <= 8.64e15;
+}
+
+function setTabCursorTime(tabKey: string, sourceId: string | null, time: number | null): void {
+  const current = cursors.get(tabKey);
+  if (time === null) {
+    // Only the chart the cursor is on can take it away: a chart clearing a
+    // cursor it no longer holds must not clear another chart's. A null source
+    // clears whichever chart holds it.
+    if (!current || (sourceId !== null && current.sourceId !== sourceId)) return;
+    cursors.delete(tabKey);
+  } else {
+    if (sourceId === null || (current?.sourceId === sourceId && current.time === time)) return;
+    cursors.set(tabKey, { time, sourceId });
+  }
+  for (const listener of listeners) listener();
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/** A chart's handle on the cursor its layout tab shares. */
+export interface TabCursorLink {
+  /** Calls `listener` whenever a tab's cursor moves. */
+  subscribe(listener: () => void): () => void;
+  /** Where another chart's cursor is in this tab: null when none is, or the cursor is this chart's own. */
+  time(): number | null;
+  /** Whether this chart's cursor is the tab's. */
+  held(): boolean;
+  /** Reports this chart's cursor, or null when it leaves. */
+  publish(time: number | null): void;
+  /** Clears the tab's cursor, whichever chart holds it, a pinned one too. */
+  clear(): void;
+  /** Whether the tab's cursor is pinned. */
+  pinned?(): boolean;
+  /** Pins the tab's cursor at `time`, which no chart's pointer moves, or unpins it with null. */
+  pin?(time: number | null): void;
+}
+
+/** A layout tab is named by its id; older saved tabs have none, and go by position. */
+const tabKeyAt = (layouts: readonly SavedLayout[], index: number): string => layouts[index]?.id ?? `index:${index}`;
+const selectTabKey = (state: AppState): string => tabKeyAt(state.config.layouts, state.config.activeLayoutIndex);
+
+/**
+ * Moves the cursors of a store's tabs with their tabs when the tab list
+ * changes. A tab with an id keeps its key while it is open. One without is
+ * keyed by its place, so when tabs open, close or move its cursor follows its
+ * name to the new place if no other tab shares that name, and goes otherwise.
+ * So a closed tab's pin goes with it, and a tab that takes its place never
+ * inherits it. Edits that leave every tab where it was keep every key, one
+ * tab renamed included.
+ */
+function retargetTabCursors(before: readonly SavedLayout[], after: readonly SavedLayout[]): void {
+  const inPlace = before.length === after.length && before.every((tab, index) => tab.id === after[index]!.id);
+  if (inPlace && before.filter((tab, index) => tab.name !== after[index]!.name).length <= 1) return;
+  const afterKeys = new Set(after.map((_, index) => tabKeyAt(after, index)));
+  const named = (tabs: readonly SavedLayout[], name: string) => tabs.filter((tab) => tab.id === undefined && tab.name === name).length;
+  const moved = new Map<string, TabCursor>();
+  let changed = false;
+  before.forEach((tab, index) => {
+    const key = tabKeyAt(before, index);
+    const cursor = cursors.get(key);
+    if (!cursor) return;
+    cursors.delete(key);
+    let target: string | null = null;
+    if (tab.id !== undefined) target = afterKeys.has(key) ? key : null;
+    else if (named(before, tab.name) === 1 && named(after, tab.name) === 1) {
+      target = `index:${after.findIndex((next) => next.id === undefined && next.name === tab.name)}`;
+    }
+    if (target !== key) changed = true;
+    if (target !== null) moved.set(target, cursor);
+  });
+  for (const [key, cursor] of moved) cursors.set(key, cursor);
+  if (changed) for (const listener of listeners) listener();
+}
+
+const watchedStores = new WeakSet<AppContextStoreValue>();
+/** Follows a store's tab list once, from the first chart that links to it. */
+function watchTabs(store: AppContextStoreValue): void {
+  if (watchedStores.has(store)) return;
+  watchedStores.add(store);
+  let tabs = store.getState().config.layouts;
+  store.subscribe(() => {
+    const next = store.getState().config.layouts;
+    if (next === tabs) return;
+    const before = tabs;
+    tabs = next;
+    retargetTabCursors(before, next);
+  });
+}
+
+/**
+ * Shares a chart's cursor time with the other charts in its layout tab.
+ * `sourceId` names the chart, unique in the tab: two charts in one pane each
+ * have their own, so either follows the other. Reading the handle does not
+ * re-render anything when the cursor moves: what draws the cursor
+ * subscribes, so a pointer move on one chart re-renders the other charts and
+ * nothing around them. A null `sourceId`, or no app around it (a test, a
+ * screenshot), shares nothing. `viewer` says whether the chart shows the pin
+ * and can lift it now; only such charts keep a pin from going (see below).
+ */
+export function useTabCursorLink(sourceId: string | null, { viewer = true }: { viewer?: boolean } = {}): TabCursorLink | undefined {
+  const tabKey = useOptionalAppSelector<string | null>(selectTabKey, null);
+  const app = useContext(AppContext);
+  const paneId = useOptionalPaneInstanceId();
+  const link = useMemo<TabCursorLink | undefined>(() => tabKey === null || sourceId === null ? undefined : {
+    subscribe,
+    time: () => {
+      const cursor = cursors.get(tabKey);
+      return cursor && cursor.sourceId !== sourceId ? cursor.time : null;
+    },
+    held: () => cursors.get(tabKey)?.sourceId === sourceId,
+    publish: (time) => {
+      // A pinned cursor stays until it is unpinned: hovering a chart, or leaving it, does not move it.
+      if (cursors.get(tabKey)?.sourceId === PINNED) return;
+      setTabCursorTime(tabKey, sourceId, time !== null && Number.isFinite(time) ? time : null);
+    },
+    clear: () => setTabCursorTime(tabKey, null, null),
+    pinned: () => cursors.get(tabKey)?.sourceId === PINNED,
+    // Null unpins; a time no Date can hold changes nothing.
+    pin: (time) => {
+      if (time === null || isMoment(time)) setTabCursorTime(tabKey, PINNED, time);
+    },
+  }, [sourceId, tabKey]);
+  useEffect(() => {
+    if (app && "subscribe" in app) watchTabs(app);
+  }, [app]);
+  useEffect(() => {
+    if (!link) return;
+    // A chart closed or switched away from under the cursor takes its cursor with it.
+    return () => link.publish(null);
+  }, [link]);
+  useEffect(() => {
+    if (!link || tabKey === null || !viewer) return;
+    pinViewers.set(tabKey, (pinViewers.get(tabKey) ?? 0) + 1);
+    return () => {
+      const left = (pinViewers.get(tabKey) ?? 1) - 1;
+      if (left > 0) {
+        pinViewers.set(tabKey, left);
+        return;
+      }
+      pinViewers.delete(tabKey);
+      // The pin is the tab's, so it stays when the chart it was pinned on
+      // closes and others remain, and through a switch to another tab. When
+      // the last chart showing it closes, nothing in the tab could lift it,
+      // so it goes too: a chart that is not interactive (an overview's
+      // sparkline) shows no pin and does not count. Read once the commit
+      // settles, from the app's current state: a chart replaced in place, or
+      // one in a pane that is still open (reloading, under a dialog), keeps it.
+      // A closed tab's pin goes with the tab (`retargetTabCursors`).
+      queueMicrotask(() => {
+        if (pinViewers.has(tabKey) || !app) return;
+        const state = "getState" in app ? app.getState() : app.state;
+        if (selectTabKey(state) !== tabKey) return;
+        if (paneId !== null && findPaneInstance(state.config.layout, paneId)) return;
+        setTabCursorTime(tabKey, PINNED, null);
+      });
+    };
+  }, [app, link, paneId, tabKey, viewer]);
+  return link;
+}
+
+/**
+ * The moment the layout tab's crosshair is pinned at, for a pane that is not a
+ * chart (news, the tape): null while nothing is pinned. It follows the pin, not
+ * a pointer passing over a chart, so a list re-renders when the pin moves and
+ * never on a pointer move.
+ */
+export function usePinnedTabTime(): number | null {
+  const tabKey = useOptionalAppSelector<string | null>(selectTabKey, null);
+  const pinnedTime = useCallback(() => {
+    const cursor = tabKey === null ? undefined : cursors.get(tabKey);
+    return cursor?.sourceId === PINNED ? cursor.time : null;
+  }, [tabKey]);
+  return useSyncExternalStore(subscribe, pinnedTime);
+}
+
+/** The moment the active layout tab has its crosshair pinned at, outside React: a shared link opens there. */
+export function pinnedTabTime(state: AppState): number | null {
+  const cursor = cursors.get(selectTabKey(state));
+  return cursor?.sourceId === PINNED ? cursor.time : null;
+}
+
+/** Lifts the layout tab's pin from a pane that is not a chart, as Esc does on a chart. */
+export function useUnpinTab(): () => void {
+  const tabKey = useOptionalAppSelector<string | null>(selectTabKey, null);
+  return useCallback(() => {
+    if (tabKey !== null) setTabCursorTime(tabKey, PINNED, null);
+  }, [tabKey]);
+}

package/src/state/hooks/quote-streaming.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { useAppVisible, usePaneInView } from "../app/activity";
 import type { QuoteSubscriptionTarget } from "../../types/data-provider";
@@ -252,8 +253,8 @@ export function useQuoteUpdates(
       lastPollRef.current = { key: instrumentKey, at: Date.now() };
       try {
         await coordinator.loadQuotesBatch(instruments, { forceRefresh: true });
-      } catch {
-        // Polling is best effort and the coordinator retains the last good quote.
+      } catch (error) {
+        logFailure("state.hooks.quote-streaming", "Polling broker quotes failed")(error);
       } finally {
         inFlight = false;
       }

package/src/state/hooks/session-snapshot.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import { useEffect, useRef } from "react";
 import type { AppSessionStorePort } from "../../core/app-service-ports";
 import {
@@ -69,8 +70,8 @@ export function usePersistSessionSnapshot(
         recentTickers: currentState.recentTickers,
         tickers: currentState.tickers,
       }) satisfies AppSessionSnapshot;
-    } catch {
-      // Snapshot persistence is best-effort during teardown.
+    } catch (error) {
+      logFailure("persist", "Building the saved session snapshot failed")(error);
       return null;
     }
   };

package/src/state/persist-scheduler.ts

@@ -1,3 +1,5 @@
+import { logFailure } from "../utils/log-failure";
+
 export const CONFIG_SAVE_DEBOUNCE_MS = 500;
 /** For config fields that change on every cursor move (recent tickers, the live pane-state mirror). */
 export const LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS = 5_000;
@@ -51,7 +53,10 @@ export function createPersistScheduler<T>({
       try {
         await save(value);
       } catch (error) {
-        if (reportError) onError?.(error);
+        if (reportError) {
+          if (onError) onError(error);
+          else logFailure("persist", "Scheduled persistence failed")(error);
+        }
         throw error;
       }
     });
@@ -60,11 +65,14 @@ export function createPersistScheduler<T>({
     inFlightSaves.add(saveTask);
     void saveTask.then(
       () => { inFlightSaves.delete(saveTask); },
-      () => { inFlightSaves.delete(saveTask); },
+      () => {
+        // Intentional ignore: The returned saveTask or enqueueSave already reports this failure.
+        inFlightSaves.delete(saveTask);
+      },
     );
     // Keep the serialization chain usable after a failed immediate save while
     // still returning that failure to its caller.
-    inFlight = saveTask.catch(() => {});
+    inFlight = saveTask.catch(() => { /* Intentional ignore: The returned saveTask reports to the caller; this rejection only keeps the queue usable. */ });
     return saveTask;
   };
 
@@ -76,7 +84,7 @@ export function createPersistScheduler<T>({
     const value = pendingValue as T;
     pendingValue = undefined;
     hasPendingValue = false;
-    return enqueueSave(value, true).catch(() => {});
+    return enqueueSave(value, true).catch(() => { /* Intentional ignore: enqueueSave reports scheduled errors before this drain consumes them. */ });
   };
 
   return {

package/src/sync/controller.ts

@@ -87,6 +87,13 @@ export class CloudSyncController {
   private syncQueued = false;
   private clientId: string | null = null;
   private lastSignature: string | null = null;
+  /**
+   * The content signature of the cloud's copy, with the revision and the
+   * write it belongs to. Each 15 s poll pulls the same copy again until a
+   * device writes; working its signature out every time was a third of an
+   * idle sync on a large workspace (GLO-925).
+   */
+  private cloudSignature: { transportId: string; revision: number; clientId: string; createdAt: string; signature: string } | null = null;
   private baseline: Record<string, unknown> | null = null;
   private baselineLoaded = false;
   private pulledContributors: SyncSnapshot["contributors"] = {};
@@ -302,7 +309,7 @@ export class CloudSyncController {
       });
       return {
         revision: response.snapshot ? response.revision : 0,
-        signature: response.snapshot ? snapshotContentSignature(response.snapshot) : null,
+        signature: response.snapshot ? this.pulledSignature(transport, response.revision, response.snapshot) : null,
       };
     } catch (error) {
       if (!this.isCurrent(runtime, transport)) return null;
@@ -435,6 +442,19 @@ export class CloudSyncController {
     return this.runtime === runtime && runtime.getTransport()?.transport === transport;
   }
 
+  private pulledSignature(transport: SyncTransport, revision: number | null, snapshot: SyncSnapshot): string {
+    const kept = this.cloudSignature;
+    if (revision != null && kept && kept.transportId === transport.id && kept.revision === revision
+      && kept.clientId === snapshot.clientId && kept.createdAt === snapshot.createdAt) {
+      return kept.signature;
+    }
+    const signature = snapshotContentSignature(snapshot);
+    this.cloudSignature = revision == null
+      ? null
+      : { transportId: transport.id, revision, clientId: snapshot.clientId, createdAt: snapshot.createdAt, signature };
+    return signature;
+  }
+
   private shouldApplyPulledRevision(revision: number | null): boolean {
     return revision == null || this.appliedRevision == null || revision > this.appliedRevision;
   }
@@ -456,6 +476,7 @@ export class CloudSyncController {
     this.inFlight = null;
     this.syncQueued = false;
     this.lastSignature = null;
+    this.cloudSignature = null;
     this.appliedRevision = null;
     this.baseline = null;
     this.baselineLoaded = false;