gloomberb 0.18.2 → 0.18.4

package/src/portfolio/mutations.ts

@@ -1,11 +1,11 @@
 import type { AppConfig } from "../types/config";
 import type { Portfolio, PortfolioCash, TickerPosition, TickerRecord, Watchlist } from "../types/ticker";
-import { resolveCurrencyUnit, US_CENTS } from "../utils/currency-units";
+import { normalizeHeldCurrencyCode, resolveCurrencyUnit, US_CENTS } from "../utils/currency-units";
 import { slugifyName } from "../utils/slugify";
 import { parseCollectionRef } from "../team/collections";
 import { findNamedCollection } from "./collection-name";
 import { isFuturesTicker } from "./futures-positions";
-import { manualPortfolioLots } from "./manual-lots";
+import { manualPortfolioLots, mergeLotCostTerms, type LotCostFxConflict } from "./manual-lots";
 
 export interface DeleteWatchlistResult {
   config: AppConfig;
@@ -39,15 +39,41 @@ export interface SetManualPortfolioPositionInput {
    * read does not unsize it.
    */
   multiplier?: number;
-  /** The purchase date, YYYY-MM-DD. Left out, a single manual lot keeps the one it had. */
-  dateAcquired?: string;
+  /**
+   * The purchase date, YYYY-MM-DD. Null clears it; left out, the lots keep
+   * theirs (several, their earliest: mergeLotCostTerms).
+   */
+  dateAcquired?: string | null;
   /**
    * The rate the cost was bought at: one unit of `currency` in `costFx.currency`.
-   * Null clears it; left out, a single manual lot in the same currency keeps the one it had.
+   * Null clears it; left out, manual lots in the same currency keep theirs
+   * (several, weighted by cost), and lots whose rates cannot become one
+   * refuse the set (LotCostFxMergeError).
    */
   costFx?: { rate: number; currency: string } | null;
 }
 
+/**
+ * Several lots replaced by one position whose cost FX rate would be inferred
+ * from theirs, when theirs cannot honestly become one (mergeLotCostTerms):
+ * the set is refused until the position's own rate is given or cleared.
+ */
+export class LotCostFxMergeError extends Error {
+  constructor(readonly lotCount: number, readonly conflict: LotCostFxConflict, ratedCount: number) {
+    super(lotCostFxMergeMessage(lotCount, conflict, ratedCount));
+    this.name = "LotCostFxMergeError";
+  }
+}
+
+function lotCostFxMergeMessage(lotCount: number, conflict: LotCostFxConflict, ratedCount: number): string {
+  if (conflict === "lot-currencies") return `The ${lotCount} lots are in different currencies, so one position cannot keep the FX rate their costs were bought at.`;
+  if (conflict === "rate-currencies") return `The ${lotCount} lots' costs were converted into different currencies, so one position cannot keep their FX rates.`;
+  const rated = ratedCount === 1
+    ? "1 converts its cost at the FX rate it was bought at"
+    : `${ratedCount} convert their cost at the FX rate they were bought at`;
+  return `Of the ${lotCount} lots, ${rated} and ${lotCount - ratedCount} at today's, so one position cannot keep their rates.`;
+}
+
 /** What a position's size counts, as its field and messages name it. */
 export type PositionQuantityLabel = "Contracts" | "Shares";
 
@@ -112,7 +138,11 @@ export function resolveManualPositionCurrency(
   baseCurrency: string | undefined,
   contractCurrency?: string | null,
 ): string {
-  return (rawCurrency?.trim() || contractCurrency?.trim() || ticker.metadata.currency || portfolio.currency || baseCurrency || "USD").toUpperCase();
+  // Pence typed as GBp stay pence: upper-cased they would read as pounds. A listing's own GBp is
+  // what its quote is shown in once converted, pounds, so a blank currency still saves GBP.
+  const typed = rawCurrency?.trim();
+  if (typed) return normalizeHeldCurrencyCode(typed);
+  return (contractCurrency?.trim() || ticker.metadata.currency || portfolio.currency || baseCurrency || "USD").toUpperCase();
 }
 
 /** A plain ISO code in major units (AUD), else null: pence-type units, US cents and free text never total a portfolio. */
@@ -140,10 +170,11 @@ export function hasOpenPortfolioPositions(portfolioId: string, tickers: Iterable
 /**
  * Whether a manual portfolio's currency follows its holdings. Only with the
  * default USD base: a base currency the user chose is what manual portfolios
- * total in. Team portfolios keep the currency the team gave them.
+ * total in. Team portfolios keep the currency the team gave them, and one
+ * created in a currency keeps that.
  */
 function takesHoldingsCurrency(config: AppConfig, portfolio: Portfolio): boolean {
-  return isManualPortfolio(portfolio) && !portfolio.teamId && config.baseCurrency.trim().toUpperCase() === "USD";
+  return isManualPortfolio(portfolio) && !portfolio.teamId && !portfolio.fixedCurrency && config.baseCurrency.trim().toUpperCase() === "USD";
 }
 
 function withPortfolioCurrency(config: AppConfig, portfolioId: string, currency: string): AppConfig {
@@ -239,10 +270,15 @@ export function clearPortfolioTargetWeights(
   };
 }
 
+/**
+ * A new manual portfolio in `baseCurrency`, or, with `fixedCurrency`, in
+ * `currency` for good (Portfolio.fixedCurrency).
+ */
 export function createManualPortfolio(
   config: AppConfig,
   name: string,
   baseCurrency: string,
+  { fixedCurrency }: { fixedCurrency?: string } = {},
 ): { config: AppConfig; portfolio: Portfolio } {
   const trimmedName = name.trim();
   if (!trimmedName) {
@@ -258,11 +294,9 @@ export function createManualPortfolio(
     throw new Error(`Portfolio "${trimmedName}" already exists.`);
   }
 
-  const portfolio: Portfolio = {
-    id,
-    name: trimmedName,
-    currency: (baseCurrency || config.baseCurrency || "USD").toUpperCase(),
-  };
+  const portfolio: Portfolio = fixedCurrency
+    ? { id, name: trimmedName, currency: fixedCurrency.toUpperCase(), fixedCurrency: true }
+    : { id, name: trimmedName, currency: (baseCurrency || config.baseCurrency || "USD").toUpperCase() };
 
   return {
     config: {
@@ -399,7 +433,7 @@ export function setManualPortfolioPosition(
   portfolioId: string,
   input: SetManualPortfolioPositionInput,
 ): SetManualPortfolioPositionResult {
-  const nextCurrency = input.currency.trim().toUpperCase();
+  const nextCurrency = normalizeHeldCurrencyCode(input.currency);
   const sharesError = validatePositionShares(input.shares, positionQuantityLabel(ticker));
   if (sharesError) throw new Error(sharesError);
   if (!Number.isFinite(input.avgCost)) {
@@ -411,14 +445,18 @@ export function setManualPortfolioPosition(
 
   const replacedPositions = ticker.metadata.positions.filter((position) => position.portfolio === portfolioId);
   const replacedPositionCount = replacedPositions.length;
-  // Editing a single snapshot (for example after a split) does not change its
-  // acquisition date. A consolidated replacement of several lots has no one date.
-  const single = replacedPositions.length === 1 && replacedPositions[0]?.broker === "manual" ? replacedPositions[0] : null;
-  const dateAcquired = input.dateAcquired ?? single?.dateAcquired;
-  // The rate the cost was bought at goes with its cost: a lot kept in its currency keeps it unless it is replaced or cleared.
-  const keptCostFx = single && single.currency?.trim().toUpperCase() === nextCurrency
-    && typeof single.costFxRate === "number" && single.costFxCurrency
-    ? { rate: single.costFxRate, currency: single.costFxCurrency } : null;
+  // Editing a snapshot (for example after a split) changes neither its purchase date nor, while its
+  // currency stays, the rate its cost was bought at. Several manual lots keep theirs merged.
+  const manual = replacedPositions.length > 0 && replacedPositions.every((position) => position.broker === "manual");
+  const kept = manual ? mergeLotCostTerms(replacedPositions) : {};
+  const dateAcquired = input.dateAcquired === undefined ? kept.dateAcquired : input.dateAcquired;
+  const keptCostFx = kept.costFx && kept.currency === nextCurrency ? kept.costFx : null;
+  // Lots in this currency with a rate that cannot become the position's: refused rather than dropped or guessed.
+  const ratedHere = replacedPositions.filter((position) =>
+    normalizeHeldCurrencyCode(position.currency) === nextCurrency && position.costFxRate != null && position.costFxCurrency);
+  if (input.costFx === undefined && kept.costFxConflict && ratedHere.length > 0) {
+    throw new LotCostFxMergeError(replacedPositions.length, kept.costFxConflict, replacedPositions.filter((position) => position.costFxRate != null && position.costFxCurrency).length);
+  }
   const costFx = input.costFx === undefined ? keptCostFx : input.costFx;
   if (costFx && !(Number.isFinite(costFx.rate) && costFx.rate > 0)) throw new Error("The cost FX rate must be a positive number.");
   // A contract's size does not change with the count held; one the lots agree on carries over.

package/src/portfolio/suffixed-listings.ts

@@ -0,0 +1,209 @@
+import type { AppConfig } from "../types/config";
+import type { TickerMetadata, TickerPosition, TickerRecord } from "../types/ticker";
+import { listingSuffixVenue, tickerHasListingSuffix } from "../sources/listing-symbols";
+import { canonicalExchange, parsePublicTickerKey, publicTickerKey } from "../utils/exchanges";
+
+/**
+ * A lot as the fields sync keeps of it (`sanitizePosition`), so a copy that
+ * went through sync, or through an older build, reads as the same lot.
+ */
+function lotFingerprint(lot: TickerPosition): string {
+  const costFx = lot.costFxRate != null && lot.costFxCurrency ? [lot.costFxRate, lot.costFxCurrency] : [null, null];
+  return JSON.stringify([
+    lot.portfolio, lot.shares, lot.avgCost ?? null, lot.currency ?? null, lot.dateAcquired ?? null, ...costFx,
+    lot.broker, lot.side ?? null, lot.multiplier ?? null,
+  ]);
+}
+
+interface SuffixedListingMerge {
+  /** The rows to save: each listing's row with what its suffixed rows held, then those rows emptied. */
+  saves: TickerRecord[];
+  /**
+   * Each suffixed row's key to its listing row's key: the rows merged now,
+   * and ones merged before, whose targets an older copy of the config may
+   * still name.
+   */
+  moved: Map<string, string>;
+  /** Custom fields a suffixed row held another value for than its listing's row did: kept on the suffixed row. */
+  keptCustom: Array<{ from: string; into: string; fields: string[] }>;
+}
+
+function isFiled(metadata: TickerMetadata): boolean {
+  return metadata.portfolios.length > 0 || metadata.watchlists.length > 0 || metadata.positions.length > 0;
+}
+
+/** A broker's row: the broker keys what it reports, and its next sync writes there again. */
+function isBrokerRow(metadata: TickerMetadata): boolean {
+  return (metadata.broker_contracts ?? []).length > 0 || metadata.positions.some((position) => position.broker !== "manual");
+}
+
+function union(left: readonly string[], right: readonly string[]): string[] {
+  return [...new Set([...left, ...right])];
+}
+
+function isEmptyValue(value: unknown): boolean {
+  return value == null || (typeof value === "string" && value.trim() === "");
+}
+
+/**
+ * The listing's custom fields with the suffixed row's: the listing's value
+ * where it has one, else the suffixed row's. A field both hold with other
+ * values keeps the listing's, and the suffixed row's value stays with it.
+ */
+function mergeCustom(listing: Record<string, unknown>, suffixed: Record<string, unknown>) {
+  const custom = { ...listing };
+  const kept: Record<string, unknown> = {};
+  for (const [field, value] of Object.entries(suffixed)) {
+    if (isEmptyValue(value)) continue;
+    if (isEmptyValue(custom[field])) custom[field] = value;
+    else if (JSON.stringify(custom[field]) !== JSON.stringify(value)) kept[field] = value;
+  }
+  return { custom, kept };
+}
+
+/**
+ * The key of a listing's row (SYMBOL on VENUE): the row saved there already,
+ * under the bare symbol or a venue key, else, when `create`, the venue's key
+ * (GARAN:BIST, SHOP:XTSE). A merge never takes the bare key, so typing SHOP
+ * still means the US listing. Null when there is none to take, or the
+ * venue's key holds another venue's row.
+ */
+function listingKey(
+  symbol: string,
+  exchange: string,
+  rows: ReadonlyMap<string, TickerRecord>,
+  keysBySymbol: ReadonlyMap<string, readonly string[]>,
+  create: boolean,
+): string | null {
+  const onVenue = (key: string) => canonicalExchange(rows.get(key)?.metadata.exchange) === exchange;
+  const venueKey = publicTickerKey(symbol, exchange);
+  if (onVenue(symbol)) return symbol;
+  if (onVenue(venueKey)) return venueKey;
+  const named = keysBySymbol.get(symbol)?.find((key) => !!parsePublicTickerKey(key).exchange && onVenue(key));
+  if (named) return named;
+  return create && !rows.has(venueKey) ? venueKey : null;
+}
+
+/**
+ * Rows a portfolio or watchlist holds under a vendor's suffixed key (GARAN.IS
+ * on BIST) merged into their listing's own row (GARAN on BIST), which is made
+ * when there is none (`listingKey`): memberships, tags and custom fields
+ * (`mergeCustom`) join, and lots are added, each once: the listing's row
+ * records what it took (`mergedLots`), so a copy sync brings back is not
+ * counted twice. The suffixed row stays, emptied, for a link or a layout that
+ * names it. A broker's row is the broker's to key and stays as it is, and so
+ * does a suffix no saved venue confirms (`listingSuffixVenue`: MKC.V on NYSE
+ * is a share class). Null when no suffixed row has a listing's row.
+ */
+export function mergeSuffixedListings(tickers: readonly TickerRecord[]): SuffixedListingMerge | null {
+  const rows = new Map(tickers.map((ticker) => [ticker.metadata.ticker, ticker] as const));
+  const keysBySymbol = new Map<string, string[]>();
+  const index = (key: string) => {
+    const { symbol } = parsePublicTickerKey(key);
+    keysBySymbol.set(symbol, [...keysBySymbol.get(symbol) ?? [], key]);
+  };
+  for (const key of rows.keys()) index(key);
+  const listings = new Set<string>();
+  const emptied = new Set<string>();
+  const moved = new Map<string, string>();
+  const keptCustom: SuffixedListingMerge["keptCustom"] = [];
+  for (const { metadata: suffixed } of tickers) {
+    if (isBrokerRow(suffixed)) continue;
+    const parsed = parsePublicTickerKey(suffixed.ticker);
+    if (!tickerHasListingSuffix(parsed.symbol)) continue;
+    const venue = listingSuffixVenue(parsed.symbol, parsed.exchange ?? suffixed.exchange);
+    if (!venue) continue;
+    const filed = isFiled(suffixed);
+    const key = listingKey(venue.symbol, venue.exchange, rows, keysBySymbol, filed);
+    if (!key) continue;
+    moved.set(suffixed.ticker, key);
+    if (!filed) continue;
+    const existing = rows.get(key)?.metadata;
+    if (!existing) index(key);
+    const { mergedLots: _lots, broker_contracts: _contracts, ...rest } = suffixed;
+    const listing: TickerMetadata = existing ?? {
+      ...rest, ticker: key, exchange: venue.exchange, portfolios: [], watchlists: [], positions: [], tags: [], custom: {},
+    };
+    // Lots the listing's row took from this key before count once: a copy brought back is not added again.
+    const taken = [...listing.mergedLots?.[suffixed.ticker] ?? []];
+    const unseen = [...taken];
+    const added: TickerPosition[] = [];
+    for (const lot of suffixed.positions) {
+      const fingerprint = lotFingerprint(lot);
+      const seen = unseen.indexOf(fingerprint);
+      if (seen >= 0) {
+        unseen.splice(seen, 1);
+        continue;
+      }
+      added.push(lot);
+      taken.push(fingerprint);
+    }
+    const { custom, kept } = mergeCustom(listing.custom, suffixed.custom);
+    if (Object.keys(kept).length > 0) keptCustom.push({ from: suffixed.ticker, into: key, fields: Object.keys(kept) });
+    rows.set(key, {
+      metadata: {
+        ...listing,
+        name: listing.name || suffixed.name,
+        currency: listing.currency || suffixed.currency,
+        portfolios: union(listing.portfolios, [...suffixed.portfolios, ...added.map((lot) => lot.portfolio)]),
+        watchlists: union(listing.watchlists, suffixed.watchlists),
+        positions: [...listing.positions, ...added],
+        tags: union(listing.tags, suffixed.tags),
+        custom,
+        ...taken.length > 0 ? { mergedLots: { ...listing.mergedLots, [suffixed.ticker]: taken } } : {},
+      },
+    });
+    rows.set(suffixed.ticker, { metadata: { ...suffixed, portfolios: [], watchlists: [], positions: [], tags: [], custom: kept } });
+    listings.add(key);
+    emptied.add(suffixed.ticker);
+  }
+  if (moved.size === 0) return null;
+  // The listings' rows first: saved in this order, a stop between them loses nothing.
+  return { saves: [...listings, ...emptied].map((key) => rows.get(key)!), moved, keptCustom };
+}
+
+/**
+ * The config with each portfolio's target for a suffixed key moved to its
+ * listing's row, added to any target that row had: the two rows' share of
+ * the portfolio is one listing's. The same config when no target moved.
+ */
+export function moveTargetWeights(config: AppConfig, moved: ReadonlyMap<string, string>): AppConfig {
+  let changed = false;
+  const portfolios = config.portfolios.map((portfolio) => {
+    const targets = portfolio.targetWeights;
+    if (!targets || ![...moved.keys()].some((key) => key in targets)) return portfolio;
+    const next = { ...targets };
+    for (const [from, to] of moved) {
+      if (!(from in next)) continue;
+      next[to] = (next[to] ?? 0) + next[from]!;
+      delete next[from];
+    }
+    changed = true;
+    return { ...portfolio, targetWeights: next };
+  });
+  return changed ? { ...config, portfolios } : config;
+}
+
+/**
+ * `mergeSuffixedListings` for a saved profile: the config with its targets
+ * moved is saved first, then the rows, the listings' before the ones they
+ * took from, so a stop at any point leaves nothing a second run does not
+ * finish. The profile comes back as it now is; null when nothing changed.
+ */
+export async function mergeSavedSuffixedListings(
+  tickers: readonly TickerRecord[],
+  config: AppConfig,
+  save: { config: (config: AppConfig) => Promise<void>; tickers: (rows: TickerRecord[]) => Promise<void> },
+): Promise<{ tickers: TickerRecord[]; config: AppConfig; keptCustom: SuffixedListingMerge["keptCustom"] } | null> {
+  const merge = mergeSuffixedListings(tickers);
+  if (!merge) return null;
+  const nextConfig = moveTargetWeights(config, merge.moved);
+  if (merge.saves.length === 0 && nextConfig === config) return null;
+  if (nextConfig !== config) await save.config(nextConfig);
+  if (merge.saves.length > 0) await save.tickers(merge.saves);
+  const saved = new Map(merge.saves.map((row) => [row.metadata.ticker, row] as const));
+  const kept = tickers.map((ticker) => saved.get(ticker.metadata.ticker) ?? ticker);
+  const keys = new Set(tickers.map((ticker) => ticker.metadata.ticker));
+  const added = merge.saves.filter((row) => !keys.has(row.metadata.ticker));
+  return { tickers: [...kept, ...added], config: nextConfig, keptCustom: merge.keptCustom };
+}

package/src/portfolio/totals-currency.ts

@@ -0,0 +1,24 @@
+import type { Portfolio } from "../types/ticker";
+import { isManualPortfolio } from "./mutations";
+
+const CURRENCY_CODE = /^[A-Z]{3}$/;
+
+function currencyCode(value: string | undefined): string | null {
+  const code = value?.trim().toUpperCase() ?? "";
+  return CURRENCY_CODE.test(code) ? code : null;
+}
+
+/**
+ * The currency a portfolio's totals, market values and P&L are in. A broker
+ * portfolio uses its account currency, and a manual one created in a
+ * currency that currency. Another manual portfolio uses its stored currency
+ * with the default USD base (its first holding sets it, see
+ * adoptFirstPositionCurrency); a base currency the user chose is what manual
+ * portfolios and watchlists total in.
+ */
+export function resolvePortfolioTotalsCurrency(portfolio: Portfolio | null | undefined, baseCurrency: string): string {
+  const base = currencyCode(baseCurrency) ?? "USD";
+  if (!portfolio) return base;
+  if (isManualPortfolio(portfolio) && !portfolio.fixedCurrency && base !== "USD") return base;
+  return currencyCode(portfolio.currency) ?? base;
+}

package/src/public/__snapshots__/public-api.test.ts.snap

@@ -44,7 +44,9 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "BulletList",
     "Button",
     "ButtonActionScope",
+    "COUNTRY_FLAG_CELLS",
     "Card",
+    "ChartRead",
     "ChartStrip",
     "ChartTableHeader",
     "Checkbox",
@@ -53,6 +55,8 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "ColumnGridPair",
     "CompositeChart",
     "ConfirmDialog",
+    "CountryFlag",
+    "CountryFlagLead",
     "CurveSurface",
     "DELAYED_SEGMENT",
     "DataTable",
@@ -168,6 +172,7 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "statGridRows",
     "staticSeries",
     "unavailableText",
+    "useChartReadRows",
     "useChartTableLayout",
     "useChartTableSelection",
     "useExternalLinkFooter",
@@ -183,8 +188,11 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "usePaneTabs",
     "usePaneTicker",
     "useQueryBarSearch",
+    "useRowNotes",
     "useTableLoadMore",
     "useTickerRowPaneMenu",
+    "withCountryFlag",
+    "withFlagRoom",
   ],
   "./dialog": [
     "DialogHostProvider",
@@ -383,6 +391,9 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "SERIES_FREQUENCIES",
     "TIME_RANGES",
     "TIME_RANGE_ORDER",
+    "aggregatePriceBars",
+    "chartBarSizeSource",
+    "chartBarSizeStepMs",
     "clampTimeRangeToMaxRange",
     "defineSeries",
     "describeSeriesUnits",
@@ -396,11 +407,14 @@ exports[`the runtime exports of every public subpath are the reviewed ones 1`] =
     "getSupportedPresetResolution",
     "inferSeriesFrequency",
     "intersectChartResolutionSupport",
+    "isChartResolution",
     "isIntradayResolution",
+    "isManualChartResolution",
     "isRangePresetSupported",
     "isValidSeriesUnit",
     "normalizeChartResolution",
     "normalizeChartResolutionSupport",
+    "parseChartBarSize",
     "parseSeriesCsv",
     "sortChartResolutions",
     "validateSeriesDefinition",

package/src/public/time-series.ts

@@ -11,19 +11,22 @@ export {
   CHART_RESOLUTIONS, TIME_RANGES,
 } from "../time-series/range";
 export type {
-  ChartDateWindow, ChartResolution, TimeRange,
+  ChartBarSizeUnit, ChartDateWindow, ChartResolution, CustomChartResolution, TimeRange,
 } from "../time-series/range";
 export {
-  CHART_RESOLUTION_STEP_MS, clampTimeRangeToMaxRange, DEFAULT_CHART_RESOLUTION_SUPPORT,
-  getBestSupportedResolutionForVisibleWindow, getChartResolutionLabel, getExpandedBufferRange,
-  getNextBufferRange, getPresetResolution, getSupportedChartResolutionsForViewport,
-  getSupportedPresetResolution, getSupportMaxRange, intersectChartResolutionSupport,
-  isIntradayResolution, isRangePresetSupported, normalizeChartResolution,
-  normalizeChartResolutionSupport, sortChartResolutions, TIME_RANGE_ORDER,
+  CHART_RESOLUTION_STEP_MS, chartBarSizeSource, chartBarSizeStepMs, clampTimeRangeToMaxRange,
+  DEFAULT_CHART_RESOLUTION_SUPPORT, getBestSupportedResolutionForVisibleWindow, getChartResolutionLabel,
+  getExpandedBufferRange, getNextBufferRange, getPresetResolution, getSupportedChartResolutionsForViewport,
+  getSupportedPresetResolution, getSupportMaxRange, intersectChartResolutionSupport, isChartResolution,
+  isIntradayResolution, isManualChartResolution, isRangePresetSupported, normalizeChartResolution,
+  normalizeChartResolutionSupport, parseChartBarSize, sortChartResolutions, TIME_RANGE_ORDER,
 } from "../time-series/resolution";
 export type {
-  ChartResolutionSupport, ManualChartResolution,
+  ChartBarSize, ChartResolutionSupport, ManualChartResolution,
 } from "../time-series/resolution";
+// Bars of a size the source does not serve, built from its shorter ones the way the chart builds them.
+export { aggregatePriceBars } from "../time-series/bar-aggregation";
+export type { AggregatedPricePoint, BarAggregationListing } from "../time-series/bar-aggregation";
 
 // The resolved shape itself: what a chart-series capability returns and what
 // the composite chart draws. A plugin that answers `chartSeriesProvider`

package/src/remote/schema.ts

@@ -375,7 +375,7 @@ export const REMOTE_OPERATIONS: RemoteOperationSchema[] = [
 ];
 
 export const REMOTE_AGENT_HELP = {
-  title: "Gloomberb remote control guide",
+  title: "Gloom remote control guide",
   quickStart: [
     "Read app://snapshot once to orient; it includes schema, current layout, panes, command bar state, and semantic UI nodes.",
     "Prefer app-level operations such as app.search, layout.setGrid, layout.closeFloating, and ticker.pin before falling back to ui.invoke.",

package/src/renderers/browser/config-host.ts

@@ -16,6 +16,7 @@ import {
 } from "../../types/config";
 import { researchEntryFromSearch } from "./research-entry";
 import { BROWSER_STORAGE_KEYS, SafeJsonStorage, type StorageLike } from "../../data/json-storage";
+import { stopBootFrameRecorders } from "../dom/boot-frame";
 
 export const BROWSER_DATA_DIR = "browser://local";
 
@@ -168,6 +169,8 @@ export function createBrowserConfigStore(storage: StorageLike, search = ""): Con
       return config;
     },
     async resetAllData(dataDir) {
+      // Before the keys go, or the frame saved as the page closes would bring the old layout back.
+      stopBootFrameRecorders();
       for (const key of Object.values(BROWSER_STORAGE_KEYS)) {
         try { storage.removeItem(key); } catch {}
       }

package/src/renderers/browser/main.tsx

@@ -9,6 +9,8 @@ import { getBrowserPlugins } from "../../plugins/catalog-browser";
 import { DomErrorBoundary, DomHostProviders } from "../dom/dom-host-providers";
 import { installFocusScopeRelease } from "../dom/host/focus-scope";
 import { installDomMarketDataFrames } from "../dom/data-frames";
+import { releaseBootFrameWhenDrawn, startBootFrameRecorder } from "../dom/boot-frame";
+import { BROWSER_STORAGE_KEYS } from "../../data/json-storage";
 import { createBrowserAppServices } from "./app-services";
 import {
   installBrowserFetchTransports,
@@ -69,7 +71,11 @@ if (!rootElement) throw new Error("Missing root element");
 const appRootElement = rootElement;
 appRootElement.tabIndex = -1;
 const root = createRoot(appRootElement);
-root.render(<div className="gloom-loading">Starting Gloomberb...</div>);
+// The page drew the last session's layout, or the bare shell, before this
+// script loaded (dom/boot-frame.ts); it stays until the app has drawn its own.
+const releaseBootFrame = releaseBootFrameWhenDrawn(document, appRootElement);
+/** How long after the app mounts the launch frame stays at most. */
+const BOOT_FRAME_RELEASE_FALLBACK_MS = 4_000;
 
 async function boot(): Promise<void> {
   // Read before anything can save a workspace or tidy the address.
@@ -145,7 +151,7 @@ async function boot(): Promise<void> {
   root.render(
     <DomErrorBoundary label="Browser renderer crashed" fallback={(error) => (
       <div className="gloom-fatal">
-        <h1>Gloomberb crashed</h1>
+        <h1>Gloom crashed</h1>
         <pre>{error instanceof Error ? error.message : String(error)}</pre>
         <button onClick={() => window.location.reload()}>Reload</button>
       </div>
@@ -163,10 +169,24 @@ async function boot(): Promise<void> {
     </DomErrorBoundary>,
   );
   appRootElement.focus({ preventScroll: true });
+  // A layout with neither panes nor a status bar has nothing to wait for.
+  window.setTimeout(releaseBootFrame, BOOT_FRAME_RELEASE_FALLBACK_MS);
+  startBootFrameRecorder({
+    doc: document,
+    root: appRootElement,
+    save: (frame) => {
+      try {
+        localStorage.setItem(BROWSER_STORAGE_KEYS.bootFrame, JSON.stringify(frame));
+      } catch {
+        // Intentional ignore: storage full or blocked; the next launch draws the bare shell.
+      }
+    },
+  });
 }
 
 void boot().catch((error) => {
   reportCrash(error, { kind: "uncaught" });
   const message = error instanceof Error ? error.message : String(error);
-  root.render(<div className="gloom-fatal"><h1>Gloomberb failed to start</h1><pre>{message}</pre></div>);
+  releaseBootFrame();
+  root.render(<div className="gloom-fatal"><h1>Gloom failed to start</h1><pre>{message}</pre></div>);
 });