gloomberb 0.13.2 → 0.14.0

package/src/utils/http-proxy-response.ts

@@ -0,0 +1,44 @@
+/**
+ * Rebuilds a `Response` from a proxied envelope.
+ *
+ * Both proxying transports (desktop's Bun backend, the web app's worker route)
+ * return `set-cookie` alongside the other headers rather than inside them,
+ * because a `Headers` object built in a renderer cannot hold multiple cookies
+ * and the browser strips the header anyway. Callers that read cookies, like a
+ * plugin completing a login, need `get("set-cookie")` and `getSetCookie()` to
+ * work, so those are restored here.
+ */
+export interface HttpProxyResponseEnvelope {
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  setCookie?: string[];
+  body: string;
+}
+
+export function createProxyResponseHeaders(
+  headers: Record<string, string>,
+  setCookie: string[] = [],
+): Headers {
+  const responseHeaders = new Headers(headers);
+  if (setCookie.length === 0) return responseHeaders;
+
+  const originalGet = responseHeaders.get.bind(responseHeaders);
+  responseHeaders.get = ((name: string) => (
+    name.toLowerCase() === "set-cookie" ? setCookie[0] ?? null : originalGet(name)
+  )) as Headers["get"];
+  (responseHeaders as Headers & { getSetCookie?: () => string[] }).getSetCookie = () => [...setCookie];
+  return responseHeaders;
+}
+
+export function createProxyResponse(envelope: HttpProxyResponseEnvelope): Response {
+  const headers = createProxyResponseHeaders(envelope.headers, envelope.setCookie ?? []);
+  const response = new Response(envelope.body, {
+    status: envelope.status,
+    statusText: envelope.statusText,
+    headers,
+  });
+  // `new Response` copies the headers, which drops the accessors above.
+  Object.defineProperty(response, "headers", { value: headers, configurable: true });
+  return response;
+}

package/src/utils/http-transport.ts

@@ -1,9 +1,29 @@
 export type HttpFetchTransport = (url: string, init?: RequestInit) => Promise<Response>;
 
+export interface HttpFetchTransportOptions {
+  /**
+   * Whether the transport resolves as soon as headers arrive and exposes a
+   * live `response.body`. A transport that proxies over RPC and returns the
+   * whole payload as a string must leave this false so long-lived reads such
+   * as server-sent events degrade instead of hanging.
+   */
+  streaming?: boolean;
+}
+
 let httpFetchTransport: HttpFetchTransport | null = null;
+let httpFetchStreaming = true;
 
-export function setHttpFetchTransport(transport: HttpFetchTransport | null): void {
+export function setHttpFetchTransport(
+  transport: HttpFetchTransport | null,
+  options: HttpFetchTransportOptions = {},
+): void {
   httpFetchTransport = transport;
+  httpFetchStreaming = transport ? options.streaming ?? false : true;
+}
+
+/** False when the installed transport buffers whole responses. */
+export function isHttpFetchStreaming(): boolean {
+  return httpFetchStreaming;
 }
 
 export function httpFetch(url: string, init?: RequestInit): Promise<Response> {

package/src/utils/income-statement.ts

@@ -0,0 +1,46 @@
+import type { FinancialStatement, IncomeStatementField } from "../types/financials";
+
+export const INCOME_STATEMENT_FIELDS: readonly IncomeStatementField[] = [
+  "netIncome", "netIncomeIncludingNoncontrollingInterests", "netIncomeCommonStockholders",
+];
+
+export function isIncomeStatementField(field: string): field is IncomeStatementField {
+  return (INCOME_STATEMENT_FIELDS as readonly string[]).includes(field);
+}
+
+/** An explicit SEC observation or coverage gap outranks unidentified cached income. */
+export function incomeFieldOwner(
+  field: IncomeStatementField,
+  primary: FinancialStatement,
+  fallback?: FinancialStatement,
+): FinancialStatement | undefined {
+  return [primary, fallback?.date === primary.date ? fallback : undefined]
+    .filter((row): row is FinancialStatement => !!row && (row.fieldSources?.[field]?.source === "sec" || row.unavailableFields?.includes(field) === true))
+    .sort((left, right) => incomeFieldKnowledgeDate(right, field).localeCompare(incomeFieldKnowledgeDate(left, field)))[0];
+}
+
+/** Income revisions cannot be ordered by an unrelated asset's publication date. */
+export function incomeFieldKnowledgeDate(row: FinancialStatement, field: IncomeStatementField): string {
+  return row.fieldSources?.[field]?.filed ?? row.fieldAvailability?.[field]
+    ?? (row.unavailableFields?.includes(field)
+      ? Object.values(row.fieldSources ?? {}).map(source => source?.filed ?? "").sort().at(-1) ?? ""
+      : "");
+}
+
+/** Copy the value and its attribution together; never revive an explicit gap. */
+export function copyIncomeField(target: FinancialStatement, owner: FinancialStatement, field: IncomeStatementField): void {
+  target.fieldSources = { ...target.fieldSources };
+  delete target.fieldSources[field];
+  target.unavailableFields = (target.unavailableFields ?? []).filter(key => key !== field);
+  if (owner.unavailableFields?.includes(field)) {
+    delete target[field];
+    target.unavailableFields.push(field);
+  } else {
+    const value = owner[field];
+    if (typeof value === "number" && Number.isFinite(value)) target[field] = value;
+    else delete target[field];
+    if (owner.fieldSources?.[field]) target.fieldSources[field] = owner.fieldSources[field];
+  }
+  if (!target.unavailableFields.length) delete target.unavailableFields;
+  if (!Object.keys(target.fieldSources).length) delete target.fieldSources;
+}

package/src/utils/instrument-identity.test.ts

@@ -0,0 +1,26 @@
+import { expect, test } from "bun:test";
+import type { BrokerContractRef } from "../types/instrument";
+import { brokerContractIdentityKey, instrumentIdentityKey, scopedBrokerContractIdentityKey } from "./instrument-identity";
+
+const contract: BrokerContractRef = { brokerId: "fixture", brokerInstanceId: "one", symbol: "ACME", localSymbol: "ACME LEGACY", secType: "OPT", exchange: "SMART", primaryExchange: "NASDAQ", currency: "USD", lastTradeDateOrContractMonth: "20261016", right: "C", strike: 100, multiplier: "100", tradingClass: "ACME" };
+
+test("fallback identities distinguish every supplied financial definition even with a local symbol", () => {
+  const base = brokerContractIdentityKey(contract);
+  for (const change of [{ symbol: "OTHER" }, { localSymbol: "OTHER" }, { secType: "FOP" }, { exchange: "CBOE" }, { primaryExchange: "NYSE" }, { currency: "EUR" }, { lastTradeDateOrContractMonth: "20261120" }, { right: "P" }, { strike: 110 }, { multiplier: "10" }, { tradingClass: "ADJUSTED" }] as Partial<BrokerContractRef>[]) {
+    expect(brokerContractIdentityKey({ ...contract, ...change })).not.toBe(base);
+  }
+  expect(brokerContractIdentityKey({ ...contract, strike: 0 })).not.toBe(brokerContractIdentityKey({ ...contract, strike: undefined }));
+  expect(brokerContractIdentityKey({ ...contract, strike: NaN })).not.toBe(brokerContractIdentityKey({ ...contract, strike: undefined }));
+  expect(base).toStartWith("definition-v1:");
+  expect(brokerContractIdentityKey({ ...contract, symbol: " acme ", currency: "usd" })).toBe(base);
+});
+
+test("canonical IDs remain primary while source scope and public instruments remain distinct", () => {
+  expect(brokerContractIdentityKey({ ...contract, conId: 0 })).toBe("0");
+  expect(brokerContractIdentityKey({ ...contract, conId: 12, strike: 110 })).toBe(brokerContractIdentityKey({ ...contract, conId: 12 }));
+  expect(scopedBrokerContractIdentityKey({ ...contract, brokerInstanceId: "two" })).not.toBe(scopedBrokerContractIdentityKey(contract));
+  expect(brokerContractIdentityKey({ ...contract, brokerInstanceId: "two" })).toBe(brokerContractIdentityKey(contract));
+  const target = { symbol: "ACME", exchange: "NASDAQ", brokerId: "fixture", brokerInstanceId: "one", instrument: contract };
+  expect(instrumentIdentityKey({ ...target, symbol: "OTHER" })).not.toBe(instrumentIdentityKey(target));
+  expect(instrumentIdentityKey({ symbol: " acme ", exchange: "nasdaq" })).toBe("ACME|NASDAQ|||");
+});

package/src/utils/instrument-identity.ts

@@ -0,0 +1,35 @@
+import type { BrokerContractRef } from "../types/instrument";
+
+const normalized = (value: string | undefined): string => value?.trim().toUpperCase() ?? "";
+
+/** Source-declared contract identity, independent of UI symbols and routing priority. */
+export function brokerContractIdentityKey(contract: BrokerContractRef): string {
+  if (contract.conId != null) return String(contract.conId);
+  // A local symbol alone need not identify the supplied expiry, strike or deliverable.
+  // Version this fallback so old symbol-only cache entries cannot supply its prices.
+  return `definition-v1:${JSON.stringify([
+    normalized(contract.localSymbol), normalized(contract.symbol), normalized(contract.secType),
+    normalized(contract.exchange), normalized(contract.primaryExchange), normalized(contract.currency),
+    normalized(contract.lastTradeDateOrContractMonth), normalized(contract.right),
+    contract.strike == null ? null : Number.isFinite(contract.strike) ? contract.strike : String(contract.strike),
+    normalized(contract.multiplier), normalized(contract.tradingClass),
+  ])}`;
+}
+
+export function scopedBrokerContractIdentityKey(contract: BrokerContractRef): string {
+  return JSON.stringify([contract.brokerId, contract.brokerInstanceId ?? "", brokerContractIdentityKey(contract)]);
+}
+
+export function instrumentIdentityKey(instrument: {
+  symbol: string;
+  exchange?: string;
+  brokerId?: string;
+  brokerInstanceId?: string;
+  instrument?: BrokerContractRef | null;
+}): string {
+  return [
+    normalized(instrument.symbol), normalized(instrument.exchange),
+    instrument.brokerId ?? "", instrument.brokerInstanceId ?? "",
+    instrument.instrument ? brokerContractIdentityKey(instrument.instrument) : "",
+  ].join("|");
+}

package/src/utils/latest-financial-period.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { latestFinancialPeriod } from "./latest-financial-period";
+
+test("period selection rejects malformed and impossible dates without normalizing them into a new period", () => {
+  const valid = { date: "2024-02-29", value: 0 };
+  const invalid = ["", "TTM", "2026-2-28", "2026-02-29", "2026-04-31", "2026-13-01", "2026-06-30T00:00:00Z"];
+  const rows = [valid, ...invalid.map(date => ({ date, value: 100 }))];
+  expect(latestFinancialPeriod(rows, row => row.date)).toBe(valid);
+  expect(latestFinancialPeriod(rows.slice(1), row => row.date)).toBeUndefined();
+  expect(latestFinancialPeriod([], row => String(row))).toBeUndefined();
+});
+
+test("equal periods preserve last source precedence and never prefer a larger or more complete value", () => {
+  const first = { date: "2025-12-31", value: 100, availableAt: "2026-03-01" };
+  const last = { date: "2025-12-31", value: 0, availableAt: "2026-02-01" };
+  expect(latestFinancialPeriod([first, last, { date: "2024-12-31", value: 200 }], row => row.date)).toBe(last);
+  const partial = { date: "2026-06-30" };
+  expect(latestFinancialPeriod([partial, first, last], row => row.date)).toBe(partial);
+});

package/src/utils/latest-financial-period.ts

@@ -0,0 +1,26 @@
+/** A source-reported calendar period end, without rolling impossible dates forward. */
+export function isFinancialPeriodDate(period: unknown): period is string {
+  if (typeof period !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(period)) return false;
+  const date = new Date(`${period}T00:00:00Z`);
+  return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === period;
+}
+
+/** Select a reported calendar period, without inferring dates or merging revisions. */
+export function latestFinancialPeriod<T>(
+  rows: readonly T[] | undefined,
+  periodOf: (row: T) => string,
+): T | undefined {
+  let latest: T | undefined;
+  let latestPeriod = "";
+  for (const row of rows ?? []) {
+    const period = periodOf(row);
+    if (!isFinancialPeriodDate(period)) continue;
+    // Equal periods retain the source's last row, as the previous positional
+    // lookup did. A filing/publication date is not a reporting-period end.
+    if (period >= latestPeriod) {
+      latest = row;
+      latestPeriod = period;
+    }
+  }
+  return latest;
+}

package/src/utils/market-capitalization-consumers.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "bun:test";
+import type { TickerRecord } from "../types/ticker";
+import type { TickerFinancials } from "../types/financials";
+import { getColumnValue, getSortValue } from "../plugins/builtin/portfolio-list/column-values";
+import { buildTrackedCurrencies } from "../plugins/builtin/portfolio-list/pane/data";
+import { buildOverviewStats } from "../plugins/builtin/ticker-detail/overview/model";
+
+const ticker: TickerRecord = { metadata: { ticker: "F:XNYS", name: "Ford", exchange: "NYSE", currency: "USD",
+  portfolios: [], watchlists: [], positions: [], custom: {}, tags: [] } };
+const column = { id: "market_cap", label: "MCAP", width: 12, align: "right" as const };
+const fundamentals = { marketCap: 100, marketCapCurrency: "EUR", financialCurrency: "USD", freeCashFlow: -20,
+  source: "yahoo" as const, fetchedAt: "2026-09-11T15:23:57Z" };
+const makeFinancials = (extra: Partial<TickerFinancials> = {}): TickerFinancials => ({
+  annualStatements: [], quarterlyStatements: [], priceHistory: [], fundamentals, ...extra,
+});
+const context = { baseCurrency: "GBP", exchangeRates: new Map([["EUR", 1.2], ["GBP", 2]]), now: 1 };
+const overview = (data: TickerFinancials, rates = context.exchangeRates) => buildOverviewStats({
+  quote: data.quote, fundamentals: data.fundamentals, quoteCurrency: "USD", baseCurrency: "GBP",
+  toBase: () => { throw new Error("Market cap must not use a quote-currency conversion"); }, marketCapExchangeRates: rates,
+});
+
+test("overview and portfolio use the cap's explicit currency when a quote has no capitalization", () => {
+  const data = makeFinancials({ quote: { symbol: "F:XNYS", currency: "USD", price: 14, change: 0, changePercent: 0, lastUpdated: 1 } });
+  expect(getColumnValue(column, ticker, data, context).text).toBe("60");
+  expect(getSortValue(column, ticker, data, context)).toBe(60);
+  expect(overview(data).find(({ label }) => label === "Market Cap")?.value).toBe("60 GBP");
+  expect(data.quote?.marketCap).toBeUndefined();
+  expect(data.fundamentals).toEqual(fundamentals);
+});
+
+test("fundamental caps remain available without reviving any price quote", () => {
+  const data = makeFinancials();
+  expect(getColumnValue(column, ticker, data, context).text).toBe("60");
+  expect(getSortValue(column, ticker, data, context)).toBe(60);
+  expect(overview(data).find(({ label }) => label === "Market Cap")?.value).toBe("60 GBP");
+  expect(data.quote).toBeUndefined();
+});
+
+test("missing FX never creates a comparable 1:1 market cap; overview retains explicit original units", () => {
+  const data = makeFinancials(); const exchangeRates = new Map<string, number>();
+  expect(getColumnValue(column, ticker, data, { ...context, exchangeRates }).text).toBe("—");
+  expect(getSortValue(column, ticker, data, { ...context, exchangeRates })).toBeNull();
+  expect(overview(data, exchangeRates).find(({ label }) => label === "Market Cap")?.value).toBe("100 EUR");
+  expect(buildTrackedCurrencies([ticker], new Map([[ticker.metadata.ticker, data]]), null, "GBP")).toContain("EUR");
+});
+
+test("a valid quote cap keeps precedence and its own currency", () => {
+  const data = makeFinancials({ quote: { symbol: "F:XNYS", currency: "USD", marketCap: 200, price: 14, change: 0, changePercent: 0, lastUpdated: 1 } });
+  expect(getColumnValue(column, ticker, data, context).text).toBe("100");
+  expect(getSortValue(column, ticker, data, context)).toBe(100);
+  expect(overview(data).find(({ label }) => label === "Market Cap")?.value).toBe("100 GBP");
+});
+
+test("ticker and statement currencies cannot fill a missing capitalization currency", () => {
+  const data = makeFinancials({ fundamentals: { ...fundamentals, marketCapCurrency: undefined } });
+  expect(getColumnValue(column, ticker, data, context).text).toBe("—");
+  expect(getSortValue(column, ticker, data, context)).toBeNull();
+  expect(overview(data).some(({ label }) => label === "Market Cap")).toBe(false);
+});

package/src/utils/market-capitalization.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test";
+import { selectMarketCapitalization, describeFundamentalMarketCap } from "./market-capitalization";
+import type { Quote } from "../types/financials";
+
+const quote: Quote = { symbol: "F:XNYS", price: 14.01, currency: "USD", change: 0, changePercent: 0,
+  lastUpdated: Date.parse("2026-09-11T15:30:00Z"), providerId: "yahoo" };
+const fundamentals = { marketCap: 55_866_216_448, marketCapCurrency: "USD", source: "yahoo" as const,
+  fetchedAt: "2026-09-11T15:23:57.311Z", financialCurrency: "USD", freeCashFlow: -7_940_250_112, stale: false };
+
+test("a lightweight quote preserves the separately sourced capitalization and retrieval time", () => {
+  const selected = selectMarketCapitalization(quote, fundamentals)!;
+  expect(selected).toEqual({ value: fundamentals.marketCap, currency: "USD",
+    provenance: { kind: "fundamentals", source: "yahoo", retrievedAt: fundamentals.fetchedAt, stale: false } });
+  expect(describeFundamentalMarketCap(selected.provenance)).toContain("retrieved 2026-09-11 15:23:57 UTC");
+  expect(describeFundamentalMarketCap(selected.provenance)).toContain("valuation date unavailable");
+  expect(selectMarketCapitalization(undefined, fundamentals)).toEqual(selected);
+  expect(quote.marketCap).toBeUndefined();
+});
+
+test("a valid quote capitalization wins without borrowing the fallback currency or retrieval time", () => {
+  expect(selectMarketCapitalization({ ...quote, marketCap: 60e9 }, { ...fundamentals, marketCapCurrency: "EUR" }))
+    .toEqual({ value: 60e9, currency: "USD", provenance: { kind: "quote", source: "yahoo" } });
+  expect(selectMarketCapitalization({ ...quote, marketCap: 0 }, fundamentals)?.value).toBe(0);
+});
+
+test.each([undefined, "", "GBp"])("unknown or unnormalized capitalization currency %s is not inferred from a USD quote", (marketCapCurrency) => {
+  expect(selectMarketCapitalization(quote, { ...fundamentals, marketCapCurrency })).toBeNull();
+});
+
+test.each([NaN, Infinity, -1])("unusable capitalization %s is not ranked", (marketCap) => {
+  expect(selectMarketCapitalization({ ...quote, marketCap }, { ...fundamentals, marketCap })).toBeNull();
+});
+
+test("stale and undated fundamental provenance remains explicit", () => {
+  const selected = selectMarketCapitalization(quote, { ...fundamentals, fetchedAt: undefined, stale: true })!;
+  expect(describeFundamentalMarketCap(selected.provenance)).toContain("retrieval time unavailable, stale");
+  expect(selected.provenance.retrievedAt).toBeUndefined();
+});

package/src/utils/market-capitalization.ts

@@ -0,0 +1,58 @@
+import type { Fundamentals, Quote } from "../types/financials";
+
+export interface MarketCapitalization {
+  value: number;
+  currency: string;
+  provenance: {
+    kind: "quote" | "fundamentals";
+    source?: string;
+    retrievedAt?: string;
+    stale?: boolean;
+  };
+}
+
+function usableValue(value: number | undefined): value is number {
+  return value != null && Number.isFinite(value) && value >= 0;
+}
+
+function explicitCurrency(currency: string | undefined): currency is string {
+  return currency != null && /^[A-Z]{3}$/.test(currency);
+}
+
+/** A lightweight quote can omit capitalization without invalidating the snapshot. */
+export function selectMarketCapitalization(
+  quote: Quote | undefined,
+  fundamentals: Fundamentals | undefined,
+): MarketCapitalization | null {
+  if (usableValue(quote?.marketCap) && explicitCurrency(quote?.currency)) {
+    return { value: quote.marketCap, currency: quote.currency,
+      provenance: { kind: "quote", source: quote.providerId } };
+  }
+  if (!usableValue(fundamentals?.marketCap) || !explicitCurrency(fundamentals?.marketCapCurrency)) return null;
+  return { value: fundamentals.marketCap, currency: fundamentals.marketCapCurrency,
+    provenance: { kind: "fundamentals", source: fundamentals.source,
+      retrievedAt: fundamentals.fetchedAt, stale: fundamentals.stale } };
+}
+
+export function describeFundamentalMarketCap(provenance: MarketCapitalization["provenance"]): string {
+  const source = provenance.source ?? "source unavailable";
+  const parsed = provenance.retrievedAt ? Date.parse(provenance.retrievedAt) : NaN;
+  const retrieval = Number.isFinite(parsed)
+    ? `retrieved ${new Date(parsed).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, " UTC")}`
+    : "retrieval time unavailable";
+  return `${source} fundamentals, ${retrieval}${provenance.stale ? ", stale" : ""}; valuation date unavailable`;
+}
+
+export function convertMarketCapitalization(
+  value: number | null,
+  currency: string | null,
+  baseCurrency: string,
+  rates: ReadonlyMap<string, number>,
+): number | null {
+  if (value == null || !Number.isFinite(value) || !currency) return null;
+  if (currency === baseCurrency) return value;
+  const fromRate = currency === "USD" ? 1 : rates.get(currency);
+  const toRate = baseCurrency === "USD" ? 1 : rates.get(baseCurrency);
+  if (fromRate == null || toRate == null || !Number.isFinite(fromRate) || !Number.isFinite(toRate) || fromRate <= 0 || toRate <= 0) return null;
+  return value * fromRate / toRate;
+}

package/src/utils/options.test.ts

@@ -0,0 +1,20 @@
+import { expect, test } from "bun:test";
+
+test("expiry labels preserve the contract date across investor time zones", () => {
+  const modulePath = new URL("./options.ts", import.meta.url).pathname;
+  // Separate processes exercise the host Date implementation without changing
+  // the timezone used by other suites. Include DST and a year boundary.
+  for (const timezone of ["America/New_York", "America/Los_Angeles", "Asia/Tokyo"]) {
+    const result = Bun.spawnSync([process.execPath, "-e", `
+      import { formatExpDate } from ${JSON.stringify(modulePath)};
+      console.log(JSON.stringify([
+        Date.UTC(2026, 8, 11), Date.UTC(2026, 9, 16),
+        Date.UTC(2026, 10, 20), Date.UTC(2027, 0, 1),
+      ].map(ms => formatExpDate(ms / 1000))));
+    `], { env: { ...process.env, TZ: timezone }, stdout: "pipe", stderr: "pipe" });
+    expect(result.exitCode).toBe(0);
+    expect(JSON.parse(result.stdout.toString())).toEqual([
+      "Sep 11 '26", "Oct 16 '26", "Nov 20 '26", "Jan 1 '27",
+    ]);
+  }
+});

package/src/utils/options.ts

@@ -3,12 +3,12 @@ import type { TickerRecord } from "../types/ticker";
 
 const MONTH_ABBREV = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
 
-/** Format a unix timestamp (seconds) as "Mon DD 'YY" */
+/** Chain timestamps encode an expiry calendar date in UTC, not a local instant. */
 export function formatExpDate(ts: number): string {
   const d = new Date(ts * 1000);
-  const month = MONTH_ABBREV[d.getMonth()] || String(d.getMonth() + 1);
-  const yy = String(d.getFullYear()).slice(2);
-  return `${month} ${d.getDate()} '${yy}`;
+  const month = MONTH_ABBREV[d.getUTCMonth()] || String(d.getUTCMonth() + 1);
+  const yy = String(d.getUTCFullYear()).slice(2);
+  return `${month} ${d.getUTCDate()} '${yy}`;
 }
 
 /**

package/src/utils/perf-marks.ts

@@ -5,6 +5,15 @@ const PERF_ERROR_MS = 200;
 
 const perfLog = debugLog.createLogger("perf");
 
+/**
+ * `GLOOMBERB_PERF_TRACE=1` mirrors every sample to stderr as one line with the
+ * elapsed process time, so a tmux-driven run yields a startup timeline without
+ * opening the in-app log. Resolved once: the check sits on every measured call.
+ */
+const traceToStderr = typeof process !== "undefined"
+  && !!process.env?.GLOOMBERB_PERF_TRACE
+  && typeof process.stderr?.write === "function";
+
 function now(): number {
   return typeof performance !== "undefined" && typeof performance.now === "function"
     ? performance.now()
@@ -20,6 +29,10 @@ function logSlowPerfSample(
     durationMs: Math.round(durationMs * 10) / 10,
     ...(metadata ?? {}),
   };
+  if (traceToStderr) {
+    const detail = metadata ? ` ${JSON.stringify(metadata)}` : "";
+    process.stderr.write(`perf ${name} ${payload.durationMs}ms t=${Math.round(now())}${detail}\n`);
+  }
   if (durationMs >= PERF_ERROR_MS) {
     perfLog.error(name, payload);
   } else if (durationMs >= PERF_WARN_MS) {
@@ -27,6 +40,19 @@ function logSlowPerfSample(
   }
 }
 
+export function isPerfTraceEnabled(): boolean {
+  return traceToStderr;
+}
+
+/** A sample measured elsewhere (a React Profiler callback, for instance). */
+export function recordPerfSample(
+  name: string,
+  durationMs: number,
+  metadata?: Record<string, unknown>,
+): void {
+  logSlowPerfSample(name, durationMs, metadata);
+}
+
 export function measurePerf<T>(
   name: string,
   fn: () => T,

package/src/utils/plugin-proxy-hosts.json

@@ -0,0 +1,16 @@
+{
+  "hosts": [
+    "api.elections.kalshi.com",
+    "api.nasdaq.com",
+    "api.votehub.com",
+    "clob.polymarket.com",
+    "data-api.polymarket.com",
+    "fc.yahoo.com",
+    "gamma-api.polymarket.com",
+    "nasdaqtrader.com",
+    "production.dataviz.cnn.io",
+    "query1.finance.yahoo.com",
+    "query2.finance.yahoo.com",
+    "stockanalysis.com"
+  ]
+}

package/src/utils/plugin-proxy-hosts.ts

@@ -0,0 +1,25 @@
+import allowed from "./plugin-proxy-hosts.json";
+
+/**
+ * Hosts the hosted web app is allowed to reach through the worker proxy.
+ *
+ * The list is not written by hand. It is generated from the `hosts` every
+ * plugin in the browser catalog declares (`scripts/generate-web-proxy-hosts.ts`,
+ * checked in CI), so a plugin bundled into the web app gets its hosts proxied
+ * by declaring them and nothing else does. Anything listed can be reached with
+ * our IP and our bandwidth, which is why the worker refuses everything else
+ * and why the list is exactly what shipped plugins need.
+ *
+ * Shared by both halves on purpose. The worker uses it to refuse, and the
+ * browser uses it to decide what to route: everything not listed keeps going
+ * out as a direct fetch, which is what the marketplace feed and the
+ * CORS-friendly data sources already rely on. If the two disagreed, the client
+ * would send requests the server rejects, or quietly bypass the allowlist.
+ */
+export const PROXY_ALLOWED_HOSTS: readonly string[] = allowed.hosts;
+
+/** Matches a host exactly, or as a subdomain of an allowed parent. */
+export function isProxiedHost(hostname: string, hosts: readonly string[] = PROXY_ALLOWED_HOSTS): boolean {
+  const host = hostname.toLowerCase();
+  return hosts.some((allowed) => host === allowed || host.endsWith(`.${allowed}`));
+}

package/src/utils/price-earnings.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test";
+import type { TickerFinancials } from "../types/financials";
+import type { TickerRecord } from "../types/ticker";
+import { getColumnValue, getSortValue } from "../plugins/builtin/portfolio-list/column-values";
+import { buildOverviewStats } from "../plugins/builtin/ticker-detail/overview/model";
+import { relativeValuationValues } from "../plugins/builtin/research/relative-valuation-model";
+
+const ticker: TickerRecord = { metadata: {
+  ticker: "TEST", name: "Test", exchange: "NASDAQ", currency: "USD",
+  portfolios: [], watchlists: [], positions: [], custom: {}, tags: [],
+} };
+const context = { baseCurrency: "USD", exchangeRates: new Map<string, number>(), now: 1 };
+
+test.each([
+  { value: -5.2, text: "N/M", comparable: null },
+  { value: 0, text: "N/M", comparable: null },
+  { value: undefined, text: "—", comparable: null },
+  { value: Number.NaN, text: "—", comparable: null },
+  { value: Number.POSITIVE_INFINITY, text: "—", comparable: null },
+  { value: 12.3, text: "12.3", comparable: 12.3 },
+])("portfolio and peer P/E comparisons handle $value consistently", ({ value, text, comparable }) => {
+  const data: TickerFinancials = { annualStatements: [], quarterlyStatements: [], priceHistory: [],
+    fundamentals: { trailingPE: value, forwardPE: value, eps: -3.1 } };
+  for (const id of ["pe", "forward_pe"]) {
+    const column = { id, label: id, width: 8, align: "right" as const };
+    expect(getColumnValue(column, ticker, data, context).text).toBe(text);
+    expect(getSortValue(column, ticker, data, context)).toBe(comparable);
+  }
+  expect(relativeValuationValues(data)).toMatchObject({ trailingPE: comparable, forwardPE: comparable });
+});
+
+test("overview keeps reported losses and a positive forecast while marking the trailing multiple non-comparable", () => {
+  const fundamentals = { trailingPE: -5.2, forwardPE: 12.3, eps: -3.1, financialCurrency: "USD" };
+  const stats = buildOverviewStats({ quote: undefined, fundamentals, quoteCurrency: "USD", baseCurrency: "USD", toBase: (value) => value });
+  expect(stats.find(({ label }) => label === "P/E (TTM)")?.value).toBe("N/M");
+  expect(stats.find(({ label }) => label === "Fwd P/E")?.value).toBe("12.3");
+  expect(stats.find(({ label }) => label === "EPS")?.value).toBe("-$3.10");
+  expect(fundamentals).toMatchObject({ trailingPE: -5.2, forwardPE: 12.3, eps: -3.1 });
+});

package/src/utils/price-earnings.ts

@@ -0,0 +1,13 @@
+import { formatNumber } from "./format";
+
+export const PRICE_EARNINGS_NOTICE = "N/M = not meaningful. Non-positive P/E values are excluded from ranking.";
+
+/** Negative earnings do not make a security cheaper than a profitable peer. */
+export function comparablePriceEarnings(value: number | null | undefined): number | null {
+  return value != null && Number.isFinite(value) && value > 0 ? value : null;
+}
+
+export function formatPriceEarnings(value: number | null | undefined, precision = 1): string {
+  if (value == null || !Number.isFinite(value)) return "—";
+  return value <= 0 ? "N/M" : formatNumber(value, precision);
+}

package/src/utils/price-history-integrity.ts

@@ -0,0 +1,61 @@
+import type { PricePoint } from "../types/financials";
+
+type ReportedPricePoint = Readonly<Omit<PricePoint, "date" | "historySource"> & {
+  date: string;
+  historySource?: Readonly<NonNullable<PricePoint["historySource"]>>;
+}>;
+
+export interface PriceHistoryIntegrity {
+  readonly reason: "inconsistent-ohlc";
+  /** Original reported values, retained for inspection, never used as replacements. */
+  readonly sourcePoints: ReadonlyArray<ReportedPricePoint>;
+}
+
+function snapshotReportedPoint(point: ReportedPricePoint): ReportedPricePoint {
+  return Object.freeze({ ...point, ...(point.historySource ? { historySource: Object.freeze({ ...point.historySource }) } : {}) });
+}
+
+export function mergePriceHistoryIntegrity(...entries: readonly PriceHistoryIntegrity[]): PriceHistoryIntegrity {
+  return Object.freeze({
+    reason: "inconsistent-ohlc",
+    sourcePoints: Object.freeze(entries.flatMap((entry) => entry.sourcePoints.map(snapshotReportedPoint))),
+  });
+}
+
+function finite(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function above(left: number, right: number): boolean {
+  return left - right > 8 * Number.EPSILON * Math.max(Math.abs(left), Math.abs(right));
+}
+
+/** Missing OHLC fields are not contradictory: close-only histories remain usable. */
+export function pricePointIntegrity(point: PricePoint): PriceHistoryIntegrity | undefined {
+  const { open, high, low, close } = point;
+  const invalid = (finite(high) && finite(low) && above(low, high))
+    || [open, close].some((value) => finite(value)
+      && ((finite(high) && above(value, high)) || (finite(low) && above(low, value))));
+  if (!invalid) return undefined;
+  const date = new Date(point.date);
+  return Object.freeze({
+    reason: "inconsistent-ohlc",
+    sourcePoints: Object.freeze([snapshotReportedPoint({ ...point, date: Number.isFinite(date.getTime()) ? date.toISOString() : String(point.date) })]),
+  });
+}
+
+/** Calculation/display fields deliberately exclude the contradictory source row. */
+export function pricePointValues(point: PricePoint, integrity = pricePointIntegrity(point)) {
+  const value = (number: number | undefined) => !integrity && finite(number) ? number : null;
+  return {
+    open: value(point.open), high: value(point.high), low: value(point.low),
+    close: value(point.close), volume: value(point.volume),
+    ...(integrity ? { integrity } : {}),
+  };
+}
+
+export function priceHistoryIntegrityNotice(count: number): string | undefined {
+  return count > 0
+    ? `${count} inconsistent OHLC ${count === 1 ? "bar is" : "bars are"} unavailable. Affected calculations contain gaps; original values and reasons are retained in JSON exports.`
+    : undefined;
+}