gloomberb 0.9.2 → 0.9.4

package/src/cli/pane-functions/screenshot.ts

@@ -1,7 +1,7 @@
 import { dirname, resolve } from "path";
 import { mkdir } from "fs/promises";
 import type { PaneRuntimeState } from "../../core/state/app/state";
-import type { TickerFinancials } from "../../types/financials";
+import type { OptionsChain, TickerFinancials } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 import { slugifyName } from "../../utils/slugify";
 import { renderDesktopPaneScreenshot, type DesktopPaneShotPayload } from "../desktop-pane-shot";
@@ -18,6 +18,7 @@ import {
 
 const DESKTOP_CELL_WIDTH_PX = 8;
 const DESKTOP_CELL_HEIGHT_PX = 18;
+const OPTIONS_PANE_ID = "options";
 
 export function defaultScreenshotPath(resolved: ResolvedPaneFunction, rawArg: string): string {
   const suffix = slugifyName([resolved.token, rawArg].filter(Boolean).join("-"), "pane");
@@ -70,11 +71,21 @@ async function buildDesktopShotPayload(
 
   const tickers: TickerRecord[] = [];
   const financials: Array<[string, TickerFinancials]> = [];
+  const optionsChains: Array<[string, OptionsChain]> = [];
+  const includeOptionsChains = resolved.pane.id === OPTIONS_PANE_ID || resolved.template?.paneId === OPTIONS_PANE_ID;
   for (const symbol of collectShotSymbols(resolved, rawArg)) {
     const entry = await fetchTickerFinancials(context, symbol);
     const data = await withShotPriceHistory(context, symbol, entry.tickerFile, entry.financials);
     tickers.push(entry.tickerFile ?? createFallbackTicker(symbol, data, context));
     financials.push([symbol, data]);
+    if (includeOptionsChains && context.dataProvider.getOptionsChain) {
+      const exchange = entry.tickerFile?.metadata.exchange
+        ?? data.quote?.listingExchangeName
+        ?? data.quote?.exchangeName
+        ?? "";
+      const chain = await context.dataProvider.getOptionsChain(symbol, exchange);
+      optionsChains.push([symbol, chain]);
+    }
   }
 
   return {
@@ -86,6 +97,7 @@ async function buildDesktopShotPayload(
     heightPx,
     tickers,
     financials,
+    optionsChains,
     paneState,
   };
 }

package/src/cli/registry.test.ts

@@ -18,6 +18,7 @@ const originalHome = process.env.HOME;
 
 afterEach(async () => {
   process.env.HOME = originalHome;
+  process.exitCode = 0;
   await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
 });
 
@@ -182,6 +183,45 @@ describe("CLI dispatch", () => {
     expect(stdout).toContain("ok:hello world");
   });
 
+  test("renders plugin command failures through structured output", async () => {
+    process.env.HOME = await createTempHome("gloomberb-cli-registry-failure-home-");
+    const originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+    try {
+      const { result, stderr } = await captureConsole(() => dispatchCli(
+        ["fail-example", "--json"],
+        {
+          externalPlugins: [{
+            plugin: {
+              id: "failing-cli",
+              name: "Failing CLI",
+              version: "1.0.0",
+              cliCommands: [{
+                name: "fail-example",
+                description: "Fail on purpose",
+                execute: (_args, ctx) => ctx.fail("Synthetic failure.", "Synthetic details."),
+              }],
+            },
+            path: "/tmp/failing-cli",
+          }],
+        },
+      ));
+
+      expect(result).toEqual({ kind: "handled" });
+      expect(process.exitCode).toBe(1);
+      expect(JSON.parse(stderr)).toEqual({
+        ok: false,
+        error: {
+          code: "cli_error",
+          message: "Synthetic failure.",
+          details: "Synthetic details.",
+        },
+      });
+    } finally {
+      process.exitCode = originalExitCode ?? 0;
+    }
+  });
+
   test("routes prediction market commands and aliases through launch-ui requests", async () => {
     process.env.HOME = await createTempHome("gloomberb-cli-prediction-home-");
 

package/src/cli/registry.ts

@@ -1,9 +1,17 @@
 import type { AppConfig } from "../types/config";
-import type { CliCommandContext, CliCommandDef, CliDispatchResult, GloomPlugin } from "../types/plugin";
+import type {
+  CliCommandContext,
+  CliCommandDef,
+  CliDispatchResult,
+  GloomPlugin,
+  PluginCliCommandDescriptor,
+} from "../types/plugin";
 import type { LoadedExternalPlugin } from "../plugins/loader";
 import { getPluginCatalog } from "../plugins/catalog";
-import { initConfigData, initMarketData } from "./context";
+import { initCliServices, initConfigData, initMarketData } from "./context";
 import { closeAndFail, fail } from "./errors";
+import { DEFAULT_CLI_OPTIONS, type CliGlobalOptions } from "./options";
+import { printCliResult } from "./result";
 import {
   cliStyles,
   colorBySign,
@@ -26,6 +34,8 @@ export interface CliCommandRegistry {
   lookup: ReadonlyMap<string, RegisteredCliCommand>;
   config: AppConfig | null;
   plugins: GloomPlugin[];
+  externalPlugins: LoadedExternalPlugin[];
+  descriptors: Array<{ pluginId: string; descriptor: PluginCliCommandDescriptor }>;
 }
 
 interface BuildCliCommandRegistryOptions {
@@ -61,6 +71,19 @@ function getCommandUsageLabel(command: CliCommandDef): string {
   return command.help?.usage?.[0] ?? command.name;
 }
 
+function descriptorToCommand(descriptor: PluginCliCommandDescriptor): CliCommandDef | null {
+  if (!descriptor.execute) return null;
+  return {
+    name: descriptor.name,
+    aliases: descriptor.aliases,
+    description: descriptor.summary,
+    help: descriptor.examples?.length
+      ? { usage: descriptor.examples }
+      : undefined,
+    execute: descriptor.execute,
+  };
+}
+
 function renderHelpSections(registry: CliCommandRegistry): string[] {
   const lines: string[] = [];
 
@@ -149,6 +172,7 @@ export function buildCliCommandRegistry({
   }
 
   const loadablePlugins: GloomPlugin[] = [];
+  const descriptors: Array<{ pluginId: string; descriptor: PluginCliCommandDescriptor }> = [];
   for (const entry of catalog) {
     if (entry.error) {
       registryLog.warn(`Skipping external plugin "${entry.plugin.id}" for CLI registration.`, {
@@ -161,6 +185,11 @@ export function buildCliCommandRegistry({
     for (const command of entry.plugin.cliCommands ?? []) {
       registerCommand(command, entry.plugin.id, "plugin");
     }
+    for (const descriptor of entry.plugin.cli?.commands ?? []) {
+      descriptors.push({ pluginId: entry.plugin.id, descriptor });
+      const command = descriptorToCommand(descriptor);
+      if (command) registerCommand(command, entry.plugin.id, "plugin");
+    }
   }
 
   const commands = allCommands.filter((entry) => (
@@ -180,14 +209,25 @@ export function buildCliCommandRegistry({
     lookup,
     config,
     plugins: loadablePlugins,
+    externalPlugins,
+    descriptors,
   };
 }
 
-export function createCliCommandContext(ownerId: string, plugins: GloomPlugin[]): CliCommandContext {
+export function createCliCommandContext(
+  ownerId: string,
+  registryOrPlugins: Pick<CliCommandRegistry, "plugins" | "externalPlugins"> | GloomPlugin[],
+  cliOptions: CliGlobalOptions = DEFAULT_CLI_OPTIONS,
+): CliCommandContext {
+  const registry = Array.isArray(registryOrPlugins)
+    ? { plugins: registryOrPlugins, externalPlugins: [] }
+    : registryOrPlugins;
   return {
     initConfigData,
-    initMarketData: () => initMarketData({ plugins }),
-    plugins,
+    initMarketData: () => initMarketData({ plugins: registry.plugins }),
+    initServices: () => initCliServices({ externalPlugins: registry.externalPlugins }),
+    cliOptions,
+    plugins: registry.plugins,
     fail,
     closeAndFail,
     output: {
@@ -197,6 +237,7 @@ export function createCliCommandContext(ownerId: string, plugins: GloomPlugin[])
       renderStat,
       renderTable,
     },
+    printResult: (result, options) => printCliResult(result, cliOptions, options),
     log: debugLog.createLogger(ownerId === "core" ? "cli" : ownerId),
   };
 }

package/src/cli/result.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import { serializeCliError, serializeCliResult } from "./result";
+import type { CliGlobalOptions } from "./options";
+
+const baseOptions: CliGlobalOptions = {
+  format: "text",
+  quiet: false,
+  color: null,
+  refresh: false,
+  dryRun: false,
+  yes: false,
+};
+
+describe("serializeCliResult", () => {
+  test("renders limited JSON result envelopes", () => {
+    const output = serializeCliResult(
+      { data: [{ symbol: "AAPL" }, { symbol: "MSFT" }] },
+      { ...baseOptions, format: "json", limit: 1 },
+    );
+    expect(JSON.parse(output)).toEqual({
+      ok: true,
+      data: [{ symbol: "AAPL" }],
+    });
+  });
+
+  test("includes display column metadata in JSON envelopes", () => {
+    const output = serializeCliResult(
+      { data: [{ quote: { symbol: "AAPL", price: 123 } }] },
+      { ...baseOptions, format: "json" },
+      {
+        rows: (data) => data.map((row) => row.quote),
+        columns: [
+          { key: "symbol", header: "Symbol" },
+          { key: "price", header: "Last", align: "right" },
+        ],
+      },
+    );
+    expect(JSON.parse(output)).toEqual({
+      ok: true,
+      data: [{ quote: { symbol: "AAPL", price: 123 } }],
+      columns: [
+        { key: "symbol", header: "Symbol" },
+        { key: "price", header: "Last", align: "right" },
+      ],
+    });
+  });
+
+  test("renders CSV with provided column order", () => {
+    const output = serializeCliResult(
+      { data: [{ symbol: "AAPL", name: "Apple, Inc." }] },
+      { ...baseOptions, format: "csv" },
+      {
+        columns: [
+          { key: "symbol", header: "Symbol" },
+          { key: "name", header: "Name" },
+        ],
+      },
+    );
+    expect(output).toBe('Symbol,Name\nAAPL,"Apple, Inc."');
+  });
+
+  test("renders NDJSON rows", () => {
+    const output = serializeCliResult(
+      { data: [{ symbol: "AAPL" }, { symbol: "MSFT" }] },
+      { ...baseOptions, format: "ndjson" },
+    );
+    expect(output).toBe('{"symbol":"AAPL"}\n{"symbol":"MSFT"}');
+  });
+});
+
+describe("serializeCliError", () => {
+  test("renders stable structured errors for JSON", () => {
+    const output = serializeCliError(
+      { code: "auth_required", message: "Sign in first.", retryable: true },
+      { ...baseOptions, format: "json" },
+    );
+    expect(JSON.parse(output)).toEqual({
+      ok: false,
+      error: { code: "auth_required", message: "Sign in first.", retryable: true },
+    });
+  });
+});

package/src/cli/result.ts

@@ -0,0 +1,149 @@
+import type { CliGlobalOptions } from "./options";
+import { renderTable, type CliTableColumn } from "../utils/cli-output";
+
+export interface CliResult<T = unknown> {
+  data: T;
+  metadata?: Record<string, unknown>;
+  warnings?: string[];
+}
+
+export interface CliErrorObject {
+  code: string;
+  message: string;
+  details?: unknown;
+  retryable?: boolean;
+}
+
+export interface CliResultColumn<Row = Record<string, unknown>> extends CliTableColumn {
+  key: string;
+  value?: (row: Row) => unknown;
+}
+
+export interface CliResultRenderOptions<T = unknown, Row = Record<string, unknown>> {
+  text?: (data: T) => string;
+  columns?: CliResultColumn<Row>[];
+  rows?: (data: T) => Row[];
+}
+
+interface CliResultJsonEnvelope<T> extends CliResult<T> {
+  ok: true;
+  columns?: Array<Pick<CliResultColumn, "key" | "header" | "align" | "width">>;
+}
+
+function applyLimit<T>(data: T, limit?: number): T {
+  if (!Array.isArray(data) || limit == null) return data;
+  return data.slice(0, limit) as T;
+}
+
+function asRows<T, Row>(data: T, limit?: number, rows?: (data: T) => Row[]): Row[] {
+  const resolvedRows = rows ? rows(data) : (Array.isArray(data) ? data : [data]) as Row[];
+  return limit == null ? resolvedRows : resolvedRows.slice(0, limit);
+}
+
+function normalizeCell(value: unknown): string {
+  if (value == null) return "";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+function inferColumns(rows: Record<string, unknown>[]): CliResultColumn<Record<string, unknown>>[] {
+  const keys = new Set<string>();
+  for (const row of rows) {
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+      for (const key of Object.keys(row)) keys.add(key);
+    }
+  }
+  return [...keys].map((key) => ({ key, header: key }));
+}
+
+function csvEscape(value: string): string {
+  if (!/[",\n\r]/.test(value)) return value;
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+function serializeColumns<Row>(columns?: CliResultColumn<Row>[]) {
+  return columns?.map((column) => ({
+    key: column.key,
+    header: column.header,
+    ...(column.align ? { align: column.align } : {}),
+    ...(column.width ? { width: column.width } : {}),
+  }));
+}
+
+function renderCsv<Row extends Record<string, unknown>>(
+  rows: Row[],
+  columns?: CliResultColumn<Row>[],
+): string {
+  const resolvedColumns = columns && columns.length > 0
+    ? columns
+    : inferColumns(rows as Record<string, unknown>[]) as CliResultColumn<Row>[];
+  const header = resolvedColumns.map((column) => csvEscape(column.header)).join(",");
+  const body = rows.map((row) => resolvedColumns
+    .map((column) => csvEscape(normalizeCell(column.value ? column.value(row) : row[column.key])))
+    .join(","));
+  return [header, ...body].join("\n");
+}
+
+function renderTextTable<Row extends Record<string, unknown>>(
+  rows: Row[],
+  columns?: CliResultColumn<Row>[],
+): string {
+  const resolvedColumns = columns && columns.length > 0
+    ? columns
+    : inferColumns(rows as Record<string, unknown>[]) as CliResultColumn<Row>[];
+  return renderTable(
+    resolvedColumns.map((column) => ({
+      header: column.header,
+      align: column.align,
+      width: column.width,
+    })),
+    rows.map((row) => resolvedColumns.map((column) => normalizeCell(column.value ? column.value(row) : row[column.key]))),
+  );
+}
+
+export function serializeCliResult<T, Row extends Record<string, unknown> = Record<string, unknown>>(
+  result: CliResult<T>,
+  options: CliGlobalOptions,
+  renderOptions: CliResultRenderOptions<T, Row> = {},
+): string {
+  if (options.format === "json") {
+    const columns = serializeColumns(renderOptions.columns);
+    const envelope: CliResultJsonEnvelope<T> = {
+      ok: true,
+      ...result,
+      data: applyLimit(result.data, options.limit),
+      ...(columns?.length ? { columns } : {}),
+    };
+    return JSON.stringify(envelope, null, 2);
+  }
+
+  const rows = asRows(result.data, options.limit, renderOptions.rows);
+  if (options.format === "ndjson") {
+    return rows.map((row) => JSON.stringify(row)).join("\n");
+  }
+  if (options.format === "csv") {
+    return renderCsv(rows as Row[], renderOptions.columns);
+  }
+  if (renderOptions.text) {
+    return renderOptions.text(result.data);
+  }
+  return renderTextTable(rows as Row[], renderOptions.columns);
+}
+
+export function printCliResult<T, Row extends Record<string, unknown> = Record<string, unknown>>(
+  result: CliResult<T>,
+  options: CliGlobalOptions,
+  renderOptions: CliResultRenderOptions<T, Row> = {},
+): void {
+  if (options.quiet && options.format === "text") return;
+  const output = serializeCliResult(result, options, renderOptions);
+  if (output) console.log(output);
+}
+
+export function serializeCliError(error: CliErrorObject, options: CliGlobalOptions): string {
+  if (options.format === "json" || options.format === "ndjson") {
+    return JSON.stringify({ ok: false, error }, null, options.format === "json" ? 2 : 0);
+  }
+  return error.details == null ? error.message : `${error.message}\n${String(error.details)}`;
+}

package/src/cli/types.ts

@@ -2,6 +2,7 @@ import type { AppConfig } from "../types/config";
 import { AppPersistence } from "../data/app-persistence";
 import { TickerRepository } from "../data/ticker-repository";
 import { AssetDataRouter } from "../sources/provider-router";
+import type { AppServices } from "../core/app-services";
 
 export type ConfigContext = {
   config: AppConfig;
@@ -13,3 +14,13 @@ export type ConfigContext = {
 export type MarketContext = ConfigContext & {
   dataProvider: AssetDataRouter;
 };
+
+export type CliServicesContext = {
+  config: AppConfig;
+  dataDir: string;
+  services: AppServices;
+  dataProvider: AssetDataRouter;
+  persistence: AppPersistence;
+  store: TickerRepository;
+  destroy(): void;
+};

package/src/cli.test.ts

@@ -22,6 +22,7 @@ const originalHome = process.env.HOME;
 
 afterEach(async () => {
   process.env.HOME = originalHome;
+  process.exitCode = 0;
   await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
 });
 
@@ -96,12 +97,12 @@ async function captureConsole<T>(fn: () => Promise<T> | T): Promise<{ result: T;
   }
 }
 
-async function captureConsoleFailure(fn: () => Promise<unknown> | unknown): Promise<{ stdout: string; stderr: string; error: unknown }> {
+async function captureConsoleFailure(fn: () => Promise<unknown> | unknown): Promise<{ stdout: string; stderr: string; exitCode: string | number | undefined }> {
   const logs: string[] = [];
   const errors: string[] = [];
   const originalLog = console.log;
   const originalError = console.error;
-  const originalExit = process.exit;
+  const originalExitCode = process.exitCode;
 
   console.log = (...args: unknown[]) => {
     logs.push(args.map(String).join(" "));
@@ -109,23 +110,22 @@ async function captureConsoleFailure(fn: () => Promise<unknown> | unknown): Prom
   console.error = (...args: unknown[]) => {
     errors.push(args.map(String).join(" "));
   };
-  process.exit = ((code?: number) => {
-    throw new Error(`process.exit:${code ?? 0}`);
-  }) as typeof process.exit;
+  process.exitCode = undefined;
 
   try {
     await fn();
-    throw new Error("Expected command to fail.");
-  } catch (error) {
+    if (process.exitCode == null || process.exitCode === 0) {
+      throw new Error("Expected command to fail.");
+    }
     return {
       stdout: logs.join("\n"),
       stderr: errors.join("\n"),
-      error,
+      exitCode: process.exitCode,
     };
   } finally {
     console.log = originalLog;
     console.error = originalError;
-    process.exit = originalExit;
+    process.exitCode = originalExitCode ?? 0;
   }
 }
 
@@ -226,7 +226,7 @@ describe("CLI portfolio commands", () => {
     });
 
     const result = await captureConsoleFailure(() => runCli(["portfolio", "create", "Research"]));
-    expect(String(result.error)).toContain("process.exit:1");
+    expect(result.exitCode).toBe(1);
     expect(result.stderr).toContain('Portfolio "Research" already exists.');
   });
 
@@ -370,7 +370,7 @@ describe("CLI portfolio commands", () => {
     });
 
     const result = await captureConsoleFailure(() => runCli(["portfolio", "add", "IBKR Account", "NVDA"]));
-    expect(String(result.error)).toContain("process.exit:1");
+    expect(result.exitCode).toBe(1);
     expect(result.stderr).toContain('Portfolio "IBKR Account" is broker-managed and cannot be modified manually.');
   });
 });

package/src/components/chart/bar-chart-renderer.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, test } from "bun:test";
-import { buildBarChartScene, renderBarChart, renderNativeBarChart } from "./bar-chart-renderer";
+import {
+  buildBarChartScene,
+  renderBarChart,
+  renderBarChartAxis,
+  renderBarChartYAxis,
+  renderNativeBarChart,
+  resolveNativeBarPixelBounds,
+  resolveBarChartHover,
+} from "./bar-chart-renderer";
 
 const series = [
   {
@@ -27,27 +35,124 @@ describe("bar chart renderer", () => {
     const scene = buildBarChartScene(series, {
       width: 24,
       height: 8,
-      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666" },
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666", negativeColor: "#ff5555" },
     });
 
     expect(scene).not.toBeNull();
     expect(scene!.categories).toEqual(["2024", "2025"]);
     expect(scene!.bars).toHaveLength(4);
     expect(scene!.zeroRow).toBeGreaterThanOrEqual(0);
+    expect(scene!.bars.find((bar) => bar.value < 0)?.color).toBe("#ff5555");
   });
 
   test("renders text fallback and native bitmap output", () => {
     const scene = buildBarChartScene(series, {
       width: 24,
       height: 8,
-      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666" },
+      colors: {
+        bgColor: "#000000",
+        gridColor: "#333333",
+        axisColor: "#666666",
+        negativeColor: "#ff5555",
+        hoverColor: "#ffffff",
+      },
     })!;
 
     expect(renderBarChart(scene).join("\n")).toContain("█");
 
     const bitmap = renderNativeBarChart(scene, 96, 48);
+    const negativePixel = Array.from({ length: bitmap.pixels.length / 4 }).some((_, pixelIndex) => {
+      const index = pixelIndex * 4;
+      return bitmap.pixels[index]! > 200 && bitmap.pixels[index + 1]! < 100 && bitmap.pixels[index + 2]! < 100;
+    });
     expect(bitmap.width).toBe(96);
     expect(bitmap.height).toBe(48);
     expect(bitmap.pixels.some((value) => value > 0)).toBe(true);
+    expect(negativePixel).toBe(true);
+
+    const hover = resolveBarChartHover(scene, scene.bars[0]!.x);
+    expect(renderBarChart(scene, hover).join("\n")).toContain("▓");
+    const hoverBitmap = renderNativeBarChart(scene, 96, 48, hover);
+    const hoverPixel = Array.from({ length: hoverBitmap.pixels.length / 4 }).some((_, pixelIndex) => {
+      const index = pixelIndex * 4;
+      return hoverBitmap.pixels[index]! > 240 && hoverBitmap.pixels[index + 1]! > 240 && hoverBitmap.pixels[index + 2]! > 240;
+    });
+    expect(hoverBitmap.pixels).not.toEqual(bitmap.pixels);
+    expect(hoverPixel).toBe(true);
+  });
+
+  test("renders y-axis labels and resolves hover targets", () => {
+    const scene = buildBarChartScene(series, {
+      width: 24,
+      height: 8,
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666" },
+    })!;
+
+    const yAxis = renderBarChartYAxis(scene, 8, (value) => String(Math.round(value)));
+    const labelCount = yAxis.filter((line) => line.trim().length > 0).length;
+    expect(labelCount).toBeGreaterThanOrEqual(5);
+    expect(yAxis.join("\n")).toContain("22");
+    expect(yAxis.join("\n")).toContain("0");
+
+    const hover = resolveBarChartHover(scene, scene.bars[1]!.x);
+    expect(hover).toMatchObject({
+      seriesId: "NVDA",
+      seriesLabel: "NVDA",
+      category: "2024",
+      value: 20,
+      x: scene.bars[1]!.x,
+      width: scene.bars[1]!.width,
+      row: scene.bars[1]!.row,
+    });
+  });
+
+  test("renders dense single-series bars with consistent separators and readable x-axis labels", () => {
+    const denseSeries = [{
+      id: "value",
+      label: "Value",
+      color: "#00ff66",
+      points: Array.from({ length: 14 }, (_unused, index) => ({
+        category: `${2015 + index} Q1`,
+        value: index + 1,
+      })),
+    }];
+    const scene = buildBarChartScene(denseSeries, {
+      width: 47,
+      height: 8,
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666", negativeColor: "#ff5555" },
+    })!;
+
+    const lastBar = scene.bars.at(-1)!;
+    expect(lastBar.x + lastBar.width).toBe(scene.width);
+    expect(renderBarChart(scene)[scene.zeroRow]).not.toContain("─");
+
+    const bitmapWidth = 470;
+    const pixelBounds = scene.bars.map((bar) => resolveNativeBarPixelBounds(scene, bar, bitmapWidth));
+    const pixelWidths = pixelBounds.map((bounds) => bounds.rightExclusive - bounds.left);
+    expect(Math.max(...pixelWidths) - Math.min(...pixelWidths)).toBeLessThanOrEqual(1);
+    expect(pixelBounds[0]!.left).toBe(0);
+    expect(pixelBounds.at(-1)!.rightExclusive).toBe(bitmapWidth);
+    const pixelGaps: number[] = [];
+    for (let index = 1; index < pixelBounds.length; index++) {
+      pixelGaps.push(pixelBounds[index]!.left - pixelBounds[index - 1]!.rightExclusive);
+    }
+    expect(new Set(pixelGaps)).toEqual(new Set([1]));
+
+    const bitmap = renderNativeBarChart(scene, bitmapWidth, 80);
+    const zeroY = Math.round((scene.zeroRow / Math.max(scene.height - 1, 1)) * (bitmap.height - 1));
+    let separatorColumns = 0;
+    for (let x = 0; x < bitmap.width; x++) {
+      const index = (zeroY * bitmap.width + x) * 4;
+      if (bitmap.pixels[index + 1]! <= 120) separatorColumns++;
+    }
+    expect(separatorColumns).toBe(scene.categories.length - 1);
+
+    const axis = renderBarChartAxis(scene, 1);
+    expect(axis).toHaveLength(1);
+    expect(axis.every((line) => line.length === scene.width)).toBe(true);
+    expect(axis.join("\n")).toContain("2015");
+    expect(axis.join("\n")).not.toContain("Q1");
+    expect(axis.join("\n")).not.toContain("20 20");
+    expect(axis[0]!.endsWith("  ")).toBe(true);
   });
 });