@effindomv2/runtime 0.1.0

package/src/bridge/utils/backends.ts

@@ -0,0 +1,163 @@
+import { EdBackendType, EdDeviceState } from '../../core-types';
+import type { BridgeLoaderInfo, CoreModule, EdBackendType as EdBackendTypeValue } from '../../core-types';
+import { normalizeBackendType, normalizeDeviceState } from './encoding';
+
+const WEBGPU_INIT_TIMEOUT_MS = 1_500;
+
+// TEMPORARY: keep WebGPU disabled from the bridge until resize/device-loss stability
+// issues are resolved. Default to WebGL2 with software fallback.
+export const DEFAULT_BACKEND_LADDER = [EdBackendType.WEBGL2, EdBackendType.CPU] as const;
+
+export function backendTypeToRenderer(backendType: EdBackendTypeValue): BridgeLoaderInfo['activeRenderer'] {
+  switch (backendType) {
+    case EdBackendType.WEBGPU:
+      return 'webgpu';
+    case EdBackendType.WEBGL2:
+      return 'webgl2';
+    case EdBackendType.CPU:
+      return 'cpu';
+    default:
+      return 'none';
+  }
+}
+
+export function setActiveRenderer(loaderInfo: BridgeLoaderInfo, backendType: EdBackendTypeValue): void {
+  loaderInfo.activeRenderer = backendTypeToRenderer(backendType);
+  window.__bridgeLoaderInfo = loaderInfo;
+}
+
+async function waitForAnimationFrame(): Promise<void> {
+  await new Promise<void>((resolve) => {
+    requestAnimationFrame(() => {
+      resolve();
+    });
+  });
+}
+
+export async function waitForWebGpuInit(core: CoreModule): Promise<EdBackendTypeValue> {
+  const deadline = performance.now() + WEBGPU_INIT_TIMEOUT_MS;
+  while (performance.now() < deadline) {
+    const backendType = normalizeBackendType(core._ed_get_backend_type());
+    const deviceState = normalizeDeviceState(core._ed_get_device_state());
+    if (backendType === EdBackendType.WEBGPU) {
+      return backendType;
+    }
+    if (deviceState !== EdDeviceState.RECOVERING) {
+      return backendType;
+    }
+    await waitForAnimationFrame();
+  }
+  return normalizeBackendType(core._ed_get_backend_type());
+}
+
+export async function probeWebGpuAdapter(): Promise<boolean> {
+  const nav = navigator as Navigator & { gpu?: { requestAdapter?: () => Promise<unknown> } };
+  if (nav.gpu?.requestAdapter === undefined) {
+    return false;
+  }
+  try {
+    const adapter = await nav.gpu.requestAdapter();
+    return adapter !== null && adapter !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+export function backendLabel(backend: EdBackendTypeValue): string {
+  if (backend === EdBackendType.WEBGPU) return 'WebGPU';
+  if (backend === EdBackendType.WEBGL2) return 'WebGL2';
+  if (backend === EdBackendType.CPU) return 'Software/Raster';
+  return 'None';
+}
+
+// Attempts to initialise exactly one backend. Returns true on success.
+// Safe to call after a device loss — wraps all init calls in try/catch.
+export async function tryReviveBackend(
+  core: CoreModule,
+  canvas: HTMLCanvasElement,
+  dpr: number,
+  backend: EdBackendTypeValue,
+): Promise<boolean> {
+  const w = canvas.width;
+  const h = canvas.height;
+  try {
+    if (backend === EdBackendType.WEBGPU) {
+      if (!await probeWebGpuAdapter()) return false;
+      core._ed_init(w, h, dpr);
+      return await waitForWebGpuInit(core) === EdBackendType.WEBGPU;
+    }
+    if (backend === EdBackendType.WEBGL2) {
+      core._ed_init_webgl(w, h, dpr);
+      return normalizeBackendType(core._ed_get_backend_type()) === EdBackendType.WEBGL2;
+    }
+    core._ed_init_sw(w, h, dpr);
+    return normalizeBackendType(core._ed_get_backend_type()) === EdBackendType.CPU;
+  } catch {
+    return false;
+  }
+}
+
+export async function initRenderer(
+  core: CoreModule,
+  canvas: HTMLCanvasElement,
+  dpr: number,
+  loaderInfo: BridgeLoaderInfo,
+  backendLadder: readonly EdBackendTypeValue[] = DEFAULT_BACKEND_LADDER,
+): Promise<EdBackendTypeValue> {
+  const physicalWidth = canvas.width;
+  const physicalHeight = canvas.height;
+  const ladder = backendLadder.length > 0 ? backendLadder : DEFAULT_BACKEND_LADDER;
+  const firstBackend = ladder[0] ?? EdBackendType.WEBGPU;
+  let webGpuAttempted = false;
+  let webGl2Attempted = false;
+
+  for (const backend of ladder) {
+    if (backend === EdBackendType.WEBGPU) {
+      // Probe the adapter before calling ed_init. On platforms like Ubuntu where
+      // navigator.gpu exists but has no adapter (Vulkan blocklist, no GPU, etc.),
+      // requestAdapter() returns null. Calling ed_init without checking locks the
+      // canvas to a WebGPU context (even on failure), preventing WebGL2 init.
+      if (!await probeWebGpuAdapter()) {
+        continue;
+      }
+      webGpuAttempted = true;
+      core._ed_init(physicalWidth, physicalHeight, dpr);
+      const resolvedBackend = await waitForWebGpuInit(core);
+      if (resolvedBackend === EdBackendType.WEBGPU) {
+        setActiveRenderer(loaderInfo, resolvedBackend);
+        return resolvedBackend;
+      }
+      continue;
+    }
+
+    if (backend === EdBackendType.WEBGL2) {
+      webGl2Attempted = true;
+      core._ed_init_webgl(physicalWidth, physicalHeight, dpr);
+      if (normalizeBackendType(core._ed_get_backend_type()) === EdBackendType.WEBGL2) {
+        if (webGpuAttempted || firstBackend === EdBackendType.WEBGPU) {
+          console.warn('RENDERER FALLBACK: WebGPU failed to initialize or unavailable! Fell back to WebGL2');
+        }
+        setActiveRenderer(loaderInfo, EdBackendType.WEBGL2);
+        return EdBackendType.WEBGL2;
+      }
+      continue;
+    }
+
+    core._ed_init_sw(physicalWidth, physicalHeight, dpr);
+    if (normalizeBackendType(core._ed_get_backend_type()) === EdBackendType.CPU) {
+      const triedBackends = [
+        webGpuAttempted ? 'WebGPU' : null,
+        webGl2Attempted ? 'WebGL2' : null,
+      ].filter(Boolean).join(' and ');
+      const reason = triedBackends.length > 0
+        ? `${triedBackends} failed to initialize or unavailable!`
+        : 'No GPU backend available.';
+      console.error(`RENDERER FALLBACK: ${reason} Fell back to Software/Raster - performance will be painfully slow`);
+      setActiveRenderer(loaderInfo, EdBackendType.CPU);
+      return EdBackendType.CPU;
+    }
+  }
+
+  setActiveRenderer(loaderInfo, EdBackendType.NONE);
+  throw new Error('Failed to initialize any renderer backend.');
+}

package/src/bridge/utils/encoding.ts

@@ -0,0 +1,128 @@
+import { EdBackendType, EdDeviceState } from '../../core-types';
+import type {
+  CoreModule,
+  EdBackendType as EdBackendTypeValue,
+  EdDeviceState as EdDeviceStateValue,
+  UiModule,
+  WasmHandleLike,
+} from '../../core-types';
+
+export type WasmModuleMemoryView = Pick<UiModule | CoreModule, 'usesMemory64'>;
+
+function extractHandlePrimitive(handle: WasmHandleLike): bigint | number | string {
+  if (typeof handle === 'bigint' || typeof handle === 'number' || typeof handle === 'string') {
+    return handle;
+  }
+  const symbolPrimitive = (handle as { [Symbol.toPrimitive]?: (hint: string) => unknown })[Symbol.toPrimitive]?.('default');
+  if (
+    typeof symbolPrimitive === 'bigint' ||
+    typeof symbolPrimitive === 'number' ||
+    typeof symbolPrimitive === 'string'
+  ) {
+    return symbolPrimitive;
+  }
+  const primitive = handle.valueOf();
+  if (typeof primitive === 'bigint' || typeof primitive === 'number' || typeof primitive === 'string') {
+    return primitive;
+  }
+  const stringified = handle.toString();
+  if (typeof stringified === 'string') {
+    return stringified;
+  }
+  throw new TypeError(`Cannot convert ${String(handle)} to BigInt.`);
+}
+
+export function handleToBigInt(handle: WasmHandleLike): bigint {
+  const primitive = extractHandlePrimitive(handle);
+  if (typeof primitive === 'bigint') {
+    return primitive;
+  }
+  if (typeof primitive === 'number') {
+    if (!Number.isInteger(primitive)) {
+      throw new TypeError(`Cannot convert non-integer handle ${String(primitive)} to BigInt.`);
+    }
+    return BigInt(primitive);
+  }
+  if (typeof primitive === 'string') {
+    return BigInt(primitive);
+  }
+  throw new TypeError(`Cannot convert ${String(handle)} to BigInt.`);
+}
+
+export function handleToString(handle: WasmHandleLike): string {
+  return handleToBigInt(handle).toString();
+}
+
+export function pointerToHeapOffset(pointer: WasmHandleLike): number {
+  if (typeof pointer === 'number') {
+    if (!Number.isInteger(pointer)) {
+      throw new TypeError(`Cannot convert non-integer pointer ${String(pointer)} to a heap offset.`);
+    }
+    return pointer;
+  }
+  const value = handleToBigInt(pointer);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError(`Pointer ${value.toString()} exceeds JavaScript heap offset precision.`);
+  }
+  return Number(value);
+}
+
+export function normalizePointerForWasm(
+  module: WasmModuleMemoryView,
+  pointer: WasmHandleLike,
+): number | bigint {
+  return module.usesMemory64 === true ? handleToBigInt(pointer) : pointerToHeapOffset(pointer);
+}
+
+export function toHeapPointer(
+  module: WasmModuleMemoryView,
+  pointer: WasmHandleLike,
+): { readonly ptr: number | bigint; readonly offset: number } {
+  const ptr = normalizePointerForWasm(module, pointer);
+  return {
+    ptr,
+    offset: pointerToHeapOffset(ptr),
+  };
+}
+
+export function normalizeBackendType(value: number): EdBackendTypeValue {
+  switch (value) {
+    case EdBackendType.WEBGPU:
+    case EdBackendType.WEBGL2:
+    case EdBackendType.CPU:
+      return value;
+    default:
+      return EdBackendType.NONE;
+  }
+}
+
+export function normalizeDeviceState(value: number): EdDeviceStateValue {
+  switch (value) {
+    case EdDeviceState.LOST:
+    case EdDeviceState.RECOVERING:
+      return value;
+    default:
+      return EdDeviceState.OK;
+  }
+}
+
+type ModifierSource =
+  | Pick<KeyboardEvent, 'shiftKey' | 'ctrlKey' | 'altKey' | 'metaKey'>
+  | Pick<PointerEvent, 'shiftKey' | 'ctrlKey' | 'altKey' | 'metaKey'>;
+
+export function computeModifiers(event: ModifierSource): number {
+  let modifiers = 0;
+  if (event.shiftKey) {
+    modifiers |= 1 << 0;
+  }
+  if (event.ctrlKey) {
+    modifiers |= 1 << 1;
+  }
+  if (event.altKey) {
+    modifiers |= 1 << 2;
+  }
+  if (event.metaKey) {
+    modifiers |= 1 << 3;
+  }
+  return modifiers;
+}

package/src/bridge/utils/fetch.ts

@@ -0,0 +1,147 @@
+export const ASSET_FETCH_ATTEMPTS = 4;
+const ASSET_RETRY_DELAY_MS = 100;
+const scriptSourceCache = new Map<string, Promise<string>>();
+
+function delay(ms: number): Promise<void> {
+  return new Promise<void>((resolve) => {
+    window.setTimeout(resolve, ms);
+  });
+}
+
+export function resolveAssetUrl(url: string): string {
+  return new URL(url, document.baseURI).toString();
+}
+
+export function normalizeFetchIntegrity(integrity: string | null | undefined): string | null {
+  if (integrity === null || integrity === undefined || integrity.length === 0) {
+    return null;
+  }
+  const value = integrity;
+  if (!value.startsWith('sha256-')) {
+    return value;
+  }
+  let digest = value.slice(7).replace(/-/g, '+').replace(/_/g, '/');
+  while ((digest.length % 4) !== 0) {
+    digest += '=';
+  }
+  return `sha256-${digest}`;
+}
+
+export function bytesToBase64(bytes: Uint8Array): string {
+  let binary = '';
+  for (let index = 0; index < bytes.length; index += 0x8000) {
+    const chunk = bytes.subarray(index, Math.min(index + 0x8000, bytes.length));
+    binary += String.fromCharCode(...chunk);
+  }
+  return window.btoa(binary);
+}
+
+export async function verifyFetchedIntegrity(assetUrl: string, buffer: ArrayBuffer, integrity: string | null | undefined): Promise<ArrayBuffer> {
+  const normalizedIntegrity = normalizeFetchIntegrity(integrity);
+  if (normalizedIntegrity === null) {
+    return buffer;
+  }
+  const digestBuffer = await globalThis.crypto.subtle.digest('SHA-256', buffer);
+  const actualIntegrity = `sha256-${bytesToBase64(new Uint8Array(digestBuffer))}`;
+  if (actualIntegrity !== normalizedIntegrity) {
+    throw new Error(`Integrity mismatch for ${assetUrl}`);
+  }
+  return buffer;
+}
+
+export function buildFetchInit(integrity: string | null | undefined, cache: RequestCache = 'force-cache'): RequestInit {
+  const fetchIntegrity = normalizeFetchIntegrity(integrity);
+  const init: RequestInit = {
+    credentials: 'same-origin',
+    cache,
+  };
+  if (fetchIntegrity !== null) {
+    init.integrity = fetchIntegrity;
+  }
+  return init;
+}
+
+export async function fetchWithRetry<T>(
+  url: string,
+  attempts: number,
+  read: (response: Response) => T | Promise<T>,
+  init?: RequestInit,
+): Promise<T> {
+  let lastError: unknown = null;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      const response = await fetch(url, init);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${String(response.status)}`);
+      }
+      return await read(response);
+    } catch (error: unknown) {
+      lastError = error;
+      if (attempt === attempts) {
+        break;
+      }
+      await delay(ASSET_RETRY_DELAY_MS * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(`Failed to fetch ${url}`);
+}
+
+export async function fetchBinaryAsset(url: string, integrity: string | null | undefined): Promise<Uint8Array> {
+  const assetUrl = resolveAssetUrl(url);
+  const buffer = await fetchWithRetry<ArrayBuffer>(
+    assetUrl,
+    ASSET_FETCH_ATTEMPTS,
+    async (response) => await response.arrayBuffer(),
+    buildFetchInit(integrity),
+  );
+  return new Uint8Array(await verifyFetchedIntegrity(assetUrl, buffer, integrity));
+}
+
+export async function fetchResponseWithRetry(url: string, integrity: string | null | undefined): Promise<Response> {
+  const assetUrl = resolveAssetUrl(url);
+  return await fetchWithRetry<Response>(
+    assetUrl,
+    ASSET_FETCH_ATTEMPTS,
+    (response) => response,
+    buildFetchInit(integrity),
+  );
+}
+
+export async function loadScriptResource(scriptUrl: string, integrity: string | null | undefined): Promise<void> {
+  const absoluteUrl = resolveAssetUrl(scriptUrl);
+  const sourceText = await fetchScriptSource(absoluteUrl, integrity);
+  const blobSource = sourceText.includes('//# sourceURL=')
+    ? sourceText
+    : `${sourceText}\n//# sourceURL=${absoluteUrl.replace(/\s/g, '%20')}`;
+  const blobUrl = URL.createObjectURL(new Blob([blobSource], { type: 'application/javascript' }));
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const script = document.createElement('script');
+      script.src = blobUrl;
+      script.async = true;
+      script.addEventListener('load', () => {
+        script.remove();
+        resolve();
+      });
+      script.addEventListener('error', () => {
+        script.remove();
+        reject(new Error(`Failed to execute ${absoluteUrl}`));
+      });
+      document.head.appendChild(script);
+    });
+  } finally {
+    URL.revokeObjectURL(blobUrl);
+  }
+}
+
+export async function fetchScriptSource(scriptUrl: string, integrity: string | null | undefined): Promise<string> {
+  const absoluteUrl = resolveAssetUrl(scriptUrl);
+  const cacheKey = `${absoluteUrl}::${integrity ?? ''}`;
+  let sourcePromise = scriptSourceCache.get(cacheKey);
+  if (sourcePromise === undefined) {
+    sourcePromise = fetchBinaryAsset(absoluteUrl, integrity).then((scriptBytes) =>
+      new TextDecoder('utf-8').decode(scriptBytes));
+    scriptSourceCache.set(cacheKey, sourcePromise);
+  }
+  return await sourcePromise;
+}

package/src/bridge/utils/heap.ts

@@ -0,0 +1,118 @@
+import type { CoreModule, UiModule, WasmHandleLike } from '../../core-types';
+import { normalizePointerForWasm, pointerToHeapOffset } from './encoding';
+
+const textEncoder = new TextEncoder();
+
+export function writeUtf8ToHeap(
+  module: Pick<UiModule | CoreModule, 'HEAPU8' | '_malloc' | '_free' | 'refreshHeapViews' | 'usesMemory64'>,
+  text: string,
+): { readonly ptr: WasmHandleLike; readonly offset: number; readonly len: number; dispose(): void } {
+  const bytes = textEncoder.encode(text);
+  const ptr = normalizePointerForWasm(module, bytes.byteLength === 0 ? 0 : module._malloc(bytes.byteLength));
+  const offset = pointerToHeapOffset(ptr);
+  module.refreshHeapViews?.();
+  if (bytes.byteLength > 0 && offset === 0) {
+    throw new Error('WASM string malloc failed.');
+  }
+  if (bytes.byteLength > 0) {
+    module.HEAPU8.set(bytes, offset);
+  }
+  return {
+    ptr,
+    offset,
+    len: bytes.byteLength,
+    dispose: () => {
+      if (offset !== 0) {
+        module._free(ptr);
+      }
+    },
+  };
+}
+
+export function writeBytesToHeap(
+  module: Pick<UiModule | CoreModule, 'HEAPU8' | '_malloc' | '_free' | 'refreshHeapViews' | 'usesMemory64'>,
+  bytes: Uint8Array,
+): { readonly ptr: WasmHandleLike; readonly offset: number; readonly len: number; dispose(): void } {
+  const ptr = normalizePointerForWasm(module, bytes.byteLength === 0 ? 0 : module._malloc(bytes.byteLength));
+  const offset = pointerToHeapOffset(ptr);
+  module.refreshHeapViews?.();
+  if (bytes.byteLength > 0 && offset === 0) {
+    throw new Error('WASM bytes malloc failed.');
+  }
+  if (bytes.byteLength > 0) {
+    module.HEAPU8.set(bytes, offset);
+  }
+  return {
+    ptr,
+    offset,
+    len: bytes.byteLength,
+    dispose: () => {
+      if (offset !== 0) {
+        module._free(ptr);
+      }
+    },
+  };
+}
+
+export function extractCommandBuffer(ui: UiModule): Uint32Array {
+  const lengthPtr = normalizePointerForWasm(ui, ui._malloc(4));
+  const lengthOffset = pointerToHeapOffset(lengthPtr);
+  if (lengthOffset === 0) {
+    throw new Error('ui length malloc failed.');
+  }
+
+  try {
+    const bufferPtr = ui._ui_get_command_buffer(lengthPtr);
+    ui.refreshHeapViews?.();
+    const wordCount = ui.HEAPU32[lengthOffset >>> 2] ?? 0;
+    const bufferOffset = pointerToHeapOffset(normalizePointerForWasm(ui, bufferPtr));
+    if (bufferOffset === 0 || wordCount === 0) {
+      return new Uint32Array();
+    }
+    const wordOffset = bufferOffset >>> 2;
+    return ui.HEAPU32.slice(wordOffset, wordOffset + wordCount);
+  } finally {
+    ui._free(lengthPtr);
+  }
+}
+
+export function extractSemanticBuffer(ui: UiModule): Uint32Array {
+  const lengthPtr = normalizePointerForWasm(ui, ui._malloc(4));
+  const lengthOffset = pointerToHeapOffset(lengthPtr);
+  if (lengthOffset === 0) {
+    throw new Error('ui semantic length malloc failed.');
+  }
+
+  try {
+    const bufferPtr = ui._ui_get_semantic_buffer(lengthPtr);
+    ui.refreshHeapViews?.();
+    const wordCount = ui.HEAPU32[lengthOffset >>> 2] ?? 0;
+    const bufferOffset = pointerToHeapOffset(normalizePointerForWasm(ui, bufferPtr));
+    if (bufferOffset === 0 || wordCount === 0) {
+      return new Uint32Array();
+    }
+    const wordOffset = bufferOffset >>> 2;
+    return ui.HEAPU32.slice(wordOffset, wordOffset + wordCount);
+  } finally {
+    ui._free(lengthPtr);
+  }
+}
+
+export function executeCommandBuffer(core: CoreModule, words: Uint32Array): void {
+  if (words.length === 0) {
+    return;
+  }
+  const ptr = normalizePointerForWasm(core, core._malloc(words.byteLength));
+  const offset = pointerToHeapOffset(ptr);
+  core.refreshHeapViews?.();
+  if (offset === 0) {
+    throw new Error('core command malloc failed.');
+  }
+
+  try {
+    core.HEAPU32.set(words, offset >>> 2);
+    core._ed_execute_command_buffer(ptr, words.length);
+  } finally {
+    core._free(ptr);
+  }
+}

package/src/bridge.ts

@@ -0,0 +1,93 @@
+import type { BridgeRuntime, BridgeState } from './core-types';
+import { createBridgeSession, type BridgeSession } from './bridge/init';
+import { installCallbacks } from './bridge/interaction';
+import { prepareRuntimeAssets } from './bridge/utils/assets';
+import {
+  handleToBigInt,
+  handleToString,
+  normalizePointerForWasm,
+  pointerToHeapOffset,
+  toHeapPointer,
+} from './bridge/utils/encoding';
+
+let currentRuntime: BridgeRuntime | null = null;
+let currentSession: BridgeSession | null = null;
+let bridgeReadyPromise: Promise<BridgeRuntime> | null = null;
+let sessionChain: Promise<void> = Promise.resolve();
+
+const runtimeRef: { current: BridgeRuntime | null } = { current: null };
+const interactionState = installCallbacks(runtimeRef);
+const preparedAssetsPromise = prepareRuntimeAssets();
+
+async function bootRuntimeSession(): Promise<BridgeRuntime> {
+  currentRuntime?.resetLogs();
+  currentSession?.destroy();
+  currentSession = null;
+
+  const preparedAssets = await preparedAssetsPromise;
+  const session = await createBridgeSession({
+    interactionState,
+    preparedAssets,
+    runtimeRef,
+  });
+  currentSession = session;
+  currentRuntime = session.runtime;
+  window.__bridgeReady = true;
+  window.__bridgeDebug = {
+    forceDeviceLost() {
+      session.runtime.core._ed_debug_simulate_device_lost?.();
+      session.runtime.requestFrame();
+    },
+  };
+  delete window.__bridgeError;
+  return session.runtime;
+}
+
+function queueRuntimeBoot(): Promise<BridgeRuntime> {
+  sessionChain = sessionChain
+    .catch(() => undefined)
+    .then(async () => {
+      await bootRuntimeSession();
+    });
+  return sessionChain.then(() => {
+    if (currentRuntime === null) {
+      throw new Error('Bridge runtime failed to boot.');
+    }
+    return currentRuntime;
+  });
+}
+
+bridgeReadyPromise = queueRuntimeBoot().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error);
+  window.__bridgeReady = false;
+  window.__bridgeError = message;
+  throw error;
+});
+
+const bridgeState: BridgeState = {
+  get ready(): Promise<BridgeRuntime> {
+    return bridgeReadyPromise ?? Promise.reject(new Error('Bridge runtime is not booting.'));
+  },
+  getRuntime: () => currentRuntime,
+  recreateRuntime: async () => {
+    bridgeReadyPromise = queueRuntimeBoot();
+    return await bridgeReadyPromise;
+  },
+  resetLogs: () => {
+    if (currentRuntime !== null) {
+      currentRuntime.resetLogs();
+    }
+  },
+  handleToBigInt,
+  handleToString,
+  pointerToHeapOffset,
+  normalizePointerForWasm,
+  toHeapPointer,
+};
+
+window.__bridgeReady = false;
+window.EffinDomBrowserBridge = bridgeState;
+
+void bridgeReadyPromise.catch(() => undefined);
+
+export {};