gloomberb 0.18.2 → 0.18.4

package/src/renderers/share/layout-view.tsx

@@ -108,7 +108,7 @@ export function LayoutShareView({
   return (
     <main className="layout-share wide">
       <header>
-        <p className="eyebrow">Shared via Gloomberb</p>
+        <p className="eyebrow">Shared via Gloom</p>
         <h1>{entry.name}</h1>
         <p className="layout-meta">{[author, date, `${entry.layout.instances.length} panes`].filter(Boolean).join(" · ")}</p>
       </header>
@@ -126,7 +126,7 @@ export function LayoutShareView({
 
       <div className="handoff">
         <a className="cta" href={openLiveUrl}>Use this layout</a>
-        <p className="descriptor">Opens in Gloomberb as an independent, editable copy.</p>
+        <p className="descriptor">Opens in Gloom as an independent, editable copy.</p>
       </div>
     </main>
   );

package/src/renderers/share/main.tsx

@@ -40,7 +40,7 @@ function LayoutApp({ id }: { id: string }) {
 
   return state.entry
     ? <LayoutShareView entry={state.entry} openLiveUrl={openLiveMarketplaceLayoutUrl(id)} />
-    : <main><h1>Gloomberb</h1><p>{state.error ?? "Loading shared layout..."}</p></main>;
+    : <main><h1>Gloom</h1><p>{state.error ?? "Loading shared layout..."}</p></main>;
 }
 
 function ContentShareApp({ id }: { id: string }) {
@@ -91,18 +91,18 @@ function ContentShareApp({ id }: { id: string }) {
       />
     );
   }
-  return <main><h1>Gloomberb</h1><p>{state.error ?? "Loading shared view..."}</p></main>;
+  return <main><h1>Gloom</h1><p>{state.error ?? "Loading shared view..."}</p></main>;
 }
 
 function SocialShareApp() {
   const pathname = window.location.pathname;
   const layoutId = parseMarketplaceLayoutId(pathname);
   if (layoutId) return <LayoutApp id={layoutId} />;
-  if (pathname.startsWith("/l/")) return <main><h1>Gloomberb</h1><p>Invalid layout link.</p></main>;
+  if (pathname.startsWith("/l/")) return <main><h1>Gloom</h1><p>Invalid layout link.</p></main>;
   const shareId = parseShareId(pathname);
   return shareId
     ? <ContentShareApp id={shareId} />
-    : <main><h1>Gloomberb</h1><p>Invalid share link.</p></main>;
+    : <main><h1>Gloom</h1><p>Invalid share link.</p></main>;
 }
 
 const root = document.getElementById("root");

package/src/renderers/share/view.tsx

@@ -89,7 +89,7 @@ export function ShareView({
     return (
       <main className="pane">
         <header>
-          <p className="eyebrow">Shared via Gloomberb</p>
+          <p className="eyebrow">Shared via Gloom</p>
           <h1>{share.data.title}</h1>
           {share.data.description ? <p className="pane-description">{share.data.description}</p> : null}
         </header>

package/src/series/resolve.ts

@@ -6,7 +6,8 @@ import type {
   SeriesPeriod,
   TimeSeriesPoint,
 } from "../time-series/types";
-import { getPresetResolution, type ManualChartResolution } from "../time-series/resolution";
+import { chartBarSizeSource, getPresetResolution, isCustomChartResolution } from "../time-series/resolution";
+import { futuresSessionOpenMinute } from "../market-data/market/trading-sessions";
 import { SERIES_COLORS } from "../theme/series-colors";
 import type {
   LoadedSeriesDefinition,
@@ -74,9 +75,24 @@ function seriesColor(id: string, lineIndex = 0): string {
   return SERIES_COLORS[(hash + lineIndex) % SERIES_COLORS.length]!;
 }
 
-/** The bar size a chart draws prices in: the one it was set to, else its range's default. */
-function viewportResolution(viewport: ChartViewportSpec): ManualChartResolution {
-  return viewport.resolution === "auto" ? getPresetResolution(viewport.range) : viewport.resolution;
+/**
+ * The bars a chart draws prices in, as a load request states them: the bar
+ * size it was set to, else its range's default. A size the source does not
+ * serve (4h) goes as the source bars it is built from (`resolution: 1h`) and
+ * the size itself (`barSize: 4h`), so a series that knows only the source
+ * sizes still gets one it knows.
+ */
+function viewportBars(viewport: ChartViewportSpec, ticker: string | undefined): Pick<SeriesLoadRequest, "resolution" | "barSize"> {
+  if (viewport.resolution === "auto") return { resolution: getPresetResolution(viewport.range) };
+  if (!isCustomChartResolution(viewport.resolution)) return { resolution: viewport.resolution };
+  const openMinute = ticker ? futuresSessionOpenMinute(splitTicker(ticker).symbol, splitTicker(ticker).exchange) : null;
+  return { resolution: chartBarSizeSource(viewport.resolution, [], openMinute), barSize: viewport.resolution };
+}
+
+/** `NESN:XSWX` as its symbol and listing. */
+function splitTicker(ticker: string): { symbol: string; exchange: string } {
+  const colon = ticker.lastIndexOf(":");
+  return colon > 0 ? { symbol: ticker.slice(0, colon), exchange: ticker.slice(colon + 1) } : { symbol: ticker, exchange: "" };
 }
 
 /** The dates a chart viewport covers, as a series load request takes them. */
@@ -133,7 +149,7 @@ function loadSeries(definition: LoadedSeriesDefinition, request: SeriesLoadReque
   if (signal?.aborted) return Promise.reject(signal.reason);
   // A window measured back from now moves by milliseconds between the lines' requests.
   const minute = (date: Date | undefined) => date ? Math.floor(date.getTime() / 60_000) : null;
-  const key = JSON.stringify([shared.ticker ?? null, minute(shared.start), minute(shared.end), shared.resolution ?? null]);
+  const key = JSON.stringify([shared.ticker ?? null, minute(shared.start), minute(shared.end), shared.resolution ?? null, shared.barSize ?? null]);
   let byKey = sharedLoads.get(definition);
   if (!byKey) sharedLoads.set(definition, byKey = new Map());
   let load = byKey.get(key);
@@ -182,7 +198,7 @@ export async function resolveLoadedSeries(
   const { points, edge, warning, attribution } = loadResult(await loadSeries(definition, {
     ...seriesLoadWindow(request.viewport, now),
     ...(ticker ? { ticker } : {}),
-    resolution: viewportResolution(request.viewport),
+    ...viewportBars(request.viewport, ticker),
     ...(request.signal ? { signal: request.signal } : {}),
   }), line);
   const seriesId = ticker ? `${definition.id}/${ticker}` : definition.id;

package/src/series/standalone.ts

@@ -4,11 +4,12 @@ import type { CapabilityInvoker } from "../capabilities/types";
 import type { GloomPlugin } from "../types/plugin";
 import { resolveRegisteredSeries } from "./capability";
 import { readSeriesFolder } from "./files";
-import { SeriesRegistry } from "./registry";
+import { SeriesRegistry, seriesExpression } from "./registry";
+import type { SeriesDefinition } from "./types";
 
 /**
  * Charts the catalog's loaded series where no plugin runtime runs, such as a
- * `gloomberb fn G` report: the series plugins declare, and the files in the
+ * `gloom fn G` report: the series plugins declare, and the files in the
  * data directory's series folder. Series a plugin registers from its setup
  * need the app.
  */
@@ -47,3 +48,30 @@ export function standaloneSeriesInvoker(
     },
   };
 }
+
+/**
+ * The plugins' catalog series by what `fn G` charts each as (`FRED:DFII10`),
+ * where no plugin runtime runs: a series with an input (a ticker's field) is
+ * no one expression. The first plugin to declare an expression keeps it, as
+ * the registry's `findByExpression` does.
+ */
+export function standaloneSeriesCatalog(
+  plugins: readonly GloomPlugin[],
+  disabledPlugins: readonly string[] = [],
+): (expression: string) => SeriesDefinition | undefined {
+  let byExpression: Map<string, SeriesDefinition> | null = null;
+  return (expression) => {
+    if (!byExpression) {
+      byExpression = new Map();
+      for (const plugin of plugins) {
+        if (disabledPlugins.includes(plugin.id)) continue;
+        for (const definition of plugin.series ?? []) {
+          if (definition.input) continue;
+          const key = seriesExpression(definition);
+          if (!byExpression.has(key)) byExpression.set(key, definition);
+        }
+      }
+    }
+    return byExpression.get(expression);
+  };
+}

package/src/series/types.ts

@@ -6,7 +6,7 @@
  * either loads its own history (`load`) or points at something the composer
  * already draws (`expression`), such as a FRED series or a ticker field.
  */
-import type { ManualChartResolution } from "../time-series/resolution";
+import type { ChartBarSize, ManualChartResolution } from "../time-series/resolution";
 
 /** How often a series gets a new observation. */
 export type SeriesFrequency =
@@ -72,6 +72,13 @@ export interface SeriesLoadRequest {
    * bars uses it to compute on the same bars.
    */
   resolution?: ManualChartResolution;
+  /**
+   * Set when the chart builds its bars from `resolution` bars rather than
+   * drawing those (`4h` from `1h`, `2d` from `1d`): the bar size it draws. A
+   * series computed from a ticker's bars builds them the same way with
+   * `aggregatePriceBars`, so its points fall on the chart's bars.
+   */
+  barSize?: ChartBarSize;
   signal?: AbortSignal;
 }
 

package/src/shares/api.ts

@@ -1,4 +1,5 @@
 import { ApiRequestError } from "../api-client/errors";
+import { DataServiceUnreachableError } from "../utils/network-failure";
 import { parseSharePayload, type SharePayload } from "./payload";
 
 declare const __GLOOMBERB_API_URL__: string | undefined;
@@ -36,11 +37,13 @@ function validDate(value: unknown): value is string {
  * A request that never got an answer, in the words of whichever fetch made
  * it: a browser's ("Failed to fetch", Safari's "Load failed", Firefox's
  * "NetworkError ..."), Bun's ("Unable to connect ...", which the desktop
- * relays from its Bun process as a plain message), or a timeout.
+ * relays from its Bun process as a plain message), the Cloud client's
+ * `DataServiceUnreachableError` for any of them, or a timeout.
  */
 const NETWORK_FAILURE = /failed to fetch|load failed|networkerror|network connection was lost|appears to be offline|fetch failed|unable to connect|socket connection was closed|typo in the url or port|timed out/i;
 
 function isNetworkFailure(error: unknown): boolean {
+  if (error instanceof DataServiceUnreachableError) return true;
   if (!error || typeof error !== "object") return false;
   const { name, message } = error as { name?: unknown; message?: unknown };
   return name === "AbortError" || name === "TimeoutError" || (typeof message === "string" && NETWORK_FAILURE.test(message));

package/src/shares/pane.ts

@@ -53,7 +53,7 @@ export async function openPaneShare(
     return;
   }
   const template = pluginRegistry.paneTemplates.get(share.templateId);
-  if (!template?.publicShare) throw new Error("This shared pane is unavailable in this version of Gloomberb.");
+  if (!template?.publicShare) throw new Error("This shared pane is unavailable in this version of Gloom.");
   const options = template.publicShare.restore(share.data);
   if (!options) throw new Error("This shared pane contains invalid settings.");
   await pluginRegistry.createPaneFromTemplateAsync(template.id, options);

package/src/sources/gloomberb-cloud/fred-series.ts

@@ -68,21 +68,66 @@ const TURKISH_CPI: SeriesNotOnFred = {
   url: "https://www.tcmb.gov.tr/wps/wcm/connect/EN/TCMB+EN/Main+Menu/Statistics/Inflation+Data/Consumer+Prices",
 };
 
+/** IBGE's IPCA (433) and IPCA-15 (7478), as the central bank's SGS republishes them. */
+const brazilianCpi = (code: number): SeriesNotOnFred => ({
+  publisher: "IBGE",
+  via: "the Banco Central do Brasil's SGS",
+  url: `https://www3.bcb.gov.br/sgspub/consultarvalores/telaCvsSelecionarSeries.paint?codigoSerie=${code}`,
+});
+
 const NOT_ON_FRED: Readonly<Record<string, SeriesNotOnFred>> = {
   TURCPIYOY: TURKISH_CPI,
   TURCPIMOM: TURKISH_CPI,
+  BRAIPCAMOM: brazilianCpi(433),
+  BRAIPCA15MOM: brazilianCpi(7478),
+  // NAHB's builder sentiment index as first released, from the economic calendar's actuals.
+  NAHBHMI: {
+    publisher: "NAHB",
+    via: "the economic calendar",
+    url: "https://www.nahb.org/news-and-economics/housing-economics/indices/housing-market-index",
+  },
+};
+
+/** A series Gloom Cloud computes from two of FRED's, the first less the second, and how. */
+interface ComputedFromFred {
+  legs: readonly [string, string];
+  note: string;
+}
+
+const COMPUTED_FROM_FRED: Readonly<Record<string, ComputedFromFred>> = {
+  MORTGAGE30US10Y: {
+    legs: ["MORTGAGE30US", "DGS10"],
+    note: "MORTGAGE30US minus DGS10 on each Freddie Mac PMMS date; when the Treasury market is closed that day, the 10-year yield of the session before.",
+  },
 };
 
+/** How a series Gloom Cloud computes from FRED's is computed, for the note under its table; null for any other. */
+export function computedFredSeriesNote(seriesId: string): string | null {
+  return COMPUTED_FROM_FRED[seriesId.trim().toUpperCase()]?.note ?? null;
+}
+
 /** The publisher of a served series FRED does not carry; null for FRED's own. */
 export function seriesNotOnFred(seriesId: string): SeriesNotOnFred | null {
   return NOT_ON_FRED[seriesId.trim().toUpperCase()] ?? null;
 }
 
-/** The series' page on the FRED site, where its notes and release schedule live, or its publisher's page when FRED does not carry it. */
+/**
+ * The series' page on the FRED site, where its notes and release schedule
+ * live; FRED's graph of both legs for a series computed from two; its
+ * publisher's page when FRED does not carry it.
+ */
 export function fredSeriesUrl(seriesId: string): string {
+  const legs = COMPUTED_FROM_FRED[seriesId.trim().toUpperCase()]?.legs;
+  if (legs) return `https://fred.stlouisfed.org/graph/?id=${legs.join(",")}`;
   return seriesNotOnFred(seriesId)?.url ?? `https://fred.stlouisfed.org/series/${seriesId}`;
 }
 
+/** What a source line names a series by: `FRED DGS10`, or the FRED series a computed one comes from (`FRED MORTGAGE30US minus DGS10`). */
+export function fredSourceLabel(seriesId: string): string {
+  const legs = COMPUTED_FROM_FRED[seriesId.trim().toUpperCase()]?.legs;
+  return `FRED ${legs ? legs.join(" minus ") : seriesId}`;
+}
+
 function cacheKey(request: FredSeriesRequest): string {
   const range = [
     request.startDate ? `start=${request.startDate}` : "",

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,
@@ -44,7 +45,7 @@ import { resolveCurrencyUnit } from "../../utils/currency-units";
 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 { createProviderMiss, ProviderBusyError, providerMissReason, StaleHistoryError } from "../provider-errors";
 import { parseListingDelisting } from "../../market-data/quotes/delisting";
 import { isRetryableApiError } from "../../api-client/errors";
 import { assertSecRegistrantMatches } from "../sec-registrant";
@@ -56,8 +57,9 @@ import { hongKongListingCode, tickerHasListingSuffix } from "../listing-symbols"
 import { parseSecAcceptanceTime } from "../sec-edgar/acceptance-time";
 import { hasMalformedIntradayHistory } from "../../time-series/history-quality";
 import {
-  cloudNewsParams,
+  cloudNewsReadArticles,
   mapCloudNewsArticle,
+  readCloudNews,
 } from "./news";
 import {
   GLOOMBERB_CLOUD_PROVIDER_ID,
@@ -76,6 +78,7 @@ import {
 import {
   getPerpetualHistory,
   getPerpetualQuote,
+  streamedPerpetualQuote,
   namesPerpetualMarket,
   perpetualTarget,
   searchPerpetualMarkets,
@@ -122,6 +125,7 @@ function mapCloudSecFiling(item: {
   filingUrl: string;
   primaryDocumentUrl?: string;
   fileNumber?: string;
+  fundSeries?: boolean;
 }): SecFilingItem {
   return {
     accessionNumber: item.accessionNumber,
@@ -138,6 +142,7 @@ function mapCloudSecFiling(item: {
     primaryDocumentUrl: item.primaryDocumentUrl,
     // Absent from an older server: no file number is not the same as an empty one.
     ...(typeof item.fileNumber === "string" ? { fileNumber: item.fileNumber } : {}),
+    ...(typeof item.fundSeries === "boolean" ? { fundSeries: item.fundSeries } : {}),
   };
 }
 
@@ -202,7 +207,7 @@ function mapCloudPriceHistory(
   // or a stale answer without bars, are a miss.
   const stale = isStaleCloudResponse(response);
   if (stale && response.status !== "success" && response.status !== "partial") {
-    throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
+    throw new StaleHistoryError(`Cloud chart data is stale for ${ticker}`);
   }
   if (response.status === "unsupported" && response.reasonCode === "HISTORY_RETENTION" && requestedEnd) {
     const retention = parseHistoryRetention(response.historyRetention);
@@ -227,7 +232,7 @@ function mapCloudPriceHistory(
     ).map((point) => mapPricePoint(point, divisor, exchange, coin)),
   );
   if (stale && !reachesLatestSettledSession(points, Date.now(), { symbol: ticker, exchange, intervalMs: priceHistoryIntervalMs(interval) })) {
-    throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
+    throw new StaleHistoryError(`Cloud chart data is stale for ${ticker}`);
   }
   const intraday = /^\d+(min|h)$/i.test(interval);
   // Daily bars answering an intraday range: the listing has no intraday bars.
@@ -718,6 +723,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;
@@ -878,14 +889,23 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     targets: QuoteSubscriptionTarget[],
     onQuote: (target: QuoteSubscriptionTarget, quote: Quote) => void,
   ): () => void {
-    // Perpetual markets are polled, a minute apart at the venue; the quote stream carries none.
-    const { valid } = cloudBatchTargets(splitPerpetualTargets(targets).others);
+    // A perpetual market streams as its listing on its venue (BTC:HYPERLIQUID): Gloom Cloud follows the venue's own
+    // socket for it, once the server says it can (the socket holds it back until then).
+    const { perpetuals, others } = splitPerpetualTargets(targets);
+    const valid: Array<{ target: QuoteSubscriptionTarget; request: { symbol: string; exchange?: string } }> = [
+      ...cloudBatchTargets(others).valid,
+      ...perpetuals.flatMap((target) => {
+        const listing = perpetualTarget(target.symbol, target.exchange);
+        return listing ? [{ target, request: { symbol: listing.symbol, exchange: listing.exchange } }] : [];
+      }),
+    ];
     if (!valid.length) return () => {};
     // No-op without a session credential; covers browser cookie sessions too.
     void apiClient.ensureVerifiedSession().catch(logFailure("sources.gloomberb-cloud.index", "Verifying the quote streaming session failed"));
     const targetMap = new Map<string, QuoteSubscriptionTarget[]>();
-    for (const { target } of valid) {
-      const key = quoteTargetKey(target.symbol, target.exchange);
+    for (const { target, request } of valid) {
+      // A perpetual comes back as its listing, whatever form it was asked for in.
+      const key = perpetuals.includes(target) ? quoteTargetKey(request.symbol, request.exchange) : quoteTargetKey(target.symbol, target.exchange);
       const matches = targetMap.get(key) ?? [];
       matches.push(target);
       targetMap.set(key, matches);
@@ -909,7 +929,10 @@ export class GloomberbCloudProvider implements AssetDataProvider {
         }
         const matchedKey = cloudResponseTargetKey(key, requested);
         const matches = matchedKey ? targetMap.get(matchedKey) ?? [] : [];
-        const mappedQuote = mapQuote(quote);
+        if (!matches.length) return;
+        const listing = perpetualTarget(target.symbol, target.exchange);
+        const mappedQuote = listing ? streamedPerpetualQuote(quote, listing) : mapQuote(quote);
+        if (!mappedQuote) return;
         for (const match of matches) {
           onQuote(match, retainRequestedQuoteSymbol(mappedQuote, match.symbol));
         }
@@ -934,21 +957,21 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
           return normalizeNewsFeed(query) === "ticker" ? !!query.ticker && !predictionMarketListing(query.ticker, query.exchange) : true;
         },
         async fetchNewsPage(query: NewsQuery) {
-          const response = await withCloudFallback(
-            () => apiClient.getCloudNews(cloudNewsParams(query)),
+          const read = await withCloudFallback(
+            () => readCloudNews(apiClient, query),
             "Cloud news is unavailable",
           );
           return {
-            articles: response.items.map((item) => mapCloudNewsArticle(item, query.ticker)),
-            nextCursor: response.nextCursor ?? null,
+            articles: cloudNewsReadArticles(read, query.ticker),
+            nextCursor: read.nextCursor ?? null,
           };
         },
         async fetchNews(query: NewsQuery): Promise<NewsArticle[]> {
-          const response = await withCloudFallback(
-            () => apiClient.getCloudNews(cloudNewsParams(query)),
+          const read = await withCloudFallback(
+            () => readCloudNews(apiClient, query),
             "Cloud news is unavailable",
           );
-          return response.items.map((item) => mapCloudNewsArticle(item, query.ticker));
+          return cloudNewsReadArticles(read, query.ticker);
         },
         async fetchNewsStory(storyId: string): Promise<NewsArticle | null> {
           const story = await withCloudFallback(

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

@@ -3,11 +3,15 @@ import { readableNewsSource } from "../../news/source-label";
 import { collectNewsDisplayTickers } from "../../news/ticker-symbols";
 import type { NewsArticle, NewsQuery, NewsStoryItem } from "../../types/news-source";
 import type {
+  apiClient,
+  CloudNewsListResponse,
   CloudNewsPayload,
   CloudNewsStoryItemPayload,
 } from "../../api-client";
 import type { CloudNewsParams } from "../../api-client/paths";
 import { parsePublicTickerKey, publicExchange } from "../../utils/exchanges";
+import { coinSearchName } from "../../utils/crypto-pair";
+import { logFailure } from "../../utils/log-failure";
 import { getListingSymbol, tickerHasListingSuffix } from "../listing-symbols";
 
 function normalizeStringArray(value: unknown): string[] {
@@ -129,3 +133,38 @@ export function cloudNewsParams(query: NewsQuery): CloudNewsParams {
     cursor: query.cursor,
   };
 }
+
+/** A page of Gloom Cloud stories, with the text searched for when a coin pair's feed had none filed under it. */
+export type CloudNewsRead = CloudNewsListResponse & { searchedFor?: string };
+
+type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "searchCloudNews">;
+
+/**
+ * A news query's first page from Gloom Cloud. Stories are filed under company
+ * tickers, and a coin pair (BTC-USD) rarely has any filed under it, so its
+ * empty feed falls back to the stories that mention the coin ("bitcoin"),
+ * marked with what was searched. A later page, a failed search or a coin with
+ * no name to search keeps the empty answer.
+ */
+export async function readCloudNews(client: CloudNewsClient, query: NewsQuery): Promise<CloudNewsRead> {
+  const response = await client.getCloudNews(cloudNewsParams(query));
+  if (response.items.length > 0 || query.cursor || normalizeNewsFeed(query) !== "ticker") return response;
+  const text = coinSearchName(query.ticker, query.exchange, query.listingName);
+  if (!text) return response;
+  const found = await client.searchCloudNews(text, query.limit)
+    .catch(logFailure("sources.gloomberb-cloud.news", "Search a coin's stories failed", null));
+  return found && found.items.length > 0 ? { items: found.items, nextCursor: null, searchedFor: text } : response;
+}
+
+/** A read's stories as articles, each marked with the text a coin's fallback searched for. */
+export function cloudNewsReadArticles(read: CloudNewsRead, ticker?: string): NewsArticle[] {
+  return read.items.map((item) => {
+    const article = mapCloudNewsArticle(item, read.searchedFor ? undefined : ticker);
+    return read.searchedFor ? { ...article, searchedFor: read.searchedFor } : article;
+  });
+}
+
+/** What a pane or report says above the stories a coin's fallback found: "No stories are filed under BTC-USD; these mention bitcoin." */
+export function coinNewsFallbackNotice(ticker: string, searchedFor: string): string {
+  return `No stories are filed under ${ticker}; these mention ${searchedFor}.`;
+}

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

@@ -28,6 +28,7 @@ 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";
+import { readIntradayBar, readStaleReason } from "../../market-data/quotes/intraday-bar";
 
 export const GLOOMBERB_CLOUD_PROVIDER_ID = "gloomberb-cloud" as const;
 
@@ -96,6 +97,8 @@ export function mapQuote(
   return withoutUndefinedFields(reconcileQuoteDayRange({
     ...quote,
     delisting: parseListingDelisting(quote.delisting),
+    intradayBar: readIntradayBar(quote.intradayBar),
+    staleReason: readStaleReason(quote.staleReason),
     priceBasis,
     priceObservation,
     currency: currency || quote.currency,
@@ -222,6 +225,15 @@ function parseCloudPricePointDate(
     : new Date(value);
 }
 
+/** A served venue count, when it is one: a venue name and a count of zero or more. */
+function venueVolume(value: unknown): { venueVolume: { venue: string; volume: number } } | null {
+  if (!value || typeof value !== "object") return null;
+  const { venue, volume } = value as { venue?: unknown; volume?: unknown };
+  return typeof venue === "string" && venue.trim() && typeof volume === "number" && Number.isFinite(volume) && volume >= 0
+    ? { venueVolume: { venue: venue.trim(), volume } }
+    : null;
+}
+
 /**
  * One served bar. `coin`: the bars are a coin's, which trades every hour of every day. Its intraday volume is the
  * value traded in the bar on major spot venues, and a bar no venue reported has none rather than 0, so a 0 (from an
@@ -241,6 +253,7 @@ export function mapPricePoint(
     low: normalizePriceValueByDivisor(point.low, divisor),
     close: normalizePriceValueByDivisor(point.close, divisor) ?? point.close,
     volume: coin && point.volume === 0 ? undefined : point.volume,
+    ...(venueVolume(point.venueVolume) ?? {}),
     ...(point.partial === true ? { partial: true } : {}),
     ...(point.filled === true ? { filled: true } : {}),
     ...(point.unsettled === true ? { unsettled: true } : {}),
@@ -437,7 +450,7 @@ const HISTORY_OUTPUT_SIZE: Record<TimeRange, number> = {
   "ALL": 600,
 };
 
-/** The bar size comes from the shared range table, which `gloomberb help history` also lists. */
+/** The bar size comes from the shared range table, which `gloom help history` also lists. */
 export function toHistoryRequest(range: TimeRange): {
   interval: string;
   outputsize: number;

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

@@ -115,7 +115,55 @@ export function perpetualQuote(row: PerpBoardRow, listing: PerpetualListing): Qu
     dataSource: "delayed",
     ...(row.markPrice != null ? { mark: row.markPrice } : {}),
     ...(row.lastPrice != null ? { lastTradePrice: row.lastPrice } : {}),
-    ...(row.stale || row.delisted ? { stale: true } : {}),
+    // Said either way: a fresh reading merged over a stale one must clear it, not inherit it.
+    stale: row.stale === true || row.delisted === true,
+    perpetual: row,
+  };
+}
+
+/** The figures a streamed row is read by: each a finite number, or none. */
+const STREAMED_FIGURES = ["markPrice", "lastPrice", "fundingRate8h", "openInterestUsd", "premium"] as const;
+
+/**
+ * A row the market socket carried for this listing's market, readable as a fetched one; null for anything else. A
+ * figure the frame leaves out (a server writes no key for a value it does not have) is none, as null says.
+ */
+function streamedRow(value: unknown, listing: PerpetualListing): PerpBoardRow | null {
+  if (!value || typeof value !== "object") return null;
+  const row = value as PerpBoardRow;
+  if (typeof row.marketId !== "string" || row.marketId.toLowerCase() !== listing.marketId.toLowerCase()
+    || typeof row.quoteCurrency !== "string" || typeof row.observedAt !== "string" || !Number.isFinite(Date.parse(row.observedAt))) return null;
+  const figures: Partial<Record<(typeof STREAMED_FIGURES)[number], number | null>> = {};
+  for (const field of STREAMED_FIGURES) {
+    const figure: unknown = row[field];
+    if (figure != null && !(typeof figure === "number" && Number.isFinite(figure))) return null;
+    figures[field] = figure ?? null;
+  }
+  return { ...row, ...figures };
+}
+
+/**
+ * A perpetual's quote from the market socket: the same quote its fetched row
+ * makes, from the row the socket carried, marked live while the venue's own
+ * socket feeds it. Null when the frame holds no row for this market.
+ */
+export function streamedPerpetualQuote(
+  frame: { perpetual?: unknown; dataSource?: unknown; delivery?: unknown; stale?: unknown; bid?: unknown; ask?: unknown },
+  listing: PerpetualListing,
+): Quote | null {
+  const row = streamedRow(frame.perpetual, listing);
+  const quote = row ? perpetualQuote(row, listing) : null;
+  if (!quote) return null;
+  const number = (value: unknown) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+  const bid = number(frame.bid);
+  const ask = number(frame.ask);
+  return {
+    ...quote,
+    ...(frame.dataSource === "live" ? { dataSource: "live" as const } : {}),
+    ...(frame.delivery === "stream" || frame.delivery === "poll" ? { delivery: frame.delivery } : {}),
+    stale: quote.stale === true || frame.stale === true,
+    ...(bid !== undefined ? { bid } : {}),
+    ...(ask !== undefined ? { ask } : {}),
   };
 }
 

package/src/sources/listing-symbols.ts

@@ -139,6 +139,43 @@ export function listingSuffixConflictsWithExchange(ticker: string, exchange: str
   return suffixes.length > 0 && !suffixes.includes(ticker.slice(ticker.indexOf(".")));
 }
 
+/**
+ * The venue a vendor's suffix names, whatever else it could be: GARAN.IS is
+ * GARAN on BIST, 7203.T 7203 on JPX, and MKC.V reads as MKC on TSXV, though it
+ * is McCormick's voting class on NYSE. For a caller that confirms it, by a row
+ * saved on that venue or the listing's own quote (`listingSuffixVenue`). Null
+ * for a symbol without a venue suffix (BRK.B) and a suffix several venues share.
+ */
+export function listingSuffixCandidate(ticker: string): { symbol: string; exchange: string } | null {
+  if (!tickerHasListingSuffix(ticker)) return null;
+  const dot = ticker.indexOf(".");
+  const suffix = ticker.slice(dot);
+  // The one host venue the suffix names, else the one venue the table names for it (BIST, which the host table lacks).
+  const venues = new Set(HOST_SUFFIX_ENTRIES.filter(([, entry]) => entry === suffix).map(([venue]) => venue));
+  const venue = listingSuffixExchange(ticker) ?? (venues.size === 1 ? [...venues][0] : undefined);
+  return venue ? { symbol: ticker.slice(0, dot), exchange: venue } : null;
+}
+
+/**
+ * The listing a vendor's suffixed symbol stands for, when that is settled:
+ * GARAN.IS is GARAN on BIST, VOD.L on LSE is VOD there. A venue the table
+ * knows settles it, either way: its own suffix maps, another's (MKC.V on NYSE,
+ * McCormick's voting class) does not. With no venue, or one the table does not
+ * know (IST, JNB), the suffix's own venue is read for a suffix of two letters
+ * or more; a one-letter suffix is also a US class letter (MKC.V, BRK.B), so it
+ * maps only when a venue agrees. Null when it does not map.
+ */
+export function listingSuffixVenue(ticker: string, exchange?: string): { symbol: string; exchange: string } | null {
+  const candidate = listingSuffixCandidate(ticker);
+  if (!candidate) return null;
+  const suffix = ticker.slice(ticker.indexOf("."));
+  const given = canonicalExchange(exchange);
+  // SMART routes for a broker; it names no venue.
+  const suffixes = given && given !== "SMART" ? HOST_SUFFIX_ENTRIES.filter(([venue]) => venue === given).map(([, entry]) => entry) : [];
+  if (suffixes.length > 0) return suffixes.includes(suffix) ? { symbol: candidate.symbol, exchange: given } : null;
+  return suffix.length > 2 ? candidate : null;
+}
+
 /** Infer a venue only when the suffix names one recognized host exchange. */
 export function listingSuffixExchange(ticker: string): string | undefined {
   if (!tickerHasListingSuffix(ticker)) return undefined;