gloomberb 0.16.6 → 0.17.0

package/src/shares/personal-pane.ts

@@ -1,64 +1,52 @@
+import type { ResolvedPane } from "../layout/pane-manager";
+import { getPaneSettings } from "../pane-settings";
 import type { PluginRegistry } from "../plugins/registry";
-import type { AppConfig, PaneInstanceConfig } from "../types/config";
-import type { TickerRecord } from "../types/ticker";
+import { resolveCollectionForPane, resolveTickerForPane, type AppState } from "../state/app/context";
+import type { LayoutConfig } from "../types/config";
+import type { PanePersonalData, PanePersonalDataContext } from "../types/plugin";
+import { resolvePanePersonalData } from "./pane-image";
 
-/** Keys a pane names a portfolio or a broker account by. */
-const ACCOUNT_KEY = /collection|portfolio|account|broker/i;
+export interface PanePersonalDataSource {
+  registry: Pick<PluginRegistry, "brokers" | "getPanePluginId" | "getBrokerPluginId">;
+  state: AppState;
+  /** The layout the pane is in, for its `personalData` rule. */
+  layout: LayoutConfig;
+  pane: Pick<ResolvedPane, "instance" | "def">;
+}
 
-interface PersonalPaneSource {
-  registry: Pick<PluginRegistry, "panes" | "brokers" | "getPanePluginId" | "getBrokerPluginId">;
-  instance: Pick<PaneInstanceConfig, "paneId" | "params" | "settings">;
-  paneState?: Readonly<Record<string, unknown>>;
-  /** The ticker the pane shows, when it shows one. */
-  symbol?: string | null;
-  config: Pick<AppConfig, "portfolios" | "brokerInstances">;
-  tickers?: ReadonlyMap<string, TickerRecord>;
+/** What a pane shows now, for its `personalData` rule. */
+function personalDataContext({ state, layout, pane }: Omit<PanePersonalDataSource, "registry">): PanePersonalDataContext {
+  const paneId = pane.instance.instanceId;
+  return {
+    config: state.config,
+    layout,
+    paneId,
+    paneType: pane.instance.paneId,
+    pane: pane.instance,
+    settings: getPaneSettings(pane.instance),
+    paneState: state.paneState[paneId] ?? {},
+    activeTicker: resolveTickerForPane(state, paneId),
+    activeCollectionId: resolveCollectionForPane(state, paneId),
+    tickers: state.tickers,
+  };
 }
 
-function accountValues(record: Readonly<Record<string, unknown>> | undefined): string[] {
-  if (!record) return [];
-  return Object.entries(record).flatMap(([key, value]) => {
-    if (!ACCOUNT_KEY.test(key)) return [];
-    if (typeof value === "string") return [value];
-    return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
-  });
+/** Whether the plugin that owns a pane also connects a broker. */
+function ownerConnectsBroker(registry: PanePersonalDataSource["registry"], paneType: string): boolean {
+  const owner = registry.getPanePluginId(paneType);
+  return !!owner && [...registry.brokers.keys()].some((brokerType) => registry.getBrokerPluginId(brokerType) === owner);
 }
 
 /**
- * Whether a pane shows the user's holdings, balances or account data, so its
- * contents are asked about before they leave the device. Read from what every
- * pane already declares, with no list of panes to keep up to date:
- *
- * - it keeps fields to itself when shared (`portableShare.private`): the
- *   portfolio, account, broker, chat, team and thesis panes, and Ask Gloom;
- * - its plugin brings a broker, as an external broker plugin's panes do;
- * - it shows a ticker the user holds (a research pane lists the position);
- * - it is set to one of the user's portfolios or broker connections.
+ * The personal data a pane shows now, from its `PaneDef.personalData` (and,
+ * for a pane that declares nothing, the fallback in `resolvePanePersonalData`);
+ * null for market data. The one answer to "does this pane show the person's
+ * own data, so ask before it leaves the device": sharing its picture to chat
+ * and attaching it to an Ask Gloom question both read it here, from the same
+ * context.
  */
-export function paneShowsPersonalData({
-  registry,
-  instance,
-  paneState,
-  symbol,
-  config,
-  tickers,
-}: PersonalPaneSource): boolean {
-  const def = registry.panes.get(instance.paneId);
-  if (def?.portableShare?.private) return true;
-
-  const pluginId = registry.getPanePluginId(instance.paneId);
-  if (pluginId && [...registry.brokers.keys()].some((brokerId) => registry.getBrokerPluginId(brokerId) === pluginId)) {
-    return true;
-  }
-
-  const held = symbol ? tickers?.get(symbol)?.metadata.positions : undefined;
-  if (held?.some((position) => position.shares !== 0)) return true;
-
-  const accounts = new Set([
-    ...config.portfolios.map((portfolio) => portfolio.id),
-    ...config.brokerInstances.map((instance) => instance.id),
-  ]);
-  return [instance.params, instance.settings, paneState]
-    .flatMap(accountValues)
-    .some((value) => accounts.has(value));
+export function panePersonalData({ registry, ...source }: PanePersonalDataSource): PanePersonalData | null {
+  return resolvePanePersonalData(source.pane.def, personalDataContext(source), {
+    ownerConnectsBroker: ownerConnectsBroker(registry, source.pane.def.id),
+  });
 }

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

@@ -2,7 +2,7 @@ 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, parseHistoryCoverageStart } from "../history-coverage";
+import { HistoryCoverageError, parseHistoryCoverageNote, parseHistoryCoverageStart } from "../history-coverage";
 import {
   normalizeChartResolutionSupport,
   type ChartResolutionSupport,
@@ -16,6 +16,7 @@ import type {
   SecFilingDocument,
   SecFilingItem,
   MarketDataRequestContext,
+  QuoteBatchOptions,
   QuoteBatchResult,
   QuoteSubscriptionTarget,
   SearchRequestContext,
@@ -177,6 +178,7 @@ function mapCloudPriceHistory(
   extendedHours = false,
 ): PriceHistoryResult {
   const coverageStart = parseHistoryCoverageStart(response.coverage);
+  const coverageNote = parseHistoryCoverageNote(response.coverage);
   if (response.status === "empty" && coverageStart
     && requestedStart.getTime() < Date.parse(coverageStart)) throw new HistoryCoverageError(coverageStart);
   // The server marks a cached copy it could not refresh in time. Bars that
@@ -237,6 +239,7 @@ function mapCloudPriceHistory(
     resolution,
     ...(session && matchingSource && matchingIdentity ? { session } : {}),
     ...(coverageStart ? { coverageStart } : {}),
+    ...(coverageNote ? { coverageNote } : {}),
     ...(extendedHours ? { extendedHours: true } : {}),
   };
 }
@@ -492,8 +495,10 @@ export class GloomberbCloudProvider implements AssetDataProvider {
 
   async getQuotesBatch(
     targets: QuoteSubscriptionTarget[],
-    options: { forceRefresh?: boolean } = {},
+    options: QuoteBatchOptions = {},
   ): Promise<QuoteBatchResult[]> {
+    // This provider keeps no quote cache of its own.
+    if (options.cacheOnly) return targets.map((target) => ({ target, quote: null }));
     const { perpetuals, others } = splitPerpetualTargets(targets);
     if (perpetuals.length) {
       const [listed, answered] = await Promise.all([

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

@@ -120,6 +120,11 @@ export function mapQuote(
       divisor,
     ),
     extendedSessionPrint: typeof quote.extendedSessionPrint === "boolean" ? quote.extendedSessionPrint : undefined,
+    overnightPrice: normalizePriceValueByDivisor(quote.overnightPrice, divisor),
+    overnightChange: normalizePriceValueByDivisor(quote.overnightChange, divisor),
+    overnightPriceKind: quote.overnightPriceKind === "trade" || quote.overnightPriceKind === "mark"
+      ? quote.overnightPriceKind
+      : undefined,
     listingExchangeName,
     listingExchangeFullName,
     exchangeName: listingExchangeName,

package/src/sources/history-coverage.ts

@@ -19,14 +19,32 @@ export function parseHistoryCoverageStart(coverage: unknown): string | undefined
   return dates.length ? dates.reduce((latest, date) => date > latest ? date : latest) : undefined;
 }
 
-function historyCoverageMessage(coverageStart: string): string {
-  return `Verified price history starts ${coverageStart}; earlier prices are excluded.`;
+/**
+ * Why a source serves nothing before its coverage, when it says, such as
+ * "old-shekel quotes before 1992 are not served": one line of plain text.
+ */
+export function parseHistoryCoverageNote(coverage: unknown): string | undefined {
+  if (!coverage || typeof coverage !== "object" || !parseHistoryCoverageStart(coverage)) return undefined;
+  return historyCoverageNoteText((coverage as Record<string, unknown>).note);
+}
+
+/** A coverage note fit to print: a short line without control characters, its closing full stop dropped. */
+export function historyCoverageNoteText(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const note = value.trim().replace(/\.$/, "");
+  return note && note.length <= 200 && !/[\u0000-\u001f\u007f]/.test(note) ? note : undefined;
+}
+
+function historyCoverageMessage(coverageStart: string, note?: string): string {
+  return note
+    ? `Price history starts ${coverageStart}; ${note}.`
+    : `Verified price history starts ${coverageStart}; earlier prices are excluded.`;
 }
 
 /** Shown while the visible window starts before the source's coverage. */
-export function historyCoverageNotice(coverageStart: string | undefined, visibleStart: number | null): string | null {
+export function historyCoverageNotice(coverageStart: string | undefined, visibleStart: number | null, note?: string): string | null {
   if (!coverageStart || (visibleStart !== null && visibleStart >= Date.parse(coverageStart))) return null;
-  return historyCoverageMessage(coverageStart);
+  return historyCoverageMessage(coverageStart, note);
 }
 
 /** The whole requested window lies before the source's declared coverage. */

package/src/sources/history-result.ts

@@ -4,7 +4,7 @@ import type { DataProvider, MarketDataRequestContext } from "../types/data-provi
 import type { PriceHistoryResult } from "../types/price-history";
 import { parseHistorySession } from "../market-data/history-session";
 import { canonicalHistoryInterval } from "./history-retention";
-import { isHistoryCoverageDate } from "./history-coverage";
+import { historyCoverageNoteText, isHistoryCoverageDate } from "./history-coverage";
 
 export type HistoryResultRequest =
   | { kind: "range"; range: TimeRange }
@@ -40,6 +40,8 @@ export function normalizeHistoryResult(
     ...(session ? { session } : {}),
     ...(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)
+      ? { coverageNote: historyCoverageNoteText(result.coverageNote) } : {}),
     ...(result.extendedHours === true ? { extendedHours: true } : {}),
     ...(result.savedCopyBehind === true ? { savedCopyBehind: true as const } : {}),
   };

package/src/sources/provider-errors.ts

@@ -71,7 +71,8 @@ export function noteProviderAnswer(note: ProviderMissNote | undefined): void {
   if (note) note.notFound = false;
 }
 
-const NOT_A_TICKER = /^Not a ticker: (.+)\.$/;
+// A command may follow it with the listing search suggests: "Not a ticker: USD_NGN. Did you mean USDNGN=X (...)?"
+const NOT_A_TICKER = /^Not a ticker: (.+?)\.(?= Did you mean |$)/;
 
 /** "Not a ticker: APPLE.", what a request for a symbol no listing carries ends in. */
 function notATickerMessage(symbol: string): string {

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

@@ -1,6 +1,7 @@
 import type {
   CachedFinancialsTarget,
   MarketDataRequestContext,
+  QuoteBatchOptions,
   QuoteBatchResult,
   QuoteSubscriptionTarget,
   TickerFinancialsBatchResult,
@@ -48,8 +49,11 @@ export class ProviderRouterBatchRoutes {
 
   async getQuotesBatch(
     targets: QuoteSubscriptionTarget[],
-    options: { forceRefresh?: boolean } = {},
+    options: QuoteBatchOptions = {},
   ): Promise<QuoteBatchResult[]> {
+    if (options.cacheOnly) return targets.map((target) => ({ target, quote: this.cachedQuote(target) }));
+    // The signal is the caller's; providers are asked as before.
+    const providerOptions = { forceRefresh: options.forceRefresh };
     const forceRefresh = options.forceRefresh === true;
     const results = new Array<QuoteBatchResult | null>(targets.length).fill(null);
     const misses: Array<{ index: number; target: QuoteSubscriptionTarget }> = [];
@@ -91,7 +95,7 @@ export class ProviderRouterBatchRoutes {
         providerIndexes.set(key, bucket);
       }
       const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
-      const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, options).catch(() => []);
+      const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, providerOptions).catch(() => []);
       for (const item of batchResults) {
         if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange, item.target.symbol, { recentAnswer: true })) continue;
         const key = this.quoteBatchKey(item.target);
@@ -197,6 +201,18 @@ export class ProviderRouterBatchRoutes {
     return results.map((result, index) => result ?? { target: targets[index]!, financials: null });
   }
 
+  /** The newest cached quote for a target from any source, however old: what a board paints first. */
+  private cachedQuote(target: QuoteSubscriptionTarget): Quote | null {
+    const context = target.context;
+    const entityKey = this.deps.getEntityKey(target.symbol, context?.instrument);
+    const variantKeys = this.deps.getTickerVariantCandidates(target.exchange);
+    const sourceKeys = [
+      ...this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate)),
+      ...this.deps.getProviderSourceKeys(),
+    ];
+    return selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, true)?.value ?? null;
+  }
+
   private quoteBatchKey(target: QuoteSubscriptionTarget): string {
     return `${target.symbol.trim().toUpperCase()}:${canonicalExchange(target.exchange ?? "")}`;
   }

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

@@ -11,6 +11,7 @@ import type {
   CachedFinancialsTarget,
   DataProvider,
   MarketDataRequestContext,
+  QuoteBatchOptions,
   QuoteBatchResult,
   QuoteSubscriptionTarget,
   SearchRequestContext,
@@ -194,7 +195,7 @@ export class AssetDataRouter implements DataProvider {
 
   async getQuotesBatch(
     targets: QuoteSubscriptionTarget[],
-    options: { forceRefresh?: boolean } = {},
+    options: QuoteBatchOptions = {},
   ): Promise<QuoteBatchResult[]> {
     const mapped = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, target.context));
     const results = await this.batchRoutes.getQuotesBatch(mapped.valid, options);

package/src/state/app/context/index.tsx

@@ -398,13 +398,14 @@ function useUpdatePaneLayout(options: { saveDelayMs?: number } = {}) {
   }, [dispatch, saveDelayMs, stateRef]);
 }
 
-/** Keep a content-derived pane title in its saved layout, without exposing config writes. */
-export function usePaneTitle(title: string, paneId?: string): void {
+/** Keep a content-derived pane title in its saved layout, without exposing config writes. Null leaves the title alone. */
+export function usePaneTitle(title: string | null, paneId?: string): void {
   const id = useScopedPaneId(paneId);
   // A follower's title changes with every cursor move in its source; that is
   // not worth a config write per step.
   const updateLayout = useUpdatePaneLayout({ saveDelayMs: LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS });
   useEffect(() => {
+    if (title == null) return;
     updateLayout((layout) => {
       const pane = findPaneInstance(layout, id);
       return !pane || pane.title === title ? layout

package/src/test-support/builtin-panes.ts

@@ -0,0 +1,31 @@
+import { createPaneDiscoveryContext } from "../cli/pane-functions/discovery";
+import { getLoadablePlugins } from "../plugins/catalog";
+import { createDefaultConfig } from "../types/config";
+import type { GloomPlugin, PaneDef } from "../types/plugin";
+
+/**
+ * Every built-in pane definition, the panes a plugin registers in `setup()`
+ * included, as `gloomberb catalog` finds them. `dispose` stops the plugins
+ * that were set up.
+ */
+export async function loadBuiltinPanes(): Promise<{ panes: Map<string, PaneDef>; dispose: () => void }> {
+  const config = createDefaultConfig("/gloom");
+  const { panes, paneTemplates: _templates, ...discovery } = createPaneDiscoveryContext({
+    getConfig: () => config,
+    panes: new Map(getLoadablePlugins().flatMap((plugin) => plugin.panes ?? []).map((pane) => [pane.id, pane])),
+  });
+  const started: GloomPlugin[] = [];
+  const dispose = () => {
+    for (const plugin of started.splice(0).reverse()) plugin.dispose?.();
+  };
+  try {
+    for (const plugin of getLoadablePlugins()) {
+      started.push(plugin);
+      await plugin.setup?.(discovery);
+    }
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+  return { panes, dispose };
+}

package/src/tickers/listing-venues.ts

@@ -10,6 +10,7 @@ import {
   parsePublicTickerKey,
   typedExchangeCode,
 } from "../utils/exchanges";
+import { currencyPairSpelling } from "../utils/currency-pair";
 
 export interface ListingStore {
   loadTicker(symbol: string): Promise<TickerRecord | null>;
@@ -78,6 +79,27 @@ export async function quotedOnVenue(listing: { symbol: string; exchange: string
   }
 }
 
+/**
+ * A currency pair typed the way a security could also be written, USD-NGN or
+ * USDNGN, read as the pair the service lists (USDNGN=X) when search, as the
+ * command bar reads the same text, finds no listing under those letters: MNT-USD
+ * stays the coin. Null for any other text, and for a listing.
+ */
+export async function readAmbiguousCurrencyPair(typed: string, { store, dataProvider }: ListingDeps): Promise<string | null> {
+  const pair = currencyPairSpelling(typed);
+  if (!pair?.ambiguous) return null;
+  try {
+    const tickers = new Map((await store.loadAllTickers()).map((ticker) => [ticker.metadata.ticker.toUpperCase(), ticker] as const));
+    const resolved = await resolveTickerSearch({ query: typed, activeTicker: null, tickers, dataProvider });
+    const exchange = !resolved ? undefined : resolved.kind === "local" ? resolved.ticker.metadata.exchange : resolved.result.exchange;
+    const listed = resolved ? currencyPairSpelling(resolved.symbol, exchange) : null;
+    return listed && !listed.ambiguous && listed.symbol === pair.symbol ? pair.symbol : null;
+  } catch {
+    // Several listings under those letters, or no search: the letters stay a symbol.
+    return null;
+  }
+}
+
 /** What a typed code that names several venues (7203:TSE) was read as. */
 export type SharedCodeReading =
   /** The one of the code's venues the symbol trades on. */

package/src/tickers/search/index.ts

@@ -5,6 +5,7 @@ import { canonicalExchange, isSharedExchangeCode, isUsListingExchange, parsePubl
 import { getListingSymbol, tickerHasListingSuffix } from "../../sources/listing-symbols";
 import { parseOptionSymbol } from "../../utils/options";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
+import { currencyPairSpelling } from "../../utils/currency-pair";
 import { assetClassMarketSymbol, parseAssetClassQuery } from "./asset-classes";
 import { bareFuturesCode, futuresContractByCode } from "../../market-data/futures-board";
 import { searchContractKey, searchInstrumentKey } from "./identity";
@@ -311,9 +312,13 @@ export function resolveTickerSearch(options: ResolveTickerSearchOptions): Promis
   const typed = symbolSearchQuery(requested);
   // A futures board code no security uses is its future (TTF is TTF=F), unless a saved ticker holds it.
   const future = pickListing || options.tickers.has(typed) ? null : bareFuturesCode(typed);
-  const symbol = future?.symbol ?? typed;
+  // A currency pair is the one listing the service has for it, however it is written: EUR/USD and
+  // JPY=X are EURUSD=X and USDJPY=X. USD-NGN and USDNGN, which a security could also be written as
+  // (MNT-USD is a coin), are the pair only when nothing is listed under those letters.
+  const pair = pickListing || future ? null : currencyPairSpelling(typed);
+  const symbol = future?.symbol ?? (pair && !pair.ambiguous ? pair.symbol : typed);
   const literal = resolveTickerSymbol(symbol, options, pickListing ? requested : null);
-  const alternatives = pickListing ? [] : dottedVenueQueries(symbol);
+  const alternatives = pickListing ? [] : [...dottedVenueQueries(symbol), ...pair?.ambiguous ? [pair.symbol] : []];
   // Most input has no venue code to retry: hand back the literal lookup
   // itself, so it settles no later than it did before the retry existed.
   if (alternatives.length === 0) return literal;

package/src/tickers/search/ranking.ts

@@ -649,6 +649,23 @@ function scoreSearchAlias(intent: SearchQueryIntent, alias: string): number {
   return score;
 }
 
+/**
+ * Whether the query is, letter for letter, one of the codes the server sent an
+ * index with: IBOV and "IBOV Index" for ^BVSP. A code is how that index is
+ * typed (the symbol itself carries a caret nobody types), so the index answers
+ * to it as to an exact symbol. Only an index does: a stock or a fund named by a
+ * code keeps the rank its own symbol gives it.
+ */
+export function answersToIndexCode(
+  item: Pick<TickerSearchRankableItem, "searchAliases" | "instrumentType">,
+  query: string,
+): boolean {
+  const code = (text: string) => text.trim().replace(/\s+/g, " ").toUpperCase();
+  const typed = code(query);
+  return !!typed && normalizeSearchText(item.instrumentType ?? "") === "INDEX"
+    && !!item.searchAliases?.some((alias) => code(alias) === typed);
+}
+
 function scoreSymbolMatchRank(
   intent: SearchQueryIntent,
   item: Pick<TickerSearchRankableItem, "label"> & Partial<TickerSearchRankableItem>,
@@ -656,6 +673,8 @@ function scoreSymbolMatchRank(
   if (normalizeTickerSymbol(item.symbol || item.label) === normalizeTickerSymbol(intent.rawQuery)) return 4;
   if (isQualifiedTickerQuery(intent.rawQuery)) return matchesQualifiedTicker(item, intent.rawQuery) ? 4 : 0;
   if (parsePublicTickerKey(item.symbol || item.label).symbol === normalizeTickerSymbol(intent.rawQuery)) return 4;
+  // Below a real symbol of that name (SPX Technologies), above every partial match (IBOV11).
+  if (answersToIndexCode(item, intent.rawQuery)) return 2;
   if (isCryptoInstrumentType(item.instrumentType)) return 0;
   if (isExplicitMarketSymbol(item.symbol || item.label)) return 0;
   if (!intent.normalizedQuery && !intent.compactQuery) return 0;

package/src/time-series/chart-data.ts

@@ -139,6 +139,8 @@ export function liveQuoteObservation(
 ): LiveQuoteObservation | null {
   if (!quote || isQuoteStaleForCurrentSession(quote, quoteObservationNow(quote, now))) return null;
   if (hasUnknownBondHistoryBasis(quote, assetCategory)) return null;
+  // No history covers the overnight session: its prices form or move no bar.
+  if (quote.overnightPrice != null) return null;
   const quoteTime = quote.lastUpdated;
   const quotePrice = getActiveQuotePrice(quote);
   if (

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

@@ -1,13 +1,20 @@
-import type { PricePoint } from "../types/financials";
+import type { PricePoint, QuoteMetadata } from "../types/financials";
 import type { PriceHistoryResult } from "../types/price-history";
 import type { InstrumentRef } from "../market-data/request-types";
 import { instrumentIdentityKey } from "../utils/instrument-identity";
 import type { TimeRange } from "./range";
-import type { ManualChartResolution } from "./resolution";
+import type { ChartResolutionSupport, ManualChartResolution } from "./resolution";
 
 const MAX_PARSED_HISTORY = 32;
 const parsedHistory = new Map<string, PriceHistoryResult>();
 
+function listingKey(instrument: InstrumentRef): string {
+  return instrumentIdentityKey({ ...instrument,
+    brokerId: instrument.brokerId ?? instrument.instrument?.brokerId,
+    brokerInstanceId: instrument.brokerInstanceId ?? instrument.instrument?.brokerInstanceId,
+  });
+}
+
 export function parsedPriceHistoryKey(
   instrument: InstrumentRef,
   range: TimeRange,
@@ -15,15 +22,38 @@ export function parsedPriceHistoryKey(
 ): string {
   // This is an in-memory seed cache. Never reuse earlier symbol-only keys:
   // their observations may have come from a different broker contract.
-  return JSON.stringify([
-    "parsed-history-v2",
-    instrumentIdentityKey({ ...instrument,
-      brokerId: instrument.brokerId ?? instrument.instrument?.brokerId,
-      brokerInstanceId: instrument.brokerInstanceId ?? instrument.instrument?.brokerInstanceId,
-    }),
-    range,
-    resolution ?? "",
-  ]);
+  return JSON.stringify(["parsed-history-v2", listingKey(instrument), range, resolution ?? ""]);
+}
+
+/**
+ * What a settled chart learned about a listing that its cached bars do not
+ * carry: the quote's currency and instrument type, and the intervals its
+ * source serves. A seed drawn without them labels its axes without units and
+ * offers placeholder intervals, so the settled chart that replaces it a
+ * moment later moves the plot and redraws every label.
+ */
+interface SeedListingFacts {
+  quoteMetadata?: QuoteMetadata;
+  resolutionSupport?: ChartResolutionSupport[];
+}
+
+const MAX_LISTING_FACTS = 64;
+const listingFacts = new Map<string, SeedListingFacts>();
+
+export function rememberSeedListingFacts(instrument: InstrumentRef, facts: SeedListingFacts): void {
+  const key = listingKey(instrument);
+  const merged = { ...listingFacts.get(key), ...facts };
+  listingFacts.delete(key);
+  listingFacts.set(key, merged);
+  while (listingFacts.size > MAX_LISTING_FACTS) {
+    const oldest = listingFacts.keys().next().value;
+    if (oldest === undefined) break;
+    listingFacts.delete(oldest);
+  }
+}
+
+export function readSeedListingFacts(instrument: InstrumentRef): SeedListingFacts | undefined {
+  return listingFacts.get(listingKey(instrument));
 }
 
 export function rememberParsedPriceHistory(