@flighthq/host-electron 0.5.1-next.920.da8f530 → 0.6.0

package/src/electronTray.test.ts

@@ -7,34 +7,49 @@ import {
   setTrayIconContextMenu,
   setTrayIconTemplate,
 } from '@flighthq/tray/contract';
+import type { TrayIcon } from '@flighthq/tray/contract';
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  electronHostTray,
+  electronHostTrayBalloon,
+  electronHostTrayBalloonEvents,
+  electronHostTrayBounds,
+  electronHostTrayDoubleClickPolicy,
+  electronHostTrayDropEvents,
+  electronHostTrayImage,
+  electronHostTrayInteractionEvents,
+  electronHostTrayLifecycle,
+  electronHostTrayMenu,
+  electronHostTrayMenuSelectionEvents,
+  electronHostTrayPopupMenu,
+  electronHostTrayPressedImage,
+  electronHostTrayTemplateImage,
+  electronHostTrayTitle,
+  electronHostTrayTooltip,
+  populateElectronHostTrayBalloon,
+  populateElectronHostTrayBalloonEvents,
+  populateElectronHostTrayBounds,
+  populateElectronHostTrayDoubleClickPolicy,
+  populateElectronHostTrayDropEvents,
+  populateElectronHostTrayImage,
+  populateElectronHostTrayInteractionEvents,
+  populateElectronHostTrayLifecycle,
+  populateElectronHostTrayMenu,
+  populateElectronHostTrayMenuSelectionEvents,
+  populateElectronHostTrayPopupMenu,
+  populateElectronHostTrayPressedImage,
+  populateElectronHostTrayTemplateImage,
+  populateElectronHostTrayTitle,
+  populateElectronHostTrayTooltip,
+} from './electronTray.ts';
 import type {
   ElectronApi,
   ElectronMenu,
   ElectronMenuItemOptions,
   ElectronNativeImage,
   ElectronTray,
-  TrayIconForHost,
-} from '@flighthq/types/contract';
-import { describe, expect, it, vi } from 'vitest';
-
-import {
-  createElectronTrayCapabilities,
-  initializeTrayBalloonBackend,
-  initializeTrayBalloonEventsBackend,
-  initializeTrayBoundsBackend,
-  initializeTrayDoubleClickPolicyBackend,
-  initializeTrayDropEventsBackend,
-  initializeTrayImageBackend,
-  initializeTrayInteractionEventsBackend,
-  initializeTrayLifecycleBackend,
-  initializeTrayMenuBackend,
-  initializeTrayMenuSelectionEventsBackend,
-  initializeTrayPopupMenuBackend,
-  initializeTrayPressedImageBackend,
-  initializeTrayTemplateImageBackend,
-  initializeTrayTitleBackend,
-  initializeTrayTooltipBackend,
-} from './electronTray';
+} from './types/index.ts';
 
 interface FakeImage extends ElectronNativeImage {
   source: string;
@@ -71,7 +86,7 @@ function fakeElectron() {
         templates.push(template);
         return { popup() {} };
       },
-      setApplicationMenu() {},
+      setAppMenu() {},
     },
     Tray: function (this: FakeTray, image: ElectronNativeImage) {
       this.destroyed = false;
@@ -118,19 +133,19 @@ function fakeElectron() {
   return { electron, templates, trays };
 }
 
-async function acquire<
-  Host extends { tray: { lifecycle: NonNullable<ReturnType<typeof createElectronTrayCapabilities>['lifecycle']> } },
->(host: Host): Promise<TrayIconForHost<Host>> {
-  const result = await createTrayIcon(host, { icon: 'icon.png' });
+async function acquire(
+  hostTrayLifecycle: NonNullable<ReturnType<typeof electronHostTray>['lifecycle']>,
+): Promise<TrayIcon> {
+  const result = await createTrayIcon(hostTrayLifecycle, { icon: 'icon.png' });
   if (result.outcome !== 'created') throw new Error(result.outcome);
   return result.tray;
 }
 
-describe('createElectronTrayCapabilities', () => {
-  it('exposes only the slots supported by the injected OS profile', () => {
+describe('electronHostTray', () => {
+  it('exposes the slots supported by the injected OS profile and none exclusive to another', () => {
     const { electron } = fakeElectron();
-    expect(Object.keys(createElectronTrayCapabilities(electron, 'linux')).sort()).toEqual(
-      [
+    const supported = {
+      linux: [
         'bounds',
         'image',
         'interactionEvents',
@@ -139,10 +154,8 @@ describe('createElectronTrayCapabilities', () => {
         'menuSelectionEvents',
         'popupMenu',
         'tooltip',
-      ].sort(),
-    );
-    expect(Object.keys(createElectronTrayCapabilities(electron, 'macos')).sort()).toEqual(
-      [
+      ],
+      macos: [
         'bounds',
         'doubleClickPolicy',
         'dropEvents',
@@ -156,10 +169,8 @@ describe('createElectronTrayCapabilities', () => {
         'templateImage',
         'title',
         'tooltip',
-      ].sort(),
-    );
-    expect(Object.keys(createElectronTrayCapabilities(electron, 'windows')).sort()).toEqual(
-      [
+      ],
+      windows: [
         'balloon',
         'balloonEvents',
         'bounds',
@@ -170,14 +181,26 @@ describe('createElectronTrayCapabilities', () => {
         'menuSelectionEvents',
         'popupMenu',
         'tooltip',
-      ].sort(),
-    );
+      ],
+    } as const;
+    for (const profile of ['linux', 'macos', 'windows'] as const) {
+      const slots = Object.keys(electronHostTray(electron, profile));
+      const exclusiveElsewhere: readonly string[] = Object.entries(supported)
+        .filter(([other]) => other !== profile)
+        .flatMap(([, others]) => others)
+        .filter((slot) => !(supported[profile] as readonly string[]).includes(slot));
+      expect(slots, profile).toEqual(expect.arrayContaining([...supported[profile]]));
+      expect(
+        slots.filter((slot) => exclusiveElsewhere.includes(slot)),
+        profile,
+      ).toEqual([]);
+    }
   });
 
-  it('constructs the native resource before publishing the Entity', async () => {
+  it('constructs the native resource before publishing', async () => {
     const { electron, trays } = fakeElectron();
-    const host = { tray: createElectronTrayCapabilities(electron, 'macos') };
-    const result = await createTrayIcon(host, {
+    const host = { tray: electronHostTray(electron, 'macos') };
+    const result = await createTrayIcon(host.tray.lifecycle, {
       icon: 'icon.png',
       iconTemplate: true,
       title: 'Flight',
@@ -191,12 +214,12 @@ describe('createElectronTrayCapabilities', () => {
 
   it('keeps one native listener while delivering full pointer payload to multiple subscribers', async () => {
     const { electron, trays } = fakeElectron();
-    const host = { tray: createElectronTrayCapabilities(electron, 'linux') };
-    const tray = await acquire(host);
+    const host = { tray: electronHostTray(electron, 'linux') };
+    const tray = await acquire(host.tray.lifecycle);
     const first = vi.fn();
     const second = vi.fn();
-    onTrayInteraction(tray, first);
-    onTrayInteraction(tray, second);
+    onTrayInteraction(host.tray.interactionEvents, tray, first);
+    onTrayInteraction(host.tray.interactionEvents, tray, second);
     expect(trays[0].handlers.click).toHaveLength(1);
     trays[0].handlers.click[0]!({ altKey: true, ctrlKey: true, metaKey: true, shiftKey: true }, { x: 7, y: 9 });
     expect(first).toHaveBeenCalledWith(
@@ -207,14 +230,14 @@ describe('createElectronTrayCapabilities', () => {
 
   it('routes a menu selection only through that Tray signal', async () => {
     const { electron, templates } = fakeElectron();
-    const host = { tray: createElectronTrayCapabilities(electron, 'linux') };
-    const first = await acquire(host);
-    const second = await acquire(host);
+    const host = { tray: electronHostTray(electron, 'linux') };
+    const first = await acquire(host.tray.lifecycle);
+    const second = await acquire(host.tray.lifecycle);
     const firstIds: string[] = [];
     const secondIds: string[] = [];
-    onTrayMenuSelection(first, ({ id }) => firstIds.push(id));
-    onTrayMenuSelection(second, ({ id }) => secondIds.push(id));
-    await setTrayIconContextMenu(first, [{ id: 'open', label: 'Open' }]);
+    onTrayMenuSelection(host.tray.menuSelectionEvents, first, ({ id }) => firstIds.push(id));
+    onTrayMenuSelection(host.tray.menuSelectionEvents, second, ({ id }) => secondIds.push(id));
+    await setTrayIconContextMenu(host.tray.menu, first, [{ id: 'open', label: 'Open' }]);
     templates[0][0].click?.();
     expect(firstIds).toEqual(['open']);
     expect(secondIds).toEqual([]);
@@ -222,16 +245,16 @@ describe('createElectronTrayCapabilities', () => {
 
   it('realizes later template changes through the current native image', async () => {
     const { electron, trays } = fakeElectron();
-    const host = { tray: createElectronTrayCapabilities(electron, 'macos') };
-    const tray = await acquire(host);
-    expect((await setTrayIconTemplate(tray, true)).outcome).toBe('updated');
+    const host = { tray: electronHostTray(electron, 'macos') };
+    const tray = await acquire(host.tray.lifecycle);
+    expect((await setTrayIconTemplate(host.tray.templateImage, tray, true)).outcome).toBe('updated');
     expect((trays[0].image as FakeImage).template).toBe(true);
   });
 
   it('returns invalid-icon without publishing a ghost record', async () => {
     const { electron, trays } = fakeElectron();
-    const host = { tray: createElectronTrayCapabilities(electron, 'linux') };
-    const result = await createTrayIcon(host, { icon: 'invalid' });
+    const host = { tray: electronHostTray(electron, 'linux') };
+    const result = await createTrayIcon(host.tray.lifecycle, { icon: 'invalid' });
     expect(result.outcome).toBe('invalid-icon');
     expect(trays).toHaveLength(0);
     expect(host.tray.lifecycle.list()).toEqual([]);
@@ -239,8 +262,8 @@ describe('createElectronTrayCapabilities', () => {
 
   it('attempts listener and native teardown, then retries only failed steps', async () => {
     const { electron, trays } = fakeElectron();
-    const host = { tray: createElectronTrayCapabilities(electron, 'linux') };
-    const tray = await acquire(host);
+    const host = { tray: electronHostTray(electron, 'linux') };
+    const tray = await acquire(host.tray.lifecycle);
     trays[0].removeFailures = 1;
     trays[0].destroyFailures = 1;
     expect((await destroyTrayIcon(tray)).outcome).toBe('tray-destroy-failed');
@@ -250,97 +273,190 @@ describe('createElectronTrayCapabilities', () => {
 
   it('owns balloon commands only on the Windows shape', async () => {
     const { electron } = fakeElectron();
-    const host = { tray: createElectronTrayCapabilities(electron, 'windows') };
-    const tray = await acquire(host);
-    expect((await displayTrayBalloon(tray, { text: 'Done', title: 'Flight' })).outcome).toBe('displayed');
+    const host = { tray: electronHostTray(electron, 'windows') };
+    const tray = await acquire(host.tray.lifecycle);
+    expect((await displayTrayBalloon(host.tray.balloon, tray, { text: 'Done', title: 'Flight' })).outcome).toBe(
+      'displayed',
+    );
+  });
+});
+
+describe('electronHostTrayBalloon', () => {
+  it('constructs a tray balloon provider', () => {
+    expect(electronHostTrayBalloon(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostTrayBalloonEvents', () => {
+  it('constructs a tray balloon events provider', () => {
+    expect(electronHostTrayBalloonEvents(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostTrayBounds', () => {
+  it('constructs a tray bounds provider', () => {
+    expect(electronHostTrayBounds(fakeElectron().electron, 'linux')).toBeDefined();
+  });
+});
+
+describe('electronHostTrayDoubleClickPolicy', () => {
+  it('constructs a tray double click policy provider', () => {
+    expect(electronHostTrayDoubleClickPolicy(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostTrayDropEvents', () => {
+  it('constructs a tray drop events provider', () => {
+    expect(electronHostTrayDropEvents(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostTrayImage', () => {
+  it('constructs a tray image provider', () => {
+    expect(electronHostTrayImage(fakeElectron().electron, 'linux')).toBeDefined();
   });
 });
-describe('initializeTrayBalloonBackend', () => {
-  it('is the construction initializer of createTrayBalloonBackend', () => {
-    expect(typeof initializeTrayBalloonBackend).toBe('function');
+
+describe('electronHostTrayInteractionEvents', () => {
+  it('constructs a tray interaction events provider', () => {
+    expect(electronHostTrayInteractionEvents(fakeElectron().electron, 'linux')).toBeDefined();
+  });
+});
+
+describe('electronHostTrayLifecycle', () => {
+  it('constructs a tray lifecycle provider', () => {
+    expect(electronHostTrayLifecycle(fakeElectron().electron, 'linux')).toBeDefined();
+  });
+});
+
+describe('electronHostTrayMenu', () => {
+  it('constructs a tray menu provider', () => {
+    expect(electronHostTrayMenu(fakeElectron().electron, 'linux')).toBeDefined();
+  });
+});
+
+describe('electronHostTrayMenuSelectionEvents', () => {
+  it('constructs a tray menu selection events provider', () => {
+    expect(electronHostTrayMenuSelectionEvents(fakeElectron().electron, 'linux')).toBeDefined();
+  });
+});
+
+describe('electronHostTrayPopupMenu', () => {
+  it('constructs a tray popup menu provider', () => {
+    expect(electronHostTrayPopupMenu(fakeElectron().electron, 'linux')).toBeDefined();
+  });
+});
+
+describe('electronHostTrayPressedImage', () => {
+  it('constructs a tray pressed image provider', () => {
+    expect(electronHostTrayPressedImage(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostTrayTemplateImage', () => {
+  it('constructs a tray template image provider', () => {
+    expect(electronHostTrayTemplateImage(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostTrayTitle', () => {
+  it('constructs a tray title provider', () => {
+    expect(electronHostTrayTitle(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostTrayTooltip', () => {
+  it('constructs a tray tooltip provider', () => {
+    expect(electronHostTrayTooltip(fakeElectron().electron, 'linux')).toBeDefined();
+  });
+});
+
+describe('populateElectronHostTrayBalloon', () => {
+  it('is the construction initializer of electronHostTrayBalloon', () => {
+    expect(typeof populateElectronHostTrayBalloon).toBe('function');
   });
 });
 
-describe('initializeTrayBalloonEventsBackend', () => {
-  it('is the construction initializer of createTrayBalloonEventsBackend', () => {
-    expect(typeof initializeTrayBalloonEventsBackend).toBe('function');
+describe('populateElectronHostTrayBalloonEvents', () => {
+  it('is the construction initializer of electronHostTrayBalloonEvents', () => {
+    expect(typeof populateElectronHostTrayBalloonEvents).toBe('function');
   });
 });
 
-describe('initializeTrayBoundsBackend', () => {
-  it('is the construction initializer of createTrayBoundsBackend', () => {
-    expect(typeof initializeTrayBoundsBackend).toBe('function');
+describe('populateElectronHostTrayBounds', () => {
+  it('is the construction initializer of electronHostTrayBounds', () => {
+    expect(typeof populateElectronHostTrayBounds).toBe('function');
   });
 });
 
-describe('initializeTrayDoubleClickPolicyBackend', () => {
-  it('is the construction initializer of createTrayDoubleClickPolicyBackend', () => {
-    expect(typeof initializeTrayDoubleClickPolicyBackend).toBe('function');
+describe('populateElectronHostTrayDoubleClickPolicy', () => {
+  it('is the construction initializer of electronHostTrayDoubleClickPolicy', () => {
+    expect(typeof populateElectronHostTrayDoubleClickPolicy).toBe('function');
   });
 });
 
-describe('initializeTrayDropEventsBackend', () => {
-  it('is the construction initializer of createTrayDropEventsBackend', () => {
-    expect(typeof initializeTrayDropEventsBackend).toBe('function');
+describe('populateElectronHostTrayDropEvents', () => {
+  it('is the construction initializer of electronHostTrayDropEvents', () => {
+    expect(typeof populateElectronHostTrayDropEvents).toBe('function');
   });
 });
 
-describe('initializeTrayImageBackend', () => {
-  it('is the construction initializer of createTrayImageBackend', () => {
-    expect(typeof initializeTrayImageBackend).toBe('function');
+describe('populateElectronHostTrayImage', () => {
+  it('is the construction initializer of electronHostTrayImage', () => {
+    expect(typeof populateElectronHostTrayImage).toBe('function');
   });
 });
 
-describe('initializeTrayInteractionEventsBackend', () => {
-  it('is the construction initializer of createTrayInteractionEventsBackend', () => {
-    expect(typeof initializeTrayInteractionEventsBackend).toBe('function');
+describe('populateElectronHostTrayInteractionEvents', () => {
+  it('is the construction initializer of electronHostTrayInteractionEvents', () => {
+    expect(typeof populateElectronHostTrayInteractionEvents).toBe('function');
   });
 });
 
-describe('initializeTrayLifecycleBackend', () => {
-  it('is the construction initializer of createTrayLifecycleBackend', () => {
-    expect(typeof initializeTrayLifecycleBackend).toBe('function');
+describe('populateElectronHostTrayLifecycle', () => {
+  it('is the construction initializer of electronHostTrayLifecycle', () => {
+    expect(typeof populateElectronHostTrayLifecycle).toBe('function');
   });
 });
 
-describe('initializeTrayMenuBackend', () => {
-  it('is the construction initializer of createTrayMenuBackend', () => {
-    expect(typeof initializeTrayMenuBackend).toBe('function');
+describe('populateElectronHostTrayMenu', () => {
+  it('is the construction initializer of electronHostTrayMenu', () => {
+    expect(typeof populateElectronHostTrayMenu).toBe('function');
   });
 });
 
-describe('initializeTrayMenuSelectionEventsBackend', () => {
-  it('is the construction initializer of createTrayMenuSelectionEventsBackend', () => {
-    expect(typeof initializeTrayMenuSelectionEventsBackend).toBe('function');
+describe('populateElectronHostTrayMenuSelectionEvents', () => {
+  it('is the construction initializer of electronHostTrayMenuSelectionEvents', () => {
+    expect(typeof populateElectronHostTrayMenuSelectionEvents).toBe('function');
   });
 });
 
-describe('initializeTrayPopupMenuBackend', () => {
-  it('is the construction initializer of createTrayPopupMenuBackend', () => {
-    expect(typeof initializeTrayPopupMenuBackend).toBe('function');
+describe('populateElectronHostTrayPopupMenu', () => {
+  it('is the construction initializer of electronHostTrayPopupMenu', () => {
+    expect(typeof populateElectronHostTrayPopupMenu).toBe('function');
   });
 });
 
-describe('initializeTrayPressedImageBackend', () => {
-  it('is the construction initializer of createTrayPressedImageBackend', () => {
-    expect(typeof initializeTrayPressedImageBackend).toBe('function');
+describe('populateElectronHostTrayPressedImage', () => {
+  it('is the construction initializer of electronHostTrayPressedImage', () => {
+    expect(typeof populateElectronHostTrayPressedImage).toBe('function');
   });
 });
 
-describe('initializeTrayTemplateImageBackend', () => {
-  it('is the construction initializer of createTrayTemplateImageBackend', () => {
-    expect(typeof initializeTrayTemplateImageBackend).toBe('function');
+describe('populateElectronHostTrayTemplateImage', () => {
+  it('is the construction initializer of electronHostTrayTemplateImage', () => {
+    expect(typeof populateElectronHostTrayTemplateImage).toBe('function');
   });
 });
 
-describe('initializeTrayTitleBackend', () => {
-  it('is the construction initializer of createTrayTitleBackend', () => {
-    expect(typeof initializeTrayTitleBackend).toBe('function');
+describe('populateElectronHostTrayTitle', () => {
+  it('is the construction initializer of electronHostTrayTitle', () => {
+    expect(typeof populateElectronHostTrayTitle).toBe('function');
   });
 });
 
-describe('initializeTrayTooltipBackend', () => {
-  it('is the construction initializer of createTrayTooltipBackend', () => {
-    expect(typeof initializeTrayTooltipBackend).toBe('function');
+describe('populateElectronHostTrayTooltip', () => {
+  it('is the construction initializer of electronHostTrayTooltip', () => {
+    expect(typeof populateElectronHostTrayTooltip).toBe('function');
   });
 });

package/src/electronUpdater.test.ts

@@ -1,7 +1,9 @@
-import type { ElectronApi } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
-
-import { createElectronUpdaterBackend, initializeElectronUpdaterBackend } from './electronUpdater';
+import {
+  electronHostUpdater,
+  electronHostUpdaterCommand,
+  populateElectronHostUpdaterCommand,
+} from './electronUpdater.ts';
+import type { ElectronApi } from './types/index.ts';
 
 type NativeListener = (...args: unknown[]) => void;
 
@@ -58,12 +60,18 @@ function emit(listeners: Map<string, Set<NativeListener>>, event: string, ...arg
   for (const listener of [...(listeners.get(event) ?? [])]) listener(...args);
 }
 
-describe('createElectronUpdaterBackend', () => {
+describe('electronHostUpdater', () => {
+  it('constructs the Entity-backed updater command slot', () => {
+    const updater = electronHostUpdater(fakeElectron().electron);
+    expect(Object.keys(updater)).toEqual(['command']);
+  });
+});
+
+describe('electronHostUpdaterCommand', () => {
   it('returns an Entity and applies its immutable feed policy at construction', () => {
     const { electron, calls } = fakeElectron();
-    const backend = createElectronUpdaterBackend(electron, 'https://updates.test/feed');
+    const backend = electronHostUpdaterCommand(electron, 'https://updates.test/feed');
 
-    expect(EntityRuntimeKey in backend).toBe(true);
     expect(calls.feedUrls).toEqual(['https://updates.test/feed']);
 
     backend.destroy();
@@ -72,7 +80,7 @@ describe('createElectronUpdaterBackend', () => {
 
   it('runs one awaited Squirrel check through the private native event transaction', async () => {
     const { electron, listeners, calls } = fakeElectron();
-    const backend = createElectronUpdaterBackend(electron);
+    const backend = electronHostUpdaterCommand(electron);
 
     const pending = backend.check();
     expect(calls.checks).toBe(1);
@@ -83,7 +91,6 @@ describe('createElectronUpdaterBackend', () => {
     const outcome = await pending;
     expect(outcome.reason).toBe('downloaded');
     if (outcome.reason !== 'downloaded') throw new Error('expected downloaded update');
-    expect(EntityRuntimeKey in outcome.update).toBe(true);
     expect(outcome.update.info).toEqual({
       downloadSizeBytes: null,
       isMandatory: null,
@@ -100,7 +107,7 @@ describe('createElectronUpdaterBackend', () => {
 
   it('copies and freezes downloaded metadata and uses null for every unknown field', async () => {
     const { electron, listeners } = fakeElectron();
-    const backend = createElectronUpdaterBackend(electron);
+    const backend = electronHostUpdaterCommand(electron);
     const nativeArgs: unknown[] = [{}, '', undefined, ''];
 
     const pending = backend.check();
@@ -125,19 +132,19 @@ describe('createElectronUpdaterBackend', () => {
 
   it('settles not-available and native error with method-tight portable outcomes', async () => {
     const first = fakeElectron();
-    const notAvailable = createElectronUpdaterBackend(first.electron).check();
+    const notAvailable = electronHostUpdaterCommand(first.electron).check();
     emit(first.listeners, 'update-not-available');
     await expect(notAvailable).resolves.toEqual({ reason: 'not-available' });
 
     const second = fakeElectron();
-    const failed = createElectronUpdaterBackend(second.electron).check();
+    const failed = electronHostUpdaterCommand(second.electron).check();
     emit(second.listeners, 'error', new Error('native detail'));
     await expect(failed).resolves.toEqual({ reason: 'operation-failed' });
   });
 
   it('classifies a concurrent check without dispatching a second native operation', async () => {
     const { electron, listeners, calls } = fakeElectron();
-    const backend = createElectronUpdaterBackend(electron);
+    const backend = electronHostUpdaterCommand(electron);
 
     const first = backend.check();
     await expect(backend.check()).resolves.toEqual({ reason: 'check-in-progress' });
@@ -148,7 +155,7 @@ describe('createElectronUpdaterBackend', () => {
 
   it('rolls back every listener acquired before a partial attach failure', async () => {
     const { electron, listeners, calls } = fakeElectron({ failAttachFor: 'update-not-available' });
-    const backend = createElectronUpdaterBackend(electron);
+    const backend = electronHostUpdaterCommand(electron);
 
     await expect(backend.check()).resolves.toEqual({ reason: 'operation-failed' });
     expect(calls.checks).toBe(0);
@@ -160,7 +167,7 @@ describe('createElectronUpdaterBackend', () => {
     const { electron, listeners, calls } = fakeElectron({
       removeFailures: { 'update-available': 1 },
     });
-    const backend = createElectronUpdaterBackend(electron);
+    const backend = electronHostUpdaterCommand(electron);
 
     const pending = backend.check();
     emit(listeners, 'update-not-available');
@@ -186,7 +193,7 @@ describe('createElectronUpdaterBackend', () => {
 
   it('settles an in-flight transaction and deduplicates repeated provider destroy aliases', async () => {
     const { electron, calls } = fakeElectron();
-    const backend = createElectronUpdaterBackend(electron);
+    const backend = electronHostUpdaterCommand(electron);
     const pending = backend.check();
 
     backend.destroy();
@@ -203,8 +210,8 @@ describe('createElectronUpdaterBackend', () => {
     expect(calls.feedUrls).toEqual([]);
   });
 });
-describe('initializeElectronUpdaterBackend', () => {
-  it('is the construction initializer of createElectronUpdaterBackend', () => {
-    expect(typeof initializeElectronUpdaterBackend).toBe('function');
+describe('populateElectronHostUpdaterCommand', () => {
+  it('is the construction initializer of electronHostUpdaterCommand', () => {
+    expect(typeof populateElectronHostUpdaterCommand).toBe('function');
   });
 });