gloomberb 0.9.5 → 0.9.7

package/src/remote/server.ts

@@ -0,0 +1,121 @@
+import { randomUUID } from "crypto";
+import { createServer, type IncomingMessage, type ServerResponse } from "http";
+import type { RemoteAppKind, RemoteControlRequest, RemoteControlResponse, RemoteEndpoint } from "./types";
+import { REMOTE_CONTROL_PROTOCOL_VERSION } from "./types";
+import { removeRemoteEndpointFiles, writeRemoteEndpointFiles } from "./endpoint";
+
+export interface RemoteControlServerOptions {
+  dataDir: string;
+  appKind: RemoteAppKind;
+  handle: (request: RemoteControlRequest) => Promise<RemoteControlResponse>;
+}
+
+export interface RemoteControlServer {
+  endpoint: RemoteEndpoint;
+  close(): Promise<void>;
+}
+
+const MAX_BODY_BYTES = 2 * 1024 * 1024;
+
+export async function startRemoteControlServer(options: RemoteControlServerOptions): Promise<RemoteControlServer> {
+  const token = randomUUID();
+  const httpServer = createServer((request, response) => {
+    void handleHttpRequest(options.handle, token, request, response);
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => {
+      httpServer.off("error", reject);
+      resolve();
+    });
+  });
+
+  const address = httpServer.address();
+  if (!address || typeof address === "string") {
+    httpServer.close();
+    throw new Error("Remote control server did not bind to a TCP port.");
+  }
+
+  const endpoint: RemoteEndpoint = {
+    protocolVersion: REMOTE_CONTROL_PROTOCOL_VERSION,
+    appKind: options.appKind,
+    pid: process.pid,
+    port: address.port,
+    token,
+    startedAt: new Date().toISOString(),
+  };
+  await writeRemoteEndpointFiles(options.dataDir, endpoint);
+
+  return {
+    endpoint,
+    close: async () => {
+      await new Promise<void>((resolve, reject) => {
+        httpServer.close((error) => (error ? reject(error) : resolve()));
+      }).catch((error) => {
+        if ((error as NodeJS.ErrnoException).code !== "ERR_SERVER_NOT_RUNNING") throw error;
+      });
+      await removeRemoteEndpointFiles(options.dataDir, endpoint);
+    },
+  };
+}
+
+async function handleHttpRequest(
+  handle: RemoteControlServerOptions["handle"],
+  token: string,
+  request: IncomingMessage,
+  response: ServerResponse,
+): Promise<void> {
+  try {
+    if (request.method === "GET" && request.url === "/health") {
+      sendJson(response, 200, { ok: true });
+      return;
+    }
+    if (request.method !== "POST" || request.url !== "/rpc") {
+      sendJson(response, 404, { ok: false, error: { code: "not_found", message: "Unknown remote control endpoint." } });
+      return;
+    }
+    if (request.headers.authorization !== `Bearer ${token}`) {
+      sendJson(response, 401, { ok: false, error: { code: "unauthorized", message: "Invalid remote control token." } });
+      return;
+    }
+
+    const body = await readBody(request);
+    const remoteRequest = JSON.parse(body) as RemoteControlRequest;
+    sendJson(response, 200, await handle(remoteRequest));
+  } catch (error) {
+    sendJson(response, 500, {
+      ok: false,
+      error: {
+        code: "remote_transport_error",
+        message: error instanceof Error ? error.message : String(error),
+      },
+    });
+  }
+}
+
+async function readBody(request: IncomingMessage): Promise<string> {
+  let total = 0;
+  const chunks: Uint8Array[] = [];
+  for await (const chunk of request) {
+    const bytes = chunk instanceof Uint8Array ? new Uint8Array(chunk) : new TextEncoder().encode(String(chunk));
+    total += bytes.byteLength;
+    if (total > MAX_BODY_BYTES) throw new Error("Remote control request is too large.");
+    chunks.push(bytes);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(body);
+}
+
+function sendJson(response: ServerResponse, status: number, body: unknown): void {
+  response.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+  });
+  response.end(JSON.stringify(body));
+}

package/src/remote/types.ts

@@ -0,0 +1,119 @@
+export const REMOTE_CONTROL_PROTOCOL_VERSION = 1;
+
+export type RemoteAppKind = "tui" | "desktop";
+
+export interface RemoteEndpoint {
+  protocolVersion: number;
+  appKind: RemoteAppKind;
+  pid: number;
+  port: number;
+  token: string;
+  startedAt: string;
+}
+
+export interface RemoteJsonPatchOperation {
+  op: "add" | "replace" | "remove";
+  path: string;
+  value?: unknown;
+}
+
+export type RemoteStateInclude =
+  | "app"
+  | "layout"
+  | "panes"
+  | "commandBar"
+  | "commandBar.results"
+  | "ui"
+  | "schema"
+  | "help"
+  | "all";
+
+export type RemoteControlRequest =
+  | { type: "help"; topic?: string }
+  | { type: "schema" }
+  | { type: "get"; resource: string; include?: RemoteStateInclude[] }
+  | { type: "call"; operation: string; input?: unknown; dryRun?: boolean; include?: RemoteStateInclude[] }
+  | {
+    type: "patch";
+    resource: string;
+    patch: RemoteJsonPatchOperation[];
+    expectRev?: string;
+    dryRun?: boolean;
+    include?: RemoteStateInclude[];
+  }
+  | {
+    type: "batch";
+    requests: RemoteControlRequest[];
+    dryRun?: boolean;
+    haltOnError?: boolean;
+    settle?: "none" | "afterEach" | "afterBatch";
+    include?: RemoteStateInclude[];
+  };
+
+export interface RemoteIncludedState {
+  rev: string;
+  included: RemoteStateInclude[];
+  app?: unknown;
+  layout?: unknown;
+  panes?: unknown;
+  commandBar?: unknown;
+  ui?: RemoteUiNodeSnapshot[];
+  schema?: RemoteControlSchema;
+  help?: unknown;
+}
+
+export interface RemoteControlSuccess<T = unknown> {
+  ok: true;
+  data: T;
+  rev?: string;
+  state?: RemoteIncludedState;
+  warnings?: string[];
+}
+
+export interface RemoteControlFailure {
+  ok: false;
+  error: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+}
+
+export type RemoteControlResponse<T = unknown> =
+  | RemoteControlSuccess<T>
+  | RemoteControlFailure;
+
+export interface RemoteResourceSchema {
+  uri: string;
+  description: string;
+  patchable?: boolean;
+}
+
+export interface RemoteOperationSchema {
+  id: string;
+  description: string;
+  inputShape?: string;
+  outputShape?: string;
+  returns?: string;
+  recommendedNextReads?: string[];
+  examples?: unknown[];
+  sideEffectLevel: "none" | "local-write" | "network-write" | "external-side-effect" | "external-trade";
+  requiresConfirmation?: boolean;
+  dryRun?: boolean;
+}
+
+export interface RemoteControlSchema {
+  protocolVersion: number;
+  resources: RemoteResourceSchema[];
+  operations: RemoteOperationSchema[];
+  help: unknown;
+}
+
+export interface RemoteUiNodeSnapshot {
+  id: string;
+  role: string;
+  label?: string;
+  disabled?: boolean;
+  actions: string[];
+  metadata?: Record<string, unknown>;
+}

package/src/renderers/electrobun/bun/index.ts

@@ -55,6 +55,8 @@ import {
   desktopWindowStyleMask,
 } from "./desktop/window-style";
 import { applyDesktopWindowControl, type DesktopWindowControlAction } from "./desktop/window-controls";
+import { startRemoteControlServer, type RemoteControlServer } from "../../../remote/server";
+import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 type DesktopRpc = ReturnType<typeof BrowserView.defineRPC<ElectrobunDesktopRpcSchema>>;
 
@@ -70,6 +72,7 @@ let services: AppServices | null = null;
 let mainWindow: BrowserWindow | null = null;
 let desktopWorkspace: DesktopWorkspace | null = null;
 let desktopRestartInProgress = false;
+let desktopRemoteControlServer: RemoteControlServer | null = null;
 
 const windowRpcRegistry = createDesktopRpcRegistry<DesktopRpc>();
 const contextMenuRequestRpcs = new Map<string, DesktopRpc>();
@@ -100,6 +103,10 @@ function requireDesktopWorkspace(): DesktopWorkspace {
   return desktopWorkspace;
 }
 
+function remoteFailure(code: string, message: string): RemoteControlResponse {
+  return { ok: false, error: { code, message } };
+}
+
 const {
   forEachReadyWindowRpc,
   getRpcWindowKey,
@@ -130,6 +137,46 @@ const detachedWindowManager = new DesktopDetachedWindowManager<DesktopRpc>({
   stateBroadcaster: desktopStateBroadcaster,
 });
 
+async function forwardRemoteControlRequest(request: RemoteControlRequest): Promise<RemoteControlResponse> {
+  const rpc = getWindowRpc(MAIN_WINDOW_RPC_KEY);
+  if (!rpc || !isWindowRpcReady(MAIN_WINDOW_RPC_KEY)) {
+    return remoteFailure("remote_unavailable", "The main desktop window is not ready for remote control requests.");
+  }
+  try {
+    const response = await rpc.request["remote.request"]({
+      request: encodeRpcValue(request) as RemoteControlRequest,
+    });
+    return decodeRpcValue<RemoteControlResponse>(response);
+  } catch (error) {
+    return remoteFailure(
+      "remote_forward_error",
+      error instanceof Error ? error.message : String(error),
+    );
+  }
+}
+
+async function ensureDesktopRemoteControlServer(): Promise<void> {
+  if (desktopRemoteControlServer) return;
+  const config = requireConfig();
+  desktopRemoteControlServer = await startRemoteControlServer({
+    dataDir: config.dataDir,
+    appKind: "desktop",
+    handle: forwardRemoteControlRequest,
+  });
+  console.error("[remote] desktop control endpoint started", {
+    port: desktopRemoteControlServer.endpoint.port,
+  });
+}
+
+function stopDesktopRemoteControlServer(): void {
+  const server = desktopRemoteControlServer;
+  desktopRemoteControlServer = null;
+  if (!server) return;
+  void server.close().catch((error) => {
+    console.error("[remote] desktop control endpoint cleanup failed", summarizeError(error));
+  });
+}
+
 function openMainWindowDevTools(): void {
   mainWindow?.webview.openDevTools();
 }
@@ -228,6 +275,7 @@ function disposeWindowScopedResources(windowKey: string): void {
 }
 
 function teardownServices(): void {
+  stopDesktopRemoteControlServer();
   capabilityBridge.disposeAll();
   services?.destroy();
   services = null;
@@ -306,7 +354,7 @@ async function initialize(
   rpc: DesktopRpc,
   payload: Record<string, unknown>,
 ) {
-  return initializeDesktopBackend({
+  const init = await initializeDesktopBackend({
     getCurrentConfig: () => currentConfig,
     getCurrentServices: () => services,
     getDesktopSnapshot,
@@ -328,6 +376,12 @@ async function initialize(
     },
     syncConfigAccessors,
   });
+  if (init.windowKind === "main") {
+    void ensureDesktopRemoteControlServer().catch((error) => {
+      console.error("[remote] desktop control endpoint failed", summarizeError(error));
+    });
+  }
+  return init;
 }
 
 async function handleBackendRequest(

package/src/renderers/electrobun/shared/protocol.ts

@@ -4,6 +4,7 @@ import type { DesktopApplicationMenuCommand } from "../../../types/desktop-menu"
 import type { AppConfig } from "../../../types/config";
 import type { UpdateProgress } from "../../../updater";
 import type { CapabilityManifest } from "../../../capabilities";
+import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 export const ELECTROBUN_CONTEXT_MENU_ACTION = "gloom.context-menu.select";
 
@@ -59,6 +60,10 @@ export interface DesktopRestartMessage {
   source?: string;
 }
 
+export interface RemoteControlRequestMessage {
+  request: RemoteControlRequest;
+}
+
 export interface ElectrobunDesktopRpcSchema {
   bun: {
     requests: {
@@ -72,7 +77,12 @@ export interface ElectrobunDesktopRpcSchema {
     };
   };
   webview: {
-    requests: {};
+    requests: {
+      "remote.request": {
+        params: RemoteControlRequestMessage;
+        response: RemoteControlResponse;
+      };
+    };
     messages: {
       "context-menu.select": ContextMenuSelectMessage;
       "application-menu.select": ApplicationMenuSelectMessage;

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -9,10 +9,12 @@ import {
   type DesktopStateMessage,
   type DesktopThemePreviewMessage,
   type ElectrobunBackendInit,
+  type RemoteControlRequestMessage,
   type ElectrobunDesktopRpcSchema,
   type UpdateProgressMessage,
 } from "../shared/protocol";
 import { decodeRpcValue, encodeRpcValue } from "./rpc-codec";
+import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 type ContextMenuSelectListener = (message: ContextMenuSelectMessage) => void;
 type ApplicationMenuSelectListener = (message: ApplicationMenuSelectMessage) => void;
@@ -21,8 +23,10 @@ type DesktopDockPreviewListener = (message: DesktopDockPreviewMessage) => void;
 type DesktopThemePreviewListener = (message: DesktopThemePreviewMessage) => void;
 type UpdateProgressListener = (message: UpdateProgressMessage) => void;
 type CapabilityEventListener = (message: CapabilityEventMessage) => void;
+type RemoteControlRequestHandler = (request: RemoteControlRequest) => Promise<RemoteControlResponse>;
 
 let initSnapshot: ElectrobunBackendInit | null = null;
+let remoteControlRequestHandler: RemoteControlRequestHandler | null = null;
 const contextMenuSelectListeners = new Map<string, Set<ContextMenuSelectListener>>();
 const applicationMenuSelectListeners = new Set<ApplicationMenuSelectListener>();
 const desktopStateListeners = new Set<DesktopStateListener>();
@@ -63,7 +67,21 @@ function subscribe<T>(
 const rpc = Electroview.defineRPC<ElectrobunDesktopRpcSchema>({
   maxRequestTime: 120_000,
   handlers: {
-    requests: {},
+    requests: {
+      "remote.request": async (message: RemoteControlRequestMessage) => {
+        if (!remoteControlRequestHandler) {
+          return {
+            ok: false,
+            error: {
+              code: "remote_unavailable",
+              message: "The desktop app has not installed a remote control handler yet.",
+            },
+          };
+        }
+        const decoded = decodeRpcValue<RemoteControlRequest>(message.request);
+        return encodeRpcValue(await remoteControlRequestHandler(decoded)) as RemoteControlResponse;
+      },
+    },
     messages: {
       "context-menu.select": (message) => {
         dispatch(contextMenuSelectListeners, message.requestId, message);
@@ -140,6 +158,15 @@ export function getElectrobunBackendInitSnapshot(): ElectrobunBackendInit | null
   return initSnapshot;
 }
 
+export function setElectrobunRemoteRequestHandler(handler: RemoteControlRequestHandler | null): () => void {
+  remoteControlRequestHandler = handler;
+  return () => {
+    if (remoteControlRequestHandler === handler) {
+      remoteControlRequestHandler = null;
+    }
+  };
+}
+
 export function onCapabilityEvent(
   subscriptionId: string,
   listener: (message: CapabilityEventMessage) => void,

package/src/renderers/electrobun/view/build-assets.ts

@@ -23,6 +23,7 @@ const COMMON_ALIAS_RULES: AliasRule[] = [
   ["./kitty/support", "components/chart/native/renderer-selection.ts", "native-stubs/chart/kitty-support.ts"],
   ["native/surface/manager", "native-stubs/chart/surface-manager.ts"],
   ["native/surface/sync", "native-stubs/chart/surface-sync.ts"],
+  ["./native-loader", "plugins/ibkr/gateway/service/index.ts", "native-stubs/ibkr-native-loader.ts"],
 ];
 
 export function electrobunViewPath(...parts: string[]): string {

package/src/renderers/electrobun/view/host/box.tsx

@@ -135,6 +135,10 @@ export const WebBox = forwardRef<HTMLDivElement, Record<string, unknown> & { chi
       callMouseHandler(propsRef.current.onMouseScroll, event, "scroll");
     };
 
+    const handleMouseOver = (event: MouseEvent) => {
+      callMouseHandler(propsRef.current.onMouseOver, event, "over");
+    };
+
     const handleMouseOut = (event: MouseEvent) => {
       pendingMoveRef.current = null;
       callMouseHandler(propsRef.current.onMouseOut, event, "out");
@@ -147,6 +151,7 @@ export const WebBox = forwardRef<HTMLDivElement, Record<string, unknown> & { chi
         data-gloom-interactive={hasDirectMouseHandler(props) ? "true" : undefined}
         ref={elementRef}
         onMouseDown={handleMouseDown}
+        onMouseOver={handleMouseOver}
         onMouseMove={(event) => scheduleFrameMouseHandler(event, "move")}
         onMouseUp={(event) => callMouseHandler(propsRef.current.onMouseUp, event, "up")}
         onMouseOut={handleMouseOut}

package/src/renderers/electrobun/view/host/mouse.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { hasDirectMouseHandler, mouseHandlers } from "./mouse";
+
+function fakeMouseEvent() {
+  return {
+    clientX: 16,
+    clientY: 36,
+    button: 0,
+    detail: 0,
+    timeStamp: 1,
+    shiftKey: false,
+    altKey: false,
+    ctrlKey: false,
+    metaKey: false,
+    preventDefault() {},
+    stopPropagation() {},
+  };
+}
+
+describe("desktop web mouse host", () => {
+  test("forwards mouse over handlers", () => {
+    let cellX = -1;
+    let cellY = -1;
+    const handlers = mouseHandlers({
+      onMouseOver: (event: { x: number; y: number }) => {
+        cellX = event.x;
+        cellY = event.y;
+      },
+    });
+
+    handlers.onMouseOver?.(fakeMouseEvent() as never);
+
+    expect(cellX).toBe(2);
+    expect(cellY).toBe(2);
+    expect(hasDirectMouseHandler({ onMouseOver: () => {} })).toBe(true);
+  });
+});

package/src/renderers/electrobun/view/host/mouse.ts

@@ -73,6 +73,7 @@ export function mouseHandlers(props: Record<string, unknown>) {
   );
   return {
     onMouseDown: wrap(props.onMouseDown),
+    onMouseOver: wrap(props.onMouseOver),
     onMouseMove: wrap(props.onMouseMove),
     onMouseUp: wrap(props.onMouseUp),
     onMouseOut: wrap(props.onMouseOut),
@@ -91,6 +92,7 @@ export function callCellMouseHandler(handler: unknown, event: CellMouseEvent): v
 
 export function hasDirectMouseHandler(props: Record<string, unknown>): boolean {
   return typeof props.onMouseDown === "function"
+    || typeof props.onMouseOver === "function"
     || typeof props.onMouseUp === "function"
     || typeof props.onMouseMove === "function"
     || typeof props.onMouseOut === "function"

package/src/renderers/electrobun/view/main.tsx

@@ -5,7 +5,7 @@ import { App } from "../../../app";
 import { UiHostProvider } from "../../../ui/host";
 import { debugLog } from "../../../utils/debug-log";
 import { measurePerfAsync } from "../../../utils/perf-marks";
-import { backendRequest, initElectrobunBackend } from "./backend-rpc";
+import { backendRequest, initElectrobunBackend, setElectrobunRemoteRequestHandler } from "./backend-rpc";
 import { installElectrobunAiHost } from "./ai-host";
 import { installElectrobunBrokerRemoteClient } from "./broker-remote-client";
 import { installElectrobunConfigStoreHost } from "./config-host";
@@ -89,6 +89,9 @@ async function boot() {
   const desktopWindowBridge = createDesktopWindowBridge(init.windowKind, init.paneId);
   const desktopApplicationMenuBridge = createApplicationMenuBridge();
   const webUiHost = createWebUiHost(init.desktopPlatform);
+  const remoteControlAdapter = init.windowKind === "main"
+    ? { registerHandler: setElectrobunRemoteRequestHandler }
+    : undefined;
   measurePerfAsync("startup.electrobun.root-render", async () => {
     root.render(
       <ElectrobunErrorBoundary>
@@ -102,6 +105,7 @@ async function boot() {
                   desktopApplicationMenuBridge={desktopApplicationMenuBridge}
                   desktopSnapshot={desktopSnapshot}
                   desktopThemePreview={init.desktopThemePreview}
+                  remoteControlAdapter={remoteControlAdapter}
                 />
               </WebDialogHostProvider>
             </WebToastHostProvider>

package/src/renderers/electrobun/view/native-stubs/ibkr-native-loader.ts

@@ -0,0 +1,3 @@
+export function loadNativeGatewayModule(): Promise<never> {
+  return Promise.reject(new Error("IBKR native gateway is unavailable in the desktop web renderer."));
+}

package/src/renderers/opentui/chart-surface.test.tsx

@@ -0,0 +1,101 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { createTestRenderer } from "@opentui/core/testing";
+import { act } from "react";
+import { ChartSurface, Text } from "../../ui";
+import { getNativeSurfaceManager } from "../../components/chart/native/surface/manager";
+import type { ChartRendererPreference } from "../../components/chart/core/types";
+import { AppProvider } from "../../state/app/context";
+import { createDefaultConfig } from "../../types/config";
+import { createOpenTuiTestRoot } from "./test-utils";
+
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
+let root: ReturnType<typeof createOpenTuiTestRoot> | undefined;
+const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+
+const bitmap = {
+  width: 4,
+  height: 4,
+  pixels: new Uint8Array(4 * 4 * 4).fill(255),
+};
+
+function setNativeRendererReady(): void {
+  (testSetup!.renderer as { _capabilities: unknown })._capabilities = { kitty_graphics: true };
+  (testSetup!.renderer as { _resolution: unknown })._resolution = { width: 800, height: 400 };
+}
+
+function surfaceCount(): number {
+  const manager = getNativeSurfaceManager(testSetup!.renderer as never) as unknown as {
+    surfaces: Map<string, unknown>;
+  };
+  return manager.surfaces.size;
+}
+
+async function flushFrames(): Promise<void> {
+  await act(async () => {
+    await testSetup!.renderOnce();
+    await testSetup!.renderOnce();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await testSetup!.renderOnce();
+  });
+}
+
+function Harness({ preference }: { preference: ChartRendererPreference }) {
+  const config = createDefaultConfig(`/tmp/gloomberb-chart-surface-${preference}`);
+  config.chartPreferences.renderer = preference;
+
+  return (
+    <AppProvider config={config}>
+      <ChartSurface width={20} height={4} flexDirection="column" bitmaps={[bitmap]}>
+        <Text>fallback chart</Text>
+      </ChartSurface>
+    </AppProvider>
+  );
+}
+
+afterEach(() => {
+  if (root) {
+    act(() => {
+      root!.unmount();
+    });
+    root = undefined;
+  }
+  if (testSetup) {
+    testSetup.renderer.destroy();
+    testSetup = undefined;
+  }
+  actEnvironment.IS_REACT_ACT_ENVIRONMENT = false;
+});
+
+describe("OpenTuiChartSurface", () => {
+  test("does not register kitty surfaces when the chart renderer is forced to braille", async () => {
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+    testSetup = await createTestRenderer({ width: 40, height: 12 });
+    setNativeRendererReady();
+    root = createOpenTuiTestRoot(testSetup.renderer);
+
+    act(() => {
+      root!.render(<Harness preference="braille" />);
+    });
+
+    await flushFrames();
+
+    expect(testSetup.captureCharFrame()).toContain("fallback chart");
+    expect(surfaceCount()).toBe(0);
+  });
+
+  test("registers kitty surfaces when the chart renderer is forced to kitty and native graphics are ready", async () => {
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+    testSetup = await createTestRenderer({ width: 40, height: 12 });
+    setNativeRendererReady();
+    root = createOpenTuiTestRoot(testSetup.renderer);
+
+    act(() => {
+      root!.render(<Harness preference="kitty" />);
+    });
+
+    await flushFrames();
+
+    expect(testSetup.captureCharFrame()).not.toContain("fallback chart");
+    expect(surfaceCount()).toBe(1);
+  });
+});