gloomberb 0.9.2 → 0.9.3

package/src/plugins/builtin/substack/read-state.ts

@@ -0,0 +1,55 @@
+import { useCallback, useMemo } from "react";
+import { usePluginState } from "../../runtime";
+import {
+  DEFAULT_MAX_READ_IDS,
+  markReadId,
+  normalizeReadIds,
+  sameStringArray,
+} from "../shared/read-state";
+
+export interface SubstackReadState {
+  articleIds: string[];
+}
+
+const SUBSTACK_READ_STATE_SCHEMA_VERSION = 1;
+const READ_STATE_KEY = "read-articles";
+const EMPTY_READ_STATE: SubstackReadState = { articleIds: [] };
+
+export const MAX_READ_SUBSTACK_ARTICLE_IDS = DEFAULT_MAX_READ_IDS;
+
+export function normalizeSubstackReadState(state: SubstackReadState): SubstackReadState {
+  return {
+    articleIds: normalizeReadIds(state.articleIds, MAX_READ_SUBSTACK_ARTICLE_IDS),
+  };
+}
+
+export function markSubstackArticleRead(
+  state: SubstackReadState,
+  articleId: string,
+): SubstackReadState {
+  const current = normalizeSubstackReadState(state).articleIds;
+  const articleIds = markReadId(current, articleId, MAX_READ_SUBSTACK_ARTICLE_IDS);
+
+  return sameStringArray(articleIds, state.articleIds) ? state : { articleIds };
+}
+
+export function useSubstackReadState() {
+  const [readState, setReadState] = usePluginState<SubstackReadState>(
+    READ_STATE_KEY,
+    EMPTY_READ_STATE,
+    { schemaVersion: SUBSTACK_READ_STATE_SCHEMA_VERSION },
+  );
+  const normalizedReadState = useMemo(
+    () => normalizeSubstackReadState(readState),
+    [readState],
+  );
+  const readArticleIds = useMemo(
+    () => new Set(normalizedReadState.articleIds),
+    [normalizedReadState],
+  );
+  const markArticleRead = useCallback((articleId: string) => {
+    setReadState((current) => markSubstackArticleRead(current, articleId));
+  }, [setReadState]);
+
+  return { readArticleIds, markArticleRead };
+}

package/src/plugins/builtin/thirteenf/pane.test.tsx

@@ -224,6 +224,32 @@ describe("ThirteenFPane", () => {
     ).toBeUndefined();
   });
 
+  test("moves from the first fund row to search with Up", async () => {
+    setHttpFetchTransport(async (url) => {
+      const path = new URL(String(url)).pathname;
+      if (path.endsWith("/topfunds")) {
+        return json([
+          { cik: "1", name: "Alpha Capital", period_of_report: "2026-03-31", pnl: null },
+        ]);
+      }
+      return json([]);
+    });
+
+    await act(async () => {
+      testSetup = await testRender(<Harness />, { width: 100, height: 20 });
+    });
+    await renderFrames();
+
+    await emitKeypress({ name: "up", sequence: "\u001B[A" });
+    await act(async () => {
+      await testSetup!.mockInput.typeText("BRK");
+      await testSetup!.renderOnce();
+    });
+    await renderFrames(2);
+
+    expect(testSetup!.captureCharFrame()).toContain("BRK");
+  });
+
   test("rapid keyboard navigation activates the current rendered row", async () => {
     setHttpFetchTransport(async (url) => {
       const path = new URL(String(url)).pathname;

package/src/plugins/builtin/thirteenf/pane.tsx

@@ -15,6 +15,7 @@ import {
   Tabs,
   usePaneFooter,
   type DataTableKeyEvent,
+  type DataTableRootKeyContext,
 } from "../../../components";
 import { useShortcut } from "../../../react/input";
 import { usePaneSettingValue } from "../../../state/app/context";
@@ -23,6 +24,7 @@ import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
 import type { PaneProps } from "../../../types/plugin";
 import { isDetailBackNavigationKey } from "../../../utils/back-navigation";
 import { isPlainKey } from "../../../utils/keyboard";
+import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { truncateWithEllipsis } from "../../../utils/text-wrap";
 import { usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { loadBrowserRows, loadFilingPositions, loadFundDetail } from "./data";
@@ -303,6 +305,7 @@ export function ThirteenFPane({ focused, width, height }: PaneProps) {
         normalizeValue={trimSearchValue}
         onFocus={focusSearch}
         onBlur={blurSearch}
+        onNavigateDown={blurSearch}
         onQueryChange={updateQuery}
       />
     </Box>
@@ -312,7 +315,15 @@ export function ThirteenFPane({ focused, width, height }: PaneProps) {
     ? "Loading 13F funds..."
     : error ?? warning ?? "No 13F funds found.";
 
-  const handleRootKeyDown = useCallback((event: DataTableKeyEvent) => {
+  const handleRootKeyDown = useCallback((
+    event: DataTableKeyEvent,
+    context: DataTableRootKeyContext,
+  ) => {
+    if (context.selectedIndex <= 0 && isPlainArrowUp(event)) {
+      stopSearchFocusNavigation(event);
+      focusSearch();
+      return true;
+    }
     if (event.name === "r") {
       event.preventDefault?.();
       event.stopPropagation?.();

package/src/plugins/pane-manager/docking.ts

@@ -6,6 +6,7 @@ import {
   findDockLeaf,
   getNodeAtPath,
   replaceNodeAtPath,
+  type DockGeometryOptions,
   type DockTarget,
   type LayoutBounds,
 } from "./dock-tree";
@@ -116,11 +117,17 @@ export function applyDrop(layout: LayoutConfig, draggedId: string, dropTarget: D
   return insertRelativeToLeaf(layout, draggedId, dropTarget.targetId, direction);
 }
 
-export function simulateDrop(layout: LayoutConfig, draggedId: string, dropTarget: DropTarget, bounds: LayoutBounds): LayoutSimulation {
+export function simulateDrop(
+  layout: LayoutConfig,
+  draggedId: string,
+  dropTarget: DropTarget,
+  bounds: LayoutBounds,
+  options?: DockGeometryOptions,
+): LayoutSimulation {
   const nextLayout = applyDrop(layout, draggedId, dropTarget);
   return {
     layout: nextLayout,
-    previewRect: getLeafRect(nextLayout, draggedId, bounds),
+    previewRect: getLeafRect(nextLayout, draggedId, bounds, options),
   };
 }
 

package/src/plugins/pane-manager/queries.ts

@@ -10,6 +10,7 @@ import {
   countColumnsFromGeometry,
   findDockLeaf,
   getDockLeafLayouts,
+  type DockGeometryOptions,
   type LayoutBounds,
 } from "./dock-tree";
 
@@ -20,8 +21,13 @@ export interface ResolvedPane {
   path?: Array<0 | 1>;
 }
 
-export function getLeafRect(layout: LayoutConfig, instanceId: string, bounds: LayoutBounds): LayoutBounds | null {
-  return getDockLeafLayouts(layout, bounds).find((entry) => entry.instanceId === instanceId)?.rect ?? null;
+export function getLeafRect(
+  layout: LayoutConfig,
+  instanceId: string,
+  bounds: LayoutBounds,
+  options?: DockGeometryOptions,
+): LayoutBounds | null {
+  return getDockLeafLayouts(layout, bounds, options).find((entry) => entry.instanceId === instanceId)?.rect ?? null;
 }
 
 export function resolveDocked(

package/src/plugins/prediction-markets/controller/index.ts

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { type InputRenderable, type ScrollBoxRenderable } from "../../../ui";
 import { useViewport } from "../../../react/input";
+import { useAppInputCapture } from "../../../state/app/input-capture";
 import { usePaneInstance } from "../../../state/app/context";
 import {
   useDebouncedPluginPaneState,
@@ -101,6 +102,7 @@ export function usePredictionMarketsController({
   const [searchFocused, setSearchFocused] = useState(false);
   const [initialParamsApplied, setInitialParamsApplied] = useState(false);
   const appViewport = useViewport();
+  useAppInputCapture(focused && searchFocused);
 
   const scrollRef = useRef<ScrollBoxRenderable>(null);
   const headerScrollRef = useRef<ScrollBoxRenderable>(null);

package/src/plugins/prediction-markets/controller/keyboard.ts

@@ -1,6 +1,7 @@
 import { useCallback, type RefObject } from "react";
 import { type ScrollBoxRenderable } from "../../../ui";
 import { useShortcut } from "../../../react/input";
+import { isPlainArrowDown, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { getAdjacentPredictionCategoryId } from "../categories";
 import { resolvePredictionKeyboardCommand } from "../keyboard";
 import { getAdjacentPredictionVenueScope } from "../navigation";
@@ -16,7 +17,14 @@ import type {
 interface PredictionKeyboardEvent {
   name?: string;
   sequence?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+  alt?: boolean;
+  option?: boolean;
   shift?: boolean;
+  defaultPrevented?: boolean;
+  propagationStopped?: boolean;
   preventDefault?: () => void;
   stopPropagation?: () => void;
 }
@@ -62,6 +70,25 @@ export function usePredictionControllerKeyboard({
   setVenue,
   toggleWatchlist,
 }: UsePredictionControllerKeyboardParams) {
+  const handleSearchNavigation = useCallback(
+    (event: PredictionKeyboardEvent) => {
+      if (!focused || !searchFocused) return;
+
+      if (isPlainArrowDown(event)) {
+        stopSearchFocusNavigation(event);
+        blurSearch();
+        return;
+      }
+
+      if (resolvePredictionKeyboardCommand(event) === "escape") {
+        event.stopPropagation?.();
+        event.preventDefault?.();
+        blurSearch();
+      }
+    },
+    [blurSearch, focused, searchFocused],
+  );
+
   const cycleDetailOutcome = useCallback(
     (direction: "previous" | "next") => {
       if (detailTab !== "overview" || sortedOutcomeMarkets.length === 0) {
@@ -98,15 +125,11 @@ export function usePredictionControllerKeyboard({
 
   const handleKeyboard = useCallback(
     (event: PredictionKeyboardEvent) => {
+      if (event.defaultPrevented || event.propagationStopped) return;
       if (!focused) return;
       const command = resolvePredictionKeyboardCommand(event);
 
       if (searchFocused) {
-        if (command === "escape") {
-          event.stopPropagation?.();
-          event.preventDefault?.();
-          blurSearch();
-        }
         return;
       }
 
@@ -216,5 +239,11 @@ export function usePredictionControllerKeyboard({
     ],
   );
 
+  useShortcut(handleSearchNavigation, {
+    allowEditable: true,
+    enabled: focused && searchFocused,
+    phase: "before",
+  });
+
   useShortcut(handleKeyboard);
 }

package/src/plugins/prediction-markets/pane.test.tsx

@@ -265,6 +265,38 @@ describe("prediction markets pane interactions", () => {
     expect(frame).not.toContain("\u2190 Back");
   });
 
+  test("moves focus between search and the market table with arrows", async () => {
+    installPredictionMarketMocks();
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+
+    await emitKeypress(testSetup, { name: "j", sequence: "j" });
+    await flushFrames(testSetup, 1);
+
+    await emitKeypress(testSetup, { name: "up", sequence: "\u001b[A" });
+    await flushFrames(testSetup);
+
+    let frame = testSetup.captureCharFrame();
+    expect(frame).toContain("/ search markets");
+
+    await emitKeypress(testSetup, { name: "up", sequence: "\u001b[A" });
+    await flushFrames(testSetup);
+
+    frame = testSetup.captureCharFrame();
+    expect(frame).toContain("? search markets");
+
+    await emitKeypress(testSetup, {
+      name: "down",
+      sequence: "\u001b[B",
+      targetEditable: true,
+    });
+    await flushFrames(testSetup);
+
+    frame = testSetup.captureCharFrame();
+    expect(frame).toContain("/ search markets");
+  });
+
   test("supports detail outcome navigation and escape return from the keyboard", async () => {
     attachPredictionMarketsPersistence(new MemoryPersistence());
 

package/src/plugins/prediction-markets/pane.tsx

@@ -1,6 +1,12 @@
 import { Box, Input, Text } from "../../ui";
 import { useCallback, useMemo, useRef } from "react";
-import { DataTableStackView, Tabs, usePaneFooter } from "../../components";
+import {
+  DataTableStackView,
+  Tabs,
+  usePaneFooter,
+  type DataTableKeyEvent,
+  type DataTableRootKeyContext,
+} from "../../components";
 import { createRowValueCache } from "../../components/ui/row-value-cache";
 import type { PaneProps } from "../../types/plugin";
 import { colors } from "../../theme/colors";
@@ -9,6 +15,7 @@ import { usePredictionMarketsController } from "./controller";
 import { PredictionMarketDetailPane } from "./detail/pane";
 import { getPredictionColumnValue } from "./metrics";
 import { BROWSE_TABS, VENUE_TABS } from "./navigation";
+import { isPlainArrowUp, stopSearchFocusNavigation } from "../../utils/search-focus-navigation";
 import type {
   PredictionBrowseTab,
   PredictionCategoryId,
@@ -217,6 +224,18 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
     watchlistedRowKeys,
   ]);
 
+  const handleRootKeyDown = useCallback((
+    event: DataTableKeyEvent,
+    context: DataTableRootKeyContext,
+  ) => {
+    if (context.selectedIndex <= 0 && isPlainArrowUp(event)) {
+      stopSearchFocusNavigation(event);
+      controller.actions.focusSearch();
+      return true;
+    }
+    return false;
+  }, [controller.actions.focusSearch]);
+
   const detailContent =
     controller.selectedSummary && controller.selectedRow ? (
       <Box
@@ -271,6 +290,7 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
       }}
       onActivate={(row) =>
         controller.actions.openSelectedRow(row.key)}
+      onRootKeyDown={handleRootKeyDown}
       columns={controller.visibleColumns}
       items={controller.visibleRows}
       sortColumnId={controller.sortPreference.columnId}

package/src/plugins/prediction-markets/test-helpers.tsx

@@ -531,6 +531,7 @@ export async function emitKeypress(
   event: {
     name?: string;
     sequence?: string;
+    targetEditable?: boolean;
     shift?: boolean;
   },
 ) {

package/src/renderers/electrobun/bun/application-menu/click.test.ts

@@ -30,6 +30,15 @@ describe("applicationMenuCommand", () => {
     })).toEqual({ type: "open-devtools" });
   });
 
+  test("parses the native quit command", () => {
+    expect(applicationMenuCommand({
+      data: {
+        action: ELECTROBUN_APPLICATION_MENU_ACTION,
+        data: { type: "quit" },
+      },
+    })).toEqual({ type: "quit" });
+  });
+
   test("ignores unknown command types", () => {
     expect(applicationMenuCommand({
       data: {

package/src/renderers/electrobun/bun/application-menu/click.ts

@@ -45,6 +45,7 @@ function normalizeApplicationMenuCommand(value: unknown): ElectrobunApplicationM
     case "layout-redo":
     case "layout-gridlock":
     case "open-devtools":
+    case "quit":
       return { type: command.type };
     default:
       return null;

package/src/renderers/electrobun/bun/application-menu/index.test.ts

@@ -9,4 +9,13 @@ describe("desktop application menu", () => {
   test("keeps the native application menu on macOS", () => {
     expect(buildDesktopApplicationMenu("darwin")).toEqual(buildApplicationMenu());
   });
+
+  test("routes macOS quit through an explicit command item", () => {
+    const appMenu = buildApplicationMenu()[0]?.submenu;
+    expect(appMenu?.at(-1)).toMatchObject({
+      label: "Quit Gloomberb",
+      accelerator: "CmdOrCtrl+Q",
+      data: { type: "quit" },
+    });
+  });
 });

package/src/renderers/electrobun/bun/application-menu/index.ts

@@ -6,7 +6,8 @@ const GITHUB_ISSUE_URL = "https://github.com/vincelwt/gloomberb/issues/new/choos
 
 export type ElectrobunApplicationMenuCommand =
   | DesktopApplicationMenuCommand
-  | { type: "open-devtools" };
+  | { type: "open-devtools" }
+  | { type: "quit" };
 
 function commandItem(
   label: string,
@@ -38,7 +39,7 @@ export function buildApplicationMenu(): ApplicationMenuItemConfig[] {
         { role: "hideOthers" },
         { role: "showAll" },
         { type: "divider" },
-        { role: "quit" },
+        commandItem("Quit Gloomberb", { type: "quit" }, { accelerator: "CmdOrCtrl+Q" }),
       ],
     },
     {

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

@@ -281,6 +281,15 @@ function closeAllDetachedWindows(): void {
   detachedWindowManager.closeAll();
 }
 
+function quitDesktopApp(): void {
+  closeAllDetachedWindows();
+  teardownServices();
+  const window = mainWindow;
+  mainWindow = null;
+  window?.close();
+  Utils.quit();
+}
+
 function controlWindowForRpcKey(windowKey: string | undefined, action: DesktopWindowControlAction): boolean {
   const targetWindow = windowKey === MAIN_WINDOW_RPC_KEY
     ? mainWindow
@@ -446,6 +455,10 @@ ApplicationMenu.on("application-menu-clicked", (event: unknown) => {
     openMainWindowDevTools();
     return;
   }
+  if (command.type === "quit") {
+    quitDesktopApp();
+    return;
+  }
   if (!isWindowRpcReady(MAIN_WINDOW_RPC_KEY)) return;
   getWindowRpc(MAIN_WINDOW_RPC_KEY)?.send["application-menu.select"]({ command });
 });

package/src/renderers/electrobun/bun/window/focus.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import { detachedRpcKey, focusWindowForRpcKey, MAIN_WINDOW_RPC_KEY, type FocusableElectrobunWindow } from "./focus";
+
+describe("Electrobun window focus routing", () => {
+  test("uses activate for the main window", () => {
+    const calls: string[] = [];
+    const mainWindow: FocusableElectrobunWindow = {
+      activate: () => calls.push("activate"),
+      focus: () => calls.push("focus"),
+    };
+
+    expect(focusWindowForRpcKey(MAIN_WINDOW_RPC_KEY, mainWindow, new Map())).toBe(true);
+    expect(calls).toEqual(["activate"]);
+  });
+
+  test("uses activate for detached windows", () => {
+    const calls: string[] = [];
+    const detachedWindows = new Map<string, FocusableElectrobunWindow>([
+      ["pane:1", { activate: () => calls.push("detached") }],
+    ]);
+
+    expect(focusWindowForRpcKey(detachedRpcKey("pane:1"), null, detachedWindows)).toBe(true);
+    expect(calls).toEqual(["detached"]);
+  });
+
+  test("falls back to focus for legacy window objects", () => {
+    const calls: string[] = [];
+    const mainWindow: FocusableElectrobunWindow = {
+      focus: () => calls.push("focus"),
+    };
+
+    expect(focusWindowForRpcKey(MAIN_WINDOW_RPC_KEY, mainWindow, new Map())).toBe(true);
+    expect(calls).toEqual(["focus"]);
+  });
+});

package/src/renderers/electrobun/bun/window/focus.ts

@@ -3,6 +3,7 @@ export const MAIN_WINDOW_RPC_KEY = "main";
 const DETACHED_WINDOW_RPC_PREFIX = "detached:";
 
 export interface FocusableElectrobunWindow {
+  activate?: () => void;
   focus?: () => void;
 }
 
@@ -31,6 +32,10 @@ export function focusWindowForRpcKey(
   detachedWindows: ReadonlyMap<string, FocusableElectrobunWindow>,
 ): boolean {
   const window = resolveWindowForRpcKey(rpcKey, mainWindow, detachedWindows);
+  if (window?.activate) {
+    window.activate();
+    return true;
+  }
   if (!window?.focus) return false;
   window.focus();
   return true;

package/src/renderers/electrobun/view/app-services.ts

@@ -7,7 +7,7 @@ import type { AppServices } from "../../../core/app-services";
 import type { AppConfig } from "../../../types/config";
 import { newsProvider } from "../../../capabilities";
 import { debugLog } from "../../../utils/debug-log";
-import { measurePerf } from "../../../utils/perf-marks";
+import { measurePerf, measurePerfAsync } from "../../../utils/perf-marks";
 import { getRendererBuiltinPlugins } from "../../../plugins/catalog-ui";
 import { createRemoteAssetDataClient } from "./remote/asset-data-client";
 import { RemotePersistence } from "./remote/persistence";
@@ -47,10 +47,11 @@ export function createAppServices({ config }: { config: AppConfig }): AppService
   }));
 
   const plugins = getRendererBuiltinPlugins();
+  const pluginReadyPromises: Promise<void>[] = [];
   for (const plugin of plugins) {
-    measurePerf("startup.services.register-plugin", () => {
-      void pluginRegistry.register(plugin);
-    }, { pluginId: plugin.id });
+    pluginReadyPromises.push(measurePerfAsync("startup.services.register-plugin", () => (
+      pluginRegistry.register(plugin)
+    ), { pluginId: plugin.id }));
   }
   measurePerf("startup.services.news-start", () => {
     newsService.start();
@@ -65,6 +66,7 @@ export function createAppServices({ config }: { config: AppConfig }): AppService
     marketData,
     pluginRegistry,
     newsService,
+    ready: Promise.all(pluginReadyPromises).then(() => {}),
     destroy() {
       setSharedMarketDataCoordinator(null);
       setSharedNewsService(null);

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

@@ -0,0 +1,50 @@
+import { renderAsciiText, type AsciiFontName } from "../../../../ui/ascii-font";
+
+const WEB_GLOOMBERB_WORDMARK = [
+  "  ____ _                       _               _     ",
+  " / ___| | ___   ___  _ __ ___ | |__   ___ _ __| |__  ",
+  "| |  _| |/ _ \\ / _ \\| '_ ` _ \\| '_ \\ / _ \\ '__| '_ \\ ",
+  "| |_| | | (_) | (_) | | | | | | |_) |  __/ |  | |_) |",
+  " \\____|_|\\___/ \\___/|_| |_| |_|_.__/ \\___|_|  |_.__/ ",
+];
+
+type WebWordmarkVariant = "legacy" | "compat" | null;
+
+function currentDesktopPlatform(): string {
+  const navigatorLike = (globalThis as {
+    navigator?: {
+      platform?: string;
+      userAgent?: string;
+      userAgentData?: { platform?: string };
+    };
+  }).navigator;
+  return [
+    navigatorLike?.userAgentData?.platform,
+    navigatorLike?.platform,
+    navigatorLike?.userAgent,
+  ].filter(Boolean).join(" ");
+}
+
+function isMacDesktopPlatform(desktopPlatform?: string): boolean {
+  const raw = desktopPlatform?.trim() || currentDesktopPlatform();
+  return /(darwin|mac|iphone|ipad|ipod)/i.test(raw);
+}
+
+export function webAsciiTextWordmarkVariant(
+  text: string,
+  font: AsciiFontName = "tiny",
+  desktopPlatform?: string,
+): WebWordmarkVariant {
+  if (font !== "wordmark" || text.trim().toLowerCase() !== "gloomberb") return null;
+  return isMacDesktopPlatform(desktopPlatform) ? "legacy" : "compat";
+}
+
+export function webAsciiTextLines(
+  text: string,
+  font: AsciiFontName = "tiny",
+  desktopPlatform?: string,
+): string[] {
+  return webAsciiTextWordmarkVariant(text, font, desktopPlatform) === "compat"
+    ? WEB_GLOOMBERB_WORDMARK
+    : renderAsciiText(text, font);
+}

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

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { renderAsciiText } from "../../../../ui/ascii-font";
+import { webAsciiTextLines, webAsciiTextWordmarkVariant } from "./ascii-text";
+
+describe("desktop web ASCII text", () => {
+  test("keeps the legacy Gloomberb wordmark on macOS", () => {
+    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "darwin")).toBe("legacy");
+    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "MacIntel")).toBe("legacy");
+    expect(webAsciiTextLines("Gloomberb", "wordmark", "darwin")).toEqual(
+      renderAsciiText("Gloomberb", "wordmark"),
+    );
+  });
+
+  test("uses the web-safe Gloomberb wordmark off macOS", () => {
+    const lines = webAsciiTextLines("Gloomberb", "wordmark", "win32");
+
+    expect(webAsciiTextWordmarkVariant("Gloomberb", "wordmark", "win32")).toBe("compat");
+    expect(lines).toHaveLength(5);
+    expect(lines[0]).toContain("____");
+    expect(lines).not.toEqual(renderAsciiText("Gloomberb", "wordmark"));
+  });
+});