gloomberb 0.16.2 → 0.16.3

package/src/renderers/opentui/ui-host.tsx

@@ -2,6 +2,7 @@ import { RGBA, StyledText as OpenTuiStyledText, SyntaxStyle, TextAttributes as O
 import { createElement, forwardRef, useEffect, useRef, useState, type ReactNode } from "react";
 import { TextAttributes, type UiHost, type TextProps } from "../../ui/host";
 import { renderAsciiText } from "../../ui/ascii-font";
+import { scrollBoxScrollsVertically } from "../../ui/scroll-box-axis";
 import { OpenTuiImageSurface } from "./image/surface";
 import { OpenTuiChartSurface } from "./chart-surface";
 
@@ -141,7 +142,12 @@ function mapTextContent(content: unknown): unknown {
 }
 
 const OpenTuiBox = createOpenTuiPrimitive("box");
-const OpenTuiScrollBox = createOpenTuiPrimitive("scrollbox");
+const OpenTuiScrollBoxPrimitive = createOpenTuiPrimitive("scrollbox");
+// The native box scrolls vertically unless scrollY is false; the shared rule
+// also keeps the one-row horizontal strips from scrolling on that axis.
+const OpenTuiScrollBox = forwardRef<unknown, OpenTuiPrimitiveProps>(function OpenTuiScrollBox(props, ref) {
+  return createElement(OpenTuiScrollBoxPrimitive, { ...props, scrollY: scrollBoxScrollsVertically(props), ref });
+});
 const OpenTuiInput = createOpenTuiPrimitive("input");
 const OpenTuiTextarea = createOpenTuiPrimitive("textarea");
 const OpenTuiMediaSurface = createOpenTuiPrimitive("box");

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

@@ -1,5 +1,6 @@
 import { futuresGenericListing, futuresGenericPriceBasis } from "../../utils/futures-generic";
 import type { TimeRange } from "../../time-series/range";
+import { RANGE_HISTORY_RESOLUTION } from "../../time-series/resolution";
 import type {
   FinancialStatement,
   Fundamentals,
@@ -370,29 +371,24 @@ export function formatCloudDateTime(
   return `${year}-${month}-${day}`;
 }
 
+const HISTORY_OUTPUT_SIZE: Record<TimeRange, number> = {
+  "1D": 24 * 12,
+  "1W": 7 * 24,
+  "1M": 31,
+  "3M": 93,
+  "6M": 186,
+  "1Y": 366,
+  "5Y": 261,
+  "ALL": 600,
+};
+
+/** The bar size comes from the shared range table, which `gloomberb help history` also lists. */
 export function toHistoryRequest(range: TimeRange): {
   interval: string;
   outputsize: number;
   rangeKey: TimeRange;
 } {
-  switch (range) {
-    case "1D":
-      return { interval: "5min", outputsize: 24 * 12, rangeKey: range };
-    case "1W":
-      return { interval: "1h", outputsize: 7 * 24, rangeKey: range };
-    case "1M":
-      return { interval: "1day", outputsize: 31, rangeKey: range };
-    case "3M":
-      return { interval: "1day", outputsize: 93, rangeKey: range };
-    case "6M":
-      return { interval: "1day", outputsize: 186, rangeKey: range };
-    case "1Y":
-      return { interval: "1day", outputsize: 366, rangeKey: range };
-    case "5Y":
-      return { interval: "1week", outputsize: 261, rangeKey: range };
-    case "ALL":
-      return { interval: "1month", outputsize: 600, rangeKey: range };
-    default:
-      return { interval: "1day", outputsize: 366, rangeKey: range };
-  }
+  const resolution = RANGE_HISTORY_RESOLUTION[range];
+  if (!resolution) return { interval: "1day", outputsize: 366, rangeKey: range };
+  return { interval: toCloudInterval(resolution), outputsize: HISTORY_OUTPUT_SIZE[range], rangeKey: range };
 }

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

@@ -66,7 +66,7 @@ export class ProviderRouterBatchRoutes {
       const rawCached = selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, false);
       const cached = rawCached && (brokerSourceKeys.includes(rawCached.sourceKey)
         ? !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(rawCached.value, target.exchange))
-        : isProviderQuoteUsableForCurrentSession(rawCached.value, target.exchange, target.symbol))
+        : isProviderQuoteUsableForCurrentSession(rawCached.value, target.exchange, target.symbol, { recentAnswer: !rawCached.stale }))
         ? rawCached
         : null;
       if (cached && !forceRefresh && !cached.stale) {
@@ -93,7 +93,7 @@ export class ProviderRouterBatchRoutes {
       const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
       const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, options).catch(() => []);
       for (const item of batchResults) {
-        if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange, item.target.symbol)) continue;
+        if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange, item.target.symbol, { recentAnswer: true })) continue;
         const key = this.quoteBatchKey(item.target);
         const sourceKey = this.deps.providerSourceKey(batchProvider);
         for (const entry of providerIndexes.get(key) ?? []) {
@@ -162,7 +162,7 @@ export class ProviderRouterBatchRoutes {
         const key = this.cachedFinancialsBatchKey(item.target);
         let value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(item.financials));
         if (value && !item.target.instrument && !providerFinancialsMatchTarget(value, item.target.symbol, item.target.exchange)) continue;
-        if (value) value = dropUnusableProviderQuote(value, item.target.exchange);
+        if (value) value = dropUnusableProviderQuote(value, item.target.exchange, { recentAnswer: true });
         if (!value) continue;
         const sourceKey = this.deps.providerSourceKey(batchProvider);
         for (const entry of providerIndexes.get(key) ?? []) {

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

@@ -200,7 +200,7 @@ export class ProviderRouterFinancialRoutes {
     const rawCached = selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, false);
     const cachedIsStale = rawCached && (brokerSourceKeys.includes(rawCached.sourceKey)
       ? isQuoteContributionStaleForCurrentSession(quoteWithFreshnessExchange(rawCached.value, exchange))
-      : !isProviderQuoteUsableForCurrentSession(rawCached.value, exchange, ticker));
+      : !isProviderQuoteUsableForCurrentSession(rawCached.value, exchange, ticker, { recentAnswer: !rawCached.stale }));
     const cached = rawCached && !cachedIsStale
       ? rawCached
       : null;
@@ -259,7 +259,7 @@ export class ProviderRouterFinancialRoutes {
       if (
         record
         && (includeStale || !record.stale)
-        && isProviderQuoteUsableForCurrentSession(record.value, exchange, ticker)
+        && isProviderQuoteUsableForCurrentSession(record.value, exchange, ticker, { recentAnswer: !record.stale })
       ) {
         return record.value;
       }

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

@@ -7,7 +7,16 @@ import { redactUnavailableFundamentals, RETRACTABLE_VALUATION_FIELDS } from "../
 import { isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshness";
 import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import { parsePublicTickerKey } from "../../utils/exchanges";
-import { activeUsMarketSession, delayedFeedLagMs, isMiddayBreakPrint, isUsPriorSessionPremarketQuote } from "../../market-data/market/freshness";
+import {
+  activeUsMarketSession,
+  delayedFeedLagMs,
+  isMiddayBreakPrint,
+  isRegularSessionTime,
+  isUsPostSessionPrint,
+  isUsPriorSessionPremarketQuote,
+  isUsRegularCloseQuoteInPostSession,
+  latestRegularSessionOpen,
+} from "../../market-data/market/freshness";
 import {
   mergeQuoteContributionMaps,
   isQuoteContributionStaleForCurrentSession,
@@ -122,7 +131,42 @@ function isQuoteInActiveSession(quote: Quote, now: number): boolean {
   return false;
 }
 
-function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
+// An opening auction can print before the continuous open (Hong Kong's at 09:20).
+const OPENING_AUCTION_MS = 15 * 60_000;
+
+/**
+ * Whether Gloom Cloud vouches that a delayed quote is current, however long
+ * ago its last trade was. The service judges more than that trade's age: it
+ * knows when it asked for the quote and how often the listing trades, so a
+ * thinly traded listing's hour-old trade can be the current price while its
+ * venue trades. Its verdict stands in for the age bound when:
+ * - the service answered on this request, or a cache entry still inside its
+ *   TTL holds that answer (`recentAnswer`); a copy past the TTL is not vouched for;
+ * - the answer says `stale: false`. One without the flag vouches for nothing,
+ *   and one flagged stale never gets this far;
+ * - the quote is delayed. The service bounds a delayed quote's feed age itself
+ *   but not a real-time one's, so real-time quotes keep the age bound;
+ * - it reports the regular session, the venue's session is in progress as
+ *   the delayed feed shows it, and the trade belongs to that session; or it
+ *   reports a US after-hours price, the after-hours session is in progress and
+ *   the trade belongs to it.
+ * The answer says nothing about how often a listing trades, so a liquid
+ * listing the service wrongly vouches for is accepted too. The service's own
+ * bound for liquid listings, about twenty minutes, is tighter than this one.
+ */
+function isVouchedCurrentByService(quote: Quote, exchange: string | undefined, now: number): boolean {
+  if (quote.providerId !== "gloomberb-cloud" || quote.stale !== false || quote.dataSource !== "delayed") return false;
+  if (quote.marketState === "POST") {
+    return finitePositiveNumber(quote.postMarketPrice) && isUsPostSessionPrint(quote.lastUpdated, exchange, now);
+  }
+  if (quote.marketState !== "REGULAR") return false;
+  const feedTime = now - delayedFeedLagMs(exchange);
+  if (isRegularSessionTime(exchange, feedTime) !== true) return false;
+  const open = latestRegularSessionOpen(exchange, feedTime);
+  return open != null && quote.lastUpdated >= open - OPENING_AUCTION_MS;
+}
+
+function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now(), recentAnswer = false): boolean {
   // The shared freshness predicate already validates and dates a daily NAV.
   if (quote.priceObservation === "nav") return false;
   if (!isQuoteInActiveSession(quote, now)) return false;
@@ -132,12 +176,17 @@ function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
   if (isUsPriorSessionPremarketQuote(quote.lastUpdated, exchange, quote.marketState, now)) {
     return false;
   }
+  // Likewise today's regular close before any after-hours trade.
+  if (quote.postMarketPrice == null && isUsRegularCloseQuoteInPostSession(quote.lastUpdated, exchange, quote.marketState, now)) {
+    return false;
+  }
   if (!Number.isFinite(quote.lastUpdated)) return false;
   const delayed = quote.dataSource === "delayed";
   const maxAge = delayed ? ACTIVE_DELAYED_PROVIDER_QUOTE_MAX_AGE_MS : ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS;
   if (now - quote.lastUpdated <= maxAge) return false;
   // While the venue pauses at midday, the morning's last print is the current price.
-  return !isMiddayBreakPrint(quote.lastUpdated, exchange, now, delayed ? delayedFeedLagMs(exchange) : 0);
+  if (isMiddayBreakPrint(quote.lastUpdated, exchange, now, delayed ? delayedFeedLagMs(exchange) : 0)) return false;
+  return !(recentAnswer && isVouchedCurrentByService(quote, exchange, now));
 }
 
 export function providerQuoteMatchesTarget(quote: Quote | null | undefined, symbol?: string, exchange?: string): quote is Quote {
@@ -157,11 +206,21 @@ export function providerQuoteMatchesTarget(quote: Quote | null | undefined, symb
   return true;
 }
 
-export function isProviderQuoteUsableForCurrentSession(quote: Quote | null | undefined, exchange?: string, symbol?: string): quote is Quote {
+/**
+ * `recentAnswer`: the source answered with this quote on this request, or a
+ * cache entry still inside its TTL holds it. Only then can the source's own
+ * verdict on a delayed quote stand in for the age bound.
+ */
+export function isProviderQuoteUsableForCurrentSession(
+  quote: Quote | null | undefined,
+  exchange?: string,
+  symbol?: string,
+  options: { recentAnswer?: boolean } = {},
+): quote is Quote {
   if (!providerQuoteMatchesTarget(quote, symbol, exchange)) return false;
   const normalized = quoteWithFreshnessExchange(quote, exchange);
   if (isQuoteStaleForCurrentSession(normalized)) return false;
-  if (isActiveProviderQuoteTooOld(normalized)) return false;
+  if (isActiveProviderQuoteTooOld(normalized, Date.now(), options.recentAnswer === true)) return false;
   // Futures may trade or settle at zero or negative prices. Require explicit
   // source type metadata; an alias alone cannot establish the price domain.
   const futures = ["FUT", "FUTURE", "FUTURES"].includes(normalized.instrumentType?.trim().toUpperCase() ?? "");
@@ -188,8 +247,12 @@ export function providerFinancialsMatchTarget(value: TickerFinancials, symbol: s
   return quoteMetadataMatchesTarget(metadata, hasListing ? symbol : parsePublicTickerKey(symbol).symbol, hasListing ? exchange : undefined);
 }
 
-export function dropUnusableProviderQuote(value: TickerFinancials, exchange?: string): TickerFinancials {
-  if (!value.quote || isProviderQuoteUsableForCurrentSession(value.quote, exchange)) {
+export function dropUnusableProviderQuote(
+  value: TickerFinancials,
+  exchange?: string,
+  options: { recentAnswer?: boolean } = {},
+): TickerFinancials {
+  if (!value.quote || isProviderQuoteUsableForCurrentSession(value.quote, exchange, undefined, options)) {
     return value;
   }
 

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

@@ -73,7 +73,7 @@ export class ProviderRouterPrimaryRoutes {
         if (rawValue && !context?.instrument && !providerFinancialsMatchTarget(rawValue, ticker, exchange)) continue;
         const resolvedValue = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(rawValue));
         if (resolvedValue && !context?.instrument && !providerFinancialsMatchTarget(resolvedValue, ticker, exchange)) continue;
-        let value = resolvedValue ? dropUnusableProviderQuote(resolvedValue, exchange) : null;
+        let value = resolvedValue ? dropUnusableProviderQuote(resolvedValue, exchange, { recentAnswer: true }) : null;
         if (!value) continue;
         const sourceKey = this.options.providerSourceKey(provider);
         if (context?.statementHistory === "extended" && !hasReusableExtendedHistory(value)) {
@@ -187,7 +187,7 @@ export class ProviderRouterPrimaryRoutes {
     for (const provider of this.options.providersInPriorityOrder()) {
       try {
         const quote = await provider.getQuote(ticker, exchange, context);
-        if (!isProviderQuoteUsableForCurrentSession(quote, exchange, ticker)) continue;
+        if (!isProviderQuoteUsableForCurrentSession(quote, exchange, ticker, { recentAnswer: true })) continue;
         const sourceKey = this.options.providerSourceKey(provider);
         this.options.cacheResource(
           "quote",

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/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] : []),
+  ]);
+}

package/src/time-series/resolution.ts

@@ -37,6 +37,21 @@ const RANGE_PRESET_RESOLUTION: Record<TimeRange, ManualChartResolution> = {
   "ALL": "1mo",
 };
 
+/**
+ * The bar size a price history for a range is served in, unlike the chart
+ * presets above: what `gloomberb history` and the historical prices pane get.
+ */
+export const RANGE_HISTORY_RESOLUTION: Readonly<Record<TimeRange, ManualChartResolution>> = {
+  "1D": "5m",
+  "1W": "1h",
+  "1M": "1d",
+  "3M": "1d",
+  "6M": "1d",
+  "1Y": "1d",
+  "5Y": "1wk",
+  "ALL": "1mo",
+};
+
 const RANGE_PRELOAD_BUFFER: Record<TimeRange, TimeRange> = {
   "1D": "1W",
   "1W": "1M",

package/src/types/financials.ts

@@ -38,7 +38,21 @@ export interface QuoteMetadata {
   fieldSources?: Partial<Record<"currency" | "instrumentType", QuoteMetadataSource>>;
 }
 
-export interface Quote {
+/**
+ * What a record's share counts count: depositary receipts or the ordinary
+ * shares behind them. Gloom Cloud states it only when it established it.
+ */
+export type ShareBasis = "depositary_receipt" | "ordinary";
+
+/** How a depositary receipt relates to the ordinary shares, as Gloom Cloud states it. */
+interface DepositaryReceiptFacts {
+  /** Whether the listing is a depositary receipt; absent when unknown. */
+  isDepositaryReceipt?: boolean;
+  /** Ordinary shares per receipt, on a receipt's own records. */
+  adrRatio?: number;
+}
+
+export interface Quote extends DepositaryReceiptFacts {
   /** Applies to this price observation; a stored position cannot supply it. */
   priceBasis?: PriceBasis;
   /** Daily fund net asset value; independent of the units used to format its price. */
@@ -109,7 +123,11 @@ export interface QuoteContribution extends Quote {
 
 export type QuoteContributionMap = Record<string, QuoteContribution>;
 
-export interface Fundamentals {
+export interface Fundamentals extends DepositaryReceiptFacts {
+  /** Every share count here is on this basis, the basis of the listing's price and market cap; absent when unproven. */
+  shareBasis?: ShareBasis;
+  /** On a receipt, the ordinary shares behind `sharesOutstanding`. */
+  underlyingOrdinaryShares?: number;
   source?: "gloom";
   fetchedAt?: string;
   stale?: boolean;
@@ -180,6 +198,8 @@ export interface HolderRecord {
   percentHeld?: number;
   changeShares?: number;
   changePercent?: number;
+  /** Set when the position's filing ties it to the receipts or to the ordinary shares. */
+  shareBasis?: ShareBasis;
 }
 
 interface HolderSummary {
@@ -189,11 +209,18 @@ interface HolderSummary {
   institutionsCount?: number;
 }
 
-export interface HolderData {
+export interface HolderData extends DepositaryReceiptFacts {
   providerId?: string;
   symbol: string;
   name?: string;
+  /** The listing's price currency. */
   currency?: string;
+  /** The currency of `value`, which can differ from the listing's (USD on a London line priced from 13F filings). */
+  valueCurrency?: string;
+  /** Reported shares times the latest price, or times the price at the report date. */
+  valueBasis?: "latest_price" | "period_end_price";
+  /** Set when every row is on one basis. */
+  shareBasis?: ShareBasis;
   exchange?: string;
   asOf?: string;
   summary?: HolderSummary;
@@ -430,6 +457,8 @@ export interface ReportedEarningsCohort {
 export interface EarningsResultProvenance { version: 1; reported: ReportedEarningsCohort }
 
 export interface FinancialStatement {
+  /** The basis of this row's share counts and per-share earnings; absent when unproven. */
+  shareBasis?: ShareBasis;
   /** @deprecated No longer populated. */
   earningsResult?: EarningsResultProvenance;
   /** EPS lines unavailable for this period, for example because they disagree with the row's own income and shares. */

package/src/ui/host.tsx

@@ -108,6 +108,12 @@ export interface SyntaxStyleLike {
   }): number;
 }
 
+/** Where a drag has a box this frame: an offset in cells from where it is laid out. */
+export interface LiveBoxFrame {
+  dx: number;
+  dy: number;
+}
+
 export interface BoxRenderable {
   x?: number;
   y?: number;
@@ -117,6 +123,12 @@ export interface BoxRenderable {
   absoluteY?: number;
   absoluteBounds?: { x: number; y: number; width: number; height: number };
   getBoundingClientRect?: () => { x: number; y: number; width: number; height: number };
+  /**
+   * Desktop only: draws the box at `frame` by restyling its own element, with
+   * no render, until it is called with null. The offset rides the compositor,
+   * so it costs no layout or repaint.
+   */
+  setLiveFrame?: (frame: LiveBoxFrame | null) => void;
   [key: string]: unknown;
 }