gloomberb 0.18.0 → 0.18.2

package/src/sync/core-contributors.ts

@@ -1,4 +1,5 @@
 import { scheduleConfigSave } from "../state/config-save-scheduler";
+import { normalizeStoredBaseCurrency } from "../utils/base-currency";
 import { debugLog } from "../utils/debug-log";
 import { fnv1aHex, stableStringify } from "../utils/hash";
 import type { AppConfig, BrokerInstanceConfig, SavedLayout } from "../types/config";
@@ -39,6 +40,16 @@ import {
   knownBrokerHoldings,
   type KnownBrokerHoldings,
 } from "../brokers/broker-portfolio-sync";
+import {
+  isLocalOnlyInstance,
+  isLocalOnlyPortfolio,
+  localOnlyScope,
+  publicConfig,
+  publicMarketData,
+  publicTickers,
+  withLocalOnlyEntries,
+  type LocalOnlyScope,
+} from "./local-only";
 
 /**
  * What a saved layout mirrors from the live session rather than from the
@@ -264,6 +275,7 @@ function sanitizePosition(position: TickerPosition): TickerPosition {
     avgCost: position.avgCost,
     currency: position.currency,
     dateAcquired: position.dateAcquired,
+    ...(position.costFxRate != null && position.costFxCurrency ? { costFxRate: position.costFxRate, costFxCurrency: position.costFxCurrency } : {}),
     broker: position.broker,
     side: position.side,
     marketValue: position.marketValue,
@@ -611,9 +623,11 @@ function collectCoreCollectionsPayload(
   financials: Map<string, TickerFinancials>,
   exchangeRates: Map<string, number>,
   brokerAccounts: Record<string, BrokerAccount[]>,
+  /** The financials whose quotes may be uploaded: without those a source that keeps its market data local supplied. */
+  quoted: Map<string, TickerFinancials> = financials,
 ) {
   const records = [...tickers.values()]
-    .map((ticker) => sanitizeTickerMetadata(ticker.metadata, financials.get(ticker.metadata.ticker)))
+    .map((ticker) => sanitizeTickerMetadata(ticker.metadata, quoted.get(ticker.metadata.ticker)))
     .filter(isSyncableTicker);
 
   // Only the USD anchor goes on the wire, as before: readers of the snapshot
@@ -872,14 +886,38 @@ interface LayoutMergeContext {
   pushedAt?: string;
 }
 
+/** A pulled config without profiles and portfolios that are local-only here (an older build may have pushed them). */
+function publicConfigPayload(payload: Record<string, unknown>, scope: LocalOnlyScope): Record<string, unknown> {
+  const without = (entries: unknown, isLocal: (entry: Record<string, unknown>) => boolean) => (
+    Array.isArray(entries) ? entries.filter((entry) => !isRecord(entry) || !isLocal(entry)) : entries
+  );
+  return {
+    ...payload,
+    ...("brokerInstances" in payload ? { brokerInstances: without(payload.brokerInstances, (entry) => isLocalOnlyInstance({ id: String(entry.id) }, scope)) } : {}),
+    ...("portfolios" in payload ? { portfolios: without(payload.portfolios, (entry) => isLocalOnlyPortfolio(entry as unknown as Portfolio, scope)) } : {}),
+  };
+}
+
 function mergeConfigPayload(
   config: AppConfig,
   payload: unknown,
   baselineConfig: AppConfig = config,
   lastSyncedPayload?: unknown,
   layoutContext: LayoutMergeContext = {},
+  scope: LocalOnlyScope | null = null,
 ): AppConfig | null {
   if (!isRecord(payload)) return null;
+  if (scope) {
+    // Merged as if the local-only profiles and portfolios were not here, then put back as they were.
+    const local = publicConfig(config, scope);
+    const merged = mergeConfigPayload(local, publicConfigPayload(payload, scope), baselineConfig === config ? local : publicConfig(baselineConfig, scope),
+      lastSyncedPayload, layoutContext);
+    return merged && {
+      ...merged,
+      brokerInstances: withLocalOnlyEntries(merged.brokerInstances, config.brokerInstances, (instance) => isLocalOnlyInstance(instance, scope)),
+      portfolios: withLocalOnlyEntries(merged.portfolios, config.portfolios, (portfolio) => isLocalOnlyPortfolio(portfolio, scope)),
+    };
+  }
   const next: AppConfig = { ...config };
   // Two guards, both needed. baselineConfig catches edits made while this pull
   // was in flight; lastSyncedPayload catches edits made while the app was not
@@ -899,6 +937,8 @@ function mergeConfigPayload(
   };
 
   assign("baseCurrency");
+  // A device on an older version may still send a name or sign (Canadian dollar, CA$): it applies as its code, as a saved one loads.
+  if (typeof next.baseCurrency === "string" && next.baseCurrency.trim()) next.baseCurrency = normalizeStoredBaseCurrency(next.baseCurrency);
   assign("refreshIntervalMinutes");
   if ("portfolios" in payload && canApply("portfolios")) {
     const syncedPortfolios = payload.portfolios;
@@ -1147,6 +1187,8 @@ interface PulledTickersMerge {
   /** This device's live broker portfolios, each with the side holding its latest broker sync. */
   brokerPortfolios: ReadonlyMap<string, "local" | "pulled">;
   known: KnownBrokerHoldings;
+  /** Connections kept on this device: their portfolios' holdings here outlast any pull. */
+  localOnly: LocalOnlyScope | null;
 }
 
 /**
@@ -1223,7 +1265,7 @@ function mergePulledTicker(
   const portfolios: string[] = [];
   for (const portfolioId of portfolioIds) {
     const brokerSide = merge.brokerPortfolios.get(portfolioId);
-    const takePulled = brokerSide
+    const takePulled = merge.localOnly?.portfolioIds.has(portfolioId) ? false : brokerSide
       ? brokerSide === "pulled"
       : !comparable || sameAsStored(
         holdingIn(localPositions, localLinks, portfolioId),
@@ -1268,7 +1310,7 @@ export const coreConfigSyncContributor: SyncContributor = {
   id: CORE_CONFIG_CONTRIBUTOR_ID,
   schemaVersion: 1,
   collect: ({ state, baselinePayload, memo }) => withLayoutProvenance(
-    collectCoreConfigPayload(state.config) as Record<string, unknown>,
+    collectCoreConfigPayload(publicConfig(state.config, localOnlyScope(state.config))) as Record<string, unknown>,
     baselinePayload,
     memo?.get(),
   ),
@@ -1281,7 +1323,7 @@ export const coreConfigSyncContributor: SyncContributor = {
     const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload, {
       memo: memo?.get(),
       pushedAt,
-    });
+    }, localOnlyScope(state.config));
     if (!nextConfig) return;
     const configChanged = !valuesEqual(nextConfig, state.config);
     if (configChanged) {
@@ -1327,15 +1369,24 @@ export const coreConfigSyncContributor: SyncContributor = {
 export const coreCollectionsSyncContributor: SyncContributor = {
   id: "core.collections",
   schemaVersion: 1,
-  collect: async ({ state }) => collectCoreCollectionsPayload(
-    state.config,
-    state.tickers,
-    state.financials,
-    await loadHoldingExchangeRates(state.config, state.tickers, state.financials),
-    state.brokerAccounts,
-  ),
+  collect: async ({ state, isLocalMarketData }) => {
+    // Connections the user keeps on this device stay here, with their portfolios, account values and
+    // positions; so do the quotes and bars of a source that keeps its market data local.
+    const scope = localOnlyScope(state.config);
+    const config = publicConfig(state.config, scope);
+    const tickers = publicTickers(state.tickers, scope);
+    return collectCoreCollectionsPayload(
+      config,
+      tickers,
+      state.financials,
+      await loadHoldingExchangeRates(config, tickers, state.financials),
+      state.brokerAccounts,
+      publicMarketData(state.financials, isLocalMarketData),
+    );
+  },
   apply: async (payload, { snapshot, baselinePayload, baselineState, getState, isCurrent, dispatch, tickerRepository }) => {
     if (!isRecord(payload)) return;
+    const scope = localOnlyScope(getState().config);
     hydrateProfileAnalytics(payload);
     if (!isCurrent()) return;
     // The config contributor applies first, so this is the config this pull left.
@@ -1355,6 +1406,7 @@ export const coreCollectionsSyncContributor: SyncContributor = {
         portfolios: [pulledPortfolios, pulledConfig?.portfolios].flatMap(idEntries),
         brokerInstances: idEntries(pulledConfig?.brokerInstances),
       }),
+      localOnly: scope,
     };
     // Tickers here and pulled ones drop the ids of any watchlist that is gone
     // (removed elsewhere, or deleted by an older build that left its id on the

package/src/sync/local-only.ts

@@ -0,0 +1,121 @@
+import type { AppConfig, BrokerInstanceConfig } from "../types/config";
+import type { Quote, TickerFinancials } from "../types/financials";
+import type { BrokerContractRef } from "../types/instrument";
+import type { Portfolio, TickerPosition, TickerRecord } from "../types/ticker";
+
+/**
+ * Broker connections the user keeps on this device (`BrokerInstanceConfig.localOnly`), and the
+ * portfolios of their accounts. Cloud sync leaves the connections, those portfolios with their
+ * account values, and the positions held in them out of every push, and keeps them through every
+ * pull, so nothing of them reaches Gloom Cloud and a pull never removes them here.
+ */
+export interface LocalOnlyScope {
+  instanceIds: ReadonlySet<string>;
+  portfolioIds: ReadonlySet<string>;
+}
+
+/**
+ * Whether a source keeps the quotes and bars it supplies on this device (`BrokerAdapter.localMarketData`),
+ * by its provider id: a broker's is its broker id.
+ */
+export type LocalMarketDataLookup = (providerId: string) => boolean;
+
+/** The connections the user keeps on this device, or null when there are none. */
+export function localOnlyScope(config: Pick<AppConfig, "brokerInstances" | "portfolios">): LocalOnlyScope | null {
+  const instanceIds = new Set(config.brokerInstances.flatMap((instance) => instance.localOnly === true ? [instance.id] : []));
+  if (instanceIds.size === 0) return null;
+  const scope = { instanceIds, portfolioIds: new Set<string>() };
+  return { instanceIds, portfolioIds: new Set(config.portfolios.flatMap((portfolio) => isLocalOnlyPortfolio(portfolio, scope) ? [portfolio.id] : [])) };
+}
+
+export function isLocalOnlyInstance(instance: Pick<BrokerInstanceConfig, "id">, scope: LocalOnlyScope): boolean {
+  return scope.instanceIds.has(instance.id);
+}
+
+export function isLocalOnlyPortfolio(portfolio: Pick<Portfolio, "id" | "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return scope.portfolioIds.has(portfolio.id) || !!portfolio.brokerInstanceId && scope.instanceIds.has(portfolio.brokerInstanceId)
+    // A pulled portfolio has no profile id; its own id names the profile.
+    || [...scope.instanceIds].some((id) => portfolio.id.startsWith(`broker:${id}:`));
+}
+
+function isLocalOnlyPosition(position: Pick<TickerPosition, "portfolio" | "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return scope.portfolioIds.has(position.portfolio) || !!position.brokerInstanceId && scope.instanceIds.has(position.brokerInstanceId);
+}
+
+function isLocalOnlyContract(contract: Pick<BrokerContractRef, "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return !!contract.brokerInstanceId && scope.instanceIds.has(contract.brokerInstanceId);
+}
+
+/** The config as Cloud sync may see it: without the connections kept on this device and their portfolios. */
+export function publicConfig<T extends Pick<AppConfig, "brokerInstances" | "portfolios">>(config: T, scope: LocalOnlyScope | null): T {
+  if (!scope) return config;
+  const brokerInstances = config.brokerInstances.filter((instance) => !isLocalOnlyInstance(instance, scope));
+  const portfolios = config.portfolios.filter((portfolio) => !isLocalOnlyPortfolio(portfolio, scope));
+  if (brokerInstances.length === config.brokerInstances.length && portfolios.length === config.portfolios.length) return config;
+  return { ...config, brokerInstances, portfolios };
+}
+
+/** The ticker as Cloud sync may see it: without positions, portfolios or contracts of connections kept on this device. */
+function publicTicker(ticker: TickerRecord, scope: LocalOnlyScope | null): TickerRecord {
+  if (!scope) return ticker;
+  const { metadata } = ticker;
+  const positions = metadata.positions.filter((position) => !isLocalOnlyPosition(position, scope));
+  const portfolios = metadata.portfolios.filter((id) => !scope.portfolioIds.has(id));
+  const contracts = metadata.broker_contracts?.filter((contract) => !isLocalOnlyContract(contract, scope));
+  if (positions.length === metadata.positions.length && portfolios.length === metadata.portfolios.length
+    && contracts?.length === metadata.broker_contracts?.length) return ticker;
+  return { ...ticker, metadata: { ...metadata, positions, portfolios, ...(contracts ? { broker_contracts: contracts } : {}) } };
+}
+
+export function publicTickers(tickers: Map<string, TickerRecord>, scope: LocalOnlyScope | null): Map<string, TickerRecord> {
+  if (!scope) return tickers;
+  return new Map([...tickers].map(([symbol, ticker]) => [symbol, publicTicker(ticker, scope)]));
+}
+
+/** The quote fields sync uploads, any of which a source that keeps its market data local may have supplied. */
+const SYNCED_QUOTE_FIELDS = ["price", "change", "changePercent", "previousClose"] as const;
+
+function isLocalQuote(quote: Quote, isLocal: LocalMarketDataLookup): boolean {
+  const provenance = quote.provenance;
+  const providers = [quote.providerId, provenance?.price?.providerId, ...SYNCED_QUOTE_FIELDS.map((field) => provenance?.fields?.[field]?.providerId)];
+  return providers.some((providerId) => !!providerId && isLocal(providerId));
+}
+
+/** The provider of stored bars, from their source key: `provider:<id>` or `broker:<broker id>:<profile>`. */
+function historyProvider(sourceKey: string | undefined): string | null {
+  const [kind, id] = sourceKey?.split(":") ?? [];
+  return (kind === "provider" || kind === "broker") && id ? id : null;
+}
+
+/**
+ * Financials as Cloud sync may upload them: without a quote or bars a source that keeps its market
+ * data local supplied. Sync reads only the quote and the week's move from them.
+ */
+export function publicMarketData(financials: Map<string, TickerFinancials>, isLocal?: LocalMarketDataLookup): Map<string, TickerFinancials> {
+  if (!isLocal) return financials;
+  const output = new Map<string, TickerFinancials>();
+  for (const [symbol, entry] of financials) {
+    const localQuote = !!entry.quote && isLocalQuote(entry.quote, isLocal);
+    const provider = historyProvider(entry.priceHistorySourceKey);
+    const localBars = !!provider && isLocal(provider);
+    output.set(symbol, localQuote || localBars ? { ...entry, ...(localQuote ? { quote: undefined } : {}), ...(localBars ? { priceHistory: [] } : {}) } : entry);
+  }
+  return output;
+}
+
+/**
+ * `merged` (a list merged without the local-only entries) with this device's local-only entries
+ * of `local` back where they were: each stays at its place among the others, so an unchanged list
+ * comes back equal to `local`. An entry the pull brought that is local-only here is left out.
+ */
+export function withLocalOnlyEntries<T>(merged: readonly T[], local: readonly T[], isLocalOnly: (entry: T) => boolean): T[] {
+  const incoming = merged.filter((entry) => !isLocalOnly(entry));
+  const output: T[] = [];
+  let next = 0;
+  for (const entry of local) {
+    if (isLocalOnly(entry)) output.push(entry);
+    else if (next < incoming.length) output.push(incoming[next++]!);
+  }
+  output.push(...incoming.slice(next));
+  return output;
+}

package/src/sync/react.ts

@@ -41,6 +41,12 @@ export function useCloudSyncRuntime({
       baselineStore,
       getContributors: () => pluginRegistry.getEnabledSyncContributors(),
       getTransport: () => pluginRegistry.getActiveSyncTransport(),
+      isLocalMarketData: (providerId) => {
+        const broker = pluginRegistry.brokers.get(providerId);
+        if (broker) return broker.localMarketData === true;
+        // A broker whose plugin is off may still have its quotes about from before; they stay here too.
+        return getState().config.brokerInstances.some((instance) => instance.brokerType === providerId);
+      },
     });
   }, [baselineStore, dispatch, getState, pluginRegistry, tickerRepository]);
 

package/src/sync/types.ts

@@ -1,6 +1,7 @@
 import type { Dispatch } from "react";
 import type { AppAction, AppState } from "../core/state/app/state";
 import type { AppTickerRepositoryPort } from "../core/app-service-ports";
+import type { LocalMarketDataLookup } from "./local-only";
 
 export const SYNC_SNAPSHOT_SCHEMA_VERSION = 1;
 
@@ -31,6 +32,8 @@ interface SyncContributorMemo {
 
 interface SyncCollectContext {
   state: AppState;
+  /** Sources whose quotes and bars never leave this device (`BrokerAdapter.localMarketData`); none when absent. */
+  isLocalMarketData?: LocalMarketDataLookup;
   /** The payload this device last pushed for this contributor, or null when it never synced. */
   baselinePayload?: unknown;
   memo?: SyncContributorMemo;

package/src/team/collections.ts

@@ -174,6 +174,8 @@ export function applyMembership(
       currency: position?.currency ?? currency,
       broker: "manual",
       ...(!flipped && position?.dateAcquired ? { dateAcquired: position.dateAcquired } : {}),
+      // So does the rate its cost was bought at, with its cost.
+      ...(!flipped && position?.costFxRate != null && position.costFxCurrency ? { costFxRate: position.costFxRate, costFxCurrency: position.costFxCurrency } : {}),
       // A future's contract size stays with the holding when the team changes its count.
       ...(position?.multiplier ? { multiplier: position.multiplier } : {}),
     });

package/src/tickers/listing-fate.ts

@@ -19,6 +19,7 @@ import { isQuoteBeforeLatestSession, isQuoteStaleForCurrentSession } from "../ma
 import { formatMarketPriceWithCurrency, quoteFormatOptions } from "../market-data/market/format";
 import { canonicalExchange, isUsListingExchange, parsePublicTickerKey, resolveExchangeTimeZone } from "../utils/exchanges";
 import { zonedDateKey } from "../utils/zoned-date-time";
+import { delistingLabel } from "../market-data/quotes/delisting";
 
 /*
  * What became of a symbol, read the way `quote` reads it: the listing's own
@@ -33,8 +34,10 @@ const ENDED_AFTER_MS = 183 * 24 * 60 * 60_000;
 /**
  * The exchange-local date a listing last traded, when its quote is stale and
  * that was over half a year ago (TWTR's 2022-10-27); null for anything newer.
+ * A quote that says its listing no longer trades gives its last session.
  */
 function endedTradingDate(quote: Quote, now = Date.now()): string | null {
+  if (quote.delisting) return quote.delisting.lastTradeDate;
   const last = Math.max(...[quote.lastTradeTime, quote.lastUpdated].filter((time): time is number => Number.isFinite(time)));
   if (!(last > 0) || now - last < ENDED_AFTER_MS || !isQuoteStaleForCurrentSession(quote, now)) return null;
   return quoteDateKey(quote, last);
@@ -60,12 +63,18 @@ export function tradingListing(quote: Quote | null | undefined, now = Date.now()
   return quote && !endedTradingDate(quote, now) ? quotedListing(quote) : null;
 }
 
-/** "TWTR: no longer trading since 2022-10-27 (last price $53.86)", for a quote that stopped long ago. */
+/**
+ * "TWTR: no longer trading since 2022-10-27 (last price $53.86)", for a quote
+ * that stopped long ago; "TWTR: Delisted Oct 27, 2022 (last price $53.86)"
+ * when the quote says the listing no longer trades.
+ */
 export function noLongerTradingNote(label: string, quote: Quote, now = Date.now()): string | null {
   const date = endedTradingDate(quote, now);
   if (!date) return null;
   const price = formatMarketPriceWithCurrency(quote.price, quote.currency, quoteFormatOptions(quote));
-  return `${label}: no longer trading since ${date} (last price ${price})`;
+  return quote.delisting
+    ? `${label}: ${delistingLabel(quote.delisting)} (last price ${price})`
+    : `${label}: no longer trading since ${date} (last price ${price})`;
 }
 
 /**
@@ -81,11 +90,17 @@ export interface ListingFate {
   /**
    * The line a command with nothing to serve for the symbol says: `quote`'s
    * change line when its company left it ("FB now lists ...; Meta Platforms
-   * trades as META (changed 2022-06-09)"), else, for a listing that stopped,
-   * "TWTR stopped trading 2022-10-27; no history or options served". Null
-   * for a symbol that trades as it always has.
+   * trades as META (changed 2022-06-09)"), else, for a listing the service
+   * says no longer trades, "TWTR: Delisted Oct 27, 2022", and for another
+   * that stopped, "XYZ stopped trading 2022-10-27; no history or options
+   * served". Null for a symbol that trades as it always has.
    */
   note: string | null;
+  /**
+   * "TWTR: Delisted Oct 27, 2022" when the listing's quote says it no longer
+   * trades: its history is served, ending on that session, and says so.
+   */
+  delisted?: string;
   /**
    * The change when the symbol's company trades under another symbol now
    * and its own quote shows nothing new listed under it (`movedAwayChange`):
@@ -156,9 +171,10 @@ export function describeListingFate(
   const abroad = !!quote && !!bareListingNote({ symbol, request: { exchange: listing.exchange ?? "" } }, quote);
   const current = tradingListing(quote, now);
   const change = abroad ? null : describeTickerChange(symbol, changes, current);
-  const note = tickerChangeLine(change) ?? (endedOn ? `${symbol} stopped trading ${endedOn}; no history or options served` : null);
+  const delisted = quote?.delisting && !abroad ? `${symbol}: ${delistingLabel(quote.delisting)}` : undefined;
+  const note = tickerChangeLine(change) ?? delisted ?? (endedOn ? `${symbol} stopped trading ${endedOn}; no history or options served` : null);
   const formerIssuer = abroad ? null : describeFormerIssuer(symbol, changes, current);
-  return { endedOn, change, note, moved: quote ? movedAwayChange(change) : null, formerIssuer };
+  return { endedOn, change, note, moved: quote ? movedAwayChange(change) : null, formerIssuer, ...(delisted ? { delisted } : {}) };
 }
 
 /**
@@ -200,7 +216,8 @@ export async function loadListingFate(
 
 /**
  * The lines a command says about a symbol's fate beside what it served. With
- * nothing served, `fate.note`. With data, `quote`'s change line when the
+ * nothing served, `fate.note`. With data, `fate.delisted` for a listing that
+ * no longer trades ("TWTR: Delisted Oct 27, 2022"), `quote`'s change line when the
  * symbol's company left it (FB's bars are the fund listed there now), and, for
  * bars from before the symbol's holder took it (META's from 2021), that they
  * are from its old symbol: "Includes FB-era bars: META was FB until 2022-06-09".
@@ -211,6 +228,8 @@ export function listingFateNotes(fate: ListingFate, served: { served: boolean; f
   const first = served.firstDate?.slice(0, 10);
   const earlier = change?.kind === "formerly" && first ? change.changes.filter((hop) => first < hop.date).map((hop) => hop.from) : [];
   return [
+    // What it served ends on the listing's last session, and says so.
+    fate.delisted ?? null,
     tickerChangeLine(change),
     earlier.length > 0 ? `Includes ${earlier.join("- and ")}-era bars: ${change!.note}` : null,
   ].filter((line): line is string => !!line);

package/src/tickers/metadata.ts

@@ -9,6 +9,15 @@ const DEFAULT_TICKER_METADATA: Omit<TickerMetadata, "ticker" | "exchange" | "cur
   tags: [],
 };
 
+/** A lot's cost FX rate, kept only whole: a positive rate and the currency it converts into. */
+function hydrateCostFx(raw: Record<string, unknown>): Pick<TickerPosition, "costFxRate" | "costFxCurrency"> {
+  const rate = raw.costFxRate ?? raw.cost_fx_rate;
+  const currency = raw.costFxCurrency ?? raw.cost_fx_currency;
+  return typeof rate === "number" && Number.isFinite(rate) && rate > 0 && typeof currency === "string" && currency.trim()
+    ? { costFxRate: rate, costFxCurrency: currency.trim() }
+    : {};
+}
+
 function hydratePosition(raw: Record<string, unknown>): TickerPosition {
   const avgCost = Object.hasOwn(raw, "avgCost") ? raw.avgCost : raw.avg_cost;
   return {
@@ -18,6 +27,7 @@ function hydratePosition(raw: Record<string, unknown>): TickerPosition {
     priceBasis: raw.priceBasis === "per-unit" || raw.priceBasis === "percent-of-par" ? raw.priceBasis : undefined,
     currency: (raw.currency as string) ?? undefined,
     dateAcquired: (raw.dateAcquired ?? raw.date_acquired) as string | undefined,
+    ...hydrateCostFx(raw),
     broker: (raw.broker as string) ?? "manual",
     side: (raw.side as "long" | "short") ?? undefined,
     marketValue: (raw.marketValue ?? raw.market_value) as number | undefined,

package/src/tickers/search/index.ts

@@ -38,6 +38,7 @@ import { readTerminalListingCode } from "../terminal-codes";
 import { isProviderBusy, ProviderBusyError, SEARCH_BUSY_MESSAGE } from "../../sources/provider-errors";
 import { settleWithin } from "../../utils/async-deadline";
 import { companyNameExtraWords } from "../company-name";
+import { delistingLabel } from "../../market-data/quotes/delisting";
 export type {
   ResolvedTickerSearch,
   TickerSearchCandidate,
@@ -58,6 +59,17 @@ const MAX_NAMED_LISTINGS = 6;
  */
 export const LISTING_SEARCH_LIMIT = 30;
 
+/**
+ * A listing's name as a choice between listings gives it: a listing that no
+ * longer trades says so and when ("First Republic Bank · Last traded Apr 28,
+ * 2023"), and drops a name that only repeats its symbol.
+ */
+function listingChoiceName(result: InstrumentSearchResult): string {
+  if (!result.delisting) return result.name;
+  const name = result.name && normalizeTickerSymbol(result.name) !== normalizeTickerSymbol(result.symbol) ? result.name : "";
+  return [name, delistingLabel(result.delisting)].filter(Boolean).join(" · ");
+}
+
 export class AmbiguousTickerError extends Error {
   constructor(readonly query: string, readonly listings: readonly string[], readonly listingNames: Readonly<Record<string, string>> = {}) {
     // Every listing is a choice: a list cut short could leave out the one meant.
@@ -467,7 +479,7 @@ async function resolveTickerSymbol(
   }
   const listings = new Set(matches.map((item) => publicTickerKey(item.symbol, listingExchange(item.result!))));
   const ambiguity = (query: string) => new AmbiguousTickerError(query, [...listings], Object.fromEntries(matches.map((item) => [
-    publicTickerKey(item.symbol, listingExchange(item.result!)), item.result!.name,
+    publicTickerKey(item.symbol, listingExchange(item.result!)), listingChoiceName(item.result!),
   ])));
   if (pickerQuery && listings.size > 1) throw ambiguity(pickerQuery);
   // A code that names several venues (TSE) the symbol trades on more than one of is a choice.
@@ -485,7 +497,12 @@ async function resolveTickerSymbol(
       });
       const exchange = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
       const currency = resolveCurrencyUnit(quote.currency).currency;
-      if (exchange && currency && Number.isFinite(quote.price) && quote.price !== 0
+      const ended = quote.delisting;
+      if (ended) {
+        // The symbol's own quote is a US listing that no longer trades (a bare FRC, whose
+        // venue is not on record): it is the run search offers with the same last session.
+        verified = matches.filter((item) => item.result?.delisting?.lastTradeDate === ended.lastTradeDate);
+      } else if (exchange && currency && Number.isFinite(quote.price) && quote.price !== 0
         && Number.isFinite(quote.lastUpdated) && quote.lastUpdated > 0) {
         const sameSecurity = matches.filter((item) => {
           const result = item.result!;
@@ -663,7 +680,11 @@ async function searchProviderResults(
 
   // A sector word ("defense", which the server answers with rows tagged with it) lists its small companies by
   // name; the server orders "defense ETF" by size, which a name search does not. Those funds lead the list.
-  const theme = withThemeFunds && !assetClass ? themeQueryWord([...byKey.values()], query) : null;
+  // So do they when the funds are asked for by name: "defense etf" searches "defense", whose answer holds
+  // only the few funds tagged with it (not ITA), and "gold miners etf" a phrase no symbol is.
+  const fundsAsked = assetClass?.code === "ETF" || assetClass?.code === "FUND";
+  const theme = withThemeFunds && (!assetClass || fundsAsked)
+    && (themeQueryWord([...byKey.values()], query) || (fundsAsked && /\s/.test(query.trim())));
   if (theme) {
     try {
       const { onPartial: _ignored, ...context } = searchContext ?? {};

package/src/time-series/price-comparison.ts

@@ -123,6 +123,41 @@ export function resolvePriceComparison(
   };
 }
 
+/**
+ * The bars a compared leg pans and zooms over: inside the view only its shared
+ * dates, as the chart shows them, and every loaded bar past either edge of the
+ * view. Clipping the whole buffer to the view left a pan or a zoom out nothing
+ * to move into until the next fetch, and none at all toward newer bars.
+ */
+export function comparedBufferPoints(
+  points: readonly TimeSeriesPoint[],
+  shared: { start: number | null; end: number | null },
+  view: { start: number | null; end: number | null },
+): TimeSeriesPoint[] {
+  const { start, end } = shared;
+  if (start === null || end === null) return [];
+  const before = view.start === null ? Number.NEGATIVE_INFINITY : Math.min(start, view.start);
+  const after = view.end === null ? Number.POSITIVE_INFINITY : Math.max(end, view.end);
+  return points.filter((point) => {
+    const time = point.date.getTime();
+    return time < before || time > after || (time >= start && time <= end);
+  });
+}
+
+/** A compared leg's pan buffer around `view`; see comparedBufferPoints. */
+export function bufferPriceComparison(
+  series: ResolvedSeries,
+  comparison: PriceComparison | null,
+  view: { start: number | null; end: number | null },
+): ResolvedSeries {
+  if (!comparison?.seriesIds.includes(series.id)) return series;
+  return {
+    ...series,
+    latestChangePercent: undefined,
+    points: comparedBufferPoints(series.points, priceComparisonBoundsForSeries(series, comparison)!, view),
+  };
+}
+
 /** Clip only compared legs; raw observations and study inputs stay available in the source cache. */
 export function clipPriceComparison(series: ResolvedSeries, comparison: PriceComparison | null): ResolvedSeries {
   if (!comparison?.seriesIds.includes(series.id)) return series;