@flighthq/host-electron 0.1.0

package/src/electronClipboard.test.ts

@@ -0,0 +1,86 @@
+import { createElectronClipboardBackend } from './electronClipboard';
+import type { ElectronApi, ElectronNativeImage } from './electronModule';
+
+function fakeElectron(): ElectronApi {
+  const store = { text: '', html: '', rtf: '', imageDataUrl: '', bookmarkTitle: '', bookmarkUrl: '' };
+  const image = (dataUrl: string): ElectronNativeImage => ({
+    toDataUrl: () => dataUrl,
+    isEmpty: () => dataUrl === '',
+  });
+  return {
+    clipboard: {
+      readText: () => store.text,
+      writeText: (t: string) => {
+        store.text = t;
+      },
+      readHtml: () => store.html,
+      writeHtml: (h: string) => {
+        store.html = h;
+      },
+      readRTF: () => store.rtf,
+      writeRTF: (r: string) => {
+        store.rtf = r;
+      },
+      readBookmark: () => ({ title: store.bookmarkTitle, url: store.bookmarkUrl }),
+      writeBookmark: (title: string, url: string) => {
+        store.bookmarkTitle = title;
+        store.bookmarkUrl = url;
+      },
+      readImage: () => image(store.imageDataUrl),
+      writeImage: (img: ElectronNativeImage) => {
+        store.imageDataUrl = img.toDataUrl();
+      },
+      clear: () => {
+        store.text = '';
+        store.html = '';
+        store.rtf = '';
+        store.imageDataUrl = '';
+        store.bookmarkTitle = '';
+        store.bookmarkUrl = '';
+      },
+    },
+    nativeImage: {
+      createFromDataUrl: (dataUrl: string) => image(dataUrl),
+      createFromPath: () => image(''),
+    },
+  } as unknown as ElectronApi;
+}
+
+describe('createElectronClipboardBackend', () => {
+  it('round-trips text through the Electron clipboard', async () => {
+    const backend = createElectronClipboardBackend(fakeElectron());
+    expect(await backend.writeText('hi')).toBe(true);
+    expect(await backend.readText()).toBe('hi');
+    expect(await backend.hasText()).toBe(true);
+  });
+
+  it('round-trips HTML and RTF', async () => {
+    const backend = createElectronClipboardBackend(fakeElectron());
+    await backend.writeHtml('<b>x</b>');
+    await backend.writeRTF('{\\rtf1 x}');
+    expect(await backend.readHtml()).toBe('<b>x</b>');
+    expect(await backend.readRTF()).toBe('{\\rtf1 x}');
+  });
+
+  it('round-trips an image as a data URL', async () => {
+    const backend = createElectronClipboardBackend(fakeElectron());
+    expect(await backend.hasImage()).toBe(false);
+    await backend.writeImage('data:image/png;base64,AAAA');
+    expect(await backend.readImage()).toBe('data:image/png;base64,AAAA');
+    expect(await backend.hasImage()).toBe(true);
+  });
+
+  it('returns null for an empty bookmark and round-trips a set one', async () => {
+    const backend = createElectronClipboardBackend(fakeElectron());
+    expect(await backend.readBookmark()).toBeNull();
+    await backend.writeBookmark('Flight', 'https://example.test');
+    expect(await backend.readBookmark()).toEqual({ title: 'Flight', url: 'https://example.test' });
+  });
+
+  it('clears all formats', async () => {
+    const backend = createElectronClipboardBackend(fakeElectron());
+    await backend.writeText('x');
+    expect(await backend.clear()).toBe(true);
+    expect(await backend.readText()).toBe('');
+  });
+});

package/src/electronDialog.test.ts

@@ -0,0 +1,95 @@
+import { createElectronDialogBackend } from './electronDialog';
+import type {
+  ElectronApi,
+  ElectronMessageBoxOptions,
+  ElectronOpenDialogOptions,
+  ElectronSaveDialogOptions,
+} from './electronModule';
+
+function fakeElectron(overrides: {
+  open?: { canceled: boolean; filePaths: string[] };
+  save?: { canceled: boolean; filePath?: string };
+  message?: { response: number; checkboxChecked: boolean };
+}): {
+  electron: ElectronApi;
+  calls: {
+    openOptions?: ElectronOpenDialogOptions;
+    saveOptions?: ElectronSaveDialogOptions;
+    messageOptions?: ElectronMessageBoxOptions;
+  };
+} {
+  const calls: {
+    openOptions?: ElectronOpenDialogOptions;
+    saveOptions?: ElectronSaveDialogOptions;
+    messageOptions?: ElectronMessageBoxOptions;
+  } = {};
+  const electron = {
+    dialog: {
+      showOpenDialog: async (_window: unknown, options: ElectronOpenDialogOptions) => {
+        calls.openOptions = options;
+        return overrides.open ?? { canceled: false, filePaths: [] };
+      },
+      showSaveDialog: async (_window: unknown, options: ElectronSaveDialogOptions) => {
+        calls.saveOptions = options;
+        return overrides.save ?? { canceled: false, filePath: undefined };
+      },
+      showMessageBox: async (_window: unknown, options: ElectronMessageBoxOptions) => {
+        calls.messageOptions = options;
+        return overrides.message ?? { response: 0, checkboxChecked: false };
+      },
+    },
+  } as unknown as ElectronApi;
+  return { electron, calls };
+}
+
+describe('createElectronDialogBackend', () => {
+  it('builds open-dialog properties from options and returns file handles', async () => {
+    const { electron, calls } = fakeElectron({ open: { canceled: false, filePaths: ['/a', '/b'] } });
+    const backend = createElectronDialogBackend(electron);
+    const handles = await backend.openFile({ multiple: true, directory: true });
+    expect(handles).toEqual([
+      { kind: 'Directory', name: 'a', path: '/a' },
+      { kind: 'Directory', name: 'b', path: '/b' },
+    ]);
+    expect(calls.openOptions?.properties).toEqual(['openFile', 'multiSelections', 'openDirectory']);
+  });
+
+  it('returns an empty array when the open dialog is canceled', async () => {
+    const { electron } = fakeElectron({ open: { canceled: true, filePaths: ['/a'] } });
+    const backend = createElectronDialogBackend(electron);
+    expect(await backend.openFile({})).toEqual([]);
+  });
+
+  it('returns the save handle or null when canceled or empty', async () => {
+    const ok = fakeElectron({ save: { canceled: false, filePath: '/out.txt' } });
+    expect(await createElectronDialogBackend(ok.electron).saveFile({})).toEqual({
+      kind: 'File',
+      name: 'out.txt',
+      path: '/out.txt',
+    });
+    const canceled = fakeElectron({ save: { canceled: true } });
+    expect(await createElectronDialogBackend(canceled.electron).saveFile({})).toBeNull();
+  });
+
+  it('maps message results to button index, cancelled, and checkbox state', async () => {
+    const { electron, calls } = fakeElectron({ message: { response: 2, checkboxChecked: true } });
+    const backend = createElectronDialogBackend(electron);
+    const result = await backend.message({ message: 'hi', kind: 'warning' });
+    expect(result).toEqual({ buttonIndex: 2, cancelled: false, checkboxChecked: true });
+    expect(calls.messageOptions?.type).toBe('warning');
+  });
+
+  it('confirm returns true only when the OK button is chosen', async () => {
+    const yes = fakeElectron({ message: { response: 0, checkboxChecked: false } });
+    expect(await createElectronDialogBackend(yes.electron).confirm({ message: 'ok?' })).toBe(true);
+    const no = fakeElectron({ message: { response: 1, checkboxChecked: false } });
+    expect(await createElectronDialogBackend(no.electron).confirm({ message: 'ok?' })).toBe(false);
+    expect(no.calls.messageOptions?.buttons).toEqual(['OK', 'Cancel']);
+  });
+
+  it('prompt resolves to null since Electron has no native text dialog', async () => {
+    const { electron } = fakeElectron({});
+    const backend = createElectronDialogBackend(electron);
+    expect(await backend.prompt({ message: 'name?', defaultValue: 'default' })).toBeNull();
+  });
+});

package/src/electronIpc.test.ts

@@ -0,0 +1,47 @@
+import { createElectronIpcBackend } from './electronIpc';
+import type { ElectronApi } from './electronModule';
+
+function fakeElectron(): {
+  electron: ElectronApi;
+  channels: Map<string, Set<(event: unknown, ...args: unknown[]) => void>>;
+} {
+  const channels = new Map<string, Set<(event: unknown, ...args: unknown[]) => void>>();
+  const electron = {
+    ipcMain: {
+      on: (channel: string, listener: (event: unknown, ...args: unknown[]) => void) => {
+        if (!channels.has(channel)) channels.set(channel, new Set());
+        channels.get(channel)?.add(listener);
+      },
+      removeListener: (channel: string, listener: (event: unknown, ...args: unknown[]) => void) => {
+        channels.get(channel)?.delete(listener);
+      },
+    },
+  } as unknown as ElectronApi;
+  return { electron, channels };
+}
+
+describe('createElectronIpcBackend', () => {
+  it('send no-ops without a webContents target', () => {
+    const { electron } = fakeElectron();
+    const backend = createElectronIpcBackend(electron);
+    expect(() => backend.send('channel', [1, 2])).not.toThrow();
+  });
+
+  it('invoke resolves to undefined on the main side', async () => {
+    const { electron } = fakeElectron();
+    const backend = createElectronIpcBackend(electron);
+    expect(await backend.invoke('channel', [])).toBeUndefined();
+  });
+
+  it('subscribe receives renderer args and unsubscribes the same handler', () => {
+    const { electron, channels } = fakeElectron();
+    const backend = createElectronIpcBackend(electron);
+    let received: readonly unknown[] | undefined;
+    const unsubscribe = backend.subscribe('chat', (args) => (received = args));
+    expect(channels.get('chat')?.size).toBe(1);
+    for (const listener of channels.get('chat') ?? []) listener({ sender: 1 }, 'hello', 42);
+    expect(received).toEqual(['hello', 42]);
+    unsubscribe();
+    expect(channels.get('chat')?.size).toBe(0);
+  });
+});

package/src/electronMenu.test.ts

@@ -0,0 +1,85 @@
+import { createElectronMenuBackend } from './electronMenu';
+import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions } from './electronModule';
+
+function fakeElectron(): {
+  electron: ElectronApi;
+  built: ElectronMenuItemOptions[][];
+  applied: (ElectronMenu | null)[];
+  popups: { x?: number; y?: number }[];
+} {
+  const built: ElectronMenuItemOptions[][] = [];
+  const applied: (ElectronMenu | null)[] = [];
+  const popups: { x?: number; y?: number }[] = [];
+  const electron = {
+    Menu: {
+      buildFromTemplate: (template: ElectronMenuItemOptions[]) => {
+        built.push(template);
+        return {
+          template,
+          popup: (options?: { x?: number; y?: number }) => {
+            popups.push(options ?? {});
+          },
+        } as unknown as ElectronMenu;
+      },
+      setApplicationMenu: (menu: ElectronMenu | null) => {
+        applied.push(menu);
+      },
+    },
+  } as unknown as ElectronApi;
+  return { electron, built, applied, popups };
+}
+
+// Clicks the menu item with the given id from the most recently built template.
+function clickItem(built: ElectronMenuItemOptions[][], id: string): void {
+  const findIn = (items: ElectronMenuItemOptions[]): ElectronMenuItemOptions | undefined => {
+    for (const item of items) {
+      if (item.id === id) return item;
+      if (item.submenu) {
+        const found = findIn(item.submenu);
+        if (found) return found;
+      }
+    }
+    return undefined;
+  };
+  const item = findIn(built[built.length - 1]);
+  item?.click?.();
+}
+
+describe('createElectronMenuBackend', () => {
+  it('builds and applies the application menu and reports clicks via subscribeSelect', () => {
+    const { electron, built, applied } = fakeElectron();
+    const backend = createElectronMenuBackend(electron);
+    const seen: string[] = [];
+    backend.subscribeSelect((id) => seen.push(id));
+    expect(
+      backend.setApplicationMenu([
+        { id: 'open', label: 'Open' },
+        { label: 'Edit', submenu: [{ id: 'copy', label: 'Copy' }] },
+      ]),
+    ).toBe(true);
+    expect(applied.length).toBe(1);
+    clickItem(built, 'open');
+    clickItem(built, 'copy');
+    expect(seen).toEqual(['open', 'copy']);
+  });
+
+  it('stops delivering selects after unsubscribe', () => {
+    const { electron, built } = fakeElectron();
+    const backend = createElectronMenuBackend(electron);
+    const seen: string[] = [];
+    const unsubscribe = backend.subscribeSelect((id) => seen.push(id));
+    backend.setApplicationMenu([{ id: 'a', label: 'A' }]);
+    unsubscribe();
+    clickItem(built, 'a');
+    expect(seen).toEqual([]);
+  });
+
+  it('resolves the context menu promise with the clicked id', async () => {
+    const { electron, built, popups } = fakeElectron();
+    const backend = createElectronMenuBackend(electron);
+    const pending = backend.popupContextMenu([{ id: 'paste', label: 'Paste' }], 10, 20);
+    expect(popups).toEqual([{ x: 10, y: 20 }]);
+    clickItem(built, 'paste');
+    expect(await pending).toBe('paste');
+  });
+});

package/src/electronNotification.test.ts

@@ -0,0 +1,97 @@
+import type { ElectronApi, ElectronNotificationOptions } from './electronModule';
+import { createElectronNotificationBackend } from './electronNotification';
+
+interface FakeNotification {
+  options: ElectronNotificationOptions;
+  shown: boolean;
+  handlers: Record<string, (...args: unknown[]) => void>;
+  show(): void;
+  close(): void;
+  on(event: string, listener: (...args: unknown[]) => void): void;
+}
+
+function fakeElectron(supported = true): {
+  electron: ElectronApi;
+  notifications: FakeNotification[];
+} {
+  const notifications: FakeNotification[] = [];
+  const electron = {
+    Notification: Object.assign(
+      function (this: FakeNotification, options: ElectronNotificationOptions) {
+        this.options = options;
+        this.shown = false;
+        this.handlers = {};
+        this.show = () => {
+          this.shown = true;
+        };
+        this.close = () => {};
+        this.on = (event: string, listener: (...args: unknown[]) => void) => {
+          this.handlers[event] = listener;
+        };
+        notifications.push(this);
+      },
+      { isSupported: () => supported },
+    ),
+  } as unknown as ElectronApi;
+  return { electron, notifications };
+}
+
+describe('createElectronNotificationBackend', () => {
+  it('shows a notification and resolves to its id', async () => {
+    const { electron, notifications } = fakeElectron();
+    const backend = createElectronNotificationBackend(electron);
+    expect(backend.isSupported()).toBe(true);
+    expect(backend.getPermission()).toBe('granted');
+    expect(await backend.requestPermission()).toBe('granted');
+    const id = await backend.notify({ id: 'n1', title: 'Hi', body: 'there', actions: [{ id: 'ok', title: 'OK' }] });
+    expect(id).toBe('n1');
+    expect(notifications[0].options.title).toBe('Hi');
+    expect(notifications[0].options.actions).toEqual([{ type: 'button', text: 'OK' }]);
+    expect(notifications[0].shown).toBe(true);
+  });
+
+  it('returns an empty id when notifications are unsupported', async () => {
+    const { electron } = fakeElectron(false);
+    const backend = createElectronNotificationBackend(electron);
+    expect(backend.isSupported()).toBe(false);
+    expect(backend.getPermission()).toBe('denied');
+    expect(await backend.requestPermission()).toBe('denied');
+    expect(await backend.notify({ title: 'x' })).toBe('');
+  });
+
+  it('forwards click events with the notification id and stops after unsubscribe', async () => {
+    const { electron, notifications } = fakeElectron();
+    const backend = createElectronNotificationBackend(electron);
+    const ids: string[] = [];
+    const unsubscribe = backend.subscribeClick((id) => ids.push(id));
+    await backend.notify({ id: 'msg-1', title: 'x' });
+    notifications[0].handlers['click']();
+    unsubscribe();
+    notifications[0].handlers['click']();
+    expect(ids).toEqual(['msg-1']);
+  });
+
+  it('forwards action events mapping the electron index back to the action id', async () => {
+    const { electron, notifications } = fakeElectron();
+    const backend = createElectronNotificationBackend(electron);
+    const seen: [string, string][] = [];
+    backend.subscribeAction((id, actionId) => seen.push([id, actionId]));
+    await backend.notify({
+      id: 'msg-2',
+      title: 'x',
+      actions: [
+        { id: 'yes', title: 'Yes' },
+        { id: 'no', title: 'No' },
+      ],
+    });
+    notifications[0].handlers['action']({}, 1);
+    expect(seen).toEqual([['msg-2', 'no']]);
+  });
+
+  it('updateNotification returns false (no in-place update support)', async () => {
+    const { electron } = fakeElectron();
+    const backend = createElectronNotificationBackend(electron);
+    await backend.notify({ title: 'Hi', tag: 'u1' });
+    expect(await backend.updateNotification('u1', { title: 'Updated' })).toBe(false);
+  });
+});

package/src/electronPlatform.test.ts

@@ -0,0 +1,28 @@
+import type { PlatformInfo } from '@flighthq/types';
+
+import type { ElectronApi } from './electronModule';
+import { createElectronPlatformBackend } from './electronPlatform';
+
+function fakeElectron(): ElectronApi {
+  return {
+    app: {
+      getLocale: () => 'en-US',
+    },
+  } as unknown as ElectronApi;
+}
+
+describe('createElectronPlatformBackend', () => {
+  it('fills platform info from process and electron locale', () => {
+    const backend = createElectronPlatformBackend(fakeElectron());
+    const out = {} as PlatformInfo;
+    const result = backend.getInfo(out);
+    expect(result).toBe(out);
+    expect(out.kind).toBe('desktop');
+    expect(out.isTouch).toBe(false);
+    expect(out.locale).toBe('en-US');
+    // Running under Node, so name maps to a desktop OS and arch is reported.
+    expect(['windows', 'macos', 'linux', 'unknown']).toContain(out.name);
+    expect(typeof out.arch).toBe('string');
+    expect(typeof out.version).toBe('string');
+  });
+});

package/src/electronPower.test.ts

@@ -0,0 +1,110 @@
+import type { PowerStatus } from '@flighthq/types';
+
+import type { ElectronApi } from './electronModule';
+import { createElectronPowerBackend } from './electronPower';
+
+function emptyStatus(): PowerStatus {
+  return {
+    batteryLevel: 0,
+    chargingTime: 0,
+    dischargingTime: 0,
+    isBatteryLow: false,
+    isCharging: false,
+    isLowPower: false,
+    isOnBattery: false,
+    thermalState: 'Unknown',
+  };
+}
+
+function fakeElectron(options: { onBatteryPower?: boolean; startId?: number }): {
+  electron: ElectronApi;
+  monitorListeners: Map<string, Set<() => void>>;
+  blocker: { started: number[]; stopped: number[] };
+} {
+  const monitorListeners = new Map<string, Set<() => void>>();
+  const blocker = { started: [] as number[], stopped: [] as number[] };
+  let nextId = options.startId ?? 7;
+  const electron = {
+    powerMonitor: {
+      onBatteryPower: options.onBatteryPower,
+      on: (event: string, listener: () => void) => {
+        if (!monitorListeners.has(event)) monitorListeners.set(event, new Set());
+        monitorListeners.get(event)?.add(listener);
+      },
+      removeListener: (event: string, listener: () => void) => {
+        monitorListeners.get(event)?.delete(listener);
+      },
+    },
+    powerSaveBlocker: {
+      start: () => {
+        const id = nextId++;
+        blocker.started.push(id);
+        return id;
+      },
+      stop: (id: number) => {
+        blocker.stopped.push(id);
+      },
+      isStarted: () => true,
+    },
+  } as unknown as ElectronApi;
+  return { electron, monitorListeners, blocker };
+}
+
+describe('createElectronPowerBackend', () => {
+  it('getStatus reports no battery level and infers charging from AC power', () => {
+    const onAc = createElectronPowerBackend(fakeElectron({ onBatteryPower: false }).electron);
+    const status = onAc.getStatus(emptyStatus());
+    expect(status).toEqual({
+      batteryLevel: -1,
+      chargingTime: -1,
+      dischargingTime: -1,
+      isBatteryLow: false,
+      isCharging: true,
+      isLowPower: false,
+      isOnBattery: false,
+      thermalState: 'Unknown',
+    });
+    const onBattery = createElectronPowerBackend(fakeElectron({ onBatteryPower: true }).electron);
+    const batteryStatus = onBattery.getStatus(emptyStatus());
+    expect(batteryStatus.isCharging).toBe(false);
+    expect(batteryStatus.isOnBattery).toBe(true);
+  });
+
+  it('subscribe wires both AC and battery events and unsubscribes both', () => {
+    const { electron, monitorListeners } = fakeElectron({});
+    const backend = createElectronPowerBackend(electron);
+    const unsubscribe = backend.subscribe(() => {});
+    expect(monitorListeners.get('on-battery')?.size).toBe(1);
+    expect(monitorListeners.get('on-ac')?.size).toBe(1);
+    unsubscribe();
+    expect(monitorListeners.get('on-battery')?.size).toBe(0);
+    expect(monitorListeners.get('on-ac')?.size).toBe(0);
+  });
+
+  it('subscribeSuspend and subscribeResume register and remove their listeners', () => {
+    const { electron, monitorListeners } = fakeElectron({});
+    const backend = createElectronPowerBackend(electron);
+    const unsubSuspend = backend.subscribeSuspend(() => {});
+    const unsubResume = backend.subscribeResume(() => {});
+    expect(monitorListeners.get('suspend')?.size).toBe(1);
+    expect(monitorListeners.get('resume')?.size).toBe(1);
+    unsubSuspend();
+    unsubResume();
+    expect(monitorListeners.get('suspend')?.size).toBe(0);
+    expect(monitorListeners.get('resume')?.size).toBe(0);
+  });
+
+  it('setKeepAwake starts a single blocker and stops it when disabled', () => {
+    const { electron, blocker } = fakeElectron({ startId: 42 });
+    const backend = createElectronPowerBackend(electron);
+    expect(backend.setKeepAwake(true)).toBe(true);
+    expect(blocker.started).toEqual([42]);
+    // Already held — no second blocker, returns the requested state.
+    expect(backend.setKeepAwake(true)).toBe(true);
+    expect(blocker.started).toEqual([42]);
+    expect(backend.setKeepAwake(false)).toBe(true);
+    expect(blocker.stopped).toEqual([42]);
+    // Already released.
+    expect(backend.setKeepAwake(false)).toBe(false);
+  });
+});

package/src/electronProtocol.test.ts

@@ -0,0 +1,63 @@
+import type { ElectronApi } from './electronModule';
+import { createElectronProtocolBackend } from './electronProtocol';
+
+function fakeElectron(): {
+  electron: ElectronApi;
+  listeners: Map<string, ((...args: unknown[]) => void)[]>;
+  registered: Set<string>;
+} {
+  const listeners = new Map<string, ((...args: unknown[]) => void)[]>();
+  const registered = new Set<string>();
+  const electron = {
+    app: {
+      setAsDefaultProtocolClient: (scheme: string) => {
+        registered.add(scheme);
+        return true;
+      },
+      removeAsDefaultProtocolClient: (scheme: string) => {
+        registered.delete(scheme);
+        return true;
+      },
+      isDefaultProtocolClient: (scheme: string) => registered.has(scheme),
+      on: (event: string, listener: (...args: unknown[]) => void) => {
+        const list = listeners.get(event) ?? [];
+        list.push(listener);
+        listeners.set(event, list);
+      },
+      removeListener: (event: string, listener: (...args: unknown[]) => void) => {
+        const list = listeners.get(event) ?? [];
+        listeners.set(
+          event,
+          list.filter((l) => l !== listener),
+        );
+      },
+    },
+  } as unknown as ElectronApi;
+  return { electron, listeners, registered };
+}
+
+describe('createElectronProtocolBackend', () => {
+  it('registers, queries, and unregisters a scheme', () => {
+    const fake = fakeElectron();
+    const backend = createElectronProtocolBackend(fake.electron);
+    expect(backend.isRegistered('flight')).toBe(false);
+    expect(backend.register('flight')).toBe(true);
+    expect(backend.isRegistered('flight')).toBe(true);
+    expect(backend.setAsDefault('flight')).toBe(true);
+    expect(backend.unregister('flight')).toBe(true);
+    expect(backend.isRegistered('flight')).toBe(false);
+  });
+
+  it('adapts the open-url event and unsubscribes', () => {
+    const fake = fakeElectron();
+    const backend = createElectronProtocolBackend(fake.electron);
+    let url = '';
+    const off = backend.subscribe((next) => {
+      url = next;
+    });
+    for (const l of fake.listeners.get('open-url') ?? []) l({}, 'flight://open');
+    expect(url).toBe('flight://open');
+    off();
+    expect(fake.listeners.get('open-url')).toHaveLength(0);
+  });
+});

package/src/electronRegister.test.ts

@@ -0,0 +1,57 @@
+import { getAppName, setAppBackend } from '@flighthq/app';
+import { readClipboardText, setClipboardBackend } from '@flighthq/clipboard';
+import { setStorageBackend } from '@flighthq/storage';
+
+import type { ElectronApi } from './electronModule';
+import { registerElectronBackends } from './electronRegister';
+
+// A fake Electron module broad enough that every createElectron*Backend constructs without touching
+// missing members. Backends close over `electron` and only call into it when their methods run, so a
+// thin fake suffices to prove registration routes the capability seams to the Electron backends.
+function fakeElectron(): ElectronApi {
+  const noop = () => {};
+  const off = () => () => {};
+  return {
+    app: {
+      getName: () => 'ElectronApp',
+      getLocale: () => 'en-US',
+      getPath: () => '/userData',
+      on: noop,
+      removeListener: noop,
+    },
+    clipboard: {
+      readText: () => 'ELECTRON-TEXT',
+    },
+    fs: {
+      existsSync: () => false,
+      readFileSync: () => '{}',
+      writeFileSync: noop,
+    },
+    globalShortcut: {},
+    screen: { on: noop, removeListener: noop },
+    powerMonitor: { on: noop, removeListener: noop },
+    powerSaveBlocker: {},
+    nativeImage: {},
+    ipcMain: { on: noop, removeListener: noop },
+    autoUpdater: { on: noop, removeListener: noop },
+    shell: {},
+    dialog: {},
+    Menu: { buildFromTemplate: () => ({ popup: noop }), setApplicationMenu: noop },
+    // The remaining members are unused at registration time.
+    _off: off,
+  } as unknown as ElectronApi;
+}
+
+afterEach(() => {
+  setClipboardBackend(null);
+  setAppBackend(null);
+  setStorageBackend(null);
+});
+
+describe('registerElectronBackends', () => {
+  it('routes capability seams to the Electron backends without throwing', async () => {
+    registerElectronBackends(fakeElectron());
+    expect(getAppName()).toBe('ElectronApp');
+    expect(await readClipboardText()).toBe('ELECTRON-TEXT');
+  });
+});