@forgeax/engine-app 0.0.0-dev.8d955ade1c79

package/src/execution/capabilities.ts

@@ -0,0 +1,102 @@
+import {
+  EXECUTION_CAPABILITY_NAMES,
+  type ExecutionCapabilities,
+  type ExecutionCapabilityName,
+} from './types';
+
+export function unavailableExecutionCapabilities(reason: string): ExecutionCapabilities {
+  return Object.fromEntries(
+    EXECUTION_CAPABILITY_NAMES.map((name) => [name, { available: false, reason }]),
+  ) as unknown as ExecutionCapabilities;
+}
+
+export function missingExecutionCapabilities(
+  capabilities: ExecutionCapabilities,
+  required: readonly ExecutionCapabilityName[],
+): readonly ExecutionCapabilityName[] {
+  return required.filter((name) => !capabilities[name].available);
+}
+
+interface WorkerProbeResult {
+  readonly workerAnimationFrame: boolean;
+  readonly workerWebGpu: boolean;
+  readonly atomicsWait: boolean;
+}
+
+function probeWorker(timeoutMs: number): Promise<WorkerProbeResult> {
+  return new Promise((resolve) => {
+    const source = `postMessage({workerAnimationFrame:typeof requestAnimationFrame==='function',workerWebGpu:typeof navigator==='object'&&navigator.gpu!==undefined,atomicsWait:typeof Atomics==='object'&&typeof Atomics.wait==='function'})`;
+    const url = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+    const worker = new Worker(url);
+    const finish = (result: WorkerProbeResult): void => {
+      worker.terminate();
+      URL.revokeObjectURL(url);
+      resolve(result);
+    };
+    const timeout = setTimeout(
+      () => finish({ workerAnimationFrame: false, workerWebGpu: false, atomicsWait: false }),
+      timeoutMs,
+    );
+    worker.onmessage = (event: MessageEvent<WorkerProbeResult>) => {
+      clearTimeout(timeout);
+      finish(event.data);
+    };
+    worker.onerror = () => {
+      clearTimeout(timeout);
+      finish({ workerAnimationFrame: false, workerWebGpu: false, atomicsWait: false });
+    };
+  });
+}
+
+export async function probeExecutionCapabilities(
+  canvas: HTMLCanvasElement,
+  timeoutMs = 2_000,
+): Promise<ExecutionCapabilities> {
+  const workerAvailable = typeof Worker === 'function';
+  const offscreenAvailable = typeof canvas.transferControlToOffscreen === 'function';
+  const isolated = globalThis.crossOriginIsolated === true;
+  const sabAvailable = typeof SharedArrayBuffer === 'function';
+  const worker = workerAvailable
+    ? await probeWorker(timeoutMs)
+    : { workerAnimationFrame: false, workerWebGpu: false, atomicsWait: false };
+  return {
+    worker: {
+      available: workerAvailable,
+      reason: workerAvailable ? 'Worker constructor observed' : 'Worker constructor unavailable',
+    },
+    offscreenCanvas: {
+      available: offscreenAvailable,
+      reason: offscreenAvailable
+        ? 'canvas transferControlToOffscreen observed'
+        : 'canvas cannot transfer to OffscreenCanvas',
+    },
+    workerAnimationFrame: {
+      available: worker.workerAnimationFrame,
+      reason: worker.workerAnimationFrame
+        ? 'requestAnimationFrame observed in DedicatedWorker'
+        : 'requestAnimationFrame unavailable in DedicatedWorker',
+    },
+    workerWebGpu: {
+      available: worker.workerWebGpu,
+      reason: worker.workerWebGpu
+        ? 'navigator.gpu observed in DedicatedWorker'
+        : 'navigator.gpu unavailable in DedicatedWorker',
+    },
+    crossOriginIsolated: {
+      available: isolated,
+      reason: isolated ? 'crossOriginIsolated is true' : 'crossOriginIsolated is false',
+    },
+    sharedArrayBuffer: {
+      available: sabAvailable,
+      reason: sabAvailable
+        ? 'SharedArrayBuffer constructor observed'
+        : 'SharedArrayBuffer constructor unavailable',
+    },
+    atomicsWait: {
+      available: worker.atomicsWait,
+      reason: worker.atomicsWait
+        ? 'Atomics.wait observed in DedicatedWorker'
+        : 'Atomics.wait unavailable in DedicatedWorker',
+    },
+  };
+}

package/src/execution/control.ts

@@ -0,0 +1,48 @@
+import type { AudioState } from '@forgeax/engine-audio';
+import { err } from '@forgeax/engine-types';
+import { APP_ERROR_HINTS, APP_EXPECTED, AppError } from '../errors';
+import { executionAudioReport } from './report';
+import type { ExecutionControl, ExecutionEngineHealth, ExecutionReport } from './types';
+
+export function cloneExecutionReport(report: ExecutionReport): ExecutionReport {
+  return structuredClone(report);
+}
+
+export interface LocalExecutionControl extends ExecutionControl {
+  setEngineHealth(health: ExecutionEngineHealth): void;
+}
+
+export interface LocalExecutionReportProviders {
+  readonly audio?: () => AudioState;
+  readonly world?: () => ExecutionReport['world'];
+}
+
+export function createLocalExecutionControl(
+  initial: ExecutionReport,
+  providers: LocalExecutionReportProviders = {},
+): LocalExecutionControl {
+  let current = cloneExecutionReport(initial);
+  return {
+    setEngineHealth: (health) => {
+      current = { ...current, engine: { ...current.engine, health } };
+    },
+    report: () =>
+      cloneExecutionReport({
+        ...current,
+        world: providers.world?.() ?? current.world,
+        audio: executionAudioReport(providers.audio?.()),
+      }),
+    rebuild: async () =>
+      err(
+        new AppError({
+          code: 'app-execution-rebuild-failed',
+          expected: APP_EXPECTED['app-execution-rebuild-failed'],
+          hint: APP_ERROR_HINTS['app-execution-rebuild-failed'],
+          detail: {
+            worldIdentity: current.world.identity,
+            cause: new Error('This local assembly has no bootstrap module.'),
+          },
+        }),
+      ),
+  };
+}

package/src/execution/engine-worker-runtime.ts

@@ -0,0 +1,383 @@
+import { type AudioIntent, createAudioIntentBackend } from '@forgeax/engine-audio';
+import { createWorldContext, World } from '@forgeax/engine-ecs';
+import type { SharedKernelExecutor } from '@forgeax/engine-ecs/shared';
+import type { InputBackend, InputBackendSample } from '@forgeax/engine-input';
+import type { Context, Plugin } from '@forgeax/engine-plugin';
+import type { Renderer } from '@forgeax/engine-render';
+import { constructRuntimeRendererHost } from '@forgeax/engine-runtime/internal/renderer-host';
+import { createAnimationPayloadLookup } from '../animation-asset-lookup';
+import { syncCameraAspect } from '../canvas-policy';
+import { workerEngineProfile } from '../internal/worker-engine-profile';
+import { createRenderFeatureHost } from '../renderer-plugin';
+import { commitAttachedWorld, SerializedRebuildQueue } from './attached-world-swap';
+import {
+  executionBootstrapHostPlugin,
+  type PreparedExecutionBootstrap,
+  prepareBootstrapEntry,
+} from './bootstrap-entry';
+import { createKernelPool, type KernelPool } from './kernel-pool';
+import type {
+  EngineToHostMessage,
+  ExecutionFrameMessage,
+  ExecutionInitMessage,
+  ExecutionRebuildMessage,
+  HostToEngineMessage,
+} from './protocol';
+
+const scope = globalThis as unknown as {
+  postMessage(message: EngineToHostMessage): void;
+  onmessage: ((event: MessageEvent<HostToEngineMessage>) => void) | null;
+  close(): void;
+};
+
+let renderer: Renderer | undefined;
+let assets: import('@forgeax/engine-assets-runtime').AssetRegistry | undefined;
+let currentSample: InputBackendSample = {
+  downKeys: new Set(),
+  upKeys: new Set(),
+  buttons: [false, false, false],
+  movementX: 0,
+  movementY: 0,
+  wheelDelta: 0,
+  focused: true,
+  pointerLocked: false,
+};
+let lastFrameId = 0;
+let engineCanvas: OffscreenCanvas | undefined;
+interface WorkerRealm {
+  readonly world: World;
+  readonly init: ExecutionInitMessage;
+  pendingAudioIntents: AudioIntent[];
+  kernelPool: KernelPool | undefined;
+  pluginContext: Context | undefined;
+}
+
+let realm: WorkerRealm | undefined;
+const rebuildQueue = new SerializedRebuildQueue();
+
+const inputBackend: InputBackend = {
+  sample: () => currentSample,
+  detach: () => {},
+};
+
+function sharedKernelPlugin(target: WorkerRealm): Plugin {
+  return {
+    name: 'shared-kernel-executor',
+    inject: ['world'],
+    apply(ctx) {
+      const executor: SharedKernelExecutor = {
+        warmup(kernel) {
+          target.kernelPool ??= createKernelPool();
+          target.kernelPool.warmup?.(kernel);
+        },
+        execute(kernel, spans) {
+          target.kernelPool ??= createKernelPool();
+          return target.kernelPool.execute(kernel, spans);
+        },
+      };
+      ctx.effect(() => {
+        ctx.world.insertResource('SharedKernelExecutor', executor);
+        return () => {
+          ctx.world.removeResource('SharedKernelExecutor');
+          target.kernelPool?.dispose();
+          target.kernelPool = undefined;
+        };
+      }, 'execution/shared-kernel');
+    },
+  };
+}
+
+function serializableCause(cause: unknown): { readonly name: string; readonly message: string } {
+  return cause instanceof Error
+    ? { name: cause.name, message: cause.message }
+    : { name: 'Error', message: String(cause) };
+}
+
+function serializableDetail(cause: unknown): unknown {
+  if (cause instanceof Error) return serializableCause(cause);
+  if (Array.isArray(cause)) return cause.map(serializableDetail);
+  if (typeof cause === 'object' && cause !== null) {
+    return Object.fromEntries(
+      Object.entries(cause).map(([key, value]) => [key, serializableDetail(value)]),
+    );
+  }
+  return cause;
+}
+
+function postFault(
+  source: 'bootstrap' | 'runtime' | 'world' | 'rebuild',
+  code: string,
+  expected: string,
+  hint: string,
+  cause: unknown,
+  partialWrite = false,
+): void {
+  scope.postMessage({
+    kind: 'fault',
+    worldIdentity: realm?.world.identity ?? null,
+    source,
+    code,
+    expected,
+    hint,
+    detail: serializableDetail(cause),
+    partialWrite,
+    retryable: false,
+  });
+}
+
+async function disposeRealm(target: WorkerRealm): Promise<void> {
+  await target.pluginContext?.fiber.dispose();
+  target.pluginContext = undefined;
+  target.pendingAudioIntents = [];
+}
+
+function postBootstrapFault(error: {
+  readonly code: string;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: unknown;
+}): void {
+  postFault('bootstrap', error.code, error.expected, error.hint, error.detail);
+}
+
+async function createRealm(init: ExecutionInitMessage): Promise<boolean> {
+  const preparedResult = await prepareBootstrapEntry(init.bootstrapUrl, init.bootstrapData);
+  if (!preparedResult.ok) {
+    postBootstrapFault(preparedResult.error);
+    return false;
+  }
+  const prepared: PreparedExecutionBootstrap = preparedResult.value;
+  const nextWorld = new World({
+    ...(init.time !== undefined ? { time: init.time } : {}),
+    storage: init.tier === 'shared' ? 'shared' : 'local',
+  });
+  const candidate: WorkerRealm = {
+    world: nextWorld,
+    init,
+    pendingAudioIntents: [],
+    kernelPool: undefined,
+    pluginContext: undefined,
+  };
+  const audioBackend = createAudioIntentBackend({
+    emit: (intent) => candidate.pendingAudioIntents.push(intent),
+  });
+  let candidateRenderer: Renderer | undefined;
+  let rendererLifecycleTransferred = false;
+  const previousRenderer = renderer;
+  let previousSurfaceReleased = false;
+  try {
+    if (previousRenderer !== undefined) {
+      const released = previousRenderer.releaseSurface();
+      if (!released.ok) throw released.error;
+      previousSurfaceReleased = true;
+    }
+    const constructed = await constructRuntimeRendererHost(
+      init.canvas,
+      prepared.features === undefined ? {} : { features: prepared.features },
+      init.shaderManifestUrl === undefined
+        ? undefined
+        : { shaderManifestUrl: init.shaderManifestUrl },
+    );
+    if (!constructed.ok) throw constructed.error;
+    candidateRenderer = constructed.value.renderer;
+    assets = constructed.value.assets;
+    rendererLifecycleTransferred = true;
+    const pluginContext = await createWorldContext(
+      nextWorld,
+      workerEngineProfile({
+        renderer: candidateRenderer,
+        rendererFeatureHost: createRenderFeatureHost(constructed.value.featureHost),
+        assets,
+        input: inputBackend,
+        audio: audioBackend,
+        animationPayloads: createAnimationPayloadLookup(assets),
+        extensions: [
+          ...(init.tier === 'shared' ? [sharedKernelPlugin(candidate)] : []),
+          executionBootstrapHostPlugin({
+            ...(init.bootstrapPort === undefined ? {} : { port: init.bootstrapPort }),
+            setPointerLockAllowed(allowed): void {
+              scope.postMessage({
+                kind: 'host-control',
+                command: 'set-pointer-lock-allowed',
+                allowed,
+              });
+            },
+          }),
+          ...(prepared.plugins ?? []),
+        ],
+      }),
+    );
+    candidate.pluginContext = pluginContext;
+    const activeRenderer = candidateRenderer;
+    const previousRealm = realm;
+    const committed = await commitAttachedWorld(candidateRenderer, nextWorld, async () => {
+      await candidate.kernelPool?.ready();
+      return true;
+    });
+    if (!committed) {
+      await disposeRealm(candidate);
+      if (previousSurfaceReleased) previousRenderer?.restoreSurface();
+      return false;
+    }
+    realm = candidate;
+    renderer = activeRenderer;
+    lastFrameId = 0;
+    if (previousRealm !== undefined) await disposeRealm(previousRealm);
+    return true;
+  } catch (cause) {
+    await disposeRealm(candidate);
+    if (!rendererLifecycleTransferred) candidateRenderer?.dispose();
+    if (previousSurfaceReleased) previousRenderer?.restoreSurface();
+    throw cause;
+  }
+}
+
+async function initialize(message: ExecutionInitMessage): Promise<void> {
+  try {
+    engineCanvas = message.canvas;
+    if (!(await createRealm(message))) return;
+    scope.postMessage({
+      kind: 'ready',
+      worldIdentity: realm?.world.identity ?? '',
+      realm: 'worker',
+      workerWebGpu: typeof navigator === 'object' && navigator.gpu !== undefined,
+    });
+  } catch (cause) {
+    postFault(
+      'bootstrap',
+      'app-execution-bootstrap-failed',
+      'Engine Worker creates a realm-local World, Renderer and GPU owner',
+      'inspect the worker bootstrap cause and module URL',
+      cause,
+    );
+  }
+}
+
+function runFrame(message: ExecutionFrameMessage): void {
+  const activeRealm = realm;
+  if (activeRealm === undefined || renderer === undefined) return;
+  const { world } = activeRealm;
+  if (message.worldIdentity !== world.identity || message.frameId <= lastFrameId) return;
+  currentSample = message.inputSample;
+  const canvasWidth =
+    Number.isFinite(message.canvasWidth) && message.canvasWidth > 0
+      ? Math.max(1, Math.floor(message.canvasWidth))
+      : undefined;
+  const canvasHeight =
+    Number.isFinite(message.canvasHeight) && message.canvasHeight > 0
+      ? Math.max(1, Math.floor(message.canvasHeight))
+      : undefined;
+  if (canvasWidth !== undefined && canvasHeight !== undefined) {
+    if (engineCanvas !== undefined) {
+      if (engineCanvas.width !== canvasWidth) engineCanvas.width = canvasWidth;
+      if (engineCanvas.height !== canvasHeight) engineCanvas.height = canvasHeight;
+    }
+    syncCameraAspect(world, canvasWidth, canvasHeight);
+  }
+  const started = performance.now();
+  try {
+    const update = world.update(message.deltaSeconds);
+    if (!update.ok) throw update.error;
+    if (world.execution.health === 'poisoned') {
+      const fault = world.execution.fault;
+      postFault(
+        'world',
+        fault?.code ?? 'world-poisoned',
+        'World remains healthy through update',
+        'rebuild the poisoned World explicitly',
+        fault,
+        fault?.partialWrite ?? true,
+      );
+      return;
+    }
+    const updateFinished = performance.now();
+    const attached = renderer.attach(world);
+    if (!attached.ok) throw attached.error;
+    const draw = renderer.draw({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    if (!draw.ok) throw draw.error;
+    lastFrameId = message.frameId;
+    const kernelDispatch = activeRealm.kernelPool?.takeLastDispatch() ?? null;
+    const audioIntents = activeRealm.pendingAudioIntents;
+    activeRealm.pendingAudioIntents = [];
+    scope.postMessage({
+      kind: 'frame-complete',
+      worldIdentity: world.identity,
+      frameId: message.frameId,
+      engineUpdateMs: updateFinished - started,
+      kernelWaitMs: kernelDispatch?.waitMs ?? 0,
+      ...(audioIntents.length > 0 ? { audioIntents } : {}),
+      ...(kernelDispatch !== null
+        ? {
+            kernelDispatch: {
+              eligible: true,
+              usedShared: kernelDispatch.mode === 'shared',
+              reason:
+                kernelDispatch.mode === 'shared' ? ('shared' as const) : ('forced-inline' as const),
+              dispatched: kernelDispatch.dispatched,
+              completed: kernelDispatch.completed,
+            },
+          }
+        : {}),
+    });
+  } catch (cause) {
+    const fault = world.execution.fault;
+    postFault(
+      fault === null ? 'runtime' : 'world',
+      fault?.code ?? 'app-system-update-failed',
+      'World update completes before Renderer draw',
+      fault === null ? 'inspect the runtime cause' : 'rebuild the poisoned World explicitly',
+      cause,
+      fault?.partialWrite ?? false,
+    );
+  }
+}
+
+async function rebuild(message: ExecutionRebuildMessage): Promise<void> {
+  const activeRealm = realm;
+  if (
+    activeRealm === undefined ||
+    renderer === undefined ||
+    message.worldIdentity !== activeRealm.world.identity
+  )
+    return;
+  const previousWorldIdentity = activeRealm.world.identity;
+  try {
+    if (engineCanvas === undefined) return;
+    const init: ExecutionInitMessage = { ...activeRealm.init, canvas: engineCanvas };
+    if (!(await createRealm(init))) return;
+    scope.postMessage({
+      kind: 'rebuilt',
+      previousWorldIdentity,
+      worldIdentity: realm?.world.identity ?? '',
+    });
+  } catch (cause) {
+    postFault(
+      'rebuild',
+      'app-execution-rebuild-failed',
+      'bootstrap creates a fresh World identity',
+      'inspect the bootstrap cause or create a new App',
+      cause,
+    );
+  }
+}
+
+scope.onmessage = (event): void => {
+  const message = event.data;
+  if (message.kind === 'init') void initialize(message);
+  else if (message.kind === 'frame') runFrame(message);
+  else if (message.kind === 'rebuild') {
+    void rebuildQueue.enqueue(() => rebuild(message));
+  } else if (message.kind === 'dispose') {
+    void (async () => {
+      if (realm !== undefined) {
+        await disposeRealm(realm);
+        realm = undefined;
+      }
+      scope.close();
+    })();
+  }
+};

package/src/execution/engine-worker.ts

@@ -0,0 +1,163 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { APP_ERROR_HINTS, APP_EXPECTED, AppError, type AppError as AppErrorType } from '../errors';
+import { validateExecutionBootstrapData } from './bootstrap-entry';
+import type {
+  EngineToHostMessage,
+  ExecutionFaultMessage,
+  ExecutionInitMessage,
+  ExecutionReadyMessage,
+  HostToEngineMessage,
+} from './protocol';
+
+export interface EngineWorkerSession {
+  readonly worker: Worker;
+  readonly ready: ExecutionReadyMessage;
+  post(message: HostToEngineMessage, transfer?: Transferable[]): void;
+  listen(listener: (message: EngineToHostMessage) => void): () => void;
+  dispose(): void;
+}
+
+export interface StartEngineWorkerOptions {
+  readonly canvas: HTMLCanvasElement;
+  readonly bootstrapUrl: string;
+  readonly bootstrapData?: import('./types').ExecutionBootstrapValue;
+  readonly bootstrapPort?: MessagePort;
+  readonly assetCatalog?: import('./types').ExecutionAssetCatalog;
+  readonly shaderManifestUrl?: string;
+  readonly time?: import('@forgeax/engine-ecs').TimePolicy;
+  readonly timeoutMs: number;
+  readonly tier: import('./types').ExecutionTier;
+  readonly workerFactory?: () => Worker;
+}
+
+function deadlineError(timeoutMs: number): AppErrorType {
+  return new AppError({
+    code: 'app-execution-deadline-exceeded',
+    expected: APP_EXPECTED['app-execution-deadline-exceeded'],
+    hint: APP_ERROR_HINTS['app-execution-deadline-exceeded'],
+    detail: { phase: 'handshake', timeoutMs },
+  });
+}
+
+function startupFault(message: ExecutionFaultMessage, moduleUrl: string): AppErrorType {
+  return new AppError({
+    code: 'app-execution-bootstrap-failed',
+    expected: APP_EXPECTED['app-execution-bootstrap-failed'],
+    hint: APP_ERROR_HINTS['app-execution-bootstrap-failed'],
+    detail: { phase: 'bootstrap', moduleUrl, cause: message.detail },
+  });
+}
+
+export async function startEngineWorker(
+  options: StartEngineWorkerOptions,
+): Promise<Result<EngineWorkerSession, AppErrorType>> {
+  const validData = validateExecutionBootstrapData(options.bootstrapData, options.bootstrapUrl);
+  if (!validData.ok) return validData;
+  const worker =
+    options.workerFactory?.() ??
+    new Worker(new URL('./engine-worker-runtime.mjs', import.meta.url), {
+      type: 'module',
+      name: 'forgeax-engine',
+    });
+  const listeners = new Set<(message: EngineToHostMessage) => void>();
+  let settled = false;
+  let resolveReady: (result: Result<ExecutionReadyMessage, AppErrorType>) => void = () => {};
+  const readyPromise = new Promise<Result<ExecutionReadyMessage, AppErrorType>>((resolve) => {
+    resolveReady = resolve;
+  });
+  const timeout = setTimeout(() => {
+    if (settled) return;
+    settled = true;
+    worker.terminate();
+    resolveReady(err(deadlineError(options.timeoutMs)));
+  }, options.timeoutMs);
+  worker.onmessage = (event: MessageEvent<EngineToHostMessage>) => {
+    const message = event.data;
+    if (!settled && message.kind === 'ready') {
+      settled = true;
+      clearTimeout(timeout);
+      resolveReady(ok(message));
+    } else if (!settled && message.kind === 'fault') {
+      settled = true;
+      clearTimeout(timeout);
+      worker.terminate();
+      resolveReady(err(startupFault(message, options.bootstrapUrl)));
+    }
+    for (const listener of listeners) listener(message);
+  };
+  worker.onerror = (event) => {
+    if (settled) {
+      const crash: ExecutionFaultMessage = {
+        kind: 'fault',
+        worldIdentity: null,
+        source: 'runtime',
+        code: 'worker-crashed',
+        expected: 'Engine Worker remains alive while the App is running',
+        hint: 'inspect the Worker error and create a new App; transferred canvas ownership is terminal',
+        detail: { message: event.message },
+        partialWrite: false,
+        retryable: false,
+      };
+      for (const listener of listeners) listener(crash);
+      return;
+    }
+    settled = true;
+    clearTimeout(timeout);
+    worker.terminate();
+    resolveReady(
+      err(
+        startupFault(
+          {
+            kind: 'fault',
+            worldIdentity: null,
+            source: 'bootstrap',
+            code: 'worker-error',
+            expected: 'Engine Worker module loads',
+            hint: 'inspect the Worker module graph',
+            detail: { message: event.message },
+            partialWrite: false,
+            retryable: false,
+          },
+          options.bootstrapUrl,
+        ),
+      ),
+    );
+  };
+
+  const offscreen = options.canvas.transferControlToOffscreen();
+  const init: ExecutionInitMessage = {
+    kind: 'init',
+    canvas: offscreen,
+    bootstrapUrl: options.bootstrapUrl,
+    ...(options.bootstrapData === undefined ? {} : { bootstrapData: options.bootstrapData }),
+    ...(options.bootstrapPort === undefined ? {} : { bootstrapPort: options.bootstrapPort }),
+    ...(options.assetCatalog === undefined ? {} : { assetCatalog: options.assetCatalog }),
+    ...(options.shaderManifestUrl !== undefined
+      ? { shaderManifestUrl: options.shaderManifestUrl }
+      : {}),
+    ...(options.time !== undefined ? { time: options.time } : {}),
+    tier: options.tier,
+  };
+  worker.postMessage(init, [
+    offscreen,
+    ...(options.bootstrapPort === undefined ? [] : [options.bootstrapPort]),
+  ]);
+  const ready = await readyPromise;
+  if (!ready.ok) return ready;
+  return ok({
+    worker,
+    ready: ready.value,
+    post(message, transfer = []): void {
+      worker.postMessage(message, transfer);
+    },
+    listen(listener): () => void {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    dispose(): void {
+      worker.postMessage({ kind: 'dispose' } satisfies HostToEngineMessage);
+      worker.terminate();
+      listeners.clear();
+    },
+  });
+}