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

package/src/electronRegister.test.ts

@@ -1,13 +1,184 @@
-import { getAppName } from '@flighthq/app/contract';
+import { getAppName } from '@flighthq/app';
 import { readClipboardText } from '@flighthq/clipboard/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
-import type { ElectronApi } from '@flighthq/types/contract';
+import { EntityRuntimeKey } from '@flighthq/entity/contract';
+import type { EntityRaw, EntityRuntime } from '@flighthq/entity/contract';
 
-import { initializeElectronHost, registerElectronBackends } from './electronRegister';
+import * as contractApi from './contract.ts';
+import { electronHost } from './electronRegister.ts';
+import * as publicApi from './index.ts';
+import type { ElectronApi } from './types/index.ts';
 
-// 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.
+const GROUPS = [
+  ['accessibility', 'electronHostAccessibilityGroup'],
+  ['app', 'electronHostApp'],
+  ['audio', 'electronHostAudioGroup'],
+  ['audioDecode', 'electronHostAudioDecodeGroup'],
+  ['bitmap', 'electronHostBitmapGroup'],
+  ['canvas', 'electronHostCanvasGroup'],
+  ['clipboard', 'electronHostClipboard'],
+  ['compress', 'electronHostCompressGroup'],
+  ['connectivity', 'electronHostConnectivityGroup'],
+  ['decompress', 'electronHostDecompressGroup'],
+  ['device', 'electronHostDeviceGroup'],
+  ['dialog', 'electronHostDialog'],
+  ['fileSystem', 'electronHostFileSystemGroup'],
+  ['font', 'electronHostFontGroup'],
+  ['fullscreen', 'electronHostFullscreenGroup'],
+  ['geolocation', 'electronHostGeolocationGroup'],
+  ['gl', 'electronHostGlGroup'],
+  ['glyph', 'electronHostGlyphGroup'],
+  ['haptics', 'electronHostHapticsGroup'],
+  ['image', 'electronHostImageGroup'],
+  ['imageDecode', 'electronHostImageDecodeGroup'],
+  ['imageEncode', 'electronHostImageEncodeGroup'],
+  ['input', 'electronHostInputGroup'],
+  ['ipc', 'electronHostIpc'],
+  ['lifecycle', 'electronHostLifecycleGroup'],
+  ['mediaSession', 'electronHostMediaSessionGroup'],
+  ['menu', 'electronHostMenu'],
+  ['midi', 'electronHostMidiGroup'],
+  ['net', 'electronHostNetGroup'],
+  ['notification', 'electronHostNotification'],
+  ['permissions', 'electronHostPermissionsGroup'],
+  ['platform', 'electronHostPlatformGroup'],
+  ['power', 'electronHostPower'],
+  ['preferences', 'electronHostStorageGroup'],
+  ['protocol', 'electronHostProtocol'],
+  ['screen', 'electronHostScreen'],
+  ['sensors', 'electronHostSensorsGroup'],
+  ['share', 'electronHostShareGroup'],
+  ['shell', 'electronHostShell'],
+  ['shortcut', 'electronHostShortcut'],
+  ['socket', 'electronHostSocketGroup'],
+  ['softKeyboard', 'electronHostSoftKeyboardGroup'],
+  ['statusBar', 'electronHostStatusBarGroup'],
+  ['surface', 'electronHostSurfaceGroup'],
+  ['textSegment', 'electronHostTextSegmentGroup'],
+  ['textShaper', 'electronHostTextShaperGroup'],
+  ['tray', 'electronHostTray'],
+  ['updater', 'electronHostUpdater'],
+  ['video', 'electronHostVideoGroup'],
+  ['wgpu', 'electronHostWgpuGroup'],
+  ['window', 'electronHostWindow'],
+] as const;
+
+const LEAVES = [
+  'electronHostAppActivate',
+  'electronHostAppActivationPolicy',
+  'electronHostAppAllWindowsClosed',
+  'electronHostAppBadge',
+  'electronHostAppDock',
+  'electronHostAppFocus',
+  'electronHostAppHide',
+  'electronHostAppLocale',
+  'electronHostAppLoginItem',
+  'electronHostAppName',
+  'electronHostAppNameWrite',
+  'electronHostAppOpenFile',
+  'electronHostAppPath',
+  'electronHostAppQuit',
+  'electronHostAppQuitRequest',
+  'electronHostAppReady',
+  'electronHostAppRecentDocuments',
+  'electronHostAppRelaunch',
+  'electronHostAppSecondInstance',
+  'electronHostAppShow',
+  'electronHostAppSingleInstance',
+  'electronHostAppUserModelId',
+  'electronHostAppVersion',
+  'electronHostClipboardBookmark',
+  'electronHostClipboardFormats',
+  'electronHostClipboardImage',
+  'electronHostClipboardText',
+  'electronHostDirectoryOpenDialog',
+  'electronHostFileOpenDialog',
+  'electronHostFileSaveDialog',
+  'electronHostIpcHandle',
+  'electronHostIpcInvoke',
+  'electronHostIpcMessage',
+  'electronHostIpcSend',
+  'electronHostIpcTargetedSend',
+  'electronHostAppMenu',
+  'electronHostMenuPopup',
+  'electronHostMenuSelect',
+  'electronHostMessageDialog',
+  'electronHostNotificationAction',
+  'electronHostNotificationClick',
+  'electronHostNotificationClose',
+  'electronHostNotificationDelivery',
+  'electronHostNotificationDismiss',
+  'electronHostNotificationLifecycle',
+  'electronHostNotificationReceived',
+  'electronHostNotificationReply',
+  'electronHostPlatform',
+  'electronHostPowerBatteryHealth',
+  'electronHostPowerChange',
+  'electronHostPowerIdle',
+  'electronHostPowerKeepAwake',
+  'electronHostPowerSessionLock',
+  'electronHostPowerStatus',
+  'electronHostPowerSuspension',
+  'electronHostPowerThermal',
+  'electronHostProtocolDefault',
+  'electronHostProtocolOpen',
+  'electronHostProtocolRegistration',
+  'electronHostProtocolRegistrationQuery',
+  'electronHostProtocolUnregistration',
+  'electronHostScreenChange',
+  'electronHostScreenQuery',
+  'electronHostShellBeep',
+  'electronHostShellExternal',
+  'electronHostShellPathOpen',
+  'electronHostShellPathReveal',
+  'electronHostShellShortcutLink',
+  'electronHostShellTrash',
+  'electronHostShortcutQuery',
+  'electronHostShortcutTrigger',
+  'electronHostStorage',
+  'electronHostTrayBalloon',
+  'electronHostTrayBalloonEvents',
+  'electronHostTrayBounds',
+  'electronHostTrayDoubleClickPolicy',
+  'electronHostTrayDropEvents',
+  'electronHostTrayImage',
+  'electronHostTrayInteractionEvents',
+  'electronHostTrayLifecycle',
+  'electronHostTrayMenu',
+  'electronHostTrayMenuSelectionEvents',
+  'electronHostTrayPopupMenu',
+  'electronHostTrayPressedImage',
+  'electronHostTrayTemplateImage',
+  'electronHostTrayTitle',
+  'electronHostTrayTooltip',
+  'electronHostUpdaterCommand',
+  'electronHostWindowAppearance',
+  'electronHostWindowAttach',
+  'electronHostWindowAttention',
+  'electronHostWindowContentProtection',
+  'electronHostWindowFocus',
+  'electronHostWindowFullscreen',
+  'electronHostWindowGeometry',
+  'electronHostWindowHierarchy',
+  'electronHostWindowLifecycle',
+  'electronHostWindowProgress',
+  'electronHostWindowShadow',
+  'electronHostWindowShell',
+  'electronHostWindowSizeConstraints',
+  'electronHostWindowState',
+  'electronHostWindowVisibility',
+  'electronHostWindowZOrder',
+] as const;
+
+const AUXILIARY_EXPORTS = ['getAppWindowForElectronId', 'getElectronBrowserWindow', 'getElectronWindowId'] as const;
+
+type EntityCompatibility = EntityRaw & { [EntityRuntimeKey]: EntityRuntime | undefined };
+type ElectronLeafResult = ReturnType<(typeof publicApi)[(typeof LEAVES)[number]]>;
+type ElectronLeafProvidersAreAllEntities =
+  Exclude<ElectronLeafResult, undefined> extends EntityCompatibility ? true : false;
+type ElectronFullHostIsEntity = ReturnType<typeof publicApi.electronHost> extends EntityCompatibility ? true : false;
+
+// A fake Electron API broad enough that every host constructor can close over its injected dependency
+// without calling missing native operations during construction.
 function fakeElectron(): ElectronApi {
   const noop = () => {};
   const off = () => () => {};
@@ -40,25 +211,56 @@ function fakeElectron(): ElectronApi {
     dialog: {},
     Menu: {
       buildFromTemplate: () => ({ popup: noop }),
-      setApplicationMenu: noop,
+      setAppMenu: noop,
     },
     // The remaining members are unused at registration time.
     _off: off,
   } as unknown as ElectronApi;
 }
 
-describe('initializeElectronHost', () => {
-  it('is the construction initializer of createElectronHost', () => {
-    expect(typeof initializeElectronHost).toBe('function');
+describe('electronHost', () => {
+  it('exports exactly the canonical full, group, and supported leaf constructors from both lanes', () => {
+    const expected = [...new Set(['electronHost', ...GROUPS.map((entry) => entry[1]), ...LEAVES])].sort();
+    const expectedSurface = [...expected, ...AUXILIARY_EXPORTS].sort();
+    for (const api of [publicApi, contractApi]) {
+      expect(Object.keys(api).sort()).toEqual(expectedSurface);
+      const names = Object.keys(api)
+        .filter((name) => /^electronHost(?:$|[A-Z])/u.test(name))
+        .sort();
+      expect(names).toEqual(expected);
+      expect(
+        Object.keys(api).filter((name) =>
+          /^(?:createElectron|initializeElectron|makeElectron|registerElectron)/u.test(name),
+        ),
+      ).toEqual([]);
+      for (const name of names) expect(Reflect.get(api, name), name).toBeTypeOf('function');
+    }
+    for (const name of expected) expect(Reflect.get(publicApi, name)).toBe(Reflect.get(contractApi, name));
   });
-});
-describe('registerElectronBackends', () => {
+
+  it('types the full host as an Entity and leaf capabilities as structural', () => {
+    expectTypeOf<ElectronFullHostIsEntity>().toEqualTypeOf<true>();
+    expectTypeOf<ElectronLeafProvidersAreAllEntities>().toEqualTypeOf<false>();
+  });
+
+  it('constructs every Host group through explicit canonical boundaries', () => {
+    const host = electronHost(fakeElectron(), { platform: 'linux' }) as unknown as Record<string, unknown>;
+    const hostGroups = [...HOST_GROUP_NAMES];
+    expect(GROUPS.map((entry) => entry[0]).sort()).toEqual(hostGroups);
+    expect(
+      Object.keys(host)
+        .filter((key) => key !== String(EntityRuntimeKey))
+        .sort(),
+    ).toEqual(hostGroups);
+    for (const [path] of GROUPS) expect(host[path], path).not.toBeUndefined();
+  });
+
   it('routes capability seams to the Electron backends without throwing', async () => {
-    const host = registerElectronBackends(fakeElectron(), {
+    const host = electronHost(fakeElectron(), {
       platform: 'linux',
     });
-    expect(host.media).toEqual({});
-    expect(EntityRuntimeKey in host).toBe(true);
+    expect(host.audio).toEqual({});
+    expect(host.video).toEqual({});
     expect(host.dialog.directoryOpen.open).toBeTypeOf('function');
     expect(host.dialog.fileOpen.open).toBeTypeOf('function');
     expect(host.dialog.fileSave.save).toBeTypeOf('function');
@@ -68,26 +270,23 @@ describe('registerElectronBackends', () => {
     expect(host.ipc.handle.handle).toBeTypeOf('function');
     expect(host.ipc.message.subscribe).toBeTypeOf('function');
     expect(host.ipc.targetedSend.send).toBeTypeOf('function');
-    expect(EntityRuntimeKey in host.shortcut.query).toBe(true);
-    expect(EntityRuntimeKey in host.shortcut.trigger).toBe(true);
-    expect(EntityRuntimeKey in host.updater.command).toBe(true);
     expect(host.updater.command.check).toBeTypeOf('function');
     expect(Object.keys(host.clipboard).sort()).toEqual(['bookmark', 'formats', 'image', 'text']);
     expect(host.connectivity).toEqual({});
-    expect(host.storage.local.getItem('missing')).toEqual({
+    expect(host.preferences.local.getItem('missing')).toEqual({
       reason: 'ok',
       value: null,
     });
-    expect(host.window.open).toBeTypeOf('function');
-    expect(getAppName(host)).toBe('ElectronApp');
-    expect(await readClipboardText(host)).toBe('ELECTRON-TEXT');
+    expect(host.window.lifecycle.open).toBeTypeOf('function');
+    expect(getAppName(host.app.name)).toBe('ElectronApp');
+    expect(await readClipboardText(host.clipboard.text)).toBe('ELECTRON-TEXT');
   });
 
   it('constructs the exact six Shell slots from an injected platform fact', () => {
-    const windowsHost = registerElectronBackends(fakeElectron(), {
+    const windowsHost = electronHost(fakeElectron(), {
       platform: 'windows',
     });
-    const linuxHost = registerElectronBackends(fakeElectron(), {
+    const linuxHost = electronHost(fakeElectron(), {
       platform: 'linux',
     });
     expect(Object.keys(windowsHost.shell).sort()).toEqual([
@@ -99,6 +298,61 @@ describe('registerElectronBackends', () => {
       'trash',
     ]);
     expect(Object.keys(linuxHost.shell).sort()).toEqual(['beep', 'external', 'pathOpen', 'pathReveal', 'trash']);
-    for (const provider of Object.values(windowsHost.shell)) expect(EntityRuntimeKey in provider).toBe(true);
   });
 });
+
+// The capability groups every provider host carries (D26: each provider declares its own; there is no
+// aggregate Host to read them from).
+const HOST_GROUP_NAMES = [
+  'accessibility',
+  'app',
+  'audio',
+  'audioDecode',
+  'bitmap',
+  'canvas',
+  'clipboard',
+  'compress',
+  'connectivity',
+  'decompress',
+  'device',
+  'dialog',
+  'fileSystem',
+  'font',
+  'fullscreen',
+  'geolocation',
+  'gl',
+  'glyph',
+  'haptics',
+  'image',
+  'imageDecode',
+  'imageEncode',
+  'input',
+  'ipc',
+  'lifecycle',
+  'mediaSession',
+  'menu',
+  'midi',
+  'net',
+  'notification',
+  'permissions',
+  'platform',
+  'power',
+  'preferences',
+  'protocol',
+  'screen',
+  'sensors',
+  'share',
+  'shell',
+  'shortcut',
+  'socket',
+  'softKeyboard',
+  'statusBar',
+  'surface',
+  'textSegment',
+  'textShaper',
+  'tray',
+  'updater',
+  'video',
+  'wgpu',
+  'window',
+];

package/src/electronScreen.test.ts

@@ -1,12 +1,14 @@
-import type { ScreenInfo, ElectronApi, ElectronDisplay } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
+import { createScreenInfo } from '@flighthq/screen/contract';
+import type { ScreenInfo } from '@flighthq/screen/contract';
 
 import {
-  createElectronScreenCapabilities,
-  initializeEmptyScreenInfo,
-  initializeScreenChangeBackend,
-  initializeScreenQueryBackend,
-} from './electronScreen';
+  electronHostScreen,
+  electronHostScreenChange,
+  electronHostScreenQuery,
+  populateElectronHostScreenChange,
+  populateElectronHostScreenQuery,
+} from './electronScreen.ts';
+import type { ElectronApi, ElectronDisplay } from './types/index.ts';
 
 function display(id: number, x: number): ElectronDisplay {
   return {
@@ -46,16 +48,16 @@ function fakeElectron(): {
   return { electron, listeners };
 }
 
-describe('createElectronScreenCapabilities', () => {
-  it('returns Entity-backed query and change facets', () => {
-    const capabilities = createElectronScreenCapabilities(fakeElectron().electron);
-    expect(EntityRuntimeKey in capabilities.query).toBe(true);
-    expect(EntityRuntimeKey in capabilities.change).toBe(true);
+describe('electronHostScreen', () => {
+  it('returns query and change facets', () => {
+    const capabilities = electronHostScreen(fakeElectron().electron);
+    expect(capabilities.query).toBeDefined();
+    expect(capabilities.change).toBeDefined();
   });
 
   it('fills the primary screen into out', () => {
     const { electron } = fakeElectron();
-    const backend = createElectronScreenCapabilities(electron).query;
+    const backend = electronHostScreen(electron).query;
     const out = {} as ScreenInfo;
     const result = backend.getPrimaryScreen(out);
     expect(result).toBe(out);
@@ -70,12 +72,12 @@ describe('createElectronScreenCapabilities', () => {
       scaleFactor: 2,
       isPrimary: true,
     });
-    expect(Object.keys(out).filter((key) => key !== String(EntityRuntimeKey))).toHaveLength(25);
+    expect(Object.keys(out).sort()).toEqual(Object.keys(createScreenInfo()).sort());
   });
 
   it('enumerates all screens marking the primary', () => {
     const { electron } = fakeElectron();
-    const backend = createElectronScreenCapabilities(electron).query;
+    const backend = electronHostScreen(electron).query;
     const out: ScreenInfo[] = [];
     backend.getScreens(out);
     expect(out).toHaveLength(2);
@@ -88,7 +90,7 @@ describe('createElectronScreenCapabilities', () => {
 
   it('subscribes to all change events and unsubscribes from all', () => {
     const fake = fakeElectron();
-    const backend = createElectronScreenCapabilities(fake.electron).change;
+    const backend = electronHostScreen(fake.electron).change;
     let count = 0;
     const off = backend.subscribe(() => {
       count++;
@@ -103,20 +105,27 @@ describe('createElectronScreenCapabilities', () => {
     expect(fake.listeners.get('display-metrics-changed')).toHaveLength(0);
   });
 });
-describe('initializeEmptyScreenInfo', () => {
-  it('is the construction initializer of createEmptyScreenInfo', () => {
-    expect(typeof initializeEmptyScreenInfo).toBe('function');
+
+describe('electronHostScreenChange', () => {
+  it('constructs a screen change provider', () => {
+    expect(electronHostScreenChange(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostScreenQuery', () => {
+  it('constructs a screen query provider', () => {
+    expect(electronHostScreenQuery(fakeElectron().electron)).toBeDefined();
   });
 });
 
-describe('initializeScreenChangeBackend', () => {
-  it('is the construction initializer of createScreenChangeBackend', () => {
-    expect(typeof initializeScreenChangeBackend).toBe('function');
+describe('populateElectronHostScreenChange', () => {
+  it('is the construction initializer of electronHostScreenChange', () => {
+    expect(typeof populateElectronHostScreenChange).toBe('function');
   });
 });
 
-describe('initializeScreenQueryBackend', () => {
-  it('is the construction initializer of createScreenQueryBackend', () => {
-    expect(typeof initializeScreenQueryBackend).toBe('function');
+describe('populateElectronHostScreenQuery', () => {
+  it('is the construction initializer of electronHostScreenQuery', () => {
+    expect(typeof populateElectronHostScreenQuery).toBe('function');
   });
 });

package/src/electronShell.test.ts

@@ -1,58 +1,27 @@
-import type { ElectronApi } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
-
 import {
-  initializeShellBeepBackend,
-  initializeShellExternalBackend,
-  initializeShellPathOpenBackend,
-  initializeShellPathRevealBackend,
-  initializeShellShortcutLinkBackend,
-  initializeShellTrashBackend,
-  makeElectronShellCapabilities,
-} from './electronShell';
+  electronHostShell,
+  electronHostShellBeep,
+  electronHostShellExternal,
+  electronHostShellPathOpen,
+  electronHostShellPathReveal,
+  electronHostShellShortcutLink,
+  electronHostShellTrash,
+  populateElectronHostShellBeep,
+  populateElectronHostShellExternal,
+  populateElectronHostShellPathOpen,
+  populateElectronHostShellPathReveal,
+  populateElectronHostShellShortcutLink,
+  populateElectronHostShellTrash,
+} from './electronShell.ts';
+import type { ElectronApi } from './types/index.ts';
 
 function fakeElectron(shell: Partial<ElectronApi['shell']>): ElectronApi {
   return { shell } as unknown as ElectronApi;
 }
 
-describe('initializeShellBeepBackend', () => {
-  it('is the construction initializer of createShellBeepBackend', () => {
-    expect(typeof initializeShellBeepBackend).toBe('function');
-  });
-});
-describe('initializeShellExternalBackend', () => {
-  it('is the construction initializer of createShellExternalBackend', () => {
-    expect(typeof initializeShellExternalBackend).toBe('function');
-  });
-});
-
-describe('initializeShellPathOpenBackend', () => {
-  it('is the construction initializer of createShellPathOpenBackend', () => {
-    expect(typeof initializeShellPathOpenBackend).toBe('function');
-  });
-});
-
-describe('initializeShellPathRevealBackend', () => {
-  it('is the construction initializer of createShellPathRevealBackend', () => {
-    expect(typeof initializeShellPathRevealBackend).toBe('function');
-  });
-});
-
-describe('initializeShellShortcutLinkBackend', () => {
-  it('is the construction initializer of createShellShortcutLinkBackend', () => {
-    expect(typeof initializeShellShortcutLinkBackend).toBe('function');
-  });
-});
-
-describe('initializeShellTrashBackend', () => {
-  it('is the construction initializer of createShellTrashBackend', () => {
-    expect(typeof initializeShellTrashBackend).toBe('function');
-  });
-});
-
-describe('makeElectronShellCapabilities', () => {
-  it('constructs every Windows provider as an Entity', () => {
-    const capabilities = makeElectronShellCapabilities(fakeElectron({}), 'windows');
+describe('electronHostShell', () => {
+  it('constructs every Windows provider', () => {
+    const capabilities = electronHostShell(fakeElectron({}), 'windows');
     expect(Object.keys(capabilities).sort()).toEqual([
       'beep',
       'external',
@@ -61,11 +30,10 @@ describe('makeElectronShellCapabilities', () => {
       'shortcutLink',
       'trash',
     ]);
-    for (const provider of Object.values(capabilities)) expect(EntityRuntimeKey in provider).toBe(true);
   });
 
   it('omits shortcutLink on an injected non-Windows platform', () => {
-    expect(Object.keys(makeElectronShellCapabilities(fakeElectron({}), 'linux')).sort()).toEqual([
+    expect(Object.keys(electronHostShell(fakeElectron({}), 'linux')).sort()).toEqual([
       'beep',
       'external',
       'pathOpen',
@@ -75,9 +43,9 @@ describe('makeElectronShellCapabilities', () => {
   });
 
   it('maps awaited external completion and rejection', async () => {
-    const ok = makeElectronShellCapabilities(fakeElectron({ openExternal: async () => {} }), 'linux');
+    const ok = electronHostShell(fakeElectron({ openExternal: async () => {} }), 'linux');
     await expect(ok.external?.open('https://example.test')).resolves.toEqual({ reason: 'ok' });
-    const failed = makeElectronShellCapabilities(
+    const failed = electronHostShell(
       fakeElectron({
         openExternal: async () => {
           throw new Error('denied');
@@ -89,9 +57,9 @@ describe('makeElectronShellCapabilities', () => {
   });
 
   it('preserves an Electron path error string', async () => {
-    const success = makeElectronShellCapabilities(fakeElectron({ openPath: async () => '' }), 'linux');
+    const success = electronHostShell(fakeElectron({ openPath: async () => '' }), 'linux');
     await expect(success.pathOpen?.open('/a')).resolves.toEqual({ reason: 'ok' });
-    const failed = makeElectronShellCapabilities(fakeElectron({ openPath: async () => 'no such file' }), 'linux');
+    const failed = electronHostShell(fakeElectron({ openPath: async () => 'no such file' }), 'linux');
     await expect(failed.pathOpen?.open('/a')).resolves.toEqual({
       message: 'no such file',
       reason: 'operation-failed',
@@ -99,7 +67,7 @@ describe('makeElectronShellCapabilities', () => {
   });
 
   it('does not turn an empty rejected path open into success', async () => {
-    const capabilities = makeElectronShellCapabilities(
+    const capabilities = electronHostShell(
       fakeElectron({
         openPath: async () => {
           throw new Error('');
@@ -112,7 +80,7 @@ describe('makeElectronShellCapabilities', () => {
 
   it('maps path reveal and trash outcomes', async () => {
     let revealed = '';
-    const capabilities = makeElectronShellCapabilities(
+    const capabilities = electronHostShell(
       fakeElectron({
         showItemInFolder(path) {
           revealed = path;
@@ -127,7 +95,7 @@ describe('makeElectronShellCapabilities', () => {
   });
 
   it('keeps shortcut read and write outcomes method-tight', async () => {
-    const capabilities = makeElectronShellCapabilities(
+    const capabilities = electronHostShell(
       fakeElectron({
         readShortcutLink: () => ({ target: '/target' }),
         writeShortcutLink: () => false,
@@ -145,7 +113,79 @@ describe('makeElectronShellCapabilities', () => {
 
   it('dispatches beep synchronously', () => {
     const beep = vi.fn();
-    makeElectronShellCapabilities(fakeElectron({ beep }), 'linux').beep?.beep();
+    electronHostShell(fakeElectron({ beep }), 'linux').beep?.beep();
     expect(beep).toHaveBeenCalledOnce();
   });
 });
+
+describe('electronHostShellBeep', () => {
+  it('constructs a shell beep provider', () => {
+    expect(electronHostShellBeep(fakeElectron({}))).toBeDefined();
+  });
+});
+
+describe('electronHostShellExternal', () => {
+  it('constructs a shell external provider', () => {
+    expect(electronHostShellExternal(fakeElectron({}))).toBeDefined();
+  });
+});
+
+describe('electronHostShellPathOpen', () => {
+  it('constructs a shell path open provider', () => {
+    expect(electronHostShellPathOpen(fakeElectron({}))).toBeDefined();
+  });
+});
+
+describe('electronHostShellPathReveal', () => {
+  it('constructs a shell path reveal provider', () => {
+    expect(electronHostShellPathReveal(fakeElectron({}))).toBeDefined();
+  });
+});
+
+describe('electronHostShellShortcutLink', () => {
+  it('constructs a shell shortcut link provider', () => {
+    expect(electronHostShellShortcutLink(fakeElectron({}))).toBeDefined();
+  });
+});
+
+describe('electronHostShellTrash', () => {
+  it('constructs a shell trash provider', () => {
+    expect(electronHostShellTrash(fakeElectron({}))).toBeDefined();
+  });
+});
+
+describe('populateElectronHostShellBeep', () => {
+  it('is the construction initializer of electronHostShellBeep', () => {
+    expect(typeof populateElectronHostShellBeep).toBe('function');
+  });
+});
+
+describe('populateElectronHostShellExternal', () => {
+  it('is the construction initializer of electronHostShellExternal', () => {
+    expect(typeof populateElectronHostShellExternal).toBe('function');
+  });
+});
+
+describe('populateElectronHostShellPathOpen', () => {
+  it('is the construction initializer of electronHostShellPathOpen', () => {
+    expect(typeof populateElectronHostShellPathOpen).toBe('function');
+  });
+});
+
+describe('populateElectronHostShellPathReveal', () => {
+  it('is the construction initializer of electronHostShellPathReveal', () => {
+    expect(typeof populateElectronHostShellPathReveal).toBe('function');
+  });
+});
+
+describe('populateElectronHostShellShortcutLink', () => {
+  it('is the construction initializer of electronHostShellShortcutLink', () => {
+    expect(typeof populateElectronHostShellShortcutLink).toBe('function');
+  });
+});
+
+describe('populateElectronHostShellTrash', () => {
+  it('is the construction initializer of electronHostShellTrash', () => {
+    expect(typeof populateElectronHostShellTrash).toBe('function');
+  });
+});