gloomberb 0.19.2 → 0.19.3

package/src/plugins/builtin/thirteenf/data.ts

@@ -15,6 +15,7 @@ import { isoDateDaysAgo, isoDateToday, isoDateYearsAgo } from "../../../utils/ca
 import { abortable, withDeadline } from "../../../utils/async-deadline";
 import { logFailure } from "../../../utils/log-failure";
 import {
+  amendmentKind,
   buildBrowserRows,
   filingGapFor,
   estimateFilingQuarterReturn,
@@ -33,6 +34,7 @@ import type {
   FundBrowserRow,
   FundDetailData,
   ThirteenFBrowserTab,
+  ThirteenFDetailLoading,
   ThirteenFFilingGap,
   ThirteenFFund,
   ThirteenFHoldingRecord,
@@ -162,9 +164,12 @@ async function loadBrowserPage(
   const pageApiOptions = { ...apiOptions, offset };
 
   if (tab === "performance") {
-    const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, pageApiOptions);
     const quarters = priorQuarters(quarter);
-    const history = await loadRankingHistory(quarters, signal, apiOptions);
+    // The prior quarters' rankings do not depend on this page, so they are read beside it.
+    const [topFunds, history] = await Promise.all([
+      listTopThirteenFFunds(quarter, browserLimit, signal, pageApiOptions),
+      loadRankingHistory(quarters, signal, apiOptions),
+    ]);
     const funds: ThirteenFFund[] = topFunds.map((fund) => ({ cik: fund.cik, name: fund.name }));
     const rows = buildBrowserRows({ topFunds, source: "performance" }).map(row => ({ ...row, priorReturns: quarters.map((previous, index) => ({ quarter: previous, value: history[index]?.get(row.cik) ?? null })) }));
     const result: BrowserLoadResult = {
@@ -183,7 +188,10 @@ async function loadBrowserPage(
 
   if (tab === "latest") {
     const filings = await listThirteenFFilings(isoDateDaysAgo(21, now), to, latestLimit, signal, pageApiOptions);
-    const selected = dedupeLatestForms(filings);
+    // An original filing or a restatement is its period's whole report, and an
+    // amendment of unknown kind shows no totals either way: only one that adds
+    // NEW HOLDINGS needs the fund's earlier filing for its quarter's totals.
+    const selected = dedupeLatestForms(filings).filter((form) => amendmentKind(form) === "new-holdings");
     const rows = buildBrowserRows({ latestFilings: filings, source: "latest" });
     const result: BrowserLoadResult = {
       rows,
@@ -516,12 +524,66 @@ export async function loadFundPerformance(
   };
 }
 
+/** Rows a fund's two newest reports may hold together for their holdings to be read ahead. */
+const PREFETCH_HOLDINGS_MAX = 2_000;
+
+/**
+ * Reads ahead what opening a fund asks first, while the cursor rests on its
+ * row: its filing list, which every other request waits on, and the holdings
+ * of its two newest reports when they hold PREFETCH_HOLDINGS_MAX rows or fewer
+ * together. A large filer's holdings wait for Enter. These are loadFundDetail's
+ * own requests, so opening the fund reads them from cache or joins them.
+ */
+export async function prefetchFundDetail(cik: string, signal: AbortSignal): Promise<void> {
+  const now = new Date();
+  const forms = await listThirteenFForms(cik, isoDateYearsAgo(4, now), isoDateToday(now), 100, signal);
+  const filings = buildPeriodReports(forms).slice(0, 2).flatMap((report) => report.filings);
+  const rows = filings.reduce((sum, form) => sum + (form.tableEntryTotal ?? Infinity), 0);
+  if (!filings.length || rows > PREFETCH_HOLDINGS_MAX) return;
+  await Promise.all(filings.map((form) => listThirteenFFormHoldings(cik, form.accessionNumber, signal, { entries: form.tableEntryTotal })));
+}
+
+/**
+ * One fund read ahead at a time (prefetchFundDetail): resting on another row
+ * stops the last one's requests, and `cancel` stops it when the list goes.
+ */
+export function createFundPrefetcher(prefetch: (cik: string, signal: AbortSignal) => Promise<void> = prefetchFundDetail) {
+  let current: { cik: string; controller: AbortController } | null = null;
+  return {
+    prefetch(cik: string) {
+      if (current?.cik === cik) return;
+      current?.controller.abort();
+      const entry = { cik, controller: new AbortController() };
+      current = entry;
+      void prefetch(cik, entry.controller.signal).catch(() => {
+        // Intentional ignore: a fund read ahead that fails is read again, and the failure shown, when it opens.
+      }).finally(() => {
+        if (current === entry) current = null;
+      });
+    },
+    cancel() {
+      current?.controller.abort();
+      current = null;
+    },
+  };
+}
+
+/**
+ * A fund's latest report and the one before it, with their holdings. With
+ * `onProgress`, the fund as it fills in: the latest report's holdings as
+ * soon as they are read (a large filing's first rows before the rest), then
+ * the prior quarter they are compared with and EDGAR's filing list, each
+ * part still loading named in `loading`. The answer is the whole fund.
+ */
 export async function loadFundDetail(
   cik: string,
   fallbackName: string,
   signal?: AbortSignal,
   /** `filingGap: false` skips EDGAR's filing list, for a load that never shows it (an overlap). */
-  options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & { filingGap?: boolean } = {},
+  options: Pick<Forms13FReadOptions, "forceRefresh" | "onSavedCopy"> & {
+    filingGap?: boolean;
+    onProgress?: (detail: FundDetailData) => void;
+  } = {},
 ): Promise<FundDetailData> {
   const now = new Date();
   const warnings: string[] = [];
@@ -541,47 +603,87 @@ export async function loadFundDetail(
   const previousReport = reports[1];
   const latestForm = latestReport?.filings.at(-1) ?? null;
   const previousForm = previousReport?.filings.at(-1) ?? null;
-  async function loadReport(report: ThirteenFPeriodReport | undefined): Promise<ThirteenFHoldingRecord[]> {
+  const checkGap = options.filingGap !== false;
+  const parts: Pick<FundDetailData, "latestHoldings" | "previousHoldings" | "filingGap"> & { loading: ThirteenFDetailLoading } = {
+    latestHoldings: [],
+    previousHoldings: [],
+    filingGap: null,
+    loading: { positions: true, ...(previousReport ? { comparison: true } : {}), ...(checkGap ? { filingGap: true } : {}) },
+  };
+  const detail = (): FundDetailData => {
+    const loading = Object.fromEntries(Object.entries(parts.loading).filter(([, value]) => value)) as ThirteenFDetailLoading;
+    return {
+      cik: normalizeCik(cik),
+      name: latestForm?.companyName || fallbackName,
+      forms,
+      latestForm,
+      previousForm,
+      latestHoldings: parts.latestHoldings,
+      previousHoldings: parts.previousHoldings,
+      latestReport,
+      previousReport,
+      warnings: [...warnings],
+      filingGap: parts.filingGap,
+      ...(saved.savedAt != null ? { savedAt: saved.savedAt } : {}),
+      ...(Object.keys(loading).length ? { loading } : {}),
+    };
+  };
+  let failed = false;
+  // The fund is shown once its latest holdings, or a large filing's first rows, are in.
+  const progress = () => {
+    if (!options.onProgress || failed || signal?.aborted || (parts.loading.positions && !parts.latestHoldings.length)) return;
+    options.onProgress(detail());
+  };
+  async function loadReport(report: ThirteenFPeriodReport | undefined, onFirstRows?: (rows: ThirteenFHoldingRecord[]) => void): Promise<ThirteenFHoldingRecord[]> {
     if (!report) return [];
-    const holdings: ThirteenFHoldingRecord[] = [];
-    for (const form of report.filings) {
-      const rows = await listThirteenFFormHoldings(cik, form.accessionNumber, signal, apiOptions);
-      holdings.push(...rows);
+    // An amended period's filings are read at once: the original and each of its additions.
+    const filings = await Promise.all(report.filings.map((form, index) => listThirteenFFormHoldings(cik, form.accessionNumber, signal, {
+      ...apiOptions,
+      entries: form.tableEntryTotal,
+      ...(index === 0 && onFirstRows ? { onFirstRows } : {}),
+    })));
+    report.filings.forEach((form, index) => {
+      const rows = filings[index]!;
       if (form.tableEntryTotal != null && rows.length !== form.tableEntryTotal) {
         report.complete = false;
         warnings.push(`${report.periodOfReport}: loaded ${rows.length} of ${form.tableEntryTotal} disclosed entries for ${form.accessionNumber}.`);
       }
-    }
+    });
     if (!report.complete && !warnings.some((warning) => warning.startsWith(report.periodOfReport))) {
       warnings.push(`${report.periodOfReport}: amendment type or original report unavailable; disclosed entries cannot be reconciled into a full report.`);
     }
-    return holdings;
+    return filings.flat();
   }
-  const [latestHoldings, previousHoldings, filingGap] = await Promise.all([
-    loadReport(latestReport),
+  await Promise.all([
+    loadReport(latestReport, options.onProgress ? (rows) => {
+      if (!parts.loading.positions) return;
+      parts.latestHoldings = rows;
+      progress();
+    } : undefined).then((rows) => {
+      parts.latestHoldings = rows;
+      parts.loading.positions = false;
+      progress();
+    }),
     loadReport(previousReport).catch((error) => {
       if (signal?.aborted) throw error;
       if (previousReport) previousReport.complete = false;
       warnings.push(`${previousReport?.periodOfReport ?? "Prior quarter"}: holdings unavailable; comparison unavailable.`);
       return [];
+    }).then((rows) => {
+      parts.previousHoldings = rows;
+      parts.loading.comparison = false;
+      progress();
     }),
-    options.filingGap === false ? null
-      : loadFilingGap(cik, latestForm?.periodOfReport, signal, now, { forceRefresh: options.forceRefresh }),
-  ]);
-  return {
-    cik: normalizeCik(cik),
-    name: latestForm?.companyName || fallbackName,
-    forms,
-    latestForm,
-    previousForm,
-    latestHoldings,
-    previousHoldings,
-    latestReport,
-    previousReport,
-    warnings,
-    filingGap,
-    ...(saved.savedAt != null ? { savedAt: saved.savedAt } : {}),
-  };
+    (checkGap ? loadFilingGap(cik, latestForm?.periodOfReport, signal, now, { forceRefresh: options.forceRefresh }) : Promise.resolve(null)).then((gap) => {
+      parts.filingGap = gap;
+      parts.loading.filingGap = false;
+      progress();
+    }),
+  ]).catch((error: unknown) => {
+    failed = true;
+    throw error;
+  });
+  return detail();
 }
 
 export async function loadFilingPositions(

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

@@ -6,13 +6,11 @@ import {
   inferBrowserTabFromQuery,
   isCikQuery,
 } from "./model";
-import { ThirteenFPane } from "./pane";
 import {
   attachThirteenFApiPersistence,
   resetThirteenFApiPersistence,
 } from "./api";
 import { thirteenFHeadless } from "./headless";
-import { ThirteenFTickerPane } from "./signals-pane";
 import { isKnownNonUsListing } from "../../../utils/sec";
 import { isKnownMutualFund } from "../../../tickers/instrument-kind";
 
@@ -32,7 +30,7 @@ export const thirteenFModule: PluginModule = {
       id: "thirteenf",
       name: "13F",
       order: 39,
-      component: ThirteenFTickerPane,
+      get component(): typeof import("./signals-pane").ThirteenFTickerPane { const { ThirteenFTickerPane } = require("./signals-pane"); return ThirteenFTickerPane; },
       instruments: ["equity", "fund"],
       isVisible: ({ ticker, financials }) => !isKnownNonUsListing(ticker) && !isKnownMutualFund(ticker, financials),
     });
@@ -47,7 +45,7 @@ export const thirteenFModule: PluginModule = {
       id: THIRTEENF_PANE_ID,
       name: "13F Funds",
       icon: "13F",
-      component: ThirteenFPane,
+      get component(): typeof import("./pane").ThirteenFPane { const { ThirteenFPane } = require("./pane"); return ThirteenFPane; },
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 112, height: 36 },

package/src/plugins/builtin/thirteenf/model.ts

@@ -547,6 +547,8 @@ export function estimateFilingQuarterReturn(data: FundDetailData, splits: SplitF
 
 export function hasComparable13FQuarter(data: FundDetailData): boolean {
   if (data.latestReport?.complete === false || data.previousReport?.complete === false) return false;
+  // Until both quarters are in whole, a line one of them lacks is not a buy or a sale.
+  if (data.loading?.positions || data.loading?.comparison) return false;
   const current = data.latestForm?.periodOfReport;
   const previous = data.previousForm?.periodOfReport;
   return adjacentQuarterPeriods(current, previous);

package/src/plugins/builtin/thirteenf/pane.tsx

@@ -23,7 +23,7 @@ import { nextHeaderSort } from "../../../utils/sort-values";
 import { useAssetData, usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { useMineTickers } from "../shared/mine-tickers";
 import { usePaneStatusFooter, usePaneStatusLinkFooter } from "../../../components/layout/pane/status-footer";
-import { corporateSplitFactor, loadBrowserRows, loadFilingPositions, loadFundDetail, loadSplitFactors } from "./data";
+import { corporateSplitFactor, createFundPrefetcher, loadBrowserRows, loadFilingPositions, loadFundDetail, loadSplitFactors } from "./data";
 import { FundOverlapView } from "./overlap-pane";
 import { ThirteenFCrowdingPane, ThirteenFTickerHoldingsView } from "./signals-pane";
 import { PaneFooterScope, savedCopyFooterInfo } from "../../../components/layout/pane/footer";
@@ -196,13 +196,11 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
     blurSearch();
     setDetailSeed({ cik: row.cik, name: row.name });
   }, [blurSearch]);
-  // Every request behind a fund detail is cached per path, so warming it
-  // while the cursor rests on the row makes Enter read from cache.
-  const prefetchDetail = useCallback((row: FundBrowserRow) => {
-    void loadFundDetail(row.cik, row.name).catch(() => {
-      // Intentional ignore: speculative prefetch is retried and failures are shown when the fund opens.
-    });
-  }, []);
+  // The fund's first requests are read ahead while the cursor rests on its
+  // row, one fund at a time, and stopped when the cursor moves on.
+  const prefetcher = useMemo(() => createFundPrefetcher(), []);
+  useEffect(() => () => prefetcher.cancel(), [prefetcher]);
+  const prefetchDetail = useCallback((row: FundBrowserRow) => prefetcher.prefetch(row.cik), [prefetcher]);
 
   const browserStatusInfo = useMemo<PaneFooterSegment[]>(() => [
         ...(loadingMore ? [{ id: "loading-more", parts: [{ text: "loading more", tone: "muted" as const }] }] : []),
@@ -372,7 +370,11 @@ export function FundDetailView({
     abortRef.current = controller;
     setStatus("loading");
     setError(null);
-    void loadFundDetail(seed.cik, seed.name, controller.signal, { forceRefresh: refresh })
+    void loadFundDetail(seed.cik, seed.name, controller.signal, {
+      forceRefresh: refresh,
+      // A first load shows the fund as it fills in; a refresh keeps what is on screen until it answers whole.
+      ...(refresh ? {} : { onProgress: (partial: FundDetailData) => { if (abortRef.current === controller) setData(partial); } }),
+    })
       .then((nextData) => {
         if (abortRef.current !== controller) return;
         setData(nextData);
@@ -392,6 +394,8 @@ export function FundDetailView({
       .catch((loadError) => {
         if (abortRef.current !== controller) return;
         if (loadError instanceof Error && loadError.name === "AbortError") return;
+        // A first load that failed after its first rows shows the error, not a part of the filing as the fund.
+        setData((current) => current?.loading ? null : current);
         setError(loadError instanceof Error ? loadError.message : String(loadError));
         setStatus("error");
       });
@@ -522,7 +526,10 @@ export function FundDetailView({
       ...(staleFiling ? { tone: "warning" as const } : {}) },
     data && hasComparable13FQuarter(data)
       ? { id: "compared", label: "Compared with", value: data.previousForm!.periodOfReport }
-      : { id: "compared", label: "Compared with", value: "No prior quarter", tone: "muted" },
+      // The quarter the changes will compare with, dim until both are in.
+      : data?.loading && hasComparable13FQuarter({ ...data, loading: undefined })
+        ? { id: "compared", label: "Compared with", value: data.previousForm!.periodOfReport, tone: "muted" }
+        : { id: "compared", label: "Compared with", value: "No prior quarter", tone: "muted" },
     ...(data?.latestReport && data.latestReport.filings.length > 1
       ? [{ id: "combined", label: "Combined", value: `${data.latestReport.filings.length} filings` }]
       : []),
@@ -593,7 +600,9 @@ export function FundDetailView({
         ]}
         meta={data?.name && data.name !== seed.name ? data.name : undefined}
       />
-      {activeTab === "overlap" && data ? <FundOverlapView data={data} focused={focused} width={width} /> : activeTab === "filings" ? (
+      {activeTab === "overlap" && data ? data.loading?.positions || data.loading?.comparison ? (
+        <PaneStatusBody loading align="center" loadingLabel="Loading 13F filing..." />
+      ) : <FundOverlapView data={data} focused={focused} width={width} /> : activeTab === "filings" ? (
         <DataTableStackView<FundTimelineRow, FundTimelineColumn>
           focused={focused}
           detailOpen={!!openFiling}

package/src/plugins/builtin/thirteenf/types.ts

@@ -101,6 +101,18 @@ export interface FundDetailData {
   filingGap?: ThirteenFFilingGap | null;
   /** A refresh failed and the oldest copy that answered instead was saved at this time (ms). */
   savedAt?: number;
+  /** The parts still loading, while the fund fills in (loadFundDetail's `onProgress`); absent once whole. */
+  loading?: ThirteenFDetailLoading;
+}
+
+/** Parts of a fund's detail still loading. */
+export interface ThirteenFDetailLoading {
+  /** The latest report's holdings are a large filing's first rows. */
+  positions?: boolean;
+  /** The prior quarter's holdings, which the latest are compared with. */
+  comparison?: boolean;
+  /** EDGAR's filing list, for a fund behind on its filings. */
+  filingGap?: boolean;
 }
 
 /** A manager a 13F-NT names as reporting its holdings. */

package/src/plugins/builtin/ticker-detail/data-panes/historical-prices.tsx

@@ -131,7 +131,9 @@ function buildHistoricalPriceRows(points: PricePoint[], venue: string | undefine
   const sorted = points
     .flatMap((point, sourceIndex) => {
       const date = pricePointDate(point);
-      return date ? [{ point: pricePointValues(point), date, sourceIndex, partial: point.partial === true, filled: point.filled === true }] : [];
+      return date ? [{
+        point: pricePointValues(point), date, sourceIndex, partial: point.partial === true, filled: point.filled === true, contract: point.contract,
+      }] : [];
     })
     .sort((left, right) => left.date.getTime() - right.date.getTime());
   const size = historyBarSize(sorted.map((entry) => entry.date.getTime()));
@@ -142,10 +144,21 @@ function buildHistoricalPriceRows(points: PricePoint[], venue: string | undefine
   const times = sorted.map((entry) => entry.date.getTime());
   const interval = size === "intraday" ? null : size;
   const afterGap = historyBarsAfterHole(times, interval);
-  const gapNotices = [historyMissingPeriodsNote(times, interval), historyChangeBaseNote(times, interval)]
-    .filter((notice): notice is string => notice != null);
+  // A continuous future's bar on another contract than the bar before has no change: two months' prices are no move.
+  let held: string | undefined;
+  const rolled = sorted.map((entry) => {
+    const roll = !!entry.contract && !!held && held !== entry.contract;
+    held = entry.contract ?? held;
+    return roll;
+  });
+  const rolls = sorted.flatMap((entry, index) => rolled[index] ? [`${entry.date.toISOString().slice(0, 10)} (${entry.contract})`] : []);
+  const gapNotices = [
+    historyMissingPeriodsNote(times, interval),
+    historyChangeBaseNote(times, interval),
+    rolls.length > 0 ? `No CHG at ${rolls.length === 1 ? "the roll" : "each roll"} to a new contract: ${rolls.join(", ")}` : null,
+  ].filter((notice): notice is string => notice != null);
   const rows = sorted.map((entry, index) => {
-    const previous = sorted[index - 1]?.point;
+    const previous = rolled[index] ? undefined : sorted[index - 1]?.point;
     const { point, date, sourceIndex, filled } = entry;
     const newest = index === sorted.length - 1;
     const partial = newest && (!!forming || dayToDate);

package/src/plugins/builtin/ticker-detail/data-panes/returns-history.ts

@@ -15,6 +15,10 @@ import type { DataProvider } from "../../../../types/data-provider";
 import type { PricePoint } from "../../../../types/financials";
 import { isRoundTheClockCoin } from "../../../../utils/crypto-pair";
 import { isCurrencyPairListing } from "../../../../utils/fx-market-hours";
+import { latestRegularSessionClose } from "../../../../market-data/market/freshness";
+import { futuresSessionOpenMinute } from "../../../../market-data/market/trading-sessions";
+import { calendarBarStart } from "../../../../time-series/chart-data";
+import { newestClosedSession, newestSessionClose, withOfficialCloses } from "../../../../time-series/official-close";
 import {
   effectiveReturnResolution,
   endsAtLatestBar,
@@ -39,6 +43,8 @@ export interface ReturnSeries {
   lastSession?: string;
   /** The venue whose sessions the window follows; empty when none is known. */
   venue: string;
+  /** The local date of the newest session, closed but without its official close yet: its last bar ends on the last trade. */
+  closingPrintPending?: string;
 }
 
 export interface ReturnSeriesRequest {
@@ -66,20 +72,76 @@ function historyErrorMessage(error: unknown, resolution: ManualChartResolution):
 /**
  * The venue whose sessions set where the window ends: the one the ticker
  * names, else the listing its quote names, so a bare VTI ends at the NYSE
- * Arca close on a weekend. Coins and currency pairs need none.
+ * Arca close on a weekend, with the listing's currency when that was read.
+ * Coins and currency pairs need none.
  */
-async function sessionVenue(provider: DataProvider, symbol: string, exchange: string): Promise<string> {
-  if (exchange || isRoundTheClockCoin(symbol) || isCurrencyPairListing(symbol, exchange)) return exchange;
+async function sessionVenue(provider: DataProvider, symbol: string, exchange: string): Promise<{ venue: string; currency?: string }> {
+  if (exchange || isRoundTheClockCoin(symbol) || isCurrencyPairListing(symbol, exchange)) return { venue: exchange };
   try {
     const metadata = provider.getQuoteMetadata
       ? await provider.getQuoteMetadata(symbol, exchange)
       : await provider.getQuote(symbol, exchange);
-    return metadata?.listingExchangeName ?? "";
+    return { venue: metadata?.listingExchangeName ?? "", ...(metadata?.currency ? { currency: metadata.currency } : {}) };
   } catch (error) {
-    return logFailure("ticker-detail.data-panes.returns-history", "Read return session venue failed", "")(error);
+    return { venue: logFailure("ticker-detail.data-panes.returns-history", "Read return session venue failed", "")(error) };
   }
 }
 
+const DAY_MS = 86_400_000;
+
+/**
+ * Intraday bars with each closed session's last bar on its official close
+ * (withOfficialCloses), so every total and the base they are measured from
+ * are the closes `history` and CMP give, not the last trade before the
+ * closing auction. Earlier sessions take their daily bar's close, dated by
+ * the venue's local date; the newest closed session the close
+ * newestSessionClose picks from the quote and its daily bar, or the note
+ * that its print is to come. Daily and longer bars, futures (which settle
+ * rather than close on a print) and listings without sessions are returned
+ * as loaded.
+ */
+async function withSessionCloses(
+  provider: DataProvider,
+  target: { symbol: string; exchange: string; venue: string; currency?: string },
+  interval: ManualChartResolution,
+  points: PricePoint[],
+  now: number,
+  context: { cacheMode: "refresh" } | undefined,
+): Promise<{ points: PricePoint[]; closingPrintPending?: string }> {
+  const venue = target.venue || undefined;
+  if (!isIntradayResolution(interval) || !points.length || futuresSessionOpenMinute(target.symbol, target.venue || target.exchange) != null
+    || !latestRegularSessionClose(venue, now)) return { points };
+  const newest = newestClosedSession(points, { venue, now });
+  // Whole UTC days, so the same window asks the same read (and its cached copy) all day.
+  const first = Math.floor(new Date(points[0]!.date).getTime() / DAY_MS) * DAY_MS - 2 * DAY_MS;
+  const end = Math.floor(Math.min(now, new Date(points.at(-1)!.date).getTime() + DAY_MS) / DAY_MS) * DAY_MS + DAY_MS - 1;
+  const [daily, quote] = await Promise.all([
+    fetchHistoryResult(provider, target.symbol, target.exchange, { kind: "detail", start: new Date(first), end: new Date(end), interval: "1d" }, context)
+      .catch(logFailure("ticker-detail.data-panes.returns-history", "Read the daily closes of a return window failed", null)),
+    // Only the newest closed session needs the quote's word on its close.
+    newest
+      ? Promise.resolve(provider.getQuote(target.symbol, target.exchange, context))
+        .catch(logFailure("ticker-detail.data-panes.returns-history", "Read the official close of a return window failed", null))
+      : null,
+  ]);
+  const dailyCloses = new Map<string, number>();
+  for (const bar of daily?.points ?? []) {
+    const time = new Date(bar.date).getTime();
+    if (!bar.partial && Number.isFinite(time) && Number.isFinite(bar.close) && bar.close > 0) {
+      dailyCloses.set(calendarBarStart(time, "1d", venue), bar.close);
+    }
+  }
+  const closes = new Map([...dailyCloses].filter(([date]) => date !== newest?.date));
+  const decided = newest
+    ? newestSessionClose(quote, { ...newest, venue, currency: target.currency ?? null, dailyClose: dailyCloses.get(newest.date) ?? null })
+    : null;
+  if (newest && decided && "close" in decided) closes.set(newest.date, decided.close);
+  return {
+    points: withOfficialCloses(points, closes, { venue, now }),
+    ...(newest && decided && "pending" in decided ? { closingPrintPending: newest.date } : {}),
+  };
+}
+
 /**
  * The bars of a return window and where it starts and ends, as RETURN, its
  * report and its capture all load them: the window ends now while the
@@ -91,7 +153,7 @@ export async function loadReturnSeries(provider: DataProvider, request: ReturnSe
   if (request.window) return loadReturnWindow(provider, request, request.window);
   const { symbol, exchange, range, support, now } = request;
   const interval = effectiveReturnResolution(range, request.resolution, support);
-  const venue = await sessionVenue(provider, symbol, exchange);
+  const { venue, currency } = await sessionVenue(provider, symbol, exchange);
   const windowEnd = returnWindowEnd({ symbol, exchange: venue }, now);
   const visibleFrom = returnVisibleFrom(range, interval, windowEnd.end, venue || undefined);
   const start = new Date(visibleFrom - returnLookbackMs(range, interval, support));
@@ -100,18 +162,24 @@ export async function loadReturnSeries(provider: DataProvider, request: ReturnSe
   let result;
   try {
     // Exact bounds first, then the interval's range history, as charts do
-    // when a source keeps no bars for the exact window.
-    result = await fetchHistoryResult(provider, symbol, exchange, { kind: "detail", start, end, interval }, context);
+    // when a source keeps no bars for the exact window or failed to load it
+    // (the range history may answer from a saved copy); the failure stands when that has none either.
+    let detailFailure: unknown = null;
+    result = await fetchHistoryResult(provider, symbol, exchange, { kind: "detail", start, end, interval }, context)
+      .catch((error: unknown) => { detailFailure = error; return null; });
     if (!result?.points.length) {
       result = await fetchHistoryResult(provider, symbol, exchange, { kind: "resolution", range: returnSupportRange(range), resolution: interval }, context) ?? result;
     }
+    if (!result?.points.length && detailFailure) throw detailFailure;
   } catch (error) {
     throw historyErrorMessage(error, interval);
   }
   if (!result) throw new Error("Price history unavailable");
   const latest = latestBarTime(result.points);
+  const closed = await withSessionCloses(provider, { symbol, exchange, venue, currency }, interval, result.points, now, context);
   return {
-    points: result.points,
+    points: closed.points,
+    ...(closed.closingPrintPending ? { closingPrintPending: closed.closingPrintPending } : {}),
     // A 1W to 5Y window's rows start after its base close, found among the bars by their session days.
     visibleFrom: endsAtLatestBar(range) && latest !== null && latest < windowEnd.end
       ? returnVisibleFrom(range, interval, latest, venue || undefined)
@@ -142,7 +210,7 @@ async function loadReturnWindow(provider: DataProvider, request: ReturnSeriesReq
   const step = CHART_RESOLUTION_STEP_MS[request.resolution];
   let interval = available.includes(request.resolution) ? request.resolution
     : available.find((candidate) => CHART_RESOLUTION_STEP_MS[candidate] >= step) ?? available.at(-1) ?? "1d";
-  const venue = await sessionVenue(provider, symbol, exchange);
+  const { venue, currency } = await sessionVenue(provider, symbol, exchange);
   const context = request.forceRefresh ? { cacheMode: "refresh" as const } : undefined;
   const load = async (resolution: ManualChartResolution) => {
     // A daily or longer bar is stamped at midnight UTC, so the window takes every bar from its first date's day, week or month on.
@@ -167,8 +235,10 @@ async function loadReturnWindow(provider: DataProvider, request: ReturnSeriesReq
     }
   }
   if (!loaded?.result) throw new Error("Price history unavailable");
+  const closed = await withSessionCloses(provider, { symbol, exchange, venue, currency }, interval, loaded.result.points, now, context);
   return {
-    points: loaded.result.points,
+    points: closed.points,
+    ...(closed.closingPrintPending ? { closingPrintPending: closed.closingPrintPending } : {}),
     visibleFrom: loaded.visibleFrom,
     visibleTo: Math.min(last, now),
     ...(loaded.result.coverageStart ? { coverageStart: loaded.result.coverageStart } : {}),

package/src/plugins/builtin/ticker-detail/headless.ts

@@ -52,6 +52,7 @@ import { DAY_SO_FAR_TEXT, withSessionBar } from "../../../time-series/session-ba
 import { buildReturnRows, closedMarketNote, isTodayReturnRow, returnBaseCloseDay, type ReturnRange } from "./data-panes/returns-model";
 import { periodBaseText } from "../../../market-data/market/period-return";
 import { loadReturnSeries } from "./data-panes/returns-history";
+import { CLOSING_PRINT_PENDING_TEXT } from "../../../time-series/official-close";
 import {
   closedHistoryBarDay, formingHistoryBar, HISTORY_DEFAULT_RANGE, historyBarDate, historyBarSize, historyBarSizeWord, historyDateHeader, isDailyOrLongerBar,
   type HistoryBarSize,
@@ -596,7 +597,10 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
       ...figures,
       ...forming || dayToDate ? [{ key: "partial", header: "Partial", format: (value: unknown) => value === true ? "true" : "" }] : [],
     ];
-    const textColumns: HeadlessPaneColumn[] = [timeColumn(true), ...figures];
+    // A narrow table drops the dollar moves, the interval's first, rather than putting Total % on a line under every row.
+    const textFigures = figures.map((column) => column.key === "intervalChange" ? { ...column, optional: true, dropPriority: 2 }
+      : column.key === "totalChange" ? { ...column, optional: true, dropPriority: 1 } : column);
+    const textColumns: HeadlessPaneColumn[] = [timeColumn(true), ...textFigures];
     // An interval the range is too long for is served in the nearest longer bar; say so rather than switch silently.
     const notices = [
       maxDrawdownLine,
@@ -619,8 +623,12 @@ export const returnsHeadless: HeadlessPaneDefinition<"rows"> = {
         oldest: null,
         ...(forming ? { periodToDate: forming } : closedDay ? { asOf: closedDay } : {}),
         ...(series.venue ? { cadenceExchange: series.venue } : {}),
-        // The window ends at the last session while the market is shut, which the status line says.
-        ...(series.lastSession ? { note: closedMarketNote(series.lastSession, series.visibleTo) } : {}),
+        // The window ends at the last session while the market is shut, which the status line says, and whether its
+        // last bar ends on the official close yet.
+        ...(series.lastSession || series.closingPrintPending ? { note: [
+          series.lastSession ? closedMarketNote(series.lastSession, series.visibleTo) : null,
+          series.closingPrintPending ? CLOSING_PRINT_PENDING_TEXT : null,
+        ].filter(Boolean).join(", ") } : {}),
         ...(dayToDate ? { basis: "daily bars", note: `the newest bar is ${DAY_SO_FAR_TEXT}` } : {}),
       },
       metadata: {