gloomberb 0.16.4 → 0.16.6

package/src/plugins/builtin/research-search/pane.tsx

@@ -20,7 +20,6 @@ import {
 } from "../../../components";
 import { TickerBadgeList } from "../../../components/ticker/badge/list";
 import { useShortcut } from "../../../react/input";
-import { useInlineTickerOpener } from "../../../state/hooks/inline-tickers";
 import { colors } from "../../../theme/colors";
 import { Box, type InputRenderable, type ScrollBoxRenderable } from "../../../ui";
 import { useDialog } from "../../../ui/dialog";
@@ -51,6 +50,8 @@ import {
 } from "./data";
 import { useDocumentFocusRequest } from "./focus-handoff";
 import { SearchDocumentView } from "./document-view";
+import { searchArticle } from "./article";
+import { useOpenTickerChoice } from "../shared/ticker-choice";
 import { SavedSearchesView } from "./saved-view";
 import {
   buildResultColumns,
@@ -97,7 +98,6 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
   const openPlan = useCloudPlanAction();
   const openUpgrade = useCloudUpgradeAction("srch-wall");
   const dialog = useDialog();
-  const openTicker = useInlineTickerOpener();
 
   const [seedQuery] = usePaneSettingValue("query", "");
   const [mode, setMode] = usePluginPaneState<PaneMode>("mode", "results");
@@ -142,10 +142,11 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
   const failure = useMemo<RequestFailure | null>(() => (
     failedWith ? { message: errorMessage(failedWith), status: statusOf(failedWith) } : null
   ), [failedWith]);
-  const openHit = useMemo(
-    () => (openHitId ? hits.find((hit) => hit.id === openHitId) ?? null : null),
+  const openHitIndex = useMemo(
+    () => (openHitId ? hits.findIndex((hit) => hit.id === openHitId) : -1),
     [hits, openHitId],
   );
+  const openHit = openHitIndex >= 0 ? hits[openHitIndex]! : null;
 
   const focusField = useCallback((field: Exclude<ActiveField, null>) => {
     setActiveField(field);
@@ -326,6 +327,22 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
   }, []);
 
   const closeDetail = useCallback(() => setOpenHitId(null), [setOpenHitId]);
+  // n and p read on through the results without going back to the list.
+  const openAdjacent = useCallback((step: 1 | -1) => {
+    const next = hits[openHitIndex + step];
+    if (!next) return;
+    setSelectedHitId(next.id);
+    setOpenHitId(next.id);
+  }, [hits, openHitIndex, setOpenHitId, setSelectedHitId]);
+  const openNext = useMemo(
+    () => (openHitIndex >= 0 && openHitIndex < hits.length - 1 ? () => openAdjacent(1) : null),
+    [hits.length, openAdjacent, openHitIndex],
+  );
+  const openPrevious = useMemo(
+    () => (openHitIndex > 0 ? () => openAdjacent(-1) : null),
+    [openAdjacent, openHitIndex],
+  );
+  const openTickerChoice = useOpenTickerChoice();
 
   // Opened straight onto a hit from the command bar, ahead of its own results.
   const focusRequestedHit = useCallback((hit: CloudSearchHit) => {
@@ -402,11 +419,18 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
     status,
   ]);
 
-  // The ticker a badge click would open: the open document's, else the cursor
+  // The tickers [t] offers: those the open document names, else the cursor
   // row's (the table's cursor rests on the first row until one is chosen).
-  const hintTicker = mode === "results"
-    ? (openHit ?? hits.find((hit) => hit.id === selectedHitId) ?? hits[0])?.ticker || null
-    : null;
+  const documentTickers = useMemo(
+    () => (openHit && document ? searchArticle(document, openHit).tickers : null),
+    [document, openHit],
+  );
+  const hintTickers = useMemo(() => {
+    if (mode !== "results") return [];
+    if (documentTickers && documentTickers.length > 0) return documentTickers;
+    const ticker = (openHit ?? hits.find((hit) => hit.id === selectedHitId) ?? hits[0])?.ticker;
+    return ticker ? [ticker] : [];
+  }, [documentTickers, hits, mode, openHit, selectedHitId]);
   const footerHints = useMemo<PaneHint[]>(() => {
     // A wall or upsell replaces the results, so nothing there can be saved or opened.
     if (signInRequired || verificationRequired || proRequired) return [];
@@ -419,14 +443,14 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
       ];
     }
     return [
-      ...(hintTicker ? [{ id: "ticker", key: "t", label: "icker", onPress: () => openTicker(hintTicker) }] : []),
+      ...(hintTickers.length > 0 ? [{ id: "ticker", key: "t", label: "icker", onPress: () => openTickerChoice(hintTickers) }] : []),
       ...(!openHit && trimmedQuery ? [{ id: "save", key: "Ctrl+S", label: "save search", onPress: saveCurrentSearch }] : []),
     ];
   }, [
-    hintTicker,
+    hintTickers,
     mode,
     openHit,
-    openTicker,
+    openTickerChoice,
     proRequired,
     removeSaved,
     saved,
@@ -438,28 +462,12 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
     verificationRequired,
   ]);
 
-  // The stack title already names the open document, so the footer carries what
-  // the title cannot: which company, when, and what kind. Not how long: a
-  // section count is the kind of number the reader scrolls past anyway.
-  const documentIdentity = useMemo(() => {
-    if (!openHit) return null;
-    return [
-      formatHitDate(openHit.publishedAt),
-      // The type leads the footer when the document has no ticker, so repeating
-      // it here would say the same thing twice on one row.
-      openHit.ticker ? hitTypeLabel(openHit) : null,
-    ].filter((part): part is string => !!part).join(" · ");
-  }, [openHit]);
-
+  // The reader's header names the open document, its source, date and
+  // tickers, so the footer keeps to what changes and what can be done.
   useExternalLinkFooter({
     registrationId: RESEARCH_SEARCH_PANE_ID,
     focused,
     url: openHit?.url ?? null,
-    source: documentIdentity,
-    // Never a fixed word: the row is led by whichever of these the document
-    // actually has, because a footer is for what changes as you move between
-    // documents, not for saying "document".
-    label: openHit ? (openHit.ticker || hitTypeLabel(openHit)) : "",
     info: footerInfo,
     hints: footerHints,
     showHint: !!openHit?.url,
@@ -609,7 +617,7 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
         focused={focused && activeField === null && !typePickerOpen}
         detailOpen={!!openHit}
         onBack={closeDetail}
-        detailTitle={openHit?.title}
+        // No title in the stack bar: the reader sets the headline at the top of the text.
         detailContent={openHit ? (
           <SearchDocumentView
             hit={openHit}
@@ -619,7 +627,10 @@ export function ResearchSearchPane({ focused, paneId, width, height }: PaneProps
               ? "This document is part of Gloom Cloud Pro."
               : documentFailure?.message ?? null}
             width={width}
+            height={Math.max(1, height - tabRows - 1)}
             focused={focused && activeField === null && !typePickerOpen}
+            onNext={openNext}
+            onPrevious={openPrevious}
           />
         ) : (
           <Box flexGrow={1} />

package/src/plugins/builtin/research-search/snippet.ts

@@ -103,32 +103,3 @@ export function snippetMatchTerms(snippet: string): string[] {
 export function truncateSegments(segments: SnippetSegment[], width: number): SnippetSegment[] {
   return truncateTextSegments(segments, width, (ellipsis) => ({ text: ellipsis, marked: false }));
 }
-
-/** Splits plain text on the matched terms so a full chunk can show the same highlights. */
-export function highlightTerms(text: string, terms: readonly string[]): SnippetSegment[] {
-  const usable = terms.filter((term) => term.length > 0);
-  if (usable.length === 0) return [{ text, marked: false }];
-
-  const pattern = new RegExp(
-    `(${usable.map(escapeRegExp).sort((a, b) => b.length - a.length).join("|")})`,
-    "gi",
-  );
-  const segments: SnippetSegment[] = [];
-  let cursor = 0;
-  for (let match = pattern.exec(text); match; match = pattern.exec(text)) {
-    // A zero-width match would loop forever on the same index.
-    if (match[0].length === 0) {
-      pattern.lastIndex += 1;
-      continue;
-    }
-    pushSegment(segments, text.slice(cursor, match.index), false);
-    pushSegment(segments, match[0], true);
-    cursor = match.index + match[0].length;
-  }
-  pushSegment(segments, text.slice(cursor), false);
-  return segments.filter((segment) => segment.text.length > 0);
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/src/plugins/builtin/revenue-breakdown/headless.ts

@@ -1,10 +1,14 @@
 import type { RevenueBreakdownView } from "../../../api-client/revenue-breakdown";
-import type { HeadlessPaneDefinition } from "../../../types/plugin";
+import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchRevenueBreakdown } from "./client";
-import { quarterLabel, reportedSpan } from "./model";
+import { growthPercent, quarterLabel, reportedSpan, revenueAmount, sharePercent } from "./model";
 import { SEC_FILINGS } from "../shared/report-freshness";
 import { resolveHeadlessIssuerListing } from "../shared/headless-market-data";
 
+/** Amounts compact and shares and growth in percent, as the pane prints them (15.97B, 83.7%, +10.8%); exports keep the whole number. */
+const number = (format: (value: number | null) => string) => (value: unknown) => format(typeof value === "number" ? value : null);
+const amountColumn = (key: string, header: string): HeadlessPaneColumn => ({ key, header, align: "right", textFormat: number(revenueAmount) });
+
 export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
   freshness: { ...SEC_FILINGS, basis: "10-Q and 10-K filings" },
@@ -17,10 +21,10 @@ export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
     aliases: ["SEG"],
     dataRequirements: ["Gloom Cloud revenue breakdowns from 10-Q and 10-K XBRL"],
     limitations: [
-      "US filers only; 20-F filers report no quarterly breakdown",
-      "Rows are the members that add up to reported revenue; subtotals are dropped",
-      "Fiscal quarters; Q4 is the fiscal year less nine months",
-      "Free accounts get the two largest rows",
+      "US filers only; 20-F filers report no quarterly breakdown.",
+      "Rows are the members that add up to reported revenue; subtotals are dropped.",
+      "Fiscal quarters; Q4 is the fiscal year less nine months.",
+      "Free accounts get the two largest rows.",
     ],
   },
   options: [
@@ -48,6 +52,13 @@ export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
       sections: [
         {
           title: `Quarterly revenue by ${data.view}`,
+          columns: [
+            { key: data.view, header: data.view[0]!.toUpperCase() + data.view.slice(1) },
+            ...data.periods.map((period) => amountColumn(quarterLabel(period), quarterLabel(period))),
+            amountColumn("ttm", "TTM"),
+            { key: "share", header: "Share", align: "right", textFormat: number(sharePercent) },
+            { key: "yoy", header: "YoY", align: "right", textFormat: number(growthPercent) },
+          ],
           rows: data.rows.map((row) => ({
             [data.view]: row.label,
             ...Object.fromEntries(data.periods.map((period, index) => [quarterLabel(period), row.values[index]])),
@@ -58,6 +69,7 @@ export const revenueBreakdownHeadless: HeadlessPaneDefinition<"bundle"> = {
         },
         {
           title: "Total revenue",
+          columns: [{ key: "quarter", header: "Quarter" }, { key: "end", header: "End" }, amountColumn("revenue", "Revenue")],
           rows: data.periods.map((period, index) => ({
             quarter: quarterLabel(period),
             end: period.end,

package/src/plugins/builtin/seasonality/client.ts

@@ -13,30 +13,38 @@ export interface SeasonalityHistory {
   fetchedAt: number;
 }
 
+/** Monthly closes for the Returns and Overlay tabs, daily closes for Weekdays. */
+export type SeasonalityCadence = "monthly" | "daily";
+
 const CANCELLED = "Seasonality history load was cancelled";
-/** The cadence the pane reads, and so the cadence a screenshot captures. */
-export const SEASONALITY_HISTORY_RESOLUTION: ManualChartResolution = "1mo";
+/** The cadence each tab reads, and so the cadence a screenshot of it captures. */
+export const SEASONALITY_HISTORY_RESOLUTION: Record<SeasonalityCadence, ManualChartResolution> = { monthly: "1mo", daily: "1d" };
+/** Daily history is served to five years; a longer request can come back as weekly bars. */
+const BUFFER_RANGE = { monthly: "ALL", daily: "5Y" } as const;
 
 /**
  * Every month on record: the lookback is cut in the model, so changing it never
  * refetches. Monthly bars, because daily history is only served to 5Y where
  * provider support is not known yet, and a longer daily request comes back as
- * Monday-stamped weeks that file a week's close under the wrong month.
+ * Monday-stamped weeks that file a week's close under the wrong month. The
+ * Weekdays tab needs sessions, so it reads those five years of daily bars.
  */
 export async function loadSeasonalityHistory(
-  request: { instrument: InstrumentRef; signal?: AbortSignal; forceRefresh?: boolean },
+  request: { instrument: InstrumentRef; cadence?: SeasonalityCadence; signal?: AbortSignal; forceRefresh?: boolean },
   marketData?: DataProvider,
 ): Promise<SeasonalityHistory> {
   if (request.signal?.aborted) throw abortError(CANCELLED);
+  const cadence = request.cadence ?? "monthly";
   const now = Date.now();
   const coordinator = marketData ? new MarketDataCoordinator(marketData) : getSharedMarketDataCoordinator();
   try {
     if (!coordinator) throw new Error("Market data coordinator unavailable");
-    const entry = await abortable(coordinator.loadChart({ instrument: request.instrument, bufferRange: "ALL",
-      granularity: "resolution", resolution: SEASONALITY_HISTORY_RESOLUTION }, { forceRefresh: request.forceRefresh }), request.signal, CANCELLED);
+    const entry = await abortable(coordinator.loadChart({ instrument: request.instrument, bufferRange: BUFFER_RANGE[cadence],
+      granularity: "resolution", resolution: SEASONALITY_HISTORY_RESOLUTION[cadence] }, { forceRefresh: request.forceRefresh }), request.signal, CANCELLED);
     const history = resolveEntryValue(entry) ?? [];
     return { history, stale: !!entry.error || (entry.staleAt != null && entry.staleAt <= now),
-      error: entry.error?.message ?? (history.length ? null : "Monthly price history unavailable"), fetchedAt: entry.fetchedAt ?? now };
+      error: entry.error?.message ?? (history.length ? null : `${cadence === "daily" ? "Daily" : "Monthly"} price history unavailable`),
+      fetchedAt: entry.fetchedAt ?? now };
   } catch (error) {
     if (request.signal?.aborted || (error instanceof Error && error.name === "AbortError")) throw abortError(CANCELLED);
     return { history: [], stale: false, error: errorMessage(error), fetchedAt: now };

package/src/plugins/builtin/seasonality/headless.ts

@@ -1,38 +1,62 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { loadSeasonalityHistory } from "./client";
-import { MONTH_LABELS, projectSeasonality } from "./model";
+import { MONTH_LABELS, projectSeasonality, projectWeekdays, TURN_OF_MONTH_LABELS } from "./model";
 
-const percent = (value: unknown) => typeof value === "number" ? `${(value * 100).toFixed(1)}%` : "--";
+const percent = (digits: number) => (value: unknown) => typeof value === "number" ? `${(value * 100).toFixed(digits)}%` : "--";
+const statColumns = (digits: number, countHeader: string) => [{ key: "mean", header: "Avg", format: percent(digits) },
+  { key: "median", header: "Median", format: percent(digits) }, { key: "hitRate", header: "Up", format: percent(1) }, { key: "count", header: countHeader }];
 
 export const seasonalityHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Ticker" },
   // Dated by the month of its last monthly close.
   freshness: { status: "not-a-feed", basis: "monthly closes", maxAgeMinutes: 45 * 24 * 60 },
   describe: (args) => `SEAS ${args.symbols[0] ?? ""}`,
-  discovery: { screenshotReadiness: "live-dom", limitations: ["Local-price closes; dividends and FX are excluded."] },
+  discovery: { screenshotReadiness: "live-dom", limitations: ["Local-price closes; dividends and FX are excluded.",
+    "Weekdays reads daily closes, which are served for the last five years only."] },
   options: [
-    { key: "tab", type: "enum", values: [{ value: "returns" }, { value: "overlay" }], defaultValue: "returns",
+    { key: "tab", type: "enum", values: [{ value: "returns" }, { value: "overlay" }, { value: "weekdays" }], defaultValue: "returns",
       description: "Initial view", pluginState: { pluginId: "ticker-research", key: "activeTabId" } },
-    { key: "lookbackYears", type: "integer", minimum: 1, maximum: 30, defaultValue: 10, description: "Calendar years, the current one included" },
+    { key: "lookbackYears", type: "integer", minimum: 1, maximum: 30, defaultValue: 10, description: "Calendar years, the current one included; Weekdays covers every daily close served" },
   ],
   async load(args, ctx) {
     const instrument = await resolveHeadlessInstrument(ctx, args.symbols[0]!);
-    const history = await loadSeasonalityHistory({ instrument, signal: ctx.signal }, ctx.marketData);
+    const weekdays = args.options.tab === "weekdays";
+    const history = await loadSeasonalityHistory({ instrument, cadence: weekdays ? "daily" : "monthly", signal: ctx.signal }, ctx.marketData);
     ctx.signal.throwIfAborted();
+    const common = { errors: history.error ? [history.error] : [] };
+    if (weekdays) {
+      const model = projectWeekdays(history.history, { symbol: instrument.symbol, exchange: instrument.exchange, fetchedAt: history.fetchedAt });
+      const present = model.start != null;
+      return {
+        sections: [
+          { title: "By weekday", columns: [{ key: "day", header: "Day" }, ...statColumns(3, "Sessions")],
+            rows: model.weekdays },
+          { title: "Turn of month", columns: [{ key: "day", header: "Session" }, ...statColumns(3, "Sessions")],
+            rows: [...model.turnOfMonth.map((stat, index) => ({ day: TURN_OF_MONTH_LABELS[index], ...stat })),
+              { day: "Turn of month", ...model.turnWindow }, { day: "Other days", ...model.otherDays }] },
+        ],
+        complete: !history.stale && !history.error && present,
+        unavailableSymbols: present ? [] : [instrument.symbol],
+        ...common,
+        // Dated by its last session's close.
+        freshness: { basis: "daily closes", maxAgeMinutes: 14 * 24 * 60 },
+        metadata: { unit: "decimal return, local-price session close to close", start: model.start, asOf: model.asOf, stale: history.stale,
+          fetchedAt: history.fetchedAt, methodology: "docs/research-data.md#seasonality" },
+      };
+    }
     const model = projectSeasonality(history.history, { symbol: instrument.symbol, lookbackYears: Number(args.options.lookbackYears) || 10 });
-    const monthColumns = MONTH_LABELS.map((label, month) => ({ key: `m${month}`, header: label, format: percent }));
+    const monthColumns = MONTH_LABELS.map((label, month) => ({ key: `m${month}`, header: label, format: percent(1) }));
     return {
       sections: [
-        { title: "By month", columns: [{ key: "month", header: "Month" }, { key: "mean", header: "Avg", format: percent },
-          { key: "median", header: "Median", format: percent }, { key: "hitRate", header: "Up", format: percent }, { key: "count", header: "Years" }],
-        rows: model.months.map((stat) => ({ ...stat, month: MONTH_LABELS[stat.month] })) },
-        { title: "Monthly returns", columns: [{ key: "year", header: "Year" }, ...monthColumns, { key: "total", header: "Year", format: percent }],
+        { title: "By month", columns: [{ key: "month", header: "Month" }, ...statColumns(1, "Years")],
+          rows: model.months.map((stat) => ({ ...stat, month: MONTH_LABELS[stat.month] })) },
+        { title: "Monthly returns", columns: [{ key: "year", header: "Year" }, ...monthColumns, { key: "total", header: "Year", format: percent(1) }],
           rows: model.years.map((year) => ({ year: year.year, total: year.total, ...Object.fromEntries(year.months.map((value, month) => [`m${month}`, value])) })) },
       ],
       complete: !history.stale && !history.error && model.years.length > 0,
       unavailableSymbols: model.years.length ? [] : [instrument.symbol],
-      errors: history.error ? [history.error] : [],
+      ...common,
       metadata: { unit: "decimal return, local-price close to close", asOf: model.asOf?.toISOString() ?? null, stale: history.stale,
         fetchedAt: history.fetchedAt, averagePath: model.averagePath, methodology: "docs/research-data.md#seasonality" },
     };

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

@@ -14,7 +14,7 @@ export const seasonalityModule: PluginModule = {
   }],
   paneTemplates: [{ ...createTickerSurfacePaneTemplate({
     id: "seasonality-pane", paneId: "seasonality", label: "Seasonality",
-    description: "Monthly returns by year, each month's average and hit rate, and every year's path on one calendar.",
-    keywords: ["seas", "seasonality", "seasonal", "monthly returns", "calendar"], shortcut: "SEAS", publicShare: true,
+    description: "Monthly returns by year, each month's average and hit rate, every year's path on one calendar, and returns by weekday and turn of month.",
+    keywords: ["seas", "seasonality", "seasonal", "monthly returns", "calendar", "weekday", "day of week", "turn of month"], shortcut: "SEAS", publicShare: true,
   }), headless: seasonalityHeadless }],
 };

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

@@ -1,4 +1,8 @@
+import { latestRegularSessionClose } from "../../../market-data/market/freshness";
+import { listingSuffixExchange, tickerHasListingSuffix } from "../../../sources/listing-symbols";
+import { calendarBarStart } from "../../../time-series/chart-data";
 import type { PricePoint } from "../../../types/financials";
+import { isRoundTheClockCoin } from "../../../utils/crypto-pair";
 
 export const MONTH_LABELS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
 /** Year overlays share one calendar; 2000 is a leap year, so Feb 29 has a place. */
@@ -122,3 +126,118 @@ export function projectSeasonality(history: readonly PricePoint[], options: { sy
 
   return { symbol: options.symbol, years, months, paths, averagePath, asOf: last.date };
 }
+
+/** Monday first; a Saturday or Sunday row appears only for a venue that trades then. */
+const WEEKDAY_LABELS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] as const;
+/** The turn of the month: a month's last session, then the next month's first three. */
+export const TURN_OF_MONTH_LABELS = ["Last day", "Day 1", "Day 2", "Day 3"] as const;
+
+export interface DailyReturnStat {
+  mean: number | null;
+  median: number | null;
+  /** Share of sessions that closed up. */
+  hitRate: number | null;
+  count: number;
+}
+
+export interface WeekdayModel {
+  symbol: string;
+  /**
+   * Each day of the week that held a session, in the venue's week: Monday
+   * first, or Sunday first where Sunday sessions outnumber Friday ones.
+   */
+  weekdays: (DailyReturnStat & { day: (typeof WEEKDAY_LABELS)[number] })[];
+  /** In TURN_OF_MONTH_LABELS order. */
+  turnOfMonth: DailyReturnStat[];
+  /** The four turn-of-month sessions pooled, against every other session whose place in its month is known. */
+  turnWindow: DailyReturnStat;
+  otherDays: DailyReturnStat;
+  /** Session dates of the first and last return counted, "YYYY-MM-DD". */
+  start: string | null;
+  asOf: string | null;
+}
+
+function returnStat(values: number[]): DailyReturnStat {
+  return { count: values.length, mean: mean(values), median: median(values),
+    hitRate: values.length ? values.filter((value) => value > 0).length / values.length : null };
+}
+
+/** Closing auctions and late prints settle after the bell, as price history allows for. */
+const SESSION_SETTLE_MS = 30 * 60_000;
+
+/** The venue a listing's sessions follow: a bare symbol without a listing suffix is a US listing. */
+function sessionVenue(symbol: string, exchange: string | undefined): string | undefined {
+  if (exchange || isRoundTheClockCoin(symbol)) return exchange;
+  return listingSuffixExchange(symbol) ?? (tickerHasListingSuffix(symbol) ? undefined : "NYSE");
+}
+
+/**
+ * The latest session date whose close had settled by `time`, on the venue's
+ * calendar; for a coin, whose daily bar is a UTC day, the UTC day before.
+ * Null where the venue's sessions are unknown.
+ */
+function settledSessionDate(symbol: string, venue: string | undefined, time: number): string | null {
+  if (isRoundTheClockCoin(symbol, venue)) return new Date(time - SESSION_SETTLE_MS - DAY_MS).toISOString().slice(0, 10);
+  return venue ? latestRegularSessionClose(venue, time - SESSION_SETTLE_MS)?.date ?? null : null;
+}
+
+/**
+ * Close-to-close returns of daily bars, each filed under its session date: the
+ * venue's date for a bar stamped at its open or local midnight, the label for a
+ * date-only bar at UTC midnight. Every session served counts; there is no
+ * lookback. A session still trading when the history was fetched is left out.
+ * A Monday after a holiday Friday runs from Thursday's close. A session's
+ * place in its month is only known once the session before the month started
+ * is in the history, and the latest session may still turn out to be its
+ * month's last, so those stay out of the turn-of-month split (but not out of
+ * the weekdays).
+ */
+export function projectWeekdays(history: readonly PricePoint[], options: { symbol: string; exchange?: string; fetchedAt: number }): WeekdayModel {
+  const venue = sessionVenue(options.symbol, options.exchange);
+  const settled = settledSessionDate(options.symbol, venue, options.fetchedAt);
+  const sessions = new Map<string, number>();
+  for (const point of history
+    .map((entry) => ({ time: new Date(entry.date).getTime(), close: entry.close }))
+    .filter((entry) => Number.isFinite(entry.close) && entry.close > 0 && Number.isFinite(entry.time))
+    .sort((left, right) => left.time - right.time)) {
+    const day = calendarBarStart(point.time, "1d", venue);
+    if (settled == null || day <= settled) sessions.set(day, point.close);
+  }
+  const days = [...sessions.entries()].sort(([left], [right]) => left.localeCompare(right));
+  const empty = returnStat([]);
+  // Weekly or monthly bars would file a week's move under one weekday.
+  if (days.length < 2 || medianGapDays(days.map(([day]) => ({ date: new Date(`${day}T00:00:00Z`) }))) > 4) {
+    return { symbol: options.symbol, weekdays: [], turnOfMonth: TURN_OF_MONTH_LABELS.map(() => empty),
+      turnWindow: empty, otherDays: empty, start: null, asOf: null };
+  }
+
+  const weekdays: number[][] = WEEKDAY_LABELS.map(() => []);
+  const turnOfMonth: number[][] = TURN_OF_MONTH_LABELS.map(() => []);
+  const other: number[] = [];
+  /** The session's place in its month, 1 for the first; null until a month's start is seen. */
+  let position: number | null = null;
+  for (let index = 1; index < days.length; index++) {
+    const [day, close] = days[index]!;
+    const month = day.slice(0, 7);
+    position = month !== days[index - 1]![0].slice(0, 7) ? 1 : position == null ? null : position + 1;
+    const value = close / days[index - 1]![1] - 1;
+    weekdays[(new Date(`${day}T00:00:00Z`).getUTCDay() + 6) % 7]!.push(value);
+    const next = days[index + 1]?.[0];
+    if (next != null && next.slice(0, 7) !== month) turnOfMonth[0]!.push(value);
+    else if (position != null && position <= 3) turnOfMonth[position]!.push(value);
+    else if (next != null && position != null) other.push(value);
+  }
+
+  const stats = weekdays.map((values, day) => ({ day: WEEKDAY_LABELS[day]!, ...returnStat(values) }));
+  // A Sunday-to-Thursday venue (Tadawul, Boursa Kuwait) starts its week on Sunday.
+  const ordered = stats[6]!.count > stats[4]!.count ? [stats[6]!, ...stats.slice(0, 6)] : stats;
+  return {
+    symbol: options.symbol,
+    weekdays: ordered.filter((stat) => stat.count > 0),
+    turnOfMonth: turnOfMonth.map(returnStat),
+    turnWindow: returnStat(turnOfMonth.flat()),
+    otherDays: returnStat(other),
+    start: days[1]![0],
+    asOf: days.at(-1)![0],
+  };
+}