gloomberb 0.16.0 → 0.16.1

package/src/market-data/quotes/freshness.ts

@@ -1,5 +1,7 @@
 import type { Quote } from "../../types/financials";
 import { isUsListingExchange } from "../../utils/exchanges";
+import { zonedDateKey } from "../../utils/zoned-date-time";
+import { getPublishedUsEquitySession } from "../published-us-sessions";
 import { quoteFutureToleranceMs } from "./clock";
 import {
   activeUsExtendedHoursSession,
@@ -7,6 +9,9 @@ import {
   isUsPriorSessionPremarketQuote,
 } from "../market/freshness";
 
+// Give the next regular session's NAV time to publish after its actual close.
+const NAV_PUBLICATION_ALLOWANCE_MS = 12 * 60 * 60_000;
+
 /**
  * Receipt time cannot establish when the source observed a quoted price. A
  * stamp slightly ahead of local time is clock skew, not a bad observation.
@@ -18,6 +23,36 @@ export function hasValidQuoteObservationTime(quote: Pick<Quote, "lastUpdated">,
     && Number.isFinite(new Date(timestamp).getTime()) && Number.isFinite(new Date(now).getTime());
 }
 
+/** The source date of a validated daily fund observation, including an old NAV. */
+export function dailyNavDate(quote: Quote, now = Date.now()): string | null {
+  if (quote.priceObservation !== "nav" || quote.instrumentType !== "MUTUALFUND"
+    || (quote.priceBasis !== undefined && quote.priceBasis !== "per-unit")
+    || !Number.isFinite(quote.price) || quote.price <= 0
+    || !hasValidQuoteObservationTime(quote, now) || quote.lastUpdated > now) return null;
+  const exchange = quote.listingExchangeName || quote.exchangeName;
+  const date = quote.changeSessionDate;
+  if (typeof exchange !== "string" || typeof date !== "string"
+    || getPublishedUsEquitySession(exchange, date)?.kind !== "session"
+    || zonedDateKey(quote.lastUpdated, "America/New_York") !== date) return null;
+  return date;
+}
+
+function isDailyNavStale(quote: Quote, now: number): boolean {
+  const date = dailyNavDate(quote, now);
+  if (!date) return true;
+  const exchange = quote.listingExchangeName || quote.exchangeName;
+  const today = zonedDateKey(now, "America/New_York");
+  if (!today || !getPublishedUsEquitySession(exchange!, today) || date > today) return true;
+  const sourceDay = Date.parse(`${date}T00:00:00Z`);
+  for (let ahead = 1; ahead <= 10; ahead++) {
+    const nextDate = new Date(sourceDay + ahead * 24 * 60 * 60_000).toISOString().slice(0, 10);
+    const next = getPublishedUsEquitySession(exchange!, nextDate);
+    if (!next) return true;
+    if (next.kind === "session") return now >= next.close + NAV_PUBLICATION_ALLOWANCE_MS;
+  }
+  return true;
+}
+
 export function isExtendedHoursExchange(quote: Quote): boolean {
   return isUsListingExchange(quote.listingExchangeName || quote.exchangeName);
 }
@@ -38,6 +73,7 @@ export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, n
   if (!quote) return false;
   if (quote.stale === true) return true;
   if (!hasValidQuoteObservationTime(quote, now)) return true;
+  if (quote.priceObservation != null) return isDailyNavStale(quote, now);
   if (isQuoteMissingActiveSessionPrice(quote, now)) return true;
 
   // A tolerated future stamp belongs to the session in progress, not the next one.

package/src/market-data/quotes/resolution.ts

@@ -12,7 +12,7 @@ import { mergeQuoteMetadata, quoteMetadataFromQuote } from "./metadata";
 import { resolvePriceBasis } from "../market/price-basis";
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
 import { debugLog } from "../../utils/debug-log";
-import { hasValidQuoteObservationTime, isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "./freshness";
+import { dailyNavDate, hasValidQuoteObservationTime, isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "./freshness";
 import { activeUsExtendedHoursSession, isTimestampStaleForExchangeSession } from "../market/freshness";
 import {
   finalizeSessionFields,
@@ -243,7 +243,10 @@ function buildAcceptedPriceCandidates(contributions: QuoteContribution[], now: n
 } {
   const ranks = new Map(contributions.map((quote) => [quote, priceRank(quote, now)] as const));
   const sorted = [...contributions]
-    .filter((quote) => Number.isFinite(quote.price))
+    // Even a stale research snapshot must have its own NAV evidence. Canonical
+    // fallbacks cannot supply a missing observation time or security type.
+    .filter((quote) => Number.isFinite(quote.price)
+      && (quote.priceObservation == null || dailyNavDate(quote, now) !== null))
     .sort((left, right) => {
       const rankDelta = ranks.get(left)! - ranks.get(right)!;
       if (rankDelta !== 0) return rankDelta;
@@ -281,7 +284,7 @@ function buildAcceptedPriceCandidates(contributions: QuoteContribution[], now: n
 }
 
 export function isQuoteContributionStaleForCurrentSession(contribution: Quote, now = Date.now()): boolean {
-  if (contribution.marketState != null) return isQuoteStaleForCurrentSession(contribution, now);
+  if (contribution.priceObservation != null || contribution.marketState != null) return isQuoteStaleForCurrentSession(contribution, now);
   // A price-only source can be combined with independent session metadata.
   // Its observation must still belong to the current active session.
   if (contribution.stale === true || !hasValidQuoteObservationTime(contribution, now)) return true;
@@ -387,8 +390,8 @@ export function resolveCanonicalQuote(
   const { accepted: acceptedPriceCandidates, rejectedProviders } = buildAcceptedPriceCandidates(effectiveQuoteCandidates, now);
   if (acceptedPriceCandidates.length === 0) return {};
 
-  const sessionCandidates = buildSessionCandidates(effectiveQuoteCandidates);
-  const listingCandidates = buildListingCandidates(contributions);
+  let sessionCandidates = buildSessionCandidates(effectiveQuoteCandidates);
+  let listingCandidates = buildListingCandidates(contributions);
   const routingCandidates = buildRoutingCandidates(contributions);
   const descriptiveCandidates = buildDescriptiveCandidates(contributions);
 
@@ -401,9 +404,18 @@ export function resolveCanonicalQuote(
   // The selected response owns the price convention; metadata enrichment must
   // not declare units for another provider's price or supply incompatible anchors.
   assignField(resolved, provenance, "priceBasis", priceProvider);
+  assignField(resolved, provenance, "priceObservation", priceProvider);
+  const isNav = priceProvider?.priceObservation === "nav";
+  if (isNav) {
+    sessionCandidates = priceProvider ? [priceProvider] : [];
+    listingCandidates = sessionCandidates;
+  } else {
+    sessionCandidates = sessionCandidates.filter((quote) => quote.priceObservation == null);
+  }
   const selectedBasis = resolvePriceBasis(priceProvider?.priceBasis, priceProvider?.instrumentType);
   const compatiblePrice = (candidate: QuoteContribution) => candidate === priceProvider
-    || selectedBasis !== null && resolvePriceBasis(candidate.priceBasis, candidate.instrumentType) === selectedBasis;
+    || !isNav && candidate.priceObservation == null
+      && selectedBasis !== null && resolvePriceBasis(candidate.priceBasis, candidate.instrumentType) === selectedBasis;
   const compatiblePriceCandidates = acceptedPriceCandidates.filter(compatiblePrice);
   for (const field of PRICE_FIELD_KEYS) {
     if (field === "price") continue;
@@ -459,13 +471,14 @@ export function resolveCanonicalQuote(
 
   let descriptiveProvider: QuoteContribution | undefined;
   for (const field of DESCRIPTIVE_FIELD_KEYS) {
-    const provider = pickField(resolved, provenance, field, field === "high52w" || field === "low52w" ? descriptiveCandidates.filter(compatiblePrice) : descriptiveCandidates);
+    const ownsPriceField = field === "high52w" || field === "low52w" || isNav && (field === "volume" || field === "marketCap");
+    const provider = pickField(resolved, provenance, field, ownsPriceField ? descriptiveCandidates.filter(compatiblePrice) : descriptiveCandidates);
     descriptiveProvider ??= provider;
   }
   provenance.descriptive = toProvenance(descriptiveProvider);
   // Descriptive enrichment cannot turn an unknown-unit bond observation into
   // an ordinary share price by replacing its source-reported security type.
-  if (priceProvider?.instrumentType?.trim().toUpperCase() === "BOND") {
+  if (isNav || priceProvider?.instrumentType?.trim().toUpperCase() === "BOND") {
     assignField(resolved, provenance, "instrumentType", priceProvider);
   }
 
@@ -474,6 +487,7 @@ export function resolveCanonicalQuote(
     providerId: priceProvider?.providerId ?? contributions[0]!.providerId,
     price: Number(resolved.price ?? priceProvider?.price ?? 0),
     priceBasis: priceProvider?.priceBasis,
+    priceObservation: priceProvider?.priceObservation,
     // The price's own source unit, like its basis; another provider's divisor does not apply.
     ...(typeof priceProvider?.providerPriceDivisor === "number" ? { providerPriceDivisor: priceProvider.providerPriceDivisor } : {}),
     currency: String(resolved.currency ?? priceProvider?.currency ?? contributions[0]!.currency ?? ""),

package/src/market-data/quotes/time.ts

@@ -1,4 +1,20 @@
 import type { Quote } from "../../types/financials";
+import { getLanguage, tf } from "../../i18n";
+import { dailyNavDate } from "./freshness";
+
+/** The published NAV session date, independent of local time and receipt time. */
+export function formatQuoteNavAsOf(quote: Quote | null | undefined, now = Date.now()): string | null {
+  const date = quote && dailyNavDate(quote, now);
+  if (!date) return null;
+  const sourceDate = new Date(`${date}T00:00:00Z`);
+  const dateText = new Intl.DateTimeFormat(getLanguage(), {
+    timeZone: "UTC",
+    month: "short",
+    day: "numeric",
+    ...(sourceDate.getUTCFullYear() !== new Date(now).getUTCFullYear() ? { year: "numeric" as const } : {}),
+  }).format(sourceDate);
+  return tf("NAV · as of {date}", { date: dateText });
+}
 
 function clampQuoteTimestamp(lastUpdated: number | undefined, now = Date.now()): number | null {
   if (typeof lastUpdated !== "number" || !Number.isFinite(lastUpdated) || lastUpdated <= 0) {

package/src/plugins/builtin/analytics/risk-client.ts

@@ -9,6 +9,7 @@ import type {
 import { createPluginCache } from "../../../data/plugin-cache";
 import { loadCloudResource } from "../shared/cloud-resource";
 import { canonicalExchange, normalizeSymbol } from "../../../utils/exchanges";
+import { resolveCurrencyUnit } from "../../../utils/currency-units";
 import type { PricePoint } from "../../../types/financials";
 import { resolveDatedReturns, type DatedReturn } from "./metrics";
 import { qualifySharpeCadence } from "./sharpe-cadence";
@@ -18,15 +19,27 @@ export interface RiskInstrument {
   symbol: string;
   exchange: string;
 }
+/** A holding to load: what ranks it by value before any daily history is requested. */
+export interface RiskHoldingRequest extends RiskInstrument {
+  /** Signed quantity; with a USD quote it ranks the holding by current value. */
+  quantity?: number;
+  /** The currency the position is recorded in, for the rate that values it when it is left out. */
+  currency?: string | null;
+  /** USD value from the broker's own snapshot, ranking a holding no USD quote values. */
+  snapshotValue?: number | null;
+  /** Outside the basket model whatever its history says (a short, a derivative): quoted, never history-requested. */
+  unsupported?: boolean;
+}
 interface RiskMarketHistory {
   instrument: RiskInstrument;
   currency: string | null;
   quote: CloudQuotePayload | null;
-  points: CloudPricePointPayload[];
   returns: DatedReturn[];
   asOf: string | null;
   /** Latest completed close, used as the mark when no current quote arrived. */
   closeMark?: { price: number; date: string; currency: string } | null;
+  /** The listing's own price when it does not quote in USD: it values a left-out holding, never a return. */
+  listing?: { price: number; currency: string } | null;
   error: string | null;
 }
 export interface RiskMarketSnapshot {
@@ -36,7 +49,22 @@ export interface RiskMarketSnapshot {
   fetchedAt: string;
   warnings: string[];
   brokerOptions?: import("./risk-options").PortfolioOptionBook;
+  /** USD per unit of each listing or position currency of the holdings, at load time. */
+  fxRates?: Record<string, number>;
 }
+/**
+ * The most holdings one load requests daily history for, largest current USD
+ * value first. Each holding costs one Cloud request of up to 18 months of
+ * closes, four in flight, again after every two-minute cache expiry, and the
+ * correlation view pairs every basket holding with every other. See
+ * docs/research-data.md for the measured cost behind the number.
+ */
+export const RISK_HISTORY_LIMIT = 150;
+/** Holdings quoted in one load, 50 to a batch request. */
+const RISK_QUOTE_LIMIT = 500;
+const HISTORY_CONCURRENCY = 4;
+const MAX_FX_CURRENCIES = 24;
+export const BEYOND_SIZE_REASON = `Beyond the supported size: only the ${RISK_HISTORY_LIMIT} largest holdings by value are modelled`;
 // Listing venues as the quotes report them; MTUM lists on Cboe BZX, not Arca.
 export const RISK_FACTOR_INSTRUMENTS: RiskInstrument[] = [
   ["SPY", "ARCA"],
@@ -56,12 +84,12 @@ const message = (error: unknown) =>
 export const portfolioRiskCache = createPluginCache<RiskMarketSnapshot>({
   kind: "portfolio-risk",
   source: "gloom-cloud",
-  schemaVersion: 2,
+  schemaVersion: 3,
   policy: { staleMs: 2 * 60_000, expireMs: 24 * 60 * 60_000 },
 });
 type RiskCloudClient = Pick<
   typeof apiClient,
-  "getCloudHistory" | "getCloudQuotesBatch" | "getCloudFredSeries"
+  "getCloudHistory" | "getCloudQuotesBatch" | "getCloudFredSeries" | "getCloudExchangeRate"
 >;
 
 function validateRiskQuote(
@@ -101,7 +129,6 @@ export function validateRiskHistory(
   quote: CloudQuotePayload | null,
   now = new Date(),
 ): {
-  points: CloudPricePointPayload[];
   returns: DatedReturn[];
   asOf: string;
   closeMark: { price: number; date: string; currency: string } | null;
@@ -192,7 +219,6 @@ export function validateRiskHistory(
     throw new Error(cadence.reason ?? "Daily session cadence unavailable");
   const lastPoint = points.at(-1)!;
   return {
-    points,
     returns: resolved.returns,
     asOf: last,
     // A missing or stale quote is not a current mark; the latest dated close is.
@@ -229,38 +255,69 @@ function validateFred(
   return data;
 }
 
+/** The USD value a holding ranks by before its history loads; unknown ranks last. */
+function rankValue(request: RiskHoldingRequest, quote: CloudQuotePayload | null): number {
+  if (quote && request.quantity != null && Number.isFinite(request.quantity))
+    return Math.abs(request.quantity * quote.price);
+  const snapshot = request.snapshotValue;
+  return snapshot != null && Number.isFinite(snapshot) ? Math.abs(snapshot) : -1;
+}
+const largestFirst = (
+  left: { rank: number; order: number },
+  right: { rank: number; order: number },
+) => right.rank - left.rank || left.order - right.order;
+
 /**
- * The signal stops the fetch: no request starts once it aborts, the ones in
- * flight are cancelled, and the call rejects instead of returning a partial
- * snapshot nobody is waiting for.
+ * Quotes every holding, then requests daily history only for the factor
+ * proxies and the largest USD holdings that can enter the basket, up to
+ * RISK_HISTORY_LIMIT. Holdings that quote in another currency, positions the
+ * caller marks unsupported and holdings past the limit get no history request;
+ * their entry says why. The signal stops the fetch: no request starts once it
+ * aborts, the ones in flight are cancelled, and the call rejects instead of
+ * returning a partial snapshot nobody is waiting for.
  */
 export async function fetchPortfolioRiskMarket(
-  instruments: readonly RiskInstrument[],
+  holdings: readonly RiskHoldingRequest[],
   client: RiskCloudClient = apiClient,
   now = new Date(),
   signal?: AbortSignal,
 ): Promise<RiskMarketSnapshot> {
   signal?.throwIfAborted();
-  const unique = [
-    ...new Map(
-      [...instruments, ...RISK_FACTOR_INSTRUMENTS].map((row) => [
-        riskInstrumentId(row),
-        {
-          symbol: normalizeSymbol(row.symbol),
-          exchange: canonicalExchange(row.exchange),
-        },
-      ]),
-    ).values(),
+  const normalized = (row: RiskInstrument): RiskInstrument => ({
+    symbol: normalizeSymbol(row.symbol),
+    exchange: canonicalExchange(row.exchange),
+  });
+  const factors = new Map(
+    RISK_FACTOR_INSTRUMENTS.map((row) => [riskInstrumentId(row), normalized(row)]),
+  );
+  const entries = new Map<
+    string,
+    { id: string; instrument: RiskInstrument; request: RiskHoldingRequest; order: number; rank: number }
+  >();
+  for (const request of holdings) {
+    const id = riskInstrumentId(request);
+    if (!entries.has(id))
+      entries.set(id, {
+        id,
+        instrument: normalized(request),
+        request,
+        order: entries.size,
+        rank: rankValue(request, null),
+      });
+  }
+  const quoted = [...entries.values()].sort(largestFirst).slice(0, RISK_QUOTE_LIMIT);
+  const targets = [
+    ...new Map([
+      ...quoted.map((row) => [row.id, row.instrument] as const),
+      ...factors,
+    ]).values(),
   ];
-  if (unique.length > 87)
-    throw new Error(
-      "Portfolio risk supports at most 80 holdings plus its factor proxies",
-    );
   const quotes = new Map<string, CloudQuotePayload>();
+  const listings = new Map<string, { price: number; currency: string }>();
   const warnings: string[] = [];
-  for (let start = 0; start < unique.length; start += 50) {
+  for (let start = 0; start < targets.length; start += 50) {
     signal?.throwIfAborted();
-    const requested = unique.slice(start, start + 50);
+    const requested = targets.slice(start, start + 50);
     try {
       const response = await client.getCloudQuotesBatch(
         requested,
@@ -275,17 +332,25 @@ export async function fetchPortfolioRiskMarket(
               canonicalExchange(item.exchange),
         );
         if (
-          target &&
-          item.status === "success" &&
-          item.data &&
-          normalizeSymbol(item.data.symbol) === normalizeSymbol(target.symbol)
-        ) {
-          try {
-            validateRiskQuote(item.data, target, now);
-            quotes.set(riskInstrumentId(target), item.data);
-          } catch (error) {
-            warnings.push(`${target.symbol}: ${message(error)}`);
-          }
+          !target ||
+          item.status !== "success" ||
+          !item.data ||
+          normalizeSymbol(item.data.symbol) !== normalizeSymbol(target.symbol)
+        )
+          continue;
+        const id = riskInstrumentId(target);
+        // A holding quoted in another currency never enters the USD basket;
+        // its price only values what is left out.
+        if (!factors.has(id) && item.data.currency && item.data.currency !== "USD") {
+          if (Number.isFinite(item.data.price) && item.data.price > 0)
+            listings.set(id, { price: item.data.price, currency: item.data.currency });
+          continue;
+        }
+        try {
+          validateRiskQuote(item.data, target, now);
+          quotes.set(id, item.data);
+        } catch (error) {
+          warnings.push(`${target.symbol}: ${message(error)}`);
         }
       }
     } catch (error) {
@@ -293,6 +358,17 @@ export async function fetchPortfolioRiskMarket(
       warnings.push(`Holding marks: ${message(error)}`);
     }
   }
+  const candidates = quoted
+    .filter((row) => !factors.has(row.id) && !row.request.unsupported && !listings.has(row.id))
+    .map((row) => ({ ...row, rank: rankValue(row.request, quotes.get(row.id) ?? null) }))
+    .sort(largestFirst);
+  const requestedIds = new Set([
+    ...factors.keys(),
+    ...candidates.slice(0, RISK_HISTORY_LIMIT).map((row) => row.id),
+  ]);
+  const instruments = [
+    ...new Map([...factors, ...[...entries.values()].map((row) => [row.id, row.instrument] as const)]).entries(),
+  ];
   const start = new Date(now);
   start.setUTCMonth(start.getUTCMonth() - 18);
   start.setUTCDate(1);
@@ -301,15 +377,36 @@ export async function fetchPortfolioRiskMarket(
     endDate = new Date(Date.parse(today) - 86_400_000)
       .toISOString()
       .slice(0, 10);
-  const histories: RiskMarketHistory[] = new Array(unique.length);
+  const histories: RiskMarketHistory[] = instruments.map(([id, instrument]) => {
+    const quote = quotes.get(id) ?? null,
+      listing = listings.get(id) ?? null;
+    return {
+      instrument,
+      quote,
+      listing,
+      currency: quote?.currency ?? listing?.currency ?? null,
+      returns: [],
+      asOf: null,
+      error: requestedIds.has(id)
+        ? null
+        : listing
+          ? "Current USD listing identity unavailable"
+          : entries.get(id)?.request.unsupported
+            ? "Outside the long USD equity basket"
+            : BEYOND_SIZE_REASON,
+    };
+  });
+  const pending = instruments.flatMap(([id], index) =>
+    requestedIds.has(id) ? [index] : [],
+  );
   let next = 0;
   const historyWork = Promise.all(
-    Array.from({ length: Math.min(4, unique.length) }, async () => {
-      while (next < unique.length) {
+    Array.from({ length: Math.min(HISTORY_CONCURRENCY, pending.length) }, async () => {
+      while (next < pending.length) {
         signal?.throwIfAborted();
-        const index = next++,
-          instrument = unique[index]!,
-          quote = quotes.get(riskInstrumentId(instrument)) ?? null;
+        const index = pending[next++]!,
+          entry = histories[index]!,
+          { instrument, quote } = entry;
         try {
           const response = await client.getCloudHistory(
             instrument.symbol,
@@ -332,28 +429,30 @@ export async function fetchPortfolioRiskMarket(
             now,
           );
           histories[index] = {
-            instrument,
-            quote,
+            ...entry,
             currency: quote?.currency ?? resolved.closeMark?.currency ?? null,
             ...resolved,
             error: null,
           };
         } catch (error) {
           if (isAccessDenied(error) || signal?.aborted) throw error;
-          histories[index] = {
-            instrument,
-            quote,
-            currency: quote?.currency ?? null,
-            points: [],
-            returns: [],
-            asOf: null,
-            error: message(error),
-          };
+          histories[index] = { ...entry, error: message(error) };
         }
       }
     }),
   );
-  const [, fred] = await Promise.all([
+  // Rates value left-out holdings that do not quote in USD; they never convert a return.
+  const fxCurrencies = [
+    ...new Set(
+      [...entries.values()].flatMap((row) => {
+        const currency = resolveCurrencyUnit(
+          listings.get(row.id)?.currency ?? (quotes.has(row.id) ? null : row.request.currency),
+        ).currency;
+        return currency && currency !== "USD" ? [currency] : [];
+      }),
+    ),
+  ].slice(0, MAX_FX_CURRENCIES);
+  const [, fred, fx] = await Promise.all([
     historyWork,
     Promise.allSettled(
       ["DGS10", "VIXCLS"].map(async (id) =>
@@ -368,6 +467,17 @@ export async function fetchPortfolioRiskMarket(
         ),
       ),
     ),
+    Promise.allSettled(
+      fxCurrencies.map(async (currency) => {
+        const response = await client.getCloudExchangeRate(currency);
+        const rate = response.status === "success" || response.status === "partial"
+          ? response.data?.rate
+          : undefined;
+        if (typeof rate !== "number" || !Number.isFinite(rate) || rate <= 0)
+          throw new Error(response.reasonCode ?? "Rate unavailable");
+        return [currency, rate] as const;
+      }),
+    ),
   ]);
   signal?.throwIfAborted();
   for (const [index, result] of fred.entries()) {
@@ -378,24 +488,40 @@ export async function fetchPortfolioRiskMarket(
       );
     }
   }
+  const fxRates: Record<string, number> = {};
+  for (const [index, result] of fx.entries()) {
+    if (result.status === "fulfilled") fxRates[result.value[0]] = result.value[1];
+    else {
+      if (isAccessDenied(result.reason)) throw result.reason;
+      warnings.push(`${fxCurrencies[index]} exchange rate: ${message(result.reason)}`);
+    }
+  }
   return {
     histories,
     yields: fred[0]!.status === "fulfilled" ? fred[0]!.value : null,
     volatility: fred[1]!.status === "fulfilled" ? fred[1]!.value : null,
     fetchedAt: now.toISOString(),
     warnings,
+    fxRates,
   };
 }
-const cacheKey = (instruments: readonly RiskInstrument[]) =>
-  [...new Set(instruments.map(riskInstrumentId))].sort().join(",");
+/** What changes the requests: identity, size and whether a holding can enter the basket. */
+const cacheKey = (holdings: readonly RiskHoldingRequest[]) =>
+  [
+    ...new Set(
+      holdings.map(
+        (row) => `${riskInstrumentId(row)}|${row.quantity ?? ""}|${row.currency ?? ""}|${row.unsupported ? 1 : 0}`,
+      ),
+    ),
+  ].sort().join(",");
 export async function loadPortfolioRiskMarket(
-  instruments: readonly RiskInstrument[],
+  holdings: readonly RiskHoldingRequest[],
   force = false,
 ) {
   const { payload, stale, refreshError } = await loadCloudResource(
     portfolioRiskCache,
-    cacheKey(instruments),
-    () => fetchPortfolioRiskMarket(instruments),
+    cacheKey(holdings),
+    () => fetchPortfolioRiskMarket(holdings),
     { force },
   );
   return {