gloomberb 0.18.1 → 0.18.3

package/src/renderers/electrobun/view/news-source.ts

@@ -1,12 +1,13 @@
 import { apiClient } from "../../../api-client";
 import { newsProvider, type NewsCapability } from "../../../capabilities";
 import { cloudNewsParams, mapCloudNewsArticle } from "../../../sources/gloomberb-cloud/news";
-import type { NewsArticle, NewsQuery } from "../../../types/news-source";
+import type { NewsArticle, NewsPage, NewsQuery } from "../../../news/types";
 
 interface BackendNews {
   id: string;
   name: string;
   getNews(query: NewsQuery): Promise<NewsArticle[]>;
+  getNewsPage(query: NewsQuery): Promise<NewsPage>;
 }
 
 type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "getCloudNewsStory">;
@@ -33,7 +34,8 @@ export function createDesktopNewsSource(backend: BackendNews, client: CloudNewsC
             nextCursor: response.nextCursor ?? null,
           };
         } catch {
-          return { articles: await backend.getNews(query), nextCursor: null };
+          // The aggregate page keeps RSS failures beside any usable stories.
+          return backend.getNewsPage(query);
         }
       },
       fetchNewsStory: async (storyId) => mapCloudNewsArticle(await client.getCloudNewsStory(storyId)),

package/src/renderers/electrobun/view/remote/asset-data-client.ts

@@ -1,5 +1,5 @@
 import type { CapabilityManifest } from "../../../../capabilities";
-import type { NewsArticle, NewsQuery } from "../../../../news/types";
+import type { NewsArticle, NewsPage, NewsQuery } from "../../../../news/types";
 import type { DataProvider } from "../../../../types/data-provider";
 import type { TickerFinancials } from "../../../../types/financials";
 import { backendRequest, getElectrobunBackendInitSnapshot, subscribeBackendCapability } from "../backend-rpc";
@@ -14,6 +14,7 @@ const ASSET_DATA_REQUEST_TIMEOUT_MS = 115_000;
 
 export type RemoteAssetDataClient = DataProvider & {
   getNews(query: NewsQuery): Promise<NewsArticle[]>;
+  getNewsPage(query: NewsQuery): Promise<NewsPage>;
 };
 
 interface RemoteAssetDataClientBase {
@@ -21,6 +22,7 @@ interface RemoteAssetDataClientBase {
   name: string;
   getCachedFinancialsForTargets: NonNullable<DataProvider["getCachedFinancialsForTargets"]>;
   getNews(query: NewsQuery): Promise<NewsArticle[]>;
+  getNewsPage(query: NewsQuery): Promise<NewsPage>;
   subscribeQuotes: NonNullable<DataProvider["subscribeQuotes"]>;
 }
 
@@ -130,6 +132,11 @@ export function createRemoteAssetDataClient(): RemoteAssetDataClient {
         ? invoke<NewsArticle[]>(NEWS_CAPABILITY_ID, "fetchNews", { query })
         : Promise.resolve([])
     ),
+    getNewsPage: (query) => (
+      hasRendererOperation(newsOperations, "fetchNewsPage")
+        ? invoke<NewsPage>(NEWS_CAPABILITY_ID, "fetchNewsPage", { query })
+        : Promise.reject(new Error("News is unavailable."))
+    ),
     subscribeQuotes: (targets, onQuote) => {
       if (!hasRendererOperation(assetDataOperations, "subscribeQuotes")) return () => {};
       return quoteSubscriptions.subscribe(targets, onQuote);

package/src/renderers/opentui/start.tsx

@@ -37,6 +37,9 @@ import {
   readOrCreateInstallId,
 } from "../../telemetry/crash-reports-node";
 import { currentTelemetryConfig } from "../../telemetry/live-config";
+import { installUpdateFailureReporter } from "../../telemetry/update-failures";
+import { createNodeUpdateFailureHost } from "../../telemetry/update-failures-node";
+import { terminalInstallKind } from "../../updater";
 import { flushUsageCounts, installUsageCounter, usageCountsEnabled } from "../../telemetry/usage-counts";
 import { attentionCountsEnabled, installAttentionCounter } from "../../telemetry/attention-counts";
 import { starPromptEnvironmentAllows } from "../../app/star-prompt/model";
@@ -117,6 +120,10 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       surface: "terminal",
       getConfig: () => ({ dataDir: config.dataDir, telemetry: currentTelemetryConfig(config)?.telemetry }),
     }));
+    installUpdateFailureReporter(createNodeUpdateFailureHost({
+      installKind: terminalInstallKind(),
+      getDataDir: () => config.dataDir,
+    }));
     installUsageCounter({
       surface: "terminal",
       os: describeNodeOs(),

package/src/series/validate.ts

@@ -14,8 +14,8 @@ const DRAW_STYLES: readonly SeriesDrawStyle[] = ["line", "area", "step", "column
 const PLACEMENTS: readonly SeriesPlacement[] = ["price", "panel"];
 const LINE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const COLOR_PATTERN = /^#[0-9A-Fa-f]{6}$/;
-/** A chart holds ten series: the ticker's price and the lines, with one to spare. */
-const MAX_SERIES_LINES = 8;
+/** A chart holds twenty series: the ticker's price and up to sixteen lines, with room for a few more. */
+const MAX_SERIES_LINES = 16;
 
 /** Units with no scale: a percentage of something, not a quantity of it. */
 const RATE_UNITS = ["%", "bp", "x", "ratio", "index", "score", "points"] as const;

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

@@ -30,6 +30,7 @@ import { parseHistorySession } from "../../market-data/history-session";
 import { quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import type { InstrumentSearchResult } from "../../types/instrument";
 import type { TickerChanges } from "../../types/ticker-changes";
+import type { IssuerListings } from "../../types/issuer-listings";
 import {
   apiClient,
   type CloudAnalystResearchPayload,
@@ -45,6 +46,7 @@ import { isRoundTheClockCoin } from "../../utils/crypto-pair";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss, ProviderBusyError, providerMissReason } from "../provider-errors";
+import { parseListingDelisting } from "../../market-data/quotes/delisting";
 import { isRetryableApiError } from "../../api-client/errors";
 import { assertSecRegistrantMatches } from "../sec-registrant";
 import { nonUsSecListingVenue } from "../../utils/sec";
@@ -251,9 +253,11 @@ function mapCloudPriceHistory(
   }
   // Sessions of daily bars the answer left out for a close at or below zero.
   const nonPositiveCloseDates = resolution === "1d" ? cloudNonPositiveCloseDates(response.omittedSessions) : undefined;
+  const delisting = parseListingDelisting(response.delisting);
   return {
     points,
     resolution,
+    ...(delisting ? { delisting } : {}),
     ...(session && matchingSource && matchingIdentity ? { session } : {}),
     ...(nonPositiveCloseDates ? { nonPositiveCloseDates } : {}),
     ...(coverageStart ? { coverageStart } : {}),
@@ -262,6 +266,28 @@ function mapCloudPriceHistory(
   };
 }
 
+const DAY_MS = 86_400_000;
+/** Listings Gloom Cloud said no longer trade, by listing key: the day after each one's last session. */
+const delistedHistoryEnds = new Map<string, Date>();
+
+/**
+ * Where a trailing window ends for a listing that no longer trades: the day
+ * after its last session, as a window ending now ends the day after today's.
+ * A window ending now would hold none of its bars, or only the last few.
+ */
+function delistedHistoryEnd(response: CloudMarketResponse<unknown>, key: string): Date | null {
+  const delisting = parseListingDelisting(response.delisting);
+  if (!delisting) {
+    // The symbol trades again (another issuer took it): its windows end now.
+    delistedHistoryEnds.delete(key);
+    return null;
+  }
+  const end = new Date(Date.parse(`${delisting.lastTradeDate}T00:00:00Z`) + DAY_MS);
+  if (delistedHistoryEnds.size >= 1024) delistedHistoryEnds.clear();
+  delistedHistoryEnds.set(key, end);
+  return end;
+}
+
 function cloudHistoryResolution(interval: string): ManualChartResolution | null {
   const canonical = canonicalHistoryInterval(interval);
   return (["1m", "5m", "15m", "30m", "1h", "1d", "1wk", "1mo"] as const)
@@ -549,14 +575,14 @@ export class GloomberbCloudProvider implements AssetDataProvider {
         // A successful batch can contain an expired cache fallback for only
         // one listing. Match the single-quote freshness boundary and let the
         // normal router retry that item without discarding its healthy peers.
-        if (item.stale === true) {
+        // A listing that no longer trades has only that last quote: kept, flagged stale.
+        const delisted = !!parseListingDelisting(item.data?.delisting);
+        if (item.stale === true && !delisted) {
           return { target, quote: null, error: createProviderMiss(`Cloud quotes are stale for ${target.symbol}`) };
         }
         if ((item.status === "success" || item.status === "partial") && item.data) {
-          return {
-            target,
-            quote: retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol),
-          };
+          const quote = retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol);
+          return { target, quote: item.stale === true ? { ...quote, stale: true } : quote };
         }
         return {
           target,
@@ -693,6 +719,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return cloudTickerChangesBatch(symbols, options);
   }
 
+  async getIssuerListings(symbol: string, exchange = "", options: { signal?: AbortSignal } = {}): Promise<IssuerListings | null> {
+    const response = await apiClient.getCloudIssuerListings(symbol, exchange, options);
+    // "empty" is an answer: the service holds no company for the listing.
+    return response.status === "success" || response.status === "partial" ? response.data : null;
+  }
+
   async searchBatch(queries: string[], options: { limit?: number; signal?: AbortSignal } = {}): Promise<Map<string, InstrumentSearchResult[]> | null> {
     const answers = await cloudSearchBatch(queries, options);
     if (!answers) return null;
@@ -778,19 +810,27 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const target = cloudInstrumentTarget(ticker, exchange);
     exchange = target.exchange ?? "";
     const interval = toCloudInterval(resolution);
-    const endDate = new Date();
-    const startDate = subtractTimeRange(endDate, bufferRange);
     const includeTime = /^\d+(min|h)$/i.test(interval);
-    const { response, extendedHours } = await withCloudFallback(
-      () => loadCloudHistory(interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, {
-        interval,
-        startDate: formatCloudDateTime(startDate, includeTime, exchange),
-        endDate: formatCloudHistoryEnd(endDate, includeTime, exchange),
-        ...(session ? { session } : {}),
-      }), _context),
-      `Cloud chart data is unavailable for ${ticker}`,
-    );
-    return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate, extendedHours);
+    const listingKey = canonicalTickerKey(target.symbol, exchange);
+    const load = (endDate: Date) => {
+      const startDate = subtractTimeRange(endDate, bufferRange);
+      return withCloudFallback(
+        () => loadCloudHistory(interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, {
+          interval,
+          startDate: formatCloudDateTime(startDate, includeTime, exchange),
+          endDate: formatCloudHistoryEnd(endDate, includeTime, exchange),
+          ...(session ? { session } : {}),
+        }), _context),
+        `Cloud chart data is unavailable for ${ticker}`,
+      ).then((answer) => ({ ...answer, startDate, endDate }));
+    };
+    // A listing that no longer trades is read up to its last session, not up to now.
+    const knownEnd = delistedHistoryEnds.get(listingKey);
+    const now = new Date();
+    let answer = await load(knownEnd ?? now);
+    const delistedEnd = delistedHistoryEnd(answer.response, listingKey);
+    if (delistedEnd ? delistedEnd.getTime() < answer.endDate.getTime() : knownEnd) answer = await load(delistedEnd ?? now);
+    return mapCloudPriceHistory(answer.response, target.symbol, exchange, interval, answer.startDate, answer.endDate, answer.extendedHours);
   }
 
   async getDetailedPriceHistory(

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

@@ -27,6 +27,7 @@ import { createProviderMiss } from "../provider-errors";
 import { reconcileQuoteDayRange } from "../../market-data/quotes/day-range";
 import { redactUnavailableFundamentals } from "../../utils/fundamentals";
 import { readWithdrawnObservations } from "../../utils/statement-gaps";
+import { parseListingDelisting } from "../../market-data/quotes/delisting";
 
 export const GLOOMBERB_CLOUD_PROVIDER_ID = "gloomberb-cloud" as const;
 
@@ -94,6 +95,7 @@ export function mapQuote(
     : futuresBasis ?? quote.priceBasis;
   return withoutUndefinedFields(reconcileQuoteDayRange({
     ...quote,
+    delisting: parseListingDelisting(quote.delisting),
     priceBasis,
     priceObservation,
     currency: currency || quote.currency,
@@ -130,6 +132,8 @@ export function mapQuote(
       divisor,
     ),
     extendedSessionPrint: typeof quote.extendedSessionPrint === "boolean" ? quote.extendedSessionPrint : undefined,
+    // A coin's move over 24 hours, or none, when its previous close is undatable.
+    changeBasis: quote.changeBasis === "24h" || quote.changeBasis === "none" ? quote.changeBasis : undefined,
     overnightPrice: normalizePriceValueByDivisor(quote.overnightPrice, divisor),
     overnightChange: normalizePriceValueByDivisor(quote.overnightChange, divisor),
     overnightPriceKind: quote.overnightPriceKind === "trade" || quote.overnightPriceKind === "mark"

package/src/sources/history-result.ts

@@ -6,6 +6,7 @@ import { parseHistorySession } from "../market-data/history-session";
 import { canonicalHistoryInterval } from "./history-retention";
 import { historyCoverageNoteText, isHistoryCoverageDate } from "./history-coverage";
 import { readNonPositiveCloseDates } from "./history-omitted";
+import { parseListingDelisting } from "../market-data/quotes/delisting";
 
 export type HistoryResultRequest =
   | { kind: "range"; range: TimeRange }
@@ -38,6 +39,7 @@ export function normalizeHistoryResult(
   // A contradictory declaration cannot be laundered into unknown legacy data.
   if (result.session != null && (!session || result.resolution === null)) return null;
   const nonPositiveCloseDates = readNonPositiveCloseDates(result.nonPositiveCloseDates);
+  const delisting = parseListingDelisting(result.delisting);
   return { points: result.points, resolution: result.resolution,
     ...(session ? { session } : {}),
     ...(nonPositiveCloseDates ? { nonPositiveCloseDates } : {}),
@@ -47,6 +49,7 @@ export function normalizeHistoryResult(
       ? { coverageNote: historyCoverageNoteText(result.coverageNote) } : {}),
     ...(result.extendedHours === true ? { extendedHours: true } : {}),
     ...(result.savedCopyBehind === true ? { savedCopyBehind: true as const } : {}),
+    ...(delisting ? { delisting } : {}),
   };
 }
 

package/src/sources/provider-errors.ts

@@ -1,4 +1,6 @@
-const PROVIDER_MISS_BRAND = Symbol("provider-miss");
+// Registered, so a miss raised by another copy of this module (a plugin that
+// resolved `gloomberb/market-data` from the source tree) is still recognized.
+const PROVIDER_MISS_BRAND = Symbol.for("gloomberb.provider-miss");
 const EXPECTED_PROVIDER_MISS = /No data found|symbol may be delisted|"code":"Not Found"|No history for /i;
 
 const MAX_REASON_LENGTH = 200;

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

@@ -4,6 +4,7 @@ import { canonicalHistoryInterval, HistoryRetentionError, isHistoryRetentionErro
   type HistoryRecoveryCandidate, type HistoryRetention, type HistorySourceOutcome } from "../history-retention";
 import type { BrokerCandidate } from "./brokers";
 import { withBrokerTimeout } from "./brokers";
+import type { BrokerHistoryOptions } from "../../types/broker";
 import type { DataProvider, MarketDataRequestContext } from "../../types/data-provider";
 import type { PriceHistoryResult } from "../../types/price-history";
 import { fetchHistoryResult, historyResolutionForInterval, InvalidHistoryResultError, normalizeHistoryResult } from "../history-result";
@@ -244,6 +245,29 @@ function mergeRequestHistoryGaps(
   })));
 }
 
+/** The extended session goes only to a broker that serves it, and only when the chart asked. */
+function brokerHistoryOptions(candidate: BrokerCandidate, context?: MarketDataRequestContext): [BrokerHistoryOptions] | [] {
+  return context?.historySession === "extended" && candidate.broker.extendedHoursHistory === true ? [{ session: "extended" }] : [];
+}
+
+/**
+ * With Ext hours on, a broker that serves only the regular session answers
+ * after the market-data providers, which may hold the extended session; it is
+ * still the last resort before nothing. Otherwise the order is unchanged.
+ */
+function brokersForSession(candidates: BrokerCandidate[], context?: MarketDataRequestContext): { first: BrokerCandidate[]; last: BrokerCandidate[] } {
+  if (context?.historySession !== "extended") return { first: candidates, last: [] };
+  return {
+    first: candidates.filter((candidate) => candidate.broker.extendedHoursHistory === true),
+    last: candidates.filter((candidate) => candidate.broker.extendedHoursHistory !== true),
+  };
+}
+
+function isIntradayInterval(interval: string | undefined): boolean {
+  const ms = interval ? priceHistoryIntervalMs(interval) : null;
+  return ms != null && ms < 24 * 60 * 60 * 1000;
+}
+
 function normalizeRequestResult(value: PriceHistoryResult, request: HistoryRequestDescriptor): PriceHistoryResult {
   // Only this router says a copy is behind, when it answers: neither a source
   // nor a stored copy can carry that verdict in.
@@ -254,8 +278,12 @@ function normalizeRequestResult(value: PriceHistoryResult, request: HistoryReque
   };
 }
 
-/** A copy fetched at `fetchedAt`, now for a source's answer. */
+/**
+ * A copy fetched at `fetchedAt`, now for a source's answer. A listing that no
+ * longer trades is never behind: its bars end on its last session for good.
+ */
 function resultIsStale(value: PriceHistoryResult, symbol: string, exchange: string, fetchedAt: number, intervalMs?: number | null): boolean {
+  if (value.delisting) return false;
   return isPriceHistoryStaleForCurrentWindow(value.points, Date.now(), {
     symbol, exchange, intervalMs: intervalMs ?? (value.resolution ? priceHistoryIntervalMs(value.resolution) : undefined), session: value.session,
     fetchedAt,
@@ -425,6 +453,7 @@ export class ProviderRouterHistoryRoutes {
           bufferRange,
           resolution,
           context?.instrument ?? null,
+          ...brokerHistoryOptions(candidate, context),
         )
         : null,
       fetchProvider: (provider) => fetchHistoryResult(provider, ticker, exchange, { kind: "resolution", range: bufferRange, resolution }, context),
@@ -543,6 +572,7 @@ export class ProviderRouterHistoryRoutes {
           endDate,
           barSize,
           context?.instrument ?? null,
+          ...brokerHistoryOptions(candidate, context),
         )
         : null,
       fetchProvider: (provider) => fetchHistoryResult(provider, ticker, exchange, { kind: "detail", start: startDate, end: endDate, interval: barSize }, context),
@@ -551,10 +581,13 @@ export class ProviderRouterHistoryRoutes {
 
   private async executeHistoryRequest(request: HistoryRequestDescriptor): Promise<PriceHistoryResult> {
     const recovery = this.validateRecovery(request);
-    const brokerCandidates = recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false);
+    const { first: brokerCandidates, last: regularSessionBrokers } = brokersForSession(
+      recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false), request.context);
+    // Cached copies rank in the order the sources are asked.
     const sourceKeys = recovery ? [recovery.sourceKey] : [
       ...brokerCandidates.map((candidate) => this.deps.brokerSourceKey(candidate)),
       ...this.deps.getProviderSourceKeys(),
+      ...regularSessionBrokers.map((candidate) => this.deps.brokerSourceKey(candidate)),
     ];
     const cachedRecords = listCachedResources<unknown>(
       this.deps.resources,
@@ -584,6 +617,7 @@ export class ProviderRouterHistoryRoutes {
     const currentWindow = request.requestedEnd === undefined || isCurrentHistoryWindow(new Date(request.requestedEnd));
     const now = Date.now();
     const fetchState = (record: { fetchedAt: number; value: PriceHistoryResult }, checkedAt?: number): CalendarHistoryFetchState => currentWindow
+      && !record.value.delisting
       ? calendarHistoryFetchState(record.value.points, record.fetchedAt, now, {
         symbol: target.symbol,
         exchange: target.exchange || request.target.exchange,
@@ -661,6 +695,12 @@ export class ProviderRouterHistoryRoutes {
     });
     if (providerResult && hasUsablePriceHistory(providerResult.value.points)) return withReportedGaps(providerResult.value);
     if (providerResult) reportedGaps.push(providerResult.value);
+    if (regularSessionBrokers.length) {
+      const regularResult = await withBrokerTimeout(this.fetchBrokerHistory(request, regularSessionBrokers, onUnavailable, attempts));
+      for (const sourceKey of [...attempts.pending]) recordHistoryOutcome(attempts, sourceKey, "timeout");
+      if (regularResult && hasUsablePriceHistory(regularResult.value.points)) return withReportedGaps(regularResult.value);
+      if (regularResult) reportedGaps.push(regularResult.value);
+    }
     // A failed refetch falls back in the same order the cache hit used, so a
     // failing request answers what the next request will: a current copy
     // first, else a saved copy short of the latest session, which beats an
@@ -722,10 +762,12 @@ export class ProviderRouterHistoryRoutes {
   private async refreshHistory(request: HistoryRequestDescriptor): Promise<void> {
     try {
       const recovery = this.validateRecovery(request);
-      const brokerCandidates = recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false);
-      const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, brokerCandidates));
+      const { first, last } = brokersForSession(recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false), request.context);
+      const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, first));
       if (brokerResult && hasUsablePriceHistory(brokerResult.value.points)) return;
-      await this.fetchProviderHistory(request);
+      const providerResult = await this.fetchProviderHistory(request);
+      if (providerResult && hasUsablePriceHistory(providerResult.value.points)) return;
+      if (last.length) await withBrokerTimeout(this.fetchBrokerHistory(request, last));
     } catch (error) {
       logFailure("sources.provider-router.history", "Refreshing background price history failed")(error);
     }
@@ -745,7 +787,8 @@ export class ProviderRouterHistoryRoutes {
         const fetched = await request.fetchBroker(candidate);
         if (fetched === null) { recordHistoryOutcome(attempts, sourceKey, "empty"); return null; }
         if (!Array.isArray(fetched)) { recordHistoryOutcome(attempts, sourceKey, "malformed"); return null; }
-        const value = normalizeRequestResult({ points: fetched, resolution: historyResolutionForInterval(request.interval), sourceKey }, request);
+        const value = normalizeRequestResult({ points: fetched, resolution: historyResolutionForInterval(request.interval), sourceKey,
+          ...(brokerHistoryOptions(candidate, request.context).length && isIntradayInterval(request.interval) ? { extendedHours: true } : {}) }, request);
         if (hasUsablePriceHistory(value.points) && request.isFetchedValueStale(value)) { recordHistoryOutcome(attempts, sourceKey, "stale"); return null; }
         recordHistoryOutcome(attempts, sourceKey, hasUsablePriceHistory(value.points) ? "success" : value.points.length ? "reported-gaps" : "empty");
         onUnavailable?.(this.deps.brokerSourceKey(candidate), value);

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

@@ -26,6 +26,7 @@ import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget
 import type { NewsArticle, NewsQuery } from "../../news/types";
 import type { BrokerContractRef, InstrumentSearchResult } from "../../types/instrument";
 import type { TickerChanges } from "../../types/ticker-changes";
+import type { IssuerListings } from "../../types/issuer-listings";
 import type { TimeRange } from "../../time-series/range";
 import type { ChartResolutionSupport, ManualChartResolution } from "../../time-series/resolution";
 import { debugLog } from "../../utils/debug-log";
@@ -317,6 +318,21 @@ export class AssetDataRouter implements DataProvider {
     return null;
   }
 
+  /** The first source that holds the company's listings; one that fails is passed over. */
+  async getIssuerListings(symbol: string, exchange?: string, options?: { signal?: AbortSignal }): Promise<IssuerListings | null> {
+    for (const provider of this.providersInPriorityOrder()) {
+      if (!provider.getIssuerListings) continue;
+      try {
+        const listings = await provider.getIssuerListings(symbol, exchange, options);
+        if (listings) return listings;
+      } catch (error) {
+        if (options?.signal?.aborted) return null;
+        logFailure("sources.provider-router.index", "Issuer listings failed")(error);
+      }
+    }
+    return null;
+  }
+
   async getEarningsCalendar(symbols: string[], context?: MarketDataRequestContext) {
     return this.supplementalRoutes.getEarningsCalendar(symbols, context);
   }
@@ -412,7 +428,8 @@ export class AssetDataRouter implements DataProvider {
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, context?: MarketDataRequestContext): Promise<OptionsChain> {
-    return (await this.getCachedQuery("getOptionsChain", [ticker, exchange, expirationDate, context]).load({ force: context?.cacheMode === "refresh", background: this.revalidateInBackground })).value;
+    return (await this.getCachedQuery("getOptionsChain", [ticker, exchange, expirationDate, context])
+      .load({ force: context?.cacheMode === "refresh", background: this.revalidateInBackground && context?.cacheMode !== "current" })).value;
   }
 
   getCachedQuery<K extends CachedAssetMethod>(method: K, args: CachedAssetArgs<K>) {

package/src/state/app/activity.ts

@@ -190,6 +190,19 @@ export function usePaneInView(): boolean {
   return useContext(PaneInViewContext);
 }
 
+/**
+ * Whether the pane around the caller is the focused one, as its frame draws
+ * it (a pane under the open command bar is not). Null outside a pane.
+ */
+const PaneFocusedContext = createContext<boolean | null>(null);
+
+export const PaneFocusedProvider = PaneFocusedContext.Provider;
+
+/** For chrome a pane shows only while focused (a chart's drawing tools); null outside a pane. */
+export function usePaneFocused(): boolean | null {
+  return useContext(PaneFocusedContext);
+}
+
 /**
  * Gate a pane's market data (stream priority, polls, refresh clocks) on this:
  * the app can be seen and the pane is on screen. A covered pane should keep

package/src/sync/controller.ts

@@ -13,6 +13,7 @@ import {
   type SyncSnapshot,
   type SyncTransport,
 } from "./types";
+import type { LocalMarketDataLookup } from "./local-only";
 
 type CloudSyncPhase = "idle" | "disabled" | "syncing" | "synced" | "error";
 
@@ -32,6 +33,8 @@ interface SyncRuntime {
   getContributors: () => RegisteredSyncContributor[];
   getTransport: () => RegisteredSyncTransport | null;
   baselineStore?: SyncBaselineStore;
+  /** Sources whose quotes and bars never leave this device (`BrokerAdapter.localMarketData`); none when absent. */
+  isLocalMarketData?: LocalMarketDataLookup;
 }
 
 const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
@@ -357,6 +360,7 @@ export class CloudSyncController {
         state: runtime.getState(),
         baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
         memo: this.memoFor(runtime, entry.contributor.id),
+        isLocalMarketData: runtime.isLocalMarketData,
       });
       payloads[entry.contributor.id] = {
         schemaVersion: entry.contributor.schemaVersion,