@skenora/runtime 0.1.2

package/dist/core/runtime-session.js

@@ -0,0 +1,1344 @@
+import { FreeCamera } from "@babylonjs/core/Cameras/freeCamera";
+import { Engine } from "@babylonjs/core/Engines/engine";
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial";
+import { Scene } from "@babylonjs/core/scene";
+import { normalizeMaterialExecutionPolicy, SCENE_CAPABILITY_VERSIONS, OWNED_PBR_CAPABILITY_ID, findUnavailableSceneCapabilities, SceneCapabilityUnavailableError, normalizeRuntimeQualityPolicy, applySceneQualityPolicy, restoreRequestedQuality, MATERIAL_EFFECT_CAPABILITY_IDS, isMaterialEffectRuntimeProperty, MaterialAnimationError, MATERIAL_ANIMATION_CAPABILITY_ID, MATERIAL_PROGRAM_CAPABILITY_ID, MATERIAL_PROGRAM_V2_CAPABILITY_ID, MATERIAL_PROGRAM_LIMITS, TEXTURE_PROGRAM_CAPABILITY_ID, TEXTURE_PROGRAM_LIMITS, RENDER_GRAPH_CAPABILITY_ID, RENDER_GRAPH_LIMITS, PROCEDURAL_GEOMETRY_CAPABILITY_ID, PROCEDURAL_GEOMETRY_LIMITS, validateMaterialAnimations, getMaterialEffectSceneConflicts, createSkenoraDiagnostic, finalizeSkenoraDiagnostics, } from "@skenora/contracts";
+import { EventHub } from "@skenora/events";
+import { PluginHost } from "@skenora/plugins";
+import { calculateNodeBounds, CameraController, } from "../systems/camera-controller.js";
+import { AnnotationProjector } from "../projection/annotation-projector.js";
+import { CameraPathController } from "../systems/camera-path-controller.js";
+import { AnimationController } from "../systems/animation-controller.js";
+import { SceneDocumentApplier } from "../projection/document-applier.js";
+import { createBuiltInEntityProjectors } from "../projection/built-in-entity-projectors.js";
+import { EntityProjectionRegistry } from "../projection/entity-projection-registry.js";
+import { RuntimeProjectionState } from "../projection/runtime-projection-state.js";
+import { applyTransform, importModelEntity, isTransformNode, setNodeVisible, readAuthoredGroupState, } from "../projection/model-importer.js";
+import { PARTICLE_PLAYBACK_CAPABILITY, } from "../projection/particle-capability.js";
+import { ViewportController } from "../presentation/viewport-controller.js";
+import { TextureAnimationController } from "../systems/texture-animation-controller.js";
+import { MaterialAnimationController } from "../systems/material-animation-controller.js";
+import { RuntimeClock } from "../systems/runtime-clock.js";
+import { MaterialBindingResolver } from "../systems/material-binding-resolver.js";
+import { setPbrMaterialProperty } from "../systems/pbr-material.js";
+import { listMaterialSlots, MaterialProjectionError, } from "../systems/material-slots.js";
+import { applyCameraEntityProperties, captureCameraEntityProperties, captureCameraEntityTransform, } from "../projection/camera-entity-factory.js";
+import { calculateNodeStatistics, describeNodeTree, RuntimeNodeEffects, } from "../inspection/node-tools.js";
+import { createRuntimeAnimationCapability, createRuntimeCameraCapability, createRuntimeMaterialCapability, createRuntimeNodeCapability, createRuntimeParticleCapability, createRuntimeTextureAnimationCapability, } from "./built-in-runtime-capabilities.js";
+import { RUNTIME_ANIMATIONS_CAPABILITY, RUNTIME_CAMERA_CAPABILITY, RUNTIME_MATERIALS_CAPABILITY, RUNTIME_MATERIAL_ANIMATIONS_CAPABILITY, RUNTIME_NODES_CAPABILITY, RUNTIME_PARTICLES_CAPABILITY, RUNTIME_TEXTURE_ANIMATIONS_CAPABILITY, RuntimeCapabilityRegistry, } from "./runtime-capability-registry.js";
+import { RuntimeDocumentCoordinator, } from "./runtime-document-coordinator.js";
+import { GpuProgramCache } from "../systems/gpu-program-cache.js";
+const ALL_DOCUMENT_SETTINGS = [
+    "camera",
+    "cameraPaths",
+    "environment",
+    "ground",
+    "fog",
+    "weather",
+    "lights",
+    "materials",
+    "textureAnimations",
+    "postProcess",
+];
+export class RuntimeSession {
+    canvas;
+    engine;
+    scene;
+    annotations;
+    viewport;
+    events;
+    capabilities;
+    executionMode;
+    materialPolicy;
+    qualityPolicy;
+    #adaptRatio;
+    #engineRatioLimit;
+    #qualityState = null;
+    #animations;
+    #textureAnimations;
+    #materialAnimations;
+    #clock = new RuntimeClock();
+    #nodeEffects;
+    #ownsEvents;
+    #entityProjections;
+    #projectionState = new RuntimeProjectionState();
+    #materialResolver;
+    #documents;
+    #plugins;
+    #gpuPrograms;
+    #renderFrame = () => {
+        if (this.#contextLost) {
+            this.#clock.resetInterval();
+            return;
+        }
+        this.#clock.tick(performance.now());
+        this.scene.render();
+    };
+    #camera = null;
+    #cameraPaths = null;
+    #applier = null;
+    #resizeObserver = null;
+    #grid = null;
+    #rendering = false;
+    #behaviorDocument = null;
+    #behaviorsRunning = false;
+    #disposed = false;
+    #contextLost = false;
+    #lastProbeVerdict = null;
+    constructor(canvas, options = {}) {
+        this.canvas = canvas;
+        this.materialPolicy = normalizeMaterialExecutionPolicy(options.materialPolicy);
+        this.qualityPolicy = normalizeRuntimeQualityPolicy(options.qualityPolicy);
+        this.#adaptRatio =
+            options.adaptToDeviceRatio === true ||
+                options.engineOptions?.adaptToDeviceRatio === true;
+        this.#engineRatioLimit = options.engineOptions?.limitDeviceRatio;
+        this.executionMode = options.executionMode ?? "authoring";
+        this.events = options.events ?? new EventHub();
+        this.#ownsEvents = options.events === undefined;
+        this.engine = new Engine(canvas, options.antialias ?? true, options.engineOptions, options.adaptToDeviceRatio ?? false);
+        this.#gpuPrograms = new GpuProgramCache(this.engine.webGLVersion >= 2 ? "babylon-webgl2" : "babylon-webgl1", this.materialPolicy.maxInstances);
+        this.scene = new Scene(this.engine);
+        if (this.qualityPolicy.maxPixelRatio !== undefined) {
+            // The host cap owns DPR updates. Babylon's proportional auto-resize would
+            // otherwise grow the scale past that cap when the display DPR changes.
+            this.engine.adaptToDeviceRatio = false;
+            this.#resizeForQuality();
+        }
+        this.engine.onContextLostObservable.add(() => {
+            this.#contextLost = true;
+            this.#clock.resetInterval();
+        });
+        this.engine.onContextRestoredObservable.add(() => {
+            this.#contextLost = false;
+            this.#clock.resetInterval();
+        });
+        this.#materialResolver = new MaterialBindingResolver(this.scene);
+        this.#entityProjections = new EntityProjectionRegistry(createBuiltInEntityProjectors({
+            shouldAutoStartBehaviors: () => this.#behaviorsRunning,
+        }));
+        this.#animations = new AnimationController(this.scene);
+        this.annotations = new AnnotationProjector(this.scene, (entityId) => {
+            const node = this.#getNode(entityId);
+            return isTransformNode(node) ? node : null;
+        });
+        this.viewport = new ViewportController(this.scene);
+        this.#textureAnimations = new TextureAnimationController(this.scene, (materialId) => this.#getMaterials(materialId), this.#clock, (animationId, error) => this.#reportRuntimeError(error, `textureAnimation:${animationId}`));
+        this.#materialAnimations = new MaterialAnimationController(this.#clock, {
+            validate: (materialId, animation) => this.#validateMaterialAnimation(materialId, animation),
+            write: (materialId, property, value) => this.#writeMaterialProperty(materialId, property, value),
+        }, (state) => this.events.publish("runtime.material.animation", state, {
+            source: "runtime",
+        }), this.materialPolicy.maxActiveAnimations);
+        this.#nodeEffects = new RuntimeNodeEffects(this.scene);
+        this.capabilities = new RuntimeCapabilityRegistry();
+        const nodes = createRuntimeNodeCapability((entityId) => this.#getNode(entityId), this.#nodeEffects);
+        this.capabilities.register(RUNTIME_NODES_CAPABILITY, nodes);
+        this.capabilities.register(RUNTIME_MATERIAL_ANIMATIONS_CAPABILITY, {
+            play: (materialId, animationId, options) => this.#materialAnimations.play(materialId, animationId, options),
+            pause: (materialId, animationId) => this.#materialAnimations.pause(materialId, animationId),
+            resume: (materialId, animationId) => this.#materialAnimations.resume(materialId, animationId),
+            stop: (materialId, animationId) => this.#materialAnimations.stop(materialId, animationId),
+            reset: (materialId, animationId) => this.#materialAnimations.reset(materialId, animationId),
+            getState: (materialId, animationId) => this.#materialAnimations.getState(materialId, animationId),
+        });
+        this.capabilities.register(RUNTIME_MATERIALS_CAPABILITY, createRuntimeMaterialCapability((materialId) => this.#getMaterial(materialId), (materialId, property, value) => this.#setMaterialProperty(materialId, property, value)));
+        this.capabilities.register(RUNTIME_CAMERA_CAPABILITY, createRuntimeCameraCapability({
+            frame: (entityIds) => this.#frame(entityIds),
+            activateEntity: (entityId, controls) => this.#activateCameraEntity(entityId, controls),
+            restoreViewport: () => this.#restoreViewportCamera(),
+            getPaths: () => this.#cameraPaths,
+        }));
+        this.capabilities.register(RUNTIME_ANIMATIONS_CAPABILITY, createRuntimeAnimationCapability(this.#animations, nodes));
+        this.capabilities.register(RUNTIME_PARTICLES_CAPABILITY, createRuntimeParticleCapability((entityId, running) => this.#setParticleRunning(entityId, running)));
+        this.capabilities.register(RUNTIME_TEXTURE_ANIMATIONS_CAPABILITY, createRuntimeTextureAnimationCapability(this.#textureAnimations));
+        this.#documents = new RuntimeDocumentCoordinator(this.events, () => this.#resetDocumentProjection(), (document, resources, context) => this.#projectDocument(document, resources, context), (document) => this.#assertCapabilities(document));
+        this.#plugins = new PluginHost(this);
+        this.resume();
+        if ((options.autoResize ?? true) && typeof ResizeObserver !== "undefined") {
+            this.#resizeObserver = new ResizeObserver(() => this.resize());
+            this.#resizeObserver.observe(canvas);
+        }
+        try {
+            for (const plugin of options.plugins ?? [])
+                this.install(plugin);
+            for (const extension of options.extensions ?? [])
+                this.install(extension);
+        }
+        catch (error) {
+            this.dispose();
+            throw error;
+        }
+        this.events.publish("runtime.ready", { scene: this.scene }, { source: "runtime" });
+    }
+    get viewportCamera() {
+        return this.#camera;
+    }
+    get rendering() {
+        return this.#rendering;
+    }
+    /** Whether document-authored auto behaviors are currently running. */
+    get behaviorsRunning() {
+        return this.#behaviorsRunning;
+    }
+    getQualityState() {
+        if (!this.#qualityState)
+            return null;
+        return {
+            ...structuredClone(this.#qualityState),
+            resolution: {
+                requestedPixelRatio: this.#requestedPixelRatio(),
+                effectivePixelRatio: 1 / this.engine.getHardwareScalingLevel(),
+            },
+        };
+    }
+    /** Serializable observation of the active Babylon backend and device caps. */
+    getBackendSnapshot() {
+        const unavailable = this.#disposed || this.engine.isDisposed;
+        const caps = unavailable
+            ? {}
+            : this.engine.getCaps();
+        const webGlVersion = readFiniteNumber(this.engine.webGLVersion) ?? 0;
+        const contextStatus = unavailable
+            ? "disposed"
+            : this.#contextLost
+                ? "lost"
+                : webGlVersion > 0
+                    ? "available"
+                    : "unavailable";
+        const diagnostics = [];
+        if (contextStatus !== "available") {
+            diagnostics.push(createSkenoraDiagnostic({
+                code: `runtime-backend-${contextStatus}`,
+                severity: contextStatus === "lost" ? "error" : "warning",
+                stage: "environment",
+                message: `Runtime backend is ${contextStatus}`,
+                recoverable: contextStatus !== "disposed",
+                repair: contextStatus === "lost"
+                    ? "Wait for context restoration or recreate the runtime."
+                    : "Create an active browser RuntimeSession before probing.",
+            }));
+        }
+        const featureKeys = [
+            "depthTextureExtension",
+            "drawBuffersExtension",
+            "instancedArrays",
+            "parallelShaderCompile",
+            "standardDerivatives",
+            "textureFloat",
+            "textureFloatLinearFiltering",
+            "textureHalfFloat",
+            "textureHalfFloatLinearFiltering",
+            "vertexArrayObject",
+        ];
+        const features = featureKeys.filter((key) => caps[key] === true);
+        const limitKeys = [
+            "maxCombinedTexturesImageUnits",
+            "maxCubemapTextureSize",
+            "maxFragmentUniformVectors",
+            "maxMSAASamples",
+            "maxTextureImageUnits",
+            "maxTextureSize",
+            "maxVaryingVectors",
+            "maxVertexAttribs",
+            "maxVertexTextureImageUnits",
+            "maxVertexUniformVectors",
+        ];
+        const limits = {};
+        for (const key of limitKeys) {
+            const value = readFiniteNumber(caps[key]);
+            if (value !== undefined)
+                limits[key] = value;
+        }
+        const quality = unavailable ? null : this.getQualityState();
+        return Object.freeze({
+            version: 1,
+            capturedAt: new Date().toISOString(),
+            backend: webGlVersion >= 2
+                ? "babylon-webgl2"
+                : webGlVersion >= 1
+                    ? "babylon-webgl1"
+                    : "unknown",
+            shaderLanguage: webGlVersion >= 1 ? "glsl" : "unknown",
+            engine: Object.freeze({ name: "Babylon.js Engine" }),
+            contextStatus,
+            features: Object.freeze([...features].sort()),
+            limits: Object.freeze(limits),
+            facts: Object.freeze({
+                antialias: !unavailable && this.engine.getCreationOptions().antialias === true,
+                hardwareScalingLevel: unavailable
+                    ? 0
+                    : this.engine.getHardwareScalingLevel(),
+                renderHeight: unavailable ? 0 : this.engine.getRenderHeight(),
+                renderWidth: unavailable ? 0 : this.engine.getRenderWidth(),
+                rendering: this.#rendering,
+                webGlVersion,
+                ...(this.#lastProbeVerdict === null
+                    ? {}
+                    : { lastProbeVerdict: this.#lastProbeVerdict }),
+            }),
+            capabilities: Object.freeze(this.getCapabilityAvailability().map((entry) => Object.freeze(structuredClone(entry)))),
+            ...(quality === null ? {} : { quality: structuredClone(quality) }),
+            diagnostics: finalizeSkenoraDiagnostics(diagnostics),
+        });
+    }
+    getGpuProgramCacheSnapshot() {
+        return this.#gpuPrograms.snapshot();
+    }
+    /**
+     * Exercises the live backend. A healthy verdict requires both a real scene
+     * render and a one-pixel GPU readback; construction alone is never proof.
+     */
+    async probe() {
+        const startedAt = new Date().toISOString();
+        const diagnostics = [];
+        let renderAttempted = false;
+        let renderCompleted = false;
+        let readbackAttempted = false;
+        let readbackCompleted = false;
+        let byteLength;
+        if (this.#disposed || this.engine.isDisposed) {
+            diagnostics.push(createSkenoraDiagnostic({
+                code: "runtime-probe-disposed",
+                stage: "render",
+                message: "Cannot probe a disposed RuntimeSession",
+                recoverable: false,
+                repair: "Create a new RuntimeSession and run the probe again.",
+            }));
+        }
+        else if (this.#contextLost) {
+            diagnostics.push(createSkenoraDiagnostic({
+                code: "runtime-probe-context-lost",
+                stage: "render",
+                message: "Cannot probe while the graphics context is lost",
+                recoverable: true,
+                repair: "Wait for context restoration and run the probe again.",
+            }));
+        }
+        else if (!this.scene.activeCamera) {
+            diagnostics.push(createSkenoraDiagnostic({
+                code: "runtime-probe-no-active-camera",
+                severity: "warning",
+                stage: "render",
+                message: "A real render probe requires an active scene camera",
+                recoverable: true,
+                repair: "Load a SceneDocument before running the runtime probe.",
+            }));
+        }
+        else {
+            try {
+                renderAttempted = true;
+                this.scene.render();
+                renderCompleted = true;
+                readbackAttempted = true;
+                const pixels = await this.engine.readPixels(0, 0, 1, 1);
+                byteLength = pixels.byteLength;
+                readbackCompleted = byteLength >= 4;
+                if (!readbackCompleted) {
+                    diagnostics.push(createSkenoraDiagnostic({
+                        code: "runtime-probe-empty-readback",
+                        stage: "render",
+                        message: "GPU readback returned fewer than four bytes",
+                        recoverable: true,
+                        repair: "Recreate the runtime and inspect browser GPU diagnostics.",
+                        details: { byteLength },
+                    }));
+                }
+            }
+            catch (error) {
+                diagnostics.push(createSkenoraDiagnostic({
+                    code: "runtime-probe-failed",
+                    stage: "render",
+                    message: error instanceof Error ? error.message : "Runtime probe failed",
+                    recoverable: true,
+                    repair: "Inspect the backend snapshot and browser GPU diagnostics.",
+                    ...(error instanceof Error ? { causeCode: error.name } : {}),
+                }));
+            }
+        }
+        const verdict = renderCompleted && readbackCompleted
+            ? "healthy"
+            : renderAttempted ||
+                readbackAttempted ||
+                diagnostics.some((item) => item.severity === "error")
+                ? "unhealthy"
+                : "unverified";
+        this.#lastProbeVerdict = verdict;
+        const report = Object.freeze({
+            version: 1,
+            verdict,
+            startedAt,
+            finishedAt: new Date().toISOString(),
+            backend: this.getBackendSnapshot(),
+            evidence: Object.freeze({
+                renderAttempted,
+                renderCompleted,
+                readbackAttempted,
+                readbackCompleted,
+                ...(byteLength === undefined ? {} : { byteLength }),
+            }),
+            diagnostics: finalizeSkenoraDiagnostics(diagnostics),
+        });
+        this.events.publish("runtime.probe.completed", report, {
+            source: "runtime",
+        });
+        return report;
+    }
+    #qualityDocument(document) {
+        const caps = this.engine.getCaps();
+        const state = applySceneQualityPolicy(document, this.qualityPolicy, {
+            maxTextureSize: Math.max(1, caps.maxTextureSize),
+            maxSamples: Math.max(1, caps.maxMSAASamples),
+            depthTextures: caps.depthTextureExtension,
+        });
+        return {
+            state,
+            document: {
+                ...document,
+                lights: [...state.effective.lights],
+                postProcess: state.effective.postProcess,
+            },
+        };
+    }
+    #publishQuality() {
+        const state = this.getQualityState();
+        if (state)
+            this.events.publish("runtime.quality.changed", state, {
+                source: "runtime",
+            });
+    }
+    #requestedPixelRatio() {
+        if (!this.#adaptRatio)
+            return 1;
+        const ratio = typeof window === "undefined" ? 1 : window.devicePixelRatio || 1;
+        return Math.min(ratio, this.#engineRatioLimit || ratio);
+    }
+    #resizeForQuality() {
+        if (this.qualityPolicy.maxPixelRatio !== undefined) {
+            const scale = 1 /
+                Math.min(this.#requestedPixelRatio(), this.qualityPolicy.maxPixelRatio);
+            if (this.engine.getHardwareScalingLevel() !== scale) {
+                this.engine.setHardwareScalingLevel(scale);
+                return;
+            }
+        }
+        this.engine.resize();
+    }
+    #getNode(entityId) {
+        return this.#projectionState.getNode(entityId);
+    }
+    classifyEntityChange(entity, path) {
+        return this.#entityProjections.classifyChange(entity.type, path);
+    }
+    #getMaterial(materialId) {
+        const materials = this.#getMaterials(materialId);
+        if (materials.length > 1) {
+            throw new MaterialProjectionError({
+                stage: "binding",
+                code: "ambiguous-material-instance",
+                materialId,
+                message: "This material has multiple independent instances; use a material-wide operation or distinct authored material IDs.",
+            });
+        }
+        return materials[0] ?? null;
+    }
+    #getMaterials(materialId) {
+        const owned = this.#applier?.materials.getOwnedMaterials(materialId);
+        if (owned)
+            return owned;
+        const material = this.#materialResolver.get(materialId);
+        return material ? [material] : [];
+    }
+    describeMaterialSlots(entityId) {
+        this.#assertActive();
+        return listMaterialSlots(this.scene, entityId, (mesh) => this.#applier
+            ? this.#applier.materials.readOriginalMaterial(mesh)
+            : mesh.material).map((slot) => ({ ...slot.descriptor }));
+    }
+    #setMaterialProperty(materialId, property, value) {
+        this.#writeMaterialProperty(materialId, property, value);
+        this.#materialAnimations.cancelTarget(materialId, property);
+    }
+    #validateMaterialAnimation(materialId, animation) {
+        const material = this.#behaviorDocument?.materials[materialId];
+        const instances = this.#applier?.materials.getOwnedMaterials(materialId);
+        if (!material?.creation ||
+            !instances?.length ||
+            ((animation.property === "metallic" ||
+                animation.property === "roughness") &&
+                instances.some((instance) => instance[animation.property] === null)))
+            throw new MaterialAnimationError("material-animation-target", materialId, animation.id);
+        if (validateMaterialAnimations({ ...material, animations: [animation] })
+            .length)
+            throw new MaterialAnimationError("material-animation-invalid", materialId, animation.id);
+    }
+    #writeMaterialProperty(materialId, property, value) {
+        this.#assertActive();
+        if (this.#behaviorDocument?.materials[materialId]?.creation &&
+            this.#behaviorDocument.materials[materialId]?.effects?.dissolve &&
+            ((property === "alpha" && value !== 1) ||
+                (property === "transparencyMode" && value !== 0)))
+            throw new MaterialProjectionError({
+                stage: "prepare",
+                code: "material-effect-pass-unsupported",
+                materialId,
+                message: "Dissolve version 1 requires opaque rendering.",
+            });
+        if (isMaterialEffectRuntimeProperty(property)) {
+            if (!this.#applier)
+                throw new Error("Material projection is not active");
+            this.#applier.materials.setEffectProperty(materialId, property, value);
+            return;
+        }
+        const materials = this.#getMaterials(materialId);
+        if (!materials.length ||
+            materials.some((material) => !(material instanceof PBRMaterial))) {
+            throw new Error(`PBR material not found: ${materialId}`);
+        }
+        for (const material of materials)
+            setPbrMaterialProperty(material, property, value);
+    }
+    #activateCameraEntity(entityId, controls = false) {
+        this.#assertActive();
+        const camera = this.#entityProjections.getNode(entityId);
+        if (!(camera instanceof FreeCamera))
+            return false;
+        this.#camera?.setEnabled(false);
+        for (const item of this.#entityProjections.entries("camera")) {
+            if (item.node instanceof FreeCamera)
+                item.node.detachControl();
+        }
+        this.scene.activeCamera = camera;
+        if (controls)
+            camera.attachControl(this.canvas, true);
+        this.#applier?.refreshPostProcessCamera();
+        this.events.publish("runtime.camera.activated", { entityId, viewport: false }, { source: "runtime" });
+        return true;
+    }
+    #restoreViewportCamera() {
+        this.#assertActive();
+        for (const item of this.#entityProjections.entries("camera")) {
+            if (item.node instanceof FreeCamera)
+                item.node.detachControl();
+        }
+        if (!this.#camera)
+            return;
+        this.scene.activeCamera = this.#camera.camera;
+        this.#camera.setEnabled(true);
+        this.#applier?.refreshPostProcessCamera();
+        this.events.publish("runtime.camera.activated", { entityId: null, viewport: true }, { source: "runtime" });
+    }
+    describeModelNodes(entityId) {
+        const imported = this.#projectionState.getImported(entityId);
+        if (!imported)
+            return [];
+        const rootSet = new Set(imported.roots);
+        const nodeSet = new Set(imported.nodes);
+        return imported.nodes.flatMap((node) => {
+            if (rootSet.has(node) || !isTransformNode(node))
+                return [];
+            const parent = node.parent && nodeSet.has(node.parent) ? node.parent : null;
+            return [
+                {
+                    nodeId: readSourceNodeId(node),
+                    name: node.name,
+                    parentNodeId: parent && !rootSet.has(parent) ? readSourceNodeId(parent) : null,
+                    type: "getBoundingInfo" in node ? "mesh" : "group",
+                    transform: {
+                        position: {
+                            x: node.position.x,
+                            y: node.position.y,
+                            z: node.position.z,
+                        },
+                        rotation: {
+                            x: node.rotation.x,
+                            y: node.rotation.y,
+                            z: node.rotation.z,
+                        },
+                        scaling: {
+                            x: node.scaling.x,
+                            y: node.scaling.y,
+                            z: node.scaling.z,
+                        },
+                        ...(node.rotationQuaternion
+                            ? {
+                                rotationQuaternion: {
+                                    x: node.rotationQuaternion.x,
+                                    y: node.rotationQuaternion.y,
+                                    z: node.rotationQuaternion.z,
+                                    w: node.rotationQuaternion.w,
+                                },
+                            }
+                            : {}),
+                    },
+                },
+            ];
+        });
+    }
+    describeModelNodeTree(entityId, filter = {}) {
+        const imported = this.#projectionState.getImported(entityId);
+        return imported ? describeNodeTree(imported.roots, filter) : [];
+    }
+    getModelStatistics(entityId) {
+        const imported = this.#projectionState.getImported(entityId);
+        return calculateNodeStatistics(imported?.roots ?? []);
+    }
+    describeModelMaterials(entityId) {
+        const imported = this.#projectionState.getImported(entityId);
+        if (!imported)
+            return [];
+        return imported.container.materials.flatMap((material) => {
+            if (!(material instanceof PBRMaterial))
+                return [];
+            const identity = { id: `${entityId}:${material.id}` };
+            const captured = this.#applier
+                ? this.#applier.captureMaterial(material, identity)
+                : capturePbrMaterial(material, identity);
+            return [
+                {
+                    ...captured,
+                    targetEntityId: entityId,
+                    targetName: material.name,
+                },
+            ];
+        });
+    }
+    /** Captures document-owned runtime edits without serializing Babylon internals. */
+    captureDocument(source) {
+        this.#assertActive();
+        const document = structuredClone(source);
+        if (this.#camera)
+            document.camera = this.#camera.capture();
+        if (this.#applier) {
+            document.environment = this.#applier.environment.capture(source.environment);
+            document.ground = this.#applier.captureGround(source.ground);
+            document.fog = this.#applier.captureFog(source.fog);
+            document.weather = this.#applier.captureWeather(source.weather);
+            document.lights = [...this.#applier.lighting.capture()];
+            document.postProcess = this.#applier.capturePostProcess(source.postProcess);
+        }
+        for (const [entityId, entity] of Object.entries(document.entities)) {
+            const node = this.#projectionState.getNode(entityId);
+            if (!node)
+                continue;
+            entity.name = node.name;
+            entity.enabled =
+                readAuthoredGroupState(node)?.enabled ?? node.isEnabled(false);
+            entity.visible = readNodeVisible(node);
+            if (!isTransformNode(node))
+                continue;
+            entity.transform = {
+                position: {
+                    x: node.position.x,
+                    y: node.position.y,
+                    z: node.position.z,
+                },
+                rotation: {
+                    x: node.rotation.x,
+                    y: node.rotation.y,
+                    z: node.rotation.z,
+                },
+                scaling: {
+                    x: node.scaling.x,
+                    y: node.scaling.y,
+                    z: node.scaling.z,
+                },
+                ...(node.rotationQuaternion
+                    ? {
+                        rotationQuaternion: {
+                            x: node.rotationQuaternion.x,
+                            y: node.rotationQuaternion.y,
+                            z: node.rotationQuaternion.z,
+                            w: node.rotationQuaternion.w,
+                        },
+                    }
+                    : {}),
+            };
+        }
+        for (const { entityId, node } of this.#entityProjections.entries("camera")) {
+            if (!(node instanceof FreeCamera))
+                continue;
+            const entity = document.entities[entityId];
+            if (!entity)
+                continue;
+            entity.transform = captureCameraEntityTransform(node);
+            entity.properties = captureCameraEntityProperties(node);
+        }
+        if (this.#applier) {
+            for (const materialId of Object.keys(document.materials)) {
+                const instances = this.#getMaterials(materialId).filter((material) => material instanceof PBRMaterial);
+                if (!instances.length)
+                    continue;
+                const captured = instances.map((material) => this.#applier.captureMaterial(material, { id: materialId }));
+                if (captured.some((value) => JSON.stringify(value) !== JSON.stringify(captured[0]))) {
+                    throw new MaterialProjectionError({
+                        stage: "prepare",
+                        code: "divergent-material-instances",
+                        materialId,
+                        message: "Independent instances differ and cannot be captured as one definition. Use distinct authored material IDs.",
+                    });
+                }
+                document.materials[materialId] = {
+                    ...document.materials[materialId],
+                    ...captured[0],
+                };
+            }
+        }
+        if (this.#qualityState)
+            restoreRequestedQuality(document, source, this.#qualityState);
+        return document;
+    }
+    updateEntity(entity) {
+        this.#assertActive();
+        if (this.#behaviorDocument?.entities[entity.id]) {
+            this.#behaviorDocument.entities[entity.id] = structuredClone(entity);
+        }
+        if (this.#entityProjections.update(entity))
+            return;
+        const node = this.#projectionState.getNode(entity.id);
+        if (!node)
+            return;
+        node.name = entity.name;
+        if (isTransformNode(node))
+            applyTransform(node, entity.transform);
+        node.setEnabled(entity.enabled);
+        setNodeVisible(node, entity.visible);
+    }
+    async applyDocumentSettings(document, settings) {
+        this.#assertActive();
+        this.#assertCapabilities(document);
+        this.#behaviorDocument = structuredClone(document);
+        const quality = this.#qualityDocument(document);
+        const effective = quality.document;
+        const selected = new Set(settings ?? ALL_DOCUMENT_SETTINGS);
+        if (selected.has("camera"))
+            this.#camera?.apply(document.camera);
+        if (selected.has("cameraPaths")) {
+            this.#cameraPaths?.setPaths(document.cameraPaths);
+        }
+        if (selected.has("materials")) {
+            this.#materialAnimations.stopAll();
+            this.#textureAnimations.stopAll();
+            this.#nodeEffects.clear();
+            this.#materialResolver.setBindings(document.materialBindings);
+        }
+        const applier = this.#applier;
+        if (applier) {
+            if (settings === undefined) {
+                await applier.apply(effective);
+            }
+            else {
+                if (selected.has("environment")) {
+                    await applier.applyEnvironment(document);
+                }
+                if (selected.has("ground"))
+                    await applier.applyGround(document);
+                if (selected.has("fog"))
+                    await applier.applyFog(document);
+                if (selected.has("weather"))
+                    await applier.applyWeather(document);
+                if (selected.has("lights"))
+                    applier.applyLights(effective);
+                if (selected.has("postProcess")) {
+                    await applier.applyPostProcess(effective);
+                }
+                if (selected.has("materials"))
+                    await applier.applyMaterials(document);
+            }
+        }
+        if (selected.has("textureAnimations") || selected.has("materials")) {
+            this.#textureAnimations.setAnimations(document.textureAnimations);
+            if (this.#behaviorsRunning) {
+                this.#textureAnimations.startAuto();
+            }
+        }
+        if (selected.has("materials")) {
+            this.#materialAnimations.setMaterials(document.materials);
+            if (this.#behaviorsRunning)
+                this.#materialAnimations.startAuto();
+        }
+        this.#qualityState = quality.state;
+        this.#publishQuality();
+    }
+    /** Data-only observation of this composition; does not load optional chunks. */
+    getCapabilityAvailability() {
+        const compatibility = this.#disposed || this.engine.isDisposed
+            ? "unsupported"
+            : this.#contextLost
+                ? "unknown"
+                : "supported";
+        return Object.entries(SCENE_CAPABILITY_VERSIONS).map(([id, version]) => {
+            const effect = Object.keys(MATERIAL_EFFECT_CAPABILITY_IDS).find((kind) => MATERIAL_EFFECT_CAPABILITY_IDS[kind] === id);
+            const entityType = id.startsWith("skenora.entity.")
+                ? id.slice("skenora.entity.".length)
+                : null;
+            const installed = entityType && entityType !== "model"
+                ? this.#entityProjections.supports(entityType)
+                : id === MATERIAL_ANIMATION_CAPABILITY_ID
+                    ? this.capabilities.has(RUNTIME_MATERIAL_ANIMATIONS_CAPABILITY)
+                    : true;
+            return {
+                id,
+                version,
+                installed,
+                enabled: !this.#disposed &&
+                    ((id !== OWNED_PBR_CAPABILITY_ID &&
+                        id !== MATERIAL_ANIMATION_CAPABILITY_ID &&
+                        id !== MATERIAL_PROGRAM_CAPABILITY_ID &&
+                        id !== MATERIAL_PROGRAM_V2_CAPABILITY_ID &&
+                        id !== TEXTURE_PROGRAM_CAPABILITY_ID &&
+                        id !== RENDER_GRAPH_CAPABILITY_ID) ||
+                        this.materialPolicy.enabled) &&
+                    (!effect ||
+                        (this.materialPolicy.enabled &&
+                            !this.materialPolicy.disabledEffects.includes(effect))),
+                compatibility,
+                ...(id === OWNED_PBR_CAPABILITY_ID
+                    ? {
+                        limits: {
+                            maxInstances: this.materialPolicy.maxInstances,
+                            maxTextures: this.materialPolicy.maxTextures,
+                            maxActiveAnimations: this.materialPolicy.maxActiveAnimations,
+                            preparationTimeoutMs: this.materialPolicy.preparationTimeoutMs,
+                        },
+                    }
+                    : {}),
+                ...(id === MATERIAL_ANIMATION_CAPABILITY_ID
+                    ? {
+                        limits: {
+                            maxActiveAnimations: this.materialPolicy.maxActiveAnimations,
+                            maxTracksPerMaterial: 64,
+                        },
+                    }
+                    : {}),
+                ...(id === PROCEDURAL_GEOMETRY_CAPABILITY_ID
+                    ? { limits: { ...PROCEDURAL_GEOMETRY_LIMITS } }
+                    : {}),
+                ...(id === MATERIAL_PROGRAM_CAPABILITY_ID ||
+                    id === MATERIAL_PROGRAM_V2_CAPABILITY_ID
+                    ? { limits: { ...MATERIAL_PROGRAM_LIMITS } }
+                    : {}),
+                ...(id === TEXTURE_PROGRAM_CAPABILITY_ID
+                    ? { limits: { ...TEXTURE_PROGRAM_LIMITS } }
+                    : {}),
+                ...(id === RENDER_GRAPH_CAPABILITY_ID
+                    ? { limits: { ...RENDER_GRAPH_LIMITS } }
+                    : {}),
+            };
+        });
+    }
+    #assertCapabilities(document) {
+        const conflict = getMaterialEffectSceneConflicts(document)[0];
+        if (conflict)
+            throw new MaterialProjectionError({
+                stage: "prepare",
+                code: conflict.code,
+                materialId: conflict.materialId,
+                message: conflict.message,
+            });
+        const automatic = Object.values(document.materials).flatMap((material) => material.creation
+            ? (material.animations ?? [])
+                .filter((animation) => animation.autoStart)
+                .map((animation) => ({
+                materialId: material.id,
+                animationId: animation.id,
+            }))
+            : []);
+        if (automatic.length > this.materialPolicy.maxActiveAnimations)
+            throw new MaterialAnimationError("material-animation-budget-exceeded", automatic[0].materialId, automatic[0].animationId);
+        const unavailable = findUnavailableSceneCapabilities(document, this.getCapabilityAvailability());
+        if (unavailable[0])
+            throw new SceneCapabilityUnavailableError(unavailable[0]);
+    }
+    async loadDocument(document, resources, options = {}) {
+        this.#assertActive();
+        const loading = this.#documents.load(document, resources, options);
+        const generation = this.#documents.generation;
+        await loading;
+        if (generation !== this.#documents.generation || this.#disposed)
+            return;
+        if (this.executionMode === "playback" && this.#behaviorDocument) {
+            this.startDocumentBehaviors();
+        }
+    }
+    /** Starts document-authored auto behaviors without enabling editor tools. */
+    startDocumentBehaviors() {
+        this.#assertActive();
+        if (this.#behaviorsRunning)
+            return;
+        const document = this.#behaviorDocument;
+        if (!document) {
+            throw new Error("A document must be loaded before starting behaviors");
+        }
+        this.#behaviorsRunning = true;
+        try {
+            this.#textureAnimations.startAuto();
+            this.#materialAnimations.startAuto();
+            for (const entity of Object.values(document.entities)) {
+                if (entity.type !== "particle")
+                    continue;
+                const config = (entity.properties ??
+                    {});
+                this.#setParticleRunning(entity.id, entity.enabled && entity.visible && config.autoStart !== false);
+            }
+        }
+        catch (error) {
+            this.#behaviorsRunning = false;
+            this.#textureAnimations.stopAll();
+            this.#materialAnimations.stopAll();
+            for (const { entityId } of this.#entityProjections.entries("particle")) {
+                this.#setParticleRunning(entityId, false);
+            }
+            throw error;
+        }
+    }
+    /** Stops document-authored auto behaviors while keeping the scene loaded. */
+    stopDocumentBehaviors() {
+        this.#assertActive();
+        this.#behaviorsRunning = false;
+        this.#textureAnimations.stopAll();
+        this.#materialAnimations.stopAll();
+        for (const { entityId } of this.#entityProjections.entries("particle")) {
+            this.#setParticleRunning(entityId, false);
+        }
+    }
+    #frame(entityIds) {
+        const ids = entityIds ?? this.#projectionState.rootEntityIds;
+        const nodes = ids.flatMap((id) => this.#projectionState.frameNodes(id));
+        if (!entityIds && nodes.length === 0) {
+            nodes.push(...this.#projectionState.importedRoots());
+        }
+        this.#camera?.frame(nodes);
+    }
+    centerImportedModelsAtOrigin() {
+        this.#assertActive();
+        const roots = [...new Set(this.#projectionState.importedRoots())];
+        const bounds = calculateNodeBounds(roots);
+        if (!bounds)
+            return false;
+        const rootSet = new Set(roots);
+        const topLevelRoots = roots.filter((root) => !root.parent || !rootSet.has(root.parent));
+        for (const root of topLevelRoots) {
+            if (!isTransformNode(root))
+                continue;
+            root.position.subtractInPlace(bounds.center);
+            root.computeWorldMatrix(true);
+        }
+        return true;
+    }
+    resize() {
+        this.#assertActive();
+        this.#resizeForQuality();
+        for (const { node } of this.#entityProjections.entries("camera")) {
+            if (!(node instanceof FreeCamera))
+                continue;
+            applyCameraEntityProperties(node, captureCameraEntityProperties(node), this.scene);
+        }
+        this.#publishQuality();
+    }
+    pause() {
+        this.#assertActive();
+        if (!this.#rendering)
+            return;
+        this.#disposeOperation("stopRenderLoop", () => this.engine.stopRenderLoop(this.#renderFrame));
+        this.#rendering = false;
+        this.#clock.resetInterval();
+    }
+    resume() {
+        this.#assertActive();
+        if (this.#rendering)
+            return;
+        this.#clock.resetInterval();
+        this.engine.runRenderLoop(this.#renderFrame);
+        this.#rendering = true;
+    }
+    install(plugin) {
+        this.#assertActive();
+        return this.#plugins.install(plugin);
+    }
+    async showGrid(visible) {
+        this.#assertActive();
+        if (!this.#grid) {
+            const { GridHelper } = await import("../editor-tools/grid-helper.js");
+            this.#assertActive();
+            this.#grid = new GridHelper(this.scene);
+        }
+        this.#grid.setEnabled(visible);
+    }
+    #setParticleRunning(entityId, running) {
+        const playback = this.#entityProjections.getCapability(entityId, PARTICLE_PLAYBACK_CAPABILITY);
+        if (!playback)
+            return false;
+        playback.setRunning(running);
+        return true;
+    }
+    get backgroundVisible() {
+        return this.#applier?.environment.backgroundVisible ?? true;
+    }
+    setBackgroundVisible(visible) {
+        this.#assertActive();
+        this.#applier?.environment.setBackgroundVisible(visible);
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#documents.dispose();
+        this.engine.stopRenderLoop(this.#renderFrame);
+        this.#rendering = false;
+        try {
+            this.#plugins.dispose();
+        }
+        catch (error) {
+            this.#reportRuntimeError(error, "disposePlugins");
+        }
+        this.capabilities.clear();
+        this.#disposeOperation("disconnectResizeObserver", () => this.#resizeObserver?.disconnect());
+        this.#disposeOperation("disposeGrid", () => this.#grid?.dispose());
+        this.#disposeOperation("resetDocumentProjection", () => this.#resetDocumentProjection());
+        this.#disposeOperation("disposeViewport", () => this.viewport.dispose());
+        this.#disposeOperation("disposeTextureAnimations", () => this.#textureAnimations.dispose());
+        this.#disposeOperation("disposeMaterialAnimations", () => this.#materialAnimations.dispose());
+        this.#clock.dispose();
+        this.#disposeOperation("disposeNodeEffects", () => this.#nodeEffects.dispose());
+        this.#disposeOperation("disposeGpuProgramCache", () => this.#gpuPrograms.dispose());
+        this.#disposeOperation("disposeScene", () => this.scene.dispose());
+        this.#disposeOperation("disposeEngine", () => this.engine.dispose());
+        if (this.#ownsEvents) {
+            try {
+                this.events.dispose();
+            }
+            catch {
+                // All owned runtime resources have already been released.
+            }
+        }
+    }
+    async #projectDocument(document, resources, context) {
+        this.#camera = new CameraController(this.scene, this.canvas, document.camera);
+        this.#cameraPaths = new CameraPathController(this.#camera, document.cameraPaths);
+        const applier = new SceneDocumentApplier(this.scene, resources, (binding) => this.#materialResolver.resolve(binding), {
+            policy: this.materialPolicy,
+            onPreparation: (event) => this.events.publish("runtime.material.preparation", event, {
+                source: "runtime",
+            }),
+            gpuProgramCache: this.#gpuPrograms,
+            onGpuProgramPreparation: (event) => this.events.publish("runtime.gpu-program.preparation", event, {
+                source: "runtime",
+            }),
+        });
+        this.#applier = applier;
+        this.#materialResolver.setBindings(document.materialBindings);
+        this.#projectionState.setRootEntityIds(document.rootEntityIds);
+        const modelEntities = Object.values(document.entities).filter((entity) => entity.type === "model" && entity.assetId);
+        const modelResults = await Promise.allSettled(modelEntities.map(async (entity) => {
+            throwIfAborted(context.signal);
+            if (!entity.assetId) {
+                throw new Error(`Model entity has no asset: ${entity.id}`);
+            }
+            const asset = document.assets[entity.assetId];
+            if (!asset) {
+                throw new Error(`Model asset is missing: ${entity.assetId}`);
+            }
+            const imported = await importModelEntity(this.scene, resources, asset, entity, context.signal);
+            return { entity, imported };
+        }));
+        if (!context.isCurrent() || context.signal?.aborted) {
+            disposeImportedResults(modelResults);
+            throwIfAborted(context.signal);
+            return false;
+        }
+        const rejectedModels = modelResults.flatMap((result, index) => result.status === "rejected"
+            ? [{ entity: modelEntities[index], error: result.reason }]
+            : []);
+        const abortError = rejectedModels
+            .map((item) => item.error)
+            .find(isAbortError);
+        const successfulModels = modelResults.length - rejectedModels.length;
+        if (abortError ||
+            (rejectedModels.length > 0 &&
+                (context.modelLoadPolicy === "strict" || successfulModels === 0))) {
+            for (const failure of rejectedModels) {
+                if (!failure.entity)
+                    continue;
+                this.events.publish("runtime.model.failed", { entityId: failure.entity.id, error: failure.error }, { source: "runtime" });
+            }
+            try {
+                disposeImportedResults(modelResults);
+            }
+            catch (cleanupError) {
+                throw new AggregateError([...rejectedModels.map((item) => item.error), cleanupError], "Model loading failed and successful imports could not be disposed");
+            }
+            if (abortError)
+                throw abortError;
+            const errors = rejectedModels.map((item) => item.error);
+            throw errors.length === 1
+                ? errors[0]
+                : new AggregateError(errors, "Multiple model entities failed to load");
+        }
+        for (const result of modelResults) {
+            if (result.status !== "fulfilled")
+                continue;
+            this.#projectionState.addImported(result.value.imported);
+            this.#projectionState.setNode(result.value.entity.id, result.value.imported.root);
+        }
+        let loaded = 0;
+        let completed = 0;
+        modelResults.forEach((result, index) => {
+            const entity = modelEntities[index];
+            if (!entity)
+                return;
+            completed += 1;
+            if (result.status === "fulfilled") {
+                const { imported } = result.value;
+                this.#bindSubEntities(document, entity.id, imported);
+                this.events.publish("runtime.model.loaded", { entityId: entity.id, roots: [imported.root] }, { source: "runtime" });
+                loaded += 1;
+                this.events.publish("runtime.loading.progress", {
+                    loaded,
+                    completed,
+                    total: modelEntities.length,
+                    entityId: entity.id,
+                    status: "loaded",
+                }, { source: "runtime" });
+                return;
+            }
+            this.events.publish("runtime.model.failed", { entityId: entity.id, error: result.reason }, { source: "runtime" });
+            this.events.publish("runtime.loading.progress", {
+                loaded,
+                completed,
+                total: modelEntities.length,
+                entityId: entity.id,
+                status: "failed",
+            }, { source: "runtime" });
+        });
+        const projectionContext = {
+            scene: this.scene,
+            document,
+            resources,
+            ...(context.signal ? { signal: context.signal } : {}),
+        };
+        for (const entity of Object.values(document.entities)) {
+            if (!this.#entityProjections.supports(entity.type))
+                continue;
+            if (entity.type === "group" && entity.sourceNode !== undefined)
+                continue;
+            throwIfAborted(context.signal);
+            if (!context.isCurrent())
+                return false;
+            const projection = await this.#entityProjections.create(projectionContext, entity);
+            if (!context.isCurrent() || context.signal?.aborted) {
+                this.#entityProjections.dispose(entity.id);
+                throwIfAborted(context.signal);
+                return false;
+            }
+            if (projection) {
+                this.#projectionState.setNode(entity.id, projection.node);
+            }
+        }
+        for (const entity of Object.values(document.entities)) {
+            if (!entity.parentId)
+                continue;
+            const parentEntity = document.entities[entity.parentId];
+            if (entity.sourceNode && parentEntity?.type === "model") {
+                // Imported source roots remain below their asset-alignment root.
+                continue;
+            }
+            const node = this.#projectionState.getNode(entity.id);
+            const parent = this.#projectionState.getNode(entity.parentId);
+            if (node && parent)
+                node.parent = parent;
+        }
+        if (!context.isCurrent())
+            return false;
+        const quality = this.#qualityDocument(document);
+        await applier.apply(quality.document, context.signal);
+        if (!context.isCurrent() || context.signal?.aborted) {
+            applier.dispose();
+            throwIfAborted(context.signal);
+            return false;
+        }
+        this.#textureAnimations.setAnimations(document.textureAnimations);
+        this.#materialAnimations.setMaterials(document.materials);
+        this.#behaviorDocument = structuredClone(document);
+        this.#qualityState = quality.state;
+        this.#publishQuality();
+        return true;
+    }
+    #clearProjectionState() {
+        const errors = [];
+        attempt(errors, () => this.#nodeEffects.clear());
+        attempt(errors, () => this.#entityProjections.clear());
+        attempt(errors, () => this.#materialResolver.clear());
+        attempt(errors, () => this.#projectionState.clear());
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "Runtime projection state could not be cleared");
+        }
+    }
+    #resetDocumentProjection() {
+        const errors = [];
+        this.#behaviorsRunning = false;
+        this.#behaviorDocument = null;
+        this.#qualityState = null;
+        attempt(errors, () => this.#textureAnimations.setAnimations({}));
+        attempt(errors, () => this.#materialAnimations.setMaterials({}));
+        this.#clock.resetInterval();
+        attempt(errors, () => this.#applier?.dispose());
+        this.#applier = null;
+        attempt(errors, () => this.#cameraPaths?.dispose());
+        this.#cameraPaths = null;
+        attempt(errors, () => this.#camera?.dispose());
+        this.#camera = null;
+        attempt(errors, () => this.#clearProjectionState());
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "Runtime document projection could not be reset");
+        }
+    }
+    #bindSubEntities(document, modelEntityId, imported) {
+        for (const entity of Object.values(document.entities)) {
+            if (!entity.sourceNode ||
+                !isDescendantOf(document, entity.id, modelEntityId)) {
+                continue;
+            }
+            const node = imported.nodes.find((candidate) => readSourceNodeId(candidate) === entity.sourceNode ||
+                candidate.name === entity.sourceNode);
+            if (!node)
+                continue;
+            const metadata = node.metadata;
+            const skenora = metadata?.skenora;
+            node.metadata = {
+                ...metadata,
+                skenora: {
+                    ...skenora,
+                    entityId: entity.id,
+                    assetId: document.entities[modelEntityId]?.assetId,
+                },
+            };
+            this.#projectionState.setNode(entity.id, node);
+            this.updateEntity(entity);
+        }
+    }
+    #assertActive() {
+        if (this.#disposed)
+            throw new Error("RuntimeSession has been disposed");
+    }
+    #disposeOperation(operation, action) {
+        try {
+            action();
+        }
+        catch (error) {
+            this.#reportRuntimeError(error, operation);
+        }
+    }
+    #reportRuntimeError(error, operation) {
+        try {
+            this.events.publish("runtime.error", { error, operation }, { source: "runtime" });
+        }
+        catch {
+            // Disposal continues even when an externally owned event hub is gone.
+        }
+    }
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw new DOMException("The runtime load was aborted", "AbortError");
+}
+function readFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function isAbortError(error) {
+    return ((error instanceof DOMException && error.name === "AbortError") ||
+        (!!error &&
+            typeof error === "object" &&
+            "name" in error &&
+            error.name === "AbortError"));
+}
+function disposeImportedResults(results) {
+    const errors = [];
+    for (const result of results) {
+        if (result.status !== "fulfilled")
+            continue;
+        try {
+            result.value.imported.container.dispose();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors, "Cancelled model imports could not be disposed");
+    }
+}
+function isDescendantOf(document, entityId, ancestorId) {
+    let current = document.entities[entityId];
+    const visited = new Set();
+    while (current?.parentId) {
+        if (current.parentId === ancestorId)
+            return true;
+        if (visited.has(current.parentId))
+            return false;
+        visited.add(current.parentId);
+        current = document.entities[current.parentId];
+    }
+    return false;
+}
+function readSourceNodeId(node) {
+    const metadata = node.metadata;
+    return typeof metadata?.skenora?.sourceNodeId === "string"
+        ? metadata.skenora.sourceNodeId
+        : node.id;
+}
+function capturePbrMaterial(material, identity) {
+    return {
+        ...identity,
+        workflow: material.metallic === null && material.roughness === null
+            ? "specular-glossiness"
+            : "metallic-roughness",
+        baseColor: {
+            r: material.albedoColor.r,
+            g: material.albedoColor.g,
+            b: material.albedoColor.b,
+        },
+        reflectivityColor: {
+            r: material.reflectivityColor.r,
+            g: material.reflectivityColor.g,
+            b: material.reflectivityColor.b,
+        },
+        metallic: material.metallic,
+        roughness: material.roughness,
+        microSurface: material.microSurface,
+        metallicF0Factor: material.metallicF0Factor,
+        alpha: material.alpha,
+        emissiveColor: {
+            r: material.emissiveColor.r,
+            g: material.emissiveColor.g,
+            b: material.emissiveColor.b,
+        },
+        emissiveIntensity: material.emissiveIntensity,
+        doubleSided: !material.backFaceCulling,
+    };
+}
+function readNodeVisible(node) {
+    const metadata = node.metadata;
+    if (typeof metadata?.skenora?.entityVisible === "boolean") {
+        return metadata.skenora.entityVisible;
+    }
+    const meshes = node.getChildMeshes(false);
+    if ("visibility" in node) {
+        const visibility = node.visibility;
+        if (visibility > 0)
+            return true;
+    }
+    return meshes.length === 0 || meshes.some((mesh) => mesh.visibility > 0);
+}
+function attempt(errors, action) {
+    try {
+        action();
+    }
+    catch (error) {
+        errors.push(error);
+    }
+}
+//# sourceMappingURL=runtime-session.js.map