gloomberb 0.16.0 → 0.16.2

package/src/renderers/electrobun/view/rpc-timeout.ts

@@ -1,6 +1,10 @@
 import { getCloudApiBaseUrl } from "../../../api-client/request";
+import { RpcTimeoutError } from "../../../utils/rpc-timeout-error";
 import type { DesktopBackendRequestMethod } from "../shared/protocol";
 
+/** How long the view waits for the Bun process to answer one request. */
+export const RPC_MAX_REQUEST_TIME_MS = 120_000;
+
 /** What Electrobun's request timer rejects with: no method, request id or caller. */
 const ELECTROBUN_REQUEST_TIMEOUT_MESSAGE = "RPC request timed out.";
 
@@ -16,7 +20,9 @@ const ELECTROBUN_REQUEST_TIMEOUT_MESSAGE = "RPC request timed out.";
  * from the user's config (a broker gateway, a feed, a plugin endpoint) and is
  * only called external. Never the payload, rest of the path, query or headers.
  * Elapsed time is rounded to 10 s because crash reports are deduplicated per
- * session on the message.
+ * session on the message. The error keeps its message and `Error` type, and
+ * carries the elapsed time so a timer that fired long after its limit (the
+ * machine slept) can be told from a request that really stalled.
  */
 export async function nameRpcTimeout<T>(
   method: DesktopBackendRequestMethod,
@@ -28,8 +34,13 @@ export async function nameRpcTimeout<T>(
     return await request();
   } catch (error) {
     if (!(error instanceof Error) || error.message !== ELECTROBUN_REQUEST_TIMEOUT_MESSAGE) throw error;
-    const seconds = Math.round((performance.now() - startedAt) / 10_000) * 10;
-    throw new Error(`RPC request timed out: ${describeRequest(method, payload)} after ~${seconds}s`, { cause: error });
+    const elapsedMs = performance.now() - startedAt;
+    const seconds = Math.round(elapsedMs / 10_000) * 10;
+    throw new RpcTimeoutError(`RPC request timed out: ${describeRequest(method, payload)} after ~${seconds}s`, {
+      elapsedMs,
+      limitMs: RPC_MAX_REQUEST_TIME_MS,
+      cause: error,
+    });
   }
 }
 

package/src/renderers/electrobun/view/update-host.ts

@@ -6,33 +6,57 @@ import {
 } from "../../../updater";
 import { backendRequest, onBackendMessage } from "./backend-rpc";
 
+/**
+ * Starts a backend update request and follows its `update.progress` messages
+ * until one ends the flow: `ready` ends a download, and `done` or `error` end
+ * either flow. A request that itself fails is reported as an error.
+ */
+function followUpdateFlow(
+  start: () => Promise<unknown>,
+  onProgress: (progress: UpdateProgress) => void,
+  endsFlow: (progress: UpdateProgress) => boolean,
+): Promise<void> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const unsubscribe = onBackendMessage("update.progress", ({ progress }) => {
+      onProgress(progress);
+      if (endsFlow(progress)) {
+        settled = true;
+        unsubscribe();
+        resolve();
+      }
+    });
+
+    start().catch((error) => {
+      if (settled) return;
+      unsubscribe();
+      onProgress({
+        phase: "error",
+        error: error instanceof Error ? error.message : String(error),
+      });
+      resolve();
+    });
+  });
+}
+
 export function installElectrobunUpdateHost(): void {
   setUpdateHost({
     checkForUpdateDetailed(currentVersion: string): Promise<UpdateCheckResult> {
       return backendRequest("update.check", { currentVersion });
     },
     performUpdate(release: ReleaseInfo, onProgress: (progress: UpdateProgress) => void): Promise<void> {
-      return new Promise((resolve) => {
-        let settled = false;
-        const unsubscribe = onBackendMessage("update.progress", ({ progress }) => {
-          onProgress(progress);
-          if (progress.phase === "done" || progress.phase === "error") {
-            settled = true;
-            unsubscribe();
-            resolve();
-          }
-        });
-
-        backendRequest("update.start", { release }).catch((error) => {
-          if (settled) return;
-          unsubscribe();
-          onProgress({
-            phase: "error",
-            error: error instanceof Error ? error.message : String(error),
-          });
-          resolve();
-        });
-      });
+      return followUpdateFlow(
+        () => backendRequest("update.start", { release }),
+        onProgress,
+        (progress) => progress.phase === "ready" || progress.phase === "done" || progress.phase === "error",
+      );
+    },
+    applyUpdate(onProgress: (progress: UpdateProgress) => void): Promise<void> {
+      return followUpdateFlow(
+        () => backendRequest("update.apply"),
+        onProgress,
+        (progress) => progress.phase === "done" || progress.phase === "error",
+      );
     },
   });
 }

package/src/renderers/opentui/host.tsx

@@ -108,6 +108,11 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
     enableMouseMovement: true,
   });
   const root = createRoot(renderer);
+  // Every mounted ScrollBox listens for `selection` and many components for
+  // `resize`, so the counts grow with the panes on screen (14 and 18 with one
+  // DES open at 80x24) and fall back when they close. Node's default warning
+  // at 11 is not a leak here, and it prints over the panes.
+  renderer.setMaxListeners(0);
   installResolutionEventBridge(renderer);
   // Streamed quotes apply and notify on one clock of up to 10 Hz: every
   // visible row stays live while a burst of ticks costs one terminal redraw,

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

@@ -40,6 +40,8 @@ import { resolveCurrencyUnit } from "../../utils/currency-units";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss } from "../provider-errors";
+import { assertSecRegistrantMatches } from "../sec-registrant";
+import { nonUsSecListingVenue } from "../../utils/sec";
 import { publicListingTarget } from "../listing-target";
 import { canonicalHistoryInterval, HistoryRetentionError, parseHistoryRecoveryCandidate, parseHistoryRetention, type HistoryRetention } from "../history-retention";
 import { getRouterEntityKey } from "../provider-router/cache";
@@ -195,7 +197,7 @@ function mapCloudPriceHistory(
       `Cloud chart data is unavailable for ${ticker}`,
     ).map((point) => mapPricePoint(point, divisor, exchange)),
   );
-  if (stale && !reachesLatestSettledSession(points, Date.now(), { exchange, intervalMs: priceHistoryIntervalMs(interval) })) {
+  if (stale && !reachesLatestSettledSession(points, Date.now(), { symbol: ticker, exchange, intervalMs: priceHistoryIntervalMs(interval) })) {
     throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
   }
   if (
@@ -486,11 +488,30 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     );
   }
 
-  async getSecFilings(ticker: string, count = 15): Promise<SecFilingItem[]> {
-    return withCloudFallback(async () => {
-      const response = await apiClient.getCloudSecFilings({ ticker, limit: count, offset: 0 });
+  async getSecFilings(ticker: string, count = 15, exchange?: string, context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
+    const venue = nonUsSecListingVenue(ticker, exchange);
+    const name = venue ? context?.listingName?.trim() || await this.listingName(ticker, venue) || undefined : undefined;
+    const filings = await withCloudFallback(async () => {
+      const response = await apiClient.getCloudSecFilings({ ticker, exchange, name, limit: count, offset: 0 });
       return response.filings.map(mapCloudSecFiling);
     }, `Cloud SEC filings are unavailable for ${ticker}`);
+    if (!venue || filings.length === 0) return filings;
+    const symbol = parsePublicTickerKey(ticker).symbol;
+    // Without the listing's company the filings cannot be told apart from another company's.
+    if (!name) throw createProviderMiss(`SEC filings for ${symbol} could not be matched to its ${venue} listing`);
+    assertSecRegistrantMatches(filings, { symbol, exchange: venue, name });
+    return filings;
+  }
+
+  /** The company a listing belongs to, from its own quote; null when the quote prices another venue. */
+  private async listingName(ticker: string, venue: string): Promise<string | null> {
+    try {
+      const quote = await this.getQuote(ticker, venue);
+      const quoteVenue = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+      return quoteVenue === venue ? quote.name?.trim() || null : null;
+    } catch {
+      return null;
+    }
   }
 
   async getSecFilingDocuments(filing: SecFilingItem): Promise<SecFilingDocument[]> {

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

@@ -36,10 +36,31 @@ 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,
 ): Quote {
+  if (quote.priceBasis != null && !["nav", "per-unit", "percent-of-par", "points", "thirty-seconds"].includes(quote.priceBasis)) {
+    throw createProviderMiss("Unsupported quote price basis");
+  }
   const { currency, divisor } = resolveCurrencyUnit(quote.currency);
   const listingExchangeName = quote.listingExchangeName ?? quote.exchangeName;
   const listingExchangeFullName =
@@ -47,24 +68,34 @@ 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.
   const generic = futuresGenericListing(quote.symbol, quote.listingExchangeName ?? quote.exchangeName);
-  const priceBasis = generic ? futuresGenericPriceBasis(generic) : null;
+  const priceObservation = quote.priceBasis === "nav" ? "nav" : undefined;
+  const priceBasis = quote.priceBasis === "nav"
+    ? "per-unit"
+    : (generic ? futuresGenericPriceBasis(generic) : null) ?? quote.priceBasis;
   return withoutUndefinedFields(reconcileQuoteDayRange({
     ...quote,
-    ...priceBasis ? { priceBasis } : {},
+    priceBasis,
+    priceObservation,
     currency: currency || quote.currency,
     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,
@@ -92,7 +92,7 @@ export function sanitizeCachedFinancials(
 }
 
 export function quoteWithFreshnessExchange(quote: Quote, exchange?: string): Quote {
-  if (!exchange || quote.listingExchangeName || quote.exchangeName) return quote;
+  if (!exchange || quote.priceObservation != null || quote.listingExchangeName || quote.exchangeName) return quote;
   return {
     ...quote,
     listingExchangeName: exchange,
@@ -123,18 +123,21 @@ function isQuoteInActiveSession(quote: Quote, now: number): boolean {
 }
 
 function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
+  // The shared freshness predicate already validates and dates a daily NAV.
+  if (quote.priceObservation === "nav") return false;
   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 } } : {}),
   };
 }