gloomberb 0.16.1 → 0.16.3

package/src/sources/sec-registrant.ts

@@ -0,0 +1,75 @@
+import type { SecFilingItem } from "../types/data-provider";
+import { ProviderMissError } from "./provider-errors";
+
+/** Legal forms and grouping words, which say nothing about which company a name is. */
+const COMPANY_NAME_FILLER = new Set([
+  "THE", "SA", "PLC", "LTD", "LIMITED", "CORP", "CORPORATION", "INC", "INCORPORATED", "NV", "AG", "SE",
+  "HOLDING", "HOLDINGS", "GROUP", "COMPANY", "CO",
+]);
+
+/**
+ * The first word of a company name that tells it apart, in capitals without
+ * accents: "BANCO" for "Banco Santander, S.A.", "BP" for "BP p.l.c.". Null
+ * when the name is only legal forms.
+ */
+function companyNameToken(name: string | null | undefined): string | null {
+  const words = (name ?? "")
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toUpperCase()
+    // An initialism (S.A., N.V., p.l.c.) is one word; any other dot separates two (Amazon.com).
+    .replace(/\b(?:[A-Z]\.){2,}/g, (initialism) => initialism.replaceAll(".", ""))
+    .replace(/['\u2019]/g, "")
+    .split(/[^A-Z0-9]+/);
+  return words.find((word) => word && !COMPANY_NAME_FILLER.has(word)) ?? null;
+}
+
+/**
+ * Whether two names are clearly different companies. Names that cannot be
+ * compared count as the same, so only a plain conflict hides anything.
+ */
+export function areDifferentCompanies(left: string | null | undefined, right: string | null | undefined): boolean {
+  const leftToken = companyNameToken(left);
+  const rightToken = companyNameToken(right);
+  return !!leftToken && !!rightToken && leftToken !== rightToken;
+}
+
+export interface SecListing {
+  /** The bare symbol, such as SAN. */
+  symbol: string;
+  /** The listing's canonical venue, such as EPA. */
+  exchange: string;
+  /** The listing's company, from its own quote. */
+  name: string;
+}
+
+/** "No SEC filings found for Sanofi (EPA). The SEC lists SAN as Banco Santander, S.A. (NYSE)." */
+export function secRegistrantMismatchMessage(listing: SecListing, registrantName: string, registrantExchange?: string | null): string {
+  const registrant = registrantExchange ? `${registrantName} (${registrantExchange})` : registrantName;
+  return `No SEC filings found for ${listing.name} (${listing.exchange}). The SEC lists ${listing.symbol} as ${registrant}${registrant.endsWith(".") ? "" : "."}`;
+}
+
+/** The SEC knows the listing's symbol as another company: SAN on EPA is Sanofi, SAN at the SEC is Banco Santander. */
+export class SecRegistrantMismatchError extends ProviderMissError {
+  constructor(readonly listing: SecListing, readonly registrantName: string) {
+    super(secRegistrantMismatchMessage(listing, registrantName));
+    this.name = "SecRegistrantMismatchError";
+  }
+}
+
+/** The company the filings were filed by. */
+function registrantName(filings: readonly SecFilingItem[]): string | null {
+  return filings.map((filing) => filing.companyName?.trim()).find((name): name is string => !!name) ?? null;
+}
+
+/**
+ * A lookup for a listing outside the US can answer with the US registrant of
+ * the same symbol: a backend that predates venue-aware lookups ignores the
+ * venue. Those filings are another company's, so they are refused.
+ */
+export function assertSecRegistrantMatches(filings: readonly SecFilingItem[], listing: SecListing): void {
+  const registrant = registrantName(filings);
+  if (registrant && areDifferentCompanies(listing.name, registrant)) {
+    throw new SecRegistrantMismatchError(listing, registrant);
+  }
+}

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

@@ -44,6 +44,7 @@ import {
 import type { AppAction, AppState } from "../../../core/state/app/state";
 import { scheduleConfigSave } from "../../config-save-scheduler";
 import { LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS } from "../../persist-scheduler";
+import { fireAndForget } from "../../../utils/fire-and-forget";
 
 export {
   appReducer,
@@ -565,10 +566,16 @@ export function AppProvider({
     if (signature === lastMainSyncRef.current) return;
     lastMainSyncRef.current = signature;
     latestMainStateRevisionRef.current += 1;
-    void desktopBridge.syncMainState({
-      ...snapshot,
-      mainStateRevision: latestMainStateRevisionRef.current,
-    });
+    // A snapshot that did not arrive must not count as sent. Forget it, unless
+    // a newer one has replaced it, so the next effect run sends it again. The
+    // two syncs below dedupe the same way.
+    fireAndForget(
+      desktopBridge.syncMainState({ ...snapshot, mainStateRevision: latestMainStateRevisionRef.current }),
+      "desktop.syncMainState",
+      () => {
+        if (lastMainSyncRef.current === signature) lastMainSyncRef.current = null;
+      },
+    );
   }, [
     buildDesktopSnapshot,
     desktopBridge,
@@ -581,9 +588,12 @@ export function AppProvider({
 
   useEffect(() => {
     if (desktopBridge?.kind !== "main" || !desktopBridge.syncThemePreview) return;
-    if (lastThemePreviewSyncRef.current === state.themePreview) return;
-    lastThemePreviewSyncRef.current = state.themePreview;
-    void desktopBridge.syncThemePreview({ theme: state.themePreview });
+    const theme = state.themePreview;
+    if (lastThemePreviewSyncRef.current === theme) return;
+    lastThemePreviewSyncRef.current = theme;
+    fireAndForget(desktopBridge.syncThemePreview({ theme }), "desktop.setThemePreview", () => {
+      if (lastThemePreviewSyncRef.current === theme) lastThemePreviewSyncRef.current = undefined;
+    });
   }, [desktopBridge, state.themePreview]);
 
   useEffect(() => {
@@ -598,7 +608,13 @@ export function AppProvider({
     const paneSignature = serializePaneState(state.paneState[desktopBridge.paneId]);
     if (paneSignature === lastDetachedPaneSyncRef.current) return;
     lastDetachedPaneSyncRef.current = paneSignature;
-    void desktopBridge.replaceDetachedPaneState(desktopBridge.paneId, state.paneState[desktopBridge.paneId] ?? {});
+    fireAndForget(
+      desktopBridge.replaceDetachedPaneState(desktopBridge.paneId, state.paneState[desktopBridge.paneId] ?? {}),
+      "desktop.replaceDetachedPaneState",
+      () => {
+        if (lastDetachedPaneSyncRef.current === paneSignature) lastDetachedPaneSyncRef.current = null;
+      },
+    );
   }, [desktopBridge, serializePaneState, state.paneState]);
 
   useLayoutEffect(() => {

package/src/state/hooks/quote-streaming.ts

@@ -106,21 +106,28 @@ export function useQuoteStreaming(
   const paneInView = usePaneInView();
   const coordinator = getSharedMarketDataCoordinator();
 
-  const normalizedEntries = new Map<string, QuoteSubscriptionTarget>();
-  for (const target of targets) {
-    const resolved = normalizeQuoteStreamSubscriptionTarget(target);
-    if (!resolved) continue;
-    const normalized = paneInView ? resolved : downgradeOffscreenQuoteTarget(resolved);
-    const key = buildQuoteStreamSubscriptionKey(normalized);
-    normalizedEntries.set(key, normalized);
-  }
-  const sortedEntries = [...normalizedEntries.entries()].sort(([left], [right]) => left.localeCompare(right));
-  const normalizedTargets = sortedEntries.map(([, target]) => target);
-  const subscriptionKey = sortedEntries.map(([key]) => key).join("|");
-  const identityKey = [...new Set(normalizedTargets.map(buildQuoteStreamSubscriptionIdentityKey))]
-    .sort()
-    .join("\u001f");
-  const coordinatorTargets = toCoordinatorQuoteTargets(normalizedTargets);
+  // Keyed on the array, not its contents: callers memoize their targets, and a
+  // portfolio re-renders on every data frame, where re-keying and sorting a
+  // thousand targets cost a few milliseconds each time.
+  const { coordinatorTargets, identityKey, subscriptionKey } = useMemo(() => {
+    const normalizedEntries = new Map<string, QuoteSubscriptionTarget>();
+    for (const target of targets) {
+      const resolved = normalizeQuoteStreamSubscriptionTarget(target);
+      if (!resolved) continue;
+      const normalized = paneInView ? resolved : downgradeOffscreenQuoteTarget(resolved);
+      const key = buildQuoteStreamSubscriptionKey(normalized);
+      normalizedEntries.set(key, normalized);
+    }
+    const sortedEntries = [...normalizedEntries.entries()].sort(([left], [right]) => left.localeCompare(right));
+    const normalizedTargets = sortedEntries.map(([, target]) => target);
+    return {
+      coordinatorTargets: toCoordinatorQuoteTargets(normalizedTargets),
+      identityKey: [...new Set(normalizedTargets.map(buildQuoteStreamSubscriptionIdentityKey))]
+        .sort()
+        .join("\u001f"),
+      subscriptionKey: sortedEntries.map(([key]) => key).join("|"),
+    };
+  }, [paneInView, targets]);
   const latestSubscriptionRef = useRef({
     identityKey,
     subscriptionKey,
@@ -208,11 +215,16 @@ export function useQuoteUpdates(
 ): void {
   const appActive = useAppVisible();
   const coordinator = getSharedMarketDataCoordinator();
-  const normalizedTargets = normalizeQuoteStreamSubscriptionTargets(targets);
-  const instrumentKey = normalizedTargets
-    .map((target) => buildQuoteKey(instrumentFromQuoteTarget(target)))
-    .sort()
-    .join("\u001f");
+  const { instrumentKey, normalizedTargets } = useMemo(() => {
+    const normalized = normalizeQuoteStreamSubscriptionTargets(targets);
+    return {
+      instrumentKey: normalized
+        .map((target) => buildQuoteKey(instrumentFromQuoteTarget(target)))
+        .sort()
+        .join("\u001f"),
+      normalizedTargets: normalized,
+    };
+  }, [targets]);
   const instruments = useMemo(() => uniqueQuoteInstruments(normalizedTargets), [instrumentKey]);
 
   useQuoteStreaming(targets, { enabled: liveStreaming });
@@ -270,12 +282,15 @@ export function useLiveQuoteEntries(
   subscriptionStartedAt: number;
 } {
   const appActive = useAppVisible();
-  const normalizedTargets = normalizeQuoteStreamSubscriptionTargets(targets);
-  const targetKey = [...new Set(
-    normalizedTargets.map((target) => buildQuoteStreamSubscriptionIdentityKey(target)),
-  )]
-    .sort()
-    .join("\u001f");
+  const { normalizedTargets, targetKey } = useMemo(() => {
+    const normalized = normalizeQuoteStreamSubscriptionTargets(targets);
+    return {
+      normalizedTargets: normalized,
+      targetKey: [...new Set(normalized.map((target) => buildQuoteStreamSubscriptionIdentityKey(target)))]
+        .sort()
+        .join("\u001f"),
+    };
+  }, [targets]);
   const liveStreaming = options.liveStreaming !== false;
   const freshnessKey = options.freshnessScopeKey ?? targetKey;
   const subscriptionKey = `${appActive ? "active" : "inactive"}\u001f${liveStreaming ? "live" : "poll"}\u001f${freshnessKey}`;

package/src/state/pane-scroll-registry.tsx

@@ -5,9 +5,12 @@ import { useAppSelector, useOptionalPaneInstanceId } from "./app/context";
 
 type ScrollDirection = "up" | "down";
 
+/** A scroll position: rows (or cells), or device pixels where the host measures in them. */
+type ScrollTarget = { cells: number } | { pixels: number };
+
 interface PaneScrollAction {
   direction: ScrollDirection;
-  resolveTarget(scrollBox: ScrollBoxRenderable): number | null;
+  resolveTarget(scrollBox: ScrollBoxRenderable): ScrollTarget | null;
 }
 
 interface PaneScrollEntry {
@@ -57,17 +60,58 @@ function isVisibleScrollBox(scrollBox: ScrollBoxRenderable): boolean {
   return !hasHiddenAncestor(scrollBox) && !hasCollapsedBounds(scrollBox);
 }
 
-function clampScrollTop(scrollBox: ScrollBoxRenderable, target: number): number | null {
+function maxScrollTop(scrollBox: ScrollBoxRenderable): number {
   const viewportHeight = Math.max(0, scrollBox.viewport?.height ?? 0);
-  if (viewportHeight <= 0) return null;
-  const maxScrollTop = Math.max(0, scrollBox.scrollHeight - viewportHeight);
-  if (maxScrollTop <= 0) return null;
-  return Math.max(0, Math.min(maxScrollTop, target));
+  if (viewportHeight <= 0) return 0;
+  return Math.max(0, scrollBox.scrollHeight - viewportHeight);
+}
+
+/**
+ * The desktop host rounds its viewport and content to whole rows, which can
+ * leave up to half a row of content past the last scrollable row. Where it
+ * also reports pixels, the ends are measured in them.
+ */
+function pixelRange(scrollBox: ScrollBoxRenderable): { top: number; max: number } | null {
+  const { scrollTopPx, scrollHeightPx, viewportPx } = scrollBox;
+  if (!scrollBox.scrollToPixels || typeof scrollTopPx !== "number" || typeof scrollHeightPx !== "number" || !viewportPx) {
+    return null;
+  }
+  return { top: scrollTopPx, max: Math.max(0, scrollHeightPx - viewportPx.height) };
 }
 
-function scrollTargetByDelta(scrollBox: ScrollBoxRenderable, delta: number): number | null {
-  const target = clampScrollTop(scrollBox, scrollBox.scrollTop + delta);
-  return target == null || target === scrollBox.scrollTop ? null : target;
+function topTarget(scrollBox: ScrollBoxRenderable): ScrollTarget | null {
+  if ((scrollBox.viewport?.height ?? 0) <= 0) return null;
+  const pixels = pixelRange(scrollBox);
+  if (pixels) return pixels.top >= 1 ? { pixels: 0 } : null;
+  return scrollBox.scrollTop > 0 ? { cells: 0 } : null;
+}
+
+function bottomTarget(scrollBox: ScrollBoxRenderable): ScrollTarget | null {
+  const max = maxScrollTop(scrollBox);
+  // A body that overflows by less than a row is not worth capturing the keys for.
+  if (max <= 0) return null;
+  const pixels = pixelRange(scrollBox);
+  if (pixels) return pixels.max - pixels.top >= 1 ? { pixels: pixels.max } : null;
+  return max !== scrollBox.scrollTop ? { cells: max } : null;
+}
+
+function scrollTargetByDelta(scrollBox: ScrollBoxRenderable, delta: number): ScrollTarget | null {
+  if ((scrollBox.viewport?.height ?? 0) <= 0) return null;
+  const wanted = scrollBox.scrollTop + delta;
+  if (delta < 0 && wanted <= 0) return topTarget(scrollBox);
+  if (delta > 0 && wanted >= maxScrollTop(scrollBox)) return bottomTarget(scrollBox);
+  return delta === 0 ? null : { cells: wanted };
+}
+
+function applyScrollTarget(scrollBox: ScrollBoxRenderable, target: ScrollTarget): void {
+  if ("pixels" in target) {
+    scrollBox.scrollToPixels?.(target.pixels);
+    return;
+  }
+  scrollBox.scrollTo(target.cells);
+  if (scrollBox.scrollTop !== target.cells) {
+    scrollBox.scrollTop = target.cells;
+  }
 }
 
 /**
@@ -76,7 +120,7 @@ function scrollTargetByDelta(scrollBox: ScrollBoxRenderable, delta: number): num
  */
 export function scrollByLines(scrollBox: ScrollBoxRenderable, delta: number): void {
   const target = scrollTargetByDelta(scrollBox, delta);
-  if (target != null) scrollBox.scrollTop = target;
+  if (target) applyScrollTarget(scrollBox, target);
 }
 
 function arrowScrollLines(scrollBox: ScrollBoxRenderable): number {
@@ -117,20 +161,9 @@ function resolveKeyScrollAction(event: PaneScrollKeyEvent): PaneScrollAction | n
         ),
       };
     case "home":
-      return {
-        direction: "up",
-        resolveTarget: (scrollBox) => (
-          scrollBox.scrollTop > 0 ? 0 : null
-        ),
-      };
+      return { direction: "up", resolveTarget: topTarget };
     case "end":
-      return {
-        direction: "down",
-        resolveTarget: (scrollBox) => {
-          const target = clampScrollTop(scrollBox, Number.MAX_SAFE_INTEGER);
-          return target == null || target === scrollBox.scrollTop ? null : target;
-        },
-      };
+      return { direction: "down", resolveTarget: bottomTarget };
     default:
       return null;
   }
@@ -145,12 +178,12 @@ function getEntryScore(entry: PaneScrollEntry, scrollBox: ScrollBoxRenderable):
 function findScrollableEntry(paneId: string, action: PaneScrollAction): {
   entry: PaneScrollEntry;
   scrollBox: ScrollBoxRenderable;
-  target: number;
+  target: ScrollTarget;
 } | null {
   const entries = paneScrollBoxes.get(paneId);
   if (!entries) return null;
 
-  let best: { entry: PaneScrollEntry; scrollBox: ScrollBoxRenderable; target: number; score: number } | null = null;
+  let best: { entry: PaneScrollEntry; scrollBox: ScrollBoxRenderable; target: ScrollTarget; score: number } | null = null;
   for (const entry of entries.values()) {
     const scrollBox = entry.ref.current;
     if (!scrollBox) continue;
@@ -176,17 +209,16 @@ function scrollPaneByKey(paneId: string, event: PaneScrollKeyEvent): boolean {
   const match = findScrollableEntry(paneId, action);
   if (!match) return false;
 
-  const previousTop = match.scrollBox.scrollTop;
-  match.scrollBox.scrollTo(match.target);
-  if (match.scrollBox.scrollTop !== match.target) {
-    match.scrollBox.scrollTop = match.target;
-  }
+  const { scrollBox } = match;
+  const position = () => scrollBox.scrollTopPx ?? scrollBox.scrollTop;
+  const previousTop = scrollBox.scrollTop;
+  const previousPosition = position();
+  applyScrollTarget(scrollBox, match.target);
 
-  const delta = Math.abs(match.scrollBox.scrollTop - previousTop);
-  if (delta > 0) {
-    match.entry.onScrollActivity?.({ scroll: { direction: action.direction, delta } });
-  }
-  return delta > 0;
+  if (position() === previousPosition) return false;
+  const delta = Math.max(1, Math.abs(scrollBox.scrollTop - previousTop));
+  match.entry.onScrollActivity?.({ scroll: { direction: action.direction, delta } });
+  return true;
 }
 
 export function useForwardedScrollBoxRef<T>(

package/src/sync/core-contributors.ts

@@ -102,6 +102,10 @@ function sanitizePortfolio(portfolio: Portfolio): Portfolio {
     currency: portfolio.currency,
     brokerId: portfolio.brokerId,
     lastSyncedAt: portfolio.lastSyncedAt,
+    // Cash and targets are the user's own entries: a pulled portfolio without
+    // them would erase them on this device.
+    ...(portfolio.cash ? { cash: { ...portfolio.cash } } : {}),
+    ...(portfolio.targetWeights ? { targetWeights: { ...portfolio.targetWeights } } : {}),
   };
 }
 

package/src/telemetry/crash-reports.ts

@@ -6,6 +6,7 @@ import {
   type CrashReportsPayload,
 } from "../api-client";
 import type { TelemetryConfig } from "../types/config";
+import { isSleepRpcTimeout } from "../utils/rpc-timeout-error";
 import { VERSION } from "../version";
 
 /**
@@ -172,10 +173,12 @@ function toReportError(error: unknown, context: CrashReportContext): PendingErro
 /**
  * Queues one error. Safe to call from any error handler: it never throws,
  * never awaits, and drops the error when reporting is off, already seen this
- * session, or over the session cap.
+ * session, or over the session cap. A desktop request timeout that fired
+ * after the machine slept is not an error at all and is dropped too.
  */
 export function reportCrash(error: unknown, context: CrashReportContext): void {
   try {
+    if (isSleepRpcTimeout(error)) return;
     if (host && !host.isEnabled()) return;
     if (accepted >= MAX_ERRORS_PER_SESSION) return;
     const entry = toReportError(error, context);

package/src/test-support/cli-context.ts

@@ -8,7 +8,8 @@ export interface PrintedCliResult {
 }
 
 /**
- * A command context whose `initMarketData` resolves to `market` (config, store, dataProvider, ...).
+ * A command context whose `initMarketData` and `initConfigData` resolve to `market` (config, store, dataProvider, ...),
+ * with an empty ticker store unless `market` brings one.
  * `fail` throws, every printResult call is kept in `printed`, and `closeCount` reports how many
  * times the command closed its persistence.
  */
@@ -18,9 +19,16 @@ export function createTestCliContext(
 ): { context: CliCommandContext; printed: PrintedCliResult[]; closeCount: () => number } {
   const printed: PrintedCliResult[] = [];
   let closed = 0;
+  const init = async () => ({
+    persistence: { close: () => { closed += 1; } },
+    // Commands look up the saved listing of every symbol they are given.
+    store: { loadTicker: async () => null, loadAllTickers: async () => [] },
+    ...market,
+  });
   const context = {
     cliOptions: { ...DEFAULT_CLI_OPTIONS, ...cliOptions },
-    initMarketData: async () => ({ persistence: { close: () => { closed += 1; } }, ...market }),
+    initMarketData: init,
+    initConfigData: init,
     printResult: (result: CliResult<any>, options?: CliResultRenderOptions<any, any>) => { printed.push({ result, options }); },
     fail: (message: string): never => { throw new Error(message); },
   } as unknown as CliCommandContext;

package/src/test-support/margin-account.ts

@@ -0,0 +1,108 @@
+import type { Quote, TickerFinancials } from "../types/financials";
+import type { Portfolio, TickerRecord } from "../types/ticker";
+import type { BrokerAccount } from "../types/trading";
+import { createTestTicker } from "./ticker";
+
+/**
+ * An invented margin account: 1.0M of equity carrying 1.6M of positions, the
+ * difference borrowed in three currencies. It holds a US stock, a listing
+ * quoted in euros and an option, which no quote prices, so it stays at its
+ * broker mark. Every figure is made up.
+ */
+export const MARGIN_PORTFOLIO: Portfolio = {
+  id: "broker:margin-test:M1",
+  name: "Margin test",
+  currency: "USD",
+  brokerId: "test",
+  brokerInstanceId: "margin-test",
+  brokerAccountId: "M1",
+};
+
+/** Dollars per unit of each currency. */
+export const MARGIN_EXCHANGE_RATES = new Map([["USD", 1], ["EUR", 1.2], ["JPY", 0.008]]);
+
+const OPTION = "CCC   280121C00050000";
+
+function holding(symbol: string, details: {
+  exchange: string;
+  currency: string;
+  shares: number;
+  mark: number;
+  multiplier?: number;
+  assetCategory?: string;
+}): TickerRecord {
+  return createTestTicker(symbol, symbol, {
+    exchange: details.exchange,
+    currency: details.currency,
+    assetCategory: details.assetCategory,
+    portfolios: [MARGIN_PORTFOLIO.id],
+    positions: [{
+      portfolio: MARGIN_PORTFOLIO.id,
+      shares: details.shares,
+      avgCost: details.mark,
+      markPrice: details.mark,
+      marketValue: details.shares * details.mark * (details.multiplier ?? 1),
+      unrealizedPnl: 0,
+      multiplier: details.multiplier,
+      currency: details.currency,
+      side: "long",
+      broker: "test",
+      brokerInstanceId: "margin-test",
+      brokerAccountId: "M1",
+    }],
+  });
+}
+
+export const MARGIN_TICKERS: TickerRecord[] = [
+  holding("AAA", { exchange: "NASDAQ", currency: "USD", shares: 4_000, mark: 200 }),
+  holding("BBB", { exchange: "XETRA", currency: "EUR", shares: 5_000, mark: 100 }),
+  holding(OPTION, { exchange: "", currency: "USD", shares: 20, mark: 100, multiplier: 100, assetCategory: "OPT" }),
+];
+
+export function createMarginAccount(overrides: Partial<BrokerAccount> = {}): BrokerAccount {
+  return {
+    accountId: "M1",
+    name: "Margin test",
+    currency: "USD",
+    source: "cloud",
+    updatedAt: Date.now() - 60_000,
+    netLiquidation: 1_000_000,
+    grossPositionValue: 1_600_000,
+    totalCashValue: -600_000,
+    cashBalances: [
+      { currency: "EUR", quantity: -250_000, baseValue: -300_000, baseCurrency: "USD" },
+      { currency: "JPY", quantity: -25_000_000, baseValue: -200_000, baseCurrency: "USD" },
+      { currency: "USD", quantity: -100_000, baseValue: -100_000, baseCurrency: "USD" },
+    ],
+    ...overrides,
+  };
+}
+
+function liveQuote(symbol: string, price: number, previousClose: number, currency: string, exchange: string): TickerFinancials {
+  const quote: Quote = {
+    symbol,
+    price,
+    change: price - previousClose,
+    changePercent: (price / previousClose - 1) * 100,
+    previousClose,
+    currency,
+    lastUpdated: Date.now() - 1_000,
+    listingExchangeName: exchange,
+    marketState: "REGULAR",
+    dataSource: "live",
+  };
+  return { annualStatements: [], quarterlyStatements: [], priceHistory: [], quote };
+}
+
+/**
+ * Real-time quotes for the stock and the euro listing, the stock `move`
+ * dollars above its mark. With `option`, the option is quoted at its mark too,
+ * so every position has a live price.
+ */
+export function marginQuotes({ move = 0, option = false }: { move?: number; option?: boolean } = {}): Map<string, TickerFinancials> {
+  return new Map([
+    ["AAA", liveQuote("AAA", 200 + move, 200, "USD", "NASDAQ")],
+    ["BBB", liveQuote("BBB", 100, 100, "EUR", "XETRA")],
+    ...(option ? [[OPTION, liveQuote(OPTION, 100, 100, "USD", "CBOE")] as const] : []),
+  ]);
+}