gloomberb 0.10.1 → 0.10.2

package/src/react/input.test.ts

@@ -1,7 +1,15 @@
 import { describe, expect, test } from "bun:test";
-import { shouldDeliverShortcut, type KeyEventLike } from "./input";
+import {
+  createShortcutRegistry,
+  shouldDeliverShortcut,
+  type KeyEventLike,
+  type ShortcutOptions,
+  type ShortcutRegistry,
+} from "./input";
 
 function keyEvent(overrides: Partial<KeyEventLike> = {}): KeyEventLike {
+  let defaultPrevented = false;
+  let propagationStopped = false;
   return {
     key: "k",
     name: "k",
@@ -9,12 +17,36 @@ function keyEvent(overrides: Partial<KeyEventLike> = {}): KeyEventLike {
     shift: false,
     alt: false,
     meta: false,
-    preventDefault: () => {},
-    stopPropagation: () => {},
+    get defaultPrevented() {
+      return defaultPrevented;
+    },
+    get propagationStopped() {
+      return propagationStopped;
+    },
+    preventDefault: () => {
+      defaultPrevented = true;
+    },
+    stopPropagation: () => {
+      propagationStopped = true;
+    },
     ...overrides,
   };
 }
 
+function registerShortcut(
+  registry: ShortcutRegistry,
+  handler: (event: KeyEventLike) => void,
+  options: ShortcutOptions & { isEnabled?: () => boolean } = {},
+): () => void {
+  return registry.register({
+    handler,
+    isEnabled: options.isEnabled ?? (() => options.enabled !== false),
+    allowsEditable: () => options.allowEditable === true,
+    phase: options.phase ?? "normal",
+    scope: options.scope,
+  });
+}
+
 describe("shouldDeliverShortcut", () => {
   test("keeps plain app shortcuts out of editable targets by default", () => {
     expect(shouldDeliverShortcut(keyEvent({ targetEditable: true }), false)).toBe(false);
@@ -27,3 +59,94 @@ describe("shouldDeliverShortcut", () => {
     expect(shouldDeliverShortcut(keyEvent({ targetEditable: true, meta: true }), false)).toBe(true);
   });
 });
+
+describe("shortcut registry", () => {
+  test("dispatches capture, normal, and bubble phases in order", () => {
+    const calls: string[] = [];
+    const registry = createShortcutRegistry();
+    registerShortcut(registry, () => calls.push("normal-1"));
+    registerShortcut(registry, () => calls.push("after"), { phase: "after" });
+    registerShortcut(registry, () => calls.push("before"), { phase: "before" });
+    registerShortcut(registry, () => calls.push("normal-2"));
+
+    registry.dispatch(keyEvent());
+
+    expect(calls).toEqual(["before", "normal-1", "normal-2", "after"]);
+  });
+
+  test("skips the bubble phase after an earlier handler prevents the default action", () => {
+    const calls: string[] = [];
+    const registry = createShortcutRegistry();
+    registerShortcut(registry, (event) => {
+      calls.push("normal");
+      event.preventDefault();
+    });
+    registerShortcut(registry, () => calls.push("after"), { phase: "after" });
+
+    registry.dispatch(keyEvent());
+
+    expect(calls).toEqual(["normal"]);
+  });
+
+  test("gives the newest scope first refusal and keeps a consumed event in that scope", () => {
+    const calls: string[] = [];
+    const registry = createShortcutRegistry();
+    registerShortcut(registry, () => calls.push("older"), { scope: "older-dialog" });
+    registerShortcut(registry, () => calls.push("global"));
+    registerShortcut(registry, (event) => {
+      calls.push("newer-1");
+      event.preventDefault();
+    }, { scope: "newer-dialog" });
+    registerShortcut(registry, () => calls.push("newer-2"), { scope: "newer-dialog" });
+
+    registry.dispatch(keyEvent());
+
+    expect(calls).toEqual(["newer-1", "newer-2"]);
+  });
+
+  test("falls through scopes until a handler consumes the event", () => {
+    const calls: string[] = [];
+    const registry = createShortcutRegistry();
+    registerShortcut(registry, () => calls.push("older"), { scope: "older" });
+    registerShortcut(registry, () => calls.push("global"));
+    registerShortcut(registry, () => calls.push("newer"), { scope: "newer" });
+
+    registry.dispatch(keyEvent());
+
+    expect(calls).toEqual(["newer", "older", "global"]);
+  });
+
+  test("applies editable and enabled gates before scope ordering", () => {
+    const calls: string[] = [];
+    const registry = createShortcutRegistry();
+    registerShortcut(registry, () => calls.push("editable-blocked"), { scope: "newest" });
+    registerShortcut(registry, () => calls.push("disabled"), {
+      scope: "newest",
+      enabled: false,
+    });
+    registerShortcut(registry, () => calls.push("allowed"), {
+      scope: "older",
+      allowEditable: true,
+    });
+
+    registry.dispatch(keyEvent({ targetEditable: true }));
+
+    expect(calls).toEqual(["allowed"]);
+  });
+
+  test("stops propagation immediately and removes cleaned-up handlers", () => {
+    const calls: string[] = [];
+    const registry = createShortcutRegistry();
+    const unregister = registerShortcut(registry, () => calls.push("removed"));
+    unregister();
+    registerShortcut(registry, (event) => {
+      calls.push("stop");
+      event.stopPropagation();
+    });
+    registerShortcut(registry, () => calls.push("skipped"));
+
+    registry.dispatch(keyEvent());
+
+    expect(calls).toEqual(["stop"]);
+  });
+});

package/src/react/input.ts

@@ -1,4 +1,11 @@
-import { createContext, createElement, useContext, type ReactNode } from "react";
+import {
+  createContext,
+  createElement,
+  useContext,
+  useLayoutEffect,
+  useRef,
+  type ReactNode,
+} from "react";
 
 export interface KeyEventLike {
   key: string;
@@ -18,11 +25,123 @@ export interface KeyEventLike {
 
 export interface ShortcutOptions {
   enabled?: boolean;
+  /**
+   * Groups related handlers into one interaction surface. Within each phase,
+   * newer enabled scopes receive events before older scopes and unscoped
+   * handlers. Once a scoped handler prevents the default action, only that
+   * scope receives the rest of the dispatch.
+   */
   scope?: string;
   phase?: "before" | "normal" | "after";
   allowEditable?: boolean;
 }
 
+interface ShortcutRegistration {
+  handler(event: KeyEventLike): void;
+  isEnabled(): boolean;
+  allowsEditable(): boolean;
+  scope?: string;
+  phase: NonNullable<ShortcutOptions["phase"]>;
+}
+
+interface ShortcutEntry extends ShortcutRegistration {
+  order: number;
+}
+
+export interface ShortcutRegistry {
+  register(registration: ShortcutRegistration): () => void;
+  dispatch(event: KeyEventLike): void;
+}
+
+const SHORTCUT_PHASES: ReadonlyArray<ShortcutEntry["phase"]> = [
+  "before",
+  "normal",
+  "after",
+];
+
+function normalizeShortcutScope(scope: string | undefined): string | undefined {
+  const normalized = scope?.trim();
+  return normalized || undefined;
+}
+
+function orderShortcutEntries(entries: ShortcutEntry[]): ShortcutEntry[] {
+  const scopePriority = new Map<string, number>();
+  for (const entry of entries) {
+    if (!entry.scope) continue;
+    scopePriority.set(entry.scope, Math.max(scopePriority.get(entry.scope) ?? 0, entry.order));
+  }
+
+  return entries.sort((left, right) => {
+    if (left.scope === right.scope) return left.order - right.order;
+    if (!left.scope) return 1;
+    if (!right.scope) return -1;
+    return (scopePriority.get(right.scope) ?? 0) - (scopePriority.get(left.scope) ?? 0);
+  });
+}
+
+export function createShortcutRegistry(): ShortcutRegistry {
+  let nextOrder = 1;
+  const entries = new Map<number, ShortcutEntry>();
+
+  return {
+    register(registration) {
+      const order = nextOrder++;
+      entries.set(order, {
+        ...registration,
+        scope: normalizeShortcutScope(registration.scope),
+        order,
+      });
+      return () => {
+        entries.delete(order);
+      };
+    },
+    dispatch(event) {
+      const eligible = orderShortcutEntries(
+        [...entries.values()].filter((entry) => (
+          entry.isEnabled() && shouldDeliverShortcut(event, entry.allowsEditable())
+        )),
+      );
+      let claimedScope: string | undefined;
+
+      for (const phase of SHORTCUT_PHASES) {
+        if (phase === "after" && (event.defaultPrevented || event.propagationStopped)) return;
+        for (const entry of eligible) {
+          if (entry.phase !== phase) continue;
+          if (claimedScope && entry.scope !== claimedScope) continue;
+
+          const wasDefaultPrevented = event.defaultPrevented === true;
+          entry.handler(event);
+          if (!wasDefaultPrevented && event.defaultPrevented && entry.scope) {
+            claimedScope = entry.scope;
+          }
+          if (event.propagationStopped) return;
+        }
+      }
+    },
+  };
+}
+
+export function useRegisteredShortcut(
+  registry: ShortcutRegistry,
+  handler: (event: KeyEventLike) => void,
+  options?: ShortcutOptions,
+): void {
+  const handlerRef = useRef(handler);
+  const enabledRef = useRef(options?.enabled !== false);
+  const allowEditableRef = useRef(options?.allowEditable === true);
+  handlerRef.current = handler;
+  enabledRef.current = options?.enabled !== false;
+  allowEditableRef.current = options?.allowEditable === true;
+
+  useLayoutEffect(() => registry.register({
+    handler: (event) => handlerRef.current(event),
+    isEnabled: () => enabledRef.current,
+    allowsEditable: () => allowEditableRef.current,
+    phase: options?.phase ?? "normal",
+    scope: options?.scope,
+  }), [options?.phase, options?.scope, registry]);
+}
+
 export interface InputHost {
   useShortcut(
     handler: (event: KeyEventLike) => void,

package/src/remote/app-host.tsx

@@ -1,4 +1,4 @@
-import { createContext, useContext, useEffect, useMemo } from "react";
+import { useEffect, useMemo } from "react";
 import type { Dispatch, ReactNode } from "react";
 import type { PluginRegistry } from "../plugins/registry";
 import type { AppAction, AppState } from "../state/app/context";
@@ -9,14 +9,7 @@ import type { RemoteControlRequest, RemoteControlResponse } from "./types";
 
 export type RemoteControlHandler = (request: RemoteControlRequest) => Promise<RemoteControlResponse>;
 
-const RemoteControlHandlerContext = createContext<RemoteControlHandler | null>(null);
-
-export function useRemoteControlHandler(): RemoteControlHandler | null {
-  return useContext(RemoteControlHandlerContext);
-}
-
 export interface RemoteControlAdapter {
-  handleRequest?: RemoteControlHandler;
   startServer?(options: { dataDir: string; handle: RemoteControlHandler }): void | (() => void | Promise<void>);
   registerHandler?(handler: RemoteControlHandler | null): void | (() => void);
 }
@@ -82,9 +75,5 @@ export function RemoteControlHost({
     };
   }, [adapter, controller]);
 
-  return (
-    <RemoteControlHandlerContext value={adapter?.handleRequest ?? (adapter ? controller.handle : null)}>
-      {children}
-    </RemoteControlHandlerContext>
-  );
+  return children;
 }

package/src/renderers/electrobun/bun/desktop/backend-requests.ts

@@ -9,7 +9,11 @@ import {
 } from "../../../../data/config/store";
 import type { AppConfig } from "../../../../types/config";
 import type { DesktopSharedStateSnapshot } from "../../../../types/desktop-window";
-import type { ReleaseInfo } from "../../../../updater";
+import type {
+  DesktopBackendRequestPayload,
+  DesktopBackendRequestResponse,
+  DesktopCoreRequest,
+} from "../../shared/protocol";
 import {
   checkElectrobunDesktopUpdate,
 } from "./update";
@@ -18,22 +22,6 @@ import {
   type DesktopWorkspace,
 } from "./workspace";
 
-const UNHANDLED_BACKEND_REQUEST = Symbol("unhandled backend request");
-
-interface DesktopBackendRequestHandled {
-  handled: true;
-  value: unknown;
-}
-
-interface DesktopBackendRequestUnhandled {
-  handled: false;
-  value: typeof UNHANDLED_BACKEND_REQUEST;
-}
-
-export type DesktopBackendRequestResult =
-  | DesktopBackendRequestHandled
-  | DesktopBackendRequestUnhandled;
-
 interface DesktopBackendRequestOptions {
   clearCurrentConfig: () => void;
   closeAllDetachedWindows: () => void;
@@ -42,8 +30,7 @@ interface DesktopBackendRequestOptions {
   getDesktopWorkspace: () => DesktopWorkspace | null;
   getServices: () => AppServices;
   getSessionSnapshot: () => AppSessionSnapshot | null;
-  method: string;
-  payload: Record<string, unknown>;
+  request: DesktopCoreRequest;
   reconcileDetachedWindows: () => void;
   registerCoreCapabilities: () => void;
   sendDesktopState: (snapshot: DesktopSharedStateSnapshot) => void;
@@ -55,19 +42,10 @@ interface DesktopBackendRequestOptions {
   teardownServices: () => void;
 }
 
-function handled(value: unknown): DesktopBackendRequestHandled {
-  return { handled: true, value };
-}
-
-function unhandled(): DesktopBackendRequestUnhandled {
-  return { handled: false, value: UNHANDLED_BACKEND_REQUEST };
-}
-
 async function importDesktopConfig({
   closeAllDetachedWindows,
   getConfig,
   getSessionSnapshot,
-  payload,
   reconcileDetachedWindows,
   registerCoreCapabilities,
   sendDesktopState,
@@ -76,11 +54,13 @@ async function importDesktopConfig({
   setServices,
   syncConfigAccessors,
   teardownServices,
-}: DesktopBackendRequestOptions): Promise<AppConfig> {
+}: DesktopBackendRequestOptions,
+  payload: DesktopBackendRequestPayload<"config.import">,
+): Promise<AppConfig> {
   closeAllDetachedWindows();
   setDesktopWorkspace(null);
   teardownServices();
-  setCurrentConfig(await importConfig(payload.dataDir as string, payload.srcPath as string));
+  setCurrentConfig(await importConfig(payload.dataDir, payload.srcPath));
   setServices(createAppServices({
     config: getConfig(),
     plugins: getDesktopBackendPlugins(),
@@ -96,7 +76,7 @@ async function importDesktopConfig({
 
 export async function handleDesktopBackendRequest(
   options: DesktopBackendRequestOptions,
-): Promise<DesktopBackendRequestResult> {
+): Promise<DesktopBackendRequestResponse<DesktopCoreRequest["method"]>> {
   const {
     clearCurrentConfig,
     closeAllDetachedWindows,
@@ -104,64 +84,68 @@ export async function handleDesktopBackendRequest(
     getConfig,
     getDesktopWorkspace,
     getServices,
-    method,
-    payload,
+    request,
     setCurrentConfig,
     setDesktopWorkspace,
     startUpdate,
     teardownServices,
   } = options;
 
-  switch (method) {
+  switch (request.method) {
     case "update.check":
-      return handled(checkElectrobunDesktopUpdate(
-        typeof payload.currentVersion === "string" ? payload.currentVersion : "",
-      ));
+      return checkElectrobunDesktopUpdate(
+        typeof request.payload.currentVersion === "string" ? request.payload.currentVersion : "",
+      );
     case "update.start": {
-      const release = payload.release && typeof payload.release === "object"
-        ? payload.release as Partial<ReleaseInfo>
-        : null;
-      startUpdate(typeof payload.currentVersion === "string" ? payload.currentVersion : release?.version ?? "");
-      return handled(null);
+      const { release, currentVersion } = request.payload;
+      startUpdate(typeof currentVersion === "string" ? currentVersion : release.version);
+      return null;
     }
     case "ticker.loadAll":
-      return handled(getServices().tickerRepository.loadAllTickers());
+      return getServices().tickerRepository.loadAllTickers();
     case "ticker.load":
-      return handled(getServices().tickerRepository.loadTicker(payload.symbol as string));
+      return getServices().tickerRepository.loadTicker(request.payload.symbol);
     case "ticker.save":
-      return handled(getServices().tickerRepository.saveTicker(payload.ticker as never));
+      await getServices().tickerRepository.saveTicker(request.payload.ticker);
+      return null;
     case "ticker.delete":
-      return handled(getServices().tickerRepository.deleteTicker(payload.symbol as string));
+      await getServices().tickerRepository.deleteTicker(request.payload.symbol);
+      return null;
     case "config.save": {
-      setCurrentConfig(payload.config as AppConfig);
+      setCurrentConfig(request.payload.config);
       const desktopWorkspace = getDesktopWorkspace();
       if (desktopWorkspace) {
         await commitDesktopSnapshot(desktopWorkspace.replaceConfig(getConfig(), { layoutChanged: true }));
-        return handled(null);
+        return null;
       }
-      return handled(saveConfig(getConfig()));
+      await saveConfig(getConfig());
+      return null;
     }
     case "config.resetAllData":
       closeAllDetachedWindows();
       setDesktopWorkspace(null);
       teardownServices();
       clearCurrentConfig();
-      return handled(resetAllData(payload.dataDir as string));
+      await resetAllData(request.payload.dataDir);
+      return null;
     case "config.export":
-      return handled(exportConfig(payload.config as AppConfig, payload.destPath as string));
+      await exportConfig(request.payload.config, request.payload.destPath);
+      return null;
     case "config.import":
-      return handled(await importDesktopConfig(options));
+      return importDesktopConfig(options, request.payload);
     case "session.set":
       getServices().persistence.sessions.set(
-        payload.sessionId as string,
-        payload.value,
-        payload.schemaVersion as number | undefined,
+        request.payload.sessionId,
+        request.payload.value,
+        request.payload.schemaVersion,
       );
-      return handled(null);
+      return null;
     case "session.delete":
-      getServices().persistence.sessions.delete(payload.sessionId as string);
-      return handled(null);
-    default:
-      return unhandled();
+      getServices().persistence.sessions.delete(request.payload.sessionId);
+      return null;
+    default: {
+      const exhaustive: never = request;
+      throw new Error(`Unknown core backend method: ${String(exhaustive)}`);
+    }
   }
 }

package/src/renderers/electrobun/bun/desktop/capability-bridge.ts

@@ -1,4 +1,5 @@
 import type { AppServices } from "../../../../core/app-services";
+import type { DesktopCapabilityRequest } from "../../shared/protocol";
 import { encodeRpcValue } from "../../view/rpc-codec";
 
 type CapabilityRegistry = AppServices["pluginRegistry"]["capabilities"];
@@ -45,26 +46,25 @@ export class DesktopCapabilityBridge<Rpc extends DesktopCapabilityRpc> {
 
   async handle(
     rpc: Rpc,
-    method: string,
-    payload: Record<string, unknown>,
+    request: DesktopCapabilityRequest,
   ): Promise<unknown> {
     const registry = this.options.getRegistry();
-    switch (method) {
+    switch (request.method) {
       case "capability.invoke":
         return registry.invoke(
-          payload.capabilityId as string,
-          payload.operationId as string,
-          payload.payload,
+          request.payload.capabilityId,
+          request.payload.operationId,
+          request.payload.payload,
           { renderer: true },
         );
       case "capability.subscribe": {
-        const clientSubscriptionId = payload.subscriptionId as string;
+        const clientSubscriptionId = request.payload.subscriptionId;
         const scopedSubscriptionId = this.scopeClientId(rpc, clientSubscriptionId);
         this.subscriptions.get(scopedSubscriptionId)?.();
         await registry.subscribe(
-          payload.capabilityId as string,
-          payload.operationId as string,
-          payload.payload,
+          request.payload.capabilityId,
+          request.payload.operationId,
+          request.payload.payload,
           (event) => {
             rpc.send["capability.event"]({
               subscriptionId: clientSubscriptionId,
@@ -77,13 +77,15 @@ export class DesktopCapabilityBridge<Rpc extends DesktopCapabilityRpc> {
         return null;
       }
       case "capability.unsubscribe": {
-        const scopedSubscriptionId = this.scopeClientId(rpc, payload.subscriptionId as string);
+        const scopedSubscriptionId = this.scopeClientId(rpc, request.payload.subscriptionId);
         this.subscriptions.get(scopedSubscriptionId)?.();
         this.subscriptions.delete(scopedSubscriptionId);
         return null;
       }
-      default:
-        throw new Error(`Unknown capability method: ${method}`);
+      default: {
+        const exhaustive: never = request;
+        throw new Error(`Unknown capability method: ${String(exhaustive)}`);
+      }
     }
   }
 

package/src/renderers/electrobun/bun/desktop/host-requests.ts

@@ -1,10 +1,14 @@
 import { Buffer } from "node:buffer";
 import { ContextMenu, Utils, type BrowserWindow } from "electrobun/bun";
 import { buildSoundCommand } from "../../../../notifications/app-notifier";
-import type { DesktopRestartMessage } from "../../shared/protocol";
+import type {
+  DesktopBackendRequestResponse,
+  DesktopHostRequest,
+  DesktopRestartMessage,
+  DesktopWindowControlAction,
+} from "../../shared/protocol";
 import { getContextMenuRequestId, normalizeContextMenuItems } from "../context-menu/normalize";
 import { MAIN_WINDOW_RPC_KEY } from "../window/focus";
-import type { DesktopWindowControlAction } from "./window-controls";
 
 interface DesktopHostRequestOptions<TRpc> {
   clearMainWindow: () => void;
@@ -13,8 +17,7 @@ interface DesktopHostRequestOptions<TRpc> {
   focusWindowForRpcKey: (windowKey: string) => void;
   getMainWindow: () => BrowserWindow | null;
   getRpcWindowKey: (rpc: TRpc) => string | undefined;
-  method: string;
-  payload: Record<string, unknown>;
+  request: DesktopHostRequest;
   restartDesktopApp: (message?: DesktopRestartMessage) => void;
   rpc: TRpc;
   teardownServices: () => void;
@@ -54,18 +57,17 @@ export function handleDesktopHostRequest<TRpc>({
   focusWindowForRpcKey,
   getMainWindow,
   getRpcWindowKey,
-  method,
-  payload,
+  request,
   restartDesktopApp,
   rpc,
   teardownServices,
   trackContextMenuRequest,
-}: DesktopHostRequestOptions<TRpc>): unknown {
-  switch (method) {
+}: DesktopHostRequestOptions<TRpc>): DesktopBackendRequestResponse<DesktopHostRequest["method"]> {
+  switch (request.method) {
     case "host.restart":
       restartDesktopApp({
-        reason: typeof payload.reason === "string" ? payload.reason : undefined,
-        source: typeof payload.source === "string" ? payload.source : "backend-request",
+        reason: typeof request.payload.reason === "string" ? request.payload.reason : undefined,
+        source: typeof request.payload.source === "string" ? request.payload.source : "backend-request",
       });
       return null;
     case "host.exit": {
@@ -81,7 +83,7 @@ export function handleDesktopHostRequest<TRpc>({
       return null;
     }
     case "host.windowControl": {
-      const action = normalizeWindowControlAction(payload.action);
+      const action = normalizeWindowControlAction(request.payload.action);
       const windowKey = getRpcWindowKey(rpc);
       if (action === "close" && windowKey === MAIN_WINDOW_RPC_KEY) {
         closeAllDetachedWindows();
@@ -101,13 +103,13 @@ export function handleDesktopHostRequest<TRpc>({
       return null;
     }
     case "host.openExternal":
-      if (typeof payload.url !== "string") {
+      if (typeof request.payload.url !== "string") {
         throw new Error("host.openExternal requires a URL.");
       }
-      Utils.openExternal(payload.url);
+      Utils.openExternal(request.payload.url);
       return null;
     case "host.copyText":
-      Utils.clipboardWriteText(normalizeText(payload.text) ?? "");
+      Utils.clipboardWriteText(normalizeText(request.payload.text) ?? "");
       return null;
     case "host.focusWindow": {
       const windowKey = getRpcWindowKey(rpc);
@@ -115,7 +117,7 @@ export function handleDesktopHostRequest<TRpc>({
       return null;
     }
     case "host.copyPngImage": {
-      const pngBase64 = normalizeText(payload.pngBase64);
+      const pngBase64 = normalizeText(request.payload.pngBase64);
       if (!pngBase64) throw new Error("host.copyPngImage requires PNG data.");
       Utils.clipboardWriteImage(new Uint8Array(Buffer.from(pngBase64, "base64")));
       return null;
@@ -123,23 +125,25 @@ export function handleDesktopHostRequest<TRpc>({
     case "host.readText":
       return Utils.clipboardReadText() ?? "";
     case "host.notify":
-      playNotificationSound(normalizeText(payload.sound));
+      playNotificationSound(normalizeText(request.payload.sound));
       Utils.showNotification({
-        title: normalizeText(payload.title) ?? "Gloomberb",
-        body: normalizeText(payload.body),
-        subtitle: normalizeText(payload.subtitle),
+        title: normalizeText(request.payload.title) ?? "Gloomberb",
+        body: normalizeText(request.payload.body),
+        subtitle: normalizeText(request.payload.subtitle),
         silent: true,
       });
       return null;
     case "host.showContextMenu": {
-      const menu = normalizeContextMenuItems(payload.menu);
+      const menu = normalizeContextMenuItems(request.payload.menu);
       if (menu.length === 0) return false;
       const requestId = getContextMenuRequestId(menu);
       if (requestId) trackContextMenuRequest(requestId, rpc);
       ContextMenu.showContextMenu(menu as never);
       return true;
     }
-    default:
-      throw new Error(`Unknown host method: ${method}`);
+    default: {
+      const exhaustive: never = request;
+      throw new Error(`Unknown host method: ${String(exhaustive)}`);
+    }
   }
 }