gloomberb 0.16.4 → 0.16.5

package/src/series/resolve.ts

@@ -0,0 +1,107 @@
+import { MAX_CHART_SERIES_POINTS } from "../capabilities/chart-series";
+import { subtractTimeRange } from "../time-series/date-window";
+import type {
+  ChartViewportSpec,
+  ResolvedSeries,
+  SeriesPeriod,
+  TimeSeriesPoint,
+} from "../time-series/types";
+import { SERIES_COLORS } from "../theme/series-colors";
+import type {
+  LoadedSeriesDefinition,
+  SeriesFrequency,
+  SeriesLoadOutput,
+  SeriesLoadRequest,
+  SeriesPoint,
+} from "./types";
+
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+
+/** A point's date, with a bare `YYYY-MM-DD` read as that UTC day. */
+function seriesPointDate(value: SeriesPoint["date"]): Date | null {
+  const date = typeof value === "string" && DATE_ONLY.test(value.trim())
+    ? new Date(`${value.trim()}T00:00:00Z`)
+    : value instanceof Date ? new Date(value.getTime()) : new Date(value);
+  return Number.isFinite(date.getTime()) ? date : null;
+}
+
+/** Oldest first, one point per instant (the last one given wins), at most the chart's point limit. */
+export function normalizeSeriesPoints(points: readonly SeriesPoint[]): TimeSeriesPoint[] {
+  const byTime = new Map<number, number | null>();
+  for (const point of points) {
+    const date = point ? seriesPointDate(point.date) : null;
+    if (!date) continue;
+    const value = typeof point.value === "number" && Number.isFinite(point.value) ? point.value : null;
+    byTime.set(date.getTime(), value);
+  }
+  const sorted = [...byTime].sort(([left], [right]) => left - right);
+  return sorted.slice(-MAX_CHART_SERIES_POINTS).map(([time, value]) => {
+    const date = new Date(time);
+    return { date, observedAt: date, value };
+  });
+}
+
+function nativeFrequency(frequency: SeriesFrequency): SeriesPeriod {
+  return frequency === "intraday" || frequency === "irregular" ? "auto" : frequency;
+}
+
+/** Series in one unit share an axis; percentages share it with FRED's. */
+function seriesUnitGroup(unit: string): string {
+  return unit === "%" ? "percent" : `series:${unit.toLowerCase()}`;
+}
+
+/** One colour per id, so two loaded series on a chart are told apart. */
+function seriesColor(id: string): string {
+  let hash = 0;
+  for (const char of id) hash = (hash * 31 + char.charCodeAt(0)) >>> 0;
+  return SERIES_COLORS[hash % SERIES_COLORS.length]!;
+}
+
+/** The dates a chart viewport covers, as a series load request takes them. */
+export function seriesLoadWindow(viewport: ChartViewportSpec, now = new Date()): Pick<SeriesLoadRequest, "start" | "end"> {
+  if (viewport.dateWindow) {
+    const start = new Date(viewport.dateWindow.start);
+    const end = new Date(viewport.dateWindow.end);
+    if (Number.isFinite(start.getTime()) && Number.isFinite(end.getTime())) return { start, end };
+  }
+  if (viewport.range === "ALL") return {};
+  return { start: subtractTimeRange(now, viewport.range) };
+}
+
+function loadResult(output: SeriesLoadOutput): { points: readonly SeriesPoint[]; warning?: string } {
+  if (Array.isArray(output)) return { points: output };
+  const result = output as Exclude<SeriesLoadOutput, readonly SeriesPoint[]>;
+  if (!result || !Array.isArray(result.points)) throw new Error("Series loader returned no points.");
+  return result;
+}
+
+export async function resolveLoadedSeries(
+  definition: LoadedSeriesDefinition,
+  request: { viewport: ChartViewportSpec; ticker?: string; signal?: AbortSignal },
+  now = new Date(),
+): Promise<ResolvedSeries> {
+  const ticker = request.ticker?.trim().toUpperCase() || undefined;
+  const { points, warning } = loadResult(await definition.load({
+    ...seriesLoadWindow(request.viewport, now),
+    ...(ticker ? { ticker } : {}),
+    ...(request.signal ? { signal: request.signal } : {}),
+  }));
+  const id = ticker ? `${definition.id}/${ticker}` : definition.id;
+  const style = definition.style ?? "line";
+  return {
+    id,
+    label: ticker ? `${ticker} · ${definition.name}` : definition.name,
+    color: seriesColor(id),
+    unit: definition.unit,
+    unitGroup: seriesUnitGroup(definition.unit),
+    nativeFrequency: nativeFrequency(definition.frequency),
+    dataShape: "scalar",
+    style,
+    transform: "raw",
+    axis: "left",
+    panelId: "main",
+    interpolation: style === "step" ? "step-after" : "none",
+    ...(warning ? { warning } : {}),
+    points: normalizeSeriesPoints(points),
+  };
+}

package/src/series/standalone.ts

@@ -0,0 +1,48 @@
+import { chartSeriesResolveRequestSchema } from "../capabilities/chart-series";
+import type { CapabilityInvoker } from "../capabilities/types";
+import type { GloomPlugin } from "../types/plugin";
+import { resolveRegisteredSeries } from "./capability";
+import { readSeriesFolder } from "./files";
+import { SeriesRegistry } from "./registry";
+
+/**
+ * Charts the catalog's loaded series where no plugin runtime runs, such as a
+ * `gloomberb fn G` report: the series plugins declare, and the files in the
+ * data directory's series folder. Series a plugin registers from its setup
+ * need the app.
+ */
+export function standaloneSeriesInvoker(
+  plugins: readonly GloomPlugin[],
+  dataDir: string,
+  disabledPlugins: readonly string[] = [],
+): CapabilityInvoker {
+  let registry: Promise<SeriesRegistry> | null = null;
+  const build = async () => {
+    const built = new SeriesRegistry({ pluginHosts: (pluginId) => plugins.find((plugin) => plugin.id === pluginId)?.hosts });
+    const register = (pluginId: string, definitions: readonly Parameters<SeriesRegistry["register"]>[1][]) => {
+      for (const definition of definitions) {
+        try {
+          built.register(pluginId, definition);
+        } catch {
+          // The app logs a definition it refuses; a report charts the rest.
+        }
+      }
+    };
+    for (const plugin of plugins) {
+      if (!disabledPlugins.includes(plugin.id)) register(plugin.id, plugin.series ?? []);
+    }
+    register("user", await readSeriesFolder(dataDir));
+    return built;
+  };
+  return {
+    capabilityManifests: () => [],
+    async invokeCapability<T>(capabilityId: string, operationId: string, payload: unknown, options?: { signal?: AbortSignal }) {
+      if (operationId !== "resolve") throw new Error(`Capability "${capabilityId}" is not available.`);
+      registry ??= build();
+      const request = chartSeriesResolveRequestSchema.parse(payload);
+      const resolved = await resolveRegisteredSeries(await registry, capabilityId, request.seriesId, request.viewport, options?.signal);
+      if (!resolved) throw new Error(`Chart series capability "${capabilityId}" is unavailable. Enable its plugin or provider.`);
+      return resolved as T;
+    },
+  };
+}

package/src/series/types.ts

@@ -0,0 +1,145 @@
+/**
+ * Series a plugin registers for the data catalog and the chart composer.
+ *
+ * One definition is one catalog entry: a named line with a unit and a
+ * frequency that the composer can draw next to any other entry. A definition
+ * either loads its own history (`load`) or points at something the composer
+ * already draws (`expression`), such as a FRED series or a ticker field.
+ */
+
+/** How often a series gets a new observation. */
+export type SeriesFrequency =
+  | "intraday"
+  | "daily"
+  | "weekly"
+  | "monthly"
+  | "quarterly"
+  | "annual"
+  | "irregular";
+
+/**
+ * What a series asks for before it can be charted: a ticker (AAPL), an option
+ * contract (AAPL 260618C00200000) or a crypto pair (BTC-USD). A series without
+ * an input charts as it is.
+ */
+export type SeriesInput = "ticker" | "option" | "crypto";
+
+/** How a loaded series is drawn when it is first added to a chart. */
+export type SeriesDrawStyle = "line" | "area" | "step" | "columns" | "points";
+
+export interface SeriesPoint {
+  /** The observation date: a Date, an ISO date or date-time string, or epoch milliseconds. */
+  date: Date | string | number;
+  /** Null marks a missing observation, which the chart draws as a gap. */
+  value: number | null;
+}
+
+export interface SeriesLoadRequest {
+  /** The first date the chart shows. Absent when the chart asks for all history. */
+  start?: Date;
+  /** The last date the chart shows. Absent means up to now. */
+  end?: Date;
+  /** The symbol typed for a series with an `input`, upper case (AAPL, BTC-USD). */
+  ticker?: string;
+  signal?: AbortSignal;
+}
+
+export interface SeriesLoadResult {
+  points: readonly SeriesPoint[];
+  /** A note the chart shows above the plot, such as "cached data is stale". */
+  warning?: string;
+}
+
+export type SeriesLoadOutput = readonly SeriesPoint[] | SeriesLoadResult;
+
+interface SeriesDefinitionBase {
+  /**
+   * `namespace:name`, unique across the app, e.g. `fear-greed:index`. The
+   * namespace belongs to the plugin that registers its first series; a loaded
+   * series charts as `CAP:<id>`. Letters, digits, `.`, `_` and `-`.
+   */
+  id: string;
+  /** What the catalog and the chart legend call the series. */
+  name: string;
+  /**
+   * The unit every value is in. Series in the same unit share a chart axis.
+   * See `describeSeriesUnits()` for the accepted forms: `%`, `bp`, `index`,
+   * `USD`, `billion USD`, `thousand barrels/day` and so on.
+   */
+  unit: string;
+  frequency: SeriesFrequency;
+  /** The catalog tab the series is listed under, such as "Credit" or "Sentiment". */
+  group?: string;
+  /** Extra words the catalog search matches, such as a ticker the series is often read against. */
+  tags?: readonly string[];
+  /** One sentence for the catalog search and for `gloomberb` automation. */
+  description?: string;
+  /**
+   * The official body that publishes the data (a statistics agency, a central
+   * bank, an exchange regulator), when the series is public data. Never the
+   * service a plugin fetches it from.
+   */
+  publisher?: string;
+  /** The publisher's page for the series. */
+  url?: string;
+  /** Ask for a ticker, an option or a crypto pair before charting. */
+  input?: SeriesInput;
+}
+
+/** A series that loads its own history. */
+export interface LoadedSeriesDefinition extends SeriesDefinitionBase {
+  /**
+   * The observations from `request.start` to `request.end`, oldest or newest
+   * first. Returning more history than asked for is fine; the chart clips it.
+   */
+  load(request: SeriesLoadRequest): SeriesLoadOutput | Promise<SeriesLoadOutput>;
+  /**
+   * For a series that changes during the day: how often, in milliseconds, a
+   * chart showing it loads it again. At least one minute.
+   */
+  refreshMs?: number;
+  /** How the series is drawn when first added; a line when omitted. */
+  style?: SeriesDrawStyle;
+  expression?: never;
+}
+
+/**
+ * A catalog entry for something the chart composer already draws:
+ * `FRED:UNRATE`, `UST:10Y`, `FUT:ES`, `^VIX:close`. With an `input`, write
+ * `{ticker}` where the symbol goes: `{ticker}:close`.
+ */
+export interface ExpressionSeriesDefinition extends SeriesDefinitionBase {
+  expression: string;
+  load?: never;
+  refreshMs?: never;
+  style?: never;
+}
+
+export type SeriesDefinition = LoadedSeriesDefinition | ExpressionSeriesDefinition;
+
+/** A definition as the registry holds it, with the plugin that registered it. */
+export interface RegisteredSeries {
+  definition: SeriesDefinition;
+  /** The plugin that registered the series. */
+  pluginId: string;
+}
+
+/**
+ * What the catalog lists for a series, without functions: the shape that
+ * crosses from the desktop's Bun process to its view.
+ */
+export interface SeriesCatalogEntry {
+  id: string;
+  name: string;
+  unit: string;
+  frequency: SeriesFrequency;
+  group?: string;
+  tags?: readonly string[];
+  description?: string;
+  publisher?: string;
+  url?: string;
+  input?: SeriesInput;
+  /** The chart expression; `{ticker}` stands for the input. */
+  expression: string;
+  pluginId: string;
+}

package/src/series/validate.ts

@@ -0,0 +1,171 @@
+import type {
+  SeriesDefinition,
+  SeriesDrawStyle,
+  SeriesFrequency,
+  SeriesInput,
+} from "./types";
+
+export const SERIES_FREQUENCIES: readonly SeriesFrequency[] = [
+  "intraday", "daily", "weekly", "monthly", "quarterly", "annual", "irregular",
+];
+const SERIES_INPUTS: readonly SeriesInput[] = ["ticker", "option", "crypto"];
+const DRAW_STYLES: readonly SeriesDrawStyle[] = ["line", "area", "step", "columns", "points"];
+
+/** Units with no scale: a percentage of something, not a quantity of it. */
+const RATE_UNITS = ["%", "bp", "x", "ratio", "index", "score", "points"] as const;
+/** Quantities, which may take a scale ("thousand barrels"). */
+const QUANTITY_UNITS = [
+  "number", "count", "units", "shares", "contracts", "days", "people", "jobs", "posts", "views", "hours",
+  "barrels", "barrels/day", "cubic feet", "MW", "MWh", "tons", "ounces",
+  // The instrument's own currency, for a field that applies to any ticker.
+  "currency", "currency/share",
+] as const;
+/** What a price is quoted per: `USD/barrel`, `USD/GPU-hour`. */
+const PER_UNITS = ["share", "barrel", "gallon", "MMBtu", "MWh", "ounce", "ton", "hour", "GPU-hour"] as const;
+const SCALES = ["thousand", "million", "billion", "trillion"] as const;
+
+const RATE_SET: ReadonlySet<string> = new Set(RATE_UNITS);
+const QUANTITY_SET: ReadonlySet<string> = new Set(QUANTITY_UNITS);
+const PER_SET: ReadonlySet<string> = new Set(PER_UNITS);
+const CURRENCY_CODE = /^[A-Z]{3}$/;
+
+const NAMESPACE_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/;
+const TICKER_PLACEHOLDER = "{ticker}";
+const MIN_REFRESH_MS = 60_000;
+
+/** The unit forms `unit` accepts, in one line for an error or a doc. */
+export function describeSeriesUnits(): string {
+  return `${RATE_UNITS.join(", ")}; ${QUANTITY_UNITS.join(", ")} or a currency code (USD), optionally after `
+    + `${SCALES.join(", ")}; or a currency per ${PER_UNITS.join(", ")} (USD/barrel).`;
+}
+
+function isQuantityBase(value: string): boolean {
+  if (QUANTITY_SET.has(value) || CURRENCY_CODE.test(value)) return true;
+  const slash = value.indexOf("/");
+  return slash > 0 && CURRENCY_CODE.test(value.slice(0, slash)) && PER_SET.has(value.slice(slash + 1));
+}
+
+export function isValidSeriesUnit(unit: string): boolean {
+  if (RATE_SET.has(unit)) return true;
+  const space = unit.indexOf(" ");
+  const scale = space > 0 ? unit.slice(0, space) : "";
+  if ((SCALES as readonly string[]).includes(scale)) return isQuantityBase(unit.slice(space + 1));
+  return isQuantityBase(unit);
+}
+
+/** Splits `namespace:name`; null when the id is not one. */
+export function splitSeriesId(id: string): { namespace: string; name: string } | null {
+  const separator = id.indexOf(":");
+  if (separator < 0) return null;
+  const namespace = id.slice(0, separator);
+  const name = id.slice(separator + 1);
+  return NAMESPACE_PATTERN.test(namespace) && NAME_PATTERN.test(name) ? { namespace, name } : null;
+}
+
+/**
+ * The words a public label must not contain: the services the registering
+ * plugin reaches, taken from its declared hosts (`api.example.com` forbids
+ * "example"). A catalog says what a series is, not who serves it.
+ */
+export function hostLabelWords(hosts: readonly string[] = []): string[] {
+  const words = new Set<string>();
+  for (const host of hosts) {
+    const labels = host.trim().toLowerCase().split(".").filter(Boolean);
+    const name = labels.length >= 2 ? labels[labels.length - 2] : labels[0];
+    if (name && name.length >= 3) words.add(name);
+  }
+  return [...words];
+}
+
+interface SeriesValidationContext {
+  /** Words no label may contain; see `hostLabelWords`. */
+  forbiddenWords?: readonly string[];
+}
+
+const DOMAIN = /\b[a-z0-9-]+\.(?:com|net|org|io|co|ai|dev|app|gov|edu|info|biz)\b/i;
+const SOURCE_ID = /\b(?:provider|source|feed):[a-z0-9_-]/i;
+
+function fail(id: unknown, message: string): never {
+  throw new Error(`Invalid series ${typeof id === "string" && id ? `"${id}"` : "definition"}: ${message}`);
+}
+
+function checkLabel(id: string, field: string, value: unknown, max: number, context: SeriesValidationContext, optional = true): void {
+  if (value === undefined && optional) return;
+  if (typeof value !== "string" || !value.trim() || value.length > max || /[\r\n\t]/.test(value)) {
+    fail(id, `${field} must be a single line of 1 to ${max} characters.`);
+  }
+  if (DOMAIN.test(value) || SOURCE_ID.test(value)) {
+    fail(id, `${field} "${value}" names a host or an internal source; say what the data is instead.`);
+  }
+  const lower = value.toLowerCase();
+  const named = context.forbiddenWords?.find((word) => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(lower));
+  if (named) fail(id, `${field} "${value}" names "${named}", a service the plugin fetches from.`);
+}
+
+/**
+ * Throws a message naming the series and the problem when a definition
+ * cannot be registered: a malformed id, an unknown unit or frequency, a label
+ * that names a host or a fetched-from service, or both or neither of `load`
+ * and `expression`. Ids are checked for uniqueness by the registry.
+ */
+export function validateSeriesDefinition(definition: SeriesDefinition, context: SeriesValidationContext = {}): void {
+  if (!definition || typeof definition !== "object") fail(undefined, "expected an object.");
+  const { id } = definition;
+  if (typeof id !== "string" || !splitSeriesId(id)) {
+    fail(id, "id must be namespace:name, with a lower-case namespace and letters, digits, \".\", \"_\" or \"-\".");
+  }
+  checkLabel(id, "name", definition.name, 120, context, false);
+  if (typeof definition.unit !== "string" || !isValidSeriesUnit(definition.unit)) {
+    fail(id, `unit "${String(definition.unit)}" is not one of: ${describeSeriesUnits()}`);
+  }
+  if (!SERIES_FREQUENCIES.includes(definition.frequency)) {
+    fail(id, `frequency must be one of ${SERIES_FREQUENCIES.join(", ")}.`);
+  }
+  checkLabel(id, "group", definition.group, 32, context);
+  checkLabel(id, "description", definition.description, 300, context);
+  checkLabel(id, "publisher", definition.publisher, 60, context);
+  if (definition.tags !== undefined) {
+    if (!Array.isArray(definition.tags) || definition.tags.length > 16) fail(id, "tags must be a list of at most 16 words.");
+    for (const tag of definition.tags) checkLabel(id, "tag", tag, 40, context, false);
+  }
+  if (definition.url !== undefined && (typeof definition.url !== "string" || !/^https?:\/\/\S+$/.test(definition.url))) {
+    fail(id, "url must be an http or https address.");
+  }
+  if (definition.input !== undefined && !SERIES_INPUTS.includes(definition.input)) {
+    fail(id, `input must be one of ${SERIES_INPUTS.join(", ")}.`);
+  }
+  const hasLoad = typeof definition.load === "function";
+  const hasExpression = definition.expression !== undefined;
+  if (hasLoad === hasExpression) fail(id, "give exactly one of load or expression.");
+  if (hasExpression) {
+    const expression = definition.expression;
+    if (typeof expression !== "string" || !expression.trim() || expression.length > 200 || /[;,\n]/.test(expression)) {
+      fail(id, "expression must be one chart series, such as FRED:UNRATE or {ticker}:close.");
+    }
+    if (expression.includes(TICKER_PLACEHOLDER) !== (definition.input !== undefined)) {
+      fail(id, definition.input
+        ? `an expression with an input must contain ${TICKER_PLACEHOLDER}.`
+        : `${TICKER_PLACEHOLDER} needs an input.`);
+    }
+    return;
+  }
+  const loaded = definition as Extract<SeriesDefinition, { load: unknown }>;
+  if (loaded.refreshMs !== undefined && (!Number.isFinite(loaded.refreshMs) || loaded.refreshMs < MIN_REFRESH_MS)) {
+    fail(id, `refreshMs must be at least ${MIN_REFRESH_MS}.`);
+  }
+  if (loaded.style !== undefined && !DRAW_STYLES.includes(loaded.style)) {
+    fail(id, `style must be one of ${DRAW_STYLES.join(", ")}.`);
+  }
+}
+
+/**
+ * Checks a definition and returns it, so a plugin's static list fails where it
+ * is written: `series: [defineSeries({ ... })]`.
+ */
+export function defineSeries<T extends SeriesDefinition>(definition: T): T {
+  validateSeriesDefinition(definition);
+  return definition;
+}
+
+export { TICKER_PLACEHOLDER };

package/src/sources/gloomberb-cloud/index.ts

@@ -201,15 +201,15 @@ function mapCloudPriceHistory(
   if (stale && !reachesLatestSettledSession(points, Date.now(), { symbol: ticker, exchange, intervalMs: priceHistoryIntervalMs(interval) })) {
     throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
   }
-  if (
-    /^\d+(min|h)$/i.test(interval)
-    && hasMalformedIntradayHistory(points)
-  ) {
+  const intraday = /^\d+(min|h)$/i.test(interval);
+  // Daily bars answering an intraday range: the listing has no intraday bars.
+  const dailyBars = intraday && response.servedResolution === "1day";
+  if (intraday && !dailyBars && hasMalformedIntradayHistory(points)) {
     throw createProviderMiss(`Cloud chart data failed OHLC validation for ${ticker}`);
   }
   const matchingInterval = [response.providerMeta?.servedResolution, response.providerMeta?.requestedResolution]
     .every((declared) => declared === undefined || canonicalHistoryInterval(declared) === canonicalHistoryInterval(interval));
-  const resolution = matchingInterval ? cloudHistoryResolution(interval) : null;
+  const resolution = dailyBars ? "1d" : matchingInterval ? cloudHistoryResolution(interval) : null;
   // Metadata this client cannot read (a newer version, a far-off clock) is
   // absent, not contradictory; only a readable mismatch rejects the history.
   const declared = parseHistorySession(response.historySession) !== null;
@@ -490,9 +490,9 @@ export class GloomberbCloudProvider implements AssetDataProvider {
       stale: data.stale === true || response.stale === true };
   }
 
-  async search(query: string, _context?: SearchRequestContext): Promise<InstrumentSearchResult[]> {
+  async search(query: string, context?: SearchRequestContext): Promise<InstrumentSearchResult[]> {
     return withCloudFallback(
-      () => apiClient.searchInstruments(query, 10),
+      () => apiClient.searchInstruments(query, context?.limit ?? 10),
       "Cloud search is unavailable",
     );
   }

package/src/sources/gloomberb-cloud/normalizers.ts

@@ -119,6 +119,7 @@ export function mapQuote(
       quote.postMarketChange,
       divisor,
     ),
+    extendedSessionPrint: typeof quote.extendedSessionPrint === "boolean" ? quote.extendedSessionPrint : undefined,
     listingExchangeName,
     listingExchangeFullName,
     exchangeName: listingExchangeName,

package/src/sources/history-result.ts

@@ -41,6 +41,7 @@ export function normalizeHistoryResult(
     ...(typeof result.sourceKey === "string" && /^(provider|broker):[^\r\n\0]+$/.test(result.sourceKey) ? { sourceKey: result.sourceKey } : {}),
     ...(isHistoryCoverageDate(result.coverageStart) ? { coverageStart: result.coverageStart } : {}),
     ...(result.extendedHours === true ? { extendedHours: true } : {}),
+    ...(result.savedCopyBehind === true ? { savedCopyBehind: true as const } : {}),
   };
 }
 

package/src/sources/listing-symbols.ts

@@ -21,9 +21,12 @@ const EXCHANGE_SUFFIX_MAP: Record<string, string> = {
   SFB: ".ST", Stockholm: ".ST", OMX: ".ST", CPH: ".CO", HEX: ".HE", HEL: ".HE", OSE: ".OL", OSL: ".OL", OMXNO: ".OL", ICEX: ".IC",
   VSE: ".VI", WSE: ".WA", GPW: ".WA", PRA: ".PR", BUX: ".BD", ATHEX: ".AT", BVB: ".RO", BIST: ".IS",
   TASE: ".TA",
+  MSX: ".OM",
   JSE: ".JO",
+  BHB: ".BH",
   BVMF: ".SA", MEXI: ".MX", BYMA: ".BA", BCS: ".SN",
-  TADAWUL: ".SR", QE: ".QA", DFM: ".AE",
+  TADAWUL: ".SR", QE: ".QA", DFM: ".AE", KUWAIT: ".KW",
+  EGX: ".CA",
 };
 
 const EXCHANGE_FALLBACKS: Record<string, string[]> = {

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

@@ -137,7 +137,10 @@ export class ProviderRouterBatchRoutes {
         this.deps.resources, this.deps.getEntityKey(target.symbol, context.instrument),
         financialHistoryVariants(this.deps.getTickerVariantCandidates(target.exchange), context)[0] ?? "", this.deps.getProviderSourceKeys(),
       );
-      if (cached.value?.quote && !forceRefresh && target.statementHistory !== "extended" && (!needsFinancialProfile(cached.value) || profileAttempted)) {
+      // The selection wraps a cached quote even when no financials were ever
+      // fetched; a quote alone has no fundamentals, so it is not a hit.
+      const fetched = cached.brokerRecord != null || (cached.providerRecords?.length ?? 0) > 0;
+      if (fetched && cached.value?.quote && !forceRefresh && target.statementHistory !== "extended" && (!needsFinancialProfile(cached.value) || profileAttempted)) {
         results[index] = { target, financials: cached.value };
         return;
       }

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

@@ -15,12 +15,13 @@ export const FINANCIALS_SCHEMA_VERSION = 13;
 export const QUOTE_SCHEMA_VERSION = 3;
 export const MARKET_METADATA_SCHEMA_VERSION = 2;
 // Refresh persisted provider metadata through the managed backend on upgrade.
+// corporateActions-v3: earnings rows resolved against the earnings history.
 const SCHEMA_VERSIONS: Record<string, number> = {
   financials: FINANCIALS_SCHEMA_VERSION,
   quote: QUOTE_SCHEMA_VERSION,
   holders: MARKET_METADATA_SCHEMA_VERSION,
   "analystResearch-v2": MARKET_METADATA_SCHEMA_VERSION,
-  "corporateActions-v2": MARKET_METADATA_SCHEMA_VERSION,
+  "corporateActions-v3": MARKET_METADATA_SCHEMA_VERSION,
   "options-chain": MARKET_METADATA_SCHEMA_VERSION,
   "exchange-rate": MARKET_METADATA_SCHEMA_VERSION,
 };
@@ -34,7 +35,8 @@ const DEFAULT_CACHE_POLICIES = {
   news: { staleMs: 15 * 60_000, expireMs: 2 * 24 * 60 * 60_000 },
   holders: { staleMs: 24 * 60 * 60_000, expireMs: 7 * 24 * 60 * 60_000 },
   analystResearch: { staleMs: 24 * 60 * 60_000, expireMs: 7 * 24 * 60 * 60_000 },
-  corporateActions: { staleMs: 24 * 60 * 60_000, expireMs: 14 * 24 * 60 * 60_000 },
+  // Earnings rows carry report-day actuals and date changes; portfolios load these for every holding.
+  corporateActions: { staleMs: 6 * 60 * 60_000, expireMs: 14 * 24 * 60 * 60_000 },
   secFilings: { staleMs: 15 * 60_000, expireMs: 2 * 24 * 60 * 60_000 },
   secFilingDocuments: { staleMs: 30 * 24 * 60 * 60_000, expireMs: 365 * 24 * 60 * 60_000 },
   secFilingContent: { staleMs: 30 * 24 * 60 * 60_000, expireMs: 365 * 24 * 60 * 60_000 },

package/src/sources/provider-router/cached-routes.ts

@@ -211,7 +211,7 @@ export class ProviderRouterCachedRoutes {
         error: `No analyst research provider available for ${ticker}`,
       };
       case "getCorporateActions": return {
-        ...tickerRoute("corporateActions-v2", "corporateActions"), request: (provider, force) => provider.getCorporateActions?.(ticker, exchange, force ? { ...extra, cacheMode: "refresh" } : extra),
+        ...tickerRoute("corporateActions-v3", "corporateActions"), request: (provider, force) => provider.getCorporateActions?.(ticker, exchange, force ? { ...extra, cacheMode: "refresh" } : extra),
         rank: (data: CorporateActionsData) => !hasCorporateActionsValue(data) ? 0 : data.stale || Object.values(data.coverage ?? {}).includes("unavailable") ? 1 : 2,
         acceptCached: (data: CorporateActionsData) => !data.stale && !Object.values(data.coverage ?? {}).includes("unavailable"), throwLastError: true,
         error: `No corporate actions provider available for ${ticker}`,

package/src/sources/provider-router/financial-routes.ts

@@ -57,6 +57,7 @@ function withoutSessionState(quote: Quote): Quote {
   delete fallback.postMarketPrice;
   delete fallback.postMarketChange;
   delete fallback.postMarketChangePercent;
+  delete fallback.extendedSessionPrint;
   return fallback;
 }
 

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

@@ -471,6 +471,19 @@ function mergeFundamentals(primary: Fundamentals | undefined, fallback: Fundamen
     // A fallback cannot retrospectively denominate an older cached snapshot.
     delete merged.financialCurrency;
   }
+  if (merged) {
+    // A conversion, or an EPS currency apart from the amounts', describes the currency it came with, never one
+    // merged from elsewhere.
+    const denominated = primary?.financialCurrency ? primary : merged.financialCurrency ? fallback : undefined;
+    if (denominated?.ttmConversion) merged.ttmConversion = denominated.ttmConversion;
+    else delete merged.ttmConversion;
+    if (denominated?.epsCurrency) merged.epsCurrency = denominated.epsCurrency;
+    else delete merged.epsCurrency;
+    // The rate a trailing P/E converted its EPS at pairs with that multiple.
+    const trailing = primary?.trailingPE != null ? primary : fallback;
+    if (trailing?.trailingPEConversion) merged.trailingPEConversion = trailing.trailingPEConversion;
+    else delete merged.trailingPEConversion;
+  }
   return redactUnavailableFundamentals(merged);
 }