gloomberb 0.10.4 → 0.11.0

package/src/tickers/search/index.ts

@@ -1,6 +1,7 @@
 import type { SearchRequestContext, DataProvider } from "../../types/data-provider";
 import type { InstrumentSearchResult } from "../../types/instrument";
 import type { TickerRecord } from "../../types/ticker";
+import { canonicalExchange } from "../../utils/exchanges";
 import { parseOptionSymbol } from "../../utils/options";
 import {
   buildSymbolAliases,
@@ -36,6 +37,7 @@ const SHARE_CLASS_SUFFIXES = new Set(["A", "B", "C", "D", "K"]);
 
 interface TickerSearchCandidateOptions {
   includeOptionContracts?: boolean;
+  providerRanks?: ReadonlyMap<string, number>;
 }
 
 export function normalizeTickerInput(activeTicker: string | null, arg?: string): string | null {
@@ -53,14 +55,21 @@ export function createLocalTickerSearchCandidates(
     if (options.includeOptionContracts === false && isOptionTickerRecord(ticker)) return [];
     const symbol = normalizeTickerSymbol(ticker.metadata.ticker);
     const hint = providerHints.get(symbol);
+    const exchangeLabel = ticker.metadata.exchange || hint?.exchange || hint?.primaryExchange;
+    const savedExchange = canonicalExchange(ticker.metadata.exchange);
+    const hintPrimaryExchange = canonicalExchange(hint?.primaryExchange);
+    const primaryExchangeLabel = !savedExchange || !hintPrimaryExchange || savedExchange === hintPrimaryExchange
+      ? hint?.primaryExchange
+      : undefined;
     return [{
       id: `goto:${ticker.metadata.ticker}`,
       label: ticker.metadata.ticker,
       symbol,
       detail: resolveLocalSearchName(ticker, hint),
-      right: hint?.exchange || ticker.metadata.exchange,
-      exchangeLabel: hint?.exchange || ticker.metadata.exchange,
-      primaryExchangeLabel: hint?.primaryExchange,
+      right: exchangeLabel,
+      exchangeLabel,
+      primaryExchangeLabel,
+      providerRank: options.providerRanks?.get(symbol),
       category: "Saved",
       kind: "ticker",
       saved: true,
@@ -77,7 +86,7 @@ function createProviderTickerSearchCandidates(
   localTickers: ReadonlyMap<string, TickerRecord>,
   options: TickerSearchCandidateOptions = {},
 ): TickerSearchCandidate[] {
-  return searchResults.flatMap((result) => {
+  return searchResults.flatMap((result, providerRank) => {
     if (options.includeOptionContracts === false && isOptionSearchResult(result)) return [];
     const symbol = getSearchResultSymbol(result);
     const saved = localTickers.has(symbol);
@@ -89,6 +98,7 @@ function createProviderTickerSearchCandidates(
       right: result.exchange || result.primaryExchange || result.type || undefined,
       exchangeLabel: result.exchange,
       primaryExchangeLabel: result.primaryExchange,
+      providerRank,
       category: saved ? "Saved" : "Other Listings",
       kind: "search",
       saved,
@@ -141,13 +151,16 @@ export function buildTickerSearchCandidates({
   totalLimit?: number;
   includeOptionContracts?: boolean;
 }): TickerSearchCandidate[] {
-  const candidateOptions = { includeOptionContracts };
   const filteredProviderResults = includeOptionContracts
     ? providerResults
     : providerResults.filter((result) => !isOptionSearchResult(result));
-  const providerHints = buildProviderHintMap(filteredProviderResults);
+  const providerHints = buildProviderHints(filteredProviderResults, tickers);
+  const candidateOptions = {
+    includeOptionContracts,
+    providerRanks: providerHints.ranks,
+  };
   const localItems = rankTickerSearchItems(
-    createLocalTickerSearchCandidates(tickers.values(), providerHints, candidateOptions),
+    createLocalTickerSearchCandidates(tickers.values(), providerHints.results, candidateOptions),
     query,
   );
   const providerItems = createProviderTickerSearchCandidates(filteredProviderResults, tickers, candidateOptions);
@@ -192,16 +205,28 @@ export async function resolveTickerSearch({
   };
 }
 
-function buildProviderHintMap(searchResults: InstrumentSearchResult[]): Map<string, InstrumentSearchResult> {
-  const hints = new Map<string, InstrumentSearchResult>();
-  for (const result of searchResults) {
+function buildProviderHints(
+  searchResults: InstrumentSearchResult[],
+  localTickers: ReadonlyMap<string, TickerRecord>,
+): {
+  results: Map<string, InstrumentSearchResult>;
+  ranks: Map<string, number>;
+} {
+  const results = new Map<string, InstrumentSearchResult>();
+  const ranks = new Map<string, number>();
+  for (const [rank, result] of searchResults.entries()) {
     const symbol = getSearchResultSymbol(result);
-    const existing = hints.get(symbol);
-    if (!existing || getProviderHintRichness(result) > getProviderHintRichness(existing)) {
-      hints.set(symbol, result);
+    if (!ranks.has(symbol)) ranks.set(symbol, rank);
+    const existing = results.get(symbol);
+    const preferredExchange = localTickers.get(symbol)?.metadata.exchange;
+    if (
+      !existing
+      || getProviderHintScore(result, preferredExchange) > getProviderHintScore(existing, preferredExchange)
+    ) {
+      results.set(symbol, result);
     }
   }
-  return hints;
+  return { results, ranks };
 }
 
 async function searchProviderResults(
@@ -284,14 +309,26 @@ function getProviderHintRichness(result: InstrumentSearchResult): number {
   return score;
 }
 
+function getProviderHintScore(result: InstrumentSearchResult, preferredExchange?: string): number {
+  const canonicalPreferredExchange = canonicalExchange(preferredExchange);
+  const matchesPreferredExchange = canonicalPreferredExchange
+    && [
+      result.exchange,
+      result.primaryExchange,
+      result.brokerContract?.exchange,
+      result.brokerContract?.primaryExchange,
+    ].some((exchange) => canonicalExchange(exchange) === canonicalPreferredExchange);
+  return getProviderHintRichness(result) + (matchesPreferredExchange ? 10_000 : 0);
+}
+
 function assignTickerSearchCategories<T extends TickerSearchCandidate>(items: T[]): T[] {
-  const hasSavedListing = items.some((item) =>
-    item.saved && item.instrumentClass !== "fund" && item.instrumentClass !== "derivative"
-  );
-  let assignedPrimaryListing = hasSavedListing;
+  let assignedPrimaryListing = false;
 
   return items.map((item) => {
     if (item.saved || item.kind === "ticker") {
+      if (item.instrumentClass !== "fund" && item.instrumentClass !== "derivative") {
+        assignedPrimaryListing = true;
+      }
       return { ...item, category: "Saved" };
     }
     if (item.instrumentClass === "fund" || item.instrumentClass === "derivative") {

package/src/tickers/search/ranking.ts

@@ -6,6 +6,23 @@ import type {
 const FUND_TYPES = new Set(["ETF", "ETN", "ETP", "FUND", "MUTUALFUND", "CEF", "CLOSEDEND"]);
 const DERIVATIVE_TYPES = new Set(["OPT", "OPTION", "OPTIONS", "FUT", "FUTURE", "FUTURES", "WARRANT", "WARRANTS", "RIGHT", "RIGHTS"]);
 const EQUITY_TYPES = new Set(["STK", "STOCK", "EQUITY", "COMMONSTOCK", "COMMON STOCK", "ADR", "ORDINARYSHARES", "ORDINARY SHARES"]);
+const COMPANY_NAME_SUFFIXES = new Set([
+  "AG",
+  "CO",
+  "COMPANY",
+  "CORP",
+  "CORPORATION",
+  "INC",
+  "INCORPORATED",
+  "LTD",
+  "LIMITED",
+  "NV",
+  "PLC",
+  "R",
+  "REGISTERED",
+  "SA",
+  "SE",
+]);
 
 const EXCHANGE_HINT_ALIASES: Record<string, string[]> = {
   NASDAQ: ["NASDAQ", "NMS"],
@@ -46,10 +63,13 @@ const ASSET_HINT_MAP: Record<string, TickerSearchInstrumentClass> = {
   FUTURES: "derivative",
 };
 
+const SAVED_MATCH_BONUS = 900;
+
 interface SearchQueryIntent {
   normalizedQuery: string;
   compactQuery: string;
   companyQuery: string;
+  companyQueryKey: string;
   exchangeHints: string[];
   assetPreference: TickerSearchInstrumentClass | null;
 }
@@ -82,6 +102,7 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       const normalizedLabel = normalizeSearchText(item.label);
       const normalizedDetail = normalizeSearchText(item.detail);
       const normalizedRight = normalizeSearchText(item.right || "");
+      const companyNameKey = getCompanyNameKey(item.detail);
       const textQueries = [intent.normalizedQuery, intent.companyQuery].filter(Boolean);
       const labelScore = maxScoreForQueries(textQueries, normalizedLabel, {
         exact: 24_000,
@@ -107,16 +128,23 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
         .reduce((best, alias) => Math.max(best, scoreSearchAlias(intent, alias)), 0);
       const textScore = labelScore + detailScore + aliasScore;
       const saved = isSavedSearchItem(item);
-      const priorityScore = scoreAssetPreference(intent, item.instrumentClass)
-        + scoreExchangePreference(intent, item)
-        + scoreListingPriority(item);
+      const explicitIntentScore = scoreAssetPreference(intent, item.instrumentClass)
+        + scoreExchangePreference(intent, item);
+      const priorityScore = explicitIntentScore + scoreListingPriority(item);
+      const companyMatchRank = scoreCompanyNameMatch(intent, companyNameKey);
       return {
         item,
         index,
+        companyMatchRank,
+        companyNameKey,
+        issuerGroupKey: companyMatchRank > 0 && item.instrumentClass === "equity"
+          ? companyNameKey
+          : null,
+        explicitIntentScore,
         normalizedSymbol: normalizeSearchText(item.symbol || item.label),
         symbolMatchRank: scoreSymbolMatchRank(intent, item),
         textScore,
-        score: textScore + priorityScore + (textScore > 0 && saved ? 900 : 0),
+        score: textScore + priorityScore + (textScore > 0 && saved ? SAVED_MATCH_BONUS : 0),
       };
     });
 
@@ -126,21 +154,83 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       .map(({ normalizedSymbol }) => normalizedSymbol),
   );
 
-  const filtered = ranked
-    .filter(({ item, normalizedSymbol, textScore }) => {
-      if (textScore <= 0) return false;
-      if (item.kind !== "search") return true;
-      return !matchedLocalSymbols.has(normalizedSymbol);
-    })
-    .sort((a, b) => {
-      if (b.symbolMatchRank !== a.symbolMatchRank) return b.symbolMatchRank - a.symbolMatchRank;
-      if (b.score !== a.score) return b.score - a.score;
-      const aSaved = isSavedSearchItem(a.item);
-      const bSaved = isSavedSearchItem(b.item);
-      if (aSaved !== bSaved) return aSaved ? -1 : 1;
-      if (a.item.label.length !== b.item.label.length) return a.item.label.length - b.item.label.length;
-      return a.index - b.index;
+  const filtered = ranked.filter(({ item, normalizedSymbol, textScore }) => {
+    if (textScore <= 0) return false;
+    if (item.kind !== "search") return true;
+    return !matchedLocalSymbols.has(normalizedSymbol);
+  });
+
+  type RankedEntry = (typeof ranked)[number];
+  const compareFallbackEntries = (a: RankedEntry, b: RankedEntry): number => {
+    if (b.symbolMatchRank !== a.symbolMatchRank) return b.symbolMatchRank - a.symbolMatchRank;
+    if (b.score !== a.score) return b.score - a.score;
+    const aSaved = isSavedSearchItem(a.item);
+    const bSaved = isSavedSearchItem(b.item);
+    if (aSaved !== bSaved) return aSaved ? -1 : 1;
+    if (a.item.label.length !== b.item.label.length) return a.item.label.length - b.item.label.length;
+    return a.index - b.index;
+  };
+
+  const hasExplicitHint = intent.exchangeHints.length > 0 || intent.assetPreference != null;
+  const bucketGroups = new Map<string, Map<string, RankedEntry[]>>();
+  for (const entry of filtered) {
+    const exactSymbolRank = entry.symbolMatchRank >= 2 ? entry.symbolMatchRank : 0;
+    const bucketKey = [
+      exactSymbolRank,
+      hasExplicitHint ? entry.explicitIntentScore : 0,
+      entry.companyMatchRank,
+    ].join(":");
+    const groupKey = entry.issuerGroupKey
+      ? `issuer:${entry.issuerGroupKey}`
+      : `item:${entry.index}`;
+    const groups = bucketGroups.get(bucketKey) ?? new Map<string, RankedEntry[]>();
+    const group = groups.get(groupKey) ?? [];
+    group.push(entry);
+    groups.set(groupKey, group);
+    bucketGroups.set(bucketKey, groups);
+  }
+
+  const groupOrderByIndex = new Map<number, number>();
+  for (const groups of bucketGroups.values()) {
+    const orderedGroups = [...groups.values()]
+      .map((entries) => ({
+        entries,
+        representative: entries.reduce((best, entry) =>
+          compareFallbackEntries(entry, best) < 0 ? entry : best
+        ),
+      }))
+      .sort((a, b) => compareFallbackEntries(a.representative, b.representative));
+    orderedGroups.forEach(({ entries }, order) => {
+      entries.forEach((entry) => groupOrderByIndex.set(entry.index, order));
     });
+  }
+
+  filtered.sort((a, b) => {
+    // Precedence is exact symbol, explicit query hints, whole-word company
+    // relevance, issuer relevance, provider order within that issuer, partial
+    // symbol, saved relevance, then stable source order.
+    const aExactSymbolRank = a.symbolMatchRank >= 2 ? a.symbolMatchRank : 0;
+    const bExactSymbolRank = b.symbolMatchRank >= 2 ? b.symbolMatchRank : 0;
+    if (bExactSymbolRank !== aExactSymbolRank) return bExactSymbolRank - aExactSymbolRank;
+    if (hasExplicitHint && b.explicitIntentScore !== a.explicitIntentScore) {
+      return b.explicitIntentScore - a.explicitIntentScore;
+    }
+    if (b.companyMatchRank !== a.companyMatchRank) {
+      return b.companyMatchRank - a.companyMatchRank;
+    }
+    const aGroupOrder = groupOrderByIndex.get(a.index) ?? a.index;
+    const bGroupOrder = groupOrderByIndex.get(b.index) ?? b.index;
+    if (aGroupOrder !== bGroupOrder) return aGroupOrder - bGroupOrder;
+    if (
+      a.issuerGroupKey
+      && a.issuerGroupKey === b.issuerGroupKey
+    ) {
+      const aProviderRank = a.item.providerRank ?? Number.POSITIVE_INFINITY;
+      const bProviderRank = b.item.providerRank ?? Number.POSITIVE_INFINITY;
+      if (aProviderRank !== bProviderRank) return aProviderRank - bProviderRank;
+    }
+    return compareFallbackEntries(a, b);
+  });
 
   const deduped: T[] = [];
   const seen = new Set<string>();
@@ -216,6 +306,7 @@ function analyzeSearchQuery(query: string): SearchQueryIntent {
     normalizedQuery,
     compactQuery,
     companyQuery,
+    companyQueryKey: normalizeCompanyName(companyQuery),
     exchangeHints,
     assetPreference,
   };
@@ -356,6 +447,40 @@ function scoreListingPriority(item: Pick<TickerSearchRankableItem, "label"> & Pa
   return score;
 }
 
+function getCompanyNameKey(detail: string): string {
+  return normalizeCompanyName(detail.split("|")[0] || "");
+}
+
+function normalizeCompanyName(name: string): string {
+  const tokens = normalizeSearchText(name).split(" ").filter(Boolean);
+  while (tokens.length > 1) {
+    if (COMPANY_NAME_SUFFIXES.has(tokens.at(-1)!)) {
+      tokens.pop();
+      continue;
+    }
+
+    const punctuatedSuffix = [...COMPANY_NAME_SUFFIXES].find((suffix) =>
+      suffix.length > 1
+      && tokens.length > suffix.length
+      && tokens.slice(-suffix.length).every((token, index) =>
+        token.length === 1 && token === suffix[index]
+      )
+    );
+    if (!punctuatedSuffix) break;
+    tokens.splice(-punctuatedSuffix.length);
+  }
+  return tokens.join(" ");
+}
+
+function scoreCompanyNameMatch(intent: SearchQueryIntent, companyName: string): number {
+  const query = intent.companyQueryKey;
+  if (!query || !companyName) return 0;
+  if (companyName === query) return 3;
+  if (companyName.startsWith(`${query} `)) return 2;
+  if (companyName.includes(` ${query} `) || companyName.endsWith(` ${query}`)) return 1;
+  return 0;
+}
+
 function isSavedSearchItem(item: Pick<TickerSearchRankableItem, "kind" | "category"> & Partial<TickerSearchRankableItem>): boolean {
   return item.saved === true || item.kind === "ticker" || item.category === "Saved" || item.category === "Open";
 }

package/src/tickers/search/types.ts

@@ -16,6 +16,7 @@ export interface TickerSearchRankableItem {
   instrumentClass?: TickerSearchInstrumentClass;
   exchangeLabel?: string;
   primaryExchangeLabel?: string;
+  providerRank?: number;
   searchAliases?: string[];
 }
 

package/src/time-series/alignment.ts

@@ -80,11 +80,23 @@ export function alignTimeSeries(
   const exactMaps = series.map((entry) => (
     new Map(entry.points.map((point) => [effectiveTimeSeriesPointTime(point), point]))
   ));
+  const carryPoints = series.map((entry) => [...entry.points].sort((left, right) => (
+    effectiveTimeSeriesPointTime(left) - effectiveTimeSeriesPointTime(right)
+  )));
   const sortedTimes = [...timeline].sort((left, right) => left - right);
+  const carryPointers = new Array<number>(series.length).fill(-1);
   const rows: AlignedTimeSeriesRow[] = [];
   for (const time of sortedTimes) {
     const values: Record<string, AlignedSeriesValue | null> = {};
     series.forEach((entry, seriesIndex) => {
+      const points = carryPoints[seriesIndex]!;
+      let pointer = carryPointers[seriesIndex]!;
+      while (
+        pointer + 1 < points.length
+        && effectiveTimeSeriesPointTime(points[pointer + 1]!) <= time
+      ) pointer += 1;
+      carryPointers[seriesIndex] = pointer;
+
       const exact = exactMaps[seriesIndex]!.get(time);
       if (exact) {
         values[entry.id] = { point: exact, value: scalarPointValue(exact), carried: false };
@@ -96,20 +108,12 @@ export function alignTimeSeries(
         return;
       }
 
-      let previous: TimeSeriesPoint | null = null;
-      let previousEligibleAt = Number.NEGATIVE_INFINITY;
-      for (const point of entry.points) {
-        const eligibleAt = effectiveTimeSeriesPointTime(point);
-        if (eligibleAt <= time && eligibleAt >= previousEligibleAt) {
-          previous = point;
-          previousEligibleAt = eligibleAt;
-        }
-      }
-      if (!previous) {
+      if (pointer < 0) {
         values[entry.id] = null;
         return;
       }
-      const age = time - previousEligibleAt;
+      const previous = points[pointer]!;
+      const age = time - effectiveTimeSeriesPointTime(previous);
       if (options.maxCarryMilliseconds !== undefined && age > options.maxCarryMilliseconds) {
         values[entry.id] = null;
         return;

package/src/time-series/field-catalog.ts

@@ -300,6 +300,16 @@ export function isMarketFieldId(id: string): boolean {
   return canonicalTimeSeriesFieldId(id).startsWith("market.");
 }
 
+export function isPriceOnlyMarketFieldId(id: string): boolean {
+  const canonical = canonicalTimeSeriesFieldId(id);
+  return canonical === "market.ohlcv"
+    || canonical === "market.open"
+    || canonical === "market.high"
+    || canonical === "market.low"
+    || canonical === "market.close"
+    || canonical === "market.volume";
+}
+
 export function isFundamentalFieldId(id: string): boolean {
   const canonical = canonicalTimeSeriesFieldId(id);
   return canonical.startsWith("fundamental.") || canonical.startsWith("valuation.");

package/src/time-series/fundamentals.ts

@@ -240,11 +240,10 @@ function mergeStatementsByPeriod(
   const groups: InternalStatement[][] = [];
   const sorted = [...statements].sort((left, right) => left.date.localeCompare(right.date));
   for (const statement of sorted) {
-    const group = groups.find((candidate) => (
-      areNearbyFinancialPeriodEnds(candidate[0]!.date, statement.date)
-    ));
-    if (group) group.push(statement as InternalStatement);
-    else groups.push([statement as InternalStatement]);
+    const lastGroup = groups.at(-1);
+    if (lastGroup && areNearbyFinancialPeriodEnds(lastGroup[0]!.date, statement.date)) {
+      lastGroup.push(statement as InternalStatement);
+    } else groups.push([statement as InternalStatement]);
   }
   return groups
     .map(mergeStatementPeriodGroup)
@@ -601,12 +600,22 @@ function pointForStatement(
   };
 }
 
+/**
+ * `PricePoint.date` is typed as a `Date`, but history that has crossed a JSON
+ * boundary (persisted caches, the screenshot payload) arrives as a string. Read
+ * it defensively so a serialized round trip cannot crash valuation history.
+ */
+function pointTime(point: PricePoint): number {
+  const date = point.date;
+  return date instanceof Date ? date.getTime() : Date.parse(date as unknown as string);
+}
+
 function priceAtOrBefore(priceHistory: readonly PricePoint[], date: string): number | null {
   const target = Date.parse(date);
   if (!Number.isFinite(target)) return null;
   let closest: { time: number; close: number } | undefined;
   for (const point of priceHistory) {
-    const time = point.date.getTime();
+    const time = pointTime(point);
     if (!Number.isFinite(time) || time > target || !finiteNumber(point.close) || point.close <= 0) continue;
     if (!closest || time > closest.time) closest = { time, close: point.close };
   }
@@ -767,11 +776,10 @@ function dedupeFundamentalPeriods(points: readonly TimeSeriesPoint[]): TimeSerie
     left.observedAt.getTime() - right.observedAt.getTime()
   ));
   for (const point of sorted) {
-    const group = groups.find((candidate) => (
-      areNearbyFinancialPeriodEnds(candidate[0]!.observedAt, point.observedAt)
-    ));
-    if (group) group.push(point);
-    else groups.push([point]);
+    const lastGroup = groups.at(-1);
+    if (lastGroup && areNearbyFinancialPeriodEnds(lastGroup[0]!.observedAt, point.observedAt)) {
+      lastGroup.push(point);
+    } else groups.push([point]);
   }
   return groups
     .map((group) => group.slice(1).reduce(preferredPeriodPoint, group[0]!))

package/src/time-series/hooks.ts

@@ -2,7 +2,8 @@ import { useMemo } from "react";
 import { apiClient } from "../api-client";
 import { loadCachedFredSeries } from "../data/fred-series";
 import { instrumentFromTicker } from "../market-data/request-types";
-import { useAssetData } from "../plugins/runtime";
+import { useAssetData, useCapabilityInvoker } from "../plugins/runtime";
+import { createChartSeriesResolver } from "../capabilities";
 import { useAppSelector } from "../state/app/context";
 import type { FredSeriesRequest } from "../data/fred-series";
 import type { TickerRecord } from "../types/ticker";
@@ -56,11 +57,16 @@ export function useResolvedChartSpec(
   options: UseChartResolutionOptions = {},
 ): UseChartResolutionResult {
   const dataProvider = useAssetData();
+  const capabilityInvoker = useCapabilityInvoker();
   const tickers = useAppSelector((state) => state.tickers);
   const hydratedSpec = useMemo(
     () => hydrateChartSpecInstruments(spec, tickers),
     [spec, tickers],
   );
-  const sources = useMemo(() => ({ dataProvider, loadFredSeries: loadFred }), [dataProvider]);
+  const sources = useMemo(() => ({
+    dataProvider,
+    loadFredSeries: loadFred,
+    resolveCapabilitySeries: createChartSeriesResolver(capabilityInvoker),
+  }), [capabilityInvoker, dataProvider]);
   return useChartResolution(hydratedSpec, sources, options);
 }

package/src/time-series/parsed-history-cache.ts

@@ -0,0 +1,35 @@
+import type { PricePoint } from "../types/financials";
+import type { TimeRange } from "./range";
+import type { ManualChartResolution } from "./resolution";
+
+const MAX_PARSED_HISTORY = 32;
+const parsedHistory = new Map<string, PricePoint[]>();
+
+export function parsedPriceHistoryKey(
+  symbol: string,
+  exchange: string,
+  range: TimeRange,
+  resolution?: ManualChartResolution,
+): string {
+  return [
+    symbol.trim().toUpperCase(),
+    exchange.trim().toUpperCase(),
+    range,
+    resolution ?? "",
+  ].join("|");
+}
+
+export function rememberParsedPriceHistory(key: string, points: PricePoint[]): void {
+  if (points.length === 0) return;
+  if (parsedHistory.has(key)) parsedHistory.delete(key);
+  parsedHistory.set(key, points);
+  while (parsedHistory.size > MAX_PARSED_HISTORY) {
+    const oldest = parsedHistory.keys().next().value;
+    if (oldest === undefined) break;
+    parsedHistory.delete(oldest);
+  }
+}
+
+export function readParsedPriceHistory(key: string): PricePoint[] | undefined {
+  return parsedHistory.get(key);
+}

package/src/time-series/resolution.ts

@@ -169,6 +169,16 @@ export function normalizeChartResolutionSupport(support: readonly ChartResolutio
   );
 }
 
+/** Yahoo-shaped support used for first paint when broker/provider support is async. */
+export const DEFAULT_CHART_RESOLUTION_SUPPORT: ChartResolutionSupport[] = normalizeChartResolutionSupport([
+  { resolution: "5m", maxRange: "1W" },
+  { resolution: "15m", maxRange: "1M" },
+  { resolution: "1h", maxRange: "3M" },
+  { resolution: "1d", maxRange: "5Y" },
+  { resolution: "1wk", maxRange: "ALL" },
+  { resolution: "1mo", maxRange: "ALL" },
+]);
+
 export function intersectChartResolutionSupport(
   supportSets: Array<readonly ChartResolutionSupport[]>,
 ): ChartResolutionSupport[] {