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

package/src/electronDefaultHostGroups.test.ts

@@ -0,0 +1,148 @@
+import {
+  webHostAudioDecode,
+  webHostImageDecode,
+  webHostImageEncode,
+  webHostTextShaper,
+} from '@flighthq/host-web/contract';
+
+import {
+  electronHostAccessibilityGroup,
+  electronHostAudioGroup,
+  electronHostBitmapGroup,
+  electronHostConnectivityGroup,
+  electronHostDeviceGroup,
+  electronHostFileSystemGroup,
+  electronHostFontGroup,
+  electronHostFullscreenGroup,
+  electronHostGeolocationGroup,
+  electronHostGlGroup,
+  electronHostGlyphGroup,
+  electronHostHapticsGroup,
+  electronHostAudioDecodeGroup,
+  electronHostImageDecodeGroup,
+  electronHostImageEncodeGroup,
+  electronHostImageGroup,
+  electronHostInputGroup,
+  electronHostLifecycleGroup,
+  electronHostMediaSessionGroup,
+  electronHostMidiGroup,
+  electronHostNetGroup,
+  electronHostPermissionsGroup,
+  electronHostSensorsGroup,
+  electronHostShareGroup,
+  electronHostSocketGroup,
+  electronHostSoftKeyboardGroup,
+  electronHostStatusBarGroup,
+  electronHostCanvasGroup,
+  electronHostSurfaceGroup,
+  electronHostTextSegmentGroup,
+  electronHostCompressGroup,
+  electronHostDecompressGroup,
+  electronHostTextShaperGroup,
+  electronHostVideoGroup,
+  electronHostWgpuGroup,
+} from './electronDefaultHostGroups.ts';
+import type { ElectronApi } from './types/index.ts';
+
+const electron = {} as ElectronApi;
+
+function emptyGroup(factory: () => object): () => void {
+  return () => {
+    it('constructs an exact empty capability group', () => {
+      expect(factory()).toEqual({});
+    });
+  };
+}
+
+const accessibilityGroup = emptyGroup(() => electronHostAccessibilityGroup(electron));
+const audioGroup = emptyGroup(() => electronHostAudioGroup(electron));
+const bitmapGroup = emptyGroup(() => electronHostBitmapGroup(electron));
+const connectivityGroup = emptyGroup(() => electronHostConnectivityGroup(electron));
+const deviceGroup = emptyGroup(() => electronHostDeviceGroup(electron));
+const fileSystemGroup = emptyGroup(() => electronHostFileSystemGroup(electron));
+const fontGroup = emptyGroup(() => electronHostFontGroup(electron));
+const fullscreenGroup = emptyGroup(() => electronHostFullscreenGroup(electron));
+const geolocationGroup = emptyGroup(() => electronHostGeolocationGroup(electron));
+const glGroup = emptyGroup(() => electronHostGlGroup(electron));
+const glyphGroup = emptyGroup(() => electronHostGlyphGroup(electron));
+const hapticsGroup = emptyGroup(() => electronHostHapticsGroup(electron));
+const imageGroup = emptyGroup(() => electronHostImageGroup(electron));
+const inputGroup = emptyGroup(() => electronHostInputGroup(electron));
+const lifecycleGroup = emptyGroup(() => electronHostLifecycleGroup(electron));
+const mediaSessionGroup = emptyGroup(() => electronHostMediaSessionGroup(electron));
+const midiGroup = emptyGroup(() => electronHostMidiGroup(electron));
+const netGroup = emptyGroup(() => electronHostNetGroup(electron));
+const permissionsGroup = emptyGroup(() => electronHostPermissionsGroup(electron));
+const sensorsGroup = emptyGroup(() => electronHostSensorsGroup(electron));
+const shareGroup = emptyGroup(() => electronHostShareGroup(electron));
+const socketGroup = emptyGroup(() => electronHostSocketGroup(electron));
+const softKeyboardGroup = emptyGroup(() => electronHostSoftKeyboardGroup(electron));
+const statusBarGroup = emptyGroup(() => electronHostStatusBarGroup(electron));
+const canvasGroup = emptyGroup(() => electronHostCanvasGroup(electron));
+const surfaceGroup = emptyGroup(() => electronHostSurfaceGroup(electron));
+const textSegmentGroup = emptyGroup(() => electronHostTextSegmentGroup(electron));
+const compressGroup = emptyGroup(() => electronHostCompressGroup(electron));
+const decompressGroup = emptyGroup(() => electronHostDecompressGroup(electron));
+const videoGroup = emptyGroup(() => electronHostVideoGroup(electron));
+const wgpuGroup = emptyGroup(() => electronHostWgpuGroup(electron));
+
+describe('electronHostAccessibilityGroup', accessibilityGroup);
+describe('electronHostAudioDecodeGroup', () => {
+  it('delegates to the shared web audio decode capabilities', () => {
+    expect(electronHostAudioDecodeGroup(electron)).toBe(webHostAudioDecode);
+  });
+});
+describe('electronHostAudioGroup', audioGroup);
+describe('electronHostBitmapGroup', bitmapGroup);
+describe('electronHostCanvasGroup', canvasGroup);
+describe('electronHostCompressGroup', compressGroup);
+describe('electronHostConnectivityGroup', connectivityGroup);
+describe('electronHostDecompressGroup', decompressGroup);
+describe('electronHostDeviceGroup', deviceGroup);
+describe('electronHostFileSystemGroup', fileSystemGroup);
+describe('electronHostFontGroup', fontGroup);
+describe('electronHostFullscreenGroup', fullscreenGroup);
+describe('electronHostGeolocationGroup', geolocationGroup);
+describe('electronHostGlGroup', glGroup);
+describe('electronHostGlyphGroup', glyphGroup);
+describe('electronHostHapticsGroup', hapticsGroup);
+describe('electronHostImageDecodeGroup', () => {
+  it('delegates to the shared web image decode capabilities', () => {
+    expect(electronHostImageDecodeGroup(electron)).toBe(webHostImageDecode);
+  });
+});
+describe('electronHostImageEncodeGroup', () => {
+  it('delegates to the shared web image encode capabilities', () => {
+    expect(electronHostImageEncodeGroup(electron)).toBe(webHostImageEncode);
+  });
+});
+describe('electronHostImageGroup', imageGroup);
+describe('electronHostInputGroup', inputGroup);
+describe('electronHostLifecycleGroup', lifecycleGroup);
+describe('electronHostMediaSessionGroup', mediaSessionGroup);
+describe('electronHostMidiGroup', midiGroup);
+describe('electronHostNetGroup', netGroup);
+describe('electronHostPermissionsGroup', permissionsGroup);
+describe('electronHostSensorsGroup', sensorsGroup);
+describe('electronHostShareGroup', shareGroup);
+describe('electronHostSocketGroup', socketGroup);
+describe('electronHostSoftKeyboardGroup', softKeyboardGroup);
+describe('electronHostStatusBarGroup', statusBarGroup);
+describe('electronHostSurfaceGroup', surfaceGroup);
+
+describe('electronHostTextSegmentGroup', textSegmentGroup);
+describe('electronHostTextShaperGroup', () => {
+  it('fills the shaper slot with the shared web text shaper', () => {
+    const group = electronHostTextShaperGroup(electron);
+    expect(group.shaper).toBe(webHostTextShaper);
+  });
+
+  it('is plain data with no Entity runtime and no symbol keys', () => {
+    const group = electronHostTextShaperGroup(electron);
+    expect(Symbol.for('EntityRuntime') in group).toBe(false);
+    expect(Object.getOwnPropertySymbols(group)).toEqual([]);
+    expect(Object.keys(group)).toEqual(['shaper']);
+  });
+});
+describe('electronHostVideoGroup', videoGroup);
+describe('electronHostWgpuGroup', wgpuGroup);

package/src/electronDialog.test.ts

@@ -1,21 +1,20 @@
+import {
+  electronHostDialog,
+  electronHostDirectoryOpenDialog,
+  electronHostFileOpenDialog,
+  electronHostFileSaveDialog,
+  electronHostMessageDialog,
+  populateElectronHostDirectoryOpenDialog,
+  populateElectronHostFileOpenDialog,
+  populateElectronHostFileSaveDialog,
+  populateElectronHostMessageDialog,
+} from './electronDialog.ts';
 import type {
   ElectronApi,
   ElectronMessageBoxOptions,
   ElectronOpenDialogOptions,
   ElectronSaveDialogOptions,
-} from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
-
-import {
-  createElectronDirectoryOpenDialogBackend,
-  createElectronFileOpenDialogBackend,
-  createElectronFileSaveDialogBackend,
-  createElectronMessageDialogBackend,
-  initializeElectronDirectoryOpenDialogBackend,
-  initializeElectronFileOpenDialogBackend,
-  initializeElectronFileSaveDialogBackend,
-  initializeElectronMessageDialogBackend,
-} from './electronDialog';
+} from './types/index.ts';
 
 function fakeElectron(overrides: {
   open?: { canceled: boolean; filePaths: string[] } | Error;
@@ -48,37 +47,42 @@ function fakeElectron(overrides: {
   return { electron, calls };
 }
 
-describe('createElectronDirectoryOpenDialogBackend', () => {
+describe('electronHostDialog', () => {
+  it('constructs the exact dialog group', () => {
+    const dialog = electronHostDialog(fakeElectron({}).electron);
+    expect(Object.keys(dialog).sort()).toEqual(['directoryOpen', 'fileOpen', 'fileSave', 'message']);
+  });
+});
+
+describe('electronHostDirectoryOpenDialog', () => {
   it('uses a method-tight single-directory operation', async () => {
     const { electron, calls } = fakeElectron({ open: { canceled: false, filePaths: ['/docs'] } });
-    const result = await createElectronDirectoryOpenDialogBackend(electron).open();
+    const result = await electronHostDirectoryOpenDialog(electron).open();
     expect(calls.openOptions).toEqual({ properties: ['openDirectory'] });
     expect(result.outcome === 'selected' ? result.handle.path : null).toBe('/docs');
   });
 });
 
-describe('createElectronFileOpenDialogBackend', () => {
-  it('exposes independent Entity providers', () => {
+describe('electronHostFileOpenDialog', () => {
+  it('exposes independent providers', () => {
     const electron = fakeElectron({}).electron;
     const providers = [
-      createElectronDirectoryOpenDialogBackend(electron),
-      createElectronFileOpenDialogBackend(electron),
-      createElectronFileSaveDialogBackend(electron),
+      electronHostDirectoryOpenDialog(electron),
+      electronHostFileOpenDialog(electron),
+      electronHostFileSaveDialog(electron),
     ];
-    expect(providers.every((provider) => EntityRuntimeKey in provider)).toBe(true);
     expect(new Set(providers).size).toBe(3);
   });
 
   it('returns selected nonempty file handles and maps common filters/multiple', async () => {
     const { electron, calls } = fakeElectron({ open: { canceled: false, filePaths: ['/a', '/b'] } });
-    const result = await createElectronFileOpenDialogBackend(electron).open({
+    const result = await electronHostFileOpenDialog(electron).open({
       filters: [{ accept: { 'text/plain': ['.txt'], 'text/markdown': ['md'] }, name: 'Text' }],
       multiple: true,
     });
     expect(result.outcome).toBe('selected');
     if (result.outcome === 'selected') {
       expect(result.handles.map((handle) => handle.name)).toEqual(['a', 'b']);
-      expect(result.handles.every((handle) => EntityRuntimeKey in handle)).toBe(true);
     }
     expect(calls.openOptions).toEqual({
       filters: [{ extensions: ['txt', 'md'], name: 'Text' }],
@@ -88,21 +92,19 @@ describe('createElectronFileOpenDialogBackend', () => {
 
   it('uses the independent single-directory operation and preserves a root basename', async () => {
     const { electron, calls } = fakeElectron({ open: { canceled: false, filePaths: ['/'] } });
-    const result = await createElectronDirectoryOpenDialogBackend(electron).open();
+    const result = await electronHostDirectoryOpenDialog(electron).open();
     expect(calls.openOptions).toEqual({ properties: ['openDirectory'] });
     expect(result.outcome === 'selected' ? result.handle.name : null).toBe('/');
   });
 
   it('distinguishes cancel, security denial, and operation failure', async () => {
-    const cancelled = await createElectronFileOpenDialogBackend(
+    const cancelled = await electronHostFileOpenDialog(
       fakeElectron({ open: { canceled: true, filePaths: ['/ignored'] } }).electron,
     ).open({});
-    const security = await createElectronFileOpenDialogBackend(
+    const security = await electronHostFileOpenDialog(
       fakeElectron({ open: Object.assign(new Error('denied'), { code: 'EACCES' }) }).electron,
     ).open({});
-    const failed = await createElectronFileOpenDialogBackend(fakeElectron({ open: new Error('broken') }).electron).open(
-      {},
-    );
+    const failed = await electronHostFileOpenDialog(fakeElectron({ open: new Error('broken') }).electron).open({});
     expect(cancelled.outcome).toBe('cancelled');
     expect(security.outcome).toBe('security-denied');
     expect(failed.outcome).toBe('file-open-failed');
@@ -110,81 +112,81 @@ describe('createElectronFileOpenDialogBackend', () => {
 
   it('maps the common defaultName invariant and returns a selected save handle', async () => {
     const { electron, calls } = fakeElectron({ save: { canceled: false, filePath: '/out.txt' } });
-    const result = await createElectronFileSaveDialogBackend(electron).save({ defaultName: 'suggested.txt' });
+    const result = await electronHostFileSaveDialog(electron).save({ defaultName: 'suggested.txt' });
     expect(calls.saveOptions?.defaultPath).toBe('suggested.txt');
     expect(result.outcome === 'selected' ? result.handle.path : null).toBe('/out.txt');
   });
 
   it('reports runtime-unavailable when an Electron dialog method is absent', async () => {
     const electron = { dialog: {} } as ElectronApi;
-    expect((await createElectronDirectoryOpenDialogBackend(electron).open()).outcome).toBe('runtime-unavailable');
-    expect((await createElectronFileOpenDialogBackend(electron).open({})).outcome).toBe('runtime-unavailable');
-    expect((await createElectronFileSaveDialogBackend(electron).save({})).outcome).toBe('runtime-unavailable');
+    expect((await electronHostDirectoryOpenDialog(electron).open()).outcome).toBe('runtime-unavailable');
+    expect((await electronHostFileOpenDialog(electron).open({})).outcome).toBe('runtime-unavailable');
+    expect((await electronHostFileSaveDialog(electron).save({})).outcome).toBe('runtime-unavailable');
   });
 
   it('does not open a native picker when already aborted', async () => {
     const { electron, calls } = fakeElectron({ open: { canceled: false, filePaths: ['/ignored'] } });
     const controller = new AbortController();
     controller.abort();
-    await expect(createElectronFileOpenDialogBackend(electron).open({ signal: controller.signal })).resolves.toEqual({
+    await expect(electronHostFileOpenDialog(electron).open({ signal: controller.signal })).resolves.toEqual({
       outcome: 'cancelled',
     });
     expect(calls.openOptions).toBeUndefined();
   });
 });
 
-describe('createElectronFileSaveDialogBackend', () => {
+describe('electronHostFileSaveDialog', () => {
   it('maps the common default name and returns one selected handle', async () => {
     const { electron, calls } = fakeElectron({ save: { canceled: false, filePath: '/saved.txt' } });
-    const result = await createElectronFileSaveDialogBackend(electron).save({ defaultName: 'suggested.txt' });
+    const result = await electronHostFileSaveDialog(electron).save({ defaultName: 'suggested.txt' });
     expect(calls.saveOptions?.defaultPath).toBe('suggested.txt');
     expect(result.outcome === 'selected' ? result.handle.path : null).toBe('/saved.txt');
   });
 });
 
-describe('createElectronMessageDialogBackend', () => {
+describe('electronHostMessageDialog', () => {
   it('maps message results to button index, cancelled, and checkbox state', async () => {
     const { electron, calls } = fakeElectron({ message: { response: 2, checkboxChecked: true } });
-    const result = await createElectronMessageDialogBackend(electron).message({ message: 'hi', kind: 'warning' });
+    const result = await electronHostMessageDialog(electron).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 createElectronMessageDialogBackend(yes.electron).confirm({ message: 'ok?' })).toBe(true);
+    expect(await electronHostMessageDialog(yes.electron).confirm({ message: 'ok?' })).toBe(true);
     const no = fakeElectron({ message: { response: 1, checkboxChecked: false } });
-    expect(await createElectronMessageDialogBackend(no.electron).confirm({ message: 'ok?' })).toBe(false);
+    expect(await electronHostMessageDialog(no.electron).confirm({ message: 'ok?' })).toBe(false);
     expect(no.calls.messageOptions?.buttons).toEqual(['OK', 'Cancel']);
   });
 
   it('forwards the signal supported by Electron message boxes', async () => {
     const { electron, calls } = fakeElectron({});
     const signal = new AbortController().signal;
-    await createElectronMessageDialogBackend(electron).message({ message: 'wait', signal });
+    await electronHostMessageDialog(electron).message({ message: 'wait', signal });
     expect(calls.messageOptions?.signal).toBe(signal);
   });
 });
-describe('initializeElectronDirectoryOpenDialogBackend', () => {
-  it('is the construction initializer of createElectronDirectoryOpenDialogBackend', () => {
-    expect(typeof initializeElectronDirectoryOpenDialogBackend).toBe('function');
+describe('populateElectronHostDirectoryOpenDialog', () => {
+  it('is the construction initializer of electronHostDirectoryOpenDialog', () => {
+    expect(typeof populateElectronHostDirectoryOpenDialog).toBe('function');
   });
 });
 
-describe('initializeElectronFileOpenDialogBackend', () => {
-  it('is the construction initializer of createElectronFileOpenDialogBackend', () => {
-    expect(typeof initializeElectronFileOpenDialogBackend).toBe('function');
+describe('populateElectronHostFileOpenDialog', () => {
+  it('is the construction initializer of electronHostFileOpenDialog', () => {
+    expect(typeof populateElectronHostFileOpenDialog).toBe('function');
   });
 });
 
-describe('initializeElectronFileSaveDialogBackend', () => {
-  it('is the construction initializer of createElectronFileSaveDialogBackend', () => {
-    expect(typeof initializeElectronFileSaveDialogBackend).toBe('function');
+describe('populateElectronHostFileSaveDialog', () => {
+  it('is the construction initializer of electronHostFileSaveDialog', () => {
+    expect(typeof populateElectronHostFileSaveDialog).toBe('function');
   });
 });
 
-describe('initializeElectronMessageDialogBackend', () => {
-  it('is the construction initializer of createElectronMessageDialogBackend', () => {
-    expect(typeof initializeElectronMessageDialogBackend).toBe('function');
+describe('populateElectronHostMessageDialog', () => {
+  it('is the construction initializer of electronHostMessageDialog', () => {
+    expect(typeof populateElectronHostMessageDialog).toBe('function');
   });
 });

package/src/electronHostTreeShaking.test.ts

@@ -0,0 +1,51 @@
+// @vitest-environment node
+
+import { build } from 'esbuild';
+
+describe('Electron Host tree shaking', () => {
+  it('keeps a direct App leaf independent of sibling and full-host assembly', async () => {
+    const output = await bundleElectronHostExport('electronHostAppName');
+    expect(output).toContain('electronHostAppName');
+    expect(output).toContain('getName');
+    expect(output).not.toContain('getLocale');
+    expect(output).not.toContain('requestSingleInstanceLock');
+    expect(output).not.toContain('availableFormats');
+  });
+
+  it('keeps the Clipboard text leaf independent of sibling clipboard providers', async () => {
+    const output = await bundleElectronHostExport('electronHostClipboardText');
+    expect(output).toContain('electronHostClipboardText');
+    expect(output).toContain('readText');
+    expect(output).toContain('writeText');
+    expect(output).not.toContain('availableFormats');
+    expect(output).not.toContain('nativeImage');
+    expect(output).not.toContain('readBookmark');
+    expect(output).not.toContain('readRTF');
+  });
+});
+
+async function bundleElectronHostExport(name: string): Promise<string> {
+  const result = await build({
+    bundle: true,
+    format: 'esm',
+    logLevel: 'silent',
+    minify: true,
+    packages: 'external',
+    platform: 'node',
+    stdin: {
+      contents: `export { ${name} } from './index.ts';`,
+      resolveDir: fileUrlDirectory(import.meta.url),
+      sourcefile: `tree-shake-${name}.ts`,
+    },
+    treeShaking: true,
+    write: false,
+  });
+  return result.outputFiles[0].text;
+}
+
+function fileUrlDirectory(url: string): string {
+  const directory = new URL('.', url);
+  const pathname = decodeURIComponent(directory.pathname);
+  if (directory.hostname !== '') return `//${directory.hostname}${pathname}`;
+  return /^\/[A-Za-z]:\//.test(pathname) ? pathname.slice(1) : pathname;
+}

package/src/electronIpc.test.ts

@@ -1,18 +1,17 @@
-import type { ElectronApi, ElectronIpcRenderer, ElectronIpcTarget, Entity } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
-
 import {
-  createElectronIpcHandleBackend,
-  createElectronIpcInvokeBackend,
-  createElectronIpcMessageBackend,
-  createElectronIpcSendBackend,
-  createElectronIpcTargetedSendBackend,
-  initializeElectronIpcHandleBackend,
-  initializeElectronIpcInvokeBackend,
-  initializeElectronIpcMessageBackend,
-  initializeElectronIpcSendBackend,
-  initializeElectronIpcTargetedSendBackend,
-} from './electronIpc';
+  electronHostIpc,
+  electronHostIpcHandle,
+  electronHostIpcInvoke,
+  electronHostIpcMessage,
+  electronHostIpcSend,
+  electronHostIpcTargetedSend,
+  populateElectronHostIpcHandle,
+  populateElectronHostIpcInvoke,
+  populateElectronHostIpcMessage,
+  populateElectronHostIpcSend,
+  populateElectronHostIpcTargetedSend,
+} from './electronIpc.ts';
+import type { ElectronApi, ElectronIpcRenderer, ElectronIpcTarget } from './types/index.ts';
 
 function fakeElectron(): {
   channels: Map<string, Set<(event: unknown, ...args: unknown[]) => void>>;
@@ -63,10 +62,17 @@ function fakeRenderer(): {
   };
 }
 
-describe('createElectronIpcHandleBackend', () => {
+describe('electronHostIpc', () => {
+  it('constructs the main-process IPC group', () => {
+    const ipc = electronHostIpc(fakeElectron().electron);
+    expect(Object.keys(ipc).sort()).toEqual(['handle', 'message', 'targetedSend']);
+  });
+});
+
+describe('electronHostIpcHandle', () => {
   it('registers a main-process handler, drops the event, and releases it idempotently', async () => {
     const { electron, handlers } = fakeElectron();
-    const backend = createElectronIpcHandleBackend(electron);
+    const backend = electronHostIpcHandle(electron);
     const stop = backend.handle('double', (value) => (value as number) * 2);
 
     expect(await handlers.get('double')?.({ sender: 1 }, 4)).toBe(8);
@@ -75,37 +81,22 @@ describe('createElectronIpcHandleBackend', () => {
     stop();
     expect(handlers.has('double')).toBe(false);
   });
-
-  it('returns an Entity', () => {
-    const backend: Entity = createElectronIpcHandleBackend(fakeElectron().electron);
-    expect(EntityRuntimeKey in backend).toBe(true);
-  });
 });
 
-describe('createElectronIpcInvokeBackend', () => {
+describe('electronHostIpcInvoke', () => {
   it('invokes from the renderer with spread arguments and returns the response', async () => {
     const { invocations, renderer } = fakeRenderer();
-    const backend = createElectronIpcInvokeBackend(renderer);
+    const backend = electronHostIpcInvoke(renderer);
 
     await expect(backend.invoke('compute', [1, 2])).resolves.toEqual({ args: [1, 2], channel: 'compute' });
     expect(invocations).toEqual([{ args: [1, 2], channel: 'compute' }]);
   });
-
-  it('returns an Entity', () => {
-    const backend: Entity = createElectronIpcInvokeBackend(fakeRenderer().renderer);
-    expect(EntityRuntimeKey in backend).toBe(true);
-  });
 });
 
-describe('createElectronIpcMessageBackend', () => {
-  it('returns an Entity in both runtime and type', () => {
-    const backend: Entity = createElectronIpcMessageBackend(fakeElectron().electron);
-    expect(EntityRuntimeKey in backend).toBe(true);
-  });
-
+describe('electronHostIpcMessage', () => {
   it('delivers a renderer message with its arguments, dropping the event object', () => {
     const { electron, channels } = fakeElectron();
-    const backend = createElectronIpcMessageBackend(electron);
+    const backend = electronHostIpcMessage(electron);
     const seen: readonly unknown[][] = [];
     backend.subscribe('ping', (args) => (seen as unknown[][]).push([...args]));
     for (const listener of channels.get('ping') ?? []) listener({ sender: 1 }, 'a', 2);
@@ -116,7 +107,7 @@ describe('createElectronIpcMessageBackend', () => {
   // provider-level destroy: ipcMain is the caller's to tear down, not this backend's.
   it('removes exactly its own ipcMain listener on unsubscribe', () => {
     const { electron, channels } = fakeElectron();
-    const backend = createElectronIpcMessageBackend(electron);
+    const backend = electronHostIpcMessage(electron);
     const stopFirst = backend.subscribe('ping', () => {});
     backend.subscribe('ping', () => {});
     expect(channels.get('ping')?.size).toBe(2);
@@ -125,7 +116,7 @@ describe('createElectronIpcMessageBackend', () => {
   });
 
   it('remains independent from the other IPC capabilities', () => {
-    const backend = createElectronIpcMessageBackend(fakeElectron().electron);
+    const backend = electronHostIpcMessage(fakeElectron().electron);
     expect(Object.keys(backend).filter((key) => key !== 'constructor')).toEqual(['subscribe']);
     expect('send' in backend).toBe(false);
     expect('invoke' in backend).toBe(false);
@@ -135,23 +126,18 @@ describe('createElectronIpcMessageBackend', () => {
   });
 });
 
-describe('createElectronIpcSendBackend', () => {
+describe('electronHostIpcSend', () => {
   it('sends from the renderer with spread arguments', () => {
     const { renderer, sent } = fakeRenderer();
-    const backend = createElectronIpcSendBackend(renderer);
+    const backend = electronHostIpcSend(renderer);
 
     backend.send('log', ['hello', 7]);
 
     expect(sent).toEqual([{ args: ['hello', 7], channel: 'log' }]);
   });
-
-  it('returns an Entity', () => {
-    const backend: Entity = createElectronIpcSendBackend(fakeRenderer().renderer);
-    expect(EntityRuntimeKey in backend).toBe(true);
-  });
 });
 
-describe('createElectronIpcTargetedSendBackend', () => {
+describe('electronHostIpcTargetedSend', () => {
   it('keeps the target generic and delegates to its Electron send seam', () => {
     const sent: Array<{ readonly args: readonly unknown[]; readonly channel: string }> = [];
     const target: ElectronIpcTarget & { readonly label: string } = {
@@ -160,44 +146,39 @@ describe('createElectronIpcTargetedSendBackend', () => {
         sent.push({ args, channel });
       },
     };
-    const backend = createElectronIpcTargetedSendBackend<typeof target>();
+    const backend = electronHostIpcTargetedSend<typeof target>();
 
     backend.send(target, 'refresh', [1, 2]);
 
     expect(sent).toEqual([{ args: [1, 2], channel: 'refresh' }]);
   });
-
-  it('returns an Entity', () => {
-    const backend: Entity = createElectronIpcTargetedSendBackend<ElectronIpcTarget>();
-    expect(EntityRuntimeKey in backend).toBe(true);
-  });
 });
-describe('initializeElectronIpcHandleBackend', () => {
-  it('is the construction initializer of createElectronIpcHandleBackend', () => {
-    expect(typeof initializeElectronIpcHandleBackend).toBe('function');
+describe('populateElectronHostIpcHandle', () => {
+  it('is the construction initializer of electronHostIpcHandle', () => {
+    expect(typeof populateElectronHostIpcHandle).toBe('function');
   });
 });
 
-describe('initializeElectronIpcInvokeBackend', () => {
-  it('is the construction initializer of createElectronIpcInvokeBackend', () => {
-    expect(typeof initializeElectronIpcInvokeBackend).toBe('function');
+describe('populateElectronHostIpcInvoke', () => {
+  it('is the construction initializer of electronHostIpcInvoke', () => {
+    expect(typeof populateElectronHostIpcInvoke).toBe('function');
   });
 });
 
-describe('initializeElectronIpcMessageBackend', () => {
-  it('is the construction initializer of createElectronIpcMessageBackend', () => {
-    expect(typeof initializeElectronIpcMessageBackend).toBe('function');
+describe('populateElectronHostIpcMessage', () => {
+  it('is the construction initializer of electronHostIpcMessage', () => {
+    expect(typeof populateElectronHostIpcMessage).toBe('function');
   });
 });
 
-describe('initializeElectronIpcSendBackend', () => {
-  it('is the construction initializer of createElectronIpcSendBackend', () => {
-    expect(typeof initializeElectronIpcSendBackend).toBe('function');
+describe('populateElectronHostIpcSend', () => {
+  it('is the construction initializer of electronHostIpcSend', () => {
+    expect(typeof populateElectronHostIpcSend).toBe('function');
   });
 });
 
-describe('initializeElectronIpcTargetedSendBackend', () => {
-  it('is the construction initializer of createElectronIpcTargetedSendBackend', () => {
-    expect(typeof initializeElectronIpcTargetedSendBackend).toBe('function');
+describe('populateElectronHostIpcTargetedSend', () => {
+  it('is the construction initializer of electronHostIpcTargetedSend', () => {
+    expect(typeof populateElectronHostIpcTargetedSend).toBe('function');
   });
 });