gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/analytics/account-returns.ts

@@ -0,0 +1,109 @@
+import { colors } from "../../../theme/colors";
+import type { BrokerPortfolioPerformance } from "../../../types/trading";
+import { formatNumber } from "../../../utils/format";
+import type { PriceHistoryIntegrity } from "../../../utils/price-history-integrity";
+import { formatReturn } from "./display";
+import { alignedAssetReturns, computeDatedBeta, computeSharpeRatio, type DatedReturn } from "./metrics";
+import type { AnalyticsMetricRow } from "./view";
+
+const MIN_ACCOUNT_RETURNS = 10;
+const TRADING_DAYS = 252;
+/** Weekends and holidays stretch a daily series to three or four calendar days at most. */
+const MAX_DAILY_GAP_DAYS = 4;
+
+/**
+ * The account's own daily returns, from the broker's time-weighted history.
+ * Unlike the basket of current holdings, these include financing, FX, options,
+ * shorts, fees and the trades actually made, so leveraged and foreign accounts
+ * are measured as they are. A money-weighted series mixes in deposit timing and
+ * is not used.
+ */
+export function accountDailyReturns(performance: BrokerPortfolioPerformance | null): DatedReturn[] | null {
+  if (!performance || performance.measure === "MWR") return null;
+  const points = [...performance.points]
+    .filter((point) => /^\d{4}-\d{2}-\d{2}$/.test(point.date))
+    .sort((left, right) => left.date.localeCompare(right.date));
+  const returns: DatedReturn[] = [];
+  for (let index = 1; index < points.length; index += 1) {
+    const previous = points[index - 1]!;
+    const point = points[index]!;
+    const value = Number.isFinite(point.dailyReturn)
+      ? point.dailyReturn!
+      : Number.isFinite(point.cumulativeReturn) && Number.isFinite(previous.cumulativeReturn) && previous.cumulativeReturn! > -1
+        ? (1 + point.cumulativeReturn!) / (1 + previous.cumulativeReturn!) - 1
+        : Number.NaN;
+    if (Number.isFinite(value)) returns.push({ startDateKey: previous.date, dateKey: point.date, value });
+  }
+  // The statistics below annualize daily returns; a weekly or monthly history would be misread.
+  const gaps = returns
+    .map((point) => (Date.parse(point.dateKey) - Date.parse(point.startDateKey)) / 86_400_000)
+    .sort((left, right) => left - right);
+  const medianGap = gaps[Math.floor(gaps.length / 2)] ?? Number.POSITIVE_INFINITY;
+  return returns.length >= MIN_ACCOUNT_RETURNS && medianGap <= MAX_DAILY_GAP_DAYS ? returns : null;
+}
+
+export function annualizedVolatility(returns: DatedReturn[]): number | null {
+  if (returns.length < MIN_ACCOUNT_RETURNS) return null;
+  const values = returns.map((point) => point.value);
+  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+  const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / (values.length - 1);
+  return Math.sqrt(variance * TRADING_DAYS);
+}
+
+/** Largest peak-to-trough fall of the compounded series, as a negative fraction. */
+export function maxDrawdown(returns: DatedReturn[]): number | null {
+  if (returns.length < MIN_ACCOUNT_RETURNS) return null;
+  let level = 1;
+  let peak = 1;
+  let worst = 0;
+  for (const point of returns) {
+    level *= 1 + point.value;
+    peak = Math.max(peak, level);
+    worst = Math.min(worst, level / peak - 1);
+  }
+  return worst;
+}
+
+function compactDate(value: string): string {
+  return new Date(`${value}T00:00:00Z`).toLocaleDateString("en-GB", {
+    day: "2-digit", month: "short", year: "2-digit", timeZone: "UTC",
+  }).replaceAll(" ", "");
+}
+
+function sampleWindow(sample: DatedReturn[]): string | undefined {
+  return sample.length
+    ? `${compactDate(sample[0]!.startDateKey)}–${compactDate(sample.at(-1)!.dateKey)} ·${sample.length}`
+    : undefined;
+}
+
+/** Risk rows measured on the account's own returns rather than estimated from holdings. */
+export function buildAccountRiskRows({
+  returns,
+  benchmarkReturns,
+  benchmarkIntegrity = null,
+}: {
+  returns: DatedReturn[];
+  benchmarkReturns: DatedReturn[];
+  benchmarkIntegrity?: PriceHistoryIntegrity | null;
+}): AnalyticsMetricRow[] {
+  const window = sampleWindow(returns);
+  const betaSample = alignedAssetReturns(returns, benchmarkReturns);
+  const sharpe = computeSharpeRatio(returns.map((point) => point.value));
+  const beta = benchmarkIntegrity ? null : computeDatedBeta(returns, benchmarkReturns);
+  const volatility = annualizedVolatility(returns);
+  const drawdown = maxDrawdown(returns);
+  const detail = window ? `Account · ${window}` : "Account";
+  return [
+    { id: "sharpe", label: "Sharpe", value: formatNumber(sharpe ?? undefined, 2), detail },
+    {
+      id: "beta",
+      label: "Beta (SPY)",
+      value: beta == null ? "—" : formatNumber(beta, 2),
+      detail: benchmarkIntegrity
+        ? "SPY benchmark: inconsistent OHLC history"
+        : beta == null ? "Insufficient overlap with SPY" : `Account · ${sampleWindow(betaSample)}`,
+    },
+    { id: "volatility", label: "Volatility", value: volatility == null ? "—" : formatReturn(volatility).replace("+", ""), detail },
+    { id: "max-drawdown", label: "Max drawdown", value: drawdown == null ? "—" : drawdown === 0 ? "0.00%" : formatReturn(drawdown), detail },
+  ].map((row) => ({ ...row, color: colors.textMuted }));
+}

package/src/plugins/builtin/analytics/broker-performance.ts

@@ -17,13 +17,15 @@ function findBrokerInstance(config: AppConfig, portfolio: Portfolio | null): Bro
   return config.brokerInstances.find((instance) => instance.id === portfolio.brokerInstanceId) ?? null;
 }
 
-function isConfiguredIbkrFlexProfile(instance: BrokerInstanceConfig): boolean {
+/** An IBKR profile that can supply account history: Flex statements or the Cloud connection. */
+function isIbkrHistoryProfile(instance: BrokerInstanceConfig): boolean {
   if (instance.brokerType !== "ibkr" || instance.enabled === false) return false;
   const config = instance.config ?? {};
   const flex = typeof config.flex === "object" && config.flex
     ? config.flex as Record<string, unknown>
     : {};
   const mode = instance.connectionMode ?? config.connectionMode;
+  if (mode === "cloud") return true;
   return mode === "flex"
     && typeof flex.token === "string"
     && flex.token.length > 0
@@ -42,7 +44,7 @@ function findBrokerPerformanceCandidates(
   const candidates = [primary];
   for (const instance of config.brokerInstances) {
     if (instance.id === primary.id) continue;
-    if (!isConfiguredIbkrFlexProfile(instance)) continue;
+    if (!isIbkrHistoryProfile(instance)) continue;
     candidates.push(instance);
   }
   return candidates;

package/src/plugins/builtin/analytics/display.ts

@@ -1,35 +1,3 @@
-import { colors } from "../../../theme/colors";
-import { formatCompactAmount } from "../../../utils/format";
-
-export function sharpeColor(sharpe: number): string {
-  if (sharpe > 1) return colors.positive;
-  if (sharpe < 0) return colors.negative;
-  return colors.textDim;
-}
-
-export function sharpeLabel(sharpe: number): string {
-  if (sharpe > 1) return "good";
-  if (sharpe >= 0) return "okay";
-  return "poor";
-}
-
-export function betaLabel(beta: number): string {
-  if (beta > 1.2) return "high vol";
-  if (beta >= 0.8) return "market";
-  return "defensive";
-}
-
-export function betaColor(beta: number): string {
-  if (beta > 1.2) return colors.negative;
-  if (beta >= 0.8) return colors.textMuted ?? colors.text;
-  return colors.positive;
-}
-
-// P&L moves with every streamed price; fixed decimals keep the percent detail after it still.
-export function formatSignedCompact(value: number | null): string {
-  return formatCompactAmount(value ?? undefined, { signed: true });
-}
-
 export function formatWeight(weight: number | null): string {
   if (weight == null || !Number.isFinite(weight)) return "—";
   return `${(weight * 100).toFixed(1)}%`;

package/src/plugins/builtin/analytics/index.tsx

@@ -5,11 +5,23 @@ import { portfolioRiskCache } from "./risk-client";
 import { Box, Text } from "../../../ui";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { TextAttributes } from "../../../ui";
-import { EmptyState, SectionHeading, Tabs, usePaneHeaderTabs, usePaneNoticeFooter } from "../../../components";
+import {
+  chartTableChromeRows,
+  ChartTableHeader,
+  EmptyState,
+  formatPercentAxis,
+  PaneStatusBody,
+  scalarPoint,
+  staticSeries,
+  usePaneNoticeFooter,
+  usePaneTabs,
+  type ChartTableChart,
+} from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
 import { colors } from "../../../theme/colors";
-import { convertCurrency } from "../../../utils/format";
+import { convertCurrency, formatCompactAmount } from "../../../utils/format";
+import { nextHeaderSort } from "../../../utils/sort-values";
 import {
   getFocusedCollectionId,
   useAppSelector,
@@ -20,12 +32,13 @@ import {
 import { useChartQueries, useFxRatesMap } from "../../../market-data/hooks";
 import { useLiveTickerFinancialsMap, useSampledValue } from "../../../state/hooks/live-ticker-financials";
 import { buildPortfolioFinancialsMap } from "../../../market-data/portfolio-financials";
-import { selectEffectiveExchangeRates } from "../../../utils/exchange-rate-map";
 import { usePortfolioAccountState } from "../portfolio-list/summary/live-accounts";
 import { calculatePortfolioSummaryTotals, type ColumnContext } from "../portfolio-list/metrics";
+import { accountDailyReturns, buildAccountRiskRows } from "./account-returns";
 import {
   buildPerformanceChartPoints,
   performanceHistoryNote,
+  resolvePerformanceMetric,
   useBrokerPortfolioPerformance,
 } from "./broker-performance";
 import {
@@ -40,8 +53,8 @@ import {
   buildPortfolioChartTargets,
   buildPortfolioReturnSeries,
   buildPortfolioBetaResult,
+  formatHistoryValueAxis,
   PORTFOLIO_BENCHMARK,
-  formatHistoryAxisValue,
   resolvePerformancePalette,
 } from "./pane-model";
 import {
@@ -49,18 +62,19 @@ import {
   buildSectorRowsFromPortfolioColumns,
   buildTrackedCurrencies,
   DEFAULT_SECTOR_SORT,
-  nextSectorSortPreference,
   sortSectorRows,
   type SectorSortPreference,
+  type SectorTableColumn,
 } from "./sector-model";
 import { describePortfolioTab, resolvePortfolioId, resolveTemplatePortfolioId } from "./portfolio-selection";
 import {
-  AnalyticsMetricsPanel,
-  PortfolioHistorySection,
+  analyticsFigures,
+  riskFigureNotices,
   SectorAllocationTable,
 } from "./view";
 
 const ANALYTICS_STATS_SAMPLE_MS = 5_000;
+const unavailableHistory = "Account history unavailable.";
 
 function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
   const focusedCollectionId = useAppSelector((state) => getFocusedCollectionId(state));
@@ -68,7 +82,6 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
   const baseCurrency = useAppSelector((state) => state.config.baseCurrency);
   const tickersBySymbol = useAppSelector((state) => state.tickers);
   const cachedFinancials = useAppSelector((state) => state.financials);
-  const cachedExchangeRates = useAppSelector((state) => state.exchangeRates);
   const brokerAccounts = useAppSelector((state) => state.brokerAccounts);
   const config = usePaneAppConfig();
   const paneInstance = usePaneInstance();
@@ -103,13 +116,14 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
     setCurrentPortfolioId(portfolioId);
     setSelectedSectorId(null);
   }, [setCurrentPortfolioId]);
-  const tabsInHeader = usePaneHeaderTabs(portfolioTabs.length > 0 ? {
+  const { strip: tabStrip, rows: tabRows } = usePaneTabs(portfolioTabs.length > 0 ? {
     tabs: portfolioTabs,
     activeValue: activePortfolioId,
     onSelect: handlePortfolioSelect,
     focused,
+    compact: true,
   } : null);
-  const tabRows = tabsInHeader ? 0 : 1;
+  const bodyHeight = Math.max(3, height - tabRows);
 
   const portfolioTickers = useMemo(() => {
     if (!activePortfolioId) return [];
@@ -166,31 +180,35 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
     () => buildPerformanceChartPoints(brokerPerformance.performance),
     [brokerPerformance.performance],
   );
+  // The broker's own daily returns, when it has them, replace the holdings basket for risk.
+  const accountReturns = useMemo(
+    () => accountDailyReturns(brokerPerformance.performance),
+    [brokerPerformance.performance],
+  );
   const accountStateInput = useMemo(() => ({ brokerAccounts, config }), [brokerAccounts, config]);
   const { accountState, accountsError } = usePortfolioAccountState(activePortfolio, accountStateInput);
   const trackedCurrencies = useMemo(
     () => [...buildTrackedCurrencies(portfolioTickers, financials, baseCurrency), accountState?.account.currency],
     [accountState?.account.currency, baseCurrency, financials, portfolioTickers],
   );
-  const fetchedExchangeRates = useFxRatesMap(trackedCurrencies);
-  const effectiveExchangeRates = selectEffectiveExchangeRates(fetchedExchangeRates, cachedExchangeRates);
+  const exchangeRates = useFxRatesMap(trackedCurrencies);
   const columnContext = useMemo<ColumnContext>(() => ({
     activeTab: activePortfolioId || undefined,
     baseCurrency,
-    exchangeRates: effectiveExchangeRates,
+    exchangeRates,
     now: Date.now(),
-  }), [activePortfolioId, baseCurrency, effectiveExchangeRates]);
+  }), [activePortfolioId, baseCurrency, exchangeRates]);
 
   const portfolioStats = useMemo(
     () => calculatePortfolioSummaryTotals(
       portfolioTickers,
       financials,
       baseCurrency,
-      effectiveExchangeRates,
+      exchangeRates,
       true,
       activePortfolioId || null,
     ),
-    [activePortfolioId, baseCurrency, effectiveExchangeRates, financials, portfolioTickers],
+    [activePortfolioId, baseCurrency, exchangeRates, financials, portfolioTickers],
   );
 
   const returnSeriesResult = useMemo(
@@ -258,14 +276,18 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
         value,
         accountState?.account.currency ?? "",
         baseCurrency,
-        effectiveExchangeRates,
+        exchangeRates,
       ),
     }),
-    [accountState, activePortfolio, baseCurrency, brokerPerformance.performance, effectiveExchangeRates, portfolioStats],
+    [accountState, activePortfolio, baseCurrency, brokerPerformance.performance, exchangeRates, portfolioStats],
   );
 
   const riskRows = useMemo(
-    () => hasPositions ? buildAnalyticsRiskRows({
+    () => !hasPositions ? [] : accountReturns ? buildAccountRiskRows({
+      returns: accountReturns,
+      benchmarkReturns: spyReturnSeries.returns,
+      benchmarkIntegrity: spyReturnSeries.integrity,
+    }) : buildAnalyticsRiskRows({
       sharpe,
       beta,
       coverage: returnSeriesResult.coverage,
@@ -280,37 +302,62 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
       benchmarkTimestamps: betaResult.benchmarkTimestamps,
       returns: portfolioReturnSeries,
       benchmarkReturns: spyReturnSeries.returns,
-    }) : [],
-    [beta, betaResult, hasPositions, returnSeriesResult, spyReturnSeries, sharpe],
+    }),
+    [accountReturns, beta, betaResult, hasPositions, returnSeriesResult, spyReturnSeries, sharpe],
   );
-  const metricsHeight = summaryRows.length === 0 && riskRows.length === 0
-    ? 0 : summaryRows.length + (riskRows.length > 0 ? riskRows.length + 5 : 3);
+  const figures = useMemo(() => analyticsFigures(summaryRows, riskRows, width), [riskRows, summaryRows, width]);
   const historyNote = performanceHistoryNote(brokerPerformance.performance);
+  const performance = brokerPerformance.performance;
+  const historyValues = performanceChartPoints.filter((point) => Number.isFinite(point.close)).length;
+  // Nothing else to show: the history's own state replaces the body instead of a footer warning.
+  const historyOnly = !hasPositions && figures.length === 0 && historyValues < 2;
   usePaneNoticeFooter({
     registrationId: "analytics:data-notices",
-    notices: [...allocationNotices.map((notice) => notice.text), ...(historyNote ? [historyNote] : [])],
+    notices: [
+      ...allocationNotices.map((notice) => notice.text),
+      ...(historyNote ? [historyNote] : []),
+      ...riskFigureNotices(riskRows),
+      ...(!historyOnly && brokerPerformance.error && !performance
+        ? [`${unavailableHistory} ${brokerPerformance.error}`] : []),
+      ...(performance && historyValues < 2 && !historyNote ? ["Account history needs at least two observations for a chart."] : []),
+    ],
     focused,
     enabled: hasPositions || hasAccountContent,
     title: "Portfolio data",
   });
-  const availableHistoryChartHeight = height - metricsHeight - 6 - tabRows;
-  const historyChartHeight = performanceChartPoints.filter((point) => Number.isFinite(point.close)).length >= 2 && availableHistoryChartHeight >= 5
-    ? Math.min(8, availableHistoryChartHeight)
-    : 0;
-  const showHistoryChart = historyChartHeight >= 5;
   const performancePalette = useMemo(
-    () => resolvePerformancePalette(brokerPerformance.performance),
-    [brokerPerformance.performance],
+    () => resolvePerformancePalette(performance),
+    [performance],
   );
-  const historyAxisLabel = buildHistoryAxisLabel({
-    performance: brokerPerformance.performance,
-  });
-  const formatHistoryAxis = useCallback((value: number) => (
-    formatHistoryAxisValue(value, brokerPerformance.performance)
-  ), [brokerPerformance.performance]);
+  // The account's own history: its value in the account currency, or its
+  // cumulative return in percent when the broker reports no value.
+  const historyChart = useMemo<ChartTableChart | null>(() => {
+    if (historyValues < 2) return brokerPerformance.loading && !performance ? { loading: true } : null;
+    const returns = resolvePerformanceMetric(performance) === "cumulativeReturn";
+    const series = [staticSeries(
+      performanceChartPoints.map((point) => scalarPoint(point.date, Number.isFinite(point.close) ? point.close * (returns ? 100 : 1) : null)),
+      {
+        id: "account-history",
+        label: returns ? "Broker return" : buildHistoryAxisLabel({ performance }),
+        color: performancePalette.lineColor,
+        calendarSpaced: true,
+      },
+    )];
+    return {
+      series,
+      formatValue: returns
+        ? (value: number) => `${value > 0 ? "+" : ""}${value.toFixed(2)}%`
+        : (value: number) => formatCompactAmount(value),
+      formatAxisValue: returns ? formatPercentAxis : formatHistoryValueAxis,
+      ...(performance?.stale ? { legendAccessory: <Text fg={colors.textDim}>cached</Text>, legendAccessoryWidth: 6 } : {}),
+      remoteKind: "portfolio-account-history",
+    };
+  }, [brokerPerformance.loading, historyValues, performance, performanceChartPoints, performancePalette]);
 
   const handleSectorHeaderClick = useCallback((columnId: string) => {
-    setSectorSort((current) => nextSectorSortPreference(current, columnId));
+    setSectorSort((current) => nextHeaderSort(current, columnId as SectorTableColumn["id"], {
+      resetTo: { columnId: null, direction: "asc" },
+    }));
   }, []);
 
   useEffect(() => {
@@ -327,17 +374,9 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
         </Box>
       ) : (
         <>
-          {!tabsInHeader && (
+          {tabStrip && (
             <Box flexDirection="row" height={1}>
-              <Box flexShrink={1} overflow="hidden">
-                <Tabs
-                  tabs={portfolioTabs}
-                  activeValue={activePortfolioId}
-                  onSelect={handlePortfolioSelect}
-                  compact
-                  focused={focused}
-                />
-              </Box>
+              <Box flexShrink={1} overflow="hidden">{tabStrip}</Box>
             </Box>
           )}
 
@@ -351,47 +390,39 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
                   : "Add holdings from the Portfolio pane (PF), or connect a broker in BR to sync them."}
               />
             </Box>
-          ) : (
-            <>
-              {metricsHeight > 0 && <AnalyticsMetricsPanel
-                summaryRows={summaryRows}
-                riskRows={riskRows}
-                height={metricsHeight}
-              />}
-
-              <PortfolioHistorySection
-                show={showHistoryChart}
-                loading={brokerPerformance.loading}
-                error={brokerPerformance.error}
-                width={width}
-                height={historyChartHeight}
-                points={performanceChartPoints}
-                palette={performancePalette}
-                axisLabel={historyAxisLabel}
-                period={brokerPerformance.performance?.period}
-                stale={brokerPerformance.performance?.stale}
-                formatAxisValue={formatHistoryAxis}
-              />
-
-              {hasPositions && (
-                <>
-                  <Box height={1} paddingX={1}>
-                    <SectionHeading title="Holdings by sector" />
-                  </Box>
-
-                  <SectorAllocationTable
-                    focused={focused}
-                    resetScrollKey={activePortfolioId}
-                    columns={sectorColumns}
-                    rows={sortedSectorRows}
-                    sort={sectorSort}
-                    selectedSectorId={effectiveSelectedSectorId}
-                    onHeaderClick={handleSectorHeaderClick}
-                    onSelectSector={setSelectedSectorId}
-                  />
-                </>
+          ) : historyOnly ? (
+            <PaneStatusBody
+              loading={brokerPerformance.loading}
+              error={brokerPerformance.error}
+              empty
+              subject="account history"
+              errorTitle={unavailableHistory}
+              emptyTitle="Account history needs at least two observations for a chart."
+            />
+          ) : hasPositions ? (
+            <SectorAllocationTable
+              focused={focused}
+              resetScrollKey={activePortfolioId}
+              columns={sectorColumns}
+              rows={sortedSectorRows}
+              sort={sectorSort}
+              selectedSectorId={effectiveSelectedSectorId}
+              onHeaderClick={handleSectorHeaderClick}
+              onSelectSector={setSelectedSectorId}
+              width={width}
+              height={bodyHeight}
+              before={(
+                <ChartTableHeader width={width} height={bodyHeight} tableRows={sortedSectorRows.length}
+                  tableChromeRows={chartTableChromeRows(sectorColumns, width)}
+                  figures={figures} chart={historyChart} />
               )}
-            </>
+            />
+          ) : (
+            // A cash-only account: the figures and its history take the body.
+            <Box flexDirection="column" height={bodyHeight}>
+              <ChartTableHeader width={width} height={bodyHeight} tableRows={0} tableChromeRows={0}
+                figures={figures} chart={historyChart} />
+            </Box>
           )}
         </>
       )}

package/src/plugins/builtin/analytics/metrics.ts

@@ -121,10 +121,6 @@ export function resolveDatedReturns(history: PricePoint[]): ReturnHistoryResult
   return { returns, integrity: null };
 }
 
-export function computeDatedReturns(history: PricePoint[]): DatedReturn[] {
-  return resolveDatedReturns(history).returns;
-}
-
 function validReturnInterval(point: DatedReturn): boolean {
   return typeof point.startDateKey === "string" && point.startDateKey < point.dateKey && Number.isFinite(point.value);
 }
@@ -170,28 +166,6 @@ export function computeDatedBeta(assetReturns: DatedReturn[], marketReturns: Dat
   return computeBeta(aligned.asset, aligned.market);
 }
 
-export interface SectorAllocation {
-  sector: string;
-  weight: number;
-  value: number;
-}
-
-export function computeSectorAllocation(
-  positions: Array<{ sector: string; marketValue: number }>,
-): SectorAllocation[] {
-  const sectorMap = new Map<string, number>();
-  let total = 0;
-  for (const pos of positions) {
-    const sector = pos.sector || "Unknown";
-    sectorMap.set(sector, (sectorMap.get(sector) ?? 0) + pos.marketValue);
-    total += pos.marketValue;
-  }
-  if (total === 0) return [];
-  return [...sectorMap.entries()]
-    .map(([sector, value]) => ({ sector, weight: value / total, value }))
-    .sort((a, b) => b.weight - a.weight || a.sector.localeCompare(b.sector));
-}
-
 export function hasPortfolioPosition(ticker: TickerRecord, portfolioId: string): boolean {
   return ticker.metadata.positions.some((position) => position.portfolio === portfolioId);
 }

package/src/plugins/builtin/analytics/pane-model.ts

@@ -1,10 +1,12 @@
 import { resolveChartPalette } from "../../../components/chart/core/palette";
+import type { CompositeAxisDomain } from "../../../components/chart/composite/types";
+import { spanDigits } from "../../../components/chart-table";
 import { colors, priceColor } from "../../../theme/colors";
 import type { TickerFinancials, PricePoint } from "../../../types/financials";
 import type { BrokerAccount, BrokerPortfolioPerformance } from "../../../types/trading";
 import type { Portfolio, TickerRecord } from "../../../types/ticker";
 import { formatCompact, formatCompactAmount, formatNumber, formatPercentRaw } from "../../../utils/format";
-import { formatRelativeAge } from "../../../utils/relative-time";
+import { formatRelativeAge } from "../../../utils/datetime-format";
 import type { PriceHistoryIntegrity } from "../../../utils/price-history-integrity";
 import { instrumentFromTicker, type ChartRequest, type TickerInstrumentOptions } from "../../../market-data/request-types";
 import { buildChartKey } from "../../../market-data/selectors";
@@ -16,10 +18,7 @@ import {
 import type { ColumnContext, PortfolioSummaryTotals } from "../portfolio-list/metrics";
 import type { ResolvedPortfolioAccountState } from "../portfolio-list/summary";
 import { buildPerformanceChartPoints, resolvePerformanceMetric } from "./broker-performance";
-import {
-  formatReturn,
-  formatSignedCompact,
-} from "./display";
+import { formatReturn } from "./display";
 import {
   resolveDatedReturns,
   alignedAssetReturns,
@@ -34,6 +33,7 @@ import {
 import { getPortfolioPositionValue } from "./sector-model";
 import type { AnalyticsMetricRow } from "./view";
 import { qualifySharpeCadence, qualifyReturnTimestamps, type SharpeCadenceResult, type ReturnTimestampResult, type TimestampHistory } from "./sharpe-cadence";
+import { isFiniteNumber } from "../../../utils/guards";
 
 export const PORTFOLIO_BENCHMARK = {
   symbol: "SPY", exchange: "ARCA", currency: "USD", isin: "US78462F1030",
@@ -67,12 +67,8 @@ function formatAccountFreshness(account: ResolvedPortfolioAccountState["account"
   return account.updatedAt ? formatRelativeAge(account.updatedAt) : null;
 }
 
-function finiteNumber(value: unknown): value is number {
-  return typeof value === "number" && Number.isFinite(value);
-}
-
 function formatMarginLeverage(netLiquidation: number | undefined, totalMarketValue: number): string | null {
-  if (!finiteNumber(netLiquidation) || netLiquidation <= 0 || !finiteNumber(totalMarketValue) || totalMarketValue < 0) return null;
+  if (!isFiniteNumber(netLiquidation) || netLiquidation <= 0 || !isFiniteNumber(totalMarketValue) || totalMarketValue < 0) return null;
   return `${(totalMarketValue / netLiquidation).toFixed(1)}x`;
 }
 
@@ -226,7 +222,7 @@ export function buildAnalyticsSummaryRows({
   const accountFreshness = formatAccountFreshness(account);
   const totalMarketValue = resolvePortfolioMarketValue(portfolioStats, account, convertAccountValue, basis);
   const netLiquidation = resolvePortfolioNetLiquidation(portfolioStats, account, convertAccountValue, basis);
-  const hasMarketValue = portfolioStats.hasPositions || finiteNumber(account?.grossPositionValue);
+  const hasMarketValue = portfolioStats.hasPositions || isFiniteNumber(account?.grossPositionValue);
 
   if (portfolioStats.unavailableConversions?.length || (account && !Number.isFinite(convertAccountValue(1)))) {
     rows.push({
@@ -273,22 +269,22 @@ export function buildAnalyticsSummaryRows({
     });
   }
 
-  if (portfolioStats.hasPositions || finiteNumber(account?.dailyPnl)) {
-    const dailyPnlPct = portfolioStats.hasPositions || finiteNumber(account?.netLiquidation)
+  if (portfolioStats.hasPositions || isFiniteNumber(account?.dailyPnl)) {
+    const dailyPnlPct = portfolioStats.hasPositions || isFiniteNumber(account?.netLiquidation)
       ? accountMetrics.dailyPnlPct : Number.NaN;
     rows.push({
       id: "day-pnl",
       label: "Day",
-      value: formatSignedCompact(accountMetrics.dailyPnl),
+      value: formatCompactAmount(accountMetrics.dailyPnl, { signed: true }),
       detail: `(${formatPercentRaw(dailyPnlPct)})`,
       color: priceColor(accountMetrics.dailyPnl),
     });
   }
-  if (portfolioStats.hasPositions || finiteNumber(account?.unrealizedPnl)) {
+  if (portfolioStats.hasPositions || isFiniteNumber(account?.unrealizedPnl)) {
     rows.push({
       id: "pnl",
       label: "P&L",
-      value: formatSignedCompact(accountMetrics.unrealizedPnl),
+      value: formatCompactAmount(accountMetrics.unrealizedPnl, { signed: true }),
       detail: `(${formatPercentRaw(accountMetrics.unrealizedPnlPct)})`,
       color: priceColor(accountMetrics.unrealizedPnl),
     });
@@ -297,7 +293,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "realized-pnl",
       label: "Realized",
-      value: formatSignedCompact(accountMetrics.realizedPnl),
+      value: formatCompactAmount(accountMetrics.realizedPnl, { signed: true }),
       color: priceColor(accountMetrics.realizedPnl),
     });
   }
@@ -456,6 +452,18 @@ export function buildHistoryAxisLabel({
     : "Return";
 }
 
+/**
+ * Compact account values whose decimals follow the plotted range, so the
+ * ticks stay apart: 55k / 60k across a wide range, 10.2k / 10.4k across a
+ * narrow one.
+ */
+export function formatHistoryValueAxis(value: number, domain: Pick<CompositeAxisDomain, "min" | "max">): string {
+  const magnitude = Math.max(Math.abs(domain.min), Math.abs(domain.max));
+  const [divisor, suffix] = magnitude >= 1e9 ? [1e9, "B"] : magnitude >= 1e6 ? [1e6, "M"] : magnitude >= 1e3 ? [1e3, "k"] : [1, ""];
+  const digits = spanDigits({ min: domain.min / divisor, max: domain.max / divisor });
+  return `${(value / divisor).toFixed(digits)}${suffix}`;
+}
+
 export function formatHistoryAxisValue(
   value: number,
   performance: BrokerPortfolioPerformance | null,