gloomberb 0.15.2 → 0.15.4

package/src/utils/price-history.ts

@@ -4,6 +4,7 @@ import { hasPublishedSessionCalendar, isTimestampStaleForExchangeSession, latest
 import { zonedDateTimeParts } from "./zoned-date-time";
 import { regularHistorySessionStaleness } from "../market-data/history-session";
 import type { HistorySession } from "../types/price-history";
+import { BAR_INTERVAL_UNIT_MS, parseBarInterval } from "../time-series/resolution";
 
 const MAX_CURRENT_INTRADAY_HISTORY_LAG_MS = 18 * 60 * 60 * 1000;
 const MAX_SAME_SESSION_HISTORY_LAG_MS = 30 * 60 * 1000;
@@ -17,16 +18,8 @@ interface PriceHistoryFreshnessOptions {
 }
 
 export function priceHistoryIntervalMs(interval: string): number | null {
-  const match = /^(\d+)\s*(m|min|mins|minute|minutes|h|hr|hour|hours|d|day|days|w|wk|week|weeks|mo|month|months)$/i.exec(interval.trim());
-  if (!match) return null;
-  const count = Number(match[1]);
-  const unit = match[2]!.toLowerCase();
-  const step = /^(mo|month)/.test(unit) ? 30 * DAY_MS
-    : /^(w|wk|week)/.test(unit) ? 7 * DAY_MS
-    : /^(d|day)/.test(unit) ? DAY_MS
-    : /^(h|hr|hour)/.test(unit) ? 60 * 60 * 1000
-    : 60 * 1000;
-  return count > 0 && Number.isFinite(count * step) ? count * step : null;
+  const parsed = parseBarInterval(interval);
+  return parsed ? parsed.count * BAR_INTERVAL_UNIT_MS[parsed.unit] : null;
 }
 
 function inferredHistoryIntervalMs(points: PricePoint[]): number | null {
@@ -295,8 +288,40 @@ export function calendarHistoryFetchState(
   return now - lastCheck >= pace ? "recheck" : "behind";
 }
 
+function isPlaceholderBar(point: PricePoint): boolean {
+  return point.volume === 0 && Number.isFinite(point.close)
+    && point.open === point.close && point.high === point.close && point.low === point.close;
+}
+
+const trimmedHistories = new WeakMap<PricePoint[], PricePoint[]>();
+// An offer priced the day before trading, or a value carried forward to the
+// opening auction, sits days at most before the first print.
+const PLACEHOLDER_LEAD_MAX_MS = 7 * DAY_MS;
+
+/**
+ * Bars at the very start of a traded series with no volume and one price
+ * (open = high = low = close) are placeholders, not trades: an offer price or
+ * a carried-forward value before the first print. They are dropped only when
+ * the next priced bar reports volume within days. Series that never report
+ * volume (FX, most indices) and long-lived indices whose early decades carry
+ * none keep every bar. Expects date order.
+ */
+export function dropLeadingPlaceholderBars(points: PricePoint[]): PricePoint[] {
+  if (points.length === 0 || !isPlaceholderBar(points[0]!)) return points;
+  const cached = trimmedHistories.get(points);
+  if (cached) return cached;
+  let start = 1;
+  while (start < points.length && isPlaceholderBar(points[start]!)) start++;
+  const firstPrint = points.slice(start).find((point) => Number.isFinite(point.close));
+  const result = firstPrint && (firstPrint.volume ?? 0) > 0
+    && getPricePointTimestamp(firstPrint) - getPricePointTimestamp(points[0]!) <= PLACEHOLDER_LEAD_MAX_MS
+    ? points.slice(start) : points;
+  trimmedHistories.set(points, result);
+  return result;
+}
+
 export function normalizeTickerFinancialsPriceHistory(financials: TickerFinancials): TickerFinancials {
-  const priceHistory = normalizePriceHistory(financials.priceHistory ?? []);
+  const priceHistory = dropLeadingPlaceholderBars(normalizePriceHistory(financials.priceHistory ?? []));
   return priceHistory === financials.priceHistory
     ? financials
     : { ...financials, priceHistory };

package/src/utils/sec.ts

@@ -1,16 +1,11 @@
 import type { TickerRecord } from "../types/ticker";
-import { canonicalExchange } from "./exchanges";
+import { canonicalExchange, US_LISTING_EXCHANGES } from "./exchanges";
 
+/** Canonical US equity venues: the listing exchanges plus other lit and OTC venues. */
 const US_EQUITY_EXCHANGES = new Set([
-  "AMEX",
-  "ARCA",
-  "BATS",
+  ...US_LISTING_EXCHANGES,
   "BYX",
   "IEX",
-  "NASDAQ",
-  "NMS",
-  "NYSE",
-  "NYSEARCA",
   "OTC",
   "PINK",
   // Yahoo's codes for Cboe BZX and the OTC Markets tiers.

package/src/utils/semver.ts

@@ -1,3 +1,5 @@
+import { VERSION } from "../version";
+
 /**
  * Just enough semver for plugin versions: `1.2.3`, `v1.2.3`, and a
  * prerelease suffix. Anything else is not a version and compares as unknown.
@@ -46,3 +48,16 @@ export function formatVersion(value: string | null | undefined): string | null {
   const base = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
   return parsed.prerelease ? `${base}-${parsed.prerelease}` : base;
 }
+
+/**
+ * The Gloomberb a plugin's published code needs, when this build is older;
+ * null when it runs here or the registry does not say. The registry states it
+ * for the code an install or update would land on, not the checkout already
+ * on disk, so it blocks those two actions and nothing else. Without it the
+ * update goes through and the plugin then fails to compile against a host
+ * that lacks what it imports.
+ */
+export function requiredGloomberb(minGloomberb: string | null | undefined, current: string = VERSION): string | null {
+  const order = compareSemver(current, minGloomberb);
+  return order !== null && order < 0 ? formatVersion(minGloomberb) : null;
+}

package/src/utils/shortcut-labels.ts

@@ -1,35 +1,10 @@
-export type ShortcutPlatform = "darwin" | "win32" | "linux" | "unknown";
-export type ShortcutDisplayMode = "platform" | "terminal";
-
-function platformFromProcess(): ShortcutPlatform | null {
-  const platform = (globalThis as { process?: { platform?: string } }).process?.platform;
-  if (platform === "darwin" || platform === "win32" || platform === "linux") return platform;
-  return null;
-}
+import { detectPlatform, type DesktopPlatform } from "./platform";
 
-function platformFromNavigator(): ShortcutPlatform | null {
-  const navigatorLike = (globalThis as {
-    navigator?: {
-      platform?: string;
-      userAgent?: string;
-      userAgentData?: { platform?: string };
-    };
-  }).navigator;
-  const raw = [
-    navigatorLike?.userAgentData?.platform,
-    navigatorLike?.platform,
-    navigatorLike?.userAgent,
-  ].filter(Boolean).join(" ").toLowerCase();
-
-  if (!raw) return null;
-  if (/(mac|iphone|ipad|ipod)/.test(raw)) return "darwin";
-  if (/win/.test(raw)) return "win32";
-  if (/(linux|x11)/.test(raw)) return "linux";
-  return null;
-}
+export type ShortcutPlatform = DesktopPlatform;
+export type ShortcutDisplayMode = "platform" | "terminal";
 
 export function detectShortcutPlatform(): ShortcutPlatform {
-  return platformFromProcess() ?? platformFromNavigator() ?? "unknown";
+  return detectPlatform((globalThis as { process?: { platform?: string } }).process?.platform);
 }
 
 function isMacShortcutPlatform(platform: ShortcutPlatform = detectShortcutPlatform()): boolean {

package/src/utils/sort-values.ts

@@ -23,6 +23,34 @@ export interface SortPreference<Id extends string> {
   direction: SortDirection;
 }
 
+export interface HeaderSortOptions<Id extends string, Reset = SortPreference<Id>> {
+  /** Direction a newly clicked column starts in. Defaults to ascending. */
+  firstDirection?: SortDirection | ((columnId: Id) => SortDirection);
+  /**
+   * State a third click on the same column returns to, such as the table's
+   * default sort or `{ columnId: null }` for unsorted. Without it the column
+   * keeps flipping between directions.
+   */
+  resetTo?: Reset;
+}
+
+/**
+ * Sort state after a column header click. A new column starts in its first
+ * direction and a second click flips it; the next click either flips back or,
+ * with `resetTo`, returns to that state.
+ */
+export function nextHeaderSort<Id extends string, Reset extends SortPreference<string> = never>(
+  current: { readonly columnId: Id | null; readonly direction: SortDirection },
+  columnId: Id,
+  options: HeaderSortOptions<Id, Reset> = {},
+): { columnId: Id; direction: SortDirection } | NoInfer<Reset> {
+  const { firstDirection = "asc", resetTo } = options;
+  const first = typeof firstDirection === "function" ? firstDirection(columnId) : firstDirection;
+  if (current.columnId !== columnId) return { columnId, direction: first };
+  if (resetTo !== undefined && current.direction !== first) return resetTo;
+  return { columnId, direction: current.direction === "asc" ? "desc" : "asc" };
+}
+
 /**
  * Keyboard equivalent of clicking column headers: walks every sort state the
  * mouse can reach (each column ascending then descending, plus the unsorted

package/src/utils/statement-gaps.ts

@@ -0,0 +1,94 @@
+import type { EarningsField, FinancialStatement, StatementGapField } from "../types/financials";
+import { isIncomeStatementField } from "./income-statement";
+
+/**
+ * Lines outside net income that a source can declare unavailable for a period.
+ * Net income lines use the same `unavailableFields` list but keep their own
+ * per-field owners (see income-statement.ts).
+ */
+const STATEMENT_GAP_FIELDS = ["totalRevenue", "operatingRevenue", "pretaxIncome", "taxProvision"] as const satisfies readonly StatementGapField[];
+const EARNINGS_FIELDS = ["basicEps", "eps"] as const satisfies readonly EarningsField[];
+
+type GapField = StatementGapField | EarningsField;
+
+function isEarningsField(field: string): field is EarningsField {
+  return (EARNINGS_FIELDS as readonly string[]).includes(field);
+}
+
+/** Whether the row declares this line unavailable for its period. */
+export function hasStatementGap(row: FinancialStatement | undefined, field: string): boolean {
+  if (!row) return false;
+  return isEarningsField(field)
+    ? Array.isArray(row.unavailableEarnings) && row.unavailableEarnings.includes(field)
+    : Array.isArray(row.unavailableFields) && (row.unavailableFields as string[]).includes(field);
+}
+
+/** Whether the row declares a gap in a line other than the net income lines. */
+export function hasNonIncomeStatementGap(row: FinancialStatement | undefined): boolean {
+  return [...STATEMENT_GAP_FIELDS, ...EARNINGS_FIELDS].some((field) => hasStatementGap(row, field));
+}
+
+function removeValue(row: FinancialStatement, field: GapField): void {
+  delete row[field];
+  if (row.fieldAvailability && field in row.fieldAvailability) {
+    row.fieldAvailability = { ...row.fieldAvailability };
+    delete row.fieldAvailability[field];
+  }
+}
+
+/** A copy of the row with these lines declared unavailable and their values removed. */
+export function withStatementGaps<T extends FinancialStatement>(row: T, fields: readonly GapField[]): T {
+  if (fields.length === 0) return row;
+  const result = { ...row };
+  for (const field of fields) {
+    removeValue(result, field);
+    if (isEarningsField(field)) result.unavailableEarnings = [...new Set([...(result.unavailableEarnings ?? []), field])];
+    else result.unavailableFields = [...new Set([...(result.unavailableFields ?? []), field])];
+  }
+  return result;
+}
+
+/**
+ * Carry declared gaps into a row merged from these inputs. A gap any input
+ * declares wins over another input's value, so neither a vendor figure nor a
+ * chart residual can fill it. Net income entries already on the target stay
+ * as their owner merge left them.
+ */
+export function mergeStatementGaps(target: FinancialStatement, rows: readonly (FinancialStatement | undefined)[]): void {
+  const lines = STATEMENT_GAP_FIELDS.filter((field) => rows.some((row) => hasStatementGap(row, field)));
+  const earnings = EARNINGS_FIELDS.filter((field) => rows.some((row) => hasStatementGap(row, field)));
+  const income = (Array.isArray(target.unavailableFields) ? target.unavailableFields : []).filter(isIncomeStatementField);
+  const unavailableFields = [...income, ...lines];
+  if (unavailableFields.length) target.unavailableFields = unavailableFields;
+  else delete target.unavailableFields;
+  if (earnings.length) target.unavailableEarnings = earnings;
+  else delete target.unavailableEarnings;
+  for (const field of [...lines, ...earnings]) removeValue(target, field);
+}
+
+// Gloom Cloud strips a withdrawn value and names it with an id on the row,
+// such as "…-2025q4-revenue". The suffix names the line; the row is the period.
+// This bridge goes away once the payload lists the lines in `unavailableFields`
+// and `unavailableEarnings` itself.
+const WITHDRAWN_LINE_SUFFIXES: ReadonlyArray<readonly [string, GapField]> = [
+  ["-operating-revenue", "operatingRevenue"],
+  ["-revenue", "totalRevenue"],
+  ["-parent-income", "netIncome"],
+  ["-common-income", "netIncomeCommonStockholders"],
+  ["-pretax", "pretaxIncome"],
+  ["-tax", "taxProvision"],
+  ["-basicEps", "basicEps"],
+  ["-eps", "eps"],
+];
+
+/** Read a row's Cloud withdrawal ids as declared gaps and drop the ids. */
+export function readWithdrawnObservations<T extends FinancialStatement>(row: T): T {
+  if (row.withdrawnObservations === undefined) return row;
+  const ids = Array.isArray(row.withdrawnObservations) ? row.withdrawnObservations : [];
+  const fields = ids.flatMap((id) => {
+    const line = typeof id === "string" ? WITHDRAWN_LINE_SUFFIXES.find(([suffix]) => id.endsWith(suffix)) : undefined;
+    return line ? [line[1]] : [];
+  });
+  const { withdrawnObservations: _ids, ...rest } = row;
+  return withStatementGaps(rest as T, fields);
+}

package/src/utils/zoned-date-time.ts

@@ -42,6 +42,18 @@ export function zonedDateTimeParts(utcMs: number, timeZone: string): ZonedDateTi
   };
 }
 
+const dateKeyFormatters = new Map<string, Intl.DateTimeFormat>();
+
+/** The calendar day an instant falls on in an IANA timezone, as "YYYY-MM-DD". */
+export function zonedDateKey(utcMs: number, timeZone: string): string {
+  let value = dateKeyFormatters.get(timeZone);
+  if (!value) {
+    value = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" });
+    dateKeyFormatters.set(timeZone, value);
+  }
+  return value.format(utcMs);
+}
+
 function zonedOffsetMs(utcMs: number, timeZone: string): number {
   const parts = zonedDateTimeParts(utcMs, timeZone);
   const wallMs = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);

package/src/api-client/askg.test.ts

@@ -1,256 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  classifyASKGRequestError,
-  createSseDecoder,
-  readASKGEventStream,
-  CloudASKGApi,
-} from "./askg";
-import { ApiRequestError } from "./errors";
-import type { ASKGSseEvent } from "../plugins/builtin/cloud/askg/protocol";
-
-function streamOf(chunks: string[]): ReadableStream<Uint8Array> {
-  const encoder = new TextEncoder();
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      for (const chunk of chunks) controller.enqueue(encoder.encode(chunk));
-      controller.close();
-    },
-  });
-}
-
-function frame(event: Record<string, unknown>): string {
-  return `id: ${event.seq}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
-}
-
-describe("createSseDecoder", () => {
-  test("joins frames split across chunks and drops keep-alive comments", () => {
-    const decoder = createSseDecoder();
-    expect(decoder.push("id: 1\nevent: text-delta\nda")).toEqual([]);
-    expect(decoder.push('ta: {"a":1}\n')).toEqual([]);
-    const frames = decoder.push('\n: keep-alive\n\nid: 2\ndata: {"b":2}\n\n');
-    expect(frames).toEqual([
-      { id: "1", event: "text-delta", data: '{"a":1}' },
-      { id: "2", data: '{"b":2}' },
-    ]);
-  });
-
-  test("keeps multi-line data and \\r\\n line endings", () => {
-    const decoder = createSseDecoder();
-    expect(decoder.push("data: one\r\ndata: two\r\n\r\n")).toEqual([
-      { data: "one\ntwo" },
-    ]);
-  });
-});
-
-describe("readASKGEventStream", () => {
-  test("emits typed events in order and reports the terminal reason", async () => {
-    const events: ASKGSseEvent[] = [];
-    const outcome = await readASKGEventStream(
-      streamOf([
-        frame({ seq: 1, type: "text-delta", turnId: "t1", delta: "he" }),
-        frame({ seq: 2, type: "text-delta", turnId: "t1", delta: "llo" }),
-        frame({ seq: 3, type: "done", turnId: "t1", reason: "complete" }),
-      ]),
-      { onEvent: (event) => events.push(event) },
-    );
-
-    expect(events.map((event) => event.type)).toEqual([
-      "text-delta",
-      "text-delta",
-      "done",
-    ]);
-    expect(outcome).toEqual({ lastSeq: 3, done: "complete" });
-  });
-
-  test("skips events a resumed stream replays", async () => {
-    const deltas: string[] = [];
-    const outcome = await readASKGEventStream(
-      streamOf([
-        frame({ seq: 1, type: "text-delta", turnId: "t1", delta: "old" }),
-        frame({ seq: 2, type: "text-delta", turnId: "t1", delta: "new" }),
-      ]),
-      {
-        lastSeq: 1,
-        onEvent: (event) => {
-          if (event.type === "text-delta") deltas.push(event.delta);
-        },
-      },
-    );
-
-    expect(deltas).toEqual(["new"]);
-    expect(outcome.done).toBeNull();
-  });
-
-  test("ignores frames that are not protocol events", async () => {
-    const events: ASKGSseEvent[] = [];
-    await readASKGEventStream(
-      streamOf([
-        "data: not json\n\n",
-        'data: {"hello":true}\n\n',
-        frame({
-          seq: 4,
-          type: "tool-result-ack",
-          turnId: "t1",
-          toolCallId: "c1",
-        }),
-      ]),
-      { onEvent: (event) => events.push(event) },
-    );
-    expect(events).toHaveLength(1);
-    expect(events[0]?.type).toBe("tool-result-ack");
-  });
-});
-
-function transportFor(
-  open: (init: RequestInit | undefined) => Promise<Response>,
-) {
-  const requests: Array<{ path: string; init?: RequestInit }> = [];
-  const api = new CloudASKGApi({
-    request: async <T>(path: string, init?: RequestInit) => {
-      requests.push({ path, init });
-      return undefined as T;
-    },
-    openStream: (path, init) => {
-      requests.push({ path, init });
-      return open(init);
-    },
-    isStreamingSupported: () => true,
-    delay: async () => {},
-  });
-  return { api, requests };
-}
-
-describe("CloudASKGApi.streamTurn", () => {
-  test("resumes a dropped stream with Last-Event-ID and finishes the answer", async () => {
-    let attempt = 0;
-    const { api, requests } = transportFor(async () => {
-      attempt += 1;
-      return new Response(
-        streamOf(
-          attempt === 1
-            ? [
-                frame({
-                  seq: 1,
-                  type: "text-delta",
-                  turnId: "t1",
-                  delta: "half ",
-                }),
-              ]
-            : [
-                frame({
-                  seq: 1,
-                  type: "text-delta",
-                  turnId: "t1",
-                  delta: "half ",
-                }),
-                frame({
-                  seq: 2,
-                  type: "text-delta",
-                  turnId: "t1",
-                  delta: "answer",
-                }),
-                frame({
-                  seq: 3,
-                  type: "done",
-                  turnId: "t1",
-                  reason: "complete",
-                }),
-              ],
-        ),
-      );
-    });
-
-    const deltas: string[] = [];
-    const reason = await api.streamTurn(
-      "s1",
-      { turnId: "t1", input: "hi" },
-      {
-        onEvent: (event) => {
-          if (event.type === "text-delta") deltas.push(event.delta);
-        },
-      },
-    );
-
-    expect(reason).toBe("complete");
-    // The replayed first event is dropped, so the answer is not doubled.
-    expect(deltas.join("")).toBe("half answer");
-    expect(
-      new Headers(requests[0]?.init?.headers).get("Last-Event-ID"),
-    ).toBeNull();
-    expect(new Headers(requests[1]?.init?.headers).get("Last-Event-ID")).toBe(
-      "1",
-    );
-    // The same turn id re-attaches instead of asking again.
-    expect(JSON.parse(String(requests[1]?.init?.body)).turnId).toBe("t1");
-  });
-
-  test("gives up with a retryable network error when the stream keeps dropping", async () => {
-    const { api } = transportFor(
-      async () =>
-        new Response(
-          streamOf([
-            frame({ seq: 1, type: "text-delta", turnId: "t1", delta: "x" }),
-          ]),
-        ),
-    );
-    await expect(
-      api.streamTurn(
-        "s1",
-        { turnId: "t1", input: "hi" },
-        { onEvent: () => {} },
-      ),
-    ).rejects.toMatchObject({ code: "network", retryable: true });
-  });
-});
-
-describe("CloudASKGApi.postToolResult", () => {
-  const payload = {
-    turnId: "t1",
-    toolCallId: "call-1",
-    status: "ok" as const,
-    truncated: false,
-    elapsedMs: 12,
-  };
-
-  test("sends the tool call id as the idempotency key", async () => {
-    const { api, requests } = transportFor(async () => new Response(""));
-    expect(await api.postToolResult("s1", payload)).toBe("accepted");
-    expect(new Headers(requests[0]?.init?.headers).get("Idempotency-Key")).toBe(
-      "call-1",
-    );
-  });
-
-  test("reports a closed result window instead of failing the turn", async () => {
-    const api = new CloudASKGApi({
-      request: async () => {
-        throw new ApiRequestError("result window closed", 410);
-      },
-      openStream: async () => new Response(""),
-      isStreamingSupported: () => true,
-    });
-    expect(await api.postToolResult("s1", payload)).toBe("too-late");
-  });
-});
-
-describe("classifyASKGRequestError", () => {
-  test("maps the documented statuses onto handled codes", () => {
-    expect(
-      classifyASKGRequestError(new ApiRequestError("pro required", 402)).code,
-    ).toBe("tier_required");
-    expect(
-      classifyASKGRequestError(new ApiRequestError("old protocol", 426)).code,
-    ).toBe("protocol");
-    expect(
-      classifyASKGRequestError(new ApiRequestError("disabled", 503)).code,
-    ).toBe("model_unavailable");
-    const limited = classifyASKGRequestError(
-      new ApiRequestError("too many", 429, 42_000),
-    );
-    expect(limited.code).toBe("rate_limited");
-    expect(limited.retryAfterMs).toBe(42_000);
-    expect(
-      classifyASKGRequestError(new ApiRequestError("daily cap reached", 429))
-        .code,
-    ).toBe("daily_turn_cap");
-  });
-});

package/src/api-client/errors.test.ts

@@ -1,11 +0,0 @@
-import { expect, test } from "bun:test";
-import { parseApiErrorMessage } from "./errors";
-
-test("an HTML error page from the proxy becomes its title, not raw markup", () => {
-  const cloudflare = `<!DOCTYPE html>\n<!--[if lt IE 7]> <html class="no-js ie6 oldie" lang="en-US"> <![endif]-->\n<html><head><title>api.gloom.sh | 502: Bad gateway</title></head><body>...</body></html>`;
-  expect(parseApiErrorMessage(cloudflare)).toBe("502: Bad gateway");
-  expect(parseApiErrorMessage("<html><body>down</body></html>")).toBe("The server returned an error page.");
-  expect(parseApiErrorMessage(JSON.stringify({ error: "Senate PTR filings are unavailable right now." })))
-    .toBe("Senate PTR filings are unavailable right now.");
-  expect(parseApiErrorMessage("plain text")).toBe("plain text");
-});