gloomberb 0.9.7 → 0.9.9

package/src/brokers/remote-broker-adapter.ts

@@ -44,6 +44,9 @@ export function createRemoteBrokerAdapter(adapter: BrokerAdapter): BrokerAdapter
     ...adapter,
     validate: (instance) => invoke<boolean>(instance, "validate"),
     importPositions: (instance) => invoke(instance, "importPositions"),
+    importPortfolioSnapshot: adapter.importPortfolioSnapshot
+      ? (instance) => invoke(instance, "importPortfolioSnapshot")
+      : undefined,
     connect: (instance) => invoke<void>(instance, "connect"),
     disconnect: (instance) => invoke<void>(instance, "disconnect"),
     getStatus: (instance) => getBrokerRemoteClient()?.getStatus(instance.id) ?? adapter.getStatus?.(instance) ?? disconnectedStatus(),

package/src/capabilities/registry.test.ts

@@ -47,6 +47,10 @@ describe("CapabilityRegistry", () => {
 
     dispose();
     expect(registry.list()).toEqual([]);
+
+    registry.register("plugin-b", testCapability());
+    dispose();
+    expect(registry.list()).toHaveLength(1);
   });
 
   test("filters disabled plugins and disabled capabilities", () => {
@@ -134,4 +138,25 @@ describe("CapabilityRegistry", () => {
     expect(disposed).toBe(2);
     expect(registry.list()).toEqual([]);
   });
+
+  test("disposes subscriptions that finish after their capability is removed", async () => {
+    const registry = new CapabilityRegistry();
+    let finishSubscribe!: (dispose: () => void) => void;
+    let disposed = 0;
+    const disposeCapability = registry.register("plugin-a", testCapability({
+      operations: {
+        ticks: {
+          kind: "stream",
+          subscribe: () => new Promise((resolve) => { finishSubscribe = resolve; }),
+        },
+      },
+    }));
+
+    const subscribing = registry.subscribe("plugin-service.test", "ticks", {}, () => {});
+    disposeCapability();
+    finishSubscribe(() => { disposed += 1; });
+
+    await expect(subscribing).rejects.toThrow("not available");
+    expect(disposed).toBe(1);
+  });
 });

package/src/capabilities/registry.ts

@@ -24,15 +24,22 @@ export class CapabilityRegistry {
     if (existing) {
       throw new Error(`Capability "${capability.id}" already registered by plugin "${existing.pluginId}".`);
     }
-    this.capabilities.set(capability.id, { pluginId, capability });
+    const registration = { pluginId, capability };
+    this.capabilities.set(capability.id, registration);
     return () => {
+      if (this.capabilities.get(capability.id) !== registration) return;
       this.capabilities.delete(capability.id);
+      let firstError: unknown;
       for (const [subscriptionId, entry] of this.subscriptions) {
         if (entry.capabilityId === capability.id) {
-          entry.dispose();
-          this.subscriptions.delete(subscriptionId);
+          try {
+            this.unsubscribe(subscriptionId);
+          } catch (error) {
+            firstError ??= error;
+          }
         }
       }
+      if (firstError) throw firstError;
     };
   }
 
@@ -97,6 +104,10 @@ export class CapabilityRegistry {
     const subscriptionId = options.subscriptionId ?? `${capabilityId}:${operationId}:${this.nextSubscriptionId++}`;
     this.unsubscribe(subscriptionId);
     const dispose = await operation.subscribe(input, emit, { capability, operationId });
+    if (this.capabilities.get(capabilityId)?.capability !== capability) {
+      dispose();
+      throw new Error(`Capability "${capabilityId}" is not available.`);
+    }
     this.subscriptions.set(subscriptionId, { capabilityId, dispose });
     return subscriptionId;
   }
@@ -104,12 +115,18 @@ export class CapabilityRegistry {
   unsubscribe(subscriptionId: string): void {
     const entry = this.subscriptions.get(subscriptionId);
     if (!entry) return;
-    entry.dispose();
     this.subscriptions.delete(subscriptionId);
+    entry.dispose();
   }
 
   destroy(): void {
-    for (const subscriptionId of [...this.subscriptions.keys()]) this.unsubscribe(subscriptionId);
+    for (const subscriptionId of [...this.subscriptions.keys()]) {
+      try {
+        this.unsubscribe(subscriptionId);
+      } catch {
+        // Continue releasing the remaining subscriptions.
+      }
+    }
     this.capabilities.clear();
   }
 

package/src/cli/commands/automation.ts

@@ -102,9 +102,7 @@ export const aiCliCommand: CliCommandDef = {
     if (action === "ask") {
       const rawArgs = args.slice(1);
       const providerId = takeOption(rawArgs, "--provider") ?? detectProviders().find((provider) => provider.available)?.id;
-      const provider = getAiProvider(providerId);
-      if (!provider) ctx.fail("Unknown AI provider.");
-      const selectedProvider = provider;
+      const selectedProvider = getAiProvider(providerId) ?? ctx.fail("Unknown AI provider.");
       if (!selectedProvider.available) ctx.fail(`${selectedProvider.name} is not installed or not available in PATH.`);
       const prompt = rawArgs.join(" ").trim();
       if (!prompt) ctx.fail("Usage: gloomberb ai ask [--provider id] <prompt>");

package/src/cli/commands/command-utils.ts

@@ -15,13 +15,6 @@ export function takeOption(args: string[], name: string): string | undefined {
   return value;
 }
 
-export function takeFlag(args: string[], name: string): boolean {
-  const index = args.indexOf(name);
-  if (index < 0) return false;
-  args.splice(index, 1);
-  return true;
-}
-
 export function parseJsonPayload(value: string | undefined, ctx: CliCommandContext): unknown {
   if (!value) return {};
   try {

package/src/cli/commands/overview.ts

@@ -211,8 +211,8 @@ async function runCorrelation(args: string[], ctx: Parameters<CliCommandDef["exe
 
 export const overviewCliCommands: CliCommandDef[] = [
   { name: "movers", description: "Fetch gainers, losers, active, or trending market movers", help: { usage: ["movers [gainers|losers|active|trending]"] }, execute: runMoverCommand },
-  { name: "indices", description: "Fetch major US index quotes", execute: (args, ctx) => runQuoteBasket([...MARKET_SUMMARY_SYMBOLS], ctx, { group: "indices" }) },
-  { name: "sectors", description: "Fetch SPDR sector ETF quotes", execute: (args, ctx) => runQuoteBasket(SECTOR_ETFS, ctx, { group: "sectors" }) },
+  { name: "indices", description: "Fetch major US index quotes", execute: (_args, ctx) => runQuoteBasket([...MARKET_SUMMARY_SYMBOLS], ctx, { group: "indices" }) },
+  { name: "sectors", description: "Fetch SPDR sector ETF quotes", execute: (_args, ctx) => runQuoteBasket(SECTOR_ETFS, ctx, { group: "sectors" }) },
   { name: "fear-greed", description: "Fetch CNN Fear & Greed gauge data", execute: runFearGreed },
   { name: "econ", description: "Fetch economic calendar events", help: { usage: ["econ [--country US|G7|EU|all] [--impact high|medium|low|all]"] }, execute: runEcon },
   { name: "fred", description: "Fetch a FRED series through the configured cloud session", help: { usage: ["fred <series-id> [--start yyyy-mm-dd]"] }, execute: runFred },

package/src/cli/commands/plugins.ts

@@ -1,6 +1,6 @@
 import { join } from "path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { getPluginsDir } from "../../plugins/loader";
 import {
   cliStyles,
@@ -18,18 +18,34 @@ function ensurePluginsDir() {
   }
 }
 
-function parseGitHubRef(ref: string): { url: string; name: string } {
-  if (ref.startsWith("https://github.com/")) {
-    const clean = ref.replace(/\.git$/, "");
-    const name = clean.split("/").pop()!;
-    return { url: clean.endsWith(".git") ? ref : `${clean}.git`, name };
+const GITHUB_SEGMENT_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+function validatePluginDirectoryName(name: string): string {
+  if (!GITHUB_SEGMENT_PATTERN.test(name)) {
+    throw new Error(`Invalid plugin name: ${name}.`);
   }
-  if (ref.startsWith("github:")) {
-    ref = ref.slice(7);
+  return name;
+}
+
+function parseGitHubRef(rawRef: string): { url: string; name: string } {
+  const ref = rawRef.startsWith("github:") ? rawRef.slice("github:".length) : rawRef;
+  let segments: string[];
+  if (ref.startsWith("https://")) {
+    const parsed = new URL(ref);
+    if (parsed.hostname !== "github.com" || parsed.port || parsed.username || parsed.password || parsed.search || parsed.hash) {
+      throw new Error(`Invalid plugin reference: ${rawRef}. Use user/repo or a GitHub URL.`);
+    }
+    segments = parsed.pathname.split("/").filter(Boolean);
+  } else if (!ref.includes("://")) {
+    segments = ref.split("/");
+  } else {
+    segments = [];
   }
-  if (ref.includes("/") && !ref.includes("://")) {
-    const name = ref.split("/").pop()!;
-    return { url: `https://github.com/${ref}.git`, name };
+  const [owner, rawRepo] = segments;
+  const repo = rawRepo?.replace(/\.git$/, "");
+  if (segments.length === 2 && owner && GITHUB_SEGMENT_PATTERN.test(owner) && repo) {
+    const name = validatePluginDirectoryName(repo);
+    return { url: `https://github.com/${owner}/${name}.git`, name };
   }
   throw new Error(`Invalid plugin reference: ${ref}. Use user/repo or a GitHub URL.`);
 }
@@ -47,8 +63,9 @@ export async function installPlugin(ref: string) {
   console.log(cliStyles.muted(url));
 
   try {
-    execSync(`git clone --depth 1 ${url} ${targetDir}`, { stdio: "inherit" });
+    execFileSync("git", ["clone", "--depth", "1", url, targetDir], { stdio: "inherit" });
   } catch {
+    rmSync(targetDir, { recursive: true, force: true });
     fail(`Failed to clone ${url}.`);
   }
 
@@ -56,7 +73,7 @@ export async function installPlugin(ref: string) {
   if (existsSync(pkgPath)) {
     console.log(cliStyles.muted("Installing plugin dependencies..."));
     try {
-      execSync("bun install", { cwd: targetDir, stdio: "inherit" });
+      execFileSync("bun", ["install"], { cwd: targetDir, stdio: "inherit" });
     } catch {
       console.error(cliStyles.warning("Warning: failed to install plugin dependencies."));
     }
@@ -92,7 +109,7 @@ export async function installPlugin(ref: string) {
 }
 
 export async function removePlugin(name: string) {
-  const targetDir = join(PLUGINS_DIR, name);
+  const targetDir = join(PLUGINS_DIR, validatePluginDirectoryName(name));
   if (!existsSync(targetDir)) {
     fail(`Plugin "${name}" was not found.`, PLUGINS_DIR);
   }
@@ -103,7 +120,7 @@ export async function removePlugin(name: string) {
 export async function updatePlugins(name?: string) {
   ensurePluginsDir();
   const dirs = name
-    ? [name]
+    ? [validatePluginDirectoryName(name)]
     : readdirSync(PLUGINS_DIR, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => entry.name);
@@ -121,10 +138,10 @@ export async function updatePlugins(name?: string) {
     }
     console.log(cliStyles.accent(`Updating ${dir}...`));
     try {
-      execSync("git pull", { cwd: targetDir, stdio: "inherit" });
+      execFileSync("git", ["pull", "--ff-only"], { cwd: targetDir, stdio: "inherit" });
       const pkgPath = join(targetDir, "package.json");
       if (existsSync(pkgPath)) {
-        execSync("bun install", { cwd: targetDir, stdio: "inherit" });
+        execFileSync("bun", ["install"], { cwd: targetDir, stdio: "inherit" });
       }
     } catch {
       console.error(cliStyles.danger(`Failed to update ${dir}.`));

package/src/cli/index.ts

@@ -14,7 +14,7 @@ import {
 import { fail, inferCliErrorOptions, printCliError } from "./errors";
 import { setCliColorEnabledOverride } from "../utils/cli-output";
 import { search, searchCandidatesForCli, buildSearchReport } from "./commands/search";
-import { ticker, buildTickerReport } from "./commands/ticker";
+import { ticker } from "./commands/ticker";
 import { apiCliCommand } from "./commands/api";
 import { marketDataCliCommands } from "./commands/market";
 import { overviewCliCommands } from "./commands/overview";
@@ -216,7 +216,7 @@ async function createRegistry(options: DispatchCliOptions = {}): Promise<CliComm
   return registry;
 }
 
-export { buildSearchReport, buildTickerReport, searchCandidatesForCli };
+export { buildSearchReport, searchCandidatesForCli };
 
 export async function dispatchCli(args: string[], options: DispatchCliOptions = {}): Promise<CliDispatchResult> {
   let parsed;

package/src/cli.test.ts

@@ -6,14 +6,11 @@ import { AppPersistence } from "./data/app-persistence";
 import { loadConfig, saveConfig } from "./data/config/store";
 import {
   buildSearchReport,
-  buildTickerReport,
   runCli,
   searchCandidatesForCli,
 } from "./cli/index";
 import { createDefaultConfig } from "./types/config";
 import { TickerRepository } from "./data/ticker-repository";
-import type { TickerFinancials } from "./types/financials";
-import type { NewsItem, SecFilingItem } from "./types/data-provider";
 import type { TickerRecord } from "./types/ticker";
 import { createTestDataProvider } from "./test-support/data-provider";
 
@@ -375,160 +372,6 @@ describe("CLI portfolio commands", () => {
   });
 });
 
-describe("buildTickerReport", () => {
-  test("includes deeper fundamentals and recent statement sections", async () => {
-    const config = createDefaultConfig("/tmp/gloomberb-cli-report");
-    config.watchlists = [{ id: "growth", name: "Growth" }];
-
-    const ticker = makeTicker({
-      portfolios: ["main"],
-      watchlists: ["growth"],
-      positions: [{
-        portfolio: "main",
-        shares: 10,
-        avgCost: 400,
-        broker: "manual",
-      }],
-      assetCategory: "STK",
-      sector: "Technology",
-      industry: "Semiconductors",
-    });
-
-    const financials: TickerFinancials = {
-      quote: {
-        symbol: "NVDA",
-        price: 912.34,
-        currency: "USD",
-        change: 12.5,
-        changePercent: 1.39,
-        lastUpdated: Date.UTC(2026, 3, 1, 14, 30),
-        marketCap: 2_240_000_000_000,
-        volume: 48_000_000,
-        name: "NVIDIA Corporation",
-        exchangeName: "NMS",
-        marketState: "REGULAR",
-        bid: 912.3,
-        ask: 912.4,
-        bidSize: 100,
-        askSize: 200,
-        open: 905,
-        high: 918,
-        low: 901,
-        high52w: 980,
-        low52w: 500,
-        dataSource: "live",
-      },
-      fundamentals: {
-        trailingPE: 35.2,
-        forwardPE: 29.8,
-        pegRatio: 1.4,
-        enterpriseValue: 2_300_000_000_000,
-        operatingCashFlow: 82_000_000_000,
-        freeCashFlow: 67_000_000_000,
-        dividendYield: 0.001,
-        revenue: 128_000_000_000,
-        netIncome: 73_000_000_000,
-        eps: 2.97,
-        operatingMargin: 0.58,
-        profitMargin: 0.57,
-        revenueGrowth: 0.42,
-        return1Y: 0.88,
-        return3Y: 2.45,
-        lastQuarterGrowth: 0.61,
-        sharesOutstanding: 2_450_000_000,
-      },
-      profile: {
-        description: "Designs GPUs and accelerated computing platforms.",
-        sector: "Technology",
-        industry: "Semiconductors",
-      },
-      annualStatements: [{
-        date: "2025-12-31",
-        totalRevenue: 128_000_000_000,
-        grossProfit: 97_000_000_000,
-        operatingIncome: 76_000_000_000,
-        netIncome: 73_000_000_000,
-        ebitda: 79_000_000_000,
-        operatingCashFlow: 82_000_000_000,
-        freeCashFlow: 67_000_000_000,
-        cashAndCashEquivalents: 40_000_000_000,
-        totalAssets: 110_000_000_000,
-        totalLiabilities: 36_000_000_000,
-        totalDebt: 9_000_000_000,
-        totalEquity: 74_000_000_000,
-        eps: 11.84,
-        dilutedShares: 2_450_000_000,
-      }],
-      quarterlyStatements: [{
-        date: "2026-03-31",
-        totalRevenue: 38_000_000_000,
-        grossProfit: 28_000_000_000,
-        operatingIncome: 22_000_000_000,
-        netIncome: 21_000_000_000,
-        ebitda: 23_000_000_000,
-        operatingCashFlow: 24_000_000_000,
-        freeCashFlow: 19_000_000_000,
-        cashAndCashEquivalents: 42_000_000_000,
-        totalAssets: 118_000_000_000,
-        totalLiabilities: 38_000_000_000,
-        totalDebt: 9_000_000_000,
-        totalEquity: 80_000_000_000,
-        eps: 3.4,
-        dilutedShares: 2_455_000_000,
-      }],
-      priceHistory: [],
-    };
-
-    const recentNews: NewsItem[] = [{
-      title: "NVIDIA unveils next platform",
-      source: "Example News",
-      url: "https://example.com/nvda-platform",
-      publishedAt: "2026-04-01T15:45:00.000Z" as unknown as Date,
-      summary: "Analysts expect the launch to expand datacenter demand.",
-    }];
-
-    const recentSecFilings: SecFilingItem[] = [{
-      accessionNumber: "0000000000-26-000001",
-      form: "8-K",
-      filingDate: "2026-03-31T00:00:00.000Z" as unknown as Date,
-      cik: "0001045810",
-      filingUrl: "https://www.sec.gov/Archives/example-8k",
-      primaryDocument: "nvda-8k.htm",
-      primaryDocDescription: "Current report announcing a product launch",
-      items: "2.02, 7.01",
-    }];
-
-    const report = await buildTickerReport({
-      symbol: "NVDA",
-      tickerFile: ticker,
-      financials,
-      config,
-      toBase: async (value) => value,
-      notes: "Conviction remains high.\nWatch gross margin guidance.",
-      recentNews,
-      recentSecFilings,
-    });
-
-    expect(report).toContain("Fundamentals");
-    expect(report).toContain("(+1.39%)");
-    expect(report).not.toContain("++1.39%");
-    expect(report).toContain("Operating Cash Flow");
-    expect(report).toContain("Latest Annual (2025-12-31)");
-    expect(report).toContain("Latest Quarter (2026-03-31)");
-    expect(report).toContain("Watchlists Growth");
-    expect(report).toContain("Designs GPUs and accelerated computing platforms.");
-    expect(report).toContain("Notes");
-    expect(report).toContain("Conviction remains high.");
-    expect(report).toContain("Recent News");
-    expect(report).toContain("NVIDIA unveils next platform");
-    expect(report).toContain("Example News");
-    expect(report).toContain("Apr 1, 2026");
-    expect(report).toContain("Recent SEC Filings");
-    expect(report).toContain("8-K | Mar 31, 2026");
-    expect(report).toContain("Current report announcing a product launch");
-  });
-});
-
 describe("CLI search helpers", () => {
   test("merges local ticker matches with provider company search results", async () => {
     const candidates = await searchCandidatesForCli({

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

@@ -7,6 +7,7 @@ import {
   renderNativeBarChart,
   resolveNativeBarPixelBounds,
   resolveBarChartHover,
+  resolveNativeBarChartHover,
 } from "./bar-chart-renderer";
 
 const series = [
@@ -122,16 +123,14 @@ describe("bar chart renderer", () => {
       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 zeroRow = renderBarChart(scene)[scene.zeroRow]!;
+    expect([...zeroRow].filter((char) => char === "█").length).toBeGreaterThan(0);
+    expect([...zeroRow].filter((char) => char === "─").length).toBeGreaterThanOrEqual(scene.categories.length - 1);
 
     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);
@@ -139,13 +138,7 @@ describe("bar chart renderer", () => {
     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);
+    expect(bitmap.pixels.some((value) => value > 0)).toBe(true);
 
     const axis = renderBarChartAxis(scene, 1);
     expect(axis).toHaveLength(1);
@@ -155,4 +148,86 @@ describe("bar chart renderer", () => {
     expect(axis.join("\n")).not.toContain("20 20");
     expect(axis[0]!.endsWith("  ")).toBe(true);
   });
+
+  test("drops null-only categories while keeping fixed ticker slots", () => {
+    const sparseSeries = [
+      {
+        id: "AMD",
+        label: "AMD",
+        color: "#00ff66",
+        points: [
+          { category: "2025 Q1", value: 10 },
+          { category: "2025 Q2", value: 11 },
+          { category: "2025 Q3", value: 12 },
+          { category: "2025 Q4", value: null },
+        ],
+      },
+      {
+        id: "NVDA",
+        label: "NVDA",
+        color: "#4dabf7",
+        points: [
+          { category: "2025 Q1", value: 20 },
+          { category: "2025 Q3", value: 30 },
+          { category: "2025 Q4", value: null },
+        ],
+      },
+    ];
+    const scene = buildBarChartScene(sparseSeries, {
+      width: 36,
+      height: 8,
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666", negativeColor: "#ff5555" },
+    })!;
+
+    expect(scene.categories).toEqual(["2025 Q1", "2025 Q2", "2025 Q3"]);
+    const middleCategoryBars = scene.bars.filter((bar) => bar.category === "2025 Q2");
+    expect(middleCategoryBars).toHaveLength(1);
+    expect(middleCategoryBars[0]!.seriesCount).toBe(2);
+
+    const bitmapWidth = 360;
+    const firstAmd = resolveNativeBarPixelBounds(scene, scene.bars.find((bar) => bar.category === "2025 Q1" && bar.seriesId === "AMD")!, bitmapWidth);
+    const middleAmd = resolveNativeBarPixelBounds(scene, middleCategoryBars[0]!, bitmapWidth);
+    expect(middleAmd.rightExclusive - middleAmd.left).toBe(firstAmd.rightExclusive - firstAmd.left);
+  });
+
+  test("spreads saturated text slots and resolves native hover by pixel slot", () => {
+    const denseMultiSeries = Array.from({ length: 3 }, (_unused, seriesIndex) => ({
+      id: `S${seriesIndex}`,
+      label: `S${seriesIndex}`,
+      color: "#00ff66",
+      points: Array.from({ length: 80 }, (_point, categoryIndex) => ({
+        category: `${2020 + Math.floor(categoryIndex / 4)} Q${categoryIndex % 4 + 1}`,
+        value: seriesIndex + categoryIndex + 1,
+      })),
+    }));
+    const scene = buildBarChartScene(denseMultiSeries, {
+      width: 80,
+      height: 8,
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666", negativeColor: "#ff5555" },
+    })!;
+
+    const xPositions = scene.bars.map((bar) => bar.x);
+    expect(Math.min(...xPositions)).toBe(0);
+    expect(Math.max(...xPositions)).toBe(scene.width - 1);
+    expect(new Set(xPositions).size).toBe(scene.width);
+    expect(xPositions.filter((x) => x === scene.width - 1).length).toBeLessThanOrEqual(denseMultiSeries.length);
+
+    const target = scene.bars.find((bar, index) => (
+      scene.bars.findIndex((candidate) => candidate.x === bar.x) < index
+    ))!;
+    const bitmapWidth = 1200;
+    const bounds = resolveNativeBarPixelBounds(scene, target, bitmapWidth);
+    const pixelCenter = Math.floor((bounds.left + bounds.rightExclusive - 1) / 2);
+
+    expect(scene.bars.filter((bar) => bar.x === target.x).length).toBeGreaterThan(1);
+    expect(resolveBarChartHover(scene, target.x)).not.toMatchObject({
+      seriesId: target.seriesId,
+      category: target.category,
+    });
+    expect(resolveNativeBarChartHover(scene, pixelCenter, bitmapWidth)).toMatchObject({
+      seriesId: target.seriesId,
+      category: target.category,
+      value: target.value,
+    });
+  });
 });