@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/tickers/company-name.ts

@@ -1,3 +1,5 @@
+import type { InstrumentSearchResult } from "../types/instrument";
+
 /**
  * Company names as venues spell them, compared and shortened for sentences.
  * One company's listings carry its name with different legal forms and share
@@ -9,7 +11,7 @@
 const NAME_NOISE = new Set([
   "co", "company", "corp", "corporation", "inc", "incorporated", "ltd", "limited", "llc", "lp", "plc", "sa", "ag", "nv", "se",
   "spa", "ab", "as", "asa", "oyj", "bv", "gmbh", "kgaa", "bhd", "berhad", "pcl", "the", "adr", "ads", "cedear", "cedears",
-  "sponsored", "unsponsored", "cdr", "cdi",
+  "sponsored", "unsponsored", "cdr", "cdi", "aktiengesellschaft", "aktiebolag",
 ]);
 // Words a venue adds to the share it lists ("Microsoft Corporation Common Stock"), never part of whose it is.
 const SHARE_NOISE = new Set(["common", "ordinary", "stock", "shares"]);
@@ -43,6 +45,56 @@ export function sameCompany(left: string | null | undefined, right: string | nul
   return [...fewer].every((word) => more.has(word));
 }
 
+// Words that tell one class of a company's shares from another ("Berkshire Hathaway Inc. Class B"), never its business.
+const SHARE_CLASS_WORD = /^(?:class|series|[a-z]|\d+)$/;
+
+/** Whether two names differ only in how they name a class of shares, so they are one company's whatever the venue. */
+function sameBusinessWords(left: Set<string>, right: Set<string>): boolean {
+  const differ = [...left].filter((word) => !right.has(word)).concat([...right].filter((word) => !left.has(word)));
+  return differ.every((word) => SHARE_CLASS_WORD.test(word));
+}
+
+/** A company line as `companyLines` weighs it. */
+export interface CompanyLineFacts {
+  name: string | null | undefined;
+  /** The line's canonical venue. */
+  exchange: string;
+  /** A depositary receipt, whose name says whose shares it holds rather than whose it is. */
+  receipt: boolean;
+  /** The service marks it as its company's home line (`homeListing`). */
+  home: boolean;
+}
+
+/**
+ * The lines among `lines` that are `lead`'s company's own (`sameCompany`),
+ * less those under a name that adds words for another business, though one
+ * name's words are all in the other's: Siemens Energy AG and Siemens
+ * Healthineers AG are not Siemens AG, nor Sony Financial Group Sony Group. A
+ * name is another business's where a venue lists a line under it beside a
+ * line under the lead's own name (both on XETRA, both in Tokyo), or where it
+ * and a line under the lead's name are each marked as a home line, since a
+ * company has one (Siemens Ltd. on NSE beside Siemens AG on XETRA). Receipts
+ * are named for the shares they hold, so they never tell two businesses
+ * apart, and nor do words that name a class of shares (Class B). A name with
+ * more words on no shared venue stays the company's (Deutsche Lufthansa AG on
+ * XETRA for LUFTHANSA on Budapest). `lead` is always one of them.
+ */
+export function companyLines<T>(lead: T, lines: readonly T[], facts: (line: T) => CompanyLineFacts): T[] {
+  const own = facts(lead);
+  const ownWords = companyWords(own.name);
+  const ownName = (line: CompanyLineFacts) => sameBusinessWords(companyWords(line.name), ownWords);
+  const candidates = lines.filter((line) => line === lead || sameCompany(own.name, facts(line).name));
+  const read = candidates.map((line) => ({ line, facts: facts(line), words: companyWords(facts(line).name) }));
+  const ownShares = read.filter((entry) => !entry.facts.receipt && ownName(entry.facts));
+  const ownVenues = new Set(ownShares.map((entry) => entry.facts.exchange).filter(Boolean));
+  const ownHome = ownShares.some((entry) => entry.facts.home);
+  // A name another business goes by, once one of its share lines gives it away: all its lines are that business's.
+  const others = read.filter((entry) => !entry.facts.receipt && !ownName(entry.facts)
+    && ((!!entry.facts.exchange && ownVenues.has(entry.facts.exchange)) || (entry.facts.home && ownHome)));
+  const otherBusiness = (words: Set<string>) => others.some((other) => sameBusinessWords(other.words, words));
+  return read.filter((entry) => entry.line === lead || ownName(entry.facts) || !otherBusiness(entry.words)).map((entry) => entry.line);
+}
+
 /**
  * How many words a listing's name has beyond a company name typed for it,
  * which it must have every word of: 0 for the same name however each spells
@@ -152,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);
@@ -234,3 +305,15 @@ export function companyNameCase(name: string): string {
     }).join("");
   });
 }
+
+/** Letters and digits only, in capitals: "JP Morgan" and "JPMorgan" are JPMORGAN. */
+export function runTogether(text: string): string {
+  return text.normalize("NFKD").replace(/\p{M}/gu, "").toUpperCase().replace(/[^\p{L}\p{N}]/gu, "");
+}
+
+/** Whether the service marked the row with the name as typed: the company it means by it. */
+export function namedByService(typed: string, result: Pick<InstrumentSearchResult, "searchAliases">): boolean {
+  const wanted = runTogether(typed);
+  return !!wanted && Array.isArray(result.searchAliases)
+    && result.searchAliases.some((alias) => typeof alias === "string" && runTogether(alias) === wanted);
+}

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

@@ -1,5 +1,5 @@
-import { canonicalExchange } from "../../utils/exchanges";
-import { companyNameExtraWords, sameCompany } from "../company-name";
+import { canonicalExchange, isUsListingExchange } from "../../utils/exchanges";
+import { companyLines, companyNameExtraWords, namedByService, type CompanyLineFacts } from "../company-name";
 import { answersOnlyByKeyword, isQualifiedTickerQuery } from "./ranking";
 import type { TickerSearchCandidate } from "./types";
 
@@ -29,6 +29,69 @@ export function lineDistance(type: string, exchange: string, symbol: string): 0
   return SECONDARY_VENUES.has(exchange) || /\d/.test(symbol) && /[A-Za-z]/.test(symbol) ? 1 : 0;
 }
 
+/** How the primary-listing choice weighs one of a company's lines. */
+export interface WeighedCompanyLine {
+  /** `listingDistance`: 0 its own line, 1 a line quoting shares listed elsewhere, 2 a receipt. */
+  distance: number;
+  /** The search score the service gives the listings people look up most; null when it gives none. */
+  score: number | null;
+}
+
+/**
+ * The line a company's search lists as its primary listing instead of `lead`,
+ * the line search put first, often the one-off cross-listing whose short name
+ * matched the query (LUFTHANSA on Budapest): its lines go by how far each is
+ * from being its own line, then by the search score. The lead gives way only
+ * to a closer line, or to one searched at least twice as often, or any scored
+ * line when it has no score. With `named` (the service marked the lead with
+ * the name as typed) no score outweighs the mark: only a closer line does.
+ * `lines` holds the lead. `search` and a company's name typed for a listing
+ * (`findListingOfCompanyName`) choose by this one rule, so both open the same
+ * listing.
+ */
+export function primaryCompanyLine<T>(
+  lead: T,
+  lines: readonly T[],
+  weigh: (line: T) => WeighedCompanyLine,
+  options: { named?: boolean } = {},
+): T {
+  const order = (line: T) => lines.indexOf(line);
+  const [home] = [...lines].sort((a, b) => weigh(a).distance - weigh(b).distance
+    || (weigh(b).score ?? -1) - (weigh(a).score ?? -1) || order(a) - order(b));
+  if (!home || home === lead) return lead;
+  const [best, first] = [weigh(home), weigh(lead)];
+  const closer = best.distance < first.distance;
+  const moreSearched = !options.named && best.distance === first.distance && best.score != null
+    && (first.score == null || best.score >= first.score * 2);
+  return closer || moreSearched ? home : lead;
+}
+
+/** A row as `companyLines` weighs it. */
+function lineFacts(candidate: TickerSearchCandidate): CompanyLineFacts {
+  return {
+    name: candidateName(candidate),
+    exchange: candidateExchange(candidate),
+    receipt: listingDistance(candidate) === 2,
+    home: candidate.result?.homeListing === true,
+  };
+}
+
+/** The rows of `lead`'s company among `items` (`companyLines`): never a line of another business its name is in (Siemens Energy for Siemens). */
+function companyRows<T extends TickerSearchCandidate>(lead: T, items: readonly T[]): T[] {
+  return companyLines(lead, items.filter((item) => item === lead || isListedEquity(item)), lineFacts);
+}
+
+/** `primaryCompanyLine` among `items` of `start`'s company, for the command bar's rows. */
+function primaryLineOf<T extends TickerSearchCandidate>(start: T, items: readonly T[], query: string): T {
+  const name = candidateName(start);
+  const named = !!start.result && namedByService(query, start.result);
+  const lines = companyRows(start, items).filter((item) => item === start
+    || !named || companyNameExtraWords(candidateName(item), name) != null);
+  return primaryCompanyLine(start, lines, (item) => ({
+    distance: listingDistance(item), score: item.result?.popularity ?? item.popularity ?? null,
+  }), { named });
+}
+
 function candidateName(candidate: TickerSearchCandidate): string {
   return candidate.result?.name || candidate.detail.split(" | ")[0] || "";
 }
@@ -51,24 +114,57 @@ function isListedEquity(candidate: TickerSearchCandidate): boolean {
  * service marks as the company's home (`homeListing`) takes the lead from
  * the company's first row. Without that mark, a receipt in the lead gives
  * way to the company's own shares on an exchange (`listingDistance` 0, not
- * an OTC or regional line), the name nearest the receipt's first. A query that names a venue (LVMH:TSX,
- * 7203.T) asked for that line, and a saved row keeps the lead.
+ * an OTC or regional line), the name nearest the receipt's first. Then the
+ * line `search` calls the company's primary listing (`primaryCompanyLine`)
+ * takes the lead, so a name opens what `search` lists first: LHA on XETRA
+ * for "lufthansa", not LUFTHANSA on Budapest. A company's lines are never
+ * another business's its name is in (`companyLines`: Siemens Energy AG for
+ * 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 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;
   const lead = items.find((item) => item.instrumentClass !== "fund" && item.instrumentClass !== "derivative"
     && !answersOnlyByKeyword(item, query));
   if (!lead || !isListedEquity(lead)) return items;
+  const typedSymbol = lead.symbol.toUpperCase() === query.trim().toUpperCase();
+  const meant = typedSymbol && !isUsListingExchange(candidateExchange(lead)) && !(lead.result && namedByService(query, lead.result))
+    // A company's shares under another symbol: an index the code also names (SPX) or the word's own line elsewhere (SAP) is not it.
+    ? items.find((item) => item !== lead && isListedEquity(item) && item.instrumentClass === "equity" && !!item.result
+      && 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 = items.filter((item) => item !== lead && isListedEquity(item) && sameCompany(name, candidateName(item)));
+  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))
     || items.indexOf(a) - items.indexOf(b))[0];
   const marked = lines.filter((item) => item.result?.homeListing === true);
+  const own = listingDistance(lead) === 2 ? nearest(lines.filter((item) => listingDistance(item) === 0)) : undefined;
   const home = lead.result?.homeListing === true ? undefined
     : marked.length ? nearest(marked)
-    : listingDistance(lead) === 2 ? nearest(lines.filter((item) => listingDistance(item) === 0))
-    : undefined;
-  if (!home) return items;
+    // A listing searched by its own symbol is that listing, as `search` keeps it.
+    : typedSymbol ? own
+    : primaryLineOf(own ?? lead, [lead, ...lines], query);
+  if (!home || home === lead) return items;
+  return moveAhead(items, home, lead);
+}
+
+/** `items` with `home` moved just ahead of `lead`. */
+function moveAhead<T>(items: readonly T[], home: T, lead: T): T[] {
   const rest = items.filter((item) => item !== home);
   const at = rest.indexOf(lead);
   return [...rest.slice(0, at), home, ...rest.slice(at)];

package/src/tickers/search/index.ts

@@ -54,7 +54,7 @@ export {
   rankTickerSearchItems,
 } from "./ranking";
 export { upsertTickerFromSearchResult } from "./upsert";
-export { candidateExchange, listingDistance } from "./home-listing";
+export { candidateExchange, listingDistance, primaryCompanyLine } from "./home-listing";
 
 const MAX_NAMED_LISTINGS = 6;
 
@@ -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";