gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/econ-statistics/transform.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { applyTransform, periodsPerYear } from "./transform";
-
-function monthly(values: number[], startYear = 2020): Array<{ date: string; value: number }> {
-  return values.map((value, index) => {
-    const month = (index % 12) + 1;
-    const year = startYear + Math.floor(index / 12);
-    return { date: `${year}-${String(month).padStart(2, "0")}-01`, value };
-  });
-}
-
-describe("periodsPerYear", () => {
-  test("reads cadence off the gaps rather than being told", () => {
-    expect(periodsPerYear(monthly([1, 2, 3, 4, 5]))).toBe(12);
-    expect(periodsPerYear([
-      { date: "2024-01-01", value: 1 },
-      { date: "2024-04-01", value: 2 },
-      { date: "2024-07-01", value: 3 },
-      { date: "2024-10-01", value: 4 },
-    ])).toBe(4);
-    expect(periodsPerYear([
-      { date: "2024-01-06", value: 1 },
-      { date: "2024-01-13", value: 2 },
-      { date: "2024-01-20", value: 3 },
-      { date: "2024-01-27", value: 4 },
-    ])).toBe(52);
-  });
-});
-
-describe("applyTransform", () => {
-  test("year over year looks back a whole cadence, not one print", () => {
-    // 13 monthly points where the index rises 10% across the year.
-    const points = monthly([100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 110]);
-    const yoy = applyTransform(points, "yoy");
-    expect(yoy).toHaveLength(1);
-    expect(yoy[0]!.date).toBe("2021-01-01");
-    expect(yoy[0]!.value).toBeCloseTo(10, 6);
-  });
-
-  test("month over month uses the previous print", () => {
-    const mom = applyTransform(monthly([100, 101]), "mom");
-    expect(mom).toHaveLength(1);
-    expect(mom[0]!.value).toBeCloseTo(1, 6);
-  });
-
-  test("a quarterly move is stated at the annual rate it implies", () => {
-    // Cadence is inferred from the gaps, so it takes a few prints to see quarterly.
-    const quarterly = [
-      { date: "2024-01-01", value: 100 },
-      { date: "2024-04-01", value: 100 },
-      { date: "2024-07-01", value: 100 },
-      { date: "2024-10-01", value: 101 },
-    ];
-    // 1% in a quarter compounds to about 4.06% a year, not 4%.
-    const value = applyTransform(quarterly, "qoq-annualized").at(-1)!.value;
-    expect(value).toBeCloseTo((Math.pow(1.01, 4) - 1) * 100, 6);
-    expect(value).toBeGreaterThan(4);
-  });
-
-  test("too few prints to infer cadence falls back to monthly", () => {
-    // Two points cannot show a gap pattern, so a year-over-year lag is unknowable.
-    expect(applyTransform([
-      { date: "2024-01-01", value: 100 },
-      { date: "2024-04-01", value: 101 },
-    ], "yoy")).toHaveLength(0);
-  });
-
-  test("change is a difference, so it keeps the series' own units", () => {
-    const change = applyTransform(monthly([150_000, 150_120]), "change");
-    expect(change[0]!.value).toBeCloseTo(120, 6);
-  });
-
-  test("levels pass through and gaps are dropped, not interpolated", () => {
-    const level = applyTransform([
-      { date: "2024-03-01", value: 2 },
-      { date: "2024-01-01", value: null },
-      { date: "2024-02-01", value: 1 },
-    ], "level");
-    // Sorted ascending, with the null month absent rather than filled in.
-    expect(level.map((point) => point.date)).toEqual(["2024-02-01", "2024-03-01"]);
-  });
-
-  test("a zero base cannot produce a percent change", () => {
-    expect(applyTransform(monthly([0, 5]), "mom")).toHaveLength(0);
-  });
-
-  test("missing months never shift year-over-year comparisons into different periods", () => {
-    const observations: Array<{ date: string; value: number | null }> = monthly([
-      100, 102, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 110, 112,
-    ]);
-    observations[1]!.value = null;
-    expect(applyTransform(observations, "yoy")).toEqual([{ date: "2021-01-01", value: expect.closeTo(10, 6) }]);
-    const mom = applyTransform(observations, "mom");
-    expect(mom.some((point) => point.date === "2020-03-01")).toBe(false);
-  });
-
-  test("annualized GDP growth requires the immediately preceding quarter", () => {
-    const observations = [
-      { date: "2024-01-01", value: 100 },
-      { date: "2024-04-01", value: 101 },
-      { date: "2024-07-01", value: null },
-      { date: "2024-10-01", value: 104 },
-    ];
-    const result = applyTransform(observations, "qoq-annualized");
-    expect(result).toHaveLength(1);
-    expect(result[0]!.date).toBe("2024-04-01");
-    expect(result[0]!.value).toBeCloseTo((1.01 ** 4 - 1) * 100);
-  });
-});

package/src/plugins/builtin/econ-statistics/transform.ts

@@ -1,94 +0,0 @@
-import type { DatedObservation } from "../shared/series-cache";
-
-/**
- * How a raw FRED series becomes the number people quote. An index level like CPI
- * is meaningless on its own; the year-over-year change is the statistic.
- */
-export type StatTransform =
-  | "level"
-  | "yoy"
-  | "mom"
-  | "qoq-annualized"
-  | "change";
-
-export interface StatPoint {
-  date: string;
-  value: number;
-}
-
-const MS_PER_DAY = 86_400_000;
-
-/**
- * Infers cadence from the median gap between prints, so a transform does not have
- * to be told whether a series is daily, weekly, monthly or quarterly.
- */
-export function periodsPerYear(observations: readonly DatedObservation[]): number {
-  const dates = observations
-    .filter((entry) => entry.value != null)
-    .map((entry) => Date.parse(entry.date))
-    .filter((value) => Number.isFinite(value));
-  if (dates.length < 3) return 12;
-
-  const gaps: number[] = [];
-  for (let i = 1; i < dates.length; i += 1) {
-    const gap = (dates[i]! - dates[i - 1]!) / MS_PER_DAY;
-    if (gap > 0) gaps.push(gap);
-  }
-  if (gaps.length === 0) return 12;
-  gaps.sort((a, b) => a - b);
-  const median = gaps[Math.floor(gaps.length / 2)]!;
-
-  if (median <= 4) return 252;
-  if (median <= 10) return 52;
-  if (median <= 45) return 12;
-  if (median <= 135) return 4;
-  return 1;
-}
-
-/** Applies a transform, dropping the leading points it cannot look back from. */
-export function applyTransform(
-  observations: readonly DatedObservation[],
-  transform: StatTransform,
-): StatPoint[] {
-  const clean = observations
-    .filter((entry): entry is { date: string; value: number } =>
-      entry.value != null && Number.isFinite(entry.value) && Number.isFinite(Date.parse(entry.date)))
-    .slice()
-    .sort((a, b) => a.date.localeCompare(b.date));
-  if (clean.length === 0) return [];
-
-  if (transform === "level") {
-    return clean.map((entry) => ({ date: entry.date, value: entry.value }));
-  }
-
-  const perYear = transform === "qoq-annualized" ? 4 : periodsPerYear(clean);
-  const lag = transform === "yoy" ? perYear : 1;
-  // FRED monthly/quarterly observations represent calendar periods. Removing a
-  // missing month before applying a positional lag turns y/y into a 13-month
-  // change, or reports a two-quarter GDP move as one quarter's annualized rate.
-  const calendarCadence = perYear === 12 || perYear === 4 || perYear === 1;
-  const byMonth = new Map(clean.map((point) => [point.date.slice(0, 7), point]));
-  const lagMonths = transform === "yoy" ? 12 : 12 / perYear;
-  const out: StatPoint[] = [];
-  for (let i = 0; i < clean.length; i += 1) {
-    const now = clean[i]!;
-    const before = calendarCadence
-      ? byMonth.get(new Date(Date.UTC(Number(now.date.slice(0, 4)), Number(now.date.slice(5, 7)) - 1 - lagMonths, 1)).toISOString().slice(0, 7))
-      : clean[i - lag];
-    if (!before) continue;
-    if (transform === "change") {
-      out.push({ date: now.date, value: now.value - before.value });
-      continue;
-    }
-    if (before.value === 0) continue;
-    const ratio = now.value / before.value;
-    if (transform === "qoq-annualized") {
-      // A quarterly move stated as the annual rate it implies, as the BEA reports it.
-      if (ratio <= 0) continue;
-      out.push({ date: now.date, value: (Math.pow(ratio, perYear) - 1) * 100 });
-      continue;
-    }
-    out.push({ date: now.date, value: (ratio - 1) * 100 });
-  }
-  return out;
-}

package/src/plugins/builtin/econ-statistics/trend.ts

@@ -1,57 +0,0 @@
-import type { StatPoint } from "./transform";
-
-const MS_PER_DAY = 86_400_000;
-
-export interface TrendFit {
-  alpha: number;
-  beta: number;
-  sigma: number;
-  originMs: number;
-}
-
-/**
- * Plain least squares against time. These series go negative routinely, so unlike
- * the valuation ratios there is no log variant to choose.
- */
-export function fitTrend(points: readonly StatPoint[]): TrendFit {
-  const usable = points.filter((point) => Number.isFinite(point.value));
-  const empty: TrendFit = { alpha: 0, beta: 0, sigma: 0, originMs: 0 };
-  if (usable.length === 0) return empty;
-
-  const originMs = Date.parse(usable[0]!.date);
-  if (usable.length < 2) return { alpha: usable[0]!.value, beta: 0, sigma: 0, originMs };
-
-  const xs = usable.map((point) => (Date.parse(point.date) - originMs) / MS_PER_DAY);
-  const ys = usable.map((point) => point.value);
-  const n = xs.length;
-  let sumX = 0;
-  let sumY = 0;
-  let sumXX = 0;
-  let sumXY = 0;
-  for (let i = 0; i < n; i += 1) {
-    sumX += xs[i]!;
-    sumY += ys[i]!;
-    sumXX += xs[i]! * xs[i]!;
-    sumXY += xs[i]! * ys[i]!;
-  }
-  const denom = n * sumXX - sumX * sumX;
-  const beta = denom === 0 ? 0 : (n * sumXY - sumX * sumY) / denom;
-  const alpha = (sumY - beta * sumX) / n;
-  if (n < 3) return { alpha, beta, sigma: 0, originMs };
-
-  let residualSq = 0;
-  for (let i = 0; i < n; i += 1) {
-    const residual = ys[i]! - (alpha + beta * xs[i]!);
-    residualSq += residual * residual;
-  }
-  return { alpha, beta, sigma: Math.sqrt(residualSq / (n - 2)), originMs };
-}
-
-export function trendAt(fit: TrendFit, date: string): number {
-  return fit.alpha + fit.beta * ((Date.parse(date) - fit.originMs) / MS_PER_DAY);
-}
-
-export function sigmaVsTrend(fit: TrendFit, value: number, date: string): number {
-  if (!(fit.sigma > 0)) return 0;
-  return (value - trendAt(fit, date)) / fit.sigma;
-}

package/src/plugins/builtin/econ-statistics/view.test.ts

@@ -1,43 +0,0 @@
-import { expect, test } from "bun:test";
-import { projectStat } from "./view";
-import { findStat } from "./stats";
-import { fitTrend } from "./trend";
-
-test("1Y ago matches calendar periods even when an intermediate month is missing", () => {
-  const points = Array.from({ length: 25 }, (_, index) => ({
-    date: new Date(Date.UTC(2024, 6 + index, 1)).toISOString().slice(0, 10),
-    value: index,
-  })).filter((point) => point.date !== "2025-10-01");
-  const view = projectStat({ stat: findStat("cpi-yoy"), points, trend: fitTrend(points) }, "5Y");
-  expect(view.latest.date).toBe("2026-07-01");
-  expect(view.yearAgo).toEqual({ date: "2025-07-01", value: 12 });
-  const missingBase = points.filter((point) => point.date !== "2025-07-01");
-  expect(projectStat({ stat: findStat("cpi-yoy"), points: missingBase, trend: fitTrend(missingBase) }, "5Y").yearAgo).toBeNull();
-});
-
-
-test("daily 1Y ago clamps February 29 to February 28 instead of looking forward into March", () => {
-  const points = [
-    { date: "2023-02-27", value: 4.1 }, { date: "2023-02-28", value: 4.2 },
-    { date: "2023-03-01", value: 4.3 }, { date: "2024-02-28", value: 4.4 },
-    { date: "2024-02-29", value: 4.5 },
-  ];
-  const view = projectStat({ stat: findStat("ten-year"), points, trend: fitTrend(points) }, "5Y");
-  expect(view.yearAgo).toEqual({ date: "2023-02-28", value: 4.2 });
-});
-
-test("an on-schedule print is not stale until its release is overdue", () => {
-  const stale = (id: string, latest: string, now: string, months = 1) => {
-    const points = Array.from({ length: 8 }, (_, index) => {
-      const date = new Date(`${latest}T00:00:00Z`);
-      date.setUTCMonth(date.getUTCMonth() - (7 - index) * months);
-      return { date: date.toISOString().slice(0, 10), value: index };
-    });
-    return projectStat({ stat: findStat(id), points, trend: fitTrend(points) }, "5Y", { nowMs: Date.parse(`${now}T12:00:00Z`) }).observationStale;
-  };
-  expect(stale("pce-yoy", "2026-07-01", "2026-09-24")).toBe(false);
-  expect(stale("pce-yoy", "2026-07-01", "2026-10-20")).toBe(true);
-  expect(stale("cpi-yoy", "2026-08-01", "2026-10-15")).toBe(false);
-  expect(stale("real-gdp", "2026-04-01", "2026-10-29", 3)).toBe(false);
-  expect(stale("real-gdp", "2026-04-01", "2026-11-30", 3)).toBe(true);
-});

package/src/plugins/builtin/equity-screener/headless.test.ts

@@ -1,22 +0,0 @@
-import { expect, test } from "bun:test";
-import { MAX_TOOL_RESULT_BYTES } from "../cloud/askg/protocol";
-import { equityScreenerHeadless } from "./headless";
-import { screenFixture } from "./test-fixture";
-
-test("a full page with more matches is neither an error nor too large for an Ask Gloom tool result", async () => {
-  const data = screenFixture();
-  const row = data.rows[0]!;
-  data.rows = Array.from({ length: 100 }, (_, index) => ({ ...row, symbol: `S${index}` }));
-  // Sparse fields make every real payload "partial"; that is not a failure.
-  Object.assign(data, { status: "partial", nextCursor: "next", universe: { ...data.universe, covered: 700, matched: 680 } });
-  const apiClient = { equityScreener: async () => structuredClone(data) };
-  const result = await equityScreenerHeadless.load({ argument: undefined, options: {} } as never, { apiClient } as never);
-  expect(result.errors).toEqual([]);
-  expect(result.complete).toBe(false);
-  expect(result.metadata).toMatchObject({ matched: 680, returned: 100, hasMore: true, notices: ["Top 100 of 680 matches; narrow the criteria to see the rest."] });
-  expect(new TextEncoder().encode(JSON.stringify(result)).byteLength).toBeLessThan(MAX_TOOL_RESULT_BYTES);
-
-  data.warnings = ["Bounded scan: some listings were not evaluated."];
-  const bounded = await equityScreenerHeadless.load({ argument: undefined, options: {} } as never, { apiClient } as never);
-  expect(bounded.errors).toEqual(data.warnings);
-});

package/src/plugins/builtin/equity-screener/model.test.ts

@@ -1,116 +0,0 @@
-import { screenFixture as payload } from "./test-fixture";
-import { expect, test } from "bun:test";
-import type { ScreenSnapshot } from "../../../api-client/equity-screener";
-import { fetchScreen } from "./client";
-import {
-  appendScreenPage,
-  criterionText,
-  DEFAULT_SCREEN,
-  formatScreenValue,
-  metricDate,
-  parseCriterion,
-  parseThreshold,
-  resultFields,
-  parseScreenDefinition,
-  validateScreenPayload,
-} from "./model";
-const field = {
-  id: "trailingPE" as const,
-  label: "P/E",
-  kind: "number" as const,
-  unit: "x",
-  description: "",
-  operators: ["gte", "between", "present"] as const,
-};
-
-test("criteria preserve zero and finite bounds, reject blank, currency ambiguity and observed-subset absence claims", () => {
-  expect(
-    parseCriterion({ ...field, operators: [...field.operators] }, "gte", "0"),
-  ).toEqual({ field: "trailingPE", op: "gte", value: 0 });
-  expect(() =>
-    parseCriterion({ ...field, operators: [...field.operators] }, "gte", ""),
-  ).toThrow("finite");
-  expect(() =>
-    parseCriterion(
-      { ...field, operators: [...field.operators] },
-      "between",
-      "20,10",
-    ),
-  ).toThrow("ascending");
-  expect(() =>
-    parseScreenDefinition({ ...DEFAULT_SCREEN, currency: null }),
-  ).toThrow("currency");
-  expect(() =>
-    parseScreenDefinition({
-      ...DEFAULT_SCREEN,
-      criteria: [{ field: "insiderPurchases90d", op: "eq", value: 0 }],
-    }),
-  ).toThrow("supported operator");
-});
-test("boundaries reject fabricated dates and percentiles; pagination cannot cross snapshots", () => {
-  const data = payload();
-  expect(validateScreenPayload(data)).toBe(data);
-  data.rows[0]!.metrics.price.value = 1;
-  data.rows[0]!.metrics.price.state = "available";
-  expect(() => validateScreenPayload(data)).toThrow("price");
-  data.rows[0]!.metrics.price.asOf = "2026-09-22";
-  data.rows[0]!.metrics.price.percentile.value = 101;
-  expect(() => validateScreenPayload(data)).toThrow("price");
-  const dated = payload();
-  dated.snapshot!.assembledAt = null as unknown as ScreenSnapshot["assembledAt"];
-  expect(() => validateScreenPayload(dated)).toThrow("snapshot identity");
-  const undated = payload();
-  undated.rows[0]!.metrics.marketCap.value = 12;
-  undated.rows[0]!.metrics.marketCap.state = "partial";
-  undated.rows[0]!.metrics.marketCap.observedAt = "2026-09-22T12:00:00Z";
-  expect(validateScreenPayload(undated).rows[0]!.metrics.marketCap.asOf).toBeNull();
-  const next = payload();
-  next.snapshot!.id = "two";
-  expect(() => appendScreenPage(payload(), next)).toThrow("snapshot changed");
-  expect(appendScreenPage(payload(), payload()).rows).toHaveLength(1);
-});
-
-test("query boundary rejects valid rows from different criteria", async () => {
-  const response = payload();
-  response.definition.criteria = [];
-  await expect(fetchScreen(DEFAULT_SCREEN, null, undefined, {
-    equityScreener: async () => response,
-  })).rejects.toThrow("requested criteria");
-});
-
-test("thresholds accept scale suffixes and reject anything else", () => {
-  expect(parseThreshold("10B")).toBe(10_000_000_000);
-  expect(parseThreshold("1.5t")).toBe(1_500_000_000_000);
-  expect(parseThreshold("-0.5")).toBe(-0.5);
-  expect(parseThreshold("1e6")).toBe(1_000_000);
-  expect(parseThreshold("10 B")).toBeNull();
-  expect(parseThreshold("ten")).toBeNull();
-  expect(criterionText({ field: "marketCap", op: "gte", value: 10_000_000_000 })).toBe("Market cap >= 10B");
-  expect(criterionText({ field: "trailingPE", op: "between", value: [0, 25] })).toBe("Trailing P/E between 0, 25");
-});
-
-test("values keep sign, scale and missing distinct from zero", () => {
-  expect(formatScreenValue("marketCap", 5_547_531_698_176)).toBe("5.55T");
-  expect(formatScreenValue("revenueGrowthPercent", 65.47)).toBe("+65.5");
-  expect(formatScreenValue("revenueGrowthPercent", 0)).toBe("0.0");
-  expect(formatScreenValue("insiderSales90d", 20)).toBe("20");
-  expect(formatScreenValue("trailingPE", null)).toBe("--");
-});
-
-test("undated provider values show their collection date, never an invented source date", () => {
-  const base = payload().rows[0]!.metrics.trailingPE;
-  expect(metricDate({ ...base, asOf: "2026-08-31", observedAt: "2026-09-22T12:00:00Z" })).toEqual({ text: "2026-08-31", collected: false });
-  expect(metricDate({ ...base, value: 10, asOf: null, observedAt: "2026-09-22T12:00:00Z" })).toEqual({ text: "2026-09-22", collected: true });
-  expect(metricDate({ ...base, value: null, asOf: null, observedAt: null })).toEqual({ text: "--", collected: false });
-});
-
-test("result columns lead with the focus metric and the screen's criteria; money needs a currency", () => {
-  const definition = parseScreenDefinition({
-    version: 1,
-    currency: "USD",
-    criteria: [{ field: "operatingMarginPercent", op: "gte", value: 20 }, { field: "sector", op: "in", value: ["Technology"] }],
-    sort: { field: "trailingPE", direction: "asc" },
-  });
-  expect(resultFields(definition, "trailingPE").slice(0, 3)).toEqual(["trailingPE", "operatingMarginPercent", "marketCap"]);
-  expect(resultFields({ ...definition, currency: null }, "trailingPE")).not.toContain("price");
-});

package/src/plugins/builtin/equity-screener/results.test.tsx

@@ -1,44 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { act, useState } from "react";
-import { testRender } from "../../../renderers/opentui/test-utils";
-import { Text } from "../../../ui";
-import type { ScreenDefinition, ScreenPayload } from "../../../api-client/equity-screener";
-import { DEFAULT_SCREEN } from "./model";
-import { screenFixture } from "./test-fixture";
-import { useScreenResults } from "./results";
-
-let setup: Awaited<ReturnType<typeof testRender>> | undefined;
-afterEach(async () => { if (setup) await act(async () => setup!.renderer.destroy()); setup = undefined; });
-async function settle(action?: () => void) { await act(async () => { action?.(); await setup!.renderOnce(); }); }
-test("late pagination and refreshes cannot repopulate a changed query or account", async () => {
-  const requests: Array<{ signal?: AbortSignal; definition: ScreenDefinition; resolve: (data: ScreenPayload) => void }> = [];
-  const fetcher = (definition: ScreenDefinition, _cursor?: string | null, signal?: AbortSignal) => new Promise<ScreenPayload>(resolve => requests.push({ definition, signal, resolve }));
-  let latest!: ReturnType<typeof useScreenResults>, changeDefinition!: (definition: ScreenDefinition) => void, changeSession!: (id: string) => void;
-  function Harness() {
-    const [definition, setDefinition] = useState(DEFAULT_SCREEN), [session, setSession] = useState("account-one");
-    changeDefinition = setDefinition; changeSession = setSession;
-    latest = useScreenResults(definition, session, fetcher);
-    return <Text>{latest.data?.rows.map(row => row.symbol).join(",") ?? "pending"}</Text>;
-  }
-  await act(async () => { setup = await testRender(<Harness />, { width: 50, height: 4 }); });
-  const first = screenFixture(); first.nextCursor = "page-two";
-  await settle(() => requests[0]!.resolve(first));
-  expect(latest.data?.rows[0]?.symbol).toBe("AAPL");
-  await settle(() => { void latest.loadMore(); });
-  const oldPage = requests[1]!;
-  await settle(() => changeDefinition({ ...DEFAULT_SCREEN, criteria: [] }));
-  expect(oldPage.signal?.aborted).toBe(true);
-  expect(latest.data).toBeNull();
-  const late = screenFixture(); late.rows[0]!.symbol = "MSFT";
-  await settle(() => oldPage.resolve(late));
-  expect(latest.data).toBeNull();
-  const current = screenFixture(); current.definition = requests[2]!.definition; current.rows[0]!.symbol = "NVDA";
-  await settle(() => requests[2]!.resolve(current));
-  expect(latest.data?.rows[0]?.symbol).toBe("NVDA");
-  await settle(() => { void latest.load(); });
-  const oldRefresh = requests[3]!;
-  await settle(() => changeSession("account-two"));
-  await settle(() => oldRefresh.resolve(current));
-  expect(oldRefresh.signal?.aborted).toBe(true);
-  expect(latest.data).toBeNull();
-});

package/src/plugins/builtin/equity-screener/test-fixture.ts

@@ -1,63 +0,0 @@
-import { NUMERIC_FIELDS, type ScreenPayload } from "../../../api-client/equity-screener";
-import { DEFAULT_SCREEN } from "./model";
-export function screenFixture(): ScreenPayload {
-  return {
-    version: 1,
-    status: "available",
-    definition: structuredClone(DEFAULT_SCREEN),
-    snapshot: {
-      id: "one",
-      assembledAt: "2026-09-22T16:00:00Z",
-      expiresAt: "2026-09-22T18:00:00Z",
-      sourceOldestAt: null,
-      sourceNewestAt: null,
-    },
-    universe: {
-      covered: 1,
-      matched: 1,
-      skipped: 0,
-      knownByField: {} as any,
-      missingByField: {} as any,
-      partialByField: {} as any,
-      staleByField: {} as any,
-      currencies: ["USD"],
-      sectors: [],
-      exchanges: [],
-    },
-    nextCursor: null,
-    warnings: [],
-    rows: [
-      {
-        symbol: "AAPL",
-        exchange: "NASDAQ",
-        name: "Apple",
-        currency: "USD",
-        sector: "Technology",
-        industry: null,
-        warnings: [],
-        metrics: Object.fromEntries(
-          NUMERIC_FIELDS.map((id) => [
-            id,
-            {
-              value: null,
-              unit: "x",
-              asOf: null,
-              availableAt: null,
-              observedAt: null,
-              source: "test",
-              state: "unavailable",
-              scope: "reported",
-              reason: null,
-              sourceUrl: null,
-              percentile: {
-                value: null,
-                sampleCount: 0,
-                scope: "covered-universe",
-              },
-            },
-          ]),
-        ) as any,
-      },
-    ],
-  };
-}