@flighthq/host-electron 0.5.1-next.903.f434bc2 → 0.5.1-next.905.5fbf787

package/README.md

@@ -13,5 +13,5 @@ Import the supported application-facing API from `@flighthq/host-electron`. The
 This package is part of the locked-version Flight SDK graph. Applications may instead install and import `@flighthq/sdk` when package-level tree shaking is sufficient.
 
 - [Flight project](https://github.com/flighthq/flight)
-- [Source for @flighthq/host-electron@0.5.1-next.903.f434bc2](https://github.com/flighthq/flight/tree/f434bc233778d75aeea61995df3a8cfaec459a85/packages/host-electron)
-- [License](https://github.com/flighthq/flight/blob/f434bc233778d75aeea61995df3a8cfaec459a85/LICENSE.md)
+- [Source for @flighthq/host-electron@0.5.1-next.905.5fbf787](https://github.com/flighthq/flight/tree/5fbf7874064c384307542d68b4dcb6a895ff0dcf/packages/host-electron)
+- [License](https://github.com/flighthq/flight/blob/5fbf7874064c384307542d68b4dcb6a895ff0dcf/LICENSE.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/host-electron",
-  "version": "0.5.1-next.903.f434bc2",
+  "version": "0.5.1-next.905.5fbf787",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,25 +38,25 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/entity": "0.5.1-next.903.f434bc2",
-    "@flighthq/app": "0.5.1-next.903.f434bc2",
-    "@flighthq/application": "0.5.1-next.903.f434bc2",
-    "@flighthq/clipboard": "0.5.1-next.903.f434bc2",
-    "@flighthq/dialog": "0.5.1-next.903.f434bc2",
-    "@flighthq/ipc": "0.5.1-next.903.f434bc2",
-    "@flighthq/menu": "0.5.1-next.903.f434bc2",
-    "@flighthq/notification": "0.5.1-next.903.f434bc2",
-    "@flighthq/platform": "0.5.1-next.903.f434bc2",
-    "@flighthq/power": "0.5.1-next.903.f434bc2",
-    "@flighthq/protocol": "0.5.1-next.903.f434bc2",
-    "@flighthq/shell": "0.5.1-next.903.f434bc2",
-    "@flighthq/screen": "0.5.1-next.903.f434bc2",
-    "@flighthq/shortcut": "0.5.1-next.903.f434bc2",
-    "@flighthq/signals": "0.5.1-next.903.f434bc2",
-    "@flighthq/storage": "0.5.1-next.903.f434bc2",
-    "@flighthq/tray": "0.5.1-next.903.f434bc2",
-    "@flighthq/types": "0.5.1-next.903.f434bc2",
-    "@flighthq/updater": "0.5.1-next.903.f434bc2"
+    "@flighthq/entity": "0.5.1-next.905.5fbf787",
+    "@flighthq/app": "0.5.1-next.905.5fbf787",
+    "@flighthq/application": "0.5.1-next.905.5fbf787",
+    "@flighthq/clipboard": "0.5.1-next.905.5fbf787",
+    "@flighthq/dialog": "0.5.1-next.905.5fbf787",
+    "@flighthq/ipc": "0.5.1-next.905.5fbf787",
+    "@flighthq/menu": "0.5.1-next.905.5fbf787",
+    "@flighthq/notification": "0.5.1-next.905.5fbf787",
+    "@flighthq/platform": "0.5.1-next.905.5fbf787",
+    "@flighthq/power": "0.5.1-next.905.5fbf787",
+    "@flighthq/protocol": "0.5.1-next.905.5fbf787",
+    "@flighthq/shell": "0.5.1-next.905.5fbf787",
+    "@flighthq/screen": "0.5.1-next.905.5fbf787",
+    "@flighthq/shortcut": "0.5.1-next.905.5fbf787",
+    "@flighthq/signals": "0.5.1-next.905.5fbf787",
+    "@flighthq/storage": "0.5.1-next.905.5fbf787",
+    "@flighthq/tray": "0.5.1-next.905.5fbf787",
+    "@flighthq/types": "0.5.1-next.905.5fbf787",
+    "@flighthq/updater": "0.5.1-next.905.5fbf787"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/electronApp.test.ts

@@ -2,7 +2,37 @@ import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions } from '@flight
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { describe, expect, it, vi } from 'vitest';
 
-import { createElectronAppCapabilities } from './electronApp';
+import {
+  createElectronAppCapabilities,
+  initializeAppActivateBackend,
+  initializeAppActivationPolicyBackend,
+  initializeAppAllWindowsClosedBackend,
+  initializeAppBadgeBackend,
+  initializeAppDockBackend,
+  initializeAppFocusBackend,
+  initializeAppHideBackend,
+  initializeAppLocaleBackend,
+  initializeAppLoginItemBackend,
+  initializeAppNameBackend,
+  initializeAppNameWriteBackend,
+  initializeAppOpenFileBackend,
+  initializeAppPathBackend,
+  initializeAppQuitBackend,
+  initializeAppQuitRequestBackend,
+  initializeAppReadyBackend,
+  initializeAppRecentDocumentsBackend,
+  initializeAppRelaunchBackend,
+  initializeAppSecondInstanceBackend,
+  initializeAppShowBackend,
+  initializeAppSingleInstanceBackend,
+  initializeAppUserModelIdBackend,
+  initializeAppVersionBackend,
+  initializeAppVisibilityQueryBackend,
+  initializeElectronCommonAppCapabilities,
+  initializeElectronLinuxAppCapabilities,
+  initializeElectronMacosAppCapabilities,
+  initializeElectronWindowsAppCapabilities,
+} from './electronApp';
 
 function fakeElectron() {
   const calls: string[] = [];
@@ -144,3 +174,170 @@ describe('createElectronAppCapabilities', () => {
     expect(() => createElectronAppCapabilities(electron, 'macos')).toThrow('require app.dock');
   });
 });
+describe('initializeAppActivateBackend', () => {
+  it('is the construction initializer of createAppActivateBackend', () => {
+    expect(typeof initializeAppActivateBackend).toBe('function');
+  });
+});
+
+describe('initializeAppActivationPolicyBackend', () => {
+  it('is the construction initializer of createAppActivationPolicyBackend', () => {
+    expect(typeof initializeAppActivationPolicyBackend).toBe('function');
+  });
+});
+
+describe('initializeAppAllWindowsClosedBackend', () => {
+  it('is the construction initializer of createAppAllWindowsClosedBackend', () => {
+    expect(typeof initializeAppAllWindowsClosedBackend).toBe('function');
+  });
+});
+
+describe('initializeAppBadgeBackend', () => {
+  it('is the construction initializer of createAppBadgeBackend', () => {
+    expect(typeof initializeAppBadgeBackend).toBe('function');
+  });
+});
+
+describe('initializeAppDockBackend', () => {
+  it('is the construction initializer of createAppDockBackend', () => {
+    expect(typeof initializeAppDockBackend).toBe('function');
+  });
+});
+
+describe('initializeAppFocusBackend', () => {
+  it('is the construction initializer of createAppFocusBackend', () => {
+    expect(typeof initializeAppFocusBackend).toBe('function');
+  });
+});
+
+describe('initializeAppHideBackend', () => {
+  it('is the construction initializer of createAppHideBackend', () => {
+    expect(typeof initializeAppHideBackend).toBe('function');
+  });
+});
+
+describe('initializeAppLocaleBackend', () => {
+  it('is the construction initializer of createAppLocaleBackend', () => {
+    expect(typeof initializeAppLocaleBackend).toBe('function');
+  });
+});
+
+describe('initializeAppLoginItemBackend', () => {
+  it('is the construction initializer of createAppLoginItemBackend', () => {
+    expect(typeof initializeAppLoginItemBackend).toBe('function');
+  });
+});
+
+describe('initializeAppNameBackend', () => {
+  it('is the construction initializer of createAppNameBackend', () => {
+    expect(typeof initializeAppNameBackend).toBe('function');
+  });
+});
+
+describe('initializeAppNameWriteBackend', () => {
+  it('is the construction initializer of createAppNameWriteBackend', () => {
+    expect(typeof initializeAppNameWriteBackend).toBe('function');
+  });
+});
+
+describe('initializeAppOpenFileBackend', () => {
+  it('is the construction initializer of createAppOpenFileBackend', () => {
+    expect(typeof initializeAppOpenFileBackend).toBe('function');
+  });
+});
+
+describe('initializeAppPathBackend', () => {
+  it('is the construction initializer of createAppPathBackend', () => {
+    expect(typeof initializeAppPathBackend).toBe('function');
+  });
+});
+
+describe('initializeAppQuitBackend', () => {
+  it('is the construction initializer of createAppQuitBackend', () => {
+    expect(typeof initializeAppQuitBackend).toBe('function');
+  });
+});
+
+describe('initializeAppQuitRequestBackend', () => {
+  it('is the construction initializer of createAppQuitRequestBackend', () => {
+    expect(typeof initializeAppQuitRequestBackend).toBe('function');
+  });
+});
+
+describe('initializeAppReadyBackend', () => {
+  it('is the construction initializer of createAppReadyBackend', () => {
+    expect(typeof initializeAppReadyBackend).toBe('function');
+  });
+});
+
+describe('initializeAppRecentDocumentsBackend', () => {
+  it('is the construction initializer of createAppRecentDocumentsBackend', () => {
+    expect(typeof initializeAppRecentDocumentsBackend).toBe('function');
+  });
+});
+
+describe('initializeAppRelaunchBackend', () => {
+  it('is the construction initializer of createAppRelaunchBackend', () => {
+    expect(typeof initializeAppRelaunchBackend).toBe('function');
+  });
+});
+
+describe('initializeAppSecondInstanceBackend', () => {
+  it('is the construction initializer of createAppSecondInstanceBackend', () => {
+    expect(typeof initializeAppSecondInstanceBackend).toBe('function');
+  });
+});
+
+describe('initializeAppShowBackend', () => {
+  it('is the construction initializer of createAppShowBackend', () => {
+    expect(typeof initializeAppShowBackend).toBe('function');
+  });
+});
+
+describe('initializeAppSingleInstanceBackend', () => {
+  it('is the construction initializer of createAppSingleInstanceBackend', () => {
+    expect(typeof initializeAppSingleInstanceBackend).toBe('function');
+  });
+});
+
+describe('initializeAppUserModelIdBackend', () => {
+  it('is the construction initializer of createAppUserModelIdBackend', () => {
+    expect(typeof initializeAppUserModelIdBackend).toBe('function');
+  });
+});
+
+describe('initializeAppVersionBackend', () => {
+  it('is the construction initializer of createAppVersionBackend', () => {
+    expect(typeof initializeAppVersionBackend).toBe('function');
+  });
+});
+
+describe('initializeAppVisibilityQueryBackend', () => {
+  it('is the construction initializer of createAppVisibilityQueryBackend', () => {
+    expect(typeof initializeAppVisibilityQueryBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronCommonAppCapabilities', () => {
+  it('is the construction initializer of createElectronCommonAppCapabilities', () => {
+    expect(typeof initializeElectronCommonAppCapabilities).toBe('function');
+  });
+});
+
+describe('initializeElectronLinuxAppCapabilities', () => {
+  it('is the construction initializer of createElectronLinuxAppCapabilities', () => {
+    expect(typeof initializeElectronLinuxAppCapabilities).toBe('function');
+  });
+});
+
+describe('initializeElectronMacosAppCapabilities', () => {
+  it('is the construction initializer of createElectronMacosAppCapabilities', () => {
+    expect(typeof initializeElectronMacosAppCapabilities).toBe('function');
+  });
+});
+
+describe('initializeElectronWindowsAppCapabilities', () => {
+  it('is the construction initializer of createElectronWindowsAppCapabilities', () => {
+    expect(typeof initializeElectronWindowsAppCapabilities).toBe('function');
+  });
+});

package/src/electronClipboard.test.ts

@@ -1,7 +1,7 @@
 import type { ElectronApi, ElectronNativeImage } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronClipboardBackend } from './electronClipboard';
+import { createElectronClipboardBackend, initializeElectronClipboardBackend } from './electronClipboard';
 
 function fakeElectron(): ElectronApi {
   const store = { text: '', html: '', rtf: '', imageDataUrl: '', bookmarkTitle: '', bookmarkUrl: '' };
@@ -88,3 +88,8 @@ describe('createElectronClipboardBackend', () => {
     expect(await backend.readText()).toBe('');
   });
 });
+describe('initializeElectronClipboardBackend', () => {
+  it('is the construction initializer of createElectronClipboardBackend', () => {
+    expect(typeof initializeElectronClipboardBackend).toBe('function');
+  });
+});

package/src/electronDialog.test.ts

@@ -11,6 +11,10 @@ import {
   createElectronFileOpenDialogBackend,
   createElectronFileSaveDialogBackend,
   createElectronMessageDialogBackend,
+  initializeElectronDirectoryOpenDialogBackend,
+  initializeElectronFileOpenDialogBackend,
+  initializeElectronFileSaveDialogBackend,
+  initializeElectronMessageDialogBackend,
 } from './electronDialog';
 
 function fakeElectron(overrides: {
@@ -161,3 +165,26 @@ describe('createElectronMessageDialogBackend', () => {
     expect(calls.messageOptions?.signal).toBe(signal);
   });
 });
+describe('initializeElectronDirectoryOpenDialogBackend', () => {
+  it('is the construction initializer of createElectronDirectoryOpenDialogBackend', () => {
+    expect(typeof initializeElectronDirectoryOpenDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronFileOpenDialogBackend', () => {
+  it('is the construction initializer of createElectronFileOpenDialogBackend', () => {
+    expect(typeof initializeElectronFileOpenDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronFileSaveDialogBackend', () => {
+  it('is the construction initializer of createElectronFileSaveDialogBackend', () => {
+    expect(typeof initializeElectronFileSaveDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronMessageDialogBackend', () => {
+  it('is the construction initializer of createElectronMessageDialogBackend', () => {
+    expect(typeof initializeElectronMessageDialogBackend).toBe('function');
+  });
+});

package/src/electronIpc.test.ts

@@ -7,6 +7,11 @@ import {
   createElectronIpcMessageBackend,
   createElectronIpcSendBackend,
   createElectronIpcTargetedSendBackend,
+  initializeElectronIpcHandleBackend,
+  initializeElectronIpcInvokeBackend,
+  initializeElectronIpcMessageBackend,
+  initializeElectronIpcSendBackend,
+  initializeElectronIpcTargetedSendBackend,
 } from './electronIpc';
 
 function fakeElectron(): {
@@ -167,3 +172,32 @@ describe('createElectronIpcTargetedSendBackend', () => {
     expect(EntityRuntimeKey in backend).toBe(true);
   });
 });
+describe('initializeElectronIpcHandleBackend', () => {
+  it('is the construction initializer of createElectronIpcHandleBackend', () => {
+    expect(typeof initializeElectronIpcHandleBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronIpcInvokeBackend', () => {
+  it('is the construction initializer of createElectronIpcInvokeBackend', () => {
+    expect(typeof initializeElectronIpcInvokeBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronIpcMessageBackend', () => {
+  it('is the construction initializer of createElectronIpcMessageBackend', () => {
+    expect(typeof initializeElectronIpcMessageBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronIpcSendBackend', () => {
+  it('is the construction initializer of createElectronIpcSendBackend', () => {
+    expect(typeof initializeElectronIpcSendBackend).toBe('function');
+  });
+});
+
+describe('initializeElectronIpcTargetedSendBackend', () => {
+  it('is the construction initializer of createElectronIpcTargetedSendBackend', () => {
+    expect(typeof initializeElectronIpcTargetedSendBackend).toBe('function');
+  });
+});

package/src/electronMenu.test.ts

@@ -2,7 +2,13 @@ import type { MenuApplicationBackend, MenuPopupBackend, MenuSelectBackend } from
 import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronMenuBackends } from './electronMenu';
+import {
+  createElectronMenuBackends,
+  initializeElectronMenuCapabilities,
+  initializeMenuApplicationBackend,
+  initializeMenuPopupBackend,
+  initializeMenuSelectBackend,
+} from './electronMenu';
 
 function fakeElectron(): {
   electron: ElectronApi;
@@ -149,3 +155,26 @@ function _slots(api: ElectronApi): {
     subscribeSelect: select.subscribe,
   };
 }
+describe('initializeElectronMenuCapabilities', () => {
+  it('is the construction initializer of createElectronMenuCapabilities', () => {
+    expect(typeof initializeElectronMenuCapabilities).toBe('function');
+  });
+});
+
+describe('initializeMenuApplicationBackend', () => {
+  it('is the construction initializer of createMenuApplicationBackend', () => {
+    expect(typeof initializeMenuApplicationBackend).toBe('function');
+  });
+});
+
+describe('initializeMenuPopupBackend', () => {
+  it('is the construction initializer of createMenuPopupBackend', () => {
+    expect(typeof initializeMenuPopupBackend).toBe('function');
+  });
+});
+
+describe('initializeMenuSelectBackend', () => {
+  it('is the construction initializer of createMenuSelectBackend', () => {
+    expect(typeof initializeMenuSelectBackend).toBe('function');
+  });
+});

package/src/electronNotification.test.ts

@@ -2,7 +2,11 @@ import { closeNotification } from '@flighthq/notification/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import type { ElectronApi, ElectronNotificationOptions } from '@flighthq/types/contract';
 
-import { createElectronNotificationCapabilities } from './electronNotification';
+import {
+  createElectronNotificationCapabilities,
+  initializeElectronMacosNotificationCapabilities,
+  initializeElectronNotificationCapabilities,
+} from './electronNotification';
 
 interface FakeNotification {
   close(): void;
@@ -186,3 +190,14 @@ describe('createElectronNotificationCapabilities', () => {
     expect(secondCloses).toBe(2);
   });
 });
+describe('initializeElectronMacosNotificationCapabilities', () => {
+  it('is the construction initializer of createElectronMacosNotificationCapabilities', () => {
+    expect(typeof initializeElectronMacosNotificationCapabilities).toBe('function');
+  });
+});
+
+describe('initializeElectronNotificationCapabilities', () => {
+  it('is the construction initializer of createElectronNotificationCapabilities', () => {
+    expect(typeof initializeElectronNotificationCapabilities).toBe('function');
+  });
+});

package/src/electronPlatform.test.ts

@@ -1,7 +1,7 @@
 import type { PlatformInfo, ElectronApi } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronPlatformBackend } from './electronPlatform';
+import { createElectronPlatformBackend, initializeElectronPlatformBackend } from './electronPlatform';
 
 function fakeElectron(): ElectronApi {
   return {
@@ -30,3 +30,8 @@ describe('createElectronPlatformBackend', () => {
     expect(typeof out.version).toBe('string');
   });
 });
+describe('initializeElectronPlatformBackend', () => {
+  it('is the construction initializer of createElectronPlatformBackend', () => {
+    expect(typeof initializeElectronPlatformBackend).toBe('function');
+  });
+});

package/src/electronPower.test.ts

@@ -1,7 +1,18 @@
 import type { PowerStatus, ElectronApi } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronPowerBackends } from './electronPower';
+import {
+  createElectronPowerBackends,
+  initializeElectronPowerCapabilities,
+  initializePowerBatteryHealthBackend,
+  initializePowerChangeBackend,
+  initializePowerIdleBackend,
+  initializePowerKeepAwakeBackend,
+  initializePowerSessionLockBackend,
+  initializePowerStatusBackend,
+  initializePowerSuspensionBackend,
+  initializePowerThermalBackend,
+} from './electronPower';
 
 function emptyStatus(): PowerStatus {
   return {
@@ -165,3 +176,56 @@ describe('electron power slot coverage', () => {
     expect('destroy' in slots.status).toBe(false);
   });
 });
+describe('initializeElectronPowerCapabilities', () => {
+  it('is the construction initializer of createElectronPowerCapabilities', () => {
+    expect(typeof initializeElectronPowerCapabilities).toBe('function');
+  });
+});
+
+describe('initializePowerBatteryHealthBackend', () => {
+  it('is the construction initializer of createPowerBatteryHealthBackend', () => {
+    expect(typeof initializePowerBatteryHealthBackend).toBe('function');
+  });
+});
+
+describe('initializePowerChangeBackend', () => {
+  it('is the construction initializer of createPowerChangeBackend', () => {
+    expect(typeof initializePowerChangeBackend).toBe('function');
+  });
+});
+
+describe('initializePowerIdleBackend', () => {
+  it('is the construction initializer of createPowerIdleBackend', () => {
+    expect(typeof initializePowerIdleBackend).toBe('function');
+  });
+});
+
+describe('initializePowerKeepAwakeBackend', () => {
+  it('is the construction initializer of createPowerKeepAwakeBackend', () => {
+    expect(typeof initializePowerKeepAwakeBackend).toBe('function');
+  });
+});
+
+describe('initializePowerSessionLockBackend', () => {
+  it('is the construction initializer of createPowerSessionLockBackend', () => {
+    expect(typeof initializePowerSessionLockBackend).toBe('function');
+  });
+});
+
+describe('initializePowerStatusBackend', () => {
+  it('is the construction initializer of createPowerStatusBackend', () => {
+    expect(typeof initializePowerStatusBackend).toBe('function');
+  });
+});
+
+describe('initializePowerSuspensionBackend', () => {
+  it('is the construction initializer of createPowerSuspensionBackend', () => {
+    expect(typeof initializePowerSuspensionBackend).toBe('function');
+  });
+});
+
+describe('initializePowerThermalBackend', () => {
+  it('is the construction initializer of createPowerThermalBackend', () => {
+    expect(typeof initializePowerThermalBackend).toBe('function');
+  });
+});

package/src/electronProtocol.test.ts

@@ -2,7 +2,15 @@ import type { ElectronApi } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
-import { createElectronProtocolCapabilities } from './electronProtocol';
+import {
+  createElectronProtocolCapabilities,
+  initializeElectronProtocolCapabilities,
+  initializeProtocolDefaultBackend,
+  initializeProtocolOpenBackend,
+  initializeProtocolRegistrationBackend,
+  initializeProtocolRegistrationQueryBackend,
+  initializeProtocolUnregistrationBackend,
+} from './electronProtocol';
 
 function fakeElectron() {
   const listeners = new Map<string, ((...args: unknown[]) => void)[]>();
@@ -63,3 +71,38 @@ describe('createElectronProtocolCapabilities', () => {
     expect(fake.listeners.get('open-url')).toHaveLength(0);
   });
 });
+describe('initializeElectronProtocolCapabilities', () => {
+  it('is the construction initializer of createElectronProtocolCapabilities', () => {
+    expect(typeof initializeElectronProtocolCapabilities).toBe('function');
+  });
+});
+
+describe('initializeProtocolDefaultBackend', () => {
+  it('is the construction initializer of createProtocolDefaultBackend', () => {
+    expect(typeof initializeProtocolDefaultBackend).toBe('function');
+  });
+});
+
+describe('initializeProtocolOpenBackend', () => {
+  it('is the construction initializer of createProtocolOpenBackend', () => {
+    expect(typeof initializeProtocolOpenBackend).toBe('function');
+  });
+});
+
+describe('initializeProtocolRegistrationBackend', () => {
+  it('is the construction initializer of createProtocolRegistrationBackend', () => {
+    expect(typeof initializeProtocolRegistrationBackend).toBe('function');
+  });
+});
+
+describe('initializeProtocolRegistrationQueryBackend', () => {
+  it('is the construction initializer of createProtocolRegistrationQueryBackend', () => {
+    expect(typeof initializeProtocolRegistrationQueryBackend).toBe('function');
+  });
+});
+
+describe('initializeProtocolUnregistrationBackend', () => {
+  it('is the construction initializer of createProtocolUnregistrationBackend', () => {
+    expect(typeof initializeProtocolUnregistrationBackend).toBe('function');
+  });
+});

package/src/electronRegister.test.ts

@@ -3,7 +3,7 @@ import { readClipboardText } from '@flighthq/clipboard/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import type { ElectronApi } from '@flighthq/types/contract';
 
-import { registerElectronBackends } from './electronRegister';
+import { initializeElectronHost, 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
@@ -47,6 +47,11 @@ function fakeElectron(): ElectronApi {
   } as unknown as ElectronApi;
 }
 
+describe('initializeElectronHost', () => {
+  it('is the construction initializer of createElectronHost', () => {
+    expect(typeof initializeElectronHost).toBe('function');
+  });
+});
 describe('registerElectronBackends', () => {
   it('routes capability seams to the Electron backends without throwing', async () => {
     const host = registerElectronBackends(fakeElectron(), {

package/src/electronScreen.test.ts

@@ -1,7 +1,12 @@
 import type { ScreenInfo, ElectronApi, ElectronDisplay } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronScreenCapabilities } from './electronScreen';
+import {
+  createElectronScreenCapabilities,
+  initializeEmptyScreenInfo,
+  initializeScreenChangeBackend,
+  initializeScreenQueryBackend,
+} from './electronScreen';
 
 function display(id: number, x: number): ElectronDisplay {
   return {
@@ -98,3 +103,20 @@ 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('initializeScreenChangeBackend', () => {
+  it('is the construction initializer of createScreenChangeBackend', () => {
+    expect(typeof initializeScreenChangeBackend).toBe('function');
+  });
+});
+
+describe('initializeScreenQueryBackend', () => {
+  it('is the construction initializer of createScreenQueryBackend', () => {
+    expect(typeof initializeScreenQueryBackend).toBe('function');
+  });
+});

package/src/electronShell.test.ts

@@ -1,12 +1,55 @@
 import type { ElectronApi } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { makeElectronShellCapabilities } from './electronShell';
+import {
+  initializeShellBeepBackend,
+  initializeShellExternalBackend,
+  initializeShellPathOpenBackend,
+  initializeShellPathRevealBackend,
+  initializeShellShortcutLinkBackend,
+  initializeShellTrashBackend,
+  makeElectronShellCapabilities,
+} from './electronShell';
 
 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');

package/src/electronShortcut.test.ts

@@ -1,7 +1,11 @@
 import type { ElectronApi } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronShortcutQueryBackend, createElectronShortcutTriggerBackend } from './electronShortcut';
+import {
+  createElectronShortcutQueryBackend,
+  createElectronShortcutTriggerBackend,
+  initializeElectronShortcutQueryBackend,
+} from './electronShortcut';
 
 function fakeElectron() {
   const callbacks = new Map<string, () => void>();
@@ -77,3 +81,8 @@ describe('createElectronShortcutTriggerBackend', () => {
     expect(fake.unregisterCalls).toEqual(['Control+A', 'Control+B', 'Control+A']);
   });
 });
+describe('initializeElectronShortcutQueryBackend', () => {
+  it('is the construction initializer of createElectronShortcutQueryBackend', () => {
+    expect(typeof initializeElectronShortcutQueryBackend).toBe('function');
+  });
+});

package/src/electronStorage.test.ts

@@ -1,7 +1,7 @@
 import type { ElectronApi } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronStorageBackend } from './electronStorage';
+import { createElectronStorageBackend, initializeElectronStorageBackend } from './electronStorage';
 
 const STORAGE_PATH = '/userData/storage.json';
 
@@ -179,3 +179,8 @@ describe('createElectronStorageBackend', () => {
     expect(backend.getItem('a')).toEqual({ reason: 'ok', value: 'visible' });
   });
 });
+describe('initializeElectronStorageBackend', () => {
+  it('is the construction initializer of createElectronStorageBackend', () => {
+    expect(typeof initializeElectronStorageBackend).toBe('function');
+  });
+});

package/src/electronTray.test.ts

@@ -17,7 +17,24 @@ import type {
 } from '@flighthq/types/contract';
 import { describe, expect, it, vi } from 'vitest';
 
-import { createElectronTrayCapabilities } from './electronTray';
+import {
+  createElectronTrayCapabilities,
+  initializeTrayBalloonBackend,
+  initializeTrayBalloonEventsBackend,
+  initializeTrayBoundsBackend,
+  initializeTrayDoubleClickPolicyBackend,
+  initializeTrayDropEventsBackend,
+  initializeTrayImageBackend,
+  initializeTrayInteractionEventsBackend,
+  initializeTrayLifecycleBackend,
+  initializeTrayMenuBackend,
+  initializeTrayMenuSelectionEventsBackend,
+  initializeTrayPopupMenuBackend,
+  initializeTrayPressedImageBackend,
+  initializeTrayTemplateImageBackend,
+  initializeTrayTitleBackend,
+  initializeTrayTooltipBackend,
+} from './electronTray';
 
 interface FakeImage extends ElectronNativeImage {
   source: string;
@@ -238,3 +255,92 @@ describe('createElectronTrayCapabilities', () => {
     expect((await displayTrayBalloon(tray, { text: 'Done', title: 'Flight' })).outcome).toBe('displayed');
   });
 });
+describe('initializeTrayBalloonBackend', () => {
+  it('is the construction initializer of createTrayBalloonBackend', () => {
+    expect(typeof initializeTrayBalloonBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayBalloonEventsBackend', () => {
+  it('is the construction initializer of createTrayBalloonEventsBackend', () => {
+    expect(typeof initializeTrayBalloonEventsBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayBoundsBackend', () => {
+  it('is the construction initializer of createTrayBoundsBackend', () => {
+    expect(typeof initializeTrayBoundsBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayDoubleClickPolicyBackend', () => {
+  it('is the construction initializer of createTrayDoubleClickPolicyBackend', () => {
+    expect(typeof initializeTrayDoubleClickPolicyBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayDropEventsBackend', () => {
+  it('is the construction initializer of createTrayDropEventsBackend', () => {
+    expect(typeof initializeTrayDropEventsBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayImageBackend', () => {
+  it('is the construction initializer of createTrayImageBackend', () => {
+    expect(typeof initializeTrayImageBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayInteractionEventsBackend', () => {
+  it('is the construction initializer of createTrayInteractionEventsBackend', () => {
+    expect(typeof initializeTrayInteractionEventsBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayLifecycleBackend', () => {
+  it('is the construction initializer of createTrayLifecycleBackend', () => {
+    expect(typeof initializeTrayLifecycleBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayMenuBackend', () => {
+  it('is the construction initializer of createTrayMenuBackend', () => {
+    expect(typeof initializeTrayMenuBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayMenuSelectionEventsBackend', () => {
+  it('is the construction initializer of createTrayMenuSelectionEventsBackend', () => {
+    expect(typeof initializeTrayMenuSelectionEventsBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayPopupMenuBackend', () => {
+  it('is the construction initializer of createTrayPopupMenuBackend', () => {
+    expect(typeof initializeTrayPopupMenuBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayPressedImageBackend', () => {
+  it('is the construction initializer of createTrayPressedImageBackend', () => {
+    expect(typeof initializeTrayPressedImageBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayTemplateImageBackend', () => {
+  it('is the construction initializer of createTrayTemplateImageBackend', () => {
+    expect(typeof initializeTrayTemplateImageBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayTitleBackend', () => {
+  it('is the construction initializer of createTrayTitleBackend', () => {
+    expect(typeof initializeTrayTitleBackend).toBe('function');
+  });
+});
+
+describe('initializeTrayTooltipBackend', () => {
+  it('is the construction initializer of createTrayTooltipBackend', () => {
+    expect(typeof initializeTrayTooltipBackend).toBe('function');
+  });
+});

package/src/electronUpdater.test.ts

@@ -1,7 +1,7 @@
 import type { ElectronApi } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createElectronUpdaterBackend } from './electronUpdater';
+import { createElectronUpdaterBackend, initializeElectronUpdaterBackend } from './electronUpdater';
 
 type NativeListener = (...args: unknown[]) => void;
 
@@ -203,3 +203,8 @@ describe('createElectronUpdaterBackend', () => {
     expect(calls.feedUrls).toEqual([]);
   });
 });
+describe('initializeElectronUpdaterBackend', () => {
+  it('is the construction initializer of createElectronUpdaterBackend', () => {
+    expect(typeof initializeElectronUpdaterBackend).toBe('function');
+  });
+});

package/src/electronWindow.test.ts

@@ -7,6 +7,7 @@ import {
   getApplicationWindowForElectronId,
   getElectronBrowserWindow,
   getElectronWindowId,
+  initializeElectronWindowBackend,
   resetElectronWindowBackendForTest,
 } from './electronWindow';
 
@@ -329,6 +330,11 @@ describe('getElectronWindowId', () => {
   });
 });
 
+describe('initializeElectronWindowBackend', () => {
+  it('is the construction initializer of createElectronWindowBackend', () => {
+    expect(typeof initializeElectronWindowBackend).toBe('function');
+  });
+});
 describe('resetElectronWindowBackendForTest', () => {
   it('clears the window identity maps', () => {
     const { electron, created } = fakeElectron();