gloomberb 0.16.2 → 0.16.4

package/src/sources/sec-edgar.ts

@@ -39,6 +39,8 @@ type CompanyFactsEntry = {
   form?: string;
   filed?: string;
   frame?: string;
+  /** A fact reporting the same figure for this span carries SEC's calendar-quarter frame. */
+  framedQuarter?: boolean;
 };
 
 type CompanyFactsStatementField = {
@@ -398,6 +400,23 @@ function companyFactsEntries(payload: unknown, tag: string, units: string[]): Co
   return [];
 }
 
+/**
+ * SEC frames one fact per span, the latest filed: a 10-K's own fourth quarter
+ * is framed only on the next 10-K that repeats it. An earlier fact reporting
+ * the framed figure for that span is that quarter too, so it keeps its date.
+ */
+function withFramedQuarters(entries: CompanyFactsEntry[], sameFigure?: SameFigure): CompanyFactsEntry[] {
+  const span = (entry: CompanyFactsEntry) => `${entry.start}:${entry.end}`;
+  const framed = new Map<string, CompanyFactsEntry[]>();
+  for (const entry of entries) {
+    if (!entry.start || !/^CY\d{4}Q[1-4]$/.test(entry.frame ?? "")) continue;
+    framed.set(span(entry), [...framed.get(span(entry)) ?? [], entry]);
+  }
+  if (!framed.size) return entries;
+  return entries.map((entry) => entry.start && framed.get(span(entry))?.some((quarter) =>
+    Object.is(quarter.val, entry.val) || sameFigure?.(entry, quarter)) ? { ...entry, framedQuarter: true } : entry);
+}
+
 function secFormRank(form: string | undefined): number {
   const normalized = normalize(form);
   if (normalized === "10-K/A") return 4;
@@ -415,6 +434,7 @@ function companyFactsFiledRank(value: string | undefined): number {
 function shouldReplaceCompanyFact(
   candidate: CompanyFactsEntry,
   selected: CompanyFactsEntry | undefined,
+  repeats?: SameFigure,
 ): boolean {
   if (!selected) return true;
   const left = candidate;
@@ -433,13 +453,45 @@ function shouldReplaceCompanyFact(
     if (filedDiff < 0) return false;
     // Later comparative repeats do not move the original disclosure date.
     // A later value change is a restatement and replaces the selected fact.
-    return !Object.is(left.val, right.val);
+    return !Object.is(left.val, right.val) && !repeats?.(left, right);
   }
   const formDiff = secFormRank(left.form) - secFormRank(right.form);
   if (formDiff !== 0) return formDiff > 0;
   return String(left.frame ?? "").localeCompare(String(right.frame ?? "")) > 0;
 }
 
+/** Whether two facts for one span report the same figure under different values. */
+type SameFigure = (left: CompanyFactsEntry, right: CompanyFactsEntry) => boolean;
+
+/**
+ * A split re-expresses EPS on the new share count: two values are one figure
+ * when the share-basis evidence puts them on different bases and they agree
+ * on the current one within each filing's cent rounding.
+ */
+function splitEquivalent(resolveEps: ReturnType<typeof createSecEpsBasisResolver>): SameFigure {
+  return (left, right) => {
+    const [a, b] = [resolveEps(left), resolveEps(right)];
+    return a.basis?.status === "split-adjusted" && b.basis?.status === "split-adjusted" && a.basis.factor !== b.basis.factor
+      && a.value !== undefined && b.value !== undefined
+      && Math.abs(a.value - b.value) <= .005 / a.basis.factor! + .005 / b.basis.factor! + 1e-12;
+  };
+}
+
+/**
+ * A later split re-expression of the selected EPS, or a later repeat of one,
+ * is a comparative repeat and not a restatement. The original disclosure
+ * stays selected and dated; the resolver carries it to the current basis.
+ */
+function splitRepeats(sameFigure: SameFigure): SameFigure {
+  const repeated = new WeakMap<CompanyFactsEntry, Set<number>>();
+  return (candidate, selected) => {
+    if (repeated.get(selected)?.has(candidate.val!)) return true;
+    if (!sameFigure(candidate, selected)) return false;
+    repeated.set(selected, (repeated.get(selected) ?? new Set()).add(candidate.val!));
+    return true;
+  };
+}
+
 function compareCompanyFactsChronologically(
   left: CompanyFactsEntry,
   right: CompanyFactsEntry,
@@ -484,7 +536,7 @@ function isQuarterlyCompanyFact(entry: CompanyFactsEntry, periodType: "duration"
       || new Date(start).toISOString().slice(0, 10) !== entry.start
       || new Date(end).toISOString().slice(0, 10) !== entry.end) return false;
   }
-  if (/^CY\d{4}Q[1-4]$/.test(entry.frame ?? "")) return true;
+  if (/^CY\d{4}Q[1-4]$/.test(entry.frame ?? "") || entry.framedQuarter) return true;
   const form = normalize(entry.form);
   const fiscalPeriod = normalize(entry.fp ?? undefined);
   if ((form !== "10-Q" && form !== "10-Q/A") || !/^Q[1-3]$/.test(fiscalPeriod)) return false;
@@ -505,9 +557,10 @@ function setCompanyFactValue(
   field: keyof FinancialStatement,
   value: number,
   entry: CompanyFactsEntry,
+  repeats?: SameFigure,
 ): void {
   const selectionKey = `${date}:${String(field)}`;
-  if (!shouldReplaceCompanyFact(entry, selectedFacts.get(selectionKey))) return;
+  if (!shouldReplaceCompanyFact(entry, selectedFacts.get(selectionKey), repeats)) return;
   const row = rows.get(date) ?? { date, dateSource: "sec", currency: "USD" };
   (row as unknown as Record<string, unknown>)[field] = value;
   if (entry.filed) {
@@ -532,6 +585,7 @@ function fillCompanyFactsStatementRows(
   field: CompanyFactsStatementField,
   period: "annual" | "quarterly",
   annualPeriodEnds: ReadonlySet<string>,
+  repeats?: SameFigure,
 ): void {
   for (const entry of [...entries].sort(compareCompanyFactsChronologically)) {
     if (!entry.end || typeof entry.val !== "number") continue;
@@ -548,6 +602,7 @@ function fillCompanyFactsStatementRows(
       field.field,
       field.transform ? field.transform(entry.val) : entry.val,
       entry,
+      repeats,
     );
   }
 }
@@ -648,10 +703,14 @@ export function parseCompanyFactsFinancialStatements(payload: unknown): SecCompa
   const quarterlyRows = new Map<string, FinancialStatement>();
   const annualSelectedFacts = new Map<string, CompanyFactsEntry>();
   const quarterlySelectedFacts = new Map<string, CompanyFactsEntry>();
+  const resolveEps = createSecEpsBasisResolver(payload);
+  // Diluted EPS only: share counts are kept only on the current basis.
+  const sameEps = splitEquivalent(resolveEps);
   const fieldEntries = COMPANY_FACTS_STATEMENT_FIELDS.map((field) => ({
     field,
-    entries: withoutDifferentMeasureFallback(field, field.tags.flatMap((tag, tagPriority) => companyFactsEntries(payload, tag, field.units)
-      .map((entry) => ({ ...entry, tagPriority, concept: tag })))),
+    entries: withoutDifferentMeasureFallback(field, field.tags.flatMap((tag, tagPriority) => withFramedQuarters(
+      companyFactsEntries(payload, tag, field.units), field.field === "eps" ? sameEps : undefined,
+    ).map((entry) => ({ ...entry, tagPriority, concept: tag })))),
   }));
   // Balance-sheet facts have no duration. Anchor their dates to actual annual
   // periods, so quarterly comparative snapshots in a 10-K stay quarterly.
@@ -659,13 +718,14 @@ export function parseCompanyFactsFinancialStatements(payload: unknown): SecCompa
     ? entries.filter(isAnnualDurationFact).map((entry) => entry.end!)
     : []));
 
+  const epsRepeats = splitRepeats(sameEps);
   for (const { field, entries } of fieldEntries) {
     if (entries.length === 0) continue;
-    fillCompanyFactsStatementRows(annualRows, annualSelectedFacts, entries, field, "annual", annualPeriodEnds);
-    fillCompanyFactsStatementRows(quarterlyRows, quarterlySelectedFacts, entries, field, "quarterly", annualPeriodEnds);
+    const repeats = field.field === "eps" ? epsRepeats : undefined;
+    fillCompanyFactsStatementRows(annualRows, annualSelectedFacts, entries, field, "annual", annualPeriodEnds, repeats);
+    fillCompanyFactsStatementRows(quarterlyRows, quarterlySelectedFacts, entries, field, "quarterly", annualPeriodEnds, repeats);
   }
 
-  const resolveEps = createSecEpsBasisResolver(payload);
   const fourthQuarters = FOURTH_QUARTER_LINES.flatMap(({ fields, source }) => secFourthQuarters(fields, typeof source === "string"
     ? fieldEntries.find(({ field }) => field.field === source)?.entries ?? []
     : source.flatMap((tag, tagPriority) => companyFactsEntries(payload, tag, ["USD"]).map((entry) => ({ ...entry, tagPriority, concept: tag })))));

package/src/state/pane-scroll-registry.tsx

@@ -5,9 +5,12 @@ import { useAppSelector, useOptionalPaneInstanceId } from "./app/context";
 
 type ScrollDirection = "up" | "down";
 
+/** A scroll position: rows (or cells), or device pixels where the host measures in them. */
+type ScrollTarget = { cells: number } | { pixels: number };
+
 interface PaneScrollAction {
   direction: ScrollDirection;
-  resolveTarget(scrollBox: ScrollBoxRenderable): number | null;
+  resolveTarget(scrollBox: ScrollBoxRenderable): ScrollTarget | null;
 }
 
 interface PaneScrollEntry {
@@ -57,17 +60,58 @@ function isVisibleScrollBox(scrollBox: ScrollBoxRenderable): boolean {
   return !hasHiddenAncestor(scrollBox) && !hasCollapsedBounds(scrollBox);
 }
 
-function clampScrollTop(scrollBox: ScrollBoxRenderable, target: number): number | null {
+function maxScrollTop(scrollBox: ScrollBoxRenderable): number {
   const viewportHeight = Math.max(0, scrollBox.viewport?.height ?? 0);
-  if (viewportHeight <= 0) return null;
-  const maxScrollTop = Math.max(0, scrollBox.scrollHeight - viewportHeight);
-  if (maxScrollTop <= 0) return null;
-  return Math.max(0, Math.min(maxScrollTop, target));
+  if (viewportHeight <= 0) return 0;
+  return Math.max(0, scrollBox.scrollHeight - viewportHeight);
+}
+
+/**
+ * The desktop host rounds its viewport and content to whole rows, which can
+ * leave up to half a row of content past the last scrollable row. Where it
+ * also reports pixels, the ends are measured in them.
+ */
+function pixelRange(scrollBox: ScrollBoxRenderable): { top: number; max: number } | null {
+  const { scrollTopPx, scrollHeightPx, viewportPx } = scrollBox;
+  if (!scrollBox.scrollToPixels || typeof scrollTopPx !== "number" || typeof scrollHeightPx !== "number" || !viewportPx) {
+    return null;
+  }
+  return { top: scrollTopPx, max: Math.max(0, scrollHeightPx - viewportPx.height) };
 }
 
-function scrollTargetByDelta(scrollBox: ScrollBoxRenderable, delta: number): number | null {
-  const target = clampScrollTop(scrollBox, scrollBox.scrollTop + delta);
-  return target == null || target === scrollBox.scrollTop ? null : target;
+function topTarget(scrollBox: ScrollBoxRenderable): ScrollTarget | null {
+  if ((scrollBox.viewport?.height ?? 0) <= 0) return null;
+  const pixels = pixelRange(scrollBox);
+  if (pixels) return pixels.top >= 1 ? { pixels: 0 } : null;
+  return scrollBox.scrollTop > 0 ? { cells: 0 } : null;
+}
+
+function bottomTarget(scrollBox: ScrollBoxRenderable): ScrollTarget | null {
+  const max = maxScrollTop(scrollBox);
+  // A body that overflows by less than a row is not worth capturing the keys for.
+  if (max <= 0) return null;
+  const pixels = pixelRange(scrollBox);
+  if (pixels) return pixels.max - pixels.top >= 1 ? { pixels: pixels.max } : null;
+  return max !== scrollBox.scrollTop ? { cells: max } : null;
+}
+
+function scrollTargetByDelta(scrollBox: ScrollBoxRenderable, delta: number): ScrollTarget | null {
+  if ((scrollBox.viewport?.height ?? 0) <= 0) return null;
+  const wanted = scrollBox.scrollTop + delta;
+  if (delta < 0 && wanted <= 0) return topTarget(scrollBox);
+  if (delta > 0 && wanted >= maxScrollTop(scrollBox)) return bottomTarget(scrollBox);
+  return delta === 0 ? null : { cells: wanted };
+}
+
+function applyScrollTarget(scrollBox: ScrollBoxRenderable, target: ScrollTarget): void {
+  if ("pixels" in target) {
+    scrollBox.scrollToPixels?.(target.pixels);
+    return;
+  }
+  scrollBox.scrollTo(target.cells);
+  if (scrollBox.scrollTop !== target.cells) {
+    scrollBox.scrollTop = target.cells;
+  }
 }
 
 /**
@@ -76,7 +120,7 @@ function scrollTargetByDelta(scrollBox: ScrollBoxRenderable, delta: number): num
  */
 export function scrollByLines(scrollBox: ScrollBoxRenderable, delta: number): void {
   const target = scrollTargetByDelta(scrollBox, delta);
-  if (target != null) scrollBox.scrollTop = target;
+  if (target) applyScrollTarget(scrollBox, target);
 }
 
 function arrowScrollLines(scrollBox: ScrollBoxRenderable): number {
@@ -117,20 +161,9 @@ function resolveKeyScrollAction(event: PaneScrollKeyEvent): PaneScrollAction | n
         ),
       };
     case "home":
-      return {
-        direction: "up",
-        resolveTarget: (scrollBox) => (
-          scrollBox.scrollTop > 0 ? 0 : null
-        ),
-      };
+      return { direction: "up", resolveTarget: topTarget };
     case "end":
-      return {
-        direction: "down",
-        resolveTarget: (scrollBox) => {
-          const target = clampScrollTop(scrollBox, Number.MAX_SAFE_INTEGER);
-          return target == null || target === scrollBox.scrollTop ? null : target;
-        },
-      };
+      return { direction: "down", resolveTarget: bottomTarget };
     default:
       return null;
   }
@@ -145,12 +178,12 @@ function getEntryScore(entry: PaneScrollEntry, scrollBox: ScrollBoxRenderable):
 function findScrollableEntry(paneId: string, action: PaneScrollAction): {
   entry: PaneScrollEntry;
   scrollBox: ScrollBoxRenderable;
-  target: number;
+  target: ScrollTarget;
 } | null {
   const entries = paneScrollBoxes.get(paneId);
   if (!entries) return null;
 
-  let best: { entry: PaneScrollEntry; scrollBox: ScrollBoxRenderable; target: number; score: number } | null = null;
+  let best: { entry: PaneScrollEntry; scrollBox: ScrollBoxRenderable; target: ScrollTarget; score: number } | null = null;
   for (const entry of entries.values()) {
     const scrollBox = entry.ref.current;
     if (!scrollBox) continue;
@@ -176,17 +209,16 @@ function scrollPaneByKey(paneId: string, event: PaneScrollKeyEvent): boolean {
   const match = findScrollableEntry(paneId, action);
   if (!match) return false;
 
-  const previousTop = match.scrollBox.scrollTop;
-  match.scrollBox.scrollTo(match.target);
-  if (match.scrollBox.scrollTop !== match.target) {
-    match.scrollBox.scrollTop = match.target;
-  }
+  const { scrollBox } = match;
+  const position = () => scrollBox.scrollTopPx ?? scrollBox.scrollTop;
+  const previousTop = scrollBox.scrollTop;
+  const previousPosition = position();
+  applyScrollTarget(scrollBox, match.target);
 
-  const delta = Math.abs(match.scrollBox.scrollTop - previousTop);
-  if (delta > 0) {
-    match.entry.onScrollActivity?.({ scroll: { direction: action.direction, delta } });
-  }
-  return delta > 0;
+  if (position() === previousPosition) return false;
+  const delta = Math.max(1, Math.abs(scrollBox.scrollTop - previousTop));
+  match.entry.onScrollActivity?.({ scroll: { direction: action.direction, delta } });
+  return true;
 }
 
 export function useForwardedScrollBoxRef<T>(

package/src/sync/core-contributors.ts

@@ -24,7 +24,8 @@ import {
 import {
   addLegacyBuiltinDisabledPluginAliases,
   addLegacyBuiltinPluginOwnerAliases,
-  normalizeBuiltinDisabledPluginIds,
+  decodeBuiltinDisabledPluginIds,
+  encodeBuiltinDisabledPluginIds,
   normalizeBuiltinPluginStateMap,
 } from "../plugins/ownership";
 import { isRecord } from "../utils/guards";
@@ -363,7 +364,7 @@ function collectCoreConfigPayload(config: AppConfig) {
     // This build merges profiles one by one before it pushes, so a profile
     // missing from its list was removed, not one it never pulled.
     brokerInstancesMergedById: true,
-    disabledPlugins: addLegacyBuiltinDisabledPluginAliases(config.disabledPlugins),
+    disabledPlugins: addLegacyBuiltinDisabledPluginAliases(encodeBuiltinDisabledPluginIds(config.disabledPlugins)),
     disabledSources: config.disabledSources,
     pluginConfig: addLegacyBuiltinPluginOwnerAliases(config.pluginConfig),
     theme: config.theme,
@@ -678,7 +679,7 @@ function mergeConfigPayload(
     && Array.isArray(payload.disabledPlugins)
     && payload.disabledPlugins.every((pluginId) => typeof pluginId === "string")
   ) {
-    next.disabledPlugins = normalizeBuiltinDisabledPluginIds(payload.disabledPlugins);
+    next.disabledPlugins = decodeBuiltinDisabledPluginIds(payload.disabledPlugins);
   }
   if (canApply("pluginConfig") && isPluginStateMap(payload.pluginConfig)) {
     next.pluginConfig = withLocalPluginSecrets(

package/src/test-support/cli-context.ts

@@ -8,7 +8,7 @@ export interface PrintedCliResult {
 }
 
 /**
- * A command context whose `initMarketData` and `initConfigData` resolve to `market` (config, store, dataProvider, ...),
+ * A command context whose `initMarketData`, `initConfigData` and `initServices` resolve to `market` (config, store, dataProvider, ...),
  * with an empty ticker store unless `market` brings one.
  * `fail` throws, every printResult call is kept in `printed`, and `closeCount` reports how many
  * times the command closed its persistence.
@@ -29,6 +29,7 @@ export function createTestCliContext(
     cliOptions: { ...DEFAULT_CLI_OPTIONS, ...cliOptions },
     initMarketData: init,
     initConfigData: init,
+    initServices: async () => ({ ...await init(), destroy: () => { closed += 1; } }),
     printResult: (result: CliResult<any>, options?: CliResultRenderOptions<any, any>) => { printed.push({ result, options }); },
     fail: (message: string): never => { throw new Error(message); },
   } as unknown as CliCommandContext;

package/src/test-support/data-provider.ts

@@ -1,3 +1,4 @@
+import { createProviderMiss } from "../sources/provider-errors";
 import type { DataProvider } from "../types/data-provider";
 import type { InstrumentSearchResult } from "../types/instrument";
 import type { Quote, TickerFinancials } from "../types/financials";
@@ -20,6 +21,22 @@ export function createTestDataProvider(overrides: Partial<DataProvider> = {}): D
   };
 }
 
+/**
+ * A source that answers every request the way Gloom Cloud answers a symbol no listing carries:
+ * an empty status with the reason code NOT_FOUND.
+ */
+export function createNotFoundProvider(overrides: Partial<DataProvider> = {}): DataProvider {
+  const miss = () => Promise.reject(createProviderMiss("NOT_FOUND", undefined, { notFound: true }));
+  return createTestDataProvider({
+    id: "not-found",
+    priority: 100,
+    getQuote: miss,
+    getTickerFinancials: miss,
+    getPriceHistory: miss,
+    ...overrides,
+  });
+}
+
 export function createTestQuote(overrides: Partial<Quote> = {}): Quote {
   return {
     symbol: "AAPL",
@@ -49,3 +66,20 @@ export const fallbackProvider: DataProvider = createTestDataProvider({
   getTickerFinancials: async () => createTestFinancials(),
   getQuote: async () => createTestQuote(),
 });
+
+/**
+ * A source that has nothing for any request, the way Gloom Cloud answers an empty status.
+ * `reason` is the sentence the service gave for it; without one the miss is bare.
+ */
+export function createEmptyAnswerProvider(reason?: string, overrides: Partial<DataProvider> = {}): DataProvider {
+  const miss = () => Promise.reject(createProviderMiss("NOT_FOUND", reason));
+  return createTestDataProvider({
+    id: "empty-answer",
+    priority: 100,
+    getQuote: miss,
+    getTickerFinancials: miss,
+    getExchangeRate: miss,
+    getExchangeRateSnapshot: miss,
+    ...overrides,
+  });
+}

package/src/test-support/margin-account.ts

@@ -0,0 +1,108 @@
+import type { Quote, TickerFinancials } from "../types/financials";
+import type { Portfolio, TickerRecord } from "../types/ticker";
+import type { BrokerAccount } from "../types/trading";
+import { createTestTicker } from "./ticker";
+
+/**
+ * An invented margin account: 1.0M of equity carrying 1.6M of positions, the
+ * difference borrowed in three currencies. It holds a US stock, a listing
+ * quoted in euros and an option, which no quote prices, so it stays at its
+ * broker mark. Every figure is made up.
+ */
+export const MARGIN_PORTFOLIO: Portfolio = {
+  id: "broker:margin-test:M1",
+  name: "Margin test",
+  currency: "USD",
+  brokerId: "test",
+  brokerInstanceId: "margin-test",
+  brokerAccountId: "M1",
+};
+
+/** Dollars per unit of each currency. */
+export const MARGIN_EXCHANGE_RATES = new Map([["USD", 1], ["EUR", 1.2], ["JPY", 0.008]]);
+
+const OPTION = "CCC   280121C00050000";
+
+function holding(symbol: string, details: {
+  exchange: string;
+  currency: string;
+  shares: number;
+  mark: number;
+  multiplier?: number;
+  assetCategory?: string;
+}): TickerRecord {
+  return createTestTicker(symbol, symbol, {
+    exchange: details.exchange,
+    currency: details.currency,
+    assetCategory: details.assetCategory,
+    portfolios: [MARGIN_PORTFOLIO.id],
+    positions: [{
+      portfolio: MARGIN_PORTFOLIO.id,
+      shares: details.shares,
+      avgCost: details.mark,
+      markPrice: details.mark,
+      marketValue: details.shares * details.mark * (details.multiplier ?? 1),
+      unrealizedPnl: 0,
+      multiplier: details.multiplier,
+      currency: details.currency,
+      side: "long",
+      broker: "test",
+      brokerInstanceId: "margin-test",
+      brokerAccountId: "M1",
+    }],
+  });
+}
+
+export const MARGIN_TICKERS: TickerRecord[] = [
+  holding("AAA", { exchange: "NASDAQ", currency: "USD", shares: 4_000, mark: 200 }),
+  holding("BBB", { exchange: "XETRA", currency: "EUR", shares: 5_000, mark: 100 }),
+  holding(OPTION, { exchange: "", currency: "USD", shares: 20, mark: 100, multiplier: 100, assetCategory: "OPT" }),
+];
+
+export function createMarginAccount(overrides: Partial<BrokerAccount> = {}): BrokerAccount {
+  return {
+    accountId: "M1",
+    name: "Margin test",
+    currency: "USD",
+    source: "cloud",
+    updatedAt: Date.now() - 60_000,
+    netLiquidation: 1_000_000,
+    grossPositionValue: 1_600_000,
+    totalCashValue: -600_000,
+    cashBalances: [
+      { currency: "EUR", quantity: -250_000, baseValue: -300_000, baseCurrency: "USD" },
+      { currency: "JPY", quantity: -25_000_000, baseValue: -200_000, baseCurrency: "USD" },
+      { currency: "USD", quantity: -100_000, baseValue: -100_000, baseCurrency: "USD" },
+    ],
+    ...overrides,
+  };
+}
+
+function liveQuote(symbol: string, price: number, previousClose: number, currency: string, exchange: string): TickerFinancials {
+  const quote: Quote = {
+    symbol,
+    price,
+    change: price - previousClose,
+    changePercent: (price / previousClose - 1) * 100,
+    previousClose,
+    currency,
+    lastUpdated: Date.now() - 1_000,
+    listingExchangeName: exchange,
+    marketState: "REGULAR",
+    dataSource: "live",
+  };
+  return { annualStatements: [], quarterlyStatements: [], priceHistory: [], quote };
+}
+
+/**
+ * Real-time quotes for the stock and the euro listing, the stock `move`
+ * dollars above its mark. With `option`, the option is quoted at its mark too,
+ * so every position has a live price.
+ */
+export function marginQuotes({ move = 0, option = false }: { move?: number; option?: boolean } = {}): Map<string, TickerFinancials> {
+  return new Map([
+    ["AAA", liveQuote("AAA", 200 + move, 200, "USD", "NASDAQ")],
+    ["BBB", liveQuote("BBB", 100, 100, "EUR", "XETRA")],
+    ...(option ? [[OPTION, liveQuote(OPTION, 100, 100, "USD", "CBOE")] as const] : []),
+  ]);
+}

package/src/test-support/shell-pane-keys.tsx

@@ -28,6 +28,7 @@ export function TestShellPaneKeys(options: Partial<ShellPaneKeyOptions> & { focu
     startWindowMode: () => {},
     toggleFocusedPaneFullscreen: none,
     toggleFocusedPaneFloating: none,
+    toggleFocusedPaneNewLayout: none,
     ...options,
   });
   return null;

package/src/theme/series-colors.ts

@@ -0,0 +1,46 @@
+/** Colours for series told apart by name (compared tickers, markets). */
+export const SERIES_COLORS = [
+  "#4dabf7",
+  "#63e6be",
+  "#f6c85f",
+  "#b197fc",
+  "#ff8787",
+  "#ffa94d",
+  "#74c0fc",
+  "#e599f7",
+  "#8ce99a",
+  "#ffd43b",
+] as const;
+
+/**
+ * Okabe-Ito on a dark page, ordered so the first slots, the ones most charts
+ * use, sit furthest apart under deuteranopia, protanopia and tritanopia.
+ */
+const COLORBLIND_DARK_SERIES = ["#56b4e9", "#e69f00", "#f0e442", "#d55e00", "#009e73", "#cc79a7", "#0072b2"] as const;
+
+/** The same family on a light page: yellow and sky blue fade into white, so ink and a dark ochre stand in. */
+const COLORBLIND_LIGHT_SERIES = ["#0072b2", "#d55e00", "#009e73", "#1f2328", "#7a5c00", "#cc79a7"] as const;
+
+const THEME_SERIES_COLORS: Readonly<Record<string, readonly string[]>> = {
+  colorblind: COLORBLIND_DARK_SERIES,
+  "colorblind-light": COLORBLIND_LIGHT_SERIES,
+  "high-contrast": COLORBLIND_DARK_SERIES,
+};
+
+/** The theme's own palette for named series, or null where it draws them in `SERIES_COLORS`. */
+export function themeSeriesColors(themeId: string): readonly string[] | null {
+  return THEME_SERIES_COLORS[themeId] ?? null;
+}
+
+const DEFAULT_SLOT = new Map<string, number>(SERIES_COLORS.map((color, index) => [color, index]));
+
+/**
+ * A series colour as the theme draws it. A slot of the default palette moves
+ * to the same slot of the theme's palette; any other colour, chosen on purpose
+ * by a pane or a person, stays as it is.
+ */
+export function themedSeriesColor(color: string, themeId: string): string {
+  const palette = THEME_SERIES_COLORS[themeId];
+  const slot = palette ? DEFAULT_SLOT.get(color.toLowerCase()) : undefined;
+  return slot === undefined ? color : palette![slot % palette!.length]!;
+}