gloomberb 0.15.2 → 0.15.4

package/src/renderers/electrobun/view/data-table/index.test.tsx

@@ -1,127 +0,0 @@
-/** @jsxImportSource react */
-import { expect, test } from "bun:test";
-import { tableHeaderPx } from "./dom";
-import { act, useRef, useState } from "react";
-import type { ScrollBoxRenderable } from "../../../../ui/host";
-import { AppContext, createInitialState } from "../../../../state/app/context";
-import { createDefaultConfig } from "../../../../types/config";
-import type { DataTableVisibleRange } from "../../../../components/ui/data-table";
-import { useTableBodyScrollActivity } from "../../../../components/table-view-shared";
-import { createDomTestHarness } from "../test-utils";
-import { WEB_CELL_HEIGHT } from "../input-host";
-import { WebDataTable } from ".";
-
-const { window: testWindow, render } = createDomTestHarness();
-const items = Array.from({ length: 100 }, (_, index) => index);
-
-test("controlled centering keeps following late quotes until the user scrolls", async () => {
-  let updateQuoteTarget: (index: number) => void = () => {};
-  let updateItems: (next: number[]) => void = () => {};
-  let userScrolls = 0;
-  let controlledScrolls = 0;
-  let paginationChecks = 0;
-  const ranges: DataTableVisibleRange[] = [];
-  const state = createInitialState(createDefaultConfig("/tmp/gloom-table-test"));
-
-  function Harness() {
-    const headerScrollRef = useRef<ScrollBoxRenderable | null>(null);
-    const scrollRef = useRef<ScrollBoxRenderable | null>(null);
-    const userScrolled = useRef(false);
-    const [targetIndex, setTargetIndex] = useState(0);
-    const [currentItems, setCurrentItems] = useState(items);
-    updateItems = setCurrentItems;
-    // Options waits for the underlying quote, then follows it until an actual
-    // user scroll. The renderer must not turn its own centering into that lock.
-    updateQuoteTarget = (index) => {
-      if (!userScrolled.current) setTargetIndex(index);
-    };
-    const onBodyScrollActivity = useTableBodyScrollActivity({
-      syncHeaderScroll: () => {},
-      onBodyScrollActivity: (source) => {
-        if (source === "programmatic") {
-          controlledScrolls += 1;
-          return;
-        }
-        userScrolled.current = true;
-        userScrolls += 1;
-      },
-      afterScroll: () => { paginationChecks += 1; },
-    });
-    return (
-      <AppContext value={{ state, dispatch: () => {} }}>
-        <WebDataTable
-          items={currentItems}
-          columns={[{ id: "strike", label: "Strike", width: 10, align: "right" }]}
-          sortColumnId={null}
-          sortDirection="asc"
-          onHeaderClick={() => {}}
-          headerScrollRef={headerScrollRef}
-          scrollRef={scrollRef}
-          syncHeaderScroll={() => {}}
-          onBodyScrollActivity={onBodyScrollActivity}
-          onVisibleRangeChange={(range) => ranges.push(range)}
-          getItemKey={String}
-          isSelected={(_item, index) => index === targetIndex}
-          onSelect={() => {}}
-          renderCell={(item) => ({ text: String(item) })}
-          emptyStateTitle="No strikes"
-          virtualize={false}
-          scrollToIndex={targetIndex}
-          scrollToIndexAlign="center"
-        />
-      </AppContext>
-    );
-  }
-
-  const container = await render(<Harness />);
-  const body = container.querySelector('[data-gloom-role="data-table-body-scroll"]') as HTMLElement;
-  // A header row plus ten body rows.
-  Object.defineProperty(body, "clientHeight", { configurable: true, value: tableHeaderPx() + WEB_CELL_HEIGHT * 10 });
-  const settle = () => new Promise((resolve) => setTimeout(resolve, 25));
-  const emitScroll = () => body.dispatchEvent(new testWindow.Event("scroll") as unknown as Event);
-
-  await act(async () => { updateQuoteTarget(40); });
-  await act(async () => {
-    // happy-dom does not emit the native event when scrollTop is assigned.
-    emitScroll();
-    await settle();
-  });
-  expect(body.scrollTop).toBe(35 * WEB_CELL_HEIGHT);
-  expect(ranges.at(-1)).toEqual({ start: 35, end: 45 });
-  expect(userScrolls).toBe(0);
-  expect(controlledScrolls).toBe(1);
-
-  await act(async () => { updateQuoteTarget(50); });
-  await act(async () => { emitScroll(); await settle(); });
-  expect(body.scrollTop).toBe(45 * WEB_CELL_HEIGHT);
-  expect(userScrolls).toBe(0);
-  expect(controlledScrolls).toBe(2);
-
-  // An uncached options expiry empties the table while loading. The browser
-  // clamps the old scroll offset to zero when its scrollable content vanishes.
-  // That native scroll event must not lock out the next expiry's ATM selection.
-  await act(async () => { updateItems([]); });
-  await act(async () => {
-    body.scrollTop = 0;
-    emitScroll();
-    await settle();
-  });
-  expect(userScrolls).toBe(0);
-  await act(async () => { updateItems(items); updateQuoteTarget(60); });
-  await act(async () => { emitScroll(); await settle(); });
-  expect(body.scrollTop).toBe(55 * WEB_CELL_HEIGHT);
-  expect(userScrolls).toBe(0);
-
-  await act(async () => {
-    body.dispatchEvent(new testWindow.WheelEvent("wheel", { bubbles: true, deltaY: -50 }) as unknown as Event);
-    body.scrollTop = 0;
-    emitScroll();
-    await settle();
-  });
-  expect(userScrolls).toBe(1);
-  expect(paginationChecks).toBe(4);
-  expect(ranges.at(-1)).toEqual({ start: 0, end: 10 });
-
-  await act(async () => { updateQuoteTarget(70); await settle(); });
-  expect(body.scrollTop).toBe(0);
-});

package/src/renderers/electrobun/view/desktop/controls.test.tsx

@@ -1,161 +0,0 @@
-/** @jsxImportSource react */
-import { expect, test } from "bun:test";
-import { act, useState } from "react";
-import { WebCheckbox, WebSegmentedControl } from "./controls";
-import { WebListView } from "./list-view";
-import { Button } from "../../../../components/ui/button";
-import { TextField } from "../../../../components/ui/fields";
-import { ActionRow } from "../../../../components/ui/action-row";
-import { Box, Text } from "../../../../ui";
-import { createDomTestHarness } from "../test-utils";
-
-const { render: renderDom } = createDomTestHarness();
-
-test("desktop checkbox keeps browser state aligned with controlled selection on input and label clicks", async () => {
-  const changes: boolean[] = [];
-  const parentEvents: string[] = [];
-  function Selection() {
-    const [selected, setSelected] = useState(false);
-    return <div onClick={() => parentEvents.push("click")} onMouseDown={() => parentEvents.push("mousedown")}
-      onKeyDown={() => parentEvents.push("keydown")}>
-      <WebCheckbox label="Correlation 20" checked={selected} onChange={(value) => {
-        changes.push(value);
-        setSelected(value);
-      }} />
-      <output>{selected ? "Study enabled" : "Study disabled"}</output>
-      <WebCheckbox label="Unavailable" disabled checked={false} onChange={() => parentEvents.push("disabled")} />
-    </div>;
-  }
-  const container = await renderDom(<Selection />);
-  const [input, disabled] = [...container.querySelectorAll("input")];
-  const [label, disabledLabel] = [...container.querySelectorAll("label")];
-  const mouseDown = new MouseEvent("mousedown", { bubbles: true, cancelable: true });
-  const space = new KeyboardEvent("keydown", { key: " ", bubbles: true, cancelable: true });
-  await act(async () => {
-    input!.dispatchEvent(mouseDown);
-    input!.dispatchEvent(space);
-  });
-  // Browser focus and keyboard activation must remain enabled; happy-dom does
-  // not synthesize a native Space click, so the actual click is tested below.
-  expect(mouseDown.defaultPrevented).toBe(false);
-  expect(space.defaultPrevented).toBe(false);
-  await act(async () => { input!.click(); });
-  expect(container.querySelector("output")!.textContent).toBe("Study enabled");
-  expect(input!.checked).toBe(true);
-  await act(async () => { label!.click(); });
-  expect(container.querySelector("output")!.textContent).toBe("Study disabled");
-  expect(input!.checked).toBe(false);
-  await act(async () => { label!.click(); });
-  expect(input!.checked).toBe(true);
-  await act(async () => { input!.click(); });
-  expect(input!.checked).toBe(false);
-  await act(async () => { disabled!.click(); disabledLabel!.click(); });
-  expect(changes).toEqual([true, false, true, false]);
-  expect(parentEvents).toEqual([]);
-});
-
-test("desktop segmented controls expose radio semantics and keyboard selection", async () => {
-  const selected: string[] = [];
-  const container = await renderDom(
-    <WebSegmentedControl
-      options={[{ label: "Call", value: "call" }, { label: "Put", value: "put" }]}
-      value="call"
-      onChange={(value) => selected.push(value)}
-    />,
-  );
-
-  const group = container.querySelector('[role="radiogroup"]');
-  const radios = [...container.querySelectorAll('[role="radio"]')] as unknown as HTMLElement[];
-  expect(group).not.toBeNull();
-  expect(radios.map((radio) => radio.getAttribute("aria-checked"))).toEqual(["true", "false"]);
-
-  await act(async () => {
-    radios[0]!.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowRight", bubbles: true }));
-    radios[1]!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
-  });
-  expect(selected).toEqual(["put", "put"]);
-});
-
-test("shared buttons activate once by mouse or keyboard and isolate nested actions", async () => {
-  const presses: string[] = [];
-  const container = await renderDom(
-    <Box onMouseDown={() => presses.push("row")}>
-      <Button label="Reply to message" displayLabel="Reply" stopPropagation onPress={() => presses.push("reply")} />
-      <Button label="Disabled" disabled onPress={() => presses.push("disabled")} />
-      <ActionRow label="Cash" expanded onPress={() => presses.push("cash")}>
-        <Box flexGrow={1} /><Text>USD 100</Text>
-      </ActionRow>
-    </Box>,
-  );
-  const [reply, disabled, disclosure] = [...container.querySelectorAll("button")] as HTMLButtonElement[];
-  expect(reply!.getAttribute("aria-label")).toBe("Reply to message");
-  expect(disclosure!.getAttribute("aria-expanded")).toBe("true");
-  expect(container.querySelector("button button")).toBeNull();
-  await act(async () => {
-    reply!.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
-    reply!.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
-    reply!.click();
-    reply!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
-    reply!.dispatchEvent(new KeyboardEvent("keydown", { key: " ", bubbles: true, cancelable: true }));
-    disabled!.click();
-    disabled!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
-  });
-  expect(presses).toEqual(["reply", "reply", "reply"]);
-});
-
-test("TextField delivers normalized native keys before submit and respects cancellation", async () => {
-  const keys: string[] = [];
-  const submitted: string[] = [];
-  const container = await renderDom(
-    <TextField focused value="draft" onSubmit={(value) => submitted.push(value)} onKeyDown={(event) => {
-      keys.push(`${event.name}:${event.shift}`);
-      if (event.shift) event.preventDefault();
-    }} />,
-  );
-  const input = container.querySelector("input")!;
-  await act(async () => {
-    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", shiftKey: true, bubbles: true, cancelable: true }));
-    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
-  });
-  expect(keys).toEqual(["return:true", "return:false"]);
-  expect(submitted).toEqual(["draft"]);
-});
-
-test("desktop lists skip disabled rows during keyboard selection and activation", async () => {
-  const selected: number[] = [];
-  const activated: string[] = [];
-  const container = await renderDom(
-    <WebListView items={[{ id: "a", label: "A" }, { id: "b", label: "B", disabled: true }, { id: "c", label: "C" }]}
-      selectedIndex={0} onSelect={(index) => selected.push(index)} onActivate={(item) => activated.push(item.id)} />,
-  );
-  const rows = [...container.querySelectorAll<HTMLElement>('[role="option"]')];
-  await act(async () => {
-    rows[0]!.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true, cancelable: true }));
-    rows[1]!.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
-    rows[1]!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
-    rows[2]!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
-  });
-  expect(document.activeElement).toBe(rows[2]);
-  expect(selected).toEqual([2, 2]);
-  expect(activated).toEqual(["c"]);
-});
-
-test("clicking a native action uses the value committed by the field blur", async () => {
-  const saved: string[] = [];
-  function Form() {
-    const [committed, setCommitted] = useState("old");
-    return <>
-      <TextField focused value="  edited  " onBlur={(value) => setCommitted(value.trim())} />
-      <Button label="Save" onPress={() => saved.push(committed)} />
-    </>;
-  }
-  const container = await renderDom(<Form />);
-  const button = container.querySelector("button")!;
-  // The browser focuses the button after mousedown, before delivering click.
-  await act(async () => {
-    button.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
-    button.focus();
-  });
-  await act(async () => { button.click(); });
-  expect(saved).toEqual(["edited"]);
-});

package/src/renderers/electrobun/view/desktop/list-view.test.tsx

@@ -1,37 +0,0 @@
-/** @jsxImportSource react */
-import { expect, test } from "bun:test";
-import { act, useState } from "react";
-import { WebListView } from "./list-view";
-import { createDomTestHarness } from "../test-utils";
-
-const { render: renderDom } = createDomTestHarness();
-
-test("a focused list row follows the outside cursor, and checkbox rows leave Enter to the dialog", async () => {
-  const activated: string[] = [];
-  let moveCursor: (index: number) => void = () => {};
-  function Checklist() {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    moveCursor = setSelectedIndex;
-    return <WebListView checkboxRows items={[{ id: "a", label: "A" }, { id: "b", label: "B" }, { id: "c", label: "C" }]}
-      selectedIndex={selectedIndex} onSelect={setSelectedIndex} onActivate={(item) => activated.push(item.id)} />;
-  }
-  const container = await renderDom(<Checklist />);
-  const rows = [...container.querySelectorAll<HTMLElement>('[role="option"]')];
-  // Outside a dialog a pressed row takes no focus that would keep the pane's keys.
-  const press = new MouseEvent("mousedown", { bubbles: true, cancelable: true });
-  await act(async () => { rows[1]!.dispatchEvent(press); });
-  expect(press.defaultPrevented).toBe(true);
-
-  // Tab left the focus on row A, then the dialog's j/k moves the cursor to C.
-  await act(async () => { rows[0]!.focus(); });
-  await act(async () => { moveCursor(2); });
-  expect(document.activeElement).toBe(rows[2]);
-  const enter = new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true });
-  const space = new KeyboardEvent("keydown", { key: " ", bubbles: true, cancelable: true });
-  await act(async () => {
-    rows[2]!.dispatchEvent(enter);
-    rows[2]!.dispatchEvent(space);
-  });
-  expect(enter.defaultPrevented).toBe(false);
-  expect(activated).toEqual(["b", "c"]);
-});

package/src/renderers/electrobun/view/desktop/window/snapshot.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createDefaultConfig } from "../../../../../types/config";
-import type { DesktopSharedStateSnapshot } from "../../../../../types/desktop-window";
-import { detachedSnapshotKey } from "./snapshot";
-
-function createSnapshot(): DesktopSharedStateSnapshot {
-  const config = createDefaultConfig("/tmp/gloomberb-test");
-  config.layout.detached = [{ instanceId: "ticker-detail:main", x: 20, y: 20, width: 640, height: 420 }];
-  return {
-    config,
-    paneState: {
-      "portfolio-list:main": { cursorSymbol: "AAPL", collectionId: "main" },
-      "ticker-detail:main": { activeTabId: "overview" },
-    },
-    focusedPaneId: "portfolio-list:main",
-    activePanel: "left",
-    statusBarVisible: true,
-  };
-}
-
-describe("detached desktop snapshots", () => {
-  test("ignores unrelated window state", () => {
-    const snapshot = createSnapshot();
-    const key = detachedSnapshotKey(snapshot, "ticker-detail:main");
-
-    expect(detachedSnapshotKey({
-      ...snapshot,
-      activePanel: "right",
-      focusedPaneId: "chat:main",
-      paneState: {
-        ...snapshot.paneState,
-        "chat:main": { draft: "unrelated" },
-      },
-    }, "ticker-detail:main")).toBe(key);
-  });
-
-  test("tracks the detached pane and its follow source", () => {
-    const snapshot = createSnapshot();
-    const key = detachedSnapshotKey(snapshot, "ticker-detail:main");
-
-    expect(detachedSnapshotKey({
-      ...snapshot,
-      paneState: {
-        ...snapshot.paneState,
-        "ticker-detail:main": { activeTabId: "financials" },
-      },
-    }, "ticker-detail:main")).not.toBe(key);
-
-    expect(detachedSnapshotKey({
-      ...snapshot,
-      paneState: {
-        ...snapshot.paneState,
-        "portfolio-list:main": { cursorSymbol: "MSFT", collectionId: "main" },
-      },
-    }, "ticker-detail:main")).not.toBe(key);
-  });
-});

package/src/renderers/electrobun/view/desktop-deeplink-bridge.ts

@@ -1,10 +0,0 @@
-import type { DesktopDeepLinkBridge } from "../../../types/desktop-deeplink";
-import { onDesktopDeepLink } from "./backend-rpc";
-
-export function createDesktopDeepLinkBridge(): DesktopDeepLinkBridge {
-  return {
-    subscribe(listener) {
-      return onDesktopDeepLink(listener);
-    },
-  };
-}

package/src/renderers/electrobun/view/dialog-host.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { isDialogDismissKey, shouldFocusDialogContainer } from "./dialog-host";
-
-describe("desktop dialog focus and dismissal", () => {
-  test("dismisses on Escape, including legacy WebView key names", () => {
-    expect(isDialogDismissKey({ key: "Escape", isComposing: false })).toBe(true);
-    expect(isDialogDismissKey({ key: "Esc", isComposing: false })).toBe(true);
-    expect(isDialogDismissKey({ key: "Enter", isComposing: false })).toBe(false);
-    expect(isDialogDismissKey({ key: "Escape", isComposing: true })).toBe(false);
-  });
-
-  test("preserves focus already owned by dialog content", () => {
-    const child = {} as Element;
-    const outside = {} as Element;
-    const dialog = {
-      contains(element: Node | null) {
-        return element === child;
-      },
-    };
-
-    expect(shouldFocusDialogContainer(dialog, child)).toBe(false);
-    expect(shouldFocusDialogContainer(dialog, outside)).toBe(true);
-    expect(shouldFocusDialogContainer(dialog, null)).toBe(true);
-  });
-});

package/src/renderers/electrobun/view/dialog-stack.test.tsx

@@ -1,73 +0,0 @@
-/** @jsxImportSource react */
-import { expect, test } from "bun:test";
-import { act } from "react";
-import { useDialog, type AlertContext, type DialogApi } from "../../../ui/dialog";
-import { WebDialogHostProvider } from "./dialog-host";
-import { moveDialogFocus } from "./key-event";
-import { createDomTestHarness } from "./test-utils";
-
-const { window, render } = createDomTestHarness({ withUi: false });
-
-let dialog: DialogApi | null = null;
-function Capture() {
-  dialog = useDialog();
-  return null;
-}
-
-function Buttons({ names }: { names: string[] }) {
-  return <div>{names.map((name) => <button key={name} type="button">{name}</button>)}</div>;
-}
-
-function tab(shiftKey = false) {
-  return moveDialogFocus({ key: "Tab", shiftKey, ctrlKey: false, metaKey: false, altKey: false, defaultPrevented: false });
-}
-
-function focusedText() {
-  return window.document.activeElement?.textContent ?? null;
-}
-
-test("a dialog opened from a dialog stacks, and closing it returns to the first", async () => {
-  await render(<WebDialogHostProvider><Capture /></WebDialogHostProvider>);
-  let dismissInner: (() => void) | null = null;
-  await act(async () => {
-    void dialog!.alert({ content: <Buttons names={["Outer"]} /> });
-  });
-  await act(async () => {
-    void dialog!.alert({
-      content: (ctx: AlertContext) => {
-        dismissInner = ctx.dismiss;
-        return <Buttons names={["Inner"]} />;
-      },
-    });
-  });
-  const texts = () => [...window.document.querySelectorAll(".gloom-dialog")].map((node) => node.textContent);
-  expect(texts()).toEqual(["Outer", "Inner"]);
-
-  await act(async () => { dismissInner!(); });
-  expect(texts()).toEqual(["Outer"]);
-});
-
-test("Tab walks the topmost dialog's controls and wraps", async () => {
-  await render(<WebDialogHostProvider><Capture /></WebDialogHostProvider>);
-  await act(async () => {
-    void dialog!.alert({ content: <Buttons names={["Save", "Cancel"]} /> });
-  });
-
-  expect(tab()).toBe(true);
-  expect(focusedText()).toBe("Save");
-  tab();
-  expect(focusedText()).toBe("Cancel");
-  tab();
-  expect(focusedText()).toBe("Save");
-  tab(true);
-  expect(focusedText()).toBe("Cancel");
-});
-
-test("Tab is left alone when no dialog is open or a handler already took it", async () => {
-  await render(<WebDialogHostProvider><Capture /></WebDialogHostProvider>);
-  expect(tab()).toBe(false);
-  await act(async () => {
-    void dialog!.alert({ content: <Buttons names={["Only"]} /> });
-  });
-  expect(moveDialogFocus({ key: "Tab", shiftKey: false, ctrlKey: false, metaKey: false, altKey: false, defaultPrevented: true })).toBe(false);
-});

package/src/renderers/electrobun/view/external-plugins.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { loadDesktopExternalPlugins } from "./external-plugins";
-import type { DesktopExternalPluginBundle } from "../shared/protocol";
-
-/**
- * The guarantee under test is containment: a plugin that fails to compile, ships
- * no bundle, or exports the wrong shape must surface as a broken entry the
- * marketplace can explain, never as an exception that stops the desktop app from
- * starting. Every case here is one a user can hit by installing a bad plugin.
- */
-function bundle(overrides: Partial<DesktopExternalPluginBundle>): DesktopExternalPluginBundle {
-  return { id: "x", name: "X", version: "1.0.0", path: "/tmp/x", directory: "x", ...overrides };
-}
-
-describe("loadDesktopExternalPlugins", () => {
-  test("does nothing when there is nothing to load", async () => {
-    expect(await loadDesktopExternalPlugins([])).toEqual([]);
-  });
-
-  test("carries a compile error through instead of throwing", async () => {
-    const [entry] = await loadDesktopExternalPlugins([
-      bundle({ id: "broken", error: "Could not resolve ./nope" }),
-    ]);
-
-    expect(entry?.error).toBe("Could not resolve ./nope");
-    expect(entry?.plugin.id).toBe("broken");
-  });
-
-  test("reports a bundle that arrived without code", async () => {
-    const [entry] = await loadDesktopExternalPlugins([bundle({ id: "empty" })]);
-
-    expect(entry?.error).toContain("no bundle");
-  });
-
-  test("keeps a terminal-only plugin apart from the broken ones", async () => {
-    // IBKR Gateway declares cli and tui on purpose. Reporting that as a load
-    // error made the marketplace call a working install "failed".
-    const [entry] = await loadDesktopExternalPlugins([
-      bundle({ id: "ibkr-gateway", targets: ["cli", "tui"], unsupportedTarget: "desktop" }),
-    ]);
-
-    expect(entry?.error).toBeUndefined();
-    expect(entry?.unsupportedTarget).toBe("desktop");
-    expect(entry?.plugin.targets).toEqual(["cli", "tui"]);
-  });
-
-  test("keeps loading the rest after one plugin fails", async () => {
-    const entries = await loadDesktopExternalPlugins([
-      bundle({ id: "first", error: "boom" }),
-      bundle({ id: "second", error: "also boom" }),
-    ]);
-
-    expect(entries.map((entry) => entry.plugin.id)).toEqual(["first", "second"]);
-    expect(entries.every((entry) => entry.error)).toBe(true);
-  });
-});

package/src/renderers/electrobun/view/history-metadata-rpc.test.ts

@@ -1,62 +0,0 @@
-import { expect, test } from "bun:test";
-import { assetDataProvider } from "../../../capabilities/factories";
-import { CapabilityRegistry } from "../../../capabilities/registry";
-import type { DataProvider } from "../../../types/data-provider";
-import type { PriceHistoryResult } from "../../../types/price-history";
-import { HistoryRetentionError, type HistoryRetention } from "../../../sources/history-retention";
-import { DesktopCapabilityBridge } from "../bun/desktop/capability-bridge";
-import { decodeRpcResponse, decodeRpcValue, encodeRpcResponse, encodeRpcValue } from "./rpc-codec";
-
-const { createRPC } = await import(new URL("../shared/rpc.ts", import.meta.resolve("electrobun/view")).href);
-
-function transport(provider: DataProvider) {
-  const registry = new CapabilityRegistry();
-  registry.register("test", assetDataProvider(provider));
-  const bridge = new DesktopCapabilityBridge({ getRegistry: () => registry, getWindowKey: () => "research" });
-  let receiveClient: (value: unknown) => void, receiveServer: (value: unknown) => void;
-  const client = createRPC({ maxRequestTime: 1000 });
-  const server = createRPC({ requestHandler: { "backend.request": (request: unknown) =>
-    encodeRpcResponse(() => bridge.handle({ send: { "capability.event": () => {} } }, decodeRpcValue(request))) } });
-  client.setTransport({ registerHandler: (handler: typeof receiveClient) => { receiveClient = handler; },
-    send: (value: unknown) => { queueMicrotask(() => receiveServer(JSON.parse(JSON.stringify(value)))); } });
-  server.setTransport({ registerHandler: (handler: typeof receiveServer) => { receiveServer = handler; },
-    send: (value: unknown) => { queueMicrotask(() => receiveClient(JSON.parse(JSON.stringify(value)))); } });
-  return { registry, request: (operationId: string, payload: unknown) => client.request["backend.request"](encodeRpcValue({
-    method: "capability.invoke", payload: { capabilityId: `asset-data.${provider.id}`, operationId, payload },
-  })).then(decodeRpcResponse) };
-}
-
-test("history metadata methods cross desktop capabilities and JSON with Dates, acquisition time and context intact", async () => {
-  const calls: unknown[][] = [];
-  const result: PriceHistoryResult = { points: [{ date: new Date("2026-09-21T19:45:00Z"), close: 338.89, volume: 2218511 }],
-    resolution: "15m", sourceKey: "provider:gloomberb-cloud", session: { version: 1, kind: "regular", calendar: "us-equity",
-      timeZone: "America/New_York", symbol: "AAPL", exchange: "NASDAQ", interval: "15min", source: "yahoo",
-      timestampConvention: "bar-open", barAlignment: "session-open", observedAt: Date.parse("2026-09-22T12:42:12Z") } };
-  const load = async (...args: unknown[]) => { calls.push(args); return result; };
-  const { request } = transport({ id: "test", name: "History", getPriceHistoryWithMetadata: load,
-    getPriceHistoryForResolutionWithMetadata: load, getDetailedPriceHistoryWithMetadata: load } as unknown as DataProvider);
-  const startDate = new Date("2026-09-14T00:00:00Z"), endDate = new Date("2026-09-22T12:42:12Z");
-  const context = { brokerId: "ibkr", brokerInstanceId: "work", instrument: { brokerId: "ibkr", conId: 11, symbol: "AAPL" },
-    historyRequestKey: "stable-acquisition", cacheMode: "refresh" };
-  expect(await request("getDetailedPriceHistoryWithMetadata", { ticker: "AAPL", exchange: "NASDAQ", startDate, endDate, barSize: "15m", context })).toEqual(result);
-  expect(calls[0]).toEqual(["AAPL", "NASDAQ", startDate, endDate, "15m", context]);
-  expect(await request("getPriceHistoryForResolutionWithMetadata", { ticker: "AAPL", exchange: "NASDAQ", bufferRange: "1M", resolution: "15m", context })).toEqual(result);
-  expect(calls[1]).toEqual(["AAPL", "NASDAQ", "1M", "15m", context]);
-  expect(await request("getPriceHistoryWithMetadata", { ticker: "AAPL", exchange: "NASDAQ", range: "1M", context })).toEqual(result);
-  expect(calls).toHaveLength(3);
-});
-
-test("metadata-aware desktop history preserves typed retention errors and does not advertise unsupported methods", async () => {
-  const now = Math.floor(Date.now() / 1000) * 1000;
-  const retention: HistoryRetention = { version: 1, source: "yahoo", symbol: "BTC-USD", exchange: "CCC", interval: "15min",
-    requestedStart: now - 90 * 86_400_000, requestedEnd: now, observedAt: now, availableStart: now - 60 * 86_400_000 };
-  const { request } = transport({ id: "test", name: "History", getDetailedPriceHistoryWithMetadata: async () => {
-    throw new HistoryRetentionError(retention);
-  } } as unknown as DataProvider);
-  const error = await request("getDetailedPriceHistoryWithMetadata", { ticker: "BTC-USD", exchange: "CCC",
-    startDate: new Date(retention.requestedStart), endDate: new Date(retention.requestedEnd), barSize: "15m" }).catch((failure: unknown) => failure);
-  expect(error).toBeInstanceOf(HistoryRetentionError);
-  expect((error as HistoryRetentionError).retention).toEqual(retention);
-  const legacy = transport({ id: "legacy", name: "Legacy", getPriceHistory: async () => [] } as unknown as DataProvider);
-  expect(legacy.registry.manifests()[0]!.operations.some(op => op.id.endsWith("WithMetadata"))).toBe(false);
-});

package/src/renderers/electrobun/view/host/ascii-text.test.ts

@@ -1,48 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { webAsciiTextWordmarkVariant } from "./ascii-text";
-
-const globalWithNavigator = globalThis as { navigator?: unknown };
-const originalNavigator = Object.getOwnPropertyDescriptor(globalThis, "navigator");
-
-function stubNavigator(platform: string): void {
-  Object.defineProperty(globalThis, "navigator", {
-    value: { platform, userAgent: platform },
-    configurable: true,
-    writable: true,
-  });
-}
-
-afterEach(() => {
-  if (originalNavigator) Object.defineProperty(globalThis, "navigator", originalNavigator);
-  else delete globalWithNavigator.navigator;
-});
-
-/**
- * The block-glyph wordmark only renders on macOS fonts, so every other platform
- * gets the `/ \ | _` fallback. The DOM host is shared by Electrobun, which knows
- * its `process.platform`, and the hosted web build, which does not and passes a
- * sentinel instead. Reading that sentinel as "not macOS" is what shipped the
- * wrong wordmark to Mac browsers.
- */
-describe("web wordmark variant", () => {
-  test("trusts a real platform from the desktop host over the navigator", () => {
-    stubNavigator("MacIntel");
-    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "darwin")).toBe("legacy");
-    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "win32")).toBe("compat");
-    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "linux")).toBe("compat");
-  });
-
-  test("falls back to the navigator when the host names no OS", () => {
-    stubNavigator("MacIntel");
-    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "browser")).toBe("legacy");
-    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "")).toBe("legacy");
-    stubNavigator("Win32");
-    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "browser")).toBe("compat");
-  });
-
-  test("leaves anything that is not the wordmark alone", () => {
-    stubNavigator("MacIntel");
-    expect(webAsciiTextWordmarkVariant("Gloomberb", "tiny", "darwin")).toBeNull();
-    expect(webAsciiTextWordmarkVariant("Portfolio", "wordmark", "darwin")).toBeNull();
-  });
-});