@gloom-sh/terminal 0.0.0-stage → 0.19.0

package/src/renderers/dom/test-utils.tsx

@@ -0,0 +1,79 @@
+/** @jsxImportSource react */
+import { afterAll, afterEach, beforeAll } from "bun:test";
+import { Window } from "happy-dom";
+import { act, type ReactNode } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { UiHostProvider } from "../../ui";
+import type { UiHost } from "../../ui/host";
+import { WebBox } from "./host/box";
+import { WebText, WebSpan } from "./host/text";
+import { WebScrollBox } from "./host/scroll-box";
+import { WebInput } from "./host/input";
+import { WebImageSurface } from "./host/image-surface";
+import { WebButton, WebTextField } from "./desktop/controls";
+import { noopRendererHost } from "../../test-support/renderer-host";
+
+const BASE_CAPABILITIES = { cellWidthPx: 8, cellHeightPx: 18, fractionalViewport: true, nativePaneChrome: true };
+
+function createUi(capabilities: UiHost["capabilities"]): UiHost {
+  return {
+    kind: "desktop-web",
+    capabilities: { ...BASE_CAPABILITIES, ...capabilities },
+    Box: WebBox, Text: WebText, Span: WebSpan, ScrollBox: WebScrollBox,
+    Button: WebButton, Input: WebInput, TextField: WebTextField, ImageSurface: WebImageSurface,
+    SpinnerMark: () => null,
+  } as unknown as UiHost;
+}
+
+/** Each suite owns its DOM, including roots and globals even when an assertion fails. */
+export function createDomTestHarness({ withUi = true, capabilities }: {
+  withUi?: boolean;
+  /** Merged over the defaults, for surfaces that only exist on desktop chrome. */
+  capabilities?: UiHost["capabilities"];
+} = {}) {
+  const ui = createUi(capabilities);
+  const window = new Window({ url: "http://localhost" });
+  const roots = new Set<Root>();
+  const globals = {
+    IS_REACT_ACT_ENVIRONMENT: true,
+    window, document: window.document, navigator: window.navigator,
+    KeyboardEvent: window.KeyboardEvent, MouseEvent: window.MouseEvent,
+    WheelEvent: window.WheelEvent, Event: window.Event,
+    HTMLElement: window.HTMLElement, Node: window.Node,
+    requestAnimationFrame: (callback: (time: number) => void) => window.setTimeout(() => callback(Date.now()), 8),
+    cancelAnimationFrame: (id: NodeJS.Timeout) => window.clearTimeout(id),
+  };
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  beforeAll(() => {
+    for (const [key, value] of Object.entries(globals)) {
+      previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+      Object.defineProperty(globalThis, key, { configurable: true, writable: true, value });
+    }
+  });
+  afterEach(async () => {
+    await act(async () => {
+      for (const root of roots) root.unmount();
+      roots.clear();
+    });
+    window.document.body.replaceChildren();
+    await window.happyDOM.abort();
+  });
+  afterAll(() => {
+    for (const [key, descriptor] of previous) {
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+      else Reflect.deleteProperty(globalThis, key);
+    }
+  });
+
+  async function render(node: ReactNode): Promise<HTMLElement> {
+    const container = window.document.createElement("div");
+    window.document.body.appendChild(container);
+    const root = createRoot(container as unknown as HTMLElement);
+    roots.add(root);
+    await act(async () => {
+      root.render(withUi ? <UiHostProvider ui={ui} renderer={noopRendererHost}>{node}</UiHostProvider> : node);
+    });
+    return container as unknown as HTMLElement;
+  }
+  return { window, render };
+}

package/src/renderers/dom/toast-host.tsx

@@ -0,0 +1,95 @@
+/** @jsxImportSource react */
+import { useState, useSyncExternalStore, type ReactNode } from "react";
+import { useActionShortcut } from "../../ui";
+import {
+  createToastStore,
+  ToastHostProvider,
+  type ToastHost,
+  type ToastStore,
+} from "../../ui/toast";
+import { WebButton } from "./desktop/controls";
+import { WebIconButton } from "./desktop/icons";
+
+function ToastViewport({ store }: { store: ToastStore }) {
+  const toasts = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+  const { dismiss } = store;
+  const actionShortcut = useActionShortcut("notification-action");
+  const dismissShortcut = useActionShortcut("notification-dismiss");
+  const newestActionId = toasts.findLast((toast) => toast.options?.action)?.id;
+  return (
+    <div className="gloom-toast-viewport" aria-label="Notifications" aria-live="polite">
+      {toasts.map((toast) => {
+        const { action, secondaryAction, title, subtitle } = toast.options ?? {};
+        const activate = () => {
+          if (!action) return;
+          try {
+            action.onClick();
+          } finally {
+            dismiss(toast.id);
+          }
+        };
+        return (
+          <div
+            key={toast.id}
+            className="gloom-toast"
+            data-type={toast.tone}
+            data-actionable={action ? "true" : "false"}
+            onClick={action ? activate : undefined}
+          >
+            <span className="gloom-toast-indicator" aria-hidden="true" />
+            {(title || subtitle) && (
+              <div className="gloom-toast-heading">
+                {title && <span className="gloom-toast-title">{title}</span>}
+                {subtitle && <span className="gloom-toast-subtitle">{subtitle}</span>}
+              </div>
+            )}
+            <div className="gloom-toast-body">{toast.body}</div>
+            <div className="gloom-toast-controls">
+              {action && (
+                <WebButton
+                  label={action.label}
+                  shortcut={toast.id === newestActionId && actionShortcut ? actionShortcut : undefined}
+                  onPress={activate}
+                  stopPropagation
+                />
+              )}
+              {secondaryAction && (
+                <WebButton
+                  label={secondaryAction.label}
+                  variant="ghost"
+                  stopPropagation
+                  onPress={() => {
+                    try {
+                      secondaryAction.onClick();
+                    } finally {
+                      dismiss(toast.id);
+                    }
+                  }}
+                />
+              )}
+              <WebIconButton
+                icon="close"
+                label="Dismiss notification"
+                shortcut={dismissShortcut || undefined}
+                onPress={() => dismiss(toast.id)}
+              />
+            </div>
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+export function WebToastHostProvider({ children }: { children: ReactNode }) {
+  const [host] = useState<ToastHost>(() => {
+    const store = createToastStore();
+    return { ...store, Viewport: () => <ToastViewport store={store} /> };
+  });
+
+  return (
+    <ToastHostProvider host={host}>
+      {children}
+    </ToastHostProvider>
+  );
+}

package/src/renderers/dom/windowed-list.tsx

@@ -0,0 +1,201 @@
+/** @jsxImportSource react */
+import { useCallback, useLayoutEffect, useRef } from "react";
+import { observeElementRect, observeElementOffset, elementScroll } from "@tanstack/react-virtual";
+import type { WindowedListProps } from "../../components/ui/windowed-list";
+import type { ScrollBoxRenderable } from "../../ui/host";
+import { STICKY_BOTTOM_THRESHOLD_PX } from "../../ui/sticky-scroll";
+import { ScrollBox } from "../../ui";
+import { useWindowedRows } from "./windowed-rows";
+
+/** Uses the table's windowing engine, with measured rows and end anchoring. */
+export function WebWindowedList({ itemKeys, renderItem, scrollRef, estimateSize = 64, overscan = 8, onScrollActivity, onPinChange, onPointerMove, role }: WindowedListProps) {
+  const contentRef = useRef<HTMLDivElement | null>(null);
+  // Only the reader (a scroll to a position the list did not set) or a jump
+  // unpins. Sizes and arrivals keep it, as the DOM scroll box's sticky scroll
+  // does, and being at the end pins.
+  const pinnedRef = useRef(true);
+  // On a hidden initial mount, rows can be measured on reveal before the
+  // viewport observer runs. Keep the initial pin until that first real rect.
+  const resizingViewport = useRef(true);
+  // display:none, until the viewport is measured again. Its scroll position is not the list's then.
+  const hiddenRef = useRef(false);
+  // The position the list last set, or last read from a scroll event.
+  const knownTop = useRef<number | null>(null);
+  // A jump to a message: where it lands decides the pin, the end does not pull it back.
+  const navigating = useRef(false);
+  const syncOffset = useRef<((offset: number, scrolling: boolean) => void) | null>(null);
+  const onPinRef = useRef(onPinChange);
+  onPinRef.current = onPinChange;
+  const reportPin = useCallback((pinned: boolean) => {
+    if (pinnedRef.current === pinned) return;
+    pinnedRef.current = pinned;
+    onPinRef.current?.(pinned);
+  }, []);
+  /** A position the list did not set is the reader's: it pins or unpins by where it is. */
+  const readerScrolled = useCallback((element: HTMLElement) => {
+    if (knownTop.current === null || element.scrollTop === knownTop.current) return false;
+    knownTop.current = element.scrollTop;
+    reportPin(element.scrollHeight - element.clientHeight - element.scrollTop <= STICKY_BOTTOM_THRESHOLD_PX);
+    return true;
+  }, [reportPin]);
+  const getItemKey = useCallback((index: number) => itemKeys[index]!, [itemKeys]);
+  const { list, rows } = useWindowedRows(contentRef, {
+    count: itemKeys.length,
+    getItemKey,
+    getScrollElement: () => contentRef.current?.parentElement ?? null,
+    estimateSize: () => estimateSize,
+    // Images can end at fractional pixels. Rounding rows accumulates gaps or
+    // overlaps, and a remounted row may have a different wrapping width.
+    measureElement: (node, entry, instance) => {
+      // display:none reports zero for every row. Those are not new message
+      // heights: retain the measured history until its tab is visible again.
+      if (!instance.scrollElement?.clientHeight) return instance.measurementsCache[Number(node.dataset.index)]?.size ?? estimateSize;
+      return entry?.borderBoxSize?.[0]?.blockSize ?? node.getBoundingClientRect().height;
+    },
+    overscan,
+    // Start with the tail, never a first render of the entire channel. The
+    // actual viewport and row sizes replace these estimates before paint.
+    initialRect: { width: 0, height: 1 },
+    initialOffset: () => itemKeys.length * estimateSize,
+    anchorTo: "end",
+    // A hidden scrollport reports no extent, which otherwise looks like its
+    // end to the windowing engine when a message arrives in an inactive tab.
+    followOnAppend: pinnedRef.current,
+    scrollEndThreshold: STICKY_BOTTOM_THRESHOLD_PX,
+    scrollToFn: (offset, options, instance) => {
+      // Grow the scroll extent before scrolling to it. Otherwise the browser
+      // clamps a size correction to the old bottom, losing the last wrapped line.
+      if (contentRef.current) contentRef.current.style.height = `${instance.getTotalSize()}px`;
+      elementScroll(offset, options, instance);
+      // Measurements can arrive before the browser's scroll event. Report the
+      // applied position now so they cannot correct against the previous jump.
+      const element = instance.scrollElement;
+      if (element && element.clientHeight > 0) {
+        knownTop.current = element.scrollTop;
+        syncOffset.current?.(element.scrollTop, false);
+      }
+    },
+    observeElementOffset: (instance, callback) => {
+      syncOffset.current = callback;
+      // The engine's settle callback repeats the last event's offset, which an
+      // adjustment since may have replaced: read the live one.
+      const dispose = observeElementOffset(instance, (_offset, scrolling) => {
+        const element = instance.scrollElement;
+        if (!element?.clientHeight || hiddenRef.current) return;
+        if (!resizingViewport.current) readerScrolled(element);
+        knownTop.current = element.scrollTop;
+        callback(element.scrollTop, scrolling);
+      });
+      return () => { syncOffset.current = null; dispose?.(); };
+    },
+    observeElementRect: (instance, callback) => {
+      let height: number | undefined;
+      return observeElementRect(instance, (rect) => {
+        if (rect.height === 0) { hiddenRef.current = true; return; }
+        // Width belongs to CSS. A live horizontal resize need not render React.
+        if (height === rect.height && !hiddenRef.current) return;
+        const restore = hiddenRef.current;
+        hiddenRef.current = false;
+        height = rect.height;
+        const follow = pinnedRef.current;
+        const offset = instance.scrollOffset;
+        resizingViewport.current = true;
+        callback({ width: 0, height: rect.height });
+        if (follow) instance.scrollToEnd();
+        else if (restore && offset !== null) instance.scrollToOffset(offset);
+        resizingViewport.current = false;
+      });
+    },
+    onChange: (instance) => {
+      const element = instance.scrollElement;
+      if (resizingViewport.current || hiddenRef.current || !element?.clientHeight) return;
+      if (readerScrolled(element) || navigating.current) return;
+      const end = element.scrollHeight - element.clientHeight;
+      const atEnd = end - element.scrollTop <= STICKY_BOTTOM_THRESHOLD_PX;
+      if (!pinnedRef.current) {
+        if (atEnd) reportPin(true);
+        return;
+      }
+      // Rows can report new heights before the viewport reports its own in the
+      // same frame, and a row that grows in view keeps its top. Neither is the
+      // reader leaving the end: keep it, by the DOM's extent, not the engine's.
+      if (!atEnd) instance.scrollToOffset(end);
+    },
+  });
+  // Preserve the top of the first visible row, including a partially read row.
+  // Measuring overscan above it must adjust even during an upward wheel gesture.
+  list.shouldAdjustScrollPositionOnItemSizeChange = (row, _delta, instance) => row.end <= (instance.scrollOffset ?? 0);
+  const keysRef = useRef(itemKeys);
+  keysRef.current = itemKeys;
+  const restoreFrame = useRef<number | null>(null);
+  const cancelRestore = useCallback(() => {
+    if (restoreFrame.current !== null) cancelAnimationFrame(restoreFrame.current);
+    restoreFrame.current = null;
+  }, []);
+  /** Scrolls for a jump, then pins or unpins by where it landed. Nothing moved, nothing changes. */
+  const navigate = useCallback((scroll: () => void) => {
+    const from = list.scrollElement?.scrollTop;
+    navigating.current = true;
+    try { scroll(); } finally { navigating.current = false; }
+    if (list.scrollElement?.clientHeight && list.scrollElement.scrollTop !== from) reportPin(list.isAtEnd(STICKY_BOTTOM_THRESHOLD_PX));
+  }, [list, reportPin]);
+  const handleScrollActivity = useCallback<NonNullable<WindowedListProps["onScrollActivity"]>>((event) => {
+    if (event?.scroll) cancelRestore();
+    onScrollActivity?.(event);
+  }, [cancelRestore, onScrollActivity]);
+  const setScrollRef = useCallback((handle: ScrollBoxRenderable | null) => {
+    if (handle) {
+      handle.scrollToEnd = () => {
+        cancelRestore();
+        pinnedRef.current = true;
+        list.scrollToEnd();
+        onPinRef.current?.(true);
+      };
+      handle.scrollToItem = (key, { align = "auto", offset = 0 } = {}) => {
+        const index = keysRef.current.indexOf(key);
+        if (index < 0) return false;
+        cancelRestore();
+        if (align === "center") {
+          const row = list.elementsCache.get(key)?.getBoundingClientRect();
+          const view = list.scrollElement?.getBoundingClientRect();
+          // A link to an already visible row marks it without moving the reader.
+          if (row && view && view.height > 0 && row.top >= view.top && row.bottom <= view.bottom) return true;
+        }
+        // Selection calls this even when the row is already in view. A no-op
+        // must not unpin a reader at the bottom before the composer resizes.
+        navigate(() => list.scrollToIndex(index, { align }));
+        if (align === "start") {
+          // The target must be mounted and measured before restoring a partial
+          // row at the viewport's top. Cancel on disposal or a subsequent jump.
+          restoreFrame.current = requestAnimationFrame(() => {
+            restoreFrame.current = requestAnimationFrame(() => {
+              restoreFrame.current = null;
+              const row = list.elementsCache.get(key);
+              const scroller = list.scrollElement;
+              if (row && scroller) navigate(() => list.scrollToOffset(scroller.scrollTop + row.getBoundingClientRect().top - scroller.getBoundingClientRect().top - offset));
+            });
+          });
+        }
+        return true;
+      };
+    }
+    scrollRef.current = handle;
+  }, [cancelRestore, list, navigate, scrollRef]);
+  useLayoutEffect(() => {
+    list.scrollToEnd();
+    return cancelRestore;
+  }, [cancelRestore, list]);
+  const setContent = useCallback((node: HTMLDivElement | null) => {
+    contentRef.current = node;
+  }, []);
+  return <ScrollBox ref={setScrollRef} flexGrow={1} scrollY focusable={false}
+    data-gloom-role={role} onMouseScroll={handleScrollActivity} onMouseMove={onPointerMove}
+    style={{ minHeight: 0, display: "block", overflowAnchor: "none" }}>
+    <div ref={setContent} style={{ position: "relative", width: "100%", height: list.getTotalSize() }}>
+      {rows.map((row) => <div key={row.key} data-index={row.index} ref={list.measureElement}
+        style={{ position: "absolute", top: 0, left: 0, width: "100%", transform: `translateY(${row.start}px)` }}>
+        {renderItem(row.index)}
+      </div>)}
+    </div>
+  </ScrollBox>;
+}

package/src/renderers/dom/windowed-rows.ts

@@ -0,0 +1,65 @@
+import { useLayoutEffect, useReducer, useRef, useState, type RefObject } from "react";
+import { flushSync } from "react-dom";
+import { Virtualizer, type VirtualizerOptions } from "@tanstack/react-virtual";
+
+/**
+ * The shared windowing engine with a buffered React subscription. Size changes
+ * update CSS positions directly; React only mounts rows when the viewport is
+ * about to leave the existing overscan. In particular, wrapping during a pane
+ * resize must not commit once per visible-range change.
+ */
+export function useWindowedRows(
+  content: RefObject<HTMLDivElement | null>,
+  options: VirtualizerOptions<HTMLElement, HTMLDivElement>,
+) {
+  const [, render] = useReducer((value: number) => value + 1, 0);
+  const windowRef = useRef<{ start: number; end: number; count: number; firstKey: unknown } | null>(null);
+  const needsWindow = (list: Virtualizer<HTMLElement, HTMLDivElement>) => {
+    const mounted = windowRef.current;
+    const visible = list.range;
+    if (!mounted || mounted.count !== list.options.count || mounted.firstKey !== list.options.getItemKey(0)) return true;
+    if (!visible) return false;
+    // Scroll notifications commit synchronously. Keep two rows in reserve,
+    // but let the rest of the overscan absorb wrapping during a live resize.
+    const buffer = Math.min(2, list.options.overscan);
+    return (mounted.start > 0 && visible.startIndex < mounted.start + buffer)
+      || (mounted.end < list.options.count - 1 && visible.endIndex > mounted.end - buffer)
+      // A much smaller viewport must also shed its old window. Keep hysteresis
+      // for ordinary wrapping, without retaining an arbitrarily large old view.
+      || visible.startIndex - mounted.start > list.options.overscan * 2
+      || mounted.end - visible.endIndex > list.options.overscan * 2;
+  };
+  const positionRows = (list: Virtualizer<HTMLElement, HTMLDivElement>) => {
+    const total = list.getTotalSize();
+    if (content.current) content.current.style.height = `${total}px`;
+    for (const [key, element] of list.elementsCache) {
+      const row = list.measurementsCache[Number(element.dataset.index)];
+      if (row?.key === key) element.style.transform = `translateY(${row.start}px)`;
+    }
+  };
+  const resolved = {
+    ...options,
+    onChange: (list: Virtualizer<HTMLElement, HTMLDivElement>, sync: boolean) => {
+      positionRows(list);
+      if (needsWindow(list)) {
+        if (sync) flushSync(render);
+        else render();
+      }
+      options.onChange?.(list, sync);
+    },
+  };
+  const [list] = useState(() => new Virtualizer(resolved));
+  list.setOptions(resolved);
+  const desired = list.getVirtualItems();
+  if (needsWindow(list)) windowRef.current = {
+    start: desired[0]?.index ?? 0,
+    end: desired.at(-1)?.index ?? -1,
+    count: options.count,
+    firstKey: options.getItemKey?.(0),
+  };
+  const mounted = windowRef.current!;
+  const rows = list.measurementsCache.slice(mounted.start, mounted.end + 1);
+  useLayoutEffect(() => list._didMount(), [list]);
+  useLayoutEffect(() => { list._willUpdate(); positionRows(list); });
+  return { list, rows };
+}

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

@@ -0,0 +1,66 @@
+import {
+  ELECTROBUN_APPLICATION_MENU_ACTION,
+  type ElectrobunApplicationMenuCommand,
+} from "./index";
+import { recordOrNull } from "../../../../utils/guards";
+import { createOneShots } from "../../../../utils/one-shot";
+import { menuClickPayload } from "../menu-event";
+
+function normalizeApplicationMenuCommand(value: unknown): ElectrobunApplicationMenuCommand | null {
+  const command = recordOrNull(value);
+  if (!command || typeof command.type !== "string") return null;
+
+  switch (command.type) {
+    case "open-command-bar":
+      if (command.query != null && typeof command.query !== "string") return null;
+      return command.query == null
+        ? { type: "open-command-bar" }
+        : { type: "open-command-bar", query: command.query };
+    case "open-plugin-workflow":
+      return typeof command.commandId === "string" && command.commandId.length > 0
+        ? { type: "open-plugin-workflow", commandId: command.commandId }
+        : null;
+    case "open-builtin-workflow":
+      return typeof command.actionId === "string" && command.actionId.length > 0
+        ? { type: "open-builtin-workflow", actionId: command.actionId }
+        : null;
+    case "open-url":
+      return typeof command.url === "string" && command.url.length > 0
+        ? { type: "open-url", url: command.url }
+        : null;
+    case "check-for-updates":
+    case "toggle-status-bar":
+    case "open-layout-gallery":
+    case "layout-undo":
+    case "layout-redo":
+    case "layout-gridlock":
+    case "open-devtools":
+    case "quit":
+      return { type: command.type };
+    default:
+      return null;
+  }
+}
+
+export function applicationMenuCommand(event: unknown): ElectrobunApplicationMenuCommand | null {
+  const payload = menuClickPayload(event);
+  if (payload?.action !== ELECTROBUN_APPLICATION_MENU_ACTION) return null;
+  return normalizeApplicationMenuCommand(payload.data);
+}
+
+/**
+ * Holding a menu accelerator (Cmd+Shift+L, Cmd+K) makes the system click its
+ * item again about thirty times a second, and the click that reaches the Bun
+ * process says nothing about being a repeat. Each command runs once, then not
+ * again until none has come for a cooldown: a held key stays refused, and
+ * nothing queues up to run after it is released.
+ */
+export function createApplicationMenuGate(options?: { cooldownMs?: number; now?: () => number }) {
+  const shots = createOneShots(options);
+  return (command: ElectrobunApplicationMenuCommand): boolean => {
+    const shot = shots.get(JSON.stringify(command));
+    if (shot.refuses()) return false;
+    shot.end();
+    return true;
+  };
+}

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

@@ -0,0 +1,137 @@
+import type { ApplicationMenuItemConfig } from "electrobun/bun";
+import type { DesktopApplicationMenuCommand } from "../../../../types/desktop-menu";
+import type { KeybindingsConfig } from "../../../../types/config";
+import { menuAcceleratorFor } from "../../../../app/keybindings/labels";
+import { resolveKeybindings, type ResolvedKeybindings } from "../../../../app/keybindings/resolve";
+
+export const ELECTROBUN_APPLICATION_MENU_ACTION = "gloom.application-menu.select";
+const GITHUB_ISSUE_URL = "https://github.com/gloom-sh/gloomberb/issues/new/choose";
+
+export type ElectrobunApplicationMenuCommand =
+  | DesktopApplicationMenuCommand
+  | { type: "open-devtools" };
+
+function commandItem(
+  label: string,
+  command: ElectrobunApplicationMenuCommand,
+  options: { accelerator?: string } = {},
+): ApplicationMenuItemConfig {
+  return {
+    label,
+    action: ELECTROBUN_APPLICATION_MENU_ACTION,
+    data: command,
+    ...(options.accelerator ? { accelerator: options.accelerator } : {}),
+  };
+}
+
+function openCommandBar(label: string, query: string, options?: { accelerator?: string }): ApplicationMenuItemConfig {
+  return commandItem(label, { type: "open-command-bar", query }, options);
+}
+
+function buildApplicationMenu(keybindings: ResolvedKeybindings): ApplicationMenuItemConfig[] {
+  const accelerator = (actionId: string) => ({ accelerator: menuAcceleratorFor(keybindings, actionId) });
+  return [
+    {
+      label: "Gloom",
+      submenu: [
+        { role: "about" },
+        { type: "divider" },
+        commandItem("Check for Updates...", { type: "check-for-updates" }),
+        openCommandBar("Release Channel...", "Release Channel"),
+        { type: "divider" },
+        { role: "hide" },
+        { role: "hideOthers" },
+        { role: "showAll" },
+        { type: "divider" },
+        commandItem("Quit Gloom", { type: "quit" }, { accelerator: "CmdOrCtrl+Q" }),
+      ],
+    },
+    {
+      label: "File",
+      submenu: [
+        openCommandBar("Search Ticker...", "DES ", accelerator("ticker-search")),
+        { type: "divider" },
+        commandItem("New Portfolio...", { type: "open-builtin-workflow", actionId: "new-portfolio" }),
+        commandItem("New Watchlist...", { type: "open-builtin-workflow", actionId: "new-watchlist" }),
+        commandItem("Set Portfolio Position...", { type: "open-builtin-workflow", actionId: "set-portfolio-position" }),
+        { type: "divider" },
+        commandItem("Add Broker Account...", { type: "open-builtin-workflow", actionId: "add-broker-account" }),
+        { type: "divider" },
+        openCommandBar("Import Config...", "Import Config"),
+        openCommandBar("Export Config...", "Export Config"),
+        { type: "divider" },
+        openCommandBar("Reset All Data...", "Reset All Data"),
+      ],
+    },
+    {
+      label: "Edit",
+      submenu: [
+        { role: "undo" },
+        { role: "redo" },
+        { type: "divider" },
+        { role: "cut" },
+        { role: "copy" },
+        { role: "paste" },
+        { role: "pasteAndMatchStyle" },
+        { role: "delete" },
+        { role: "selectAll" },
+      ],
+    },
+    {
+      label: "View",
+      submenu: [
+        openCommandBar("Open Command Bar", "", accelerator("command-bar")),
+        commandItem("Open Developer Tools", { type: "open-devtools" }),
+        { type: "divider" },
+        commandItem("Toggle Status Bar", { type: "toggle-status-bar" }),
+        { type: "divider" },
+        openCommandBar("Change Theme...", "TH "),
+        openCommandBar("Manage Plugins...", "PL "),
+      ],
+    },
+    {
+      label: "Layout",
+      submenu: [
+        commandItem("Layouts...", { type: "open-layout-gallery" }, accelerator("layout-gallery")),
+        openCommandBar("Layout Actions...", "LMA "),
+        { type: "divider" },
+        commandItem("Undo Layout Change", { type: "layout-undo" }),
+        commandItem("Redo Layout Change", { type: "layout-redo" }),
+        commandItem("Tidy Windows", { type: "layout-gridlock" }, accelerator("tidy-windows")),
+        { type: "divider" },
+        commandItem("New Layout...", { type: "open-builtin-workflow", actionId: "new-layout" }),
+        openCommandBar("Add a Desk...", "DESK "),
+        commandItem("Rename Current Layout...", { type: "open-builtin-workflow", actionId: "rename-layout" }),
+        openCommandBar("Duplicate Current Layout", "Duplicate Layout"),
+        openCommandBar("Delete Current Layout...", "Delete Layout"),
+      ],
+    },
+    {
+      label: "Window",
+      submenu: [
+        { role: "minimize" },
+        { role: "zoom" },
+        { type: "divider" },
+        { role: "toggleFullScreen" },
+        { type: "divider" },
+        { role: "close" },
+        { type: "divider" },
+        { role: "bringAllToFront" },
+      ],
+    },
+    {
+      label: "Help",
+      submenu: [
+        openCommandBar("Gloom Help", "HELP"),
+        commandItem("Open Issue on GitHub", { type: "open-url", url: GITHUB_ISSUE_URL }),
+      ],
+    },
+  ];
+}
+
+export function buildDesktopApplicationMenu(
+  platform = process.platform,
+  keybindings?: KeybindingsConfig,
+): ApplicationMenuItemConfig[] {
+  return platform === "win32" ? [] : buildApplicationMenu(resolveKeybindings(keybindings));
+}