pelican-engine 0.0.0-stage → 0.3.1

package/lib/renderer/browser.js

@@ -0,0 +1,2015 @@
+import * as THREE from "three/webgpu";
+import { prepareGameplay } from "./gameplay.js";
+import { GPUTracer } from "./pathtrace.js";
+import { SurfaceTracer } from "./surface-tracer.js";
+import { createRenderSettingsDriver, resolveRenderSettings, } from "../runtime/render-settings.js";
+import { buildBVH, extractTriangles } from "./geometry.js";
+import { evaluateGraph, runComputeGraph } from "./graph.js";
+import { uniform } from "three/tsl";
+import { typedGraphToTSL, materialGraphNormalToTSL } from "./graph-tsl.js";
+import { startupPolicy, boundedOperation, runtimeStatus, inspectTraceCapabilities } from "./startup.js";
+import { renderCapabilities, requireCompute, validateRenderCapabilities } from "../runtime/render-capabilities.js";
+import { createComputeDriver } from "../runtime/compute-service.js";
+import { createComputeExecutor } from "./compute-executor.js";
+import { createPostProcessComposer } from "./postprocess.js";
+import { vertexGraphsToTSL } from "./vertex-graphs.js";
+import { createVertexBoundsOwner } from "./vertex-bounds.js";
+import { createRenderBufferBridge } from "./render-buffers.js";
+import { createRenderTextureBridge } from "./render-textures.js";
+import { createComputeTextureAssets } from "./compute-texture-assets.js";
+import { SDK_VERSION } from "../sdk/index.js";
+import { RuntimeHost } from "../runtime/host.js";
+import { resolveEntityDefinition } from "../runtime/prefabs.js";
+import { ResourceManager, } from "../runtime/resources.js";
+import { parseCommand, result as protocolResult, } from "../protocol/index.js";
+import { validateBrowserCheckpoint, prepareCheckpointProbes, selectInspectRecords, } from "./checkpoint.js";
+import { createSimulation } from "../experiments/simulation/index.js";
+import { createWorldProbe } from "../experiments/world/index.js";
+const width = Number(new URLSearchParams(location.search).get("width") ?? 960);
+const height = Number(new URLSearchParams(location.search).get("height") ?? 540);
+const status = document.querySelector("#status");
+const errors = [];
+const startup = startupPolicy(import.meta.env.DEV, location.search);
+let adapterInfo;
+let mode = "raster";
+let tick = 0, playing = false, cameraPhase = 0, bvhMs = 0, uploadMs = 0, submitMs = 0;
+let frameAccumulator = 0;
+let lastStepCpuMs = 0;
+let lastFrameTime;
+let triangleCount = 0, nodeCount = 0, generation = 0;
+let lastGeometryHash = 0;
+const inputLog = [];
+const topologyObjects = [];
+const metrics = [];
+const scene = new THREE.Scene();
+const probeEnabled = new URLSearchParams(location.search).get("probe") === "m0";
+const probeRoot = new THREE.Group();
+probeRoot.visible = probeEnabled;
+scene.add(probeRoot);
+scene.background = new THREE.Color("#111d2a");
+const camera = new THREE.PerspectiveCamera(48, width / height, 0.05, 100);
+const rasterCanvas = document.createElement("canvas"), traceCanvas = document.createElement("canvas");
+for (const canvas of [rasterCanvas, traceCanvas]) {
+    canvas.style.position = "absolute";
+    canvas.style.left = "0";
+    canvas.style.top = "0";
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+    document.body.appendChild(canvas);
+}
+traceCanvas.style.pointerEvents = "none";
+traceCanvas.style.display = "none";
+const standard = (color, roughness = 0.75) => new THREE.MeshStandardMaterial({ color, roughness });
+const ground = new THREE.Mesh(new THREE.BoxGeometry(14, 0.2, 14), standard(0x7c8797));
+ground.position.y = -0.2;
+ground.receiveShadow = true;
+probeRoot.add(ground);
+const back = new THREE.Mesh(new THREE.BoxGeometry(14, 5, 0.15), standard(0x243b50));
+back.position.set(0, 2.2, -4);
+probeRoot.add(back);
+const box = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), standard(0xe5923f, 0.25));
+box.position.set(-1.6, 0.5, 0);
+box.castShadow = true;
+probeRoot.add(box);
+const morphGeo = new THREE.SphereGeometry(0.7, 12, 8);
+const original = morphGeo.getAttribute("position");
+const morph = original.clone();
+for (let i = 0; i < morph.count; i++)
+    morph.setXYZ(i, original.getX(i) * (1 + 0.4 * Math.sin(original.getY(i) * 5)), original.getY(i) * 1.5, original.getZ(i));
+morphGeo.morphAttributes.position = [morph];
+const morphMesh = new THREE.Mesh(morphGeo, standard(0x36a8a1, 0.4));
+morphMesh.position.set(1.5, 0.8, -0.2);
+morphMesh.castShadow = true;
+probeRoot.add(morphMesh);
+const skinGeo = new THREE.CylinderGeometry(0.24, 0.35, 1.8, 8, 6);
+const positions = skinGeo.getAttribute("position");
+const indices = [], weights = [];
+for (let i = 0; i < positions.count; i++) {
+    const y = positions.getY(i);
+    const factor = Math.max(0, Math.min(1, (y + 0.3) / 1.2));
+    indices.push(0, 1, 0, 0);
+    weights.push(1 - factor, factor, 0, 0);
+}
+skinGeo.setAttribute("skinIndex", new THREE.Uint16BufferAttribute(indices, 4));
+skinGeo.setAttribute("skinWeight", new THREE.Float32BufferAttribute(weights, 4));
+const skinned = new THREE.SkinnedMesh(skinGeo, standard(0xc24f72));
+const root = new THREE.Bone(), tip = new THREE.Bone();
+root.position.y = -0.9;
+tip.position.y = 0.9;
+root.add(tip);
+skinned.add(root);
+skinned.bind(new THREE.Skeleton([root, tip]));
+skinned.position.set(0, 1, -1.4);
+probeRoot.add(skinned);
+const lamp = new THREE.PointLight(0xffdfb0, 100, 30, 2);
+lamp.position.set(-3, 6, 3);
+lamp.castShadow = true;
+lamp.shadow.mapSize.set(1024, 1024);
+probeRoot.add(lamp, new THREE.HemisphereLight(0xa4c8f0, 0x26321d, 1));
+let renderer, tracer, device;
+let backendKind = "uninitialized";
+let contextWasPlaying = false;
+let waitingForWebglRestore = false;
+let pendingSurface;
+const lostDevices = new WeakSet();
+const lostRenderers = new WeakSet();
+let surfaceTracer;
+let renderControl;
+let computeControl;
+let computeExecutor;
+let renderBufferBridge;
+let renderTextureBridge;
+let postComposer;
+let vertexBounds;
+let legacyTracerDisposed = false;
+let recoveringGpu = false;
+let recoveryTask;
+let recoveryCount = 0;
+let drawTail = Promise.resolve();
+let tickTail = Promise.resolve();
+let nativeInputTail = Promise.resolve();
+let inputDrawActive = false, inputDrawRequested = false;
+let frameSerial = 0;
+const recoveryEvents = [];
+const gameObjects = new Map();
+const gameRoot = new THREE.Group();
+scene.add(gameRoot);
+let authoredCamera = { position: [0, 3.4, 7], target: [0, 0.9, 0] };
+let authoredLights = [];
+let compiledIR = null;
+let runtime;
+const resourceManager = new ResourceManager();
+resourceManager.registerLoader("json", {
+    async load(descriptor, signal) {
+        const response = await fetch(descriptor.url, { signal });
+        if (!response.ok)
+            throw new Error(`TC_RESOURCE_HTTP: ${response.status}`);
+        return response.json();
+    },
+    dispose() { },
+});
+resourceManager.registerLoader("module", {
+    async load(descriptor, signal) {
+        const module = await import(/* @vite-ignore */ descriptor.url);
+        if (signal.aborted)
+            throw new Error("TC_RESOURCE_CANCELLED");
+        if (typeof module.createGame !== "function")
+            throw new Error("TC_GAME_EXPORT");
+        return module;
+    },
+    dispose() { },
+});
+let gameplay;
+let contentScope;
+let contentGeneration = 0;
+let loadingContent = false;
+let disposed = false;
+let terminalFault = false;
+let restoring = false;
+let frameRequest;
+let disposal;
+let gameMaterials = new Map();
+const componentState = new Map();
+const transforms = new Map();
+const materialGraphs = [];
+const graphTime = uniform(0);
+function slotTypes(graphs) { return Object.assign({}, ...graphs.map(graph => graph.bufferTypes ?? {})); }
+function materialSlotTypes(binding) { return slotTypes([...Object.values(binding.graphs), ...Object.values(binding.vertex ?? {})]); }
+function textureSlotTypes(graphs) { return Object.assign({}, ...graphs.map(graph => graph.textureSlots ?? {})); }
+function materialTextureTypes(binding) { return textureSlotTypes([...Object.values(binding.graphs), ...Object.values(binding.vertex ?? {})]); }
+function usesRenderTextures(ir) { return ir.materials.some(d => Object.keys(textureSlotTypes([...(d.graph ? [d.graph] : []), ...Object.values(d.graphs ?? {}), ...Object.values(d.vertex ?? {})])).length) || ir.postProcesses?.some(d => Object.keys(d.graph.textureSlots ?? {}).length); }
+function usesRenderSlots(ir) { return ir.materials.some(d => Object.keys(slotTypes([...(d.graph ? [d.graph] : []), ...Object.values(d.graphs ?? {}), ...Object.values(d.vertex ?? {})])).length) || ir.postProcesses?.some(d => Object.keys(d.graph.bufferTypes ?? {}).length); }
+function slotResources(owner, id) { return id.startsWith("$post.") ? owner.effectBuffers.resources(id.slice(6)) : owner.buffers.resources(id); }
+function textureResources(owner, id) { return id.startsWith("$post.") ? owner.effectTextures.resources(id.slice(6)) : owner.textures.resources(id); }
+function applyMaterialGraphs(material, binding, uniforms, bridge, textureBridge) {
+    const slots = materialSlotTypes(binding);
+    if (Object.keys(slots).length) {
+        if (!bridge)
+            throw new Error("TC_RENDER_BUFFER_CAPABILITY: Material storage slots require a managed WebGPU bridge.");
+        bridge.prepare(material, slots);
+    }
+    const textureSlots = materialTextureTypes(binding);
+    if (Object.keys(textureSlots).length) {
+        if (!textureBridge)
+            throw new Error("TC_RENDER_TEXTURE_CAPABILITY: Material texture slots require a managed WebGPU bridge.");
+        textureBridge.prepare(material, textureSlots);
+    }
+    const sampleTextureSlot = (name, uv) => textureBridge.node(material, name, uv, textureSlots[name]);
+    for (const [channel, graph] of Object.entries(binding.graphs)) {
+        let node = typedGraphToTSL(graph, graphTime, uniforms, binding.textures, {
+            readBuffer: (name, index, type) => bridge.node(material, name, index, type, true),
+            sampleTextureSlot,
+        });
+        if (channel === "normalWorld")
+            node = materialGraphNormalToTSL(node);
+        else if (["roughness", "metalness", "opacity"].includes(channel))
+            node = node.clamp(0, 1);
+        const key = { baseColor: "colorNode", emissive: "emissiveNode", roughness: "roughnessNode", metalness: "metalnessNode", opacity: "opacityNode", normalWorld: "normalNode" }[channel];
+        material[key] = node;
+    }
+    if (binding.graphs.opacity) {
+        material.transparent = true;
+        material.alphaMap = null;
+    }
+    if (binding.vertex) {
+        material.positionNode = vertexGraphsToTSL(binding, graphTime, uniforms, binding.textures, (name, index, type) => bridge.node(material, name, index, type), sampleTextureSlot);
+        material.userData.pelicanVertexNormal = Boolean(binding.vertex.normal);
+    }
+    material.needsUpdate = true;
+}
+const componentsId = (component) => typeof component === "string" ? component : component.id;
+const facade = {
+    getTransform(id) {
+        if (!runtime)
+            throw new Error("TC_RUNTIME_NOT_ATTACHED");
+        return runtime.facade.getTransform(id);
+    },
+    setTransform(id, patch) {
+        if (!runtime)
+            throw new Error("TC_RUNTIME_NOT_ATTACHED");
+        runtime.facade.setTransform(id, patch);
+        syncRuntime();
+    },
+    getComponent(id, component) {
+        if (!runtime)
+            throw new Error("TC_RUNTIME_NOT_ATTACHED");
+        return runtime.facade.getComponent(id, componentsId(component));
+    },
+    setComponent(id, component, value) {
+        if (!runtime)
+            throw new Error("TC_RUNTIME_NOT_ATTACHED");
+        runtime.facade.setComponent(id, componentsId(component), value);
+        syncRuntime();
+    },
+    query(component) {
+        return runtime?.world.query(componentsId(component)) ?? [];
+    },
+};
+function reportFailure(error) {
+    if (disposed)
+        return;
+    playing = false;
+    terminalFault = true;
+    lastFrameTime = undefined;
+    const message = String(error);
+    errors.push(message);
+    if (document.documentElement) {
+        document.documentElement.dataset.pelicanReady = "false";
+        document.documentElement.dataset.pelicanFailure = message;
+    }
+    status.hidden = false;
+    status.textContent = message;
+    console.error(error);
+}
+function requireRuntime() {
+    if (disposed)
+        throw new Error("TC_BROWSER_DISPOSED: Reload the page before issuing commands.");
+    if (loadingContent || restoring || recoveringGpu)
+        throw new Error("TC_CONTENT_BUSY: Wait for the current content or GPU recovery transaction.");
+    if (!runtime)
+        throw new Error("TC_RUNTIME_NOT_ATTACHED");
+    return runtime;
+}
+function releaseObject(root, releaseMaterials = false, ownedMaterials = []) {
+    const geometries = new Set();
+    const materials = new Set(ownedMaterials);
+    root.traverse((object) => {
+        if (object instanceof THREE.Mesh) {
+            geometries.add(object.geometry);
+            if (releaseMaterials)
+                for (const material of Array.isArray(object.material)
+                    ? object.material
+                    : [object.material])
+                    materials.add(material);
+        }
+        if (object instanceof THREE.SkinnedMesh)
+            object.skeleton.dispose();
+        if (object instanceof THREE.Light && "shadow" in object)
+            object.shadow?.dispose();
+    });
+    for (const geometry of geometries)
+        geometry.dispose();
+    for (const material of materials)
+        material.dispose();
+    root.userData.lightTarget?.removeFromParent();
+    root.removeFromParent();
+    root.clear();
+}
+function createEntityView(entity, materials) {
+    const node = new THREE.Group();
+    node.name = entity.id;
+    if (entity.light) {
+        const light = entity.light.kind === "point"
+            ? new THREE.PointLight(entity.light.color ?? "#ffffff", entity.light.intensity ?? 1)
+            : new THREE.DirectionalLight(entity.light.color ?? "#ffffff", entity.light.intensity ?? 1);
+        light.castShadow = entity.light.castShadow ?? false;
+        if (light instanceof THREE.DirectionalLight) {
+            light.target.position.fromArray(entity.light.target ?? [0, 0, 0]);
+            // Targets use world coordinates and must remain outside the transformed light group.
+            node.userData.lightTarget = light.target;
+        }
+        if ("shadow" in light) {
+            const shadow = entity.light.shadow;
+            light.shadow.mapSize.set(shadow?.mapSize ?? 2048, shadow?.mapSize ?? 2048);
+            light.shadow.bias = shadow?.bias ?? -0.0001;
+            light.shadow.normalBias = shadow?.normalBias ?? 0.04;
+            light.shadow.camera.near = shadow?.near ?? 0.1;
+            light.shadow.camera.far = shadow?.far ?? 100;
+            if (light instanceof THREE.DirectionalLight) {
+                const extent = shadow?.extent ?? 20;
+                Object.assign(light.shadow.camera, {
+                    left: -extent,
+                    right: extent,
+                    top: extent,
+                    bottom: -extent,
+                });
+            }
+            light.shadow.camera.updateProjectionMatrix();
+        }
+        node.add(light);
+    }
+    if (entity.mesh) {
+        const material = materials.get(entity.mesh.material);
+        if (!material)
+            throw new Error(`TC_MATERIAL_MISSING: ${entity.mesh.material}`);
+        const g = entity.mesh.geometry;
+        const geometry = g.kind === "box"
+            ? new THREE.BoxGeometry(...(g.size ?? [1, 1, 1]))
+            : g.kind === "sphere"
+                ? new THREE.SphereGeometry(g.radius ?? 0.5, g.segments ?? 12, 8)
+                : new THREE.PlaneGeometry(...(g.size ?? [1, 1]));
+        for (const input of material.userData.pelicanGraphInputs ?? []) {
+            if ((input === "uv" || input === "uv1") && !geometry.hasAttribute(input)) {
+                geometry.dispose();
+                throw new Error(`TC_GRAPH_UV: Material ${entity.mesh.material} requires ${input} on entity ${entity.id}. Use geometry with that UV channel or change the graph.`);
+            }
+        }
+        const mesh = new THREE.Mesh(geometry, material);
+        mesh.castShadow = entity.mesh.castShadow;
+        mesh.receiveShadow = entity.mesh.receiveShadow;
+        node.add(mesh);
+    }
+    return node;
+}
+function syncRuntime() {
+    if (!runtime)
+        return;
+    transforms.clear();
+    componentState.clear();
+    const records = runtime.world.records();
+    const live = new Set(records.map((record) => record.id));
+    const modelRecords = compiledIR
+        ? records.filter((record) => resolveEntityDefinition(compiledIR, record)?.model)
+        : [];
+    gameplay?.models.reconcileBindings(modelRecords.map((record) => ({
+        entity: record.id,
+        definition: resolveEntityDefinition(compiledIR, record).model,
+    })));
+    // Each entity view owns its own visual subtree; detach tracked descendants before disposal.
+    const prefabById = new Map(records.map((record) => [record.id, record.prefab]));
+    const removed = new Set([...gameObjects]
+        .filter(([id, object]) => !live.has(id) || object.userData.pelicanPrefab !== prefabById.get(id))
+        .map(([, object]) => object));
+    for (const object of gameObjects.values())
+        for (let parent = object.parent; parent; parent = parent.parent)
+            if (removed.has(parent)) {
+                gameRoot.add(object);
+                break;
+            }
+    for (const [id, object] of gameObjects)
+        if (!live.has(id)) {
+            gameplay?.models.remove(id);
+            releaseObject(object);
+            gameObjects.delete(id);
+        }
+    for (const record of records) {
+        transforms.set(record.id, structuredClone(record.transform));
+        componentState.set(record.id, structuredClone(record.components));
+        let object = gameObjects.get(record.id);
+        if (object && object.userData.pelicanPrefab !== record.prefab) {
+            gameplay?.models.get(record.id)?.node.removeFromParent();
+            releaseObject(object);
+            gameObjects.delete(record.id);
+            object = undefined;
+        }
+        if (!object) {
+            const authored = compiledIR
+                ? resolveEntityDefinition(compiledIR, record)
+                : undefined;
+            object = authored
+                ? createEntityView(authored, gameMaterials)
+                : new THREE.Group();
+            object.name = record.id;
+            object.userData.pelicanPrefab = record.prefab;
+            gameRoot.add(object);
+            if (object.userData.lightTarget)
+                gameRoot.add(object.userData.lightTarget);
+            gameObjects.set(record.id, object);
+        }
+        if (modelRecords.some((model) => model.id === record.id))
+            gameplay?.models.attach(record.id, object);
+        object.position.fromArray(record.transform.position);
+        object.rotation.set(...record.transform.rotation);
+        object.scale.fromArray(record.transform.scale);
+    }
+    for (const record of records) {
+        const object = gameObjects.get(record.id);
+        const parent = record.parent ? gameObjects.get(record.parent) : gameRoot;
+        if (parent && object.parent !== parent)
+            parent.add(object);
+    }
+    gameRoot.updateMatrixWorld(true);
+    authoredLights = [];
+    for (const entity of compiledIR?.scene.entities ?? [])
+        if (entity.light) {
+            const light = gameObjects
+                .get(entity.id)
+                ?.children.find((child) => child instanceof THREE.Light);
+            if (light)
+                authoredLights.push({ definition: entity.light, object: light });
+        }
+}
+let simulation;
+const simulationGroup = new THREE.Group();
+scene.add(simulationGroup);
+let world;
+const worldGroup = new THREE.Group();
+scene.add(worldGroup);
+function syncWorld() {
+    for (const child of [...worldGroup.children]) {
+        worldGroup.remove(child);
+        if (child instanceof THREE.Mesh) {
+            child.geometry.dispose();
+            child.material.dispose();
+        }
+    }
+    if (!world)
+        return;
+    for (const chunk of world.getRenderState().chunks) {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute("position", new THREE.Float32BufferAttribute(chunk.positions, 3));
+        geometry.setIndex(chunk.indices);
+        geometry.computeVertexNormals();
+        const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({
+            color: 0x61935c,
+            roughness: 0.9,
+            side: THREE.DoubleSide,
+        }));
+        mesh.position.set(0, 0.15, -1);
+        worldGroup.add(mesh);
+    }
+}
+function syncSimulation() {
+    // Rebuild the deliberately tiny probe representation; production pooling is a later milestone.
+    for (const child of [...simulationGroup.children]) {
+        simulationGroup.remove(child);
+        if (child instanceof THREE.Mesh) {
+            child.geometry.dispose();
+            child.material.dispose();
+        }
+    }
+    if (!simulation)
+        return;
+    const state = simulation.getRenderState();
+    const offset = new THREE.Vector3(0, 0.3, 1.4);
+    for (const [list, color] of [
+        [state.bodies, 0xffb54a],
+        [state.particles, 0x4ea9d9],
+    ])
+        for (const particle of list) {
+            const mesh = new THREE.Mesh(new THREE.IcosahedronGeometry(particle.radius, 0), standard(color, 0.5));
+            mesh.position.fromArray(particle.position).add(offset);
+            simulationGroup.add(mesh);
+        }
+    if (state.triangles.length) {
+        const vertices = [];
+        for (const triangle of state.triangles)
+            for (const index of triangle)
+                vertices.push(...new THREE.Vector3()
+                    .fromArray(state.particles[index].position)
+                    .add(offset)
+                    .toArray());
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute("position", new THREE.Float32BufferAttribute(vertices, 3));
+        geometry.computeVertexNormals();
+        const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({
+            color: 0x7bd1cd,
+            side: THREE.DoubleSide,
+            roughness: 0.7,
+        }));
+        simulationGroup.add(mesh);
+    }
+}
+async function loadGame(sceneId, saved, loadSlot) {
+    if (disposed)
+        throw new Error("TC_BROWSER_DISPOSED");
+    if (loadingContent || restoring)
+        throw new Error("TC_CONTENT_BUSY: Wait for the current content transaction.");
+    loadingContent = true;
+    let nextScope;
+    let nextGameplay;
+    let nextRender;
+    let nextCompute;
+    let nextPostComposer;
+    let nextVertexBounds;
+    let nextComputeExecutor;
+    let nextRenderBufferBridge;
+    let nextRenderTextureBridge;
+    let candidate;
+    let candidateGame;
+    let attached = false;
+    let committed = false;
+    const nextRoot = new THREE.Group();
+    const nextMaterials = new Map();
+    const nextObjects = new Map();
+    const nextGraphs = [];
+    try {
+        nextScope = resourceManager.createScope();
+        const generation = ++contentGeneration;
+        const sceneURL = new URL(`${import.meta.env.BASE_URL}generated/scene.ir.json`, document.baseURI);
+        sceneURL.searchParams.set("v", String(generation));
+        const sceneLease = await resourceManager.acquire("json", `compiled-scene-${generation}`, { url: sceneURL.href }, nextScope);
+        const ir = structuredClone(resourceManager.get(sceneLease.handle));
+        if (!ir || ir.format !== "pelican.scene" || ir.version !== 1)
+            throw new Error("TC_IR_VERSION");
+        if (sceneId && sceneId !== ir.scene.id) {
+            const selected = ir.scenes?.find((entry) => entry.id === sceneId);
+            if (!selected)
+                throw new Error("TC_SCENE_MISSING: " + sceneId);
+            ir.scenes = [
+                ir.scene,
+                ...(ir.scenes ?? []).filter((entry) => entry.id !== sceneId),
+            ];
+            ir.scene = selected;
+        }
+        if (saved &&
+            (saved.format !== "pelican.save" ||
+                saved.version !== 1 ||
+                saved.engineVersion !== SDK_VERSION ||
+                saved.gameId !== ir.gameId ||
+                JSON.stringify(saved.assets) !==
+                    JSON.stringify(Object.fromEntries(ir.assets.map((a) => [a.id, a.hash])))))
+            throw new Error("TC_SAVE_VERSION: Save does not match this game version and asset set.");
+        // Normal games have SDK services even when their content is only primitives.
+        if (!probeEnabled ||
+            ir.input ||
+            ir.ui ||
+            ir.sounds ||
+            ir.scene.follow ||
+            ir.scene.environment.lighting === "studio" ||
+            [...ir.scene.entities, ...ir.prefabs].some((entity) => entity.model || entity.rigidBody || entity.character) ||
+            ir.materials.some((material) => material.texture))
+            nextGameplay = await prepareGameplay(ir, new URL(import.meta.env.BASE_URL + "generated/", document.baseURI).href, renderer, nextMaterials);
+        nextComputeExecutor = backendKind === "webgpu" && (ir.computes.length || ir.computeBuffers?.length || ir.computeTextures?.length) ? createComputeExecutor(device) : undefined;
+        nextCompute = createComputeDriver({
+            kernels: ir.computes,
+            buffers: ir.computeBuffers,
+            textures: ir.computeTextures,
+            textureAssets: createComputeTextureAssets(nextGameplay?.textures ?? new Map()),
+            capabilities: () => renderCapabilities(backendKind),
+            time: () => candidate?.facade.time.elapsed ?? 0,
+            executor: nextComputeExecutor,
+        });
+        nextRender = createRenderSettingsDriver(ir.render ?? {}, ir.materials, () => renderCapabilities(backendKind), ir.postProcesses, {
+            describe: handle => { const descriptor = nextCompute.service.describeBuffer(handle); return { id: descriptor.id, type: descriptor.type, count: descriptor.count }; },
+            resource: id => nextCompute.resource(id),
+            setPins: ids => nextCompute.setRenderPins(ids),
+        }, {
+            describe: handle => { const { id, width, height, format } = nextCompute.service.describeTexture(handle); return { id, width, height, format }; },
+            resource: id => nextCompute.textureResource(id),
+            setPins: ids => nextCompute.setRenderPins(ids),
+        });
+        if (usesRenderSlots(ir))
+            nextRenderBufferBridge = createRenderBufferBridge(renderer, () => computeExecutor, id => slotResources(nextRender, id));
+        if (usesRenderTextures(ir))
+            nextRenderTextureBridge = createRenderTextureBridge(renderer, () => computeExecutor, id => textureResources(nextRender, id));
+        candidate = new RuntimeHost(ir, {
+            plugins: [nextRender.factory, nextCompute.factory, ...(nextGameplay?.plugins ?? [])],
+        });
+        const gameURL = new URL(`${import.meta.env.BASE_URL}generated/game.js`, document.baseURI);
+        gameURL.searchParams.set("v", String(generation));
+        const moduleLease = await resourceManager.acquire("module", `compiled-game-${generation}`, { url: gameURL.href }, nextScope);
+        const module = resourceManager.get(moduleLease.handle);
+        candidateGame = module.createGame(candidate.facade);
+        candidate.attach(candidateGame);
+        attached = true;
+        if (ir.postProcesses?.length)
+            nextPostComposer = createPostProcessComposer(renderer, width, height, ir.postProcesses, nextGameplay?.textures ?? new Map(), nextRenderBufferBridge, nextRenderTextureBridge);
+        const nextCamera = {
+            position: [...ir.scene.camera.position],
+            target: [...ir.scene.camera.target],
+        };
+        const nextBackground = new THREE.Color(ir.scene.environment.background);
+        const ambient = new THREE.HemisphereLight(0xa4c8f0, 0x26321d, ir.scene.environment.ambientIntensity);
+        nextRoot.add(ambient);
+        for (const definition of ir.materials) {
+            const Material = (definition.transmission ?? 0) > 0 || definition.ior !== undefined || definition.specularIntensity !== undefined || definition.specularColor !== undefined
+                ? THREE.MeshPhysicalNodeMaterial
+                : THREE.MeshStandardNodeMaterial;
+            const material = new Material({
+                color: definition.color,
+                roughness: definition.roughness,
+                metalness: definition.metalness,
+                emissive: definition.emissive ?? "#000000",
+                emissiveIntensity: definition.emissiveIntensity ?? 1,
+                opacity: definition.opacity ?? 1,
+                transparent: (definition.opacity ?? 1) < 1,
+                alphaTest: definition.alphaTest ?? 0,
+                side: definition.side === "double"
+                    ? THREE.DoubleSide
+                    : definition.side === "back"
+                        ? THREE.BackSide
+                        : THREE.FrontSide,
+            });
+            if (material instanceof THREE.MeshPhysicalNodeMaterial) {
+                material.transmission = definition.transmission ?? 0;
+                material.ior = definition.ior ?? 1.5;
+                material.specularIntensity = definition.specularIntensity ?? 1;
+                material.specularColor.set(definition.specularColor ?? "#ffffff");
+                material.attenuationColor.set(definition.attenuationColor ?? "#ffffff");
+                material.attenuationDistance =
+                    definition.attenuationDistance ?? Infinity;
+            }
+            material.name = definition.id;
+            if (definition.texture)
+                material.map = nextGameplay.textures.get(definition.texture);
+            nextMaterials.set(definition.id, material);
+            if (definition.graph || definition.graphs || definition.vertex) {
+                const graphs = { ...(definition.graph ? { baseColor: definition.graph } : {}), ...definition.graphs };
+                const uniforms = new Map();
+                for (const p of definition.parameters ?? []) {
+                    const value = Array.isArray(p.default) ? p.default.length === 2 ? new THREE.Vector2(...p.default) : p.default.length === 3 ? new THREE.Vector3(...p.default) : new THREE.Vector4(...p.default) : p.default;
+                    uniforms.set(p.name, uniform(value, p.type));
+                }
+                const textures = nextGameplay?.textures ?? new Map();
+                const binding = { id: definition.id, graphs, ...(definition.vertex ? { vertex: definition.vertex } : {}), time: 0, parameters: nextRender.service.materialParameters(definition.id), textures };
+                if (Object.keys(materialSlotTypes(binding)).length)
+                    binding.buffers = nextRender.buffers.resources(definition.id);
+                if (Object.keys(materialTextureTypes(binding)).length)
+                    binding.managedTextures = nextRender.textures.resources(definition.id);
+                applyMaterialGraphs(material, binding, uniforms, nextRenderBufferBridge, nextRenderTextureBridge);
+                material.userData.pelicanGraphInputs = [...new Set([...Object.values(graphs), ...Object.values(definition.vertex ?? {})].flatMap(graph => graph.requiredInputs ?? []))];
+                nextGraphs.push({ material, graph: definition.graph, binding, uniforms });
+            }
+        }
+        for (const entity of ir.scene.entities) {
+            const node = createEntityView(entity, nextMaterials);
+            node.userData.pelicanPrefab = entity.prefab;
+            if (entity.model)
+                nextGameplay.models.instantiate(entity.id, entity.model, node);
+            node.position.fromArray(entity.transform.position);
+            node.rotation.set(...entity.transform.rotation);
+            node.scale.fromArray(entity.transform.scale);
+            nextRoot.add(node);
+            if (node.userData.lightTarget)
+                nextRoot.add(node.userData.lightTarget);
+            nextObjects.set(entity.id, node);
+        }
+        for (const entity of ir.scene.entities)
+            if (entity.parent)
+                nextObjects.get(entity.parent).add(nextObjects.get(entity.id));
+        nextRoot.traverse(object => {
+            if (!(object instanceof THREE.Mesh))
+                return;
+            for (const material of Array.isArray(object.material) ? object.material : [object.material]) {
+                for (const input of material.userData.pelicanGraphInputs ?? [])
+                    if ((input === "uv" || input === "uv1") && !object.geometry.hasAttribute(input))
+                        throw new Error(`TC_GRAPH_UV: Material ${material.name} requires ${input} on object ${object.name || object.uuid}.`);
+                if (material.userData.pelicanVertexNormal && !object.geometry.hasAttribute("normal"))
+                    throw new Error("TC_VERTEX_NORMAL_ATTRIBUTE: Vertex normal graphs require a normal attribute.");
+            }
+        });
+        if (saved) {
+            if (loadSlot)
+                nextGameplay?.services.adoptStorageRequest("load", loadSlot);
+            candidate.restore(saved.runtime);
+        }
+        if (nextGraphs.some(item => item.binding.vertex)) {
+            nextVertexBounds = createVertexBoundsOwner();
+            for (const item of nextGraphs) {
+                item.binding.time = candidate.inspect().scheduler.tick / 60;
+                item.binding.parameters = nextRender.service.materialParameters(item.binding.id);
+                if (item.binding.buffers)
+                    item.binding.buffers = nextRender.buffers.resources(item.binding.id);
+                if (item.binding.managedTextures)
+                    item.binding.managedTextures = nextRender.textures.resources(item.binding.id);
+            }
+            const boundsScene = new THREE.Scene();
+            boundsScene.add(nextRoot);
+            nextVertexBounds.update(boundsScene, new Map(nextGraphs.map(item => [item.material, item.binding])));
+            nextRoot.removeFromParent();
+        }
+        if (disposed)
+            throw new Error("TC_BROWSER_DISPOSED");
+        // No await in commit: a complete host/view/scope replaces the previous content together.
+        const previous = runtime, previousScope = contentScope, previousMaterials = gameMaterials, previousGameplay = gameplay, previousPostComposer = postComposer, previousVertexBounds = vertexBounds, previousRenderBufferBridge = renderBufferBridge, previousRenderTextureBridge = renderTextureBridge;
+        const previousRoot = new THREE.Group();
+        if (gameRoot.children.length)
+            previousRoot.add(...gameRoot.children);
+        compiledIR = ir;
+        runtime = candidate;
+        renderControl = nextRender;
+        computeControl = nextCompute;
+        computeExecutor = nextComputeExecutor;
+        renderBufferBridge = nextRenderBufferBridge;
+        renderTextureBridge = nextRenderTextureBridge;
+        postComposer = nextPostComposer;
+        vertexBounds = nextVertexBounds;
+        surfaceTracer?.clearContent();
+        gameplay = nextGameplay;
+        contentScope = nextScope;
+        gameMaterials = nextMaterials;
+        committed = true;
+        if (nextRoot.children.length)
+            gameRoot.add(...nextRoot.children);
+        gameObjects.clear();
+        for (const [id, node] of nextObjects)
+            gameObjects.set(id, node);
+        materialGraphs.splice(0, materialGraphs.length, ...nextGraphs);
+        authoredCamera = nextCamera;
+        scene.background = nextBackground;
+        scene.environment = nextGameplay?.environment ?? null;
+        camera.fov = ir.scene.camera.fov;
+        camera.near = ir.scene.camera.near;
+        camera.far = ir.scene.camera.far;
+        camera.updateProjectionMatrix();
+        tick = candidate.inspect().scheduler.tick;
+        frameAccumulator = 0;
+        lastFrameTime = undefined;
+        inputLog.length = 0;
+        terminalFault = false;
+        syncRuntime();
+        nextGameplay?.mount((key, pressed) => {
+            if (!loadingContent && !restoring && !disposed)
+                runtime?.input(key, pressed);
+        }, (type, payload) => {
+            if (!loadingContent && !restoring && !disposed)
+                runtime?.emitExternal(type, payload);
+        });
+        try {
+            previous?.dispose();
+        }
+        catch (error) {
+            errors.push(`TC_CONTENT_CLEANUP: ${String(error)}`);
+        }
+        await previousGameplay?.dispose();
+        previousPostComposer?.dispose();
+        previousVertexBounds?.dispose();
+        previousRenderBufferBridge?.dispose();
+        previousRenderTextureBridge?.dispose();
+        releaseObject(previousRoot);
+        for (const material of previousMaterials.values())
+            material.dispose();
+        await previousScope?.release();
+        return ir;
+    }
+    catch (error) {
+        if (!committed) {
+            try {
+                if (attached)
+                    candidate?.dispose();
+                else {
+                    try {
+                        candidateGame?.dispose();
+                    }
+                    finally {
+                        candidate?.dispose();
+                    }
+                }
+            }
+            catch (cleanupError) {
+                errors.push(`TC_CONTENT_CLEANUP: ${String(cleanupError)}`);
+            }
+            await nextGameplay?.dispose();
+            nextRender?.dispose();
+            nextCompute?.dispose();
+            nextPostComposer?.dispose();
+            nextVertexBounds?.dispose();
+            nextRenderBufferBridge?.dispose();
+            nextRenderTextureBridge?.dispose();
+            releaseObject(nextRoot);
+            for (const material of nextMaterials.values())
+                material.dispose();
+            await nextScope?.release();
+        }
+        throw error;
+    }
+    finally {
+        loadingContent = false;
+    }
+}
+/** Only completed fixed ticks may request browser persistence or scene transactions. */
+async function processGameRequests() {
+    await computeControl?.flush();
+    if (!gameplay || !compiledIR || !runtime)
+        return;
+    const requests = gameplay.services.takeRequests();
+    for (const request of requests) {
+        if (request.type === "scene") {
+            await loadGame(request.id);
+            continue;
+        }
+        const slot = request.id;
+        const key = "pelican:" + compiledIR.gameId + ":" + slot;
+        try {
+            if (request.type === "save") {
+                syncRuntime();
+                const saved = {
+                    format: "pelican.save",
+                    version: 1,
+                    engineVersion: SDK_VERSION,
+                    gameId: compiledIR.gameId,
+                    sceneId: compiledIR.scene.id,
+                    assets: Object.fromEntries(compiledIR.assets.map((a) => [a.id, a.hash])),
+                    runtime: runtime.snapshot(),
+                };
+                localStorage.setItem(key, JSON.stringify(saved));
+                gameplay.services.storageComplete("save", slot);
+            }
+            else {
+                const text = localStorage.getItem(key);
+                if (text === null)
+                    throw new Error("TC_SAVE_MISSING: " + slot);
+                const saved = JSON.parse(text);
+                if (!saved || typeof saved.sceneId !== "string")
+                    throw new Error("TC_SAVE_FORMAT");
+                await loadGame(saved.sceneId, saved, slot);
+                gameplay.services.storageComplete("load", slot);
+            }
+        }
+        catch (error) {
+            gameplay?.services.storageComplete(request.type, slot, String(error));
+        }
+    }
+}
+function animate() {
+    const time = tick / 60;
+    graphTime.value = time;
+    for (const item of materialGraphs) {
+        item.binding.time = time;
+        item.binding.parameters = renderControl.service.materialParameters(item.binding.id);
+        if (item.binding.buffers)
+            item.binding.buffers = renderControl.buffers.resources(item.binding.id);
+        if (item.binding.managedTextures)
+            item.binding.managedTextures = renderControl.textures.resources(item.binding.id);
+        for (const [name, parameter] of item.uniforms) {
+            const value = item.binding.parameters[name];
+            if (Array.isArray(value))
+                parameter.value.fromArray(value);
+            else
+                parameter.value = value;
+        }
+        if (probeEnabled && item.graph) {
+            const value = evaluateGraph(item.graph, time);
+            if (typeof value === "boolean")
+                throw Error("TC_GRAPH_TYPE: Legacy color graph must return vec3.");
+            item.material.color.fromArray(typeof value === "number" ? [value, value, value] : [...value]);
+        }
+    }
+    box.position.x = -1.6 + Math.sin(time) * 0.65;
+    box.rotation.y = time * 0.5;
+    morphMesh.morphTargetInfluences[0] = (Math.sin(time * 1.3) + 1) * 0.5;
+    tip.rotation.z = Math.sin(time * 1.8) * 0.5;
+    const base = new THREE.Vector3().fromArray(authoredCamera.position), target = new THREE.Vector3().fromArray(authoredCamera.target);
+    const offset = base
+        .sub(target)
+        .applyAxisAngle(new THREE.Vector3(0, 1, 0), cameraPhase);
+    if (!gameplay?.services.inspect().camera) {
+        camera.position.copy(target).add(offset);
+        camera.lookAt(target);
+    }
+    camera.updateMatrixWorld();
+    vertexBounds?.update(scene, new Map(materialGraphs.map(item => [item.material, item.binding])));
+    gameplay?.present(camera, gameObjects, playing ? 1 / 60 : 0, tick);
+}
+function updateTraceGeometry() {
+    const start = performance.now();
+    const geometry = buildBVH(extractTriangles(scene));
+    bvhMs = performance.now() - start;
+    triangleCount = geometry.triangleCount;
+    nodeCount = geometry.nodeCount;
+    let hash = 2166136261;
+    for (let i = 0; i < geometry.triangles.length; i += 7)
+        hash = Math.imul(hash ^ Math.round(geometry.triangles[i] * 10000), 16777619);
+    lastGeometryHash = hash >>> 0;
+    const uploadStart = performance.now();
+    tracer.upload(geometry);
+    uploadMs = performance.now() - uploadStart;
+    generation++;
+}
+function cameraFrame() {
+    const forward = new THREE.Vector3();
+    camera.getWorldDirection(forward);
+    const right = new THREE.Vector3()
+        .setFromMatrixColumn(camera.matrixWorld, 0)
+        .multiplyScalar(Math.tan(THREE.MathUtils.degToRad(camera.fov / 2)) * camera.aspect);
+    const up = new THREE.Vector3()
+        .setFromMatrixColumn(camera.matrixWorld, 1)
+        .multiplyScalar(Math.tan(THREE.MathUtils.degToRad(camera.fov / 2)));
+    const light = authoredLights[0];
+    const position = light
+        ? light.object.getWorldPosition(new THREE.Vector3()).toArray()
+        : [-3, 6, 3];
+    const definition = light?.definition;
+    const color = new THREE.Color(definition?.color ?? 0xffdfb0);
+    return {
+        origin: camera.position.toArray(),
+        forward: forward.toArray(),
+        right: right.toArray(),
+        up: up.toArray(),
+        near: camera.near,
+        far: camera.far,
+        light: {
+            position,
+            color: color.toArray(),
+            intensity: definition?.intensity ?? 55,
+            directional: definition?.kind === "directional",
+        },
+        environment: scene.background.toArray(),
+        ambient: compiledIR?.scene.environment.ambientIntensity ?? 1,
+    };
+}
+function draw(accumulate = false, changed = true) {
+    const operation = drawTail.then(async () => {
+        document.documentElement.dataset.pelicanFrameState = "drawing";
+        try {
+            await drawFrame(accumulate, changed);
+            frameSerial++;
+            document.documentElement.dataset.pelicanFrameSerial =
+                String(frameSerial);
+        }
+        finally {
+            document.documentElement.dataset.pelicanFrameState = "idle";
+        }
+    });
+    drawTail = operation.catch(() => { });
+    return operation;
+}
+async function drawFrame(accumulate = false, changed = true) {
+    if (disposed)
+        throw new Error("TC_BROWSER_DISPOSED");
+    await computeControl?.flush();
+    const start = performance.now();
+    syncRuntime();
+    animate();
+    renderBufferBridge?.update();
+    renderTextureBridge?.update();
+    const settings = renderControl?.service.state() ?? resolveRenderSettings({ mode });
+    const effects = postComposer && renderControl?.postProcesses.states().some(effect => effect.enabled) ? postComposer : undefined;
+    validateRenderCapabilities(settings, renderCapabilities(backendKind));
+    if (mode !== settings.mode)
+        setMode(settings.mode);
+    if (probeEnabled && vertexBounds)
+        throw new Error("TC_VERTEX_PROBE_UNSUPPORTED: Vertex graphs require a normal game scene, not the historical tracing sidecar.");
+    rasterCanvas.style.display = mode === "raster" || effects ? "block" : "none";
+    traceCanvas.style.display = mode === "raster" || effects ? "none" : "block";
+    if (effects && probeEnabled)
+        throw new Error("TC_POSTPROCESS_PROBE_UNSUPPORTED: Controlled effects require a normal game scene, not the historical M0 tracing sidecar.");
+    if (mode !== "raster" && !probeEnabled) {
+        if (!surfaceTracer) {
+            if (!legacyTracerDisposed) {
+                tracer.dispose();
+                legacyTracerDisposed = true;
+            }
+            const controller = new AbortController();
+            const ownedDevice = device;
+            pendingSurface = controller;
+            const retain = (candidate) => {
+                if (controller.signal.aborted || disposed || device !== ownedDevice) {
+                    candidate.dispose();
+                    throw new Error("TC_TRACE_CANCELLED: Surface initialization owner changed.");
+                }
+                return candidate;
+            };
+            try {
+                const candidate = await boundedOperation(SurfaceTracer.create(device, traceCanvas, width, height, renderer, reportFailure, import.meta.env.DEV, controller.signal).then(retain), "surface renderer initialization");
+                surfaceTracer = retain(candidate);
+            }
+            finally {
+                controller.abort();
+                if (pendingSurface === controller)
+                    pendingSurface = undefined;
+            }
+            changed = true;
+        }
+        const surfaceState = surfaceTracer.inspect();
+        const needsMotion = settings.denoise && settings.debug === "beauty";
+        if (changed ||
+            surfaceState.triangleCount === 0 ||
+            surfaceState.motion.enabled !== needsMotion)
+            await boundedOperation(surfaceTracer.update(scene, new Set(materialGraphs.map((item) => item.material)), needsMotion, new Map(materialGraphs.map(item => [item.material, item.binding])), computeExecutor), "surface content capture");
+        if (effects)
+            await surfaceTracer.prepareLinearPresentation();
+        submitMs = surfaceTracer.render(camera, settings, effects?.traceTargets());
+        if (effects)
+            effects.present(renderControl.postProcesses, tick / 60, settings);
+        const report = surfaceTracer.inspect();
+        triangleCount = report.triangleCount;
+        nodeCount = report.nodeCount;
+        bvhMs =
+            (report.acceleration?.metrics.refitMs ?? 0) +
+                (report.acceleration?.metrics.buildMs ?? 0);
+        uploadMs = report.uploadMs;
+        metrics.push({
+            frame: tick,
+            bvhMs,
+            uploadMs,
+            submitMs,
+            wallMs: performance.now() - start,
+            simulationMs: lastStepCpuMs,
+        });
+        if (metrics.length > 2000)
+            metrics.shift();
+        status.hidden = false;
+        status.textContent = runtimeStatus({
+            backend: backendKind,
+            mode,
+            playing,
+            automation: startup.automation,
+            tick,
+            triangles: triangleCount,
+            faulted: terminalFault,
+        });
+        return;
+    }
+    if (changed) {
+        if ((gameplay || legacyTracerDisposed || backendKind === "webgl2") && mode === "raster") {
+            // Raster does not consume a CPU BVH. Count authored triangles without rebuilding/uploading tracing buffers.
+            triangleCount = 0;
+            scene.traverseVisible((object) => {
+                if (object instanceof THREE.Mesh && !object.userData.noTrace)
+                    triangleCount +=
+                        (object.geometry.index?.count ??
+                            object.geometry.getAttribute("position").count) / 3;
+            });
+            nodeCount = 0;
+            bvhMs = 0;
+            uploadMs = 0;
+        }
+        else
+            updateTraceGeometry();
+    }
+    renderer.toneMappingExposure = settings.exposure;
+    if (mode !== "path") {
+        if (effects) {
+            effects.captureRaster(scene, camera);
+            effects.present(renderControl.postProcesses, tick / 60, settings);
+        }
+        else
+            renderer.render(scene, camera);
+    }
+    if (mode !== "raster")
+        submitMs = tracer.renderFrame(cameraFrame(), mode, accumulate);
+    else
+        submitMs = 0;
+    metrics.push({
+        frame: tick,
+        bvhMs: changed ? bvhMs : 0,
+        uploadMs: changed ? uploadMs : 0,
+        submitMs,
+        wallMs: performance.now() - start,
+        simulationMs: lastStepCpuMs,
+    });
+    if (metrics.length > 2000)
+        metrics.shift();
+    status.hidden = false;
+    status.textContent = runtimeStatus({
+        backend: backendKind,
+        mode,
+        playing,
+        automation: startup.automation,
+        tick,
+        triangles: triangleCount,
+        faulted: terminalFault,
+    });
+}
+async function applyInput(key) {
+    if (!probeEnabled) {
+        const host = requireRuntime();
+        host.input(key, true);
+        if (!playing)
+            await stepRuntime();
+        syncRuntime();
+        tick = host.inspect().scheduler.tick;
+        return;
+    }
+    const id = compiledIR?.scene.entities.find((entity) => entity.mesh)?.id;
+    if (!id)
+        return;
+    const t = facade.getTransform(id);
+    if (key === "ArrowRight" || key === "ArrowLeft")
+        facade.setTransform(id, {
+            position: [
+                t.position[0] + (key === "ArrowRight" ? 0.25 : -0.25),
+                t.position[1],
+                t.position[2],
+            ],
+        });
+}
+function onKeyDown(event) {
+    if (gameplay?.consumesKeyboard(event))
+        return;
+    if (disposed || terminalFault || loadingContent || restoring || !runtime)
+        return;
+    try {
+        if (compiledIR?.input &&
+            Object.values(compiledIR.input).some((keys) => keys.includes(event.key)))
+            event.preventDefault();
+        gameplay?.unlockAudio();
+        queueNativeInput(async () => {
+            inputLog.push({ tick, key: event.key });
+            await applyInput(event.key);
+            if (!playing)
+                requestInputDraw();
+        });
+    }
+    catch (error) {
+        reportFailure(error);
+    }
+}
+function requestInputDraw() {
+    inputDrawRequested = true;
+    if (inputDrawActive)
+        return;
+    inputDrawActive = true;
+    void (async () => {
+        try {
+            while (inputDrawRequested && !playing && !disposed) {
+                inputDrawRequested = false;
+                await draw(false, true);
+            }
+        }
+        catch (error) {
+            if (!disposed)
+                reportFailure(error);
+        }
+        finally {
+            inputDrawActive = false;
+        }
+    })();
+}
+function queueNativeInput(operation) {
+    nativeInputTail = nativeInputTail.then(async () => {
+        await tickTail;
+        if (disposed || terminalFault || loadingContent || restoring || !runtime)
+            return;
+        await operation();
+    }).catch(error => { if (!disposed)
+        reportFailure(error); });
+}
+function onKeyUp(event) {
+    if (gameplay?.consumesKeyboard(event))
+        return;
+    if (disposed ||
+        terminalFault ||
+        loadingContent ||
+        restoring ||
+        !runtime ||
+        probeEnabled)
+        return;
+    queueNativeInput(() => { requireRuntime().input(event.key, false); });
+}
+window.addEventListener("keydown", onKeyDown);
+window.addEventListener("keyup", onKeyUp);
+async function stepRuntime() {
+    const started = performance.now();
+    const host = requireRuntime();
+    if (terminalFault)
+        throw new Error("TC_BROWSER_FAULTED: Restore a valid checkpoint or reload content before stepping.");
+    try {
+        const operation = tickTail.then(async () => {
+            if (disposed || host !== runtime)
+                throw new Error("TC_BROWSER_DISPOSED: Tick owner changed.");
+            await host.stepAsync(1);
+        });
+        tickTail = operation.catch(() => { });
+        await operation;
+        tick = host.inspect().scheduler.tick;
+        simulation?.step();
+    }
+    catch (error) {
+        tick = host.inspect().scheduler.tick;
+        reportFailure(error);
+        throw error;
+    }
+    finally {
+        lastStepCpuMs = performance.now() - started;
+    }
+}
+function setMode(next) {
+    if (next !== "raster")
+        requireCompute(renderCapabilities(backendKind), next);
+    if (next !== mode) {
+        surfaceTracer?.invalidateTemporal();
+        postComposer?.resetHistory("mode");
+    }
+    mode = next;
+    document.documentElement.dataset.pelicanMode = next;
+    rasterCanvas.style.display = next === "raster" ? "block" : "none";
+    traceCanvas.style.display = next === "raster" ? "none" : "block";
+    traceCanvas.style.opacity = "1";
+}
+function inspect(options) {
+    const bounded = options &&
+        (options.entity !== undefined ||
+            options.offset !== undefined ||
+            options.limit !== undefined);
+    syncRuntime();
+    const runtimeState = runtime?.inspect();
+    const selected = bounded
+        ? selectInspectRecords(runtimeState?.records ?? [], options)
+        : undefined;
+    return {
+        ready: !disposed && !terminalFault && !recoveringGpu,
+        playback: {
+            playing,
+            automation: startup.automation,
+            state: terminalFault ? "faulted" : playing ? "running" : "paused",
+        },
+        backend: backendKind === "webgpu" ? "WebGPUBackend" : backendKind === "webgl2" ? "WebGLBackend" : "uninitialized",
+        adapter: adapterInfo,
+        mode,
+        rendering: {
+            postProcesses: postComposer?.inspect(),
+            vertex: vertexBounds?.inspect(),
+            bufferBindings: renderBufferBridge?.inspect(),
+            textureBindings: renderTextureBridge?.inspect(),
+            computeGpu: computeExecutor?.inspect(),
+            effectStates: renderControl?.postProcesses.states(),
+            compute: computeControl?.inspect(),
+            backendDiagnostic: backendKind === "webgl2" ? { code: "TC_RENDER_WEBGL2_FALLBACK", severity: "info", message: "WebGPU initialization unavailable; using Three.js built-in WebGL2 fallback. Available modes: raster." } : null,
+            settings: renderControl?.service.state(),
+            surface: surfaceTracer?.inspect(),
+            gpuRecovery: {
+                active: recoveringGpu,
+                count: recoveryCount,
+                events: [...recoveryEvents],
+            },
+        },
+        tick,
+        width,
+        height,
+        inputLog: [...inputLog],
+        triangleCount,
+        nodeCount,
+        generation,
+        geometryHash: lastGeometryHash,
+        objects: {
+            box: box.position.toArray(),
+            morph: morphMesh.morphTargetInfluences[0],
+            bone: tip.rotation.z,
+            camera: camera.position.toArray(),
+        },
+        errors: [...errors],
+        ...(bounded ? {} : { compiledIR }),
+        runtime: runtimeState && {
+            ...runtimeState,
+            records: selected?.records ?? runtimeState.records,
+        },
+        ...(selected ? { paging: selected.paging } : {}),
+        frameClock: {
+            fixedDt: 1 / 60,
+            accumulator: frameAccumulator,
+            backlogTicks: Math.floor(frameAccumulator * 60),
+            maxStepsPerFrame: 8,
+        },
+        resources: resourceManager.inspect(),
+        gameplay: gameplay?.inspect(),
+        game: {
+            transforms: selected
+                ? Object.fromEntries(selected.records.map((record) => [record.id, record.transform]))
+                : Object.fromEntries(transforms),
+            components: selected
+                ? Object.fromEntries(selected.records.map((record) => [record.id, record.components]))
+                : Object.fromEntries(componentState),
+        },
+        simulation: simulation?.inspect(),
+        world: world?.inspect(),
+        metrics: [...metrics],
+        capabilities: {
+            ...renderCapabilities(backendKind),
+            ...inspectTraceCapabilities({ backend: backendKind, legacyProbe: probeEnabled, surfaceInitialized: !!surfaceTracer, gameplay: !!gameplay, maxBounces: renderControl?.service.state().maxBounces ?? 5 }),
+        },
+    };
+}
+async function disposeBrowser() {
+    if (disposal)
+        return disposal;
+    disposed = true;
+    playing = false;
+    lastFrameTime = undefined;
+    if (frameRequest !== undefined)
+        cancelAnimationFrame(frameRequest);
+    frameRequest = undefined;
+    document.documentElement.dataset.pelicanReady = "false";
+    window.removeEventListener("keydown", onKeyDown);
+    window.removeEventListener("keyup", onKeyUp);
+    rasterCanvas.removeEventListener("webglcontextrestored", onContextRestored);
+    window.removeEventListener("pagehide", onPageHide);
+    const pending = [];
+    const clean = (action) => {
+        try {
+            const result = action();
+            if (result && typeof result.then === "function")
+                pending.push(Promise.resolve(result));
+        }
+        catch (error) {
+            errors.push(`TC_BROWSER_CLEANUP: ${String(error)}`);
+        }
+    };
+    clean(() => runtime?.dispose());
+    clean(() => computeControl?.dispose());
+    clean(() => postComposer?.dispose());
+    clean(() => vertexBounds?.dispose());
+    clean(() => renderBufferBridge?.dispose());
+    clean(() => renderTextureBridge?.dispose());
+    clean(() => gameplay?.dispose());
+    clean(() => simulation?.dispose());
+    clean(() => world?.dispose());
+    clean(() => resourceManager.dispose());
+    clean(() => releaseObject(scene, true, gameMaterials.values()));
+    clean(() => pendingSurface?.abort());
+    clean(() => tracer?.dispose());
+    clean(() => surfaceTracer?.dispose());
+    clean(async () => {
+        const gl = backendKind === "webgl2" ? rasterCanvas.getContext("webgl2") : null;
+        try {
+            await renderer?.dispose();
+        }
+        finally {
+            gl?.getExtension("WEBGL_lose_context")?.loseContext();
+        }
+    });
+    clean(() => device?.destroy());
+    gameObjects.clear();
+    gameMaterials.clear();
+    transforms.clear();
+    componentState.clear();
+    materialGraphs.length = 0;
+    authoredLights = [];
+    topologyObjects.length = 0;
+    compiledIR = null;
+    runtime = undefined;
+    renderControl = undefined;
+    computeControl = undefined;
+    postComposer = undefined;
+    vertexBounds = undefined;
+    computeExecutor = undefined;
+    renderBufferBridge = undefined;
+    renderTextureBridge = undefined;
+    gameplay = undefined;
+    simulation = undefined;
+    world = undefined;
+    contentScope = undefined;
+    rasterCanvas.remove();
+    traceCanvas.remove();
+    disposal = Promise.allSettled(pending).then((results) => {
+        for (const result of results)
+            if (result.status === "rejected")
+                errors.push(`TC_BROWSER_CLEANUP: ${String(result.reason)}`);
+    });
+    return disposal;
+}
+function onPageHide() {
+    void disposeBrowser();
+}
+window.addEventListener("pagehide", onPageHide);
+async function initializeGpu() {
+    let abandoned = false;
+    const candidate = new THREE.WebGPURenderer({ canvas: rasterCanvas, antialias: true, powerPreference: "high-performance" });
+    renderer = candidate;
+    renderer.setPixelRatio(1);
+    renderer.setSize(width, height);
+    renderer.shadowMap.enabled = true;
+    renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    renderer.onDeviceLost = (info) => {
+        if (disposed || renderer !== candidate)
+            return;
+        if (info.api === "WebGL") {
+            lostRenderers.add(candidate);
+            if (recoveringGpu)
+                return;
+            contextWasPlaying = playing;
+            playing = false;
+            recoveringGpu = true;
+            waitingForWebglRestore = true;
+            document.documentElement.dataset.pelicanReady = "false";
+            recoveryEvents.push({ phase: "lost", reason: "TC_RENDER_CONTEXT_LOST: WebGL2 context lost; waiting for browser restoration.", tick });
+            status.hidden = false;
+            status.textContent = "WebGL2 · TC_RENDER_CONTEXT_LOST";
+        }
+    };
+    try {
+        await boundedOperation(candidate.init().then(async () => {
+            if (abandoned || disposed || renderer !== candidate)
+                await candidate.dispose();
+        }), "renderer initialization");
+    }
+    catch (error) {
+        abandoned = true;
+        throw new Error("TC_RENDER_BACKEND_UNAVAILABLE: WebGPU and built-in WebGL2 fallback could not initialize. Enable a supported graphics backend and reload. " + String(error));
+    }
+    if (disposed)
+        return;
+    // Backend objects stay private; only plain capability data crosses the SDK boundary.
+    const backend = candidate.backend;
+    backendKind = backend.isWebGLBackend ? "webgl2" : "webgpu";
+    document.documentElement.dataset.pelicanBackend = backendKind;
+    adapterInfo = undefined;
+    legacyTracerDisposed = backendKind !== "webgpu";
+    if (backendKind === "webgl2")
+        return;
+    if (!backend.device)
+        throw new Error("TC_RENDER_BACKEND_UNAVAILABLE: Initialized backend has no compute device.");
+    device = backend.device;
+    const identity = device.adapterInfo;
+    adapterInfo = {
+        vendor: identity.vendor,
+        architecture: identity.architecture,
+        isFallbackAdapter: identity.isFallbackAdapter,
+        features: [...device.features],
+    };
+    const ownedDevice = device;
+    device.addEventListener("uncapturederror", (event) => {
+        if (!disposed && device === ownedDevice && !recoveringGpu)
+            reportFailure(new Error("TC_GPU_VALIDATION: " + event.error.message));
+    });
+    void device.lost.then((info) => {
+        lostDevices.add(ownedDevice);
+        if (disposed || device !== ownedDevice || recoveringGpu)
+            return;
+        recoveryTask = recoverGpu(info);
+        void recoveryTask.catch((error) => {
+            reportFailure(error);
+        });
+    });
+    status.textContent = "GPU tracer";
+    tracer = new GPUTracer(device, traceCanvas, width, height);
+    legacyTracerDisposed = false;
+}
+async function submittedWork(label = "GPU submission") {
+    if (backendKind === "webgpu")
+        await boundedOperation(device.queue.onSubmittedWorkDone(), label);
+}
+function onContextRestored() {
+    if (disposed || backendKind !== "webgl2" || !waitingForWebglRestore)
+        return;
+    waitingForWebglRestore = false;
+    recoveringGpu = false;
+    playing = contextWasPlaying;
+    recoveryTask = recoverGpu({ reason: "unknown", message: "WebGL2 context restored" });
+    void recoveryTask.catch(reportFailure);
+}
+rasterCanvas.addEventListener("webglcontextrestored", onContextRestored);
+async function recoverGpu(info) {
+    const wasPlaying = playing;
+    recoveringGpu = true;
+    playing = false;
+    lastFrameTime = undefined;
+    document.documentElement.dataset.pelicanReady = "false";
+    status.hidden = false;
+    status.textContent = `Rebuilding ${backendKind} resources`;
+    recoveryEvents.push({
+        phase: "lost",
+        reason: info.reason + ": " + info.message,
+        tick,
+    });
+    try {
+        pendingSurface?.abort();
+        renderBufferBridge?.dispose();
+        renderBufferBridge = undefined;
+        renderTextureBridge?.dispose();
+        renderTextureBridge = undefined;
+        computeControl?.replaceExecutor(undefined);
+        postComposer?.dispose();
+        postComposer = undefined;
+        surfaceTracer?.dispose();
+        surfaceTracer = undefined;
+        tracer?.dispose();
+        await renderer?.dispose();
+        await initializeGpu();
+        if (disposed)
+            return;
+        computeExecutor = backendKind === "webgpu" && (compiledIR?.computes.length || compiledIR?.computeBuffers?.length || compiledIR?.computeTextures?.length) ? createComputeExecutor(device) : undefined;
+        computeControl?.replaceExecutor(computeExecutor);
+        if (compiledIR && usesRenderSlots(compiledIR)) {
+            renderBufferBridge = createRenderBufferBridge(renderer, () => computeExecutor, id => slotResources(renderControl, id));
+        }
+        if (compiledIR && usesRenderTextures(compiledIR))
+            renderTextureBridge = createRenderTextureBridge(renderer, () => computeExecutor, id => textureResources(renderControl, id));
+        for (const item of materialGraphs)
+            applyMaterialGraphs(item.material, item.binding, item.uniforms, renderBufferBridge, renderTextureBridge);
+        if (gameplay)
+            scene.environment =
+                (await gameplay.rebuildGpuResources(renderer)) ?? null;
+        if (compiledIR?.postProcesses?.length)
+            postComposer = createPostProcessComposer(renderer, width, height, compiledIR.postProcesses, gameplay?.textures ?? new Map(), renderBufferBridge, renderTextureBridge);
+        await draw(false, true);
+        if (disposed)
+            return;
+        if (lostRenderers.has(renderer) || (backendKind === "webgpu" && lostDevices.has(device)))
+            throw new Error("TC_GPU_RECOVERY_DEVICE_LOST: Replacement backend was lost during reconstruction. Reload after restoring graphics availability.");
+        terminalFault = false;
+        delete document.documentElement.dataset.pelicanFailure;
+        document.documentElement.dataset.pelicanReady = "true";
+        recoveryCount++;
+        recoveryEvents.push({
+            phase: "restored",
+            reason: backendKind === "webgpu" ? "new WebGPU device" : "new WebGL2 renderer",
+            tick,
+        });
+        playing = wasPlaying;
+        lastFrameTime = undefined;
+    }
+    catch (error) {
+        playing = false;
+        recoveryEvents.push({ phase: "failed", reason: String(error), tick });
+        throw new Error("TC_GPU_RECOVERY_FAILED: " + String(error));
+    }
+    finally {
+        recoveringGpu = false;
+    }
+}
+async function boot() {
+    await initializeGpu();
+    status.textContent = "Loading compiled game";
+    await boundedOperation(loadGame(), "compiled content initialization");
+    status.textContent = "Drawing compiled game";
+    setMode("raster");
+    await draw();
+    const api = {
+        inspect,
+        configureRendering: async (settings) => {
+            requireRuntime().facade.render.configure(settings);
+            await draw(false, true);
+            await submittedWork("render settings frame");
+            return inspect();
+        },
+        exerciseDeviceLoss: async () => {
+            requireRuntime();
+            requireCompute(renderCapabilities(backendKind), "Device loss probe");
+            const lost = device;
+            lost.destroy();
+            await boundedOperation(lost.lost, "injected device loss");
+            await Promise.resolve();
+            if (!recoveryTask)
+                throw new Error("TC_GPU_RECOVERY_NOT_STARTED");
+            await boundedOperation(recoveryTask, "device recovery", 60000);
+            if (device === lost)
+                throw new Error("TC_GPU_RECOVERY_DEVICE_UNCHANGED");
+            return inspect();
+        },
+        exerciseContextLoss: async () => {
+            requireRuntime();
+            if (backendKind !== "webgl2")
+                throw new Error("TC_RENDER_CONTEXT_PROBE_BACKEND: This probe requires WebGL2.");
+            const gl = rasterCanvas.getContext("webgl2");
+            const extension = gl.getExtension("WEBGL_lose_context");
+            if (!extension)
+                throw new Error("TC_RENDER_CONTEXT_PROBE_UNAVAILABLE: Browser does not expose WEBGL_lose_context.");
+            const lost = new Promise((resolve) => rasterCanvas.addEventListener("webglcontextlost", () => resolve(), { once: true }));
+            const restored = new Promise((resolve) => rasterCanvas.addEventListener("webglcontextrestored", () => resolve(), { once: true }));
+            extension.loseContext();
+            await boundedOperation(lost, "WebGL2 injected context loss");
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            extension.restoreContext();
+            await boundedOperation(restored, "WebGL2 context restoration");
+            await boundedOperation(recoveryTask, "WebGL2 resource recovery");
+            return inspect();
+        },
+        mode: async (next) => {
+            requireRuntime();
+            const previous = mode;
+            try {
+                renderControl?.service.configure({ mode: next });
+                setMode(next);
+                await draw(false, true);
+            }
+            catch (error) {
+                renderControl?.service.configure({ mode: previous });
+                setMode(previous);
+                await draw(false, true);
+                throw error;
+            }
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        step: async (count = 1) => {
+            requireRuntime();
+            if (!Number.isInteger(count) || count < 1 || count > 10000)
+                throw new Error("TC_PROTOCOL_STEPS: count must be in [1,10000].");
+            for (let i = 0; i < count; i++) {
+                await stepRuntime();
+                await processGameRequests();
+                syncSimulation();
+                await draw(false, true);
+            }
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        camera: async (phase) => {
+            cameraPhase = phase;
+            await draw(false, false);
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        accumulate: async (count = 16) => {
+            if (mode === "raster")
+                throw new Error("TC_TRACE_MODE: Accumulation is available in path or hybrid mode.");
+            if (!Number.isSafeInteger(count) || count < 1 || count > 4096)
+                throw new Error("TC_TRACE_SAMPLES: Development accumulation count must be an integer in [1,4096].");
+            for (let i = 0; i < count; i++)
+                await draw(i > 0, false);
+            await submittedWork("GPU submission");
+            return surfaceTracer ? surfaceTracer.pixels() : tracer.pixelStats();
+        },
+        pixels: () => surfaceTracer && mode !== "raster"
+            ? surfaceTracer.pixels()
+            : legacyTracerDisposed
+                ? Promise.resolve({
+                    available: false,
+                    mode: "raster",
+                    reason: "Surface statistics are not a raster framebuffer readback; use the external current-page capture.",
+                })
+                : tracer.pixelStats(),
+        linearPixels: (filtered = true) => {
+            if (!surfaceTracer)
+                throw new Error("TC_TRACE_NOT_ACTIVE");
+            return surfaceTracer.readRadiance(filtered);
+        },
+        motionPixels: () => {
+            if (!surfaceTracer)
+                throw new Error("TC_TRACE_NOT_ACTIVE");
+            return surfaceTracer.readMotion();
+        },
+        traceFaultTarget: (pixel, sample = 0) => {
+            if (!surfaceTracer)
+                throw new Error("TC_TRACE_NOT_ACTIVE");
+            surfaceTracer.setFaultTarget(pixel, sample);
+        },
+        temporalPixels: () => {
+            if (!surfaceTracer)
+                throw new Error("TC_TRACE_NOT_ACTIVE");
+            return surfaceTracer.readTemporal();
+        },
+        primaryStats: () => {
+            if (!surfaceTracer || mode !== "hybrid")
+                throw new Error("TC_TRACE_PRIMARY_NOT_ACTIVE");
+            return surfaceTracer.readPrimaryStats();
+        },
+        guidePixels: () => {
+            if (!surfaceTracer)
+                throw new Error("TC_TRACE_NOT_ACTIVE");
+            return surfaceTracer.readGuides();
+        },
+        gpuTimeMs: () => backendKind !== "webgpu" ? Promise.resolve(null) : surfaceTracer ? surfaceTracer.gpuTimeMs() : tracer.gpuTimeMs(),
+        vertexRay: (origin, direction) => {
+            requireRuntime();
+            if (!vertexBounds)
+                throw new Error("TC_VERTEX_NOT_ACTIVE: This scene has no controlled vertex graphs.");
+            return vertexBounds.intersect(origin, direction);
+        },
+        ray: (origin, direction) => {
+            requireCompute(renderCapabilities(backendKind), "Traced ray query");
+            return surfaceTracer
+                ? surfaceTracer.queryRay(origin, direction)
+                : tracer.queryRay(origin, direction);
+        },
+        compute: async (id, time) => {
+            requireCompute(renderCapabilities(backendKind), "Compute graph");
+            const definition = compiledIR?.computes.find((c) => c.id === id);
+            if (!definition)
+                throw new Error(`TC_COMPUTE_MISSING:${id}`);
+            return runComputeGraph(device, definition.graph, definition.count, definition.workgroupSize, time);
+        },
+        simulation: async (kind) => {
+            simulation?.dispose();
+            simulation = createSimulation(kind);
+            syncSimulation();
+            await draw();
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        snapshot: () => {
+            const host = requireRuntime();
+            syncRuntime();
+            return structuredClone({
+                format: "pelican.browser",
+                version: 1,
+                engineVersion: SDK_VERSION,
+                tick,
+                cameraPhase,
+                transforms: Object.fromEntries(transforms),
+                components: Object.fromEntries(componentState),
+                inputLog,
+                simulation: simulation?.snapshot(),
+                world: world?.snapshot(),
+                runtime: host.snapshot(),
+                frameAccumulator,
+                resources: resourceManager.snapshot(contentScope),
+                topology: topologyObjects.map((object) => object.position.toArray()),
+            });
+        },
+        restore: async (value) => {
+            const host = requireRuntime();
+            const saved = validateBrowserCheckpoint(value, resourceManager.snapshot(contentScope));
+            restoring = true;
+            let prepared;
+            const nextTopology = [];
+            let committed = false;
+            try {
+                prepared = await prepareCheckpointProbes(saved);
+                for (const position of saved.topology) {
+                    const mesh = new THREE.Mesh(new THREE.IcosahedronGeometry(0.35, 0), standard(0x98dd66));
+                    mesh.position.fromArray(position);
+                    nextTopology.push(mesh);
+                }
+                if (disposed || runtime !== host)
+                    throw new Error("TC_BROWSER_DISPOSED: Checkpoint owner changed.");
+                // Host preflights scheduler/world atomically and preserves generational invalidation.
+                // Invalid sidecars have already failed on isolated candidates, without touching this host.
+                host.restore(saved.runtime);
+                postComposer?.resetHistory("restore");
+                surfaceTracer?.invalidateTemporal("restore");
+                const previousSimulation = simulation, previousWorld = world;
+                simulation = prepared.simulation;
+                world = prepared.world;
+                frameAccumulator = saved.frameAccumulator;
+                lastFrameTime = undefined;
+                tick = saved.tick;
+                cameraPhase = saved.cameraPhase;
+                terminalFault = false;
+                inputLog.length = 0;
+                inputLog.push(...saved.inputLog);
+                for (const object of topologyObjects)
+                    releaseObject(object, true);
+                topologyObjects.splice(0, topologyObjects.length, ...nextTopology);
+                for (const mesh of nextTopology)
+                    scene.add(mesh);
+                committed = true;
+                previousSimulation?.dispose();
+                previousWorld?.dispose();
+                syncRuntime();
+                syncSimulation();
+                syncWorld();
+            }
+            finally {
+                if (!committed) {
+                    prepared?.dispose();
+                    for (const object of nextTopology)
+                        releaseObject(object, true);
+                }
+                restoring = false;
+            }
+            await draw();
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        worldLoad: async () => {
+            world?.dispose();
+            world = createWorldProbe({ chunkSize: 2, cellsPerChunk: 4 });
+            await Promise.all([world.loadChunk([0, 0]), world.loadChunk([1, 0])]);
+            syncWorld();
+            await draw();
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        worldEdit: async () => {
+            if (!world)
+                throw new Error("TC_WORLD_NOT_LOADED");
+            await world.applyEdits([{ chunk: [0, 0], x: 2, z: 2, height: 1.8 }]);
+            syncWorld();
+            await draw();
+            await submittedWork("GPU submission");
+            return {
+                state: inspect(),
+                collision: world.sampleHeight({ chunk: [0, 0], local: [1, 0, 1] }),
+                navigation: world.getNavigationState(),
+            };
+        },
+        worldUnload: async () => {
+            await world?.unloadChunk([0, 0]);
+            syncWorld();
+            await draw();
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        worldReload: async () => {
+            await world?.loadChunk([0, 0]);
+            syncWorld();
+            await draw();
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        topology: async () => {
+            const extra = new THREE.Mesh(new THREE.IcosahedronGeometry(0.35, 0), standard(0x98dd66));
+            extra.position.set(2, 0.5, 1.5);
+            scene.add(extra);
+            topologyObjects.push(extra);
+            await draw();
+            await submittedWork("GPU submission");
+            return inspect();
+        },
+        play: () => {
+            requireRuntime();
+            if (terminalFault)
+                throw new Error("TC_BROWSER_FAULTED: Restore a valid checkpoint or reload content before resuming.");
+            playing = true;
+            lastFrameTime = undefined;
+            status.textContent = runtimeStatus({
+                backend: backendKind,
+                mode,
+                playing,
+                automation: startup.automation,
+                tick,
+                triangles: triangleCount,
+            });
+        },
+        pause: () => {
+            playing = false;
+            lastFrameTime = undefined;
+            status.textContent = runtimeStatus({
+                backend: backendKind,
+                mode,
+                playing,
+                automation: startup.automation,
+                tick,
+                triangles: triangleCount,
+            });
+        },
+        get adapter() {
+            return adapterInfo;
+        },
+        loadGame,
+        setComponent: (id, component, value) => facade.setComponent(id, component, value),
+        worldTransforms: () => {
+            scene.updateMatrixWorld(true);
+            return Object.fromEntries([...gameObjects].map(([id, object]) => [
+                id,
+                object.getWorldPosition(new THREE.Vector3()).toArray(),
+            ]));
+        },
+        geometryProbe: (id, value) => {
+            if (id === "morph")
+                morphMesh.morphTargetInfluences[0] = value;
+            else
+                tip.rotation.z = value;
+            const object = id === "morph" ? morphMesh : skinned;
+            scene.updateMatrixWorld(true);
+            if (object instanceof THREE.SkinnedMesh)
+                object.skeleton.update();
+            const vertices = [];
+            for (let i = 0; i < object.geometry.getAttribute("position").count; i++)
+                vertices.push(object
+                    .getVertexPosition(i, new THREE.Vector3())
+                    .applyMatrix4(object.matrixWorld)
+                    .toArray());
+            updateTraceGeometry();
+            return { vertices, hash: lastGeometryHash };
+        },
+        cameraDirection: () => cameraFrame(),
+        command: async (input) => {
+            const taskId = `runtime-${Date.now()}`;
+            try {
+                const command = parseCommand(input);
+                await nativeInputTail;
+                await tickTail;
+                if (command.type !== "inspect")
+                    requireRuntime();
+                let data;
+                switch (command.type) {
+                    case "inspect":
+                        data = inspect(command);
+                        break;
+                    case "capture":
+                        throw new Error("TC_CONTROL_TOOL_ONLY: Use capture --live through development bridge.");
+                    case "step":
+                        data = await api.step(command.count);
+                        break;
+                    case "pause":
+                        api.pause();
+                        data = inspect();
+                        break;
+                    case "resume":
+                        api.play();
+                        data = inspect();
+                        break;
+                    case "snapshot":
+                        data = api.snapshot();
+                        break;
+                    case "recordStart":
+                        requireRuntime().startRecording();
+                        data = inspect();
+                        break;
+                    case "recordStop":
+                        data = requireRuntime().stopRecording();
+                        break;
+                    case "recordCancel":
+                        requireRuntime().cancelRecording();
+                        data = inspect();
+                        break;
+                    case "replay": {
+                        const host = requireRuntime();
+                        const replay = await host.replayAsync(command.trace);
+                        tick = host.inspect().scheduler.tick;
+                        if (replay.status !== "passed") {
+                            const error = new Error(`TC_REPLAY_DIVERGENCE: ${replay.fault?.message ?? "Replay did not complete."}`);
+                            reportFailure(error);
+                            throw error;
+                        }
+                        data = replay;
+                        syncRuntime();
+                        await draw();
+                        break;
+                    }
+                    case "restore":
+                        data = await api.restore(command.snapshot);
+                        break;
+                    case "input":
+                        requireRuntime().input(command.key, command.pressed);
+                        data = inspect();
+                        break;
+                    case "setComponent":
+                        requireRuntime().facade.setComponent(command.entity, command.component, command.value);
+                        syncRuntime();
+                        await draw();
+                        data = inspect();
+                        break;
+                    case "mode":
+                        data = await api.mode(command.mode);
+                        break;
+                }
+                if (data === undefined)
+                    throw new Error("TC_CONTROL_NO_RESULT: Command did not produce a result.");
+                return protocolResult(taskId, "succeeded", data);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (message.includes("TC_GPU_TIMEOUT"))
+                    reportFailure(error);
+                return protocolResult(taskId, "failed", null, [
+                    {
+                        code: message.match(/TC_[A-Z0-9_]+/)?.[0] ?? "TC_CONTROL_FAILURE",
+                        severity: "error",
+                        message,
+                        remediation: "Inspect the runtime state and correct the command or source before retrying.",
+                    },
+                ]);
+            }
+        },
+    };
+    if (import.meta.env.DEV)
+        window.__pelican = api;
+    async function loop(now) {
+        if (disposed)
+            return;
+        try {
+            if (playing &&
+                !terminalFault &&
+                !loadingContent &&
+                !restoring &&
+                !recoveringGpu) {
+                const elapsed = lastFrameTime === undefined ? 0 : (now - lastFrameTime) / 1000;
+                lastFrameTime = now;
+                frameAccumulator += Math.max(0, elapsed);
+                let steps = 0;
+                while (frameAccumulator >= 1 / 60 && steps < 8) {
+                    await stepRuntime();
+                    frameAccumulator -= 1 / 60;
+                    await processGameRequests();
+                    steps++;
+                }
+                if (steps)
+                    syncSimulation();
+                await draw(false, steps > 0);
+            }
+            else {
+                lastFrameTime = undefined;
+            }
+        }
+        catch (error) {
+            if (!terminalFault)
+                reportFailure(error);
+        }
+        if (!disposed)
+            frameRequest = requestAnimationFrame(loop);
+    }
+    frameRequest = requestAnimationFrame(loop);
+    playing = startup.playing;
+    document.documentElement.dataset.pelicanReady = "true";
+    status.textContent = runtimeStatus({
+        backend: backendKind,
+        mode,
+        playing,
+        automation: startup.automation,
+        tick,
+        triangles: triangleCount,
+    });
+}
+boot().catch((error) => {
+    reportFailure(error);
+    if (import.meta.env.DEV)
+        window.__pelicanFailure =
+            String(error);
+    void disposeBrowser();
+});