gloomberb 0.13.2 → 0.14.0

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

@@ -1,4 +1,8 @@
+import { assertTradingPriceHistory } from "../listing-history";
+import { exchangeRateMetadata } from "../../utils/exchange-rate-snapshot";
+import type { ExchangeRateSnapshot } from "../../types/exchange-rate";
 import type { TimeRange } from "../../time-series/range";
+import { hasShellCoverageRestriction, HistoryCoverageError, isShellLondonTarget, SHELL_VERIFIED_LINEAGE_START } from "../history-coverage";
 import {
   normalizeChartResolutionSupport,
   type ChartResolutionSupport,
@@ -16,7 +20,8 @@ import type {
   SearchRequestContext,
   TickerFinancialsBatchResult,
 } from "../../types/data-provider";
-import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, TickerFinancials } from "../../types/financials";
+import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, QuoteMetadata, TickerFinancials } from "../../types/financials";
+import { quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import type { InstrumentSearchResult } from "../../types/instrument";
 import {
   apiClient,
@@ -27,10 +32,12 @@ import {
   type CloudPricePointPayload,
 } from "../../api-client";
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
-import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
-import { canonicalTickerKey } from "../../utils/exchanges";
+import { resolveCurrencyUnit } from "../../utils/currency-units";
+import { canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory } from "../../utils/price-history";
 import { createProviderMiss } from "../provider-errors";
+import { publicListingTarget } from "../listing-target";
+import { tickerHasYahooSuffix } from "../yahoo-finance/symbols";
 import { hasMalformedIntradayHistory } from "../../time-series/history-quality";
 import {
   cloudNewsParams,
@@ -73,6 +80,8 @@ function mapCloudSecFiling(item: {
   form: string;
   filingDate: string;
   acceptedAt?: string;
+  /** Unmodified SEC acceptanceDateTime; a missing timezone is not inferred. */
+  acceptedAtRaw?: string;
   primaryDocument?: string;
   primaryDocDescription?: string;
   items?: string;
@@ -85,7 +94,9 @@ function mapCloudSecFiling(item: {
     accessionNumber: item.accessionNumber,
     form: item.form,
     filingDate: new Date(`${item.filingDate}T00:00:00Z`),
-    acceptedAt: item.acceptedAt ? new Date(item.acceptedAt) : undefined,
+    acceptedAt: item.acceptedAt && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.test(item.acceptedAt)
+      ? new Date(item.acceptedAt) : undefined,
+    acceptedAtRaw: item.acceptedAtRaw ?? item.acceptedAt,
     primaryDocument: item.primaryDocument,
     primaryDocDescription: item.primaryDocDescription,
     items: item.items,
@@ -121,13 +132,18 @@ function mapCloudPriceHistory(
   ticker: string,
   exchange: string,
   interval: string,
+  requestedStart: Date,
 ): PricePoint[] {
+  if (response.status === "empty" && isShellLondonTarget(ticker, exchange)
+    && requestedStart.getTime() < Date.parse(SHELL_VERIFIED_LINEAGE_START)
+    && hasShellCoverageRestriction(response.coverage)) throw new HistoryCoverageError(response.coverage.source);
   if (isStaleCloudResponse(response)) {
     throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
   }
-  const { divisor } = resolvePriceHistoryCurrencyUnit(
+  // Cloud history is already in major currency units unless the response
+  // explicitly declares a raw subunit. The exchange alone cannot set its scale.
+  const { divisor } = resolveCurrencyUnit(
     response.currency ?? response.providerMeta?.currency,
-    exchange,
   );
   const points = normalizePriceHistory(
     unwrapRequiredCloudResponse(
@@ -141,17 +157,72 @@ function mapCloudPriceHistory(
     ?? ""
   ).trim().toLowerCase();
   if (
-    /(min|h)$/i.test(interval)
+    /^\d+(min|h)$/i.test(interval)
     && upstream !== "yahoo"
     && hasMalformedIntradayHistory(points)
   ) {
     throw createProviderMiss(`Cloud chart data failed OHLC validation for ${ticker}`);
   }
-  return points;
+  return assertTradingPriceHistory(points, { symbol: ticker, exchange }, "provider:gloomberb-cloud");
 }
 
 function quoteTargetKey(symbol: string, exchange?: string): string {
-  return canonicalTickerKey(symbol, exchange);
+  const target = publicListingTarget(symbol, exchange);
+  const base = target.exchange && tickerHasYahooSuffix(target.symbol) ? target.symbol.slice(0, target.symbol.indexOf(".")) : target.symbol;
+  return canonicalTickerKey(base, target.exchange);
+}
+
+function cloudResponseTargetKey(key: string, requested: Set<string>): string | undefined {
+  if (requested.has(key)) return key;
+  const symbol = parsePublicTickerKey(key).symbol;
+  // A venue-less request may discover one listing. Never guess between two
+  // requested listings or erase an unresolved suffix to make it match.
+  return requested.has(symbol) && [...requested].filter((candidate) => parsePublicTickerKey(candidate).symbol === symbol).length === 1
+    ? symbol : undefined;
+}
+
+const cloudInstrumentTarget = publicListingTarget;
+
+function cloudBatchTargets<T extends { symbol: string; exchange?: string }>(targets: T[]) {
+  const valid: Array<{ target: T; request: ReturnType<typeof cloudInstrumentTarget> }> = [];
+  const invalid: Array<{ target: T; error: unknown }> = [];
+  for (const target of targets) {
+    try { valid.push({ target, request: cloudInstrumentTarget(target.symbol, target.exchange) }); }
+    catch (error) { invalid.push({ target, error }); }
+  }
+  return { valid, invalid };
+}
+
+function matchCloudBatchItems<T extends { symbol: string; exchange?: string }, I extends { symbol: string; exchange?: string }>(targets: T[], items: I[]) {
+  const pending = new Map<string, T[]>();
+  for (const target of targets) {
+    const key = quoteTargetKey(target.symbol, target.exchange);
+    pending.set(key, [...(pending.get(key) ?? []), target]);
+  }
+  const matched: Array<{ target: T; item: I }> = [];
+  const requested = new Set(pending.keys());
+  const responses = items.flatMap((item) => {
+    try { return [{ item, key: quoteTargetKey(item.symbol, item.exchange) }]; }
+    catch { return []; }
+  });
+  for (const { item, key: responseKey } of responses) {
+    const key = cloudResponseTargetKey(responseKey, requested);
+    if (!key) continue;
+    if (key !== responseKey && new Set(responses.filter((response) => parsePublicTickerKey(response.key).symbol === key).map((response) => response.key)).size !== 1) continue;
+    for (const target of pending.get(key) ?? []) matched.push({ target, item });
+    pending.delete(key);
+  }
+  return { matched, missing: [...pending.values()].flat() };
+}
+
+function retainRequestedQuoteSymbol(quote: Quote, ticker: string): Quote {
+  return parsePublicTickerKey(ticker).exchange || tickerHasYahooSuffix(ticker) ? { ...quote, symbol: ticker } : quote;
+}
+
+function retainRequestedFinancialsSymbol(financials: TickerFinancials, ticker: string): TickerFinancials {
+  return financials.quote
+    ? { ...financials, quote: retainRequestedQuoteSymbol(financials.quote, ticker) }
+    : financials;
 }
 
 async function requireVerifiedSession(): Promise<void> {
@@ -188,16 +259,18 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return true;
   }
 
-  async getTickerFinancials(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<TickerFinancials> {
+  async getTickerFinancials(ticker: string, exchange = "", context?: MarketDataRequestContext): Promise<TickerFinancials> {
+    const target = cloudInstrumentTarget(ticker, exchange);
     return withCloudFallback(async () => {
-      const response = await apiClient.getCloudFinancials(ticker, exchange);
+      const response = await apiClient.getCloudFinancials(target.symbol, target.exchange, context?.statementHistory);
       if (isStaleCloudResponse(response)) {
         throw createProviderMiss(`Cloud financials are stale for ${ticker}`);
       }
-      return mapCloudFinancials(
+      return retainRequestedFinancialsSymbol(mapCloudFinancials(
         unwrapRequiredCloudResponse(response, `Cloud financials are unavailable for ${ticker}`),
         response.providerMeta,
-      );
+        target,
+      ), ticker);
     }, `Cloud financials are unavailable for ${ticker}`);
   }
 
@@ -205,27 +278,31 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     targets: CachedFinancialsTarget[],
     options: { forceRefresh?: boolean } = {},
   ): Promise<TickerFinancialsBatchResult[]> {
+    if (targets.some((target) => target.statementHistory === "extended")) {
+      return Promise.all(targets.map(async (target) => {
+        try { return { target, financials: await this.getTickerFinancials(target.symbol, target.exchange, target) }; }
+        catch (error) { return { target, financials: null, error }; }
+      }));
+    }
+    const { valid, invalid } = cloudBatchTargets(targets);
+    const rejected = invalid.map((entry) => ({ ...entry, financials: null }));
+    if (!valid.length) return rejected;
+    const submitted = valid.map((entry) => entry.target);
     return withCloudFallback(async () => {
       const response = await apiClient.getCloudFinancialsBatch(
-        targets.map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange,
-        })),
+        valid.map((entry) => entry.request),
         options.forceRefresh ? "refresh" : "cache-first",
       );
       if (isStaleCloudResponse(response)) {
         throw createProviderMiss("Cloud financials are stale");
       }
       const payload = unwrapRequiredCloudResponse(response, "Cloud financials are unavailable");
-      return payload.items.map((item, index) => {
-        const target = targets[index] ?? {
-          symbol: item.symbol,
-          exchange: item.exchange,
-        };
+      const { matched, missing } = matchCloudBatchItems(submitted, payload.items);
+      return [...rejected, ...matched.map(({ target, item }) => {
         if ((item.status === "success" || item.status === "partial") && item.data) {
           return {
             target,
-            financials: mapCloudFinancials(item.data),
+            financials: retainRequestedFinancialsSymbol(mapCloudFinancials(item.data, undefined, cloudInstrumentTarget(target.symbol, target.exchange)), target.symbol),
           };
         }
         return {
@@ -233,51 +310,65 @@ export class GloomberbCloudProvider implements AssetDataProvider {
           financials: null,
           error: mapBatchError(item, `Cloud financials are unavailable for ${target.symbol}`),
         };
-      });
+      }), ...missing.map((target) => ({ target, financials: null, error: createProviderMiss(`Cloud financials are unavailable for ${target.symbol}`) }))];
     }, "Cloud financials are unavailable");
   }
 
   async getQuote(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<Quote> {
+    const target = cloudInstrumentTarget(ticker, exchange);
     return withCloudFallback(
       async () => {
-        const response = await apiClient.getCloudQuote(ticker, exchange);
+        const response = await apiClient.getCloudQuote(target.symbol, target.exchange);
         if (isStaleCloudResponse(response)) {
           throw createProviderMiss(`Cloud quotes are stale for ${ticker}`);
         }
-        return mapQuote(
+        return retainRequestedQuoteSymbol(mapQuote(
           unwrapRequiredCloudResponse(response, `Cloud quotes are unavailable for ${ticker}`),
           response.providerMeta,
-        );
+        ), ticker);
       },
       `Cloud quotes are unavailable for ${ticker}`,
     );
   }
 
+  async getQuoteMetadata(ticker: string, exchange = ""): Promise<QuoteMetadata | null> {
+    const target = cloudInstrumentTarget(ticker, exchange);
+    const response = await apiClient.getCloudQuote(target.symbol, target.exchange);
+    const quote = mapQuote(unwrapRequiredCloudResponse(response, `Cloud quote metadata is unavailable for ${ticker}`), response.providerMeta);
+    const metadata = quoteMetadataFromQuote(quote);
+    if (isStaleCloudResponse(response)) metadata.source.stale = true;
+    return quoteMetadataMatchesTarget(metadata, ticker, target.exchange) ? metadata : null;
+  }
+
   async getQuotesBatch(
     targets: QuoteSubscriptionTarget[],
     options: { forceRefresh?: boolean } = {},
   ): Promise<QuoteBatchResult[]> {
+    const { valid, invalid } = cloudBatchTargets(targets);
+    const rejected = invalid.map((entry) => ({ ...entry, quote: null }));
+    if (!valid.length) return rejected;
+    const submitted = valid.map((entry) => entry.target);
     return withCloudFallback(async () => {
       const response = await apiClient.getCloudQuotesBatch(
-        targets.map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange,
-        })),
+        valid.map((entry) => entry.request),
         options.forceRefresh ? "refresh" : "cache-first",
       );
       if (isStaleCloudResponse(response)) {
         throw createProviderMiss("Cloud quotes are stale");
       }
       const payload = unwrapRequiredCloudResponse(response, "Cloud quotes are unavailable");
-      return payload.items.map((item, index) => {
-        const target = targets[index] ?? {
-          symbol: item.symbol,
-          exchange: item.exchange,
-        };
+      const { matched, missing } = matchCloudBatchItems(submitted, payload.items);
+      return [...rejected, ...matched.map(({ target, item }) => {
+        // 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) {
+          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: mapQuote(item.data),
+            quote: retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol),
           };
         }
         return {
@@ -285,13 +376,24 @@ export class GloomberbCloudProvider implements AssetDataProvider {
           quote: null,
           error: mapBatchError(item, `Cloud quotes are unavailable for ${target.symbol}`),
         };
-      });
+      }), ...missing.map((target) => ({ target, quote: null, error: createProviderMiss(`Cloud quotes are unavailable for ${target.symbol}`) }))];
     }, "Cloud quotes are unavailable");
   }
 
   async getExchangeRate(fromCurrency: string): Promise<number> {
-    const response = await apiClient.getCloudExchangeRate(fromCurrency);
-    return unwrapRequiredCloudResponse(response, `Cloud exchange rate is unavailable for ${fromCurrency}`).rate;
+    return (await this.getExchangeRateSnapshot(fromCurrency)).rate;
+  }
+
+  async getExchangeRateSnapshot(fromCurrency: string): Promise<ExchangeRateSnapshot> {
+    const currency = fromCurrency.trim().toUpperCase();
+    const response = await apiClient.getCloudExchangeRate(currency);
+    const data = unwrapRequiredCloudResponse(response, `Cloud exchange rate is unavailable for ${currency}`);
+    exchangeRateMetadata({ ...data, asOf: data.asOf ?? response.asOf }, currency);
+    // Older servers have no observation metadata. Keep asOf unknown rather than
+    // presenting the request completion time as the rate's time.
+    return { ...data, rate: data.rate, fromCurrency: currency, toCurrency: "USD", source: data.source ?? this.id,
+      asOf: data.asOf ?? response.asOf, fetchedAt: data.fetchedAt ?? new Date().toISOString(),
+      stale: data.stale === true || response.stale === true };
   }
 
   async search(query: string, _context?: SearchRequestContext): Promise<InstrumentSearchResult[]> {
@@ -339,25 +441,28 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   }
 
   async getHolders(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<HolderData> {
+    const target = cloudInstrumentTarget(ticker, exchange);
     await requireVerifiedSession();
     return withCloudFallback(async () => {
-      const response = await apiClient.getCloudHolders(ticker, exchange);
+      const response = await apiClient.getCloudHolders(target.symbol, target.exchange);
       return unwrapRequiredCloudResponse(response, `Cloud holders are unavailable for ${ticker}`) as CloudHoldersPayload;
     }, `Cloud holders are unavailable for ${ticker}`);
   }
 
   async getAnalystResearch(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<AnalystResearchData> {
+    const target = cloudInstrumentTarget(ticker, exchange);
     await requireVerifiedSession();
     return withCloudFallback(async () => {
-      const response = await apiClient.getCloudAnalystResearch(ticker, exchange);
+      const response = await apiClient.getCloudAnalystResearch(target.symbol, target.exchange);
       return unwrapRequiredCloudResponse(response, `Cloud analyst research is unavailable for ${ticker}`) as CloudAnalystResearchPayload;
     }, `Cloud analyst research is unavailable for ${ticker}`);
   }
 
   async getCorporateActions(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<CorporateActionsData> {
+    const target = cloudInstrumentTarget(ticker, exchange);
     await requireVerifiedSession();
     return withCloudFallback(async () => {
-      const response = await apiClient.getCloudCorporateActions(ticker, exchange);
+      const response = await apiClient.getCloudCorporateActions(target.symbol, target.exchange);
       return unwrapRequiredCloudResponse(response, `Cloud corporate actions are unavailable for ${ticker}`) as CloudCorporateActionsPayload;
     }, `Cloud corporate actions are unavailable for ${ticker}`);
   }
@@ -367,12 +472,14 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   }
 
   async getPriceHistory(ticker: string, exchange: string, range: TimeRange, _context?: MarketDataRequestContext): Promise<PricePoint[]> {
+    const target = cloudInstrumentTarget(ticker, exchange);
+    exchange = target.exchange ?? "";
     const request = toHistoryRequest(range);
     const response = await withCloudFallback(
-      () => apiClient.getCloudHistory(ticker, exchange, request),
+      () => apiClient.getCloudHistory(target.symbol, exchange, request),
       `Cloud chart data is unavailable for ${ticker}`,
     );
-    return mapCloudPriceHistory(response, ticker, exchange, request.interval);
+    return mapCloudPriceHistory(response, ticker, exchange, request.interval, getRangeStartDate(range, new Date()));
   }
 
   async getPriceHistoryForResolution(
@@ -382,19 +489,21 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     resolution: ManualChartResolution,
     _context?: MarketDataRequestContext,
   ): Promise<PricePoint[]> {
+    const target = cloudInstrumentTarget(ticker, exchange);
+    exchange = target.exchange ?? "";
     const interval = toCloudInterval(resolution);
     const endDate = new Date();
     const startDate = getRangeStartDate(bufferRange, endDate);
-    const includeTime = /(min|h)$/i.test(interval);
+    const includeTime = /^\d+(min|h)$/i.test(interval);
     const response = await withCloudFallback(
-      () => apiClient.getCloudHistory(ticker, exchange, {
+      () => apiClient.getCloudHistory(target.symbol, exchange, {
         interval,
         startDate: formatCloudDateTime(startDate, includeTime, exchange),
         endDate: formatCloudDateTime(endDate, includeTime, exchange),
       }),
       `Cloud chart data is unavailable for ${ticker}`,
     );
-    return mapCloudPriceHistory(response, ticker, exchange, interval);
+    return mapCloudPriceHistory(response, ticker, exchange, interval, startDate);
   }
 
   async getDetailedPriceHistory(
@@ -405,22 +514,25 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     barSize: string,
     _context?: MarketDataRequestContext,
   ): Promise<PricePoint[]> {
+    const target = cloudInstrumentTarget(ticker, exchange);
+    exchange = target.exchange ?? "";
     const interval = toCloudInterval(barSize);
-    const includeTime = /(min|h)$/i.test(interval);
+    const includeTime = /^\d+(min|h)$/i.test(interval);
     const response = await withCloudFallback(
-      () => apiClient.getCloudHistory(ticker, exchange, {
+      () => apiClient.getCloudHistory(target.symbol, exchange, {
         interval,
         startDate: formatCloudDateTime(startDate, includeTime, exchange),
         endDate: formatCloudDateTime(endDate, includeTime, exchange),
       }),
       `Cloud detailed chart history is unavailable for ${ticker}`,
     );
-    return mapCloudPriceHistory(response, ticker, exchange, interval);
+    return mapCloudPriceHistory(response, ticker, exchange, interval, startDate);
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, _context?: MarketDataRequestContext): Promise<OptionsChain> {
+    const target = cloudInstrumentTarget(ticker, exchange);
     return withCloudFallback(async () => {
-      const response = await apiClient.getCloudOptionsChain(ticker, exchange, expirationDate);
+      const response = await apiClient.getCloudOptionsChain(target.symbol, target.exchange, expirationDate);
       const chain = unwrapRequiredCloudResponse(
         response,
         `Cloud options chains are unavailable for ${ticker}`,
@@ -433,34 +545,36 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     targets: QuoteSubscriptionTarget[],
     onQuote: (target: QuoteSubscriptionTarget, quote: Quote) => void,
   ): () => void {
+    const { valid } = cloudBatchTargets(targets);
+    if (!valid.length) return () => {};
     // No-op without a session credential; covers browser cookie sessions too.
     void apiClient.ensureVerifiedSession().catch(() => {});
     const targetMap = new Map<string, QuoteSubscriptionTarget[]>();
-    for (const target of targets) {
+    for (const { target } of valid) {
       const key = quoteTargetKey(target.symbol, target.exchange);
       const matches = targetMap.get(key) ?? [];
       matches.push(target);
       targetMap.set(key, matches);
     }
+    const requested = new Set(targetMap.keys());
 
     return apiClient.subscribeQuotes(
-      targets.map((target) => ({
-        symbol: target.symbol,
-        exchange: target.exchange,
+      valid.map(({ target, request }) => ({
+        ...request,
         surface: target.surface,
         visible: target.visible,
         selected: target.selected,
         weight: target.weight,
       })),
       (target, quote) => {
-        const key = quoteTargetKey(target.symbol, target.exchange);
-        const matches = targetMap.get(key) ?? [{
-          symbol: target.symbol,
-          exchange: target.exchange,
-        }];
+        let key: string;
+        try { key = quoteTargetKey(target.symbol, target.exchange); }
+        catch { return; }
+        const matchedKey = cloudResponseTargetKey(key, requested);
+        const matches = matchedKey ? targetMap.get(matchedKey) ?? [] : [];
         const mappedQuote = mapQuote(quote);
         for (const match of matches) {
-          onQuote(match, mappedQuote);
+          onQuote(match, retainRequestedQuoteSymbol(mappedQuote, match.symbol));
         }
       },
     );

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

@@ -5,7 +5,8 @@ import type {
   CloudNewsStoryItemPayload,
 } from "../../api-client";
 import type { CloudNewsParams } from "../../api-client/paths";
-import { publicExchange } from "../../utils/exchanges";
+import { parsePublicTickerKey, publicExchange } from "../../utils/exchanges";
+import { getYahooSymbol, tickerHasYahooSuffix } from "../yahoo-finance/symbols";
 
 function normalizeStringArray(value: unknown): string[] {
   return Array.isArray(value)
@@ -92,10 +93,17 @@ export function mapCloudNewsArticle(
 
 export function cloudNewsParams(query: NewsQuery): CloudNewsParams {
   const feed = query.feed ?? (query.scope === "ticker" ? "ticker" : "latest");
+  const ticker = query.ticker ? parsePublicTickerKey(query.ticker) : undefined;
+  const exchange = ticker?.exchange ?? query.exchange;
+  let symbol = ticker?.symbol;
+  if (symbol && exchange && tickerHasYahooSuffix(symbol)) {
+    const baseSymbol = symbol.slice(0, symbol.lastIndexOf("."));
+    if (getYahooSymbol(baseSymbol, exchange) === symbol) symbol = baseSymbol;
+  }
   return {
     feed,
-    ticker: feed === "ticker" ? query.ticker : undefined,
-    exchange: feed === "ticker" ? publicExchange(query.exchange) : undefined,
+    ticker: feed === "ticker" ? symbol : undefined,
+    exchange: feed === "ticker" ? publicExchange(exchange) : undefined,
     tickerTier:
       feed === "ticker" ? query.tickerTier ?? "primary" : query.tickerTier,
     tickerRelations: query.tickerRelations,

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

@@ -1,13 +1,37 @@
 import { describe, expect, test } from "bun:test";
-import { mapCloudFinancials } from "./normalizers";
+import { mapCloudFinancials, mapQuote } from "./normalizers";
+import type { CloudQuotePayload } from "../../api-client";
+
+describe("cloud quote wire values", () => {
+  test.each([null, undefined, Number.NaN, Infinity, -Infinity])(
+    "normalizes unavailable daily changes independently, including %s",
+    (missing) => {
+      const quote: CloudQuotePayload = {
+        symbol: "VOD", currency: "GBp", price: 100, lastUpdated: 1,
+        providerId: "gloomberb-cloud", dataSource: "delayed",
+        change: missing, changePercent: 0,
+      };
+      const withoutChange = mapQuote(quote);
+      expect(withoutChange.change).toBeNaN();
+      expect(withoutChange.changePercent).toBe(0);
+      const withoutPercent = mapQuote({ ...quote, change: 2, changePercent: missing });
+      expect(withoutPercent.change).toBe(0.02);
+      expect(withoutPercent.changePercent).toBeNaN();
+    },
+  );
+});
 
 describe("mapCloudFinancials", () => {
   test("divides GBp history with the raw quote currency, not the normalized GBP quote", () => {
     const financials = mapCloudFinancials({
       quote: {
+        providerId: "gloomberb-cloud",
+        dataSource: "delayed",
         symbol: "VOD",
         price: 23.1,
         currency: "GBp",
+        regularClose: 23,
+        regularCloseSessionDate: "2026-05-12",
         change: 1,
         changePercent: 4.5,
         lastUpdated: Date.parse("2026-05-13T15:00:00Z"),
@@ -28,6 +52,8 @@ describe("mapCloudFinancials", () => {
 
     expect(financials.quote?.currency).toBe("GBP");
     expect(financials.quote?.price).toBeCloseTo(0.231);
+    expect(financials.quote?.regularClose).toBeCloseTo(0.23);
+    expect(financials.quote?.regularCloseSessionDate).toBe("2026-05-12");
     expect(financials.priceHistory[0]?.close).toBeCloseTo(0.231);
     expect(financials.priceHistory[0]?.date.toISOString()).toBe("2026-05-13T09:15:00.000Z");
   });

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

@@ -1,4 +1,5 @@
 import type { TimeRange } from "../../time-series/range";
+import { verifiedPriceHistorySource } from "../history-coverage";
 import type {
   OptionsChain,
   PricePoint,
@@ -6,6 +7,7 @@ import type {
   TickerFinancials,
 } from "../../types/financials";
 import {
+  type CloudFinancialsPayload,
   type CloudMarketBatchItem,
   type CloudMarketResponse,
   type CloudOptionsChainPayload,
@@ -15,6 +17,10 @@ import {
 import { normalizePriceValueByDivisor, resolveCurrencyUnit } from "../../utils/currency-units";
 import { resolveExchangeTimeZone } from "../../utils/exchanges";
 import { createProviderMiss } from "../provider-errors";
+import { reconcileQuoteDayRange } from "../../market-data/quotes/day-range";
+import { redactUnavailableFundamentals } from "../../utils/fundamentals";
+import { retractKnownCloudValuation } from "./valuation-observations";
+import { withdrawKnownProviderStatements } from "../../utils/statement-observations";
 
 export const GLOOMBERB_CLOUD_PROVIDER_ID = "gloomberb-cloud" as const;
 
@@ -38,12 +44,20 @@ export function mapQuote(
     quote.fullExchangeName ??
     listingExchangeName;
   const internalProviderId = cloudInternalProviderId(providerMeta);
-  return {
+  const change = typeof quote.change === "number" && Number.isFinite(quote.change)
+    ? quote.change / divisor
+    : Number.NaN;
+  const changePercent = typeof quote.changePercent === "number" && Number.isFinite(quote.changePercent)
+    ? quote.changePercent
+    : Number.NaN;
+  return reconcileQuoteDayRange({
     ...quote,
     currency: currency || quote.currency,
     price: normalizePriceValueByDivisor(quote.price, divisor) ?? quote.price,
-    change: normalizePriceValueByDivisor(quote.change, divisor) ?? quote.change,
+    change,
+    changePercent,
     previousClose: normalizePriceValueByDivisor(quote.previousClose, divisor),
+    regularClose: normalizePriceValueByDivisor(quote.regularClose, divisor),
     high52w: normalizePriceValueByDivisor(quote.high52w, divisor),
     low52w: normalizePriceValueByDivisor(quote.low52w, divisor),
     bid: normalizePriceValueByDivisor(quote.bid, divisor),
@@ -52,6 +66,7 @@ export function mapQuote(
     high: normalizePriceValueByDivisor(quote.high, divisor),
     low: normalizePriceValueByDivisor(quote.low, divisor),
     mark: normalizePriceValueByDivisor(quote.mark, divisor),
+    lastTradePrice: normalizePriceValueByDivisor(quote.lastTradePrice, divisor),
     preMarketPrice: normalizePriceValueByDivisor(quote.preMarketPrice, divisor),
     preMarketChange: normalizePriceValueByDivisor(
       quote.preMarketChange,
@@ -97,7 +112,7 @@ export function mapQuote(
           },
         }
       : quote.provenance,
-  };
+  });
 }
 
 const LOCAL_DATE_TIME_PATTERN =
@@ -178,6 +193,7 @@ export function mapPricePoint(
 ): PricePoint {
   return {
     date: parseCloudPricePointDate(point.date, exchange),
+    ...(verifiedPriceHistorySource(point.historySource) ? { historySource: verifiedPriceHistorySource(point.historySource) } : {}),
     open: normalizePriceValueByDivisor(point.open, divisor),
     high: normalizePriceValueByDivisor(point.high, divisor),
     low: normalizePriceValueByDivisor(point.low, divisor),
@@ -187,18 +203,22 @@ export function mapPricePoint(
 }
 
 export function mapCloudFinancials(
-  financials: TickerFinancials,
+  financials: CloudFinancialsPayload,
   providerMeta?: CloudProviderMeta,
+  target?: { symbol: string; exchange?: string },
 ): TickerFinancials {
-  const rawQuote = financials.quote as CloudQuotePayload | undefined;
+  const rawQuote = financials.quote;
   const quote = rawQuote ? mapQuote(rawQuote, providerMeta) : undefined;
   const divisor = rawQuote ? resolveCurrencyUnit(rawQuote.currency).divisor : 1;
   const exchange = rawQuote?.listingExchangeName ?? rawQuote?.exchangeName ?? "";
-  return {
+  return withdrawKnownProviderStatements(retractKnownCloudValuation({
     quote,
+    quoteMetadata: financials.quoteMetadata,
     quoteContributions: financials.quoteContributions,
     profile: financials.profile,
-    fundamentals: financials.fundamentals,
+    fundamentals: redactUnavailableFundamentals(financials.fundamentals),
+    financialCurrency: financials.financialCurrency,
+    statementHistory: financials.statementHistory,
     annualStatements: financials.annualStatements ?? [],
     quarterlyStatements: financials.quarterlyStatements ?? [],
     priceHistory: (financials.priceHistory ?? []).map((point) =>
@@ -206,7 +226,8 @@ export function mapCloudFinancials(
         ? point
         : mapPricePoint(point as unknown as CloudPricePointPayload, divisor, exchange),
     ),
-  };
+    ...(financials.epsEstimates ? { epsEstimates: financials.epsEstimates } : {}),
+  }, target), target ?? { symbol: quote?.symbol ?? financials.quoteMetadata?.symbol ?? "", exchange }, "provider:gloomberb-cloud");
 }
 
 export function mapOptionsChain(