gloomberb 0.15.1 → 0.15.3

package/src/components/chart/native/kitty/index.test.ts

@@ -1,537 +0,0 @@
-import type { CliRenderer } from "@opentui/core";
-import { describe, expect, test } from "bun:test";
-import {
-  computeBitmapSize,
-  computeNativePlacement,
-  excludeCellRects,
-  renderCrosshairStrips,
-  type CellRect,
-} from "../chart-rasterizer";
-import { resolveChartRendererState } from "../renderer-selection";
-import { NativeSurfaceManager, computeSurfaceVisibleFragments } from "../surface/manager";
-import { resolveNativeSurfaceVisibleRect, type NativeSurfaceRenderableNode } from "../surface/visibility";
-import { KittyImageManager } from "./manager";
-import { chunkBase64Payload, encodeKittyTransmitRgba } from "./protocol";
-import {
-  ensureKittySupport,
-  getCachedKittySupport,
-  resolveKittySupport,
-} from "./support";
-
-describe("resolveChartRendererState", () => {
-  test("resolves auto and forced kitty correctly", () => {
-    expect(resolveChartRendererState("auto", true, { width: 1200, height: 800 })).toMatchObject({
-      renderer: "kitty",
-      nativeReady: true,
-      nativeUnavailable: false,
-    });
-    expect(resolveChartRendererState("auto", false, { width: 1200, height: 800 })).toMatchObject({
-      renderer: "braille",
-      nativeReady: false,
-      nativeUnavailable: false,
-    });
-    expect(resolveChartRendererState("kitty", false, null)).toMatchObject({
-      renderer: "braille",
-      nativeReady: false,
-      nativeUnavailable: true,
-    });
-    expect(resolveChartRendererState("braille", true, { width: 1200, height: 800 })).toMatchObject({
-      renderer: "braille",
-      nativeReady: true,
-      nativeUnavailable: false,
-    });
-  });
-});
-
-describe("resolveKittySupport", () => {
-  const noMultiplexer = { TERM: "xterm-kitty" } as Record<string, string | undefined>;
-
-  test("never claims support behind a multiplexer, whatever it advertises", () => {
-    expect(resolveKittySupport({ kitty_graphics: true, multiplexer: "tmux" }, noMultiplexer)).toBe(false);
-    expect(resolveKittySupport({ kitty_graphics: true }, { TERM: "tmux-256color" })).toBe(false);
-    expect(resolveKittySupport({ kitty_graphics: true }, { TERM_PROGRAM: "tmux" })).toBe(false);
-    expect(resolveKittySupport({ kitty_graphics: true }, { TMUX: "/tmp/tmux-501/default,1,0" })).toBe(false);
-  });
-
-  test("keeps confirmed support and leaves an unanswered query undecided", () => {
-    expect(resolveKittySupport({ kitty_graphics: true, multiplexer: "none" }, noMultiplexer)).toBe(true);
-    expect(resolveKittySupport({ kitty_graphics: false }, noMultiplexer)).toBe(false);
-    expect(resolveKittySupport({}, noMultiplexer)).toBe(null);
-    expect(resolveKittySupport(null, noMultiplexer)).toBe(null);
-  });
-});
-
-describe("getCachedKittySupport", () => {
-  test("prefers later renderer capabilities over a failed query cache", async () => {
-    let capabilities: { kitty_graphics?: boolean; multiplexer?: string } | null = null;
-    const renderer = {
-      isDestroyed: false,
-      get capabilities() {
-        return capabilities;
-      },
-      on() {},
-      off() {},
-      write() {
-        return false;
-      },
-    } as unknown as CliRenderer;
-
-    expect(await ensureKittySupport(renderer)).toBe(false);
-    expect(getCachedKittySupport(renderer)).toBe(false);
-
-    capabilities = { kitty_graphics: true, multiplexer: "none" };
-    expect(getCachedKittySupport(renderer)).toBe(true);
-  });
-});
-
-describe("encodeKittyTransmitRgba", () => {
-  test("chunks compressed rgba uploads and keeps metadata on the first chunk", () => {
-    const rgba = new Uint8Array(64).fill(255);
-    const sequences = encodeKittyTransmitRgba({
-      imageId: 41,
-      width: 4,
-      height: 4,
-      rgba,
-      chunkSize: 8,
-    });
-
-    expect(sequences.length).toBeGreaterThan(1);
-    expect(sequences[0]).toContain("a=t");
-    expect(sequences[0]).toContain("f=32");
-    expect(sequences[0]).toContain("o=z");
-    expect(sequences[0]).toContain("i=41");
-    expect(sequences[0]).toContain("s=4");
-    expect(sequences[0]).toContain("v=4");
-    expect(sequences[0]).toContain("m=1");
-    expect(sequences[1]).not.toContain("a=t");
-    expect(sequences[sequences.length - 1]).toContain("m=0");
-  });
-
-  test("splits base64 payloads deterministically", () => {
-    expect(chunkBase64Payload("abcdefghijkl", 5)).toEqual(["abcde", "fghij", "kl"]);
-  });
-});
-
-describe("computeNativePlacement", () => {
-  test("maps clipped cell rectangles back into source pixel crops", () => {
-    const fullRect: CellRect = { x: 5, y: 4, width: 10, height: 6 };
-    const visibleRect: CellRect = { x: 8, y: 6, width: 4, height: 3 };
-    const bitmapSize = computeBitmapSize(fullRect, { width: 1000, height: 600 }, 100, 30);
-    const placement = computeNativePlacement(
-      fullRect,
-      visibleRect,
-      { width: bitmapSize.pixelWidth, height: bitmapSize.pixelHeight, pixels: new Uint8Array(0) },
-      { width: 1000, height: 600 },
-      100,
-      30,
-    );
-
-    expect(placement).toEqual({
-      column: 9,
-      row: 7,
-      cols: 4,
-      rows: 3,
-      cropX: 30,
-      cropY: 40,
-      cropWidth: 40,
-      cropHeight: 60,
-    });
-  });
-});
-
-describe("resolveNativeSurfaceVisibleRect", () => {
-  test("treats hidden ancestors as invisible for native graphics", () => {
-    const hiddenParent: NativeSurfaceRenderableNode = {
-      x: 0,
-      y: 0,
-      width: 80,
-      height: 20,
-      visible: false,
-      parent: null,
-    };
-    const child: NativeSurfaceRenderableNode = {
-      x: 2,
-      y: 3,
-      width: 20,
-      height: 8,
-      parent: hiddenParent,
-    };
-
-    expect(resolveNativeSurfaceVisibleRect(child, 100, 30)).toBeNull();
-  });
-
-  test("stops at repeated ancestors in cyclic native renderable trees", () => {
-    const root: NativeSurfaceRenderableNode = {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 30,
-      parent: null,
-    };
-    const child: NativeSurfaceRenderableNode = {
-      x: 2,
-      y: 3,
-      width: 20,
-      height: 8,
-      parent: root,
-    };
-    root.parent = child;
-
-    expect(resolveNativeSurfaceVisibleRect(child, 100, 30)).toEqual({
-      x: 2,
-      y: 3,
-      width: 20,
-      height: 8,
-    });
-  });
-
-  test("fails closed when native renderable ancestors exceed a sane depth", () => {
-    let node: NativeSurfaceRenderableNode = {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 30,
-      parent: null,
-    };
-
-    for (let index = 0; index < 300; index += 1) {
-      node = {
-        x: 0,
-        y: 0,
-        width: 100,
-        height: 30,
-        parent: node,
-      };
-    }
-
-    expect(resolveNativeSurfaceVisibleRect(node, 100, 30)).toBeNull();
-  });
-});
-
-describe("renderCrosshairStrips", () => {
-  const strips = renderCrosshairStrips({
-    pixelX: 49.5,
-    pixelY: 30.25,
-    pixelWidth: 120,
-    pixelHeight: 60,
-    cols: 12,
-    rows: 6,
-    cellWidth: 10,
-    cellHeight: 10,
-    color: "#ffffff",
-    markers: [{ pixelY: 12, color: "#ff00ff" }],
-  });
-
-  test("places thin strips on the cursor's cells with sub-cell line positions", () => {
-    const [vertical, horizontal] = strips;
-    // Cursor sits in column 4 and row 3; the vertical strip is padded by a cell.
-    expect(vertical!.rect).toEqual({ x: 3, y: 0, width: 3, height: 6 });
-    expect(horizontal!.rect).toEqual({ x: 0, y: 3, width: 12, height: 1 });
-    expect(vertical!.bitmap.width).toBe(30);
-    expect(vertical!.bitmap.height).toBe(60);
-    expect(horizontal!.bitmap.width).toBe(120);
-    expect(horizontal!.bitmap.height).toBe(10);
-
-    // Line pixels land at the cursor offset inside the strip, not at its edge.
-    const verticalOffset = (10 * vertical!.bitmap.width + 19) * 4;
-    expect(vertical!.bitmap.pixels[verticalOffset + 3]).toBeGreaterThan(0);
-    const horizontalOffset = (0 * horizontal!.bitmap.width + 60) * 4;
-    expect(horizontal!.bitmap.pixels[horizontalOffset + 3]).toBeGreaterThan(0);
-  });
-
-  test("draws series markers and stays transparent away from the cursor", () => {
-    const vertical = strips[0]!;
-    const markerOffset = (12 * vertical.bitmap.width + 19) * 4;
-    expect(vertical.bitmap.pixels[markerOffset]).toBeGreaterThan(180);
-    expect(vertical.bitmap.pixels[markerOffset + 2]).toBeGreaterThan(180);
-    expect(vertical.bitmap.pixels[(40 * vertical.bitmap.width + 1) * 4 + 3]).toBe(0);
-  });
-});
-
-describe("excludeCellRects", () => {
-  test("splits a surface into remaining visible fragments", () => {
-    expect(excludeCellRects(
-      { x: 10, y: 6, width: 12, height: 8 },
-      [{ x: 14, y: 8, width: 3, height: 2 }],
-    )).toEqual([
-      { x: 10, y: 6, width: 12, height: 2 },
-      { x: 10, y: 10, width: 12, height: 4 },
-      { x: 10, y: 8, width: 4, height: 2 },
-      { x: 17, y: 8, width: 5, height: 2 },
-    ]);
-  });
-});
-
-describe("computeSurfaceVisibleFragments", () => {
-  test("subtracts overlapping higher-layer occluders", () => {
-    expect(computeSurfaceVisibleFragments(
-      { x: 10, y: 6, width: 12, height: 8 },
-      { x: 10, y: 6, width: 12, height: 8 },
-      0,
-      "ticker-detail:main",
-      [{
-        id: "console:main",
-        paneId: "console:main",
-        rect: { x: 14, y: 8, width: 3, height: 2 },
-        zIndex: 90,
-      }],
-    )).toEqual([
-      { x: 10, y: 6, width: 12, height: 2 },
-      { x: 10, y: 8, width: 4, height: 2 },
-      { x: 17, y: 8, width: 5, height: 2 },
-      { x: 10, y: 10, width: 12, height: 4 },
-    ]);
-  });
-
-  test("ignores occluders from lower layers or the same pane", () => {
-    expect(computeSurfaceVisibleFragments(
-      { x: 10, y: 6, width: 12, height: 8 },
-      { x: 10, y: 6, width: 12, height: 8 },
-      120,
-      "chart:float",
-      [
-        {
-          id: "chart:float",
-          paneId: "chart:float",
-          rect: { x: 12, y: 8, width: 4, height: 2 },
-          zIndex: 120,
-        },
-        {
-          id: "console:main",
-          paneId: "console:main",
-          rect: { x: 14, y: 8, width: 3, height: 2 },
-          zIndex: 80,
-        },
-      ],
-    )).toEqual([
-      { x: 10, y: 6, width: 12, height: 8 },
-    ]);
-  });
-
-  test("subtracts an explicitly local overlay from its own pane", () => {
-    expect(computeSurfaceVisibleFragments(
-      { x: 10, y: 6, width: 12, height: 8 },
-      { x: 10, y: 6, width: 12, height: 8 },
-      120,
-      "chart:float",
-      [{
-        id: "chart:float:quick-add",
-        paneId: "chart:float",
-        rect: { x: 14, y: 6, width: 4, height: 3 },
-        zIndex: 120,
-        occludesOwnPane: true,
-      }],
-    )).toEqual([
-      { x: 10, y: 6, width: 4, height: 3 },
-      { x: 18, y: 6, width: 4, height: 3 },
-      { x: 10, y: 9, width: 12, height: 5 },
-    ]);
-  });
-});
-
-describe("KittyImageManager", () => {
-  test("reuses placement ids across multiple fragments and deletes the previous image on swap", () => {
-    const writes: string[] = [];
-    const renderer = {
-      write(payload: string | Uint8Array) {
-        writes.push(typeof payload === "string" ? payload : Buffer.from(payload).toString("utf8"));
-        return true;
-      },
-    } as unknown as CliRenderer;
-
-    const manager = new KittyImageManager(renderer);
-    const placements = [
-      {
-        column: 2,
-        row: 3,
-        cols: 4,
-        rows: 2,
-        cropX: 0,
-        cropY: 0,
-        cropWidth: 40,
-        cropHeight: 20,
-      },
-      {
-        column: 8,
-        row: 3,
-        cols: 2,
-        rows: 2,
-        cropX: 60,
-        cropY: 0,
-        cropWidth: 20,
-        cropHeight: 20,
-      },
-    ];
-
-    manager.render({ width: 40, height: 20, pixels: new Uint8Array(40 * 20 * 4) }, placements, "first");
-    manager.render({ width: 40, height: 20, pixels: new Uint8Array(40 * 20 * 4).fill(1) }, placements, "second");
-
-    const firstWrite = writes[0]!;
-    const secondWrite = writes[1]!;
-    const firstImageId = firstWrite.match(/i=(\d+)/)?.[1];
-    const secondImageId = secondWrite.match(/i=(\d+)/)?.[1];
-    const firstPlacementIds = [...firstWrite.matchAll(/p=(\d+)/g)].map((match) => match[1]);
-    const secondPlacementIds = [...secondWrite.matchAll(/p=(\d+)/g)].map((match) => match[1]);
-
-    expect(firstImageId).toBeTruthy();
-    expect(secondImageId).toBeTruthy();
-    expect(secondImageId).not.toBe(firstImageId);
-    expect(firstPlacementIds.length).toBeGreaterThanOrEqual(2);
-    expect(secondPlacementIds.slice(0, 2)).toEqual(firstPlacementIds.slice(0, 2));
-    expect(secondWrite).toContain(`a=d,d=I,i=${firstImageId!}`);
-  });
-});
-
-describe("NativeSurfaceManager", () => {
-  test("skips geometry sync work when the surface rect is unchanged", () => {
-    const writes: string[] = [];
-    const renderer = {
-      resolution: { width: 1200, height: 800 },
-      terminalWidth: 120,
-      terminalHeight: 40,
-      write(payload: string | Uint8Array) {
-        writes.push(typeof payload === "string" ? payload : Buffer.from(payload).toString("utf8"));
-        return true;
-      },
-    } as unknown as CliRenderer;
-
-    const manager = new NativeSurfaceManager(renderer);
-    manager.upsertSurface({
-      id: "chart",
-      paneId: "pane",
-      rect: { x: 2, y: 3, width: 20, height: 8 },
-      visibleRect: { x: 2, y: 3, width: 20, height: 8 },
-      bitmap: { width: 200, height: 80, pixels: new Uint8Array(200 * 80 * 4) },
-      bitmapKey: "frame-1",
-    });
-
-    expect(writes.length).toBe(1);
-
-    manager.updateSurfaceGeometry("chart", {
-      paneId: "pane",
-      rect: { x: 2, y: 3, width: 20, height: 8 },
-      visibleRect: { x: 2, y: 3, width: 20, height: 8 },
-    });
-
-    expect(writes.length).toBe(1);
-  });
-
-  test("clips and restores a surface as a local overlay opens and closes", () => {
-    const renderer = {
-      resolution: { width: 1200, height: 800 },
-      terminalWidth: 120,
-      terminalHeight: 40,
-      write() { return true; },
-    } as unknown as CliRenderer;
-    const manager = new NativeSurfaceManager(renderer);
-    const originalRender = KittyImageManager.prototype.render;
-    const renderedRowCounts: number[][] = [];
-    KittyImageManager.prototype.render = function(
-      _bitmap,
-      placement,
-    ) {
-      const placements = Array.isArray(placement) ? placement : [placement];
-      renderedRowCounts.push(placements.map((entry) => entry.rows));
-    };
-
-    try {
-      manager.setWindowState({
-        paneLayers: [{ paneId: "pane", zIndex: 120 }],
-        occluders: [],
-      });
-      manager.upsertSurface({
-        id: "chart",
-        paneId: "pane",
-        rect: { x: 2, y: 3, width: 20, height: 8 },
-        visibleRect: { x: 2, y: 3, width: 20, height: 8 },
-        bitmap: { width: 200, height: 80, pixels: new Uint8Array(200 * 80 * 4) },
-        bitmapKey: "frame-1",
-      });
-      manager.upsertLocalOccluder({
-        id: "quick-add",
-        paneId: "pane",
-        rect: { x: 2, y: 3, width: 20, height: 2 },
-      });
-      manager.removeLocalOccluder("quick-add");
-
-      expect(renderedRowCounts).toEqual([[8], [6], [8]]);
-    } finally {
-      KittyImageManager.prototype.render = originalRender;
-      manager.destroy();
-    }
-  });
-
-  test("skips rerendering when an identical surface snapshot is upserted", () => {
-    const renderer = {
-      resolution: { width: 1200, height: 800 },
-      terminalWidth: 120,
-      terminalHeight: 40,
-      write() { return true; },
-    } as unknown as CliRenderer;
-    const manager = new NativeSurfaceManager(renderer);
-    const originalRender = KittyImageManager.prototype.render;
-    let renderCalls = 0;
-    KittyImageManager.prototype.render = function(...args: Parameters<KittyImageManager["render"]>) {
-      renderCalls += 1;
-      return originalRender.apply(this, args);
-    };
-
-    try {
-      manager.upsertSurface({
-        id: "chart",
-        paneId: "pane",
-        rect: { x: 2, y: 3, width: 20, height: 8 },
-        visibleRect: { x: 2, y: 3, width: 20, height: 8 },
-        bitmap: { width: 200, height: 80, pixels: new Uint8Array(200 * 80 * 4) },
-        bitmapKey: "frame-1",
-      });
-      manager.upsertSurface({
-        id: "chart",
-        paneId: "pane",
-        rect: { x: 2, y: 3, width: 20, height: 8 },
-        visibleRect: { x: 2, y: 3, width: 20, height: 8 },
-        bitmap: { width: 200, height: 80, pixels: new Uint8Array(200 * 80 * 4).fill(1) },
-        bitmapKey: "frame-1",
-      });
-
-      expect(renderCalls).toBe(1);
-    } finally {
-      KittyImageManager.prototype.render = originalRender;
-      manager.destroy();
-    }
-  });
-
-  test("skips syncing all surfaces when the native window state is unchanged", () => {
-    const renderer = {
-      resolution: { width: 1200, height: 800 },
-      terminalWidth: 120,
-      terminalHeight: 40,
-      write() { return true; },
-    } as unknown as CliRenderer;
-    const manager = new NativeSurfaceManager(renderer);
-    const originalRender = KittyImageManager.prototype.render;
-    let renderCalls = 0;
-    KittyImageManager.prototype.render = function(...args: Parameters<KittyImageManager["render"]>) {
-      renderCalls += 1;
-      return originalRender.apply(this, args);
-    };
-
-    try {
-      manager.upsertSurface({
-        id: "chart",
-        paneId: "pane",
-        rect: { x: 2, y: 3, width: 20, height: 8 },
-        visibleRect: { x: 2, y: 3, width: 20, height: 8 },
-        bitmap: { width: 200, height: 80, pixels: new Uint8Array(200 * 80 * 4) },
-        bitmapKey: "frame-1",
-      });
-      manager.setWindowState({ paneLayers: [], occluders: [] });
-      manager.setWindowState({ paneLayers: [], occluders: [] });
-
-      expect(renderCalls).toBe(1);
-    } finally {
-      KittyImageManager.prototype.render = originalRender;
-      manager.destroy();
-    }
-  });
-});

package/src/components/chart/static/chart-surface.test.tsx

@@ -1,159 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { act, useEffect } from "react";
-import { testRender } from "../../../renderers/opentui/test-utils";
-import { colors } from "../../../theme/colors";
-import { RemoteUiRegistryProvider, useRemoteUiRegistry, type RemoteUiRegistry } from "../../../remote/semantic-tree";
-import { resolveChartPalette } from "../core/palette";
-import { StaticChartSurface, buildStaticChartSeries } from "./chart-surface";
-import type { ProjectedChartPoint } from "../core/data";
-import { buildCompositeChartScene } from "../composite/scene";
-
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
-let remoteRegistry: RemoteUiRegistry | null = null;
-
-afterEach(async () => {
-  const setup = testSetup;
-  testSetup = undefined;
-  remoteRegistry = null;
-  if (!setup) return;
-  await act(async () => {
-    setup.renderer.destroy();
-  });
-});
-
-const points: ProjectedChartPoint[] = [
-  { date: new Date("2026-01-01"), open: 3.5, high: 3.5, low: 3.5, close: 3.5, volume: 0 },
-  { date: new Date("2026-01-02"), open: 4.1, high: 4.1, low: 4.1, close: 4.1, volume: 0 },
-  { date: new Date("2026-01-03"), open: 4.9, high: 4.9, low: 4.9, close: 4.9, volume: 0 },
-];
-
-function RemoteRegistryProbe() {
-  const registry = useRemoteUiRegistry();
-  useEffect(() => {
-    remoteRegistry = registry;
-  }, [registry]);
-  return null;
-}
-
-describe("StaticChartSurface", () => {
-  test("calendar step charts preserve unequal time gaps and hold values until the next change", () => {
-    const irregular = points.map((point, index) => ({ ...point, date: new Date(`2026-01-${["01", "02", "11"][index]}`) }));
-    const series = buildStaticChartSeries(irregular, "step", "#00ff00", [], true);
-    const scene = buildCompositeChartScene(series, [{ id: "main" }], { width: 80, height: 10 });
-    expect(scene?.timeScale.kind).toBe("calendar");
-    const primary = scene!.panels[0]!.series[0]!;
-    expect(primary.source.style).toBe("step");
-    const [first, second, last] = primary.points;
-    expect((second!.xRatio - first!.xRatio) / (last!.xRatio - first!.xRatio)).toBeCloseTo(0.1, 10);
-    expect(primary.points.map((point) => point.value)).toEqual([3.5, 4.1, 4.9]);
-  });
-
-  test("aligns an index-keyed overlay to the primary observations", () => {
-    const [primary, overlay] = buildStaticChartSeries(points, "line", "#00ff00", [
-      { id: "secondary", color: "#ffaa00", points: [{ index: 0, value: 1 }, { index: 2, value: 3 }, { index: 9, value: 4 }] },
-    ]);
-    expect(primary?.timeBasis?.kind).toBe("market");
-    expect(overlay?.points.map((point) => [point.date.toISOString().slice(0, 10), point.value]))
-      .toEqual([["2026-01-01", 1], ["2026-01-03", 3]]);
-  });
-
-  test("renders the y-axis title with custom tick labels", async () => {
-    testSetup = await testRender(
-      <StaticChartSurface
-        points={points}
-        width={48}
-        height={10}
-        mode="line"
-        colors={resolveChartPalette(colors, "positive")}
-        yAxisLabel="Yield (%)"
-        yAxisColor={colors.textDim}
-        formatYAxisValue={(value) => `${value.toFixed(2)}%`}
-      />,
-      { width: 50, height: 12 },
-    );
-
-    await act(async () => {
-      await testSetup!.renderOnce();
-      await testSetup!.renderOnce();
-    });
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("Yield (%)");
-    expect(frame).toMatch(/\d\.\d\d%/);
-  });
-
-  test("renders custom x-axis labels and decision markers instead of dates", async () => {
-    testSetup = await testRender(
-      <StaticChartSurface
-        points={points}
-        width={56}
-        height={10}
-        mode="line"
-        colors={resolveChartPalette(colors, "positive")}
-        xAxisLabels={["0%", "50%", "100%"]}
-        xMarkers={[
-          { id: "current", xRatio: 0.1, label: "current", lineChar: "┊" },
-          { id: "target", xRatio: 0.5, label: "target", lineChar: "┃" },
-          { id: "full", xRatio: 0.8, label: "full", lineChar: "│" },
-        ]}
-        xAxisColor={colors.textDim}
-      />,
-      { width: 58, height: 12 },
-    );
-
-    await act(async () => {
-      await testSetup!.renderOnce();
-      await testSetup!.renderOnce();
-    });
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("0%");
-    expect(frame).toContain("50%");
-    expect(frame).toContain("100%");
-    expect(frame).not.toContain("Jan");
-    expect(frame).toContain("current");
-    expect(frame).toContain("target");
-    expect(frame).toContain("full");
-    expect(frame).toContain("┃");
-  });
-
-  test("moves a remote-controlled cursor and labels both axes through the formatters", async () => {
-    testSetup = await testRender(
-      <RemoteUiRegistryProvider>
-        <RemoteRegistryProbe />
-        <StaticChartSurface
-          points={points}
-          width={48}
-          height={10}
-          mode="line"
-          colors={resolveChartPalette(colors, "positive")}
-          xAxisLabels={["0%", "50%", "100%"]}
-          formatXAxisCursorValue={(ratio) => `X${Math.round(ratio * 100)}`}
-          formatYAxisValue={(value) => `Y${value.toFixed(2)}`}
-        />
-      </RemoteUiRegistryProvider>,
-      { width: 50, height: 12 },
-    );
-
-    await act(async () => {
-      await testSetup!.renderOnce();
-      await testSetup!.renderOnce();
-    });
-    const initialFrame = testSetup.captureCharFrame();
-    const chartNode = remoteRegistry?.snapshot().find((node) => node.metadata?.kind === "static-chart");
-    expect(chartNode?.actions).toContain("moveCursor");
-
-    await act(async () => {
-      await remoteRegistry!.invoke(chartNode!.id, "moveCursor", { x: 20, y: 4 });
-    });
-    await act(async () => {
-      await testSetup!.renderOnce();
-      await testSetup!.renderOnce();
-    });
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).not.toBe(initialFrame);
-    expect(frame).toMatch(/X\d+/);
-    expect(frame).toMatch(/Y\d\.\d\d/);
-  });
-});