gloomberb 0.16.1 → 0.16.2

package/src/sources/gloomberb-cloud/normalizers.ts

@@ -36,6 +36,24 @@ function cloudInternalProviderId(providerMeta?: CloudProviderMeta): string | nul
   return upstream ? `${GLOOMBERB_CLOUD_PROVIDER_ID}:${upstream}` : null;
 }
 
+/**
+ * A previous close is a price from inside the trailing 52 weeks, so it cannot
+ * sit far below the 52-week low. The service has sent 0.000205 as the
+ * Shanghai Composite's close (52-week low 3,741), which drew a +1.86e9% move.
+ * Today's price plays no part, so a real gap of any size still shows; two
+ * orders of magnitude leave room for a 52-week low that lags a crash or a split.
+ */
+const IMPOSSIBLE_CLOSE_FACTOR = 100;
+
+function isImpossiblePreviousClose(
+  previousClose: number | null | undefined,
+  low52w: number | null | undefined,
+): boolean {
+  return typeof previousClose === "number" && Number.isFinite(previousClose) && previousClose > 0
+    && typeof low52w === "number" && Number.isFinite(low52w) && low52w > 0
+    && previousClose * IMPOSSIBLE_CLOSE_FACTOR < low52w;
+}
+
 export function mapQuote(
   quote: CloudQuotePayload,
   providerMeta?: CloudProviderMeta,
@@ -50,10 +68,11 @@ export function mapQuote(
     quote.fullExchangeName ??
     listingExchangeName;
   const internalProviderId = cloudInternalProviderId(providerMeta);
-  const change = typeof quote.change === "number" && Number.isFinite(quote.change)
+  const impossibleClose = isImpossiblePreviousClose(quote.previousClose, quote.low52w);
+  const change = !impossibleClose && typeof quote.change === "number" && Number.isFinite(quote.change)
     ? quote.change / divisor
     : Number.NaN;
-  const changePercent = typeof quote.changePercent === "number" && Number.isFinite(quote.changePercent)
+  const changePercent = !impossibleClose && typeof quote.changePercent === "number" && Number.isFinite(quote.changePercent)
     ? quote.changePercent
     : Number.NaN;
   // A generic future (VX1, TY1) reads in points or 32nds, not dollars.
@@ -70,8 +89,13 @@ export function mapQuote(
     price: normalizePriceValueByDivisor(quote.price, divisor) ?? quote.price,
     change,
     changePercent,
-    previousClose: normalizePriceValueByDivisor(quote.previousClose, divisor),
+    previousClose: impossibleClose ? undefined : normalizePriceValueByDivisor(quote.previousClose, divisor),
     regularClose: normalizePriceValueByDivisor(quote.regularClose, divisor),
+    // JSON carries an unavailable move as null; the percent is unitless.
+    regularChange: normalizePriceValueByDivisor(quote.regularChange ?? undefined, divisor),
+    regularChangePercent: typeof quote.regularChangePercent === "number" && Number.isFinite(quote.regularChangePercent)
+      ? quote.regularChangePercent
+      : undefined,
     high52w: normalizePriceValueByDivisor(quote.high52w, divisor),
     low52w: normalizePriceValueByDivisor(quote.low52w, divisor),
     bid: normalizePriceValueByDivisor(quote.bid, divisor),

package/src/sources/provider-router/cached-routes.ts

@@ -3,6 +3,7 @@ import { CachedQuery, type CachedValue } from "../../data/cached-query";
 import type { CachedAssetArgs, CachedAssetMethod, CachedAssetValue, DataProvider, MarketDataRequestContext, SecFilingItem } from "../../types/data-provider";
 import type { AnalystResearchData, CorporateActionsData, HolderData } from "../../types/financials";
 import { canonicalExchange } from "../../utils/exchanges";
+import { nonUsSecListingVenue } from "../../utils/sec";
 import { shouldLogProviderError } from "../provider-errors";
 import { hasBrokerContext, withBrokerTimeout } from "./brokers";
 import { publicListingExchange } from "../listing-target";
@@ -220,9 +221,11 @@ export class ProviderRouterCachedRoutes {
       };
       case "getSecFilings": {
         const [symbol, count = 15, listingExchange, requestContext] = args as CachedAssetArgs<"getSecFilings">;
+        const exact = buildVariantKey([["exchange", canonicalExchange(listingExchange)], ["count", count]]);
         return {
           kind: "sec-filings", policy: "secFilings", entityKey: this.deps.getEntityKey(symbol, requestContext?.instrument),
-          variants: [...new Set([buildVariantKey([["exchange", canonicalExchange(listingExchange)], ["count", count]]), buildVariantKey([["count", count]]), ""])],
+          // A non-US listing never reads the bare symbol's filings: SAN in Paris is Sanofi, SAN at the SEC is Santander.
+          variants: nonUsSecListingVenue(symbol, listingExchange) ? [exact] : [...new Set([exact, buildVariantKey([["count", count]]), ""])],
           request: (provider, force) => provider.getSecFilings?.(symbol, count, listingExchange, force ? { ...requestContext, cacheMode: "refresh" } : requestContext),
           throwLastError: true, error: `No SEC filings provider available for ${symbol}`,
         };

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

@@ -7,7 +7,7 @@ import { redactUnavailableFundamentals, RETRACTABLE_VALUATION_FIELDS } from "../
 import { isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshness";
 import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import { parsePublicTickerKey } from "../../utils/exchanges";
-import { activeUsMarketSession, isUsPriorSessionPremarketQuote } from "../../market-data/market/freshness";
+import { activeUsMarketSession, delayedFeedLagMs, isMiddayBreakPrint, isUsPriorSessionPremarketQuote } from "../../market-data/market/freshness";
 import {
   mergeQuoteContributionMaps,
   isQuoteContributionStaleForCurrentSession,
@@ -128,15 +128,16 @@ function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
   if (!isQuoteInActiveSession(quote, now)) return false;
   // A prior-session close before any pre-market trade has no in-session print
   // to age; the session-date rules bound it instead.
-  if (isUsPriorSessionPremarketQuote(quote.lastUpdated, quote.listingExchangeName || quote.exchangeName, quote.marketState, now)) {
+  const exchange = quote.listingExchangeName || quote.exchangeName;
+  if (isUsPriorSessionPremarketQuote(quote.lastUpdated, exchange, quote.marketState, now)) {
     return false;
   }
   if (!Number.isFinite(quote.lastUpdated)) return false;
-  const maxAge =
-    quote.dataSource === "delayed"
-      ? ACTIVE_DELAYED_PROVIDER_QUOTE_MAX_AGE_MS
-      : ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS;
-  return now - quote.lastUpdated > maxAge;
+  const delayed = quote.dataSource === "delayed";
+  const maxAge = delayed ? ACTIVE_DELAYED_PROVIDER_QUOTE_MAX_AGE_MS : ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS;
+  if (now - quote.lastUpdated <= maxAge) return false;
+  // While the venue pauses at midday, the morning's last print is the current price.
+  return !isMiddayBreakPrint(quote.lastUpdated, exchange, now, delayed ? delayedFeedLagMs(exchange) : 0);
 }
 
 export function providerQuoteMatchesTarget(quote: Quote | null | undefined, symbol?: string, exchange?: string): quote is Quote {

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

@@ -19,6 +19,7 @@ import { subtractTimeRange } from "../../time-series/date-window";
 import { clipPriceHistoryToRange } from "../../time-series/history-window";
 import { repairIsolatedIntradayOhlcOutliers } from "../../time-series/history-quality";
 import { canonicalExchange, parsePublicTickerKey, resolveExchangeTimeZone } from "../../utils/exchanges";
+import { isRoundTheClockCoin } from "../../utils/crypto-pair";
 import { zonedDateKey } from "../../utils/zoned-date-time";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
 import { calendarHistoryFetchState, calendarHistoryLastBarDate, dropLeadingPlaceholderBars, getPricePointTimestamp, hasUsablePriceHistory, preservePriceHistoryGaps, isPriceHistoryStaleForCurrentWindow, normalizePriceHistory, priceHistoryIntervalMs, type CalendarHistoryFetchState } from "../../utils/price-history";
@@ -245,9 +246,9 @@ function normalizeRequestResult(value: PriceHistoryResult, request: HistoryReque
   };
 }
 
-function resultIsStale(value: PriceHistoryResult, exchange: string, intervalMs?: number | null): boolean {
+function resultIsStale(value: PriceHistoryResult, symbol: string, exchange: string, intervalMs?: number | null): boolean {
   return isPriceHistoryStaleForCurrentWindow(value.points, Date.now(), {
-    exchange, intervalMs: intervalMs ?? (value.resolution ? priceHistoryIntervalMs(value.resolution) : undefined), session: value.session,
+    symbol, exchange, intervalMs: intervalMs ?? (value.resolution ? priceHistoryIntervalMs(value.resolution) : undefined), session: value.session,
   });
 }
 
@@ -342,8 +343,8 @@ export class ProviderRouterHistoryRoutes {
       context,
       cachePolicyKey: intraday ? "priceHistoryIntraday" : "priceHistoryDaily",
       missingProviderError: `No history provider available for ${ticker}`,
-      isCachedValueStale: (value) => intraday && resultIsStale(value, exchange),
-      isFetchedValueStale: (value) => intraday && resultIsStale(value, exchange),
+      isCachedValueStale: (value) => intraday && resultIsStale(value, ticker, exchange),
+      isFetchedValueStale: (value) => intraday && resultIsStale(value, ticker, exchange),
       fetchBroker: async (candidate) => candidate.broker.getPriceHistory
         ? candidate.broker.getPriceHistory(
           ticker,
@@ -399,8 +400,8 @@ export class ProviderRouterHistoryRoutes {
       context,
       cachePolicyKey: intraday ? "priceHistoryIntraday" : "priceHistoryDaily",
       missingProviderError: `No resolution-aware history provider available for ${ticker}`,
-      isCachedValueStale: (value) => intraday && resultIsStale(value, exchange, intervalMs),
-      isFetchedValueStale: (value) => intraday && resultIsStale(value, exchange, intervalMs),
+      isCachedValueStale: (value) => intraday && resultIsStale(value, ticker, exchange, intervalMs),
+      isFetchedValueStale: (value) => intraday && resultIsStale(value, ticker, exchange, intervalMs),
       fetchBroker: async (candidate) => candidate.broker.getPriceHistoryForResolution
         ? candidate.broker.getPriceHistoryForResolution(
           ticker,
@@ -515,9 +516,9 @@ export class ProviderRouterHistoryRoutes {
       context,
       cachePolicyKey: intervalMs != null && intervalMs >= 24 * 60 * 60 * 1000 ? "priceHistoryDaily" : "priceHistoryIntraday",
       isCachedValueStale: (value) => currentWindowAtLookup
-        && resultIsStale(value, exchange, intervalMs),
+        && resultIsStale(value, ticker, exchange, intervalMs),
       isFetchedValueStale: (value) => isCurrentHistoryWindow(endDate)
-        && resultIsStale(value, exchange, intervalMs),
+        && resultIsStale(value, ticker, exchange, intervalMs),
       fetchBroker: async (candidate) => candidate.broker.getDetailedPriceHistory
         ? candidate.broker.getDetailedPriceHistory(
           ticker,
@@ -568,6 +569,7 @@ export class ProviderRouterHistoryRoutes {
     const now = Date.now();
     const fetchState = (record: { fetchedAt: number; value: PriceHistoryResult }, checkedAt?: number): CalendarHistoryFetchState => currentWindow
       ? calendarHistoryFetchState(record.value.points, record.fetchedAt, now, {
+        symbol: target.symbol,
         exchange: target.exchange || request.target.exchange,
         checkedAt,
         // Bar size comes from the request: a cached weekly or monthly series
@@ -580,7 +582,7 @@ export class ProviderRouterHistoryRoutes {
     const ranked = cachedRecords.filter((record) => hasUsablePriceHistory(record.value.points)).map((record) => {
       const tier = fetchTier[fetchState(record)];
       return { record, tier, exact: request.exactCacheVariantKeys.includes(record.variantKey),
-        lastBar: tier === 0 ? "" : calendarHistoryLastBarDate(record.value.points, target.exchange || request.target.exchange) ?? "" };
+        lastBar: tier === 0 ? "" : calendarHistoryLastBarDate(record.value.points, target.exchange || request.target.exchange, target.symbol) ?? "" };
     });
     // Current copies keep their listed order. Otherwise ties go to this key's
     // own copy, then the latest fetch, rather than to row order.
@@ -657,7 +659,10 @@ export class ProviderRouterHistoryRoutes {
       throw new HistoryRetentionError(candidates[0]?.retention ?? attempts.retention, { candidates, outcomes: [...attempts.outcomes.values()] });
     }
     if (!providerResult && request.missingProviderError && !reportedGaps.some((value) => value.points.length > 0)) {
-      throw new Error(request.missingProviderError);
+      // A source answered a coin's history but it stops short of the present: say so, not that nothing answered.
+      const behind = isRoundTheClockCoin(target.symbol, target.exchange || request.target.exchange)
+        && [...attempts.outcomes.values()].some((outcome) => outcome.outcome === "stale");
+      throw new Error(behind ? `Latest history for ${target.symbol} is behind` : request.missingProviderError);
     }
     return withReportedGaps(providerResult?.value ?? { points: [], resolution: historyResolutionForInterval(request.interval) });
   }

package/src/sources/sec-registrant.ts

@@ -0,0 +1,75 @@
+import type { SecFilingItem } from "../types/data-provider";
+import { ProviderMissError } from "./provider-errors";
+
+/** Legal forms and grouping words, which say nothing about which company a name is. */
+const COMPANY_NAME_FILLER = new Set([
+  "THE", "SA", "PLC", "LTD", "LIMITED", "CORP", "CORPORATION", "INC", "INCORPORATED", "NV", "AG", "SE",
+  "HOLDING", "HOLDINGS", "GROUP", "COMPANY", "CO",
+]);
+
+/**
+ * The first word of a company name that tells it apart, in capitals without
+ * accents: "BANCO" for "Banco Santander, S.A.", "BP" for "BP p.l.c.". Null
+ * when the name is only legal forms.
+ */
+function companyNameToken(name: string | null | undefined): string | null {
+  const words = (name ?? "")
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toUpperCase()
+    // An initialism (S.A., N.V., p.l.c.) is one word; any other dot separates two (Amazon.com).
+    .replace(/\b(?:[A-Z]\.){2,}/g, (initialism) => initialism.replaceAll(".", ""))
+    .replace(/['\u2019]/g, "")
+    .split(/[^A-Z0-9]+/);
+  return words.find((word) => word && !COMPANY_NAME_FILLER.has(word)) ?? null;
+}
+
+/**
+ * Whether two names are clearly different companies. Names that cannot be
+ * compared count as the same, so only a plain conflict hides anything.
+ */
+export function areDifferentCompanies(left: string | null | undefined, right: string | null | undefined): boolean {
+  const leftToken = companyNameToken(left);
+  const rightToken = companyNameToken(right);
+  return !!leftToken && !!rightToken && leftToken !== rightToken;
+}
+
+export interface SecListing {
+  /** The bare symbol, such as SAN. */
+  symbol: string;
+  /** The listing's canonical venue, such as EPA. */
+  exchange: string;
+  /** The listing's company, from its own quote. */
+  name: string;
+}
+
+/** "No SEC filings found for Sanofi (EPA). The SEC lists SAN as Banco Santander, S.A. (NYSE)." */
+export function secRegistrantMismatchMessage(listing: SecListing, registrantName: string, registrantExchange?: string | null): string {
+  const registrant = registrantExchange ? `${registrantName} (${registrantExchange})` : registrantName;
+  return `No SEC filings found for ${listing.name} (${listing.exchange}). The SEC lists ${listing.symbol} as ${registrant}${registrant.endsWith(".") ? "" : "."}`;
+}
+
+/** The SEC knows the listing's symbol as another company: SAN on EPA is Sanofi, SAN at the SEC is Banco Santander. */
+export class SecRegistrantMismatchError extends ProviderMissError {
+  constructor(readonly listing: SecListing, readonly registrantName: string) {
+    super(secRegistrantMismatchMessage(listing, registrantName));
+    this.name = "SecRegistrantMismatchError";
+  }
+}
+
+/** The company the filings were filed by. */
+function registrantName(filings: readonly SecFilingItem[]): string | null {
+  return filings.map((filing) => filing.companyName?.trim()).find((name): name is string => !!name) ?? null;
+}
+
+/**
+ * A lookup for a listing outside the US can answer with the US registrant of
+ * the same symbol: a backend that predates venue-aware lookups ignores the
+ * venue. Those filings are another company's, so they are refused.
+ */
+export function assertSecRegistrantMatches(filings: readonly SecFilingItem[], listing: SecListing): void {
+  const registrant = registrantName(filings);
+  if (registrant && areDifferentCompanies(listing.name, registrant)) {
+    throw new SecRegistrantMismatchError(listing, registrant);
+  }
+}

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

@@ -44,6 +44,7 @@ import {
 import type { AppAction, AppState } from "../../../core/state/app/state";
 import { scheduleConfigSave } from "../../config-save-scheduler";
 import { LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS } from "../../persist-scheduler";
+import { fireAndForget } from "../../../utils/fire-and-forget";
 
 export {
   appReducer,
@@ -565,10 +566,16 @@ export function AppProvider({
     if (signature === lastMainSyncRef.current) return;
     lastMainSyncRef.current = signature;
     latestMainStateRevisionRef.current += 1;
-    void desktopBridge.syncMainState({
-      ...snapshot,
-      mainStateRevision: latestMainStateRevisionRef.current,
-    });
+    // A snapshot that did not arrive must not count as sent. Forget it, unless
+    // a newer one has replaced it, so the next effect run sends it again. The
+    // two syncs below dedupe the same way.
+    fireAndForget(
+      desktopBridge.syncMainState({ ...snapshot, mainStateRevision: latestMainStateRevisionRef.current }),
+      "desktop.syncMainState",
+      () => {
+        if (lastMainSyncRef.current === signature) lastMainSyncRef.current = null;
+      },
+    );
   }, [
     buildDesktopSnapshot,
     desktopBridge,
@@ -581,9 +588,12 @@ export function AppProvider({
 
   useEffect(() => {
     if (desktopBridge?.kind !== "main" || !desktopBridge.syncThemePreview) return;
-    if (lastThemePreviewSyncRef.current === state.themePreview) return;
-    lastThemePreviewSyncRef.current = state.themePreview;
-    void desktopBridge.syncThemePreview({ theme: state.themePreview });
+    const theme = state.themePreview;
+    if (lastThemePreviewSyncRef.current === theme) return;
+    lastThemePreviewSyncRef.current = theme;
+    fireAndForget(desktopBridge.syncThemePreview({ theme }), "desktop.setThemePreview", () => {
+      if (lastThemePreviewSyncRef.current === theme) lastThemePreviewSyncRef.current = undefined;
+    });
   }, [desktopBridge, state.themePreview]);
 
   useEffect(() => {
@@ -598,7 +608,13 @@ export function AppProvider({
     const paneSignature = serializePaneState(state.paneState[desktopBridge.paneId]);
     if (paneSignature === lastDetachedPaneSyncRef.current) return;
     lastDetachedPaneSyncRef.current = paneSignature;
-    void desktopBridge.replaceDetachedPaneState(desktopBridge.paneId, state.paneState[desktopBridge.paneId] ?? {});
+    fireAndForget(
+      desktopBridge.replaceDetachedPaneState(desktopBridge.paneId, state.paneState[desktopBridge.paneId] ?? {}),
+      "desktop.replaceDetachedPaneState",
+      () => {
+        if (lastDetachedPaneSyncRef.current === paneSignature) lastDetachedPaneSyncRef.current = null;
+      },
+    );
   }, [desktopBridge, serializePaneState, state.paneState]);
 
   useLayoutEffect(() => {

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

@@ -106,21 +106,28 @@ export function useQuoteStreaming(
   const paneInView = usePaneInView();
   const coordinator = getSharedMarketDataCoordinator();
 
-  const normalizedEntries = new Map<string, QuoteSubscriptionTarget>();
-  for (const target of targets) {
-    const resolved = normalizeQuoteStreamSubscriptionTarget(target);
-    if (!resolved) continue;
-    const normalized = paneInView ? resolved : downgradeOffscreenQuoteTarget(resolved);
-    const key = buildQuoteStreamSubscriptionKey(normalized);
-    normalizedEntries.set(key, normalized);
-  }
-  const sortedEntries = [...normalizedEntries.entries()].sort(([left], [right]) => left.localeCompare(right));
-  const normalizedTargets = sortedEntries.map(([, target]) => target);
-  const subscriptionKey = sortedEntries.map(([key]) => key).join("|");
-  const identityKey = [...new Set(normalizedTargets.map(buildQuoteStreamSubscriptionIdentityKey))]
-    .sort()
-    .join("\u001f");
-  const coordinatorTargets = toCoordinatorQuoteTargets(normalizedTargets);
+  // Keyed on the array, not its contents: callers memoize their targets, and a
+  // portfolio re-renders on every data frame, where re-keying and sorting a
+  // thousand targets cost a few milliseconds each time.
+  const { coordinatorTargets, identityKey, subscriptionKey } = useMemo(() => {
+    const normalizedEntries = new Map<string, QuoteSubscriptionTarget>();
+    for (const target of targets) {
+      const resolved = normalizeQuoteStreamSubscriptionTarget(target);
+      if (!resolved) continue;
+      const normalized = paneInView ? resolved : downgradeOffscreenQuoteTarget(resolved);
+      const key = buildQuoteStreamSubscriptionKey(normalized);
+      normalizedEntries.set(key, normalized);
+    }
+    const sortedEntries = [...normalizedEntries.entries()].sort(([left], [right]) => left.localeCompare(right));
+    const normalizedTargets = sortedEntries.map(([, target]) => target);
+    return {
+      coordinatorTargets: toCoordinatorQuoteTargets(normalizedTargets),
+      identityKey: [...new Set(normalizedTargets.map(buildQuoteStreamSubscriptionIdentityKey))]
+        .sort()
+        .join("\u001f"),
+      subscriptionKey: sortedEntries.map(([key]) => key).join("|"),
+    };
+  }, [paneInView, targets]);
   const latestSubscriptionRef = useRef({
     identityKey,
     subscriptionKey,
@@ -208,11 +215,16 @@ export function useQuoteUpdates(
 ): void {
   const appActive = useAppVisible();
   const coordinator = getSharedMarketDataCoordinator();
-  const normalizedTargets = normalizeQuoteStreamSubscriptionTargets(targets);
-  const instrumentKey = normalizedTargets
-    .map((target) => buildQuoteKey(instrumentFromQuoteTarget(target)))
-    .sort()
-    .join("\u001f");
+  const { instrumentKey, normalizedTargets } = useMemo(() => {
+    const normalized = normalizeQuoteStreamSubscriptionTargets(targets);
+    return {
+      instrumentKey: normalized
+        .map((target) => buildQuoteKey(instrumentFromQuoteTarget(target)))
+        .sort()
+        .join("\u001f"),
+      normalizedTargets: normalized,
+    };
+  }, [targets]);
   const instruments = useMemo(() => uniqueQuoteInstruments(normalizedTargets), [instrumentKey]);
 
   useQuoteStreaming(targets, { enabled: liveStreaming });
@@ -270,12 +282,15 @@ export function useLiveQuoteEntries(
   subscriptionStartedAt: number;
 } {
   const appActive = useAppVisible();
-  const normalizedTargets = normalizeQuoteStreamSubscriptionTargets(targets);
-  const targetKey = [...new Set(
-    normalizedTargets.map((target) => buildQuoteStreamSubscriptionIdentityKey(target)),
-  )]
-    .sort()
-    .join("\u001f");
+  const { normalizedTargets, targetKey } = useMemo(() => {
+    const normalized = normalizeQuoteStreamSubscriptionTargets(targets);
+    return {
+      normalizedTargets: normalized,
+      targetKey: [...new Set(normalized.map((target) => buildQuoteStreamSubscriptionIdentityKey(target)))]
+        .sort()
+        .join("\u001f"),
+    };
+  }, [targets]);
   const liveStreaming = options.liveStreaming !== false;
   const freshnessKey = options.freshnessScopeKey ?? targetKey;
   const subscriptionKey = `${appActive ? "active" : "inactive"}\u001f${liveStreaming ? "live" : "poll"}\u001f${freshnessKey}`;

package/src/sync/core-contributors.ts

@@ -102,6 +102,10 @@ function sanitizePortfolio(portfolio: Portfolio): Portfolio {
     currency: portfolio.currency,
     brokerId: portfolio.brokerId,
     lastSyncedAt: portfolio.lastSyncedAt,
+    // Cash and targets are the user's own entries: a pulled portfolio without
+    // them would erase them on this device.
+    ...(portfolio.cash ? { cash: { ...portfolio.cash } } : {}),
+    ...(portfolio.targetWeights ? { targetWeights: { ...portfolio.targetWeights } } : {}),
   };
 }
 

package/src/telemetry/crash-reports.ts

@@ -6,6 +6,7 @@ import {
   type CrashReportsPayload,
 } from "../api-client";
 import type { TelemetryConfig } from "../types/config";
+import { isSleepRpcTimeout } from "../utils/rpc-timeout-error";
 import { VERSION } from "../version";
 
 /**
@@ -172,10 +173,12 @@ function toReportError(error: unknown, context: CrashReportContext): PendingErro
 /**
  * Queues one error. Safe to call from any error handler: it never throws,
  * never awaits, and drops the error when reporting is off, already seen this
- * session, or over the session cap.
+ * session, or over the session cap. A desktop request timeout that fired
+ * after the machine slept is not an error at all and is dropped too.
  */
 export function reportCrash(error: unknown, context: CrashReportContext): void {
   try {
+    if (isSleepRpcTimeout(error)) return;
     if (host && !host.isEnabled()) return;
     if (accepted >= MAX_ERRORS_PER_SESSION) return;
     const entry = toReportError(error, context);

package/src/test-support/cli-context.ts

@@ -8,7 +8,8 @@ export interface PrintedCliResult {
 }
 
 /**
- * A command context whose `initMarketData` resolves to `market` (config, store, dataProvider, ...).
+ * A command context whose `initMarketData` and `initConfigData` resolve to `market` (config, store, dataProvider, ...),
+ * with an empty ticker store unless `market` brings one.
  * `fail` throws, every printResult call is kept in `printed`, and `closeCount` reports how many
  * times the command closed its persistence.
  */
@@ -18,9 +19,16 @@ export function createTestCliContext(
 ): { context: CliCommandContext; printed: PrintedCliResult[]; closeCount: () => number } {
   const printed: PrintedCliResult[] = [];
   let closed = 0;
+  const init = async () => ({
+    persistence: { close: () => { closed += 1; } },
+    // Commands look up the saved listing of every symbol they are given.
+    store: { loadTicker: async () => null, loadAllTickers: async () => [] },
+    ...market,
+  });
   const context = {
     cliOptions: { ...DEFAULT_CLI_OPTIONS, ...cliOptions },
-    initMarketData: async () => ({ persistence: { close: () => { closed += 1; } }, ...market }),
+    initMarketData: init,
+    initConfigData: init,
     printResult: (result: CliResult<any>, options?: CliResultRenderOptions<any, any>) => { printed.push({ result, options }); },
     fail: (message: string): never => { throw new Error(message); },
   } as unknown as CliCommandContext;