gloomberb 0.16.1 → 0.16.3

package/src/renderers/electrobun/view/host/native.ts

@@ -14,16 +14,6 @@ const contextMenuActionScope = new DesktopContextMenuActionScope(
   CONTEXT_MENU_ACTION_TTL_MS,
 );
 
-export function startElectrobunWindowDrag(): void {
-  window.__electrobunInternalBridge?.postMessage(JSON.stringify([
-    JSON.stringify({
-      type: "message",
-      id: "startWindowMove",
-      payload: { id: window.__electrobunWindowId },
-    }),
-  ]));
-}
-
 export async function showDesktopContextMenu(items: ContextMenuItem[]): Promise<boolean> {
   if (!NATIVE_CONTEXT_MENU_SUPPORTED) return false;
   contextMenuActionScope.clear();

package/src/renderers/electrobun/view/host/window-move.ts

@@ -0,0 +1,28 @@
+function postWindowMove(id: "startWindowMove" | "stopWindowMove"): void {
+  window.__electrobunInternalBridge?.postMessage(JSON.stringify([
+    JSON.stringify({ type: "message", id, payload: { id: window.__electrobunWindowId } }),
+  ]));
+}
+
+let endWindowMove: (() => void) | null = null;
+
+/**
+ * Moves the window with the pointer until the button comes up. Electrobun
+ * stops the move when its native monitor sees the release, but only if the
+ * start reached it first: the start goes through the Bun process, and a quick
+ * click releases before it lands, leaving the window following the bare
+ * pointer until the next click. The release is sent from here too, as
+ * Electrobun's own drag regions do; it always arrives after the start.
+ */
+export function startElectrobunWindowDrag(): void {
+  // A press whose release never reached the page (it ended outside the window) is over.
+  endWindowMove?.();
+  postWindowMove("startWindowMove");
+  const end = () => {
+    window.removeEventListener("mouseup", end, true);
+    if (endWindowMove === end) endWindowMove = null;
+    postWindowMove("stopWindowMove");
+  };
+  endWindowMove = end;
+  window.addEventListener("mouseup", end, true);
+}

package/src/renderers/electrobun/view/remote/persistence.ts

@@ -4,7 +4,8 @@ import {
   SESSION_SAVE_DEBOUNCE_MS,
 } from "../../../../state/persist-scheduler";
 import { backendRequest, getElectrobunBackendInitSnapshot } from "../backend-rpc";
-import { MemoryResourceStore } from "../../../../data/memory-resource-store";
+import { WriteThroughResourceStore } from "../../../../data/memory-resource-store";
+import { isBrokerAccountSnapshotKey } from "../../../../brokers/account-cache";
 
 class RemoteSessionStore {
   private snapshot = getElectrobunBackendInitSnapshot()?.sessionSnapshot ?? null;
@@ -123,9 +124,21 @@ class RemotePluginStateStore {
   }
 }
 
+/**
+ * Caches stay in the view's memory, except broker account snapshots: the Bun
+ * process saves those in the cache database, as the terminal does, so a
+ * broker portfolio opens with its last known equity and cash.
+ */
+function createViewResourceStore(): WriteThroughResourceStore {
+  return new WriteThroughResourceStore(getElectrobunBackendInitSnapshot()?.savedResources ?? [], {
+    set: (record) => void backendRequest("resources.set", { record }).catch(() => {}),
+    delete: (key) => void backendRequest("resources.delete", { key }).catch(() => {}),
+  }, isBrokerAccountSnapshotKey);
+}
+
 export class RemotePersistence {
   readonly tickers = {};
-  readonly resources = new MemoryResourceStore();
+  readonly resources = createViewResourceStore();
   readonly pluginState = new RemotePluginStateStore(getElectrobunBackendInitSnapshot()?.pluginState ?? {});
   readonly sessions = new RemoteSessionStore();
 

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/ui-host.tsx

@@ -2,11 +2,8 @@
 import type { RendererHost, UiHost } from "../../../ui/host";
 import { flushUsageCounts } from "../../../telemetry/usage-counts";
 import { backendRequest } from "./backend-rpc";
-import {
-  NATIVE_CONTEXT_MENU_SUPPORTED,
-  showDesktopContextMenu,
-  startElectrobunWindowDrag,
-} from "./host/native";
+import { NATIVE_CONTEXT_MENU_SUPPORTED, showDesktopContextMenu } from "./host/native";
+import { startElectrobunWindowDrag } from "./host/window-move";
 import { createDomUiHost } from "../../dom/dom-ui-host";
 
 export function createWebUiHost(desktopPlatform?: string): UiHost {

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/renderers/opentui/ui-host.tsx

@@ -2,6 +2,7 @@ import { RGBA, StyledText as OpenTuiStyledText, SyntaxStyle, TextAttributes as O
 import { createElement, forwardRef, useEffect, useRef, useState, type ReactNode } from "react";
 import { TextAttributes, type UiHost, type TextProps } from "../../ui/host";
 import { renderAsciiText } from "../../ui/ascii-font";
+import { scrollBoxScrollsVertically } from "../../ui/scroll-box-axis";
 import { OpenTuiImageSurface } from "./image/surface";
 import { OpenTuiChartSurface } from "./chart-surface";
 
@@ -141,7 +142,12 @@ function mapTextContent(content: unknown): unknown {
 }
 
 const OpenTuiBox = createOpenTuiPrimitive("box");
-const OpenTuiScrollBox = createOpenTuiPrimitive("scrollbox");
+const OpenTuiScrollBoxPrimitive = createOpenTuiPrimitive("scrollbox");
+// The native box scrolls vertically unless scrollY is false; the shared rule
+// also keeps the one-row horizontal strips from scrolling on that axis.
+const OpenTuiScrollBox = forwardRef<unknown, OpenTuiPrimitiveProps>(function OpenTuiScrollBox(props, ref) {
+  return createElement(OpenTuiScrollBoxPrimitive, { ...props, scrollY: scrollBoxScrollsVertically(props), ref });
+});
 const OpenTuiInput = createOpenTuiPrimitive("input");
 const OpenTuiTextarea = createOpenTuiPrimitive("textarea");
 const OpenTuiMediaSurface = createOpenTuiPrimitive("box");

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

@@ -1,5 +1,6 @@
 import { futuresGenericListing, futuresGenericPriceBasis } from "../../utils/futures-generic";
 import type { TimeRange } from "../../time-series/range";
+import { RANGE_HISTORY_RESOLUTION } from "../../time-series/resolution";
 import type {
   FinancialStatement,
   Fundamentals,
@@ -36,6 +37,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 +69,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 +90,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),
@@ -346,29 +371,24 @@ export function formatCloudDateTime(
   return `${year}-${month}-${day}`;
 }
 
+const HISTORY_OUTPUT_SIZE: Record<TimeRange, number> = {
+  "1D": 24 * 12,
+  "1W": 7 * 24,
+  "1M": 31,
+  "3M": 93,
+  "6M": 186,
+  "1Y": 366,
+  "5Y": 261,
+  "ALL": 600,
+};
+
+/** The bar size comes from the shared range table, which `gloomberb help history` also lists. */
 export function toHistoryRequest(range: TimeRange): {
   interval: string;
   outputsize: number;
   rangeKey: TimeRange;
 } {
-  switch (range) {
-    case "1D":
-      return { interval: "5min", outputsize: 24 * 12, rangeKey: range };
-    case "1W":
-      return { interval: "1h", outputsize: 7 * 24, rangeKey: range };
-    case "1M":
-      return { interval: "1day", outputsize: 31, rangeKey: range };
-    case "3M":
-      return { interval: "1day", outputsize: 93, rangeKey: range };
-    case "6M":
-      return { interval: "1day", outputsize: 186, rangeKey: range };
-    case "1Y":
-      return { interval: "1day", outputsize: 366, rangeKey: range };
-    case "5Y":
-      return { interval: "1week", outputsize: 261, rangeKey: range };
-    case "ALL":
-      return { interval: "1month", outputsize: 600, rangeKey: range };
-    default:
-      return { interval: "1day", outputsize: 366, rangeKey: range };
-  }
+  const resolution = RANGE_HISTORY_RESOLUTION[range];
+  if (!resolution) return { interval: "1day", outputsize: 366, rangeKey: range };
+  return { interval: toCloudInterval(resolution), outputsize: HISTORY_OUTPUT_SIZE[range], rangeKey: range };
 }

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

@@ -66,7 +66,7 @@ export class ProviderRouterBatchRoutes {
       const rawCached = selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, false);
       const cached = rawCached && (brokerSourceKeys.includes(rawCached.sourceKey)
         ? !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(rawCached.value, target.exchange))
-        : isProviderQuoteUsableForCurrentSession(rawCached.value, target.exchange, target.symbol))
+        : isProviderQuoteUsableForCurrentSession(rawCached.value, target.exchange, target.symbol, { recentAnswer: !rawCached.stale }))
         ? rawCached
         : null;
       if (cached && !forceRefresh && !cached.stale) {
@@ -93,7 +93,7 @@ export class ProviderRouterBatchRoutes {
       const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
       const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, options).catch(() => []);
       for (const item of batchResults) {
-        if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange, item.target.symbol)) continue;
+        if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange, item.target.symbol, { recentAnswer: true })) continue;
         const key = this.quoteBatchKey(item.target);
         const sourceKey = this.deps.providerSourceKey(batchProvider);
         for (const entry of providerIndexes.get(key) ?? []) {
@@ -162,7 +162,7 @@ export class ProviderRouterBatchRoutes {
         const key = this.cachedFinancialsBatchKey(item.target);
         let value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(item.financials));
         if (value && !item.target.instrument && !providerFinancialsMatchTarget(value, item.target.symbol, item.target.exchange)) continue;
-        if (value) value = dropUnusableProviderQuote(value, item.target.exchange);
+        if (value) value = dropUnusableProviderQuote(value, item.target.exchange, { recentAnswer: true });
         if (!value) continue;
         const sourceKey = this.deps.providerSourceKey(batchProvider);
         for (const entry of providerIndexes.get(key) ?? []) {

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/financial-routes.ts

@@ -200,7 +200,7 @@ export class ProviderRouterFinancialRoutes {
     const rawCached = selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, false);
     const cachedIsStale = rawCached && (brokerSourceKeys.includes(rawCached.sourceKey)
       ? isQuoteContributionStaleForCurrentSession(quoteWithFreshnessExchange(rawCached.value, exchange))
-      : !isProviderQuoteUsableForCurrentSession(rawCached.value, exchange, ticker));
+      : !isProviderQuoteUsableForCurrentSession(rawCached.value, exchange, ticker, { recentAnswer: !rawCached.stale }));
     const cached = rawCached && !cachedIsStale
       ? rawCached
       : null;
@@ -259,7 +259,7 @@ export class ProviderRouterFinancialRoutes {
       if (
         record
         && (includeStale || !record.stale)
-        && isProviderQuoteUsableForCurrentSession(record.value, exchange, ticker)
+        && isProviderQuoteUsableForCurrentSession(record.value, exchange, ticker, { recentAnswer: !record.stale })
       ) {
         return record.value;
       }

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

@@ -7,7 +7,16 @@ 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,
+  isRegularSessionTime,
+  isUsPostSessionPrint,
+  isUsPriorSessionPremarketQuote,
+  isUsRegularCloseQuoteInPostSession,
+  latestRegularSessionOpen,
+} from "../../market-data/market/freshness";
 import {
   mergeQuoteContributionMaps,
   isQuoteContributionStaleForCurrentSession,
@@ -122,21 +131,62 @@ function isQuoteInActiveSession(quote: Quote, now: number): boolean {
   return false;
 }
 
-function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
+// An opening auction can print before the continuous open (Hong Kong's at 09:20).
+const OPENING_AUCTION_MS = 15 * 60_000;
+
+/**
+ * Whether Gloom Cloud vouches that a delayed quote is current, however long
+ * ago its last trade was. The service judges more than that trade's age: it
+ * knows when it asked for the quote and how often the listing trades, so a
+ * thinly traded listing's hour-old trade can be the current price while its
+ * venue trades. Its verdict stands in for the age bound when:
+ * - the service answered on this request, or a cache entry still inside its
+ *   TTL holds that answer (`recentAnswer`); a copy past the TTL is not vouched for;
+ * - the answer says `stale: false`. One without the flag vouches for nothing,
+ *   and one flagged stale never gets this far;
+ * - the quote is delayed. The service bounds a delayed quote's feed age itself
+ *   but not a real-time one's, so real-time quotes keep the age bound;
+ * - it reports the regular session, the venue's session is in progress as
+ *   the delayed feed shows it, and the trade belongs to that session; or it
+ *   reports a US after-hours price, the after-hours session is in progress and
+ *   the trade belongs to it.
+ * The answer says nothing about how often a listing trades, so a liquid
+ * listing the service wrongly vouches for is accepted too. The service's own
+ * bound for liquid listings, about twenty minutes, is tighter than this one.
+ */
+function isVouchedCurrentByService(quote: Quote, exchange: string | undefined, now: number): boolean {
+  if (quote.providerId !== "gloomberb-cloud" || quote.stale !== false || quote.dataSource !== "delayed") return false;
+  if (quote.marketState === "POST") {
+    return finitePositiveNumber(quote.postMarketPrice) && isUsPostSessionPrint(quote.lastUpdated, exchange, now);
+  }
+  if (quote.marketState !== "REGULAR") return false;
+  const feedTime = now - delayedFeedLagMs(exchange);
+  if (isRegularSessionTime(exchange, feedTime) !== true) return false;
+  const open = latestRegularSessionOpen(exchange, feedTime);
+  return open != null && quote.lastUpdated >= open - OPENING_AUCTION_MS;
+}
+
+function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now(), recentAnswer = false): 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;
+  }
+  // Likewise today's regular close before any after-hours trade.
+  if (quote.postMarketPrice == null && isUsRegularCloseQuoteInPostSession(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.
+  if (isMiddayBreakPrint(quote.lastUpdated, exchange, now, delayed ? delayedFeedLagMs(exchange) : 0)) return false;
+  return !(recentAnswer && isVouchedCurrentByService(quote, exchange, now));
 }
 
 export function providerQuoteMatchesTarget(quote: Quote | null | undefined, symbol?: string, exchange?: string): quote is Quote {
@@ -156,11 +206,21 @@ export function providerQuoteMatchesTarget(quote: Quote | null | undefined, symb
   return true;
 }
 
-export function isProviderQuoteUsableForCurrentSession(quote: Quote | null | undefined, exchange?: string, symbol?: string): quote is Quote {
+/**
+ * `recentAnswer`: the source answered with this quote on this request, or a
+ * cache entry still inside its TTL holds it. Only then can the source's own
+ * verdict on a delayed quote stand in for the age bound.
+ */
+export function isProviderQuoteUsableForCurrentSession(
+  quote: Quote | null | undefined,
+  exchange?: string,
+  symbol?: string,
+  options: { recentAnswer?: boolean } = {},
+): quote is Quote {
   if (!providerQuoteMatchesTarget(quote, symbol, exchange)) return false;
   const normalized = quoteWithFreshnessExchange(quote, exchange);
   if (isQuoteStaleForCurrentSession(normalized)) return false;
-  if (isActiveProviderQuoteTooOld(normalized)) return false;
+  if (isActiveProviderQuoteTooOld(normalized, Date.now(), options.recentAnswer === true)) return false;
   // Futures may trade or settle at zero or negative prices. Require explicit
   // source type metadata; an alias alone cannot establish the price domain.
   const futures = ["FUT", "FUTURE", "FUTURES"].includes(normalized.instrumentType?.trim().toUpperCase() ?? "");
@@ -187,8 +247,12 @@ export function providerFinancialsMatchTarget(value: TickerFinancials, symbol: s
   return quoteMetadataMatchesTarget(metadata, hasListing ? symbol : parsePublicTickerKey(symbol).symbol, hasListing ? exchange : undefined);
 }
 
-export function dropUnusableProviderQuote(value: TickerFinancials, exchange?: string): TickerFinancials {
-  if (!value.quote || isProviderQuoteUsableForCurrentSession(value.quote, exchange)) {
+export function dropUnusableProviderQuote(
+  value: TickerFinancials,
+  exchange?: string,
+  options: { recentAnswer?: boolean } = {},
+): TickerFinancials {
+  if (!value.quote || isProviderQuoteUsableForCurrentSession(value.quote, exchange, undefined, options)) {
     return value;
   }
 

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/provider-router/primary.ts

@@ -73,7 +73,7 @@ export class ProviderRouterPrimaryRoutes {
         if (rawValue && !context?.instrument && !providerFinancialsMatchTarget(rawValue, ticker, exchange)) continue;
         const resolvedValue = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(rawValue));
         if (resolvedValue && !context?.instrument && !providerFinancialsMatchTarget(resolvedValue, ticker, exchange)) continue;
-        let value = resolvedValue ? dropUnusableProviderQuote(resolvedValue, exchange) : null;
+        let value = resolvedValue ? dropUnusableProviderQuote(resolvedValue, exchange, { recentAnswer: true }) : null;
         if (!value) continue;
         const sourceKey = this.options.providerSourceKey(provider);
         if (context?.statementHistory === "extended" && !hasReusableExtendedHistory(value)) {
@@ -187,7 +187,7 @@ export class ProviderRouterPrimaryRoutes {
     for (const provider of this.options.providersInPriorityOrder()) {
       try {
         const quote = await provider.getQuote(ticker, exchange, context);
-        if (!isProviderQuoteUsableForCurrentSession(quote, exchange, ticker)) continue;
+        if (!isProviderQuoteUsableForCurrentSession(quote, exchange, ticker, { recentAnswer: true })) continue;
         const sourceKey = this.options.providerSourceKey(provider);
         this.options.cacheResource(
           "quote",