gloomberb 0.17.6 → 0.18.0

package/src/shares/ready.ts

@@ -0,0 +1,42 @@
+import { requestAuthDialog } from "../account/auth-dialog";
+import { apiClient } from "../api-client";
+import type { AppNotificationRequest } from "../types/plugin";
+
+type Notify = (notification: AppNotificationRequest) => unknown;
+
+function errorText(error: unknown, fallback: string): string {
+  return error instanceof Error && error.message ? error.message : fallback;
+}
+
+/**
+ * Whether the account can make a share link or post to chat now. When it
+ * cannot, one toast says what is missing: a sign-in, which then calls `retry`
+ * so Share or the report carries on, or a verified email. `purpose` finishes
+ * "Sign in to ...".
+ */
+export function readyToShare(notify: Notify, retry: () => void, purpose: string): boolean {
+  if (!apiClient.isSignedIn()) {
+    notify({
+      body: `Sign in to ${purpose}.`,
+      type: "info",
+      action: { label: "Sign in", onClick: () => { requestAuthDialog({ onSignedIn: retry }); } },
+    });
+    return false;
+  }
+  if (!apiClient.isVerified()) {
+    notify({
+      body: `Verify your email to ${purpose}.`,
+      type: "info",
+      action: {
+        label: "Resend link",
+        onClick: () => {
+          void apiClient.sendVerification()
+            .then(() => notify({ body: "Verification link sent.", type: "success" }))
+            .catch((error) => notify({ body: errorText(error, "Couldn't send the email. Try again."), type: "error" }));
+        },
+      },
+    });
+    return false;
+  }
+  return true;
+}

package/src/shares/test-harness.ts

@@ -0,0 +1,62 @@
+import { afterEach } from "bun:test";
+import type { ReactElement } from "react";
+import { apiClient } from "../api-client";
+import type { ConfirmDialogProps } from "../components/ui/confirm-dialog";
+import type { AppNotificationRequest } from "../types/plugin";
+import type { PaneShareHost, PaneShareView } from "./flow";
+import { buildPaneSharePayload } from "./pane";
+
+export const SHARE_ID = "a".repeat(32);
+export const SHARE_LINK = `https://term.gloom.sh/api/shares/${SHARE_ID}/open`;
+
+/** Puts back the account and share calls a suite's fixtures replace. */
+export function restoreShareApiAfterEach(): void {
+  const original = { signedIn: apiClient.isSignedIn, verified: apiClient.isVerified, create: apiClient.createTerminalShare };
+  afterEach(() => {
+    apiClient.isSignedIn = original.signedIn;
+    apiClient.isVerified = original.verified;
+    apiClient.createTerminalShare = original.create;
+  });
+}
+
+/**
+ * A pane Share reads, the account and share service it talks to, and what it
+ * did: the toasts, what it copied and the links it made. A question shows as
+ * the shared confirm, recorded and answered as told; a suite that draws the
+ * real dialog replaces `host.promptDialog`.
+ */
+export function shareFlowFixture(view: Partial<PaneShareView> = {}, { signedIn = true } = {}) {
+  const payload = buildPaneSharePayload({ panes: new Map([["test", { id: "test", name: "Test" }]]), paneTemplates: new Map() } as any,
+    { paneId: "test", instanceId: "test:1", settings: { selectedTab: "options", expiry: "2027-01-15" } });
+  const toasts: AppNotificationRequest[] = [];
+  const copied: string[] = [];
+  const created: unknown[] = [];
+  const questions: ConfirmDialogProps[] = [];
+  let reads = 0;
+  let answer: boolean | undefined = true;
+  let createShare = async () => ({ id: SHARE_ID, expiresAt: "2027-01-01T00:00:00Z" });
+  let copyText = async (text: string) => { copied.push(text); };
+  apiClient.isSignedIn = () => signedIn;
+  apiClient.isVerified = () => signedIn;
+  apiClient.createTerminalShare = async (value) => { created.push(value); return createShare(); };
+  const host: PaneShareHost = {
+    notify: (toast) => { toasts.push(toast); },
+    promptDialog: async <T,>(options: Parameters<PaneShareHost["promptDialog"]>[0]) => {
+      const content = options.content as (context: { resolve(value: T): void; dismiss(): void }) => ReactElement<ConfirmDialogProps>;
+      let result: T | undefined;
+      questions.push(content({ resolve: (value) => { result = value; }, dismiss: () => {} }).props);
+      if (answer !== undefined) result = answer as T;
+      return result;
+    },
+    copyText: (text) => copyText(text),
+    readShareView: async () => { reads += 1; return { sharePayload: payload, personalData: null, ...view }; },
+  };
+  return {
+    host, payload, toasts, copied, created, questions,
+    get reads() { return reads; },
+    set answer(value: boolean | undefined) { answer = value; },
+    set createShare(value: () => Promise<{ id: string; expiresAt: string }>) { createShare = value; },
+    /** Replaces the clipboard, as a browser that refuses a write does. */
+    set copyText(value: (text: string) => Promise<void>) { copyText = value; },
+  };
+}

package/src/sources/gloomberb-cloud/batched-lookups.ts

@@ -0,0 +1,73 @@
+import { apiClient } from "../../api-client";
+import { ApiRequestError } from "../../api-client/errors";
+import type { InstrumentSearchResult } from "../../types/instrument";
+import type { TickerChanges } from "../../types/ticker-changes";
+import { logFailure } from "../../utils/log-failure";
+import { chunked, mapWithConcurrency } from "../../utils/concurrency";
+
+/** Symbols asked for in one batched ticker change request; the service reads up to 500. */
+const TICKER_CHANGES_BATCH_SIZE = 500;
+/** Queries in one batched search; the service runs up to 100, as many as a signed-out quote batch reads. */
+const SEARCH_BATCH_SIZE = 100;
+/** Batch requests of one lookup in flight at once, so a long list does not ask the service for everything at the same moment. */
+const BATCHES_IN_FLIGHT = 3;
+
+type BatchRoute = "ticker-changes" | "search";
+
+/** Batch routes the service answered 404 for: an older service, asked one symbol at a time from then on. */
+const unsupported = new Set<BatchRoute>();
+
+/** A service without the batch route answers 404 (or 405, the path served for another method). */
+const isMissingRoute = (error: unknown) => error instanceof ApiRequestError && (error.status === 404 || error.status === 405);
+
+/**
+ * The answers to `keys`, a request per `size` of them, a few in flight at a
+ * time. A request that fails leaves its keys out, to be asked one at a time; a
+ * service without the route answers null, and is not asked for it again.
+ */
+async function inBatches<T>(
+  route: BatchRoute,
+  keys: readonly string[],
+  size: number,
+  load: (chunk: string[]) => Promise<Map<string, T>>,
+): Promise<Map<string, T> | null> {
+  if (unsupported.has(route)) return null;
+  const answers = new Map<string, T>();
+  await mapWithConcurrency(chunked([...new Set(keys)], size), BATCHES_IN_FLIGHT, async (chunk) => {
+    // The first chunk an older service refused says the rest would be refused too.
+    if (unsupported.has(route)) return;
+    try {
+      for (const [key, value] of await load(chunk)) answers.set(key, value);
+    } catch (error) {
+      if (isMissingRoute(error)) unsupported.add(route);
+      else logFailure("sources.gloomberb-cloud.batched-lookups", `Batched ${route} request failed`)(error);
+    }
+  });
+  return unsupported.has(route) ? null : answers;
+}
+
+/** Each symbol's ticker changes, by symbol as asked (null: none on record); null from a service that cannot batch them. */
+export function cloudTickerChangesBatch(
+  symbols: readonly string[],
+  options: { signal?: AbortSignal } = {},
+): Promise<Map<string, TickerChanges | null> | null> {
+  return inBatches("ticker-changes", symbols, TICKER_CHANGES_BATCH_SIZE, (chunk) => apiClient.getCloudTickerChangesBatch(chunk, options));
+}
+
+/**
+ * Each query's listings as the service's search answers it, by query as asked;
+ * null from a service that cannot batch searches. Perpetual markets, which
+ * `search` asks the board for beside the listings, are not included: the
+ * symbols a list is looked up by never name one.
+ */
+export function cloudSearchBatch(
+  queries: readonly string[],
+  options: { limit?: number; signal?: AbortSignal } = {},
+): Promise<Map<string, InstrumentSearchResult[]> | null> {
+  return inBatches("search", queries, SEARCH_BATCH_SIZE, (chunk) => apiClient.searchInstrumentsBatch(chunk, options.limit ?? 10, options));
+}
+
+/** Forgets which batch routes the service lacked. */
+export function resetCloudBatchSupport(): void {
+  unsupported.clear();
+}

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

@@ -1,8 +1,10 @@
+import { logFailure } from "../../utils/log-failure";
 import { exchangeRateMetadata } from "../../utils/exchange-rate-snapshot";
 import type { ExchangeRateSnapshot } from "../../types/exchange-rate";
 import type { TimeRange } from "../../time-series/range";
 import { subtractTimeRange } from "../../time-series/date-window";
 import { HistoryCoverageError, parseHistoryCoverageNote, parseHistoryCoverageStart } from "../history-coverage";
+import { cloudNonPositiveCloseDates } from "../history-omitted";
 import {
   normalizeChartResolutionSupport,
   type ChartResolutionSupport,
@@ -39,9 +41,11 @@ import {
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { normalizeNewsFeed } from "../../news/news-model";
 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, providerMissReason } from "../provider-errors";
+import { createProviderMiss, ProviderBusyError, providerMissReason } from "../provider-errors";
+import { isRetryableApiError } from "../../api-client/errors";
 import { assertSecRegistrantMatches } from "../sec-registrant";
 import { nonUsSecListingVenue } from "../../utils/sec";
 import { publicListingTarget } from "../listing-target";
@@ -57,6 +61,7 @@ import {
 import {
   GLOOMBERB_CLOUD_PROVIDER_ID,
   formatCloudDateTime,
+  formatCloudHistoryEnd,
   isEmptyCloudStatus,
   mapBatchError,
   NOT_FOUND_REASON,
@@ -73,11 +78,17 @@ import {
   namesPerpetualMarket,
   perpetualTarget,
   searchPerpetualMarkets,
+  boardSearchesFrom,
 } from "./perpetuals";
 import { predictionMarketListing } from "../../tickers/prediction-listing";
 import { settleWithin } from "../../utils/async-deadline";
+import { cloudSearchBatch, cloudTickerChangesBatch } from "./batched-lookups";
 
 const providerId = GLOOMBERB_CLOUD_PROVIDER_ID;
+/** How long a search that is not typed waits for perpetual markets. */
+const PERPETUAL_SEARCH_WAIT_MS = 2_000;
+/** How long a batched search waits for the board it answers every query's perpetual markets from. */
+const PERPETUAL_BOARD_WAIT_MS = 5_000;
 const CLOUD_RESOLUTION_SUPPORT = normalizeChartResolutionSupport([
   { resolution: "1m", maxRange: "1W" },
   { resolution: "5m", maxRange: "1M" },
@@ -109,6 +120,7 @@ function mapCloudSecFiling(item: {
   companyName?: string;
   filingUrl: string;
   primaryDocumentUrl?: string;
+  fileNumber?: string;
 }): SecFilingItem {
   return {
     accessionNumber: item.accessionNumber,
@@ -123,6 +135,8 @@ function mapCloudSecFiling(item: {
     companyName: item.companyName,
     filingUrl: item.filingUrl,
     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 } : {}),
   };
 }
 
@@ -162,8 +176,8 @@ async function loadCloudHistory(
     if (response.status === "success" || response.status === "partial" || response.status === "empty") {
       return { response, extendedHours: response.session === "extended" };
     }
-  } catch {
-    // The regular session below.
+  } catch (error) {
+    logFailure("sources.gloomberb-cloud.index", "Loading extended-hours history failed")(error);
   }
   return { response: await load(), extendedHours: false };
 }
@@ -204,11 +218,12 @@ function mapCloudPriceHistory(
   const { divisor } = resolveCurrencyUnit(
     response.currency ?? response.providerMeta?.currency,
   );
+  const coin = isRoundTheClockCoin(ticker, exchange);
   const points = normalizePriceHistory(
     unwrapRequiredCloudResponse(
       response,
       `Cloud chart data is unavailable for ${ticker}`,
-    ).map((point) => mapPricePoint(point, divisor, exchange)),
+    ).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}`);
@@ -234,10 +249,13 @@ function mapCloudPriceHistory(
   if (declared && (!session || !matchingSource || !matchingIdentity || !matchingInterval)) {
     throw createProviderMiss(`Cloud chart session metadata does not match the requested history for ${ticker}`);
   }
+  // Sessions of daily bars the answer left out for a close at or below zero.
+  const nonPositiveCloseDates = resolution === "1d" ? cloudNonPositiveCloseDates(response.omittedSessions) : undefined;
   return {
     points,
     resolution,
     ...(session && matchingSource && matchingIdentity ? { session } : {}),
+    ...(nonPositiveCloseDates ? { nonPositiveCloseDates } : {}),
     ...(coverageStart ? { coverageStart } : {}),
     ...(coverageNote ? { coverageNote } : {}),
     ...(extendedHours ? { extendedHours: true } : {}),
@@ -318,7 +336,10 @@ function matchCloudBatchItems<T extends { symbol: string; exchange?: string }, I
   const requested = new Set(pending.keys());
   const responses = items.flatMap((item) => {
     try { return [{ item, key: quoteTargetKey(item.symbol, item.exchange) }]; }
-    catch { return []; }
+    catch (error) {
+      logFailure("sources.gloomberb-cloud.index", "Matching a cloud batch response failed")(error);
+      return [];
+    }
   });
   for (const { item, key: responseKey } of responses) {
     const key = cloudResponseTargetKey(responseKey, requested);
@@ -565,12 +586,15 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async search(query: string, context?: SearchRequestContext): Promise<InstrumentSearchResult[]> {
     // Perpetual markets are listings too, asked for beside the others. They are optional: a failed lookup leaves the
     // other results, and a keystroke waits for them only briefly once the listings are in, unless the query names one.
-    const pending = searchPerpetualMarkets(query).catch(() => [] as InstrumentSearchResult[]);
+    const pending = searchPerpetualMarkets(query).catch(logFailure("sources.gloomberb-cloud.index", "Searching perpetual markets failed", [] as InstrumentSearchResult[]));
     const listings = await withCloudFallback(
       () => apiClient.searchInstruments(query, context?.limit ?? 10),
       "Cloud search is unavailable",
-    );
-    const perpetuals = await settleWithin(pending, namesPerpetualMarket(query) ? 2_000 : context?.interactive ? 250 : 2_000) ?? [];
+    ).catch((error: unknown) => {
+      // Rate limited or overloaded: the search was not run, which is not a search that found nothing.
+      throw isRetryableApiError(error) ? new ProviderBusyError("Cloud search is busy", { cause: error }) : error;
+    });
+    const perpetuals = await settleWithin(pending, namesPerpetualMarket(query) || !context?.interactive ? PERPETUAL_SEARCH_WAIT_MS : 250) ?? [];
     // Ahead of the listings, so a contract found by its plain name ("brent" for BZUSDT:BINANCE) is not cut
     // behind every warrant that names it; an exact symbol still leads.
     return perpetuals.length ? [...perpetuals, ...listings] : listings;
@@ -599,7 +623,8 @@ export class GloomberbCloudProvider implements AssetDataProvider {
       const quote = await this.getQuote(ticker, venue);
       const quoteVenue = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
       return quoteVenue === venue ? quote.name?.trim() || null : null;
-    } catch {
+    } catch (error) {
+      logFailure("sources.gloomberb-cloud.index", "Loading the filing listing name failed")(error);
       return null;
     }
   }
@@ -664,6 +689,30 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return response.status === "success" || response.status === "partial" ? response.data : null;
   }
 
+  getTickerChangesBatch(symbols: string[], options: { signal?: AbortSignal } = {}): Promise<Map<string, TickerChanges | null> | null> {
+    return cloudTickerChangesBatch(symbols, options);
+  }
+
+  async searchBatch(queries: string[], options: { limit?: number; signal?: AbortSignal } = {}): Promise<Map<string, InstrumentSearchResult[]> | null> {
+    const answers = await cloudSearchBatch(queries, options);
+    if (!answers) return null;
+    // Perpetual markets lead each answer, as `search` gives them, so a symbol in a list resolves as it does alone:
+    // one read of the board answers every query's search of it. A query that found no listing is searched again
+    // on its own, which finds them then; a board that does not answer leaves them out, as a search does.
+    const found = queries.filter((query) => answers.get(query)?.length);
+    const board = found.length
+      ? await settleWithin(apiClient.getCloudPerpsBoard().catch(logFailure("sources.gloomberb-cloud.index", "Reading the perpetual board failed", null)), PERPETUAL_BOARD_WAIT_MS)
+      : null;
+    if (!board) return answers;
+    const client = boardSearchesFrom(board);
+    for (const query of found) {
+      const perpetuals = await searchPerpetualMarkets(query, client)
+        .catch(logFailure("sources.gloomberb-cloud.index", "Searching perpetual markets failed", [] as InstrumentSearchResult[]));
+      if (perpetuals.length) answers.set(query, [...perpetuals, ...answers.get(query)!]);
+    }
+    return answers;
+  }
+
   async getArticleSummary(url: string): Promise<string | null> {
     return (await apiClient.getCloudArticleSummary(url)).summary;
   }
@@ -736,7 +785,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
       () => loadCloudHistory(interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, {
         interval,
         startDate: formatCloudDateTime(startDate, includeTime, exchange),
-        endDate: formatCloudDateTime(endDate, includeTime, exchange),
+        endDate: formatCloudHistoryEnd(endDate, includeTime, exchange),
         ...(session ? { session } : {}),
       }), _context),
       `Cloud chart data is unavailable for ${ticker}`,
@@ -800,7 +849,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const { valid } = cloudBatchTargets(splitPerpetualTargets(targets).others);
     if (!valid.length) return () => {};
     // No-op without a session credential; covers browser cookie sessions too.
-    void apiClient.ensureVerifiedSession().catch(() => {});
+    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);
@@ -821,7 +870,10 @@ export class GloomberbCloudProvider implements AssetDataProvider {
       (target, quote) => {
         let key: string;
         try { key = quoteTargetKey(target.symbol, target.exchange); }
-        catch { return; }
+        catch (error) {
+          logFailure("sources.gloomberb-cloud.index", "Matching a streamed quote failed")(error);
+          return;
+        }
         const matchedKey = cloudResponseTargetKey(key, requested);
         const matches = matchedKey ? targetMap.get(matchedKey) ?? [] : [];
         const mappedQuote = mapQuote(quote);

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

@@ -20,6 +20,8 @@ import {
 } from "../../api-client";
 import { normalizePriceValueByDivisor, resolveCurrencyUnit } from "../../utils/currency-units";
 import { resolveExchangeTimeZone } from "../../utils/exchanges";
+import { isRoundTheClockCoin } from "../../utils/crypto-pair";
+import { latestSettledSessionDate } from "../../utils/price-history";
 import { zonedDateTimeParts, zonedWallClockToUtcMs } from "../../utils/zoned-date-time";
 import { createProviderMiss } from "../provider-errors";
 import { reconcileQuoteDayRange } from "../../market-data/quotes/day-range";
@@ -216,10 +218,17 @@ function parseCloudPricePointDate(
     : new Date(value);
 }
 
+/**
+ * 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
+ * older copy, or a daily bar) is volume not reported, not a bar nothing traded in. It is read as missing, so no table
+ * prints 0 and no sum or average counts it. Any other listing keeps a 0, which a thin stock can truly trade.
+ */
 export function mapPricePoint(
   point: CloudPricePointPayload,
   divisor = 1,
   exchange = "",
+  coin = false,
 ): PricePoint {
   return {
     date: parseCloudPricePointDate(point.date, exchange),
@@ -227,7 +236,7 @@ export function mapPricePoint(
     high: normalizePriceValueByDivisor(point.high, divisor),
     low: normalizePriceValueByDivisor(point.low, divisor),
     close: normalizePriceValueByDivisor(point.close, divisor) ?? point.close,
-    volume: point.volume,
+    volume: coin && point.volume === 0 ? undefined : point.volume,
     ...(point.partial === true ? { partial: true } : {}),
     ...(point.filled === true ? { filled: true } : {}),
     ...(point.unsettled === true ? { unsettled: true } : {}),
@@ -286,6 +295,7 @@ export function mapCloudFinancials(
   const quote = rawQuote ? mapQuote(rawQuote, providerMeta) : undefined;
   const divisor = rawQuote ? resolveCurrencyUnit(rawQuote.currency).divisor : 1;
   const exchange = rawQuote?.listingExchangeName ?? rawQuote?.exchangeName ?? "";
+  const coin = isRoundTheClockCoin(rawQuote?.symbol, exchange);
   return {
     quote,
     quoteMetadata: financials.quoteMetadata,
@@ -300,7 +310,7 @@ export function mapCloudFinancials(
     priceHistory: (financials.priceHistory ?? []).map((point) =>
       point.date instanceof Date
         ? point
-        : mapPricePoint(point as unknown as CloudPricePointPayload, divisor, exchange),
+        : mapPricePoint(point as unknown as CloudPricePointPayload, divisor, exchange, coin),
     ),
     ...(financials.epsEstimates ? { epsEstimates: financials.epsEstimates } : {}),
   };
@@ -393,6 +403,25 @@ export function formatCloudDateTime(
   return `${year}-${month}-${day}`;
 }
 
+const DAY_MS = 24 * 60 * 60_000;
+
+/**
+ * The end of a window of bars that ends now. Gloom Cloud reads a date-only end
+ * as exclusive, so a daily or longer window ending on today's date holds no
+ * bar of today. Once today's regular session has settled its bar is final and
+ * the window ends the day after, so the bar is served as the range requests
+ * serve it. While the session trades, or before it opens, today's date stands:
+ * the day's bar is the live quote's then. Intraday ends carry their time.
+ */
+export function formatCloudHistoryEnd(end: Date, includeTime: boolean, exchange = ""): string {
+  const formatted = formatCloudDateTime(end, includeTime, exchange);
+  if (includeTime) return formatted;
+  const settled = latestSettledSessionDate(exchange, end.getTime());
+  return settled && settled >= formatted
+    ? new Date(Date.parse(`${settled}T00:00:00Z`) + DAY_MS).toISOString().slice(0, 10)
+    : formatted;
+}
+
 const HISTORY_OUTPUT_SIZE: Record<TimeRange, number> = {
   "1D": 24 * 12,
   "1W": 7 * 24,

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

@@ -1,5 +1,5 @@
 import { apiClient } from "../../api-client";
-import type { PerpBoardRow, PerpMarketPayload } from "../../api-client/perps";
+import type { PerpBoardPayload, PerpBoardRow, PerpMarketPayload } from "../../api-client/perps";
 import type { InstrumentSearchResult } from "../../types/instrument";
 import type { PricePoint, Quote } from "../../types/financials";
 import type { PriceHistoryResult } from "../../types/price-history";
@@ -140,6 +140,25 @@ function searchResult(row: PerpBoardRow): InstrumentSearchResult | null {
   };
 }
 
+/**
+ * A client whose board searches are answered from one copy of the board, as
+ * the board answers them: its rows whose symbol, base asset or name holds the
+ * words, in its order. The board read without a search is the one a search
+ * reads (all of it with Pro, its preview without), so a list's searches cost
+ * one board request and find what each would find alone.
+ */
+export function boardSearchesFrom(board: PerpBoardPayload, client: PerpsClient = apiClient): PerpsClient {
+  const rows = Array.isArray(board?.rows) ? board.rows : [];
+  return {
+    getCloudPerpsMarket: client.getCloudPerpsMarket,
+    getCloudPerpsHistory: client.getCloudPerpsHistory,
+    getCloudPerpsBoard: async ({ search } = {}) => {
+      const wanted = search?.trim().toUpperCase();
+      return { ...board, rows: wanted ? rows.filter((row) => `${row.symbol} ${row.baseAsset} ${row.displayName}`.toUpperCase().includes(wanted)) : rows };
+    },
+  };
+}
+
 /** The one market a query names by its market id or listing key; null for a search. */
 const namedListing = (query: string) => typedPerpetualListing(query) ?? (query.includes(":") ? perpetualListing(query) : null);
 

package/src/sources/history-omitted.ts

@@ -0,0 +1,34 @@
+/**
+ * Daily sessions a source left out of a price history because its close was
+ * at or below zero (CL=F settled at -37.63 on 2020-04-20): no price can stand
+ * for them, so they are not bars, but a reader of the series is told they
+ * were sessions.
+ */
+
+const SESSION_DATE = /^\d{4}-\d{2}-\d{2}$/;
+// More than any daily history holds; a longer list is not one a source wrote.
+const MAX_DATES = 10_000;
+
+function isSessionDate(value: unknown): value is string {
+  return typeof value === "string" && SESSION_DATE.test(value) && Number.isFinite(Date.parse(`${value}T00:00:00Z`));
+}
+
+/** A stored or passed-on list: unique session dates, ascending; undefined for anything else or nothing. */
+export function readNonPositiveCloseDates(value: unknown): string[] | undefined {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_DATES || !value.every(isSessionDate)) return undefined;
+  return [...new Set(value)].sort();
+}
+
+/**
+ * The sessions a Gloom Cloud answer lists as left out for a close at or below
+ * zero (`omittedSessions: [{ date, reason: "non-positive-close" }]`). Entries
+ * for a reason this client does not know, or that do not read, are ignored.
+ */
+export function cloudNonPositiveCloseDates(value: unknown): string[] | undefined {
+  if (!Array.isArray(value) || value.length > MAX_DATES) return undefined;
+  return readNonPositiveCloseDates(value.flatMap((entry: unknown) => {
+    if (!entry || typeof entry !== "object") return [];
+    const { date, reason } = entry as { date?: unknown; reason?: unknown };
+    return reason === "non-positive-close" && isSessionDate(date) ? [date] : [];
+  }));
+}

package/src/sources/history-result.ts

@@ -5,6 +5,7 @@ import type { PriceHistoryResult } from "../types/price-history";
 import { parseHistorySession } from "../market-data/history-session";
 import { canonicalHistoryInterval } from "./history-retention";
 import { historyCoverageNoteText, isHistoryCoverageDate } from "./history-coverage";
+import { readNonPositiveCloseDates } from "./history-omitted";
 
 export type HistoryResultRequest =
   | { kind: "range"; range: TimeRange }
@@ -36,8 +37,10 @@ export function normalizeHistoryResult(
     interval: requestedInterval ?? result.resolution ?? undefined });
   // A contradictory declaration cannot be laundered into unknown legacy data.
   if (result.session != null && (!session || result.resolution === null)) return null;
+  const nonPositiveCloseDates = readNonPositiveCloseDates(result.nonPositiveCloseDates);
   return { points: result.points, resolution: result.resolution,
     ...(session ? { session } : {}),
+    ...(nonPositiveCloseDates ? { nonPositiveCloseDates } : {}),
     ...(typeof result.sourceKey === "string" && /^(provider|broker):[^\r\n\0]+$/.test(result.sourceKey) ? { sourceKey: result.sourceKey } : {}),
     ...(isHistoryCoverageDate(result.coverageStart) ? { coverageStart: result.coverageStart } : {}),
     ...(isHistoryCoverageDate(result.coverageStart) && historyCoverageNoteText(result.coverageNote)

package/src/sources/history-retention.ts

@@ -173,5 +173,5 @@ export function parseHistoryRetentionError(value: unknown): HistoryRetentionErro
     return new HistoryRetentionError(retention, {
       candidates: value.candidates as HistoryRecoveryCandidate[], outcomes: value.outcomes as HistorySourceOutcome[],
     });
-  } catch { return null; }
+  } catch { /* Intentional ignore: Invalid recovery metadata is rejected at the desktop JSON boundary. */ return null; }
 }

package/src/sources/provider-errors.ts

@@ -47,6 +47,27 @@ function isProviderMiss(error: unknown): error is ProviderMissError {
     || (!!error && typeof error === "object" && PROVIDER_MISS_BRAND in error);
 }
 
+/**
+ * A source that could not answer just now (rate limited, overloaded, timed
+ * out) and may if asked again shortly. Unlike a miss, it says nothing about
+ * whether what was asked for exists.
+ */
+export class ProviderBusyError extends Error {
+  constructor(message = "The data service is busy", options?: { cause?: unknown }) {
+    super(message, options);
+    this.name = "ProviderBusyError";
+  }
+}
+
+export function isProviderBusy(error: unknown): error is ProviderBusyError {
+  return error instanceof ProviderBusyError;
+}
+
+/** What a search its sources could not answer says, rather than that nothing matched. */
+export const SEARCH_BUSY_MESSAGE = "Search is busy, try again in a moment.";
+/** The code a structured answer (CLI `--json`, remote control) gives that failure. */
+export const SEARCH_BUSY_CODE = "search_busy";
+
 /** The reason a provider gave for a miss, or undefined when it gave none. */
 export function providerMissReason(error: unknown): string | undefined {
   return isProviderMiss(error) ? error.reason : undefined;
@@ -57,12 +78,15 @@ export interface ProviderMissNote {
   reason?: string;
   /** True while every provider that failed said it found no listing; one that failed another way (a timeout) clears it. */
   notFound?: boolean;
+  /** The last provider failure that was not a miss (a refused session, a rate limit, a timeout). */
+  failure?: unknown;
 }
 
 export function noteProviderMiss(note: ProviderMissNote | undefined, error: unknown): void {
   if (!note) return;
   const reason = providerMissReason(error);
   if (reason) note.reason = reason;
+  if (!isProviderMiss(error)) note.failure = error;
   note.notFound = note.notFound !== false && isProviderMiss(error) && error.notFound === true;
 }
 
@@ -93,6 +117,13 @@ export function isNoProviderMessage(message: string): boolean {
   return /\bprovider available for\b/i.test(message) || notATickerSymbol(message) !== null;
 }
 
+/** The router's generic answer that no provider served a request, holding the failure behind it when a provider failed rather than missed. */
+class NoProviderError extends Error {
+  constructor(message: string, readonly failure: unknown) {
+    super(message);
+  }
+}
+
 /**
  * The router's final error when no provider answered. A reason a provider gave
  * replaces the generic wording, and so does the service's answer that no
@@ -102,7 +133,18 @@ export function isNoProviderMessage(message: string): boolean {
 export function noProviderError(message: string, note: ProviderMissNote | undefined, symbol?: string): Error {
   if (note?.reason) return createProviderMiss(note.reason, note.reason);
   if (note?.notFound === true && symbol) return createProviderMiss(notATickerMessage(symbol), undefined, { notFound: true });
-  return new Error(message);
+  return new NoProviderError(message, note?.failure);
+}
+
+/**
+ * Whether a failed read means no source has what was asked for: a source's
+ * miss, or the router's answer that none served it when none failed another
+ * way. A refused session, a rate limit or a timeout is not, as asked again it may answer.
+ */
+export function isNoSourceAnswer(error: unknown): boolean {
+  if (isProviderMiss(error)) return true;
+  if (error instanceof NoProviderError) return error.failure === undefined;
+  return error instanceof Error && !(error instanceof ProviderBusyError) && isNoProviderMessage(error.message);
 }
 
 export function shouldLogProviderError(error: unknown): boolean {

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

@@ -1,3 +1,4 @@
+import { logFailure } from "../../utils/log-failure";
 import type {
   CachedFinancialsTarget,
   MarketDataRequestContext,
@@ -96,7 +97,7 @@ export class ProviderRouterBatchRoutes {
         providerIndexes.set(key, bucket);
       }
       const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
-      const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, providerOptions).catch(() => []);
+      const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, providerOptions).catch(logFailure("sources.provider-router.batches", "Loading batch quotes failed", []));
       for (const item of batchResults) {
         if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange, item.target.symbol, { recentAnswer: true })) continue;
         const key = this.quoteBatchKey(item.target);
@@ -163,7 +164,7 @@ export class ProviderRouterBatchRoutes {
         providerIndexes.set(key, bucket);
       }
       const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
-      const batchResults = await batchProvider.getTickerFinancialsBatch!(uniqueTargets, options).catch(() => []);
+      const batchResults = await batchProvider.getTickerFinancialsBatch!(uniqueTargets, options).catch(logFailure("sources.provider-router.batches", "Loading batch financials failed", []));
       for (const item of batchResults) {
         if (!item.financials) continue;
         if (!item.target.instrument && !providerFinancialsMatchTarget(item.financials, item.target.symbol, item.target.exchange)) continue;