gloomberb 0.15.2 → 0.15.3

package/src/time-series/valuation-price.test.ts

@@ -1,267 +0,0 @@
-import { expect, spyOn, test } from "bun:test";
-import type { TickerFinancials } from "../types/financials";
-import { createTestDataProvider } from "../test-support/data-provider";
-import { createDefaultConfig } from "../types/config";
-import { loadChartPaneModel } from "../plugins/builtin/chart-composer/headless";
-import { extractFundamentalSeries, valuationPriceIssues } from "./fundamentals";
-import { resolveStudies } from "./studies";
-import { resolveChartSpecData } from "./resolve";
-import { chartQuoteOverrideKeyForSource, getLiveChartQuoteTargets, observeLiveChartQuotes } from "./live-quotes";
-import { createQuoteStoreFixture } from "./fixtures/quote-store";
-import { CHART_SPEC_VERSION, type ChartSpec, type SecuritySeriesSource } from "./types";
-
-const source = (metric = "trailingPE"): SecuritySeriesSource => ({ kind: "security",
-  instrument: { symbol: "TEST", exchange: "NYSE" }, fieldId: `valuation.${metric}`,
-  period: "annual", timestampMode: "available-at" });
-const fixture = (): TickerFinancials => ({ financialCurrency: "USD",
-  quote: { symbol: "TEST", currency: "USD", price: 60, change: 0, changePercent: 0,
-    lastUpdated: Date.parse("2026-09-11T20:00:00Z") },
-  annualStatements: [{ date: "2025-12-31", availableAt: "2026-09-10T14:00:00Z", currency: "USD",
-    eps: 10, totalRevenue: 100, dilutedShares: 10, totalDebt: 20, cashAndCashEquivalents: 5,
-    ebitda: 30, freeCashFlow: 20 }], quarterlyStatements: [],
-  priceHistory: [{ date: new Date("2026-09-09"), close: 50 },
-    { date: new Date("2026-09-10T13:30:00Z"), open: 54, high: 56, low: 53, close: 55 }],
-});
-const fields = ["trailingPE", "priceSales", "evSales", "evEbitda", "priceFcf"];
-
-test("stale quote-derived Current multiples are withheld while historical ratios and input evidence survive", () => {
-  const data = fixture();
-  const history = fields.map((field) => extractFundamentalSeries(data, source(field))[0]);
-  data.quote!.stale = true;
-  const original = JSON.stringify(data);
-  fields.forEach((field, index) => {
-    expect(extractFundamentalSeries(data, source(field))).toEqual([history[index]!]);
-    expect(valuationPriceIssues(data, source(field))).toEqual([expect.objectContaining({ kind: "quote", reason: "stale",
-      quote: expect.objectContaining({ price: 60, lastUpdated: data.quote!.lastUpdated, stale: true }) })]);
-  });
-  expect(JSON.stringify(data)).toBe(original);
-  data.quote!.stale = false;
-  for (const field of fields) expect(extractFundamentalSeries(data, source(field)).at(-1)?.periodLabel).toBe("Current");
-});
-
-test("invalid current quote price or timestamp never borrows the historical close", () => {
-  for (const patch of [{ price: NaN }, { price: Infinity }, { price: 0 }, { price: -1 },
-    { lastUpdated: NaN }, { lastUpdated: 0 }, { lastUpdated: -1 }, { lastUpdated: 9e20 }]) {
-    const data = fixture(); Object.assign(data.quote!, patch);
-    const points = extractFundamentalSeries(data, source());
-    expect(points.map((point) => point.value)).toEqual([5.5]);
-    expect(points.some((point) => point.periodLabel === "Current")).toBe(false);
-    expect(valuationPriceIssues(data, source())[0]?.kind).toBe("quote");
-  }
-  const afterHours = fixture(); Object.assign(afterHours.quote!, { high: 58, low: 53, price: 60 });
-  expect(extractFundamentalSeries(afterHours, source()).at(-1)?.value).toBe(6);
-  expect(valuationPriceIssues(afterHours, source())).toEqual([]);
-});
-
-test("a latest contradictory historical bar leaves a diagnostic gap instead of using its close or an older bar", () => {
-  const data = fixture(); data.quote!.stale = true;
-  data.priceHistory[1]!.open = 70;
-  const original = JSON.stringify(data.priceHistory);
-  for (const field of fields) {
-    const points = extractFundamentalSeries(data, source(field));
-    expect(points).toHaveLength(1);
-    expect(points[0]?.value).toBeNull();
-    expect(points[0]?.observedAt.toISOString()).toBe("2025-12-31T00:00:00.000Z");
-    expect(points[0]?.provenance?.priceHistoryIntegrity?.sourcePoints[0]).toMatchObject({ open: 70, high: 56, close: 55 });
-  }
-  expect(JSON.stringify(data.priceHistory)).toBe(original);
-  // A valid close-only row at the same time cannot erase contradictory evidence.
-  data.priceHistory.push({ date: data.priceHistory[1]!.date, close: 55 });
-  expect(extractFundamentalSeries(data, source())[0]?.value).toBeNull();
-  data.priceHistory.reverse();
-  expect(extractFundamentalSeries(data, source())[0]?.value).toBeNull();
-  // A genuinely newer valid observation before availability restores the ratio.
-  data.priceHistory.push({ date: new Date("2026-09-10T13:45:00Z"), close: 57 });
-  expect(extractFundamentalSeries(data, source())[0]?.value).toBe(5.7);
-  // Removing the corrupt source through a corrected input also restores it.
-  data.priceHistory = [{ date: new Date("2026-09-10T13:30:00Z"), close: 55 }];
-  expect(extractFundamentalSeries(data, source())[0]?.value).toBe(5.5);
-});
-
-test("later corruption and invalid dates cannot change an earlier valuation; serialized history remains supported", () => {
-  const data = fixture(); data.quote!.stale = true;
-  data.priceHistory.push({ date: new Date("2026-09-11"), open: 100, high: 56, low: 50, close: 55 });
-  data.priceHistory.push({ date: null as unknown as Date, close: 99 });
-  data.priceHistory = JSON.parse(JSON.stringify(data.priceHistory));
-  expect(extractFundamentalSeries(data, source())[0]?.value).toBe(5.5);
-  expect(extractFundamentalSeries(data, source())[0]?.provenance?.priceHistoryIntegrity).toBeUndefined();
-});
-
-test("an unusable latest historical close does not silently fall back to an older quote", () => {
-  for (const close of [0, -5, NaN, Infinity]) {
-    const data = fixture(); data.quote = undefined;
-    // Keep declared price units through a metadata-only quote.
-    data.quote = { ...fixture().quote!, lastUpdated: 0 };
-    data.priceHistory = [{ date: new Date("2026-09-09"), close: 50 },
-      { date: new Date("2026-09-10"), close }];
-    expect(extractFundamentalSeries(data, source())[0]?.value).toBeNull();
-    expect(valuationPriceIssues(data, source())).toEqual(expect.arrayContaining([
-      expect.objectContaining({ kind: "history", reason: "invalid-price" }),
-    ]));
-  }
-});
-
-async function load(data: TickerFinancials, viewport: Partial<ChartSpec["viewport"]> = {}, studies: ChartSpec["studies"] = []) {
-  const spec: ChartSpec = { version: CHART_SPEC_VERSION, viewport: { range: "5Y", resolution: "1d", ...viewport },
-    panels: [{ id: "main" }], studies, series: [{ id: "pe", source: source(), style: "line",
-      transform: "raw", axis: "left", panelId: "main", interpolation: "none" }] };
-  return loadChartPaneModel(spec, { marketData: createTestDataProvider({ getTickerFinancials: async () => data,
-    getPriceHistoryForResolution: async () => data.priceHistory, getQuote: async () => data.quote! }),
-    config: createDefaultConfig("/tmp/valuation-price-test"), apiClient: {} as any, signal: new AbortController().signal });
-}
-
-test("actual resolver/export retain stale-source diagnostics and historical values, then recover on a fresh quote", async () => {
-  const data = fixture(); data.quote!.stale = true;
-  const model = await load(data);
-  expect(model.series[0]?.points.map((point) => point.value)).toEqual([5.5]);
-  expect(model.complete).toBe(false);
-  expect(model.metadata?.warnings).toEqual(expect.arrayContaining([expect.stringContaining("source quote is stale")]));
-  expect(model.metadata?.valuationPriceIssues).toEqual([expect.objectContaining({ seriesId: "pe", issues: [
-    expect.objectContaining({ reason: "stale", quote: expect.objectContaining({ price: 60, lastUpdated: data.quote!.lastUpdated, stale: true }) }),
-  ] })]);
-  expect(model.snapshot.financials[0]?.[1].quote?.stale).toBe(true);
-  data.quote!.stale = false;
-  const recovered = await load(data);
-  expect(recovered.series[0]?.points.at(-1)?.value).toBe(6);
-  expect(recovered.metadata?.valuationPriceIssues).toBeUndefined();
-  expect(recovered.complete).not.toBe(false);
-});
-
-test("future Current quote times retain invalid-time provenance without changing historical multiples", async () => {
-  const now = Date.parse("2026-09-12T04:00:00Z");
-  const clock = spyOn(Date, "now").mockReturnValue(now);
-  const data = fixture();
-  const future = now + 86_400_000;
-  data.quote!.lastUpdated = future;
-  const original = JSON.stringify(data);
-  try {
-    for (const field of fields) {
-      expect(extractFundamentalSeries(data, source(field)).some(point => point.periodLabel === "Current")).toBe(false);
-      expect(valuationPriceIssues(data, source(field))).toEqual([expect.objectContaining({ reason: "invalid-timestamp", quote: expect.objectContaining({ lastUpdated: future, price: 60 }) })]);
-    }
-    const model = await load(data);
-    expect(model.series[0]?.points.map(point => point.value)).toEqual([5.5]);
-    expect(model.complete).toBe(false);
-    expect(model.metadata?.warnings).toEqual(expect.arrayContaining([expect.stringContaining("source quote timestamp is unavailable")]));
-    expect(model.metadata?.valuationPriceIssues).toEqual([expect.objectContaining({ issues: [expect.objectContaining({ reason: "invalid-timestamp", quote: expect.objectContaining({ lastUpdated: future }) })] })]);
-    expect(JSON.stringify(data)).toBe(original);
-    for (const viewport of [{ dateWindow: { start: "2026-09-10T13:00:00Z", end: "2026-09-10T20:00:00Z" } }, { maxPoints: 1 }]) {
-      const historical = await load(data, viewport);
-      expect(historical.complete).not.toBe(false);
-      expect(historical.metadata?.valuationPriceIssues).toBeUndefined();
-    }
-    data.quote!.lastUpdated = now - 60_000;
-    const recovered = await load(data);
-    expect(recovered.series[0]?.points.at(-1)).toMatchObject({ periodLabel: "Current", value: 6 });
-    expect(recovered.metadata?.valuationPriceIssues).toBeUndefined();
-    expect(recovered.complete).not.toBe(false);
-  } finally { clock.mockRestore(); }
-});
-
-test("actual resolver/export count a null corrupt valuation as unavailable and retain the original candle", async () => {
-  const data = fixture(); data.quote!.stale = true; data.priceHistory[1]!.open = 70;
-  const model = await load(data);
-  expect(model.complete).toBe(false);
-  expect(model.unavailableSymbols).toEqual(["TEST:XNYS"]);
-  expect(model.metadata?.priceHistoryIntegrity).toEqual(expect.arrayContaining([
-    expect.objectContaining({ seriesId: "pe", integrity: expect.objectContaining({ sourcePoints: [expect.objectContaining({ open: 70, high: 56 })] }) }),
-  ]));
-  expect(model.metadata?.summaries).toEqual(expect.arrayContaining([expect.objectContaining({ endValue: null })]));
-  expect(model.metadata?.warnings).toEqual(expect.arrayContaining([expect.stringContaining("inconsistent OHLC")]));
-});
-
-test("historical date windows and period limits do not inherit excluded current or older price failures", async () => {
-  const data = fixture(); data.quote!.stale = true;
-  for (const viewport of [{ dateWindow: { start: "2026-09-10T13:00:00Z", end: "2026-09-10T20:00:00Z" } }, { maxPoints: 1 }]) {
-    const model = await load(data, viewport);
-    expect(model.series[0]?.points.map((point) => point.value)).toEqual([5.5]);
-    expect(model.complete).not.toBe(false);
-    expect(model.metadata?.valuationPriceIssues).toBeUndefined();
-    expect(model.chart.warnings.some((warning) => warning.includes("source quote"))).toBe(false);
-  }
-  data.annualStatements.unshift({ ...data.annualStatements[0]!, date: "2024-12-31", availableAt: "2025-03-01" });
-  data.priceHistory.unshift({ date: new Date("2025-02-28"), close: 0 });
-  const limited = await load(data, { maxPoints: 1 });
-  expect(limited.series[0]?.points.map((point) => point.value)).toEqual([5.5]);
-  expect(limited.complete).toBe(true);
-  expect(limited.metadata?.valuationPriceIssues).toBeUndefined();
-  data.quote!.lastUpdated = NaN;
-  expect((await load(data, { dateWindow: { start: "2026-09-10T13:00:00Z", end: "2026-09-10T20:00:00Z" } })).complete).not.toBe(false);
-});
-
-test("all-missing requested periods retain their price evidence and remain unavailable", async () => {
-  const data = fixture(); data.quote!.stale = true; data.priceHistory[1]!.open = 70;
-  const model = await load(data, { maxPoints: 1 });
-  expect(model.series[0]?.points.map((point) => point.value)).toEqual([null]);
-  expect(model.complete).toBe(false);
-  expect(model.unavailableSymbols).toEqual(["TEST:XNYS"]);
-  expect(model.metadata?.priceHistoryIntegrity).toEqual(expect.arrayContaining([
-    expect.objectContaining({ integrity: expect.objectContaining({ sourcePoints: [expect.objectContaining({ open: 70 })] }) }),
-  ]));
-  expect(model.metadata?.valuationPriceIssues).toBeUndefined(); // Current was not requested.
-});
-
-test("invalid non-OHLC prices interrupt studies and retain the reason during later warmup", async () => {
-  const data = fixture(); data.quote!.stale = true;
-  data.annualStatements = [2023, 2024, 2025, 2026].map((year) => ({ date: `${year}-12-31`, availableAt: `${year + 1}-03-01`, currency: "USD", eps: 10 }));
-  data.priceHistory = [50, 0, 70, 80].map((close, index) => ({ date: new Date(`${2024 + index}-03-01`), close }));
-  const points = extractFundamentalSeries(data, source());
-  expect(points.map((point) => point.value)).toEqual([5, null, 7, 8]);
-  const study: ChartSpec["studies"][number] = { id: "sma", kind: "sma", inputSeriesIds: ["pe"], parameters: { period: 2 }, panelId: "main", axis: "left" };
-  const outputs = resolveStudies([{ id: "pe", label: "P/E", color: "#fff", unit: "x", unitGroup: "ratio", nativeFrequency: "annual",
-    dataShape: "scalar", style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none", points }], [study]);
-  expect(outputs.series[0]?.points.map((point) => point.value)).toEqual([null, null, 7.5]);
-  const warmup = await load(data, { dateWindow: { start: "2026-03-01", end: "2026-03-02" } }, [study]);
-  expect(warmup.series.find((entry) => entry.id === "sma")?.points[0]?.value).toBeNull();
-  expect(warmup.complete).toBe(false);
-  expect(warmup.metadata?.valuationPriceIssues).toEqual(expect.arrayContaining([
-    expect.objectContaining({ seriesId: "sma", issues: [expect.objectContaining({ kind: "history", reason: "invalid-price", point: expect.objectContaining({ close: 0 }) })] }),
-  ]));
-  expect(warmup.chart.warnings.some((warning) => warning.includes("Historical valuation unavailable"))).toBe(true);
-  expect(warmup.chart.warnings.some((warning) => warning.includes("inconsistent OHLC"))).toBe(false);
-});
-
-test.each(["NaN", "future"] as const)("actual live quote status and %s timestamp recovery recompute Current valuations", async invalidKind => {
-  const data = fixture();
-  const spec: ChartSpec = { version: CHART_SPEC_VERSION, viewport: { range: "5Y", resolution: "1d" }, panels: [{ id: "main" }],
-    studies: [], series: [{ id: "pe", source: source(), style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none" }] };
-  const provider = createTestDataProvider({ getTickerFinancials: async () => data, getQuote: async () => data.quote!,
-    getPriceHistoryForResolution: async () => data.priceHistory });
-  const store = createQuoteStoreFixture();
-  const target = getLiveChartQuoteTargets(spec)[0]!;
-  const emit = store.emit;
-  const results: Awaited<ReturnType<typeof resolveChartSpecData>>[] = [];
-  const pending: Promise<unknown>[] = [];
-  const stop = observeLiveChartQuotes({ spec, store, onChange: (quoteOverrides) => {
-    pending.push(resolveChartSpecData(spec, { dataProvider: provider,
-      now: new Date("2026-09-12"), quoteOverrides }).then((result) => results.push(result)));
-  } });
-  async function waitForCount(count: number) {
-    await Promise.all(pending);
-    expect(results).toHaveLength(count);
-  }
-  const valid = { ...data.quote!, stale: false };
-  try {
-    emit(target, { ...valid, lastUpdated: invalidKind === "NaN" ? NaN : Date.now() + 86_400_000, receivedAt: 1 });
-    await waitForCount(1);
-    // A valid timestamp must dislodge the malformed prior stream observation.
-    emit(target, { ...valid, receivedAt: 2 });
-    await waitForCount(2);
-    expect(results.at(-1)?.series[0]?.points.at(-1)?.value).toBe(6);
-    emit(target, { ...valid, stale: true, receivedAt: 3 });
-    await waitForCount(3);
-    expect(results.at(-1)?.series[0]?.points.map((point) => point.value)).toEqual([5.5]);
-    expect(results.at(-1)?.warnings.some((warning) => warning.includes("source quote is stale"))).toBe(true);
-    emit(target, { ...valid, stale: false, receivedAt: 4 });
-    await waitForCount(4);
-    expect(results.at(-1)?.series[0]?.points.at(-1)?.value).toBe(6);
-    expect(results.at(-1)?.warnings.some((warning) => warning.includes("source quote is stale"))).toBe(false);
-  } finally { stop(); }
-  for (const invalid of [NaN, Infinity, 0, -1, 9e20, Date.now() + 86_400_000]) {
-    data.quote!.lastUpdated = invalid;
-    const recovered = await resolveChartSpecData(spec, { dataProvider: provider, now: new Date("2026-09-12"),
-      quoteOverrides: new Map([[chartQuoteOverrideKeyForSource(source()), valid]]) });
-    expect(recovered.series[0]?.points.at(-1)?.value).toBe(6);
-    expect(recovered.series[0]?.valuationPriceIssues).toBeUndefined();
-  }
-});

package/src/types/config.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  createPaneInstance,
-  findPaneInstance,
-  findPrimaryPaneInstance,
-  materializeDetachedPanesAsFloating,
-  resolveFollowBindingInstance,
-  resolvePaneInstance,
-  type LayoutConfig,
-  type PaneInstanceConfig,
-} from "./config";
-
-function createLayout(instances: PaneInstanceConfig[]): LayoutConfig {
-  return {
-    dockRoot: null,
-    instances,
-    floating: [],
-    detached: [],
-  };
-}
-
-describe("findPaneInstance", () => {
-  // The lookup caches an index per instances array. In-place edits, which the
-  // screenshot CLI and chart settings still do, must not serve stale hits.
-  test("survives in-place replacement and removal in the same array", () => {
-    const first = createPaneInstance("ticker-detail", { instanceId: "ticker-detail:a" });
-    const second = createPaneInstance("ticker-detail", { instanceId: "ticker-detail:b" });
-    const layout = createLayout([first, second]);
-
-    expect(findPaneInstance(layout, "ticker-detail:b")).toBe(second);
-
-    const replacement = createPaneInstance("ticker-detail", { instanceId: "ticker-detail:c" });
-    layout.instances[1] = replacement;
-    expect(findPaneInstance(layout, "ticker-detail:b")).toBeUndefined();
-    expect(findPaneInstance(layout, "ticker-detail:c")).toBe(replacement);
-
-    layout.instances.splice(0, 1);
-    expect(findPaneInstance(layout, "ticker-detail:a")).toBeUndefined();
-    expect(findPaneInstance(layout, "ticker-detail:c")).toBe(replacement);
-
-    layout.instances.push(first);
-    expect(findPaneInstance(layout, "ticker-detail:a")).toBe(first);
-  });
-
-  test("returns the first instance when an id is duplicated", () => {
-    const first = createPaneInstance("chat", { instanceId: "chat:main" });
-    const duplicate = createPaneInstance("chat", { instanceId: "chat:main" });
-    expect(findPaneInstance(createLayout([first, duplicate]), "chat:main")).toBe(first);
-  });
-});
-
-describe("findPrimaryPaneInstance", () => {
-  test("prefers the main non-fixed ticker pane", () => {
-    const layout = createLayout([
-      createPaneInstance("portfolio-list", {
-        instanceId: "portfolio-list:main",
-        binding: { kind: "none" },
-      }),
-      createPaneInstance("ticker-detail", {
-        instanceId: "ticker-detail:pinned",
-        binding: { kind: "fixed", symbol: "AAPL" },
-      }),
-      createPaneInstance("ticker-detail", {
-        instanceId: "ticker-detail:main",
-        binding: { kind: "follow", sourceInstanceId: "portfolio-list:main" },
-      }),
-    ]);
-
-    expect(findPrimaryPaneInstance(layout, "ticker-detail")?.instanceId).toBe("ticker-detail:main");
-  });
-
-  test("does not treat fixed ticker panes as the primary pane", () => {
-    const layout = createLayout([
-      createPaneInstance("ticker-detail", {
-        instanceId: "ticker-detail:aapl",
-        binding: { kind: "fixed", symbol: "AAPL" },
-      }),
-      createPaneInstance("ticker-detail", {
-        instanceId: "ticker-detail:msft",
-        binding: { kind: "fixed", symbol: "MSFT" },
-      }),
-    ]);
-
-    expect(findPrimaryPaneInstance(layout, "ticker-detail")).toBeUndefined();
-  });
-});
-
-describe("resolvePaneInstance", () => {
-  test("accepts either an instance id or a pane id", () => {
-    const layout = createLayout([
-      createPaneInstance("portfolio-list", {
-        instanceId: "portfolio-list:main",
-        binding: { kind: "none" },
-      }),
-    ]);
-
-    expect(resolvePaneInstance(layout, "portfolio-list:main")?.instanceId).toBe("portfolio-list:main");
-    expect(resolvePaneInstance(layout, "portfolio-list")?.instanceId).toBe("portfolio-list:main");
-  });
-});
-
-describe("resolveFollowBindingInstance", () => {
-  test("walks follow bindings until it finds a matching pane", () => {
-    const layout = createLayout([
-      createPaneInstance("portfolio-list", {
-        instanceId: "portfolio-list:main",
-        binding: { kind: "none" },
-      }),
-      createPaneInstance("ticker-detail", {
-        instanceId: "ticker-detail:main",
-        binding: { kind: "follow", sourceInstanceId: "portfolio-list:main" },
-      }),
-      createPaneInstance("quote-monitor", {
-        instanceId: "quote-monitor:main",
-        binding: { kind: "follow", sourceInstanceId: "ticker-detail:main" },
-      }),
-    ]);
-
-    expect(
-      resolveFollowBindingInstance(layout, "quote-monitor:main", (instance) => instance.paneId === "portfolio-list")?.instanceId,
-    ).toBe("portfolio-list:main");
-  });
-
-  test("stops on follow cycles", () => {
-    const layout = createLayout([
-      createPaneInstance("ticker-detail", {
-        instanceId: "ticker-detail:first",
-        binding: { kind: "follow", sourceInstanceId: "quote-monitor:first" },
-      }),
-      createPaneInstance("quote-monitor", {
-        instanceId: "quote-monitor:first",
-        binding: { kind: "follow", sourceInstanceId: "ticker-detail:first" },
-      }),
-    ]);
-
-    expect(
-      resolveFollowBindingInstance(layout, "ticker-detail:first", (instance) => instance.paneId === "portfolio-list"),
-    ).toBeUndefined();
-  });
-});
-
-describe("materializeDetachedPanesAsFloating", () => {
-  test("degrades detached panes into floating panes for non-desktop renderers", () => {
-    const layout = createLayout([
-      createPaneInstance("chat", {
-        instanceId: "chat:main",
-        binding: { kind: "none" },
-      }),
-    ]);
-    layout.detached = [
-      { instanceId: "chat:main", x: 14, y: 6, width: 48, height: 18 },
-    ];
-
-    const next = materializeDetachedPanesAsFloating(layout);
-
-    expect(next.detached).toEqual([]);
-    expect(next.floating).toEqual([
-      { instanceId: "chat:main", x: 14, y: 6, width: 48, height: 18 },
-    ]);
-  });
-});

package/src/ui/context-menu.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { PluginRegistry } from "../plugins/registry";
-import type { ContextMenuItem } from "../types/context-menu";
-import type { TickerRecord } from "../types/ticker";
-import {
-  editableTextContextMenuItems,
-  linkContextMenuItems,
-  tickerContextMenuItems,
-} from "./context-menu";
-
-function ticker(overrides: Partial<TickerRecord["metadata"]> = {}): TickerRecord {
-  return {
-    metadata: {
-      ticker: "AAPL",
-      exchange: "NASDAQ",
-      currency: "USD",
-      name: "Apple",
-      portfolios: [],
-      watchlists: [],
-      positions: [],
-      custom: {},
-      tags: [],
-      ...overrides,
-    },
-  };
-}
-
-function menuLabels(items: ContextMenuItem[]): string[] {
-  return items.flatMap((item) => item.type === "divider" ? [] : [item.label ?? ""]);
-}
-
-describe("context menu item builders", () => {
-  test("editable text menu returns native edit roles", () => {
-    expect(editableTextContextMenuItems().map((item) => item.type === "role" ? item.role : "divider")).toEqual([
-      "undo",
-      "redo",
-      "divider",
-      "cut",
-      "copy",
-      "paste",
-      "divider",
-      "selectAll",
-    ]);
-  });
-
-  test("link menu includes open and copy actions", () => {
-    const labels = menuLabels(linkContextMenuItems({
-      url: "https://example.com",
-      open: () => {},
-      copy: () => {},
-    }));
-
-    expect(labels).toEqual(["Open Link", "Copy Link"]);
-  });
-
-  test("ticker menu includes plugin ticker actions and hides remove actions without memberships", () => {
-    const registry = {
-      getEnabledTickerActions() { return [...this.tickerActions.values()]; },
-    tickerActions: new Map([
-        ["alert", {
-          id: "alert",
-          label: "Set Alert",
-          execute: () => {},
-        }],
-      ]),
-      navigateTicker: () => {},
-      pinTicker: () => {},
-      openCommandBar: () => {},
-    } as unknown as PluginRegistry;
-
-    const labels = menuLabels(tickerContextMenuItems({
-      ticker: ticker(),
-      financials: null,
-      registry,
-      copyText: async () => {},
-    }));
-
-    expect(labels).toContain("Set Alert");
-    expect(labels).toContain("Add to Watchlist...");
-    expect(labels).not.toContain("Remove from Watchlist...");
-    expect(labels).not.toContain("Remove from Portfolio...");
-  });
-
-  test("ticker menu includes remove actions when memberships exist", () => {
-    const labels = menuLabels(tickerContextMenuItems({
-      ticker: ticker({ watchlists: ["watchlist:tech"], portfolios: ["portfolio:main"] }),
-      financials: null,
-      registry: null,
-      copyText: async () => {},
-    }));
-
-    expect(labels).toContain("Remove from Watchlist...");
-    expect(labels).toContain("Remove from Portfolio...");
-  });
-});

package/src/ui/qr.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { renderQrLines, renderQrSvgDataUri } from "./qr";
-
-// "test" fits a version 1 QR (21 modules); plus the 4-module quiet zone on
-// each side that is 29 columns and ceil(29 / 2) = 15 half-block lines.
-const SMALL_INPUT = "test";
-const SMALL_SIZE = 21 + 8;
-
-describe("renderQrLines", () => {
-  test("produces a square code with two module rows per line", () => {
-    const lines = renderQrLines(SMALL_INPUT);
-    expect(lines).toHaveLength(Math.ceil(SMALL_SIZE / 2));
-    for (const line of lines) {
-      expect(line).toHaveLength(SMALL_SIZE);
-      expect(line).toMatch(/^[ \u2580\u2584\u2588]+$/);
-    }
-  });
-
-  test("includes the 4-module quiet zone on every side", () => {
-    const lines = renderQrLines(SMALL_INPUT);
-    // 4 quiet rows = the first 2 lines; the bottom edge also pads the odd row.
-    expect(lines[0]).toBe(" ".repeat(SMALL_SIZE));
-    expect(lines[1]).toBe(" ".repeat(SMALL_SIZE));
-    expect(lines[13]).toBe(" ".repeat(SMALL_SIZE));
-    expect(lines[14]).toBe(" ".repeat(SMALL_SIZE));
-    for (const line of lines) {
-      expect(line.startsWith("    ")).toBe(true);
-      expect(line.endsWith("    ")).toBe(true);
-    }
-  });
-
-  test("pads the dangling bottom row light when the height is odd", () => {
-    // 29 rows means the last line only has a top half; it must never show a
-    // bottom-half or full block, or the code gains a phantom module row.
-    const lastDataLine = renderQrLines(SMALL_INPUT)[12]!;
-    expect(lastDataLine).toMatch(/^[ \u2580]+$/);
-  });
-
-  test("merges dark runs into rects that cover exactly the dark modules", () => {
-    const svg = decodeURIComponent(
-      renderQrSvgDataUri(SMALL_INPUT).slice('url("data:image/svg+xml,'.length, -2),
-    );
-    expect(svg).toContain(`viewBox="0 0 ${SMALL_SIZE} ${SMALL_SIZE}"`);
-
-    // The half-block lines carry the same grid, so counting dark halves there is
-    // an independent check that run merging did not drop or widen a module.
-    const darkModules = renderQrLines(SMALL_INPUT)
-      .join("")
-      .split("")
-      .reduce((total, char) => total + (char === "\u2588" ? 2 : char === " " ? 0 : 1), 0);
-    const darkArea = [...svg.matchAll(/<rect x="\d+" y="\d+" width="(\d+)" height="1"\/>/g)]
-      .reduce((total, match) => total + Number(match[1]), 0);
-    expect(darkArea).toBe(darkModules);
-  });
-
-  test("renders a verification URI to known stable output", () => {
-    expect(renderQrLines("https://gloom.sh/link/TEST-CODE")).toEqual([
-      "                                     ",
-      "                                     ",
-      "    █▀▀▀▀▀█  ▄▀▀█ ▀ ▄▄▄ ▄ █▀▀▀▀▀█    ",
-      "    █ ███ █  ▄███▄▀▀▄██▀▀ █ ███ █    ",
-      "    █ ▀▀▀ █ ▄▄ ▀█  ▄▄ █▄▀ █ ▀▀▀ █    ",
-      "    ▀▀▀▀▀▀▀ ▀ ▀ ▀▄▀▄█▄█▄▀ ▀▀▀▀▀▀▀    ",
-      "    ▀▄▄█ ▀▀▄▀█ ▀ ▄▀▄██▄▀▄█▄▀ ▄  ▄    ",
-      "    ▀▀▄ ▄ ▀█▄▀▄  █▀▀▄▀█▀▀▀▀█▄▀██     ",
-      "     █▀██▄▀  ▄ ▀█▄██▄▄▄██▄▀  ▀ ▀▀    ",
-      "    ▀▀█▀▄█▀▄ ▀█▄█▀▀▄ █ ▄▀█▄ ▄█▀█▀    ",
-      "      ██ ▄▀█▀▄ ███▄▄▄█▀ ▀▀▄▄ ▄ ▀▄    ",
-      "    ▀ █ ▀ ▀▀▀▀▄█▄ █▀▀▄▄ █ ▀ █  ██    ",
-      "    ▀   ▀ ▀ ▄ █ ▀ ▄█▀█ ██▀▀▀█ █▄▄    ",
-      "    █▀▀▀▀▀█ ▄█ █▀ ▄▄█▀█ █ ▀ █▄▄▀▄    ",
-      "    █ ███ █ ▄▀ ▄▄  ▄▀  ▄█▀███▄▄▀▄    ",
-      "    █ ▀▀▀ █   █▄▀▄█▄█▄▄██▄▄ █▀▀▄▀    ",
-      "    ▀▀▀▀▀▀▀ ▀▀  ▀      ▀▀  ▀▀▀ ▀     ",
-      "                                     ",
-      "                                     ",
-    ]);
-  });
-});

package/src/updater/github-releases.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { normalizeChangelogRelease } from "./github-releases";
-
-describe("normalizeChangelogRelease", () => {
-  test("maps a GitHub release into changelog row fields", () => {
-    const release = normalizeChangelogRelease({
-      id: 75,
-      tag_name: "v0.7.5",
-      name: "v0.7.5 - Crash recovery and ticker opens",
-      published_at: "2026-05-14T23:27:47Z",
-      body: "## Highlights\n\n- Fixed startup recovery.",
-      html_url: "https://github.com/gloom-sh/gloomberb/releases/tag/v0.7.5",
-    });
-
-    expect(release).toEqual({
-      id: "75",
-      tagName: "v0.7.5",
-      version: "v0.7.5",
-      title: "Crash recovery and ticker opens",
-      publishedAt: "2026-05-14T23:27:47Z",
-      body: "## Highlights\n\n- Fixed startup recovery.",
-      url: "https://github.com/gloom-sh/gloomberb/releases/tag/v0.7.5",
-    });
-  });
-
-  test("falls back to the tag page and a default body", () => {
-    const release = normalizeChangelogRelease({
-      tag_name: "v1.0.0",
-      name: "v1.0.0",
-    });
-
-    expect(release?.id).toBe("v1.0.0");
-    expect(release?.title).toBe("v1.0.0");
-    expect(release?.body).toBe("No changelog details were published for this release.");
-    expect(release?.url).toBe("https://github.com/gloom-sh/gloomberb/releases/tag/v1.0.0");
-  });
-
-  test("drops malformed releases without a tag", () => {
-    expect(normalizeChangelogRelease({ name: "Missing tag" })).toBeNull();
-  });
-});