@flighthq/host-web 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-web`. The `@fli
 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-web@0.5.1-next.903.f434bc2](https://github.com/flighthq/flight/tree/f434bc233778d75aeea61995df3a8cfaec459a85/packages/host-web)
-- [License](https://github.com/flighthq/flight/blob/f434bc233778d75aeea61995df3a8cfaec459a85/LICENSE.md)
+- [Source for @flighthq/host-web@0.5.1-next.905.5fbf787](https://github.com/flighthq/flight/tree/5fbf7874064c384307542d68b4dcb6a895ff0dcf/packages/host-web)
+- [License](https://github.com/flighthq/flight/blob/5fbf7874064c384307542d68b4dcb6a895ff0dcf/LICENSE.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/host-web",
-  "version": "0.5.1-next.903.f434bc2",
+  "version": "0.5.1-next.905.5fbf787",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,40 +38,40 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/app": "0.5.1-next.903.f434bc2",
-    "@flighthq/application": "0.5.1-next.903.f434bc2",
-    "@flighthq/audio": "0.5.1-next.903.f434bc2",
-    "@flighthq/bitmap": "0.5.1-next.903.f434bc2",
-    "@flighthq/device": "0.5.1-next.903.f434bc2",
-    "@flighthq/dialog": "0.5.1-next.903.f434bc2",
-    "@flighthq/entity": "0.5.1-next.903.f434bc2",
-    "@flighthq/filesystem": "0.5.1-next.903.f434bc2",
-    "@flighthq/font": "0.5.1-next.903.f434bc2",
-    "@flighthq/geolocation": "0.5.1-next.903.f434bc2",
-    "@flighthq/glyphatlas": "0.5.1-next.903.f434bc2",
-    "@flighthq/haptics": "0.5.1-next.903.f434bc2",
-    "@flighthq/image": "0.5.1-next.903.f434bc2",
-    "@flighthq/lifecycle": "0.5.1-next.903.f434bc2",
-    "@flighthq/media": "0.5.1-next.903.f434bc2",
-    "@flighthq/menu": "0.5.1-next.903.f434bc2",
-    "@flighthq/midi": "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/render": "0.5.1-next.903.f434bc2",
-    "@flighthq/render-gl": "0.5.1-next.903.f434bc2",
-    "@flighthq/render-wgpu": "0.5.1-next.903.f434bc2",
-    "@flighthq/screen": "0.5.1-next.903.f434bc2",
-    "@flighthq/sensors": "0.5.1-next.903.f434bc2",
-    "@flighthq/socket": "0.5.1-next.903.f434bc2",
-    "@flighthq/share": "0.5.1-next.903.f434bc2",
-    "@flighthq/signals": "0.5.1-next.903.f434bc2",
-    "@flighthq/statusbar": "0.5.1-next.903.f434bc2",
-    "@flighthq/storage": "0.5.1-next.903.f434bc2",
-    "@flighthq/types": "0.5.1-next.903.f434bc2",
-    "@flighthq/useragent": "0.5.1-next.903.f434bc2",
-    "@flighthq/video": "0.5.1-next.903.f434bc2"
+    "@flighthq/app": "0.5.1-next.905.5fbf787",
+    "@flighthq/application": "0.5.1-next.905.5fbf787",
+    "@flighthq/audio": "0.5.1-next.905.5fbf787",
+    "@flighthq/bitmap": "0.5.1-next.905.5fbf787",
+    "@flighthq/device": "0.5.1-next.905.5fbf787",
+    "@flighthq/dialog": "0.5.1-next.905.5fbf787",
+    "@flighthq/entity": "0.5.1-next.905.5fbf787",
+    "@flighthq/filesystem": "0.5.1-next.905.5fbf787",
+    "@flighthq/font": "0.5.1-next.905.5fbf787",
+    "@flighthq/geolocation": "0.5.1-next.905.5fbf787",
+    "@flighthq/glyphatlas": "0.5.1-next.905.5fbf787",
+    "@flighthq/haptics": "0.5.1-next.905.5fbf787",
+    "@flighthq/image": "0.5.1-next.905.5fbf787",
+    "@flighthq/lifecycle": "0.5.1-next.905.5fbf787",
+    "@flighthq/media": "0.5.1-next.905.5fbf787",
+    "@flighthq/menu": "0.5.1-next.905.5fbf787",
+    "@flighthq/midi": "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/render": "0.5.1-next.905.5fbf787",
+    "@flighthq/render-gl": "0.5.1-next.905.5fbf787",
+    "@flighthq/render-wgpu": "0.5.1-next.905.5fbf787",
+    "@flighthq/screen": "0.5.1-next.905.5fbf787",
+    "@flighthq/sensors": "0.5.1-next.905.5fbf787",
+    "@flighthq/socket": "0.5.1-next.905.5fbf787",
+    "@flighthq/share": "0.5.1-next.905.5fbf787",
+    "@flighthq/signals": "0.5.1-next.905.5fbf787",
+    "@flighthq/statusbar": "0.5.1-next.905.5fbf787",
+    "@flighthq/storage": "0.5.1-next.905.5fbf787",
+    "@flighthq/types": "0.5.1-next.905.5fbf787",
+    "@flighthq/useragent": "0.5.1-next.905.5fbf787",
+    "@flighthq/video": "0.5.1-next.905.5fbf787"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/webAccessibility.test.ts

@@ -2,7 +2,11 @@ import { EntityRuntimeKey } from '@flighthq/types/contract';
 import type { AccessibilityNode } from '@flighthq/types/contract';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
-import { createWebAccessibilityBackend, webAccessibilityBackend } from './webAccessibility';
+import {
+  createWebAccessibilityBackend,
+  initializeWebAccessibilityBackend,
+  webAccessibilityBackend,
+} from './webAccessibility';
 import { webHost } from './webHost';
 
 afterEach(() => {
@@ -192,10 +196,9 @@ describe('createWebAccessibilityBackend', () => {
   });
 });
 
-describe('webAccessibilityBackend', () => {
-  it('is the stable Entity provider published by webHost', () => {
-    expect(EntityRuntimeKey in webAccessibilityBackend).toBe(true);
-    expect(webHost.accessibility.provider).toBe(webAccessibilityBackend);
+describe('initializeWebAccessibilityBackend', () => {
+  it('is the construction initializer of createWebAccessibilityBackend', () => {
+    expect(typeof initializeWebAccessibilityBackend).toBe('function');
   });
 });
 
@@ -206,3 +209,9 @@ function node(
 ): AccessibilityNode {
   return { id, role, ...extras };
 }
+describe('webAccessibilityBackend', () => {
+  it('is the stable Entity provider published by webHost', () => {
+    expect(EntityRuntimeKey in webAccessibilityBackend).toBe(true);
+    expect(webHost.accessibility.provider).toBe(webAccessibilityBackend);
+  });
+});

package/src/webApp.test.ts

@@ -1,7 +1,17 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { describe, expect, it, vi } from 'vitest';
 
-import { createWebAppCapabilities } from './webApp';
+import {
+  createWebAppCapabilities,
+  initializeWebAppBadgeBackend,
+  initializeWebAppCapabilities,
+  initializeWebAppFocusBackend,
+  initializeWebAppLocaleBackend,
+  initializeWebAppNameBackend,
+  initializeWebAppQuitBackend,
+  initializeWebAppReadyBackend,
+  initializeWebAppRelaunchBackend,
+} from './webApp';
 
 describe('createWebAppCapabilities', () => {
   it('creates the exact genuine web app slots as Entities', () => {
@@ -29,3 +39,50 @@ describe('createWebAppCapabilities', () => {
     expect(listener).not.toHaveBeenCalled();
   });
 });
+describe('initializeWebAppBadgeBackend', () => {
+  it('is the construction initializer of createWebAppBadgeBackend', () => {
+    expect(typeof initializeWebAppBadgeBackend).toBe('function');
+  });
+});
+
+describe('initializeWebAppCapabilities', () => {
+  it('is the construction initializer of createWebAppCapabilities', () => {
+    expect(typeof initializeWebAppCapabilities).toBe('function');
+  });
+});
+
+describe('initializeWebAppFocusBackend', () => {
+  it('is the construction initializer of createWebAppFocusBackend', () => {
+    expect(typeof initializeWebAppFocusBackend).toBe('function');
+  });
+});
+
+describe('initializeWebAppLocaleBackend', () => {
+  it('is the construction initializer of createWebAppLocaleBackend', () => {
+    expect(typeof initializeWebAppLocaleBackend).toBe('function');
+  });
+});
+
+describe('initializeWebAppNameBackend', () => {
+  it('is the construction initializer of createWebAppNameBackend', () => {
+    expect(typeof initializeWebAppNameBackend).toBe('function');
+  });
+});
+
+describe('initializeWebAppQuitBackend', () => {
+  it('is the construction initializer of createWebAppQuitBackend', () => {
+    expect(typeof initializeWebAppQuitBackend).toBe('function');
+  });
+});
+
+describe('initializeWebAppReadyBackend', () => {
+  it('is the construction initializer of createWebAppReadyBackend', () => {
+    expect(typeof initializeWebAppReadyBackend).toBe('function');
+  });
+});
+
+describe('initializeWebAppRelaunchBackend', () => {
+  it('is the construction initializer of createWebAppRelaunchBackend', () => {
+    expect(typeof initializeWebAppRelaunchBackend).toBe('function');
+  });
+});

package/src/webAudio.test.ts

@@ -1,7 +1,12 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { webAudioBackend } from './webAudio';
+import { initializeWebAudioBackend, webAudioBackend } from './webAudio';
 
+describe('initializeWebAudioBackend', () => {
+  it('is the construction initializer of createWebAudioBackend', () => {
+    expect(typeof initializeWebAudioBackend).toBe('function');
+  });
+});
 describe('webAudioBackend', () => {
   it('is an AudioBackend entity', () => {
     expect(Object.hasOwn(webAudioBackend, EntityRuntimeKey)).toBe(true);

package/src/webBitmapEncode.test.ts

@@ -3,7 +3,11 @@ import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
 import type { Bitmap, HasGraphicsBitmapEncode } from '@flighthq/types/contract';
 import { BitmapTextureSourceKind } from '@flighthq/types/contract';
 
-import { createWebBitmapEncodeBackend, webBitmapEncodeBackend } from './webBitmapEncode';
+import {
+  createWebBitmapEncodeBackend,
+  initializeWebBitmapEncodeBackend,
+  webBitmapEncodeBackend,
+} from './webBitmapEncode';
 
 function createTestBitmap(): Bitmap {
   const out = allocateEntity<Bitmap>();
@@ -36,6 +40,11 @@ describe('createWebBitmapEncodeBackend', () => {
   });
 });
 
+describe('initializeWebBitmapEncodeBackend', () => {
+  it('is the construction initializer of createWebBitmapEncodeBackend', () => {
+    expect(typeof initializeWebBitmapEncodeBackend).toBe('function');
+  });
+});
 describe('webBitmapEncodeBackend', () => {
   it('does not allocate a canvas or ImageData at import time', () => {
     const createElement = vi.spyOn(document, 'createElement');

package/src/webBitmapReadback.test.ts

@@ -3,7 +3,11 @@ import type { HasGraphicsBitmapReadback } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { vi } from 'vitest';
 
-import { createWebBitmapReadbackBackend, webBitmapReadbackBackend } from './webBitmapReadback';
+import {
+  createWebBitmapReadbackBackend,
+  initializeWebBitmapReadbackBackend,
+  webBitmapReadbackBackend,
+} from './webBitmapReadback';
 
 function hostWith(backend: HasGraphicsBitmapReadback['graphics']['bitmapReadback']): HasGraphicsBitmapReadback {
   return { graphics: { bitmapReadback: backend } } as HasGraphicsBitmapReadback;
@@ -26,6 +30,11 @@ describe('createWebBitmapReadbackBackend', () => {
   });
 });
 
+describe('initializeWebBitmapReadbackBackend', () => {
+  it('is the construction initializer of createWebBitmapReadbackBackend', () => {
+    expect(typeof initializeWebBitmapReadbackBackend).toBe('function');
+  });
+});
 describe('webBitmapReadbackBackend', () => {
   const host = hostWith(webBitmapReadbackBackend);
 

package/src/webCanvasRenderSurface.test.ts

@@ -1,6 +1,10 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createWebCanvasRenderSurfaceCreator, webCanvasRenderSurfaceCreator } from './webCanvasRenderSurface';
+import {
+  createWebCanvasRenderSurfaceCreator,
+  initializeWebCanvasRenderSurfaceCreator,
+  webCanvasRenderSurfaceCreator,
+} from './webCanvasRenderSurface';
 
 describe('createWebCanvasRenderSurfaceCreator', () => {
   it('creates a complete host Entity', () => {
@@ -32,6 +36,11 @@ describe('createWebCanvasRenderSurfaceCreator', () => {
   });
 });
 
+describe('initializeWebCanvasRenderSurfaceCreator', () => {
+  it('is the construction initializer of createWebCanvasRenderSurfaceCreator', () => {
+    expect(typeof initializeWebCanvasRenderSurfaceCreator).toBe('function');
+  });
+});
 describe('webCanvasRenderSurfaceCreator', () => {
   it('is the reusable web-host creator', () => {
     expect(webCanvasRenderSurfaceCreator[EntityRuntimeKey]).toEqual({ binding: null });

package/src/webClipboard.test.ts

@@ -1,10 +1,15 @@
 import { ClipboardFormatText, EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { webClipboardBackend } from './webClipboard';
+import { initializeWebClipboardBackend, webClipboardBackend } from './webClipboard';
 import { webHost } from './webHost';
 
 afterEach(() => vi.unstubAllGlobals());
 
+describe('initializeWebClipboardBackend', () => {
+  it('is the construction initializer of createWebClipboardBackend', () => {
+    expect(typeof initializeWebClipboardBackend).toBe('function');
+  });
+});
 describe('webClipboardBackend', () => {
   it('is the exact provider for every web clipboard capability slot', () => {
     expect(EntityRuntimeKey in webClipboardBackend).toBe(true);

package/src/webConnectivity.test.ts

@@ -1,7 +1,11 @@
 import type { ConnectivityStatus } from '@flighthq/types/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createWebConnectivityBackend, webConnectivityBackend } from './webConnectivity';
+import {
+  createWebConnectivityBackend,
+  initializeWebConnectivityBackend,
+  webConnectivityBackend,
+} from './webConnectivity';
 import { webHost } from './webHost';
 
 afterEach(() => {
@@ -88,6 +92,11 @@ describe('createWebConnectivityBackend', () => {
   });
 });
 
+describe('initializeWebConnectivityBackend', () => {
+  it('is the construction initializer of createWebConnectivityBackend', () => {
+    expect(typeof initializeWebConnectivityBackend).toBe('function');
+  });
+});
 describe('webHost connectivity', () => {
   it('publishes stable status/change/reachability slots backed by one Entity', () => {
     expect(webHost.connectivity).toEqual({

package/src/webCursor.test.ts

@@ -1,7 +1,7 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
-import { createWebCursorBackend } from './webCursor';
+import { createWebCursorBackend, initializeWebCursorBackend } from './webCursor';
 
 describe('createWebCursorBackend', () => {
   it('returns an Entity', () => {
@@ -30,3 +30,8 @@ describe('createWebCursorBackend', () => {
     expect(element.style.cursor).toBe('');
   });
 });
+describe('initializeWebCursorBackend', () => {
+  it('is the construction initializer of createWebCursorBackend', () => {
+    expect(typeof initializeWebCursorBackend).toBe('function');
+  });
+});

package/src/webDevice.test.ts

@@ -6,7 +6,12 @@ import {
 } from '@flighthq/device/contract';
 import { DeviceFormFactorDesktop, DeviceFormFactorUnknown } from '@flighthq/types/contract';
 
-import { createWebDeviceBackend, enableWebSafeAreaInsets, webDeviceBackend } from './webDevice';
+import {
+  createWebDeviceBackend,
+  enableWebSafeAreaInsets,
+  initializeWebDeviceBackend,
+  webDeviceBackend,
+} from './webDevice';
 
 describe('createWebDeviceBackend', () => {
   it('fills the snapshot with sentinels without throwing (jsdom)', () => {
@@ -107,6 +112,11 @@ describe('enableWebSafeAreaInsets', () => {
   });
 });
 
+describe('initializeWebDeviceBackend', () => {
+  it('is the construction initializer of createWebDeviceBackend', () => {
+    expect(typeof initializeWebDeviceBackend).toBe('function');
+  });
+});
 describe('webDeviceBackend', () => {
   it('is a pre-constructed singleton', () => {
     expect(webDeviceBackend).toBeDefined();

package/src/webDialog.test.ts

@@ -2,6 +2,12 @@ import { getFileDialogHandleOperations } from '@flighthq/dialog/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
 import {
+  initializeWebDirectoryOpenDialogBackend,
+  initializeWebFileOpenDialogBackend,
+  initializeWebFileSaveDialogBackend,
+  initializeWebImageOpenDialogBackend,
+  initializeWebPhotoCaptureDialogBackend,
+  initializeWebVideoCaptureDialogBackend,
   webDirectoryOpenDialogBackend,
   webFileOpenDialogBackend,
   webFileSaveDialogBackend,
@@ -28,6 +34,91 @@ describe('existing web message providers', () => {
   });
 });
 
+describe('initializeWebDirectoryOpenDialogBackend', () => {
+  it('is the construction initializer of createWebDirectoryOpenDialogBackend', () => {
+    expect(typeof initializeWebDirectoryOpenDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeWebFileOpenDialogBackend', () => {
+  it('is the construction initializer of createWebFileOpenDialogBackend', () => {
+    expect(typeof initializeWebFileOpenDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeWebFileSaveDialogBackend', () => {
+  it('is the construction initializer of createWebFileSaveDialogBackend', () => {
+    expect(typeof initializeWebFileSaveDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeWebImageOpenDialogBackend', () => {
+  it('is the construction initializer of createWebImageOpenDialogBackend', () => {
+    expect(typeof initializeWebImageOpenDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeWebPhotoCaptureDialogBackend', () => {
+  it('is the construction initializer of createWebPhotoCaptureDialogBackend', () => {
+    expect(typeof initializeWebPhotoCaptureDialogBackend).toBe('function');
+  });
+});
+
+describe('initializeWebVideoCaptureDialogBackend', () => {
+  it('is the construction initializer of createWebVideoCaptureDialogBackend', () => {
+    expect(typeof initializeWebVideoCaptureDialogBackend).toBe('function');
+  });
+});
+
+function mockImagePicker(width: number, height: number): { input: HTMLInputElement } {
+  const input = document.createElement('input');
+  const createElement = document.createElement.bind(document);
+  Object.defineProperty(input, 'files', {
+    configurable: true,
+    value: [new File(['image'], 'photo.png', { type: 'image/png' })],
+  });
+  class LoadedImage {
+    naturalHeight = height;
+    naturalWidth = width;
+    onerror: (() => void) | null = null;
+    onload: (() => void) | null = null;
+
+    set src(_value: string) {
+      queueMicrotask(() => this.onload?.());
+    }
+  }
+  vi.spyOn(document, 'createElement').mockImplementation(((tag: string) => {
+    if (tag === 'input') return input;
+    if (tag === 'img') return new LoadedImage();
+    return createElement(tag);
+  }) as typeof document.createElement);
+  return { input };
+}
+
+function fileSystemHandle(
+  name: string,
+  text: string,
+  writable?: { abort?(reason?: unknown): Promise<void>; close(): Promise<void>; write(data: unknown): Promise<void> },
+) {
+  return {
+    kind: 'file' as const,
+    name,
+    async createWritable() {
+      if (writable === undefined) throw new Error('not writable');
+      return writable;
+    },
+    async getFile() {
+      return {
+        async arrayBuffer() {
+          return new TextEncoder().encode(text).buffer;
+        },
+        async text() {
+          return text;
+        },
+      };
+    },
+  };
+}
 describe('webDirectoryOpenDialogBackend', () => {
   it('is an Entity installed in the independent directory-open slot', () => {
     expect(EntityRuntimeKey in webDirectoryOpenDialogBackend).toBe(true);
@@ -316,53 +407,3 @@ describe('webVideoCaptureDialogBackend', () => {
     });
   });
 });
-
-function mockImagePicker(width: number, height: number): { input: HTMLInputElement } {
-  const input = document.createElement('input');
-  const createElement = document.createElement.bind(document);
-  Object.defineProperty(input, 'files', {
-    configurable: true,
-    value: [new File(['image'], 'photo.png', { type: 'image/png' })],
-  });
-  class LoadedImage {
-    naturalHeight = height;
-    naturalWidth = width;
-    onerror: (() => void) | null = null;
-    onload: (() => void) | null = null;
-
-    set src(_value: string) {
-      queueMicrotask(() => this.onload?.());
-    }
-  }
-  vi.spyOn(document, 'createElement').mockImplementation(((tag: string) => {
-    if (tag === 'input') return input;
-    if (tag === 'img') return new LoadedImage();
-    return createElement(tag);
-  }) as typeof document.createElement);
-  return { input };
-}
-
-function fileSystemHandle(
-  name: string,
-  text: string,
-  writable?: { abort?(reason?: unknown): Promise<void>; close(): Promise<void>; write(data: unknown): Promise<void> },
-) {
-  return {
-    kind: 'file' as const,
-    name,
-    async createWritable() {
-      if (writable === undefined) throw new Error('not writable');
-      return writable;
-    },
-    async getFile() {
-      return {
-        async arrayBuffer() {
-          return new TextEncoder().encode(text).buffer;
-        },
-        async text() {
-          return text;
-        },
-      };
-    },
-  };
-}

package/src/webFontLoading.test.ts

@@ -1,6 +1,6 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createWebFontLoadingBackend, webFontLoadingBackend } from './webFontLoading';
+import { createWebFontLoadingBackend, initializeWebFontLoadingBackend, webFontLoadingBackend } from './webFontLoading';
 
 describe('createWebFontLoadingBackend', () => {
   it('returns an Entity', () => {
@@ -20,6 +20,11 @@ describe('createWebFontLoadingBackend', () => {
   });
 });
 
+describe('initializeWebFontLoadingBackend', () => {
+  it('is the construction initializer of createWebFontLoadingBackend', () => {
+    expect(typeof initializeWebFontLoadingBackend).toBe('function');
+  });
+});
 describe('webFontLoadingBackend', () => {
   it('is an Entity with all four operations', () => {
     expect(EntityRuntimeKey in webFontLoadingBackend).toBe(true);

package/src/webGlRenderSurface.test.ts

@@ -3,6 +3,7 @@ import * as renderGlContract from '@flighthq/render-gl/contract';
 import {
   createWebGlRenderSurfaceProvider,
   enableHostWebGlRenderSurface,
+  initializeWebGlRenderSurfaceProvider,
   resetHostWebGlRenderSurfaceForTest,
 } from './webGlRenderSurface';
 
@@ -74,6 +75,11 @@ describe('enableHostWebGlRenderSurface', () => {
   });
 });
 
+describe('initializeWebGlRenderSurfaceProvider', () => {
+  it('is the construction initializer of createWebGlRenderSurfaceProvider', () => {
+    expect(typeof initializeWebGlRenderSurfaceProvider).toBe('function');
+  });
+});
 describe('resetHostWebGlRenderSurfaceForTest', () => {
   afterEach(() => {
     resetHostWebGlRenderSurfaceForTest();

package/src/webGlyphRasterizer.test.ts

@@ -1,7 +1,11 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
-import { createWebGlyphRasterizerBackend, webGlyphRasterizerBackend } from './webGlyphRasterizer';
+import {
+  createWebGlyphRasterizerBackend,
+  initializeWebGlyphRasterizerBackend,
+  webGlyphRasterizerBackend,
+} from './webGlyphRasterizer';
 
 describe('createWebGlyphRasterizerBackend', () => {
   it('constructs a backend with rasterize and measureMetrics', () => {
@@ -41,6 +45,11 @@ describe('createWebGlyphRasterizerBackend', () => {
   });
 });
 
+describe('initializeWebGlyphRasterizerBackend', () => {
+  it('is the construction initializer of createWebGlyphRasterizerBackend', () => {
+    expect(typeof initializeWebGlyphRasterizerBackend).toBe('function');
+  });
+});
 describe('webGlyphRasterizerBackend', () => {
   it('is an Entity with rasterize and measureMetrics', () => {
     expect(EntityRuntimeKey in webGlyphRasterizerBackend).toBe(true);

package/src/webHaptics.test.ts

@@ -1,5 +1,10 @@
-import { webHapticsBackend } from './webHaptics';
+import { initializeWebHapticsBackend, webHapticsBackend } from './webHaptics';
 
+describe('initializeWebHapticsBackend', () => {
+  it('is the construction initializer of createWebHapticsBackend', () => {
+    expect(typeof initializeWebHapticsBackend).toBe('function');
+  });
+});
 describe('webHapticsBackend', () => {
   it('reports unsupported and refuses every operation when navigator.vibrate is absent', () => {
     // jsdom has no Vibration API, which is the branch every desktop browser also takes. The backend must

package/src/webImage.test.ts

@@ -1,7 +1,7 @@
 import type { Bitmap, HasGraphicsImage } from '@flighthq/types/contract';
 import { BitmapTextureSourceKind } from '@flighthq/types/contract';
 
-import { createWebImageBackend, webImageBackend } from './webImage';
+import { createWebImageBackend, initializeWebImageBackend, webImageBackend } from './webImage';
 
 function hostWith(backend = webImageBackend): HasGraphicsImage {
   return { graphics: { image: backend } } as HasGraphicsImage;
@@ -17,6 +17,24 @@ describe('createWebImageBackend', () => {
   });
 });
 
+describe('initializeWebImageBackend', () => {
+  it('is the construction initializer of createWebImageBackend', () => {
+    expect(typeof initializeWebImageBackend).toBe('function');
+  });
+});
+
+function createTestBitmap(): Bitmap {
+  return {
+    alphaType: 'straight',
+    gamut: 'srgb',
+    data: new Uint8ClampedArray(4),
+    format: 'rgba8unorm',
+    height: 1,
+    kind: BitmapTextureSourceKind,
+    version: 0,
+    width: 1,
+  } as Bitmap;
+}
 describe('webImageBackend', () => {
   afterEach(() => {
     vi.restoreAllMocks();
@@ -33,16 +51,3 @@ describe('webImageBackend', () => {
     expect(webImageBackend.createImageFromBitmap).toBeDefined();
   });
 });
-
-function createTestBitmap(): Bitmap {
-  return {
-    alphaType: 'straight',
-    gamut: 'srgb',
-    data: new Uint8ClampedArray(4),
-    format: 'rgba8unorm',
-    height: 1,
-    kind: BitmapTextureSourceKind,
-    version: 0,
-    width: 1,
-  } as Bitmap;
-}

package/src/webInputTarget.test.ts

@@ -6,6 +6,7 @@ import type { EntityWithoutRuntime, HasInputPointerLock, InputPointerLockBackend
 import { webHost } from './webHost';
 import {
   createWebInputTargetHandle,
+  initializeWebInputTargetHandle,
   resetWebInputTargetBackendForTest,
   webInputDropFileBackend,
   webInputFocusBackend,
@@ -34,6 +35,12 @@ describe('createWebInputTargetHandle', () => {
   });
 });
 
+describe('initializeWebInputTargetHandle', () => {
+  it('is the construction initializer of createWebInputTargetHandle', () => {
+    expect(typeof initializeWebInputTargetHandle).toBe('function');
+  });
+});
+
 describe('resetWebInputTargetBackendForTest', () => {
   it('forgets existing target bindings', () => {
     const element = document.createElement('div');
@@ -414,7 +421,6 @@ describe('webRenderContextBackend', () => {
     expect(listener).not.toHaveBeenCalled();
   });
 });
-
 describe('webRenderSurfaceBackend', () => {
   it('sizes a bound canvas backing store and leaves a non-canvas target inert', () => {
     const canvas = document.createElement('canvas');

package/src/webKeyboard.test.ts

@@ -4,6 +4,9 @@ import {
   createWebSoftKeyboardChangeBackend,
   createWebSoftKeyboardInfoBackend,
   createWebSoftKeyboardVisibilityBackend,
+  initializeWebSoftKeyboardChangeBackend,
+  initializeWebSoftKeyboardInfoBackend,
+  initializeWebSoftKeyboardVisibilityBackend,
 } from './webKeyboard';
 
 type VirtualKeyboardStub = {
@@ -214,3 +217,20 @@ describe('createWebSoftKeyboardVisibilityBackend', () => {
     expect(await backend.hide()).toBe('operation-failed');
   });
 });
+describe('initializeWebSoftKeyboardChangeBackend', () => {
+  it('is the construction initializer of createWebSoftKeyboardChangeBackend', () => {
+    expect(typeof initializeWebSoftKeyboardChangeBackend).toBe('function');
+  });
+});
+
+describe('initializeWebSoftKeyboardInfoBackend', () => {
+  it('is the construction initializer of createWebSoftKeyboardInfoBackend', () => {
+    expect(typeof initializeWebSoftKeyboardInfoBackend).toBe('function');
+  });
+});
+
+describe('initializeWebSoftKeyboardVisibilityBackend', () => {
+  it('is the construction initializer of createWebSoftKeyboardVisibilityBackend', () => {
+    expect(typeof initializeWebSoftKeyboardVisibilityBackend).toBe('function');
+  });
+});

package/src/webMediasession.test.ts

@@ -6,6 +6,8 @@ import { webHost } from './webHost';
 import {
   createWebMediaSessionActionBackend,
   createWebMediaSessionBackend,
+  initializeWebMediaSessionActionBackend,
+  initializeWebMediaSessionBackend,
   webMediaSessionActionBackend,
   webMediaSessionBackend,
 } from './webMediasession';
@@ -278,6 +280,17 @@ describe('createWebMediaSessionBackend', () => {
   });
 });
 
+describe('initializeWebMediaSessionActionBackend', () => {
+  it('is the construction initializer of createWebMediaSessionActionBackend', () => {
+    expect(typeof initializeWebMediaSessionActionBackend).toBe('function');
+  });
+});
+
+describe('initializeWebMediaSessionBackend', () => {
+  it('is the construction initializer of createWebMediaSessionBackend', () => {
+    expect(typeof initializeWebMediaSessionBackend).toBe('function');
+  });
+});
 describe('web media-session command ownership', () => {
   it('releases only lanes it published and never touches action handlers', () => {
     const session = installFakeMediaSession();

package/src/webMenu.test.ts

@@ -1,6 +1,23 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { webMenuHighlightBackend, webMenuPopupBackend } from './webMenu';
+import {
+  initializeWebMenuHighlightBackend,
+  initializeWebMenuPopupBackend,
+  webMenuHighlightBackend,
+  webMenuPopupBackend,
+} from './webMenu';
+
+describe('initializeWebMenuHighlightBackend', () => {
+  it('is the construction initializer of createWebMenuHighlightBackend', () => {
+    expect(typeof initializeWebMenuHighlightBackend).toBe('function');
+  });
+});
+
+describe('initializeWebMenuPopupBackend', () => {
+  it('is the construction initializer of createWebMenuPopupBackend', () => {
+    expect(typeof initializeWebMenuPopupBackend).toBe('function');
+  });
+});
 
 describe('webMenuHighlightBackend', () => {
   it('is an Entity provider', () => {
@@ -27,7 +44,6 @@ describe('webMenuHighlightBackend', () => {
     expect(() => unsubscribeSecond()).not.toThrow();
   });
 });
-
 describe('webMenuPopupBackend', () => {
   it('is an Entity provider', () => {
     expect(EntityRuntimeKey in webMenuPopupBackend).toBe(true);

package/src/webMidi.test.ts

@@ -5,6 +5,13 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { webHost } from './webHost';
 import * as webMidi from './webMidi';
+import {
+  initializeWebMidiAccessBackend,
+  initializeWebMidiAccessCapabilities,
+  initializeWebMidiEventAttachment,
+  initializeWebMidiPermissionAccessCapabilities,
+  initializeWebMidiPermissionBackend,
+} from './webMidi';
 
 describe('createWebMidiAccessCapabilities', () => {
   it('constructs only the access profile and requests basic MIDI with zero options', async () => {
@@ -120,9 +127,9 @@ describe('createWebMidiPermissionAccessCapabilities', () => {
   });
 });
 
-describe('webHost midi', () => {
-  it('is structurally empty and cannot acquire hardware in default construction', () => {
-    expect((webHost as unknown as { midi: object }).midi).toEqual({});
+describe('initializeWebMidiAccessBackend', () => {
+  it('is the construction initializer of createWebMidiAccessBackend', () => {
+    expect(typeof initializeWebMidiAccessBackend).toBe('function');
   });
 });
 
@@ -226,3 +233,32 @@ function requiredWebFunction(name: string): (...args: any[]) => any {
   if (typeof value !== 'function') throw new TypeError(`${name} is not exported`);
   return value as (...args: any[]) => any;
 }
+describe('initializeWebMidiAccessCapabilities', () => {
+  it('is the construction initializer of createWebMidiAccessCapabilities', () => {
+    expect(typeof initializeWebMidiAccessCapabilities).toBe('function');
+  });
+});
+
+describe('initializeWebMidiEventAttachment', () => {
+  it('is the construction initializer of createWebMidiEventAttachment', () => {
+    expect(typeof initializeWebMidiEventAttachment).toBe('function');
+  });
+});
+
+describe('initializeWebMidiPermissionAccessCapabilities', () => {
+  it('is the construction initializer of createWebMidiPermissionAccessCapabilities', () => {
+    expect(typeof initializeWebMidiPermissionAccessCapabilities).toBe('function');
+  });
+});
+
+describe('initializeWebMidiPermissionBackend', () => {
+  it('is the construction initializer of createWebMidiPermissionBackend', () => {
+    expect(typeof initializeWebMidiPermissionBackend).toBe('function');
+  });
+});
+
+describe('webHost midi', () => {
+  it('is structurally empty and cannot acquire hardware in default construction', () => {
+    expect((webHost as unknown as { midi: object }).midi).toEqual({});
+  });
+});

package/src/webNet.test.ts

@@ -1,7 +1,7 @@
 import { createSignal } from '@flighthq/signals/contract';
 import type { NetProgress, NetRequest } from '@flighthq/types/contract';
 
-import { createWebNetBackend, webNetBackend } from './webNet';
+import { createWebNetBackend, initializeWebNetBackend, webNetBackend } from './webNet';
 
 interface FakeResponseInit {
   status?: number;
@@ -276,6 +276,11 @@ describe('createWebNetBackend', () => {
   });
 });
 
+describe('initializeWebNetBackend', () => {
+  it('is the construction initializer of createWebNetBackend', () => {
+    expect(typeof initializeWebNetBackend).toBe('function');
+  });
+});
 describe('webNetBackend', () => {
   it('is a pre-instantiated NetBackend const', () => {
     expect(webNetBackend).not.toBeNull();

package/src/webNotification.test.ts

@@ -7,7 +7,7 @@ import type {
   WebPageNotificationInstance,
 } from '@flighthq/types/contract';
 
-import { createWebPageNotificationCapabilities } from './webNotification';
+import { createWebPageNotificationCapabilities, initializeWebPageNotificationCapabilities } from './webNotification';
 
 interface FakeWebNotification extends WebPageNotificationInstance {
   options?: Readonly<WebNotificationOptions>;
@@ -108,3 +108,8 @@ describe('createWebPageNotificationCapabilities', () => {
     expect(secondCloses).toBe(2);
   });
 });
+describe('initializeWebPageNotificationCapabilities', () => {
+  it('is the construction initializer of createWebPageNotificationCapabilities', () => {
+    expect(typeof initializeWebPageNotificationCapabilities).toBe('function');
+  });
+});

package/src/webPlatform.test.ts

@@ -1,6 +1,6 @@
 import { createPlatformInfo } from '@flighthq/platform/contract';
 
-import { createWebPlatformBackend, webPlatformBackend } from './webPlatform';
+import { createWebPlatformBackend, initializeWebPlatformBackend, webPlatformBackend } from './webPlatform';
 
 describe('createWebPlatformBackend', () => {
   it('produces a backend that fills the out info', () => {
@@ -55,6 +55,12 @@ describe('createWebPlatformBackend', () => {
   });
 });
 
+describe('initializeWebPlatformBackend', () => {
+  it('is the construction initializer of createWebPlatformBackend', () => {
+    expect(typeof initializeWebPlatformBackend).toBe('function');
+  });
+});
+
 describe('web backend UA detection', () => {
   function withUserAgent(ua: string, fn: () => void): void {
     const original = navigator.userAgent;
@@ -300,7 +306,6 @@ describe('web backend UA detection', () => {
     });
   });
 });
-
 describe('webPlatformBackend', () => {
   it('is a pre-constructed singleton', () => {
     expect(webPlatformBackend).toBeDefined();

package/src/webPower.test.ts

@@ -2,6 +2,10 @@ import { EntityRuntimeKey } from '@flighthq/types/contract';
 
 import {
   createWebPowerReadings,
+  initializeWebPowerCapabilities,
+  initializeWebPowerKeepAwakeBackend,
+  initializeWebPowerReadings,
+  initializeWebPowerSuspensionBackend,
   webPowerCapabilities,
   webPowerKeepAwakeBackend,
   webPowerSuspensionBackend,
@@ -76,6 +80,29 @@ describe('createWebPowerReadings status', () => {
   });
 });
 
+describe('initializeWebPowerCapabilities', () => {
+  it('is the construction initializer of createWebPowerCapabilities', () => {
+    expect(typeof initializeWebPowerCapabilities).toBe('function');
+  });
+});
+
+describe('initializeWebPowerKeepAwakeBackend', () => {
+  it('is the construction initializer of createWebPowerKeepAwakeBackend', () => {
+    expect(typeof initializeWebPowerKeepAwakeBackend).toBe('function');
+  });
+});
+
+describe('initializeWebPowerReadings', () => {
+  it('is the construction initializer of createWebPowerReadings', () => {
+    expect(typeof initializeWebPowerReadings).toBe('function');
+  });
+});
+describe('initializeWebPowerSuspensionBackend', () => {
+  it('is the construction initializer of createWebPowerSuspensionBackend', () => {
+    expect(typeof initializeWebPowerSuspensionBackend).toBe('function');
+  });
+});
+
 describe('webPowerCapabilities', () => {
   // ★ EXACT SLOT COVERAGE for W. The four absent slots are the point: web previously implemented all of
   // them with inert subscriptions and constant sentinels, which no structural probe could tell from a

package/src/webProtocol.test.ts

@@ -1,7 +1,12 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { describe, expect, it, vi } from 'vitest';
 
-import { createWebProtocolCapabilities } from './webProtocol';
+import {
+  createWebProtocolCapabilities,
+  initializeWebProtocolCapabilities,
+  initializeWebProtocolLaunchBackend,
+  initializeWebProtocolRegistrationBackend,
+} from './webProtocol';
 
 describe('createWebProtocolCapabilities', () => {
   it('creates only launch and registration as Entities', () => {
@@ -21,3 +26,20 @@ describe('createWebProtocolCapabilities', () => {
     expect(registerProtocolHandler).toHaveBeenCalledExactlyOnceWith('flight', location.origin + '/?url=%s');
   });
 });
+describe('initializeWebProtocolCapabilities', () => {
+  it('is the construction initializer of createWebProtocolCapabilities', () => {
+    expect(typeof initializeWebProtocolCapabilities).toBe('function');
+  });
+});
+
+describe('initializeWebProtocolLaunchBackend', () => {
+  it('is the construction initializer of createWebProtocolLaunchBackend', () => {
+    expect(typeof initializeWebProtocolLaunchBackend).toBe('function');
+  });
+});
+
+describe('initializeWebProtocolRegistrationBackend', () => {
+  it('is the construction initializer of createWebProtocolRegistrationBackend', () => {
+    expect(typeof initializeWebProtocolRegistrationBackend).toBe('function');
+  });
+});

package/src/webRaster2DSurface.test.ts

@@ -1,6 +1,10 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { createWebRaster2DSurfaceProvider, webRaster2DSurfaceProvider } from './webRaster2DSurface';
+import {
+  createWebRaster2DSurfaceProvider,
+  initializeWebRaster2DSurfaceProvider,
+  webRaster2DSurfaceProvider,
+} from './webRaster2DSurface';
 
 describe('createWebRaster2DSurfaceProvider', () => {
   it('returns an Entity', () => {
@@ -45,6 +49,11 @@ describe('createWebRaster2DSurfaceProvider', () => {
   });
 });
 
+describe('initializeWebRaster2DSurfaceProvider', () => {
+  it('is the construction initializer of createWebRaster2DSurfaceProvider', () => {
+    expect(typeof initializeWebRaster2DSurfaceProvider).toBe('function');
+  });
+});
 describe('webRaster2DSurfaceProvider', () => {
   it('is an Entity', () => {
     expect(EntityRuntimeKey in webRaster2DSurfaceProvider).toBe(true);

package/src/webScreen.test.ts

@@ -2,7 +2,7 @@ import { createScreenInfo } from '@flighthq/screen/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
-import { createWebScreenCapabilities } from './webScreen';
+import { createWebScreenCapabilities, initializeWebScreenCapabilities } from './webScreen';
 
 afterEach(() => vi.restoreAllMocks());
 
@@ -63,3 +63,8 @@ describe('createWebScreenCapabilities', () => {
     }
   });
 });
+describe('initializeWebScreenCapabilities', () => {
+  it('is the construction initializer of createWebScreenCapabilities', () => {
+    expect(typeof initializeWebScreenCapabilities).toBe('function');
+  });
+});

package/src/webServiceWorkerNotification.test.ts

@@ -9,6 +9,7 @@ import type {
 
 import {
   createWebServiceWorkerNotificationCapabilities,
+  initializeWebServiceWorkerNotificationCapabilities,
   notifyWebServiceWorkerNotificationEvent,
 } from './webServiceWorkerNotification';
 
@@ -112,6 +113,11 @@ describe('createWebServiceWorkerNotificationCapabilities', () => {
   });
 });
 
+describe('initializeWebServiceWorkerNotificationCapabilities', () => {
+  it('is the construction initializer of createWebServiceWorkerNotificationCapabilities', () => {
+    expect(typeof initializeWebServiceWorkerNotificationCapabilities).toBe('function');
+  });
+});
 describe('notifyWebServiceWorkerNotificationEvent', () => {
   it('routes real action/click/close events without fabricating reply', async () => {
     const { api } = fakeServiceWorker();

package/src/webShare.test.ts

@@ -1,10 +1,26 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
 import { webHost } from './webHost';
-import { webShareContentBackend, webShareFilesBackend } from './webShare';
+import {
+  initializeWebShareContentBackend,
+  initializeWebShareFilesBackend,
+  webShareContentBackend,
+  webShareFilesBackend,
+} from './webShare';
 
 afterEach(() => vi.unstubAllGlobals());
 
+describe('initializeWebShareContentBackend', () => {
+  it('is the construction initializer of createWebShareContentBackend', () => {
+    expect(typeof initializeWebShareContentBackend).toBe('function');
+  });
+});
+describe('initializeWebShareFilesBackend', () => {
+  it('is the construction initializer of createWebShareFilesBackend', () => {
+    expect(typeof initializeWebShareFilesBackend).toBe('function');
+  });
+});
+
 describe('Web Share providers', () => {
   it('are Entity-composed and exposed through their honest host slots', () => {
     expect(EntityRuntimeKey in webShareContentBackend).toBe(true);

package/src/webShell.test.ts

@@ -1,9 +1,14 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
-import { webShellExternalBackend } from './webShell';
+import { initializeWebShellExternalBackend, webShellExternalBackend } from './webShell';
 
 afterEach(() => vi.unstubAllGlobals());
 
+describe('initializeWebShellExternalBackend', () => {
+  it('is the construction initializer of createWebShellExternalBackend', () => {
+    expect(typeof initializeWebShellExternalBackend).toBe('function');
+  });
+});
 describe('webShellExternalBackend', () => {
   it('is a stable Entity', () => {
     expect(EntityRuntimeKey in webShellExternalBackend).toBe(true);

package/src/webStorage.test.ts

@@ -1,7 +1,7 @@
 import { EntityRuntimeKey } from '@flighthq/types/contract';
 
 import { webHost } from './webHost';
-import { webStorageBackend } from './webStorage';
+import { initializeWebStorageBackend, webStorageBackend } from './webStorage';
 
 function namedError(name: string): Error {
   const error = new Error(name);
@@ -9,6 +9,11 @@ function namedError(name: string): Error {
   return error;
 }
 
+describe('initializeWebStorageBackend', () => {
+  it('is the construction initializer of createWebStorageBackend', () => {
+    expect(typeof initializeWebStorageBackend).toBe('function');
+  });
+});
 describe('webStorageBackend', () => {
   beforeEach(() => localStorage.clear());
   afterEach(() => vi.restoreAllMocks());

package/src/webStoragePersistence.test.ts

@@ -8,6 +8,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 import {
   createWebWindowStoragePersistenceCapabilities,
   createWebWorkerStoragePersistenceCapabilities,
+  initializeWebWorkerStoragePersistenceCapabilities,
 } from './webStoragePersistence';
 
 describe('createWebWindowStoragePersistenceCapabilities', () => {
@@ -159,3 +160,8 @@ function windowApi(options: Readonly<FakeOptions> = {}) {
   const api: WebWindowStoragePersistenceApi = { ...worker.api, persist };
   return { ...worker, api, persist };
 }
+describe('initializeWebWorkerStoragePersistenceCapabilities', () => {
+  it('is the construction initializer of createWebWorkerStoragePersistenceCapabilities', () => {
+    expect(typeof initializeWebWorkerStoragePersistenceCapabilities).toBe('function');
+  });
+});

package/src/webVideoCapability.test.ts

@@ -2,7 +2,11 @@ import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { canPlayVideoType } from '@flighthq/video/contract';
 import { describe, expect, it, vi } from 'vitest';
 
-import { createWebVideoCapabilityBackend, webVideoCapabilityBackend } from './webVideoCapability';
+import {
+  createWebVideoCapabilityBackend,
+  initializeWebVideoCapabilityBackend,
+  webVideoCapabilityBackend,
+} from './webVideoCapability';
 
 describe('createWebVideoCapabilityBackend', () => {
   it('constructs a backend with canPlayType and createVideoElement', () => {
@@ -47,6 +51,11 @@ describe('createWebVideoCapabilityBackend', () => {
   });
 });
 
+describe('initializeWebVideoCapabilityBackend', () => {
+  it('is the construction initializer of createWebVideoCapabilityBackend', () => {
+    expect(typeof initializeWebVideoCapabilityBackend).toBe('function');
+  });
+});
 describe('webVideoCapabilityBackend', () => {
   it('is an Entity with canPlayType and createVideoElement', () => {
     expect(EntityRuntimeKey in webVideoCapabilityBackend).toBe(true);

package/src/webWgpuRenderSurface.test.ts

@@ -6,6 +6,7 @@ import type { GlRenderSurfaceProvider, WgpuRenderSurfaceProvider } from '@flight
 import {
   createWebWgpuRenderSurfaceProvider,
   enableHostWebWgpuRenderSurface,
+  initializeWebWgpuRenderSurfaceProvider,
   resetHostWebWgpuRenderSurfaceForTest,
 } from './webWgpuRenderSurface';
 
@@ -139,6 +140,11 @@ describe('GL and WGPU surface provider independence', () => {
   });
 });
 
+describe('initializeWebWgpuRenderSurfaceProvider', () => {
+  it('is the construction initializer of createWebWgpuRenderSurfaceProvider', () => {
+    expect(typeof initializeWebWgpuRenderSurfaceProvider).toBe('function');
+  });
+});
 describe('resetHostWebWgpuRenderSurfaceForTest', () => {
   afterEach(() => {
     resetHostWebWgpuRenderSurfaceForTest();

package/src/webWindow.test.ts

@@ -5,6 +5,8 @@ import { webHost } from './webHost';
 import {
   createWebFullscreenTargetHandle,
   createWebWindowResizeTargetHandle,
+  initializeWebFullscreenTargetHandle,
+  initializeWebWindowResizeTargetHandle,
   resetWebWindowBackendForTest,
   webFullscreenBackend,
   webWindowBackend,
@@ -47,6 +49,18 @@ describe('createWebWindowResizeTargetHandle', () => {
   });
 });
 
+describe('initializeWebFullscreenTargetHandle', () => {
+  it('is the construction initializer of createWebFullscreenTargetHandle', () => {
+    expect(typeof initializeWebFullscreenTargetHandle).toBe('function');
+  });
+});
+
+describe('initializeWebWindowResizeTargetHandle', () => {
+  it('is the construction initializer of createWebWindowResizeTargetHandle', () => {
+    expect(typeof initializeWebWindowResizeTargetHandle).toBe('function');
+  });
+});
+
 describe('resetWebWindowBackendForTest', () => {
   it('clears fullscreen targets and subscribed listeners', async () => {
     const element = document.createElement('div');
@@ -62,7 +76,6 @@ describe('resetWebWindowBackendForTest', () => {
     expect(callback).not.toHaveBeenCalled();
   });
 });
-
 describe('webFullscreenBackend', () => {
   it('requests fullscreen for the arbitrary element carried by the opaque handle', async () => {
     const element = document.createElement('div');