gloomberb 0.17.6 → 0.18.0

package/src/{plugins/builtin/portfolio-list → portfolio}/allocation.ts

@@ -1,8 +1,8 @@
-import type { Portfolio, PortfolioCash } from "../../../types/ticker";
-import type { BrokerAccount } from "../../../types/trading";
-import { currencyMinorDigits, getCurrencySymbol, resolveAssetDisplayKind } from "../../../market-data/market/format";
-import { formatNumber } from "../../../utils/format";
-import { parseTypedNumber } from "../../../utils/decimal-comma";
+import type { Portfolio, PortfolioCash } from "../types/ticker";
+import type { BrokerAccount } from "../types/trading";
+import { currencyMinorDigits, getCurrencySymbol, resolveAssetDisplayKind } from "../market-data/market/format";
+import { formatNumber } from "../utils/format";
+import { parseTypedNumber } from "../utils/decimal-comma";
 
 /**
  * Weights, targets and the trades that would rebalance a portfolio. `PF`, its
@@ -10,9 +10,10 @@ import { parseTypedNumber } from "../../../utils/decimal-comma";
  * here, so a weight never differs between them.
  *
  * A weight is a share of the total value, cash included: the priced holdings
- * at their net market value (a short counts against it) plus the cash line.
- * A holding without a price is left out of the total and the weights and is
- * listed as unpriced, never valued at zero.
+ * at their net market value plus the cash line. A book that holds a short
+ * weighs against its gross exposure instead (WeightBasis). A holding without
+ * a price is left out of the total and the weights and is listed as
+ * unpriced, never valued at zero.
  */
 
 /** The cash line's symbol in targets and reports. */
@@ -35,7 +36,7 @@ export interface AllocationHolding {
 }
 
 export interface AllocationFigures {
-  /** Percent of the total, cash included. */
+  /** Percent of the weight base: the total, cash included, or a hedged book's gross exposure. */
   weight: number | null;
   /** Percent. */
   targetWeight: number | null;
@@ -61,6 +62,10 @@ export interface PortfolioAllocation {
   cash: PortfolioCashLine | null;
   /** Priced holdings plus cash; null when it cannot be valued. */
   total: number | null;
+  /** What the weights are a share of. */
+  weightBasis: WeightBasis;
+  /** The amount they divide: the total, or the gross exposure; null when there is no positive one. */
+  weightBase: number | null;
   /** Held symbols without a price, left out of the total and the weights. */
   unpriced: string[];
   /** The targets of the listed symbols and cash added up; null when none is set. */
@@ -105,6 +110,52 @@ export function allocationFigures(
   return { weight, targetWeight, drift, tradeValue, tradeUnits };
 }
 
+/**
+ * What weights divide by. `total`: the total value, cash included, as a book
+ * without a short is weighed. `gross`: a book that holds a short weighs each
+ * position's signed value against its gross exposure, longs plus shorts at
+ * their absolute value, so the absolute weights add up to 100% however close
+ * to zero the hedge nets, or below it. Cash is no exposure and has no weight
+ * there.
+ */
+export type WeightBasis = "total" | "gross";
+
+/** Whether any held position is short: its value, or its units when it has no price, below zero. */
+function holdsShort(holdings: readonly AllocationHolding[]): boolean {
+  return holdings.some((holding) => holding.held && (finite(holding.marketValue) ? holding.marketValue < 0 : holding.units < 0));
+}
+
+/** What the weights of these holdings are a share of, and how much it is. */
+export function allocationWeightBase(
+  holdings: readonly AllocationHolding[],
+  cashValue: number | null | undefined,
+): { basis: WeightBasis; value: number | null } {
+  if (!holdsShort(holdings)) return { basis: "total", value: weightBase(allocationTotal(holdings, cashValue)) };
+  let gross = 0;
+  for (const holding of holdings) {
+    if (holding.held && finite(holding.marketValue)) gross += Math.abs(holding.marketValue);
+  }
+  return { basis: "gross", value: weightBase(gross) };
+}
+
+/** The line that says what a hedged book's weights are a share of; null on the total, which needs none. */
+export function weightBasisNote(
+  base: Pick<PortfolioAllocation, "weightBasis" | "weightBase">,
+  money: (value: number) => string,
+): string | null {
+  if (base.weightBasis !== "gross") return null;
+  const amount = base.weightBase != null ? ` (${money(base.weightBase)})` : "";
+  return `Weights are shares of gross exposure${amount}, longs plus shorts at their absolute value, as the book holds a short; cash has no weight.`;
+}
+
+/**
+ * One lot's share of the weight base, in percent. A ticker held in several lots
+ * weighs each by its own value; the lots add up to the ticker's weight.
+ */
+export function lotWeight(marketValue: number | null | undefined, total: number | null | undefined): number | null {
+  return allocationFigures({ held: true, marketValue: marketValue ?? null, units: 0, unitPrice: null }, total, null).weight;
+}
+
 /** The total weights divide by: every priced holding plus the cash. */
 export function allocationTotal(holdings: readonly AllocationHolding[], cashValue: number | null | undefined): number | null {
   // Cash that cannot be converted leaves the total unknown rather than smaller.
@@ -127,12 +178,15 @@ export function buildPortfolioAllocation({
   targets?: Readonly<Record<string, number>>;
 }): PortfolioAllocation {
   const total = allocationTotal(holdings, cashValue);
-  const rows = holdings.map((holding) => ({ ...holding, ...allocationFigures(holding, total, holdingTarget(targets, holding.symbol)) }));
+  const base = allocationWeightBase(holdings, cashValue);
+  const rows = holdings.map((holding) => ({ ...holding, ...allocationFigures(holding, base.value, holdingTarget(targets, holding.symbol)) }));
   const cashTarget = targets?.[CASH_SYMBOL];
   const cash = cashValue != null || finite(cashTarget)
     ? {
       value: cashValue ?? 0,
-      ...allocationFigures({ held: true, marketValue: cashValue ?? 0, units: 0, unitPrice: null }, total, cashTarget),
+      // Cash is no exposure: against a gross base it keeps its target but has no weight or trade.
+      ...allocationFigures({ held: true, marketValue: cashValue ?? 0, units: 0, unitPrice: null },
+        base.basis === "gross" ? null : base.value, cashTarget),
     }
     : null;
   let targetSum: number | null = null;
@@ -144,6 +198,8 @@ export function buildPortfolioAllocation({
     rows,
     cash,
     total,
+    weightBasis: base.basis,
+    weightBase: base.value,
     unpriced: holdings.filter((holding) => holding.held && !finite(holding.marketValue)).map((holding) => holding.symbol),
     targetSum,
   };
@@ -190,9 +246,15 @@ export function parseTargetWeight(raw: string | undefined): number {
 }
 
 /** A one-line note when the targets do not add up to the whole portfolio, else null. */
-export function describeTargetSum(targetSum: number | null): string | null {
+export function describeTargetSum(targetSum: number | null, basis: WeightBasis = "total"): string | null {
   if (targetSum == null || Math.abs(targetSum - 100) < 0.05) return null;
   const remainder = 100 - targetSum;
+  // Against gross exposure, what no target covers is not cash waiting: it is a short's share, or a holding without a target.
+  if (basis === "gross") {
+    return remainder > 0
+      ? `Targets add up to ${formatAllocationWeight(targetSum)} of gross exposure; ${formatAllocationWeight(remainder)} has no target.`
+      : `Targets add up to ${formatAllocationWeight(targetSum)}, ${formatAllocationWeight(-remainder)} over the gross exposure.`;
+  }
   return remainder > 0
     ? `Targets add up to ${formatAllocationWeight(targetSum)}; ${formatAllocationWeight(remainder)} is unallocated.`
     : `Targets add up to ${formatAllocationWeight(targetSum)}, ${formatAllocationWeight(-remainder)} over the whole portfolio.`;

package/src/{plugins/builtin/portfolio-list → portfolio}/column-values.ts

@@ -1,15 +1,15 @@
 // Public API: gloomberb/components re-exports getColumnValue, getSortValue and
 // ColumnContext from here, so external plugins depend on their names and shapes.
-import { comparablePriceEarnings, formatPriceEarnings } from "../../../utils/price-earnings";
-import { convertMarketCapitalization, listedMarketCapitalization } from "../../../utils/market-capitalization";
-import type { ColumnConfig } from "../../../types/config";
-import type { AnalystResearchData, CorporateActionsData, MarketState, TickerFinancials } from "../../../types/financials";
-import type { EarningsEvent } from "../../../types/data-provider";
-import type { TickerRecord } from "../../../types/ticker";
-import { colors, priceColor } from "../../../theme/colors";
-import { formatQuoteAgeWithSource, resolveQuoteAgeTimestamp } from "../../../market-data/quotes/time";
-import { formatFeedTime, formatShortDate, parseDisplayDate, type ShortDateOptions } from "../../../utils/datetime-format";
-import { convertCurrency, formatCompact, formatCompactAmount, formatNumber, formatPercentRaw } from "../../../utils/format";
+import { comparablePriceEarnings, formatPriceEarnings } from "../utils/price-earnings";
+import { convertMarketCapitalization, listedMarketCapitalization } from "../utils/market-capitalization";
+import type { ColumnConfig } from "../types/config";
+import type { AnalystResearchData, CorporateActionsData, MarketState, TickerFinancials } from "../types/financials";
+import type { EarningsEvent } from "../types/data-provider";
+import type { TickerRecord } from "../types/ticker";
+import { colors, priceColor } from "../theme/colors";
+import { formatQuoteAgeWithSource, resolveQuoteAgeTimestamp } from "../market-data/quotes/time";
+import { formatFeedTime, formatShortDate, parseDisplayDate, type ShortDateOptions } from "../utils/datetime-format";
+import { convertCurrency, formatCompact, formatCompactAmount, formatNumber, formatPercentRaw } from "../utils/format";
 import {
   formatMarketCost,
   quoteFormatOptions,
@@ -20,7 +20,7 @@ import {
   withCurrencyMinorDigits,
   withStablePriceDigits,
   type MarketFormatOptions,
-} from "../../../market-data/market/format";
+} from "../market-data/market/format";
 import {
   getActiveQuoteDisplay,
   getCompletedRegularSessionDisplay,
@@ -30,21 +30,25 @@ import {
   marketStateDot,
   quoteDotMarketState,
   type ActiveQuoteDisplay,
-} from "../../../market-data/market/status";
-import { formatOptionTicker } from "../../../utils/options";
-import { classifyInstrumentType } from "../../../tickers/instrument-kind";
-import { perpetualDisplaySymbol, perpetualListing } from "../../../tickers/perpetual-listing";
-import { currentListingName } from "../../../tickers/listing-name";
-import { PRICE_SPARKLINE_COLUMN_ID } from "../../../components/price-sparkline/view";
-import { followLiveSparklinePrice, resolveSparklineHistory, sparklineValues } from "../../../components/price-sparkline/model";
+} from "../market-data/market/status";
+import { formatOptionTicker } from "../utils/options";
+import { distributionHistory, forwardYieldMayHaveLapsed, lapsedDividend } from "../utils/forward-dividend";
+import { classifyInstrumentType } from "../tickers/instrument-kind";
+import { isIndexLevel, reportedQuoteVolume } from "../market-data/market/index-level";
+import { perpetualDisplaySymbol, perpetualListing } from "../tickers/perpetual-listing";
+import { currentListingName } from "../tickers/listing-name";
+import { PRICE_SPARKLINE_COLUMN_ID } from "../components/price-sparkline/view";
+import { followLiveSparklinePrice, resolveSparklineHistory, sparklineValues } from "../components/price-sparkline/model";
 import {
+  listingDividendYield,
   liveDividendYield,
   liveFiftyTwoWeekRange,
   liveForwardPE,
   liveMarketCapitalization,
   liveTrailingPE,
+  measuresTrailingYield,
   targetReferencePrice,
-} from "../../../market-data/quotes/live-valuation";
+} from "../market-data/quotes/live-valuation";
 import {
   getPortfolioPositionMetrics,
   getPortfolioQuoteDisplay,
@@ -52,14 +56,17 @@ import {
   resolvePortfolioPositionPnl,
   portfolioPnlPercent,
   signedPositionDirection,
+  type PortfolioPositionMetrics,
   type PortfolioPositionPnl,
-} from "../../../portfolio/position-metrics";
+} from "./position-metrics";
 import {
   getPortfolioValuationDisplay,
   getPortfolioValuationTime,
+  valuesAtSettlement,
   type PortfolioValuationBasis,
-} from "../../../portfolio/valuation-basis";
-import { isFiniteNumber } from "../../../utils/guards";
+} from "./valuation-basis";
+import { futuresQuantityText, futuresSettlementDisplay, type PortfolioFuturesTerms } from "./futures-positions";
+import { isFiniteNumber } from "../utils/guards";
 import {
   allocationFigures,
   formatAllocationDrift,
@@ -67,6 +74,7 @@ import {
   formatTradeUnits,
   holdingTarget,
   type AllocationFigures,
+  type WeightBasis,
 } from "./allocation";
 
 export interface ColumnContext {
@@ -79,11 +87,13 @@ export interface ColumnContext {
   /** What market values, P&L, weights and the day's move are priced at; the latest print when absent. */
   valuationBasis?: PortfolioValuationBasis;
   /**
-   * The total a portfolio's weights divide by: its priced holdings at net
-   * market value plus its cash (see allocation.ts). It may trail the rows by
-   * about a second.
+   * What a portfolio's weights divide by (allocationWeightBase): its priced
+   * holdings at net market value plus its cash, or, for a book that holds a
+   * short, its gross exposure. It may trail the rows by about a second.
    */
-  portfolioTotalMarketValue?: number;
+  portfolioWeightBase?: number;
+  /** Which of the two `portfolioWeightBase` is. */
+  portfolioWeightBasis?: WeightBasis;
   /** The portfolio's target weights in percent, by symbol. */
   portfolioTargets?: Readonly<Record<string, number>>;
   supplementalVersion?: number;
@@ -94,6 +104,13 @@ export interface ColumnContext {
   perpetuals?: ReadonlyMap<string, ListedPerpetual | null>;
   /** Moves whenever `perpetuals` does. */
   perpetualsVersion?: number;
+  /**
+   * Each future's contract size and settlement by symbol (loadPortfolioFuturesTerms):
+   * at the close a future is valued, and its Last shown, at its settlement.
+   */
+  futuresTerms?: ReadonlyMap<string, PortfolioFuturesTerms>;
+  /** Moves whenever `futuresTerms` does. */
+  futuresTermsVersion?: number;
 }
 
 /** A row's stock perpetual as PERP% and FUND 8H read it; rates are fractions. */
@@ -163,6 +180,17 @@ function positionSideLabel(ticker: TickerRecord, activeTab: string | undefined):
   return "MIX";
 }
 
+/** The currency a row is listed in: its position's, else its quote's; an index's level is in points and has none. */
+function listedCurrency(
+  positionCurrency: string | undefined,
+  quoteCurrency: string,
+  ticker: TickerRecord,
+  quote: TickerFinancials["quote"],
+): string {
+  if (!positionCurrency && isIndexLevel(quote?.instrumentType || ticker.metadata.assetCategory)) return "";
+  return (positionCurrency || quoteCurrency || ticker.metadata.currency || "").toUpperCase();
+}
+
 function compactText(value: string | null | undefined): string {
   const trimmed = value?.trim();
   return trimmed ? trimmed : "—";
@@ -207,6 +235,30 @@ function nextEarningsDate(symbol: string, ctx: ColumnContext): { pending: boolea
   };
 }
 
+/**
+ * DIV%: the yield at the live price; a trailing one as DVD measures it from
+ * the cash history once that has loaded (listingDividendYield), and none
+ * once a forward yield's dividend has stopped (lapsedDividend), pending while
+ * the history that says so loads.
+ */
+function currentDividendYield(
+  symbol: string,
+  quote: TickerFinancials["quote"],
+  fundamentals: TickerFinancials["fundamentals"],
+  ctx: ColumnContext,
+): { pending: boolean; value: number | null } {
+  const now = new Date(ctx.now);
+  // The rows the corporate actions are loaded for (usePortfolioSupplementalData); a trailing yield is never withdrawn, so it does not wait.
+  if (measuresTrailingYield(fundamentals)) {
+    return { pending: false, value: listingDividendYield(quote, fundamentals, mapData(ctx.corporateActions, symbol).data, now) ?? null };
+  }
+  const value = liveDividendYield(quote, fundamentals) ?? null;
+  if (value == null || !forwardYieldMayHaveLapsed(fundamentals, now)) return { pending: false, value };
+  const actions = mapData(ctx.corporateActions, symbol);
+  if (actions.pending) return { pending: true, value: null };
+  return { pending: false, value: lapsedDividend(fundamentals!.exDividendDate, distributionHistory(actions.data, now), now) ? null : value };
+}
+
 function exDividendDate(symbol: string, ctx: ColumnContext): { pending: boolean; date: Date | null } {
   const actions = mapData(ctx.corporateActions, symbol);
   if (actions.pending) return { pending: true, date: null };
@@ -272,7 +324,7 @@ function rowAllocation(
   return {
     ...allocationFigures(
       { held, marketValue, units: baseMetrics.totalShares, unitPrice },
-      ctx.portfolioTotalMarketValue,
+      ctx.portfolioWeightBase,
       holdingTarget(ctx.portfolioTargets, ticker.metadata.ticker),
     ),
     unpriced: held && marketValue == null,
@@ -312,6 +364,30 @@ export function resolvePortfolioPriceValue(
   return { text: "—" };
 }
 
+/**
+ * What Last and Chg show for a future valued at the close: the settlement it
+ * is valued at and the move from the one before, so its value is still Last
+ * times its quantity. Null on the latest print, or without a settlement.
+ */
+function settledHeadline(
+  metrics: PortfolioPositionMetrics,
+  ctx: Pick<ColumnContext, "valuationBasis">,
+  futures: PortfolioFuturesTerms | undefined,
+): ActiveQuoteDisplay | null {
+  return futures?.settlement && valuesAtSettlement(metrics, ctx.valuationBasis ?? "latest-print")
+    ? futuresSettlementDisplay(futures.settlement) : null;
+}
+
+/** One contract as the terms word it ("100 oz"), else its multiplier ("100"); none while the size is unknown. */
+function futuresContractSizeLabel(
+  futures: PortfolioFuturesTerms | undefined,
+  multiplier: number,
+  metrics: Pick<PortfolioPositionMetrics, "unknownContractSize">,
+): { size: string } | null {
+  if (futures?.size) return futures.size;
+  return !metrics.unknownContractSize && multiplier > 1 ? { size: formatMarketQuantity(multiplier) } : null;
+}
+
 export function getColumnValue(
   col: ColumnConfig,
   ticker: TickerRecord,
@@ -324,11 +400,12 @@ export function getColumnValue(
   const quoteCurrency = quote?.currency || ticker.metadata.currency || "USD";
 
   const positionMetrics = getPortfolioPositionMetrics(ticker, ctx.activeTab, quoteCurrency, undefined, quote);
+  const futures = positionMetrics.isFuture ? ctx.futuresTerms?.get(ticker.metadata.ticker) : undefined;
   // The latest print, which the quote columns read, and the price the position is valued at.
   const liveQuote = getPortfolioQuoteDisplay(positionMetrics, quote);
-  const activeQuote = getPortfolioValuationDisplay(positionMetrics, quote, ctx.valuationBasis);
+  const activeQuote = getPortfolioValuationDisplay(positionMetrics, quote, ctx.valuationBasis, futures?.settlement);
   const displayQuote = tradedQuoteDisplay(positionMetrics, liveQuote, quote);
-  const headlineQuote = headlineQuoteDisplay(displayQuote, quote);
+  const headlineQuote = settledHeadline(positionMetrics, ctx, futures) ?? headlineQuoteDisplay(displayQuote, quote);
   const { positionCurrency, totalShares, totalCost, totalCostUnits, totalPriceUnits, multiplierHint, brokerMarkPrice } = positionMetrics;
   const baseMetrics = getPortfolioPositionMetrics(ticker, ctx.activeTab, quoteCurrency, {
     currency: ctx.baseCurrency,
@@ -376,7 +453,7 @@ export function getColumnValue(
         ),
       };
     case "currency":
-      return { text: compactText((positionCurrency || quoteCurrency || ticker.metadata.currency || "").toUpperCase()) };
+      return { text: compactText(listedCurrency(positionCurrency, quoteCurrency, ticker, quote)) };
     case "sector":
       return { text: compactText(ticker.metadata.sector || financials?.profile?.sector) };
     case "industry":
@@ -417,11 +494,14 @@ export function getColumnValue(
         ? { text: formatPercentRaw(changePercent), color: marketChangeColor(changePercent, quote.marketState) }
         : { text: "—" };
     }
-    case "volume":
-      return { text: isFiniteNumber(quote?.volume) ? formatCompact(quote.volume, { fixedDecimals: true }) : "—" };
+    case "volume": {
+      const volume = reportedQuoteVolume(quote);
+      return { text: volume != null ? formatCompact(volume, { fixedDecimals: true }) : "—" };
+    }
     case "dollar_volume": {
-      if (!displayQuote || !isFiniteNumber(quote?.volume)) return { text: "—" };
-      return { text: formatCompact(toBaseQuote(displayQuote.price * quote.volume), { fixedDecimals: true }) };
+      const volume = reportedQuoteVolume(quote);
+      if (!displayQuote || volume == null) return { text: "—" };
+      return { text: formatCompact(toBaseQuote(displayQuote.price * volume), { fixedDecimals: true }) };
     }
     case "range_52w": {
       const position = fiftyTwoWeekPosition(displayQuote, quote);
@@ -437,8 +517,9 @@ export function getColumnValue(
     case "forward_pe":
       return { text: formatPriceEarnings(liveForwardPE(quote, fundamentals)) };
     case "dividend_yield": {
-      const dividendYield = liveDividendYield(quote, fundamentals);
-      return { text: dividendYield != null ? `${(dividendYield * 100).toFixed(2)}%` : "—" };
+      const dividendYield = currentDividendYield(ticker.metadata.ticker, quote, fundamentals, ctx);
+      if (dividendYield.pending) return { text: "…" };
+      return { text: dividendYield.value != null ? `${(dividendYield.value * 100).toFixed(2)}%` : "—" };
     }
     case "ext_hours": {
       const changePercent = getExtendedSessionDisplay(quote)?.changePercent;
@@ -448,17 +529,22 @@ export function getColumnValue(
     case "side":
       return { text: positionSideLabel(ticker, ctx.activeTab) ?? "—" };
     case "shares":
-      return { text: positionMetrics.positionCount > 0 ? formatMarketQuantity(totalShares, { ...formatOptions, maxWidth: col.width }) : "—" };
+      if (positionMetrics.positionCount === 0) return { text: "—" };
+      // A future counts contracts and says what one is: -1,000 × 100 oz. The table widens the column to fit.
+      return positionMetrics.isFuture
+        ? { text: futuresQuantityText(formatMarketQuantity(totalShares, formatOptions), futuresContractSizeLabel(futures, multiplierHint, positionMetrics)) }
+        : { text: formatMarketQuantity(totalShares, { ...formatOptions, maxWidth: col.width }) };
     case "avg_cost":
       if (totalCostUnits === 0 || !Number.isFinite(totalCost)) return { text: "—" };
       // A money cost keeps its currency's minor unit, as `portfolio show` prints it: 45.50, not 45.5.
       return { text: formatMarketCost(totalCost / Math.abs(totalCostUnits), { ...withCurrencyMinorDigits(formatOptions, positionCurrency), maxWidth: col.width }) };
     case "cost_basis":
-      if (baseMetrics.positionCount === 0 || !Number.isFinite(baseMetrics.totalCost)) return { text: "—" };
-      return { text: formatCompact(baseMetrics.totalCost) };
+      // Signed, as the value is: a short's cost is what it was sold for, negative.
+      if (baseMetrics.positionCount === 0 || !Number.isFinite(baseMetrics.signedCost)) return { text: "—" };
+      return { text: formatCompact(baseMetrics.signedCost) };
     case "mkt_value": {
       if (baseMetrics.positionCount === 0) return { text: "—" };
-      const marketValue = resolvePortfolioMarketValue(baseMetrics, activeQuote ? toBaseQuote(activeQuote.price) : null)?.gross;
+      const marketValue = resolvePortfolioMarketValue(baseMetrics, activeQuote ? toBaseQuote(activeQuote.price) : null)?.net;
       return { text: marketValue == null ? UNPRICED : formatCompactAmount(marketValue) };
     }
     case "weight": {
@@ -562,7 +648,7 @@ export function getColumnValue(
     case "latency":
       return { text: formatQuoteAgeWithSource(quote, ctx.now, { seconds: true }) };
     case "as_of": {
-      const time = getPortfolioValuationTime(quote, ctx.valuationBasis, positionMetrics);
+      const time = getPortfolioValuationTime(quote, ctx.valuationBasis, positionMetrics, futures?.settlement);
       if (!time) return { text: "—" };
       // In UTC, as the header says; a close the venue's calendar gives no hour for is dated by its day.
       return { text: time.dateOnly ? formatShortDate(time.time, MONTH_DAY) : formatFeedTime(time.time, ctx.now, "—", { utc: true }) };
@@ -586,10 +672,11 @@ export function getSortValue(
   const quoteCurrency = quote?.currency || ticker.metadata.currency || "USD";
 
   const positionMetrics = getPortfolioPositionMetrics(ticker, ctx.activeTab, quoteCurrency, undefined, quote);
+  const futures = positionMetrics.isFuture ? ctx.futuresTerms?.get(ticker.metadata.ticker) : undefined;
   const liveQuote = getPortfolioQuoteDisplay(positionMetrics, quote);
-  const activeQuote = getPortfolioValuationDisplay(positionMetrics, quote, ctx.valuationBasis);
+  const activeQuote = getPortfolioValuationDisplay(positionMetrics, quote, ctx.valuationBasis, futures?.settlement);
   const displayQuote = tradedQuoteDisplay(positionMetrics, liveQuote, quote);
-  const headlineQuote = headlineQuoteDisplay(displayQuote, quote);
+  const headlineQuote = settledHeadline(positionMetrics, ctx, futures) ?? headlineQuoteDisplay(displayQuote, quote);
   const { positionCurrency, totalShares, totalCost, totalCostUnits, totalPriceUnits, brokerMarkPrice } = positionMetrics;
   const baseMetrics = getPortfolioPositionMetrics(ticker, ctx.activeTab, quoteCurrency, {
     currency: ctx.baseCurrency,
@@ -616,7 +703,7 @@ export function getSortValue(
         ?? ticker.metadata.exchange
         ?? null;
     case "currency":
-      return (positionCurrency || quoteCurrency || ticker.metadata.currency || "").toUpperCase() || null;
+      return listedCurrency(positionCurrency, quoteCurrency, ticker, quote) || null;
     case "sector":
       return ticker.metadata.sector || financials?.profile?.sector || null;
     case "industry":
@@ -647,11 +734,11 @@ export function getSortValue(
     case "change_pct":
       return headlineChangePercent(headlineQuote, quote) ?? null;
     case "volume":
-      return quote?.volume ?? null;
-    case "dollar_volume":
-      return displayQuote && isFiniteNumber(quote?.volume)
-        ? toBaseQuote(displayQuote.price * quote.volume)
-        : null;
+      return reportedQuoteVolume(quote);
+    case "dollar_volume": {
+      const volume = reportedQuoteVolume(quote);
+      return displayQuote && volume != null ? toBaseQuote(displayQuote.price * volume) : null;
+    }
     case "range_52w":
       return fiftyTwoWeekPosition(displayQuote, quote);
     case "market_cap": {
@@ -663,7 +750,7 @@ export function getSortValue(
     case "forward_pe":
       return comparablePriceEarnings(liveForwardPE(quote, fundamentals));
     case "dividend_yield":
-      return liveDividendYield(quote, fundamentals) ?? null;
+      return currentDividendYield(ticker.metadata.ticker, quote, fundamentals, ctx).value;
     case "ext_hours":
       return getExtendedSessionDisplay(quote)?.changePercent ?? null;
     case "side":
@@ -673,9 +760,9 @@ export function getSortValue(
     case "avg_cost":
       return positionMetrics.priceBasis !== null && totalCostUnits !== 0 && Number.isFinite(totalCost) ? totalCost / Math.abs(totalCostUnits) : null;
     case "cost_basis":
-      return baseMetrics.positionCount > 0 && Number.isFinite(baseMetrics.totalCost) ? baseMetrics.totalCost : null;
+      return baseMetrics.positionCount > 0 && Number.isFinite(baseMetrics.signedCost) ? baseMetrics.signedCost : null;
     case "mkt_value":
-      return resolvePortfolioMarketValue(baseMetrics, activeQuote ? toBaseQuote(activeQuote.price) : null)?.gross ?? null;
+      return resolvePortfolioMarketValue(baseMetrics, activeQuote ? toBaseQuote(activeQuote.price) : null)?.net ?? null;
     case "weight":
       return rowAllocation(ticker, activeQuote, baseMetrics, toBaseQuote, ctx).weight;
     case "target_weight":
@@ -731,7 +818,7 @@ export function getSortValue(
     case "latency":
       return quote ? ctx.now - (resolveQuoteAgeTimestamp(quote, ctx.now) ?? ctx.now) : null;
     case "as_of":
-      return getPortfolioValuationTime(quote, ctx.valuationBasis, positionMetrics)?.time ?? null;
+      return getPortfolioValuationTime(quote, ctx.valuationBasis, positionMetrics, futures?.settlement)?.time ?? null;
     case PRICE_SPARKLINE_COLUMN_ID: {
       // The trend the sparkline draws: its window, closed by the live price.
       const history = followLiveSparklinePrice(financials?.priceHistory ?? [], quote, {