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

package/dist/engine-worker-runtime.mjs

@@ -0,0 +1,827 @@
+import { createAudioIntentBackend, audioBackendPlugin } from '@forgeax/engine-audio';
+import { World, createWorldContext, Update } from '@forgeax/engine-ecs';
+import { constructRuntimeRendererHost } from '@forgeax/engine-runtime/internal/renderer-host';
+import { renderComponentsPlugin, Camera, CAMERA_PROJECTION_PERSPECTIVE } from '@forgeax/engine-render';
+import { animationPayloadsPlugin, animationRuntimePlugin } from '@forgeax/engine-animation';
+import { inputBackendPlugin, INPUT_BACKEND_KEY, InputSet, InputFrameStartScan } from '@forgeax/engine-input';
+import { scenePlugin } from '@forgeax/engine-scene';
+import { statePlugin } from '@forgeax/engine-state';
+import { err, ok } from '@forgeax/engine-types';
+import { splitSharedSpan, bindSharedSpan, isSharedSpan } from '@forgeax/engine-ecs/shared';
+
+// src/execution/engine-worker-runtime.ts
+
+// src/animation-asset-lookup.ts
+function createAnimationPayloadLookup(source) {
+  return (guid) => source?.lookup(guid);
+}
+function syncCameraAspect(world, canvasW, canvasH) {
+  if (canvasW <= 0 || canvasH <= 0) return;
+  const aspect = canvasW / canvasH;
+  const query = world.query({ with: [Camera] }).unwrap();
+  for (const row of query) {
+    const camera = world.get(row.entity, Camera);
+    if (!camera.ok) continue;
+    if (camera.value.autoAspect !== true) continue;
+    if (camera.value.projection !== CAMERA_PROJECTION_PERSPECTIVE) continue;
+    world.set(row.entity, Camera, { aspect });
+  }
+}
+function inputPlugin() {
+  return {
+    name: "input",
+    inject: ["world", "input"],
+    apply(ctx) {
+      const world = ctx.world;
+      const input = ctx.input;
+      if (input === void 0) throw new Error("Cordis activated input without its provider");
+      ctx.effect(() => {
+        world.insertResource(INPUT_BACKEND_KEY, input);
+        return () => {
+          world.removeResource(INPUT_BACKEND_KEY);
+        };
+      }, "input/resource");
+      ctx.effect(() => {
+        world.addSystems(Update, InputSet, [InputFrameStartScan]).unwrap();
+        return () => world.removeSystem(Update, InputFrameStartScan.name);
+      }, "input/frame-start-scan");
+    }
+  };
+}
+
+// src/renderer-plugin.ts
+function createRenderFeatureHost(host) {
+  return {
+    async installFeature(feature) {
+      const installed = await host.installRenderFeature(feature);
+      if (!installed.ok) return installed;
+      let released = false;
+      return {
+        ok: true,
+        value: {
+          release: async () => {
+            if (released) return { ok: true, value: void 0 };
+            released = true;
+            return host.uninstallRenderFeature(feature);
+          }
+        }
+      };
+    }
+  };
+}
+function ownedRendererPlugin(renderer2) {
+  return {
+    name: "renderer",
+    provide: "renderer",
+    apply(ctx) {
+      ctx.provide("renderer", renderer2);
+      ctx.effect(() => () => renderer2.dispose(), "render/renderer");
+    }
+  };
+}
+function renderFeatureHostPlugin(host) {
+  return {
+    name: "render-feature-host",
+    provide: "renderFeatureHost",
+    apply(ctx) {
+      ctx.provide("renderFeatureHost", host);
+    }
+  };
+}
+
+// src/internal/assets-world-plugin.ts
+var ASSET_REGISTRY_RESOURCE_KEY = "AssetRegistry";
+function rendererAssetsPlugin(assets2) {
+  return {
+    name: "renderer-assets",
+    inject: ["renderer"],
+    provide: "assets",
+    apply(ctx) {
+      if (assets2 !== void 0) ctx.provide("assets", assets2);
+    }
+  };
+}
+function assetsWorldPlugin() {
+  return {
+    name: "assets-world",
+    inject: ["world", "assets"],
+    apply(ctx) {
+      if (ctx.assets === void 0) return;
+      ctx.effect(() => {
+        ctx.world.insertResource(ASSET_REGISTRY_RESOURCE_KEY, ctx.assets);
+        return () => {
+          ctx.world.removeResource(ASSET_REGISTRY_RESOURCE_KEY);
+        };
+      }, "assets/world-resource");
+    }
+  };
+}
+
+// src/internal/worker-engine-profile.ts
+function workerEngineProfile(options) {
+  return [
+    ownedRendererPlugin(options.renderer),
+    renderComponentsPlugin(),
+    ...options.rendererFeatureHost === void 0 ? [] : [renderFeatureHostPlugin(options.rendererFeatureHost)],
+    rendererAssetsPlugin(options.assets),
+    assetsWorldPlugin(),
+    inputBackendPlugin(options.input),
+    audioBackendPlugin(options.audio),
+    scenePlugin(),
+    animationPayloadsPlugin(options.animationPayloads),
+    animationRuntimePlugin(),
+    statePlugin(),
+    inputPlugin(),
+    ...options.extensions ?? []
+  ];
+}
+
+// src/execution/attached-world-swap.ts
+var SerializedRebuildQueue = class {
+  tail = Promise.resolve();
+  enqueue(action) {
+    const current = this.tail.then(action, action);
+    this.tail = current.catch(() => void 0);
+    return current;
+  }
+};
+async function commitAttachedWorld(renderer2, nextWorld, initializeCandidate) {
+  const attached = renderer2.attach(nextWorld);
+  if (!attached.ok) throw attached.error;
+  try {
+    if (!await initializeCandidate()) {
+      attached.value.dispose();
+      return false;
+    }
+  } catch (cause) {
+    attached.value.dispose();
+    throw cause;
+  }
+  return true;
+}
+
+// src/errors.ts
+function summarizeCause(cause) {
+  if (cause === null || cause === void 0) return String(cause);
+  if (typeof cause !== "object") return String(cause);
+  const r = cause;
+  const name = typeof r.name === "string" && r.name.length > 0 ? r.name : "Error";
+  const code = typeof r.code === "string" && r.code.length > 0 ? r.code : "";
+  const message = typeof r.message === "string" ? r.message : "";
+  const head = code !== "" ? `${name} ${code}` : name;
+  const body = message !== "" ? `: ${message}` : "";
+  return `${head}${body}`.replace(/\s*\n+\s*/g, " / ");
+}
+var AppErrorClass = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(args) {
+    let causeSuffix = "";
+    if (args.code === "app-system-update-failed") {
+      const d = args.detail;
+      const sys = typeof d.systemName === "string" && d.systemName.length > 0 ? ` (system=${d.systemName})` : "";
+      causeSuffix = `; cause: ${summarizeCause(d.cause)}${sys}`;
+    } else if (args.code === "app-pointer-lock-failed") {
+      const d = args.detail;
+      causeSuffix = `; path: ${d.path}; cause: ${summarizeCause(d.cause)}`;
+    } else if (args.code === "app-plugin-activation-failed") {
+      const d = args.detail;
+      causeSuffix = `; cause: ${summarizeCause(d.cause)}`;
+    } else if (args.code === "app-execution-bootstrap-failed") {
+      const d = args.detail;
+      causeSuffix = `; phase: ${d.phase}; cause: ${summarizeCause(d.cause)}`;
+    } else if (args.code === "app-execution-kernel-failed") {
+      const d = args.detail;
+      causeSuffix = `; kernel: ${d.kernelName}; cause: ${summarizeCause(d.cause)}`;
+    } else if (args.code === "app-execution-rebuild-failed") {
+      const d = args.detail;
+      causeSuffix = `; cause: ${summarizeCause(d.cause)}`;
+    }
+    super(`[AppError ${args.code}] expected: ${args.expected}; hint: ${args.hint}${causeSuffix}`);
+    this.name = "AppError";
+    this.code = args.code;
+    this.expected = args.expected;
+    this.hint = args.hint;
+    this.detail = args.detail;
+  }
+};
+var AppError = AppErrorClass;
+var appErrorPolicy = {
+  "app-not-started": {
+    expected: 'state must be "running" or "paused" to accept stop/pause/resume; "idle" / "stopped" terminal sinks reject',
+    hint: "check getState() before calling stop/pause/resume; rebuild the handle via createApp({...}) when the previous one terminated on device-lost"
+  },
+  "app-already-running": {
+    expected: 'state must be "idle" or "paused" to start; "running" handles ignore subsequent start() calls',
+    hint: "call stop() first or audit start() call sites; the second start() is a no-op so state is preserved"
+  },
+  "app-canvas-detached": {
+    expected: "canvas.isConnected === true at createApp(canvas) entry",
+    hint: "append the canvas to the document tree before calling createApp(canvas), or use the assemble entry createApp({ renderer, world }) when the host already manages canvas lifetime"
+  },
+  "app-frame-step-invalid": {
+    expected: "stepFrame(deltaSeconds) runs only while the App is paused and deltaSeconds is finite and non-negative",
+    hint: "pause the App before deterministic stepping and pass an explicit finite delta; resume after the bounded step sequence completes"
+  },
+  "app-system-update-failed": {
+    expected: "world.update(world), renderer.draw(world), and frame-loop callbacks complete without failure",
+    hint: "inspect detail.cause for the original thrown value (EcsError / RhiError / host system bug); detail.systemName names the offending system when the call site can supply it"
+  },
+  "app-pointer-lock-failed": {
+    expected: "pointer-lock request (W3C requestPointerLock or host lockProvider.requestLock) to succeed; failure signals the browser rejected the lock or the host provider threw",
+    hint: 'remain in unlocked state; the next trusted click will automatically retry the lock request. inspect detail.path ("w3c" or "provider") and detail.cause to determine the root cause'
+  },
+  "app-plugin-activation-failed": {
+    expected: "every requested Cordis plugin fiber reaches a stable active or pending state",
+    hint: "inspect detail.cause and the plugin fiber effects; repair the failing activation before creating the App again"
+  },
+  "app-execution-tier-unavailable": {
+    expected: "the explicitly requested execution tier has every required observed capability and the shipped shared evidence gate",
+    hint: 'inspect detail.missingCapabilities and detail.sharedEvidencePassed; use tier="auto" only when an observed fallback is acceptable'
+  },
+  "app-execution-bootstrap-failed": {
+    expected: "the bootstrap URL imports a module whose default export completes as an ExecutionBootstrapEntry in the selected Engine Realm",
+    hint: "inspect detail.phase, moduleUrl and cause; export one default ExecutionBootstrapEntry that creates only realm-local engine state"
+  },
+  "app-execution-deadline-exceeded": {
+    expected: "the execution startup, handshake or frame completes within its configured bounded deadline",
+    hint: "inspect detail.phase and timeoutMs; the timed-out Worker has been terminated, so fix startup or frame work before creating a new App"
+  },
+  "app-execution-kernel-failed": {
+    expected: "a shared kernel completes every dispatched shard without leaving a possibly partial World write",
+    hint: "do not retry or draw the poisoned World; inspect detail.kernelName and cause, then call app.execution.rebuild()"
+  },
+  "app-execution-stale-world": {
+    expected: "every execution message targets the currently active World identity before it can write",
+    hint: "discard the late message and keep the current World; inspect expectedIdentity, receivedIdentity and messageKind"
+  },
+  "app-execution-rebuild-failed": {
+    expected: "explicit rebuild disposes the poisoned World and bootstraps a fresh World identity in the surviving Engine Realm",
+    hint: "inspect detail.cause; this App remains stopped, so fix the bootstrap failure or create a new App explicitly"
+  }
+};
+var APP_EXPECTED = Object.fromEntries(
+  Object.entries(appErrorPolicy).map(([code, policy]) => [code, policy.expected])
+);
+var APP_ERROR_HINTS = Object.fromEntries(
+  Object.entries(appErrorPolicy).map(([code, policy]) => [code, policy.hint])
+);
+
+// src/execution/bootstrap-entry.ts
+function executionBootstrapHostPlugin(host) {
+  return {
+    name: "execution-bootstrap-host",
+    provide: "executionBootstrapHost",
+    apply(ctx) {
+      ctx.provide("executionBootstrapHost", host);
+      if (host.port !== void 0) {
+        ctx.effect(() => () => host.port?.close(), "execution/bootstrap-port");
+      }
+    }
+  };
+}
+function bootstrapError(phase, moduleUrl, cause) {
+  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, moduleUrl, cause }
+  });
+}
+function validateExecutionBootstrapData(data, moduleUrl) {
+  if (data === void 0) return ok(void 0);
+  try {
+    structuredClone(data);
+    return ok(void 0);
+  } catch (cause) {
+    return err(bootstrapError("data", moduleUrl, cause));
+  }
+}
+async function loadBootstrapEntry(moduleUrl) {
+  let loaded;
+  try {
+    loaded = await import(
+      /* @vite-ignore */
+      moduleUrl
+    );
+  } catch (cause) {
+    return err(bootstrapError("import", moduleUrl, cause));
+  }
+  const entry = loaded.default;
+  if (typeof entry !== "function") {
+    return err(
+      bootstrapError(
+        "export",
+        moduleUrl,
+        new TypeError("default export is not an ExecutionBootstrapEntry function")
+      )
+    );
+  }
+  return ok(entry);
+}
+async function prepareBootstrapEntry(moduleUrl, data) {
+  const valid = validateExecutionBootstrapData(data, moduleUrl);
+  if (!valid.ok) return valid;
+  const loaded = await loadBootstrapEntry(moduleUrl);
+  if (!loaded.ok) return loaded;
+  try {
+    const prepared = await loaded.value(data);
+    if (typeof prepared !== "object" || prepared === null || prepared.features !== void 0 && !Array.isArray(prepared.features) || prepared.plugins !== void 0 && !Array.isArray(prepared.plugins)) {
+      return err(
+        bootstrapError(
+          "prepare",
+          moduleUrl,
+          new TypeError("execution bootstrap must return an object with feature and plugin arrays")
+        )
+      );
+    }
+    return ok(prepared);
+  } catch (cause) {
+    return err(bootstrapError("prepare", moduleUrl, cause));
+  }
+}
+function createKernelPool(options = {}) {
+  const hardware = globalThis.navigator?.hardwareConcurrency ?? 2;
+  const laneCount = Math.max(1, Math.min(options.lanes ?? hardware - 1, 8));
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const workers = Array.from(
+    { length: laneCount },
+    () => options.workerFactory?.() ?? new Worker(new URL("./kernel-worker-runtime.mjs", import.meta.url), {
+      type: "module",
+      name: "forgeax-kernel"
+    })
+  );
+  let latest = null;
+  let ready = false;
+  const preflights = /* @__PURE__ */ new Map();
+  const readyControl = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+  const initMessage = { kind: "kernel-init", ready: readyControl };
+  for (const worker of workers) worker.postMessage(initMessage);
+  const waitFor = (control, expected, label) => new Promise((resolve, reject) => {
+    const started = performance.now();
+    const poll = () => {
+      if (Atomics.load(control, 0) === expected) {
+        resolve();
+        return;
+      }
+      if (performance.now() - started >= timeoutMs) {
+        for (const worker of workers) worker.terminate();
+        reject(new Error(`${label} did not complete within ${timeoutMs}ms.`));
+        return;
+      }
+      setTimeout(poll, 1);
+    };
+    poll();
+  });
+  const readyPromise = waitFor(
+    readyControl,
+    workers.length,
+    "SharedKernel worker initialization"
+  ).then(async () => {
+    for (const [moduleUrl, preflight] of preflights) {
+      await waitFor(
+        preflight.control,
+        workers.length,
+        `SharedKernel module preflight for ${moduleUrl}`
+      );
+      if (preflight.status.some((status) => status !== 1)) {
+        throw new Error(`SharedKernel module preflight failed for ${moduleUrl}.`);
+      }
+    }
+    ready = true;
+  });
+  return {
+    laneCount,
+    ready: () => readyPromise,
+    warmup(kernel) {
+      if (preflights.has(kernel.moduleUrl)) return;
+      const control = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+      const status = new Int32Array(
+        new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * workers.length)
+      );
+      preflights.set(kernel.moduleUrl, { control, status });
+      for (const [jobIndex, worker] of workers.entries()) {
+        const message = {
+          kind: "kernel-preload",
+          moduleUrl: kernel.moduleUrl,
+          control,
+          status,
+          jobIndex
+        };
+        worker.postMessage(message);
+      }
+    },
+    takeLastDispatch: () => {
+      const dispatch = latest;
+      latest = null;
+      return dispatch;
+    },
+    execute(kernel, spans) {
+      const preflight = preflights.get(kernel.moduleUrl);
+      if (preflight === void 0) {
+        this.warmup?.(kernel);
+        latest = { mode: "forced-inline", dispatched: 0, completed: 0, waitMs: 0 };
+        return {
+          cause: new Error("SharedKernel module was not preflighted before frame dispatch."),
+          dispatched: 0,
+          completed: 0,
+          partialWrite: false
+        };
+      }
+      if (Atomics.load(preflight.control, 0) !== workers.length || preflight.status.some((status2) => status2 !== 1)) {
+        latest = { mode: "forced-inline", dispatched: 0, completed: 0, waitMs: 0 };
+        return {
+          cause: new Error("SharedKernel module preflight is incomplete or failed."),
+          dispatched: 0,
+          completed: 0,
+          partialWrite: false
+        };
+      }
+      if (!ready && Atomics.load(readyControl, 0) === workers.length) ready = true;
+      if (!ready) {
+        latest = { mode: "forced-inline", dispatched: 0, completed: 0, waitMs: 0 };
+        return {
+          cause: new Error("SharedKernel workers were not warmed before frame dispatch."),
+          dispatched: 0,
+          completed: 0,
+          partialWrite: false
+        };
+      }
+      const bindings = spans.flatMap(
+        ({ queryIndex, span }) => splitSharedSpan(bindSharedSpan(kernel, span, queryIndex), laneCount)
+      );
+      if (bindings.length === 0) {
+        latest = { mode: "forced-inline", dispatched: 0, completed: 0, waitMs: 0 };
+        return latest;
+      }
+      if (!bindings.every(isSharedSpan)) {
+        latest = { mode: "forced-inline", dispatched: 0, completed: 0, waitMs: 0 };
+        return {
+          cause: new Error("SharedKernel received a non-SAB QuerySpan."),
+          dispatched: 0,
+          completed: 0,
+          partialWrite: false
+        };
+      }
+      const control = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+      const status = new Int32Array(
+        new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * bindings.length)
+      );
+      const started = performance.now();
+      for (const [index, binding] of bindings.entries()) {
+        const message = {
+          kind: "kernel-job",
+          moduleUrl: kernel.moduleUrl,
+          binding,
+          control,
+          status,
+          jobIndex: index
+        };
+        workers[index % workers.length]?.postMessage(message);
+      }
+      while (Atomics.load(control, 0) < bindings.length) {
+        const observed = Atomics.load(control, 0);
+        const wait = Atomics.wait(control, 0, observed, timeoutMs);
+        if (wait === "timed-out") {
+          for (const worker of workers) worker.terminate();
+          return {
+            cause: new Error(`SharedKernel deadline exceeded after ${timeoutMs}ms.`),
+            dispatched: bindings.length,
+            completed: observed,
+            partialWrite: bindings.length > 0
+          };
+        }
+      }
+      const completed = status.reduce((count, value) => count + (value === 1 ? 1 : 0), 0);
+      const failed = status.some((value) => value === -1);
+      if (failed) {
+        return {
+          cause: new Error("SharedKernel worker failed."),
+          dispatched: bindings.length,
+          completed,
+          partialWrite: bindings.length > 0
+        };
+      }
+      latest = {
+        mode: "shared",
+        dispatched: bindings.length,
+        completed,
+        waitMs: performance.now() - started
+      };
+      return latest;
+    },
+    dispose() {
+      for (const worker of workers) worker.terminate();
+    }
+  };
+}
+
+// src/execution/engine-worker-runtime.ts
+var scope = globalThis;
+var renderer;
+var assets;
+var currentSample = {
+  downKeys: /* @__PURE__ */ new Set(),
+  upKeys: /* @__PURE__ */ new Set(),
+  buttons: [false, false, false],
+  movementX: 0,
+  movementY: 0,
+  wheelDelta: 0,
+  focused: true,
+  pointerLocked: false
+};
+var lastFrameId = 0;
+var engineCanvas;
+var realm;
+var rebuildQueue = new SerializedRebuildQueue();
+var inputBackend = {
+  sample: () => currentSample,
+  detach: () => {
+  }
+};
+function sharedKernelPlugin(target) {
+  return {
+    name: "shared-kernel-executor",
+    inject: ["world"],
+    apply(ctx) {
+      const executor = {
+        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 = void 0;
+        };
+      }, "execution/shared-kernel");
+    }
+  };
+}
+function serializableCause(cause) {
+  return cause instanceof Error ? { name: cause.name, message: cause.message } : { name: "Error", message: String(cause) };
+}
+function serializableDetail(cause) {
+  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, code, expected, hint, cause, partialWrite = false) {
+  scope.postMessage({
+    kind: "fault",
+    worldIdentity: realm?.world.identity ?? null,
+    source,
+    code,
+    expected,
+    hint,
+    detail: serializableDetail(cause),
+    partialWrite,
+    retryable: false
+  });
+}
+async function disposeRealm(target) {
+  await target.pluginContext?.fiber.dispose();
+  target.pluginContext = void 0;
+  target.pendingAudioIntents = [];
+}
+function postBootstrapFault(error) {
+  postFault("bootstrap", error.code, error.expected, error.hint, error.detail);
+}
+async function createRealm(init) {
+  const preparedResult = await prepareBootstrapEntry(init.bootstrapUrl, init.bootstrapData);
+  if (!preparedResult.ok) {
+    postBootstrapFault(preparedResult.error);
+    return false;
+  }
+  const prepared = preparedResult.value;
+  const nextWorld = new World({
+    ...init.time !== void 0 ? { time: init.time } : {},
+    storage: init.tier === "shared" ? "shared" : "local"
+  });
+  const candidate = {
+    world: nextWorld,
+    init,
+    pendingAudioIntents: [],
+    kernelPool: void 0,
+    pluginContext: void 0
+  };
+  const audioBackend = createAudioIntentBackend({
+    emit: (intent) => candidate.pendingAudioIntents.push(intent)
+  });
+  let candidateRenderer;
+  let rendererLifecycleTransferred = false;
+  const previousRenderer = renderer;
+  let previousSurfaceReleased = false;
+  try {
+    if (previousRenderer !== void 0) {
+      const released = previousRenderer.releaseSurface();
+      if (!released.ok) throw released.error;
+      previousSurfaceReleased = true;
+    }
+    const constructed = await constructRuntimeRendererHost(
+      init.canvas,
+      prepared.features === void 0 ? {} : { features: prepared.features },
+      init.shaderManifestUrl === void 0 ? void 0 : { 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 === void 0 ? {} : { port: init.bootstrapPort },
+            setPointerLockAllowed(allowed) {
+              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 !== void 0) await disposeRealm(previousRealm);
+    return true;
+  } catch (cause) {
+    await disposeRealm(candidate);
+    if (!rendererLifecycleTransferred) candidateRenderer?.dispose();
+    if (previousSurfaceReleased) previousRenderer?.restoreSurface();
+    throw cause;
+  }
+}
+async function initialize(message) {
+  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 !== void 0
+    });
+  } 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) {
+  const activeRealm = realm;
+  if (activeRealm === void 0 || renderer === void 0) 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)) : void 0;
+  const canvasHeight = Number.isFinite(message.canvasHeight) && message.canvasHeight > 0 ? Math.max(1, Math.floor(message.canvasHeight)) : void 0;
+  if (canvasWidth !== void 0 && canvasHeight !== void 0) {
+    if (engineCanvas !== void 0) {
+      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" : "forced-inline",
+          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) {
+  const activeRealm = realm;
+  if (activeRealm === void 0 || renderer === void 0 || message.worldIdentity !== activeRealm.world.identity)
+    return;
+  const previousWorldIdentity = activeRealm.world.identity;
+  try {
+    if (engineCanvas === void 0) return;
+    const init = { ...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) => {
+  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 !== void 0) {
+        await disposeRealm(realm);
+        realm = void 0;
+      }
+      scope.close();
+    })();
+  }
+};
+//# sourceMappingURL=engine-worker-runtime.mjs.map
+//# sourceMappingURL=engine-worker-runtime.mjs.map