gloomberb 0.15.2 → 0.15.3

package/src/components/chart/static/multi-line-chart-surface.tsx

@@ -1,105 +0,0 @@
-import { useCallback, useMemo } from "react";
-import { Box, Text } from "../../../ui";
-import { colors } from "../../../theme/colors";
-import { CompositeChart } from "../composite/composite-chart";
-import { scalarPoint, staticSeries } from "./series";
-
-export interface MultiLineChartSeries {
-  id: string;
-  label: string;
-  color: string;
-  points: Array<{ date: Date; value: number | null }>;
-}
-
-interface MultiLineChartColors {
-  bgColor: string;
-  gridColor: string;
-  axisColor: string;
-  crosshairColor: string;
-}
-
-export interface StaticMultiLineChartSurfaceProps {
-  series: MultiLineChartSeries[];
-  width: number;
-  height: number;
-  colors?: MultiLineChartColors;
-  cursorDate?: Date | null;
-  showTimeAxis?: boolean;
-  timeAxisColor?: string;
-  yAxisLabel?: string;
-  yAxisColor?: string;
-  formatYAxisValue?: (value: number) => string;
-  onCursorDateChange?: (date: Date) => void;
-  /** Left/Right step the cursor through the observations, as the pointer's hover does. */
-  focused?: boolean;
-}
-
-const PANELS = [{ id: "main" }];
-
-export function StaticMultiLineChartSurface({
-  series,
-  width,
-  height,
-  colors: chartColors = {
-    bgColor: colors.bg,
-    gridColor: colors.border,
-    axisColor: colors.textDim,
-    crosshairColor: colors.borderFocused,
-  },
-  cursorDate = null,
-  showTimeAxis = false,
-  timeAxisColor = colors.textDim,
-  yAxisLabel,
-  yAxisColor = colors.textDim,
-  formatYAxisValue,
-  onCursorDateChange,
-  focused = false,
-}: StaticMultiLineChartSurfaceProps) {
-  const totalWidth = Math.max(1, Math.floor(width));
-  const totalHeight = Math.max(1, Math.floor(height));
-  const labelRows = yAxisLabel ? 1 : 0;
-  const resolved = useMemo(() => series.map((entry) => staticSeries(
-    entry.points.map((point) => scalarPoint(point.date, point.value)),
-    { id: entry.id, label: entry.label, color: entry.color },
-  )), [series]);
-  const compositeColors = useMemo(() => ({
-    background: chartColors.bgColor,
-    grid: chartColors.gridColor,
-    crosshair: chartColors.crosshairColor,
-    text: chartColors.axisColor,
-    textDim: yAxisColor ?? timeAxisColor ?? chartColors.axisColor,
-    negative: colors.negative,
-  }), [chartColors, timeAxisColor, yAxisColor]);
-  const formatAxisValue = useMemo(
-    () => formatYAxisValue ? (value: number) => formatYAxisValue(value) : undefined,
-    [formatYAxisValue],
-  );
-  const handleCursorDateChange = useCallback((date: Date | null) => {
-    if (date) onCursorDateChange?.(date);
-  }, [onCursorDateChange]);
-
-  return (
-    <Box flexDirection="column" width={totalWidth} height={totalHeight}>
-      {yAxisLabel ? (
-        <Box height={1}>
-          <Text fg={yAxisColor}>{yAxisLabel}</Text>
-        </Box>
-      ) : null}
-      <CompositeChart
-        series={resolved}
-        panels={PANELS}
-        width={totalWidth}
-        height={Math.max(1, totalHeight - labelRows)}
-        colors={compositeColors}
-        cursorDate={cursorDate}
-        onCursorDateChange={handleCursorDateChange}
-        focused={focused}
-        navigable={false}
-        showLegend={false}
-        showTimeAxis={showTimeAxis}
-        formatAxisValue={formatAxisValue}
-        emptyMessage="No chart data"
-      />
-    </Box>
-  );
-}

package/src/components/chart/static/scatter-chart-surface.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildScatterChartModel } from "./scatter-chart-surface";
-
-const palette = {
-  bgColor: "#000000",
-  gridColor: "#333333",
-  axisColor: "#777777",
-  pointColor: "#b197fc",
-  highlightColor: "#ff0000",
-};
-
-describe("buildScatterChartModel", () => {
-  test("splits highlights, marks the zero axes, and clips the fit line to the data", () => {
-    const model = buildScatterChartModel(
-      [{ x: -2, y: -1 }, { x: 1, y: 0.5 }, { x: 2, y: 3, highlight: true }],
-      { slope: 2, intercept: 1, color: "#ffd43b" },
-      palette,
-    )!;
-    const ids = model.series.map((series) => series.id);
-    expect(ids).toEqual(["zero-y", "regression", "points", "highlight"]);
-    expect(model.markers).toEqual([{ id: "zero-x", xRatio: 0.5, color: "#777777" }]);
-
-    const fit = model.series.find((series) => series.id === "regression")!;
-    const values = fit.points.map((point) => point.value);
-    // y = 2x + 1 leaves the data's [-1, 3] range at x = -1 and x = 1.
-    expect(values).toEqual([-1, 3]);
-    expect(fit.points.map((point) => point.date.getTime() / 1_000_000)).toEqual([-1, 1]);
-    expect(model.series.find((series) => series.id === "highlight")?.points).toHaveLength(1);
-  });
-});

package/src/components/chart/static/trail-chart-model.test.ts

@@ -1,36 +0,0 @@
-import { expect, test } from "bun:test";
-import { buildTrailChart, trailAxisTicks } from "./trail-chart-model";
-
-test("scatter trails preserve backtracking and vertical edges without changing symmetric domains", () => {
-  const chart = buildTrailChart(
-    [
-      {
-        id: "loop",
-        label: "Loop",
-        color: "#ff0000",
-        points: [
-          { x: 101, y: 101, date: "2026-01-02" },
-          { x: 99, y: 102, date: "2026-01-09" },
-          { x: 99, y: 98, date: "2026-01-16" },
-          { x: 102, y: 99, date: "2026-01-23" },
-        ],
-      },
-    ],
-    100,
-    "#888888",
-  );
-  const edges = chart.series.filter((series) => series.id.includes(":edge:"));
-  expect(edges).toHaveLength(3);
-  expect(edges[0]!.points.map((point) => point.value)).toEqual([102, 101]);
-  expect(
-    edges[1]!.points[1]!.date.getTime() - edges[1]!.points[0]!.date.getTime(),
-  ).toBe(1);
-  expect((chart.min + chart.max) / 2).toBe(100);
-  expect(chart.series.at(-1)!.points[0]!.value).toBe(99);
-});
-
-test("strength axis labels sit on round values inside the domain", () => {
-  expect(trailAxisTicks(89.8, 110.2).map((tick) => tick.label)).toEqual(["95", "100", "105"]);
-  expect(trailAxisTicks(98.9, 101.1).map((tick) => tick.label)).toEqual(["99.0", "99.5", "100.0", "100.5", "101.0"]);
-  expect(trailAxisTicks(99.4, 100.6).map((tick) => tick.label)).toEqual(["99.50", "99.75", "100.00", "100.25", "100.50"]);
-});

package/src/components/chart/surface3d/model.test.ts

@@ -1,117 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  buildSurface3DScene, clampSurface3DCamera, DEFAULT_SURFACE3D_CAMERA, FLOOR, hitTestSurface3D, projectSurface3D,
-  rotateSurface3DCamera, surface3DBox, surface3DLabels, surface3DLayout, surface3DViewport, surfaceBoundaryFans, zoomSurface3DCamera,
-  type Surface3DInput,
-} from "./model";
-
-const input = (values: (number | null)[][], extra: Partial<Surface3DInput> = {}): Surface3DInput => ({
-  values,
-  columnPositions: values[0]!.map((_, index, row) => index / (row.length - 1)),
-  rowPositions: values.map((_, index) => index / (values.length - 1)),
-  zMin: 0.2, zMax: 0.5,
-  xTicks: [{ position: 0, label: "10P" }, { position: 0.5, label: "ATM" }, { position: 1, label: "10C" }],
-  yTicks: [{ position: 0, label: "7D" }, { position: 1, label: "1Y" }],
-  zTicks: [{ value: 0.2, label: "20%" }, { value: 0.3, label: "30%" }, { value: 0.4, label: "40%" }, { value: 0.5, label: "50%" }],
-  titles: { x: "DELTA", y: "EXPIRY", z: "IMPLIED VOL" },
-  ...extra,
-});
-const smooth = [[0.5, 0.4, 0.3, 0.32, 0.36], [0.42, 0.34, 0.29, 0.3, 0.33], [0.38, 0.31, 0.28, 0.29, 0.31], [0.35, 0.29, 0.26, 0.27, 0.3]];
-
-describe("scene geometry", () => {
-  test("the display lattice passes exactly through every grid node and stays within its neighbours", () => {
-    const scene = buildSurface3DScene(input(smooth), 4);
-    for (let r = 0; r < smooth.length; r += 1) for (let c = 0; c < smooth[0]!.length; c += 1) {
-      const index = (r * 4) * scene.latticeColumns + c * 4;
-      expect(scene.positions[index * 3 + 2]).toBeCloseTo(scene.worldZ(smooth[r]![c]!), 5);
-    }
-    const zs = Array.from({ length: scene.latticeRows * scene.latticeColumns }, (_, index) => scene.positions[index * 3 + 2]!);
-    expect(Math.max(...zs)).toBeLessThanOrEqual(scene.worldZ(0.5) + 1e-6);
-    expect(Math.min(...zs)).toBeGreaterThanOrEqual(scene.worldZ(0.26) - 1e-6);
-    expect(scene.indices.length).toBe((scene.latticeRows - 1) * (scene.latticeColumns - 1) * 6);
-    expect(scene.nodes).toHaveLength(20);
-    const normalLength = Math.hypot(scene.normals[0]!, scene.normals[1]!, scene.normals[2]!);
-    expect(normalLength).toBeCloseTo(1, 5);
-  });
-
-  test("holes stay open: no face spans a missing node and isolated rows remain as wire", () => {
-    const holed = smooth.map((row) => [...row]) as (number | null)[][];
-    holed[1]![2] = null;
-    const scene = buildSurface3DScene(input(holed), 2);
-    const missing = 1 * 2 * scene.latticeColumns + 2 * 2;
-    expect(Number.isNaN(scene.positions[missing * 3]!)).toBe(true);
-    expect([...scene.indices].every((index) => Number.isFinite(scene.positions[index * 3]!))).toBe(true);
-    const isolated = buildSurface3DScene(input([[0.3, 0.31, 0.32], [null, null, null], [null, null, null]]), 2);
-    expect(isolated.indices.length).toBe(0);
-    expect(isolated.wire.length).toBe(2 * 6);
-  });
-
-  test("rows of different widths join through boundary fans on existing nodes only", () => {
-    expect(surfaceBoundaryFans([[false, true, true, false], [true, true, true, true]])).toEqual([
-      [{ row: 0, column: 1 }, { row: 1, column: 0 }, { row: 1, column: 1 }],
-      [{ row: 0, column: 2 }, { row: 1, column: 2 }, { row: 1, column: 3 }],
-    ]);
-    expect(surfaceBoundaryFans([[true, false, true], [true, true, true]])).toEqual([]);
-  });
-
-  test("an ATM ridge follows the smooth surface along its column", () => {
-    const scene = buildSurface3DScene(input(smooth, { ridgeColumn: 2, ridgeLabel: "ATM" }), 3);
-    expect(scene.ridge.length).toBe((scene.latticeRows - 1) * 6);
-    expect(scene.ridge[2]).toBeCloseTo(scene.worldZ(0.3), 5);
-  });
-});
-
-describe("camera, layout and interaction", () => {
-  test("cameras clamp, wrap and zoom within bounds", () => {
-    const wrapped = clampSurface3DCamera({ azimuth: 7 * Math.PI, elevation: 9, zoom: 99 });
-    expect(Math.abs(wrapped.azimuth)).toBeCloseTo(Math.PI, 9);
-    expect(wrapped).toMatchObject({ elevation: 1.4, zoom: 2.4 });
-    expect(zoomSurface3DCamera(DEFAULT_SURFACE3D_CAMERA, 0).zoom).toBe(0.5);
-    const fallback = clampSurface3DCamera({ azimuth: Number.NaN, elevation: Number.NaN, zoom: Number.NaN });
-    expect(fallback.azimuth).toBeCloseTo(DEFAULT_SURFACE3D_CAMERA.azimuth, 9);
-    expect(fallback).toMatchObject({ elevation: DEFAULT_SURFACE3D_CAMERA.elevation, zoom: 1 });
-  });
-
-  test("the fit does not change scale while the camera turns, and every angle stays in frame", () => {
-    const scene = buildSurface3DScene(input(smooth), 2);
-    const base = surface3DViewport(800, 500, DEFAULT_SURFACE3D_CAMERA, scene.top);
-    for (let step = 0; step < 16; step += 1) {
-      const camera = rotateSurface3DCamera(DEFAULT_SURFACE3D_CAMERA, step * Math.PI / 8, 0);
-      const viewport = surface3DViewport(800, 500, camera, scene.top);
-      expect(viewport.scale).toBeCloseTo(base.scale, 9);
-      for (const node of scene.nodes) {
-        const point = projectSurface3D(node, viewport);
-        expect(point.x).toBeGreaterThan(0); expect(point.x).toBeLessThan(800);
-        expect(point.y).toBeGreaterThan(0); expect(point.y).toBeLessThan(500);
-      }
-    }
-  });
-
-  test("walls sit on the far sides and labels on the near edges as the camera turns", () => {
-    const scene = buildSurface3DScene(input(smooth), 2);
-    for (const azimuth of [-2.4, -0.7, 0.7, 2.4]) {
-      const viewport = surface3DViewport(800, 500, { azimuth, elevation: 0.6, zoom: 1 }, scene.top);
-      const layout = surface3DLayout(viewport);
-      const toViewer = (x: number, y: number) => x * viewport.sinA + y * viewport.cosA;
-      expect(toViewer(layout.farX, 0)).toBeLessThan(0);
-      expect(toViewer(0, layout.farY)).toBeLessThan(0);
-      const box = surface3DBox(scene, layout);
-      expect(box.panels).toHaveLength(3);
-      const labels = surface3DLabels(scene, viewport, layout);
-      expect(labels.filter((label) => label.key.startsWith("x:") && label.role === "tick").every((label) => Math.sign(label.world.y) === Math.sign(layout.nearY))).toBe(true);
-      // The floor-level z tick is left to the colour bar.
-      expect(labels.some((label) => label.key === "z:20%")).toBe(false);
-    }
-  });
-
-  test("hit testing returns the nearest node and prefers the nearer of two overlapping nodes", () => {
-    const scene = buildSurface3DScene(input(smooth), 2);
-    const viewport = surface3DViewport(800, 500, DEFAULT_SURFACE3D_CAMERA, scene.top);
-    const node = scene.nodes.find((point) => point.row === 2 && point.column === 3)!;
-    const at = projectSurface3D(node, viewport);
-    expect(hitTestSurface3D(scene, viewport, at.x, at.y, 2)).toEqual({ row: 2, column: 3 });
-    expect(hitTestSurface3D(scene, viewport, -500, -500)).toBeNull();
-    const floor = projectSurface3D({ ...node, z: FLOOR }, viewport);
-    expect(Number.isFinite(floor.x)).toBe(true);
-  });
-});

package/src/components/chart/surface3d/software.test.ts

@@ -1,32 +0,0 @@
-import { expect, test } from "bun:test";
-import { buildSurface3DScene, DEFAULT_SURFACE3D_CAMERA, rotateSurface3DCamera } from "./model";
-import { renderSurface3DSoftware } from "./software";
-
-const colors = { bg: "#10151e", grid: "#29323f", axis: "#8190a3", accent: "#79a7df", ridge: "#ffd27a" };
-const values = [[0.5, 0.4, 0.3, 0.32, 0.36], [0.42, 0.34, 0.29, 0.3, 0.33], [0.38, 0.31, 0.28, 0.29, 0.31], [0.35, 0.29, 0.26, 0.27, 0.3]];
-const scene = buildSurface3DScene({
-  values, columnPositions: [0, 0.25, 0.5, 0.75, 1], rowPositions: [0, 1 / 3, 2 / 3, 1], zMin: 0.2, zMax: 0.5,
-  xTicks: [{ position: 0.5, label: "ATM" }], yTicks: [{ position: 0, label: "7D" }],
-  zTicks: [{ value: 0.3, label: "30%" }], titles: { x: "DELTA", y: "EXPIRY", z: "IMPLIED VOL" },
-  ridgeColumn: 2, ridgeLabel: "ATM", selected: { row: 1, column: 2 },
-}, 3);
-
-test("the terminal raster draws a coloured, lit, deterministic surface with placed labels", () => {
-  const first = renderSurface3DSoftware(scene, 720, 440, colors, DEFAULT_SURFACE3D_CAMERA);
-  const again = renderSurface3DSoftware(scene, 720, 440, colors, DEFAULT_SURFACE3D_CAMERA);
-  expect(first.bitmap.pixels.length).toBe(720 * 440 * 4);
-  expect(Buffer.compare(first.bitmap.pixels, again.bitmap.pixels)).toBe(0);
-  const hues = new Set<string>();
-  for (let offset = 0; offset < first.bitmap.pixels.length; offset += 4) hues.add(`${first.bitmap.pixels[offset]! >> 4}:${first.bitmap.pixels[offset + 1]! >> 4}:${first.bitmap.pixels[offset + 2]! >> 4}`);
-  expect(hues.size).toBeGreaterThan(150);
-  expect(first.labels.map((label) => label.text)).toEqual(expect.arrayContaining(["ATM", "DELTA", "EXPIRY", "IMPLIED VOL", "30%"]));
-  expect(first.labels.every((label) => label.x >= 0 && label.x < 720 && label.y >= 0 && label.y < 440)).toBe(true);
-});
-
-test("draft frames keep size and differ from a rotated view; degenerate sizes stay finite", () => {
-  const draft = renderSurface3DSoftware(scene, 720, 440, colors, DEFAULT_SURFACE3D_CAMERA, { quality: "draft" });
-  expect(draft.bitmap.width).toBe(720);
-  const turned = renderSurface3DSoftware(scene, 720, 440, colors, rotateSurface3DCamera(DEFAULT_SURFACE3D_CAMERA, 0.8, 0), { quality: "draft" });
-  expect(Buffer.compare(draft.bitmap.pixels, turned.bitmap.pixels)).not.toBe(0);
-  expect(renderSurface3DSoftware(scene, Number.NaN, -10, colors, DEFAULT_SURFACE3D_CAMERA).bitmap).toMatchObject({ width: 1, height: 1 });
-});

package/src/components/command-bar/assist/inventory.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { CommandDef, PaneTemplateDef } from "../../../types/plugin";
-import type { Command } from "../commands/registry";
-import { buildAssistCommandInventory } from "./inventory";
-
-function command(overrides: Partial<Command> & { prefix: string }): Command {
-  return {
-    id: overrides.prefix.toLowerCase(),
-    label: "Command",
-    description: "A command",
-    category: "Config",
-    ...overrides,
-  };
-}
-
-function paneTemplate(overrides: Partial<PaneTemplateDef> & { id: string }): PaneTemplateDef {
-  return {
-    paneId: "pane",
-    label: "Template",
-    description: "A template",
-    ...overrides,
-  };
-}
-
-describe("buildAssistCommandInventory", () => {
-  test("maps arg placeholders onto the kinds the shortcut parser uses", () => {
-    const inventory = buildAssistCommandInventory({
-      commands: [
-        command({ prefix: "DES", aliases: ["T"], label: "Description", hasArg: true, argPlaceholder: "ticker" }),
-        command({ prefix: "HELP", label: "Help", description: "Open the help window" }),
-        command({ prefix: "LAY", label: "Layout Actions", hasArg: true, argPlaceholder: "action" }),
-      ],
-      pluginCommands: [{
-        id: "direct-message",
-        label: "DM",
-        description: "Open a DM",
-        keywords: [],
-        category: "navigation",
-        shortcut: "dm",
-        shortcutArg: { placeholder: "@username" },
-        execute: () => {},
-      }],
-      paneTemplates: [
-        paneTemplate({
-          id: "research",
-          label: "New Research Pane",
-          description: "Research view",
-          shortcut: { prefix: "RV", argPlaceholder: "tickers", argKind: "ticker-list" },
-        }),
-        paneTemplate({ id: "econ", label: "Econ", shortcut: { prefix: "ECON" } }),
-      ],
-    });
-
-    expect(inventory).toEqual([
-      { prefix: "DES", name: "Description", description: "A command", arg: { kind: "ticker", placeholder: "ticker" } },
-      { prefix: "HELP", name: "Help", description: "Open the help window" },
-      { prefix: "LAY", name: "Layout Actions", description: "A command", arg: { kind: "text", placeholder: "action" } },
-      { prefix: "DM", name: "DM", description: "Open a DM", arg: { kind: "text", placeholder: "@username" } },
-      { prefix: "RV", name: "Research", description: "Research view", arg: { kind: "ticker-list", placeholder: "tickers" } },
-      { prefix: "ECON", name: "Econ", description: "A template" },
-    ]);
-  });
-
-  test("drops prefixless commands and keeps the entry the bar would run for a duplicate prefix", () => {
-    const inventory = buildAssistCommandInventory({
-      commands: [
-        command({ prefix: "", label: "New Portfolio" }),
-        command({ prefix: "  ", label: "Reset All Data" }),
-        command({ prefix: "PL", label: "Manage Plugins" }),
-      ],
-      pluginCommands: [],
-      paneTemplates: [
-        paneTemplate({ id: "plugins-pane", label: "Plugin List", shortcut: { prefix: "pl" } }),
-      ],
-    });
-
-    expect(inventory).toEqual([
-      { prefix: "PL", name: "Manage Plugins", description: "A command" },
-    ]);
-  });
-
-  test("caps the inventory at the server limit", () => {
-    const inventory = buildAssistCommandInventory({
-      commands: Array.from({ length: 40 }, (_, index) => command({ prefix: `C${index}` })),
-      pluginCommands: [],
-      paneTemplates: [],
-      limit: 25,
-    });
-
-    expect(inventory).toHaveLength(25);
-    expect(inventory.at(-1)?.prefix).toBe("C24");
-  });
-});

package/src/components/command-bar/assist/model.test.ts

@@ -1,185 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  buildAssistResultItems,
-  formatAssistCandidateLabel,
-  isQuestionLike,
-  shouldAutoAskAssist,
-  shouldShowAssistRow,
-  type AssistRequestState,
-} from "./model";
-
-const handlers = {
-  onAsk: () => {},
-  onSignUp: () => {},
-  onRunCandidate: () => {},
-};
-
-function labels(
-  state: AssistRequestState,
-  options?: { query?: string; enabled?: boolean; auto?: boolean },
-): string[] {
-  return buildAssistResultItems({
-    ...handlers,
-    query: options?.query ?? "chart nvidia vs amd",
-    enabled: options?.enabled ?? true,
-    auto: options?.auto ?? true,
-    state,
-  }).map((item) => item.label);
-}
-
-describe("shouldAutoAskAssist", () => {
-  test("stays out of the way while the user speaks the command language", () => {
-    expect(shouldAutoAskAssist({ query: "chart nvidia vs amd", hasShortcutIntent: false })).toBe(true);
-    expect(shouldAutoAskAssist({ query: "nvda", hasShortcutIntent: false })).toBe(true);
-    // A recognized prefix — with or without an argument — is not a question.
-    expect(shouldAutoAskAssist({ query: "T NVDA", hasShortcutIntent: true })).toBe(false);
-    expect(shouldAutoAskAssist({ query: "gg", hasShortcutIntent: false })).toBe(false);
-    expect(shouldAutoAskAssist({ query: "   ", hasShortcutIntent: false })).toBe(false);
-  });
-});
-
-describe("isQuestionLike", () => {
-  test("reads a question mark or a leading question word as a question", () => {
-    expect(isQuestionLike("why is NVDA down")).toBe(true);
-    expect(isQuestionLike("chart nvidia vs amd?")).toBe(true);
-    expect(isQuestionLike("compare NVDA and AMD")).toBe(true);
-    // A single word is a prefix search, even when it reads like a question word.
-    expect(isQuestionLike("is")).toBe(false);
-    expect(isQuestionLike("chart nvidia vs amd")).toBe(false);
-    expect(isQuestionLike("  ")).toBe(false);
-  });
-});
-
-describe("shouldShowAssistRow", () => {
-  test("offers the AI on natural language, or on any dead end", () => {
-    expect(shouldShowAssistRow({ query: "chart nvidia vs amd", resultCount: 4 })).toBe(true);
-    expect(shouldShowAssistRow({ query: "zzzz", resultCount: 0 })).toBe(true);
-    expect(shouldShowAssistRow({ query: "chart", resultCount: 3 })).toBe(false);
-    expect(shouldShowAssistRow({ query: "  ", resultCount: 0 })).toBe(false);
-    // Trailing whitespace alone is not a second word.
-    expect(shouldShowAssistRow({ query: "chart ", resultCount: 3 })).toBe(false);
-  });
-});
-
-describe("buildAssistResultItems", () => {
-  test("routes signed-out users to sign up instead of the request", () => {
-    expect(labels({ status: "idle" }, { enabled: false })).toEqual(["Ask AI — sign up to enable"]);
-  });
-
-  test("renders each state of the request", () => {
-    expect(labels({ status: "idle" })).toEqual(["Thinking…"]);
-    expect(labels({ status: "idle" }, { auto: false })).toEqual([]);
-    expect(labels({ status: "loading", query: "chart nvidia vs amd", source: "auto" }))
-      .toEqual(["Thinking…"]);
-    expect(labels({ status: "answered", query: "chart nvidia vs amd", source: "auto", candidates: [] }))
-      .toEqual(["No command found — try HELP"]);
-  });
-
-  test("keeps failures silent unless the user asked for the answer", () => {
-    const failure = { status: "error", query: "chart nvidia vs amd", kind: "rate-limited" } as const;
-    expect(labels({ ...failure, source: "auto" })).toEqual([]);
-    expect(labels({ ...failure, source: "explicit" }))
-      .toEqual(["Rate limited — try again in a minute"]);
-  });
-
-  test("lays a candidate out like any other row: prefix in the badge, argument leading the label", () => {
-    expect(formatAssistCandidateLabel({ input: "DES NVDA", prefix: "DES", title: "Open security details for NVDA" }))
-      .toBe("NVDA \u00b7 Open security details");
-    expect(formatAssistCandidateLabel({ input: "G NVDA AMD", prefix: "G", title: "Chart NVDA vs AMD" }))
-      .toBe("NVDA AMD \u00b7 Chart NVDA vs AMD");
-    // No argument: the title stands alone rather than a stray separator.
-    expect(formatAssistCandidateLabel({ input: "ERN", prefix: "ERN", title: "Earnings Calendar" }))
-      .toBe("Earnings Calendar");
-    // A prefix the input does not start with is not stripped out of it.
-    expect(formatAssistCandidateLabel({ input: "show earnings", prefix: "ERN", title: "Earnings" }))
-      .toBe("show earnings \u00b7 Earnings");
-  });
-
-  test("shows candidates with the prefix as badge and runs the exact command-bar text", () => {
-    const runs: Array<[string, string | undefined]> = [];
-    const items = buildAssistResultItems({
-      ...handlers,
-      onRunCandidate: (input, prefix) => runs.push([input, prefix]),
-      query: "chart nvidia vs amd",
-      enabled: true,
-      auto: true,
-      state: {
-        status: "answered",
-        query: "chart nvidia vs amd",
-        source: "auto",
-        candidates: [{ input: "G NVDA AMD", title: "Chart NVDA vs AMD", prefix: "G", confidence: 0.9 }],
-      },
-    });
-
-    expect(items[0]?.label).toBe("NVDA AMD \u00b7 Chart NVDA vs AMD");
-    expect(items[0]?.badge).toBe("G");
-    // The marker rides the trailing column instead of shifting the label.
-    expect(items[0]?.right).toBe("✦");
-    expect(items[0]?.accent).toBe(true);
-    items[0]?.action();
-    expect(runs).toEqual([["G NVDA AMD", "G"]]);
-  });
-
-  test("offers the assistant pane for a question, without taking Enter from a command", () => {
-    const asked: string[] = [];
-    const items = buildAssistResultItems({
-      ...handlers,
-      onAskGloom: (question) => asked.push(question),
-      query: "why is NVDA down?",
-      enabled: true,
-      auto: true,
-      state: {
-        status: "answered",
-        query: "why is NVDA down?",
-        source: "auto",
-        candidates: [{ input: "DES NVDA", title: "Open security details for NVDA", prefix: "DES", confidence: 0.8 }],
-      },
-    });
-
-    expect(items.map((item) => item.label)).toEqual([
-      "NVDA \u00b7 Open security details",
-      "why is NVDA down? \u00b7 Ask Gloom",
-    ]);
-    expect(items[1]?.badge).toBe("ASKG");
-    expect(items[1]?.defaultSelectable).toBe(false);
-    items[1]?.action();
-    expect(asked).toEqual(["why is NVDA down?"]);
-  });
-
-  test("replaces the dead-end row when no command fits the query", () => {
-    const items = buildAssistResultItems({
-      ...handlers,
-      onAskGloom: () => {},
-      query: "tell me about the bond market",
-      enabled: true,
-      auto: true,
-      state: {
-        status: "answered",
-        query: "tell me about the bond market",
-        source: "auto",
-        candidates: [],
-      },
-    });
-
-    expect(items.map((item) => item.label)).toEqual(["tell me about the bond market \u00b7 Ask Gloom"]);
-    // Nothing local fits, so Enter belongs to the assistant.
-    expect(items[0]?.defaultSelectable).toBe(true);
-  });
-
-  test("leaves the row out when the assistant pane is unavailable", () => {
-    expect(labels(
-      { status: "answered", query: "why is NVDA down?", source: "auto", candidates: [] },
-      { query: "why is NVDA down?" },
-    )).toEqual(["No command found — try HELP"]);
-  });
-
-  test("ignores an answer that belongs to an earlier query", () => {
-    const state: AssistRequestState = {
-      status: "answered",
-      query: "chart nvidia",
-      source: "auto",
-      candidates: [{ input: "G NVDA", title: "Chart NVDA", prefix: "G", confidence: 0.9 }],
-    };
-    expect(labels(state, { query: "chart nvidia vs amd" })).toEqual(["Thinking…"]);
-  });
-});