gloomberb 0.18.2 → 0.18.4

package/src/sources/provider-errors.ts

@@ -1,3 +1,5 @@
+import { DataServiceUnreachableError, isNetworkFailure } from "../utils/network-failure";
+
 // Registered, so a miss raised by another copy of this module (a plugin that
 // resolved `gloomberb/market-data` from the source tree) is still recognized.
 const PROVIDER_MISS_BRAND = Symbol.for("gloomberb.provider-miss");
@@ -44,6 +46,14 @@ export function createProviderMiss(message?: string, reason?: unknown, options?:
   return new ProviderMissError(message, reason, options);
 }
 
+/** A source has the listing's bars but not up to the present: it answered, just behind. */
+export class StaleHistoryError extends ProviderMissError {
+  constructor(message: string) {
+    super(message);
+    this.name = "StaleHistoryError";
+  }
+}
+
 function isProviderMiss(error: unknown): error is ProviderMissError {
   return error instanceof ProviderMissError
     || (!!error && typeof error === "object" && PROVIDER_MISS_BRAND in error);
@@ -129,12 +139,16 @@ class NoProviderError extends Error {
 /**
  * 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
- * listing exists for `symbol` ("Not a ticker"); a timeout or any other failure
- * keeps the generic message.
+ * listing exists for `symbol` ("Not a ticker"), and a request that never
+ * reached the data service, which says that rather than that no source has the
+ * symbol; a timeout or any other failure keeps the generic message.
  */
 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 });
+  if (isNetworkFailure(note?.failure)) {
+    return note!.failure instanceof DataServiceUnreachableError ? note!.failure : new DataServiceUnreachableError(note!.failure);
+  }
   return new NoProviderError(message, note?.failure);
 }
 

package/src/sources/provider-router/financial-routes.ts

@@ -16,6 +16,7 @@ import {
   sortCachedRecords,
 } from "./cache";
 import { noProviderError, type ProviderMissNote } from "../provider-errors";
+import { servedFromSavedCopy } from "../../data/saved-copies";
 import { withBrokerTimeout } from "./brokers";
 import {
   hasMeaningfulProfile,
@@ -166,7 +167,8 @@ export class ProviderRouterFinancialRoutes {
 
     if (cached.value) {
       const brokerResult = await withBrokerTimeout(this.deps.primaryRoutes.fetchBrokerFinancials(ticker, exchange, context));
-      const providerResult = await this.deps.primaryRoutes.fetchProviderFinancials(ticker, exchange, context);
+      const refresh: ProviderMissNote = {};
+      const providerResult = await this.deps.primaryRoutes.fetchProviderFinancials(ticker, exchange, context, refresh);
       const merged = mergeFinancials(
         brokerResult?.value ?? cached.brokerRecord?.value ?? null,
         context?.statementHistory === "extended"
@@ -176,7 +178,14 @@ export class ProviderRouterFinancialRoutes {
       if (isOptionTicker && !merged?.quote) {
         return quoteOnlyFinancials(merged ?? cached.value);
       }
-      return merged ?? cached.value;
+      const answer = merged ?? cached.value;
+      // The refresh failed and the saved copy answers: marked with when its
+      // oldest part was saved, and its quote too unless a broker's live one
+      // replaced it, since the quote is what a report's closing line dates.
+      const saved = cached.providerRecords?.map((record) => record.fetchedAt) ?? [];
+      return !providerResult && refresh.failure !== undefined && cached.providerValue && saved.length > 0
+        ? savedFinancials(answer, Math.min(...saved), !brokerResult?.value?.quote)
+        : answer;
     }
 
     const brokerResult = await withBrokerTimeout(this.deps.primaryRoutes.fetchBrokerFinancials(ticker, exchange, context));
@@ -229,7 +238,10 @@ export class ProviderRouterFinancialRoutes {
     if (providerQuote) {
       return providerQuote.value;
     }
-    if (cached) return cached.value;
+    if (cached) {
+      // The refresh failed rather than finding nothing newer: the saved copy answers, and says so.
+      return misses.failure !== undefined ? servedFromSavedCopy(cached.value, cached.fetchedAt) : cached.value;
+    }
     // No source has a current quote: the last price one answered with, flagged
     // stale and dated by its own time, rather than none.
     if (misses.lastKnownQuote) return misses.lastKnownQuote;
@@ -363,3 +375,9 @@ export class ProviderRouterFinancialRoutes {
     return this.readCachedMergedFinancialsSelection(ticker, exchange, context, allowExpired, options).value;
   }
 }
+
+/** Financials as served from their saved copy, with their quote when it is the saved one. */
+function savedFinancials(value: TickerFinancials, savedAt: number, savedQuote: boolean): TickerFinancials {
+  const served = servedFromSavedCopy(value, savedAt);
+  return savedQuote && served.quote ? { ...served, quote: servedFromSavedCopy(served.quote, savedAt) } : served;
+}

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

@@ -1,5 +1,5 @@
 import type { CachedResourceRecord, ResourceStore } from "../../data/resource-store";
-import type { AnalystResearchData, CorporateActionsData, FinancialStatement, Fundamentals, Quote, TickerFinancials } from "../../types/financials";
+import type { AnalystResearchData, CompanyProfile, CorporateActionsData, FinancialStatement, Fundamentals, Quote, TickerFinancials } from "../../types/financials";
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
 import { coalesceFinancialPeriodAliases, mergeFinancialStatementRows } from "../../utils/financial-statements";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../../utils/price-history";
@@ -51,6 +51,19 @@ function isFundFinancials(financials: Pick<TickerFinancials, "quote" | "quoteMet
   return ["etf", "exchangetradedfund", "mutualfund", "fund"].includes(researchInstrumentType(financials) ?? "");
 }
 
+/**
+ * What a fund's profile keeps: its description, and where a quoted one is
+ * from with the fund's own page beside it. A provider's website for a fund is
+ * its manager's, not the fund's.
+ */
+function fundProfile(profile: CompanyProfile): CompanyProfile {
+  const source = profile.descriptionSource;
+  return {
+    description: profile.description,
+    ...(source ? { descriptionSource: source, ...(profile.website ? { website: profile.website } : {}) } : {}),
+  };
+}
+
 function excludeNonCompanyFinancials(financials: TickerFinancials): TickerFinancials {
   const type = researchInstrumentType(financials);
   if (!type || !["etf", "exchangetradedfund", "mutualfund", "fund", "index", "currency", "forex", "fx", "future", "futures", "cryptocurrency", "crypto", "digitalcurrency"].includes(type)) return financials;
@@ -71,7 +84,7 @@ function excludeNonCompanyFinancials(financials: TickerFinancials): TickerFinanc
       fetchedAt: statistics.fetchedAt,
       stale: statistics.stale,
     } : undefined,
-    profile: fund && financials.profile?.description ? { description: financials.profile.description } : undefined,
+    profile: fund && financials.profile?.description ? fundProfile(financials.profile) : undefined,
     nextEarnings: undefined,
     annualStatements: [],
     quarterlyStatements: [],

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

@@ -25,8 +25,9 @@ import { isRoundTheClockCoin } from "../../utils/crypto-pair";
 import { zonedDateKey } from "../../utils/zoned-date-time";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
 import { calendarHistoryFetchState, calendarHistoryLastBarDate, dropLeadingPlaceholderBars, getPricePointTimestamp, hasUsablePriceHistory, preservePriceHistoryGaps, isPriceHistoryStaleForCurrentWindow, normalizePriceHistory, priceHistoryIntervalMs, type CalendarHistoryFetchState } from "../../utils/price-history";
-import { noProviderError, noteProviderAnswer, noteProviderMiss, shouldLogProviderError, type ProviderMissNote } from "../provider-errors";
+import { noProviderError, noteProviderAnswer, noteProviderMiss, shouldLogProviderError, StaleHistoryError, type ProviderMissNote } from "../provider-errors";
 import { HistoryCoverageError } from "../history-coverage";
+import { servedFromSavedCopy } from "../../data/saved-copies";
 import {
   buildVariantKey,
   compactDate,
@@ -44,7 +45,9 @@ type PriceHistoryCachePolicyKey = Extract<
 >;
 // Bumped instead of adding markers: every older record is a miss and refetches.
 // Refetch source/session metadata under the current public backend contract.
-const PRICE_HISTORY_CACHE_VERSION = 7;
+// 8: copies saved while Gloom Cloud could serve bars on two split bases (NRDY
+// after its 1-for-15 reverse split of 19 Aug 2026) are not shown again.
+const PRICE_HISTORY_CACHE_VERSION = 8;
 interface HistoryRequestDescriptor {
   target: { symbol: string; exchange: string };
   identity: RouterRequestIdentity;
@@ -111,7 +114,10 @@ function candidateForRequest(request: HistoryRequestDescriptor, sourceKey: strin
 function recordHistoryError(attempts: HistoryAttempts | undefined, request: HistoryRequestDescriptor, sourceKey: string, error: unknown): void {
   if (!attempts) return;
   noteProviderMiss(attempts.misses, error);
-  if (error instanceof InvalidHistoryResultError) {
+  if (error instanceof StaleHistoryError) {
+    // It has the bars, only not up to the present: behind, as a stale copy it served would be.
+    recordHistoryOutcome(attempts, sourceKey, "stale");
+  } else if (error instanceof InvalidHistoryResultError) {
     recordHistoryOutcome(attempts, sourceKey, "malformed");
   } else if (isHistoryRetentionError(error)) {
     recordHistoryOutcome(attempts, sourceKey, "retention");
@@ -579,7 +585,21 @@ export class ProviderRouterHistoryRoutes {
     });
   }
 
+  /** The answer, named by the source that served it, so a caller can say which one did. */
   private async executeHistoryRequest(request: HistoryRequestDescriptor): Promise<PriceHistoryResult> {
+    const answer = await this.answerHistoryRequest(request);
+    const sourceName = answer.sourceKey ? this.sourceName(answer.sourceKey, request.context) : undefined;
+    return sourceName ? { ...answer, sourceName } : answer;
+  }
+
+  private sourceName(sourceKey: string, context?: MarketDataRequestContext): string | undefined {
+    const provider = this.deps.providersInPriorityOrder().find((candidate) => this.deps.providerSourceKey(candidate) === sourceKey);
+    if (provider) return provider.name;
+    return this.deps.getBrokerCandidatesForContext(context, false)
+      .find((candidate) => this.deps.brokerSourceKey(candidate) === sourceKey)?.broker.name;
+  }
+
+  private async answerHistoryRequest(request: HistoryRequestDescriptor): Promise<PriceHistoryResult> {
     const recovery = this.validateRecovery(request);
     const { first: brokerCandidates, last: regularSessionBrokers } = brokersForSession(
       recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false), request.context);
@@ -717,9 +737,9 @@ export class ProviderRouterHistoryRoutes {
       // from a current one: a thin listing's complete copy is not behind.
       const fallbackValue = request.isCachedValueStale(fallbackRecord.value, fallbackRecord.fetchedAt)
         ? { ...fallbackRecord.value, savedCopyBehind: true as const } : fallbackRecord.value;
-      return request.requestedRange
-        ? clip(withReportedGaps(fallbackValue))
-        : withReportedGaps(fallbackValue);
+      const answer = request.requestedRange ? clip(withReportedGaps(fallbackValue)) : withReportedGaps(fallbackValue);
+      // A refetch that failed, rather than one that found nothing newer, leaves the saved copy answering.
+      return attempts.misses.failure !== undefined ? servedFromSavedCopy(answer, fallbackRecord.fetchedAt) : answer;
     }
     if (coverageError) throw coverageError;
     if (attempts.coverageError) throw attempts.coverageError;
@@ -735,8 +755,10 @@ export class ProviderRouterHistoryRoutes {
       const behind = coin && [...attempts.outcomes.values()].some((outcome) => outcome.outcome === "stale");
       if (behind) throw new Error(`Latest history for ${target.symbol} is behind`);
       // A reason the service gave ("ADX listings have daily bars only.") says why; one that has no
-      // listing for the symbol says it is not a ticker; otherwise no source answered.
-      throw noProviderError(request.missingProviderError, attempts.misses, request.target.symbol);
+      // listing for the symbol says it is not a ticker; otherwise no source answered. A coin trades
+      // around the clock and its sources are there: they could not answer just now.
+      throw noProviderError(coin ? `No source could load history for ${request.target.symbol} just now` : request.missingProviderError,
+        attempts.misses, request.target.symbol);
     }
     return withReportedGaps(providerResult?.value ?? { points: [], resolution: historyResolutionForInterval(request.interval) });
   }

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

@@ -26,6 +26,7 @@ import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget
 import type { NewsArticle, NewsQuery } from "../../news/types";
 import type { BrokerContractRef, InstrumentSearchResult } from "../../types/instrument";
 import type { TickerChanges } from "../../types/ticker-changes";
+import type { IssuerListings } from "../../types/issuer-listings";
 import type { TimeRange } from "../../time-series/range";
 import type { ChartResolutionSupport, ManualChartResolution } from "../../time-series/resolution";
 import { debugLog } from "../../utils/debug-log";
@@ -317,6 +318,21 @@ export class AssetDataRouter implements DataProvider {
     return null;
   }
 
+  /** The first source that holds the company's listings; one that fails is passed over. */
+  async getIssuerListings(symbol: string, exchange?: string, options?: { signal?: AbortSignal }): Promise<IssuerListings | null> {
+    for (const provider of this.providersInPriorityOrder()) {
+      if (!provider.getIssuerListings) continue;
+      try {
+        const listings = await provider.getIssuerListings(symbol, exchange, options);
+        if (listings) return listings;
+      } catch (error) {
+        if (options?.signal?.aborted) return null;
+        logFailure("sources.provider-router.index", "Issuer listings failed")(error);
+      }
+    }
+    return null;
+  }
+
   async getEarningsCalendar(symbols: string[], context?: MarketDataRequestContext) {
     return this.supplementalRoutes.getEarningsCalendar(symbols, context);
   }

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

@@ -163,7 +163,7 @@ export class ProviderRouterPrimaryRoutes {
     const entityKey = this.options.getEntityKey(ticker, context?.instrument);
     const variantKey = this.options.getTickerVariantCandidates(exchange)[0] ?? "";
     for (const candidate of this.options.getBrokerCandidatesForContext(context, false)) {
-      if (!candidate.broker.getQuote) continue;
+      if (!candidate.broker.getQuote || candidate.broker.ticketQuotesOnly) continue;
       try {
         const result = await candidate.broker.getQuote(
           ticker,

package/src/state/app/bootstrap.ts

@@ -14,6 +14,8 @@ import { hasAmbiguousTickerContracts, resolveInstrumentForPane } from "../../cor
 import { getDockedPaneIds } from "../../layout/pane-manager";
 import { debugLog } from "../../utils/debug-log";
 import { measurePerf, measurePerfAsync } from "../../utils/perf-marks";
+import { mergeSavedSuffixedListings } from "../../portfolio/suffixed-listings";
+import { saveConfigImmediately } from "../config-save-scheduler";
 
 export const DEFAULT_WATCHLIST_TICKERS: Array<Pick<TickerMetadata, "ticker" | "exchange" | "currency" | "name">> = [
   { ticker: "AAPL", exchange: "NASDAQ", currency: "USD", name: "Apple Inc." },
@@ -253,6 +255,27 @@ export async function initializeAppState({
   let tickers = await measurePerfAsync("startup.load-tickers", () => tickerRepository.loadAllTickers());
   startupLog.info("tickers loaded", { count: tickers.length });
 
+  // A collection's rows under a vendor's suffixed key (GARAN.IS) merge into their listing's row (GARAN:BIST).
+  // The moved targets are written before the rows, so a stop in between strands none on an emptied key.
+  try {
+    const merged = await mergeSavedSuffixedListings(tickers, config, {
+      config: saveConfigImmediately,
+      tickers: async (rows) => {
+        for (const row of rows) await tickerRepository.saveTicker(row);
+      },
+    });
+    if (merged) {
+      tickers = merged.tickers;
+      startupLog.info("suffixed listing rows merged", { keptCustom: merged.keptCustom });
+      if (merged.config !== config) {
+        config = merged.config;
+        dispatch({ type: "SET_CONFIG", config });
+      }
+    }
+  } catch (error) {
+    startupLog.warn("suffixed listing merge failed", { message: error instanceof Error ? error.message : String(error) });
+  }
+
   // Seed default watchlist tickers on first run
   if (tickers.length === 0) {
     const defaultWatchlistId = config.watchlists[0]?.id ?? "watchlist";

package/src/state/hooks/inline-tickers.ts

@@ -84,6 +84,17 @@ function tickerKey(symbol: string): string {
   return listingKeys.get(symbol) ?? symbol;
 }
 
+/**
+ * Points a badge's symbol at the ticker its lookup settled on. A lookup that
+ * settles on a key other than the badge's own ($BRK-B on BRK.B, $TTF on TTF=F)
+ * must say so here: the next pass reads the badge's ticker under this key, and
+ * one that finds nothing asks again, gets the same answer and never stops.
+ */
+function pointBadgeAt(symbol: string, key: string): void {
+  if (key === symbol) listingKeys.delete(symbol);
+  else listingKeys.set(symbol, key);
+}
+
 /** The saved ticker a badge's symbol stands for: its own, or the listing its tag resolved to. */
 function badgeTicker(tickers: ReadonlyMap<string, TickerRecord>, symbol: string): TickerRecord | null {
   return tickers.get(tickerKey(symbol)) ?? null;
@@ -158,7 +169,11 @@ async function loadInlineQuotes(requests: Map<string, QuoteRequest>): Promise<vo
   // asks the provider directly.
   await Promise.all(batch.map(async ([symbol, { instrument, context }]) => {
     const provider = context.registry?.marketData;
-    if (!provider) return;
+    if (!provider) {
+      // Nobody to ask is an answer too: unrecorded, the next pass would ask again at once.
+      inlineTickerQuoteFailures.record(symbol, "error");
+      return;
+    }
     try {
       const quote = await provider.getQuote(
         instrument.symbol,
@@ -279,6 +294,8 @@ export function useInlineTickers(
   const textsKey = texts.join("\u0000");
   const symbols = useMemo(() => normalizeSymbols(texts), [textsKey]);
   const symbolsKey = symbols.join("|");
+  // A lookup can point a symbol at a saved ticker's key without changing any ticker.
+  const badgeKeys = symbols.map(tickerKey).join("|");
   const financialsEffectTarget = liveQuotes ? financials : null;
   const latestRef = useRef<InlineTickerContext>({ tickers, financials, dispatch, registry });
 
@@ -297,7 +314,7 @@ export function useInlineTickers(
       const instrument = ticker ? instrumentFromTicker(ticker, tickerKey(symbol)) : null;
       return instrument ? [instrument] : [];
     });
-  }, [liveQuotes, symbolsKey, tickers]);
+  }, [badgeKeys, liveQuotes, symbolsKey, tickers]);
   const streamingTargets = useMemo(() => {
     if (!settled) return [];
     return instruments.map((instrument) => ({
@@ -362,7 +379,9 @@ export function useInlineTickers(
       }
 
       if (!currentTicker) {
-        if (inlineTickerResolutionFailures.read(symbol, now)) continue;
+        // With no registry there is nothing to ask: a lookup would settle at
+        // once with nothing learnt, wake this effect and start again.
+        if (!registry || inlineTickerResolutionFailures.read(symbol, now)) continue;
         let resolution = resolutionInFlight.get(symbol);
         if (!resolution) {
           resolution = (async () => {
@@ -382,7 +401,7 @@ export function useInlineTickers(
                 inlineTickerResolutionFailures.record(symbol, "unknown");
                 return;
               }
-              if (target.symbol !== symbol) listingKeys.set(symbol, target.symbol);
+              pointBadgeAt(symbol, target.ticker.metadata.ticker);
               current.dispatch({ type: "UPDATE_TICKER", ticker: target.ticker });
               if (target.created) {
                 activeRegistry.events.emit("ticker:added", { symbol: target.symbol, ticker: target.ticker });
@@ -402,9 +421,15 @@ export function useInlineTickers(
               return;
             }
 
-            if (resolved.kind === "local") return;
+            if (resolved.kind === "local") {
+              // A saved ticker the symbol is another spelling of, already in state.
+              pointBadgeAt(symbol, resolved.ticker.metadata.ticker);
+              inlineTickerResolutionFailures.clear(symbol);
+              return;
+            }
 
             const { ticker, created } = await upsertTickerFromSearchResult(activeRegistry.tickerRepository, resolved.result);
+            pointBadgeAt(symbol, ticker.metadata.ticker);
             current.dispatch({ type: "UPDATE_TICKER", ticker });
             if (created) {
               activeRegistry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });

package/src/sync/controller.ts

@@ -94,7 +94,7 @@ export class CloudSyncController {
    * The content signature of the cloud's copy, with the revision and the
    * write it belongs to. Each 15 s poll pulls the same copy again until a
    * device writes; working its signature out every time was a third of an
-   * idle sync on a large workspace (GLO-925).
+   * idle sync on a large workspace.
    */
   private cloudSignature: { transportId: string; revision: number; clientId: string; createdAt: string; signature: string } | null = null;
   private baseline: Record<string, unknown> | null = null;

package/src/sync/core-contributors.ts

@@ -1,4 +1,4 @@
-import { scheduleConfigSave } from "../state/config-save-scheduler";
+import { saveConfigImmediately, scheduleConfigSave } from "../state/config-save-scheduler";
 import { normalizeStoredBaseCurrency } from "../utils/base-currency";
 import { debugLog } from "../utils/debug-log";
 import { fnv1aHex, stableStringify } from "../utils/hash";
@@ -9,6 +9,7 @@ import type { BrokerAccount } from "../types/trading";
 import { hydrateTickerMetadata } from "../tickers/metadata";
 import type { SyncContributor } from "./types";
 import { convertCurrency } from "../utils/format";
+import { fxRateCurrencies } from "../utils/currency-units";
 import { getSharedMarketDataCoordinator, resolveEntryValue } from "../market-data/coordinator";
 import {
   computeDatedBeta,
@@ -34,6 +35,7 @@ import {
 import { isFiniteNumber, isRecord, recordOrNull } from "../utils/guards";
 import { getBrokerInstance } from "../utils/broker-instances";
 import { withoutMissingWatchlists } from "../portfolio/mutations";
+import { mergeSuffixedListings, moveTargetWeights } from "../portfolio/suffixed-listings";
 import { positionContractMultiplier } from "../portfolio/position-metrics";
 import {
   clearLeftoverBrokerHoldings,
@@ -124,6 +126,7 @@ function sanitizePortfolio(portfolio: Portfolio): Portfolio {
     name: portfolio.name,
     description: portfolio.description,
     currency: portfolio.currency,
+    ...(portfolio.fixedCurrency ? { fixedCurrency: true } : {}),
     brokerId: portfolio.brokerId,
     lastSyncedAt: portfolio.lastSyncedAt,
     // Cash and targets are the user's own entries: a pulled portfolio without
@@ -379,6 +382,8 @@ function sanitizeTickerMetadata(metadata: TickerMetadata, financials?: TickerFin
     positions: metadata.positions.map(sanitizePosition),
     custom: (sanitizeUnknown(metadata.custom) as Record<string, unknown>) ?? {},
     tags: [...metadata.tags],
+    // What a listing's row took from a suffixed key's row, so a device that merges it later never counts a lot twice.
+    ...metadata.mergedLots ? { mergedLots: metadata.mergedLots } : {},
     quote: sanitizeQuote(financials),
   };
 }
@@ -468,8 +473,8 @@ function recentPriceHistory(history: PricePoint[], days: number): PricePoint[] {
  * Work derived from a bar history, kept with the history. Every sync values
  * every portfolio and quotes every filed ticker (each 15 s poll, and after
  * each workspace change), and redoing that work from each holding's bars
- * blocked the view for a quarter of a second on a few hundred holdings
- * (GLO-925). Bars change when a history loads again, which replaces the
+ * blocked the view for a quarter of a second on a few hundred holdings.
+ * Bars change when a history loads again, which replaces the
  * array; a last bar extended or revised in place, or one appended, is caught
  * by its length, time and close.
  */
@@ -597,18 +602,15 @@ async function loadHoldingExchangeRates(
   const rates = new Map([["USD", 1]]);
   const coordinator = getSharedMarketDataCoordinator();
   if (!coordinator) return rates;
-  const currencies = new Set<string>();
-  const track = (currency: string | undefined) => {
-    const normalized = currency?.trim().toUpperCase();
-    if (normalized && normalized !== "USD") currencies.add(normalized);
-  };
-  track(config.baseCurrency);
+  const held: Array<string | undefined> = [config.baseCurrency];
   for (const ticker of tickers.values()) {
     if (ticker.metadata.positions.length === 0) continue;
-    track(financials.get(ticker.metadata.ticker)?.quote?.currency);
-    for (const position of ticker.metadata.positions) track(position.currency);
+    held.push(financials.get(ticker.metadata.ticker)?.quote?.currency);
+    for (const position of ticker.metadata.positions) held.push(position.currency);
   }
-  await Promise.all([...currencies].map(async (currency) => {
+  // With a minor unit's major currency, as the panes load them (GBX and ILA have no rate of their own).
+  const currencies = fxRateCurrencies(held).filter((currency) => currency !== "USD");
+  await Promise.all(currencies.map(async (currency) => {
     // A failed FX load must not hold back the rest of the push.
     await coordinator.loadFxRate(currency).catch(() => {});
     const rate = resolveEntryValue(coordinator.getFxEntry(currency));
@@ -1435,8 +1437,12 @@ export const coreCollectionsSyncContributor: SyncContributor = {
       nextTickers.set(next.metadata.ticker, next);
       changed.push(next);
     }
-    if (changed.length === 0) return;
-    dispatch({ type: "SET_TICKERS", tickers: nextTickers });
+    const suffixed = mergePulledSuffixedListings(nextTickers, changed, state.config);
+    if (changed.length === 0 && !suffixed.config) return;
+    if (suffixed.config) dispatch({ type: "SET_CONFIG", config: suffixed.config });
+    if (changed.length > 0) dispatch({ type: "SET_TICKERS", tickers: nextTickers });
+    // The moved targets first, so a stop before the rows strands none on an emptied key.
+    if (suffixed.config) await saveConfigImmediately(suffixed.config);
     // Written one at a time, so an edit or a broker sync can replace a row
     // before its turn. That copy is newer and its writer saves it; this one
     // written over it would come back at launch as an edit and be pushed.
@@ -1447,6 +1453,32 @@ export const coreCollectionsSyncContributor: SyncContributor = {
   },
 };
 
+/**
+ * An older build still files lots under a vendor's suffixed key (GARAN.IS)
+ * and pushes them: pulled, they merge into the listing's row here as at
+ * launch (`mergeSuffixedListings`), each lot once, so they never count in
+ * both rows or go back out under the old key. The merged rows replace their
+ * entries in `tickers` and `changed`; the config comes back with targets
+ * moved, or null when none moved.
+ */
+function mergePulledSuffixedListings(
+  tickers: Map<string, TickerRecord>,
+  changed: TickerRecord[],
+  config: AppConfig,
+): { config: AppConfig | null } {
+  const merged = mergeSuffixedListings([...tickers.values()]);
+  if (!merged) return { config: null };
+  for (const row of merged.saves) {
+    tickers.set(row.metadata.ticker, row);
+    const at = changed.findIndex((record) => record.metadata.ticker === row.metadata.ticker);
+    if (at >= 0) changed[at] = row;
+    else changed.push(row);
+  }
+  for (const kept of merged.keptCustom) log.info("sync.suffixed-listing.custom-kept", kept);
+  const next = moveTargetWeights(config, merged.moved);
+  return { config: next === config ? null : next };
+}
+
 export function createCoreSyncContributors(): SyncContributor[] {
   return [coreConfigSyncContributor, coreCollectionsSyncContributor];
 }

package/src/team/collections-sync.ts

@@ -184,7 +184,8 @@ export function useTeamCollectionsSync(host: Omit<TeamCollectionsHost, "dispatch
           const item = await apiClient.putTeamCollectionItem(collection.teamId, collection.id, {
             symbol: entry.symbol,
             exchange: ticker?.metadata.exchange ?? null,
-            ...(collection.kind === "portfolio" ? { quantity: entry.quantity } : {}),
+            // A holding's purchase date and the rate its cost was bought at go with its count.
+            ...(collection.kind === "portfolio" ? { quantity: entry.quantity, ...entry.terms } : {}),
           });
           items.set(item.symbol, item);
         } catch (error) {