@gloom-sh/terminal 0.19.2 → 0.19.3

package/src/telemetry/stall-reports.ts

@@ -28,8 +28,12 @@ import { reportCrash } from "./crash-reports";
  * for the desktop app's own process, whether the app was in front and had a
  * window on screen: a hidden app's slowed timers read like a freeze. A stall
  * after a SQLite statement names the statement (a fixed name), its tries and
- * whether it waited on another program's lock. All of it is buckets and
- * flags.
+ * whether it waited on another program's lock. Where the platform's clocks
+ * can be read, it says how much of the stall the thread spent on the CPU
+ * and how busy the process's other threads were, which tells script or a
+ * collection (busy) from a wait on the disk, a lock or another thread
+ * (idle); the time the computer slept never counts as a stall (see
+ * utils/main-thread-stall.ts). All of it is buckets and flags.
  *
  * One report per process, bucket, section and app version a day; stalls of
  * the same kind after that are counted and carried in the next report, and
@@ -66,6 +70,10 @@ export interface StallReport {
   attempts?: number;
   /** After a SQLite statement: whether it waited on another connection's lock. */
   lockWait?: boolean;
+  /** Where the platform says: the share of the stall the thread was on the CPU, in percent, by tens. */
+  cpuPercent?: number;
+  /** Where the platform says: the CPU the process's other threads used meanwhile, in percent of one core, by tens. */
+  otherCpuPercent?: number;
 }
 
 type StallBucket = "1-2s" | "2-5s" | "5-15s" | "15s+";
@@ -115,6 +123,8 @@ const MAX_KINDS_KEPT = 200;
 const MAX_RECENT_KEPT = 500;
 /** What error tracking keeps of the details line; fields that do not fit are left out. */
 const MAX_DETAILS_LENGTH = 120;
+/** Other threads' CPU past this many percent of a core reads as this. */
+const MAX_OTHER_CPU_PERCENT = 990;
 
 let host: StallReporterHost | null = null;
 let attentionProbe: (() => StallAttention) | null = null;
@@ -198,20 +208,32 @@ function flag(value: boolean | null | undefined): string {
   return value == null ? "?" : value ? "1" : "0";
 }
 
+/** A share or a core count in percent, by tens. */
+function tens(value: number | undefined, max: number): number | undefined {
+  if (value === undefined || !Number.isFinite(value)) return undefined;
+  return Math.min(max, Math.max(0, Math.round(value * 10) * 10));
+}
+
 /** The context a report carries, also written at the end of the log line. */
 interface StallContext {
   phase: StallReport["phase"];
   uptime: StallReport["uptime"];
   gap: GapBucket;
   attention: StallAttention | null;
+  cpuPercent?: number;
+  otherCpuPercent?: number;
 }
 
 function stallContext(event: StallEvent, attention: StallAttention | null): StallContext {
+  const cpuPercent = tens(event.threadCpu, 100);
+  const otherCpuPercent = tens(event.otherCpu, MAX_OTHER_CPU_PERCENT);
   return {
     phase: event.phase ?? "unknown",
     uptime: uptimeBucket(event.uptimeMs),
     gap: gapBucket(event),
     attention,
+    ...(cpuPercent === undefined ? {} : { cpuPercent }),
+    ...(otherCpuPercent === undefined ? {} : { otherCpuPercent }),
   };
 }
 
@@ -229,6 +251,8 @@ function formatStallLogLine(process: StallProcess, event: StallEvent, context: S
     `up=${context.uptime}`,
     `gap=${context.gap}`,
     ...(context.attention ? [`fg=${flag(context.attention.active)}`, `vis=${flag(context.attention.visible)}`] : []),
+    ...(context.cpuPercent === undefined ? [] : [`cpu=${context.cpuPercent}`]),
+    ...(context.otherCpuPercent === undefined ? [] : [`oth=${context.otherCpuPercent}`]),
   ].join(" ");
   return `${time}  ${process.padEnd(8)}  froze ${formatSeconds(event.blockedMs).padStart(6)}  ${last}${sqlite}  [${facts}]`;
 }
@@ -245,23 +269,26 @@ function reportArch(arch: string): StallReport["arch"] {
 }
 
 /**
- * The details line error tracking keeps, most telling first: the original
- * four fields, then the new ones. One that would not fit is left out.
+ * The details line error tracking keeps, most telling first. The platform
+ * comes last: error tracking has the system and its architecture already.
+ * One that would not fit is left out.
  */
 export function formatStallReportDetails(report: StallReport): string {
   const fields = [
     `process=${report.process}`,
     `count=${report.count}`,
     `longest=${report.longestMs}ms`,
-    `platform=${report.platform}-${report.arch}`,
     `phase=${report.phase}`,
     `up=${report.uptime}`,
     `gap=${report.gap}`,
     ...(report.active === undefined ? [] : [`fg=${flag(report.active)}`]),
     ...(report.visible === undefined ? [] : [`vis=${flag(report.visible)}`]),
+    ...(report.cpuPercent === undefined ? [] : [`cpu=${report.cpuPercent}`]),
+    ...(report.otherCpuPercent === undefined ? [] : [`oth=${report.otherCpuPercent}`]),
     ...(report.lockWait === undefined ? [] : [`lock=${flag(report.lockWait)}`]),
     ...(report.attempts === undefined ? [] : [`try=${report.attempts}`]),
     `day=${report.day}`,
+    `platform=${report.platform}-${report.arch}`,
   ];
   let details = "";
   for (const field of fields) {
@@ -357,6 +384,8 @@ export function recordStall(process: StallProcess, event: StallEvent): void {
         uptime: context.uptime,
         gap: context.gap,
         ...(context.attention ? { active: context.attention.active, visible: context.attention.visible } : {}),
+        ...(context.cpuPercent === undefined ? {} : { cpuPercent: context.cpuPercent }),
+        ...(context.otherCpuPercent === undefined ? {} : { otherCpuPercent: context.otherCpuPercent }),
         ...(event.sqlite && section.startsWith("sqlite.blocked")
           ? { attempts: Math.max(1, Math.min(99, Math.round(event.sqlite.attempts))), lockWait: event.sqlite.lockWait }
           : {}),

package/src/test-support/preload.ts

@@ -1,5 +1,6 @@
 import { beforeEach } from "bun:test";
 import { resetCrashReporterForTests } from "../telemetry/crash-reports";
+import { setCliAsciiLocaleOverride, setCliColorEnabledOverride, setCliPlainOverride, setCliWidthOverride } from "../utils/cli-output";
 
 /**
  * `bun test` runs every file in one process, so module state outlives the file
@@ -8,7 +9,15 @@ import { resetCrashReporterForTests } from "../telemetry/crash-reports";
  * queue and go out with the next reporter another file installs, and its key
  * would keep a later identical report from being queued at all. Every test
  * starts with no reporter, an empty queue and nothing seen.
+ *
+ * Commands also keep output overrides for the process: a parity test that
+ * runs --plain would otherwise make a later serializer test keep empty
+ * columns. Start each test with the default output modes and terminal width.
  */
 beforeEach(() => {
   resetCrashReporterForTests();
+  setCliAsciiLocaleOverride(null);
+  setCliColorEnabledOverride(null);
+  setCliPlainOverride(null);
+  setCliWidthOverride(null);
 });

package/src/tickers/company-name.ts

@@ -204,6 +204,25 @@ export function groupByCompany<T>(
   return groups;
 }
 
+/**
+ * A one-letter code a venue pads onto the end of a name after a run of
+ * spaces: the `R` of "Americold Realty Trust Inc.   R". A longer word there
+ * (`AG`, `ASA`) is the name's own.
+ */
+const STRAY_NAME_TAIL = /\s{2,}[A-Za-z0-9]$/;
+
+/**
+ * A listing's name as a venue's file writes it, without the stray fragment a
+ * fixed-width file leaves after a run of spaces ("Americold Realty Trust
+ * Inc.   R" on Hanover is "Americold Realty Trust Inc."), and with its spaces
+ * single. A name that is only the fragment keeps it.
+ */
+export function cleanListingName(name: string): string {
+  const trimmed = name.trim();
+  const cut = trimmed.replace(STRAY_NAME_TAIL, "");
+  return (cut || trimmed).replace(/\s+/g, " ");
+}
+
 /** A company's name without its legal form, for sentences: "Avis Budget Group, Inc." is "Avis Budget Group". */
 export function shortCompanyName(name: string): string {
   const words = name.trim().split(/\s+/).filter(Boolean);

package/src/tickers/listing-fate.ts

@@ -132,6 +132,12 @@ export function listingChangeLine(fate: Pick<ListingFate, "change" | "formerIssu
 export const NO_FATE: ListingFate = { endedOn: null, change: null, note: null, moved: null, formerIssuer: null };
 /** How long a fate waits for a change lookup it started late, or for a stopped line's. */
 export const LATE_CHANGE_WAIT_MS = 2_000;
+/**
+ * How long a command that says what became of a symbol's company (GOGL's merger) waits for the lookup it started
+ * beside its own request, once that is in: the lookup takes about a third of a second, and a cached request answers
+ * at once. A lookup that hangs costs a symbol that trades no more than this.
+ */
+export const SUCCESSOR_CHANGE_WAIT_MS = 750;
 
 // The zones of the US exchanges; a venue in another is abroad.
 const US_TIME_ZONES = new Set(["America/New_York", "America/Chicago"]);
@@ -195,7 +201,11 @@ export function lineMayHaveMoved(quote: Quote | null, now = Date.now()): boolean
 export async function loadListingFate(
   listing: { symbol: string; exchange?: string | null; request?: { symbol: string; exchange: string } },
   dataProvider: Pick<DataProvider, "getQuote" | "getTickerChanges">,
-  options: { quote?: Quote | null | Promise<Quote | null>; changes?: TickerChangeLookup } = {},
+  /**
+   * `graceMs`: how long a lookup the command started waits once the quote is in, for a command that says what
+   * became of the company beside what it serves (GOGL's merger), not only whether it moved. A short grace by default.
+   */
+  options: { quote?: Quote | null | Promise<Quote | null>; changes?: TickerChangeLookup; graceMs?: number } = {},
 ): Promise<ListingFate> {
   const request = listing.request ?? { symbol: listing.symbol, exchange: listing.exchange ?? "" };
   const lookup = options.changes ?? startTickerChangeLookup(dataProvider, listing.symbol, listing.exchange);
@@ -206,7 +216,7 @@ export async function loadListingFate(
     // A lookup started beside the command's request gets a short grace once that is ready, so a slow
     // one never holds a symbol that trades. A line that stopped is waited for: only its company can
     // have moved, and then the answer decides whether the command serves anything at all.
-    const changes = await lookup.settle(!options.changes || lineMayHaveMoved(quote) ? LATE_CHANGE_WAIT_MS : undefined);
+    const changes = await lookup.settle(!options.changes || lineMayHaveMoved(quote) ? LATE_CHANGE_WAIT_MS : options.graceMs);
     return describeListingFate(listing, quote, changes);
   } catch (error) {
     logFailure("tickers-listing-fate", "Could not resolve listing fate")(error);
@@ -230,7 +240,8 @@ export function listingFateNotes(fate: ListingFate, served: { served: boolean; f
   return [
     // What it served ends on the listing's last session, and says so.
     fate.delisted ?? null,
-    tickerChangeLine(change),
+    // A company that left the symbol, else one that merged away from it (GOGL), as `quote` says it.
+    listingChangeLine(fate),
     earlier.length > 0 ? `Includes ${earlier.join("- and ")}-era bars: ${change!.note}` : null,
   ].filter((line): line is string => !!line);
 }

package/src/tickers/saved-instrument.ts

@@ -0,0 +1,17 @@
+import type { TickerRecord } from "../types/ticker";
+import { parsePublicTickerKey } from "../utils/exchanges";
+
+/**
+ * The listing a typed key stands for in a report (`resolveInstrument`): the
+ * venue it names (`SBK:JSE`), else the venue of the ticker saved under the key
+ * or under its bare symbol, so a saved `S32` held on the JSE is read there.
+ * `fn`, `shot` and the panes that read as they do resolve keys this way.
+ */
+export async function resolveSavedInstrument(
+  key: string,
+  loadTicker: (key: string) => Promise<TickerRecord | null | undefined> | TickerRecord | null | undefined,
+): Promise<{ symbol: string; exchange?: string }> {
+  const parsed = parsePublicTickerKey(key);
+  const ticker = await loadTicker(key) ?? (key !== parsed.symbol ? await loadTicker(parsed.symbol) : null);
+  return { symbol: parsed.symbol, exchange: parsed.exchange ?? ticker?.metadata.exchange };
+}

package/src/tickers/search/home-listing.ts

@@ -122,8 +122,11 @@ function isListedEquity(candidate: TickerSearchCandidate): boolean {
  * Siemens AG). The row the service marks with the word as typed is the
  * company the word means, ahead of a line abroad whose symbol is the word:
  * "siemens" is SIE on XETRA, not SIEMENS on NSE (Siemens Ltd.); a US line
- * keeps its ticker. A query that names a venue (LVMH:TSX, 7203.T) asked for
- * that line, and a saved row keeps the lead.
+ * keeps its ticker. A symbol typed whose first row is another company's
+ * regional line abroad leads with the line the service marks as a home under
+ * that symbol (YAR is Yara on OSL, not Americold on Hanover). A query that
+ * names a venue (LVMH:TSX, 7203.T) asked for that line, and a saved row keeps
+ * the lead.
  */
 export function withHomeListingLead<T extends TickerSearchCandidate>(items: T[], query: string): T[] {
   if (isQualifiedTickerQuery(query)) return items;
@@ -137,6 +140,14 @@ export function withHomeListingLead<T extends TickerSearchCandidate>(items: T[],
       && item.symbol.toUpperCase() !== lead.symbol.toUpperCase() && namedByService(query, item.result))
     : undefined;
   if (meant) return moveAhead(items, meant, lead);
+  // A line abroad that only quotes shares listed elsewhere (a German regional venue) gives way to the line the
+  // service marks as a company's home under the same symbol: YAR is Yara on Oslo, not Americold on Hanover.
+  const homeOfSymbol = typedSymbol && lead.result?.homeListing !== true && listingDistance(lead) === 1
+    && !isUsListingExchange(candidateExchange(lead))
+    ? items.find((item) => item !== lead && isListedEquity(item) && item.result?.homeListing === true
+      && item.symbol.toUpperCase() === lead.symbol.toUpperCase())
+    : undefined;
+  if (homeOfSymbol) return moveAhead(items, homeOfSymbol, lead);
   const name = candidateName(lead);
   const lines = companyRows(lead, items).filter((item) => item !== lead);
   const nearest = (candidates: T[]) => [...candidates].sort((a, b) => nameGap(name, candidateName(a)) - nameGap(name, candidateName(b))

package/src/tickers/search/index.ts

@@ -507,7 +507,10 @@ async function resolveTickerSymbol(
     throw new AmbiguousContractError(symbol, matches.map((item) => tickerInstrumentLabel(item.symbol, item.result?.brokerContract)));
   }
   const listings = new Set(matches.map((item) => publicTickerKey(item.symbol, listingExchange(item.result!))));
-  const ambiguity = (query: string) => new AmbiguousTickerError(query, [...listings], Object.fromEntries(matches.map((item) => [
+  // A line the service marks as a company's home leads the choices: YAR is Yara on Oslo before Americold's German lines.
+  const homeFirst = [...matches.filter((item) => item.result?.homeListing === true), ...matches.filter((item) => item.result?.homeListing !== true)];
+  const choices = new Set(homeFirst.map((item) => publicTickerKey(item.symbol, listingExchange(item.result!))));
+  const ambiguity = (query: string) => new AmbiguousTickerError(query, [...choices], Object.fromEntries(matches.map((item) => [
     publicTickerKey(item.symbol, listingExchange(item.result!)), listingChoiceName(item.result!),
   ])));
   if (pickerQuery && listings.size > 1) throw ambiguity(pickerQuery);

package/src/tickers/search/types.ts

@@ -3,7 +3,12 @@ import type { Quote } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 
 export type TickerSearchInstrumentClass = "equity" | "fund" | "derivative" | "other";
-type TickerSearchCategory = "Saved" | "Primary Listing" | "Other Listings" | "Funds & Derivatives" | "Related";
+/**
+ * `Other Matches`: rows `gloom search` finds for the query that are not a listing
+ * of the primary listing's company (another company's DK, a line search names
+ * no company for), kept apart from its Other Listings.
+ */
+type TickerSearchCategory = "Saved" | "Primary Listing" | "Other Listings" | "Other Matches" | "Funds & Derivatives" | "Related";
 
 export interface TickerSearchRankableItem {
   id: string;

package/src/time-series/bar-aggregation.ts

@@ -182,6 +182,8 @@ function buildBar(bucket: Bucket, intraday: boolean): AggregatedPricePoint {
   let low = Number.POSITIVE_INFINITY;
   let volume: number | undefined;
   let venueVolume: PricePoint["venueVolume"] | null | undefined;
+  // What the volume counts carries over while every bar counts the same way.
+  let volumeBasis: string | null | undefined;
   let partial = false;
   let filled = false;
   const integrity: PriceHistoryIntegrity[] = [];
@@ -189,7 +191,10 @@ function buildBar(bucket: Bucket, intraday: boolean): AggregatedPricePoint {
     const close = bar.close;
     high = Math.max(high, isFiniteNumber(bar.high) ? bar.high : close);
     low = Math.min(low, isFiniteNumber(bar.low) ? bar.low : close);
-    if (isFiniteNumber(bar.volume)) volume = (volume ?? 0) + bar.volume;
+    if (isFiniteNumber(bar.volume)) {
+      volume = (volume ?? 0) + bar.volume;
+      volumeBasis = volumeBasis === undefined || volumeBasis === bar.volumeBasis ? bar.volumeBasis ?? null : null;
+    }
     // One venue's trades add up only while every bar counts the same venue.
     if (bar.venueVolume && venueVolume !== null) {
       venueVolume = venueVolume === undefined || venueVolume.venue === bar.venueVolume.venue
@@ -207,6 +212,7 @@ function buildBar(bucket: Bucket, intraday: boolean): AggregatedPricePoint {
     low,
     close: last.close,
     ...(volume !== undefined ? { volume } : {}),
+    ...(volume !== undefined && volumeBasis ? { volumeBasis } : {}),
     ...(volume === undefined && venueVolume ? { venueVolume } : {}),
     ...(partial ? { partial: true } : {}),
     ...(filled ? { filled: true } : {}),

package/src/time-series/base-series.ts

@@ -15,7 +15,7 @@ import {
   valuationPriceIssues,
 } from "./fundamentals";
 import { extractSecuritySeries } from "./market";
-import { activeStudyInputSeriesIds } from "./studies";
+import { activeStudyInputSeriesIds } from "./studies/resolve";
 import { reportingCurrencySeries } from "./reporting-currency";
 import { compareChartQuoteRecency } from "./live-quotes";
 import { marketSeriesFrequency } from "./market";
@@ -138,8 +138,8 @@ export function baseSecuritySeries(
     : field.unit;
   const generic = field.unitGroup === "price"
     ? futuresGenericListing(spec.source.instrument.symbol, spec.source.instrument.exchange) : null;
-  // A generic future on an index, VIX or Treasuries reads in points or 32nds, and an index
-  // future's continuous symbol or contract in points, not dollars, as its quote does.
+  // Index and Treasury futures read in points or 32nds across generics,
+  // continuous symbols and listed contracts, as their quotes do.
   const genericBasis = field.unitGroup === "price" && isMarketFieldId(field.id)
     ? futuresListingPriceBasis(spec.source.instrument.symbol, spec.source.instrument.exchange) : null;
   // An index's level is points too, never the currency its members trade in.

package/src/time-series/chart-bounds.ts

@@ -15,7 +15,7 @@ import {
   type ManualChartResolution,
 } from "./resolution";
 import { TIME_RANGES, type TimeRange } from "./range";
-import { maxStudyWarmupPoints } from "./studies";
+import { maxStudyWarmupPoints } from "./studies/resolve";
 import type { PriceComparison } from "./price-comparison";
 import { resolutionForExplicitMarketPeriods } from "./market-resolution";
 import { latestSessionStart, latestTradingSessionOpen, priorSessionClose } from "../market-data/market/trading-sessions";

package/src/time-series/chart-data.ts

@@ -103,8 +103,11 @@ function finiteOrFallback(value: number | undefined, fallback: number): number {
 }
 
 function mergeQuoteIntoLatestBar(latest: PricePoint, quotePrice: number, range?: QuoteSessionRange | null): PricePoint {
-  // A later quote cannot establish which reported OHLC field was wrong.
-  if (pricePointIntegrity(latest)) return latest;
+  if (pricePointIntegrity(latest)) {
+    // A later quote cannot establish which reported OHLC field was wrong, unless it names the bar's whole session: its
+    // open, range and price are the bar (GOGL's 2026-10-30 daily bar, served with a high under its open).
+    return range?.open === undefined ? latest : { ...latest, open: range.open, high: range.high, low: range.low, close: quotePrice };
+  }
   const open = finiteOrFallback(latest.open, latest.close);
   const high = finiteOrFallback(latest.high, Math.max(open, latest.close));
   const low = finiteOrFallback(latest.low, Math.min(open, latest.close));

package/src/time-series/chart-seed.ts

@@ -10,7 +10,7 @@ import { aggregatePriceBars, futuresOpenMinuteOf, withBuiltBarSize } from "./bar
 import type { TickerFinancials } from "../types/financials";
 import { isMarketFieldId } from "./field-catalog";
 import { chartPriceHistoryIntegrityNotices } from "./market";
-import { resolveStudies } from "./studies";
+import { resolveStudies } from "./studies/resolve";
 import { clipSeriesToWindow } from "./alignment";
 import { bufferPriceComparison, clipPriceComparison, priceComparisonBoundsForSeries, resolvePriceComparison } from "./price-comparison";
 import { readSeedListingFacts } from "./parsed-history-cache";

package/src/time-series/coin-session-close.ts

@@ -0,0 +1,211 @@
+import { hasRegularCloseHour, isAlwaysOpenExchange, regularSessionCloseOn, sessionCalendarTimeZone } from "../market-data/market/freshness";
+import { fetchHistoryResult } from "../sources/history-result";
+import type { DataProvider } from "../types/data-provider";
+import { isRoundTheClockCoin } from "../utils/crypto-pair";
+import { canonicalExchange, isUsListingExchange } from "../utils/exchanges";
+import { logFailure } from "../utils/log-failure";
+import { zonedDateTimeParts, zonedWallClockToUtcMs } from "../utils/zoned-date-time";
+import type { PriceComparison } from "./price-comparison";
+import type { ResolvedSeries } from "./types";
+
+const HOUR_MS = 60 * 60_000;
+const DAY_MS = 24 * HOUR_MS;
+/** How far back hourly bars are read for a comparison: Gloom Cloud keeps a coin's for a year. A longer span keeps UTC closes. */
+const HOURLY_REACH_MS = 370 * DAY_MS;
+
+/** The venue a compared leg trades on, as its sessions are read. */
+function legVenue(series: ResolvedSeries | undefined): string | undefined {
+  return series?.timeBasis?.exchange || series?.listing?.exchange || undefined;
+}
+
+/** A coin that trades round the clock, its daily bar the UTC day: BTC-USD on the crypto venue. */
+function isRoundTheClockLeg(series: ResolvedSeries | undefined): boolean {
+  if (!series) return false;
+  const venue = legVenue(series);
+  return (!!venue && isAlwaysOpenExchange(venue)) || isRoundTheClockCoin(series.listing?.symbol, series.listing?.exchange);
+}
+
+/**
+ * A leg whose venue closes each day at a known hour: a US fund, a London share. A venue whose close hour is not
+ * known has no close to measure a coin at: the coin keeps its UTC closes, and the notice names no close.
+ */
+function sessionVenueOf(series: ResolvedSeries | undefined): string | null {
+  const venue = legVenue(series);
+  return venue && !isRoundTheClockLeg(series) && !isAlwaysOpenExchange(venue) && sessionCalendarTimeZone(venue) && hasRegularCloseHour(venue)
+    ? venue : null;
+}
+
+/** `US` for a US listing's venue, else the venue's code, as the close a coin is measured against is named. */
+function sessionMarketName(venue: string): string {
+  return isUsListingExchange(venue) ? "US" : canonicalExchange(venue);
+}
+
+type HourlyRead = Awaited<ReturnType<typeof fetchHistoryResult>>;
+type HourlyProvider = Pick<DataProvider, "getDetailedPriceHistory" | "getDetailedPriceHistoryWithMetadata">;
+interface HourlyReads {
+  /** Recent reads by listing and span: a chart resolves again on every live quote, and asks for the same hours. */
+  spans: Map<string, { at: number; read: Promise<HourlyRead> }>;
+  /** Listings whose read failed, until when they are not asked again. */
+  failedUntil: Map<string, number>;
+}
+const hourlyReadsBySource = new WeakMap<HourlyProvider, HourlyReads>();
+const HOURLY_READ_LIMIT = 64;
+/** A span reaching the last hour is read again after this long; an older one is kept until it falls out. */
+const RECENT_READ_TTL_MS = 60_000;
+/** A listing whose hourly bars failed to load is not asked again for this long, so the failure is logged once in it. */
+const FAILED_READ_TTL_MS = 2 * 60_000;
+const logHourlyFailure = logFailure("time-series.coin-session-close", "Read a coin's hourly bars for a comparison failed", null);
+
+function hourlyBars(
+  provider: HourlyProvider,
+  symbol: string,
+  exchange: string,
+  start: number,
+  end: number,
+  now: number,
+): Promise<HourlyRead> {
+  let reads = hourlyReadsBySource.get(provider);
+  if (!reads) hourlyReadsBySource.set(provider, reads = { spans: new Map(), failedUntil: new Map() });
+  const listing = `${symbol}:${exchange}`;
+  if ((reads.failedUntil.get(listing) ?? 0) > now) return Promise.resolve(null);
+  // A span ending now is keyed by its minute, so a chart redrawn within it reads it once.
+  end = Math.ceil(end / 60_000) * 60_000;
+  const key = `${listing}:${start}:${end}`;
+  const cached = reads.spans.get(key);
+  if (cached && (end < now - HOUR_MS || now - cached.at < RECENT_READ_TTL_MS)) return cached.read;
+  const read = fetchHistoryResult(provider as DataProvider, symbol, exchange, { kind: "detail", start: new Date(start), end: new Date(end), interval: "1h" })
+    .then((result) => result ?? Promise.reject(new Error("no hourly bars")))
+    .catch((error: unknown) => {
+      // A failed read is asked again only after FAILED_READ_TTL_MS, and logged once for it.
+      reads!.failedUntil.set(listing, now + FAILED_READ_TTL_MS);
+      if (reads!.spans.get(key)?.read === read) reads!.spans.delete(key);
+      return logHourlyFailure(error);
+    });
+  reads.spans.delete(key);
+  reads.spans.set(key, { at: now, read });
+  if (reads.spans.size > HOURLY_READ_LIMIT) reads.spans.delete(reads.spans.keys().next().value!);
+  return read;
+}
+
+export interface SessionCloseTiming {
+  /** The venue whose close the coins are compared against: the first compared leg that trades in sessions. */
+  venue: string;
+  /** Coin legs measured at that venue's close on each of their days, from hourly bars. */
+  atSessionClose: ReadonlySet<string>;
+  /** Of those, the legs whose newest day's session has closed: their end is that close, not a price still moving. */
+  closedEnds: ReadonlySet<string>;
+}
+
+/** The venue's wall clock of `time` in its zone, to measure a day without a session at its usual close. */
+function wallClock(time: number, zone: string): { hour: number; minute: number } {
+  const { hour, minute } = zonedDateTimeParts(time, zone);
+  return { hour, minute };
+}
+
+/**
+ * A daily comparison of a coin with a listing that trades in sessions (IBIT
+ * against BTC-USD) compares the fund's close at 20:00 UTC with the coin's at
+ * 00:00 UTC, four hours later, which on a falling night is most of the gap.
+ * When the coin's hourly bars cover its whole span, every one of its daily
+ * points from the base to its end is replaced by its price at the session
+ * venue's close (the close of the hourly bar ending then; a day the venue
+ * does not trade, at the clock time of its last close), so both legs and
+ * the line between are measured at the same instants. A coin whose hourly
+ * bars miss any of those hours (they go back a year) keeps its UTC closes
+ * throughout, and the comparison names each close time instead
+ * (priceComparisonCloseTimes): the line and its total never mix the two.
+ *
+ * Null when the comparison has no such pair of legs; otherwise the venue and
+ * the series, with the coin legs that could be measured at its close.
+ */
+export async function coinLegsAtSessionClose(
+  comparison: PriceComparison | null,
+  series: readonly ResolvedSeries[],
+  provider: HourlyProvider,
+  now: number,
+): Promise<{ timing: SessionCloseTiming; series: ResolvedSeries[] } | null> {
+  if (comparison?.alignment !== "session-date" || !comparison.legs) return null;
+  const byId = new Map(series.map((entry) => [entry.id, entry]));
+  const compared = Object.keys(comparison.legs);
+  const venue = compared.map((id) => sessionVenueOf(byId.get(id))).find((entry): entry is string => !!entry);
+  const coins = compared.filter((id) => isRoundTheClockLeg(byId.get(id)) && byId.get(id)!.historyResolution === "1d");
+  const zone = venue ? sessionCalendarTimeZone(venue) : null;
+  if (!venue || !zone || coins.length === 0) return null;
+  const atSessionClose = new Set<string>();
+  const closedEnds = new Set<string>();
+  const next = [...series];
+  await Promise.all(coins.map(async (id) => {
+    const entry = byId.get(id)!;
+    const leg = comparison.legs![id]!;
+    const symbol = entry.listing?.symbol;
+    const baseClose = regularSessionCloseOn(venue, leg.baseDay);
+    // A coin's newest day still running is its latest price; measured at the close only once the venue has closed.
+    const endClose = regularSessionCloseOn(venue, leg.endDay);
+    const endTime = endClose !== null && endClose <= now ? endClose : leg.intraday ? null : endClose;
+    if (!symbol || baseClose === null || (endTime === null && !leg.intraday)) return;
+    // The instant each of the coin's days is measured at: the venue's close that day, or on a day it does not trade,
+    // the clock time of its last close before.
+    const instants = new Map<number, number>();
+    let clock = wallClock(baseClose, zone);
+    entry.points.forEach((point, index) => {
+      const day = point.date.toISOString().slice(0, 10);
+      if (day < leg.baseDay || day > leg.endDay) return;
+      if (day === leg.endDay && endTime === null) return;
+      const close = regularSessionCloseOn(venue, day);
+      if (close !== null) clock = wallClock(close, zone);
+      instants.set(index, close ?? zonedWallClockToUtcMs(zone, Number(day.slice(0, 4)), Number(day.slice(5, 7)), Number(day.slice(8, 10)),
+        clock.hour, clock.minute, 0));
+    });
+    const times = [...instants.values()];
+    const last = Math.max(baseClose, ...times);
+    if (last > now || last - baseClose > HOURLY_REACH_MS) return;
+    const read = await hourlyBars(provider, symbol, entry.listing?.exchange ?? "", baseClose - 2 * HOUR_MS, Math.min(now, last + HOUR_MS), now);
+    if (!read || read.resolution !== "1h") return;
+    // Each finished hourly bar's close by the time it closed; a bar still forming has no close yet.
+    const closes = new Map<number, number>();
+    for (const bar of read.points) {
+      const open = new Date(bar.date).getTime();
+      if (!bar.partial && Number.isFinite(open) && Number.isFinite(bar.close) && bar.close > 0) closes.set(open + HOUR_MS, bar.close);
+    }
+    // Every day or none: a line of closes at the venue's close with a few UTC closes between would be neither.
+    if (!closes.has(baseClose) || times.some((time) => !closes.has(time))) return;
+    const points = entry.points.map((point, index) => {
+      const price = instants.has(index) ? closes.get(instants.get(index)!)! : undefined;
+      return price === undefined ? point : { ...point, value: price, close: price, rawValue: price };
+    });
+    next[next.indexOf(entry)] = { ...entry, points };
+    atSessionClose.add(id);
+    if (endTime !== null) closedEnds.add(id);
+  }));
+  return { timing: { venue, atSessionClose, closedEnds }, series: next };
+}
+
+/**
+ * What a daily comparison of coins with listings that trade in sessions says
+ * of when each is measured: `BTC-USD at the US close` when its hourly bars
+ * put it there, else `BTC-USD to 00:00 UTC, 4 h after the US close`. Null
+ * when no coin is compared with such a listing.
+ */
+export function priceComparisonCloseTimes(
+  comparison: Pick<PriceComparison, "legs">,
+  series: readonly ResolvedSeries[],
+  labels: ReadonlyMap<string, string>,
+  atSessionClose: ReadonlySet<string> = new Set(),
+): string | null {
+  const byId = new Map(series.map((entry) => [entry.id, entry]));
+  const compared = Object.keys(comparison.legs ?? {});
+  const venue = compared.map((id) => sessionVenueOf(byId.get(id))).find((entry): entry is string => !!entry);
+  const coins = compared.filter((id) => isRoundTheClockLeg(byId.get(id)));
+  if (!venue || coins.length === 0) return null;
+  const market = sessionMarketName(venue);
+  const parts = coins.map((id) => {
+    const label = labels.get(id) ?? id;
+    if (atSessionClose.has(id)) return `${label} at the ${market} close`;
+    const leg = comparison.legs![id]!;
+    const sessionClose = leg.intraday ? null : regularSessionCloseOn(venue, leg.endDay);
+    const coinClose = Date.parse(`${leg.endDay}T00:00:00Z`) + DAY_MS;
+    const hours = sessionClose === null ? null : Math.round((coinClose - sessionClose) / HOUR_MS);
+    return hours !== null && hours > 0 ? `${label} to 00:00 UTC, ${hours} h after the ${market} close` : `${label} to 00:00 UTC`;
+  });
+  return parts.join("; ");
+}

package/src/time-series/live-bars.ts

@@ -54,6 +54,8 @@ interface HistoryAnchor {
   /** Identity of the loaded version of the history's newest bar. */
   key: string;
   time: number;
+  /** The session's open, from a quote whose session is the whole bar (quoteSessionRange). */
+  open: number | null;
   /** Live extremes and close observed while this bar is still forming. */
   high: number | null;
   low: number | null;
@@ -211,6 +213,7 @@ export class LiveBarAccumulator {
     this.anchor = {
       key,
       time: latestTime,
+      open: forming ? previous?.open ?? null : null,
       high: carried?.high ?? null,
       low: carried?.low ?? null,
       close: carried?.close ?? null,
@@ -316,6 +319,7 @@ export class LiveBarAccumulator {
       return;
     }
     if (!forming && this.inBar(time, anchor.time, options, exchange)) {
+      if (range?.open !== undefined) anchor.open = range.open;
       anchor.high = Math.max(anchor.high ?? price, price, range?.high ?? price);
       anchor.low = Math.min(anchor.low ?? price, price, range?.low ?? price);
       anchor.close = price;
@@ -364,8 +368,15 @@ export class LiveBarAccumulator {
     const anchor = this.anchor!;
     if (anchor.point?.source === latest && anchor.point.version === this.version) return anchor.point.value;
     let value = latest;
-    // A later quote cannot establish which reported OHLC field was wrong.
-    if (!pricePointIntegrity(latest)) {
+    if (pricePointIntegrity(latest)) {
+      // A later quote cannot establish which reported OHLC field was wrong, unless it names the bar's whole session:
+      // its open, range, price and count are the bar (mergeQuoteIntoLatestBar).
+      if (anchor.open !== null && anchor.close !== null) {
+        const close = anchor.close;
+        value = { ...latest, open: anchor.open, high: Math.max(anchor.high ?? close, anchor.open, close),
+          low: Math.min(anchor.low ?? close, anchor.open, close), close, ...this.cumulative !== null ? { volume: this.cumulative } : {} };
+      }
+    } else {
       let volume = latest.volume;
       const end = anchor.volumeEnd ?? this.cumulative;
       if (isFiniteNumber(volume) && end !== null && anchor.volumeBase !== null) {

package/src/time-series/live-quotes.ts

@@ -3,7 +3,7 @@ import { canonicalTimeSeriesFieldId, isMarketFieldId } from "./field-catalog";
 import type { QuoteSubscriptionTarget } from "../types/data-provider";
 import type { Quote } from "../types/financials";
 import type { ChartSeriesSpec, ChartSpec, SecuritySeriesSource } from "./types";
-import { activeStudyInputSeriesIds } from "./studies";
+import { activeStudyInputSeriesIds } from "./studies/resolve";
 import { valuationSeriesUsesLiveQuote } from "./fundamentals";
 import { hasValidQuoteObservationTime } from "../market-data/quotes/freshness";
 import type { InstrumentRef } from "../market-data/request-types";