gloomberb 0.16.3 → 0.16.4

package/src/sources/provider-router/primary.ts

@@ -4,7 +4,7 @@ import type { MarketDataRequestContext } from "../../types/data-provider";
 import type { Quote, TickerFinancials } from "../../types/financials";
 import { normalizeTickerFinancialsPriceHistory } from "../../utils/price-history";
 import { resolveTickerFinancialsQuoteState } from "../../market-data/quotes/resolution";
-import { shouldLogProviderError } from "../provider-errors";
+import { noteProviderAnswer, noteProviderMiss, shouldLogProviderError, type ProviderMissNote } from "../provider-errors";
 import { quoteMetadataFromQuote } from "../../market-data/quotes/metadata";
 import {
   dropUnusableProviderQuote,
@@ -14,12 +14,19 @@ import {
   needsFinancialProfile,
   profileForSameListing,
   isProviderQuoteUsableForCurrentSession,
+  lastKnownProviderQuote,
   providerFinancialsMatchTarget,
   mergeMissingStatementArrays,
   mergeFinancials,
 } from "./financials";
 import type { ProviderRouterCoreDeps, SourceResult } from "./route-types";
 
+/** What the providers of one quote request said when none had a current quote. */
+export interface ProviderQuoteMissNote extends ProviderMissNote {
+  /** The newest priced answer for the target that was not current for its session, flagged stale. */
+  lastKnownQuote?: Quote;
+}
+
 export class ProviderRouterPrimaryRoutes {
   constructor(private readonly options: ProviderRouterCoreDeps) {}
 
@@ -61,6 +68,7 @@ export class ProviderRouterPrimaryRoutes {
     ticker: string,
     exchange?: string,
     context?: MarketDataRequestContext,
+    misses?: ProviderMissNote,
   ): Promise<SourceResult<TickerFinancials> | null> {
     const entityKey = this.options.getEntityKey(ticker, context?.instrument);
     const variantKey = financialHistoryVariants(this.options.getTickerVariantCandidates(exchange), context)[0] ?? "";
@@ -70,11 +78,11 @@ export class ProviderRouterPrimaryRoutes {
     for (const provider of this.options.providersInPriorityOrder()) {
       try {
         const rawValue = await provider.getTickerFinancials(ticker, exchange, context);
-        if (rawValue && !context?.instrument && !providerFinancialsMatchTarget(rawValue, ticker, exchange)) continue;
+        if (rawValue && !context?.instrument && !providerFinancialsMatchTarget(rawValue, ticker, exchange)) { noteProviderAnswer(misses); continue; }
         const resolvedValue = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(rawValue));
-        if (resolvedValue && !context?.instrument && !providerFinancialsMatchTarget(resolvedValue, ticker, exchange)) continue;
+        if (resolvedValue && !context?.instrument && !providerFinancialsMatchTarget(resolvedValue, ticker, exchange)) { noteProviderAnswer(misses); continue; }
         let value = resolvedValue ? dropUnusableProviderQuote(resolvedValue, exchange, { recentAnswer: true }) : null;
-        if (!value) continue;
+        if (!value) { noteProviderAnswer(misses); continue; }
         const sourceKey = this.options.providerSourceKey(provider);
         if (context?.statementHistory === "extended" && !hasReusableExtendedHistory(value)) {
           const previous = selectCachedResource<TickerFinancials>(this.options.resources, "financials", entityKey, [variantKey], [sourceKey], true);
@@ -131,6 +139,7 @@ export class ProviderRouterPrimaryRoutes {
           if (!needsFinancialProfile(primaryResult.value) && (context?.statementHistory === "extended" ? primaryResult.value.statementHistory?.status === "available" : hasDetailedStatementRows(primaryResult.value) && hasDeepStatementHistory(primaryResult.value))) return primaryResult;
         }
       } catch (error) {
+        noteProviderMiss(misses, error);
         if (shouldLogProviderError(error)) {
           this.options.logProviderError(`${provider.id} failed: ${error}`);
         }
@@ -181,13 +190,21 @@ export class ProviderRouterPrimaryRoutes {
     ticker: string,
     exchange?: string,
     context?: MarketDataRequestContext,
+    misses?: ProviderQuoteMissNote,
   ): Promise<SourceResult<Quote> | null> {
     const entityKey = this.options.getEntityKey(ticker, context?.instrument);
     const variantKey = this.options.getTickerVariantCandidates(exchange)[0] ?? "";
     for (const provider of this.options.providersInPriorityOrder()) {
       try {
         const quote = await provider.getQuote(ticker, exchange, context);
-        if (!isProviderQuoteUsableForCurrentSession(quote, exchange, ticker, { recentAnswer: true })) continue;
+        if (!isProviderQuoteUsableForCurrentSession(quote, exchange, ticker, { recentAnswer: true })) {
+          noteProviderAnswer(misses);
+          const lastKnown = misses && lastKnownProviderQuote(quote, exchange, ticker);
+          if (lastKnown && (misses.lastKnownQuote?.lastUpdated ?? -Infinity) < lastKnown.lastUpdated) {
+            misses.lastKnownQuote = lastKnown;
+          }
+          continue;
+        }
         const sourceKey = this.options.providerSourceKey(provider);
         this.options.cacheResource(
           "quote",
@@ -199,6 +216,7 @@ export class ProviderRouterPrimaryRoutes {
         );
         return { sourceKey, value: quote };
       } catch (error) {
+        noteProviderMiss(misses, error);
         if (shouldLogProviderError(error)) {
           this.options.logProviderError(`${provider.id} failed: ${error}`);
         }

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/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/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]!;
+}

package/src/theme/themes.ts

@@ -633,6 +633,81 @@ const rawThemes: Record<string, Theme> = {
     commandBg: "#000033",
     commandBorder: "#ff6600",
   },
+
+  // Gains, losses, warnings and chart series stay apart for deuteranopia,
+  // protanopia and tritanopia: up is blue, down is vermillion (the Okabe-Ito
+  // set), never red against green. The chrome is grey so hue only ever means
+  // data. themes.test.ts simulates the three deficiencies on these palettes.
+  colorblind: {
+    name: "Colorblind",
+    description: "Blue gains and vermillion losses, safe for color-blind eyes",
+    bg: "#0e1013",
+    panel: "#15181c",
+    border: "#3b4149",
+    borderFocused: "#d7dade",
+    text: "#e4e6e9",
+    textDim: "#a3a9b2",
+    textBright: "#ffffff",
+    textMuted: "#858c96",
+    positive: "#56b4e9",
+    negative: "#e66a1f",
+    neutral: "#9aa0a8",
+    warning: "#f0e442",
+    header: "#1c2026",
+    headerText: "#ffffff",
+    selected: "#2b3540",
+    selectedText: "#ffffff",
+    commandBg: "#15181c",
+    commandBorder: "#a3a9b2",
+  },
+
+  "colorblind-light": {
+    name: "Colorblind Light",
+    description: "Light, blue gains and vermillion losses, safe for color-blind eyes",
+    bg: "#ffffff",
+    panel: "#f5f6f8",
+    border: "#c8cdd4",
+    borderFocused: "#1f2328",
+    text: "#1f2328",
+    textDim: "#4d545e",
+    textBright: "#000000",
+    textMuted: "#646b75",
+    positive: "#0072b2",
+    negative: "#a84100",
+    neutral: "#5f6670",
+    warning: "#a27409",
+    header: "#e9ecef",
+    headerText: "#1f2328",
+    selected: "#d3e3f0",
+    selectedText: "#000000",
+    commandBg: "#f5f6f8",
+    commandBorder: "#1f2328",
+  },
+
+  // Every text role clears 7:1 (WCAG AAA) on the page, and the up, down and
+  // warning colours are the colour-blind safe ones.
+  "high-contrast": {
+    name: "High Contrast",
+    description: "White on black at AAA contrast, color-blind safe",
+    bg: "#000000",
+    panel: "#000000",
+    border: "#9a9a9a",
+    borderFocused: "#ffffff",
+    text: "#ffffff",
+    textDim: "#e0e0e0",
+    textBright: "#ffffff",
+    textMuted: "#c8c8c8",
+    positive: "#56b4e9",
+    negative: "#ff8c42",
+    neutral: "#c8c8c8",
+    warning: "#f0e442",
+    header: "#1a1a1a",
+    headerText: "#ffffff",
+    selected: "#3d3d3d",
+    selectedText: "#ffffff",
+    commandBg: "#000000",
+    commandBorder: "#ffffff",
+  },
 };
 
 export const themes: Record<string, Theme> = Object.fromEntries(
@@ -661,3 +736,77 @@ export function isDarkTheme(themeId: string): boolean {
 export function getTheme(id: string): Theme {
   return themes[id] ?? themes[DEFAULT_THEME]!;
 }
+
+type ThemeTrait = "colorblind-safe" | "high-contrast";
+
+const THEME_TRAITS: Readonly<Record<string, readonly ThemeTrait[]>> = {
+  colorblind: ["colorblind-safe"],
+  "colorblind-light": ["colorblind-safe"],
+  "high-contrast": ["high-contrast", "colorblind-safe"],
+};
+
+export interface ThemeSummary {
+  id: string;
+  name: string;
+  appearance: "dark" | "light";
+  traits: readonly ThemeTrait[];
+}
+
+/** Every theme in registry order: what `config themes`, help and the docs list. */
+export function listThemes(): ThemeSummary[] {
+  return getThemeIds().map((id) => ({
+    id,
+    name: themes[id]!.name,
+    appearance: isDarkTheme(id) ? "dark" : "light",
+    traits: THEME_TRAITS[id] ?? [],
+  }));
+}
+
+export type ThemeLookup =
+  | { ok: true; id: string }
+  | { ok: false; suggestion: string | null };
+
+/** `White Phosphor`, `white_phosphor` and `WHITE` all read as `white-phosphor` / `white`. */
+function themeKey(value: string): string {
+  return value.trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+
+function editDistance(left: string, right: string): number {
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let row = 1; row <= left.length; row += 1) {
+    const current = [row];
+    for (let column = 1; column <= right.length; column += 1) {
+      const substitution = previous[column - 1]! + (left[row - 1] === right[column - 1] ? 0 : 1);
+      current.push(Math.min(previous[column]! + 1, current[column - 1]! + 1, substitution));
+    }
+    previous = current;
+  }
+  return previous[right.length]!;
+}
+
+/**
+ * The theme id a person meant. An id or a display name, in any case, is that
+ * theme; anything else is unknown, with the closest id when the input is a
+ * typo of one (or of a name), or names part of exactly one theme.
+ */
+export function resolveThemeId(input: string): ThemeLookup {
+  const key = themeKey(input);
+  const ids = getThemeIds();
+  const exact = ids.find((id) => id === key) ?? ids.find((id) => themeKey(themes[id]!.name) === key);
+  if (exact) return { ok: true, id: exact };
+  if (!key) return { ok: false, suggestion: null };
+
+  let best: { id: string; distance: number } | null = null;
+  for (const id of ids) {
+    for (const candidate of [id, themeKey(themes[id]!.name)]) {
+      const distance = editDistance(key, candidate);
+      if (!best || distance < best.distance) best = { id, distance };
+    }
+  }
+  const tolerance = Math.max(2, Math.floor(key.length / 3));
+  if (best && best.distance <= tolerance) return { ok: false, suggestion: best.id };
+  const partial = key.length >= 3
+    ? ids.filter((id) => id.includes(key) || themeKey(themes[id]!.name).includes(key))
+    : [];
+  return { ok: false, suggestion: partial.length === 1 ? partial[0]! : null };
+}

package/src/tickers/search/index.ts

@@ -9,6 +9,7 @@ import { assetClassMarketSymbol, parseAssetClassQuery } from "./asset-classes";
 import { searchContractKey, searchInstrumentKey } from "./identity";
 import { tickerInstrumentLabel } from "../instrument-label";
 import {
+  answersOnlyByKeyword,
   buildSymbolAliases,
   classifyInstrumentKind,
   findExactTickerSearchMatch,
@@ -178,6 +179,7 @@ function createProviderTickerSearchCandidates(
       instrumentClass: classifyInstrumentKind(result.brokerContract?.secType || result.type),
       instrumentType: result.brokerContract?.secType || result.type,
       searchAliases: buildSearchResultAliases(result),
+      ...(searchResultKeywords(result) ? { searchKeywords: searchResultKeywords(result) } : {}),
       result,
     }];
   });
@@ -251,7 +253,7 @@ export function buildTickerSearchCandidates({
   );
   const providerItems = createProviderTickerSearchCandidates(filteredProviderResults, tickers, candidateOptions);
   const ranked = rankTickerSearchItems([...localItems, ...providerItems], query);
-  return limitTickerSearchCandidates(assignTickerSearchCategories(ranked), totalLimit, localLimit);
+  return limitTickerSearchCandidates(assignTickerSearchCategories(ranked, query), totalLimit, localLimit);
 }
 
 interface ResolveTickerSearchOptions {
@@ -589,10 +591,22 @@ function getProviderHintScore(result: InstrumentSearchResult, preferredExchange?
   return getProviderHintRichness(result) + (matchesPreferredExchange ? 10_000 : 0);
 }
 
-function assignTickerSearchCategories<T extends TickerSearchCandidate>(items: T[]): T[] {
+/** Older servers send none; anything malformed is ignored. */
+function searchResultKeywords(result: InstrumentSearchResult): string[] | undefined {
+  const keywords = Array.isArray(result.searchKeywords)
+    ? result.searchKeywords.filter((keyword): keyword is string => typeof keyword === "string" && !!keyword.trim())
+    : [];
+  return keywords.length > 0 ? keywords : undefined;
+}
+
+function assignTickerSearchCategories<T extends TickerSearchCandidate>(items: T[], query: string): T[] {
   let assignedPrimaryListing = false;
 
   return items.map((item) => {
+    // A company the theme's funds hold is not another listing of the one searched for.
+    if (!item.saved && item.kind === "search" && item.instrumentClass === "equity" && answersOnlyByKeyword(item, query)) {
+      return { ...item, category: "Related" };
+    }
     if (item.saved || item.kind === "ticker") {
       if (item.instrumentClass !== "fund" && item.instrumentClass !== "derivative") {
         assignedPrimaryListing = true;
@@ -669,5 +683,11 @@ function buildSearchResultAliases(result: InstrumentSearchResult): string[] {
   if (result.brokerContract?.symbol) {
     for (const alias of buildSymbolAliases(result.brokerContract.symbol)) aliases.add(alias);
   }
+  // Older servers send none. Anything else malformed is ignored.
+  if (Array.isArray(result.searchAliases)) {
+    for (const alias of result.searchAliases) {
+      if (typeof alias === "string" && alias.trim()) aliases.add(alias.trim());
+    }
+  }
   return [...aliases];
 }